use super::UsbSpeed;
use std::collections::HashMap;
pub(crate) fn negotiated_speeds() -> HashMap<String, UsbSpeed> {
let mut out = HashMap::new();
let hubs = enumerate_hub_paths();
if hubs.is_empty() {
return out;
}
let devices = enumerate_usb_devnodes();
let mut by_devnode: HashMap<u32, UsbSpeed> = HashMap::new();
for (devinst, _) in &devices {
if let Some(speed) = read_speed(*devinst, &hubs) {
by_devnode.insert(*devinst, speed);
}
}
for (devinst, id) in &devices {
let speed = match by_devnode.get(devinst) {
Some(speed) => *speed,
None => {
let Some(speed) = inherit_from_ancestor(*devinst, &by_devnode) else {
continue;
};
speed
}
};
out.insert(id.to_uppercase(), speed);
}
out
}
fn inherit_from_ancestor(devinst: u32, known: &HashMap<u32, UsbSpeed>) -> Option<UsbSpeed> {
use windows::Win32::Devices::DeviceAndDriverInstallation::{CM_Get_Parent, CR_SUCCESS};
let mut node = devinst;
for _ in 0..8 {
let mut parent = 0u32;
if unsafe { CM_Get_Parent(&mut parent, node, 0) } != CR_SUCCESS {
return None;
}
if let Some(speed) = known.get(&parent) {
return Some(*speed);
}
node = parent;
}
None
}
fn enumerate_hub_paths() -> HashMap<u32, Vec<u16>> {
use windows::core::PCWSTR;
use windows::Win32::Devices::DeviceAndDriverInstallation::{
SetupDiDestroyDeviceInfoList, SetupDiEnumDeviceInterfaces, SetupDiGetClassDevsW,
SetupDiGetDeviceInterfaceDetailW, DIGCF_DEVICEINTERFACE, DIGCF_PRESENT,
SP_DEVICE_INTERFACE_DATA, SP_DEVICE_INTERFACE_DETAIL_DATA_W, SP_DEVINFO_DATA,
};
use windows::Win32::Devices::Usb::GUID_DEVINTERFACE_USB_HUB;
let mut hubs = HashMap::new();
unsafe {
let Ok(set) = SetupDiGetClassDevsW(
Some(&GUID_DEVINTERFACE_USB_HUB),
PCWSTR::null(),
None,
DIGCF_PRESENT | DIGCF_DEVICEINTERFACE,
) else {
return hubs;
};
let mut index = 0u32;
loop {
let mut iface = SP_DEVICE_INTERFACE_DATA {
cbSize: std::mem::size_of::<SP_DEVICE_INTERFACE_DATA>() as u32,
..Default::default()
};
if SetupDiEnumDeviceInterfaces(set, None, &GUID_DEVINTERFACE_USB_HUB, index, &mut iface)
.is_err()
{
break;
}
index += 1;
let mut needed = 0u32;
let _ = SetupDiGetDeviceInterfaceDetailW(set, &iface, None, 0, Some(&mut needed), None);
if needed == 0 {
continue;
}
let mut buf = vec![0u8; needed as usize];
let detail = buf.as_mut_ptr() as *mut SP_DEVICE_INTERFACE_DETAIL_DATA_W;
(*detail).cbSize = std::mem::size_of::<SP_DEVICE_INTERFACE_DETAIL_DATA_W>() as u32;
let mut info = SP_DEVINFO_DATA {
cbSize: std::mem::size_of::<SP_DEVINFO_DATA>() as u32,
..Default::default()
};
if SetupDiGetDeviceInterfaceDetailW(
set,
&iface,
Some(detail),
needed,
None,
Some(&mut info),
)
.is_err()
{
continue;
}
let ptr = std::ptr::addr_of!((*detail).DevicePath) as *const u16;
let mut len = 0usize;
while *ptr.add(len) != 0 {
len += 1;
}
let mut path = std::slice::from_raw_parts(ptr, len).to_vec();
path.push(0);
hubs.insert(info.DevInst, path);
}
let _ = SetupDiDestroyDeviceInfoList(set);
}
hubs
}
fn enumerate_usb_devnodes() -> Vec<(u32, String)> {
use windows::core::PCWSTR;
use windows::Win32::Devices::DeviceAndDriverInstallation::{
CM_Get_Device_IDW, SetupDiDestroyDeviceInfoList, SetupDiEnumDeviceInfo,
SetupDiGetClassDevsW, CR_SUCCESS, DIGCF_ALLCLASSES, DIGCF_PRESENT, SP_DEVINFO_DATA,
};
let mut devices = Vec::new();
for enumerator in ["USB", "USBSTOR"] {
let wide: Vec<u16> = enumerator
.encode_utf16()
.chain(std::iter::once(0))
.collect();
unsafe {
let Ok(set) = SetupDiGetClassDevsW(
None,
PCWSTR(wide.as_ptr()),
None,
DIGCF_PRESENT | DIGCF_ALLCLASSES,
) else {
continue;
};
let mut index = 0u32;
loop {
let mut info = SP_DEVINFO_DATA {
cbSize: std::mem::size_of::<SP_DEVINFO_DATA>() as u32,
..Default::default()
};
if SetupDiEnumDeviceInfo(set, index, &mut info).is_err() {
break;
}
index += 1;
let mut buf = [0u16; 512];
if CM_Get_Device_IDW(info.DevInst, &mut buf, 0) != CR_SUCCESS {
continue;
}
let len = buf.iter().position(|&c| c == 0).unwrap_or(buf.len());
devices.push((info.DevInst, String::from_utf16_lossy(&buf[..len])));
}
let _ = SetupDiDestroyDeviceInfoList(set);
}
}
devices
}
fn read_speed(devinst: u32, hubs: &HashMap<u32, Vec<u16>>) -> Option<UsbSpeed> {
use windows::core::PCWSTR;
use windows::Win32::Devices::DeviceAndDriverInstallation::{
CM_Get_DevNode_Registry_PropertyW, CM_Get_Parent, CM_DRP_ADDRESS, CR_SUCCESS,
};
use windows::Win32::Devices::Usb::{
IOCTL_USB_GET_NODE_CONNECTION_INFORMATION_EX, USB_NODE_CONNECTION_INFORMATION_EX,
};
use windows::Win32::Foundation::CloseHandle;
use windows::Win32::Storage::FileSystem::{
CreateFileW, FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ, FILE_SHARE_WRITE, OPEN_EXISTING,
};
use windows::Win32::System::IO::DeviceIoControl;
let mut port = 0u32;
let mut len = std::mem::size_of::<u32>() as u32;
let mut ty = 0u32;
let got_port = unsafe {
CM_Get_DevNode_Registry_PropertyW(
devinst,
CM_DRP_ADDRESS,
Some(&mut ty),
Some(&mut port as *mut u32 as *mut std::ffi::c_void),
&mut len,
0,
)
};
if got_port != CR_SUCCESS {
return None;
}
let mut parent = 0u32;
if unsafe { CM_Get_Parent(&mut parent, devinst, 0) } != CR_SUCCESS {
return None;
}
let hub_path = hubs.get(&parent)?;
let handle = unsafe {
CreateFileW(
PCWSTR(hub_path.as_ptr()),
0,
FILE_SHARE_READ | FILE_SHARE_WRITE,
None,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
None,
)
}
.ok()?;
let mut info = USB_NODE_CONNECTION_INFORMATION_EX {
ConnectionIndex: port,
..Default::default()
};
let size = std::mem::size_of::<USB_NODE_CONNECTION_INFORMATION_EX>() as u32;
let mut returned = 0u32;
let result = unsafe {
DeviceIoControl(
handle,
IOCTL_USB_GET_NODE_CONNECTION_INFORMATION_EX,
Some(&mut info as *mut _ as *mut std::ffi::c_void),
size,
Some(&mut info as *mut _ as *mut std::ffi::c_void),
size,
Some(&mut returned),
None,
)
};
unsafe {
let _ = CloseHandle(handle);
}
result.ok()?;
speed_from_code(info.Speed)
}
fn speed_from_code(code: u8) -> Option<UsbSpeed> {
match code {
0 => Some(UsbSpeed::Low),
1 => Some(UsbSpeed::Full),
2 => Some(UsbSpeed::High),
3 => Some(UsbSpeed::Super),
_ => None,
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn an_unknown_speed_code_is_absent_rather_than_slow() {
assert_eq!(speed_from_code(0), Some(UsbSpeed::Low));
assert_eq!(speed_from_code(1), Some(UsbSpeed::Full));
assert_eq!(speed_from_code(2), Some(UsbSpeed::High));
assert_eq!(speed_from_code(3), Some(UsbSpeed::Super));
for unknown in 4..=u8::MAX {
assert_eq!(
speed_from_code(unknown),
None,
"code {unknown} is not a speed this build knows"
);
}
}
}