| /* | |
| * Copyright © 2017 Google | |
| * Copyright © 2019 Red Hat | |
| * | |
| * Permission is hereby granted, free of charge, to any person obtaining a | |
| * copy of this software and associated documentation files (the "Software"), | |
| * to deal in the Software without restriction, including without limitation | |
| * the rights to use, copy, modify, merge, publish, distribute, sublicense, | |
| * and/or sell copies of the Software, and to permit persons to whom the | |
| * Software is furnished to do so, subject to the following conditions: | |
| * | |
| * The above copyright notice and this permission notice (including the next | |
| * paragraph) shall be included in all copies or substantial portions of the | |
| * Software. | |
| * | |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |
| * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING | |
| * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS | |
| * IN THE SOFTWARE. | |
| */ | |
| /* Rules for device selection. | |
| * Is there an X or wayland connection open (or DISPLAY set). | |
| * If no - try and find which device was the boot_vga device. | |
| * If yes - try and work out which device is the connection primary, | |
| * DRI_PRIME tagged overrides only work if bus info, =1 will just pick an alternate. | |
| */ | |
| #include <fcntl.h> | |
| #include <stdio.h> | |
| #include <stdlib.h> | |
| #include <string.h> | |
| #include <unistd.h> | |
| #include "util/macros.h" | |
| #include "device_select.h" | |
| static bool | |
| fill_drm_device_info(const struct instance_info *info, struct device_pci_info *drm_device, | |
| VkPhysicalDevice device) | |
| { | |
| VkPhysicalDevicePCIBusInfoPropertiesEXT ext_pci_properties = | |
| (VkPhysicalDevicePCIBusInfoPropertiesEXT){ | |
| .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT}; | |
| VkPhysicalDeviceProperties2 properties = | |
| (VkPhysicalDeviceProperties2){.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2}; | |
| if (info->has_vulkan11 && info->has_pci_bus) | |
| properties.pNext = &ext_pci_properties; | |
| device_select_get_properties(info, device, &properties); | |
| drm_device->device_type = properties.properties.deviceType; | |
| drm_device->dev_info.vendor_id = properties.properties.vendorID; | |
| drm_device->dev_info.device_id = properties.properties.deviceID; | |
| if (info->has_vulkan11 && info->has_pci_bus) { | |
| drm_device->has_bus_info = true; | |
| drm_device->bus_info.domain = ext_pci_properties.pciDomain; | |
| drm_device->bus_info.bus = ext_pci_properties.pciBus; | |
| drm_device->bus_info.dev = ext_pci_properties.pciDevice; | |
| drm_device->bus_info.func = ext_pci_properties.pciFunction; | |
| } | |
| return drm_device->device_type == VK_PHYSICAL_DEVICE_TYPE_CPU; | |
| } | |
| static int | |
| device_select_find_explicit_default(struct device_pci_info *pci_infos, uint32_t device_count, | |
| const char *selection) | |
| { | |
| int default_idx = -1; | |
| unsigned vendor_id, device_id; | |
| int matched = sscanf(selection, "%x:%x", &vendor_id, &device_id); | |
| if (matched != 2) | |
| return default_idx; | |
| for (unsigned i = 0; i < device_count; ++i) { | |
| if (pci_infos[i].dev_info.vendor_id == vendor_id && | |
| pci_infos[i].dev_info.device_id == device_id) | |
| default_idx = i; | |
| } | |
| return default_idx; | |
| } | |
| static int | |
| device_select_find_typed_default(struct device_pci_info *pci_infos, uint32_t device_count, | |
| const char *selection) | |
| { | |
| static struct { | |
| const char *name; | |
| VkPhysicalDeviceType type; | |
| } names[] = { | |
| {"other", VK_PHYSICAL_DEVICE_TYPE_OTHER}, | |
| {"integrated", VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU}, | |
| {"igpu", VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU}, | |
| {"discrete", VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU}, | |
| {"dgpu", VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU}, | |
| {"virtual", VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU}, | |
| {"vgpu", VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU}, | |
| {"cpu", VK_PHYSICAL_DEVICE_TYPE_CPU}, | |
| }; | |
| for (unsigned i = 0; i < ARRAY_SIZE(names); ++i) { | |
| if (strncasecmp(names[i].name, selection, strlen(names[i].name)) == 0) { | |
| for (unsigned j = 0; j < device_count; ++j) { | |
| if (pci_infos[j].device_type == names[i].type) | |
| return j; | |
| } | |
| } | |
| } | |
| return -1; | |
| } | |
| static int | |
| device_select_find_dri_prime_tag_default(struct device_pci_info *pci_infos, uint32_t device_count, | |
| const char *dri_prime) | |
| { | |
| int default_idx = -1; | |
| /* Drop the trailing '!' if present. */ | |
| int ref = strlen("pci-xxxx_yy_zz_w"); | |
| int n = strlen(dri_prime); | |
| if (n < ref) | |
| return default_idx; | |
| if (n == ref + 1 && dri_prime[n - 1] == '!') | |
| n--; | |
| for (unsigned i = 0; i < device_count; ++i) { | |
| char *tag = NULL; | |
| if (asprintf(&tag, "pci-%04x_%02x_%02x_%1u", pci_infos[i].bus_info.domain, | |
| pci_infos[i].bus_info.bus, pci_infos[i].bus_info.dev, | |
| pci_infos[i].bus_info.func) >= 0) { | |
| if (strncmp(dri_prime, tag, n) == 0) | |
| default_idx = i; | |
| } | |
| free(tag); | |
| } | |
| return default_idx; | |
| } | |
| static int | |
| device_select_find_boot_vga_vid_did(struct device_pci_info *pci_infos, uint32_t device_count) | |
| { | |
| char path[1024]; | |
| int fd; | |
| int default_idx = -1; | |
| uint8_t boot_vga = 0; | |
| ssize_t size_ret; | |
| #pragma pack(push, 1) | |
| struct id { | |
| uint16_t vid; | |
| uint16_t did; | |
| } id; | |
| #pragma pack(pop) | |
| for (unsigned i = 0; i < 64; i++) { | |
| snprintf(path, 1023, "/sys/class/drm/card%d/device/boot_vga", i); | |
| fd = open(path, O_RDONLY); | |
| if (fd != -1) { | |
| uint8_t val; | |
| size_ret = read(fd, &val, 1); | |
| close(fd); | |
| if (size_ret == 1 && val == '1') | |
| boot_vga = 1; | |
| } else { | |
| return default_idx; | |
| } | |
| if (boot_vga) { | |
| snprintf(path, 1023, "/sys/class/drm/card%d/device/config", i); | |
| fd = open(path, O_RDONLY); | |
| if (fd != -1) { | |
| size_ret = read(fd, &id, 4); | |
| close(fd); | |
| if (size_ret != 4) | |
| return default_idx; | |
| } else { | |
| return default_idx; | |
| } | |
| break; | |
| } | |
| } | |
| if (!boot_vga) | |
| return default_idx; | |
| for (unsigned i = 0; i < device_count; ++i) { | |
| if (id.vid == pci_infos[i].dev_info.vendor_id && id.did == pci_infos[i].dev_info.device_id) { | |
| default_idx = i; | |
| break; | |
| } | |
| } | |
| return default_idx; | |
| } | |
| static int | |
| device_select_find_boot_vga_default(struct device_pci_info *pci_infos, uint32_t device_count) | |
| { | |
| char boot_vga_path[1024]; | |
| int default_idx = -1; | |
| for (unsigned i = 0; i < device_count; ++i) { | |
| /* fallback to probing the pci bus boot_vga device. */ | |
| snprintf(boot_vga_path, 1023, "/sys/bus/pci/devices/%04x:%02x:%02x.%x/boot_vga", | |
| pci_infos[i].bus_info.domain, pci_infos[i].bus_info.bus, pci_infos[i].bus_info.dev, | |
| pci_infos[i].bus_info.func); | |
| int fd = open(boot_vga_path, O_RDONLY); | |
| if (fd != -1) { | |
| uint8_t val; | |
| if (read(fd, &val, 1) == 1) { | |
| if (val == '1') | |
| default_idx = i; | |
| } | |
| close(fd); | |
| } | |
| if (default_idx != -1) | |
| break; | |
| } | |
| return default_idx; | |
| } | |
| static int | |
| device_select_find_non_cpu(struct device_pci_info *pci_infos, uint32_t device_count) | |
| { | |
| int default_idx = -1; | |
| /* pick first GPU device */ | |
| for (unsigned i = 0; i < device_count; ++i) { | |
| if (pci_infos[i].device_type != VK_PHYSICAL_DEVICE_TYPE_CPU) { | |
| default_idx = i; | |
| break; | |
| } | |
| } | |
| return default_idx; | |
| } | |
| static int | |
| find_non_cpu_skip(struct device_pci_info *pci_infos, uint32_t device_count, int skip_idx, | |
| int skip_count) | |
| { | |
| for (unsigned i = 0; i < device_count; ++i) { | |
| if (i == skip_idx) | |
| continue; | |
| if (pci_infos[i].device_type == VK_PHYSICAL_DEVICE_TYPE_CPU) | |
| continue; | |
| skip_count--; | |
| if (skip_count > 0) | |
| continue; | |
| return i; | |
| } | |
| return -1; | |
| } | |
| static bool | |
| ends_with_exclamation_mark(const char *str) | |
| { | |
| size_t n = strlen(str); | |
| return n > 1 && str[n - 1] == '!'; | |
| } | |
| static int | |
| get_selected(const struct instance_info *info, uint32_t count, struct device_pci_info *pci_infos, | |
| const char *dri_prime, bool *expose_only_one_dev) | |
| { | |
| int default_idx = -1; | |
| if (info->selection) | |
| default_idx = device_select_find_typed_default(pci_infos, count, info->selection); | |
| if (default_idx != -1) { | |
| if (info->debug) | |
| fprintf(stderr, | |
| "device-select: device_select_find_typed_default for MESA_VK_DEVICE_SELECT " | |
| "selected %i\n", | |
| default_idx); | |
| *expose_only_one_dev = ends_with_exclamation_mark(info->selection); | |
| return default_idx; | |
| } | |
| if (info->selection) | |
| default_idx = device_select_find_explicit_default(pci_infos, count, info->selection); | |
| if (default_idx != -1) { | |
| if (info->debug) | |
| fprintf(stderr, | |
| "device-select: device_select_find_explicit_default for MESA_VK_DEVICE_SELECT " | |
| "selected %i\n", | |
| default_idx); | |
| *expose_only_one_dev = ends_with_exclamation_mark(info->selection); | |
| return default_idx; | |
| } | |
| if (!dri_prime) | |
| return default_idx; | |
| /* Try DRI_PRIME=vendor_id:device_id */ | |
| default_idx = device_select_find_explicit_default(pci_infos, count, dri_prime); | |
| if (default_idx != -1) { | |
| if (info->debug) | |
| fprintf(stderr, "device-select: device_select_find_explicit_default selected %i\n", | |
| default_idx); | |
| *expose_only_one_dev = ends_with_exclamation_mark(dri_prime); | |
| return default_idx; | |
| } | |
| /* Try DRI_PRIME=pci-xxxx_yy_zz_w */ | |
| if (!info->has_vulkan11 && !info->has_pci_bus) | |
| fprintf(stderr, "device-select: cannot correctly use DRI_PRIME tag\n"); | |
| else | |
| default_idx = device_select_find_dri_prime_tag_default(pci_infos, count, dri_prime); | |
| if (default_idx != -1) { | |
| if (info->debug) | |
| fprintf(stderr, "device-select: device_select_find_dri_prime_tag_default selected %i\n", | |
| default_idx); | |
| *expose_only_one_dev = ends_with_exclamation_mark(dri_prime); | |
| } | |
| return default_idx; | |
| } | |
| static int | |
| get_default(const struct instance_info *info, uint32_t count, struct device_pci_info *pci_infos) | |
| { | |
| int default_idx = -1; | |
| bool has_cpu = false; | |
| for (unsigned i = 0; i < count; ++i) | |
| has_cpu |= pci_infos[i].device_type == VK_PHYSICAL_DEVICE_TYPE_CPU; | |
| if (default_idx == -1 && info->has_wayland) { | |
| default_idx = device_select_find_wayland_pci_default(pci_infos, count); | |
| if (info->debug && default_idx != -1) | |
| fprintf(stderr, "device-select: device_select_find_wayland_pci_default selected %i\n", | |
| default_idx); | |
| } | |
| if (default_idx == -1 && info->has_xcb) { | |
| default_idx = device_select_find_xcb_pci_default(pci_infos, count); | |
| if (info->debug && default_idx != -1) | |
| fprintf(stderr, "device-select: device_select_find_xcb_pci_default selected %i\n", | |
| default_idx); | |
| } | |
| if (default_idx == -1) { | |
| if (info->has_vulkan11 && info->has_pci_bus) | |
| default_idx = device_select_find_boot_vga_default(pci_infos, count); | |
| else | |
| default_idx = device_select_find_boot_vga_vid_did(pci_infos, count); | |
| if (info->debug && default_idx != -1) | |
| fprintf(stderr, "device-select: device_select_find_boot_vga selected %i\n", default_idx); | |
| } | |
| /* If no GPU has been selected so far, select the first non-CPU device. If none are available, | |
| * pick the first CPU device. | |
| */ | |
| if (default_idx == -1) { | |
| default_idx = device_select_find_non_cpu(pci_infos, count); | |
| if (info->debug && default_idx != -1) | |
| fprintf(stderr, "device-select: device_select_find_non_cpu selected %i\n", default_idx); | |
| } | |
| if (default_idx == -1 && has_cpu) | |
| default_idx = 0; | |
| return default_idx; | |
| } | |
| uint32_t | |
| device_select_get_first(const struct instance_info *info, uint32_t physical_device_count, | |
| VkPhysicalDevice *pPhysicalDevices, bool *expose_only_one_dev) | |
| { | |
| int default_idx = -1; | |
| int dri_prime_as_int = -1; | |
| int cpu_count = 0; | |
| if (info->dri_prime) { | |
| if (strchr(info->dri_prime, ':') == NULL) | |
| dri_prime_as_int = atoi(info->dri_prime); | |
| if (dri_prime_as_int < 0) | |
| dri_prime_as_int = 0; | |
| } | |
| struct device_pci_info *pci_infos = | |
| (struct device_pci_info *)calloc(physical_device_count, sizeof(struct device_pci_info)); | |
| if (!pci_infos) | |
| return 0; | |
| for (unsigned i = 0; i < physical_device_count; ++i) | |
| cpu_count += fill_drm_device_info(info, &pci_infos[i], pPhysicalDevices[i]) ? 1 : 0; | |
| default_idx = get_selected(info, physical_device_count, pci_infos, | |
| dri_prime_as_int ? NULL : info->dri_prime, expose_only_one_dev); | |
| if (default_idx == -1) | |
| default_idx = get_default(info, physical_device_count, pci_infos); | |
| /* DRI_PRIME=n handling - pick any other device than default. */ | |
| if (dri_prime_as_int > 0 && info->debug) | |
| fprintf(stderr, "device-select: DRI_PRIME=%d, default_idx so far: %i\n", dri_prime_as_int, | |
| default_idx); | |
| if (dri_prime_as_int > 0 && (physical_device_count - cpu_count) > 1 && | |
| (default_idx == 0 || default_idx == 1)) { | |
| default_idx = | |
| find_non_cpu_skip(pci_infos, physical_device_count, default_idx, dri_prime_as_int); | |
| if (default_idx != -1) { | |
| if (info->debug) | |
| fprintf(stderr, "device-select: find_non_cpu_skip selected %i\n", default_idx); | |
| *expose_only_one_dev = ends_with_exclamation_mark(info->dri_prime); | |
| } | |
| } | |
| free(pci_infos); | |
| return default_idx == -1 ? 0 : default_idx; | |
| } |