void
FileObjectContext::DeviceInit(
_Inout_ PWDFDEVICE_INIT DeviceInit
)
{
TRACE_FUNCTION_ENTRY(LEVEL_VERBOSE);
WDF_FILEOBJECT_CONFIG config;
WDF_FILEOBJECT_CONFIG_INIT(&config, CreateCallback, CloseCallback, nullptr);
WDF_OBJECT_ATTRIBUTES objectAttributes;
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&objectAttributes, FileObjectContext);
objectAttributes.EvtDestroyCallback = DestroyCallback;
WdfDeviceInitSetFileObjectConfig(DeviceInit, &config, &objectAttributes);
TRACE_FUNCTION_SUCCESS(LEVEL_VERBOSE);
}
NTSTATUS PVPanicEvtDeviceAdd(IN WDFDRIVER Driver,
IN PWDFDEVICE_INIT DeviceInit)
{
NTSTATUS status;
WDFDEVICE device;
WDF_PNPPOWER_EVENT_CALLBACKS pnpPowerCallbacks;
WDF_FILEOBJECT_CONFIG fileConfig;
WDF_OBJECT_ATTRIBUTES attributes;
UNREFERENCED_PARAMETER(Driver);
TraceEvents(TRACE_LEVEL_VERBOSE, DBG_INIT, "--> %!FUNC!");
PAGED_CODE();
WDF_PNPPOWER_EVENT_CALLBACKS_INIT(&pnpPowerCallbacks);
pnpPowerCallbacks.EvtDevicePrepareHardware = PVPanicEvtDevicePrepareHardware;
pnpPowerCallbacks.EvtDeviceReleaseHardware = PVPanicEvtDeviceReleaseHardware;
pnpPowerCallbacks.EvtDeviceD0Entry = PVPanicEvtDeviceD0Entry;
pnpPowerCallbacks.EvtDeviceD0Exit = PVPanicEvtDeviceD0Exit;
WdfDeviceInitSetPnpPowerEventCallbacks(DeviceInit, &pnpPowerCallbacks);
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes, DEVICE_CONTEXT);
WDF_FILEOBJECT_CONFIG_INIT(&fileConfig, PVPanicEvtDeviceFileCreate,
WDF_NO_EVENT_CALLBACK, WDF_NO_EVENT_CALLBACK);
WdfDeviceInitSetFileObjectConfig(DeviceInit, &fileConfig,
WDF_NO_OBJECT_ATTRIBUTES);
status = WdfDeviceCreate(&DeviceInit, &attributes, &device);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_INIT,
"WdfDeviceCreate failed: %!STATUS!", status);
return status;
}
TraceEvents(TRACE_LEVEL_VERBOSE, DBG_INIT, "<-- %!FUNC!");
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;
}
/*++
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
PortIODeviceCreate(
PWDFDEVICE_INIT DeviceInit
)
/*++
Routine Description:
Worker routine called to create a device and its software resources.
Arguments:
DeviceInit - 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
--*/
{
WDF_OBJECT_ATTRIBUTES deviceAttributes;
PDEVICE_CONTEXT deviceContext;
WDF_PNPPOWER_EVENT_CALLBACKS pnpPowerCallbacks;
WDFDEVICE device;
NTSTATUS status;
UNICODE_STRING ntDeviceName;
UNICODE_STRING win32DeviceName;
WDF_FILEOBJECT_CONFIG fileConfig;
PAGED_CODE();
WDF_PNPPOWER_EVENT_CALLBACKS_INIT(&pnpPowerCallbacks);
//
// Register pnp/power callbacks so that we can start and stop the timer as
// the device gets started and stopped.
//
pnpPowerCallbacks.EvtDevicePrepareHardware = PortIOEvtDevicePrepareHardware;
pnpPowerCallbacks.EvtDeviceReleaseHardware = PortIOEvtDeviceReleaseHardware;
//
// Register the PnP and power callbacks. Power policy related callbacks will
// be registered later in SotwareInit.
//
WdfDeviceInitSetPnpPowerEventCallbacks(DeviceInit, &pnpPowerCallbacks);
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&deviceAttributes, DEVICE_CONTEXT);
WDF_FILEOBJECT_CONFIG_INIT(
&fileConfig,
WDF_NO_EVENT_CALLBACK,
WDF_NO_EVENT_CALLBACK,
WDF_NO_EVENT_CALLBACK // not interested in Cleanup
);
// Let the framework complete create and close
fileConfig.AutoForwardCleanupClose = WdfFalse;
WdfDeviceInitSetFileObjectConfig(DeviceInit,
&fileConfig,
WDF_NO_OBJECT_ATTRIBUTES);
//
// Create a named deviceobject so that legacy applications can talk to us.
// Since we are naming the object, we wouldn't able to install multiple
// instance of this driver. Please note that as per PNP guidelines, we
// should not name the FDO or create symbolic links. We are doing it because
// we have a legacy APP that doesn't know how to open an interface.
//
RtlInitUnicodeString(&ntDeviceName, GPD_DEVICE_NAME);
status = WdfDeviceInitAssignName(DeviceInit,&ntDeviceName);
if (!NT_SUCCESS(status)) {
return status;
}
WdfDeviceInitSetDeviceType(DeviceInit, GPD_TYPE);
//
// Call this if the device is not holding a pagefile
// crashdump file or hibernate file.
//
WdfDeviceInitSetPowerPageable(DeviceInit);
status = WdfDeviceCreate(&DeviceInit, &deviceAttributes, &device);
if (!NT_SUCCESS(status)) {
return status;
}
//
// Get the device context and initialize it. WdfObjectGet_DEVICE_CONTEXT is an
// inline function generated by WDF_DECLARE_CONTEXT_TYPE macro in the
// device.h header file. This function will do the type checking and return
// the device context. If you pass a wrong object handle
// it will return NULL and assert if run under framework verifier mode.
//
deviceContext = PortIOGetDeviceContext(device);
//
// This values is based on the hardware design.
// I'm assuming the address is in I/O space for our hardware.
// Refer http://support.microsoft.com/default.aspx?scid=kb;en-us;Q323595
// for more info.
//
deviceContext-> PortMemoryType = 1;
//
// Create a device interface so that application can find and talk
// to us.
//
RtlInitUnicodeString(&win32DeviceName, DOS_DEVICE_NAME);
status = WdfDeviceCreateSymbolicLink(
device,
&win32DeviceName);
if (!NT_SUCCESS(status)) {
return status;
}
//
// Initialize the I/O Package and any Queues
//
status = PortIOQueueInitialize(device);
return status;
}
NTSTATUS
VIOSerialDeviceListCreatePdo(
IN WDFCHILDLIST DeviceList,
IN PWDF_CHILD_IDENTIFICATION_DESCRIPTION_HEADER IdentificationDescription,
IN PWDFDEVICE_INIT ChildInit
)
{
PVIOSERIAL_PORT pport = NULL;
NTSTATUS status = STATUS_SUCCESS;
WDFDEVICE hChild = NULL;
WDF_OBJECT_ATTRIBUTES attributes;
WDF_PNPPOWER_EVENT_CALLBACKS PnpPowerCallbacks;
WDF_DEVICE_PNP_CAPABILITIES pnpCaps;
WDF_DEVICE_STATE deviceState;
WDF_IO_QUEUE_CONFIG queueConfig;
PRAWPDO_VIOSERIAL_PORT rawPdo = NULL;
WDF_FILEOBJECT_CONFIG fileConfig;
DECLARE_CONST_UNICODE_STRING(deviceId, PORT_DEVICE_ID );
DECLARE_CONST_UNICODE_STRING(deviceLocation, L"RedHat VIOSerial Port" );
DECLARE_UNICODE_STRING_SIZE(buffer, DEVICE_DESC_LENGTH);
UNREFERENCED_PARAMETER(DeviceList);
PAGED_CODE();
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_PNP, "--> %s\n", __FUNCTION__);
pport = CONTAINING_RECORD(IdentificationDescription,
VIOSERIAL_PORT,
Header
);
WdfDeviceInitSetDeviceType(ChildInit, FILE_DEVICE_SERIAL_PORT);
WdfDeviceInitSetIoType(ChildInit, WdfDeviceIoDirect);
do
{
WdfDeviceInitSetExclusive(ChildInit, TRUE);
status = WdfPdoInitAssignRawDevice(ChildInit, &GUID_DEVCLASS_PORT_DEVICE);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP, "WdfPdoInitAssignRawDevice failed - 0x%x\n", status);
break;
}
status = WdfDeviceInitAssignSDDLString(ChildInit, &SDDL_DEVOBJ_SYS_ALL_ADM_ALL);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP, "WdfDeviceInitAssignSDDLString failed - 0x%x\n", status);
break;
}
status = WdfPdoInitAssignDeviceID(ChildInit, &deviceId);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP, "WdfPdoInitAssignDeviceID failed - 0x%x\n", status);
break;
}
status = WdfPdoInitAddHardwareID(ChildInit, &deviceId);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP, "WdfPdoInitAddHardwareID failed - 0x%x\n", status);
break;
}
status = RtlUnicodeStringPrintf(
&buffer,
L"%02u",
pport->PortId
);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP, "RtlUnicodeStringPrintf failed - 0x%x\n", status);
break;
}
status = WdfPdoInitAssignInstanceID(ChildInit, &buffer);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP, "WdfPdoInitAssignInstanceID failed - 0x%x\n", status);
break;
}
status = RtlUnicodeStringPrintf(
&buffer,
L"vport%up%u",
pport->DeviceId,
pport->PortId
);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"RtlUnicodeStringPrintf failed 0x%x\n", status);
break;
}
status = WdfPdoInitAddDeviceText(
ChildInit,
&buffer,
&deviceLocation,
0x409
);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"WdfPdoInitAddDeviceText failed 0x%x\n", status);
break;
}
WdfPdoInitSetDefaultLocale(ChildInit, 0x409);
WDF_FILEOBJECT_CONFIG_INIT(
&fileConfig,
VIOSerialPortCreate,
VIOSerialPortClose,
WDF_NO_EVENT_CALLBACK
);
WdfDeviceInitSetFileObjectConfig(
ChildInit,
&fileConfig,
WDF_NO_OBJECT_ATTRIBUTES
);
WDF_PNPPOWER_EVENT_CALLBACKS_INIT(&PnpPowerCallbacks);
PnpPowerCallbacks.EvtDeviceD0Entry = VIOSerialPortEvtDeviceD0Entry;
PnpPowerCallbacks.EvtDeviceD0ExitPreInterruptsDisabled = VIOSerialPortEvtDeviceD0ExitPreInterruptsDisabled;
PnpPowerCallbacks.EvtDeviceD0Exit = VIOSerialPortEvtDeviceD0Exit;
WdfDeviceInitSetPnpPowerEventCallbacks(ChildInit, &PnpPowerCallbacks);
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes, RAWPDO_VIOSERIAL_PORT);
attributes.SynchronizationScope = WdfSynchronizationScopeDevice;
attributes.ExecutionLevel = WdfExecutionLevelPassive;
status = WdfDeviceCreate(
&ChildInit,
&attributes,
&hChild
);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"WdfDeviceCreate failed 0x%x\n", status);
break;
}
rawPdo = RawPdoSerialPortGetData(hChild);
rawPdo->port = pport;
pport->Device = hChild;
WDF_IO_QUEUE_CONFIG_INIT(&queueConfig,
WdfIoQueueDispatchSequential
);
queueConfig.EvtIoDeviceControl = VIOSerialPortDeviceControl;
status = WdfIoQueueCreate(hChild,
&queueConfig,
WDF_NO_OBJECT_ATTRIBUTES,
&pport->IoctlQueue
);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"WdfIoQueueCreate failed (IoCtrl Queue): 0x%x\n", status);
break;
}
status = WdfDeviceConfigureRequestDispatching(
hChild,
pport->IoctlQueue,
WdfRequestTypeDeviceControl
);
if(!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"DeviceConfigureRequestDispatching failed (IoCtrl Queue): 0x%x\n", status);
break;
}
WDF_IO_QUEUE_CONFIG_INIT(&queueConfig,
WdfIoQueueDispatchSequential);
queueConfig.EvtIoRead = VIOSerialPortRead;
queueConfig.EvtIoStop = VIOSerialPortIoStop;
status = WdfIoQueueCreate(hChild,
&queueConfig,
WDF_NO_OBJECT_ATTRIBUTES,
&pport->ReadQueue
);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"WdfIoQueueCreate (Read Queue) failed 0x%x\n", status);
break;
}
status = WdfDeviceConfigureRequestDispatching(
hChild,
pport->ReadQueue,
WdfRequestTypeRead
);
if(!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"DeviceConfigureRequestDispatching failed (Read Queue): 0x%x\n", status);
break;
}
WDF_IO_QUEUE_CONFIG_INIT(&queueConfig, WdfIoQueueDispatchSequential);
queueConfig.AllowZeroLengthRequests = WdfFalse;
queueConfig.EvtIoWrite = VIOSerialPortWrite;
status = WdfIoQueueCreate(hChild, &queueConfig,
WDF_NO_OBJECT_ATTRIBUTES, &pport->WriteQueue);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"WdfIoQueueCreate failed (Write Queue): 0x%x\n", status);
break;
}
status = WdfDeviceConfigureRequestDispatching(
hChild,
pport->WriteQueue,
WdfRequestTypeWrite
);
if(!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"DeviceConfigureRequestDispatching failed (Write Queue): 0x%x\n", status);
break;
}
WDF_DEVICE_PNP_CAPABILITIES_INIT(&pnpCaps);
pnpCaps.NoDisplayInUI = WdfTrue;
pnpCaps.Removable = WdfTrue;
pnpCaps.EjectSupported = WdfTrue;
pnpCaps.SurpriseRemovalOK= WdfTrue;
pnpCaps.Address = pport->DeviceId;
pnpCaps.UINumber = pport->PortId;
WdfDeviceSetPnpCapabilities(hChild, &pnpCaps);
WDF_DEVICE_STATE_INIT(&deviceState);
deviceState.DontDisplayInUI = WdfTrue;
WdfDeviceSetDeviceState(hChild, &deviceState);
status = WdfDeviceCreateDeviceInterface(
hChild,
&GUID_VIOSERIAL_PORT,
NULL
);
if (!NT_SUCCESS (status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"WdfDeviceCreateDeviceInterface failed 0x%x\n", status);
break;
}
WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
attributes.ParentObject = hChild;
status = WdfSpinLockCreate(
&attributes,
&pport->InBufLock
);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"WdfSpinLockCreate failed 0x%x\n", status);
break;
}
WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
attributes.ParentObject = hChild;
status = WdfSpinLockCreate(
&attributes,
&pport->OutVqLock
);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"WdfSpinLockCreate failed 0x%x\n", status);
break;
}
} while (0);
if (!NT_SUCCESS(status))
{
// We can send this before PDO is PRESENT since the device won't send any response.
VIOSerialSendCtrlMsg(pport->BusDevice, pport->PortId, VIRTIO_CONSOLE_PORT_READY, 0);
}
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_PNP, "<-- %s status 0x%x\n", __FUNCTION__, 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;
}
NTSTATUS PVPanicEvtDeviceAdd(IN WDFDRIVER Driver,
IN PWDFDEVICE_INIT DeviceInit)
{
NTSTATUS status;
WDFDEVICE device;
WDF_PNPPOWER_EVENT_CALLBACKS pnpPowerCallbacks;
WDF_FILEOBJECT_CONFIG fileConfig;
WDF_OBJECT_ATTRIBUTES attributes;
WDF_IO_QUEUE_CONFIG queueConfig;
PDEVICE_CONTEXT context;
DECLARE_CONST_UNICODE_STRING(dosDeviceName, PVPANIC_DOS_DEVICE_NAME);
UNREFERENCED_PARAMETER(Driver);
TraceEvents(TRACE_LEVEL_VERBOSE, DBG_INIT, "--> %!FUNC!");
PAGED_CODE();
WDF_PNPPOWER_EVENT_CALLBACKS_INIT(&pnpPowerCallbacks);
pnpPowerCallbacks.EvtDevicePrepareHardware = PVPanicEvtDevicePrepareHardware;
pnpPowerCallbacks.EvtDeviceReleaseHardware = PVPanicEvtDeviceReleaseHardware;
pnpPowerCallbacks.EvtDeviceD0Entry = PVPanicEvtDeviceD0Entry;
pnpPowerCallbacks.EvtDeviceD0Exit = PVPanicEvtDeviceD0Exit;
WdfDeviceInitSetPnpPowerEventCallbacks(DeviceInit, &pnpPowerCallbacks);
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes, DEVICE_CONTEXT);
WDF_FILEOBJECT_CONFIG_INIT(&fileConfig, PVPanicEvtDeviceFileCreate,
WDF_NO_EVENT_CALLBACK, WDF_NO_EVENT_CALLBACK);
WdfDeviceInitSetFileObjectConfig(DeviceInit, &fileConfig,
WDF_NO_OBJECT_ATTRIBUTES);
status = WdfDeviceCreate(&DeviceInit, &attributes, &device);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_INIT,
"WdfDeviceCreate failed: %!STATUS!", status);
return status;
}
status = WdfDeviceCreateSymbolicLink(device, &dosDeviceName);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_INIT,
"WdfDeviceCreateSymbolicLink failed: %!STATUS!", status);
return status;
}
WDF_IO_QUEUE_CONFIG_INIT(&queueConfig, WdfIoQueueDispatchSequential);
queueConfig.EvtIoDeviceControl = PVPanicEvtQueueDeviceControl;
context = GetDeviceContext(device);
status = WdfIoQueueCreate(device,
&queueConfig,
WDF_NO_OBJECT_ATTRIBUTES,
&context->IoctlQueue);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_INIT,
"WdfIoQueueCreate failed: %!STATUS!", status);
return status;
}
status = WdfDeviceConfigureRequestDispatching(device,
context->IoctlQueue,
WdfRequestTypeDeviceControl);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_INIT,
"WdfDeviceConfigureRequestDispatching failed: %!STATUS!", status);
return status;
}
TraceEvents(TRACE_LEVEL_VERBOSE, DBG_INIT, "<-- %!FUNC!");
return status;
}
static NTSTATUS UsbChief_EvtDeviceAdd(IN WDFDRIVER Driver, IN PWDFDEVICE_INIT DeviceInit)
{
WDF_PNPPOWER_EVENT_CALLBACKS pnpPowerCallbacks;
WDF_OBJECT_ATTRIBUTES fileObjectAttributes, requestAttributes, fdoAttributes;
WDF_FILEOBJECT_CONFIG fileConfig;
NTSTATUS Status;
WDFDEVICE device;
WDF_IO_QUEUE_CONFIG ioQueueConfig;
WDF_DEVICE_PNP_CAPABILITIES pnpCaps;
WDFQUEUE queue;
UNICODE_STRING linkname;
UNREFERENCED_PARAMETER(Driver);
PAGED_CODE();
UsbChief_DbgPrint(DEBUG_CONFIG, ("ExtDeviceAdd\n"));
/* Init PnP */
WDF_PNPPOWER_EVENT_CALLBACKS_INIT(&pnpPowerCallbacks);
pnpPowerCallbacks.EvtDevicePrepareHardware = UsbChief_EvtDevicePrepareHardware;
WdfDeviceInitSetPnpPowerEventCallbacks(DeviceInit, &pnpPowerCallbacks);
/* Request Attributes */
WDF_OBJECT_ATTRIBUTES_INIT(&requestAttributes);
WDF_OBJECT_ATTRIBUTES_SET_CONTEXT_TYPE(&requestAttributes, REQUEST_CONTEXT);
WdfDeviceInitSetRequestAttributes(DeviceInit, &requestAttributes);
/* Fileobject init */
WDF_FILEOBJECT_CONFIG_INIT(&fileConfig, UsbChief_EvtDeviceFileCreate,
WDF_NO_EVENT_CALLBACK,
WDF_NO_EVENT_CALLBACK);
WDF_OBJECT_ATTRIBUTES_INIT(&fileObjectAttributes);
WDF_OBJECT_ATTRIBUTES_SET_CONTEXT_TYPE(&fileObjectAttributes, FILE_CONTEXT);
WdfDeviceInitSetFileObjectConfig(DeviceInit, &fileConfig, &fileObjectAttributes);
WDF_OBJECT_ATTRIBUTES_INIT(&fdoAttributes);
WDF_OBJECT_ATTRIBUTES_SET_CONTEXT_TYPE(&fdoAttributes, DEVICE_CONTEXT);
Status = WdfDeviceCreate(&DeviceInit, &fdoAttributes, &device);
if (!NT_SUCCESS(Status)) {
UsbChief_DbgPrint(0, ("WdfDeviceCreate: %08x\n", Status));
return Status;
}
RtlInitUnicodeString(&linkname, L"\\DosDevices\\ChiefUSB");
Status = WdfDeviceCreateSymbolicLink(device, &linkname);
if (!NT_SUCCESS(Status)) {
UsbChief_DbgPrint(0, ("WdfDeviceCreateSymbolicLink: %08x\n", Status));
goto out;
}
WDF_DEVICE_PNP_CAPABILITIES_INIT(&pnpCaps);
pnpCaps.SurpriseRemovalOK = WdfTrue;
WdfDeviceSetPnpCapabilities(device, &pnpCaps);
/* Register I/O callbacks */
WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE(&ioQueueConfig, WdfIoQueueDispatchParallel);
ioQueueConfig.EvtIoRead = UsbChief_EvtIoRead;
ioQueueConfig.EvtIoWrite = UsbChief_EvtIoWrite;
ioQueueConfig.EvtIoDeviceControl = UsbChief_EvtIoDeviceControl;
ioQueueConfig.EvtIoStop = UsbChief_EvtIoStop;
ioQueueConfig.EvtIoResume = UsbChief_EvtIoResume;
Status = WdfIoQueueCreate(device, &ioQueueConfig, WDF_NO_OBJECT_ATTRIBUTES, &queue);
if (!NT_SUCCESS(Status)) {
UsbChief_DbgPrint(0, ("WdfIoQueueCreate: %08x\n", Status));
goto out;
}
Status = WdfDeviceCreateDeviceInterface(device, (LPGUID)&GUID_CLASS_USBCHIEF_USB, NULL);
if (!NT_SUCCESS(Status)) {
UsbChief_DbgPrint(0, ("WdfDeviceCreateDeviceInterface: %08x\n", Status));
goto out;
}
UsbChief_DbgPrint(3, ("EvtDriverDeviceAdd successful\n"));
return STATUS_SUCCESS;
out:
return Status;
}
/**
* @brief Called by the framework when a new PDO has arrived that this driver manages.
* The device in question is not operational at this point in time.
*
* @param[in] Driver handle to WDFDRIVER object created by DriverEntry()
* @param[in,out] DeviceInit device init object provided by framework.
*
* @returns NTSTATUS value indicating success or failure.
*
*/
NTSTATUS
FdoEvtDeviceAdd(
_In_ WDFDRIVER Driver,
_Inout_ PWDFDEVICE_INIT DeviceInit
)
{
UNREFERENCED_PARAMETER(Driver);
WDF_OBJECT_ATTRIBUTES attributes;
NTSTATUS status;
TraceEvents(TRACE_LEVEL_INFORMATION, TRACE_DEVICE,
__FUNCTION__"\n");
WdfDeviceInitSetDeviceType(DeviceInit, FILE_DEVICE_BUS_EXTENDER);
WdfDeviceInitSetExclusive(DeviceInit, FALSE);
WdfDeviceInitSetIoType(DeviceInit, WdfDeviceIoDirect);
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes, USB_FDO_CONTEXT);
attributes.EvtCleanupCallback = FdoEvtDeviceContextCleanup;
//
// Device state callbacks.
//
WDF_PNPPOWER_EVENT_CALLBACKS pnpPowerCallbacks;
WDF_PNPPOWER_EVENT_CALLBACKS_INIT(&pnpPowerCallbacks);
pnpPowerCallbacks.EvtDevicePrepareHardware = FdoEvtDevicePrepareHardware;
pnpPowerCallbacks.EvtDeviceReleaseHardware = FdoEvtDeviceReleaseHardware;
pnpPowerCallbacks.EvtDeviceD0Entry = FdoEvtDeviceD0Entry;
pnpPowerCallbacks.EvtDeviceD0EntryPostInterruptsEnabled = FdoEvtDeviceD0EntryPostInterruptsEnabled;
pnpPowerCallbacks.EvtDeviceD0Exit = FdoEvtDeviceD0Exit;
pnpPowerCallbacks.EvtDeviceSurpriseRemoval = FdoEvtDeviceSurpriseRemoval;
WdfDeviceInitSetPnpPowerEventCallbacks(DeviceInit, &pnpPowerCallbacks);
//
// establish a request context
//
WDF_OBJECT_ATTRIBUTES requestAttributes;
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&requestAttributes, FDO_REQUEST_CONTEXT);
WdfDeviceInitSetRequestAttributes(DeviceInit, &requestAttributes);
//
// static verifier seems to have a rule that the FDO must call
// WdfFdoInitSetDefaultChildListConfig if any component in the driver has
// dynamic child devices, and the roothub has one if it is not operating in
// connect usb hub mode.
//
WDF_CHILD_LIST_CONFIG config;
WDF_CHILD_LIST_CONFIG_INIT(&config,
sizeof(PDO_INDENTIFICATION_DESCRIPTION),
FdoEvtChildListCreateDevice);
WdfFdoInitSetDefaultChildListConfig(DeviceInit,
&config,
WDF_NO_OBJECT_ATTRIBUTES);
//
// add a preprocess callback for QueryInterface to support multi-version USBDI intefaces
//
UCHAR MinorFunctionTable[1] = {IRP_MN_QUERY_INTERFACE};
status = WdfDeviceInitAssignWdmIrpPreprocessCallback(
DeviceInit,
FdoPreProcessQueryInterface,
IRP_MJ_PNP,
MinorFunctionTable,
1);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, TRACE_DEVICE,
__FUNCTION__": WdfDeviceInitAssignWdmIrpPreprocessCallback failed error %x\n",
status);
return status;
}
//
// Add create/close handlers
//
WDF_OBJECT_ATTRIBUTES fileAttributes;
WDF_OBJECT_ATTRIBUTES_INIT(&fileAttributes);
fileAttributes.SynchronizationScope = WdfSynchronizationScopeNone;
WDF_FILEOBJECT_CONFIG FileObjectConfig;
WDF_FILEOBJECT_CONFIG_INIT(
&FileObjectConfig,
FdoEvtDeviceFileCreate,
FdoEvtFileClose,
WDF_NO_EVENT_CALLBACK);
WdfDeviceInitSetFileObjectConfig(
DeviceInit,
&FileObjectConfig,
&fileAttributes);
WDFDEVICE device;
status = WdfDeviceCreate(&DeviceInit, &attributes, &device);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, TRACE_DEVICE,
__FUNCTION__": WdfDeviceCreate failed error %x\n",
status);
return status;
}
PUSB_FDO_CONTEXT fdoContext = DeviceGetFdoContext(device);
RtlZeroMemory(fdoContext, sizeof(USB_FDO_CONTEXT));
fdoContext->WdfDevice = device;
KeInitializeEvent(&fdoContext->resetCompleteEvent, SynchronizationEvent, FALSE);
//
// allocate the dpc request collection.
//
WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
attributes.ParentObject = device;
status = WdfCollectionCreate(&attributes,
&fdoContext->RequestCollection);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, TRACE_DEVICE,
__FUNCTION__": WdfCollectionCreate failed\n");
return status;
};
//
// The FDO is the USB Controller, create a device interface for that.
//
status = WdfDeviceCreateDeviceInterface(
device,
&GUID_DEVINTERFACE_USB_HOST_CONTROLLER,
NULL);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, TRACE_DEVICE,
__FUNCTION__": WdfDeviceCreateDeviceInterface for device %p error %x\n",
device,
status);
return status;
}
WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
attributes.ParentObject = device;
status = WdfStringCreate(NULL, &attributes, &fdoContext->hcdsymlink);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, TRACE_DEVICE,
__FUNCTION__": WdfStringCreate for device %p error %x\n",
device,
status);
return status;
}
status = WdfDeviceRetrieveDeviceInterfaceString(device,
&GUID_DEVINTERFACE_USB_HOST_CONTROLLER,
NULL,
fdoContext->hcdsymlink);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, TRACE_DEVICE,
__FUNCTION__": WdfStringCreate for device %p error %x\n",
device,
status);
return status;
}
//
// Some of our resources are independent of the device state and
// can be allocated/initialized here.
//
status = InitScratchpad(fdoContext);
if (!NT_SUCCESS(status))
{
return status;
}
//
// Initialize the I/O Package and any Queues
//
status = FdoQueueInitialize(device);
if (!NT_SUCCESS(status))
{
return status;
}
//
// --XT-- All of the WDF ISR and DPC setup code was removed
// here. The DPC is now setup through the Xen interface in the
// previous call. Note the event channel is setup but not active
// until the backend is connected.
//
//
// Allocate a watchdog timer for our Xen interface.
//
WDF_TIMER_CONFIG timerConfig;
WDF_OBJECT_ATTRIBUTES timerAttributes;
WDF_TIMER_CONFIG_INIT(
&timerConfig,
FdoEvtTimerFunc);
WDF_OBJECT_ATTRIBUTES_INIT(&timerAttributes);
timerAttributes.ParentObject = device;
timerAttributes.ExecutionLevel = WdfExecutionLevelPassive;
status = WdfTimerCreate(
&timerConfig,
&timerAttributes,
&fdoContext->WatchdogTimer);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, TRACE_DEVICE,
__FUNCTION__": WdfTimerCreate error %x\n",
status);
return status;
}
//
// Create a collection of work items.
//
WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
attributes.ParentObject = device;
status = WdfCollectionCreate(&attributes,
&fdoContext->FreeWorkItems);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, TRACE_DEVICE,
__FUNCTION__": WdfCollectionCreate error %x\n",
status);
return status;
}
for (ULONG index = 0; index < INIT_WORK_ITEM_COUNT; index++)
{
WDFWORKITEM workitem = NewWorkItem(fdoContext,
NULL,
0,0,0,0);
if (workitem)
{
status = WdfCollectionAdd(fdoContext->FreeWorkItems, workitem);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, TRACE_DEVICE,
__FUNCTION__": WdfCollectionAdd for workitem index %d error %x\n",
index,
status);
WdfObjectDelete(workitem);
return status;
}
}
}
PNP_BUS_INFORMATION busInformation;
busInformation.BusNumber = 0;
busInformation.BusTypeGuid = GUID_BUS_TYPE_USB;
busInformation.LegacyBusType = PNPBus;
WdfDeviceSetBusInformationForChildren(
device,
&busInformation);
if (NT_SUCCESS(status)) {
status = LateSetup(device);
}
return status;
}
NTSTATUS
vJoy_CreateRawPdo(
WDFDEVICE Device,
ULONG InstanceNo
)
/*++
Routine Description:
This routine creates and initialize a PDO.
Arguments:
Return Value:
NT Status code.
--*/
{
NTSTATUS status;
PWDFDEVICE_INIT pDeviceInit = NULL;
PRPDO_DEVICE_DATA pdoData = NULL;
WDFDEVICE hChild = NULL;
WDF_OBJECT_ATTRIBUTES pdoAttributes;
WDF_DEVICE_PNP_CAPABILITIES pnpCaps;
WDF_IO_QUEUE_CONFIG ioQueueConfig;
WDFQUEUE queue;
WDF_DEVICE_STATE deviceState;
PDEVICE_EXTENSION devExt;
DECLARE_CONST_UNICODE_STRING(deviceId,VJOY_RAW_DEVICE_ID );
//DECLARE_CONST_UNICODE_STRING(hardwareId,VJOY_HARDWARE_ID );
DECLARE_CONST_UNICODE_STRING(deviceLocation,L"vJoy Raw Device\0" );
DECLARE_UNICODE_STRING_SIZE(buffer, MAX_ID_LEN);
PDEVICE_OBJECT ChildDeviceObject;
PDEVICE_OBJECT ParentDeviceObject;
DECLARE_CONST_UNICODE_STRING(
SDDL_DEVOBJ_SYS_ALL_ADM_RWX_WORLD_R_RES_R,
L"D:P(A;;GA;;;SY)(A;;GRGWGX;;;BA)(A;;GR;;;WD)(A;;GR;;;RC)"
);
DECLARE_CONST_UNICODE_STRING(
SDDL_DEVOBJ_SYS_ALL_ADM_RWX_WORLD_RWX_RES_R,
L"D:P(A;;GA;;;SY)(A;;GRGWGX;;;BA)(A;;GRGWGX;;;WD)(A;;GR;;;RC)"
);
int iInterface;
WCHAR RefStr[20];
UNICODE_STRING RefStr2;
WDF_FILEOBJECT_CONFIG FileObjInit;
WDF_OBJECT_ATTRIBUTES FileObjAttributes;
WDF_OBJECT_ATTRIBUTES LockAttributes;
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_INIT, "Entered vJoy_CreateRawPdo\n");
//
// Allocate a WDFDEVICE_INIT structure and set the properties
// so that we can create a device object for the child.
//
pDeviceInit = WdfPdoInitAllocate(Device);
if (pDeviceInit == NULL) {
status = STATUS_INSUFFICIENT_RESOURCES;
LogEventWithStatus(ERRLOG_RAW_DEV_FAILED ,L"WdfPdoInitAllocate", WdfDriverWdmGetDriverObject(WdfGetDriver()), status);
goto Cleanup;
}
//
// Mark the device RAW so that the child device can be started
// and accessed without requiring a function driver. Since we are
// creating a RAW PDO, we must provide a class guid.
//
status = WdfPdoInitAssignRawDevice(pDeviceInit, &GUID_DEVINTERFACE_VJOY);
if (!NT_SUCCESS(status)) {
LogEventWithStatus(ERRLOG_RAW_DEV_FAILED ,L"WdfPdoInitAssignRawDevice", WdfDriverWdmGetDriverObject(WdfGetDriver()), status);
goto Cleanup;
}
// TODO: Assign correct SDDL
////
status = WdfDeviceInitAssignSDDLString(pDeviceInit,
&SDDL_DEVOBJ_SYS_ALL_ADM_RWX_WORLD_RWX_RES_R);
if (!NT_SUCCESS(status)) {
LogEventWithStatus(ERRLOG_RAW_DEV_FAILED ,L"WdfDeviceInitAssignSDDLString", WdfDriverWdmGetDriverObject(WdfGetDriver()), status);
goto Cleanup;
}
//
// Assign DeviceID - This will be reported to IRP_MN_QUERY_ID/BusQueryDeviceID
//
status = WdfPdoInitAssignDeviceID(pDeviceInit, &deviceId);
if (!NT_SUCCESS(status)) {
LogEventWithStatus(ERRLOG_RAW_DEV_FAILED ,L"WdfPdoInitAssignDeviceID", WdfDriverWdmGetDriverObject(WdfGetDriver()), status);
goto Cleanup;
}
//
// We could be enumerating more than one children if the filter attaches
// to multiple instances of keyboard, so we must provide a
// BusQueryInstanceID. If we don't, system will throw CA bugcheck.
//
status = RtlUnicodeStringPrintf(&buffer, VJOY_DEVICE_INSTANCE, InstanceNo);
if (!NT_SUCCESS(status)) {
LogEventWithStatus(ERRLOG_RAW_DEV_FAILED ,L"RtlUnicodeStringPrintf (1)", WdfDriverWdmGetDriverObject(WdfGetDriver()), status);
goto Cleanup;
}
status = WdfPdoInitAssignInstanceID(pDeviceInit, &buffer);
if (!NT_SUCCESS(status)) {
LogEventWithStatus(ERRLOG_RAW_DEV_FAILED ,L"WdfPdoInitAssignInstanceID", WdfDriverWdmGetDriverObject(WdfGetDriver()), status);
goto Cleanup;
}
//
// Provide a description about the device. This text is usually read from
// the device. This text is displayed momentarily by the PnP manager while
// it's looking for a matching INF. If it finds one, it uses the Device
// Description from the INF file to display in the device manager.
// Since our device is raw device and we don't provide any hardware ID
// to match with an INF, this text will be displayed in the device manager.
//
status = RtlUnicodeStringPrintf(&buffer,VJOY_DEVICE_TEXT_409 ); // English - United States
if (!NT_SUCCESS(status)) {
LogEventWithStatus(ERRLOG_RAW_DEV_FAILED ,L"RtlUnicodeStringPrintf (2)", WdfDriverWdmGetDriverObject(WdfGetDriver()), status);
goto Cleanup;
}
//
// You can call WdfPdoInitAddDeviceText multiple times, adding device
// text for multiple locales. When the system displays the text, it
// chooses the text that matches the current locale, if available.
// Otherwise it will use the string for the default locale.
// The driver can specify the driver's default locale by calling
// WdfPdoInitSetDefaultLocale.
//
status = WdfPdoInitAddDeviceText(pDeviceInit,
&buffer,
&deviceLocation,
0x409 // English - United States
);
if (!NT_SUCCESS(status)) {
LogEventWithStatus(ERRLOG_RAW_DEV_FAILED ,L"WdfPdoInitAddDeviceText (1)", WdfDriverWdmGetDriverObject(WdfGetDriver()), status);
goto Cleanup;
}
#if 0
// Hebrew (No real ned - just for fun)
status = RtlUnicodeStringPrintf(&buffer,VJOY_DEVICE_TEXT_40D, InstanceNo ); // Hebrew
if (!NT_SUCCESS(status)) {
LogEventWithStatus(ERRLOG_RAW_DEV_FAILED ,L"RtlUnicodeStringPrintf (3)", WdfDriverWdmGetDriverObject(WdfGetDriver()), status);
goto Cleanup;
}
status = WdfPdoInitAddDeviceText(pDeviceInit,
&buffer,
&deviceLocation,
0x40D // Hebrew
);
if (!NT_SUCCESS(status)) {
LogEventWithStatus(ERRLOG_RAW_DEV_FAILED ,L"WdfPdoInitAddDeviceText (2)", WdfDriverWdmGetDriverObject(WdfGetDriver()), status);
goto Cleanup;
}
#endif // 0
WdfPdoInitSetDefaultLocale(pDeviceInit, 0x409); // English - United States
WdfDeviceInitSetExclusive(pDeviceInit, FALSE);
// Create a WDFFILEOBJECT
WDF_OBJECT_ATTRIBUTES_INIT(&FileObjAttributes);
WDF_OBJECT_ATTRIBUTES_SET_CONTEXT_TYPE(&FileObjAttributes, FILEOBJECT_EXTENSION);
WDF_FILEOBJECT_CONFIG_INIT(&FileObjInit, vJoy_EvtDeviceFileCreate, WDF_NO_EVENT_CALLBACK, vJoy_EvtFileCleanup);
WdfDeviceInitSetFileObjectConfig(pDeviceInit, &FileObjInit, &FileObjAttributes);
//
// Initialize the attributes to specify the size of PDO device extension.
// All the state information private to the PDO will be tracked here.
//
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&pdoAttributes, RPDO_DEVICE_DATA);
pdoAttributes.EvtCleanupCallback = rawEvtCleanupCallback;
//
// Set up our queue to allow forwarding of requests to the parent
// This is done so that the cached data can be retrieved
//
//WdfPdoInitAllowForwardingRequestToParent(pDeviceInit);
// TODO: Replace the above because it is needed for WdfRequestForwardToParentDeviceIoQueue()
status = WdfDeviceCreate(&pDeviceInit, &pdoAttributes, &hChild);
if (!NT_SUCCESS(status)) {
LogEventWithStatus(ERRLOG_RAW_DEV_FAILED ,L"WdfDeviceCreate", WdfDriverWdmGetDriverObject(WdfGetDriver()), status);
goto Cleanup;
}
//
// Get the device context.
//
pdoData = PdoGetData(hChild);
pdoData->InstanceNo = InstanceNo;
pdoData->hParentDevice = Device;
//
// Save the I/O target handle and adjust the I/O stack size:
//
devExt = GetDeviceContext(Device);
pdoData->IoTargetToParent = devExt->IoTargetToSelf;
ChildDeviceObject = WdfDeviceWdmGetDeviceObject(hChild);
ParentDeviceObject = WdfDeviceWdmGetDeviceObject(Device);
ChildDeviceObject->StackSize = ParentDeviceObject->StackSize+1;
// Create a wait-lock object that will be used to synch access to positions[i]
// The lock is created when the raw device is created so the raw device is set to be its parent
WDF_OBJECT_ATTRIBUTES_INIT(&LockAttributes);
LockAttributes.ParentObject = hChild;
status = WdfWaitLockCreate(&LockAttributes, &(devExt->positionLock));
if (!NT_SUCCESS(status)) {
TraceEvents(TRACE_LEVEL_ERROR, DBG_INIT, "WdfWaitLockCreate failed 0x%x\n", status);
LogEventWithStatus(ERRLOG_RAW_DEV_FAILED ,L"WdfWaitLockCreate", WdfDriverWdmGetDriverObject(WdfGetDriver()), status);
goto Cleanup;
}
//
// Configure the default queue associated with the control device object
// to be Serial so that request passed to EvtIoDeviceControl are serialized.
// A default queue gets all the requests that are not
// configure-fowarded using WdfDeviceConfigureRequestDispatching.
//
WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE(&ioQueueConfig,
WdfIoQueueDispatchSequential);
ioQueueConfig.EvtIoDeviceControl = vJoy_EvtIoDeviceControlForRawPdo;
status = WdfIoQueueCreate(hChild,
&ioQueueConfig,
WDF_NO_OBJECT_ATTRIBUTES,
&queue // pointer to default queue
);
if (!NT_SUCCESS(status)) {
TraceEvents(TRACE_LEVEL_ERROR, DBG_INIT, "WdfIoQueueCreate failed 0x%x\n", status);
LogEventWithStatus(ERRLOG_RAW_DEV_FAILED ,L"WdfIoQueueCreate", WdfDriverWdmGetDriverObject(WdfGetDriver()), status);
goto Cleanup;
}
//
// Set some properties for the child device.
//
WDF_DEVICE_PNP_CAPABILITIES_INIT(&pnpCaps);
pnpCaps.Removable = WdfTrue; // Remove Icon from " Devices and Printers"
pnpCaps.SurpriseRemovalOK = WdfTrue;
pnpCaps.NoDisplayInUI = WdfTrue;
// pnpCaps.Address = InstanceNo;
pnpCaps.UINumber = 0;
WdfDeviceSetPnpCapabilities(hChild, &pnpCaps);
//
// TODO: In addition to setting NoDisplayInUI in DeviceCaps, we
// have to do the following to hide the device. Following call
// tells the framework to report the device state in
// IRP_MN_QUERY_DEVICE_STATE request.
//
WDF_DEVICE_STATE_INIT(&deviceState);
deviceState.DontDisplayInUI = WdfTrue; // Remove Icon from Device manager
WdfDeviceSetDeviceState(hChild, &deviceState);
//
// Create 16 interfaces
//
for (iInterface=1 ; iInterface <= MAX_N_DEVICES; iInterface++)
{
RtlStringCchPrintfW((NTSTRSAFE_PWSTR)RefStr, 20, VJOY_INTERFACE L"%03d", iInterface);
RtlInitUnicodeString(&RefStr2, (PCWSTR)RefStr);
status = WdfDeviceCreateDeviceInterface(hChild,&GUID_DEVINTERFACE_VJOY,&RefStr2);
if (!NT_SUCCESS (status)) {
TraceEvents(TRACE_LEVEL_ERROR, DBG_INIT, "WdfDeviceCreateDeviceInterface number %d failed 0x%x\n", iInterface, status);
LogEventWithStatus(ERRLOG_RAW_DEV_FAILED ,L"WdfDeviceCreateDeviceInterface", WdfDriverWdmGetDriverObject(WdfGetDriver()), status);
goto Cleanup;
}
};
// Mark all interfaces as unused
pdoData->UsedInterfacesMask=0;
//
// Add this device to the FDO's collection of children.
// After the child device is added to the static collection successfully,
// driver must call WdfPdoMarkMissing to get the device deleted. It
// shouldn't delete the child device directly by calling WdfObjectDelete.
//
status = WdfFdoAddStaticChild(Device, hChild);
if (!NT_SUCCESS(status)) {
LogEventWithStatus(ERRLOG_RAW_DEV_FAILED ,L"WdfFdoAddStaticChild", WdfDriverWdmGetDriverObject(WdfGetDriver()), status);
goto Cleanup;
}
return STATUS_SUCCESS;
Cleanup:
TraceEvents(TRACE_LEVEL_ERROR, DBG_INIT, "KbFiltr_CreatePdo failed %x\n", status);
//
// Call WdfDeviceInitFree if you encounter an error while initializing
// a new framework device object. If you call WdfDeviceInitFree,
// do not call WdfDeviceCreate.
//
if (pDeviceInit != NULL) {
WdfDeviceInitFree(pDeviceInit);
}
if(hChild) {
WdfObjectDelete(hChild);
}
return status;
}
// 添加设备回调
NTSTATUS EvtDriverDeviceAdd( IN WDFDRIVER Driver,
IN PWDFDEVICE_INIT DeviceInit )
{
NTSTATUS status;
WDFDEVICE device; // 设备对象
WDF_IO_QUEUE_CONFIG ioQueueConfig;
WDF_FILEOBJECT_CONFIG fileConfig;
PAGED_CODE();
// 互斥访问，同时刻只能一个应用程序与设备通信
WdfDeviceInitSetExclusive(DeviceInit, TRUE);
// 缓冲IO方式
WdfDeviceInitSetIoType(DeviceInit, WdfDeviceIoBuffered);
// 初始化文件对象
WDF_FILEOBJECT_CONFIG_INIT(&fileConfig, EvtDeviceFileCreate,
EvtFileClose, WDF_NO_EVENT_CALLBACK);
WdfDeviceInitSetFileObjectConfig(DeviceInit, &fileConfig, WDF_NO_OBJECT_ATTRIBUTES);
// 创建设备
status = WdfDeviceCreate(&DeviceInit, WDF_NO_OBJECT_ATTRIBUTES, &device);
if( !NT_SUCCESS(status) )
{
KdPrint(("[EvtDriverDeviceAdd] WdfDeviceCreate failed!"));
return status;
}
//使用缺省队列，设置I/O请求分发处理方式为串行
WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE(&ioQueueConfig, WdfIoQueueDispatchSequential);
// 设置EvtIoRead回调例程
ioQueueConfig.EvtIoRead = EvtIoRead;
// 设置EvtIoWrite回调例程
ioQueueConfig.EvtIoWrite = EvtIoWrite;
//设置EvtIoDeviceControl回调例程
ioQueueConfig.EvtIoDeviceControl = EvtIoDeviceControl;
// 创建队列
status = WdfIoQueueCreate(device, &ioQueueConfig, WDF_NO_OBJECT_ATTRIBUTES, WDF_NO_HANDLE);
if( !NT_SUCCESS(status) )
{
KdPrint(("[EvtDriverDeviceAdd] WdfIoQueueCreate failed!"));
return status;
}
// 创建设备接口
status = WdfDeviceCreateDeviceInterface(device,(LPGUID)&IOSample_DEVINTERFACE_GUID ,NULL);
if( !NT_SUCCESS(status) )
{
KdPrint(("[EvtDriverDeviceAdd] WdfDeviceCreateDeviceInterface failed!"));
}
return status;
}
NTSTATUS AndroidUsbDeviceObject::CreateFDODevice(PWDFDEVICE_INIT device_init) {
ASSERT_IRQL_PASSIVE();
ASSERT(!IsTaretDeviceCreated());
if (IsTaretDeviceCreated())
return STATUS_INTERNAL_ERROR;
// Initialize our object attributes first
WDF_OBJECT_ATTRIBUTES device_attr;
NTSTATUS status = InitObjectAttributes(&device_attr, NULL);
ASSERT(NT_SUCCESS(status));
if (!NT_SUCCESS(status))
return status;
// Initialize the pnp_power_callbacks structure. Callback events for PnP
// and Power are specified here. If we don't supply any callbacks, the
// KMDF will take appropriate default actions for an FDO device object.
// EvtDevicePrepareHardware and EvtDeviceReleaseHardware are major entry
// points for initializing / cleaning up our device. Probably, we can leave
// the rest to the framework.
WDF_PNPPOWER_EVENT_CALLBACKS pnp_power_callbacks;
WDF_PNPPOWER_EVENT_CALLBACKS_INIT(&pnp_power_callbacks);
pnp_power_callbacks.EvtDevicePrepareHardware =
EvtDevicePrepareHardwareEntry;
pnp_power_callbacks.EvtDeviceReleaseHardware =
EvtDeviceReleaseHardwareEntry;
WdfDeviceInitSetPnpPowerEventCallbacks(device_init, &pnp_power_callbacks);
// Initialize the request attributes to specify the context size and type
// for every request created by framework for this device.
WDF_OBJECT_ATTRIBUTES request_attr;
WDF_OBJECT_ATTRIBUTES_INIT(&request_attr);
WDF_OBJECT_ATTRIBUTES_SET_CONTEXT_TYPE(&request_attr, AndroidUsbWdfRequestContext);
WdfDeviceInitSetRequestAttributes(device_init, &request_attr);
// Initialize WDF_FILEOBJECT_CONFIG_INIT struct to tell the KMDF that we are
// interested in handling Create requests that get genereated when an
// application or another kernel component opens a handle through the device.
// We are not interested in receiving cleanup / close IRPs at this point.
WDF_FILEOBJECT_CONFIG file_config;
WDF_OBJECT_ATTRIBUTES file_attr;
WDF_FILEOBJECT_CONFIG_INIT(&file_config,
EvtDeviceFileCreateEntry,
WDF_NO_EVENT_CALLBACK,
WDF_NO_EVENT_CALLBACK);
WDF_OBJECT_ATTRIBUTES_INIT(&file_attr);
WDF_OBJECT_ATTRIBUTES_SET_CONTEXT_TYPE(&file_attr,
AndroidUsbWdfObjectContext);
file_attr.EvtCleanupCallback = AndroidUsbWdfObject::EvtCleanupCallbackEntry;
file_attr.EvtDestroyCallback = AndroidUsbWdfObject::EvtDestroyCallbackEntry;
// We will provide our own synchronization for file access
file_attr.SynchronizationScope = WdfSynchronizationScopeNone;
WdfDeviceInitSetFileObjectConfig(device_init, &file_config, &file_attr);
// I/O type is buffered by default. It could be very inefficient if we have
// large reads / writes through our device.
WdfDeviceInitSetIoType(device_init, WdfDeviceIoDirect);
// DeviceInit is completely initialized. So call the framework
// to create the device and attach it to the lower stack.
WDFDEVICE wdf_dev = NULL;
status = WdfDeviceCreate(&device_init, &device_attr, &wdf_dev);
ASSERT(NT_SUCCESS(status) && (NULL != wdf_dev));
if (!NT_SUCCESS(status))
return status;
// Save handle to the created device
set_wdf_object(wdf_dev);
// Tell the framework to set the SurpriseRemovalOK in the DeviceCaps so
// that we don't get the popup in usermode (on Win2K) when we surprise
// remove the device.
WDF_DEVICE_PNP_CAPABILITIES pnp_caps;
WDF_DEVICE_PNP_CAPABILITIES_INIT(&pnp_caps);
pnp_caps.SurpriseRemovalOK = WdfTrue;
WdfDeviceSetPnpCapabilities(wdf_device(), &pnp_caps);
// Create our default queue object for this device to start receiving I/O
status = CreateDefaultQueue();
ASSERT(NT_SUCCESS(status));
if (!NT_SUCCESS(status))
return status;
// Register a device interface so that app can find our device and talk to it.
status = WdfDeviceCreateDeviceInterface(wdf_device(), &android_guid, NULL);
ASSERT(NT_SUCCESS(status));
if (!NT_SUCCESS(status))
return status;
// Initialize our extension to that device. We will do this at the very end
// so we know that we successfully passed entire device create chain when
// we are called with other callbacks to that device.
status = InitializeContext();
ASSERT(NT_SUCCESS(status));
if (!NT_SUCCESS(status))
return status;
return STATUS_SUCCESS;
}
NTSTATUS
NdisProtCreateControlDevice(
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:
Driver - a pointer to the framework 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 objectAttribs;
WDF_IO_QUEUE_CONFIG ioQueueConfig;
WDF_FILEOBJECT_CONFIG fileConfig;
WDFDEVICE controlDevice = NULL;
WDFQUEUE queue;
DECLARE_CONST_UNICODE_STRING(ntDeviceName, NT_DEVICE_NAME) ;
DECLARE_CONST_UNICODE_STRING(dosDeviceName, DOS_DEVICE_NAME) ;
UNREFERENCED_PARAMETER( Driver );
DEBUGP(DL_LOUD, ("NdisProtCreateControlDevice DeviceInit %p\n", DeviceInit));
//
// I/O type is Buffered by default. We want to do direct I/O for Reads
// and Writes so set it explicitly.
//
WdfDeviceInitSetIoType(DeviceInit, WdfDeviceIoDirect);
status = WdfDeviceInitAssignName(DeviceInit, &ntDeviceName);
if (!NT_SUCCESS(status)) {
goto Error;
}
//
// Initialize WDF_FILEOBJECT_CONFIG_INIT struct to tell the
// framework whether you are interested in handle Create, Close and
// Cleanup requests that gets genereated 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,
NdisProtEvtDeviceFileCreate,
NdisProtEvtFileClose,
NdisProtEvtFileCleanup
);
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&objectAttribs,
FILE_OBJECT_CONTEXT);
WdfDeviceInitSetFileObjectConfig(DeviceInit,
&fileConfig,
&objectAttribs);
WDF_OBJECT_ATTRIBUTES_INIT(&objectAttribs);
status = WdfDeviceCreate(&DeviceInit,
&objectAttribs,
&controlDevice);
if (!NT_SUCCESS(status)) {
goto Error;
}
//
// DeviceInit is set to NULL if the device is created successfully.
//
//
// Create a symbolic link for the control object so that usermode can open
// the device.
//
status = WdfDeviceCreateSymbolicLink(controlDevice, &dosDeviceName);
if (!NT_SUCCESS(status)) {
goto Error;
}
//
// Configure a default queue associated with the control device to
// to receive read, write, and ioctl requests in parallel.
// A default queue gets all the requests that are not
// configure-fowarded using WdfDeviceConfigureRequestDispatching.
//
WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE(&ioQueueConfig,
WdfIoQueueDispatchParallel);
ioQueueConfig.EvtIoWrite = NdisProtEvtIoWrite;
ioQueueConfig.EvtIoRead = NdisProtEvtIoRead;
ioQueueConfig.EvtIoDeviceControl = NdisProtEvtIoDeviceControl;
status = WdfIoQueueCreate(controlDevice,
&ioQueueConfig,
WDF_NO_OBJECT_ATTRIBUTES,
&queue // pointer to default queue
);
if (!NT_SUCCESS(status)) {
goto Error;
}
//
// Control devices must notify WDF when they are done initializing. I/O is
// rejected until this call is made.
//
WdfControlFinishInitializing(controlDevice);
//
// Create our device object using which an application can
// access NDIS devices.
//
Globals.ControlDevice = controlDevice;
return status;
Error:
if(DeviceInit != NULL) {
//
// Free the WDFDEVICE_INIT structure only if the device
// creation fails. Otherwise framework frees the memory
// itself.
//
WdfDeviceInitFree(DeviceInit);
}
return status;
}
NTSTATUS
BalloonDeviceAdd(
IN WDFDRIVER Driver,
IN PWDFDEVICE_INIT DeviceInit)
{
NTSTATUS status = STATUS_SUCCESS;
WDFDEVICE device;
PDEVICE_CONTEXT devCtx = NULL;
WDF_INTERRUPT_CONFIG interruptConfig;
WDF_FILEOBJECT_CONFIG fileConfig;
WDF_OBJECT_ATTRIBUTES attributes;
WDF_PNPPOWER_EVENT_CALLBACKS pnpPowerCallbacks;
UNREFERENCED_PARAMETER(Driver);
PAGED_CODE();
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_PNP, "--> %s\n", __FUNCTION__);
WDF_PNPPOWER_EVENT_CALLBACKS_INIT(&pnpPowerCallbacks);
pnpPowerCallbacks.EvtDevicePrepareHardware = BalloonEvtDevicePrepareHardware;
pnpPowerCallbacks.EvtDeviceReleaseHardware = BalloonEvtDeviceReleaseHardware;
pnpPowerCallbacks.EvtDeviceD0Entry = BalloonEvtDeviceD0Entry;
pnpPowerCallbacks.EvtDeviceD0Exit = BalloonEvtDeviceD0Exit;
pnpPowerCallbacks.EvtDeviceD0ExitPreInterruptsDisabled = BalloonEvtDeviceD0ExitPreInterruptsDisabled;
WdfDeviceInitSetPnpPowerEventCallbacks(DeviceInit, &pnpPowerCallbacks);
WDF_FILEOBJECT_CONFIG_INIT(
&fileConfig,
WDF_NO_EVENT_CALLBACK,
BalloonEvtFileClose,
WDF_NO_EVENT_CALLBACK
);
WdfDeviceInitSetFileObjectConfig(DeviceInit,
&fileConfig,
WDF_NO_OBJECT_ATTRIBUTES);
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes, DEVICE_CONTEXT);
attributes.EvtCleanupCallback = BalloonEvtDeviceContextCleanup;
status = WdfDeviceCreate(&DeviceInit, &attributes, &device);
if(!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"WdfDeviceCreate failed with status 0x%08x\n", status);
return status;
}
devCtx = GetDeviceContext(device);
WDF_INTERRUPT_CONFIG_INIT(&interruptConfig,
BalloonInterruptIsr,
BalloonInterruptDpc);
interruptConfig.EvtInterruptEnable = BalloonInterruptEnable;
interruptConfig.EvtInterruptDisable = BalloonInterruptDisable;
status = WdfInterruptCreate(device,
&interruptConfig,
WDF_NO_OBJECT_ATTRIBUTES,
&devCtx->WdfInterrupt);
if (!NT_SUCCESS (status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"WdfInterruptCreate failed: 0x%08x\n", status);
return status;
}
status = WdfDeviceCreateDeviceInterface(device, &GUID_DEVINTERFACE_BALLOON, NULL);
if(!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"WdfDeviceCreateDeviceInterface failed with status 0x%08x\n", status);
return status;
}
devCtx->bShutDown = FALSE;
devCtx->num_pages = 0;
devCtx->PageListHead.Next = NULL;
ExInitializeNPagedLookasideList(
&devCtx->LookAsideList,
NULL,
NULL,
0,
sizeof(PAGE_LIST_ENTRY),
BALLOON_MGMT_POOL_TAG,
0
);
devCtx->bListInitialized = TRUE;
devCtx->pfns_table = (PPFN_NUMBER)
ExAllocatePoolWithTag(
NonPagedPool,
PAGE_SIZE,
BALLOON_MGMT_POOL_TAG
);
if(devCtx->pfns_table == NULL)
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,"ExAllocatePoolWithTag failed\n");
status = STATUS_INSUFFICIENT_RESOURCES;
return status;
}
devCtx->MemStats = (PBALLOON_STAT)
ExAllocatePoolWithTag(
NonPagedPool,
sizeof (BALLOON_STAT) * VIRTIO_BALLOON_S_NR,
BALLOON_MGMT_POOL_TAG
);
if(devCtx->MemStats == NULL)
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,"ExAllocatePoolWithTag failed\n");
status = STATUS_INSUFFICIENT_RESOURCES;
return status;
}
RtlFillMemory (devCtx->MemStats, sizeof (BALLOON_STAT) * VIRTIO_BALLOON_S_NR, -1);
KeInitializeEvent(&devCtx->HostAckEvent,
SynchronizationEvent,
FALSE
);
status = BalloonQueueInitialize(device);
if(!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
"BalloonQueueInitialize failed with status 0x%08x\n", status);
return status;
}
KeInitializeEvent(&devCtx->WakeUpThread,
SynchronizationEvent,
FALSE
);
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_PNP, "<-- %s\n", __FUNCTION__);
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;
}
/*
** Driver TODO: Complete the implementation of EvtDriverDeviceAdd for your specific device.
**
** WDF calls this callback when a device instance is added to the driver. Good drivers will do a lot of
** work here to set up everything necessary, such as adding callbacks for PNP power state changes.
** This function defines an IO queue for handling DeviceIoControl and file read requests, both of which are
** important to the POS barcode scanner model.
**
** Note that this is not a complete device add implementation, as the PNP power callbacks are not handled.
** Additionally, driver writers may wish to set up additional queues to serialize device property requests
** (see Ioctl.cpp for more info).
*/
NTSTATUS EvtDriverDeviceAdd(_In_ WDFDRIVER /* UnusedDriver */, _Inout_ PWDFDEVICE_INIT DeviceInit)
{
NTSTATUS status = STATUS_SUCCESS;
WDF_FILEOBJECT_CONFIG fileConfig;
WDF_OBJECT_ATTRIBUTES deviceAttributes;
WDF_OBJECT_ATTRIBUTES fileAttributes;
WDFDEVICE device;
// Handle file events
WDF_FILEOBJECT_CONFIG_INIT(
&fileConfig,
EvtDeviceFileCreate,
EvtFileClose,
WDF_NO_EVENT_CALLBACK
);
WDF_OBJECT_ATTRIBUTES_INIT(&fileAttributes);
WdfDeviceInitSetFileObjectConfig(
DeviceInit,
&fileConfig,
&fileAttributes
);
// Create Device
WDF_OBJECT_ATTRIBUTES_INIT(&deviceAttributes);
status = WdfDeviceCreate(
&DeviceInit,
&deviceAttributes,
&device
);
if (!NT_SUCCESS(status))
{
return status;
}
// Create a device interface for POS Barcode Scanner so that the device can be enumerated
status = WdfDeviceCreateDeviceInterface(
device,
&GUID_DEVINTERFACE_POS_SCANNER,
NULL
);
if (!NT_SUCCESS(status))
{
return status;
}
// Initialize the POS library
POS_CX_ATTRIBUTES posCxAttributes;
POS_CX_ATTRIBUTES_INIT(&posCxAttributes);
posCxAttributes.EvtDeviceOwnershipChange = EvtDeviceOwnershipChange;
status = PosCxInit(device, &posCxAttributes);
if (!NT_SUCCESS(status))
{
return status;
}
// Set up an IO queue to handle DeviceIoControl and ReadFile
WDF_IO_QUEUE_CONFIG queueConfig;
WDF_OBJECT_ATTRIBUTES attributes;
WDFQUEUE queue;
WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE(&queueConfig, WdfIoQueueDispatchSequential);
queueConfig.EvtIoDeviceControl = EvtIoDeviceControl;
queueConfig.EvtIoRead = EvtIoRead;
// Call us in PASSIVE_LEVEL
WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
attributes.ExecutionLevel = WdfExecutionLevelPassive;
status = WdfIoQueueCreate(
device,
&queueConfig,
&attributes,
&queue
);
return status;
}