Merged

sys/Ds4.c

@@ -35,14 +35,26 @@ NTSTATUS Ds4_PreparePdo(PWDFDEVICE_INIT DeviceInit, PUNICODE_STRING DeviceId, PU
     // prepare device description
     status = RtlUnicodeStringInit(DeviceDescription, L"Virtual DualShock 4 Controller");
     if (!NT_SUCCESS(status))
+    {
+        TraceEvents(TRACE_LEVEL_ERROR,
+            TRACE_DS4,
+            "RtlUnicodeStringInit failed with status %!STATUS!",
+            status);
         return status;
+    }
 
     // Set hardware IDs
     RtlUnicodeStringInit(&buffer, L"USB\\VID_054C&PID_05C4&REV_0100");
 
     status = WdfPdoInitAddHardwareID(DeviceInit, &buffer);
     if (!NT_SUCCESS(status))
+    {
+        TraceEvents(TRACE_LEVEL_ERROR,
+            TRACE_DS4,
+            "WdfPdoInitAddHardwareID failed with status %!STATUS!",
+            status);
         return status;
+    }
 
     RtlUnicodeStringCopy(DeviceId, &buffer);
 
@@ -50,26 +62,50 @@ NTSTATUS Ds4_PreparePdo(PWDFDEVICE_INIT DeviceInit, PUNICODE_STRING DeviceId, PU
 
     status = WdfPdoInitAddHardwareID(DeviceInit, &buffer);
     if (!NT_SUCCESS(status))
+    {
+        TraceEvents(TRACE_LEVEL_ERROR,
+            TRACE_DS4,
+            "WdfPdoInitAddHardwareID failed with status %!STATUS!",
+            status);
         return status;
+    }
 
     // Set compatible IDs
     RtlUnicodeStringInit(&buffer, L"USB\\Class_03&SubClass_00&Prot_00");
 
     status = WdfPdoInitAddCompatibleID(DeviceInit, &buffer);
     if (!NT_SUCCESS(status))
+    {
+        TraceEvents(TRACE_LEVEL_ERROR,
+            TRACE_DS4,
+            "WdfPdoInitAddCompatibleID (#01) failed with status %!STATUS!",
+            status);
         return status;
+    }
 
     RtlUnicodeStringInit(&buffer, L"USB\\Class_03&SubClass_00");
 
     status = WdfPdoInitAddCompatibleID(DeviceInit, &buffer);
     if (!NT_SUCCESS(status))
+    {
+        TraceEvents(TRACE_LEVEL_ERROR,
+            TRACE_DS4,
+            "WdfPdoInitAddCompatibleID (#02) failed with status %!STATUS!",
+            status);
         return status;
+    }
 
     RtlUnicodeStringInit(&buffer, L"USB\\Class_03");
 
     status = WdfPdoInitAddCompatibleID(DeviceInit, &buffer);
     if (!NT_SUCCESS(status))
+    {
+        TraceEvents(TRACE_LEVEL_ERROR,
+            TRACE_DS4,
+            "WdfPdoInitAddCompatibleID (#03) failed with status %!STATUS!",
+            status);
         return status;
+    }
 
     return STATUS_SUCCESS;
 }
@@ -93,7 +129,10 @@ NTSTATUS Ds4_PrepareHardware(WDFDEVICE Device)
     status = WdfDeviceAddQueryInterface(Device, &ifaceCfg);
     if (!NT_SUCCESS(status))
     {
-        KdPrint((DRIVERNAME "WdfDeviceAddQueryInterface failed status 0x%x\n", status));
+        TraceEvents(TRACE_LEVEL_ERROR,
+            TRACE_DS4,
+            "WdfDeviceAddQueryInterface failed with status %!STATUS!",
+            status);
         return status;
     }
 
@@ -127,8 +166,6 @@ NTSTATUS Ds4_AssignPdoContext(WDFDEVICE Device, PPDO_IDENTIFICATION_DESCRIPTION
     NTSTATUS            status;
     PDS4_DEVICE_DATA    ds4 = Ds4GetData(Device);
 
-    KdPrint((DRIVERNAME "Initializing DS4 context...\n"));
-
     // Initialize periodic timer
     WDF_TIMER_CONFIG timerConfig;
     WDF_TIMER_CONFIG_INIT_PERIODIC(&timerConfig, Ds4_PendingUsbRequestsTimerFunc, DS4_QUEUE_FLUSH_PERIOD);
@@ -144,7 +181,10 @@ NTSTATUS Ds4_AssignPdoContext(WDFDEVICE Device, PPDO_IDENTIFICATION_DESCRIPTION
     status = WdfTimerCreate(&timerConfig, &timerAttribs, &ds4->PendingUsbInRequestsTimer);
     if (!NT_SUCCESS(status))
     {
-        KdPrint((DRIVERNAME "WdfTimerCreate failed 0x%x\n", status));
+        TraceEvents(TRACE_LEVEL_ERROR,
+            TRACE_DS4,
+            "WdfTimerCreate failed with status %!STATUS!",
+            status);
         return status;
     }
 
@@ -158,38 +198,71 @@ NTSTATUS Ds4_AssignPdoContext(WDFDEVICE Device, PPDO_IDENTIFICATION_DESCRIPTION
     status = WdfDriverOpenParametersRegistryKey(WdfGetDriver(), STANDARD_RIGHTS_ALL, WDF_NO_OBJECT_ATTRIBUTES, &keyParams);
     if (!NT_SUCCESS(status))
     {
-        KdPrint((DRIVERNAME "WdfDriverOpenParametersRegistryKey failed 0x%x\n", status));
+        TraceEvents(TRACE_LEVEL_ERROR,
+            TRACE_DS4,
+            "WdfDriverOpenParametersRegistryKey failed with status %!STATUS!",
+            status);
         return status;
     }
 
     RtlUnicodeStringInit(&keyName, L"Targets");
 
-    status = WdfRegistryCreateKey(keyParams, &keyName,
-        KEY_ALL_ACCESS, REG_OPTION_NON_VOLATILE, NULL, WDF_NO_OBJECT_ATTRIBUTES, &keyTargets);
+    status = WdfRegistryCreateKey(
+        keyParams,
+        &keyName,
+        KEY_ALL_ACCESS,
+        REG_OPTION_NON_VOLATILE,
+        NULL,
+        WDF_NO_OBJECT_ATTRIBUTES,
+        &keyTargets
+    );
     if (!NT_SUCCESS(status))
     {
-        KdPrint((DRIVERNAME "WdfRegistryCreateKey failed 0x%x\n", status));
+        TraceEvents(TRACE_LEVEL_ERROR,
+            TRACE_DS4,
+            "WdfRegistryCreateKey failed with status %!STATUS!",
+            status);
         return status;
     }
 
     RtlUnicodeStringInit(&keyName, L"DualShock");
 
-    status = WdfRegistryCreateKey(keyTargets, &keyName,
-        KEY_ALL_ACCESS, REG_OPTION_NON_VOLATILE, NULL, WDF_NO_OBJECT_ATTRIBUTES, &keyDS);
+    status = WdfRegistryCreateKey(
+        keyTargets,
+        &keyName,
+        KEY_ALL_ACCESS,
+        REG_OPTION_NON_VOLATILE,
+        NULL,
+        WDF_NO_OBJECT_ATTRIBUTES,
+        &keyDS
+    );
     if (!NT_SUCCESS(status))
     {
-        KdPrint((DRIVERNAME "WdfRegistryCreateKey failed 0x%x\n", status));
+        TraceEvents(TRACE_LEVEL_ERROR,
+            TRACE_DS4,
+            "WdfRegistryCreateKey failed with status %!STATUS!",
+            status);
         return status;
     }
 
     DECLARE_UNICODE_STRING_SIZE(serialPath, 4);
     RtlUnicodeStringPrintf(&serialPath, L"%04d", Description->SerialNo);
 
-    status = WdfRegistryCreateKey(keyDS, &serialPath,
-        KEY_ALL_ACCESS, REG_OPTION_NON_VOLATILE, NULL, WDF_NO_OBJECT_ATTRIBUTES, &keySerial);
+    status = WdfRegistryCreateKey(
+        keyDS,
+        &serialPath,
+        KEY_ALL_ACCESS,
+        REG_OPTION_NON_VOLATILE,
+        NULL,
+        WDF_NO_OBJECT_ATTRIBUTES,
+        &keySerial
+    );
     if (!NT_SUCCESS(status))
     {
-        KdPrint((DRIVERNAME "WdfRegistryCreateKey failed 0x%x\n", status));
+        TraceEvents(TRACE_LEVEL_ERROR,
+            TRACE_DS4,
+            "WdfRegistryCreateKey failed with status %!STATUS!",
+            status);
         return status;
     }
 
@@ -197,13 +270,15 @@ NTSTATUS Ds4_AssignPdoContext(WDFDEVICE Device, PPDO_IDENTIFICATION_DESCRIPTION
 
     status = WdfRegistryQueryValue(keySerial, &valueName, sizeof(MAC_ADDRESS), &ds4->TargetMacAddress, NULL, NULL);
 
-    KdPrint((DRIVERNAME "MAC-Address: %02X:%02X:%02X:%02X:%02X:%02X\n",
+    TraceEvents(TRACE_LEVEL_INFORMATION,
+        TRACE_DS4,
+        "MAC-Address: %02X:%02X:%02X:%02X:%02X:%02X\n",
         ds4->TargetMacAddress.Vendor0,
         ds4->TargetMacAddress.Vendor1,
         ds4->TargetMacAddress.Vendor2,
         ds4->TargetMacAddress.Nic0,
         ds4->TargetMacAddress.Nic1,
-        ds4->TargetMacAddress.Nic2));
+        ds4->TargetMacAddress.Nic2);
 
     if (status == STATUS_OBJECT_NAME_NOT_FOUND)
     {
@@ -212,13 +287,19 @@ NTSTATUS Ds4_AssignPdoContext(WDFDEVICE Device, PPDO_IDENTIFICATION_DESCRIPTION
         status = WdfRegistryAssignValue(keySerial, &valueName, REG_BINARY, sizeof(MAC_ADDRESS), (PVOID)&ds4->TargetMacAddress);
         if (!NT_SUCCESS(status))
         {
-            KdPrint((DRIVERNAME "WdfRegistryAssignValue failed 0x%x\n", status));
+            TraceEvents(TRACE_LEVEL_ERROR,
+                TRACE_DS4,
+                "WdfRegistryAssignValue failed with status %!STATUS!",
+                status);
             return status;
         }
     }
     else if (!NT_SUCCESS(status))
     {
-        KdPrint((DRIVERNAME "WdfRegistryQueryValue failed 0x%x\n", status));
+        TraceEvents(TRACE_LEVEL_ERROR,
+            TRACE_DS4,
+            "WdfRegistryQueryValue failed with status %!STATUS!",
+            status);
         return status;
     }
 
@@ -347,6 +428,8 @@ VOID Ds4_PendingUsbRequestsTimerFunc(
     PIO_STACK_LOCATION      irpStack;
     PPDO_DEVICE_DATA        pdoData;
 
+    TraceEvents(TRACE_LEVEL_VERBOSE, TRACE_DS4, "%!FUNC! Entry");
+
     hChild = WdfTimerGetParentObject(Timer);
     pdoData = PdoGetData(hChild);
     ds4Data = Ds4GetData(hChild);
@@ -375,5 +458,7 @@ VOID Ds4_PendingUsbRequestsTimerFunc(
         // Complete pending request
         WdfRequestComplete(usbRequest, status);
     }
+
+    TraceEvents(TRACE_LEVEL_INFORMATION, TRACE_DS4, "%!FUNC! Exit with status %!STATUS!", status);
 }
 

sys/Queue.c

@@ -54,14 +54,16 @@ VOID Bus_EvtIoDeviceControl(
 
     Device = WdfIoQueueGetDevice(Queue);
 
-    KdPrint((DRIVERNAME "Bus_EvtIoDeviceControl: 0x%p\n", Device));
+    TraceEvents(TRACE_LEVEL_VERBOSE, TRACE_QUEUE, "%!FUNC! Entry (device: 0x%p)", Device);
 
     switch (IoControlCode)
     {
 #pragma region IOCTL_VIGEM_CHECK_VERSION
     case IOCTL_VIGEM_CHECK_VERSION:
 
-        KdPrint((DRIVERNAME "IOCTL_VIGEM_CHECK_VERSION\n"));
+        TraceEvents(TRACE_LEVEL_INFORMATION,
+            TRACE_QUEUE,
+            "IOCTL_VIGEM_CHECK_VERSION");
 
         status = WdfRequestRetrieveInputBuffer(Request, sizeof(VIGEM_CHECK_VERSION), (PVOID)&pCheckVersion, &length);
 
@@ -73,13 +75,20 @@ VOID Bus_EvtIoDeviceControl(
 
         status = (pCheckVersion->Version == VIGEM_COMMON_VERSION) ? STATUS_SUCCESS : STATUS_NOT_SUPPORTED;
 
+        TraceEvents(TRACE_LEVEL_VERBOSE,
+            TRACE_QUEUE,
+            "Requested version: 0x%04X, compiled version: 0x%04X",
+            pCheckVersion->Version, VIGEM_COMMON_VERSION);
+
         break;
 #pragma endregion 
 
 #pragma region IOCTL_VIGEM_PLUGIN_TARGET
     case IOCTL_VIGEM_PLUGIN_TARGET:
 
-        KdPrint((DRIVERNAME "IOCTL_VIGEM_PLUGIN_TARGET\n"));
+        TraceEvents(TRACE_LEVEL_INFORMATION,
+            TRACE_QUEUE,
+            "IOCTL_VIGEM_PLUGIN_TARGET");
 
         status = Bus_PlugInDevice(Device, Request, FALSE, &length);
 
@@ -89,7 +98,9 @@ VOID Bus_EvtIoDeviceControl(
 #pragma region IOCTL_VIGEM_UNPLUG_TARGET
     case IOCTL_VIGEM_UNPLUG_TARGET:
 
-        KdPrint((DRIVERNAME "IOCTL_VIGEM_UNPLUG_TARGET\n"));
+        TraceEvents(TRACE_LEVEL_INFORMATION,
+            TRACE_QUEUE,
+            "IOCTL_VIGEM_UNPLUG_TARGET");
 
         status = Bus_UnPlugDevice(Device, Request, FALSE, &length);
 
@@ -99,13 +110,18 @@ VOID Bus_EvtIoDeviceControl(
 #pragma region IOCTL_XUSB_SUBMIT_REPORT
     case IOCTL_XUSB_SUBMIT_REPORT:
 
-        KdPrint((DRIVERNAME "IOCTL_XUSB_SUBMIT_REPORT\n"));
+        TraceEvents(TRACE_LEVEL_VERBOSE,
+            TRACE_QUEUE,
+            "IOCTL_XUSB_SUBMIT_REPORT");
 
         status = WdfRequestRetrieveInputBuffer(Request, sizeof(XUSB_SUBMIT_REPORT), (PVOID)&xusbSubmit, &length);
 
         if (!NT_SUCCESS(status))
         {
-            KdPrint((DRIVERNAME "WdfRequestRetrieveInputBuffer failed 0x%x\n", status));
+            TraceEvents(TRACE_LEVEL_ERROR,
+                TRACE_QUEUE,
+                "WdfRequestRetrieveInputBuffer failed with status %!STATUS!",
+                status);
             break;
         }
 
@@ -114,6 +130,10 @@ VOID Bus_EvtIoDeviceControl(
             // This request only supports a single PDO at a time
             if (xusbSubmit->SerialNo == 0)
             {
+                TraceEvents(TRACE_LEVEL_ERROR,
+                    TRACE_QUEUE,
+                    "Invalid serial 0 submitted");
+
                 status = STATUS_INVALID_PARAMETER;
                 break;
             }
@@ -127,12 +147,17 @@ VOID Bus_EvtIoDeviceControl(
 #pragma region IOCTL_XUSB_REQUEST_NOTIFICATION
     case IOCTL_XUSB_REQUEST_NOTIFICATION:
 
-        KdPrint((DRIVERNAME "IOCTL_XUSB_REQUEST_NOTIFICATION\n"));
+        TraceEvents(TRACE_LEVEL_INFORMATION,
+            TRACE_QUEUE,
+            "IOCTL_XUSB_REQUEST_NOTIFICATION");
 
         // Don't accept the request if the output buffer can't hold the results
         if (OutputBufferLength < sizeof(XUSB_REQUEST_NOTIFICATION))
         {
-            KdPrint((DRIVERNAME "IOCTL_XUSB_REQUEST_NOTIFICATION: output buffer too small: %ul\n", OutputBufferLength));
+            TraceEvents(TRACE_LEVEL_ERROR,
+                TRACE_QUEUE,
+                "Output buffer %d too small, require at least %d",
+                (int)OutputBufferLength, (int)sizeof(XUSB_REQUEST_NOTIFICATION));
             break;
         }
 
@@ -140,7 +165,10 @@ VOID Bus_EvtIoDeviceControl(
 
         if (!NT_SUCCESS(status))
         {
-            KdPrint((DRIVERNAME "WdfRequestRetrieveInputBuffer failed 0x%x\n", status));
+            TraceEvents(TRACE_LEVEL_ERROR,
+                TRACE_QUEUE,
+                "WdfRequestRetrieveInputBuffer failed with status %!STATUS!",
+                status);
             break;
         }
 
@@ -149,6 +177,10 @@ VOID Bus_EvtIoDeviceControl(
             // This request only supports a single PDO at a time
             if (xusbNotify->SerialNo == 0)
             {
+                TraceEvents(TRACE_LEVEL_ERROR,
+                    TRACE_QUEUE,
+                    "Invalid serial 0 submitted");
+
                 status = STATUS_INVALID_PARAMETER;
                 break;
             }
@@ -162,13 +194,18 @@ VOID Bus_EvtIoDeviceControl(
 #pragma region IOCTL_DS4_SUBMIT_REPORT
     case IOCTL_DS4_SUBMIT_REPORT:
 
-        KdPrint((DRIVERNAME "IOCTL_DS4_SUBMIT_REPORT\n"));
+        TraceEvents(TRACE_LEVEL_VERBOSE,
+            TRACE_QUEUE,
+            "IOCTL_DS4_SUBMIT_REPORT");
 
         status = WdfRequestRetrieveInputBuffer(Request, sizeof(DS4_SUBMIT_REPORT), (PVOID)&ds4Submit, &length);
 
         if (!NT_SUCCESS(status))
         {
-            KdPrint((DRIVERNAME "WdfRequestRetrieveInputBuffer failed 0x%x\n", status));
+            TraceEvents(TRACE_LEVEL_ERROR,
+                TRACE_QUEUE,
+                "WdfRequestRetrieveInputBuffer failed with status %!STATUS!",
+                status);
             break;
         }
 
@@ -177,6 +214,10 @@ VOID Bus_EvtIoDeviceControl(
             // This request only supports a single PDO at a time
             if (ds4Submit->SerialNo == 0)
             {
+                TraceEvents(TRACE_LEVEL_ERROR,
+                    TRACE_QUEUE,
+                    "Invalid serial 0 submitted");
+
                 status = STATUS_INVALID_PARAMETER;
                 break;
             }
@@ -190,12 +231,17 @@ VOID Bus_EvtIoDeviceControl(
 #pragma region IOCTL_DS4_REQUEST_NOTIFICATION
     case IOCTL_DS4_REQUEST_NOTIFICATION:
 
-        KdPrint((DRIVERNAME "IOCTL_DS4_REQUEST_NOTIFICATION\n"));
+        TraceEvents(TRACE_LEVEL_INFORMATION,
+            TRACE_QUEUE,
+            "IOCTL_DS4_REQUEST_NOTIFICATION");
 
         // Don't accept the request if the output buffer can't hold the results
         if (OutputBufferLength < sizeof(DS4_REQUEST_NOTIFICATION))
         {
-            KdPrint((DRIVERNAME "IOCTL_DS4_REQUEST_NOTIFICATION: output buffer too small: %ul\n", OutputBufferLength));
+            TraceEvents(TRACE_LEVEL_ERROR,
+                TRACE_QUEUE,
+                "Output buffer %d too small, require at least %d",
+                (int)OutputBufferLength, (int)sizeof(DS4_REQUEST_NOTIFICATION));
             break;
         }
 
@@ -203,7 +249,10 @@ VOID Bus_EvtIoDeviceControl(
 
         if (!NT_SUCCESS(status))
         {
-            KdPrint((DRIVERNAME "WdfRequestRetrieveInputBuffer failed 0x%x\n", status));
+            TraceEvents(TRACE_LEVEL_ERROR,
+                TRACE_QUEUE,
+                "WdfRequestRetrieveInputBuffer failed with status %!STATUS!",
+                status);
             break;
         }
 
@@ -212,6 +261,10 @@ VOID Bus_EvtIoDeviceControl(
             // This request only supports a single PDO at a time
             if (ds4Notify->SerialNo == 0)
             {
+                TraceEvents(TRACE_LEVEL_ERROR,
+                    TRACE_QUEUE,
+                    "Invalid serial 0 submitted");
+
                 status = STATUS_INVALID_PARAMETER;
                 break;
             }
@@ -225,7 +278,9 @@ VOID Bus_EvtIoDeviceControl(
 #pragma region IOCTL_XGIP_SUBMIT_REPORT
     case IOCTL_XGIP_SUBMIT_REPORT:
 
-        KdPrint((DRIVERNAME "IOCTL_XGIP_SUBMIT_REPORT\n"));
+        TraceEvents(TRACE_LEVEL_VERBOSE,
+            TRACE_QUEUE,
+            "IOCTL_XGIP_SUBMIT_REPORT");
 
         status = WdfRequestRetrieveInputBuffer(Request, sizeof(XGIP_SUBMIT_REPORT), (PVOID)&xgipSubmit, &length);
 
@@ -279,7 +334,11 @@ VOID Bus_EvtIoDeviceControl(
 #pragma endregion 
 
     default:
-        KdPrint((DRIVERNAME "UNKNOWN IOCTL CODE 0x%x\n", IoControlCode));
+
+        TraceEvents(TRACE_LEVEL_WARNING,
+            TRACE_QUEUE,
+            "Unknown I/O control code 0x%X", IoControlCode);
+
         break; // default status is STATUS_INVALID_PARAMETER
     }
 
@@ -287,8 +346,15 @@ VOID Bus_EvtIoDeviceControl(
     {
         WdfRequestCompleteWithInformation(Request, status, length);
     }
+    
+    TraceEvents(TRACE_LEVEL_VERBOSE, TRACE_QUEUE, "%!FUNC! Exit with status %!STATUS!", status);
 }
 
+//
+// Gets called upon driver-to-driver communication.
+// 
+// TODO: incomplete and unused currently
+// 
 VOID Bus_EvtIoInternalDeviceControl(
     _In_ WDFQUEUE   Queue,
     _In_ WDFREQUEST Request,
@@ -344,7 +410,9 @@ VOID Bus_EvtIoDefault(
     UNREFERENCED_PARAMETER(Queue);
     UNREFERENCED_PARAMETER(Request);
 
-    KdPrint((DRIVERNAME "Bus_EvtIoDefault called\n"));
+    TraceEvents(TRACE_LEVEL_INFORMATION, TRACE_QUEUE, "%!FUNC! Entry");
 
     WdfRequestComplete(Request, STATUS_INVALID_DEVICE_REQUEST);
+
+    TraceEvents(TRACE_LEVEL_INFORMATION, TRACE_QUEUE, "%!FUNC! Exit");
 }

sys/buspdo.c

@@ -902,6 +902,6 @@ VOID Pdo_EvtIoInternalDeviceControl(
         WdfRequestComplete(Request, status);
     }
 
-    TraceEvents(TRACE_LEVEL_INFORMATION, TRACE_BUSPDO, "%!FUNC! Exit with status %!STATUS!", status);
+    TraceEvents(TRACE_LEVEL_VERBOSE, TRACE_BUSPDO, "%!FUNC! Exit with status %!STATUS!", status);
 }
 

sys/usbpdo.c

@@ -34,7 +34,9 @@ BOOLEAN USB_BUSIFFN UsbPdo_IsDeviceHighSpeed(IN PVOID BusContext)
 {
     UNREFERENCED_PARAMETER(BusContext);
 
-    KdPrint((DRIVERNAME "UsbPdo_IsDeviceHighSpeed: TRUE\n"));
+    TraceEvents(TRACE_LEVEL_INFORMATION,
+        TRACE_USBPDO,
+        "IsDeviceHighSpeed: TRUE");
 
     return TRUE;
 }
@@ -56,7 +58,10 @@ NTSTATUS USB_BUSIFFN UsbPdo_QueryBusInformation(
     UNREFERENCED_PARAMETER(BusInformationBufferLength);
     UNREFERENCED_PARAMETER(BusInformationActualLength);
 
-    KdPrint((DRIVERNAME "UsbPdo_QueryBusInformation: STATUS_UNSUCCESSFUL\n"));
+    TraceEvents(TRACE_LEVEL_INFORMATION,
+        TRACE_USBPDO,
+        "QueryBusInformation: %!STATUS!", STATUS_UNSUCCESSFUL);
+
     return STATUS_UNSUCCESSFUL;
 }
 
@@ -68,7 +73,10 @@ NTSTATUS USB_BUSIFFN UsbPdo_SubmitIsoOutUrb(IN PVOID BusContext, IN PURB Urb)
     UNREFERENCED_PARAMETER(BusContext);
     UNREFERENCED_PARAMETER(Urb);
 
-    KdPrint((DRIVERNAME "UsbPdo_SubmitIsoOutUrb: STATUS_UNSUCCESSFUL\n"));
+    TraceEvents(TRACE_LEVEL_INFORMATION,
+        TRACE_USBPDO,
+        "SubmitIsoOutUrb: %!STATUS!", STATUS_UNSUCCESSFUL);
+
     return STATUS_UNSUCCESSFUL;
 }
 
@@ -80,7 +88,10 @@ NTSTATUS USB_BUSIFFN UsbPdo_QueryBusTime(IN PVOID BusContext, IN OUT PULONG Curr
     UNREFERENCED_PARAMETER(BusContext);
     UNREFERENCED_PARAMETER(CurrentUsbFrame);
 
-    KdPrint((DRIVERNAME "UsbPdo_QueryBusTime: STATUS_UNSUCCESSFUL\n"));
+    TraceEvents(TRACE_LEVEL_INFORMATION,
+        TRACE_USBPDO,
+        "QueryBusTime: %!STATUS!", STATUS_UNSUCCESSFUL);
+
     return STATUS_UNSUCCESSFUL;
 }
 
@@ -95,7 +106,9 @@ VOID USB_BUSIFFN UsbPdo_GetUSBDIVersion(
 {
     UNREFERENCED_PARAMETER(BusContext);
 
-    KdPrint((DRIVERNAME "UsbPdo_GetUSBDIVersion: 0x500, 0x200\n"));
+    TraceEvents(TRACE_LEVEL_INFORMATION,
+        TRACE_USBPDO,
+        "GetUSBDIVersion: 0x500, 0x200");
 
     if (VersionInformation != NULL)
     {
@@ -241,7 +254,10 @@ NTSTATUS UsbPdo_GetStringDescriptorType(PURB urb, PPDO_DEVICE_DATA pCommon)
         }
         case 1:
         {
-            KdPrint((DRIVERNAME "LanguageId = 0x%X\n", urb->UrbControlDescriptorRequest.LanguageId));
+            TraceEvents(TRACE_LEVEL_VERBOSE,
+                TRACE_USBPDO,
+                "LanguageId = 0x%X",
+                urb->UrbControlDescriptorRequest.LanguageId);
 
             if (urb->UrbControlDescriptorRequest.TransferBufferLength < DS4_MANUFACTURER_NAME_LENGTH)
             {
@@ -269,7 +285,10 @@ NTSTATUS UsbPdo_GetStringDescriptorType(PURB urb, PPDO_DEVICE_DATA pCommon)
         }
         case 2:
         {
-            KdPrint((DRIVERNAME "LanguageId = 0x%X\n", urb->UrbControlDescriptorRequest.LanguageId));
+            TraceEvents(TRACE_LEVEL_VERBOSE,
+                TRACE_USBPDO,
+                "LanguageId = 0x%X",
+                urb->UrbControlDescriptorRequest.LanguageId);
 
             if (urb->UrbControlDescriptorRequest.TransferBufferLength < DS4_PRODUCT_NAME_LENGTH)
             {
@@ -315,11 +334,16 @@ NTSTATUS UsbPdo_SelectConfiguration(PURB urb, PPDO_DEVICE_DATA pCommon)
 
     pInfo = &urb->UrbSelectConfiguration.Interface;
 
-    KdPrint((DRIVERNAME ">> >> >> URB_FUNCTION_SELECT_CONFIGURATION: TotalLength %d\n", urb->UrbHeader.Length));
+    TraceEvents(TRACE_LEVEL_VERBOSE,
+        TRACE_USBPDO,
+        ">> >> >> URB_FUNCTION_SELECT_CONFIGURATION: TotalLength %d",
+        urb->UrbHeader.Length);
 
     if (urb->UrbHeader.Length == sizeof(struct _URB_SELECT_CONFIGURATION))
     {
-        KdPrint((DRIVERNAME ">> >> >> URB_FUNCTION_SELECT_CONFIGURATION: NULL ConfigurationDescriptor\n"));
+        TraceEvents(TRACE_LEVEL_VERBOSE,
+            TRACE_USBPDO,
+            ">> >> >> URB_FUNCTION_SELECT_CONFIGURATION: NULL ConfigurationDescriptor");
         return STATUS_SUCCESS;
     }
 
@@ -329,7 +353,9 @@ NTSTATUS UsbPdo_SelectConfiguration(PURB urb, PPDO_DEVICE_DATA pCommon)
 
         if (urb->UrbHeader.Length < XUSB_CONFIGURATION_SIZE)
         {
-            KdPrint((DRIVERNAME ">> >> >> URB_FUNCTION_SELECT_CONFIGURATION: Invalid ConfigurationDescriptor\n"));
+            TraceEvents(TRACE_LEVEL_WARNING,
+                TRACE_USBPDO,
+                ">> >> >> URB_FUNCTION_SELECT_CONFIGURATION: Invalid ConfigurationDescriptor\n");
             return STATUS_INVALID_PARAMETER;
         }
 
@@ -341,7 +367,9 @@ NTSTATUS UsbPdo_SelectConfiguration(PURB urb, PPDO_DEVICE_DATA pCommon)
 
         if (urb->UrbHeader.Length < DS4_CONFIGURATION_SIZE)
         {
-            KdPrint((DRIVERNAME ">> >> >> URB_FUNCTION_SELECT_CONFIGURATION: Invalid ConfigurationDescriptor\n"));
+            TraceEvents(TRACE_LEVEL_WARNING,
+                TRACE_USBPDO,
+                ">> >> >> URB_FUNCTION_SELECT_CONFIGURATION: Invalid ConfigurationDescriptor");
             return STATUS_INVALID_PARAMETER;
         }
 
@@ -353,7 +381,9 @@ NTSTATUS UsbPdo_SelectConfiguration(PURB urb, PPDO_DEVICE_DATA pCommon)
 
         if (urb->UrbHeader.Length < XGIP_CONFIGURATION_SIZE)
         {
-            KdPrint((DRIVERNAME ">> >> >> URB_FUNCTION_SELECT_CONFIGURATION: Invalid ConfigurationDescriptor\n"));
+            TraceEvents(TRACE_LEVEL_WARNING,
+                TRACE_USBPDO,
+                ">> >> >> URB_FUNCTION_SELECT_CONFIGURATION: Invalid ConfigurationDescriptor");
             return STATUS_INVALID_PARAMETER;
         }
 
@@ -375,16 +405,20 @@ NTSTATUS UsbPdo_SelectInterface(PURB urb, PPDO_DEVICE_DATA pCommon)
 {
     PUSBD_INTERFACE_INFORMATION pInfo = &urb->UrbSelectInterface.Interface;
 
-    KdPrint((DRIVERNAME ">> >> >> URB_FUNCTION_SELECT_INTERFACE: Length %d, Interface %d, Alternate %d, Pipes %d\n",
+    TraceEvents(TRACE_LEVEL_VERBOSE,
+        TRACE_USBPDO,
+        ">> >> >> URB_FUNCTION_SELECT_INTERFACE: Length %d, Interface %d, Alternate %d, Pipes %d",
         (int)pInfo->Length,
         (int)pInfo->InterfaceNumber,
         (int)pInfo->AlternateSetting,
-        pInfo->NumberOfPipes));
+        pInfo->NumberOfPipes);
 
-    KdPrint((DRIVERNAME ">> >> >> URB_FUNCTION_SELECT_INTERFACE: Class %d, SubClass %d, Protocol %d\n",
+    TraceEvents(TRACE_LEVEL_VERBOSE,
+        TRACE_USBPDO,
+        ">> >> >> URB_FUNCTION_SELECT_INTERFACE: Class %d, SubClass %d, Protocol %d",
         (int)pInfo->Class,
         (int)pInfo->SubClass,
-        (int)pInfo->Protocol));
+        (int)pInfo->Protocol);
 
     switch (pCommon->TargetType)
     {
@@ -456,7 +490,10 @@ NTSTATUS UsbPdo_SelectInterface(PURB urb, PPDO_DEVICE_DATA pCommon)
     }
     case DualShock4Wired:
     {
-        KdPrint((DRIVERNAME "Warning: not implemented\n"));
+        TraceEvents(TRACE_LEVEL_WARNING,
+            TRACE_USBPDO,
+            "Not implemented");
+
         break;
     }
     default:
@@ -480,7 +517,9 @@ NTSTATUS UsbPdo_BulkOrInterruptTransfer(PURB urb, WDFDEVICE Device, WDFREQUEST R
 
     if (pdoData == NULL)
     {
-        KdPrint((DRIVERNAME ">> >> >> Invalid common context\n"));
+        TraceEvents(TRACE_LEVEL_ERROR,
+            TRACE_USBPDO,
+            ">> >> >> PdoGetData failed");
         return STATUS_INVALID_PARAMETER;
     }
 
@@ -493,7 +532,10 @@ NTSTATUS UsbPdo_BulkOrInterruptTransfer(PURB urb, WDFDEVICE Device, WDFREQUEST R
         // Check context
         if (xusb == NULL)
         {
-            KdPrint((DRIVERNAME "No XUSB context found on device %p\n", Device));
+            TraceEvents(TRACE_LEVEL_ERROR,
+                TRACE_USBPDO,
+                "No XUSB context found on device %p\n",
+                Device);
 
             return STATUS_UNSUCCESSFUL;
         }
@@ -501,7 +543,9 @@ NTSTATUS UsbPdo_BulkOrInterruptTransfer(PURB urb, WDFDEVICE Device, WDFREQUEST R
         // Data coming FROM us TO higher driver
         if (pTransfer->TransferFlags & USBD_TRANSFER_DIRECTION_IN)
         {
-            KdPrint((DRIVERNAME ">> >> >> Incoming request, queuing...\n"));
+            TraceEvents(TRACE_LEVEL_VERBOSE,
+                TRACE_USBPDO,
+                ">> >> >> Incoming request, queuing...");
 
             if (XUSB_IS_DATA_PIPE(pTransfer))
             {
@@ -585,16 +629,21 @@ NTSTATUS UsbPdo_BulkOrInterruptTransfer(PURB urb, WDFDEVICE Device, WDFREQUEST R
         }
 
         // Data coming FROM the higher driver TO us
-        KdPrint((DRIVERNAME ">> >> >> URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER: Handle %p, Flags %X, Length %d\n",
+        TraceEvents(TRACE_LEVEL_VERBOSE,
+            TRACE_USBPDO,
+            ">> >> >> URB_FUNCTION_BULK_OR_INTERRUPT_TRANSFER: Handle %p, Flags %X, Length %d\n",
             pTransfer->PipeHandle,
             pTransfer->TransferFlags,
-            pTransfer->TransferBufferLength));
+            pTransfer->TransferBufferLength);
 
         if (pTransfer->TransferBufferLength == XUSB_LEDSET_SIZE) // Led
         {
             PUCHAR Buffer = pTransfer->TransferBuffer;
 
-            KdPrint((DRIVERNAME "-- LED Buffer: %02X %02X %02X\n", Buffer[0], Buffer[1], Buffer[2]));
+            TraceEvents(TRACE_LEVEL_VERBOSE,
+                TRACE_USBPDO,
+                "-- LED Buffer: %02X %02X %02X\n",
+                Buffer[0], Buffer[1], Buffer[2]);
 
             // extract LED byte to get controller slot
             if (Buffer[0] == 0x01 && Buffer[1] == 0x03 && Buffer[2] >= 0x02)
@@ -604,7 +653,10 @@ NTSTATUS UsbPdo_BulkOrInterruptTransfer(PURB urb, WDFDEVICE Device, WDFREQUEST R
                 if (Buffer[2] == 0x04) xusb->LedNumber = 2;
                 if (Buffer[2] == 0x05) xusb->LedNumber = 3;
 
-                KdPrint((DRIVERNAME "-- LED Number: %d\n", xusb->LedNumber));
+                TraceEvents(TRACE_LEVEL_INFORMATION,
+                    TRACE_USBPDO,
+                    "-- LED Number: %d\n",
+                    xusb->LedNumber);
             }
         }
 
@@ -613,7 +665,9 @@ NTSTATUS UsbPdo_BulkOrInterruptTransfer(PURB urb, WDFDEVICE Device, WDFREQUEST R
         {
             PUCHAR Buffer = pTransfer->TransferBuffer;
 
-            KdPrint((DRIVERNAME "-- Rumble Buffer: %02X %02X %02X %02X %02X %02X %02X %02X\n",
+            TraceEvents(TRACE_LEVEL_VERBOSE,
+                TRACE_USBPDO,
+                "-- Rumble Buffer: %02X %02X %02X %02X %02X %02X %02X %02X\n",
                 Buffer[0],
                 Buffer[1],
                 Buffer[2],
@@ -621,14 +675,14 @@ NTSTATUS UsbPdo_BulkOrInterruptTransfer(PURB urb, WDFDEVICE Device, WDFREQUEST R
                 Buffer[4],
                 Buffer[5],
                 Buffer[6],
-                Buffer[7]));
+                Buffer[7]);
 
             RtlCopyBytes(xusb->Rumble, Buffer, pTransfer->TransferBufferLength);
         }
 
         // Notify user-mode process that new data is available
         status = WdfIoQueueRetrieveNextRequest(pdoData->PendingNotificationRequests, &notifyRequest);
-        
+
         if (NT_SUCCESS(status))
         {
             PXUSB_REQUEST_NOTIFICATION notify = NULL;
@@ -648,7 +702,10 @@ NTSTATUS UsbPdo_BulkOrInterruptTransfer(PURB urb, WDFDEVICE Device, WDFREQUEST R
             }
             else
             {
-                KdPrint((DRIVERNAME "WdfRequestRetrieveOutputBuffer failed with status 0x%X\n", status));
+                TraceEvents(TRACE_LEVEL_ERROR,
+                    TRACE_USBPDO,
+                    "WdfRequestRetrieveOutputBuffer failed with status %!STATUS!",
+                    status);
             }
         }
 
@@ -662,7 +719,9 @@ NTSTATUS UsbPdo_BulkOrInterruptTransfer(PURB urb, WDFDEVICE Device, WDFREQUEST R
         if (pTransfer->TransferFlags & USBD_TRANSFER_DIRECTION_IN
             && pTransfer->PipeHandle == (USBD_PIPE_HANDLE)0xFFFF0084)
         {
-            // KdPrint((DRIVERNAME ">> >> >> Incoming request, queuing...\n"));
+            TraceEvents(TRACE_LEVEL_VERBOSE,
+                TRACE_USBPDO,
+                ">> >> >> Incoming request, queuing...");
 
             /* This request is sent periodically and relies on data the "feeder"
                has to supply, so we queue this request and return with STATUS_PENDING.
@@ -697,7 +756,10 @@ NTSTATUS UsbPdo_BulkOrInterruptTransfer(PURB urb, WDFDEVICE Device, WDFREQUEST R
             }
             else
             {
-                KdPrint((DRIVERNAME "WdfRequestRetrieveOutputBuffer failed with status 0x%X\n", status));
+                TraceEvents(TRACE_LEVEL_ERROR,
+                    TRACE_USBPDO,
+                    "WdfRequestRetrieveOutputBuffer failed with status %!STATUS!",
+                    status);
             }
         }
 
@@ -751,7 +813,9 @@ NTSTATUS UsbPdo_AbortPipe(WDFDEVICE Device)
         // Check context
         if (ds4 == NULL)
         {
-            KdPrint((DRIVERNAME "No DS4 context found on device %p\n", Device));
+            TraceEvents(TRACE_LEVEL_ERROR,
+                TRACE_USBPDO,
+                "No DS4 context found on device %p\n", Device);
 
             return STATUS_UNSUCCESSFUL;
         }
@@ -779,13 +843,17 @@ NTSTATUS UsbPdo_ClassInterface(PURB urb, WDFDEVICE Device, PPDO_DEVICE_DATA pCom
 {
     struct _URB_CONTROL_VENDOR_OR_CLASS_REQUEST* pRequest = &urb->UrbControlVendorClassRequest;
 
-    KdPrint((DRIVERNAME ">> >> >> URB_FUNCTION_CLASS_INTERFACE\n"));
-    KdPrint((DRIVERNAME ">> >> >> TransferFlags = 0x%X, Request = 0x%X, Value = 0x%X, Index = 0x%X, BufLen = %d\n",
+    TraceEvents(TRACE_LEVEL_VERBOSE,
+        TRACE_USBPDO,
+        ">> >> >> URB_FUNCTION_CLASS_INTERFACE");
+    TraceEvents(TRACE_LEVEL_VERBOSE,
+        TRACE_USBPDO,
+        ">> >> >> TransferFlags = 0x%X, Request = 0x%X, Value = 0x%X, Index = 0x%X, BufLen = %d",
         pRequest->TransferFlags,
         pRequest->Request,
         pRequest->Value,
         pRequest->Index,
-        pRequest->TransferBufferLength));
+        pRequest->TransferBufferLength);
 
     switch (pCommon->TargetType)
     {
@@ -800,7 +868,10 @@ NTSTATUS UsbPdo_ClassInterface(PURB urb, WDFDEVICE Device, PPDO_DEVICE_DATA pCom
             UCHAR reportId = HID_GET_REPORT_ID(pRequest);
             UCHAR reportType = HID_GET_REPORT_TYPE(pRequest);
 
-            KdPrint((DRIVERNAME ">> >> >> >> GET_REPORT(%d): %d\n", reportType, reportId));
+            TraceEvents(TRACE_LEVEL_VERBOSE,
+                TRACE_USBPDO,
+                ">> >> >> >> GET_REPORT(%d): %d",
+                reportType, reportId);
 
             switch (reportType)
             {
@@ -884,7 +955,10 @@ NTSTATUS UsbPdo_ClassInterface(PURB urb, WDFDEVICE Device, PPDO_DEVICE_DATA pCom
             UCHAR reportId = HID_GET_REPORT_ID(pRequest);
             UCHAR reportType = HID_GET_REPORT_TYPE(pRequest);
 
-            KdPrint((DRIVERNAME ">> >> >> >> SET_REPORT(%d): %d\n", reportType, reportId));
+            TraceEvents(TRACE_LEVEL_VERBOSE,
+                TRACE_USBPDO,
+                ">> >> >> >> SET_REPORT(%d): %d",
+                reportType, reportId);
 
             switch (reportType)
             {
@@ -1186,7 +1260,10 @@ NTSTATUS UsbPdo_GetDescriptorFromInterface(PURB urb, PPDO_DEVICE_DATA pCommon)
 
     struct _URB_CONTROL_DESCRIPTOR_REQUEST* pRequest = &urb->UrbControlDescriptorRequest;
 
-    KdPrint((DRIVERNAME ">> >> >> _URB_CONTROL_DESCRIPTOR_REQUEST: Buffer Length %d\n", pRequest->TransferBufferLength));
+    TraceEvents(TRACE_LEVEL_VERBOSE,
+        TRACE_USBPDO,
+        ">> >> >> _URB_CONTROL_DESCRIPTOR_REQUEST: Buffer Length %d",
+        pRequest->TransferBufferLength);
 
     switch (pCommon->TargetType)
     {