How to get drive letter from USB VID and PID

Jonathan Woodward 26 Reputation points
2022-01-18T09:25:30.48+00:00

Hello

I have written a C++ application which is able to detect multiple USB VID and PID devices upon insertion and removal by matching "USB\VID_%04X&PID_%04X". From this how am I able to find which drive letter the USB storage has mounted on?

The drive, letter D:// is a UF2, fat filesystem which I am using to flash upgrade an embedded device. On my Windows system this shows up under "Portable Devices" in "Device Manager".

Device SWD\WPDBUSENUM_??_USBSTOR#Disk&Ven_Logger&Prod_&Rev_1.00#9&319384a2&0&24842CB953324D5946202020FF170720&0#{53f56307-b6bf-11d0-94f2-00a0c91efb8b}

If I view the properties of the D:// drive I can get the following information under properties, events:

Device USBSTOR\Disk&Ven_Logger&Prod_&Rev_1.00\9&319384a2&0&24842CB953324D5946202020FF170720&0 was configured.

Driver Name: disk.inf
Class Guid: {4d36e967-e325-11ce-bfc1-08002be10318}
Driver Date: 06/21/2006
Driver Version: 10.0.19041.789
Driver Provider: Microsoft
Driver Section: disk_install.NT
Driver Rank: 0xFF0006
Matching Device Id: GenDisk
Outranked Drivers: disk.inf:GenDisk:00FF2002
Device Updated: false
Parent Device: USB\VID_17DE&PID_00FF&MI_02\8&1d8b0748&0&0002

Any direction how I can achieve the above in C++ would grateful.

Thanks
J

C++
C++
A high-level, general-purpose programming language, created as an extension of the C programming language, that has object-oriented, generic, and functional features in addition to facilities for low-level memory manipulation.
3,524 questions
{count} votes

Accepted answer
  1. Castorix31 81,481 Reputation points
    2022-01-18T18:30:48.937+00:00

    I did this test on my PC (in C++ as you tagged C++...) by enumerating disk drives; I get :

    DeviceID : SCSI\DISK&VEN_ATA&PROD_ST1000DM003-1SB1\4&38FBD192&0&000000                                                                                                                                                                 
        Parent DeviceID : PCI\VEN_8086&DEV_8C02&SUBSYS_B0051458&REV_05\3&11583659&0&FA
        Drive Letters : D:, E:, C:                                                                                                                                      
    DeviceID : USBSTOR\DISK&VEN__USB&PROD__SANDISK_3.2GEN1&REV_1.00\010130EBADCCCEFA5A8FF9F68DAD45551D020722931C25CB45700559C9CEEC9                                   
        Parent DeviceID : USB\VID_0781&PID_5591\010130EBADCCCEFA5A8FF9F68DAD45551D020722931C25CB45700559C9CEEC9080A500000000000000000000CE43F2EEFF0A250091558107B8A8A55D
        Drive Letters : H:   
    

    Test code :

    HANDLE hDevice = NULL;
    HDEVINFO DeviceInfoSet = SetupDiGetClassDevs(&GUID_DEVINTERFACE_DISK, NULL, NULL, DIGCF_DEVICEINTERFACE | DIGCF_PRESENT);                
    SP_DEVINFO_DATA DeviceInfoData;
    DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
    for (DWORD dwDeviceIndex = 0; SetupDiEnumDeviceInfo(DeviceInfoSet, dwDeviceIndex, &DeviceInfoData); dwDeviceIndex++)
    {
        SP_DEVICE_INTERFACE_DATA DeviceInterfaceData;
        DeviceInterfaceData.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
        for (DWORD dwMemberIndex = 0; SetupDiEnumDeviceInterfaces(DeviceInfoSet, &DeviceInfoData, &GUID_DEVINTERFACE_DISK, dwMemberIndex, &DeviceInterfaceData); dwMemberIndex++)
        {
            DWORD dwDeviceInterfaceDetailDataSize = offsetof(SP_DEVICE_INTERFACE_DETAIL_DATA, DevicePath) + MAX_PATH * sizeof(TCHAR);
            PSP_DEVICE_INTERFACE_DETAIL_DATA pDeviceInterfaceDetailData = (PSP_DEVICE_INTERFACE_DETAIL_DATA)new BYTE[dwDeviceInterfaceDetailDataSize];
            pDeviceInterfaceDetailData->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
            if (SetupDiGetDeviceInterfaceDetail(DeviceInfoSet, &DeviceInterfaceData, pDeviceInterfaceDetailData, dwDeviceInterfaceDetailDataSize, NULL, NULL))
            {
                CONFIGRET cRet;
                DEVINST hDevInst = DeviceInfoData.DevInst;
                DEVINST hParentDevInst;
                cRet = CM_Get_Parent(&hParentDevInst, hDevInst, 0);
                TCHAR wsParentDeviceID[MAX_DEVICE_ID_LEN];
                cRet = CM_Get_Device_ID(hParentDevInst, wsParentDeviceID, sizeof(wsParentDeviceID) / sizeof(TCHAR), 0);
                TCHAR wsDeviceID[MAX_DEVICE_ID_LEN];
                cRet = CM_Get_Device_ID(hDevInst, wsDeviceID, sizeof(wsDeviceID) / sizeof(TCHAR), 0);
    
                WCHAR wsText[MAX_PATH] = L"";
                wsprintf(wsText, L"DeviceID : %s\r\n", wsDeviceID); // 1 PowerDeviceD0
                OutputDebugString(wsText);
                wsprintf(wsText, L"\tParent DeviceID : %s\r\n", wsParentDeviceID); // 1 PowerDeviceD0
                OutputDebugString(wsText);
               /* hDevice = CreateFile(pDeviceInterfaceDetailData->DevicePath, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
                if (hDevice != INVALID_HANDLE_VALUE)
                {
                }*/
                WCHAR wsDriveLetters[MAX_PATH] = L"";
                GetDriveLettersFromDevInstID(wsDeviceID, wsDriveLetters);
                wsprintf(wsText, L"\tDrive Letters : %s\r\n", wsDriveLetters); // 1 PowerDeviceD0
                OutputDebugString(wsText);
            }
        }
    }   
    

    Utility functions :

    void GetDriveLettersFromDevInstID(LPCTSTR pwsDeviceInstanceID, __out LPTSTR pwsDriveLetters)                                                                               
    {                                                                                                                                                                          
        pwsDriveLetters[0] = 0;                                                                                                                                                
        HRESULT hr = CoInitializeEx(0, COINIT_MULTITHREADED);                                                                                                                  
        if (SUCCEEDED(hr))                                                                                                                                                     
        {                                                                                                                                                                      
            // hr = 0x80010119                                                                                                                                                 
            hr = CoInitializeSecurity(NULL,                                                                                                                                    
                -1,                          // COM authentication                                                                                                             
                NULL,                        // Authentication services                                                                                                        
                NULL,                        // Reserved                                                                                                                       
                RPC_C_AUTHN_LEVEL_NONE,      // RPC_C_AUTHN_LEVEL_DEFAULT,   // Default authentication                                                                         
                RPC_C_IMP_LEVEL_IMPERSONATE, // Default Impersonation                                                                                                          
                NULL,                        // Authentication info                                                                                                            
                EOAC_NONE,                   // Additional capabilities                                                                                                        
                NULL                         // Reserved                                                                                                                       
            );                                                                                                                                                                 
            if (SUCCEEDED(hr))                                                                                                                                                 
            {                                                                                                                                                                  
                IWbemLocator* pLoc = NULL;                                                                                                                                     
                hr = CoCreateInstance(CLSID_WbemLocator, 0, CLSCTX_INPROC_SERVER, IID_IWbemLocator, (LPVOID*)&pLoc);                                                           
                if (SUCCEEDED(hr))                                                                                                                                             
                {                                                                                                                                                              
                    IWbemServices* pSvc = NULL;                                                                                                                                
                    hr = pLoc->ConnectServer(bstr_t(L"ROOT\\CIMV2"), NULL, NULL, NULL, 0, NULL, NULL, &pSvc);                                                                  
                    if (SUCCEEDED(hr))                                                                                                                                         
                    {                                                                                                                                                          
                        hr = CoSetProxyBlanket(                                                                                                                                
                            pSvc,                        // Indicates the proxy to set                                                                                         
                            RPC_C_AUTHN_DEFAULT,         // RPC_C_AUTHN_WINNT,  // RPC_C_AUTHN_xxx                                                                             
                            RPC_C_AUTHZ_NONE,            // RPC_C_AUTHZ_xxx                                                                                                    
                            NULL,                        // Server principal name                                                                                              
                            RPC_C_AUTHN_LEVEL_CALL,      // RPC_C_AUTHN_LEVEL_xxx                                                                                              
                            RPC_C_IMP_LEVEL_IMPERSONATE, // RPC_C_IMP_LEVEL_xxx                                                                                                
                            NULL,                        // client identity                                                                                                    
                            EOAC_NONE                    // proxy capabilities                                                                                                 
                        );                                                                                                                                                     
                        if (SUCCEEDED(hr))                                                                                                                                     
                        {                                                                                                                                                      
                            WCHAR wsQuery[MAX_PATH] = L"";                                                                                                                     
                            lstrcpy(wsQuery, L"SELECT * FROM Win32_DiskDrive where PNPDeviceID='");                                                                            
                            lstrcat(wsQuery, pwsDeviceInstanceID);                                                                                                             
                            lstrcat(wsQuery, L"'");                                                                                                                            
                            StrReplace(wsQuery, L"\\", L"\\\\", ARRAYSIZE(wsQuery));                                                                                           
                            IEnumWbemClassObject* pWbemEnum = NULL;                                                                                                            
                            hr = pSvc->ExecQuery(bstr_t("WQL"),                                                                                                                
                                bstr_t(wsQuery),                                                                                                                               
                                WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, NULL, &pWbemEnum);                                                                      
                            if (SUCCEEDED(hr))                                                                                                                                 
                            {                                                                                                                                                  
                                IWbemClassObject* pclsObj;                                                                                                                     
                                ULONG uReturn = 0;                                                                                                                             
                                int nCount = 0;                                                                                                                                
                                while (pWbemEnum)                                                                                                                              
                                {                                                                                                                                              
                                    hr = pWbemEnum->Next(WBEM_INFINITE, 1, &pclsObj, &uReturn);                                                                                
                                    // 0x80041010  Invalid class WBEM_E_INVALID_CLASS                                                                                          
                                    // 2147749911 (0x80041017) WBEM_E_INVALID_QUERY                                                                                            
                                    if (0 == uReturn)                                                                                                                          
                                    {                                                                                                                                          
                                        break;                                                                                                                                 
                                    }                                                                                                                                          
    
                                    VARIANT vtProp;                                                                                                                            
                                    VariantInit(&vtProp);                                                                                                                      
                                    hr = pclsObj->Get(L"DeviceID", 0, &vtProp, 0, 0);                                                                                          
                                    WCHAR wsDeviceID[255] = L"";                                                                                                               
                                    wsprintf(wsDeviceID, L"%s", vtProp.bstrVal);                                                                                               
                                    VariantClear(&vtProp);                                                                                                                     
                                    lstrcpy(wsQuery, L"ASSOCIATORS OF {Win32_DiskDrive.DeviceID='");                                                                           
                                    lstrcat(wsQuery, wsDeviceID);                                                                                                              
                                    lstrcat(wsQuery, L"'");                                                                                                                    
                                    lstrcat(wsQuery, L"} WHERE AssocClass = Win32_DiskDriveToDiskPartition");                                                                  
                                    //lstrcpy(wsQuery, L"ASSOCIATORS OF {Win32_DiskDrive.DeviceID='\\\\.\\PHYSICALDRIVE0'} WHERE AssocClass = Win32_DiskDriveToDiskPartition");
    
                                    IEnumWbemClassObject* pWbemEnum2 = NULL;                                                                                                   
                                    hr = pSvc->ExecQuery(bstr_t("WQL"),                                                                                                        
                                        bstr_t(wsQuery),                                                                                                                       
                                        WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, NULL, &pWbemEnum2);                                                             
                                    StrReplace(wsQuery, L"\\", L"\\\\", ARRAYSIZE(wsQuery));                                                                                   
                                    // ASSOCIATORS OF {Win32_DiskDrive.DeviceID= "\\\\.\\PHYSICALDRIVE1"} WHERE AssocClass = Win32_DiskDriveToDiskPartition                    
                                    // hr = 0x8004103a WBEM_E_INVALID_OBJECT_PATH 2147749946 (0x8004103A)                                                                      
                                    if (SUCCEEDED(hr))                                                                                                                         
                                    {                                                                                                                                          
                                        IWbemClassObject* pclsObj2;                                                                                                            
                                        ULONG uReturn2 = 0;                                                                                                                    
                                        while (pWbemEnum2)                                                                                                                     
                                        {                                                                                                                                      
                                            hr = pWbemEnum2->Next(WBEM_INFINITE, 1, &pclsObj2, &uReturn2);                                                                     
                                            if (0 == uReturn2)                                                                                                                 
                                            {                                                                                                                                  
                                                break;                                                                                                                         
                                            }                                                                                                                                  
                                            VARIANT vtProp;                                                                                                                    
                                            VariantInit(&vtProp);                                                                                                              
                                            hr = pclsObj2->Get(L"DeviceID", 0, &vtProp, 0, 0);                                                                                 
                                            WCHAR wsPartitionDeviceID[255] = L"";                                                                                              
                                            wsprintf(wsPartitionDeviceID, L"%s", vtProp.bstrVal);                                                                              
                                            VariantClear(&vtProp);                                                                                                             
    
                                            lstrcpy(wsQuery, L"ASSOCIATORS Of {Win32_DiskPartition.DeviceID='");                                                               
                                            lstrcat(wsQuery, wsPartitionDeviceID);                                                                                             
                                            lstrcat(wsQuery, L"'");                                                                                                            
                                            lstrcat(wsQuery, L"} WHERE AssocClass = Win32_LogicalDiskToPartition");                                                            
                                            IEnumWbemClassObject* pWbemEnum3 = NULL;                                                                                           
                                            hr = pSvc->ExecQuery(bstr_t("WQL"),                                                                                                
                                                bstr_t(wsQuery),                                                                                                               
                                                WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, NULL, &pWbemEnum3);                                                     
                                            StrReplace(wsQuery, L"\\", L"\\\\", ARRAYSIZE(wsQuery));                                                                           
                                            if (SUCCEEDED(hr))                                                                                                                 
                                            {                                                                                                                                  
                                                IWbemClassObject* pclsObj3;                                                                                                    
                                                ULONG uReturn3 = 0;                                                                                                            
                                                while (pWbemEnum3)                                                                                                             
                                                {                                                                                                                              
                                                    hr = pWbemEnum3->Next(WBEM_INFINITE, 1, &pclsObj3, &uReturn3);                                                             
                                                    if (0 == uReturn3)                                                                                                         
                                                    {                                                                                                                          
                                                        break;                                                                                                                 
                                                    }                                                                                                                          
                                                    VARIANT vtProp;                                                                                                            
                                                    VariantInit(&vtProp);                                                                                                      
                                                    hr = pclsObj3->Get(L"DeviceID", 0, &vtProp, 0, 0);                                                                         
                                                    WCHAR sLogicalDeviceID[255] = L"";                                                                                         
                                                    wsprintf(sLogicalDeviceID, L"%s", vtProp.bstrVal);                                                                         
                                                    VariantClear(&vtProp);                                                                                                     
    
                                                    if (lstrcmp(pwsDriveLetters, L"") == 0)                                                                                    
                                                    {                                                                                                                          
                                                        lstrcat(pwsDriveLetters, sLogicalDeviceID);                                                                            
                                                    }                                                                                                                          
                                                    else                                                                                                                       
                                                    {                                                                                                                          
                                                        lstrcat(pwsDriveLetters, L", ");                                                                                       
                                                        lstrcat(pwsDriveLetters, sLogicalDeviceID);                                                                            
                                                    }                                                                                                                          
                                                    pclsObj3->Release();                                                                                                       
                                                }                                                                                                                              
                                                pWbemEnum3->Release();                                                                                                         
                                            }                                                                                                                                  
                                            pclsObj2->Release();                                                                                                               
                                        }                                                                                                                                      
                                        pWbemEnum2->Release();                                                                                                                 
                                    }                                                                                                                                          
    
                                    nCount++;                                                                                                                                  
                                    pclsObj->Release();                                                                                                                        
                                }                                                                                                                                              
                                pWbemEnum->Release();                                                                                                                          
                            }                                                                                                                                                  
                        }                                                                                                                                                      
                        pSvc->Release();                                                                                                                                       
                    }                                                                                                                                                          
                    pLoc->Release();                                                                                                                                           
                }                                                                                                                                                              
            }                                                                                                                                                                  
            CoUninitialize();                                                                                                                                                  
        }                                                                                                                                                                      
    }                                                                                                                                                                          
    
    
    int StrReplace(LPCTSTR sStringReplace, LPCTSTR sOldStr, LPCTSTR sNewStr, int nStringLengthMax)                                                                             
    {                                                                                                                                                                          
        int nNewLength = lstrlen(sNewStr);                                                                                                                                     
        int nOldLength = lstrlen(sOldStr);                                                                                                                                     
        int nStringLength = lstrlen(sStringReplace);                                                                                                                           
        LPCTSTR pCharRep;                                                                                                                                                      
        if ((pCharRep = wcsstr(sStringReplace, sOldStr)) == NULL)                                                                                                              
            return -1;                                                                                                                                                         
        int nAdd = 0;                                                                                                                                                          
        while (pCharRep != NULL)                                                                                                                                               
        {                          
    
    2 people found this answer helpful.

3 additional answers

Sort by: Most helpful
  1. Docs 15,141 Reputation points
    2022-01-18T15:24:54.32+00:00

    This third party software may be useful:

    https://www.nirsoft.net/utils/usb_devices_view.html
    https://www.nirsoft.net/utils/usbdeview-x64.zip

    .
    .
    .
    .
    .

    Please remember to vote and to mark the replies as answers if they help.

    On the bottom of each post there is:

    Propose as answer = answered the question

    On the left side of each post there is /\ with a number: click = a helpful post
    .
    .
    .
    .
    .

    0 comments No comments

  2. Jonathan Woodward 26 Reputation points
    2022-01-18T16:37:23.207+00:00

    I have 2 removable devices attached one of which I can match to a drive and the other not.

    0, VID = USB\VID_17DE&PID_00FF&MI_02\8&1D8B0748&0&0002, Drive = Unknown
    1, VID = USB\VID_30DE&PID_6544\0022CFF653ECC411A350A2F9, Drive = F:

    PS C:\Users\jonathan.woodward> Get-WmiObject -ClassName Win32_USBHub | Select-Object DeviceID, PNPDeviceID, Description

    DeviceID PNPDeviceID Description


    USB\VID_17DE&PID_00FF\24842CB953324D5946202020FF170720 USB\VID_17DE&PID_00FF\24842CB953324D5946202020FF170720 USB Composite Device
    USB\VID_17DE&PID_00FF&MI_02\8&1D8B0748&0&0002 USB\VID_17DE&PID_00FF&MI_02\8&1D8B0748&0&0002 USB Mass Storage Device

    USB\VID_03EB&PID_2141\J42700037974 USB\VID_03EB&PID_2141\J42700037974 USB Composite Device
    USB\VID_30DE&PID_6544\0022CFF653ECC411A350A2F9 USB\VID_30DE&PID_6544\0022CFF653ECC411A350A2F9 USB Mass Storage Device

    PS C:\Users\jonathan.woodward> Get-WmiObject -ClassName Win32_DiskDrive | Select-Object DeviceID, PNPDeviceID, Description

    DeviceID PNPDeviceID Description


    \.\PHYSICALDRIVE1 USBSTOR\DISK&VEN_LOGGER&PROD_&REV_1.00\9&319384A2&0&24842CB953324D5946202020FF170720&0 Disk drive
    \.\PHYSICALDRIVE2 USBSTOR\DISK&VEN_KIOXIA&PROD_TRANSMEMORY&REV_1.00\0022CFF653ECC411A350A2F9&0 Disk drive

    For whatever reason VID_17DE does not show me the link the other one does however it is somehow mapped to D: drive.

    This is how I get the link for the other drive:

        public static USBDevice Get(string pnpDeviceId)
        {
            if (pnpDeviceId == null)
                throw new ArgumentNullException("pnpDeviceId");
    
            IntPtr hDevInfo = SetupDiGetClassDevs(IntPtr.Zero, pnpDeviceId, IntPtr.Zero, DIGCF.DIGCF_ALLCLASSES | DIGCF.DIGCF_DEVICEINTERFACE);
            if (hDevInfo == (IntPtr)INVALID_HANDLE_VALUE)
                throw new Win32Exception(Marshal.GetLastWin32Error());
    
            SP_DEVINFO_DATA data = new SP_DEVINFO_DATA();
            data.cbSize = Marshal.SizeOf(data);
            if (!SetupDiEnumDeviceInfo(hDevInfo, 0, ref data))
            {
                int err = Marshal.GetLastWin32Error();
                if (err == ERROR_NO_MORE_ITEMS)
                    return null;
    
                throw new Win32Exception(err);
            }
    
            return new USBDevice(hDevInfo, data) { PnpDeviceId = pnpDeviceId };
        }
    

    But it returns null...

            using (USBDevice device = USBDevice.Get(PnpDeviceID))
            {
                if (device != null)
                {
                    // Get children devices
                    foreach (string childDeviceId in device.ChildrenPnpDeviceIds)
                    {
                        // Get the drive object that correspond to this id (escape the id)
                        foreach (ManagementObject drive in new ManagementObjectSearcher("SELECT DeviceID FROM Win32_DiskDrive WHERE PNPDeviceID='" + childDeviceId.Replace(@"\", @"\\") + "'").Get())
                        {
                            // Associate physical disks with partitions
                            foreach (ManagementObject partition in new ManagementObjectSearcher("ASSOCIATORS OF {Win32_DiskDrive.DeviceID='" + drive["DeviceID"] + "'} WHERE AssocClass=Win32_DiskDriveToDiskPartition").Get())
                            {
                                // Associate partitions with logical disks (drive letter volumes)
                                foreach (ManagementObject disk in new ManagementObjectSearcher("ASSOCIATORS OF {Win32_DiskPartition.DeviceID='" + partition["DeviceID"] + "'} WHERE AssocClass=Win32_LogicalDiskToPartition").Get())
                                {
                                    yield return (string)disk["DeviceID"];
                                }
                            }
                        }
                    }
                }
            }
    
    0 comments No comments

  3. Jonathan Woodward 26 Reputation points
    2022-01-18T17:03:19.23+00:00

    The PnPEntity is USB\VID_17DE&PID_00FF&MI_03\8&1D8B0748&0&0003 and not USB\VID_17DE&PID_00FF&MI_02\8&1D8B0748&0&0002 how can this happen?

    PS C:\Users\jonathan.woodward> Get-WmiObject Win32_PnPEntity -Filter 'DeviceID = "USB\VID_17DE&PID_00FF&MI_03\8&1D8B0748&0&0003"'

    __GENUS : 2
    __CLASS : Win32_PnPEntity
    __SUPERCLASS : CIM_LogicalDevice
    __DYNASTY : CIM_ManagedSystemElement
    __RELPATH : Win32_PnPEntity.DeviceID="USB\VID_17DE&PID_00FF&MI_03\8&1D8B0748&0&0003"
    __PROPERTY_COUNT : 26
    __DERIVATION : {CIM_LogicalDevice, CIM_LogicalElement, CIM_ManagedSystemElement}
    __SERVER : GCN0185
    __NAMESPACE : root\cimv2
    __PATH : \GCN0185\root\cimv2:Win32_PnPEntity.DeviceID="USB\VID_17DE&PID_00FF&MI_03\8&1D8B0748&0&0003"
    Availability :
    Caption : USB Input Device
    ClassGuid : {745a17a0-74d3-11d0-b6fe-00a0c90f57da}
    CompatibleID : {USB\Class_03&SubClass_00&Prot_00, USB\Class_03&SubClass_00, USB\Class_03}
    ConfigManagerErrorCode : 0
    ConfigManagerUserConfig : False
    CreationClassName : Win32_PnPEntity
    Description : USB Input Device
    DeviceID : USB\VID_17DE&PID_00FF&MI_03\8&1D8B0748&0&0003
    ErrorCleared :
    ErrorDescription :
    HardwareID : {USB\VID_17DE&PID_00FF&REV_4201&MI_03, USB\VID_17DE&PID_00FF&MI_03}
    InstallDate :
    LastErrorCode :
    Manufacturer : (Standard system devices)
    Name : USB Input Device
    PNPClass : HIDClass
    PNPDeviceID : USB\VID_17DE&PID_00FF&MI_03\8&1D8B0748&0&0003

    0 comments No comments