Chia-I Wu | 1930060 | 2014-08-04 08:03:57 +0800 | [diff] [blame] | 1 | /* |
Chia-I Wu | 1930060 | 2014-08-04 08:03:57 +0800 | [diff] [blame] | 2 | * |
Courtney Goeltzenleuchter | fcbe16f | 2015-10-29 13:50:34 -0600 | [diff] [blame] | 3 | * Copyright (C) 2015 Valve Corporation |
Chia-I Wu | 1930060 | 2014-08-04 08:03:57 +0800 | [diff] [blame] | 4 | * |
| 5 | * Permission is hereby granted, free of charge, to any person obtaining a |
| 6 | * copy of this software and associated documentation files (the "Software"), |
| 7 | * to deal in the Software without restriction, including without limitation |
| 8 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
| 9 | * and/or sell copies of the Software, and to permit persons to whom the |
| 10 | * Software is furnished to do so, subject to the following conditions: |
| 11 | * |
| 12 | * The above copyright notice and this permission notice shall be included |
| 13 | * in all copies or substantial portions of the 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 |
| 21 | * DEALINGS IN THE SOFTWARE. |
Chia-I Wu | 701f3f6 | 2014-09-02 08:32:09 +0800 | [diff] [blame] | 22 | * |
Courtney Goeltzenleuchter | 0555952 | 2015-10-30 11:14:30 -0600 | [diff] [blame] | 23 | * Author: Chia-I Wu <olvaffe@gmail.com> |
| 24 | * Author: Chia-I Wu <olv@lunarg.com> |
| 25 | * Author: Chris Forbes <chrisf@ijw.co.nz> |
| 26 | * Author: Courtney Goeltzenleuchter <courtney@LunarG.com> |
| 27 | * Author: Jon Ashburn <jon@lunarg.com> |
| 28 | * Author: Tony Barbour <tony@LunarG.com> |
| 29 | * |
Chia-I Wu | 1930060 | 2014-08-04 08:03:57 +0800 | [diff] [blame] | 30 | */ |
| 31 | |
| 32 | #ifndef LOADER_H |
| 33 | #define LOADER_H |
| 34 | |
David Pinedo | 9316d3b | 2015-11-06 12:54:48 -0700 | [diff] [blame] | 35 | #include <vulkan/vulkan.h> |
Jon Ashburn | 8a39efc | 2015-11-06 11:02:40 -0700 | [diff] [blame] | 36 | #include <vk_loader_platform.h> |
David Pinedo | 9316d3b | 2015-11-06 12:54:48 -0700 | [diff] [blame] | 37 | #include <vulkan/vk_debug_report_lunarg.h> |
| 38 | #include <vulkan/vk_ext_khr_swapchain.h> |
| 39 | #include <vulkan/vk_layer.h> |
| 40 | #include <vulkan/vk_icd.h> |
Chia-I Wu | 5291c76 | 2015-04-11 15:34:07 +0800 | [diff] [blame] | 41 | #include <assert.h> |
| 42 | |
Chia-I Wu | 1930060 | 2014-08-04 08:03:57 +0800 | [diff] [blame] | 43 | #if defined(__GNUC__) && __GNUC__ >= 4 |
| 44 | # define LOADER_EXPORT __attribute__((visibility("default"))) |
| 45 | #elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590) |
| 46 | # define LOADER_EXPORT __attribute__((visibility("default"))) |
| 47 | #else |
| 48 | # define LOADER_EXPORT |
| 49 | #endif |
| 50 | |
Jon Ashburn | f73e921 | 2015-08-04 10:22:33 -0600 | [diff] [blame] | 51 | #define MAX_STRING_SIZE 1024 |
Courtney Goeltzenleuchter | 110fdf9 | 2015-06-29 15:39:26 -0600 | [diff] [blame] | 52 | #define VK_MAJOR(version) (version >> 22) |
| 53 | #define VK_MINOR(version) ((version >> 12) & 0x3ff) |
| 54 | #define VK_PATCH(version) (version & 0xfff) |
Jon Ashburn | 27cd584 | 2015-05-12 17:26:48 -0600 | [diff] [blame] | 55 | |
Jon Ashburn | 5ef2060 | 2015-07-02 09:40:15 -0600 | [diff] [blame] | 56 | enum layer_type { |
Jon Ashburn | 0c26e71 | 2015-07-02 16:10:32 -0600 | [diff] [blame] | 57 | VK_LAYER_TYPE_DEVICE_EXPLICIT = 0x1, |
| 58 | VK_LAYER_TYPE_INSTANCE_EXPLICIT = 0x2, |
| 59 | VK_LAYER_TYPE_GLOBAL_EXPLICIT = 0x3, // both instance and device layer, bitwise |
| 60 | VK_LAYER_TYPE_DEVICE_IMPLICIT = 0x4, |
| 61 | VK_LAYER_TYPE_INSTANCE_IMPLICIT = 0x8, |
| 62 | VK_LAYER_TYPE_GLOBAL_IMPLICIT = 0xc, // both instance and device layer, bitwise |
Jon Ashburn | 5ef2060 | 2015-07-02 09:40:15 -0600 | [diff] [blame] | 63 | }; |
| 64 | |
Courtney Goeltzenleuchter | f579fa6 | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 65 | struct loader_extension_list { |
| 66 | size_t capacity; |
| 67 | uint32_t count; |
Jon Ashburn | 5c042ea | 2015-08-04 11:14:18 -0600 | [diff] [blame] | 68 | VkExtensionProperties *list; |
Courtney Goeltzenleuchter | f579fa6 | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 69 | }; |
| 70 | |
Jon Ashburn | 5ef2060 | 2015-07-02 09:40:15 -0600 | [diff] [blame] | 71 | struct loader_name_value { |
Jon Ashburn | f73e921 | 2015-08-04 10:22:33 -0600 | [diff] [blame] | 72 | char name[MAX_STRING_SIZE]; |
| 73 | char value[MAX_STRING_SIZE]; |
Jon Ashburn | 5ef2060 | 2015-07-02 09:40:15 -0600 | [diff] [blame] | 74 | }; |
| 75 | |
| 76 | struct loader_lib_info { |
Jon Ashburn | 3d00233 | 2015-08-20 16:35:30 -0600 | [diff] [blame] | 77 | char lib_name[MAX_STRING_SIZE]; |
Jon Ashburn | 5ef2060 | 2015-07-02 09:40:15 -0600 | [diff] [blame] | 78 | uint32_t ref_count; |
| 79 | loader_platform_dl_handle lib_handle; |
| 80 | }; |
Courtney Goeltzenleuchter | f579fa6 | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 81 | |
Jon Ashburn | 5ef2060 | 2015-07-02 09:40:15 -0600 | [diff] [blame] | 82 | struct loader_layer_functions { |
Jon Ashburn | f73e921 | 2015-08-04 10:22:33 -0600 | [diff] [blame] | 83 | char str_gipa[MAX_STRING_SIZE]; |
| 84 | char str_gdpa[MAX_STRING_SIZE]; |
Jon Ashburn | 5ef2060 | 2015-07-02 09:40:15 -0600 | [diff] [blame] | 85 | PFN_vkGetInstanceProcAddr get_instance_proc_addr; |
| 86 | PFN_vkGetDeviceProcAddr get_device_proc_addr; |
| 87 | }; |
Courtney Goeltzenleuchter | f579fa6 | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 88 | |
Jon Ashburn | 5ef2060 | 2015-07-02 09:40:15 -0600 | [diff] [blame] | 89 | struct loader_layer_properties { |
Courtney Goeltzenleuchter | 110fdf9 | 2015-06-29 15:39:26 -0600 | [diff] [blame] | 90 | VkLayerProperties info; |
Jon Ashburn | 5ef2060 | 2015-07-02 09:40:15 -0600 | [diff] [blame] | 91 | enum layer_type type; |
Jon Ashburn | 3d00233 | 2015-08-20 16:35:30 -0600 | [diff] [blame] | 92 | char lib_name[MAX_STRING_SIZE]; |
Jon Ashburn | 5ef2060 | 2015-07-02 09:40:15 -0600 | [diff] [blame] | 93 | struct loader_layer_functions functions; |
| 94 | struct loader_extension_list instance_extension_list; |
| 95 | struct loader_extension_list device_extension_list; |
| 96 | struct loader_name_value disable_env_var; |
| 97 | struct loader_name_value enable_env_var; |
| 98 | }; |
| 99 | |
| 100 | struct loader_layer_list { |
| 101 | size_t capacity; |
| 102 | uint32_t count; |
| 103 | struct loader_layer_properties *list; |
Jon Ashburn | 27cd584 | 2015-05-12 17:26:48 -0600 | [diff] [blame] | 104 | }; |
| 105 | |
Courtney Goeltzenleuchter | 371de70 | 2015-07-05 12:53:31 -0600 | [diff] [blame] | 106 | struct loader_layer_library_list { |
| 107 | size_t capacity; |
| 108 | uint32_t count; |
| 109 | struct loader_lib_info *list; |
| 110 | }; |
| 111 | |
Jon Ashburn | fc1031e | 2015-11-17 15:31:02 -0700 | [diff] [blame] | 112 | struct loader_dispatch_hash_list { |
| 113 | size_t capacity; |
| 114 | uint32_t count; |
| 115 | uint32_t *index; // index into the dev_ext dispatch table |
| 116 | }; |
| 117 | |
| 118 | #define MAX_NUM_DEV_EXTS 250 |
| 119 | // loader_dispatch_hash_entry and loader_dev_ext_dispatch_table.DevExt have one to one |
| 120 | // correspondence; one loader_dispatch_hash_entry for one DevExt dispatch entry. |
| 121 | // Also have a one to one correspondence with functions in dev_ext_trampoline.c |
| 122 | struct loader_dispatch_hash_entry { |
| 123 | char *func_name; |
| 124 | struct loader_dispatch_hash_list list; // to handle hashing collisions |
| 125 | }; |
| 126 | |
| 127 | typedef void (VKAPI_PTR *PFN_vkDevExt)(VkDevice device); |
| 128 | struct loader_dev_ext_dispatch_table { |
| 129 | PFN_vkDevExt DevExt[MAX_NUM_DEV_EXTS]; |
| 130 | }; |
| 131 | |
| 132 | struct loader_dev_dispatch_table { |
| 133 | VkLayerDispatchTable core_dispatch; |
| 134 | struct loader_dev_ext_dispatch_table ext_dispatch; |
| 135 | }; |
| 136 | |
Jon Ashburn | dc6fcad | 2015-06-10 10:06:06 -0600 | [diff] [blame] | 137 | /* per CreateDevice structure */ |
| 138 | struct loader_device { |
Jon Ashburn | fc1031e | 2015-11-17 15:31:02 -0700 | [diff] [blame] | 139 | struct loader_dev_dispatch_table loader_dispatch; |
Jon Ashburn | dc6fcad | 2015-06-10 10:06:06 -0600 | [diff] [blame] | 140 | VkDevice device; // device object from the icd |
| 141 | |
| 142 | uint32_t app_extension_count; |
| 143 | VkExtensionProperties *app_extension_props; |
| 144 | |
Courtney Goeltzenleuchter | 110fdf9 | 2015-06-29 15:39:26 -0600 | [diff] [blame] | 145 | struct loader_layer_list activated_layer_list; |
Jon Ashburn | dc6fcad | 2015-06-10 10:06:06 -0600 | [diff] [blame] | 146 | |
| 147 | struct loader_device *next; |
| 148 | }; |
| 149 | |
Jon Ashburn | 953bb3c | 2015-06-10 16:11:42 -0600 | [diff] [blame] | 150 | /* per ICD structure */ |
Jon Ashburn | 95a77ba | 2015-05-15 15:09:35 -0600 | [diff] [blame] | 151 | struct loader_icd { |
Jon Ashburn | 3d00233 | 2015-08-20 16:35:30 -0600 | [diff] [blame] | 152 | // pointers to find other structs |
| 153 | const struct loader_scanned_icds *this_icd_lib; |
| 154 | const struct loader_instance *this_instance; |
Jon Ashburn | 95a77ba | 2015-05-15 15:09:35 -0600 | [diff] [blame] | 155 | |
Jon Ashburn | dc6fcad | 2015-06-10 10:06:06 -0600 | [diff] [blame] | 156 | struct loader_device *logical_device_list; |
Jon Ashburn | 95a77ba | 2015-05-15 15:09:35 -0600 | [diff] [blame] | 157 | VkInstance instance; // instance object from the icd |
Jon Ashburn | 8d1b0b5 | 2015-05-18 13:20:15 -0600 | [diff] [blame] | 158 | PFN_vkGetDeviceProcAddr GetDeviceProcAddr; |
Jon Ashburn | 95a77ba | 2015-05-15 15:09:35 -0600 | [diff] [blame] | 159 | PFN_vkDestroyInstance DestroyInstance; |
| 160 | PFN_vkEnumeratePhysicalDevices EnumeratePhysicalDevices; |
Chris Forbes | bc0bb77 | 2015-06-21 22:55:02 +1200 | [diff] [blame] | 161 | PFN_vkGetPhysicalDeviceFeatures GetPhysicalDeviceFeatures; |
Courtney Goeltzenleuchter | 2caec86 | 2015-07-12 12:52:09 -0600 | [diff] [blame] | 162 | PFN_vkGetPhysicalDeviceFormatProperties GetPhysicalDeviceFormatProperties; |
Jon Ashburn | 754864f | 2015-07-23 18:49:07 -0600 | [diff] [blame] | 163 | PFN_vkGetPhysicalDeviceImageFormatProperties GetPhysicalDeviceImageFormatProperties; |
Jon Ashburn | 95a77ba | 2015-05-15 15:09:35 -0600 | [diff] [blame] | 164 | PFN_vkCreateDevice CreateDevice; |
Tony Barbour | 59a4732 | 2015-06-24 16:06:58 -0600 | [diff] [blame] | 165 | PFN_vkGetPhysicalDeviceProperties GetPhysicalDeviceProperties; |
Cody Northrop | d080288 | 2015-08-03 17:04:53 -0600 | [diff] [blame] | 166 | PFN_vkGetPhysicalDeviceQueueFamilyProperties GetPhysicalDeviceQueueFamilyProperties; |
Tony Barbour | 59a4732 | 2015-06-24 16:06:58 -0600 | [diff] [blame] | 167 | PFN_vkGetPhysicalDeviceMemoryProperties GetPhysicalDeviceMemoryProperties; |
Courtney Goeltzenleuchter | 35985f6 | 2015-09-14 17:22:16 -0600 | [diff] [blame] | 168 | PFN_vkEnumerateDeviceExtensionProperties EnumerateDeviceExtensionProperties; |
Mark Lobodzinski | 16e8bef | 2015-07-03 15:58:09 -0600 | [diff] [blame] | 169 | PFN_vkGetPhysicalDeviceSparseImageFormatProperties GetPhysicalDeviceSparseImageFormatProperties; |
Courtney Goeltzenleuchter | f579fa6 | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 170 | PFN_vkDbgCreateMsgCallback DbgCreateMsgCallback; |
| 171 | PFN_vkDbgDestroyMsgCallback DbgDestroyMsgCallback; |
Ian Elliott | 7e40db9 | 2015-08-21 15:09:33 -0600 | [diff] [blame] | 172 | PFN_vkGetPhysicalDeviceSurfaceSupportKHR GetPhysicalDeviceSurfaceSupportKHR; |
Courtney Goeltzenleuchter | 110fdf9 | 2015-06-29 15:39:26 -0600 | [diff] [blame] | 173 | |
Jon Ashburn | dc6fcad | 2015-06-10 10:06:06 -0600 | [diff] [blame] | 174 | struct loader_icd *next; |
Jon Ashburn | 95a77ba | 2015-05-15 15:09:35 -0600 | [diff] [blame] | 175 | }; |
| 176 | |
Jon Ashburn | 8810c5f | 2015-08-18 18:04:47 -0600 | [diff] [blame] | 177 | /* per ICD library structure */ |
| 178 | struct loader_icd_libs { |
| 179 | size_t capacity; |
| 180 | uint32_t count; |
| 181 | struct loader_scanned_icds *list; |
| 182 | }; |
| 183 | |
Jon Ashburn | 953bb3c | 2015-06-10 16:11:42 -0600 | [diff] [blame] | 184 | /* per instance structure */ |
Jon Ashburn | 27cd584 | 2015-05-12 17:26:48 -0600 | [diff] [blame] | 185 | struct loader_instance { |
Jon Ashburn | 95a77ba | 2015-05-15 15:09:35 -0600 | [diff] [blame] | 186 | VkLayerInstanceDispatchTable *disp; // must be first entry in structure |
| 187 | |
Jon Ashburn | 27cd584 | 2015-05-12 17:26:48 -0600 | [diff] [blame] | 188 | uint32_t total_gpu_count; |
Jon Ashburn | 24cd4be | 2015-11-01 14:04:06 -0700 | [diff] [blame] | 189 | struct loader_physical_device *phys_devs; |
Courtney Goeltzenleuchter | f579fa6 | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 190 | uint32_t total_icd_count; |
Jon Ashburn | 27cd584 | 2015-05-12 17:26:48 -0600 | [diff] [blame] | 191 | struct loader_icd *icds; |
| 192 | struct loader_instance *next; |
Jon Ashburn | 5c6a46f | 2015-08-14 14:49:22 -0600 | [diff] [blame] | 193 | struct loader_extension_list ext_list; // icds and loaders extensions |
Jon Ashburn | 8810c5f | 2015-08-18 18:04:47 -0600 | [diff] [blame] | 194 | struct loader_icd_libs icd_libs; |
Jon Ashburn | 3d00233 | 2015-08-20 16:35:30 -0600 | [diff] [blame] | 195 | struct loader_layer_list instance_layer_list; |
| 196 | struct loader_layer_list device_layer_list; |
Jon Ashburn | fc1031e | 2015-11-17 15:31:02 -0700 | [diff] [blame] | 197 | struct loader_dispatch_hash_entry disp_hash[MAX_NUM_DEV_EXTS]; |
Jon Ashburn | 3d00233 | 2015-08-20 16:35:30 -0600 | [diff] [blame] | 198 | |
Courtney Goeltzenleuchter | f579fa6 | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 199 | struct loader_msg_callback_map_entry *icd_msg_callback_map; |
| 200 | |
Courtney Goeltzenleuchter | 110fdf9 | 2015-06-29 15:39:26 -0600 | [diff] [blame] | 201 | struct loader_layer_list activated_layer_list; |
Courtney Goeltzenleuchter | f579fa6 | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 202 | |
| 203 | bool debug_report_enabled; |
Courtney Goeltzenleuchter | f579fa6 | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 204 | VkLayerDbgFunctionNode *DbgFunctionHead; |
Courtney Goeltzenleuchter | 7f5aafc | 2015-07-05 11:28:29 -0600 | [diff] [blame] | 205 | |
Chia-I Wu | 3432a0c | 2015-10-27 18:04:07 +0800 | [diff] [blame] | 206 | VkAllocationCallbacks alloc_callbacks; |
Ian Elliott | d3ef02f | 2015-07-06 14:36:13 -0600 | [diff] [blame] | 207 | |
| 208 | bool wsi_swapchain_enabled; |
Courtney Goeltzenleuchter | f579fa6 | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 209 | }; |
| 210 | |
Jon Ashburn | 24cd4be | 2015-11-01 14:04:06 -0700 | [diff] [blame] | 211 | /* per enumerated PhysicalDevice structure */ |
| 212 | struct loader_physical_device { |
| 213 | VkLayerInstanceDispatchTable *disp; // must be first entry in structure |
| 214 | struct loader_instance *this_instance; |
| 215 | struct loader_icd *this_icd; |
| 216 | VkPhysicalDevice phys_dev; // object from ICD |
| 217 | /* |
| 218 | * Fill in the cache of available device extensions from |
Jon Ashburn | 00eb6c0 | 2015-11-02 17:40:01 -0700 | [diff] [blame] | 219 | * this physical device. This cache can be used during CreateDevice |
Jon Ashburn | 24cd4be | 2015-11-01 14:04:06 -0700 | [diff] [blame] | 220 | */ |
| 221 | struct loader_extension_list device_extension_cache; |
| 222 | }; |
| 223 | |
Jon Ashburn | 27cd584 | 2015-05-12 17:26:48 -0600 | [diff] [blame] | 224 | struct loader_struct { |
| 225 | struct loader_instance *instances; |
Courtney Goeltzenleuchter | f579fa6 | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 226 | |
| 227 | unsigned int loaded_layer_lib_count; |
Courtney Goeltzenleuchter | dad30df | 2015-10-07 09:00:34 -0600 | [diff] [blame] | 228 | size_t loaded_layer_lib_capacity; |
Courtney Goeltzenleuchter | f579fa6 | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 229 | struct loader_lib_info *loaded_layer_lib_list; |
Jon Ashburn | 8810c5f | 2015-08-18 18:04:47 -0600 | [diff] [blame] | 230 | // TODO add ref counting of ICD libraries |
Jon Ashburn | 2d0c4bb | 2015-07-06 15:40:35 -0600 | [diff] [blame] | 231 | // TODO use this struct loader_layer_library_list scanned_layer_libraries; |
Jon Ashburn | 8810c5f | 2015-08-18 18:04:47 -0600 | [diff] [blame] | 232 | // TODO add list of icd libraries for ref counting them for closure |
Courtney Goeltzenleuchter | f579fa6 | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 233 | }; |
| 234 | |
| 235 | struct loader_scanned_icds { |
| 236 | char *lib_name; |
| 237 | loader_platform_dl_handle handle; |
Jon Ashburn | 005617f | 2015-11-17 17:35:40 -0700 | [diff] [blame] | 238 | uint32_t api_version; |
Jon Ashburn | c624c88 | 2015-07-16 10:17:29 -0600 | [diff] [blame] | 239 | PFN_vkGetInstanceProcAddr GetInstanceProcAddr; |
Courtney Goeltzenleuchter | f579fa6 | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 240 | PFN_vkCreateInstance CreateInstance; |
Courtney Goeltzenleuchter | 35985f6 | 2015-09-14 17:22:16 -0600 | [diff] [blame] | 241 | PFN_vkEnumerateInstanceExtensionProperties EnumerateInstanceExtensionProperties; |
Jon Ashburn | 27cd584 | 2015-05-12 17:26:48 -0600 | [diff] [blame] | 242 | }; |
| 243 | |
Jon Ashburn | 5ef2060 | 2015-07-02 09:40:15 -0600 | [diff] [blame] | 244 | static inline struct loader_instance *loader_instance(VkInstance instance) { |
| 245 | return (struct loader_instance *) instance; |
| 246 | } |
| 247 | |
Tony Barbour | 1d2cd3f | 2015-07-03 10:33:54 -0600 | [diff] [blame] | 248 | static inline void loader_set_dispatch(void* obj, const void *data) |
Chia-I Wu | 5291c76 | 2015-04-11 15:34:07 +0800 | [diff] [blame] | 249 | { |
| 250 | *((const void **) obj) = data; |
| 251 | } |
| 252 | |
Tony Barbour | 1d2cd3f | 2015-07-03 10:33:54 -0600 | [diff] [blame] | 253 | static inline VkLayerDispatchTable *loader_get_dispatch(const void* obj) |
Chia-I Wu | 5291c76 | 2015-04-11 15:34:07 +0800 | [diff] [blame] | 254 | { |
Jon Ashburn | 1ed042c | 2015-05-01 18:00:33 -0600 | [diff] [blame] | 255 | return *((VkLayerDispatchTable **) obj); |
Chia-I Wu | 5291c76 | 2015-04-11 15:34:07 +0800 | [diff] [blame] | 256 | } |
| 257 | |
Jon Ashburn | fc1031e | 2015-11-17 15:31:02 -0700 | [diff] [blame] | 258 | static inline struct loader_dev_dispatch_table *loader_get_dev_dispatch(const void* obj) |
| 259 | { |
| 260 | return *((struct loader_dev_dispatch_table **) obj); |
| 261 | } |
| 262 | |
Tony Barbour | 1d2cd3f | 2015-07-03 10:33:54 -0600 | [diff] [blame] | 263 | static inline VkLayerInstanceDispatchTable *loader_get_instance_dispatch(const void* obj) |
Jon Ashburn | 27cd584 | 2015-05-12 17:26:48 -0600 | [diff] [blame] | 264 | { |
| 265 | return *((VkLayerInstanceDispatchTable **) obj); |
| 266 | } |
| 267 | |
Tony Barbour | 1d2cd3f | 2015-07-03 10:33:54 -0600 | [diff] [blame] | 268 | static inline void loader_init_dispatch(void* obj, const void *data) |
Chia-I Wu | 5291c76 | 2015-04-11 15:34:07 +0800 | [diff] [blame] | 269 | { |
Jon Ashburn | 4006664 | 2015-04-15 13:34:33 -0600 | [diff] [blame] | 270 | #ifdef DEBUG |
Chia-I Wu | 5291c76 | 2015-04-11 15:34:07 +0800 | [diff] [blame] | 271 | assert(valid_loader_magic_value(obj) && |
| 272 | "Incompatible ICD, first dword must be initialized to ICD_LOADER_MAGIC. See loader/README.md for details."); |
Jon Ashburn | 4006664 | 2015-04-15 13:34:33 -0600 | [diff] [blame] | 273 | #endif |
Chia-I Wu | 5291c76 | 2015-04-11 15:34:07 +0800 | [diff] [blame] | 274 | |
Jon Ashburn | 1ed042c | 2015-05-01 18:00:33 -0600 | [diff] [blame] | 275 | loader_set_dispatch(obj, data); |
Chia-I Wu | 5291c76 | 2015-04-11 15:34:07 +0800 | [diff] [blame] | 276 | } |
| 277 | |
Jon Ashburn | 27cd584 | 2015-05-12 17:26:48 -0600 | [diff] [blame] | 278 | /* global variables used across files */ |
| 279 | extern struct loader_struct loader; |
Jon Ashburn | 87d6aa9 | 2015-08-28 15:19:27 -0600 | [diff] [blame] | 280 | extern THREAD_LOCAL_DECL struct loader_instance *tls_instance; |
Jon Ashburn | 8810c5f | 2015-08-18 18:04:47 -0600 | [diff] [blame] | 281 | extern LOADER_PLATFORM_THREAD_ONCE_DEFINITION(once_init); |
Jon Ashburn | 6301a0f | 2015-05-29 13:15:39 -0600 | [diff] [blame] | 282 | extern loader_platform_thread_mutex loader_lock; |
Jon Ashburn | 6461ef2 | 2015-09-22 13:11:00 -0600 | [diff] [blame] | 283 | extern loader_platform_thread_mutex loader_json_lock; |
Jon Ashburn | 6301a0f | 2015-05-29 13:15:39 -0600 | [diff] [blame] | 284 | extern const VkLayerInstanceDispatchTable instance_disp; |
Jon Ashburn | bacb0f5 | 2015-04-06 10:58:22 -0600 | [diff] [blame] | 285 | |
Courtney Goeltzenleuchter | f579fa6 | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 286 | struct loader_msg_callback_map_entry { |
| 287 | VkDbgMsgCallback icd_obj; |
| 288 | VkDbgMsgCallback loader_obj; |
| 289 | }; |
| 290 | |
| 291 | bool compare_vk_extension_properties( |
| 292 | const VkExtensionProperties* op1, |
| 293 | const VkExtensionProperties* op2); |
| 294 | |
Jon Ashburn | 3d00233 | 2015-08-20 16:35:30 -0600 | [diff] [blame] | 295 | VkResult loader_validate_layers( |
| 296 | const uint32_t layer_count, |
| 297 | const char * const *ppEnabledLayerNames, |
| 298 | const struct loader_layer_list *list); |
Courtney Goeltzenleuchter | 3b8c5ff | 2015-07-06 17:45:08 -0600 | [diff] [blame] | 299 | |
| 300 | VkResult loader_validate_instance_extensions( |
Jon Ashburn | 9a4c6aa | 2015-08-14 11:57:54 -0600 | [diff] [blame] | 301 | const struct loader_extension_list *icd_exts, |
Jon Ashburn | b82c185 | 2015-08-11 14:49:54 -0600 | [diff] [blame] | 302 | const struct loader_layer_list *instance_layer, |
Courtney Goeltzenleuchter | 3b8c5ff | 2015-07-06 17:45:08 -0600 | [diff] [blame] | 303 | const VkInstanceCreateInfo* pCreateInfo); |
| 304 | |
Jon Ashburn | 27cd584 | 2015-05-12 17:26:48 -0600 | [diff] [blame] | 305 | /* instance layer chain termination entrypoint definitions */ |
Chia-I Wu | 9ab6150 | 2015-11-06 06:42:02 +0800 | [diff] [blame] | 306 | VKAPI_ATTR VkResult VKAPI_CALL loader_CreateInstance( |
Jon Ashburn | 27cd584 | 2015-05-12 17:26:48 -0600 | [diff] [blame] | 307 | const VkInstanceCreateInfo* pCreateInfo, |
Chia-I Wu | 3432a0c | 2015-10-27 18:04:07 +0800 | [diff] [blame] | 308 | const VkAllocationCallbacks* pAllocator, |
Jon Ashburn | 27cd584 | 2015-05-12 17:26:48 -0600 | [diff] [blame] | 309 | VkInstance* pInstance); |
Chia-I Wu | 5291c76 | 2015-04-11 15:34:07 +0800 | [diff] [blame] | 310 | |
Chia-I Wu | 9ab6150 | 2015-11-06 06:42:02 +0800 | [diff] [blame] | 311 | VKAPI_ATTR void VKAPI_CALL loader_DestroyInstance( |
Chia-I Wu | f7458c5 | 2015-10-26 21:10:41 +0800 | [diff] [blame] | 312 | VkInstance instance, |
Chia-I Wu | 3432a0c | 2015-10-27 18:04:07 +0800 | [diff] [blame] | 313 | const VkAllocationCallbacks* pAllocator); |
Jon Ashburn | 27cd584 | 2015-05-12 17:26:48 -0600 | [diff] [blame] | 314 | |
Chia-I Wu | 9ab6150 | 2015-11-06 06:42:02 +0800 | [diff] [blame] | 315 | VKAPI_ATTR VkResult VKAPI_CALL loader_EnumeratePhysicalDevices( |
Jon Ashburn | 27cd584 | 2015-05-12 17:26:48 -0600 | [diff] [blame] | 316 | VkInstance instance, |
| 317 | uint32_t* pPhysicalDeviceCount, |
| 318 | VkPhysicalDevice* pPhysicalDevices); |
Chris Forbes | bc0bb77 | 2015-06-21 22:55:02 +1200 | [diff] [blame] | 319 | |
Chia-I Wu | 9ab6150 | 2015-11-06 06:42:02 +0800 | [diff] [blame] | 320 | VKAPI_ATTR void VKAPI_CALL loader_GetPhysicalDeviceFeatures( |
Chris Forbes | bc0bb77 | 2015-06-21 22:55:02 +1200 | [diff] [blame] | 321 | VkPhysicalDevice physicalDevice, |
| 322 | VkPhysicalDeviceFeatures* pFeatures); |
| 323 | |
Chia-I Wu | 9ab6150 | 2015-11-06 06:42:02 +0800 | [diff] [blame] | 324 | VKAPI_ATTR void VKAPI_CALL loader_GetPhysicalDeviceFormatProperties( |
Chris Forbes | bc0bb77 | 2015-06-21 22:55:02 +1200 | [diff] [blame] | 325 | VkPhysicalDevice physicalDevice, |
| 326 | VkFormat format, |
| 327 | VkFormatProperties* pFormatInfo); |
| 328 | |
Chia-I Wu | 9ab6150 | 2015-11-06 06:42:02 +0800 | [diff] [blame] | 329 | VKAPI_ATTR VkResult VKAPI_CALL loader_GetPhysicalDeviceImageFormatProperties( |
Chia-I Wu | 1724104 | 2015-10-31 00:31:16 +0800 | [diff] [blame] | 330 | VkPhysicalDevice physicalDevice, |
Jon Ashburn | 754864f | 2015-07-23 18:49:07 -0600 | [diff] [blame] | 331 | VkFormat format, |
| 332 | VkImageType type, |
| 333 | VkImageTiling tiling, |
| 334 | VkImageUsageFlags usage, |
Courtney Goeltzenleuchter | a22097a | 2015-09-10 13:44:12 -0600 | [diff] [blame] | 335 | VkImageCreateFlags flags, |
Jon Ashburn | 754864f | 2015-07-23 18:49:07 -0600 | [diff] [blame] | 336 | VkImageFormatProperties* pImageFormatProperties); |
| 337 | |
Chia-I Wu | 9ab6150 | 2015-11-06 06:42:02 +0800 | [diff] [blame] | 338 | VKAPI_ATTR void VKAPI_CALL loader_GetPhysicalDeviceSparseImageFormatProperties( |
Mark Lobodzinski | 16e8bef | 2015-07-03 15:58:09 -0600 | [diff] [blame] | 339 | VkPhysicalDevice physicalDevice, |
| 340 | VkFormat format, |
| 341 | VkImageType type, |
Chia-I Wu | 5c17c96 | 2015-10-31 00:31:16 +0800 | [diff] [blame] | 342 | VkSampleCountFlagBits samples, |
Mark Lobodzinski | 16e8bef | 2015-07-03 15:58:09 -0600 | [diff] [blame] | 343 | VkImageUsageFlags usage, |
| 344 | VkImageTiling tiling, |
| 345 | uint32_t* pNumProperties, |
| 346 | VkSparseImageFormatProperties* pProperties); |
Tony Barbour | 59a4732 | 2015-06-24 16:06:58 -0600 | [diff] [blame] | 347 | |
Chia-I Wu | 9ab6150 | 2015-11-06 06:42:02 +0800 | [diff] [blame] | 348 | VKAPI_ATTR void VKAPI_CALL loader_GetPhysicalDeviceProperties ( |
Tony Barbour | 59a4732 | 2015-06-24 16:06:58 -0600 | [diff] [blame] | 349 | VkPhysicalDevice physicalDevice, |
| 350 | VkPhysicalDeviceProperties* pProperties); |
| 351 | |
Chia-I Wu | 9ab6150 | 2015-11-06 06:42:02 +0800 | [diff] [blame] | 352 | VKAPI_ATTR VkResult VKAPI_CALL loader_EnumerateDeviceExtensionProperties (VkPhysicalDevice physicalDevice, |
Courtney Goeltzenleuchter | 110fdf9 | 2015-06-29 15:39:26 -0600 | [diff] [blame] | 353 | const char *pLayerName, uint32_t *pCount, |
Tony Barbour | 59a4732 | 2015-06-24 16:06:58 -0600 | [diff] [blame] | 354 | VkExtensionProperties* pProperties); |
| 355 | |
Chia-I Wu | 9ab6150 | 2015-11-06 06:42:02 +0800 | [diff] [blame] | 356 | VKAPI_ATTR VkResult VKAPI_CALL loader_EnumerateDeviceLayerProperties (VkPhysicalDevice physicalDevice, |
Courtney Goeltzenleuchter | 110fdf9 | 2015-06-29 15:39:26 -0600 | [diff] [blame] | 357 | uint32_t *pCount, |
| 358 | VkLayerProperties* pProperties); |
Tony Barbour | 59a4732 | 2015-06-24 16:06:58 -0600 | [diff] [blame] | 359 | |
Chia-I Wu | 9ab6150 | 2015-11-06 06:42:02 +0800 | [diff] [blame] | 360 | VKAPI_ATTR void VKAPI_CALL loader_GetPhysicalDeviceQueueFamilyProperties ( |
Cody Northrop | d080288 | 2015-08-03 17:04:53 -0600 | [diff] [blame] | 361 | VkPhysicalDevice physicalDevice, |
| 362 | uint32_t* pCount, |
| 363 | VkQueueFamilyProperties* pProperties); |
Tony Barbour | 59a4732 | 2015-06-24 16:06:58 -0600 | [diff] [blame] | 364 | |
Chia-I Wu | 9ab6150 | 2015-11-06 06:42:02 +0800 | [diff] [blame] | 365 | VKAPI_ATTR void VKAPI_CALL loader_GetPhysicalDeviceMemoryProperties ( |
Tony Barbour | 59a4732 | 2015-06-24 16:06:58 -0600 | [diff] [blame] | 366 | VkPhysicalDevice physicalDevice, |
| 367 | VkPhysicalDeviceMemoryProperties * pProperties); |
Jon Ashburn | 6301a0f | 2015-05-29 13:15:39 -0600 | [diff] [blame] | 368 | |
Chia-I Wu | 9ab6150 | 2015-11-06 06:42:02 +0800 | [diff] [blame] | 369 | VKAPI_ATTR VkResult VKAPI_CALL loader_CreateDevice( |
Jon Ashburn | 95a77ba | 2015-05-15 15:09:35 -0600 | [diff] [blame] | 370 | VkPhysicalDevice gpu, |
| 371 | const VkDeviceCreateInfo* pCreateInfo, |
Chia-I Wu | 3432a0c | 2015-10-27 18:04:07 +0800 | [diff] [blame] | 372 | const VkAllocationCallbacks* pAllocator, |
Jon Ashburn | 95a77ba | 2015-05-15 15:09:35 -0600 | [diff] [blame] | 373 | VkDevice* pDevice); |
Jon Ashburn | 27cd584 | 2015-05-12 17:26:48 -0600 | [diff] [blame] | 374 | |
Courtney Goeltzenleuchter | f579fa6 | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 375 | /* helper function definitions */ |
Jon Ashburn | 8810c5f | 2015-08-18 18:04:47 -0600 | [diff] [blame] | 376 | void loader_initialize(void); |
Jon Ashburn | bd6c488 | 2015-07-02 12:59:25 -0600 | [diff] [blame] | 377 | bool has_vk_extension_property_array( |
| 378 | const VkExtensionProperties *vk_ext_prop, |
| 379 | const uint32_t count, |
| 380 | const VkExtensionProperties *ext_array); |
Courtney Goeltzenleuchter | f579fa6 | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 381 | bool has_vk_extension_property( |
| 382 | const VkExtensionProperties *vk_ext_prop, |
| 383 | const struct loader_extension_list *ext_list); |
Jon Ashburn | 27cd584 | 2015-05-12 17:26:48 -0600 | [diff] [blame] | 384 | |
Jon Ashburn | 24cd4be | 2015-11-01 14:04:06 -0700 | [diff] [blame] | 385 | VkResult loader_add_to_ext_list( |
Jon Ashburn | e39a4f8 | 2015-08-28 13:38:21 -0600 | [diff] [blame] | 386 | const struct loader_instance *inst, |
Courtney Goeltzenleuchter | f579fa6 | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 387 | struct loader_extension_list *ext_list, |
| 388 | uint32_t prop_list_count, |
Jon Ashburn | 5c042ea | 2015-08-04 11:14:18 -0600 | [diff] [blame] | 389 | const VkExtensionProperties *props); |
Jon Ashburn | e39a4f8 | 2015-08-28 13:38:21 -0600 | [diff] [blame] | 390 | void loader_destroy_ext_list( |
| 391 | const struct loader_instance *inst, |
| 392 | struct loader_extension_list *ext_info); |
| 393 | void loader_delete_layer_properties( |
| 394 | const struct loader_instance *inst, |
| 395 | struct loader_layer_list *layer_list); |
Courtney Goeltzenleuchter | 110fdf9 | 2015-06-29 15:39:26 -0600 | [diff] [blame] | 396 | void loader_add_to_layer_list( |
Jon Ashburn | e39a4f8 | 2015-08-28 13:38:21 -0600 | [diff] [blame] | 397 | const struct loader_instance *inst, |
Courtney Goeltzenleuchter | 110fdf9 | 2015-06-29 15:39:26 -0600 | [diff] [blame] | 398 | struct loader_layer_list *list, |
| 399 | uint32_t prop_list_count, |
| 400 | const struct loader_layer_properties *props); |
Jon Ashburn | e39a4f8 | 2015-08-28 13:38:21 -0600 | [diff] [blame] | 401 | void loader_scanned_icd_clear( |
| 402 | const struct loader_instance *inst, |
| 403 | struct loader_icd_libs *icd_libs); |
| 404 | void loader_icd_scan( |
| 405 | const struct loader_instance *inst, |
| 406 | struct loader_icd_libs *icds); |
Jon Ashburn | b82c185 | 2015-08-11 14:49:54 -0600 | [diff] [blame] | 407 | void loader_layer_scan( |
Jon Ashburn | e39a4f8 | 2015-08-28 13:38:21 -0600 | [diff] [blame] | 408 | const struct loader_instance *inst, |
Jon Ashburn | b82c185 | 2015-08-11 14:49:54 -0600 | [diff] [blame] | 409 | struct loader_layer_list *instance_layers, |
| 410 | struct loader_layer_list *device_layers); |
Jon Ashburn | 8810c5f | 2015-08-18 18:04:47 -0600 | [diff] [blame] | 411 | void loader_get_icd_loader_instance_extensions( |
Jon Ashburn | e39a4f8 | 2015-08-28 13:38:21 -0600 | [diff] [blame] | 412 | const struct loader_instance *inst, |
Jon Ashburn | 8810c5f | 2015-08-18 18:04:47 -0600 | [diff] [blame] | 413 | struct loader_icd_libs *icd_libs, |
| 414 | struct loader_extension_list *inst_exts); |
Jon Ashburn | e39a4f8 | 2015-08-28 13:38:21 -0600 | [diff] [blame] | 415 | struct loader_icd *loader_get_icd_and_device( |
| 416 | const VkDevice device, |
| 417 | struct loader_device **found_dev); |
Jon Ashburn | fc1031e | 2015-11-17 15:31:02 -0700 | [diff] [blame] | 418 | void *loader_dev_ext_gpa( |
| 419 | struct loader_instance *inst, |
| 420 | const char *funcName); |
| 421 | void *loader_get_dev_ext_trampoline( |
| 422 | uint32_t index); |
Jon Ashburn | e0e6457 | 2015-09-30 12:56:42 -0600 | [diff] [blame] | 423 | struct loader_instance *loader_get_instance( |
| 424 | const VkInstance instance); |
Jon Ashburn | e39a4f8 | 2015-08-28 13:38:21 -0600 | [diff] [blame] | 425 | void loader_remove_logical_device( |
| 426 | const struct loader_instance *inst, |
Jon Ashburn | 781a7ae | 2015-11-19 15:43:26 -0700 | [diff] [blame^] | 427 | struct loader_icd *icd, |
| 428 | struct loader_device *found_dev); |
Jon Ashburn | b82c185 | 2015-08-11 14:49:54 -0600 | [diff] [blame] | 429 | VkResult loader_enable_instance_layers( |
| 430 | struct loader_instance *inst, |
| 431 | const VkInstanceCreateInfo *pCreateInfo, |
| 432 | const struct loader_layer_list *instance_layers); |
Jon Ashburn | dc6fcad | 2015-06-10 10:06:06 -0600 | [diff] [blame] | 433 | void loader_deactivate_instance_layers(struct loader_instance *instance); |
Jon Ashburn | 27cd584 | 2015-05-12 17:26:48 -0600 | [diff] [blame] | 434 | uint32_t loader_activate_instance_layers(struct loader_instance *inst); |
Courtney Goeltzenleuchter | d971b61 | 2015-06-17 20:51:59 -0600 | [diff] [blame] | 435 | void loader_activate_instance_layer_extensions(struct loader_instance *inst); |
Courtney Goeltzenleuchter | 7f5aafc | 2015-07-05 11:28:29 -0600 | [diff] [blame] | 436 | |
| 437 | void* loader_heap_alloc( |
Jon Ashburn | e39a4f8 | 2015-08-28 13:38:21 -0600 | [diff] [blame] | 438 | const struct loader_instance *instance, |
Jon Ashburn | b82c185 | 2015-08-11 14:49:54 -0600 | [diff] [blame] | 439 | size_t size, |
Chia-I Wu | 3432a0c | 2015-10-27 18:04:07 +0800 | [diff] [blame] | 440 | VkSystemAllocationScope allocationScope); |
Courtney Goeltzenleuchter | 7f5aafc | 2015-07-05 11:28:29 -0600 | [diff] [blame] | 441 | |
Courtney Goeltzenleuchter | 7f5aafc | 2015-07-05 11:28:29 -0600 | [diff] [blame] | 442 | void loader_heap_free( |
Jon Ashburn | e39a4f8 | 2015-08-28 13:38:21 -0600 | [diff] [blame] | 443 | const struct loader_instance *instance, |
Chia-I Wu | 3432a0c | 2015-10-27 18:04:07 +0800 | [diff] [blame] | 444 | void *pMemory); |
Jon Ashburn | 87d6aa9 | 2015-08-28 15:19:27 -0600 | [diff] [blame] | 445 | |
| 446 | void *loader_tls_heap_alloc(size_t size); |
| 447 | |
Chia-I Wu | 3432a0c | 2015-10-27 18:04:07 +0800 | [diff] [blame] | 448 | void loader_tls_heap_free(void *pMemory); |
Chia-I Wu | 1930060 | 2014-08-04 08:03:57 +0800 | [diff] [blame] | 449 | #endif /* LOADER_H */ |