blob: 2b1f545acef59546a7fe082d7ca4222a434ba5e3 [file] [log] [blame]
Chia-I Wu0c203242016-03-15 13:44:51 +08001/*
2 * Copyright 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#ifndef LIBVULKAN_DRIVER_H
18#define LIBVULKAN_DRIVER_H 1
19
20#include <inttypes.h>
Chia-I Wueb7db122016-03-24 09:11:06 +080021#include <bitset>
Chia-I Wu0c203242016-03-15 13:44:51 +080022#include <type_traits>
23#include <log/log.h>
24
25#include <vulkan/vulkan.h>
26#include <hardware/hwvulkan.h>
27
28#include "api_gen.h"
Chia-I Wueb7db122016-03-24 09:11:06 +080029#include "driver_gen.h"
Chia-I Wuff4a6c72016-03-24 16:05:56 +080030#include "debug_report.h"
Chia-I Wu4a6a9162016-03-26 07:17:34 +080031#include "swapchain.h"
Chia-I Wu0c203242016-03-15 13:44:51 +080032
33namespace vulkan {
34
35// This is here so that we can embed api::{Instance,Device}Data in
36// driver::{Instance,Device}Data to avoid pointer chasing. They are
37// considered opaque to the driver layer.
38namespace api {
39
40struct InstanceData {
41 InstanceDispatchTable dispatch;
42
Chia-I Wu0c203242016-03-15 13:44:51 +080043 // LayerChain::ActiveLayer array
44 void* layers;
45 uint32_t layer_count;
46
47 // debug.vulkan.enable_callback
48 PFN_vkDestroyDebugReportCallbackEXT destroy_debug_callback;
49 VkDebugReportCallbackEXT debug_callback;
50};
51
52struct DeviceData {
53 DeviceDispatchTable dispatch;
Chia-I Wu0c203242016-03-15 13:44:51 +080054};
55
56} // namespace api
57
58namespace driver {
59
Chia-I Wu94a2c0e2016-04-13 10:20:59 +080060VK_DEFINE_HANDLE(InstanceDispatchable)
61VK_DEFINE_HANDLE(DeviceDispatchable)
62
Chia-I Wu0c203242016-03-15 13:44:51 +080063struct InstanceData {
Chia-I Wueb7db122016-03-24 09:11:06 +080064 InstanceData(const VkAllocationCallbacks& alloc)
Chia-I Wucc5e2762016-03-24 13:01:16 +080065 : opaque_api_data(),
66 allocator(alloc),
67 driver(),
68 get_device_proc_addr(nullptr) {
Chia-I Wueb7db122016-03-24 09:11:06 +080069 hook_extensions.set(ProcHook::EXTENSION_CORE);
Chia-I Wueb7db122016-03-24 09:11:06 +080070 }
71
Chia-I Wu0c203242016-03-15 13:44:51 +080072 api::InstanceData opaque_api_data;
73
74 const VkAllocationCallbacks allocator;
Chia-I Wueb7db122016-03-24 09:11:06 +080075
76 std::bitset<ProcHook::EXTENSION_COUNT> hook_extensions;
Chia-I Wucc5e2762016-03-24 13:01:16 +080077
78 InstanceDriverTable driver;
79 PFN_vkGetDeviceProcAddr get_device_proc_addr;
Chia-I Wuff4a6c72016-03-24 16:05:56 +080080
81 DebugReportCallbackList debug_report_callbacks;
Chia-I Wu0c203242016-03-15 13:44:51 +080082};
83
84struct DeviceData {
Chia-I Wueb7db122016-03-24 09:11:06 +080085 DeviceData(const VkAllocationCallbacks& alloc)
Chia-I Wucc5e2762016-03-24 13:01:16 +080086 : opaque_api_data(), allocator(alloc), driver() {
Chia-I Wueb7db122016-03-24 09:11:06 +080087 hook_extensions.set(ProcHook::EXTENSION_CORE);
Chia-I Wueb7db122016-03-24 09:11:06 +080088 }
89
Chia-I Wu0c203242016-03-15 13:44:51 +080090 api::DeviceData opaque_api_data;
91
92 const VkAllocationCallbacks allocator;
Chia-I Wueb7db122016-03-24 09:11:06 +080093
94 std::bitset<ProcHook::EXTENSION_COUNT> hook_extensions;
Chia-I Wueb7db122016-03-24 09:11:06 +080095
Chia-I Wucc5e2762016-03-24 13:01:16 +080096 DeviceDriverTable driver;
Chia-I Wu0c203242016-03-15 13:44:51 +080097};
98
99bool Debuggable();
100bool OpenHAL();
101const VkAllocationCallbacks& GetDefaultAllocator();
102
103// clang-format off
104VKAPI_ATTR PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* pName);
105VKAPI_ATTR PFN_vkVoidFunction GetDeviceProcAddr(VkDevice device, const char* pName);
106VKAPI_ATTR VkResult EnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
Chia-I Wuba0be412016-03-24 16:24:40 +0800107
Chia-I Wu01cf3052016-03-24 16:16:21 +0800108VKAPI_ATTR VkResult EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
109
Chia-I Wuff4a6c72016-03-24 16:05:56 +0800110VKAPI_ATTR VkResult CreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance);
111VKAPI_ATTR void DestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator);
Chia-I Wu4901db72016-03-24 16:38:58 +0800112VKAPI_ATTR VkResult CreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice);
113VKAPI_ATTR void DestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator);
114
Chia-I Wuff4a6c72016-03-24 16:05:56 +0800115VKAPI_ATTR VkResult EnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
Chia-I Wuba0be412016-03-24 16:24:40 +0800116VKAPI_ATTR void GetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
Chia-I Wu6a58a8a2016-03-24 16:29:51 +0800117VKAPI_ATTR VkResult AllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers);
Chia-I Wu0c203242016-03-15 13:44:51 +0800118// clang-format on
119
120template <typename DispatchableType>
121void StaticAssertDispatchable(DispatchableType) {
Chia-I Wu94a2c0e2016-04-13 10:20:59 +0800122 static_assert(
123 std::is_same<DispatchableType, VkInstance>::value ||
124 std::is_same<DispatchableType, VkPhysicalDevice>::value ||
125 std::is_same<DispatchableType, VkDevice>::value ||
126 std::is_same<DispatchableType, InstanceDispatchable>::value ||
127 std::is_same<DispatchableType, VkQueue>::value ||
128 std::is_same<DispatchableType, VkCommandBuffer>::value ||
129 std::is_same<DispatchableType, DeviceDispatchable>::value,
130 "unrecognized dispatchable type");
Chia-I Wu0c203242016-03-15 13:44:51 +0800131}
132
133template <typename DispatchableType>
134bool SetDataInternal(DispatchableType dispatchable, const void* data) {
135 StaticAssertDispatchable(dispatchable);
136
137 hwvulkan_dispatch_t* dispatch =
138 reinterpret_cast<hwvulkan_dispatch_t*>(dispatchable);
139 // must be magic or already set
140 if (dispatch->magic != HWVULKAN_DISPATCH_MAGIC && dispatch->vtbl != data) {
141 ALOGE("invalid dispatchable object magic 0x%" PRIxPTR, dispatch->magic);
142 return false;
143 }
144
145 dispatch->vtbl = data;
146
147 return true;
148}
149
150template <typename DispatchableType>
151void* GetDataInternal(DispatchableType dispatchable) {
152 StaticAssertDispatchable(dispatchable);
153
154 const hwvulkan_dispatch_t* dispatch =
155 reinterpret_cast<const hwvulkan_dispatch_t*>(dispatchable);
156
157 return const_cast<void*>(dispatch->vtbl);
158}
159
160inline bool SetData(VkInstance instance, const InstanceData& data) {
161 return SetDataInternal(instance, &data);
162}
163
164inline bool SetData(VkPhysicalDevice physical_dev, const InstanceData& data) {
165 return SetDataInternal(physical_dev, &data);
166}
167
Chia-I Wu94a2c0e2016-04-13 10:20:59 +0800168inline bool SetData(InstanceDispatchable dispatchable,
169 const InstanceData& data) {
170 return SetDataInternal(dispatchable, &data);
171}
172
Chia-I Wu0c203242016-03-15 13:44:51 +0800173inline bool SetData(VkDevice dev, const DeviceData& data) {
174 return SetDataInternal(dev, &data);
175}
176
177inline bool SetData(VkQueue queue, const DeviceData& data) {
178 return SetDataInternal(queue, &data);
179}
180
181inline bool SetData(VkCommandBuffer cmd, const DeviceData& data) {
182 return SetDataInternal(cmd, &data);
183}
184
Chia-I Wu94a2c0e2016-04-13 10:20:59 +0800185inline bool SetData(DeviceDispatchable dispatchable, const DeviceData& data) {
186 return SetDataInternal(dispatchable, &data);
187}
188
Chia-I Wu0c203242016-03-15 13:44:51 +0800189inline InstanceData& GetData(VkInstance instance) {
190 return *reinterpret_cast<InstanceData*>(GetDataInternal(instance));
191}
192
193inline InstanceData& GetData(VkPhysicalDevice physical_dev) {
194 return *reinterpret_cast<InstanceData*>(GetDataInternal(physical_dev));
195}
196
Chia-I Wu94a2c0e2016-04-13 10:20:59 +0800197inline InstanceData& GetData(InstanceDispatchable dispatchable) {
198 return *reinterpret_cast<InstanceData*>(GetDataInternal(dispatchable));
199}
200
Chia-I Wu0c203242016-03-15 13:44:51 +0800201inline DeviceData& GetData(VkDevice dev) {
202 return *reinterpret_cast<DeviceData*>(GetDataInternal(dev));
203}
204
205inline DeviceData& GetData(VkQueue queue) {
206 return *reinterpret_cast<DeviceData*>(GetDataInternal(queue));
207}
208
209inline DeviceData& GetData(VkCommandBuffer cmd) {
210 return *reinterpret_cast<DeviceData*>(GetDataInternal(cmd));
211}
212
Chia-I Wu94a2c0e2016-04-13 10:20:59 +0800213inline DeviceData& GetData(DeviceDispatchable dispatchable) {
214 return *reinterpret_cast<DeviceData*>(GetDataInternal(dispatchable));
215}
216
Chia-I Wu0c203242016-03-15 13:44:51 +0800217} // namespace driver
218} // namespace vulkan
219
220#endif // LIBVULKAN_DRIVER_H