//
// call driver
//
- DPRINT1("IoStack MajorFunction %x MinorFunction %x\n", IoStack->MajorFunction, IoStack->MinorFunction);
+ DPRINT("IoStack MajorFunction %x MinorFunction %x\n", IoStack->MajorFunction, IoStack->MinorFunction);
Status = CommonDeviceExtension->DriverExtension->MajorFunction[IoStack->MajorFunction](DeviceObject, Irp);
//
//
IoStack = IoGetCurrentIrpStackLocation(Irp);
- DPRINT1("ShareAccess %x\n", IoStack->Parameters.Create.ShareAccess);
- DPRINT1("Options %x\n", IoStack->Parameters.Create.Options);
- DPRINT1("DesiredAccess %x\n", IoStack->Parameters.Create.SecurityContext->DesiredAccess);
+ DPRINT("ShareAccess %x\n", IoStack->Parameters.Create.ShareAccess);
+ DPRINT("Options %x\n", IoStack->Parameters.Create.Options);
+ DPRINT("DesiredAccess %x\n", IoStack->Parameters.Create.SecurityContext->DesiredAccess);
//
// allocate context
//
// store result
//
- DPRINT1("NewBuffer %S\n", NewBuffer);
+ DPRINT("NewBuffer %S\n", NewBuffer);
Irp->IoStatus.Information = (ULONG_PTR)NewBuffer;
return STATUS_SUCCESS;
}
// now register the device interface
//
Status = IoRegisterDeviceInterface(PDODeviceExtension->Common.HidDeviceExtension.PhysicalDeviceObject, &GUID_DEVINTERFACE_HID, NULL, &PDODeviceExtension->DeviceInterface);
- DPRINT1("[HIDCLASS] IoRegisterDeviceInterfaceState Status %x\n", Status);
+ DPRINT("[HIDCLASS] IoRegisterDeviceInterfaceState Status %x\n", Status);
if (NT_SUCCESS(Status))
{
//
// enable device interface
//
Status = IoSetDeviceInterfaceState(&PDODeviceExtension->DeviceInterface, TRUE);
- DPRINT1("[HIDCLASS] IoSetDeviceInterFaceState %x\n", Status);
+ DPRINT("[HIDCLASS] IoSetDeviceInterFaceState %x\n", Status);
}
//
IN PUNICODE_STRING RegPath)
{
- DPRINT1("********* HID PARSE *********\n");
+ DPRINT("********* HID PARSE *********\n");
return STATUS_SUCCESS;
}
//
// informal debug print
//
- DPRINT1("HIDUSB Request: %x\n", IoStack->MajorFunction);
+ DPRINT("HIDUSB Request: %x\n", IoStack->MajorFunction);
//
// done
PHID_USB_RESET_CONTEXT ResetContext;
PHID_DEVICE_EXTENSION DeviceExtension;
- DPRINT1("[HIDUSB] ResetWorkerRoutine\n");
+ DPRINT("[HIDUSB] ResetWorkerRoutine\n");
//
// get context
// get port status
//
Status = HidUsb_GetPortStatus(ResetContext->DeviceObject, &PortStatus);
- DPRINT1("[HIDUSB] ResetWorkerRoutine GetPortStatus %x PortStatus %x\n", Status, PortStatus);
+ DPRINT("[HIDUSB] ResetWorkerRoutine GetPortStatus %x PortStatus %x\n", Status, PortStatus);
if (NT_SUCCESS(Status))
{
if (!(PortStatus & USB_PORT_STATUS_ENABLE))
// get current stack location
//
IoStack = IoGetCurrentIrpStackLocation(Irp);
- DPRINT1("[HIDUSB] GetReportDescriptor: Status %x ReportLength %lu OutputBufferLength %lu TransferredLength %lu\n", Status, HidDeviceExtension->HidDescriptor->DescriptorList[0].wReportLength, IoStack->Parameters.DeviceIoControl.OutputBufferLength, BufferLength);
+ DPRINT("[HIDUSB] GetReportDescriptor: Status %x ReportLength %lu OutputBufferLength %lu TransferredLength %lu\n", Status, HidDeviceExtension->HidDescriptor->DescriptorList[0].wReportLength, IoStack->Parameters.DeviceIoControl.OutputBufferLength, BufferLength);
//
// get length to copy
//
// store result
//
- DPRINT1("[HIDUSB] IOCTL_HID_GET_DEVICE_ATTRIBUTES\n");
+ DPRINT("[HIDUSB] IOCTL_HID_GET_DEVICE_ATTRIBUTES\n");
ASSERT(HidDeviceExtension->DeviceDescriptor);
Irp->IoStatus.Information = sizeof(HID_DESCRIPTOR);
Attributes = (PHID_DEVICE_ATTRIBUTES)Irp->UserBuffer;
// sanity check
//
ASSERT(HidDeviceExtension->HidDescriptor);
- DPRINT1("[HIDUSB] IOCTL_HID_GET_DEVICE_DESCRIPTOR DescriptorLength %lu OutputBufferLength %lu\n", HidDeviceExtension->HidDescriptor->bLength, IoStack->Parameters.DeviceIoControl.OutputBufferLength);
+ DPRINT("[HIDUSB] IOCTL_HID_GET_DEVICE_DESCRIPTOR DescriptorLength %lu OutputBufferLength %lu\n", HidDeviceExtension->HidDescriptor->bLength, IoStack->Parameters.DeviceIoControl.OutputBufferLength);
//
// store length
case IOCTL_HID_GET_REPORT_DESCRIPTOR:
{
Status = HidUsb_GetReportDescriptor(DeviceObject, Irp);
- DPRINT1("[HIDUSB] IOCTL_HID_GET_REPORT_DESCRIPTOR Status %x\n", Status);
+ DPRINT("[HIDUSB] IOCTL_HID_GET_REPORT_DESCRIPTOR Status %x\n", Status);
Irp->IoStatus.Status = Status;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return Status;
Status = IoStatus.Status;
}
- DPRINT1("[HIDUSB] DispatchUrb %x\n", Status);
+ DPRINT("[HIDUSB] DispatchUrb %x\n", Status);
//
//
// print status
//
- DPRINT1("Status %x\n", Status);
+ DPRINT("Status %x\n", Status);
return Status;
}
//
// print status
//
- DPRINT1("Status %x Protocol %x\n", Status, Protocol[0] & 0xFF);
+ DPRINT("Status %x Protocol %x\n", Status, Protocol[0] & 0xFF);
//
// assert when boot protocol is still active
//
// done
//
- DPRINT1("[HIDUSB] SelectConfiguration %x\n", Status);
+ DPRINT("[HIDUSB] SelectConfiguration %x\n", Status);
return Status;
}
// get current stack location
//
IoStack = IoGetCurrentIrpStackLocation(Irp);
- DPRINT1("[HIDUSB] Pnp %x\n", IoStack->MinorFunction);
+ DPRINT("[HIDUSB] Pnp %x\n", IoStack->MinorFunction);
//
// handle requests based on request type
// complete request
//
Irp->IoStatus.Status = Status;
- DPRINT1("[HIDUSB] IRP_MN_START_DEVICE Status %x\n", Status);
+ DPRINT("[HIDUSB] IRP_MN_START_DEVICE Status %x\n", Status);
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return Status;
}
//
// informal debug
//
- DPRINT1("********* HIDUSB *********\n");
- DPRINT1("HIDUSB Registration Status %x\n", Status);
+ DPRINT("********* HIDUSB *********\n");
+ DPRINT("HIDUSB Registration Status %x\n", Status);
return Status;
}
for(Index = 0; Index < Length; Index++)
{
- DPRINT1("[KBDHID] ScanCode Index %lu ScanCode %x\n", Index, NewScanCodes[Index] & 0xFF);
+ DPRINT("[KBDHID] ScanCode Index %lu ScanCode %x\n", Index, NewScanCodes[Index] & 0xFF);
/* init input data */
RtlZeroMemory(&InputData, sizeof(KEYBOARD_INPUT_DATA));
// print out raw report
//
ASSERT(DeviceExtension->ReportLength >= 9);
- DPRINT1("[KBDHID] ReadCompletion %02x %02x %02x %02x %02x %02x %02x %02x %02x\n", DeviceExtension->Report[0], DeviceExtension->Report[1], DeviceExtension->Report[2],
+ DPRINT("[KBDHID] ReadCompletion %02x %02x %02x %02x %02x %02x %02x %02x %02x\n", DeviceExtension->Report[0], DeviceExtension->Report[1], DeviceExtension->Report[2],
DeviceExtension->Report[3], DeviceExtension->Report[4], DeviceExtension->Report[5],
DeviceExtension->Report[6], DeviceExtension->Report[7], DeviceExtension->Report[8]);
KEVENT Event;
PKBDHID_DEVICE_EXTENSION DeviceExtension;
- DPRINT1("[KBDHID]: IRP_MJ_CREATE\n");
+ DPRINT("[KBDHID]: IRP_MJ_CREATE\n");
/* get device extension */
DeviceExtension = (PKBDHID_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
/* initiating read */
Status = KbdHid_InitiateRead(DeviceExtension);
- DPRINT1("[KBDHID] KbdHid_InitiateRead: status %x\n", Status);
+ DPRINT("[KBDHID] KbdHid_InitiateRead: status %x\n", Status);
if (Status == STATUS_PENDING)
{
/* report irp is pending */
/* get current stack location */
IoStack = IoGetCurrentIrpStackLocation(Irp);
- DPRINT1("[KBDHID] InternalDeviceControl %x\n", IoStack->Parameters.DeviceIoControl.IoControlCode);
+ DPRINT("[KBDHID] InternalDeviceControl %x\n", IoStack->Parameters.DeviceIoControl.IoControlCode);
/* get device extension */
DeviceExtension = (PKBDHID_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
return Status;
}
- DPRINT1("[KBDHID] Usage %x UsagePage %x InputReportLength %lu\n", Capabilities.Usage, Capabilities.UsagePage, Capabilities.InputReportByteLength);
+ DPRINT("[KBDHID] Usage %x UsagePage %x InputReportLength %lu\n", Capabilities.Usage, Capabilities.UsagePage, Capabilities.InputReportByteLength);
/* init input report*/
DeviceExtension->ReportLength = Capabilities.InputReportByteLength;
/* get max number of buttons */
Buttons = HidP_MaxUsageListLength(HidP_Input, HID_USAGE_PAGE_KEYBOARD, PreparsedData);
- DPRINT1("[KBDHID] Buttons %lu\n", Buttons);
+ DPRINT("[KBDHID] Buttons %lu\n", Buttons);
ASSERT(Buttons > 0);
/* now allocate an array for those buttons */
/* get current irp stack */
IoStack = IoGetCurrentIrpStackLocation(Irp);
- DPRINT1("[KBDHID] IRP_MJ_PNP Request: %x\n", IoStack->MinorFunction);
+ DPRINT("[KBDHID] IRP_MJ_PNP Request: %x\n", IoStack->MinorFunction);
if (IoStack->MinorFunction == IRP_MN_STOP_DEVICE ||
IoStack->MinorFunction == IRP_MN_CANCEL_REMOVE_DEVICE ||
/* lets start the device */
Status = KbdHid_StartDevice(DeviceObject);
- DPRINT1("KbdHid_StartDevice %x\n", Status);
+ DPRINT("KbdHid_StartDevice %x\n", Status);
/* complete request */
Irp->IoStatus.Status = Status;
KEVENT Event;
PMOUHID_DEVICE_EXTENSION DeviceExtension;
- DPRINT1("MOUHID: IRP_MJ_CREATE\n");
+ DPRINT("MOUHID: IRP_MJ_CREATE\n");
/* get device extension */
DeviceExtension = (PMOUHID_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
/* initiating read */
Status = MouHid_InitiateRead(DeviceExtension);
- DPRINT1("[MOUHID] MouHid_InitiateRead: status %x\n", Status);
+ DPRINT("[MOUHID] MouHid_InitiateRead: status %x\n", Status);
if (Status == STATUS_PENDING)
{
/* report irp is pending */
/* get current stack location */
IoStack = IoGetCurrentIrpStackLocation(Irp);
- DPRINT1("[MOUHID] InternalDeviceControl %x\n", IoStack->Parameters.DeviceIoControl.IoControlCode);
+ DPRINT("[MOUHID] InternalDeviceControl %x\n", IoStack->Parameters.DeviceIoControl.IoControlCode);
/* get device extension */
DeviceExtension = (PMOUHID_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
/* queue length */
Attributes->InputDataQueueLength = 2;
- DPRINT1("[MOUHID] MouseIdentifier %x\n", Attributes->MouseIdentifier);
- DPRINT1("[MOUHID] NumberOfButtons %x\n", Attributes->NumberOfButtons);
- DPRINT1("[MOUHID] SampleRate %x\n", Attributes->SampleRate);
- DPRINT1("[MOUHID] InputDataQueueLength %x\n", Attributes->InputDataQueueLength);
+ DPRINT("[MOUHID] MouseIdentifier %x\n", Attributes->MouseIdentifier);
+ DPRINT("[MOUHID] NumberOfButtons %x\n", Attributes->NumberOfButtons);
+ DPRINT("[MOUHID] SampleRate %x\n", Attributes->SampleRate);
+ DPRINT("[MOUHID] InputDataQueueLength %x\n", Attributes->InputDataQueueLength);
/* complete request */
Irp->IoStatus.Information = sizeof(MOUSE_ATTRIBUTES);
return Status;
}
- DPRINT1("[MOUHID] Usage %x UsagePage %x InputReportLength %lu\n", Capabilities.Usage, Capabilities.UsagePage, Capabilities.InputReportByteLength);
+ DPRINT("[MOUHID] Usage %x UsagePage %x InputReportLength %lu\n", Capabilities.Usage, Capabilities.UsagePage, Capabilities.InputReportByteLength);
/* verify capabilities */
if ((Capabilities.Usage != HID_USAGE_GENERIC_POINTER && Capabilities.Usage != HID_USAGE_GENERIC_MOUSE) || Capabilities.UsagePage != HID_USAGE_PAGE_GENERIC)
/* get max number of buttons */
Buttons = HidP_MaxUsageListLength(HidP_Input, HID_USAGE_PAGE_BUTTON, PreparsedData);
- DPRINT1("[MOUHID] Buttons %lu\n", Buttons);
+ DPRINT("[MOUHID] Buttons %lu\n", Buttons);
ASSERT(Buttons > 0);
/* now allocate an array for those buttons */
/* mouse has wheel support */
DeviceExtension->MouseIdentifier = WHEELMOUSE_HID_HARDWARE;
DeviceExtension->WheelUsagePage = ValueCaps.UsagePage;
- DPRINT1("[MOUHID] mouse wheel support detected\n", Status);
+ DPRINT("[MOUHID] mouse wheel support detected\n", Status);
}
else
{
/* wheel support */
DeviceExtension->MouseIdentifier = WHEELMOUSE_HID_HARDWARE;
DeviceExtension->WheelUsagePage = ValueCaps.UsagePage;
- DPRINT1("[MOUHID] mouse wheel support detected with z-axis\n", Status);
+ DPRINT("[MOUHID] mouse wheel support detected with z-axis\n", Status);
}
}
/* get current irp stack */
IoStack = IoGetCurrentIrpStackLocation(Irp);
- DPRINT1("[MOUHID] IRP_MJ_PNP Request: %x\n", IoStack->MinorFunction);
+ DPRINT("[MOUHID] IRP_MJ_PNP Request: %x\n", IoStack->MinorFunction);
if (IoStack->MinorFunction == IRP_MN_STOP_DEVICE ||
IoStack->MinorFunction == IRP_MN_CANCEL_REMOVE_DEVICE ||
/* lets start the device */
Status = MouHid_StartDevice(DeviceObject);
- DPRINT1("MouHid_StartDevice %x\n", Status);
+ DPRINT("MouHid_StartDevice %x\n", Status);
/* complete request */
Irp->IoStatus.Status = Status;
//
// done
//
- DPRINT1("[USBCCGP] FDO initialized successfully\n");
+ DPRINT("[USBCCGP] FDO initialized successfully\n");
return Status;
}
// get stack location
IoStack = IoGetCurrentIrpStackLocation(Irp);
- DPRINT1("[USBCCGP] PnP Minor %x\n", IoStack->MinorFunction);
+ DPRINT("[USBCCGP] PnP Minor %x\n", IoStack->MinorFunction);
switch(IoStack->MinorFunction)
{
case IRP_MN_REMOVE_DEVICE:
// get stack location
IoStack = IoGetCurrentIrpStackLocation(Irp);
- DPRINT1("FDO_HandleResetCyclePort IOCTL %x\n", IoStack->Parameters.DeviceIoControl.IoControlCode);
+ DPRINT("FDO_HandleResetCyclePort IOCTL %x\n", IoStack->Parameters.DeviceIoControl.IoControlCode);
if (IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_INTERNAL_USB_RESET_PORT)
{
// handle reset / cycle ports
//
Status = FDO_HandleResetCyclePort(DeviceObject, Irp);
- DPRINT1("FDO_HandleResetCyclePort Status %x\n", Status);
+ DPRINT("FDO_HandleResetCyclePort Status %x\n", Status);
if (Status != STATUS_PENDING)
{
//
DeviceObject,
FDODeviceExtension->PhysicalDeviceObject);
- DPRINT1("USBCCGP_CustomEnumWithInterface Status %x\n", Status);
+ DPRINT("USBCCGP_CustomEnumWithInterface Status %x\n", Status);
if (!NT_SUCCESS(Status))
{
//
return Status;
}
- DPRINT1("FunctionDescriptorBufferLength %lu\n", FunctionDescriptorBufferLength);
- DPRINT1("FunctionDescriptorBuffer %p\n", FunctionDescriptorBuffer);
+ DPRINT("FunctionDescriptorBufferLength %lu\n", FunctionDescriptorBufferLength);
+ DPRINT("FunctionDescriptorBuffer %p\n", FunctionDescriptorBuffer);
//
// assume length % function buffer size
//
// this is an composite audio device
//
- DPRINT1("[USBCCGP] Audio Composite Device detected\n");
+ DPRINT("[USBCCGP] Audio Composite Device detected\n");
//
// audio interfaces are all grouped into one single function
PDEVICE_RELATIONS DeviceRelations;
PIO_STACK_LOCATION IoStack;
- DPRINT1("USBCCGP_PdoHandleDeviceRelations\n");
+ DPRINT("USBCCGP_PdoHandleDeviceRelations\n");
//
// get current irp stack location
{
StringLength = swprintf(String, L"%s&MI_%02x", DeviceId) + 1;
Length = wcslen(DeviceId) + 1;
- DPRINT1("String %p\n", String);
+ DPRINT("String %p\n", String);
//
// next string
//
ASSERT(Irp->IoStatus.Information);
swprintf(Buffer, L"%s&MI_%02x", (LPWSTR)Irp->IoStatus.Information, PDODeviceExtension->FunctionDescriptor->FunctionNumber);
- DPRINT1("BusQueryDeviceID %S\n", Buffer);
+ DPRINT("BusQueryDeviceID %S\n", Buffer);
ExFreePool((PVOID)Irp->IoStatus.Information);
Irp->IoStatus .Information = (ULONG_PTR)Buffer;
//
// no-op for PDO
//
- DPRINT1("[USBCCGP] PDO IRP_MN_START\n");
+ DPRINT("[USBCCGP] PDO IRP_MN_START\n");
Status = STATUS_SUCCESS;
break;
}
//
IoStack = IoGetCurrentIrpStackLocation(Irp);
- DPRINT1("USBCCGP_BuildConfigurationDescriptor\n");
+ DPRINT("USBCCGP_BuildConfigurationDescriptor\n");
//
// get device extension
InterfaceInformation = &Urb->UrbSelectConfiguration.Interface;
Index = 0;
Entry = NULL;
- DPRINT1("Count %x\n", InterfaceInformationCount);
+ DPRINT("Count %x\n", InterfaceInformationCount);
do
{
DPRINT1("[USBCCGP] SelectConfiguration Function %x InterfaceNumber %x Alternative %x\n", PDODeviceExtension->FunctionDescriptor->FunctionNumber, InterfaceInformation->InterfaceNumber, InterfaceInformation->AlternateSetting);
{
// initialize driver object
- DPRINT1("[USBCCGP] DriverEntry\n");
+ DPRINT("[USBCCGP] DriverEntry\n");
DriverObject->DriverExtension->AddDevice = USBCCGP_AddDevice;
DriverObject->MajorFunction[IRP_MJ_CREATE] = USBCCGP_Dispatch;
DriverObject->MajorFunction[IRP_MJ_CLOSE] = USBCCGP_Dispatch;
if ((ULONG_PTR)CommonDescriptor >= ((ULONG_PTR)DescriptorBuffer + TotalLength))
{
/* end reached */
- DPRINT1("End reached %p\n", CommonDescriptor);
+ DPRINT("End reached %p\n", CommonDescriptor);
return NULL;
}
NTSTATUS Status;
ULONG BytesRead;
- DPRINT1("CUSBHardwareDevice::Initialize\n");
+ DPRINT("CUSBHardwareDevice::Initialize\n");
//
// Create DMAMemoryManager for use with QueueHeads and Transfer Descriptors.
UCHAR Value;
UCHAR PortCount;
- DPRINT1("CUSBHardwareDevice::PnpStart\n");
+ DPRINT("CUSBHardwareDevice::PnpStart\n");
for(Index = 0; Index < TranslatedResources->List[0].PartialResourceList.Count; Index++)
{
//
if ((UsbSts & (EHCI_STS_PSS | EHCI_STS_ASS)))
{
DPRINT1("Failed to stop running schedules %x\n", UsbSts);
- ASSERT(FALSE);
+ //ASSERT(FALSE);
}
if (UsbSts & EHCI_STS_HALT)
{
DPRINT1("Could not start execution on the controller\n");
- ASSERT(FALSE);
+ //ASSERT(FALSE);
return STATUS_UNSUCCESSFUL;
}
if (!(UsbSts & EHCI_STS_PSS))
{
DPRINT1("Could not enable periodic scheduling\n");
- ASSERT(FALSE);
+ //ASSERT(FALSE);
return STATUS_UNSUCCESSFUL;
}
if (!(UsbSts & EHCI_STS_ASS))
{
DPRINT1("Failed to enable async schedule UsbSts %x\n", UsbSts);
- ASSERT(FALSE);
+ //ASSERT(FALSE);
return STATUS_UNSUCCESSFUL;
}
//
// this must be enabled now
//
- ASSERT(PortStatus & EHCI_PRT_ENABLED);
+ if (PortStatus & EHCI_PRT_ENABLED)
+ {
+ DPRINT1("Port is not enabled after reset\n");
+ //ASSERT(FALSE);
+ }
return STATUS_SUCCESS;
}
CStatus = This->EHCI_READ_REGISTER_ULONG(EHCI_USBSTS);
CStatus &= (EHCI_ERROR_INT | EHCI_STS_INT | EHCI_STS_IAA | EHCI_STS_PCD | EHCI_STS_FLR);
- DPRINT1("CStatus %x\n", CStatus);
+ DPRINT("CStatus %x\n", CStatus);
//
// Check that it belongs to EHCI
// controller reported error
//
DPRINT1("CStatus %x\n", CStatus);
- ASSERT(FALSE);
+ //ASSERT(FALSE);
}
//
{
case IRP_MN_START_DEVICE:
{
- DPRINT1("CHCDController::HandlePnp IRP_MN_START FDO\n");
+ DPRINT("CHCDController::HandlePnp IRP_MN_START FDO\n");
//
// first start lower device object
Status = SetSymbolicLink(TRUE);
}
- DPRINT1("CHCDController::HandlePnp IRP_MN_START FDO: Status %x\n", Status);
+ DPRINT("CHCDController::HandlePnp IRP_MN_START FDO: Status %x\n", Status);
break;
}
case IRP_MN_QUERY_DEVICE_RELATIONS:
{
- DPRINT1("CHCDController::HandlePnp IRP_MN_QUERY_DEVICE_RELATIONS Type %lx\n", IoStack->Parameters.QueryDeviceRelations.Type);
+ DPRINT("CHCDController::HandlePnp IRP_MN_QUERY_DEVICE_RELATIONS Type %lx\n", IoStack->Parameters.QueryDeviceRelations.Type);
if (m_HubController == NULL)
{
}
case IRP_MN_STOP_DEVICE:
{
- DPRINT1("CHCDController::HandlePnp IRP_MN_STOP_DEVICE\n");
+ DPRINT("CHCDController::HandlePnp IRP_MN_STOP_DEVICE\n");
if (m_Hardware)
{
}
case IRP_MN_REMOVE_DEVICE:
{
- DPRINT1("CHCDController::HandlePnp IRP_MN_REMOVE_DEVICE FDO\n");
+ DPRINT("CHCDController::HandlePnp IRP_MN_REMOVE_DEVICE FDO\n");
//
// delete the symbolic link
//
m_FDODeviceNumber = UsbDeviceNumber;
- DPRINT1("CreateFDO: DeviceName %wZ\n", &DeviceName);
+ DPRINT("CreateFDO: DeviceName %wZ\n", &DeviceName);
/* done */
return Status;
{
case IRP_MN_START_DEVICE:
{
- DPRINT1("CHubController::HandlePnp IRP_MN_START_DEVICE\n");
+ DPRINT("CHubController::HandlePnp IRP_MN_START_DEVICE\n");
//
// register device interface
//
}
case IRP_MN_QUERY_ID:
{
- DPRINT1("CHubController::HandlePnp IRP_MN_QUERY_ID Type %x\n", IoStack->Parameters.QueryId.IdType);
+ DPRINT("CHubController::HandlePnp IRP_MN_QUERY_ID Type %x\n", IoStack->Parameters.QueryId.IdType);
if (IoStack->Parameters.QueryId.IdType == BusQueryDeviceID)
{
swprintf(Buffer, L"USB\\ROOT_HUB");
}
- DPRINT1("Name %S\n", Buffer);
+ DPRINT("Name %S\n", Buffer);
//
// calculate length
}
case IRP_MN_QUERY_CAPABILITIES:
{
- DPRINT1("CHubController::HandlePnp IRP_MN_QUERY_CAPABILITIES\n");
+ DPRINT("CHubController::HandlePnp IRP_MN_QUERY_CAPABILITIES\n");
DeviceCapabilities = (PDEVICE_CAPABILITIES)IoStack->Parameters.DeviceCapabilities.Capabilities;
}
case IRP_MN_QUERY_INTERFACE:
{
- DPRINT1("CHubController::HandlePnp IRP_MN_QUERY_INTERFACE\n");
+ DPRINT("CHubController::HandlePnp IRP_MN_QUERY_INTERFACE\n");
//
// handle device interface requests
}
case IRP_MN_REMOVE_DEVICE:
{
- DPRINT1("CHubController::HandlePnp IRP_MN_REMOVE_DEVICE\n");
+ DPRINT("CHubController::HandlePnp IRP_MN_REMOVE_DEVICE\n");
//
// deactivate device interface for BUS PDO
}
case IRP_MN_QUERY_DEVICE_RELATIONS:
{
- DPRINT1("CHubController::HandlePnp IRP_MN_QUERY_DEVICE_RELATIONS Type %x\n", IoStack->Parameters.QueryDeviceRelations.Type);
+ DPRINT("CHubController::HandlePnp IRP_MN_QUERY_DEVICE_RELATIONS Type %x\n", IoStack->Parameters.QueryDeviceRelations.Type);
if (IoStack->Parameters.QueryDeviceRelations.Type == TargetDeviceRelation)
{
}
case IRP_MN_QUERY_BUS_INFORMATION:
{
- DPRINT1("CHubController::HandlePnp IRP_MN_QUERY_BUS_INFORMATION\n");
+ DPRINT("CHubController::HandlePnp IRP_MN_QUERY_BUS_INFORMATION\n");
//
// allocate buffer for bus information
}
case IRP_MN_STOP_DEVICE:
{
- DPRINT1("CHubController::HandlePnp IRP_MN_STOP_DEVICE\n");
+ DPRINT("CHubController::HandlePnp IRP_MN_STOP_DEVICE\n");
//
// stop device
//
//
// Else pend the IRP, to be completed when a device connects or disconnects.
//
- DPRINT1("Pending SCE Irp\n");;
+ DPRINT("Pending SCE Irp\n");
m_PendingSCEIrp = Irp;
IoMarkIrpPending(Irp);
return STATUS_PENDING;
}
DPRINT1("CUSBDevice::GetType Unknown bcdUSB Type %x\n", m_DeviceDescriptor.bcdUSB);
- PC_ASSERT(FALSE);
+ //PC_ASSERT(FALSE);
return Usb11Device;
}
//
DPRINT1("Failed to allocate sync frame list\n");
ExFreePool(m_SyncFrameListQueueHeads);
- ASSERT(FALSE);
+ //ASSERT(FALSE);
return STATUS_INSUFFICIENT_RESOURCES;
}
return;
}
DPRINT1("Unable to create a new QueueHead\n");
- PC_ASSERT(FALSE);
+ //ASSERT(FALSE);
//
// Else there was a problem
UrbStatus = USBD_STATUS_INSUFFICIENT_RESOURCES;
}
- if (UrbStatus != USBD_STATUS_SUCCESS) PC_ASSERT(FALSE);
+ if (UrbStatus != USBD_STATUS_SUCCESS)
+ {
+ DPRINT1("URB failed with status 0x%x\n", UrbStatus);
+ //PC_ASSERT(FALSE);
+ }
//
// notify request that a transfer has completed
}
default:
DPRINT1("URB Function: not supported %x\n", Urb->UrbHeader.Function);
- PC_ASSERT(FALSE);
+ //ASSERT(FALSE);
}
//
//
//DumpQueueHead(QueueHead);
- DPRINT1("BuildControlTransferQueueHead done\n");
+ DPRINT("BuildControlTransferQueueHead done\n");
//
// done
//
//
DPRINT1("Found halted queue head %p\n", QueueHead);
DumpQueueHead(QueueHead);
- ASSERT(FALSE);
+ //ASSERT(FALSE);
return TRUE;
}
LONG PortId;
BOOLEAN SignalResetComplete = FALSE;
- DPRINT1("Entered DeviceStatusChangeThread, Context %x\n", Context);
+ DPRINT("Entered DeviceStatusChangeThread, Context %x\n", Context);
WorkItemData = (PWORK_ITEM_DATA)Context;
DeviceObject = (PDEVICE_OBJECT)WorkItemData->Context;
//
// Send another SCE Request
//
- DPRINT1("Sending another SCE!\n");
+ DPRINT("Sending another SCE!\n");
QueryStatusChangeEndpoint(DeviceObject);
//
//
// NOTE: USBPORT frees this IRP
//
- DPRINT1("Received Irp %x, HubDeviceExtension->PendingSCEIrp %x\n", Irp, HubDeviceExtension->PendingSCEIrp);
+ DPRINT("Received Irp %x, HubDeviceExtension->PendingSCEIrp %x\n", Irp, HubDeviceExtension->PendingSCEIrp);
//IoFreeIrp(Irp);
//
}
WorkItemData->Context = RealDeviceObject;
- DPRINT1("Queuing work item\n");
+ DPRINT("Queuing work item\n");
//
// Queue the work item to handle initializing the device
HubDeviceExtension->PendingSCEIrp = IoAllocateIrp(RootHubDeviceObject->StackSize,
FALSE);
*/
- DPRINT1("Allocated IRP %x\n", HubDeviceExtension->PendingSCEIrp);
+ DPRINT("Allocated IRP %x\n", HubDeviceExtension->PendingSCEIrp);
if (!HubDeviceExtension->PendingSCEIrp)
{
//
// Send to RootHub
//
- DPRINT1("DeviceObject is %x\n", DeviceObject);
- DPRINT1("Iocalldriver %x with irp %x\n", RootHubDeviceObject, HubDeviceExtension->PendingSCEIrp);
+ DPRINT("DeviceObject is %x\n", DeviceObject);
+ DPRINT("Iocalldriver %x with irp %x\n", RootHubDeviceObject, HubDeviceExtension->PendingSCEIrp);
Status = IoCallDriver(RootHubDeviceObject, HubDeviceExtension->PendingSCEIrp);
return STATUS_PENDING;
ExFreePool(StringDesc);
return STATUS_INSUFFICIENT_RESOURCES;
}
- DPRINT1("Buffer %p\n", Buffer);
+ DPRINT("Buffer %p\n", Buffer);
RtlZeroMemory(Buffer, SizeNeeded);
- DPRINT1("Buffer %p\n", Buffer);
- DPRINT1("SizeNeeded %lu\n", SizeNeeded);
- DPRINT1("Offset %lu\n", FIELD_OFFSET(USB_STRING_DESCRIPTOR, bLength));
- DPRINT1("Length %lu\n", SizeNeeded - FIELD_OFFSET(USB_STRING_DESCRIPTOR, bLength));
+ DPRINT("SizeNeeded %lu\n", SizeNeeded);
+ DPRINT("Offset %lu\n", FIELD_OFFSET(USB_STRING_DESCRIPTOR, bLength));
+ DPRINT("Length %lu\n", SizeNeeded - FIELD_OFFSET(USB_STRING_DESCRIPTOR, bLength));
//
// Copy the string to destination
UsbChildExtension->usCompatibleIds.Buffer = DeviceString;
UsbChildExtension->usCompatibleIds.Length = Index * sizeof(WCHAR);
UsbChildExtension->usCompatibleIds.MaximumLength = (Index + 1) * sizeof(WCHAR);
- DPRINT1("usCompatibleIds %wZ\n", &UsbChildExtension->usCompatibleIds);
+ DPRINT("usCompatibleIds %wZ\n", &UsbChildExtension->usCompatibleIds);
//
// Construct DeviceId string
UsbChildExtension->usDeviceId.Buffer = DeviceString;
UsbChildExtension->usDeviceId.Length = (Index-1) * sizeof(WCHAR);
UsbChildExtension->usDeviceId.MaximumLength = Index * sizeof(WCHAR);
- DPRINT1("usDeviceId %wZ\n", &UsbChildExtension->usDeviceId);
+ DPRINT("usDeviceId %wZ\n", &UsbChildExtension->usDeviceId);
//
// Construct HardwareIds
UsbChildExtension->usHardwareIds.Buffer = DeviceString;
UsbChildExtension->usHardwareIds.Length = (Index + 1) * sizeof(WCHAR);
UsbChildExtension->usHardwareIds.MaximumLength = (Index + 1) * sizeof(WCHAR);
- DPRINT1("usHardWareIds %wZ\n", &UsbChildExtension->usHardwareIds);
+ DPRINT("usHardWareIds %wZ\n", &UsbChildExtension->usHardwareIds);
//
// FIXME: Handle Lang ids
else
{
UsbChildExtension->usTextDescription.MaximumLength = UsbChildExtension->usTextDescription.Length;
- DPRINT1("Usb TextDescription %wZ\n", &UsbChildExtension->usTextDescription);
+ DPRINT("Usb TextDescription %wZ\n", &UsbChildExtension->usTextDescription);
}
}
}
UsbChildExtension->usInstanceId.MaximumLength = UsbChildExtension->usInstanceId.Length;
- DPRINT1("Usb InstanceId %wZ\n", &UsbChildExtension->usInstanceId);
+ DPRINT("Usb InstanceId %wZ\n", &UsbChildExtension->usInstanceId);
}
else
{
RtlCopyMemory(UsbChildExtension->usInstanceId.Buffer, Buffer, Index * sizeof(WCHAR));
UsbChildExtension->usInstanceId.Length = UsbChildExtension->usInstanceId.MaximumLength = Index * sizeof(WCHAR);
- DPRINT1("usDeviceId %wZ\n", &UsbChildExtension->usInstanceId);
+ DPRINT("usDeviceId %wZ\n", &UsbChildExtension->usInstanceId);
}
return Status;
PDEVICE_OBJECT ChildDeviceObject = NULL;
ULONG Index = 0;
- DPRINT1("Removing device on port %d (Child index: %d)\n", PortId, Index);
+ DPRINT("Removing device on port %d (Child index: %d)\n", PortId, Index);
for (Index = 0; Index < USB_MAXCHILDREN; Index++)
{
{
if (HubDeviceExtension->ChildDeviceObject[ChildDeviceCount] == NULL)
{
- DPRINT1("Found unused entry at %d\n", ChildDeviceCount);
+ DPRINT("Found unused entry at %d\n", ChildDeviceCount);
break;
}
}
return Status;
}
- DPRINT1("USBHUB: Created Device %x\n", NewChildDeviceObject);
+ DPRINT("USBHUB: Created Device %x\n", NewChildDeviceObject);
break;
}
goto Cleanup;
}
- DPRINT1("Usb Device Handle %x\n", UsbChildExtension->UsbDeviceHandle);
+ DPRINT("Usb Device Handle %x\n", UsbChildExtension->UsbDeviceHandle);
ConfigDescSize = sizeof(USB_CONFIGURATION_DESCRIPTOR);
DeviceDescSize = sizeof(USB_DEVICE_DESCRIPTOR);
HubDeviceExtension = (PHUB_DEVICE_EXTENSION) DeviceObject->DeviceExtension;
- DPRINT1("RootHubInitCallbackFunction Sending the initial SCE Request %x\n", DeviceObject);
+ DPRINT("RootHubInitCallbackFunction Sending the initial SCE Request %x\n", DeviceObject);
//
// Send the first SCE Request
PURB ConfigUrb = NULL;
ULONG HubStatus;
- DPRINT1("IRP_MJ_PNP / IRP_MN_START_DEVICE\n");
+ DPRINT("IRP_MJ_PNP / IRP_MN_START_DEVICE\n");
//
// Allocated size including the sizeof USBD_INTERFACE_LIST_ENTRY
RootHubDeviceObject = HubDeviceExtension->RootHubPhysicalDeviceObject;
ASSERT(HubDeviceExtension->RootHubPhysicalDeviceObject);
ASSERT(HubDeviceExtension->RootHubFunctionalDeviceObject);
- DPRINT1("RootPdo %x, RootFdo %x\n",
+ DPRINT("RootPdo %x, RootFdo %x\n",
HubDeviceExtension->RootHubPhysicalDeviceObject,
HubDeviceExtension->RootHubFunctionalDeviceObject);
sizeof(USB_CONFIGURATION_DESCRIPTOR) + sizeof(USB_INTERFACE_DESCRIPTOR) + sizeof(USB_ENDPOINT_DESCRIPTOR),
NULL);
- DPRINT1("RootHub Handle %x\n", HubDeviceExtension->RootHubHandle);
+ DPRINT("RootHub Handle %x\n", HubDeviceExtension->RootHubHandle);
Urb->UrbHeader.UsbdDeviceHandle = NULL;//HubDeviceExtension->RootHubHandle;
Status = SubmitRequestToRootHub(RootHubDeviceObject,
HubDeviceExtension->ConfigurationHandle = ConfigUrb->UrbSelectConfiguration.ConfigurationHandle;
HubDeviceExtension->PipeHandle = ConfigUrb->UrbSelectConfiguration.Interface.Pipes[0].PipeHandle;
- DPRINT1("Configuration Handle %x\n", HubDeviceExtension->ConfigurationHandle);
+ DPRINT("Configuration Handle %x\n", HubDeviceExtension->ConfigurationHandle);
//
// check if function is available
//
Status = HubDeviceExtension->HubInterface.Initialize20Hub(HubInterfaceBusContext,
HubDeviceExtension->RootHubHandle, 1);
- DPRINT1("Status %x\n", Status);
+ DPRINT("Status %x\n", Status);
//
// FIXME handle error
// Enable power on all ports
//
- DPRINT1("Enabling PortPower on all ports!\n");
+ DPRINT("Enabling PortPower on all ports!\n");
for (PortId = 1; PortId <= HubDeviceExtension->HubDescriptor.bNumberOfPorts; PortId++)
{
DPRINT1("Failed to power on port %d\n", PortId);
}
- DPRINT1("RootHubInitNotification %x\n", HubDeviceExtension->HubInterface.RootHubInitNotification);
+ DPRINT("RootHubInitNotification %x\n", HubDeviceExtension->HubInterface.RootHubInitNotification);
//
// init root hub notification
case BusRelations:
{
PDEVICE_RELATIONS DeviceRelations = NULL;
- DPRINT1("IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_RELATIONS / BusRelations\n");
+ DPRINT("IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_RELATIONS / BusRelations\n");
Status = USBHUB_FdoQueryBusRelations(DeviceObject, &DeviceRelations);
}
case RemovalRelations:
{
- DPRINT1("IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_RELATIONS / RemovalRelations\n");
+ DPRINT("IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_RELATIONS / RemovalRelations\n");
return ForwardIrpAndForget(DeviceObject, Irp);
}
default:
- DPRINT1("IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_RELATIONS / Unknown type 0x%lx\n",
+ DPRINT("IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_RELATIONS / Unknown type 0x%lx\n",
Stack->Parameters.QueryDeviceRelations.Type);
return ForwardIrpAndForget(DeviceObject, Irp);
}
}
case IRP_MN_QUERY_BUS_INFORMATION:
{
- DPRINT1("IRP_MN_QUERY_BUS_INFORMATION\n");
+ DPRINT("IRP_MN_QUERY_BUS_INFORMATION\n");
break;
}
case IRP_MN_QUERY_ID:
{
- DPRINT1("IRP_MN_QUERY_ID\n");
+ DPRINT("IRP_MN_QUERY_ID\n");
break;
}
case IRP_MN_QUERY_CAPABILITIES:
{
- DPRINT1("IRP_MN_QUERY_CAPABILITIES\n");
+ DPRINT("IRP_MN_QUERY_CAPABILITIES\n");
break;
}
default:
{
- DPRINT1(" IRP_MJ_PNP / unknown minor function 0x%lx\n", Stack->MinorFunction);
+ DPRINT(" IRP_MJ_PNP / unknown minor function 0x%lx\n", Stack->MinorFunction);
return ForwardIrpAndForget(DeviceObject, Irp);
}
}
{
PHUB_DEVICE_EXTENSION DeviceExtension;
- DPRINT1("IOCTL_INTERNAL_USB_GET_PARENT_HUB_INFO\n");
+ DPRINT("IOCTL_INTERNAL_USB_GET_PARENT_HUB_INFO\n");
if (Irp->AssociatedIrp.SystemBuffer == NULL
|| Stack->Parameters.DeviceIoControl.OutputBufferLength != sizeof(PVOID))
{
// USBD_PORT_ENABLED (bit 0) or USBD_PORT_CONNECTED (bit 1)
//
DPRINT1("IOCTL_INTERNAL_USB_GET_PORT_STATUS\n");
- DPRINT1("Arg1 %x\n", *PortStatusBits);
+ DPRINT("Arg1 %x\n", *PortStatusBits);
*PortStatusBits = 0;
if (Stack->Parameters.Others.Argument1)
{
Status = GetPortStatusAndChange(RootHubDeviceObject, PortId, &PortStatus);
if (NT_SUCCESS(Status))
{
- DPRINT1("Connect %x\n", ((PortStatus.Status & USB_PORT_STATUS_CONNECT) << 1) << ((PortId - 1) * 2));
- DPRINT1("Enable %x\n", ((PortStatus.Status & USB_PORT_STATUS_ENABLE) >> 1) << ((PortId - 1) * 2));
+ DPRINT("Connect %x\n", ((PortStatus.Status & USB_PORT_STATUS_CONNECT) << 1) << ((PortId - 1) * 2));
+ DPRINT("Enable %x\n", ((PortStatus.Status & USB_PORT_STATUS_ENABLE) >> 1) << ((PortId - 1) * 2));
*PortStatusBits +=
(((PortStatus.Status & USB_PORT_STATUS_CONNECT) << 1) << ((PortId - 1) * 2)) +
(((PortStatus.Status & USB_PORT_STATUS_ENABLE) >> 1) << ((PortId - 1) * 2));
{
PHUB_CHILDDEVICE_EXTENSION ChildDeviceExtension;
//NTSTATUS Status;
- DPRINT1("USBHUB_PdoStartDevice %x\n", DeviceObject);
+ DPRINT("USBHUB_PdoStartDevice %x\n", DeviceObject);
ChildDeviceExtension = (PHUB_CHILDDEVICE_EXTENSION)DeviceObject->DeviceExtension;
//
{
case BusQueryDeviceID:
{
- DPRINT1("IRP_MJ_PNP / IRP_MN_QUERY_ID / BusQueryDeviceID\n");
+ DPRINT("IRP_MJ_PNP / IRP_MN_QUERY_ID / BusQueryDeviceID\n");
SourceString = &ChildDeviceExtension->usDeviceId;
break;
}
case BusQueryHardwareIDs:
{
- DPRINT1("IRP_MJ_PNP / IRP_MN_QUERY_ID / BusQueryHardwareIDs\n");
+ DPRINT("IRP_MJ_PNP / IRP_MN_QUERY_ID / BusQueryHardwareIDs\n");
SourceString = &ChildDeviceExtension->usHardwareIds;
break;
}
case BusQueryCompatibleIDs:
{
- DPRINT1("IRP_MJ_PNP / IRP_MN_QUERY_ID / BusQueryCompatibleIDs\n");
+ DPRINT("IRP_MJ_PNP / IRP_MN_QUERY_ID / BusQueryCompatibleIDs\n");
SourceString = &ChildDeviceExtension->usCompatibleIds;
break;
}
case BusQueryInstanceID:
{
- DPRINT1("IRP_MJ_PNP / IRP_MN_QUERY_ID / BusQueryInstanceID\n");
+ DPRINT("IRP_MJ_PNP / IRP_MN_QUERY_ID / BusQueryInstanceID\n");
SourceString = &ChildDeviceExtension->usInstanceId;
break;
}
case DeviceTextDescription:
case DeviceTextLocationInformation:
{
- DPRINT1("IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_TEXT / DeviceTextDescription\n");
+ DPRINT("IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_TEXT / DeviceTextDescription\n");
//
// does the device provide a text description
{
case IRP_MN_START_DEVICE:
{
- DPRINT1("IRP_MJ_PNP / IRP_MN_START_DEVICE\n");
+ DPRINT("IRP_MJ_PNP / IRP_MN_START_DEVICE\n");
Status = USBHUB_PdoStartDevice(DeviceObject, Irp);
break;
}
{
PDEVICE_CAPABILITIES DeviceCapabilities;
ULONG i;
- DPRINT1("IRP_MJ_PNP / IRP_MN_QUERY_CAPABILITIES\n");
+ DPRINT("IRP_MJ_PNP / IRP_MN_QUERY_CAPABILITIES\n");
DeviceCapabilities = (PDEVICE_CAPABILITIES)Stack->Parameters.DeviceCapabilities.Capabilities;
// FIXME: capabilities can change with connected device
}
case IRP_MN_QUERY_RESOURCES:
{
- DPRINT1("IRP_MJ_PNP / IRP_MN_QUERY_RESOURCES\n");
+ DPRINT("IRP_MJ_PNP / IRP_MN_QUERY_RESOURCES\n");
Information = Irp->IoStatus.Information;
Status = Irp->IoStatus.Status;
}
case IRP_MN_QUERY_RESOURCE_REQUIREMENTS:
{
- DPRINT1("IRP_MJ_PNP / IRP_MN_QUERY_RESOURCE_REQUIREMENTS\n");
+ DPRINT("IRP_MJ_PNP / IRP_MN_QUERY_RESOURCE_REQUIREMENTS\n");
Information = Irp->IoStatus.Information;
Status = Irp->IoStatus.Status;
PHUB_DEVICE_EXTENSION HubDeviceExtension = (PHUB_DEVICE_EXTENSION)UsbChildExtension->ParentDeviceObject->DeviceExtension;
PUSB_BUS_INTERFACE_HUB_V5 HubInterface = &HubDeviceExtension->HubInterface;
- DPRINT1("IRP_MJ_PNP / IRP_MN_REMOVE_DEVICE\n");
+ DPRINT("IRP_MJ_PNP / IRP_MN_REMOVE_DEVICE\n");
/* remove us from pdo list */
bFound = FALSE;
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
{
- DPRINT1("USBHUB: IRP_MJ_CREATE\n");
+ DPRINT("USBHUB: IRP_MJ_CREATE\n");
Irp->IoStatus.Status = STATUS_SUCCESS;
Irp->IoStatus.Information = 0;
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
{
- DPRINT1("USBHUB: IRP_MJ_CLOSE\n");
+ DPRINT("USBHUB: IRP_MJ_CLOSE\n");
Irp->IoStatus.Status = STATUS_SUCCESS;
Irp->IoStatus.Information = 0;
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
{
- DPRINT1("USBHUB: IRP_MJ_CLEANUP\n");
+ DPRINT("USBHUB: IRP_MJ_CLEANUP\n");
Irp->IoStatus.Status = STATUS_SUCCESS;
Irp->IoStatus.Information = 0;
PDEVICE_OBJECT DeviceObject;
PHUB_DEVICE_EXTENSION HubDeviceExtension;
NTSTATUS Status;
- DPRINT1("USBHUB: AddDevice\n");
+ DPRINT("USBHUB: AddDevice\n");
//
// Create the Device Object
//
PDEVICE_OBJECT DeviceObject,
PIRP Irp)
{
- DPRINT1("Usbhub: DispatchDeviceControl\n");
+ DPRINT("Usbhub: DispatchDeviceControl\n");
if (((PHUB_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->Common.IsFDO)
return USBHUB_FdoHandleDeviceControl(DeviceObject, Irp);
else
PDEVICE_OBJECT DeviceObject,
PIRP Irp)
{
- //DPRINT1("Usbhub: DispatchInternalDeviceControl\n");
+ DPRINT("Usbhub: DispatchInternalDeviceControl\n");
if (((PHUB_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->Common.IsFDO)
return USBHUB_IrpStub(DeviceObject, Irp);
else
PDEVICE_OBJECT DeviceObject,
PIRP Irp)
{
- DPRINT1("USBHUB: DispatchPnp\n");
+ DPRINT("USBHUB: DispatchPnp\n");
if (((PHUB_DEVICE_EXTENSION)DeviceObject->DeviceExtension)->Common.IsFDO)
return USBHUB_FdoHandlePnp(DeviceObject, Irp);
else
DriverObject->DriverExtension->AddDevice = USBHUB_AddDevice;
DriverObject->DriverUnload = USBHUB_Unload;
- DPRINT1("USBHUB: DriverEntry\n");
+ DPRINT("USBHUB: DriverEntry\n");
DriverObject->MajorFunction[IRP_MJ_CREATE] = USBHUB_Create;
DriverObject->MajorFunction[IRP_MJ_CLOSE] = USBHUB_Close;
NTSTATUS Status;
ULONG BytesRead;
- DPRINT1("CUSBHardwareDevice::Initialize\n");
+ DPRINT("CUSBHardwareDevice::Initialize\n");
//
// Create DMAMemoryManager for use with QueueHeads and Transfer Descriptors.
NTSTATUS Status;
ULONG Version;
- DPRINT1("CUSBHardwareDevice::PnpStart\n");
+ DPRINT("CUSBHardwareDevice::PnpStart\n");
for(Index = 0; Index < TranslatedResources->List[0].PartialResourceList.Count; Index++)
{
//
//
Version = READ_REGISTER_ULONG((PULONG)((ULONG_PTR)ResourceBase + OHCI_REVISION_OFFSET));
- DPRINT1("Version %x\n", Version);
+ DPRINT("Version %x\n", Version);
//
// Store Resource base
if (!NT_SUCCESS(Status))
{
DPRINT1("Failed to Initialize the controller \n");
- ASSERT(FALSE);
return Status;
}
if (!NT_SUCCESS(Status))
{
DPRINT1("Failed to stop the controller \n");
- ASSERT(FALSE);
return Status;
}
//
Periodic = OHCI_PERIODIC(m_IntervalValue);
WRITE_REGISTER_ULONG((PULONG)((PUCHAR)m_Base + OHCI_PERIODIC_START_OFFSET), Periodic);
- DPRINT1("Periodic Start %x\n", Periodic);
+ DPRINT("Periodic Start %x\n", Periodic);
//
// start the controller
}
else
{
- DPRINT1("SMM has given up ownership\n");
+ DPRINT("SMM has given up ownership\n");
}
}
else
// read contents of control register
//
Control = (READ_REGISTER_ULONG((PULONG)((PUCHAR)m_Base + OHCI_CONTROL_OFFSET)) & OHCI_HC_FUNCTIONAL_STATE_MASK);
- DPRINT1("Controller State %x\n", Control);
+ DPRINT("Controller State %x\n", Control);
if (Control != OHCI_HC_FUNCTIONAL_STATE_RESET)
{
{
ULONG Value;
- DPRINT1("CUSBHardwareDevice::SetPortFeature PortId %x Feature %x\n", PortId, Feature);
+ DPRINT("CUSBHardwareDevice::SetPortFeature PortId %x Feature %x\n", PortId, Feature);
//
// read port status
Number = READ_REGISTER_ULONG((PULONG)((PUCHAR)m_Base + OHCI_FRAME_INTERVAL_NUMBER_OFFSET));
- DPRINT1("FrameNumberInterval %x Frame %x\n", Number, m_HCCA->CurrentFrameNumber);
+ DPRINT("FrameNumberInterval %x Frame %x\n", Number, m_HCCA->CurrentFrameNumber);
//
// remove reserved bits
// the interrupt was not caused by DoneHead update
// check if something important happened
//
- DPRINT1("InterruptStatus %x InterruptEnable %x\n", READ_REGISTER_ULONG((PULONG)((PUCHAR)This->m_Base + OHCI_INTERRUPT_STATUS_OFFSET)),
+ DPRINT("InterruptStatus %x InterruptEnable %x\n", READ_REGISTER_ULONG((PULONG)((PUCHAR)This->m_Base + OHCI_INTERRUPT_STATUS_OFFSET)),
READ_REGISTER_ULONG((PULONG)((PUCHAR)This->m_Base + OHCI_INTERRUPT_ENABLE_OFFSET)));
Status = READ_REGISTER_ULONG((PULONG)((PUCHAR)This->m_Base + OHCI_INTERRUPT_STATUS_OFFSET)) & READ_REGISTER_ULONG((PULONG)((PUCHAR)This->m_Base + OHCI_INTERRUPT_ENABLE_OFFSET)) & (~OHCI_WRITEBACK_DONE_HEAD);
if (Status == 0)
//
PC_ASSERT(DeviceExtension->IsFDO);
- DPRINT1("HandleDeviceControl>Type: IoCtl %x InputBufferLength %lu OutputBufferLength %lu\n",
+ DPRINT("HandleDeviceControl>Type: IoCtl %x InputBufferLength %lu OutputBufferLength %lu\n",
IoStack->Parameters.DeviceIoControl.IoControlCode,
IoStack->Parameters.DeviceIoControl.InputBufferLength,
IoStack->Parameters.DeviceIoControl.OutputBufferLength);
{
case IRP_MN_START_DEVICE:
{
- DPRINT1("CHCDController::HandlePnp IRP_MN_START FDO\n");
+ DPRINT("CHCDController::HandlePnp IRP_MN_START FDO\n");
//
// first start lower device object
Status = SetSymbolicLink(TRUE);
}
- DPRINT1("CHCDController::HandlePnp IRP_MN_START FDO: Status %x\n", Status);
+ DPRINT("CHCDController::HandlePnp IRP_MN_START FDO: Status %x\n", Status);
break;
}
case IRP_MN_QUERY_DEVICE_RELATIONS:
{
- DPRINT1("CHCDController::HandlePnp IRP_MN_QUERY_DEVICE_RELATIONS Type %lx\n", IoStack->Parameters.QueryDeviceRelations.Type);
+ DPRINT("CHCDController::HandlePnp IRP_MN_QUERY_DEVICE_RELATIONS Type %lx\n", IoStack->Parameters.QueryDeviceRelations.Type);
if (m_HubController == NULL)
{
}
case IRP_MN_STOP_DEVICE:
{
- DPRINT1("CHCDController::HandlePnp IRP_MN_STOP_DEVICE\n");
+ DPRINT("CHCDController::HandlePnp IRP_MN_STOP_DEVICE\n");
if (m_Hardware)
{
}
case IRP_MN_REMOVE_DEVICE:
{
- DPRINT1("CHCDController::HandlePnp IRP_MN_REMOVE_DEVICE FDO\n");
+ DPRINT("CHCDController::HandlePnp IRP_MN_REMOVE_DEVICE FDO\n");
//
// delete the symbolic link
//
m_FDODeviceNumber = UsbDeviceNumber;
- DPRINT1("CreateFDO: DeviceName %wZ\n", &DeviceName);
+ DPRINT("CreateFDO: DeviceName %wZ\n", &DeviceName);
/* done */
return Status;
USHORT VendorID, DeviceID;
ULONG Dummy1;
- DPRINT1("CHubController::Initialize\n");
+ DPRINT("CHubController::Initialize\n");
//
// initialize members
// Get the number of ports and check each one for device connected
//
m_Hardware->GetDeviceDetails(NULL, NULL, &PortCount, NULL);
- DPRINT1("SCE Request %p TransferBufferLength %lu Flags %x MDL %p\n", Urb->UrbBulkOrInterruptTransfer.TransferBuffer, Urb->UrbBulkOrInterruptTransfer.TransferBufferLength, Urb->UrbBulkOrInterruptTransfer.TransferFlags, Urb->UrbBulkOrInterruptTransfer.TransferBufferMDL);
+ DPRINT("SCE Request %p TransferBufferLength %lu Flags %x MDL %p\n", Urb->UrbBulkOrInterruptTransfer.TransferBuffer, Urb->UrbBulkOrInterruptTransfer.TransferBufferLength, Urb->UrbBulkOrInterruptTransfer.TransferFlags, Urb->UrbBulkOrInterruptTransfer.TransferBufferMDL);
TransferBuffer = (PUCHAR)Urb->UrbBulkOrInterruptTransfer.TransferBuffer;
{
m_Hardware->GetPortStatus(PortId, &PortStatus, &PortChange);
- DPRINT1("Port %d: Status %x, Change %x\n", PortId, PortStatus, PortChange);
+ DPRINT("Port %d: Status %x, Change %x\n", PortId, PortStatus, PortChange);
//
{
case IRP_MN_START_DEVICE:
{
- DPRINT1("CHubController::HandlePnp IRP_MN_START_DEVICE\n");
+ DPRINT("CHubController::HandlePnp IRP_MN_START_DEVICE\n");
//
// register device interface
//
}
case IRP_MN_QUERY_ID:
{
- DPRINT1("CHubController::HandlePnp IRP_MN_QUERY_ID Type %x\n", IoStack->Parameters.QueryId.IdType);
+ DPRINT("CHubController::HandlePnp IRP_MN_QUERY_ID Type %x\n", IoStack->Parameters.QueryId.IdType);
if (IoStack->Parameters.QueryId.IdType == BusQueryDeviceID)
{
swprintf(Buffer, L"USB\\ROOT_HUB");
}
- DPRINT1("Name %S\n", Buffer);
+ DPRINT("Name %S\n", Buffer);
//
// calculate length
Index++;
- DPRINT1("Name %S\n", Buffer);
+ DPRINT("Name %S\n", Buffer);
//
// allocate buffer
}
case IRP_MN_QUERY_CAPABILITIES:
{
- DPRINT1("CHubController::HandlePnp IRP_MN_QUERY_CAPABILITIES\n");
+ DPRINT("CHubController::HandlePnp IRP_MN_QUERY_CAPABILITIES\n");
DeviceCapabilities = (PDEVICE_CAPABILITIES)IoStack->Parameters.DeviceCapabilities.Capabilities;
}
case IRP_MN_QUERY_INTERFACE:
{
- DPRINT1("CHubController::HandlePnp IRP_MN_QUERY_INTERFACE\n");
+ DPRINT("CHubController::HandlePnp IRP_MN_QUERY_INTERFACE\n");
//
// handle device interface requests
}
case IRP_MN_REMOVE_DEVICE:
{
- DPRINT1("CHubController::HandlePnp IRP_MN_REMOVE_DEVICE\n");
+ DPRINT("CHubController::HandlePnp IRP_MN_REMOVE_DEVICE\n");
//
// deactivate device interface for BUS PDO
}
case IRP_MN_QUERY_DEVICE_RELATIONS:
{
- DPRINT1("CHubController::HandlePnp IRP_MN_QUERY_DEVICE_RELATIONS Type %x\n", IoStack->Parameters.QueryDeviceRelations.Type);
+ DPRINT("CHubController::HandlePnp IRP_MN_QUERY_DEVICE_RELATIONS Type %x\n", IoStack->Parameters.QueryDeviceRelations.Type);
if (IoStack->Parameters.QueryDeviceRelations.Type == TargetDeviceRelation)
{
}
case IRP_MN_QUERY_BUS_INFORMATION:
{
- DPRINT1("CHubController::HandlePnp IRP_MN_QUERY_BUS_INFORMATION\n");
+ DPRINT("CHubController::HandlePnp IRP_MN_QUERY_BUS_INFORMATION\n");
//
// allocate buffer for bus information
}
case IRP_MN_STOP_DEVICE:
{
- DPRINT1("CHubController::HandlePnp IRP_MN_STOP_DEVICE\n");
+ DPRINT("CHubController::HandlePnp IRP_MN_STOP_DEVICE\n");
//
// stop device
//
//
// Else pend the IRP, to be completed when a device connects or disconnects.
//
- DPRINT1("Pending SCE Irp\n");;
+ DPRINT("Pending SCE Irp\n");;
m_PendingSCEIrp = Irp;
IoMarkIrpPending(Irp);
return STATUS_PENDING;
//
Status = UsbDevice->SubmitSetupPacket(&CtrlSetup, Urb->UrbControlDescriptorRequest.TransferBufferLength, Urb->UrbControlDescriptorRequest.TransferBuffer);
ASSERT(Status == STATUS_SUCCESS);
- DPRINT1("CHubController::HandleGetStatusFromDevice Status %x Length %lu DeviceStatus %x\n", Status, Urb->UrbControlDescriptorRequest.TransferBufferLength, *DeviceStatus);
+ DPRINT("CHubController::HandleGetStatusFromDevice Status %x Length %lu DeviceStatus %x\n", Status, Urb->UrbControlDescriptorRequest.TransferBufferLength, *DeviceStatus);
//
// done
{
CHubController * Controller = (CHubController*)BusContext;
- DPRINT1("USBH_InterfaceReference\n");
+ DPRINT("USBH_InterfaceReference\n");
//
// add reference
{
CHubController * Controller = (CHubController*)BusContext;
- DPRINT1("USBH_InterfaceDereference\n");
+ DPRINT("USBH_InterfaceDereference\n");
//
// release
CHubController * Controller;
NTSTATUS Status;
- DPRINT1("USBHI_CreateUsbDevice PortStatus %x\n", PortStatus);
+ DPRINT("USBHI_CreateUsbDevice PortStatus %x\n", PortStatus);
//
// first get hub controller
NTSTATUS Status;
ULONG Index = 0;
- DPRINT1("USBHI_InitializeUsbDevice\n");
+ DPRINT("USBHI_InitializeUsbDevice\n");
//
// first get controller
PUSBDEVICE UsbDevice;
CHubController * Controller;
- DPRINT1("USBHI_GetUsbDescriptors\n");
+ DPRINT("USBHI_GetUsbDescriptors\n");
//
// sanity check
CHubController * Controller;
NTSTATUS Status;
- DPRINT1("USBHI_RemoveUsbDevice\n");
+ DPRINT("USBHI_RemoveUsbDevice\n");
//
// first get controller
PUSBDEVICE OldUsbDevice, NewUsbDevice;
CHubController * Controller;
- DPRINT1("USBHI_RestoreUsbDevice\n");
+ DPRINT("USBHI_RestoreUsbDevice\n");
//
// first get controller
PC_ASSERT(Controller->ValidateUsbDevice(NewUsbDevice));
PC_ASSERT(Controller->ValidateUsbDevice(OldUsbDevice));
- DPRINT1("NewUsbDevice: DeviceAddress %x\n", NewUsbDevice->GetDeviceAddress());
- DPRINT1("OldUsbDevice: DeviceAddress %x\n", OldUsbDevice->GetDeviceAddress());
+ DPRINT("NewUsbDevice: DeviceAddress %x\n", NewUsbDevice->GetDeviceAddress());
+ DPRINT("OldUsbDevice: DeviceAddress %x\n", OldUsbDevice->GetDeviceAddress());
//
// remove old device handle
PUSBDEVICE UsbDevice;
CHubController * Controller;
- DPRINT1("USBHI_QueryDeviceInformation %p\n", BusContext);
+ DPRINT("USBHI_QueryDeviceInformation %p\n", BusContext);
//
// sanity check
{
PUSB_CONTROLLER_INFORMATION_0 ControllerInfo;
- DPRINT1("USBHI_GetControllerInformation\n");
+ DPRINT("USBHI_GetControllerInformation\n");
//
// sanity checks
USHORT Dummy1;
NTSTATUS Status;
- DPRINT1("USBHI_GetExtendedHubInformation\n");
+ DPRINT("USBHI_GetExtendedHubInformation\n");
//
// sanity checks
// looks like we need apply a dragon voodoo to fixup the device stack
// otherwise usbhub will cause a bugcheck
//
- DPRINT1("USBHI_SetDeviceHandleData %p\n", UsbDevicePdo);
+ DPRINT("USBHI_SetDeviceHandleData %p\n", UsbDevicePdo);
//
// sanity check
ULONG Speed, Dummy2;
USHORT Dummy1;
- DPRINT1("USBDI_GetUSBDIVersion\n");
+ DPRINT("USBDI_GetUSBDIVersion\n");
//
// get controller
ULONG Speed, Dummy2;
USHORT Dummy1;
- DPRINT1("USBDI_IsDeviceHighSpeed\n");
+ DPRINT("USBDI_IsDeviceHighSpeed\n");
//
// get controller
}
}
- DPRINT1("CHubController::CreatePDO: DeviceName %wZ\n", &DeviceName);
+ DPRINT("CHubController::CreatePDO: DeviceName %wZ\n", &DeviceName);
//
// fixup device stack voodoo part #1
Irp = This->m_PendingSCEIrp;
if (!Irp)
{
- DPRINT1("There was no pending IRP for SCE. Did the usb hub 2.0 driver (usbhub2) load?\n");
+ DPRINT("There was no pending IRP for SCE. Did the usb hub 2.0 driver (usbhub2) load?\n");
return;
}
}
DPRINT1("CUSBDevice::GetType Unknown bcdUSB Type %x\n", m_DeviceDescriptor.bcdUSB);
- PC_ASSERT(FALSE);
+ //PC_ASSERT(FALSE);
return Usb11Device;
}
//
CurrentDescriptor = (POHCI_ISO_TD)Descriptor->HeadLogicalDescriptor;
- DPRINT1("ISO: NextFrameNumber %x\n", FrameNumber);
+ DPRINT("ISO: NextFrameNumber %x\n", FrameNumber);
Frame = (FrameNumber & 0xFFFF);
while(CurrentDescriptor)
//
m_Hardware->GetCurrentFrameNumber(&FrameNumber);
- DPRINT1("Hardware 1ms %p Iso %p\n",m_InterruptEndpoints[0], m_IsoHeadEndpointDescriptor);
+ DPRINT("Hardware 1ms %p Iso %p\n",m_InterruptEndpoints[0], m_IsoHeadEndpointDescriptor);
ASSERT(m_InterruptEndpoints[0]->NextPhysicalEndpoint == m_IsoHeadEndpointDescriptor->PhysicalAddress.LowPart);
PrintEndpointList(m_IsoHeadEndpointDescriptor);
//
// cleanup endpoint
//
- DPRINT1("ISO endpoint complete\n");
- ASSERT(FALSE);
+ DPRINT("ISO endpoint complete\n");
+ //ASSERT(FALSE);
CleanupEndpointDescriptor(EndpointDescriptor, PreviousEndpointDescriptor);
//
// store buffer offset
//
CurrentDescriptor->Offset[SubIndex] = Urb->UrbIsochronousTransfer.IsoPacket[Index+SubIndex].Offset + PageOffset;
- DPRINT1("Index %lu PacketOffset %lu FinalOffset %lu\n", SubIndex+Index, Urb->UrbIsochronousTransfer.IsoPacket[Index+SubIndex].Offset, CurrentDescriptor->Offset[SubIndex]);
+ DPRINT("Index %lu PacketOffset %lu FinalOffset %lu\n", SubIndex+Index, Urb->UrbIsochronousTransfer.IsoPacket[Index+SubIndex].Offset, CurrentDescriptor->Offset[SubIndex]);
}
//
// store as previous descriptor
//
PreviousDescriptor = CurrentDescriptor;
- DPRINT1("Current Descriptor %p Logical %lx StartAddress %x EndAddress %x\n", CurrentDescriptor, CurrentDescriptor->PhysicalAddress.LowPart, CurrentDescriptor->BufferPhysical, CurrentDescriptor->LastPhysicalByteAddress);
+ DPRINT("Current Descriptor %p Logical %lx StartAddress %x EndAddress %x\n", CurrentDescriptor, CurrentDescriptor->PhysicalAddress.LowPart, CurrentDescriptor->BufferPhysical, CurrentDescriptor->LastPhysicalByteAddress);
//
// fire interrupt as soon transfer is finished
//
PacketCount = OHCI_ITD_GET_FRAME_COUNT(IsoTransferDescriptor->Flags);
- DPRINT1("CUSBRequest::FreeEndpointDescriptor Descriptor %p Logical %x Buffer Physical %x EndAddress %x PacketCount %lu\n", IsoTransferDescriptor, IsoTransferDescriptor->PhysicalAddress.LowPart, IsoTransferDescriptor->BufferPhysical, IsoTransferDescriptor->LastPhysicalByteAddress, PacketCount);
+ DPRINT("CUSBRequest::FreeEndpointDescriptor Descriptor %p Logical %x Buffer Physical %x EndAddress %x PacketCount %lu\n", IsoTransferDescriptor, IsoTransferDescriptor->PhysicalAddress.LowPart, IsoTransferDescriptor->BufferPhysical, IsoTransferDescriptor->LastPhysicalByteAddress, PacketCount);
for(Index = 0; Index < PacketCount; Index++)
{
- DPRINT1("PSW Index %lu Value %x\n", Index, IsoTransferDescriptor->Offset[Index]);
+ DPRINT("PSW Index %lu Value %x\n", Index, IsoTransferDescriptor->Offset[Index]);
}
//
NTSTATUS Status;
PHCDCONTROLLER HcdController;
- DPRINT1("OHCI_AddDevice\n");
+ DPRINT("OHCI_AddDevice\n");
/* first create the controller object */
Status = CreateHCDController(&HcdController);
ANSI_STRING AnsiString;
NTSTATUS Status;
- DPRINT1("USBSTOR_HandleQueryProperty\n");
+ DPRINT("USBSTOR_HandleQueryProperty\n");
//
// get current stack location
//
if (PropertyQuery->PropertyId == StorageDeviceProperty)
{
- DPRINT1("USBSTOR_HandleQueryProperty StorageDeviceProperty OutputBufferLength %lu\n", IoStack->Parameters.DeviceIoControl.OutputBufferLength);
+ DPRINT("USBSTOR_HandleQueryProperty StorageDeviceProperty OutputBufferLength %lu\n", IoStack->Parameters.DeviceIoControl.OutputBufferLength);
//
// get device extension
//
// adapter property query request
//
- DPRINT1("USBSTOR_HandleQueryProperty StorageAdapterProperty OutputBufferLength %lu\n", IoStack->Parameters.DeviceIoControl.OutputBufferLength);
+ DPRINT("USBSTOR_HandleQueryProperty StorageAdapterProperty OutputBufferLength %lu\n", IoStack->Parameters.DeviceIoControl.OutputBufferLength);
if (IoStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(STORAGE_ADAPTER_DESCRIPTOR))
{
//
// allocate urb
//
- DPRINT1("Allocating URB\n");
+ DPRINT("Allocating URB\n");
Urb = (PURB)AllocateItem(NonPagedPool, sizeof(struct _URB_CONTROL_VENDOR_OR_CLASS_REQUEST));
if (!Urb)
{
//
// allocate urb
//
- DPRINT1("Allocating URB\n");
+ DPRINT("Allocating URB\n");
Urb = (PURB)AllocateItem(NonPagedPool, sizeof(struct _URB_PIPE_REQUEST));
if (!Urb)
{
{
NTSTATUS Status;
- DPRINT1("Handling FDO removal\n");
+ DPRINT("Handling FDO removal\n");
/* We don't need to request removal of our children here */
ASSERT(InterfaceDesc->bDescriptorType == USB_INTERFACE_DESCRIPTOR_TYPE);
ASSERT(InterfaceDesc->bLength == sizeof(USB_INTERFACE_DESCRIPTOR));
- DPRINT1("bInterfaceSubClass %x\n", InterfaceDesc->bInterfaceSubClass);
+ DPRINT("bInterfaceSubClass %x\n", InterfaceDesc->bInterfaceSubClass);
if (InterfaceDesc->bInterfaceProtocol != 0x50)
{
DPRINT1("USB Device is not a bulk only device and is not currently supported\n");
//
// fdo is now initialized
//
- DPRINT1("USBSTOR_FdoHandleStartDevice FDO is initialized\n");
+ DPRINT("USBSTOR_FdoHandleStartDevice FDO is initialized\n");
return STATUS_SUCCESS;
}
}
case IRP_MN_REMOVE_DEVICE:
{
- DPRINT1("IRP_MN_REMOVE_DEVICE\n");
+ DPRINT("IRP_MN_REMOVE_DEVICE\n");
return USBSTOR_FdoHandleRemoveDevice(DeviceObject, DeviceExtension, Irp);
}
//
Status = USBSTOR_ClassRequest(DeviceObject, DeviceExtension, USB_BULK_GET_MAX_LUN, DeviceExtension->InterfaceInformation->InterfaceNumber, USBD_TRANSFER_DIRECTION_IN, sizeof(UCHAR), Buffer);
- DPRINT1("MaxLUN: %x\n", *Buffer);
+ DPRINT("MaxLUN: %x\n", *Buffer);
if (*Buffer > 0xF)
{
if (IoStack->Parameters.QueryDeviceText.DeviceTextType == DeviceTextDescription)
{
- DPRINT1("USBSTOR_PdoHandleQueryDeviceText DeviceTextDescription\n");
+ DPRINT("USBSTOR_PdoHandleQueryDeviceText DeviceTextDescription\n");
//
// allocate item
}
else
{
- DPRINT1("USBSTOR_PdoHandleQueryDeviceText DeviceTextLocationInformation\n");
+ DPRINT("USBSTOR_PdoHandleQueryDeviceText DeviceTextLocationInformation\n");
//
// allocate item
Irp->IoStatus.Information = (ULONG_PTR)DeviceId.Buffer;
}
- DPRINT1("DeviceId %wZ Status %x\n", &DeviceId, Status);
+ DPRINT("DeviceId %wZ Status %x\n", &DeviceId, Status);
//
// done
Offset += CopyField(InquiryData->Product, &Id1[Offset], 16);
Offset += CopyField(InquiryData->Revision, &Id1[Offset], 4);
Id1Length = strlen(Id1) + 1;
- DPRINT1("USBSTOR_PdoHandleQueryHardwareId HardwareId1 %s\n", Id1);
+ DPRINT("USBSTOR_PdoHandleQueryHardwareId HardwareId1 %s\n", Id1);
//
// generate id 2
Offset += CopyField(InquiryData->Vendor, &Id2[Offset], 8);
Offset += CopyField(InquiryData->Product, &Id2[Offset], 16);
Id2Length = strlen(Id2) + 1;
- DPRINT1("USBSTOR_PdoHandleQueryHardwareId HardwareId2 %s\n", Id2);
+ DPRINT("USBSTOR_PdoHandleQueryHardwareId HardwareId2 %s\n", Id2);
//
// generate id 3
Offset += sprintf(&Id3[Offset], DeviceType);
Offset += CopyField(InquiryData->Vendor, &Id3[Offset], 8);
Id3Length = strlen(Id3) + 1;
- DPRINT1("USBSTOR_PdoHandleQueryHardwareId HardwareId3 %s\n", Id3);
+ DPRINT("USBSTOR_PdoHandleQueryHardwareId HardwareId3 %s\n", Id3);
//
// generate id 4
Offset += CopyField(InquiryData->Product, &Id4[Offset], 16);
Offset += CopyField(InquiryData->Revision, &Id4[Offset], 1);
Id4Length = strlen(Id4) + 1;
- DPRINT1("USBSTOR_PdoHandleQueryHardwareId HardwareId4 %s\n", Id4);
+ DPRINT("USBSTOR_PdoHandleQueryHardwareId HardwareId4 %s\n", Id4);
//
// generate id 5
Offset = sprintf(&Id5[Offset], "USBSTOR\\");
Offset += sprintf(&Id5[Offset], GenericType);
Id5Length = strlen(Id5) + 1;
- DPRINT1("USBSTOR_PdoHandleQueryHardwareId HardwareId5 %s\n", Id5);
+ DPRINT("USBSTOR_PdoHandleQueryHardwareId HardwareId5 %s\n", Id5);
//
// generate id 6
Offset = 0;
Offset = sprintf(&Id6[Offset], GenericType);
Id6Length = strlen(Id6) + 1;
- DPRINT1("USBSTOR_PdoHandleQueryHardwareId HardwareId6 %s\n", Id6);
+ DPRINT("USBSTOR_PdoHandleQueryHardwareId HardwareId6 %s\n", Id6);
//
// compute total length
USBSTOR_ConvertToUnicodeString(Buffer, Length, 0, InstanceId, &Offset);
USBSTOR_ConvertToUnicodeString(&Buffer[Offset], Length, Offset, InstanceId, &Offset);
- DPRINT1("USBSTOR_PdoHandleQueryCompatibleId %S\n", InstanceId);
+ DPRINT("USBSTOR_PdoHandleQueryCompatibleId %S\n", InstanceId);
//
// store result
//
wcscpy(InstanceId, Buffer);
- DPRINT1("USBSTOR_PdoHandleQueryInstanceId %S\n", InstanceId);
+ DPRINT("USBSTOR_PdoHandleQueryInstanceId %S\n", InstanceId);
//
// store result
PDEVICE_RELATIONS DeviceRelations;
PIO_STACK_LOCATION IoStack;
- DPRINT1("USBSTOR_PdoHandleDeviceRelations\n");
+ DPRINT("USBSTOR_PdoHandleDeviceRelations\n");
//
// get current irp stack location
}
case IRP_MN_REMOVE_DEVICE:
{
- DPRINT1("IRP_MN_REMOVE_DEVICE\n");
+ DPRINT("IRP_MN_REMOVE_DEVICE\n");
if(*DeviceExtension->PDODeviceObject != NULL)
{
Command,
Context->cbw);
- DPRINT1("CBW %p\n", Context->cbw);
+ DPRINT("CBW %p\n", Context->cbw);
//
// now initialize the urb
KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
KeResetEvent(&Event);
- DPRINT1("Resending request\n");
+ DPRINT("Resending request\n");
//
// now send the request
}
else if (pCDB->MODE_SENSE.OperationCode == SCSIOP_MODE_SENSE)
{
- DPRINT1("SCSIOP_MODE_SENSE DataTransferLength %lu\n", Request->DataTransferLength);
+ DPRINT("SCSIOP_MODE_SENSE DataTransferLength %lu\n", Request->DataTransferLength);
ASSERT(pCDB->MODE_SENSE.AllocationLength == Request->DataTransferLength);
ASSERT(Request->DataBuffer);
IN PUNICODE_STRING RegPath)
{
- DPRINT1("********* USB Storage *********\n");
+ DPRINT("********* USB Storage *********\n");
//
// driver unload routine
projects / reactos.git / commitdiff