rss.livelink.threads-in-node

USB Driver Documentation Updates on UCSI, USB4 Testing

Ugan-Sivagnanenthirarajah — Fri, 27 Feb 2026 00:17:38 GMT

Over the past few months, we've been running a freshness pass across the USB driver documentation on Microsoft Learn and the USB4 design guidelines. The goal is straightforward: make sure the docs match the current Windows 11 driver stack, read clearly, and get you to the answer faster. Here's what changed.

USB4 required testing: new Basic Validation Tests

The USB4 ecosystem has grown significantly. As the number of USB4 router implementations grows, so does the need for a clear, repeatable validation baseline. We added a new Basic Validation Tests section to the USB4 Required Testing page.

The existing page already listed the recommended end-to-end test scenarios: driver verifier, domain power-down, wake replay, interdomain connections, and so on. What was missing was a concise set of smoke tests that OEMs and IHVs could run quickly to catch regressions in incremental USB4 firmware and driver updates without needing a full test pass. The new section fills that gap with nine concrete test scenarios:

USB4 HLK Tests: run all System.Fundamentals.SystemUSB.USB4.* and Device.BusController.USB4.* tests.
Basic Enumeration: attach a USB4 dock and a Thunderbolt 3 dock, each with a display, USB3 storage, and USB2 input. Verify clean enumeration in Device Manager, functional input, file copy, and display extension.
Display: verify two 4K displays at 60 Hz concurrently, both tunneled through a USB4 dock and directly via DisplayPort Alt Mode.
Camera (Isochronous) Streaming: stream from a USB3 camera through a USB4 dock for at least one minute with no visible glitches.
System Standby: attach a full dock topology, cycle standby five times with 30-second to 2-minute waits, and verify all devices survive each transition.
System Reboot: same topology, same verification, but with a full reboot instead of standby.
System Hibernate: same again, with hibernate.
Minimal Compatibility and Interoperability: test at least 3 display models and at least 10 USB4 dock or device models spanning Intel Thunderbolt 4, Intel Thunderbolt 5, Via USB4, Asmedia USB4, Realtek USB4, Intel Thunderbolt 3 Titan Ridge, and Intel Thunderbolt 3 Alpine Ridge.
Basic Plug/Unplug with USB4 Switch: configure the USB4 Switch with a USB4 dock on port 1 and a Thunderbolt 3 dock on port 2, run ConnExUtil.exe /cxstress for a minimum of 15 minutes (24+ hours for long-term stability), then verify the port still enumerates and charges after the test.

Each test includes explicit pass criteria: no yellow bangs, no visual glitches, expected resolution and refresh rates confirmed in the Advanced Display settings. The interoperability test (test 8) is particularly important as USB4 matures: it ensures your platform works across the full range of silicon vendors, not just the one on your bench.

If you're validating USB4 firmware or driver updates and need a quick confidence check before a broader test pass, this is the list to start with.

UCSI driver docs: cleaned up and refocused on Windows 11

The UCSI driver article got a thorough refresh: updated architecture diagram, clearer UCSI 2.0 _DSM backward-compatibility guidance, reformatted UCSIControl.exe test instructions with proper inline code for registry paths, and consistent code-style formatting across the DRP role detection and charger mismatch example flows. We also removed outdated Windows 10 Mobile references so the article now focuses exclusively on Windows 10 desktop and Windows 11.

USB generic parent driver (Usbccgp.sys): plain language rewrite

The Usbccgp.sys article, the starting point for anyone building composite USB devices, was rewritten for clarity. We simplified jargon-heavy sentences, expanded abbreviations on first use (e.g., "information (INF) file"), updated cross-references to sentence case per the Microsoft Learn style guide, and added customer-intent metadata for better search discoverability.

Community fix: interrupt endpoint direction

Here's a small one that matters more than it looks. In the How to send a USB interrupt transfer (UWP app) article, the Interrupt IN transfers section incorrectly stated that HID devices like keyboards "support interrupt OUT endpoints." Endpoint direction is fundamental (IN means device-to-host, OUT means host-to-device) and getting that wrong in official documentation can send you down entirely the wrong debugging path.

A community contributor spotted the error and submitted the fix. It now correctly reads "interrupt IN endpoints." If you've ever stared at a USB trace wondering why your interrupt transfer wasn't behaving, this might have been part of the confusion.

Thank you to everyone who submits pull requests. This is exactly the kind of contribution that makes the docs better for all of us.

What's next

These updates are part of a broader freshness initiative across the Windows Hardware driver documentation.

If you spot something that looks outdated or confusing, our documentation is open source. Submit a PR on the windows-driver-docs GitHub repository. You can also drop a comment below.

WINDOWS MEDIA CREATION TOOL SEVERELY LIMITS YOUR USB FLASH DRIVE

IDAnnoyed55 — Sun, 30 Nov 2025 00:16:10 GMT

I have been having ZERO luck at creating a Recovery Drive on my Win 11 laptop.

So I tried the Windows Media Creation Tool.

It converted my 126 GB USB flash drive to a USELESS 31.9 GB drive. After using up a lot of space for inbuilt files, it reduced to far less capacity. THERE WAS NO WARNING ON THE MICROSOFT WEBSITE THAT THIS WOULD HAPPEN.

Microsoft claimed "Installation media, such as a USB flash drive, can be used to install a new copy of Windows, perform a clean installation of Windows, or reinstall Windows." https://support.microsoft.com/en-au/windows/create-installation-media-for-windows-99a58364-8c02-206f-aa6f-40c3b507420d

The Media Creation Tool didn't have the sense to leave a FULL 32 GB or more free.

So my expensive 126 GB flash drive has been converted to a far less item and it's NOT EVEN GOOD ENOUGH TO create a Recovery Drive.

COMPLAINT TO MICROSOFT:

(1) Why didn't the Tool leave my USB flash drive at over at least 100 GB?

(2) Why no warning on what would happen?

RECOVERY DRIVE FOR WINDOWS 11

IDAnnoyed55 — Sat, 29 Nov 2025 23:48:45 GMT

After creating a System Image, the system next asks if you want to create a System Repair Disk, but demands that you have a CD / DVD drive. I have that and have tried to create a System Repair Disk on brand new, fresh out of the box CDs and DVDs and it just won’t work.

So I’ve been trying to create a Recovery Drive for Windows 11, and have tried using various USB flash drives of sizes 32 GB and 128 GB. The flashes are not being recognised and the message is to use a USB Flash of at least 32 GB. A whopping 128 GB and still not good enough!

I have also tried USB flashes of the formats FAT32, exFAT and NTFS. Still can’t create a Recovery Drive. Ditto flashes that are USB 3.1 Gen 1 and the more basic/older USB 3.0. And yes, I’ve tried the various ports on my laptop.

Additionally I tried a FAT32 flash drive 32 GB that has previously been acceptable for creating a recovery drive – fresh out of the packet. But now it won’t do a Recovery Drive – even after I have used Format to clear it.

It seems ridiculous that the Recovery Drive process demands a flash of “at least” 32GB when USB 32 GB flash drives are NOT a full 32 GB free. After inbuilt system files, they only have a capacity of about 28.7 GB. AND does not recognise higher capacity flash drives.

The only thing I’ve been able to create is a “Recovery Drive” on a FAT32 USB flash, where I DESELECTED “include system files to reinstall Windows”. But then this really worries me that I don’t have those system files.

I am extremely concerned that I now don’t have an up-to-date Recovery Drive.

NOTES TO MICROSOFT: (1) Don’t state that you can create System Repair Disks on CDs and/or DVDs when you cannot. (2) Please make the Recovery Drive process FAR more straightforward so that it actually works.

HELP: Why can’t my Windows 11 laptop create a Recovery Drive including the system files to reinstall Windows? It shouldn’t be as impossible as I’m now finding.

HELP: How do I set up a Recovery Drive. What flash drive, size and format is to be used?

Exploring USB4 in Windows Device Portal

Ugan-Sivagnanenthirarajah — Thu, 27 Nov 2025 02:25:37 GMT

Overview
USB4™ brings high-speed connectivity and advanced tunneling capabilities to modern Windows devices. To help developers and IT professionals visualize and manage USB4 topologies, Windows provides the USB4 domain viewer via the Windows device portal.

A demo of USB4 Domain Viewer in Windows Device Portal.

Key Features of the USB4 Domain Viewer

Topology Visualization
- Displays USB4 host routers (in green) and device routers (in blue).
- Supports click-and-drag navigation and zooming for detailed inspection.
- Automatically updates as the topology changes.
Host Router Details
- Each host router includes Name, VendorId, and DeviceId.
- Selecting a router reveals additional details in the sidebar.
Device Router Details
- Shows adapters and ports, distinguishing in-use adapters from unused ones.
- Selecting an adapter highlights it with a red circle for quick identification.
Tunnel Visualization
- Tunnels between device routers are illustrated clearly.
- Each tunnel uses a colon-separated unique ID (e.g., 8:1:1:9) for easy reference.
Context-Specific Sidebar
- Updates dynamically based on selected elements (routers, adapters, tunnels).
- Allows collapsing or expanding details for streamlined viewing.

A Legend of the different areas of USB4 Domain Viewer

Why It Matters

The USB4 Domain Viewer simplifies troubleshooting and topology analysis for OEMs, IHVs, and developers. By providing real-time visualization and granular details, it accelerates debugging and ensures compliance with USB4 standards.

Getting Started

Access the USB4 Domain Viewer through the Windows Device Portal on supported devices. For more details, visit the official Microsoft Learn documentation.

© 2025 Microsoft. USB4®, USB Type-C® and USB-C®, USB 2.0 Type-C™ are registered trademarks of USB Implementers Forum, Inc. Thunderbolt™ is a trademark of Intel Corporation. This article is not endorsed by or affiliated with USB-IF.

USB 128GB flash drive only works in Win 10 safe mode--not normal Win 10 mode

rrkrrk99 — Fri, 03 Oct 2025 00:05:38 GMT

I have a Lexar 128GB flash drive that only works properly in Win 10 safe mode on my two Win 10 desktop machines. In normal Win 10 the flash drive, when inserted, shows up for roughly 3 - 5 seconds in File Explorer (and the PC dings that an external device was inserted), then the flash drive disappears from File Explorer and doesn't appear in Disk Management anymore. The Windows Explorer message "USB device not recognized" keeps appearing. Other flash drives of different make and sizes work fine in the normal Win 10 of both my Win 10 PCs. So it must be just this particular flash drive for a reason I can't figure out. I have watched countless YouTube videos on getting your flash drive recognized and nothing I've tried works. I've disabled my Norton 360 and that didn't help. Wondering if anyone can think of an new way to get this flash drive to work in normal Win 10? Again, tried all kinds of recommended things in YouTube videos and articles--in Disk Management, Disk Manager, CMD prompt, DiskPart, Windows PowerShell, disabled Norton 360, talked to Lexar tech support (told me to talk to Microsoft), reformatted the drive in multiple ways, disabled USB Selective Suspend settings, used Rufus to format in nonbootable mode, and through one of the attempts (maybe the attrib -h -s -r /s /d *.* command) found autorun.inf and autorun.ico on the drive and deleted those. The crazy part is it works perfectly fine in safe mode, but is only briefly recognized before disappearing in normal Win 10. Thanks in advance for any ideas!

USB Type-C Notifications in Windows: What OEMs Need to Know

Ugan-Sivagnanenthirarajah — Fri, 29 Aug 2025 23:00:00 GMT

Windows 11 includes built-in USB Type-C troubleshooting notifications designed to help users identify and resolve issues like slow charging, unsupported accessories, and faulty connections. These notifications are part of a broader effort to improve device reliability and user experience.

While our previous post focused on the user experience, this update is for OEMs highlighting what’s required to ensure these notifications function correctly on your platforms.

Why Notifications Might Not Appear

USB Type-C notifications rely on accurate platform configuration. If notifications aren’t showing up, it’s often due to:

Missing or incorrect ACPI markup: Windows uses ACPI descriptors to identify USB Type-C ports and their capabilities. If the port isn’t correctly marked as user-accessible or Type-C, notifications may not trigger.
Incorrect connector type reporting: Mislabeling a Type-A port as Type-C (or vice versa) can lead to unexpected behavior or missed alerts.
Internal vs. external port confusion: Ports marked as internal may suppress notifications even if they’re physically accessible to users.

Validation and Testing

To ensure compatibility:

Use the Windows Hardware Lab Kit (HLK) to validate USB port descriptors.
Confirm that _UPC (USB Port Capabilities) and _PLD (Physical Location of Device) ACPI methods are correctly implemented.
Test with various charging scenarios, including underpowered chargers and hubs, to verify that notifications appear as expected. The link below has a table of the notifications and expected behaviours.

Security Considerations

Some OEMs may choose to disable data over USB Type-C in untrusted environments. If implementing such features:

Ensure the policy applies only to externally accessible ports.
Consider offering user toggles for data disablement.
Validate that disabling data doesn’t interfere with critical internal devices (e.g., touchpad, keyboard).

Recommendations for OEMs

Audit ACPI descriptors and USB Device-Specific Method for all USB ports. See https://learn.microsoft.com/en-us/windows-hardware/drivers/bringup/usb-device-specific-method---dsm-#function-7-query-if-_upc-supports-usb-c-port-capabilities-as-defined-in-acpi-specification-65
Validate notification behavior across all supported configurations.
Coordinate with Microsoft WHCP to ensure new platforms meet testing requirements.
Document exceptions clearly if certain ports or configurations are unsupported.

Learn More

For technical details and troubleshooting guidance, refer to the official documentation:
https://learn.microsoft.com/windows-hardware/drivers/usbcon/usb-type-c-troubleshooting-notifications

USB Camera fails to initialize on startup

TiONSewm — Tue, 05 Aug 2025 01:17:14 GMT

Current setup:
- Tablet with a Windows 10 IoT Enterprise image
- Application communicates to a USB camera on startup
- Application setup with as the custom shell (instead of explorer.exe)
- USB camera uses the pre-installed usbvideo.sys driver.

Issue:
I have an issue with a USB camera video system that is permanently connected to a tablet (via an internal USB hub). On some tablets the camera is correctly initialized and the application can see a video stream but on others it does not initialize. Only by manually re-installing the drivers via device manager does it seem to fix it. In some cases, the tablet ends up failing again and the drivers need to be re-installed again. What could be the issue and how could I fix it? Does this happen to anyone else?

Ending USB-C® Port Confusion

Ugan-Sivagnanenthirarajah — Tue, 23 Sep 2025 22:58:46 GMT

The Blank Display (and Why It Can Still Happen)

Five minutes before a customer demo, I plug my 4K monitor into the USB-C port on a brand-new laptop. The display doesn’t light up, and now I’m scratching my head—the cable fit, so why isn’t it working?

USB4® carries the promise of a single USB Type-C® port that can do it all – charging, high speed data, multiple displays, and compatibility with Thunderbolt™ peripherals. However, Windows Diagnostics Data shows that 27% of PCs with USB4 have encountered a limited functionality notification, meaning that a customer plugged a USB-C device in, but a feature (alternate mode) that device needs was not implemented on the PC and Windows notified the user. The reversible USB Type-C connector isn’t the problem, the inconsistent implementations of USB-C port capabilities across the PC ecosystem is.

USB Power Delivery on USB-C ports can deliver up to 240 W of power, and USB4 (which is only available over USB-C) can deliver up to 80Gbps bandwidth (up to 120Gbps for Displays), DisplayPort Alt Mode, DisplayPort and PCIe tunneling, and support for Thunderbolt™ peripherals – all through one connector. But the promise of 'universal' in Universal Serial Bus (USB) only matches user expectations if every port delivers a consistent experience, regardless of laptop manufacturer implementation choices.

So why does the demo fail? Because not all USB-C ports are created equal. You can’t tell which ones deliver the full experience just by looking at them. In this case, if the PC doesn’t support DisplayPort Alternate Mode functionality, that monitor won’t light up even though the cable fits. PC manufacturers can implement ports that look identical but differ wildly in functionality: one may charge your laptop and run a 4K display; another might only deliver USB 2.0 data speeds. The USB specification allows this, and without clear enforcement, the consumer experiences frustration, guesswork, and endless troubleshooting.

This isn’t new. As USB specification versions have evolved and added new capabilities, the complexity has sometimes left consumers in the dark, especially when ports aren’t labeled clearly. Most people don’t know what “USB 3.2 Gen 2x2” means or which port supports what features. That’s why we’re pleased to see the USB-IF introduce simpler, clearer branding guidelines like “USB 40Gbps” and “USB 80Gbps”, making it much easier for everyone to understand exactly what each port can do.

We think it’s important for this clear branding to carry through to the actual customer experience with USB-C ports on Windows 11 PCs. While the USB specifications give PC manufacturers the ability to choose which optional features the port supports, we set out to establish a minimum bar for USB-C port capabilities on PCs.

Figure 1 Table of the capabilities required by WHCP for mobile Windows systems

The Windows Hardware Compatibility Program (WHCP) comes in to turn this table into reality – turning optional features into mandatory ones, and ensure a consistent level of performance you can count on. The table above reflects what you can reliably expect from USB-C ports on WHCP-certified mobile PCs.

Some USB 40Gbps and USB 80Gbps ports on Windows 11 PCs are also certified by Intel under the Thunderbolt™ brand, allowing them to be labeled as Thunderbolt™ 4 or Thunderbolt™ 5, respectively. You can rest assured that Thunderbolt™-branded ports meet all the rigorous requirements of both Microsoft’s WHCP program and Intel’s Thunderbolt™ program. Additionally, to qualify to use the Thunderbolt™ brand from Intel, the product must first be certified by the USB-IF.

Two Firm Promises of USB-C on Windows 11

When we set out to improve the USB-C experience with WHCP, we started by defining the customer promises that we wanted to achieve. This came down to two simple goals:

USB Data, Charging and Display “just works” on all USB-C ports: Your favorite USB 1, USB 2, and USB 3 peripherals, chargers and displays will work exactly as advertised on any USB-C port on your WHCP-certified Windows 11 device.

Systems that support USB 40Gbps also give full compatibility with USB4 and Thunderbolt™ 3 peripherals: On a WHCP-certified USB 40Gbps system, you can also plug in any USB4 or Thunderbolt™ 3 device and trust it will work every time on every port.

To ensure that certified Windows 11 PCs deliver on these goals, we introduced new and updated WHCP requirements alongside the release of Windows 11, version 24H2, that are laser focused on them.

What every USB-C port needs to nail WHCP compliance

All mobile systems with USB-C ports

Meeting our first customer promise, that USB Data, Charging and Display “just works” on all USB-C ports, requires any WHCP compliant mobile PC with USB-C to support a baseline set of requirements. No matter what speeds your USB-C ports support, every port can be expected to deliver the following:

You can trust that your devices will work flawlessly, avoiding the frustration of unreliable connections, as we require USB-IF certified silicon in the PC. This guarantees that every connection is robust and reliable through USB-IF certification or equivalent electrical compliance, rigorously tested for compatibility in a lab.

Your devices will charge efficiently and consistently as every USB-C port on a certified PC needs to support USB Power Delivery charging.

DisplayPort Alt-Mode is required for all USB-C ports to support connecting monitors. When you plug a display in, you can feel confident it will work well because the ports have to be VESA certified.

The Microsoft driver stack requirement means PCs are validated using Microsoft’s built-in USB controller drivers. This ensures that security and feature updates arrive via Windows Update, keeping your system secure and up-to-date without any hassle.

All Mobile Systems Advertising USB 40Gbps or 80Gbps Support

WHCP qualified systems with USB 40Gbps or 80Gbps also deliver the second customer promise, full compatibility with USB4 and Thunderbolt™ 3 peripherals, ensuring top-tier performance and compatibility:

This ensures lightning-fast data transfers, making large file transfers and high-speed internet connections a breeze. Baseline bandwidth means every certified Windows 11 PC advertising USB 40Gbps must sustain full speed 40Gbps links on all USB-C ports.

To enable you to expand your system’s capabilities without any compatibility issues, we require PCI Express tunnelling that allows external GPUs and NVMe enclosures to work seamlessly because host routers tunnel PCIe on every port.

You can continue using your favorite peripherals without any interruptions as we require Thunderbolt™ compatibility ensures that existing Thunderbolt™ docks remain plug and play.

DisplayPort requirements ensure support for up to two 4K monitors at 60Hz, providing a stunning visual experience for your work and entertainment.

Finally, sleep and resume resilience ensures that host routers survive low-power states without dropping tunnels. This means your system remains reliable and connected, even when it’s in sleep mode.

WHCP eliminates the worry of powering devices you plug-in by requiring uniform port power requirements ensures that each USB 40Gbps port sources at least 15 W (7.5 W on tablets). Note: USB4 ports on the system must support sourcing at 15W from all ports but not all at the same time. Tablet form factor systems are not required to support 15W but must support at least 7.5W. Systems may limit individual port power below 15W when total requested power across multiple ports exceeds the system’s power budget.

WHCP already covers the next spec bump. Any PC that advertises USB 80 Gbps must meet all the above requirements, while also supporting operation in symmetric 80 / 80 Gbps mode and asymmetric 120 / 40 Gbps mode for increased display bandwidth.

How we enforce it: The Hardware Lab Kit

That “it just works” moment isn’t magic; it’s the result of a tightly choreographed process:

Translate Pain into Policy
We reflect on user feedback, telemetry, and field failures—like the left-port-only monitor issue—and convert each into a discrete WHCP requirement with acceptance criteria.
Author Automated Tests
Our team writes reproducible, automated Windows Hardware Lab Kit (HLK) test cases for every requirement: signaling timing, speed negotiation, power delivery, DisplayPort/PCIe tunnels, sleep/resume resilience, and more.
Partner-Led Validation
OEMs, silicon vendors, and accessory brands run these HLK tests and submit logs to Microsoft. Any failure halts certification until the issue is resolved in hardware or firmware.
Continuous Evolution
WHCP updates with every Windows release. New tests and criteria flow via Windows Update—so fixes and feature enhancements reach end users without new hardware.

Learn how to run HLK tests and meet the USB4 requirements at aka.ms/whcp

If You’re an OEM or Accessory Maker

Robust USB on Windows requires end-to-end testing—protocol compliance, signal integrity, power negotiation and security—and Microsoft’s USB Test Tool (MUTT) suite of hardware and automated scripts streamlines WHCP certification. Download MUTT and dive into the full device-, silicon-, and system-level requirements (including test collateral) for USB4 on Microsoft Learn:

MUTT suite: https://learn.microsoft.com/windows-hardware/drivers/usbcon/microsoft-usb-test-tool--mutt--devices

USB4 requirements: https://learn.microsoft.com/windows-hardware/design/component-guidelines/usb4-required-testing

PC manufacturers are on track to achieve WHCP compliance across most systems in the coming years.

© 2025 Microsoft. USB Type-C® and USB-C®, USB 2.0 Type-C™ are registered trademarks of USB Implementers Forum, Inc. Thunderbolt™ is a trademark of Intel Corporation. This article is not endorsed by or affiliated with USB-IF.

Discover USB Settings and Notifications in Windows 11

Ugan-Sivagnanenthirarajah — Fri, 28 Feb 2025 23:38:59 GMT

USB 40Gbps (also known as USB4) is the latest USB standard, offering faster data transfer speeds, improved power delivery, and better performance. The second revision, USB 80Gbps, (also known as USB4 V2) doubles the maximum data transfer rate to 80Gbps and supports 120Gbps in certain configurations, ensuring faster file transfers and enhanced video output. The benefits include full backwards compatibility with all USB peripherals, compatibility with Thunderbolt peripherals, and support for multiple DisplayPort streams.

USB4's tunneling technology efficiently transfers multiple data and display protocols over a single cable, making it ideal for high-performance applications. The USB4 settings page in Windows 11 provides a centralized location for users to view and manage their USB4 hubs and devices, simplifying the user experience and ensuring optimal performance. This blog post introduces the new USB4 settings page and provides an overview of the various USB settings available in Windows 11.

How can Windows help me with USB?

Windows has features that make using USB devices easy and user-friendly. It handles things like device power management automatically and lets you know if there’s an error. You can tweak these settings in USB Settings. While most users won’t need to change anything, this blog post will help you understand why some of these settings exist. Here are the details.

The options that show under the Windows 11 USB Settings page

Connection Notifications

We’ve designed Windows 11 to be your vigilant assistant, notifying you if there’s an issue connecting a USB device. This feature ensures you’re always in the know and can take immediate action. This lets Windows notify you when it detects a problem with a USB connection. You can learn more about the specific notifications that Windows sends, and what you can do in response to them here: https://support.microsoft.com/windows/fix-usb-c-problems-in-windows-f4e0e529-74f5-cdae-3194-43743f30eed2

Show a notification if this PC is charging slowly over USB

Did you know? Using an incompatible charger can slow down your PC’s charging speed. Always use the charger that supports the required power levels for your PC the fastest charging. This setting lets Windows notify you when your PC’s hardware indicates that it is charging slowly over USB. This could be due to a number of reasons:

The charger isn’t compatible with your PC.
The charger isn’t powerful enough to charge your PC.
The charger isn’t connected to a charging port on your PC.
The charging cable isn't powerful enough for the charger or PC.
Dust or dirt inside the USB port on your device prevented the charger from being inserted correctly.
The charger is connected through an external hub or dock.

You can resolve it by using making sure your charger and cable also support the power levels your PC requires for the faster charging. For example, if your PC requires 12V and 3A for the fastest charging, a 5V, 3A charger won’t give you the fastest charging.

USB Battery Saver

The USB battery saver is a feature designed to help conserve power by stopping USB devices that do not power down by themselves when the system enters standby. Most USB devices are well behaved and tend to power down or suspend when the system enters modern standby. When the feature is enabled, the USB bus will temporarily eject misbehaving devices (i.e. those that do not suspend) for the duration of the standby session. Not doing so would prevent the system from entering a low power standby state and significantly reduce battery life. Hence, this is particularly useful for extending battery life on devices that are battery-powered and support modern standby. When the USB battery saver is on, it prevents unnecessary battery usage from high-power-consuming USB devices by stopping them when the screen is off.

However, some older USB peripherals may have compatibility issues with low-power states, which is why the option to turn off the USB battery saver exists. Turning it off can have a significant impact on the system's battery life, as it may prevent the system from fully going to standby due to some USB devices still running.

Caution: Microsoft strongly recommends leaving the feature in its default-on enabled state.

USB4 Hubs and devices

Imagine plugging in your USB4 device and instantly accessing a world of faster data transfer and improved power delivery. If your PC supports USB4, here’s what you can expect to see in your settings. C This page is intended to give users insights into their system and device/dock’s USB4 capabilities. It is also meant to support IT administrators and /or customer-support channels when troubleshooting certain problems. (Note: The page is designed to only show USB4 and Thunderbolt 3 devices/hubs attached to your system. If you do not see a device here, it indicates that you do not have a USB4 hub/device attached or that the device operating is not operating in USB4 mode.). Here’s an example of this page:

The USB hubs and devices pages provide useful information on your USB4 devices.

How do I adjust USB settings?

You can manage USB Settings on any Windows 11 device by opening the Settings app, and navigating to Bluetooth & devices > USB.

How do I know which USB Settings are available?

The following settings are available on all PCs:

Connection notifications: Show a notification if there are issues connecting a USB device
USB battery saver: Stop USB devices when my screen is off to help save battery

If your PC supports charging over a USB-C port you will see the following option:

Show a notification if this PC is charging slowly over USB

If your PC is a mobile system that supports USB you will see the following Settings available when using USB4 devices on a PC with USB4 ports):

USB4 hubs and devices

Conclusion

At the end of the day, our goal is to make USB technologies in Windows seamless and intuitive. We hope this blog post has given you a glimpse into the thought and care we put into every feature, making your experience as smooth as possible. While we don’t expect most users to have to tinker with their USB Settings, we hope this blog post gave you some useful insights into the motivation behind some of the USB settings.

USB Audio 2.0 Mixer Unit control

Myrmidon — Tue, 12 Apr 2022 10:00:04 GMT

Hi,

I am developing a USB audio 2.0 (UAC2) device.

This device has a USB mixer unit (as defined by the usb audio 2.0 standard) and I was wondering how I can control/set it with the default usbaudio2.sys driver?

According to the official docs:

https://docs.microsoft.com/en-us/windows-hardware/drivers/audio/usb-2-0-audio-drivers

I should be able to send a SET request to a mixer unit with the default drivers.

I extracted some logs from the usbaudio2.sys driver and can see that it recognizes the Mixer unit:

USBAudio2] MixerUnit ID=0x50 'MY MIXER'
[2]0004.29B0::04/11/2022-15:46:32.392 [USBAudio2] Controls=0x0001
[2]0004.29B0::04/11/2022-15:46:32.392 [USBAudio2] NumInputPins=1
[2]0004.29B0::04/11/2022-15:46:32.392 [USBAudio2] [0] --> SourceID=0x20 'USB AUDIO DEMO' InputChannelCount=2
[2]0004.29B0::04/11/2022-15:46:32.392 [USBAudio2] OutputChannelCount=2
[2]0004.29B0::04/11/2022-15:46:32.392 [USBAudio2] AudioChannelCluster: NrChannels=2 ChanConfig=0x00000003 FirstStringIndex=0 NumStrings=0
[2]0004.29B0::04/11/2022-15:46:32.392 [USBAudio2] NumInputPins=1 TotalNumInputChannels=2 NumOutputChannels=2
[2]0004.29B0::04/11/2022-15:46:32.392 [USBAudio2] Mixer Controls:
[2]0004.29B0::04/11/2022-15:46:32.392 [USBAudio2] MCN 0 PROGRAMMABLE min=-18176 (0xb900) max=0 (0x0000) res=256 (0x0100)
[2]0004.29B0::04/11/2022-15:46:32.392 [USBAudio2] MCN 1 PROGRAMMABLE min=-18176 (0xb900) max=0 (0x0000) res=256 (0x0100)
[2]0004.29B0::04/11/2022-15:46:32.392 [USBAudio2] MCN 2 PROGRAMMABLE min=-18176 (0xb900) max=0 (0x0000) res=256 (0x0100)
[2]0004.29B0::04/11/2022-15:46:32.392 [USBAudio2] MCN 3 PROGRAMMABLE min=-18176 (0xb900) max=0 (0x0000) res=256 (0x0100)

I can also see GET requests for this mixer unit in the logs on my device so the windows usb audio2 driver does seem to recognize it and the min/max/res above are indeed the ones I programmed.

I can confirm that I can control the mixer unit from a Linux machine through alsamixer but would like to be able to do this from a Windows PC as well (preferably with the default driver since it has support for it). I don't see anything in the default sound control panel window or anything to actually control a mixer unit?

Thanks for any info!

Enumerated USB Audio CODEC

EEByDesign — Sat, 15 Jan 2022 12:42:06 GMT

In Windows 10 (and I assume 7 and earlier) if I plug a USB hardware device into several different USB ports on my computer running Windows 10, a new enumeration results even though the same driver is used. Example; if I plug the hardware into my computer's left most USB port on the front panel the hardware is enumerated as USB Audio CODEC. When I plug the same hardware into my computer's right most USB port on the front panel the hardware is enumerated as USB- 1 USB Audio CODEC. The saga continues especially when using USB hubs and the enumeration could easily get to be double digit enumeration names. 3rd party software that uses this hardware depends on seeing consist naming of the hardware that is plugged in, so the user must go to the software setup section and verify the correct hardware is selected in case the hardware was plugged into a different USB port on the computer.

I'd like to be able to wipe the USB enumeration table from my Windows 10 installation since I've now decided what exact USB port the hardware will always be connected to (so the only enumeration name would be USB Audio CODEC). The Microsoft Community (non tech) suggested I use the USBDeview utility to delete the table. I have tried that and it did not work. As a test I deleted the last two enumerated devices; USB- 8 Audio CODEC and USB- 9 Audio CODEC from the list, rebooted. I then plugged the hardware into a new USB port on my computer, the OS enumerated the hardware as USB- 10 Audio CODEC.

Is there a way to fix this issue or should I just live with the problem? Is there a limit to the number of enumerated names?

Regards,

Steve

High speed USB printer device communication issue on WINDOWS 11

JasonNotMe — Fri, 14 Jan 2022 06:04:14 GMT

I encountered an issue that windows 11 keeps enumerating the high speed usb printer based on LPC546 mcu, until the OS switched to full speed mode and the enumeration successed. I used ellisys USB protocol analyzer to capture the enumeration process, the result shows as the picture below. It's wired that the OS suspended the device after getting device ID, and resumed and started over the enumeration multiple times until the OS enumerated in full speed mode.

I tested the same printer on WINDOWS 10, and it worked perfectly in high speed mode.

So, does anyone have encountered the same problem and solution to it, please tell me.

Much appreciate!!

Jason

winusb driver - isochronous endpoint not working

BorisW560 — Thu, 25 Nov 2021 07:42:27 GMT

We have a usb device that working with our WDM driver written about 15 years ago .

It works on Windows XP to Windows 10 32 and 64 bit.

Device sends analog data of 2 bytes every 1ms to PC ( Data sample rate = 1000)

I tried to switch working with Microsoft winusb driver in Windows 10.

Driver installed OK;

I write some wrapper code (So my Application will work as is) to use winusb driver on

isochronous pipe streaming and get very strange behave ...

I am missing packets , on All empty packets i get Status of USBD_STATUS_ISO_NOT_ACCESSED_BY_HW

USBD_STATUS_ISO_NOT_ACCESSED_BY_HW

Extended isochronous error codes returned by USBD.
These errors appear in the packet status field of an isochronous transfer. [0xC0020000]
For some reason the controller did not access the TD associated with this packet:

/* ----- IF Using WinUSB.sys driver --------------- */ #ifdef USE_WINUSB_DRIVER #include <tchar.h> #include <strsafe.h> #include <winusb.h> #include <usb.h> #include <cstdlib> #include <initguid.h> #include <cfgmgr32.h> #include <combaseapi.h> // // Device Interface GUID. // Used by all WinUsb devices that this application talks to. // Must match "DeviceInterfaceGUIDs" registry value specified in the INF file. // yyyyyy-yyyy-yyyy-xxxx-yyyyyyyy // DEFINE_GUID(GUID_DEVINTERFACE_ECGUSB1, 0xyyyyyyyy, 0xyyyy, 0xyyy, 0xxx, 0xxx, 0xyy, 0xyy, 0xyy, 0xyy, 0xyy, 0xyy); #define ISOCH_DATA_SIZE_MS 10 #define ISOCH_TRANSFER_COUNT 2 //will need to be at least 2 /* * My device sends one sample of 2 bytes every 1ms .. => data sample rate = 1000s/s * * Problem !! * Only Transfer 1 has the data all next (ISOCH_TRANSFER_COUNT) are empty * As a result i see data arriving at sample rate of 1000 / ISOCH_TRANSFER_COUNT in Read application * * Why ????? * nvUSB.lib: Current Frame number=261744397 nvUSB.lib: bRead() Requested 1200 bytes in 50 packets per transfer. nvUSB.lib: bRead() Transfer 1 completed. Read 100 bytes. nvUSB.lib: Current Frame number=261744447 nvUSB.lib: bRead() Requested 1200 bytes in 50 packets per transfer. nvUSB.lib: bRead() Transfer 2 completed. Read 0 bytes. <-- ?? nvUSB.lib: Current Frame number=261744497 nvUSB.lib: bRead() Requested 1200 bytes in 50 packets per transfer. nvUSB.lib: bRead() Transfer 1 completed. Read 100 bytes. nvUSB.lib: Current Frame number=261744547 nvUSB.lib: bRead() Requested 1200 bytes in 50 packets per transfer. nvUSB.lib: bRead() Transfer 2 completed. Read 0 bytes. <--- ?? nvUSB.lib: Current Frame number=261744597 nvUSB.lib: bRead() Requested 1200 bytes in 50 packets per transfer. nvUSB.lib: bRead() Transfer 1 completed. Read 100 bytes. nvUSB.lib: Current Frame number=261744647 nvUSB.lib: bRead() Requested 1200 bytes in 50 packets per transfer. nvUSB.lib: bRead() Transfer 2 completed. Read 0 bytes. nvUSB.lib: Current Frame number=261744697 */ typedef struct _PCECG_PIPE_INFORMATION_EX { USBD_PIPE_TYPE PipeType; UCHAR PipeId; USHORT MaximumPacketSize; UCHAR Interval; ULONG MaximumBytesPerInterval; int index; } PCECG_PIPE_INFORMATION_EX, * PPCECG_PIPE_INFORMATION_EX; struct PIPE_ID { // Note: // Each USB device can define up to 32 endpoints(16 inputs and 16 outputs though one must be a control endpoint) // Here i assume that we will use maximum 2 for each type.. PCECG_PIPE_INFORMATION_EX Bulk_Pipe[2]; // [0] -for IN type ; [1] -for OUT type PCECG_PIPE_INFORMATION_EX Int_Pipe[2]; PCECG_PIPE_INFORMATION_EX Iso_Pipe[2]; }; typedef struct _RING_BUFFER { PUCHAR buffer; PUCHAR inPtr; PUCHAR outPtr; SIZE_T totalSize; SIZE_T currentSize; KSPIN_LOCK spinLock; SIZE_T Size; PUCHAR Base; PUCHAR End; PUCHAR Head; PUCHAR Tail; } RING_BUFFER, * PRING_BUFFER; class CUsbPCECGHelper { public: // constructor CUsbPCECGHelper(); // destructor virtual ~CUsbPCECGHelper(); BOOL GetDeviceHandle(GUID guidDeviceInterface, PHANDLE hDeviceHandle); BOOL GetWinUSBHandle(HANDLE hDeviceHandle, PWINUSB_INTERFACE_HANDLE phWinUSBHandle); BOOL GetUSBDeviceSpeed(WINUSB_INTERFACE_HANDLE hDeviceHandle, UCHAR* pDeviceSpeed); BOOL QueryDeviceEndpoints(WINUSB_INTERFACE_HANDLE hDeviceHandle, PIPE_ID* pipeid); void ClearIsobuffers(void); void ClearDeviceHandles(void); void ClearThreadHandles(void); DWORD StartThreadHandles(void); HANDLE m_hDeviceHandle ; WINUSB_INTERFACE_HANDLE m_hWinUSBHandle[2]; PIPE_ID PipeID; DRIVER_VERSION drvver; BOOL RealTimeInProgress; ULONG IsochInTransferSize; ULONG IsochInPacketCount; PUCHAR readBuffer; LPOVERLAPPED overlapped; WINUSB_ISOCH_BUFFER_HANDLE isochReadBufferHandle; PUSBD_ISO_PACKET_DESCRIPTOR isochPacketDescriptors; //reading execution thread handle HANDLE m_hEventThread; //event handle to close execution thread HANDLE m_hCloseThread; //event handle for read HANDLE m_hReadAsync[ISOCH_TRANSFER_COUNT]; DWORD m_dwInterval; BOOL m_bResult; DWORD ReadIsoBuffer(DWORD eventIndex); // Data Event thread procedure. static DWORD WINAPI AsyncReadThreadProc(__in LPVOID pvData); PRING_BUFFER m_DataRingBuffer; PRING_BUFFER AllocRingBuffer( SIZE_T Size ); VOID FreeRingBuffer( PRING_BUFFER ringBuffer); SIZE_T ReadRingBuffer( PRING_BUFFER ringBuffer, PUCHAR readBuffer, SIZE_T numberOfBytesToRead ); SIZE_T WriteRingBuffer(PRING_BUFFER ringBuffer, PUCHAR writeBuffer, SIZE_T numberOfBytesToWrite); VOID RingBufferGetAvailableSpace(PRING_BUFFER ringBuffer, SIZE_T* AvailableSpace ); VOID RingBufferGetAvailableData( PRING_BUFFER ringBuffer, SIZE_T* AvailableData ); }; CUsbPCECGHelper helperfunctionsc_class; #endif #ifdef USE_WINUSB_DRIVER CUsbPCECGHelper::CUsbPCECGHelper() { m_hDeviceHandle = INVALID_HANDLE_VALUE; m_hWinUSBHandle[0] = INVALID_HANDLE_VALUE; m_hWinUSBHandle[1] = INVALID_HANDLE_VALUE; drvver.MajorVersion = 0; drvver.MinorVersion = 0; drvver.BuildVersion = 0; PipeID.Bulk_Pipe[0].index = -1; PipeID.Int_Pipe [0].index = -1; PipeID.Iso_Pipe [0].index = -1; PipeID.Bulk_Pipe[1].index = -1; PipeID.Int_Pipe [1].index = -1; PipeID.Iso_Pipe [1].index = -1; RealTimeInProgress = FALSE; readBuffer = NULL; isochPacketDescriptors = NULL; overlapped = NULL; isochReadBufferHandle = INVALID_HANDLE_VALUE; m_hEventThread = NULL; m_hCloseThread = NULL; m_bResult = FALSE; m_DataRingBuffer = NULL; m_DataRingBuffer = AllocRingBuffer(64 * 1024); } CUsbPCECGHelper::~CUsbPCECGHelper() { ClearThreadHandles(); ClearIsobuffers(); ClearDeviceHandles(); FreeRingBuffer(m_DataRingBuffer); } void CUsbPCECGHelper::ClearThreadHandles(void) { if (NULL != m_hCloseThread) { // Stop the event thread. ::SetEvent(m_hCloseThread); // Wait for the thread to end. ::WaitForSingleObject(m_hEventThread, INFINITE); if (NULL != m_hEventThread) { CloseHandle(m_hEventThread); m_hEventThread = NULL; } CloseHandle(m_hCloseThread); m_hCloseThread = NULL; } } void CUsbPCECGHelper::ClearIsobuffers(void) { //ULONG i; if (isochReadBufferHandle != INVALID_HANDLE_VALUE) { WinUsb_UnregisterIsochBuffer(isochReadBufferHandle); isochReadBufferHandle = INVALID_HANDLE_VALUE; } if (readBuffer != NULL) { delete[] readBuffer; readBuffer = NULL; } if (isochPacketDescriptors != NULL) { delete[] isochPacketDescriptors; isochPacketDescriptors = NULL; } /* for (i = 0; i < ISOCH_TRANSFER_COUNT; i++) { if (overlapped[i].hEvent != NULL) { CloseHandle(overlapped[i].hEvent); overlapped[i].hEvent = NULL; } }*/ if (overlapped != NULL) { delete[] overlapped; overlapped = NULL; } } void CUsbPCECGHelper::ClearDeviceHandles(void) { if (m_hWinUSBHandle[0] != INVALID_HANDLE_VALUE) { WinUsb_Free(m_hWinUSBHandle[0]); m_hWinUSBHandle[0] = INVALID_HANDLE_VALUE; } if (m_hWinUSBHandle[1] != INVALID_HANDLE_VALUE) { WinUsb_Free(m_hWinUSBHandle[1]); m_hWinUSBHandle[1] = INVALID_HANDLE_VALUE; } if (m_hDeviceHandle != INVALID_HANDLE_VALUE) { CloseHandle(m_hDeviceHandle); m_hDeviceHandle = INVALID_HANDLE_VALUE; } } DWORD CUsbPCECGHelper::StartThreadHandles(void) { DWORD result = S_OK; if (m_hWinUSBHandle[0] == INVALID_HANDLE_VALUE) { return E_HANDLE; } // Create the event used to close the thread. if (NULL == m_hCloseThread) { m_hCloseThread = ::CreateEvent(NULL, FALSE, FALSE, TEXT("CloseThreadEvent")); } if (NULL == m_hCloseThread) { result=E_UNEXPECTED; } if (SUCCEEDED(result) && (m_hEventThread == NULL)) { m_hEventThread = ::CreateThread(NULL, // Cannot be inherited by child process 0, // Default stack size &CUsbPCECGHelper::AsyncReadThreadProc, // Thread proc (LPVOID)this, // Thread proc argument 0, // Starting state = running NULL); // No thread identifier if (NULL == m_hEventThread) { result = E_UNEXPECTED; } else { //DWORD dwError, dwThreadPri; if (!SetThreadPriority(m_hEventThread, THREAD_PRIORITY_HIGHEST)) { //dwError = GetLastError(); result = E_UNEXPECTED; } //dwThreadPri = GetThreadPriority(m_hEventThread); } } return result; } DWORD WINAPI CUsbPCECGHelper::AsyncReadThreadProc(__in LPVOID pvData) { #if(1) //-------------- HANDLE hEvents[ISOCH_TRANSFER_COUNT+1]; DWORD dwWait = 0; DWORD dwNum = 0; USHORT headerSize = 3; ULONG bytesRead = 0; BOOL b = FALSE; ULONG i; BOOL result = FALSE; // Cast the argument to the correct type CUsbPCECGHelper* pThis = static_cast<CUsbPCECGHelper*>(pvData); // New threads must always CoInitialize HRESULT hr = CoInitializeEx(NULL, COINIT_MULTITHREADED); ULONG totalTransferSize = pThis->IsochInTransferSize * ISOCH_TRANSFER_COUNT; pThis->readBuffer = new UCHAR[totalTransferSize]; if (pThis->readBuffer == NULL) { //sprintf_s(s, sizeof(s), "nvUSB.lib: bStart() Unable to allocate memory\n"); //OutputDebugString((LPCSTR)s); hr = E_UNEXPECTED; } else { ZeroMemory(pThis->readBuffer, totalTransferSize); } hEvents[0] = pThis->m_hCloseThread; for (i = 0; i < ISOCH_TRANSFER_COUNT; i++) { pThis->m_hReadAsync[i] = CreateEvent( NULL, // default security attribute TRUE, // manual-reset event FALSE, // initial state = not signaled NULL); // unnamed event object } for (i = 1; i < (ISOCH_TRANSFER_COUNT+1); i++) hEvents[i] = pThis->m_hReadAsync[i-1]; if (SUCCEEDED(hr)) { pThis->overlapped = new OVERLAPPED[ISOCH_TRANSFER_COUNT]; ZeroMemory(pThis->overlapped, (sizeof(OVERLAPPED) * ISOCH_TRANSFER_COUNT)); for (i = 0; i < ISOCH_TRANSFER_COUNT; i++) { // pThis->overlapped[i].hEvent = CreateEvent(NULL, TRUE, FALSE, NULL); pThis->overlapped[i].hEvent = pThis->m_hReadAsync[i]; // Initialize the rest of the OVERLAPPED structure to zero. pThis->overlapped[i].Internal = 0; pThis->overlapped[i].InternalHigh = 0; pThis->overlapped[i].Offset = 0; pThis->overlapped[i].OffsetHigh = 0; if (pThis->overlapped[i].hEvent == NULL) { //sprintf_s(s, sizeof(s), "nvUSB.lib: bStart() Unable to set event for overlapped operation\n"); //OutputDebugString((LPCSTR)s); hr = E_UNEXPECTED; } } } if (SUCCEEDED(hr)) { result = WinUsb_RegisterIsochBuffer( pThis->m_hWinUSBHandle[0], // An opaque handle to an interface in the selected configuration. That handle must be created by a previous call to WinUsb_Initialize or WinUsb_GetAssociatedInterface. pThis->PipeID.Iso_Pipe[0].PipeId, // Derived from Bit 3...0 of the bEndpointAddress field in the endpoint descriptor. pThis->readBuffer, // Pointer to the transfer buffer to be registered. totalTransferSize, // Length, in bytes, of the transfer buffer pointed to by Buffer. &pThis->isochReadBufferHandle); // Receives an opaque handle to the registered buffer. This handle is required by other WinUSB functions that perform isochronous transfers. To release the handle, call the WinUsb_UnregisterIsochBuffer function. if (!result) { //sprintf_s(s, sizeof(s), "nvUSB.lib: bStart() Isoch buffer registration failed.\n"); //OutputDebugString((LPCSTR)s); hr = E_UNEXPECTED; } } if (SUCCEEDED(hr)) { pThis->isochPacketDescriptors = new USBD_ISO_PACKET_DESCRIPTOR[pThis->IsochInPacketCount * ISOCH_TRANSFER_COUNT]; ZeroMemory(pThis->isochPacketDescriptors, pThis->IsochInPacketCount * ISOCH_TRANSFER_COUNT); //for iso endpoints read this //https://docs.microsoft.com/en-us/windows-hardware/drivers/usbcon/getting-set-up-to-use-windows-devices-usb // for (i = 0; i < ISOCH_TRANSFER_COUNT; i++) { result = WinUsb_ReadIsochPipeAsap( pThis->isochReadBufferHandle, // An opaque handle to the transfer buffer that was registered by a previous call to WinUsb_RegisterIsochBuffer. pThis->IsochInTransferSize * i, // Offset into the buffer relative to the start the transfer. pThis->IsochInTransferSize, // Length in bytes of the transfer buffer. (i == 0) ? FALSE : TRUE, // Indicates that the transfer should only be submitted if it can be scheduled in the first frame after the last pending transfer. pThis->IsochInPacketCount, // Total number of isochronous packets required to hold the transfer buffer.Also indicates the number of elements in the array pointed to by IsoPacketDescriptors. &pThis->isochPacketDescriptors[i * pThis->IsochInPacketCount], //An array of USBD_ISO_PACKET_DESCRIPTOR that receives the details of each isochronous packet in the transfer. &pThis->overlapped[i]); // Pointer to an OVERLAPPED structure used for asynchronous operations. if (!result) { DWORD lastError = GetLastError(); if (lastError != ERROR_IO_PENDING) { //sprintf_s(s, sizeof(s), "nvUSB.lib: bStart() Failed to start a read operation with error %x\n", lastError); //OutputDebugString((LPCSTR)s); hr = E_UNEXPECTED; } } } } //-------------- if (SUCCEEDED(hr)) { while (true) { for (i = 0; i < ISOCH_TRANSFER_COUNT; i++) pThis->m_bResult = ResetEvent(pThis->m_hReadAsync[i]); dwWait = WaitForMultipleObjects(ISOCH_TRANSFER_COUNT+1, // number of event objects hEvents, // array of event objects FALSE, // does not wait for all INFINITE // waits indefinitely ); if (dwWait == WAIT_OBJECT_0) //STOP_THREAD { CoUninitialize(); for (i = 0; i < ISOCH_TRANSFER_COUNT; i++) CloseHandle(pThis->m_hReadAsync[i]); return 0; } else { for (i = 1; i < (ISOCH_TRANSFER_COUNT + 1); i++) { if (dwWait == (WAIT_OBJECT_0 + i)) { pThis->ReadIsoBuffer((i-1)); } } } } } #endif #if(0) OVERLAPPED oOverlap; HANDLE hEvents[2]; DWORD dwWait = 0; DWORD dwNum = 0; const DWORD STOP_THREAD = WAIT_OBJECT_0; const DWORD READ_EVENT = WAIT_OBJECT_0 + 1; USHORT headerSize = 3; UCHAR buffer[3]; ULONG bytesRead = 0; BOOL b = FALSE; // Cast the argument to the correct type CUsbPCECGHelper* pThis = static_cast<CUsbPCECGHelper*>(pvData); // New threads must always CoInitialize HRESULT hr = CoInitializeEx(NULL, COINIT_MULTITHREADED); hEvents[0] = pThis->m_hCloseThread; pThis->m_hReadAsync = CreateEvent( NULL, // default security attribute TRUE, // manual-reset event FALSE, // initial state = not signaled NULL); // unnamed event object hEvents[1] = pThis->m_hReadAsync; /* oOverlap.hEvent = pThis->m_hReadAsync; // Initialize the rest of the OVERLAPPED structure to zero. oOverlap.Internal = 0; oOverlap.InternalHigh = 0; oOverlap.Offset = 0; oOverlap.OffsetHigh = 0; */ if (SUCCEEDED(hr)) { while (true) { /* pThis->m_bResult = ResetEvent(pThis->m_hReadAsync); pThis->ReadHeader(buffer, headerSize, &bytesRead, &oOverlap); dwWait = WaitForMultipleObjects(2, // number of event objects hEvents, // array of event objects FALSE, // does not wait for all INFINITE // waits indefinitely ); b = WinUsb_GetOverlappedResult(pThis->m_UsbHandle[1], &oOverlap, &dwNum, FALSE); */ pThis->m_bResult = ResetEvent(pThis->m_hReadAsync); dwWait = WaitForMultipleObjects(2, // number of event objects hEvents, // array of event objects FALSE, // does not wait for all INFINITE // waits indefinitely ); switch (dwWait) { case STOP_THREAD: CoUninitialize(); CloseHandle(pThis->m_hReadAsync); return 0; //break; case READ_EVENT: /* //reads the rest of the message if exist, throws events if needed if (b) { pThis->ParseDataMessage(buffer); } else { //error WinUsb_FlushPipe(pThis->m_UsbHandle[1], pThis->m_bulkInPipe); } break; */ default: break; } } } #endif //code not reached return 1; } DWORD CUsbPCECGHelper::ReadIsoBuffer(DWORD eventIndex) { #if(1) /* //for iso endpoints read this //https://docs.microsoft.com/en-us/windows-hardware/drivers/usbcon/getting-set-up-to-use-windows-devices-usb //https://docs.microsoft.com/en-us/windows-hardware/drivers/usbcon/transfer-data-to-isochronous-endpoints // */ char s[256]; DWORD Status = UsbPCECG_ERR_SUCCESS; ULONG i, j; BOOL result; DWORD lastError; ULONG numBytes = 0; BOOL ContinueStream = TRUE; ULONG frameNumber; ULONG startFrame; LARGE_INTEGER timeStamp; if (helperfunctionsc_class.m_hWinUSBHandle[0] == INVALID_HANDLE_VALUE) { return UsbPCECG_ERR_READISOBUFF; } result = WinUsb_GetCurrentFrameNumber( helperfunctionsc_class.m_hWinUSBHandle[0], &frameNumber, &timeStamp); if (!result) { sprintf_s(s, sizeof(s), "nvUSB.lib: bRead() WinUsb_GetCurrentFrameNumber failed. \n"); OutputDebugString((LPCSTR)s); return UsbPCECG_ERR_READISOBUFF; } sprintf_s(s, sizeof(s), "nvUSB.lib: Current Frame number=%d\n", frameNumber); OutputDebugString((LPCSTR)s); startFrame = frameNumber + 10; i = eventIndex; // for (i = 0; i < ISOCH_TRANSFER_COUNT; i++) { if (helperfunctionsc_class.RealTimeInProgress == FALSE) { return UsbPCECG_ERR_READISOBUFF; } result = WinUsb_GetOverlappedResult( helperfunctionsc_class.m_hWinUSBHandle[0], &helperfunctionsc_class.overlapped[i], &numBytes, TRUE); if (!result || numBytes == 0) { //0x1F = ERROR_GEN_FAILURE A device attached to the system is not functioning. //0x7A = ERROR_INSUFFICIENT_BUFFER The data area passed to a system call is too small. //0x57 = ERROR_INVALID_PARAMETER The parameter is incorrect. //0x3E5 = ERROR_IO_PENDING Overlapped I/O operation is in progress. lastError = GetLastError(); if (lastError == ERROR_IO_PENDING) //The transfer is pending.. { // try again.. if (i > 0) i--; // continue; } sprintf_s(s, sizeof(s), "nvUSB.lib: bRead() Failed to read with error %x \n", lastError); OutputDebugString((LPCSTR)s); return UsbPCECG_ERR_READISOBUFF; } else { numBytes = 0; for (j = 0; j < helperfunctionsc_class.IsochInPacketCount; j++) { numBytes += helperfunctionsc_class.isochPacketDescriptors[j].Length; //sprintf_s(s, sizeof(s), "%d-%d-%d\n", helperfunctionsc_class.isochPacketDescriptors[j].Length, helperfunctionsc_class.isochPackets[j].Offset, helperfunctionsc_class.isochPackets[j].Status); //OutputDebugString((LPCSTR)s); /* if (helperfunctionsc_class.isochPacketDescriptors[j].Length != 0 && helperfunctionsc_class.isochPackets[j].Status == 0) { memcpy(inBuffer, helperfunctionsc_class.readBuffer + helperfunctionsc_class.isochPacketDescriptors[j].Offset, helperfunctionsc_class.isochPacketDescriptors[j].Length); *nWriten += helperfunctionsc_class.isochPacketDescriptors[j].Length; inBuffer += helperfunctionsc_class.isochPacketDescriptors[j].Length; } */ /* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! sprintf_s(s, sizeof(s), "nvUSB.lib: desc.lenght=%d bytes descr.status=%x\n", helperfunctionsc_class.isochPacketDescriptors[j].Length, helperfunctionsc_class.isochPacketDescriptors[j].Status); OutputDebugString((LPCSTR)s); for ECGUSB1D-EX get nvUSB.lib: desc.lenght=2 bytes descr.status=0 if OK nvUSB.lib: desc.lenght=0 bytes descr.status=c0020000 if empty packet WD_USBD_STATUS_ISO_NOT_ACCESSED_BY_HW Extended isochronous error codes returned by USBD. These errors appear in the packet status field of an isochronous transfer. [0xC0020000] For some reason the controller did not access the TD associated with this packet: ! When the USB driver stack processes the URB, the driver discards all isochronous packets in the URB whose frame numbers are lower than the current frame number. The driver stack sets the Status member of the packet descriptor for each discarded packet to USBD_STATUS_ISO_NA_LATE_USBPORT, USBD_STATUS_ISO_NOT_ACCESSED_BY_HW, or USBD_STATUS_ISO_NOT_ACCESSED_LATE. Even though some packets in the URB are discarded, the driver stack attempts to transmit only those packets whose frame numbers are higher than the current frame number. !! */ /* if (helperfunctionsc_class.isochPacketDescriptors[j].Length == 0 && helperfunctionsc_class.isochPacketDescriptors[j].Status == USBD_STATUS_ISO_NOT_ACCESSED_BY_HW) { if (!(WinUsb_FlushPipe(helperfunctionsc_class.m_hWinUSBHandle[0], helperfunctionsc_class.PipeID.Iso_Pipe[0].PipeId))) { sprintf_s(s, sizeof(s), "nvUSB.lib: bRead() error flush pipe %d.\n", GetLastError()); OutputDebugString((LPCSTR)s); return UsbPCECG_ERR_RESETPIPE; } } */ if (helperfunctionsc_class.isochPacketDescriptors[j].Length != 0 && helperfunctionsc_class.isochPacketDescriptors[j].Status == 0) { WriteRingBuffer( helperfunctionsc_class.m_DataRingBuffer, (helperfunctionsc_class.readBuffer + helperfunctionsc_class.isochPacketDescriptors[j].Offset), helperfunctionsc_class.isochPacketDescriptors[j].Length ); } } sprintf_s(s, sizeof(s), "nvUSB.lib: bRead() Requested %d bytes in %d packets per transfer.\n", helperfunctionsc_class.IsochInTransferSize, helperfunctionsc_class.IsochInPacketCount); OutputDebugString((LPCSTR)s); } sprintf_s(s, sizeof(s), "nvUSB.lib: bRead() Transfer %d completed. Read %d bytes. \n", i + 1, numBytes); OutputDebugString((LPCSTR)s); result = WinUsb_ReadIsochPipeAsap( helperfunctionsc_class.isochReadBufferHandle, helperfunctionsc_class.IsochInTransferSize * i, helperfunctionsc_class.IsochInTransferSize, ContinueStream, helperfunctionsc_class.IsochInPacketCount, &helperfunctionsc_class.isochPacketDescriptors[i * helperfunctionsc_class.IsochInPacketCount], &helperfunctionsc_class.overlapped[i]); /* // not working // return with nvUSB.lib: bRead() Failed to read with error 1f after first time.. result = WinUsb_ReadIsochPipe( helperfunctionsc_class.isochReadBufferHandle, helperfunctionsc_class.IsochInTransferSize * i, helperfunctionsc_class.IsochInTransferSize, &startFrame, helperfunctionsc_class.IsochInPacketCount, &helperfunctionsc_class.isochPacketDescriptors[i * helperfunctionsc_class.IsochInPacketCount], &helperfunctionsc_class.overlapped[i]); */ if (!result) { lastError = GetLastError(); if (lastError == ERROR_INVALID_PARAMETER && ContinueStream) { ContinueStream = FALSE; // continue; } if (lastError != ERROR_IO_PENDING) { sprintf_s(s, sizeof(s), "nvUSB.lib: bRead() Failed to start a read operation with error %x\n", lastError); OutputDebugString((LPCSTR)s); return UsbPCECG_ERR_READISOBUFF; } ContinueStream = TRUE; } } return(Status); #endif #if(0) /* //for iso endpoints read this //https://docs.microsoft.com/en-us/windows-hardware/drivers/usbcon/getting-set-up-to-use-windows-devices-usb //https://docs.microsoft.com/en-us/windows-hardware/drivers/usbcon/transfer-data-to-isochronous-endpoints // */ char s[256]; DWORD Status = UsbPCECG_ERR_SUCCESS; ULONG i, j; BOOL result; DWORD lastError; ULONG numBytes=0; BOOL ContinueStream = TRUE; ULONG frameNumber; ULONG startFrame; LARGE_INTEGER timeStamp; if (helperfunctionsc_class.m_hWinUSBHandle[0] == INVALID_HANDLE_VALUE) { return UsbPCECG_ERR_READISOBUFF; } result = WinUsb_GetCurrentFrameNumber( helperfunctionsc_class.m_hWinUSBHandle[0], &frameNumber, &timeStamp); if (!result) { sprintf_s(s, sizeof(s), "nvUSB.lib: bRead() WinUsb_GetCurrentFrameNumber failed. \n"); OutputDebugString((LPCSTR)s); return UsbPCECG_ERR_READISOBUFF; } startFrame = frameNumber + 10; for (i = 0; i < ISOCH_TRANSFER_COUNT; i++) { if (helperfunctionsc_class.RealTimeInProgress == FALSE) { return UsbPCECG_ERR_READISOBUFF; } result = WinUsb_GetOverlappedResult( helperfunctionsc_class.m_hWinUSBHandle[0], &helperfunctionsc_class.overlapped[i], &numBytes, TRUE); if (!result || numBytes==0) { //0x1F = ERROR_GEN_FAILURE A device attached to the system is not functioning. //0x7A = ERROR_INSUFFICIENT_BUFFER The data area passed to a system call is too small. //0x57 = ERROR_INVALID_PARAMETER The parameter is incorrect. //0x3E5 = ERROR_IO_PENDING Overlapped I/O operation is in progress. lastError = GetLastError(); if (lastError == ERROR_IO_PENDING) //The transfer is pending.. { // try again.. if (i > 0) i--; continue; } sprintf_s(s, sizeof(s), "nvUSB.lib: bRead() Failed to read with error %x \n", lastError); OutputDebugString((LPCSTR)s); return UsbPCECG_ERR_READISOBUFF; } else { numBytes = 0; for (j = 0; j < helperfunctionsc_class.IsochInPacketCount; j++) { numBytes += helperfunctionsc_class.isochPacketDescriptors[j].Length; //sprintf_s(s, sizeof(s), "%d-%d-%d\n", helperfunctionsc_class.isochPacketDescriptors[j].Length, helperfunctionsc_class.isochPackets[j].Offset, helperfunctionsc_class.isochPackets[j].Status); //OutputDebugString((LPCSTR)s); /* if (helperfunctionsc_class.isochPacketDescriptors[j].Length != 0 && helperfunctionsc_class.isochPackets[j].Status == 0) { memcpy(inBuffer, helperfunctionsc_class.readBuffer + helperfunctionsc_class.isochPacketDescriptors[j].Offset, helperfunctionsc_class.isochPacketDescriptors[j].Length); *nWriten += helperfunctionsc_class.isochPacketDescriptors[j].Length; inBuffer += helperfunctionsc_class.isochPacketDescriptors[j].Length; } */ /* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! sprintf_s(s, sizeof(s), "nvUSB.lib: desc.lenght=%d bytes descr.status=%x\n", helperfunctionsc_class.isochPacketDescriptors[j].Length, helperfunctionsc_class.isochPacketDescriptors[j].Status); OutputDebugString((LPCSTR)s); for ECGUSB1D-EX get nvUSB.lib: desc.lenght=2 bytes descr.status=0 if OK nvUSB.lib: desc.lenght=0 bytes descr.status=c0020000 if empty packet WD_USBD_STATUS_ISO_NOT_ACCESSED_BY_HW Extended isochronous error codes returned by USBD. These errors appear in the packet status field of an isochronous transfer. [0xC0020000] For some reason the controller did not access the TD associated with this packet: ! When the USB driver stack processes the URB, the driver discards all isochronous packets in the URB whose frame numbers are lower than the current frame number. The driver stack sets the Status member of the packet descriptor for each discarded packet to USBD_STATUS_ISO_NA_LATE_USBPORT, USBD_STATUS_ISO_NOT_ACCESSED_BY_HW, or USBD_STATUS_ISO_NOT_ACCESSED_LATE. Even though some packets in the URB are discarded, the driver stack attempts to transmit only those packets whose frame numbers are higher than the current frame number. !! */ if (helperfunctionsc_class.isochPacketDescriptors[j].Length != 0 && helperfunctionsc_class.isochPacketDescriptors[j].Status == 0) { WriteRingBuffer( helperfunctionsc_class.m_DataRingBuffer, (helperfunctionsc_class.readBuffer + helperfunctionsc_class.isochPacketDescriptors[j].Offset), helperfunctionsc_class.isochPacketDescriptors[j].Length ); } } sprintf_s(s, sizeof(s), "nvUSB.lib: bRead() Requested %d bytes in %d packets per transfer.\n", helperfunctionsc_class.IsochInTransferSize, helperfunctionsc_class.IsochInPacketCount); OutputDebugString((LPCSTR)s); } sprintf_s(s, sizeof(s), "nvUSB.lib: bRead() Transfer %d completed. Read %d bytes. \n", i + 1, numBytes); OutputDebugString((LPCSTR)s); result = WinUsb_ReadIsochPipeAsap( helperfunctionsc_class.isochReadBufferHandle, helperfunctionsc_class.IsochInTransferSize * i, helperfunctionsc_class.IsochInTransferSize, ContinueStream, helperfunctionsc_class.IsochInPacketCount, &helperfunctionsc_class.isochPacketDescriptors[i * helperfunctionsc_class.IsochInPacketCount], &helperfunctionsc_class.overlapped[i]); /* // not working // return with nvUSB.lib: bRead() Failed to read with error 1f after first time.. result = WinUsb_ReadIsochPipe( helperfunctionsc_class.isochReadBufferHandle, helperfunctionsc_class.IsochInTransferSize * i, helperfunctionsc_class.IsochInTransferSize, &startFrame, helperfunctionsc_class.IsochInPacketCount, &helperfunctionsc_class.isochPacketDescriptors[i * helperfunctionsc_class.IsochInPacketCount], &helperfunctionsc_class.overlapped[i]); */ if (!result) { lastError = GetLastError(); if (lastError == ERROR_INVALID_PARAMETER && ContinueStream) { ContinueStream = FALSE; continue; } if (lastError != ERROR_IO_PENDING) { sprintf_s(s, sizeof(s), "nvUSB.lib: bRead() Failed to start a read operation with error %x\n", lastError); OutputDebugString((LPCSTR)s); return UsbPCECG_ERR_READISOBUFF; } ContinueStream = TRUE; } } return(Status); #endif } /* //----------------------------------------------------------------------------- // GetDeviceHandle() // // Parameters: // guidDeviceInterface: DEVICE GUID defined in WinUSB inf file // hDeviceHandle : device handle returned // // Return Values: // true : success // false: fail // // Remarks: // Function to create file handle for USB device //----------------------------------------------------------------------------- */ BOOL CUsbPCECGHelper::GetDeviceHandle(GUID guidDeviceInterface, PHANDLE hDeviceHandle) { char s[256]; #if(1) HRESULT result; HDEVINFO deviceInfo; SP_DEVINFO_DATA deviceInfoData; SP_DEVICE_INTERFACE_DATA deviceInterfaceData; SP_DRVINFO_DATA_A DriverInfo; PSP_DEVICE_INTERFACE_DETAIL_DATA interfaceDetailData; ULONG requiredLength; LPTSTR devicePath; size_t length; BOOL ret = FALSE; result = S_OK; interfaceDetailData = NULL; requiredLength = 0; devicePath = NULL; deviceInfo = SetupDiGetClassDevs( &guidDeviceInterface, NULL, NULL, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE ); if (deviceInfo == INVALID_HANDLE_VALUE) { result = E_HANDLE; } if (SUCCEEDED(result)) { // Check that a query for a second interface fails, but that the // first interface succeeds deviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA); if ( !SetupDiEnumDeviceInfo(deviceInfo, 1, &deviceInfoData) && SetupDiEnumDeviceInfo(deviceInfo, 0, &deviceInfoData)) { // Get the specific device interface deviceInterfaceData.cbSize = sizeof(SP_INTERFACE_DEVICE_DATA); if (!SetupDiEnumDeviceInterfaces(deviceInfo, &deviceInfoData,&guidDeviceInterface, 0, &deviceInterfaceData) ) { result = HRESULT_FROM_WIN32(GetLastError()); sprintf_s(s, sizeof(s), "nvUSB.lib: SetupDiEnumDeviceInterfaces failed %d.\n", result); OutputDebugString((LPCSTR)s); } // Check the size needed for the device interface details and // allocate the data needed to get the details if ( SUCCEEDED(result) && !SetupDiGetDeviceInterfaceDetail(deviceInfo,&deviceInterfaceData, NULL, 0, &requiredLength, NULL)) { if (GetLastError() == ERROR_INSUFFICIENT_BUFFER && requiredLength > 0) { interfaceDetailData =(PSP_DEVICE_INTERFACE_DETAIL_DATA)LocalAlloc(LPTR, (SIZE_T)requiredLength); if (interfaceDetailData == NULL) { result = E_OUTOFMEMORY; } else { result = S_OK; } } else { result = HRESULT_FROM_WIN32(GetLastError()); } } // Get the device interface details if (SUCCEEDED(result) && interfaceDetailData != NULL) { interfaceDetailData->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA); if (!SetupDiGetDeviceInterfaceDetail(deviceInfo,&deviceInterfaceData, interfaceDetailData,requiredLength, NULL, &deviceInfoData)) { result = HRESULT_FROM_WIN32(GetLastError()); sprintf_s(s, sizeof(s), "nvUSB.lib: SetupDiGetDeviceInterfaceDetail failed %d.\n", result); OutputDebugString((LPCSTR)s); } } if (SUCCEEDED(result) && interfaceDetailData != NULL) { // Build the null terminated device path for the device length = _tcslen(interfaceDetailData->DevicePath) + 1; devicePath = (TCHAR*)LocalAlloc(LPTR, length * sizeof(TCHAR)); if (devicePath != NULL) { StringCchCopy(devicePath, length,interfaceDetailData->DevicePath); devicePath[length - 1] = 0; sprintf_s(s, sizeof(s), "nvUSB.lib: Device path: %s\n", devicePath); OutputDebugString((LPCSTR)s); //This what i get on Windows 10 as output: // nvUSB.lib: Device path: \\?\usb#vid_10c4&pid_825f#7&1b060a7f&0&3#{93bd88a4-eb10-4706-8304-c512f18b8e42} //------------------ Get winusb driver version ----------------------------------------------------------- if (!SetupDiBuildDriverInfoList(deviceInfo, &deviceInfoData, SPDIT_COMPATDRIVER)) { result = HRESULT_FROM_WIN32(GetLastError()); sprintf_s(s, sizeof(s), "nvUSB.lib: SetupDiBuildDriverInfoList failed %d.\n", result); OutputDebugString((LPCSTR)s); } else { DriverInfo.cbSize = sizeof(SP_DRVINFO_DATA_A); if ((SetupDiEnumDriverInfoA(deviceInfo, &deviceInfoData, SPDIT_COMPATDRIVER, 0, &DriverInfo))) { sprintf_s(s, sizeof(s), "nvUSB.lib: SetupDiEnumDriverInfoA \n"); OutputDebugString((LPCSTR)s); sprintf_s(s, sizeof(s), "nvUSB.lib: winusb driver version %s v.%u.%u.%u.%u\n", DriverInfo.Description, (DWORD32)(DriverInfo.DriverVersion >> 48) & 0xFFFF, (DWORD32)(DriverInfo.DriverVersion >> 32) & 0xFFFF, (DWORD32)(DriverInfo.DriverVersion >> 16) & 0xFFFF, (DWORD32)(DriverInfo.DriverVersion >> 0) & 0xFFFF ); OutputDebugString((LPCSTR)s); drvver.MajorVersion = (WORD)(DriverInfo.DriverVersion >> 48) & 0xFFFF; drvver.MinorVersion = (WORD)(DriverInfo.DriverVersion >> 32) & 0xFFFF; drvver.BuildVersion = (WORD)(DriverInfo.DriverVersion >> 16) & 0xFFFF; } else { result = HRESULT_FROM_WIN32(GetLastError()); sprintf_s(s, sizeof(s), "nvUSB.lib: SetupDiEnumDriverInfoA failed %d.\n", result); OutputDebugString((LPCSTR)s); } } //------------------------------------------------------------------------------------------------------------- } else { result = E_OUTOFMEMORY; } } } } if (SUCCEEDED(result) && devicePath != NULL) { ret = TRUE; // Open the device handle *hDeviceHandle = CreateFile( devicePath, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL ); if (*hDeviceHandle == INVALID_HANDLE_VALUE) { result = HRESULT_FROM_WIN32(GetLastError()); sprintf_s(s, sizeof(s), "nvUSB.lib: CreateFile failed %d.\n", result); OutputDebugString((LPCSTR)s); ret = FALSE; } } // Perform cleanup of the allocated data if (devicePath != NULL) { LocalFree(devicePath); } if (interfaceDetailData != NULL) { LocalFree(interfaceDetailData); } if (deviceInfo != INVALID_HANDLE_VALUE) { (void)SetupDiDestroyDeviceInfoList(deviceInfo); } return ret; #endif #if(0) BOOL bResult = TRUE; HDEVINFO hDeviceInfo; SP_DEVINFO_DATA DeviceInfoData; SP_DRVINFO_DATA_A DriverInfo; DriverInfo.cbSize = sizeof(SP_DRVINFO_DATA_A); SP_DEVICE_INTERFACE_DATA deviceInterfaceData; PSP_DEVICE_INTERFACE_DETAIL_DATA pInterfaceDetailData = NULL; ULONG requiredLength = 0; LPTSTR lpDevicePath = NULL; DWORD index = 0; sprintf_s(s, sizeof(s), "nvUSB.lib: Enter to GetDeviceHandle\n"); OutputDebugString((LPCSTR)s); // if (guidDeviceInterface == GUID_NULL) { // return FALSE; // } // Get information about all the installed devices for the specified // device interface class. hDeviceInfo = SetupDiGetClassDevs( &guidDeviceInterface, NULL, NULL, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE); if (hDeviceInfo == INVALID_HANDLE_VALUE) { // ERROR sprintf_s(s, sizeof(s), "nvUSB.lib: Error SetupDiGetClassDevs: %d.\n", GetLastError()); OutputDebugString((LPCSTR)s); bResult = FALSE; goto done; } //Enumerate all the device interfaces in the device information set. DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA); for (index = 0; SetupDiEnumDeviceInfo(hDeviceInfo, index, &DeviceInfoData); index++) { //Reset for this iteration if (lpDevicePath) { LocalFree(lpDevicePath); lpDevicePath = NULL; } if (pInterfaceDetailData) { LocalFree(pInterfaceDetailData); pInterfaceDetailData = NULL; } // Check if last item if (GetLastError() == ERROR_NO_MORE_ITEMS) { break; } deviceInterfaceData.cbSize = sizeof(SP_INTERFACE_DEVICE_DATA); //Get information about the device interface. bResult = SetupDiEnumDeviceInterfaces( hDeviceInfo, &DeviceInfoData, &guidDeviceInterface, index, &deviceInterfaceData); bResult = SetupDiEnumDeviceInterfaces( hDeviceInfo, &DeviceInfoData, &guidDeviceInterface, index, &deviceInterfaceData); // Check if last item if (GetLastError() == ERROR_NO_MORE_ITEMS) { sprintf_s(s, sizeof(s), "nvUSB.lib: SetupDiEnumDeviceInterfaces ERROR_NO_MORE_ITEMS (%d) \n", index); OutputDebugString((LPCSTR)s); break; } //Check for some other error if (!bResult) { sprintf_s(s, sizeof(s), "nvUSB.lib: Error SetupDiEnumDeviceInterfaces: %d.\n", GetLastError()); OutputDebugString((LPCSTR)s); bResult = FALSE; goto done; } //Interface data is returned in SP_DEVICE_INTERFACE_DETAIL_DATA //which we need to allocate, so we have to call this function twice. //First to get the size so that we know how much to allocate //Second, the actual call with the allocated buffer bResult = SetupDiGetDeviceInterfaceDetail( hDeviceInfo, &deviceInterfaceData, NULL, 0, &requiredLength, NULL); //Check for some other error if (!bResult) { if ((ERROR_INSUFFICIENT_BUFFER == GetLastError()) && (requiredLength > 0)) { //we got the size, allocate buffer pInterfaceDetailData = (PSP_DEVICE_INTERFACE_DETAIL_DATA)LocalAlloc(LPTR, requiredLength); if (!pInterfaceDetailData) { // ERROR //printf("Error allocating memory for the device detail buffer.\n"); sprintf_s(s, sizeof(s), "nvUSB.lib: Error allocating memory for the device detail buffer.\n"); OutputDebugString((LPCSTR)s); bResult = FALSE; goto done; } } else { //printf("Error SetupDiEnumDeviceInterfaces: %d.\n", GetLastError()); sprintf_s(s, sizeof(s), "nvUSB.lib: Error SetupDiEnumDeviceInterfaces: %d.\n", GetLastError()); OutputDebugString((LPCSTR)s); bResult = FALSE; goto done; } } //get the interface detailed data pInterfaceDetailData->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA); //Now call it with the correct size and allocated buffer bResult = SetupDiGetDeviceInterfaceDetail( hDeviceInfo, &deviceInterfaceData, pInterfaceDetailData, requiredLength, NULL, &DeviceInfoData); //Check for some other error if (!bResult) { //printf("Error SetupDiGetDeviceInterfaceDetail: %d.\n", GetLastError()); sprintf_s(s, sizeof(s), "nvUSB.lib: Error SetupDiGetDeviceInterfaceDetail: %d.\n", GetLastError()); OutputDebugString((LPCSTR)s); bResult = FALSE; goto done; } if (!SetupDiBuildDriverInfoList(hDeviceInfo, &DeviceInfoData, SPDIT_COMPATDRIVER)) { sprintf_s(s, sizeof(s), "nvUSB.lib: Error SetupDiBuildDriverInfoList: %d.\n", GetLastError()); OutputDebugString((LPCSTR)s); } else { if ((SetupDiEnumDriverInfoA(hDeviceInfo, &DeviceInfoData, SPDIT_COMPATDRIVER, index, &DriverInfo)) != FALSE) { sprintf_s(s, sizeof(s), "nvUSB.lib: SetupDiEnumDriverInfoA \n"); OutputDebugString((LPCSTR)s); sprintf_s(s, sizeof(s), "nvUSB.lib: winusb driver version %s v.%u.%u.%u.%u\n", DriverInfo.Description, (DWORD32)(DriverInfo.DriverVersion >> 48) & 0xFFFF, (DWORD32)(DriverInfo.DriverVersion >> 32) & 0xFFFF, (DWORD32)(DriverInfo.DriverVersion >> 16) & 0xFFFF, (DWORD32)(DriverInfo.DriverVersion >> 0) & 0xFFFF ); OutputDebugString((LPCSTR)s); drvver.MajorVersion = (WORD)(DriverInfo.DriverVersion >> 48) & 0xFFFF; drvver.MinorVersion = (WORD)(DriverInfo.DriverVersion >> 32) & 0xFFFF; drvver.BuildVersion = (WORD)(DriverInfo.DriverVersion >> 16) & 0xFFFF; //copy device path size_t nLength = _tcslen(pInterfaceDetailData->DevicePath) + 1; lpDevicePath = (TCHAR*)LocalAlloc(LPTR, nLength * sizeof(TCHAR)); StringCchCopy(lpDevicePath, nLength, pInterfaceDetailData->DevicePath); lpDevicePath[nLength - 1] = 0; sprintf_s(s, sizeof(s), "nvUSB.lib: Device path: %s\n", lpDevicePath); OutputDebugString((LPCSTR)s); //This what i get on Windows 10 as output: // nvUSB.lib: Device path: \\?\usb#vid_10c4&pid_825f#7&1b060a7f&0&3#{93bd88a4-eb10-4706-8304-c512f18b8e42} break; //connect to to only one device } } }//for (index = 0; SetupDiEnumDeviceInfo(hDeviceInfo, index, &DeviceInfoData); index++) if (!lpDevicePath) { //Error. //printf("Error %d.", GetLastError()); sprintf_s(s, sizeof(s), "nvUSB.lib: lpDevicePath Error %d.\n", GetLastError()); OutputDebugString((LPCSTR)s); bResult = FALSE; goto done; } //Open the device *hDeviceHandle = CreateFile( lpDevicePath, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL); if (*hDeviceHandle == INVALID_HANDLE_VALUE) { //Error. //printf("Error %d.", GetLastError()); sprintf_s(s, sizeof(s), "nvUSB.lib: CreateFile Error %d.\n", GetLastError()); OutputDebugString((LPCSTR)s); bResult = FALSE; goto done; } done: if (lpDevicePath) { LocalFree(lpDevicePath); } if (pInterfaceDetailData) { LocalFree(pInterfaceDetailData); } if (!bResult) { if (hDeviceInfo != INVALID_HANDLE_VALUE) SetupDiDestroyDeviceInfoList(hDeviceInfo); } else { if (hDeviceInfo != INVALID_HANDLE_VALUE) bResult = SetupDiDestroyDeviceInfoList(hDeviceInfo); } sprintf_s(s, sizeof(s), "nvUSB.lib: Exit from GetDeviceHandle\n"); OutputDebugString((LPCSTR)s); return bResult; #endif } // End of GetDeviceHandle() /* //----------------------------------------------------------------------------- // GetWinUSBHandle() // // Parameters: // hDeviceHandle : device handle created for the USB device // phWinUSBHandle : WinUSB Interface handle returned // // Return Values: // true : success // false: fail // // Remarks: // Function to get WinUSB Interface Handle for the device //----------------------------------------------------------------------------- */ BOOL CUsbPCECGHelper::GetWinUSBHandle(HANDLE hDeviceHandle, PWINUSB_INTERFACE_HANDLE phWinUSBHandle) { char s[256]; BOOL bResult = FALSE; sprintf_s(s, sizeof(s), "nvUSB.lib: Enter to GetWinUSBHandle\n"); OutputDebugString((LPCSTR)s); if (hDeviceHandle == INVALID_HANDLE_VALUE) { sprintf_s(s, sizeof(s), "nvUSB.lib: Exit from GetWinUSBHandle (hDeviceHandle not valid) \n"); OutputDebugString((LPCSTR)s); return FALSE; } /* [in] DeviceHandle The handle to the device that CreateFile returned.WinUSB uses overlapped I / O, so FILE_FLAG_OVERLAPPED must be specified in the dwFlagsAndAttributes parameter of CreateFile call for DeviceHandle to have the characteristics necessary for WinUsb_Initialize to function properly. [out] InterfaceHandle Receives an opaque handle to the first(default) interface on the device.This handle is required by other WinUSB routines that perform operations on the default interface.To release the handle, call the WinUSB_Free function. WinUsb_Initialize returns TRUE if the operation succeeds. Otherwise, this routine returns FALSE, and the caller can retrieve the logged error by calling GetLastError. */ bResult = WinUsb_Initialize(hDeviceHandle, phWinUSBHandle); if (!bResult) { //Error. //printf("WinUsb_Initialize Error %d.", GetLastError()); sprintf_s(s, sizeof(s), "nvUSB.lib: WinUsb_Initialize Error %d.", GetLastError()); OutputDebugString((LPCSTR)s); return FALSE; } sprintf_s(s, sizeof(s), "nvUSB.lib: Exit from GetWinUSBHandle \n"); OutputDebugString((LPCSTR)s); return bResult; } // End of GetWinUSBHandle() /* //----------------------------------------------------------------------------- // GetUSBDeviceSpeed() // // Parameters: // hDeviceHandle : WinUSB Interface Handle // pDeviceSpeed : Device Speed returned // // Return Values: // true : success // false: fail // // Remarks: // Function to get device speed //----------------------------------------------------------------------------- */ BOOL CUsbPCECGHelper::GetUSBDeviceSpeed(WINUSB_INTERFACE_HANDLE hDeviceHandle, UCHAR* pDeviceSpeed) { char s[256]; sprintf_s(s, sizeof(s), "nvUSB.lib: Enter to GetUSBDeviceSpeed() \n"); OutputDebugString((LPCSTR)s); if (!pDeviceSpeed || hDeviceHandle == INVALID_HANDLE_VALUE) { return FALSE; } BOOL bResult = TRUE; ULONG length = sizeof(UCHAR); bResult = WinUsb_QueryDeviceInformation(hDeviceHandle, DEVICE_SPEED, &length, pDeviceSpeed); if (!bResult) { sprintf_s(s, sizeof(s), "nvUSB.lib: Error getting device speed: %d.\n", GetLastError()); OutputDebugString((LPCSTR)s); goto done; } /* if (*pDeviceSpeed == LowSpeed) { sprintf_s(s, sizeof(s), "nvUSB.lib: Device speed: %d (Low speed).\n", *pDeviceSpeed); OutputDebugString((LPCSTR)s); goto done; } if (*pDeviceSpeed == FullSpeed) { sprintf_s(s, sizeof(s), "nvUSB.lib: Device speed: %d (Full speed).\n", *pDeviceSpeed); OutputDebugString((LPCSTR)s); goto done; } */ if (*pDeviceSpeed == 1) { //---!! printf("Device speed: %d - Full speed or lower (initial documentation on MSDN was wrong).\n", *pDeviceSpeed); sprintf_s(s, sizeof(s), "nvUSB.lib: Device speed: %d (Full speed or lower).\n", *pDeviceSpeed); OutputDebugString((LPCSTR)s); goto done; } if (*pDeviceSpeed == HighSpeed) { sprintf_s(s, sizeof(s), "nvUSB.lib: Device speed: %d (High speed).\n", *pDeviceSpeed); OutputDebugString((LPCSTR)s); goto done; } sprintf_s(s, sizeof(s), "nvUSB.lib: Exit from GetUSBDeviceSpeed() \n"); OutputDebugString((LPCSTR)s); done: return bResult; } // End of GetUSBDeviceSpeed() /* //----------------------------------------------------------------------------- // QueryDeviceEndpoints() // // Parameters: // hDeviceHandle : WinUSB Interface Handle // pipeid : Pipe ID returned // // Return Values: // true : success // false: fail // // Remarks: // Function to check end points and get pipe ID //----------------------------------------------------------------------------- */ BOOL CUsbPCECGHelper::QueryDeviceEndpoints(WINUSB_INTERFACE_HANDLE hDeviceHandle, PIPE_ID* pipeid) { char s[256]; sprintf_s(s, sizeof(s), "nvUSB.lib: Enter to QueryDeviceEndpoints() \n"); OutputDebugString((LPCSTR)s); if (hDeviceHandle == INVALID_HANDLE_VALUE) { return FALSE; } BOOL bResult = TRUE; USB_INTERFACE_DESCRIPTOR InterfaceDescriptor; ZeroMemory(&InterfaceDescriptor, sizeof(USB_INTERFACE_DESCRIPTOR)); WINUSB_PIPE_INFORMATION_EX Pipe; ZeroMemory(&Pipe, sizeof(WINUSB_PIPE_INFORMATION_EX)); //WINUSB_PIPE_INFORMATION Pipe; ZeroMemory(&Pipe, sizeof(WINUSB_PIPE_INFORMATION)); bResult = WinUsb_QueryInterfaceSettings(hDeviceHandle, 0, &InterfaceDescriptor); if (bResult) { for (int index = 0; index < InterfaceDescriptor.bNumEndpoints; index++) { bResult = WinUsb_QueryPipeEx(hDeviceHandle, 0, index, &Pipe); //bResult = WinUsb_QueryPipe(hDeviceHandle, 0, index, &Pipe); if (bResult) { if (Pipe.PipeType == UsbdPipeTypeControl) { if (USB_ENDPOINT_DIRECTION_IN(Pipe.PipeId)) { sprintf_s(s, sizeof(s), "nvUSB.lib: Endpoint index: %d Pipe type: Control IN Pipe ID: %d.\n", index, Pipe.PipeId); OutputDebugString((LPCSTR)s); } if (USB_ENDPOINT_DIRECTION_OUT(Pipe.PipeId)) { sprintf_s(s, sizeof(s), "nvUSB.lib: Endpoint index: %d Pipe type: Control OUT Pipe ID: %d.\n", index, Pipe.PipeId); OutputDebugString((LPCSTR)s); } } if (Pipe.PipeType == UsbdPipeTypeIsochronous) { if (USB_ENDPOINT_DIRECTION_IN(Pipe.PipeId)) { //Printout for ECGUSB1D-EX : //nvUSB.lib: Endpoint index: 0 Pipe type: Isochronous IN Pipe ID: 129. sprintf_s(s, sizeof(s), "nvUSB.lib: Endpoint index: %d Pipe type: Isochronous IN Pipe ID: %d.\n", index, Pipe.PipeId); OutputDebugString((LPCSTR)s); pipeid->Iso_Pipe[0].PipeType = Pipe.PipeType; pipeid->Iso_Pipe[0].PipeId = Pipe.PipeId; pipeid->Iso_Pipe[0].Interval = Pipe.Interval; pipeid->Iso_Pipe[0].MaximumPacketSize = Pipe.MaximumPacketSize; pipeid->Iso_Pipe[0].index = index; pipeid->Iso_Pipe[0].MaximumBytesPerInterval = Pipe.MaximumBytesPerInterval; //Printout for ECGUSB1D-EX : //nvUSB.lib: Type=1 , Interval=1 , MaximumPacketSize=24 ,MaximumBytesPerInterval=24 sprintf_s(s, sizeof(s), "nvUSB.lib: Type=%d , Interval=%d , MaximumPacketSize=%d ,MaximumBytesPerInterval=%d\n", Pipe.PipeType, Pipe.Interval, Pipe.MaximumPacketSize, Pipe.MaximumBytesPerInterval ); OutputDebugString((LPCSTR)s); /* MaximumPacketSize The maximum size, in bytes, of the packets that are transmitted on the pipe. MaximumBytesPerInterval The maximum number of bytes that can be transmitted in single interval. This value may be a larger than the MaximumPacketSize value on high-bandwidth, high-speed periodic endpoints and SuperSpeed periodic endpoints, such as isochronous endpoints. */ } if (USB_ENDPOINT_DIRECTION_OUT(Pipe.PipeId)) { sprintf_s(s, sizeof(s), "nvUSB.lib: Endpoint index: %d Pipe type: Isochronous OUT Pipe ID: %d.\n", index, Pipe.PipeId); OutputDebugString((LPCSTR)s); pipeid->Iso_Pipe[1].PipeType = Pipe.PipeType; pipeid->Iso_Pipe[1].PipeId = Pipe.PipeId; pipeid->Iso_Pipe[1].Interval = Pipe.Interval; pipeid->Iso_Pipe[1].MaximumPacketSize = Pipe.MaximumPacketSize; pipeid->Iso_Pipe[1].index = index; pipeid->Iso_Pipe[1].MaximumBytesPerInterval = Pipe.MaximumBytesPerInterval; } } if (Pipe.PipeType == UsbdPipeTypeBulk) { if (USB_ENDPOINT_DIRECTION_IN(Pipe.PipeId)) { sprintf_s(s, sizeof(s), "nvUSB.lib: Endpoint index: %d Pipe type: Bulk IN Pipe ID: %d.\n", index, Pipe.PipeId); OutputDebugString((LPCSTR)s); pipeid->Bulk_Pipe[0].PipeType = Pipe.PipeType; pipeid->Bulk_Pipe[0].PipeId = Pipe.PipeId; pipeid->Bulk_Pipe[0].Interval = Pipe.Interval; pipeid->Bulk_Pipe[0].MaximumPacketSize = Pipe.MaximumPacketSize; pipeid->Bulk_Pipe[0].index = index; pipeid->Bulk_Pipe[0].MaximumBytesPerInterval = Pipe.MaximumBytesPerInterval; } if (USB_ENDPOINT_DIRECTION_OUT(Pipe.PipeId)) { sprintf_s(s, sizeof(s), "nvUSB.lib: Endpoint index: %d Pipe type: Bulk OUT Pipe ID: %d.\n", index, Pipe.PipeId); OutputDebugString((LPCSTR)s); pipeid->Bulk_Pipe[1].PipeType = Pipe.PipeType; pipeid->Bulk_Pipe[1].PipeId = Pipe.PipeId; pipeid->Bulk_Pipe[1].Interval = Pipe.Interval; pipeid->Bulk_Pipe[1].MaximumPacketSize = Pipe.MaximumPacketSize; pipeid->Bulk_Pipe[1].index = index; pipeid->Bulk_Pipe[1].MaximumBytesPerInterval = Pipe.MaximumBytesPerInterval; } } if (Pipe.PipeType == UsbdPipeTypeInterrupt) { if (USB_ENDPOINT_DIRECTION_IN(Pipe.PipeId)) { sprintf_s(s, sizeof(s), "nvUSB.lib: Endpoint index: %d Pipe type: Int IN Pipe ID: %d.\n", index, Pipe.PipeId); OutputDebugString((LPCSTR)s); pipeid->Int_Pipe[0].PipeType = Pipe.PipeType; pipeid->Int_Pipe[0].PipeId = Pipe.PipeId; pipeid->Int_Pipe[0].Interval = Pipe.Interval; pipeid->Int_Pipe[0].MaximumPacketSize = Pipe.MaximumPacketSize; pipeid->Int_Pipe[0].index = index; pipeid->Int_Pipe[0].MaximumBytesPerInterval = Pipe.MaximumBytesPerInterval; } if (USB_ENDPOINT_DIRECTION_OUT(Pipe.PipeId)) { sprintf_s(s, sizeof(s), "nvUSB.lib: Endpoint index: %d Pipe type: Int OUT Pipe ID: %d.\n", index, Pipe.PipeId); OutputDebugString((LPCSTR)s); pipeid->Int_Pipe[1].PipeType = Pipe.PipeType; pipeid->Int_Pipe[1].PipeId = Pipe.PipeId; pipeid->Int_Pipe[1].Interval = Pipe.Interval; pipeid->Int_Pipe[1].MaximumPacketSize = Pipe.MaximumPacketSize; pipeid->Int_Pipe[1].index = index; pipeid->Int_Pipe[1].MaximumBytesPerInterval = Pipe.MaximumBytesPerInterval; } } } else { continue; } } } //done: return bResult; } // End of QueryDeviceEndpoints() PRING_BUFFER CUsbPCECGHelper::AllocRingBuffer( SIZE_T Size ) { PRING_BUFFER ringBuffer = NULL; ringBuffer = new RING_BUFFER[sizeof(RING_BUFFER)]; if (!ringBuffer) return NULL; ringBuffer->buffer = new UCHAR[Size]; if (!ringBuffer->buffer) { free(ringBuffer); return NULL; } ringBuffer->Size = Size; ringBuffer->Base = ringBuffer->buffer; ringBuffer->End = ringBuffer->buffer + Size; ringBuffer->Head = ringBuffer->buffer; ringBuffer->Tail = ringBuffer->buffer; ringBuffer->inPtr = ringBuffer->buffer; ringBuffer->outPtr = ringBuffer->buffer; ringBuffer->totalSize = Size; ringBuffer->currentSize = 0; // KeInitializeSpinLock(&ringBuffer->spinLock); return ringBuffer; } VOID CUsbPCECGHelper::FreeRingBuffer( PRING_BUFFER ringBuffer ) { free(ringBuffer->buffer); free(ringBuffer); } VOID CUsbPCECGHelper::RingBufferGetAvailableSpace( PRING_BUFFER ringBuffer, SIZE_T* AvailableSpace ) { PUCHAR headSnapshot = NULL; PUCHAR tailSnapshot = NULL; PUCHAR tailPlusOne = NULL; if (!AvailableSpace) return; // ASSERT(AvailableSpace); // // Take a snapshot of the head and tail pointers. We will compute the // available space based on this snapshot. This is safe to do in a // single-producer, single-consumer model, because - // * A producer will call GetAvailableSpace() to determine whether // there is enough space to write the data it is trying to write. // The only other thread that could modify the amount of space // available is the consumer thread, which can only increase the // amount of space available. Hence it is safe for the producer // to write based on this snapshot. // * A consumer thread will call GetAvailableSpace() to determine // whether there is enough data in the buffer for it to read. // (Available data = Buffer size - Available space). The only // other thread that could modify the amount of space available // is the producer thread, which can only decrease the amount of // space available (thereby increasing the amount of data // available. Hence it is safe for the consumer to read based on // this snapshot. // headSnapshot = ringBuffer->Head; tailSnapshot = ringBuffer->Tail; // // In order to distinguish between a full buffer and an empty buffer, // we always leave the last byte of the buffer unused. So, an empty // buffer is denoted by - // tail == head // ... and a full buffer is denoted by - // (tail+1) == head // tailPlusOne = ((tailSnapshot + 1) == ringBuffer->End) ? ringBuffer->Base : (tailSnapshot + 1); if (tailPlusOne == headSnapshot) { // // Buffer full // *AvailableSpace = 0; } else if (tailSnapshot == headSnapshot) { // // Buffer empty // The -1 in the computation below is to account for the fact that // we always leave the last byte of the ring buffer unused in order // to distinguish between an empty buffer and a full buffer. // *AvailableSpace = ringBuffer->Size - 1; } else { if (tailSnapshot > headSnapshot) { // // Data has not wrapped around the end of the buffer // The -1 in the computation below is to account for the fact // that we always leave the last byte of the ring buffer unused // in order to distinguish between an empty buffer and a full // buffer. // *AvailableSpace = ringBuffer->Size - (tailSnapshot - headSnapshot) - 1; } else { // // Data has wrapped around the end of the buffer // The -1 in the computation below is to account for the fact // that we always leave the last byte of the ring buffer unused // in order to distinguish between an empty buffer and a full // buffer. // *AvailableSpace = (headSnapshot - tailSnapshot) - 1; } } } VOID CUsbPCECGHelper::RingBufferGetAvailableData( PRING_BUFFER ringBuffer, SIZE_T* AvailableData ) { SIZE_T availableSpace; // KIRQL oldIrql; if (!AvailableData) return; //ASSERT(AvailableData); // KeAcquireSpinLock(&ringBuffer->spinLock, &oldIrql); RingBufferGetAvailableSpace(ringBuffer, &availableSpace); // KeReleaseSpinLock(&ringBuffer->spinLock, oldIrql); // // The -1 in the arithmetic below accounts for the fact that we always // keep 1 byte of the ring buffer unused in order to distinguish // between a full buffer and an empty buffer. // *AvailableData = ringBuffer->Size - availableSpace - 1; } SIZE_T CUsbPCECGHelper::ReadRingBuffer( PRING_BUFFER ringBuffer, PUCHAR readBuffer, SIZE_T numberOfBytesToRead ) /* Routine Description: This routine reads data from a ring buffer. Arguments: ringBuffer - pointer to a ring buffer structure readBuffer - pointer to a user supplied buffer to transfer data into numberOfBytesToRead - number of bytes to read from the ring buffer Return Value: ULONG - number of bytes read. May be smaller than requested number of bytes. */ { SIZE_T byteCount; // KIRQL oldIrql; SIZE_T l_currentsize; // KeAcquireSpinLock(&ringBuffer->spinLock, &oldIrql); l_currentsize = ringBuffer->currentSize; // KeReleaseSpinLock(&ringBuffer->spinLock, oldIrql); // MarlinUSB_DbgPrint(1, ("Marlin.sys: ReadRingBuffer() enter\n")); if (numberOfBytesToRead > ringBuffer->totalSize) return 0; if (l_currentsize == 0) return 0; if (numberOfBytesToRead > l_currentsize) byteCount = l_currentsize; else byteCount = numberOfBytesToRead; // // two cases. Read either wraps or it doesn't. // Handle the non-wrapped case first // if ((ringBuffer->outPtr + byteCount - 1) < (ringBuffer->buffer + ringBuffer->totalSize)) { // MarlinUSB_DbgPrint(1, ("Marlin.sys: ReadRingBuffer() about to copy a\n")); RtlCopyMemory(readBuffer, ringBuffer->outPtr, byteCount); ringBuffer->outPtr += byteCount; if (ringBuffer->outPtr == ringBuffer->buffer + ringBuffer->totalSize) ringBuffer->outPtr = ringBuffer->buffer; } // now handle the wrapped case else { //ULONG fragSize; //Boris, 18.04.2021 (Get error: conversion from '__int64' to 'ULONG', possible loss of data) SIZE_T fragSize; // MarlinUSB_DbgPrint(1, ("Marlin.sys: ReadRingBuffer() about to copy b\n")); // get the first half of the read //Boris, 16.02.2009 ,WDK 6001.18002 build //fragSize = ringBuffer->buffer + ringBuffer->totalSize - ringBuffer->outPtr; //fragSize = ringBuffer->totalSize + (ULONG)(ringBuffer->buffer - ringBuffer->outPtr); //Boris, 18.04.2021 fragSize = (ringBuffer->totalSize + ringBuffer->buffer) - ringBuffer->outPtr; RtlCopyMemory(readBuffer, ringBuffer->outPtr, fragSize); // now get the rest RtlCopyMemory(readBuffer + fragSize, ringBuffer->buffer, byteCount - fragSize); ringBuffer->outPtr = ringBuffer->buffer + byteCount - fragSize; } // // update the current size of the ring buffer. Use spinlock to insure // atomic operation. // // KeAcquireSpinLock(&ringBuffer->spinLock, &oldIrql); ringBuffer->currentSize -= byteCount; // KeReleaseSpinLock(&ringBuffer->spinLock, oldIrql); // MarlinUSB_DbgPrint(1, ("Marlin.sys: ReadRingBuffer() exit\n")); return byteCount; /* SIZE_T availableData=0; SIZE_T dataFromCurrToEnd; SIZE_T DataSize=0; SIZE_T BytesCopied = 0; if(!readBuffer) return 0; if (numberOfBytesToRead == 0) return 0; if (ringBuffer->Head >= ringBuffer->End) return 0; // // Get the amount of data available in the buffer // RingBufferGetAvailableData(ringBuffer, &availableData); if (availableData == 0) return 0; DataSize = numberOfBytesToRead; if (DataSize > availableData) { DataSize = availableData; } BytesCopied = DataSize; if ((ringBuffer->Head + DataSize) > ringBuffer->End) { // // The data requested by the caller is wrapped around the end of the // buffer. So we'll do the copy in two steps - // * Copy X bytes from the current position to the end buffer into // the caller's buffer // * Copy (DataSize - X) bytes from the beginning to the buffer into // the caller's buffer // // // The first step of the copy ... // dataFromCurrToEnd = ringBuffer->End - ringBuffer->Head; RtlCopyMemory(readBuffer, ringBuffer->Head, dataFromCurrToEnd); readBuffer += dataFromCurrToEnd; DataSize -= dataFromCurrToEnd; // // The second step of the copy ... // RtlCopyMemory(readBuffer, ringBuffer->Base, DataSize); // // Advance the head pointer // ringBuffer->Head = ringBuffer->Base + DataSize; } else { // // The data in the buffer is NOT wrapped around the end of the buffer. // Simply copy the data over to the caller's buffer in a single step. // RtlCopyMemory(readBuffer, ringBuffer->Head, DataSize); // // Advance the head pointer // ringBuffer->Head += DataSize; if (ringBuffer->Head == ringBuffer->End) { // // We have exactly reached the end of the buffer. The next // read should wrap around and start from the beginning. // ringBuffer->Head = ringBuffer->Base; } } if (!(ringBuffer->Head < ringBuffer->End)) return 0; return BytesCopied; */ } SIZE_T CUsbPCECGHelper::WriteRingBuffer( PRING_BUFFER ringBuffer, PUCHAR writeBuffer, SIZE_T numberOfBytesToWrite ) /* Routine Description: This routine writes data to a ring buffer. If the requested write size exceeds available space in the ring buffer, then the write is rejected. Arguments: ringBuffer - pointer to a ring buffer structure readBuffer - pointer to a user supplied buffer of data to copy to the ring buffer numberOfBytesToRead - number of bytes to write to the ring buffer Return Value: ULONG - number of bytes written. */ { SIZE_T byteCount; // KIRQL oldIrql; SIZE_T l_currentsize; // KeAcquireSpinLock(&ringBuffer->spinLock, &oldIrql); l_currentsize = ringBuffer->currentSize; // KeReleaseSpinLock(&ringBuffer->spinLock, oldIrql); if (numberOfBytesToWrite > (ringBuffer->totalSize - l_currentsize)) { //MarlinUSB_DbgPrint(1, ("Marlin.sys: WriteRingBuffer() OVERFLOW\n")); return 0; } byteCount = numberOfBytesToWrite; // // two cases. Write either wraps or it doesn't. // Handle the non-wrapped case first // if ((ringBuffer->inPtr + byteCount - 1) < (ringBuffer->buffer + ringBuffer->totalSize)) { RtlCopyMemory(ringBuffer->inPtr, writeBuffer, byteCount); ringBuffer->inPtr += byteCount; if (ringBuffer->inPtr == ringBuffer->buffer + ringBuffer->totalSize) ringBuffer->inPtr = ringBuffer->buffer; } // now handle the wrapped case else { //ULONG fragSize; //Boris, 18.04.2021 (Get error: conversion from '__int64' to 'ULONG', possible loss of data) SIZE_T fragSize; // write the first fragment //Boris, 16.02.2009 ,WDK 6001.18002 build //fragSize = ringBuffer->buffer + ringBuffer->totalSize - ringBuffer->inPtr; //fragSize = ringBuffer->totalSize + (ULONG)(ringBuffer->buffer - ringBuffer->inPtr); //Boris, 18.04.2021 (Get error: conversion from '__int64' to 'ULONG', possible loss of data) fragSize = (ringBuffer->totalSize + ringBuffer->buffer) - ringBuffer->inPtr; RtlCopyMemory(ringBuffer->inPtr, writeBuffer, fragSize); // now write the rest RtlCopyMemory(ringBuffer->buffer, writeBuffer + fragSize, byteCount - fragSize); ringBuffer->inPtr = ringBuffer->buffer + byteCount - fragSize; } // // update the current size of the ring buffer. Use spinlock to insure // atomic operation. // // KeAcquireSpinLock(&ringBuffer->spinLock, &oldIrql); ringBuffer->currentSize += byteCount; // KeReleaseSpinLock(&ringBuffer->spinLock, oldIrql); //MarlinUSB_DbgPrint(1, ("Marlin.sys: WriteRingBuffer() %d bytes\n", byteCount)); return byteCount; /* SIZE_T availableSpace = 0; SIZE_T spaceFromCurrToEnd; SIZE_T bytesToCopy; SIZE_T bytesCopied=0; KIRQL oldIrql; if (!writeBuffer) return 0; if (numberOfBytesToWrite == 0) return 0; if (ringBuffer->Tail >= ringBuffer->End) return 0; // // Get the amount of space available in the buffer // KeAcquireSpinLock(&ringBuffer->spinLock, &oldIrql); RingBufferGetAvailableSpace(ringBuffer, &availableSpace); KeReleaseSpinLock(&ringBuffer->spinLock, oldIrql); // // If there is not enough space to fit in all the data passed in by the // caller then copy as much as possible and throw away the rest // if (availableSpace < numberOfBytesToWrite) { bytesToCopy = availableSpace; } else { bytesToCopy = numberOfBytesToWrite; } bytesCopied = bytesToCopy; if (bytesToCopy) { // // The buffer has some space at least // if ((ringBuffer->Tail + bytesToCopy) > ringBuffer->End) { // // The data being written will wrap around the end of the buffer. // So the copy has to be done in two steps - // * X bytes from current position to end of the buffer // * the remaining (bytesToCopy - X) from the start of the buffer // // // The first step of the copy ... // spaceFromCurrToEnd = ringBuffer->End - ringBuffer->Tail; RtlCopyMemory(ringBuffer->Tail, writeBuffer, spaceFromCurrToEnd); writeBuffer += spaceFromCurrToEnd; bytesToCopy -= spaceFromCurrToEnd; // // The second step of the copy ... // RtlCopyMemory(ringBuffer->Base, writeBuffer, bytesToCopy); // // Advance the tail pointer // ringBuffer->Tail = ringBuffer->Base + bytesToCopy; } else { // // Data does NOT wrap around the end of the buffer. Just copy it // over in a single step // RtlCopyMemory(ringBuffer->Tail, writeBuffer, bytesToCopy); // // Advance the tail pointer // ringBuffer->Tail += bytesToCopy; if (ringBuffer->Tail == ringBuffer->End) { // // We have exactly reached the end of the buffer. The next // write should wrap around and start from the beginning. // ringBuffer->Tail = ringBuffer->Base; } } if (!(ringBuffer->Tail < ringBuffer->End)) return 0; } return bytesCopied; */ } //==========================================================================================================================================================

#define ISOCH_DATA_SIZE_MS 10
#define ISOCH_TRANSFER_COUNT 2 //will need to be at least 2

/*
* My device sends one sample of 2 bytes every 1ms .. => data sample rate = 1000s/s
*
* Problem !!
* Only Transfer 1 has the data all next (ISOCH_TRANSFER_COUNT) are empty
* As a result i see data arriving at sample rate of 1000 / ISOCH_TRANSFER_COUNT in Read application
*
* Why ?????
*
nvUSB.lib: Current Frame number=261744397
nvUSB.lib: bRead() Requested 1200 bytes in 50 packets per transfer.
nvUSB.lib: bRead() Transfer 1 completed. Read 100 bytes.
nvUSB.lib: Current Frame number=261744447
nvUSB.lib: bRead() Requested 1200 bytes in 50 packets per transfer.
nvUSB.lib: bRead() Transfer 2 completed. Read 0 bytes. <-- ??
nvUSB.lib: Current Frame number=261744497
nvUSB.lib: bRead() Requested 1200 bytes in 50 packets per transfer.
nvUSB.lib: bRead() Transfer 1 completed. Read 100 bytes.
nvUSB.lib: Current Frame number=261744547
nvUSB.lib: bRead() Requested 1200 bytes in 50 packets per transfer.
nvUSB.lib: bRead() Transfer 2 completed. Read 0 bytes. <--- ??
nvUSB.lib: Current Frame number=261744597
nvUSB.lib: bRead() Requested 1200 bytes in 50 packets per transfer.
nvUSB.lib: bRead() Transfer 1 completed. Read 100 bytes.
nvUSB.lib: Current Frame number=261744647
nvUSB.lib: bRead() Requested 1200 bytes in 50 packets per transfer.
nvUSB.lib: bRead() Transfer 2 completed. Read 0 bytes.
nvUSB.lib: Current Frame number=261744697

USB Companion Controller Problem

Paul_Gregg — Sun, 21 Feb 2021 17:15:17 GMT

I'm hoping I can find some help here. I have multiple USB 3.0 controllers, both on my motherboard and on two PCI-E 1.0 boards, and all of them recognize USB 3.0 devices as USB 2.0. I am including two USB Viewer snapshots that show the device (Samsung Odyssey Plus WMR headset) plugged into two different USB sources. The tree viewer does show the companion USB 3.0 ports, but neither the motherboard nor the PCI-E boards will connect my device to the USB 3.0 controllers. I don't think its a hardware issue because this issue is happening on two different types of hardware. This has effectively made the USB 3.0 audio headphones on the WMR headset unusable.

I have updated my BIOS and all of my drivers, and cannot find the problem. I've also found posts like this (Reasons to avoid companion controllers - Microsoft Tech Community) that urge hardware developers not to use companion controllers. Any suggested solutions would be very much appreciated. Thank you!

Capturing HID data in ETW traces

PaulAttryde — Fri, 12 Feb 2021 01:39:59 GMT

Can someone give some current hints on how to capture HID data for a USB device?

I started this quest using Logman to create an ETW session using the Microsoft-Windows-USB-USBPORT and Microsoft-Windows-USB-USBHUB providers from Windows 10, but although I get a ETL file with USB information in it I'm not seeing the actual data going to/from the device.

I then found a blog recommending to use the GUIDs for HidClass and HidUSB, but I get the same result then as well. This article (https://techcommunity.microsoft.com/t5/microsoft-usb-blog/how-to-capture-and-read-hid-traces-in-windows-8-1/ba-p/270839) doesn't go into much depth on viewing the ETL file, and I see that both Network Monitor and Message Analyser have been EOLd. Is TraceView really the only way we're meant to view the files now? And where does one go in 2021 to get the most recent copy?

No admin rights for external hard drives and USB

ChleeN — Fri, 04 Sep 2020 11:48:16 GMT

I have a USB drive on the laptop. Strangely, I have no access to external drives. Keyboard and connection with the mobile phone via drive is possible. I have the latest Windows update. I suspected the problem was with the security settings or registers. Unfortunately, I have no idea what I can do to solve the problem. Windows support couldn't help either.

slow USB 2.0 bulk transfer on Windows 10

megabite — Wed, 11 Mar 2020 19:05:44 GMT

We are moving our USB 2.0 device from a custom driver to WinUSB. The device must continue to work with both the older driver and the new WinUSB approach so changing to isochronous for example would not be possible.

In our testing we are seeing significantly slower bulk transfer speeds on Windows 10 vs Windows 7 - Windows 10 takes approximately 60% longer to transfer. This same slowdown occurs whether we use the older custom driver or WinUSB.

Our data is not large = ~10 Mb/s (1 Mb every 10 Hz revolution, i.e. 100 ms)

In our base tests, we transfer two blocks of 470K, one block of 54k, and a final block of 107k.

On Windows 7, each 470k blocks take just over 18 ms to transfer - overall ~43 ms for 1.1 Mb transfer

On Windows 10, each 470k blocks take just over 29 ms to transfer == 61% longer - overall ~70 ms for 1.1 Mb transfer

These times were verified using tracing on the device running under JTAG control as well as a USB 3 analyzer.

Is there any knowledge, any information, any suggestions for the cause and possible solution for this significant difference in bulk transfer speeds? TIA!

slow USB bulk transfers on Windows 10

megabite — Wed, 11 Mar 2020 18:53:22 GMT

Our data is not large = ~10 Mb/s (1 Mb every 10 Hz revolution, i.e. 100 ms)

In our base tests, we transfer two blocks of 470K, one block of 54k, and a final block of 107k.

On Windows 7, each 470k blocks take just over 18 ms to transfer - overall transfer of 1.1 Mb takes about 43 ms

On Windows 10, each 470k blocks take just over 29 ms to transfer == 61% longer - overall transfer of 1.1 Mb takes about 70 ms

Is there any knowledge, any information, any suggestions for the cause and possible solution for this significant difference in bulk transfer speeds? TIA!

Introducing the USB4™ Switch

Philip Froese — Fri, 10 Jan 2020 17:44:32 GMT

As part of the MUTT (Microsoft USB Test Tool) family and a follow-on to the USB Type-C Connection Exerciser, we are excited to introduce the USB4 Switch: a USB Type-C 1:2 programmable switch, compatible with USB4 as well as older protocols such as Thunderbolt™ 3, USB 3.2, USB Type-C Alternate Modes, and of course Power Delivery.

The USB4 Switch automates connect-disconnect of a USB Type-C port and will be used in stress testing, switching between peripherals (for example, a dock and a display), or any automated reconfiguration of a USB Type-C port. It is compatible with the Connection Exerciser tools and scripts and integrates with the Hardware Lab Kit (HLK) test content.

It will be a required test device for Windows Certification through the HLK but is highly recommended for use much earlier in your hardware development cycle as well. In our experience, long-run randomized switching on a USB Type-C port is highly effective in exposing bugs in the hardware-firmware-software stack, both in the USB Type-C controller as well as the underlying data protocols. We expect the USB4 Switch to have similar value in the development and validation of USB4 hardware and software.

The device is available to purchase from our partners at MCCI at https://mcci.com/usb/dev-tools/model-3141/

For UCSI based systems we recommended to perform testing with some additional settings to help discover firmware bugs. Please see “Converting firmware failures to bugchecks” in this blog post.

UCSI based USB Type-C systems may see a shutdown delay if connect changes race with power transition

Philip Froese — Tue, 25 Jun 2019 18:42:50 GMT

My system takes a long time to power down if a USB Type-C device, dock, or charger is plugged in or unplugged during the power transition.

A bug in the USB Type-C Connector System Software Interface (UCSI) software implementation in Windows 10, version 1809 can cause a 60 second delay in the system sleep or shutdown process if the power-down happens while the UCSI software is busy handling a new connect or disconnect event on a USB Type-C port. Apart from the extra one minute the sleep or shutdown process takes in this circumstance, this bug does not affect normal functionality of USB Type-C on your machine. The system and the USB Type-C ports should continue to function properly after the next wake or restart of the system.

Edits based on feedback:

1) This is resolved in Windows 10 version 1903, please update to the latest released build if you are impacted by this bug.

2) The issue described only affects Windows 10 version 1809 (17763) and is fixed in 1903.

3) Please use the Feedback Hub for further feedback or questions.