Hi,
I was struggling with debugging the “device cannot start error code 10” for the FX2LP board. And I found out that if I comment out the lines related to the pnpPowerCallbacks, the “device cannot start …” is gone. So what is wrong in the pnpPowerCallbacks functions that causes the error: (Codes are shown below)
pnpPowerCallbacks.EvtDevicePrepareHardware = OsrFxEvtDevicePrepareHardware;
pnpPowerCallbacks.EvtDeviceD0Entry = OsrFxEvtDeviceD0Entry;
pnpPowerCallbacks.EvtDeviceD0Exit = OsrFxEvtDeviceD0Exit;
pnpPowerCallbacks.EvtDeviceSelfManagedIoFlush = OsrFxEvtDeviceSelfManagedIoFlush;
==================================================
NTSTATUS
OsrFxEvtDevicePrepareHardware(
WDFDEVICE Device,
WDFCMRESLIST ResourceList,
WDFCMRESLIST ResourceListTranslated
)
/*++
Routine Description:
In this callback, the driver does whatever is necessary to make the
hardware ready to use. In the case of a USB device, this involves
reading and selecting descriptors.
Arguments:
Device - handle to a device
ResourceList - handle to a resource-list object that identifies the
raw hardware resources that the PnP manager assigned
to the device
ResourceListTranslated - handle to a resource-list object that
identifies the translated hardware resources
that the PnP manager assigned to the device
Return Value:
NT status value
–*/
{
NTSTATUS status;
PDEVICE_CONTEXT pDeviceContext;
WDF_USB_DEVICE_INFORMATION deviceInfo;
ULONG waitWakeEnable;
UNREFERENCED_PARAMETER(ResourceList);
UNREFERENCED_PARAMETER(ResourceListTranslated);
waitWakeEnable = FALSE;
PAGED_CODE();
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_PNP, “–> EvtDevicePrepareHardware\n”);
pDeviceContext = GetDeviceContext(Device);
//
// Create a USB device handle so that we can communicate with the
// underlying USB stack. The WDFUSBDEVICE handle is used to query,
// configure, and manage all aspects of the USB device.
// These aspects include device properties, bus properties,
// and I/O creation and synchronization. We only create device the first
// the PrepareHardware is called. If the device is restarted by pnp manager
// for resource rebalance, we will use the same device handle but then select
// the interfaces again because the USB stack could reconfigure the device on
// restart.
//
if (pDeviceContext->UsbDevice == NULL) {
WDF_USB_DEVICE_CREATE_CONFIG config;
WDF_USB_DEVICE_CREATE_CONFIG_INIT(&config,
USBD_CLIENT_CONTRACT_VERSION_602);
status = WdfUsbTargetDeviceCreateWithParameters(Device,
&config,
WDF_NO_OBJECT_ATTRIBUTES,
&pDeviceContext->UsbDevice);
if (!NT_SUCCESS(status)) {
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
“WdfUsbTargetDeviceCreateWithParameters failed with Status code %!STATUS!\n”, status);
return status;
}
//
// TODO: If you are fetching configuration descriptor from device for
// selecting a configuration or to parse other descriptors, call OsrFxValidateConfigurationDescriptor
// to do basic validation on the descriptors before you access them .
//
}
//
// Retrieve USBD version information, port driver capabilites and device
// capabilites such as speed, power, etc.
//
WDF_USB_DEVICE_INFORMATION_INIT(&deviceInfo);
status = WdfUsbTargetDeviceRetrieveInformation(
pDeviceContext->UsbDevice,
&deviceInfo);
if (NT_SUCCESS(status)) {
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_PNP, “IsDeviceHighSpeed: %s\n”,
(deviceInfo.Traits & WDF_USB_DEVICE_TRAIT_AT_HIGH_SPEED) ? “TRUE” : “FALSE”);
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_PNP,
“IsDeviceSelfPowered: %s\n”,
(deviceInfo.Traits & WDF_USB_DEVICE_TRAIT_SELF_POWERED) ? “TRUE” : “FALSE”);
waitWakeEnable = deviceInfo.Traits &
WDF_USB_DEVICE_TRAIT_REMOTE_WAKE_CAPABLE;
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_PNP,
“IsDeviceRemoteWakeable: %s\n”,
waitWakeEnable ? “TRUE” : “FALSE”);
//
// Save these for use later.
//
pDeviceContext->UsbDeviceTraits = deviceInfo.Traits;
}
else {
pDeviceContext->UsbDeviceTraits = 0;
}
status = SelectInterfaces(Device);
if (!NT_SUCCESS(status)) {
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
“SelectInterfaces failed 0x%x\n”, status);
return status;
}
//
// Enable wait-wake and idle timeout if the device supports it
//
if (waitWakeEnable) {
status = OsrFxSetPowerPolicy(Device);
if (!NT_SUCCESS (status)) {
TraceEvents(TRACE_LEVEL_ERROR, DBG_PNP,
“OsrFxSetPowerPolicy failed %!STATUS!\n”, status);
return status;
}
}
status = OsrFxConfigContReaderForInterruptEndPoint(pDeviceContext);
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_PNP, “<– EvtDevicePrepareHardware\n”);
return status;
}
===================================================
NTSTATUS
OsrFxEvtDeviceD0Entry(
WDFDEVICE Device,
WDF_POWER_DEVICE_STATE PreviousState
)
/*++
Routine Description:
EvtDeviceD0Entry event callback must perform any operations that are
necessary before the specified device is used. It will be called every
time the hardware needs to be (re-)initialized.
This function is not marked pageable because this function is in the
device power up path. When a function is marked pagable and the code
section is paged out, it will generate a page fault which could impact
the fast resume behavior because the client driver will have to wait
until the system drivers can service this page fault.
This function runs at PASSIVE_LEVEL, even though it is not paged. A
driver can optionally make this function pageable if DO_POWER_PAGABLE
is set. Even if DO_POWER_PAGABLE isn’t set, this function still runs
at PASSIVE_LEVEL. In this case, though, the function absolutely must
not do anything that will cause a page fault.
Arguments:
Device - Handle to a framework device object.
PreviousState - Device power state which the device was in most recently.
If the device is being newly started, this will be
PowerDeviceUnspecified.
Return Value:
NTSTATUS
–*/
{
PDEVICE_CONTEXT pDeviceContext;
NTSTATUS status;
BOOLEAN isTargetStarted;
pDeviceContext = GetDeviceContext(Device);
isTargetStarted = FALSE;
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_POWER,
“–>OsrFxEvtEvtDeviceD0Entry - coming from %s\n”,
DbgDevicePowerString(PreviousState));
//
// Since continuous reader is configured for this interrupt-pipe, we must explicitly start
// the I/O target to get the framework to post read requests.
//
status = WdfIoTargetStart(WdfUsbTargetPipeGetIoTarget(pDeviceContext->InterruptPipe));
if (!NT_SUCCESS(status)) {
TraceEvents(TRACE_LEVEL_ERROR, DBG_POWER, “Failed to start interrupt pipe %!STATUS!\n”, status);
goto End;
}
isTargetStarted = TRUE;
End:
if (!NT_SUCCESS(status)) {
//
// Failure in D0Entry will lead to device being removed. So let us stop the continuous
// reader in preparation for the ensuing remove.
//
if (isTargetStarted) {
WdfIoTargetStop(WdfUsbTargetPipeGetIoTarget(pDeviceContext->InterruptPipe), WdfIoTargetCancelSentIo);
}
}
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_POWER, “<–OsrFxEvtEvtDeviceD0Entry\n”);
return status;
}
NTSTATUS
OsrFxEvtDeviceD0Exit(
WDFDEVICE Device,
WDF_POWER_DEVICE_STATE TargetState
)
/*++
Routine Description:
This routine undoes anything done in EvtDeviceD0Entry. It is called
whenever the device leaves the D0 state, which happens when the device is
stopped, when it is removed, and when it is powered off.
The device is still in D0 when this callback is invoked, which means that
the driver can still touch hardware in this routine.
EvtDeviceD0Exit event callback must perform any operations that are
necessary before the specified device is moved out of the D0 state. If the
driver needs to save hardware state before the device is powered down, then
that should be done here.
This function runs at PASSIVE_LEVEL, though it is generally not paged. A
driver can optionally make this function pageable if DO_POWER_PAGABLE is set.
Even if DO_POWER_PAGABLE isn’t set, this function still runs at
PASSIVE_LEVEL. In this case, though, the function absolutely must not do
anything that will cause a page fault.
Arguments:
Device - Handle to a framework device object.
TargetState - Device power state which the device will be put in once this
callback is complete.
Return Value:
Success implies that the device can be used. Failure will result in the
device stack being torn down.
–*/
{
PDEVICE_CONTEXT pDeviceContext;
PAGED_CODE();
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_POWER,
“–>OsrFxEvtDeviceD0Exit - moving to %s\n”,
DbgDevicePowerString(TargetState));
pDeviceContext = GetDeviceContext(Device);
WdfIoTargetStop(WdfUsbTargetPipeGetIoTarget(pDeviceContext->InterruptPipe), WdfIoTargetCancelSentIo);
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_POWER, “<–OsrFxEvtDeviceD0Exit\n”);
return STATUS_SUCCESS;
}
==================================================
VOID
OsrFxEvtDeviceSelfManagedIoFlush(
In WDFDEVICE Device
)
/*++
Routine Description:
This routine handles flush activity for the device’s
self-managed I/O operations.
Arguments:
Device - Handle to a framework device object.
Return Value:
None
–*/
{
// Service the interrupt message queue to drain any outstanding
// requests
OsrUsbIoctlGetInterruptMessage(Device, STATUS_DEVICE_REMOVED);
}