BOOLEAN
SerialPutRegistryKeyValue(
IN WDFDEVICE WdfDevice,
_In_ PCWSTR Name,
IN ULONG Value
)
/*++
Routine Description:
Can be used to write any REG_DWORD registry value stored
under Device Parameter.
Arguments:
Return Value:
TRUE - if write is successful
FALSE - otherwise
--*/
{
WDFKEY hKey = NULL;
NTSTATUS status;
BOOLEAN retValue = FALSE;
UNICODE_STRING valueName;
PAGED_CODE();
SerialDbgPrintEx(TRACE_LEVEL_VERBOSE, DBG_PNP, "Entered PciDrvWriteRegistryValue\n");
//
// write the value out to the registry
//
status = WdfDeviceOpenRegistryKey(WdfDevice,
PLUGPLAY_REGKEY_DEVICE,
STANDARD_RIGHTS_ALL,
WDF_NO_OBJECT_ATTRIBUTES,
&hKey);
if (NT_SUCCESS (status)) {
RtlInitUnicodeString(&valueName,Name);
status = WdfRegistryAssignULong (hKey,
&valueName,
Value
);
if (NT_SUCCESS (status)) {
retValue = TRUE;
}
WdfRegistryClose(hKey);
}
return retValue;
}
_Use_decl_annotations_
NTSTATUS
SaveSimBattStateToRegistry (
WDFDEVICE Device,
PSIMBATT_STATE State
)
/*
Routine Description:
Called to save simbatt state data to the registry.
Arguments:
Device - Supplies WDF device handle.
State - Supplies the pointer to the simbatt state.
Return Value:
NTSTATUS
--*/
{
WDFKEY KeyHandle;
DECLARE_CONST_UNICODE_STRING(SimbattStateRegNameStr, SIMBATT_STATE_REG_NAME);
NTSTATUS Status;
PAGED_CODE();
Status = WdfDeviceOpenRegistryKey(
Device,
PLUGPLAY_REGKEY_DEVICE,
KEY_WRITE,
NULL,
&KeyHandle
);
if (!NT_SUCCESS (Status)) {
goto SaveSimBattStateToRegistryEnd;
}
Status = WdfRegistryAssignValue(
KeyHandle,
&SimbattStateRegNameStr,
REG_BINARY,
sizeof(SIMBATT_STATE),
State
);
WdfRegistryClose(KeyHandle);
if (!NT_SUCCESS (Status)) {
goto SaveSimBattStateToRegistryEnd;
}
SaveSimBattStateToRegistryEnd:
return Status;
}
NTSTATUS WriteBackupRegistersToRegistry(HANDLE_DEV Device)
{
WDFKEY key = NULL;
WDFKEY subkey = NULL;
NTSTATUS status;
// Retrieve registry settings.
DECLARE_CONST_UNICODE_STRING(subConfigName, L"Config");
DECLARE_CONST_UNICODE_STRING(backupName, L"backup");
status = WdfDeviceOpenRegistryKey(Device, PLUGPLAY_REGKEY_DEVICE, KEY_READ, WDF_NO_OBJECT_ATTRIBUTES, &key);
if (!NT_SUCCESS(status))
{
TraceLog(TRACE_LEVEL_WARNING, TRACE_ALGO, "Error opening device registry key - %!STATUS!", status);
}
else
{
status = WdfRegistryOpenKey(key, &subConfigName, KEY_READ, WDF_NO_OBJECT_ATTRIBUTES, &subkey);
if (!NT_SUCCESS(status))
{
TraceLog(TRACE_LEVEL_WARNING, TRACE_ALGO, "Error opening registry subkey for 'Config' - %!STATUS!", status);
}
else
{
ULONG length = sizeof(gs_backupRegisters);
status = WdfRegistryAssignValue(subkey, &backupName, REG_BINARY, length, gs_backupRegisters);
if (!NT_SUCCESS(status))
{
TraceLog(TRACE_LEVEL_WARNING, TRACE_ALGO, "Error querying registry value for 'backup reg' - %!STATUS!", status);
}
}
if (subkey != NULL)
{
WdfRegistryClose(subkey);
subkey = NULL;
}
}
if (key != NULL)
{
WdfRegistryClose(key);
key = NULL;
}
return status;
}
NTSTATUS
Bus_DoStaticEnumeration(
IN WDFDEVICE Device
)
/*++
Routine Description:
The routine enables you to statically enumerate child devices
during start instead of running the enum.exe/notify.exe to
enumerate toaster devices.
In order to statically enumerate, user must specify the number
of toasters in the Toaster Bus driver's device registry. The
default value is zero.
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Enum\Root\SYSTEM\0002\
Device Parameters
NumberOfToasters:REG_DWORD:2
You can also configure this value in the Toaster Bus Inf file.
--*/
{
WDFKEY hKey = NULL;
NTSTATUS status;
ULONG value, i;
DECLARE_CONST_UNICODE_STRING(valueName, L"NumberOfToasters");
//
// If the registry value doesn't exist, we will use the
// hardcoded default number.
//
value = DEF_STATICALLY_ENUMERATED_TOASTERS;
//
// Open the device registry and read the "NumberOfToasters" value.
//
status = WdfDeviceOpenRegistryKey(Device,
PLUGPLAY_REGKEY_DEVICE,
STANDARD_RIGHTS_ALL,
NULL, // PWDF_OBJECT_ATTRIBUTES
&hKey);
if (NT_SUCCESS (status)) {
status = WdfRegistryQueryULong(hKey,
&valueName,
&value);
WdfRegistryClose(hKey);
hKey = NULL; // Set hKey to NULL to catch any accidental subsequent use.
if (NT_SUCCESS (status)) {
//
// Make sure it doesn't exceed the max. This is required to prevent
// denial of service by enumerating large number of child devices.
//
value = min(value, MAX_STATICALLY_ENUMERATED_TOASTERS);
}else {
return STATUS_SUCCESS; // This is an optional property.
}
}
KdPrint(("Enumerating %d toaster devices\n", value));
for(i=1; i<= value; i++) {
//
// Value of i is used as serial number.
//
status = Bus_PlugInDevice(Device,
BUS_HARDWARE_IDS,
BUS_HARDWARE_IDS_LENGTH / sizeof(WCHAR),
i );
}
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;
}
BOOLEAN
SerialGetRegistryKeyValue(
IN WDFDEVICE WdfDevice,
_In_ PCWSTR Name,
OUT PULONG Value
)
/*++
Routine Description:
Can be used to read any REG_DWORD registry value stored
under Device Parameter.
Arguments:
FdoData - pointer to the device extension
Name - Name of the registry value
Value -
Return Value:
TRUE if successful
FALSE if not present/error in reading registry
--*/
{
WDFKEY hKey = NULL;
NTSTATUS status;
BOOLEAN retValue = FALSE;
UNICODE_STRING valueName;
PAGED_CODE();
SerialDbgPrintEx(TRACE_LEVEL_VERBOSE, DBG_PNP, ">SerialGetRegistryKeyValue(XXX)\n");
*Value = 0;
status = WdfDeviceOpenRegistryKey(WdfDevice,
PLUGPLAY_REGKEY_DEVICE,
STANDARD_RIGHTS_ALL,
WDF_NO_OBJECT_ATTRIBUTES,
&hKey);
if (NT_SUCCESS (status)) {
RtlInitUnicodeString(&valueName,Name);
status = WdfRegistryQueryULong (hKey,
&valueName,
Value);
if (NT_SUCCESS (status)) {
retValue = TRUE;
}
WdfRegistryClose(hKey);
}
SerialDbgPrintEx(TRACE_LEVEL_VERBOSE, DBG_PNP, "<--SerialGetRegistryKeyValue %ws %d \n",
Name, *Value);
return retValue;
}
_Use_decl_annotations_
NTSTATUS OnDeviceAdd (WDFDRIVER /*WdfDriver*/, WDFDEVICE_INIT* DeviceInitPtr)
{
PAGED_CODE();
BCM_I2C_ASSERT_MAX_IRQL(PASSIVE_LEVEL);
NTSTATUS status;
//
// Configure DeviceInit structure
//
status = SpbDeviceInitConfig(DeviceInitPtr);
if (!NT_SUCCESS(status)) {
BSC_LOG_ERROR(
"SpbDeviceInitConfig() failed. (DeviceInitPtr = %p, status = %!STATUS!)",
DeviceInitPtr,
status);
return status;
}
//
// 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(DeviceInitPtr, &pnpCallbacks);
}
//
// Create the device.
//
WDFDEVICE wdfDevice;
BCM_I2C_DEVICE_CONTEXT* devicePtr;
{
WDF_OBJECT_ATTRIBUTES deviceAttributes;
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(
&deviceAttributes,
BCM_I2C_DEVICE_CONTEXT);
status = WdfDeviceCreate(
&DeviceInitPtr,
&deviceAttributes,
&wdfDevice);
if (!NT_SUCCESS(status)) {
BSC_LOG_ERROR(
"Failed to create WDFDEVICE. (DeviceInitPtr = %p, status = %!STATUS!)",
DeviceInitPtr,
status);
return status;
}
devicePtr = GetDeviceContext(wdfDevice);
NT_ASSERT(devicePtr);
devicePtr->WdfDevice = wdfDevice;
}
//
// Query registry for ClockStretchTimeout
//
{
WDFKEY wdfKey;
status = WdfDeviceOpenRegistryKey(
wdfDevice,
PLUGPLAY_REGKEY_DEVICE,
KEY_QUERY_VALUE,
WDF_NO_OBJECT_ATTRIBUTES,
&wdfKey);
if (!NT_SUCCESS(status)) {
BSC_LOG_ERROR(
"Failed to open device parameters registry key. (status=%!STATUS!)",
status);
return status;
}
auto closeRegKey = Finally([&] {
PAGED_CODE();
WdfRegistryClose(wdfKey);
});
DECLARE_CONST_UNICODE_STRING(
regValString,
REGSTR_VAL_CLOCK_STRETCH_TIMEOUT);
ULONG clockStretchTimeout;
status = WdfRegistryQueryULong(
wdfKey,
®ValString,
&clockStretchTimeout);
if (NT_SUCCESS(status)) {
if ((clockStretchTimeout & BCM_I2C_REG_CLKT_TOUT_MASK) !=
clockStretchTimeout) {
BSC_LOG_ERROR(
"Clock stretch timeout value from registry is out of range. (clockStretchTimeout=0x%x, BCM_I2C_REG_CLKT_TOUT_MASK=0x%x)",
clockStretchTimeout,
BCM_I2C_REG_CLKT_TOUT_MASK);
return STATUS_INVALID_PARAMETER;
}
BSC_LOG_INFORMATION(
"Using ClockStretchTimeout value from registry. (clockStretchTimeout=0x%x)",
clockStretchTimeout);
} else {
switch (status) {
case STATUS_OBJECT_NAME_NOT_FOUND:
clockStretchTimeout = BCM_I2C_REG_CLKT_TOUT_DEFAULT;
status = STATUS_SUCCESS;
break;
default:
BSC_LOG_ERROR(
"Failed to query clock stretch timeout from registry. (status=%!STATUS!, REGSTR_VAL_CLOCK_STRETCH_TIMEOUT=%S)",
status,
REGSTR_VAL_CLOCK_STRETCH_TIMEOUT);
return status;
}
}
devicePtr->ClockStretchTimeout = clockStretchTimeout;
}
//
// Ensure device is disable-able
//
{
WDF_DEVICE_STATE deviceState;
WDF_DEVICE_STATE_INIT(&deviceState);
deviceState.NotDisableable = WdfFalse;
WdfDeviceSetDeviceState(wdfDevice, &deviceState);
}
//
// Bind a SPB controller object to the device.
//
{
SPB_CONTROLLER_CONFIG spbConfig;
SPB_CONTROLLER_CONFIG_INIT(&spbConfig);
//
// Register for target connect callback. The driver
// does not need to respond to target disconnect.
//
spbConfig.EvtSpbTargetConnect = OnTargetConnect;
//
// Register for IO callbacks.
//
spbConfig.ControllerDispatchType = WdfIoQueueDispatchSequential;
spbConfig.EvtSpbIoRead = OnRead;
spbConfig.EvtSpbIoWrite = OnWrite;
spbConfig.EvtSpbIoSequence = OnSequence;
status = SpbDeviceInitialize(wdfDevice, &spbConfig);
if (!NT_SUCCESS(status)) {
BSC_LOG_ERROR(
"SpbDeviceInitialize failed. (wdfDevice = %p, status = %!STATUS!)",
wdfDevice,
status);
return status;
}
}
//
// Set target object attributes.
//
{
WDF_OBJECT_ATTRIBUTES targetAttributes;
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(
&targetAttributes,
BCM_I2C_TARGET_CONTEXT);
SpbControllerSetTargetAttributes(wdfDevice, &targetAttributes);
}
//
// Create an interrupt object
//
BCM_I2C_INTERRUPT_CONTEXT* interruptContextPtr;
{
WDF_OBJECT_ATTRIBUTES interruptObjectAttributes;
WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(
&interruptObjectAttributes,
BCM_I2C_INTERRUPT_CONTEXT);
WDF_INTERRUPT_CONFIG interruptConfig;
WDF_INTERRUPT_CONFIG_INIT(
&interruptConfig,
OnInterruptIsr,
OnInterruptDpc);
status = WdfInterruptCreate(
wdfDevice,
&interruptConfig,
&interruptObjectAttributes,
&devicePtr->WdfInterrupt);
if (!NT_SUCCESS(status)) {
BSC_LOG_ERROR(
"Failed to create interrupt object. (wdfDevice = %p, status = %!STATUS!)",
wdfDevice,
status);
return status;
}
interruptContextPtr = GetInterruptContext(devicePtr->WdfInterrupt);
interruptContextPtr->WdfInterrupt = devicePtr->WdfInterrupt;
}
devicePtr->InterruptContextPtr = interruptContextPtr;
NT_ASSERT(NT_SUCCESS(status));
return STATUS_SUCCESS;
}
NTSTATUS Registry_ReadAllDeviceKeys(__in PDEVICE_CONTEXT deviceContext)
{
WDFKEY hKey = NULL;
NTSTATUS status = STATUS_INVALID_DEVICE_STATE;
UNICODE_STRING valueName;
WDF_OBJECT_ATTRIBUTES collectionAttributes;
WDF_OBJECT_ATTRIBUTES stringAttributes;
GUID guidTest = {0};
PAGED_CODE();
if (!deviceContext->WdfDevice)
{
USBERR("deviceContext->WdfDevice is NULL.\n");
return status;
}
// The driver sets the PLUGPLAY_REGKEY_DEVICE flag to open the Device
// Parameters subkey under the device's hardware key, or it sets the
// PLUGPLAY_REGKEY_DRIVER flag to open the driver's software key. If the
// PLUGPLAY_REGKEY_CURRENT_HWPROFILE flag is also set,
// WdfDeviceOpenRegistryKey opens the copy of the hardware or software key
// that is in the current hardware profile.
status = WdfDeviceOpenRegistryKey(deviceContext->WdfDevice,
PLUGPLAY_REGKEY_DEVICE,
KEY_READ,
WDF_NO_OBJECT_ATTRIBUTES,
&hKey);
if (!NT_SUCCESS (status))
{
USBERR("WdfDeviceOpenRegistryKey failed.\n");
hKey = NULL;
return status;
}
//////////////////////////////////////////////////////////////////////////
// Read the device interface guids from the registry.
// These are set in the inf files [Device_AddReg] group.
//
WDF_OBJECT_ATTRIBUTES_INIT(&collectionAttributes);
collectionAttributes.ParentObject = deviceContext->WdfDevice;
status = WdfCollectionCreate(&collectionAttributes,
&deviceContext->DeviceRegSettings.DeviceInterfaceGUIDs);
if (!NT_SUCCESS(status))
{
USBERR("collection object could not be allocated. status=%Xh", status);
goto Done;
}
WDF_OBJECT_ATTRIBUTES_INIT(&stringAttributes);
stringAttributes.ParentObject = deviceContext->DeviceRegSettings.DeviceInterfaceGUIDs;
RtlInitUnicodeString(&valueName, L"DeviceInterfaceGUIDs");
status = WdfRegistryQueryMultiString(hKey, &valueName, &stringAttributes, deviceContext->DeviceRegSettings.DeviceInterfaceGUIDs);
if (NT_SUCCESS(status))
{
ULONG guidCount = WdfCollectionGetCount(deviceContext->DeviceRegSettings.DeviceInterfaceGUIDs);
ULONG guidIndex;
WDFSTRING wdfGuidString;
BOOLEAN removeGuidFromCollection;
USBMSG("Found %u DeviceInterfaceGUIDs strings.", guidCount);
for (guidIndex = 0; guidIndex < guidCount; guidIndex++)
{
removeGuidFromCollection = TRUE;
wdfGuidString = (WDFSTRING)WdfCollectionGetItem(deviceContext->DeviceRegSettings.DeviceInterfaceGUIDs, guidIndex);
status = GUIDFromWdfString(wdfGuidString, &guidTest);
if (!NT_SUCCESS(status))
{
USBERR("removing invalid DeviceInterfaceGUID string at index %u\n", guidIndex);
}
else
{
if (IsEqualGUID(&guidTest, &Libusb0DeviceGuid))
{
USBWRN("libusb0 device DeviceInterfaceGUID found. skippng..\n");
}
else if (IsEqualGUID(&guidTest, &Libusb0FilterGuid))
{
USBWRN("libusb0 filter DeviceInterfaceGUID found. skippng..\n");
}
else if (IsEqualGUID(&guidTest, &LibusbKDeviceGuid))
{
USBWRN("libusbK default device DeviceInterfaceGUID found. skippng..\n");
}
else
{
removeGuidFromCollection = FALSE;
}
}
if (removeGuidFromCollection)
{
WdfCollectionRemoveItem(deviceContext->DeviceRegSettings.DeviceInterfaceGUIDs, guidIndex);
guidIndex--;
guidCount--;
}
}
}
else
{
USBWRN("DeviceInterfaceGUIDs registry key does not exist.\n"
" Ensure the DeviceInterfaceGUIDs key has been properly set in the .inf and re-install the device.\n\n");
}
if (WdfCollectionGetCount(deviceContext->DeviceRegSettings.DeviceInterfaceGUIDs) == 0)
{
status = AddDefaultDeviceInterfaceGUID(deviceContext);
if (!NT_SUCCESS(status))
{
goto Done;
}
}
//////////////////////////////////////////////////////////////////////////
// Read the device power policy settings (if any).
// These are set in the inf files [Device_AddReg] group.
//
GetDeviceRegSettingKey(DeviceIdleEnabled, FALSE);
GetDeviceRegSettingKey(DeviceIdleIgnoreWakeEnable, FALSE);
GetDeviceRegSettingKey(UserSetDeviceIdleEnabled, FALSE);
GetDeviceRegSettingKey(DefaultIdleState, FALSE);
GetDeviceRegSettingKey(DefaultIdleTimeout, 5000);
GetDeviceRegSettingKey(SystemWakeEnabled, FALSE);
status = STATUS_SUCCESS;
Done:
if (hKey)
{
WdfRegistryClose(hKey);
hKey = NULL;
}
return status;
}
NTSTATUS
DeviceConfigure(
_In_ PDEVICE_CONTEXT DeviceContext
)
/*++
Routine Description:
This method is called after the device callback object has been initialized
and returned to the driver. It would setup the device's queues and their
corresponding callback objects.
Arguments:
FxDevice - the framework device object for which we're handling events.
Return Value:
status
--*/
{
NTSTATUS status;
WDFDEVICE device = DeviceContext->Device;
WDFKEY key;
LPGUID guid;
errno_t errorNo;
DECLARE_CONST_UNICODE_STRING(portName, REG_VALUENAME_PORTNAME);
DECLARE_UNICODE_STRING_SIZE (comPort, 10);
DECLARE_UNICODE_STRING_SIZE (symbolicLinkName, SYMBOLIC_LINK_NAME_LENGTH);
#ifdef _FAKE_MODEM
//
// Compiled as fake modem
//
guid = (LPGUID) &GUID_DEVINTERFACE_MODEM;
#else
//
// Compiled as virtual serial port
//
guid = (LPGUID) &GUID_DEVINTERFACE_COMPORT;
#endif
//
// Create device interface
//
status = WdfDeviceCreateDeviceInterface(
device,
guid,
NULL);
if (!NT_SUCCESS(status)) {
Trace(TRACE_LEVEL_ERROR,
"Error: Cannot create device interface");
goto Exit;
}
//
// Read the COM port number from the registry, which has been automatically
// created by "MsPorts!PortsClassInstaller" if INF file says "Class=Ports"
//
status = WdfDeviceOpenRegistryKey(
device,
PLUGPLAY_REGKEY_DEVICE,
KEY_QUERY_VALUE,
WDF_NO_OBJECT_ATTRIBUTES,
&key);
if (!NT_SUCCESS(status)) {
Trace(TRACE_LEVEL_ERROR,
"Error: Failed to retrieve device hardware key root");
goto Exit;
}
status = WdfRegistryQueryUnicodeString(
key,
&portName,
NULL,
&comPort);
if (!NT_SUCCESS(status)) {
Trace(TRACE_LEVEL_ERROR,
"Error: Failed to read PortName");
goto Exit;
}
//
// Manually create the symbolic link name. Length is the length in
// bytes not including the NULL terminator.
//
// 6054 and 26035 are code analysis warnings that comPort.Buffer might
// not be NULL terminated, while we know that they are.
//
#pragma warning(suppress: 6054 26035)
symbolicLinkName.Length = (USHORT)((wcslen(comPort.Buffer) * sizeof(wchar_t))
+ sizeof(SYMBOLIC_LINK_NAME_PREFIX) - sizeof(UNICODE_NULL));
if (symbolicLinkName.Length >= symbolicLinkName.MaximumLength) {
Trace(TRACE_LEVEL_ERROR, "Error: Buffer overflow when creating COM port name. Size"
" is %d, buffer length is %d", symbolicLinkName.Length, symbolicLinkName.MaximumLength);
status = STATUS_BUFFER_OVERFLOW;
goto Exit;
}
errorNo = wcscpy_s(symbolicLinkName.Buffer,
SYMBOLIC_LINK_NAME_LENGTH,
SYMBOLIC_LINK_NAME_PREFIX);
if (errorNo != 0) {
Trace(TRACE_LEVEL_ERROR,
"Failed to copy %ws to buffer with error %d",
SYMBOLIC_LINK_NAME_PREFIX, errorNo);
status = STATUS_INVALID_PARAMETER;
goto Exit;
}
errorNo = wcscat_s(symbolicLinkName.Buffer,
SYMBOLIC_LINK_NAME_LENGTH,
comPort.Buffer);
if (errorNo != 0) {
Trace(TRACE_LEVEL_ERROR,
"Failed to copy %ws to buffer with error %d",
comPort.Buffer, errorNo);
status = STATUS_INVALID_PARAMETER;
goto Exit;
}
//
// Create symbolic link
//
status = WdfDeviceCreateSymbolicLink(
device,
&symbolicLinkName);
if (!NT_SUCCESS(status)) {
Trace(TRACE_LEVEL_ERROR,
"Error: Cannot create symbolic link %ws", symbolicLinkName.Buffer);
goto Exit;
}
status = DeviceGetPdoName(DeviceContext);
if (!NT_SUCCESS(status)) {
goto Exit;
}
status = DeviceWriteLegacyHardwareKey(
DeviceContext->PdoName,
comPort.Buffer,
DeviceContext->Device);
if (NT_SUCCESS(status)) {
DeviceContext->CreatedLegacyHardwareKey = TRUE;
}
status = QueueCreate(DeviceContext);
if (!NT_SUCCESS(status)) {
goto Exit;
}
Exit:
return status;
}
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
FmCreateDosDevicesSymbolicLink(
WDFDEVICE Device,
PFM_DEVICE_DATA FmDeviceData
)
{
NTSTATUS status;
UNICODE_STRING comPort;
UNICODE_STRING pdoName;
UNICODE_STRING symbolicLink;
WDFKEY hKey = NULL;
DECLARE_CONST_UNICODE_STRING(valueName, L"PortName");
WDFSTRING string = NULL;
WDFMEMORY memory;
WDF_OBJECT_ATTRIBUTES memoryAttributes;
size_t bufferLength;
PAGED_CODE();
symbolicLink.Buffer = NULL;
//
// Open the device registry and read the "PortName" value written by the
// class installer.
//
status = WdfDeviceOpenRegistryKey(Device,
PLUGPLAY_REGKEY_DEVICE,
STANDARD_RIGHTS_ALL,
NULL, // PWDF_OBJECT_ATTRIBUTES
&hKey);
if (!NT_SUCCESS (status)) {
goto Error;
}
status = WdfStringCreate(
NULL,
WDF_NO_OBJECT_ATTRIBUTES ,
&string
);
if (!NT_SUCCESS(status)) {
goto Error;
}
//
// Retrieve the value of ValueName from registry
//
status = WdfRegistryQueryString(
hKey,
&valueName,
string
);
if (!NT_SUCCESS (status)) {
goto Error;
}
//
// Retrieve the UNICODE_STRING from string object
//
WdfStringGetUnicodeString(
string,
&comPort
);
WdfRegistryClose(hKey);
hKey = NULL;
symbolicLink.Length=0;
symbolicLink.MaximumLength = sizeof(OBJECT_DIRECTORY) + comPort.MaximumLength;
symbolicLink.Buffer = ExAllocatePoolWithTag(PagedPool,
symbolicLink.MaximumLength + sizeof(WCHAR),
'wkaF');
if (symbolicLink.Buffer == NULL) {
status = STATUS_INSUFFICIENT_RESOURCES;
goto Error;
}
RtlZeroMemory(symbolicLink.Buffer, symbolicLink.MaximumLength);
RtlAppendUnicodeToString(&symbolicLink, OBJECT_DIRECTORY);
RtlAppendUnicodeStringToString(&symbolicLink, &comPort);
//
// This DDI will get the underlying PDO name and create a symbolic to that
// because our FDO doesn't have a name.
//
status = WdfDeviceCreateSymbolicLink(Device,
&symbolicLink);
if (!NT_SUCCESS(status)) {
goto Error;
}
WDF_OBJECT_ATTRIBUTES_INIT(&memoryAttributes);
memoryAttributes.ParentObject = Device;
status = WdfDeviceAllocAndQueryProperty(Device,
DevicePropertyPhysicalDeviceObjectName,
PagedPool,
&memoryAttributes,
&memory);
if (!NT_SUCCESS(status)) {
//
// We expect a zero length buffer. Anything else is fatal.
//
goto Error;
}
pdoName.Buffer = WdfMemoryGetBuffer(memory, &bufferLength);
if (pdoName.Buffer == NULL) {
status = STATUS_INSUFFICIENT_RESOURCES;
goto Error;
}
pdoName.MaximumLength = (USHORT) bufferLength;
pdoName.Length = (USHORT) bufferLength - sizeof(UNICODE_NULL);
status = RtlWriteRegistryValue(RTL_REGISTRY_DEVICEMAP,
L"SERIALCOMM",
pdoName.Buffer,
REG_SZ,
comPort.Buffer,
comPort.Length);
if (!NT_SUCCESS(status)) {
goto Error;
}
FmDeviceData->Flags |= REG_VALUE_CREATED_FLAG;
//
// Store it so it can be deleted later.
//
FmDeviceData->PdoName = pdoName;
Error:
if (symbolicLink.Buffer != NULL) {
ExFreePool(symbolicLink.Buffer);
}
if (hKey != NULL) {
WdfRegistryClose(hKey);
}
if (string != NULL) {
WdfObjectDelete(string);
}
return status;
}
_Use_decl_annotations_
NTSTATUS
GetSimBattStateFromRegistry (
WDFDEVICE Device,
PSIMBATT_STATE State
)
/*
Routine Description:
Called to return simbatt state data from the registry if it exists.
Arguments:
Device - Supplies WDF device handle.
State - Supplies the pointer to return the simbatt state.
Return Value:
NTSTATUS
--*/
{
ULONG BufSize;
WDFKEY KeyHandle;
DECLARE_CONST_UNICODE_STRING(SimbattStateRegNameStr, SIMBATT_STATE_REG_NAME);
NTSTATUS Status;
ULONG ValueType;
PAGED_CODE();
Status = WdfDeviceOpenRegistryKey(
Device,
PLUGPLAY_REGKEY_DEVICE,
KEY_READ,
NULL,
&KeyHandle
);
if (!NT_SUCCESS (Status)) {
goto GetSimBattStateFromRegistryEnd;
}
Status = WdfRegistryQueryValue(
KeyHandle,
&SimbattStateRegNameStr,
sizeof(SIMBATT_STATE),
State,
&BufSize,
&ValueType
);
WdfRegistryClose(KeyHandle);
if (!NT_SUCCESS (Status)) {
goto GetSimBattStateFromRegistryEnd;
}
if (ValueType != REG_BINARY) {
Status = STATUS_INVALID_INFO_CLASS;
goto GetSimBattStateFromRegistryEnd;
}
if (BufSize != sizeof(SIMBATT_STATE)) {
//
// WdfRegistryQueryValue will fail if the buffer was too small.
// This check is validating if the data is smaller than the buffer.
//
Status = STATUS_INFO_LENGTH_MISMATCH;
goto GetSimBattStateFromRegistryEnd;
}
if (State->Version != SIMBATT_STATE_VERSION) {
Status = STATUS_REVISION_MISMATCH;
goto GetSimBattStateFromRegistryEnd;
}
GetSimBattStateFromRegistryEnd:
return Status;
}
