1 /* 2 * Copyright © 2021 Intel Corporation 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and associated documentation files (the "Software"), 6 * to deal in the Software without restriction, including without limitation 7 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 * and/or sell copies of the Software, and to permit persons to whom the 9 * Software is furnished to do so, subject to the following conditions: 10 * 11 * The above copyright notice and this permission notice (including the next 12 * paragraph) shall be included in all copies or substantial portions of the 13 * Software. 14 * 15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS 21 * IN THE SOFTWARE. 22 */ 23 #ifndef VK_PHYSICAL_DEVICE_H 24 #define VK_PHYSICAL_DEVICE_H 25 26 #include "vk_dispatch_table.h" 27 #include "vk_extensions.h" 28 #include "vk_object.h" 29 #include "vk_physical_device_features.h" 30 #include "vk_physical_device_properties.h" 31 32 #include "util/list.h" 33 34 #ifdef __cplusplus 35 extern "C" { 36 #endif 37 38 struct disk_cache; 39 struct wsi_device; 40 struct vk_sync_type; 41 struct vk_pipeline_cache_object_ops; 42 43 /** Base struct for all VkPhysicalDevice implementations 44 */ 45 struct vk_physical_device { 46 struct vk_object_base base; 47 48 /* See vk_instance::pdevices::list */ 49 struct list_head link; 50 51 /** Instance which is the parent of this physical device */ 52 struct vk_instance *instance; 53 54 /** Table of all supported device extensions 55 * 56 * This table is initialized from the `supported_extensions` parameter 57 * passed to `vk_physical_device_init()` if not `NULL`. If a `NULL` 58 * extension table is passed, all extensions are initialized to false and 59 * it's the responsibility of the driver to populate the table. This may 60 * be useful if the driver's physical device initialization order is such 61 * that extension support cannot be determined until significant physical 62 * device setup work has already been done. 63 */ 64 struct vk_device_extension_table supported_extensions; 65 66 /** Table of all supported features 67 * 68 * This table is initialized from the `supported_features` parameter 69 * passed to `vk_physical_device_init()` if not `NULL`. If a `NULL` 70 * features table is passed, all features are initialized to false and 71 * it's the responsibility of the driver to populate the table. This may 72 * be useful if the driver's physical device initialization order is such 73 * that feature support cannot be determined until significant physical 74 * device setup work has already been done. 75 */ 76 struct vk_features supported_features; 77 78 /** Table of all physical device properties which is initialized similarly 79 * to supported_features 80 */ 81 struct vk_properties properties; 82 83 /** Physical-device-level dispatch table */ 84 struct vk_physical_device_dispatch_table dispatch_table; 85 86 /** Disk cache, or NULL */ 87 struct disk_cache *disk_cache; 88 89 /** WSI device, or NULL */ 90 struct wsi_device *wsi_device; 91 92 /** A null-terminated array of supported sync types, in priority order 93 * 94 * The common implementations of VkFence and VkSemaphore use this list to 95 * determine what vk_sync_type to use for each scenario. The list is 96 * walked and the first vk_sync_type matching their criterion is taken. 97 * For instance, VkFence requires that it not be a timeline and support 98 * reset and CPU wait. If an external handle type is requested, that is 99 * considered just one more criterion. 100 */ 101 const struct vk_sync_type *const *supported_sync_types; 102 103 /** A null-terminated array of supported pipeline cache object types 104 * 105 * The common implementation of VkPipelineCache uses this to remember the 106 * type of objects stored in the cache and deserialize them immediately 107 * when importing the cache. If an object type isn't in this list, then it 108 * will be loaded as a raw data object and then deserialized when we first 109 * look it up. Deserializing immediately avoids a copy but may be more 110 * expensive for objects that aren't hit. 111 */ 112 const struct vk_pipeline_cache_object_ops *const *pipeline_cache_import_ops; 113 }; 114 115 VK_DEFINE_HANDLE_CASTS(vk_physical_device, base, VkPhysicalDevice, 116 VK_OBJECT_TYPE_PHYSICAL_DEVICE); 117 118 /** Initialize a vk_physical_device 119 * 120 * @param[out] physical_device The physical device to initialize 121 * @param[in] instance The instance which is the parent of this 122 * physical device 123 * @param[in] supported_extensions Table of all device extensions supported 124 * by this physical device 125 * @param[in] supported_features Table of all features supported by this 126 * physical device 127 * @param[in] dispatch_table Physical-device-level dispatch table 128 */ 129 VkResult MUST_CHECK 130 vk_physical_device_init(struct vk_physical_device *physical_device, 131 struct vk_instance *instance, 132 const struct vk_device_extension_table *supported_extensions, 133 const struct vk_features *supported_features, 134 const struct vk_properties *properties, 135 const struct vk_physical_device_dispatch_table *dispatch_table); 136 137 /** Tears down a vk_physical_device 138 * 139 * @param[out] physical_device The physical device to tear down 140 */ 141 void 142 vk_physical_device_finish(struct vk_physical_device *physical_device); 143 144 VkResult 145 vk_physical_device_check_device_features(struct vk_physical_device *physical_device, 146 const VkDeviceCreateInfo *pCreateInfo); 147 148 #ifdef __cplusplus 149 } 150 #endif 151 152 #endif /* VK_PHYSICAL_DEVICE_H */ 153