src/vulkan/device-select-layer/device_select.c - third_party/mesa - Git at Google

 /*
  * 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;
 }
	/*
	* 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;
	}