2 * The PCI Library -- List PCI devices on Win32 via Configuration Manager
4 * Copyright (c) 2021 Pali Rohár <pali@kernel.org>
6 * Can be freely distributed and used under the terms of the GNU GPL v2+.
8 * SPDX-License-Identifier: GPL-2.0-or-later
14 #include <ctype.h> /* for isxdigit() */
15 #include <stdio.h> /* for sprintf() */
16 #include <string.h> /* for strlen(), strchr(), strncmp() */
17 #include <wchar.h> /* for wcslen(), wcscpy() */
21 /* Unfortunately MinGW32 toolchain does not provide these cfgmgr32 constants. */
23 #ifndef RegDisposition_OpenExisting
24 #define RegDisposition_OpenExisting 0x00000001
27 #ifndef CM_REGISTRY_SOFTWARE
28 #define CM_REGISTRY_SOFTWARE 0x00000001
31 #ifndef CM_DRP_HARDWAREID
32 #define CM_DRP_HARDWAREID 0x00000002
34 #ifndef CM_DRP_SERVICE
35 #define CM_DRP_SERVICE 0x00000005
37 #ifndef CM_DRP_BUSNUMBER
38 #define CM_DRP_BUSNUMBER 0x00000016
40 #ifndef CM_DRP_ADDRESS
41 #define CM_DRP_ADDRESS 0x0000001D
44 #ifndef CR_INVALID_CONFLICT_LIST
45 #define CR_INVALID_CONFLICT_LIST 0x00000039
47 #ifndef CR_INVALID_INDEX
48 #define CR_INVALID_INDEX 0x0000003A
50 #ifndef CR_INVALID_STRUCTURE_SIZE
51 #define CR_INVALID_STRUCTURE_SIZE 0x0000003B
54 #ifndef fIOD_10_BIT_DECODE
55 #define fIOD_10_BIT_DECODE 0x0004
57 #ifndef fIOD_12_BIT_DECODE
58 #define fIOD_12_BIT_DECODE 0x0008
60 #ifndef fIOD_16_BIT_DECODE
61 #define fIOD_16_BIT_DECODE 0x0010
63 #ifndef fIOD_POSITIVE_DECODE
64 #define fIOD_POSITIVE_DECODE 0x0020
66 #ifndef fIOD_PASSIVE_DECODE
67 #define fIOD_PASSIVE_DECODE 0x0040
69 #ifndef fIOD_WINDOW_DECODE
70 #define fIOD_WINDOW_DECODE 0x0080
73 #define fIOD_PORT_BAR 0x0100
76 #ifndef fMD_WINDOW_DECODE
77 #define fMD_WINDOW_DECODE 0x0040
79 #ifndef fMD_MEMORY_BAR
80 #define fMD_MEMORY_BAR 0x0080
84 * Unfortunately MinGW32 toolchain does not provide import library for these
85 * cfgmgr32.dll functions. So resolve pointers to these functions at runtime.
88 #ifdef CM_Get_DevNode_Registry_PropertyA
89 #undef CM_Get_DevNode_Registry_PropertyA
91 static CONFIGRET (WINAPI *MyCM_Get_DevNode_Registry_PropertyA)(DEVINST dnDevInst, ULONG ulProperty, PULONG pulRegDataType, PVOID Buffer, PULONG pulLength, ULONG ulFlags);
92 #define CM_Get_DevNode_Registry_PropertyA MyCM_Get_DevNode_Registry_PropertyA
94 #ifdef CM_Get_DevNode_Registry_PropertyW
95 #undef CM_Get_DevNode_Registry_PropertyW
97 static CONFIGRET (WINAPI *MyCM_Get_DevNode_Registry_PropertyW)(DEVINST dnDevInst, ULONG ulProperty, PULONG pulRegDataType, PVOID Buffer, PULONG pulLength, ULONG ulFlags);
98 #define CM_Get_DevNode_Registry_PropertyW MyCM_Get_DevNode_Registry_PropertyW
100 #ifndef CM_Open_DevNode_Key
101 #undef CM_Open_DevNode_Key
103 static CONFIGRET (WINAPI *MyCM_Open_DevNode_Key)(DEVINST dnDevNode, REGSAM samDesired, ULONG ulHardwareProfile, REGDISPOSITION Disposition, PHKEY phkDevice, ULONG ulFlags);
104 #define CM_Open_DevNode_Key MyCM_Open_DevNode_Key
107 resolve_cfgmgr32_functions(void)
111 if (CM_Get_DevNode_Registry_PropertyA && CM_Get_DevNode_Registry_PropertyW && CM_Open_DevNode_Key)
114 cfgmgr32 = GetModuleHandleA("cfgmgr32.dll");
118 CM_Get_DevNode_Registry_PropertyA = (void *)GetProcAddress(cfgmgr32, "CM_Get_DevNode_Registry_PropertyA");
119 CM_Get_DevNode_Registry_PropertyW = (void *)GetProcAddress(cfgmgr32, "CM_Get_DevNode_Registry_PropertyW");
120 CM_Open_DevNode_Key = (void *)GetProcAddress(cfgmgr32, "CM_Open_DevNode_Key");
121 if (!CM_Get_DevNode_Registry_PropertyA || !CM_Get_DevNode_Registry_PropertyW || !CM_Open_DevNode_Key)
128 * cfgmgr32.dll uses custom non-Win32 error numbers which are unsupported by
129 * Win32 APIs like GetLastError() and FormatMessage() functions.
131 * Windows 7 introduced new cfgmgr32.dll function CM_MapCrToWin32Err() for
132 * translating mapping CR_* errors to Win32 errors but most error codes are
133 * not mapped. So this function is unusable.
135 * Error strings for CR_* errors are defined in cmapi.rc file which is
136 * statically linked into some system libraries (e.g. filemgmt.dll,
137 * acledit.dll, netui0.dll or netui2.dll) but due to static linking it is
138 * not possible to access these error strings easily at runtime.
140 * So define own function for translating CR_* errors directly to strings.
143 cr_strerror(CONFIGRET cr_error_id)
145 static char unknown_error[sizeof("Unknown CR error XXXXXXXXXX")];
146 static const char *cr_errors[] = {
147 "The operation completed successfully",
149 "Not enough memory is available to process this command",
150 "A required pointer parameter is invalid",
151 "The ulFlags parameter specified is invalid for this operation",
152 "The device instance handle parameter is not valid",
153 "The supplied resource descriptor parameter is invalid",
154 "The supplied logical configuration parameter is invalid",
155 "CR_INVALID_ARBITRATOR",
156 "CR_INVALID_NODELIST",
157 "CR_DEVNODE_HAS_REQS/CR_DEVINST_HAS_REQS",
158 "The RESOURCEID parameter does not contain a valid RESOURCEID",
159 "CR_DLVXD_NOT_FOUND",
160 "The specified device instance handle does not correspond to a present device",
161 "There are no more logical configurations available",
162 "There are no more resource descriptions available",
163 "This device instance already exists",
164 "The supplied range list parameter is invalid",
166 "A general internal error occurred",
167 "CR_NO_SUCH_LOGICAL_DEV",
168 "The device is disabled for this configuration",
170 "A service or application refused to allow removal of this device",
172 "CR_INVALID_LOAD_TYPE",
173 "An output parameter was too small to hold all the data available",
175 "CR_NO_REGISTRY_HANDLE",
176 "A required entry in the registry is missing or an attempt to write to the registry failed",
177 "The specified Device ID is not a valid Device ID",
178 "One or more parameters were invalid",
180 "CR_DEVLOADER_NOT_READY",
182 "There are no more hardware profiles available",
183 "CR_DEVICE_NOT_THERE",
184 "The specified value does not exist in the registry",
186 "The specified priority is invalid for this operation",
187 "This device cannot be disabled",
193 "The specified key does not exist in the registry",
194 "The specified machine name does not meet the UNC naming conventions",
195 "A general remote communication error occurred",
196 "The machine selected for remote communication is not available at this time",
197 "The Plug and Play service or another required service is not available",
199 "This routine is not implemented in this version of the operating system",
200 "The specified property type is invalid for this operation",
201 "Device interface is active",
202 "No such device interface",
203 "Invalid reference string",
204 "Invalid conflict list",
206 "Invalid structure size"
208 if (cr_error_id <= 0 || cr_error_id >= sizeof(cr_errors)/sizeof(*cr_errors))
210 sprintf(unknown_error, "Unknown CR error %lu", cr_error_id);
211 return unknown_error;
213 return cr_errors[cr_error_id];
217 win32_strerror(DWORD win32_error_id)
220 * Use static buffer which is large enough.
221 * Hopefully no Win32 API error message string is longer than 4 kB.
223 static char buffer[4096];
226 len = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, win32_error_id, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buffer, sizeof(buffer), NULL);
228 /* FormatMessage() automatically appends ".\r\n" to the error message. */
229 if (len && buffer[len-1] == '\n')
230 buffer[--len] = '\0';
231 if (len && buffer[len-1] == '\r')
232 buffer[--len] = '\0';
233 if (len && buffer[len-1] == '.')
234 buffer[--len] = '\0';
237 sprintf(buffer, "Unknown Win32 error %lu", win32_error_id);
243 fmt_validate(const char *s, int len, const char *fmt)
247 for (i = 0; i < len; i++)
248 if (!fmt[i] || (fmt[i] == '#' ? !isxdigit(s[i]) : fmt[i] != s[i]))
255 seq_xdigit_validate(const char *s, int mult, int min)
260 if (len < min*mult || len % mult)
263 for (i = 0; i < len; i++)
271 is_non_nt_system(void)
273 OSVERSIONINFOA version;
274 version.dwOSVersionInfoSize = sizeof(version);
275 return GetVersionExA(&version) && version.dwPlatformId < VER_PLATFORM_WIN32_NT;
279 is_32bit_on_win8_64bit_system(void)
284 BOOL (WINAPI *MyIsWow64Process)(HANDLE, PBOOL);
285 OSVERSIONINFOA version;
289 /* Check for Windows 8 (NT 6.2). */
290 version.dwOSVersionInfoSize = sizeof(version);
291 if (!GetVersionExA(&version) ||
292 version.dwPlatformId != VER_PLATFORM_WIN32_NT ||
293 version.dwMajorVersion < 6 ||
294 (version.dwMajorVersion == 6 && version.dwMinorVersion < 2))
298 * Check for 64-bit system via IsWow64Process() function exported
299 * from 32-bit kernel32.dll library available on the 64-bit systems.
300 * Resolve pointer to this function at runtime as this code path is
301 * primary running on 32-bit systems where are not available 64-bit
305 kernel32 = GetModuleHandleA("kernel32.dll");
309 MyIsWow64Process = (void *)GetProcAddress(kernel32, "IsWow64Process");
310 if (!MyIsWow64Process)
313 if (!MyIsWow64Process(GetCurrentProcess(), &is_wow64))
321 get_device_service_name(struct pci_access *a, DEVINST devinst, DEVINSTID_A devinst_id, BOOL *supported)
323 ULONG reg_type, reg_size, reg_len;
328 * All data are stored as 7-bit ASCII strings in system but service name is
329 * exception. It can contain UNICODE. Moreover it is passed to other Win32 API
330 * functions and therefore it cannot be converted to 8-bit ANSI string without
331 * data loss. So use wide function CM_Get_DevNode_Registry_PropertyW() in this
332 * case and deal with all wchar_t problems...
336 cr = CM_Get_DevNode_Registry_PropertyW(devinst, CM_DRP_SERVICE, ®_type, NULL, ®_size, 0);
337 if (cr == CR_CALL_NOT_IMPLEMENTED)
342 else if (cr == CR_NO_SUCH_VALUE)
347 else if (cr != CR_SUCCESS &&
348 cr != CR_BUFFER_SMALL)
350 a->warning("Cannot retrieve service name for PCI device %s: %s.", devinst_id, cr_strerror(cr));
354 else if (reg_type != REG_SZ)
356 a->warning("Cannot retrieve service name for PCI device %s: Service name is stored as unknown type 0x%lx.", devinst_id, reg_type);
363 * Returned size is on older Windows versions without nul-term char.
364 * So explicitly increase size and fill nul-term byte.
366 reg_size += sizeof(service_name[0]);
367 service_name = pci_malloc(a, reg_size);
369 cr = CM_Get_DevNode_Registry_PropertyW(devinst, CM_DRP_SERVICE, ®_type, service_name, ®_len, 0);
370 service_name[reg_size/sizeof(service_name[0]) - 1] = 0;
371 if (reg_len > reg_size)
373 pci_mfree(service_name);
377 else if (cr != CR_SUCCESS)
379 a->warning("Cannot retrieve service name for PCI device %s: %s.", devinst_id, cr_strerror(cr));
380 pci_mfree(service_name);
384 else if (reg_type != REG_SZ)
386 a->warning("Cannot retrieve service name for PCI device %s: Service name is stored as unknown type 0x%lx.", devinst_id, reg_type);
387 pci_mfree(service_name);
397 get_driver_path_for_service(struct pci_access *a, LPCWSTR service_name, SC_HANDLE manager)
399 UINT (WINAPI *get_system_root_path)(LPWSTR buffer, UINT size) = NULL;
400 DWORD service_config_size, service_config_len;
401 LPQUERY_SERVICE_CONFIGW service_config = NULL;
402 LPWSTR service_image_path = NULL;
403 SERVICE_STATUS service_status;
404 SC_HANDLE service = NULL;
405 char *driver_path = NULL;
411 service = OpenServiceW(manager, service_name, SERVICE_QUERY_CONFIG | SERVICE_QUERY_STATUS);
414 error = GetLastError();
415 if (error != ERROR_SERVICE_DOES_NOT_EXIST)
416 a->warning("Cannot open service %ls with query rights: %s.", service_name, win32_strerror(error));
420 if (!QueryServiceStatus(service, &service_status))
422 error = GetLastError();
423 a->warning("Cannot query status of service %ls: %s.", service_name, win32_strerror(error));
427 if (service_status.dwCurrentState == SERVICE_STOPPED)
430 if (service_status.dwServiceType != SERVICE_KERNEL_DRIVER)
433 if (!QueryServiceConfigW(service, NULL, 0, &service_config_size))
435 error = GetLastError();
436 if (error != ERROR_INSUFFICIENT_BUFFER)
438 a->warning("Cannot query config of service %ls: %s.", service_name, win32_strerror(error));
443 retry_service_config:
444 service_config = pci_malloc(a, service_config_size);
445 if (!QueryServiceConfigW(service, service_config, service_config_size, &service_config_len))
447 error = GetLastError();
448 if (error == ERROR_INSUFFICIENT_BUFFER)
450 pci_mfree(service_config);
451 service_config_size = service_config_len;
452 goto retry_service_config;
454 a->warning("Cannot query config of service %ls: %s.", service_name, win32_strerror(error));
458 if (service_config->dwServiceType != SERVICE_KERNEL_DRIVER)
462 * Despite QueryServiceConfig() is Win32 API, it returns lpBinaryPathName
463 * (ImagePath registry) in NT format. Unfortunately there is no Win32
464 * function for converting NT paths to Win32 paths. So do it manually and
465 * convert this NT format to human-readable Win32 path format.
469 * Old Windows versions return path to NT SystemRoot namespace via
470 * GetWindowsDirectoryW() function. New Windows versions via
471 * GetSystemWindowsDirectoryW(). GetSystemWindowsDirectoryW() is not
472 * provided in old Windows versions, so use GetProcAddress() for
473 * compatibility with all Windows versions.
475 kernel32 = GetModuleHandleW(L"kernel32.dll");
477 get_system_root_path = (void *)GetProcAddress(kernel32, "GetSystemWindowsDirectoryW");
478 if (!get_system_root_path)
479 get_system_root_path = &GetWindowsDirectoryW;
481 systemroot_len = get_system_root_path(NULL, 0);
483 if (!service_config->lpBinaryPathName || !service_config->lpBinaryPathName[0])
485 /* No ImagePath is specified, NT kernel assumes implicit kernel driver path by service name. */
486 service_image_path = pci_malloc(a, sizeof(WCHAR) * (systemroot_len + sizeof("\\System32\\drivers\\")-1 + wcslen(service_name) + sizeof(".sys")-1 + 1));
487 systemroot_len = get_system_root_path(service_image_path, systemroot_len+1);
488 if (systemroot_len && service_image_path[systemroot_len-1] != L'\\')
489 service_image_path[systemroot_len++] = L'\\';
490 wcscpy(service_image_path + systemroot_len, L"System32\\drivers\\");
491 wcscpy(service_image_path + systemroot_len + sizeof("System32\\drivers\\")-1, service_name);
492 wcscpy(service_image_path + systemroot_len + sizeof("System32\\drivers\\")-1 + wcslen(service_name), L".sys");
494 else if (wcsncmp(service_config->lpBinaryPathName, L"\\SystemRoot\\", sizeof("\\SystemRoot\\")-1) == 0)
496 /* ImagePath is in NT SystemRoot namespace, convert to Win32 path via GetSystemWindowsDirectoryW()/GetWindowsDirectoryW(). */
497 service_image_path = pci_malloc(a, sizeof(WCHAR) * (systemroot_len + wcslen(service_config->lpBinaryPathName) - (sizeof("\\SystemRoot")-1)));
498 systemroot_len = get_system_root_path(service_image_path, systemroot_len+1);
499 if (systemroot_len && service_image_path[systemroot_len-1] != L'\\')
500 service_image_path[systemroot_len++] = L'\\';
501 wcscpy(service_image_path + systemroot_len, service_config->lpBinaryPathName + sizeof("\\SystemRoot\\")-1);
503 else if (wcsncmp(service_config->lpBinaryPathName, L"\\??\\UNC\\", sizeof("\\??\\UNC\\")-1) == 0 ||
504 wcsncmp(service_config->lpBinaryPathName, L"\\??\\\\UNC\\", sizeof("\\??\\\\UNC\\")-1) == 0)
506 /* ImagePath is in NT UNC namespace, convert to Win32 UNC path via "\\\\" prefix. */
507 service_image_path = pci_malloc(a, sizeof(WCHAR) * (sizeof("\\\\") + wcslen(service_config->lpBinaryPathName) - (sizeof("\\??\\UNC\\")-1)));
508 /* Namespace separator may be single or double backslash. */
509 driver_path_len = sizeof("\\??\\")-1;
510 if (service_config->lpBinaryPathName[driver_path_len] == L'\\')
512 driver_path_len += sizeof("UNC\\")-1;
513 wcscpy(service_image_path, L"\\\\");
514 wcscpy(service_image_path + sizeof("\\\\")-1, service_config->lpBinaryPathName + driver_path_len);
516 else if (wcsncmp(service_config->lpBinaryPathName, L"\\??\\", sizeof("\\??\\")-1) == 0)
518 /* ImagePath is in NT Global?? namespace, root of the Win32 file namespace, so just remove "\\??\\" prefix to get Win32 path. */
519 service_image_path = pci_malloc(a, sizeof(WCHAR) * (wcslen(service_config->lpBinaryPathName) - (sizeof("\\??\\")-1)));
520 /* Namespace separator may be single or double backslash. */
521 driver_path_len = sizeof("\\??\\")-1;
522 if (service_config->lpBinaryPathName[driver_path_len] == L'\\')
524 wcscpy(service_image_path, service_config->lpBinaryPathName + driver_path_len);
526 else if (service_config->lpBinaryPathName[0] != L'\\')
528 /* ImagePath is relative to the NT SystemRoot namespace, convert to Win32 path via GetSystemWindowsDirectoryW()/GetWindowsDirectoryW(). */
529 service_image_path = pci_malloc(a, sizeof(WCHAR) * (systemroot_len + sizeof("\\") + wcslen(service_config->lpBinaryPathName)));
530 systemroot_len = get_system_root_path(service_image_path, systemroot_len+1);
531 if (systemroot_len && service_image_path[systemroot_len-1] != L'\\')
532 service_image_path[systemroot_len++] = L'\\';
533 wcscpy(service_image_path + systemroot_len, service_config->lpBinaryPathName);
537 /* ImagePath is in some unhandled NT namespace, copy it as is. It cannot be used in Win32 API but libpci user can be still interested in it. */
538 service_image_path = pci_malloc(a, sizeof(WCHAR) * wcslen(service_config->lpBinaryPathName));
539 wcscpy(service_image_path, service_config->lpBinaryPathName);
542 /* Calculate len of buffer needed for conversion from LPWSTR to char*. */
543 driver_path_len = WideCharToMultiByte(CP_ACP, 0, service_image_path, -1, NULL, 0, NULL, NULL);
544 if (driver_path_len <= 0)
546 error = GetLastError();
547 a->warning("Cannot convert kernel driver path from wide string to 8-bit string: %s.", win32_strerror(error));
551 driver_path = pci_malloc(a, driver_path_len);
552 driver_path_len = WideCharToMultiByte(CP_ACP, 0, service_image_path, -1, driver_path, driver_path_len, NULL, NULL);
553 if (driver_path_len <= 0)
555 error = GetLastError();
556 a->warning("Cannot convert kernel driver path from wide string to 8-bit string: %s.", win32_strerror(error));
557 pci_mfree(driver_path);
563 if (service_image_path)
564 pci_mfree(service_image_path);
566 pci_mfree(service_config);
568 CloseServiceHandle(service);
573 get_device_driver_devreg(struct pci_access *a, DEVINST devinst, DEVINSTID_A devinst_id)
578 cr = CM_Open_DevNode_Key(devinst, KEY_READ, 0, RegDisposition_OpenExisting, &key, CM_REGISTRY_SOFTWARE);
579 if (cr != CR_SUCCESS)
581 if (cr != CR_NO_SUCH_VALUE)
582 a->warning("Cannot retrieve driver key for device %s: %s.", devinst_id, cr_strerror(cr));
590 read_reg_key_string_value(struct pci_access *a, HKEY key, const char *name, DWORD *unkn_reg_type)
592 DWORD reg_type, reg_size, reg_len;
597 error = RegQueryValueExA(key, name, NULL, ®_type, NULL, ®_size);
598 if (error != ERROR_SUCCESS &&
599 error != ERROR_MORE_DATA)
604 else if (reg_type != REG_SZ)
607 *unkn_reg_type = reg_type;
612 value = pci_malloc(a, reg_size + 1);
614 error = RegQueryValueExA(key, name, NULL, ®_type, (PBYTE)value, ®_len);
615 if (error != ERROR_SUCCESS)
618 if (error == ERROR_MORE_DATA)
626 else if (reg_type != REG_SZ)
630 *unkn_reg_type = reg_type;
633 value[reg_len] = '\0';
639 driver_cmp(const char *driver, const char *match)
641 int len = strlen(driver);
642 if (driver[0] == '*')
644 if (len >= 4 && strcasecmp(driver + len - 4, ".vxd") == 0)
646 return strncasecmp(driver, match, len);
650 get_driver_path_for_regkey(struct pci_access *a, DEVINSTID_A devinst_id, HKEY key)
652 char *driver_list, *driver, *driver_next;
653 char *subdriver, *subname;
664 driver_list = read_reg_key_string_value(a, key, "DevLoader", &unkn_reg_type);
667 error = GetLastError();
669 a->warning("Cannot read driver DevLoader key for PCI device %s: DevLoader key is stored as unknown type 0x%lx.", devinst_id, unkn_reg_type);
670 else if (error != ERROR_FILE_NOT_FOUND)
671 a->warning("Cannot read driver DevLoader key for PCI device %s: %s.", devinst_id, win32_strerror(error));
676 driver = driver_list;
679 driver_next = strchr(driver, ',');
681 *(driver_next++) = '\0';
683 if (driver_cmp(driver, "ios") == 0 ||
684 driver_cmp(driver, "vcomm") == 0)
685 subname = "PortDriver";
686 else if (driver_cmp(driver, "ntkern") == 0)
687 subname = "NTMPDriver";
688 else if (driver_cmp(driver, "ndis") == 0)
689 subname = "DeviceVxDs";
690 else if (driver_cmp(driver, "vdd") == 0)
696 if (subname && strcmp(subname, "minivdd") == 0)
698 error = RegOpenKeyA(key, "Default", &subkey);
699 if (error != ERROR_SUCCESS)
701 a->warning("Cannot open driver subkey Default for PCI device %s: %s.", devinst_id, win32_strerror(error));
712 subdriver = read_reg_key_string_value(a, subkey, subname, &unkn_reg_type);
715 error = GetLastError();
717 a->warning("Cannot read driver %s key for PCI device %s: DevLoader key is stored as unknown type 0x%lx.", subname, devinst_id, unkn_reg_type);
718 else if (error != ERROR_FILE_NOT_FOUND)
719 a->warning("Cannot read driver %s key for PCI device %s: %s.", subname, devinst_id, win32_strerror(error));
720 else if (strcmp(subname, "minivdd") == 0)
725 else if (strcmp(subname, "drv") == 0)
737 char *endptr = strchr(subdriver, ',');
744 driver = driver_next;
747 if (subdriver && subdriver[0])
748 driver_ptr = subdriver;
754 if (driver_ptr && driver_ptr[0] == '*')
765 len = driver_ptr ? strlen(driver_ptr) : 0;
766 noext = driver_ptr && (len < 4 || driver_ptr[len-4] != '.');
772 if (tolower(driver_ptr[0]) >= 'a' && tolower(driver_ptr[0]) <= 'z' && driver_ptr[1] == ':')
774 /* Driver is already with absolute path. */
775 driver_path = pci_strdup(a, driver_ptr);
777 else if (driver_cmp(driver, "ntkern") == 0 && subdriver)
779 /* Driver is relative to system32\drivers\ directory which is relative to windows directory. */
780 systemdir_len = GetWindowsDirectoryA(NULL, 0);
781 driver_path = pci_malloc(a, systemdir_len + 1 + sizeof("system32\\drivers\\")-1 + strlen(driver_ptr) + 4 + 1);
782 systemdir_len = GetWindowsDirectoryA(driver_path, systemdir_len + 1);
783 if (systemdir_len && driver_path[systemdir_len - 1] != '\\')
784 driver_path[systemdir_len++] = '\\';
785 sprintf(driver_path + systemdir_len, "system32\\drivers\\%s%s", driver_ptr, noext ? ".sys" : "");
789 /* Driver is packed in vmm32.vxd which is stored in system directory. */
790 systemdir_len = GetSystemDirectoryA(NULL, 0);
791 driver_path = pci_malloc(a, systemdir_len + 1 + sizeof("vmm32.vxd ()")-1 + strlen(driver_ptr) + 4 + 1);
792 systemdir_len = GetSystemDirectoryA(driver_path, systemdir_len + 1);
793 if (systemdir_len && driver_path[systemdir_len - 1] != '\\')
794 driver_path[systemdir_len++] = '\\';
795 sprintf(driver_path + systemdir_len, "vmm32.vxd (%s%s)", driver_ptr, noext ? ".vxd" : "");
799 /* Otherwise driver is relative to system directory. */
800 systemdir_len = GetSystemDirectoryA(NULL, 0);
801 driver_path = pci_malloc(a, systemdir_len + 1 + strlen(driver_ptr) + 4 + 1);
802 systemdir_len = GetSystemDirectoryA(driver_path, systemdir_len + 1);
803 if (systemdir_len && driver_path[systemdir_len - 1] != '\\')
804 driver_path[systemdir_len++] = '\\';
805 sprintf(driver_path + systemdir_len, "%s%s", driver_ptr, noext ? ".vxd" : "");
810 pci_mfree(subdriver);
811 pci_mfree(driver_list);
816 get_device_driver_path(struct pci_dev *d, SC_HANDLE manager, BOOL manager_supported)
818 struct pci_access *a = d->access;
819 BOOL service_supported = TRUE;
820 DEVINSTID_A devinst_id = NULL;
821 LPWSTR service_name = NULL;
822 ULONG devinst_id_len = 0;
823 char *driver_path = NULL;
824 DEVINST devinst = (DEVINST)d->aux;
829 if (CM_Get_DevNode_Status(&status, &problem, devinst, 0) != CR_SUCCESS || !(status & DN_DRIVER_LOADED))
832 if (CM_Get_Device_ID_Size(&devinst_id_len, devinst, 0) == CR_SUCCESS)
834 devinst_id = pci_malloc(a, devinst_id_len + 1);
835 if (CM_Get_Device_IDA(devinst, devinst_id, devinst_id_len + 1, 0) != CR_SUCCESS)
837 pci_mfree(devinst_id);
838 devinst_id = pci_strdup(a, "UNKNOWN");
842 devinst_id = pci_strdup(a, "UNKNOWN");
844 service_name = get_device_service_name(d->access, devinst, devinst_id, &service_supported);
845 if ((!service_name || !manager) && service_supported && manager_supported)
847 else if (service_name && manager)
849 driver_path = get_driver_path_for_service(d->access, service_name, manager);
853 key = get_device_driver_devreg(d->access, devinst, devinst_id);
856 driver_path = get_driver_path_for_regkey(d->access, devinst_id, key);
864 pci_mfree(service_name);
865 pci_mfree(devinst_id);
870 fill_drivers(struct pci_access *a)
872 BOOL manager_supported;
878 /* ERROR_CALL_NOT_IMPLEMENTED is returned on systems without Service Manager support. */
879 manager_supported = TRUE;
880 manager = OpenSCManagerW(NULL, NULL, SC_MANAGER_CONNECT);
883 error = GetLastError();
884 if (error != ERROR_CALL_NOT_IMPLEMENTED)
885 a->warning("Cannot open Service Manager with connect right: %s.", win32_strerror(error));
887 manager_supported = FALSE;
890 for (d = a->devices; d; d = d->next)
892 driver = get_device_driver_path(d, manager, manager_supported);
895 pci_set_property(d, PCI_FILL_DRIVER, driver);
898 d->known_fields |= PCI_FILL_DRIVER;
902 CloseServiceHandle(manager);
906 fill_resources(struct pci_dev *d, DEVINST devinst, DEVINSTID_A devinst_id)
908 struct pci_access *a = d->access;
916 RES_DES prev_res_des;
925 int last_shared_irq = -1;
927 cr = CM_Get_DevNode_Status(&status, &problem, devinst, 0);
928 if (cr != CR_SUCCESS)
930 a->warning("Cannot retrieve status of PCI device %s: %s.", devinst_id, cr_strerror(cr));
934 cr = CR_NO_MORE_LOG_CONF;
937 * If the device is running then retrieve allocated configuration by PnP
938 * manager which is currently in use by a device.
940 if (!(status & DN_HAS_PROBLEM))
941 cr = CM_Get_First_Log_Conf(&config, devinst, ALLOC_LOG_CONF);
944 * If the device is not running or it does not have allocated configuration by
945 * PnP manager then retrieve forced configuration which prevents PnP manager
946 * from assigning resources.
948 if (cr == CR_NO_MORE_LOG_CONF)
949 cr = CM_Get_First_Log_Conf(&config, devinst, FORCED_LOG_CONF);
952 * If the device does not have neither allocated configuration by PnP manager
953 * nor forced configuration and it is not disabled in the BIOS then retrieve
954 * boot configuration supplied by the BIOS.
956 if (cr == CR_NO_MORE_LOG_CONF &&
957 (!(status & DN_HAS_PROBLEM) || problem != CM_PROB_HARDWARE_DISABLED))
958 cr = CM_Get_First_Log_Conf(&config, devinst, BOOT_LOG_CONF);
960 if (cr != CR_SUCCESS)
963 * Note: Starting with Windows 8, CM_Get_First_Log_Conf returns
964 * CR_CALL_NOT_IMPLEMENTED when used in a Wow64 scenario.
965 * To request information about the hardware resources on a local machine
966 * it is necessary implement an architecture-native version of the
967 * application using the hardware resource APIs. For example: An AMD64
968 * application for AMD64 systems.
970 if (cr == CR_CALL_NOT_IMPLEMENTED && is_32bit_on_win8_64bit_system())
972 static BOOL warn_once = FALSE;
976 a->warning("Cannot retrieve resources of PCI devices from 32-bit application on 64-bit system.");
979 else if (cr != CR_NO_MORE_LOG_CONF)
980 a->warning("Cannot retrieve resources of PCI device %s: %s.", devinst_id, cr_strerror(cr));
985 non_nt_system = is_non_nt_system();
992 ULONG child_name_len;
996 if (CM_Get_Child(&child, devinst, 0) != CR_SUCCESS)
998 else if (CM_Get_Device_ID_Size(&child_name_len, child, 0) != CR_SUCCESS)
1003 child_name = pci_malloc(a, child_name_len);
1004 if (CM_Get_Device_IDA(child, child_name, child_name_len, 0) != CR_SUCCESS)
1006 else if (strncmp(child_name, "PCI\\", 4) != 0)
1010 pci_mfree(child_name);
1013 if (has_child || d->device_class == PCI_CLASS_BRIDGE_PCI || d->device_class == PCI_CLASS_BRIDGE_CARDBUS)
1022 prev_res_des = (RES_DES)config;
1023 while ((cr = CM_Get_Next_Res_Des(&res_des, prev_res_des, ResType_All, &res_id, 0)) == CR_SUCCESS)
1025 pciaddr_t start, end, size, flags;
1026 ULONG res_des_data_size;
1029 if (prev_res_des != config)
1030 CM_Free_Res_Des_Handle(prev_res_des);
1032 prev_res_des = res_des;
1034 cr = CM_Get_Res_Des_Data_Size(&res_des_data_size, res_des, 0);
1035 if (cr != CR_SUCCESS)
1037 a->warning("Cannot retrieve resource data of PCI device %s: %s.", devinst_id, cr_strerror(cr));
1041 if (!res_des_data_size)
1043 a->warning("Cannot retrieve resource data of PCI device %s: %s.", devinst_id, "Empty data");
1047 res_des_data = pci_malloc(a, res_des_data_size);
1048 cr = CM_Get_Res_Des_Data(res_des, res_des_data, res_des_data_size, 0);
1049 if (cr != CR_SUCCESS)
1051 a->warning("Cannot retrieve resource data of PCI device %s: %s.", devinst_id, cr_strerror(cr));
1052 pci_mfree(res_des_data);
1057 * There can be more resources with the same id. In this case we are
1058 * interested in the last one in the list as at the beginning of the list
1059 * can be some virtual resources (which are not set in PCI config space).
1062 if (res_id == ResType_IO)
1064 PIO_RESOURCE io_data = (PIO_RESOURCE)res_des_data;
1066 start = io_data->IO_Header.IOD_Alloc_Base;
1067 end = io_data->IO_Header.IOD_Alloc_End;
1068 size = (end > start) ? (end - start + 1) : 0;
1069 flags = PCI_IORESOURCE_IO;
1072 * If neither 10-bit, 12-bit, nor 16-bit support is presented then
1073 * expects that this is 32-bit I/O resource. If resource does not fit
1074 * into 16-bit space then it must be 32-bit. If PCI I/O resource is
1075 * not 32-bit then it is 16-bit.
1077 if (end <= 0xffff && (io_data->IO_Header.IOD_DesFlags & (fIOD_10_BIT_DECODE|fIOD_12_BIT_DECODE|fIOD_16_BIT_DECODE)))
1078 flags |= PCI_IORESOURCE_IO_16BIT_ADDR;
1081 * 16/32-bit non-NT systems do not support these two flags.
1082 * Most NT-based Windows versions support only the fIOD_WINDOW_DECODE
1083 * flag and put all BAR resources before window resources in this
1084 * resource list. So use this fIOD_WINDOW_DECODE flag as separator
1085 * between IO/MEM windows and IO/MEM BARs of PCI Bridges.
1087 if (io_data->IO_Header.IOD_DesFlags & fIOD_WINDOW_DECODE)
1089 else if (io_data->IO_Header.IOD_DesFlags & fIOD_PORT_BAR)
1092 if (is_bar_res && bar_res_count < 6)
1094 d->flags[bar_res_count] = flags;
1095 d->base_addr[bar_res_count] = start;
1096 d->size[bar_res_count] = size;
1099 else if (!is_bar_res)
1101 d->bridge_flags[0] = flags;
1102 d->bridge_base_addr[0] = start;
1103 d->bridge_size[0] = size;
1104 d->known_fields |= PCI_FILL_BRIDGE_BASES;
1107 else if (res_id == ResType_Mem)
1109 PMEM_RESOURCE mem_data = (PMEM_RESOURCE)res_des_data;
1111 start = mem_data->MEM_Header.MD_Alloc_Base;
1112 end = mem_data->MEM_Header.MD_Alloc_End;
1113 size = (end > start) ? (end - start + 1) : 0;
1114 flags = PCI_IORESOURCE_MEM;
1117 * If fMD_PrefetchAllowed flag is set then this is
1118 * PCI Prefetchable Memory resource.
1120 if ((mem_data->MEM_Header.MD_Flags & mMD_Prefetchable) == fMD_PrefetchAllowed)
1121 flags |= PCI_IORESOURCE_PREFETCH;
1123 /* If resource does not fit into 32-bit space then it must be 64-bit. */
1124 if (is_bar_res && end > 0xffffffff)
1125 flags |= PCI_IORESOURCE_MEM_64;
1128 * These two flags (fMD_WINDOW_DECODE and fMD_MEMORY_BAR) are
1129 * unsupported on most Windows versions, so distinguish between
1130 * window and BAR based on previous resource type.
1132 if (mem_data->MEM_Header.MD_Flags & fMD_WINDOW_DECODE)
1134 else if (mem_data->MEM_Header.MD_Flags & fMD_MEMORY_BAR)
1137 /* 64-bit BAR resource must be at even position. */
1138 if (is_bar_res && (flags & PCI_IORESOURCE_MEM_64) && bar_res_count % 2)
1141 if (is_bar_res && bar_res_count < 6)
1143 d->flags[bar_res_count] = flags;
1144 d->base_addr[bar_res_count] = start;
1145 d->size[bar_res_count] = size;
1147 /* 64-bit BAR resource occupies two slots. */
1148 if (flags & PCI_IORESOURCE_MEM_64)
1151 else if (!is_bar_res && !(flags & PCI_IORESOURCE_PREFETCH))
1153 d->bridge_flags[1] = flags;
1154 d->bridge_base_addr[1] = start;
1155 d->bridge_size[1] = size;
1156 d->known_fields |= PCI_FILL_BRIDGE_BASES;
1158 else if (!is_bar_res && (flags & PCI_IORESOURCE_PREFETCH))
1160 d->bridge_flags[2] = flags;
1161 d->bridge_base_addr[2] = start;
1162 d->bridge_size[2] = size;
1163 d->known_fields |= PCI_FILL_BRIDGE_BASES;
1166 else if (res_id == ResType_IRQ)
1168 PIRQ_RESOURCE irq_data = (PIRQ_RESOURCE)res_des_data;
1171 * libpci's d->irq should be set to the non-MSI PCI IRQ and therefore
1172 * it should be level IRQ which may be shared with other PCI devices
1173 * and drivers in the system. As always we want to retrieve the last
1174 * IRQ number from the resource list.
1176 * On 16/32-bit non-NT systems is fIRQD_Level set to 2 but on NT
1177 * systems to 0. Moreover it looks like that different PCI drivers
1178 * on both NT and non-NT systems set bits 0 and 1 to wrong values
1179 * and so reported value in this list may be incorrect.
1181 * Therefore take the last level-shared IRQ number from the resource
1182 * list and if there is none of this type then take the last IRQ
1183 * number from the list.
1185 last_irq = irq_data->IRQ_Header.IRQD_Alloc_Num;
1186 if ((irq_data->IRQ_Header.IRQD_Flags & (mIRQD_Share|mIRQD_Edge_Level)) == (fIRQD_Share|fIRQD_Level))
1187 last_shared_irq = irq_data->IRQ_Header.IRQD_Alloc_Num;
1190 * IRQ resource on 16/32-bit non-NT systems is separator between
1191 * IO/MEM windows and IO/MEM BARs of PCI Bridges. After the IRQ
1192 * resource are IO/MEM BAR resources.
1194 if (!is_bar_res && non_nt_system)
1198 pci_mfree(res_des_data);
1200 if (cr != CR_NO_MORE_RES_DES)
1201 a->warning("Cannot retrieve resources of PCI device %s: %s.", devinst_id, cr_strerror(cr));
1203 if (prev_res_des != config)
1204 CM_Free_Res_Des_Handle(prev_res_des);
1206 CM_Free_Log_Conf_Handle(config);
1208 /* Set the last IRQ from the resource list to pci_dev. */
1209 if (last_shared_irq >= 0)
1210 d->irq = last_shared_irq;
1211 else if (last_irq >= 0)
1213 if (last_shared_irq >= 0 || last_irq >= 0)
1214 d->known_fields |= PCI_FILL_IRQ;
1216 if (bar_res_count > 0)
1217 d->known_fields |= PCI_FILL_BASES | PCI_FILL_SIZES | PCI_FILL_IO_FLAGS;
1221 get_device_location(struct pci_access *a, DEVINST devinst, DEVINSTID_A devinst_id, unsigned int *domain, unsigned int *bus, unsigned int *dev, unsigned int *func)
1223 ULONG reg_type, reg_len;
1225 BOOL have_bus, have_devfunc;
1226 DWORD drp_bus_num, drp_address;
1230 have_devfunc = FALSE;
1233 * DRP_BUSNUMBER consists of PCI domain number in high 24 bits
1234 * and PCI bus number in low 8 bits.
1236 reg_len = sizeof(drp_bus_num);
1237 cr = CM_Get_DevNode_Registry_PropertyA(devinst, CM_DRP_BUSNUMBER, ®_type, &drp_bus_num, ®_len, 0);
1238 if (cr == CR_SUCCESS && reg_type == REG_DWORD && reg_len == sizeof(drp_bus_num))
1240 *domain = drp_bus_num >> 8;
1241 *bus = drp_bus_num & 0xff;
1246 * DRP_ADDRESS consists of PCI device number in high 16 bits
1247 * and PCI function number in low 16 bits.
1249 reg_len = sizeof(drp_address);
1250 cr = CM_Get_DevNode_Registry_PropertyA(devinst, CM_DRP_ADDRESS, ®_type, &drp_address, ®_len, 0);
1251 if (cr == CR_SUCCESS && reg_type == REG_DWORD && reg_len == sizeof(drp_address))
1253 *dev = drp_address >> 16;
1254 *func = drp_address & 0xffff;
1255 have_devfunc = TRUE;
1259 * Device Instance Id for PCI devices is of format:
1260 * "<enumerator>\\<device_id>\\<instance_id>"
1262 * "<enumerator>" is "PCI"
1263 * "<device_id>" is "VEN_####&DEV_####&SUBSYS_########&REV_##"
1264 * and "<instance_id>" for PCI devices is at least in one of following format:
1265 * "BUS_##&DEV_##&FUNC_##"
1266 * "##.." (sequence of devfn hex bytes, where bytes represents tree path to the root)
1267 * "#..&#..&#..&#.." (four hex numbers separated by "&"; meaning is unknown yet)
1269 * First two formats are used only on systems without support for multiple
1270 * domains. The second format uses intel-conf encoding of device and function
1271 * number: Low 3 bits is function number and high 5 bits is device number.
1272 * Bus number is not really encoded in second format!
1274 * The third format is used on systems with support for multiple domains but
1275 * format is variable length and currently its meaning is unknown. Apparently
1276 * it looks like that DRP_BUSNUMBER and DRP_ADDRESS registry properties are
1277 * supported on these systems.
1279 * If DRP_BUSNUMBER or DRP_ADDRESS failed then try to parse PCI bus, device
1280 * and function numbers from Instance Id part.
1282 if (!have_bus || !have_devfunc)
1284 const char *device_id0 = strchr(devinst_id, '\\');
1285 const char *instance_id0 = device_id0 ? strchr(device_id0 + 1, '\\') : NULL;
1286 const char *instance_id = instance_id0 ? instance_id0 + 1 : NULL;
1291 if (fmt_validate(instance_id, strlen(instance_id), "BUS_##&DEV_##&FUNC_##") &&
1292 sscanf(instance_id, "BUS_%x&DEV_%x&FUNC_%x", bus, dev, func) == 3)
1295 have_devfunc = TRUE;
1297 else if (seq_xdigit_validate(instance_id, 2, 2) &&
1298 sscanf(instance_id, "%2x", &devfn) == 1)
1301 *func = devfn & 0x7;
1302 have_devfunc = TRUE;
1308 * Virtual IRQ holder devices do not have assigned any bus/dev/func number and
1309 * have "IRQHOLDER" in their Device Id part. So skip them.
1311 if (!have_bus && !have_devfunc && strncmp(devinst_id, "PCI\\IRQHOLDER\\", 14) == 0)
1315 * When some numbers cannot be retrieved via cfgmgr32 then set them to zeros
1316 * to have structure initialized. It makes sense to report via libpci also
1317 * such "incomplete" device as cfgmgr32 can provide additional information
1318 * like device/vendor ids or assigned resources.
1320 if (!have_bus && !have_devfunc)
1322 *bus = *dev = *func = 0;
1323 a->warning("Cannot retrieve bus, device and function numbers for PCI device %s: %s.", devinst_id, cr_strerror(cr));
1328 a->warning("Cannot retrieve bus number for PCI device %s: %s.", devinst_id, cr_strerror(cr));
1330 else if (!have_devfunc)
1333 a->warning("Cannot retrieve device and function numbers for PCI device %s: %s.", devinst_id, cr_strerror(cr));
1340 fill_data_from_string(struct pci_dev *d, const char *str)
1342 BOOL have_device_id;
1343 BOOL have_vendor_id;
1346 const char *endptr, *endptr2;
1350 have_device_id = have_vendor_id = (d->known_fields & PCI_FILL_IDENT);
1351 have_prog_if = have_rev_id = (d->known_fields & PCI_FILL_CLASS_EXT);
1355 endptr = strchr(str, '&');
1356 endptr2 = strchr(str, '\\');
1357 if (endptr2 && (!endptr || endptr > endptr2))
1359 len = endptr ? endptr-str : (int)strlen(str);
1361 if (!have_vendor_id &&
1362 fmt_validate(str, len, "VEN_####") &&
1363 sscanf(str, "VEN_%x", &hex) == 1)
1366 have_vendor_id = TRUE;
1368 else if (!have_device_id &&
1369 fmt_validate(str, len, "DEV_####") &&
1370 sscanf(str, "DEV_%x", &hex) == 1)
1373 have_device_id = TRUE;
1375 else if (!(d->known_fields & PCI_FILL_SUBSYS) &&
1376 fmt_validate(str, len, "SUBSYS_########") &&
1377 sscanf(str, "SUBSYS_%x", &hex) == 1)
1379 d->subsys_vendor_id = hex & 0xffff;
1380 d->subsys_id = hex >> 16;
1381 d->known_fields |= PCI_FILL_SUBSYS;
1383 else if (!have_rev_id &&
1384 fmt_validate(str, len, "REV_##") &&
1385 sscanf(str, "REV_%x", &hex) == 1)
1390 else if (!((d->known_fields & PCI_FILL_CLASS) && have_prog_if) &&
1391 (fmt_validate(str, len, "CC_####") || fmt_validate(str, len, "CC_######")) &&
1392 sscanf(str, "CC_%x", &hex) == 1)
1398 d->prog_if = hex & 0xff;
1399 have_prog_if = TRUE;
1403 if (!(d->known_fields & PCI_FILL_CLASS))
1405 d->device_class = hex;
1406 d->known_fields |= PCI_FILL_CLASS;
1410 if (!endptr || endptr == endptr2)
1416 if ((have_device_id || d->device_id) && (have_vendor_id || d->vendor_id))
1417 d->known_fields |= PCI_FILL_IDENT;
1419 if ((have_prog_if || d->prog_if) && (have_rev_id || d->rev_id))
1420 d->known_fields |= PCI_FILL_CLASS_EXT;
1424 fill_data_from_devinst_id(struct pci_dev *d, DEVINSTID_A devinst_id)
1426 const char *device_id;
1428 device_id = strchr(devinst_id, '\\');
1434 * Device Id part of Device Instance Id is in format:
1435 * "VEN_####&DEV_####&SUBSYS_########&REV_##"
1437 fill_data_from_string(d, device_id);
1441 fill_data_from_hardware_ids(struct pci_dev *d, DEVINST devinst, DEVINSTID_A devinst_id)
1443 ULONG reg_type, reg_size, reg_len;
1444 struct pci_access *a = d->access;
1445 char *hardware_ids = NULL;
1450 cr = CM_Get_DevNode_Registry_PropertyA(devinst, CM_DRP_HARDWAREID, ®_type, NULL, ®_size, 0);
1451 if (cr != CR_SUCCESS && cr != CR_BUFFER_SMALL)
1453 a->warning("Cannot retrieve hardware ids for PCI device %s: %s.", devinst_id, cr_strerror(cr));
1456 else if (reg_type != REG_MULTI_SZ && reg_type != REG_SZ) /* Older Windows versions return REG_SZ and new versions REG_MULTI_SZ. */
1458 a->warning("Cannot retrieve hardware ids for PCI device %s: Hardware ids are stored as unknown type 0x%lx.", devinst_id, reg_type);
1464 * Returned size is on older Windows versions without nul-term char.
1465 * So explicitly increase size and fill nul-term byte.
1468 hardware_ids = pci_malloc(a, reg_size);
1470 cr = CM_Get_DevNode_Registry_PropertyA(devinst, CM_DRP_HARDWAREID, ®_type, hardware_ids, ®_len, 0);
1471 hardware_ids[reg_size - 1] = 0;
1472 if (reg_len > reg_size)
1474 pci_mfree(hardware_ids);
1478 else if (cr != CR_SUCCESS)
1480 a->warning("Cannot retrieve hardware ids for PCI device %s: %s.", devinst_id, cr_strerror(cr));
1481 pci_mfree(hardware_ids);
1484 else if (reg_type != REG_MULTI_SZ && reg_type != REG_SZ) /* Older Windows versions return REG_SZ and new versions REG_MULTI_SZ. */
1486 a->warning("Cannot retrieve hardware ids for PCI device %s: Hardware ids are stored as unknown type 0x%lx.", devinst_id, reg_type);
1487 pci_mfree(hardware_ids);
1492 * Hardware ids is nul-separated nul-term string list where each string has
1493 * one of the following format:
1494 * "PCI\\VEN_####&DEV_####&SUBSYS_########&REV_##"
1495 * "PCI\\VEN_####&DEV_####&SUBSYS_########"
1496 * "PCI\\VEN_####&DEV_####&REV_##&CC_####"
1497 * "PCI\\VEN_####&DEV_####&CC_######"
1498 * "PCI\\VEN_####&DEV_####&CC_####"
1499 * "PCI\\VEN_####&DEV_####&REV_##"
1500 * "PCI\\VEN_####&DEV_####"
1502 for (str = hardware_ids; *str != '\0'; str += strlen(str) + 1)
1504 if (strncmp(str, "PCI\\", 4) != 0)
1507 fill_data_from_string(d, str);
1510 pci_mfree(hardware_ids);
1514 scan_devinst_id(struct pci_access *a, DEVINSTID_A devinst_id)
1516 unsigned int domain, bus, dev, func;
1521 cr = CM_Locate_DevNodeA(&devinst, devinst_id, CM_LOCATE_DEVNODE_NORMAL);
1522 if (cr != CR_SUCCESS)
1524 /* Do not show warning when device is not present (= does not match NORMAL flag). */
1525 if (cr != CR_NO_SUCH_DEVNODE)
1526 a->warning("Cannot retrieve handle for device %s: %s.", devinst_id, cr_strerror(cr));
1530 /* get_device_location() returns FALSE if devinst is not real PCI device. */
1531 if (!get_device_location(a, devinst, devinst_id, &domain, &bus, &dev, &func))
1534 d = pci_get_dev(a, domain, bus, dev, func);
1536 if (!d->access->aux)
1537 d->no_config_access = 1;
1538 d->aux = (void *)devinst;
1540 /* Parse device id part of devinst id and fill details into pci_dev. */
1542 fill_data_from_devinst_id(d, devinst_id);
1544 /* Retrieve hardware ids of devinst, parse them and fill details into pci_dev. */
1546 fill_data_from_hardware_ids(d, devinst, devinst_id);
1549 fill_resources(d, devinst, devinst_id);
1552 * Set parent field to cfgmgr32 parent devinst handle and aux field to current
1553 * devinst handle. At later stage in win32_cfgmgr32_scan() when all pci_dev
1554 * devices are linked, change every devinst handle by pci_dev.
1558 DEVINST parent_devinst;
1559 if (CM_Get_Parent(&parent_devinst, devinst, 0) != CR_SUCCESS)
1562 a->warning("Cannot retrieve parent handle for device %s: %s.", devinst_id, cr_strerror(cr));
1564 d->parent = (void *)parent_devinst;
1569 win32_cfgmgr32_scan(struct pci_access *a)
1571 ULONG devinst_id_list_size;
1572 PCHAR devinst_id_list;
1573 DEVINSTID_A devinst_id;
1577 if (!resolve_cfgmgr32_functions())
1579 a->warning("Required cfgmgr32.dll functions are unavailable.");
1584 * Explicitly initialize size to zero as wine cfgmgr32 implementation does not
1585 * support this API but returns CR_SUCCESS without touching size argument.
1587 devinst_id_list_size = 0;
1588 cr = CM_Get_Device_ID_List_SizeA(&devinst_id_list_size, "PCI", CM_GETIDLIST_FILTER_ENUMERATOR);
1589 if (cr != CR_SUCCESS)
1591 a->warning("Cannot retrieve list of PCI devices: %s.", cr_strerror(cr));
1594 else if (devinst_id_list_size <= 1)
1596 a->warning("Cannot retrieve list of PCI devices: No device was found.");
1600 devinst_id_list = pci_malloc(a, devinst_id_list_size);
1601 cr = CM_Get_Device_ID_ListA("PCI", devinst_id_list, devinst_id_list_size, CM_GETIDLIST_FILTER_ENUMERATOR);
1602 if (cr != CR_SUCCESS)
1604 a->warning("Cannot retrieve list of PCI devices: %s.", cr_strerror(cr));
1605 pci_mfree(devinst_id_list);
1609 /* Register pci_dev for each cfgmgr32 devinst handle. */
1610 for (devinst_id = devinst_id_list; *devinst_id; devinst_id += strlen(devinst_id) + 1)
1611 scan_devinst_id(a, devinst_id);
1613 /* Fill all drivers. */
1617 /* Switch parent fields from cfgmgr32 devinst handle to pci_dev. */
1620 struct pci_dev *d1, *d2;
1621 for (d1 = a->devices; d1; d1 = d1->next)
1623 for (d2 = a->devices; d2; d2 = d2->next)
1624 if ((DEVINST)d1->parent == (DEVINST)d2->aux)
1628 d1->known_fields |= PCI_FILL_PARENT;
1632 /* devinst stored in ->aux is not needed anymore, clear it. */
1633 for (d = a->devices; d; d = d->next)
1636 pci_mfree(devinst_id_list);
1640 win32_cfgmgr32_config(struct pci_access *a)
1642 pci_define_param(a, "win32.cfgmethod", "auto", "PCI config space access method");
1646 win32_cfgmgr32_detect(struct pci_access *a)
1648 ULONG devinst_id_list_size;
1651 if (!resolve_cfgmgr32_functions())
1653 a->debug("Required cfgmgr32.dll functions are unavailable.");
1658 * Explicitly initialize size to zero as wine cfgmgr32 implementation does not
1659 * support this API but returns CR_SUCCESS without touching size argument.
1661 devinst_id_list_size = 0;
1662 cr = CM_Get_Device_ID_List_SizeA(&devinst_id_list_size, "PCI", CM_GETIDLIST_FILTER_ENUMERATOR);
1663 if (cr != CR_SUCCESS)
1665 a->debug("CM_Get_Device_ID_List_SizeA(\"PCI\"): %s.", cr_strerror(cr));
1668 else if (devinst_id_list_size <= 1)
1670 a->debug("CM_Get_Device_ID_List_SizeA(\"PCI\"): No device was found.");
1678 win32_cfgmgr32_fill_info(struct pci_dev *d, unsigned int flags)
1681 * All available flags were filled by win32_cfgmgr32_scan().
1682 * Filling more flags is possible only from config space.
1684 if (!d->access->aux)
1687 pci_generic_fill_info(d, flags);
1691 win32_cfgmgr32_read(struct pci_dev *d, int pos, byte *buf, int len)
1693 struct pci_access *a = d->access;
1694 struct pci_access *acfg = a->aux;
1695 struct pci_dev *dcfg = d->aux;
1698 return pci_emulated_read(d, pos, buf, len);
1701 d->aux = dcfg = pci_get_dev(acfg, d->domain, d->bus, d->dev, d->func);
1703 return pci_read_block(dcfg, pos, buf, len);
1707 win32_cfgmgr32_write(struct pci_dev *d, int pos, byte *buf, int len)
1709 struct pci_access *a = d->access;
1710 struct pci_access *acfg = a->aux;
1711 struct pci_dev *dcfg = d->aux;
1717 d->aux = dcfg = pci_get_dev(acfg, d->domain, d->bus, d->dev, d->func);
1719 return pci_write_block(dcfg, pos, buf, len);
1723 win32_cfgmgr32_cleanup_dev(struct pci_dev *d)
1725 struct pci_dev *dcfg = d->aux;
1732 win32_cfgmgr32_init(struct pci_access *a)
1734 char *cfgmethod = pci_get_param(a, "win32.cfgmethod");
1735 struct pci_access *acfg;
1737 if (strcmp(cfgmethod, "") == 0 ||
1738 strcmp(cfgmethod, "auto") == 0)
1740 acfg = pci_clone_access(a);
1741 acfg->method = PCI_ACCESS_AUTO;
1743 else if (strcmp(cfgmethod, "none") == 0 ||
1744 strcmp(cfgmethod, "win32-cfgmgr32") == 0)
1747 a->error("Write access requested but option win32.cfgmethod was not set.");
1752 int m = pci_lookup_method(cfgmethod);
1754 a->error("Option win32.cfgmethod is set to an unknown access method \"%s\".", cfgmethod);
1755 acfg = pci_clone_access(a);
1759 a->debug("Loading config space access method...\n");
1760 if (!pci_init_internal(acfg, PCI_ACCESS_WIN32_CFGMGR32))
1763 a->debug("Cannot find any working config space access method.\n");
1765 a->error("Write access requested but no usable access method found.");
1773 win32_cfgmgr32_cleanup(struct pci_access *a)
1775 struct pci_access *acfg = a->aux;
1781 struct pci_methods pm_win32_cfgmgr32 = {
1783 "Win32 device listing via Configuration Manager",
1784 win32_cfgmgr32_config,
1785 win32_cfgmgr32_detect,
1786 win32_cfgmgr32_init,
1787 win32_cfgmgr32_cleanup,
1788 win32_cfgmgr32_scan,
1789 win32_cfgmgr32_fill_info,
1790 win32_cfgmgr32_read,
1791 win32_cfgmgr32_write,
1792 NULL, /* read_vpd */
1793 NULL, /* init_dev */
1794 win32_cfgmgr32_cleanup_dev,