mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-19 04:46:08 +00:00
Squash of Droid-Deck/DroidDeck#517 (ASEbrahim/DroidDeck mali-bridge @ 6b823341): the Vulkan
bridge (tools/vkbridge) that runs the guest's Vulkan on the phone's own driver, with BC1-BC7,
clip/cull distance, vertex-divisor and depth-clip emulation and dma-heap memory sharing for Mali.
All of the bridge is ASEbrahim's work; squashed only to carry it on this test branch.
Combined with #570 on this branch, a device draws through exactly one path:
- Adreno: Turnip, unchanged (checked first; the bridge setting is ignored there).
- PowerVR / Xclipse with the system HAL and a render node: the system-Vulkan path (#570).
- Anything else with the Setup toggle on (Mali): the bridge.
183 lines
6.0 KiB
C
183 lines
6.0 KiB
C
/* SPDX-License-Identifier: GPL-3.0-or-later
|
|
*
|
|
* DroidDeck Vulkan bridge - client ICD (libvulkan_droidbridge.so, glibc).
|
|
*
|
|
* A Vulkan driver for the Vulkan loader inside the Linux session. It owns no GPU: every call is
|
|
* encoded and executed by the server (app/src/main/cpp/vkbridge) on the device's real driver.
|
|
* Command buffers are recorded locally and shipped at vkEndCommandBuffer; mapped memory is
|
|
* shared pages (see server_memory.c); presentation (WSI) is implemented here.
|
|
*/
|
|
#ifndef VKB_CLIENT_H
|
|
#define VKB_CLIENT_H
|
|
|
|
#define VK_USE_PLATFORM_WAYLAND_KHR 1
|
|
#define VK_USE_PLATFORM_XCB_KHR 1
|
|
#define VK_USE_PLATFORM_XLIB_KHR 1
|
|
|
|
#include <pthread.h>
|
|
#include <stdint.h>
|
|
#include <stdlib.h>
|
|
|
|
#include "vkb_wire.h"
|
|
#include "vkb_proto.h"
|
|
#include "vkb_log.h"
|
|
#include <vulkan/vulkan.h>
|
|
#include <vulkan/vk_icd.h>
|
|
|
|
#define VKB_EXPORT __attribute__((visibility("default")))
|
|
#define VKB_API_VERSION VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION)
|
|
|
|
/* ------------------------------------------------------------------ small hash map (u64 -> ptr) */
|
|
typedef struct vkb_map {
|
|
uint64_t *keys;
|
|
void **vals;
|
|
uint32_t cap, count;
|
|
pthread_mutex_t lock;
|
|
} vkb_map;
|
|
void vkb_map_init(vkb_map *m);
|
|
void vkb_map_destroy(vkb_map *m);
|
|
void vkb_map_put(vkb_map *m, uint64_t k, void *v);
|
|
void *vkb_map_get(vkb_map *m, uint64_t k);
|
|
void *vkb_map_remove(vkb_map *m, uint64_t k);
|
|
|
|
/* ------------------------------------------------------------------ dispatchable objects */
|
|
typedef struct vkb_object {
|
|
VK_LOADER_DATA loader; /* must be first: the loader keeps its dispatch pointer here */
|
|
VkObjectType type;
|
|
uint64_t remote; /* the server's handle */
|
|
uint32_t table; /* the server's dispatch table for calls on this object */
|
|
} vkb_object;
|
|
|
|
typedef struct vkb_mem_type_map {
|
|
uint32_t server_type;
|
|
uint8_t shared;
|
|
} vkb_mem_type_map;
|
|
|
|
struct vkb_instance;
|
|
|
|
typedef struct vkb_physdev {
|
|
vkb_object obj;
|
|
struct vkb_instance *instance;
|
|
vkb_server_pd_info info;
|
|
VkPhysicalDeviceProperties props;
|
|
VkPhysicalDeviceMemoryProperties server_mem;
|
|
VkPhysicalDeviceMemoryProperties client_mem; /* what the app sees */
|
|
vkb_mem_type_map type_map[VK_MAX_MEMORY_TYPES];
|
|
uint32_t heap_map[VK_MAX_MEMORY_HEAPS]; /* client heap -> server heap */
|
|
VkExtensionProperties *exts; /* filtered device extensions */
|
|
uint32_t next;
|
|
int ready;
|
|
pthread_mutex_t lock;
|
|
struct vkb_physdev *list_next;
|
|
} vkb_physdev;
|
|
|
|
typedef struct vkb_instance {
|
|
vkb_object obj;
|
|
uint32_t api_version;
|
|
vkb_physdev *pds;
|
|
pthread_mutex_t lock;
|
|
uint8_t ext_surface, ext_wayland, ext_xcb, ext_xlib, ext_headless, ext_surface_caps2, ext_debug_utils;
|
|
} vkb_instance;
|
|
|
|
struct vkb_queue;
|
|
|
|
typedef struct vkb_device {
|
|
vkb_object obj;
|
|
vkb_physdev *pd;
|
|
vkb_instance *instance;
|
|
struct vkb_queue *queues;
|
|
pthread_mutex_t lock;
|
|
vkb_map memories; /* VkDeviceMemory -> vkb_memory* */
|
|
vkb_map templates; /* VkDescriptorUpdateTemplate -> vkb_template* */
|
|
vkb_map pools; /* VkCommandPool -> vkb_cmdpool* */
|
|
vkb_map unshared; /* VkBuffer/VkImage that cannot live in shared memory -> (void*)1 */
|
|
vkb_map shared_images; /* VkImage that may live in shared memory -> (void*)1 */
|
|
const char **enabled_exts;
|
|
uint32_t enabled_ext_count;
|
|
uint8_t ext_swapchain;
|
|
uint32_t api_version;
|
|
} vkb_device;
|
|
|
|
typedef struct vkb_queue {
|
|
vkb_object obj;
|
|
vkb_device *device;
|
|
uint32_t family, index, flags;
|
|
struct vkb_queue *next;
|
|
} vkb_queue;
|
|
|
|
typedef struct vkb_cmdbuf {
|
|
vkb_object obj;
|
|
vkb_device *device;
|
|
VkCommandPool pool;
|
|
VkCommandBufferLevel level;
|
|
vkb_enc stream;
|
|
size_t entry; /* offset of the open entry's payload */
|
|
int recording;
|
|
int broken;
|
|
struct vkb_cmdbuf *pool_next, *pool_prev;
|
|
} vkb_cmdbuf;
|
|
|
|
typedef struct vkb_cmdpool {
|
|
vkb_cmdbuf *head;
|
|
} vkb_cmdpool;
|
|
|
|
typedef struct vkb_memory {
|
|
void *ptr; /* client mapping (shared allocations) */
|
|
VkDeviceSize size;
|
|
uint32_t client_type;
|
|
int shared;
|
|
} vkb_memory;
|
|
|
|
static inline vkb_device *vkb_dev(VkDevice d) { return (vkb_device *)d; }
|
|
static inline vkb_physdev *vkb_pd(VkPhysicalDevice p) { return (vkb_physdev *)p; }
|
|
static inline vkb_instance *vkb_inst(VkInstance i) { return (vkb_instance *)i; }
|
|
static inline vkb_cmdbuf *vkb_cb(VkCommandBuffer c) { return (vkb_cmdbuf *)c; }
|
|
|
|
/* ------------------------------------------------------------------ calls */
|
|
typedef struct vkb_call {
|
|
vkb_enc e;
|
|
vkb_dec d;
|
|
uint32_t cmd, table, flags;
|
|
struct vkb_conn *conn;
|
|
} vkb_call;
|
|
|
|
void vkb_call_begin(vkb_call *c, uint32_t cmd, uint32_t table);
|
|
/* Sends the request and waits for the reply. 0 = failed (the call is already released). */
|
|
int vkb_call_exec(vkb_call *c);
|
|
void vkb_call_end(vkb_call *c);
|
|
/* Sends without waiting for a reply (void commands without outputs); ordered by vkb_msg_hdr.seq. */
|
|
int vkb_call_exec_async(vkb_call *c);
|
|
int vkb_async_results(void);
|
|
void vkb_stats_count(uint32_t cmd, int async, size_t bytes);
|
|
uint32_t vkb_table_of(const void *dispatchable);
|
|
int vkb_connected(void);
|
|
/* Per-thread transport cleanup for fork children. */
|
|
void vkb_conn_after_fork(void);
|
|
|
|
/* Command streams (cmdbuf.c). */
|
|
vkb_enc *vkb_cmd_record_begin(VkCommandBuffer cb, uint32_t cmd);
|
|
void vkb_cmd_record_end(VkCommandBuffer cb);
|
|
|
|
/* Dispatchable objects created by the server (generated stubs call this). */
|
|
void *vkb_wrap(VkObjectType type, const void *parent, uint64_t remote);
|
|
|
|
/* physdev.c */
|
|
int vkb_physdev_ready(vkb_physdev *pd);
|
|
uint32_t vkb_mem_bits_to_client(vkb_physdev *pd, uint32_t server_bits, int allow_shared);
|
|
|
|
/* memory.c */
|
|
void vkb_memory_init_device(vkb_device *d);
|
|
|
|
/* icd.c */
|
|
PFN_vkVoidFunction vkb_lookup_proc(const char *name, int level_max, vkb_device *dev, vkb_instance *inst);
|
|
int vkb_device_ext_enabled(const vkb_device *d, const char *name);
|
|
|
|
/* memory.c */
|
|
void *vkb_chain_clone(const void *pNext, void **mem);
|
|
int vkb_is_client_device_ext(const char *n);
|
|
|
|
/* misc */
|
|
int vkb_memfd(const char *name, size_t size);
|
|
|
|
#endif
|