From 68bc624859d5ac889130634c324905a665d60401 Mon Sep 17 00:00:00 2001 From: lfdevs <109842948+lfdevs@users.noreply.github.com> Date: Wed, 26 Nov 2025 20:49:09 +0800 Subject: [PATCH 1/6] Update .gitignore --- .gitignore | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitignore b/.gitignore index 30f4e69ea7de..3e337d0e5734 100644 --- a/.gitignore +++ b/.gitignore @@ -5,3 +5,4 @@ *.out /build .venv/ +.obsidian/ From a5016ab82ef0766d08bb7e9948756e2f62800613 Mon Sep 17 00:00:00 2001 From: lfdevs <109842948+lfdevs@users.noreply.github.com> Date: Wed, 26 Nov 2025 22:05:06 +0800 Subject: [PATCH 2/6] Add experimental KGSL support. The original patch (https://github.com/robertkirkman/termux-packages/commit/06a959eeddf153cebd0d3ea1a6c2eb2921b5f786) is the commit (https://github.com/xMeM/termux-packages/commit/401982b8d9eaef70669762bfff2a963341c65e52) merged together by robertkirkman. The original code was invented by Lucas Fryzek (creator of port of Freedreno OpenGL to the /dev/kgsl-3d0 kernel driver often found in Android) (https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/21570) and xMeM (creator of the port of Lucas Fryzek's Freedreno OpenGL kgsl to Android Termux:X11). --- .../0008-Add-experimental-KGSL-support.patch | 1488 +++++++++++++++++ ...-stop-turning-load_push_constants-in.patch | 10 +- debian/patches/disable_ppc64el_assembly.diff | 13 +- .../etnaviv-add-support-for-texelfetch.patch | 91 +- ...Revert-kopper-Explicitly-choose-zink.patch | 10 +- ...issing-parenthesis-on-pan_cast_and_p.patch | 7 +- debian/patches/path_max.diff | 44 +- debian/patches/series | 1 + debian/patches/src_glx_dri_common.h.diff | 12 +- 9 files changed, 1577 insertions(+), 99 deletions(-) create mode 100644 debian/patches/0008-Add-experimental-KGSL-support.patch diff --git a/debian/patches/0008-Add-experimental-KGSL-support.patch b/debian/patches/0008-Add-experimental-KGSL-support.patch new file mode 100644 index 000000000000..0fa71b5ddbd4 --- /dev/null +++ b/debian/patches/0008-Add-experimental-KGSL-support.patch @@ -0,0 +1,1488 @@ +From: lfdevs <109842948+lfdevs@users.noreply.github.com> +Date: Wed, 26 Nov 2025 22:01:31 +0800 +Subject: Add experimental KGSL support. + +The original patch (https://github.com/robertkirkman/termux-packages/commit/06a959eeddf153cebd0d3ea1a6c2eb2921b5f786) is the commit (https://github.com/xMeM/termux-packages/commit/401982b8d9eaef70669762bfff2a963341c65e52) merged together by robertkirkman. +The original code was invented by Lucas Fryzek (creator of port of Freedreno OpenGL to the /dev/kgsl-3d0 kernel driver often found in Android) (https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/21570) and xMeM (creator of the port of Lucas Fryzek's Freedreno OpenGL kgsl to Android Termux:X11). +--- + meson.build | 4 + + src/egl/drivers/dri2/egl_dri2.c | 3 + + src/egl/drivers/dri2/platform_drm.c | 4 + + src/egl/drivers/dri2/platform_surfaceless.c | 14 + + src/egl/drivers/dri2/platform_wayland.c | 11 +- + src/egl/main/eglapi.c | 1 + + src/egl/main/egldisplay.h | 1 + + src/freedreno/drm/freedreno_device.c | 34 ++- + src/freedreno/drm/freedreno_drmif.h | 14 + + src/freedreno/drm/freedreno_pipe.c | 6 + + src/freedreno/drm/freedreno_priv.h | 2 + + src/freedreno/drm/kgsl/kgsl_bo.c | 295 ++++++++++++++++++++++ + src/freedreno/drm/kgsl/kgsl_device.c | 44 ++++ + src/freedreno/drm/kgsl/kgsl_pipe.c | 225 +++++++++++++++++ + src/freedreno/drm/kgsl/kgsl_priv.h | 54 ++++ + src/freedreno/drm/kgsl/kgsl_ringbuffer_sp.c | 119 +++++++++ + src/freedreno/drm/meson.build | 11 + + src/gallium/drivers/freedreno/freedreno_context.c | 30 ++- + src/gallium/drivers/freedreno/freedreno_screen.c | 2 +- + src/gallium/drivers/zink/zink_compiler.c | 4 + + src/gallium/drivers/zink/zink_screen.c | 13 +- + src/gallium/frontends/dri/loader_dri3_helper.c | 83 +----- + src/x11/loader_x11.c | 5 + + 23 files changed, 878 insertions(+), 101 deletions(-) + create mode 100644 src/freedreno/drm/kgsl/kgsl_bo.c + create mode 100644 src/freedreno/drm/kgsl/kgsl_device.c + create mode 100644 src/freedreno/drm/kgsl/kgsl_pipe.c + create mode 100644 src/freedreno/drm/kgsl/kgsl_priv.h + create mode 100644 src/freedreno/drm/kgsl/kgsl_ringbuffer_sp.c + +diff --git a/meson.build b/meson.build +index 38292d8..d5b8c29 100644 +--- a/meson.build ++++ b/meson.build +@@ -292,6 +292,10 @@ if freedreno_kmds.length() != 0 and freedreno_kmds != [ 'msm' ] and with_freedre + endif + endif + ++if freedreno_kmds.contains('kgsl') ++ pre_args += '-DHAVE_FREEDRENO_KGSL' ++endif ++ + with_dri = false + if with_gallium and system_has_kms_drm + _glx = get_option('glx') +diff --git a/src/egl/drivers/dri2/egl_dri2.c b/src/egl/drivers/dri2/egl_dri2.c +index e813aa6..8766e7d 100644 +--- a/src/egl/drivers/dri2/egl_dri2.c ++++ b/src/egl/drivers/dri2/egl_dri2.c +@@ -841,6 +841,9 @@ dri2_setup_device(_EGLDisplay *disp, EGLBoolean software) + _EGLDevice *dev; + int render_fd; + ++ if (disp->Options.Kgsl || disp->Options.Zink) ++ software = true; ++ + /* If we're not software, we need a DRM node FD */ + assert(software || dri2_dpy->fd_render_gpu >= 0); + +diff --git a/src/egl/drivers/dri2/platform_drm.c b/src/egl/drivers/dri2/platform_drm.c +index 813e5d3..d08f23a 100644 +--- a/src/egl/drivers/dri2/platform_drm.c ++++ b/src/egl/drivers/dri2/platform_drm.c +@@ -583,6 +583,8 @@ dri2_initialize_drm(_EGLDisplay *disp) + + dri2_dpy->fd_display_gpu = + loader_open_device(drm->nodes[DRM_NODE_PRIMARY]); ++ } else if (disp->Options.Kgsl) { ++ dri2_dpy->fd_display_gpu = loader_open_device("/dev/kgsl-3d0"); + } else { + _EGLDevice *dev_list = _eglGlobal.DeviceList; + drmDevicePtr drm; +@@ -623,6 +625,8 @@ dri2_initialize_drm(_EGLDisplay *disp) + if (!dri2_dpy->gbm_dri->software) { + dri2_dpy->fd_render_gpu = + get_fd_render_gpu_drm(dri2_dpy->gbm_dri, dri2_dpy->fd_display_gpu); ++ if (dri2_dpy->fd_render_gpu < 0 && disp->Options.Kgsl) ++ dri2_dpy->fd_render_gpu = dri2_dpy->fd_display_gpu; + if (dri2_dpy->fd_render_gpu < 0) { + err = "DRI2: failed to get compatible render device"; + goto cleanup; +diff --git a/src/egl/drivers/dri2/platform_surfaceless.c b/src/egl/drivers/dri2/platform_surfaceless.c +index d981f55..e1c16ee 100644 +--- a/src/egl/drivers/dri2/platform_surfaceless.c ++++ b/src/egl/drivers/dri2/platform_surfaceless.c +@@ -377,6 +377,20 @@ dri2_initialize_surfaceless(_EGLDisplay *disp) + driver_loaded = surfaceless_probe_device_sw(disp); + } + ++ if (!driver_loaded && disp->Options.Kgsl) { ++ dri2_dpy->fd_render_gpu = loader_open_device("/dev/kgsl-3d0"); ++ dri2_dpy->driver_name = strdup("kgsl"); ++ driver_loaded = dri2_load_driver(disp); ++ if (driver_loaded) { ++ dri2_dpy->loader_extensions = image_loader_extensions; ++ } else { ++ free(dri2_dpy->driver_name); ++ dri2_dpy->driver_name = NULL; ++ close(dri2_dpy->fd_render_gpu); ++ dri2_dpy->fd_render_gpu = -1; ++ } ++ } ++ + if (!driver_loaded) { + err = "DRI2: failed to load driver"; + goto cleanup; +diff --git a/src/egl/drivers/dri2/platform_wayland.c b/src/egl/drivers/dri2/platform_wayland.c +index 940993e..f38c380 100644 +--- a/src/egl/drivers/dri2/platform_wayland.c ++++ b/src/egl/drivers/dri2/platform_wayland.c +@@ -2220,6 +2220,9 @@ dri2_initialize_wayland_drm_extensions(struct dri2_egl_display *dri2_dpy) + dmabuf_feedback_format_table_fini(&dri2_dpy->format_table); + } + ++ if (dri2_dpy->kopper) ++ return true; ++ + /* We couldn't retrieve a render node from the dma-buf feedback (or the + * feedback was not advertised at all), so we must fallback to wl_drm. */ + if (dri2_dpy->fd_render_gpu == -1) { +@@ -2281,8 +2284,12 @@ dri2_initialize_wayland_drm(_EGLDisplay *disp) + if (roundtrip(dri2_dpy) < 0) + goto cleanup; + +- if (!dri2_initialize_wayland_drm_extensions(dri2_dpy)) +- goto cleanup; ++ if (!dri2_initialize_wayland_drm_extensions(dri2_dpy)) { ++ if (disp->Options.Kgsl) ++ dri2_dpy->fd_render_gpu = loader_open_device("/dev/kgsl-3d0"); ++ else ++ goto cleanup; ++ } + + loader_get_user_preferred_fd(&dri2_dpy->fd_render_gpu, + &dri2_dpy->fd_display_gpu); +diff --git a/src/egl/main/eglapi.c b/src/egl/main/eglapi.c +index c4fa4ee..6be4686 100644 +--- a/src/egl/main/eglapi.c ++++ b/src/egl/main/eglapi.c +@@ -693,6 +693,7 @@ eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor) + + const char *env = os_get_option("MESA_LOADER_DRIVER_OVERRIDE"); + disp->Options.Zink = env && !strcmp(env, "zink"); ++ disp->Options.Kgsl = env && !strcmp(env, "kgsl"); + + const char *gallium_hud_env = os_get_option("GALLIUM_HUD"); + disp->Options.GalliumHudWarn = +diff --git a/src/egl/main/egldisplay.h b/src/egl/main/egldisplay.h +index d510483..5be9783 100644 +--- a/src/egl/main/egldisplay.h ++++ b/src/egl/main/egldisplay.h +@@ -201,6 +201,7 @@ struct _egl_display { + + /* options that affect how the driver initializes the display */ + struct { ++ EGLBoolean Kgsl; /**< Use kgsl only */ + EGLBoolean Zink; /**< Use kopper only */ + EGLBoolean FallbackZink; /**< True if zink is tried as fallback */ + EGLBoolean ForceSoftware; /**< Use software path only */ +diff --git a/src/freedreno/drm/freedreno_device.c b/src/freedreno/drm/freedreno_device.c +index 5ce05a2..4a774db 100644 +--- a/src/freedreno/drm/freedreno_device.c ++++ b/src/freedreno/drm/freedreno_device.c +@@ -23,6 +23,9 @@ struct fd_device *msm_device_new(int fd, drmVersionPtr version); + #ifdef HAVE_FREEDRENO_VIRTIO + struct fd_device *virtio_device_new(int fd, drmVersionPtr version); + #endif ++#ifdef HAVE_FREEDRENO_KGSL ++struct fd_device *kgsl_device_new(int fd); ++#endif + + uint64_t os_page_size = 4096; + +@@ -30,19 +33,20 @@ struct fd_device * + fd_device_new(int fd) + { + struct fd_device *dev = NULL; +- drmVersionPtr version; ++ drmVersionPtr version = NULL; + bool use_heap = false; ++ bool support_use_heap = true; + + os_get_page_size(&os_page_size); + ++#ifdef HAVE_LIBDRM + /* figure out if we are kgsl or msm drm driver: */ + version = drmGetVersion(fd); +- if (!version) { +- ERROR_MSG("cannot get version: %s", strerror(errno)); +- return NULL; +- } ++ if (!version) ++ DEBUG_MSG("cannot get version: %s", strerror(errno)); ++#endif + +- if (!strcmp(version->name, "msm")) { ++ if (version && !strcmp(version->name, "msm")) { + DEBUG_MSG("msm DRM device"); + if (version->version_major != 1) { + ERROR_MSG("unsupported version: %u.%u.%u", version->version_major, +@@ -52,7 +56,7 @@ fd_device_new(int fd) + + dev = msm_device_new(fd, version); + #ifdef HAVE_FREEDRENO_VIRTIO +- } else if (!strcmp(version->name, "virtio_gpu")) { ++ } else if (version && !strcmp(version->name, "virtio_gpu")) { + DEBUG_MSG("virtio_gpu DRM device"); + dev = virtio_device_new(fd, version); + /* Only devices that support a hypervisor are a6xx+, so avoid the +@@ -61,9 +65,13 @@ fd_device_new(int fd) + use_heap = true; + #endif + #if HAVE_FREEDRENO_KGSL +- } else if (!strcmp(version->name, "kgsl")) { +- DEBUG_MSG("kgsl DRM device"); ++ } else { ++ /* If drm driver not detected assume this is KGSL */ + dev = kgsl_device_new(fd); ++ /* Userspace fences are not supported with KGSL */ ++ support_use_heap = false; ++ if (dev) ++ goto out; + #endif + } + +@@ -111,7 +119,7 @@ out: + fd_pipe_del(pipe); + } + +- if (use_heap) { ++ if (support_use_heap && use_heap) { + dev->ring_heap = fd_bo_heap_new(dev, RING_FLAGS); + dev->default_heap = fd_bo_heap_new(dev, 0); + } +@@ -230,6 +238,12 @@ fd_dbg(void) + return debug_get_option_libgl(); + } + ++uint32_t ++fd_get_features(struct fd_device *dev) ++{ ++ return dev->features; ++} ++ + bool + fd_has_syncobj(struct fd_device *dev) + { +diff --git a/src/freedreno/drm/freedreno_drmif.h b/src/freedreno/drm/freedreno_drmif.h +index 4cc3391..d8f0be6 100644 +--- a/src/freedreno/drm/freedreno_drmif.h ++++ b/src/freedreno/drm/freedreno_drmif.h +@@ -49,6 +49,13 @@ enum fd_param_id { + FD_VA_SIZE, /* GPU virtual address size */ + }; + ++enum fd_reset_status { ++ FD_RESET_NO_ERROR, ++ FD_RESET_GUILTY, ++ FD_RESET_INNOCENT, ++ FD_RESET_UNKNOWN, ++}; ++ + /** + * Helper for fence/seqno comparisions which deals properly with rollover. + * Returns true if fence 'a' is before fence 'b' +@@ -179,6 +186,12 @@ enum fd_version { + }; + enum fd_version fd_device_version(struct fd_device *dev); + ++enum fd_features { ++ FD_FEATURE_DIRECT_RESET = 1, ++ FD_FEATURE_IMPORT_DMABUF = 2, ++}; ++ ++uint32_t fd_get_features(struct fd_device *dev); + bool fd_has_syncobj(struct fd_device *dev); + + /* pipe functions: +@@ -200,6 +213,7 @@ int fd_pipe_wait(struct fd_pipe *pipe, const struct fd_fence *fence); + /* timeout in nanosec */ + int fd_pipe_wait_timeout(struct fd_pipe *pipe, const struct fd_fence *fence, + uint64_t timeout); ++int fd_pipe_get_reset_status(struct fd_pipe *pipe, enum fd_reset_status *status); + + /* buffer-object functions: + */ +diff --git a/src/freedreno/drm/freedreno_pipe.c b/src/freedreno/drm/freedreno_pipe.c +index 8373488..296a88f 100644 +--- a/src/freedreno/drm/freedreno_pipe.c ++++ b/src/freedreno/drm/freedreno_pipe.c +@@ -214,6 +214,12 @@ fd_pipe_emit_fence(struct fd_pipe *pipe, struct fd_ringbuffer *ring) + return fence; + } + ++int ++fd_pipe_get_reset_status(struct fd_pipe *pipe, enum fd_reset_status *status) ++{ ++ return pipe->funcs->reset_status(pipe, status); ++} ++ + struct fd_fence * + fd_fence_new(struct fd_pipe *pipe, bool use_fence_fd) + { +diff --git a/src/freedreno/drm/freedreno_priv.h b/src/freedreno/drm/freedreno_priv.h +index 4354f3c..d28e802 100644 +--- a/src/freedreno/drm/freedreno_priv.h ++++ b/src/freedreno/drm/freedreno_priv.h +@@ -191,6 +191,7 @@ struct fd_device { + int fd; + enum fd_version version; + int32_t refcnt; ++ uint32_t features; + + /* tables to keep track of bo's, to avoid "evil-twin" fd_bo objects: + * +@@ -294,6 +295,7 @@ struct fd_pipe_funcs { + struct fd_ringbuffer *(*ringbuffer_new_object)(struct fd_pipe *pipe, + uint32_t size); + struct fd_submit *(*submit_new)(struct fd_pipe *pipe); ++ int (*reset_status)(struct fd_pipe *pipe, enum fd_reset_status *status); + + /** + * Flush any deferred submits (if deferred submits are supported by +diff --git a/src/freedreno/drm/kgsl/kgsl_bo.c b/src/freedreno/drm/kgsl/kgsl_bo.c +new file mode 100644 +index 0000000..d424002 +--- /dev/null ++++ b/src/freedreno/drm/kgsl/kgsl_bo.c +@@ -0,0 +1,295 @@ ++#include "kgsl_priv.h" ++#include "util/os_file.h" ++#include "util/os_mman.h" ++ ++#include ++ ++static uint64_t ++kgsl_bo_iova(struct fd_bo *bo) ++{ ++ struct kgsl_bo *kgsl_bo = to_kgsl_bo(bo); ++ return kgsl_bo->iova; ++} ++ ++static void ++kgsl_bo_set_name(struct fd_bo *bo, const char *fmt, va_list ap) ++{ ++ /* This function is a no op for KGSL */ ++ return; ++} ++ ++static int ++kgsl_bo_offset(struct fd_bo *bo, uint64_t *offset) ++{ ++ /* from tu_kgsl.c - offset for mmap needs to be */ ++ /* the returned alloc id shifted over 12 */ ++ *offset = bo->handle << 12; ++ return 0; ++} ++ ++static int ++kgsl_bo_madvise(struct fd_bo *bo, int willneed) ++{ ++ /* KGSL does not support this, so simply return willneed */ ++ return willneed; ++} ++ ++static int ++kgsl_bo_cpu_prep(struct fd_bo *bo, struct fd_pipe *pipe, uint32_t op) ++{ ++ /* only need to handle implicit sync here which is a NOP for KGSL */ ++ return 0; ++} ++ ++void ++kgsl_bo_close_handle(struct fd_bo *bo) ++{ ++ struct kgsl_bo *kgsl_bo = to_kgsl_bo(bo); ++ if (kgsl_bo->bo_type == KGSL_BO_IMPORT) { ++ close(kgsl_bo->import_fd); ++ } ++ ++ struct kgsl_gpumem_free_id req = { ++ .id = bo->handle ++ }; ++ ++ kgsl_pipe_safe_ioctl(bo->dev->fd, IOCTL_KGSL_GPUMEM_FREE_ID, &req); ++} ++ ++static void ++kgsl_bo_destroy(struct fd_bo *bo) ++{ ++ /* KGSL will immediately delete the BO when we close ++ * the handle, so wait on all fences to ensure ++ * the GPU is done using it before we destory it ++ */ ++ for (uint32_t i = 0; i < bo->nr_fences; i++) { ++ struct fd_pipe *pipe = bo->fences[i]->pipe; ++ pipe->funcs->wait(pipe, bo->fences[i], ~0); ++ } ++ ++ fd_bo_fini_common(bo); ++} ++ ++static void * ++kgsl_bo_map(struct fd_bo *bo) ++{ ++ struct kgsl_bo *kgsl_bo = to_kgsl_bo(bo); ++ if (!bo->map) { ++ if (kgsl_bo->bo_type == KGSL_BO_IMPORT) { ++ /* in `fd_bo_map` if it tries to mmap this BO. mmap logic is copied from ++ * https://android.googlesource.com/platform/hardware/libhardware/+/master/modules/gralloc/mapper.cpp#44 ++ */ ++ bo->map = os_mmap(0, bo->size, PROT_READ | PROT_WRITE, MAP_SHARED, kgsl_bo->import_fd, 0); ++ } else { ++ uint64_t offset; ++ int ret; ++ ++ ret = bo->funcs->offset(bo, &offset); ++ if (ret) { ++ return NULL; ++ } ++ ++ bo->map = os_mmap(0, bo->size, PROT_READ | PROT_WRITE, MAP_SHARED, ++ bo->dev->fd, offset); ++ if (bo->map == MAP_FAILED) { ++ ERROR_MSG("mmap failed: %s", strerror(errno)); ++ bo->map = NULL; ++ } ++ } ++ ++ if (bo->map == MAP_FAILED) { ++ ERROR_MSG("mmap failed: %s", strerror(errno)); ++ bo->map = NULL; ++ } ++ } ++ return bo->map; ++} ++ ++static int kgsl_bo_dmabuf(struct fd_bo *bo) { ++ struct kgsl_bo *kgsl_bo = to_kgsl_bo(bo); ++ return os_dupfd_cloexec(kgsl_bo->import_fd); ++} ++ ++static const struct fd_bo_funcs bo_funcs = { ++ .iova = kgsl_bo_iova, ++ .set_name = kgsl_bo_set_name, ++ .offset = kgsl_bo_offset, ++ .map = kgsl_bo_map, ++ .madvise = kgsl_bo_madvise, ++ .cpu_prep = kgsl_bo_cpu_prep, ++ .destroy = kgsl_bo_destroy, ++ .dmabuf = kgsl_bo_dmabuf, ++}; ++ ++/* Size is not used by KGSL */ ++struct fd_bo * ++kgsl_bo_from_handle(struct fd_device *dev, uint32_t size, uint32_t handle) ++{ ++ struct fd_bo *bo; ++ int ret; ++ struct kgsl_gpuobj_info req = { ++ .id = handle, ++ }; ++ ++ ret = kgsl_pipe_safe_ioctl(dev->fd, ++ IOCTL_KGSL_GPUOBJ_INFO, &req); ++ ++ if (ret) { ++ ERROR_MSG("Failed to get handle info (%s)", strerror(errno)); ++ return NULL; ++ } ++ ++ struct kgsl_bo *kgsl_bo = calloc(1, sizeof(*kgsl_bo)); ++ if (!kgsl_bo) ++ return NULL; ++ ++ bo = &kgsl_bo->base; ++ bo->dev = dev; ++ bo->size = req.size; ++ bo->handle = req.id; ++ bo->funcs = &bo_funcs; ++ ++ kgsl_bo->iova = req.gpuaddr; ++ ++ fd_bo_init_common(bo, dev); ++ ++ return bo; ++} ++ ++struct fd_bo * ++kgsl_bo_from_dmabuf(struct fd_device *dev, int fd) ++{ ++ struct fd_bo *bo; ++ struct kgsl_gpuobj_import_dma_buf import_dmabuf = { ++ .fd = fd, ++ }; ++ struct kgsl_gpuobj_import req = { ++ .priv = (uintptr_t)&import_dmabuf, ++ .priv_len = sizeof(import_dmabuf), ++ .flags = 0, ++ .type = KGSL_USER_MEM_TYPE_DMABUF, ++ }; ++ int ret; ++ ++ ret = kgsl_pipe_safe_ioctl(dev->fd, ++ IOCTL_KGSL_GPUOBJ_IMPORT, &req); ++ ++ if (ret) { ++ ERROR_MSG("Failed to import dma-buf (%s)", strerror(errno)); ++ return NULL; ++ } ++ ++ bo = fd_bo_from_handle(dev, req.id, 0); ++ ++ struct kgsl_bo *kgsl_bo = to_kgsl_bo(bo); ++ kgsl_bo->bo_type = KGSL_BO_IMPORT; ++ kgsl_bo->import_fd = os_dupfd_cloexec(fd); ++ ++ return bo; ++} ++ ++static int ++dma_heap_alloc(uint64_t size) ++{ ++ int ret; ++ int dma_heap = open("/dev/dma_heap/system", O_RDONLY); ++ ++ if (dma_heap < 0) { ++ int ion_heap = open("/dev/ion", O_RDONLY); ++ ++ if (ion_heap < 0) ++ return -1; ++ ++ struct ion_allocation_data { ++ __u64 len; ++ __u32 heap_id_mask; ++ __u32 flags; ++ __u32 fd; ++ __u32 unused; ++ } alloc_data = { ++ .len = size, ++ /* ION_HEAP_SYSTEM | ION_SYSTEM_HEAP_ID */ ++ .heap_id_mask = (1U << 0) | (1U << 25), ++ .flags = 0, /* uncached */ ++ }; ++ ++ ret = kgsl_pipe_safe_ioctl(ion_heap, _IOWR('I', 0, struct ion_allocation_data), ++ &alloc_data); ++ ++ close(ion_heap); ++ ++ if (ret) ++ return -1; ++ ++ return alloc_data.fd; ++ } else { ++ struct dma_heap_allocation_data alloc_data = { ++ .len = size, ++ .fd_flags = O_RDWR | O_CLOEXEC, ++ }; ++ ++ ret = kgsl_pipe_safe_ioctl(dma_heap, DMA_HEAP_IOCTL_ALLOC, &alloc_data); ++ ++ close(dma_heap); ++ ++ if (ret) ++ return -1; ++ ++ return alloc_data.fd; ++ } ++} ++ ++static struct fd_bo * ++kgsl_bo_new_dmabuf(struct fd_device *dev, uint32_t size) ++{ ++ int fd; ++ struct fd_bo *bo; ++ ++ fd = dma_heap_alloc(size); ++ if (fd < 0) { ++ ERROR_MSG("Failed to allocate dma-buf (%s)", strerror(errno)); ++ return NULL; ++ } ++ ++ bo = kgsl_bo_from_dmabuf(dev, fd); ++ ++ close(fd); ++ return bo; ++} ++ ++struct fd_bo * ++kgsl_bo_new(struct fd_device *dev, uint32_t size, uint32_t flags) ++{ ++ if (flags & (FD_BO_SHARED | FD_BO_SCANOUT)) { ++ return kgsl_bo_new_dmabuf(dev, size); ++ } ++ ++ int ret; ++ struct fd_bo *bo; ++ struct kgsl_gpumem_alloc_id req = { ++ .size = size, ++ }; ++ ++ if (flags & FD_BO_GPUREADONLY) ++ req.flags |= KGSL_MEMFLAGS_GPUREADONLY; ++ ++ ret = kgsl_pipe_safe_ioctl(dev->fd, IOCTL_KGSL_GPUMEM_ALLOC_ID, &req); ++ ++ if (ret) { ++ ERROR_MSG("GPUMEM_ALLOC_ID failed (%s)", strerror(errno)); ++ return NULL; ++ } ++ ++ bo = kgsl_bo_from_handle(dev, size, req.id); ++ ++ struct kgsl_bo *kgsl_bo = to_kgsl_bo(bo); ++ kgsl_bo->bo_type = KGSL_BO_NATIVE; ++ ++ if (!bo) { ++ ERROR_MSG("Failed to allocate buffer object"); ++ return NULL; ++ } ++ ++ return bo; ++} +diff --git a/src/freedreno/drm/kgsl/kgsl_device.c b/src/freedreno/drm/kgsl/kgsl_device.c +new file mode 100644 +index 0000000..702b666 +--- /dev/null ++++ b/src/freedreno/drm/kgsl/kgsl_device.c +@@ -0,0 +1,44 @@ ++#include "kgsl_priv.h" ++ ++static const struct fd_device_funcs funcs = { ++ .bo_new = kgsl_bo_new, ++ .pipe_new = kgsl_pipe_new, ++ .bo_from_handle = kgsl_bo_from_handle, ++ .bo_from_dmabuf = kgsl_bo_from_dmabuf, ++ .bo_close_handle = kgsl_bo_close_handle, ++ .destroy = kgsl_device_destroy, ++}; ++ ++struct fd_device * ++kgsl_device_new(int fd) ++{ ++ struct kgsl_device *kgsl_dev; ++ struct fd_device *dev; ++ struct kgsl_devinfo info; ++ ++ /* Try to read the device info to detect if the FD is really KGSL */ ++ if(kgsl_get_prop(fd, KGSL_PROP_DEVICE_INFO, &info, sizeof(info))) ++ return NULL; ++ ++ kgsl_dev = calloc(1, sizeof(*kgsl_dev)); ++ if (!kgsl_dev) ++ return NULL; ++ ++ dev = &kgsl_dev->base; ++ dev->funcs = &funcs; ++ dev->fd = fd; ++ dev->version = FD_VERSION_ROBUSTNESS; ++ dev->features = FD_FEATURE_DIRECT_RESET | FD_FEATURE_IMPORT_DMABUF; ++ ++ /* async submit_queue used for softpin deffered submits */ ++ util_queue_init(&dev->submit_queue, "sq", 8, 1, 0, NULL); ++ ++ dev->bo_size = sizeof(struct kgsl_bo); ++ ++ return dev; ++} ++ ++static void ++kgsl_device_destroy(struct fd_device *dev) ++{ ++} +diff --git a/src/freedreno/drm/kgsl/kgsl_pipe.c b/src/freedreno/drm/kgsl/kgsl_pipe.c +new file mode 100644 +index 0000000..d48f186 +--- /dev/null ++++ b/src/freedreno/drm/kgsl/kgsl_pipe.c +@@ -0,0 +1,225 @@ ++#include "kgsl_priv.h" ++#include "freedreno_ringbuffer_sp.h" ++ ++/* TODO this function is borrowed from turnip, can it be shared in some way? */ ++int ++kgsl_pipe_safe_ioctl(int fd, unsigned long request, void *arg) ++{ ++ int ret; ++ ++ do { ++ ret = ioctl(fd, request, arg); ++ } while (ret == -1 && (errno == EINTR || errno == EAGAIN)); ++ ++ return ret; ++} ++ ++/* TODO this function is borrowed from turnip, can it be shared in some way? ++ * safe_ioctl is not enough as restarted waits would not adjust the timeout ++ * which could lead to waiting substantially longer than requested ++ */ ++static int ++wait_timestamp_safe(int fd, ++ unsigned int context_id, ++ unsigned int timestamp, ++ int64_t timeout_ms) ++{ ++ int64_t start_time = os_time_get_nano(); ++ struct kgsl_device_waittimestamp_ctxtid wait = { ++ .context_id = context_id, ++ .timestamp = timestamp, ++ .timeout = timeout_ms, ++ }; ++ ++ while (true) { ++ int ret = kgsl_pipe_safe_ioctl(fd, IOCTL_KGSL_DEVICE_WAITTIMESTAMP_CTXTID, &wait); ++ ++ if (ret == -1 && (errno == EINTR || errno == EAGAIN)) { ++ int64_t current_time = os_time_get_nano(); ++ ++ /* update timeout to consider time that has passed since the start */ ++ timeout_ms -= (current_time - start_time) / 1000000; ++ if (timeout_ms <= 0) { ++ errno = ETIME; ++ return -1; ++ } ++ ++ wait.timeout = (unsigned int) timeout_ms; ++ start_time = current_time; ++ } else { ++ return ret; ++ } ++ } ++} ++ ++int ++kgsl_get_prop(int fd, unsigned int type, void *value, size_t size) ++{ ++ struct kgsl_device_getproperty getprop = { ++ .type = type, ++ .value = value, ++ .sizebytes = size, ++ }; ++ ++ return kgsl_pipe_safe_ioctl(fd, IOCTL_KGSL_DEVICE_GETPROPERTY, &getprop); ++} ++ ++static int ++kgsl_pipe_get_param(struct fd_pipe *pipe, enum fd_param_id param, ++ uint64_t *value) ++{ ++ struct kgsl_pipe *kgsl_pipe = to_kgsl_pipe(pipe); ++ switch (param) { ++ case FD_DEVICE_ID: ++ case FD_GPU_ID: ++ *value = kgsl_pipe->dev_id.gpu_id; ++ return 0; ++ case FD_GMEM_SIZE: ++ *value = kgsl_pipe->gmem_size; ++ return 0; ++ case FD_GMEM_BASE: ++ *value = kgsl_pipe->gmem_base; ++ return 0; ++ case FD_CHIP_ID: ++ *value = kgsl_pipe->dev_id.chip_id; ++ return 0; ++ case FD_NR_PRIORITIES: ++ /* Take from kgsl kmd source code, if device is a4xx or newer ++ * it has KGSL_PRIORITY_MAX_RB_LEVELS=4 priorities otherwise it just has one. ++ * https://android.googlesource.com/kernel/msm/+/refs/tags/android-13.0.0_r0.21/drivers/gpu/msm/kgsl.h#56 ++ */ ++ *value = kgsl_pipe->dev_id.gpu_id >= 400 ? 4 : 1; ++ return 0; ++ case FD_MAX_FREQ: ++ /* Explicity fault on MAX_FREQ as we don't have a way to convert ++ * timestamp values from KGSL into time values. If we use the default ++ * path an error message would be generated when this is simply an ++ * unsupported feature. ++ */ ++ return -1; ++ case FD_TIMESTAMP: ++ return -1; ++ default: ++ ERROR_MSG("invalid param id: %d", param); ++ return -1; ++ } ++} ++ ++static int ++kgsl_pipe_set_param(struct fd_pipe *pipe, uint32_t param, uint64_t value) ++{ ++ ERROR_MSG("kgsl_pipe_set_param not implemented"); ++ return -1; ++} ++ ++static int ++kgsl_pipe_wait(struct fd_pipe *pipe, const struct fd_fence *fence, uint64_t timeout) ++{ ++ struct kgsl_pipe *kgsl_pipe = to_kgsl_pipe(pipe); ++ return wait_timestamp_safe(pipe->dev->fd, kgsl_pipe->queue_id, fence->kfence, timeout); ++} ++ ++static void ++kgsl_pipe_destroy(struct fd_pipe *pipe) ++{ ++ struct kgsl_pipe *kgsl_pipe = to_kgsl_pipe(pipe); ++ struct kgsl_drawctxt_destroy req = { ++ .drawctxt_id = kgsl_pipe->queue_id, ++ }; ++ ++ fd_pipe_sp_ringpool_fini(pipe); ++ kgsl_pipe_safe_ioctl(pipe->dev->fd, IOCTL_KGSL_DRAWCTXT_DESTROY, &req); ++ free(kgsl_pipe); ++} ++ ++static int ++kgsl_reset_status(struct fd_pipe *pipe, enum fd_reset_status *status) ++{ ++ struct kgsl_pipe *kgsl_pipe = to_kgsl_pipe(pipe); ++ uint32_t value = kgsl_pipe->queue_id; ++ int ret = kgsl_get_prop(pipe->dev->fd, KGSL_PROP_GPU_RESET_STAT, &value, sizeof(value)); ++ ++ if (!ret) { ++ switch (value) { ++ case KGSL_CTX_STAT_NO_ERROR: ++ *status = FD_RESET_NO_ERROR; ++ break; ++ case KGSL_CTX_STAT_GUILTY_CONTEXT_RESET_EXT: ++ *status = FD_RESET_GUILTY; ++ break; ++ case KGSL_CTX_STAT_INNOCENT_CONTEXT_RESET_EXT: ++ *status = FD_RESET_INNOCENT; ++ break; ++ case KGSL_CTX_STAT_UNKNOWN_CONTEXT_RESET_EXT: ++ default: ++ *status = FD_RESET_UNKNOWN; ++ break; ++ } ++ } ++ ++ return ret; ++} ++ ++static const struct fd_pipe_funcs pipe_funcs = { ++ .ringbuffer_new_object = fd_ringbuffer_sp_new_object, ++ .submit_new = kgsl_submit_sp_new, ++ .reset_status = kgsl_reset_status, ++ .flush = fd_pipe_sp_flush, ++ .wait = kgsl_pipe_wait, ++ .get_param = kgsl_pipe_get_param, ++ .set_param = kgsl_pipe_set_param, ++ .destroy = kgsl_pipe_destroy, ++}; ++ ++struct fd_pipe *kgsl_pipe_new(struct fd_device *dev, enum fd_pipe_id id, ++ uint32_t prio) ++{ ++ struct kgsl_pipe *kgsl_pipe = NULL; ++ struct fd_pipe *pipe = NULL; ++ kgsl_pipe = calloc(1, sizeof(*kgsl_pipe)); ++ if (!kgsl_pipe) { ++ ERROR_MSG("allocation failed"); ++ goto fail; ++ } ++ ++ pipe = &kgsl_pipe->base; ++ pipe->dev = dev; ++ pipe->funcs = &pipe_funcs; ++ ++ struct kgsl_devinfo info; ++ if(kgsl_get_prop(dev->fd, KGSL_PROP_DEVICE_INFO, &info, sizeof(info))) ++ goto fail; ++ ++ uint64_t gmem_iova; ++ if(kgsl_get_prop(dev->fd, KGSL_PROP_UCHE_GMEM_VADDR, &gmem_iova, sizeof(gmem_iova))) ++ goto fail; ++ ++ kgsl_pipe->dev_id.gpu_id = ++ ((info.chip_id >> 24) & 0xff) * 100 + ++ ((info.chip_id >> 16) & 0xff) * 10 + ++ ((info.chip_id >> 8) & 0xff); ++ ++ kgsl_pipe->dev_id.chip_id = info.chip_id; ++ kgsl_pipe->gmem_size = info.gmem_sizebytes; ++ kgsl_pipe->gmem_base = gmem_iova; ++ ++ struct kgsl_drawctxt_create req = { ++ .flags = KGSL_CONTEXT_SAVE_GMEM | ++ KGSL_CONTEXT_NO_GMEM_ALLOC | ++ KGSL_CONTEXT_PREAMBLE, ++ }; ++ ++ int ret = kgsl_pipe_safe_ioctl(dev->fd, IOCTL_KGSL_DRAWCTXT_CREATE, &req); ++ if(ret) ++ goto fail; ++ ++ kgsl_pipe->queue_id = req.drawctxt_id; ++ ++ fd_pipe_sp_ringpool_init(pipe); ++ ++ return pipe; ++fail: ++ if (pipe) ++ fd_pipe_del(pipe); ++ return NULL; ++} +diff --git a/src/freedreno/drm/kgsl/kgsl_priv.h b/src/freedreno/drm/kgsl/kgsl_priv.h +new file mode 100644 +index 0000000..ed65c95 +--- /dev/null ++++ b/src/freedreno/drm/kgsl/kgsl_priv.h +@@ -0,0 +1,54 @@ ++#ifndef KGSL_PRIV_H ++#define KGSL_PRIV_H ++#include "freedreno_priv.h" ++ ++/* TODO the KGSL kernel interface should probably be moved */ ++/* into someplace common that both turnip and freedreno can use */ ++#include "../../vulkan/msm_kgsl.h" ++ ++int kgsl_get_prop(int fd, unsigned int type, void *value, size_t size); ++ ++struct kgsl_device { ++ struct fd_device base; ++}; ++FD_DEFINE_CAST(fd_device, kgsl_device); ++ ++struct fd_device *kgsl_device_new(int fd); ++static void kgsl_device_destroy(struct fd_device *dev); ++ ++struct kgsl_pipe { ++ struct fd_pipe base; ++ ++ struct fd_dev_id dev_id; ++ ++ uint32_t gmem_size; ++ uint64_t gmem_base; ++ uint32_t queue_id; ++}; ++FD_DEFINE_CAST(fd_pipe, kgsl_pipe); ++ ++struct fd_pipe *kgsl_pipe_new(struct fd_device *dev, enum fd_pipe_id id, ++ uint32_t prio); ++int kgsl_pipe_safe_ioctl(int fd, unsigned long request, void *arg); ++struct fd_submit *kgsl_submit_sp_new(struct fd_pipe *pipe); ++ ++struct kgsl_bo { ++ struct fd_bo base; ++ const char *name; ++ uint64_t iova; ++ uint32_t queue_id; ++ int import_fd; // fd for imported buffers ++ ++ enum { ++ KGSL_BO_NATIVE, ++ KGSL_BO_IMPORT, ++ } bo_type; ++}; ++FD_DEFINE_CAST(fd_bo, kgsl_bo); ++ ++struct fd_bo *kgsl_bo_new(struct fd_device *dev, uint32_t size, uint32_t flags); ++struct fd_bo *kgsl_bo_from_dmabuf(struct fd_device *dev, int fd); ++struct fd_bo *kgsl_bo_from_handle(struct fd_device *dev, uint32_t size, uint32_t handle); ++void kgsl_bo_close_handle(struct fd_bo *bo); ++ ++#endif +diff --git a/src/freedreno/drm/kgsl/kgsl_ringbuffer_sp.c b/src/freedreno/drm/kgsl/kgsl_ringbuffer_sp.c +new file mode 100644 +index 0000000..e8b2842 +--- /dev/null ++++ b/src/freedreno/drm/kgsl/kgsl_ringbuffer_sp.c +@@ -0,0 +1,119 @@ ++#include "kgsl_priv.h" ++#include "freedreno_ringbuffer_sp.h" ++ ++static int ++timestamp_to_fd(struct fd_pipe *pipe, uint32_t timestamp) ++{ ++ int fd; ++ struct kgsl_pipe *kgsl_pipe = to_kgsl_pipe(pipe); ++ struct kgsl_timestamp_event event = { ++ .type = KGSL_TIMESTAMP_EVENT_FENCE, ++ .context_id = kgsl_pipe->queue_id, ++ .timestamp = timestamp, ++ .priv = &fd, ++ .len = sizeof(fd), ++ }; ++ ++ int ret = kgsl_pipe_safe_ioctl(pipe->dev->fd, IOCTL_KGSL_TIMESTAMP_EVENT, &event); ++ if (ret) ++ return -1; ++ ++ return fd; ++} ++ ++static int ++flush_submit_list(struct list_head *submit_list) ++{ ++ struct fd_submit_sp *fd_submit = to_fd_submit_sp(last_submit(submit_list)); ++ struct fd_pipe *pipe = fd_submit->base.pipe; ++ struct kgsl_pipe *kgsl_pipe = to_kgsl_pipe(pipe); ++ unsigned nr_cmds = 0; ++ ++ ++ MESA_TRACE_FUNC(); ++ ++ foreach_submit (submit, submit_list) { ++ assert(submit->pipe == &kgsl_pipe->base); ++ nr_cmds += to_fd_ringbuffer_sp(submit->primary)->u.nr_cmds; ++ } ++ ++ struct kgsl_command_object cmds[nr_cmds]; ++ unsigned cmd_idx = 0; ++ foreach_submit_safe (submit, submit_list) { ++ struct fd_ringbuffer_sp *deferred_primary = ++ to_fd_ringbuffer_sp(submit->primary); ++ ++ for (unsigned i = 0; i < deferred_primary->u.nr_cmds; i++) { ++ struct fd_bo *ring_bo = deferred_primary->u.cmds[i].ring_bo; ++ ++ cmds[cmd_idx++] = (struct kgsl_command_object) { ++ .offset = 0, ++ .gpuaddr = ring_bo->iova + submit_offset(ring_bo, deferred_primary->offset), ++ .size = deferred_primary->u.cmds[i].size, ++ .flags = KGSL_CMDLIST_IB, ++ .id = ring_bo->handle, ++ }; ++ } ++ ++ if (submit == last_submit(submit_list)) { ++ DEBUG_MSG("merged %u submits", cmd_idx); ++ break; ++ } ++ ++ list_del(&submit->node); ++ fd_submit_del(submit); ++ } ++ ++ struct kgsl_cmd_syncpoint_fence sync_fence = { ++ .fd = fd_submit->in_fence_fd, ++ }; ++ ++ struct kgsl_command_syncpoint sync = { ++ .type = KGSL_CMD_SYNCPOINT_TYPE_FENCE, ++ .size = sizeof(sync_fence), ++ .priv = (uintptr_t) &sync_fence, ++ }; ++ ++ ++ struct kgsl_gpu_command req = { ++ .flags = KGSL_CMDBATCH_SUBMIT_IB_LIST, ++ .context_id = kgsl_pipe->queue_id, ++ .cmdlist = (uintptr_t) cmds, ++ .numcmds = cmd_idx, ++ .cmdsize = sizeof(struct kgsl_command_object), ++ .synclist = (uintptr_t) &sync, ++ .syncsize = sizeof(struct kgsl_command_syncpoint), ++ .numsyncs = sync_fence.fd != -1 ? 1 : 0, ++ }; ++ ++ int ret = kgsl_pipe_safe_ioctl(pipe->dev->fd, IOCTL_KGSL_GPU_COMMAND, &req); ++ ++ if (ret) { ++ ERROR_MSG("submit failed %d (%s)", ret, strerror(errno)); ++ goto fail; ++ } ++ ++ fd_submit->out_fence->kfence = req.timestamp; ++ ++ if (fd_submit->out_fence->use_fence_fd) { ++ int fd = timestamp_to_fd(pipe, req.timestamp); ++ if (fd < 0) { ++ ERROR_MSG("Failed to create sync file for timestamp (%s)", strerror(errno)); ++ goto fail; ++ } ++ ++ fd_submit->out_fence->fence_fd = fd; ++ } ++ ++ if (fd_submit->in_fence_fd != -1) ++ close(fd_submit->in_fence_fd); ++ ++fail: ++ return ret; ++} ++ ++struct fd_submit * ++kgsl_submit_sp_new(struct fd_pipe *pipe) ++{ ++ return fd_submit_sp_new(pipe, flush_submit_list); ++} +diff --git a/src/freedreno/drm/meson.build b/src/freedreno/drm/meson.build +index ffaf6c9..24e6b96 100644 +--- a/src/freedreno/drm/meson.build ++++ b/src/freedreno/drm/meson.build +@@ -62,6 +62,17 @@ if freedreno_kmds.contains('virtio') + ] + endif + ++libfreedreno_kgsl_files = files( ++ 'kgsl/kgsl_device.c', ++ 'kgsl/kgsl_bo.c', ++ 'kgsl/kgsl_pipe.c', ++ 'kgsl/kgsl_ringbuffer_sp.c', ++) ++ ++if freedreno_kmds.contains('kgsl') ++ libfreedreno_drm_files += libfreedreno_kgsl_files ++endif ++ + libfreedreno_drm = static_library( + 'freedreno_drm', + [ +diff --git a/src/gallium/drivers/freedreno/freedreno_context.c b/src/gallium/drivers/freedreno/freedreno_context.c +index a77d083..cf9a5ea 100644 +--- a/src/gallium/drivers/freedreno/freedreno_context.c ++++ b/src/gallium/drivers/freedreno/freedreno_context.c +@@ -479,6 +479,22 @@ fd_get_device_reset_status(struct pipe_context *pctx) + return status; + } + ++static enum pipe_reset_status ++fd_get_device_reset_status_direct(struct pipe_context *pctx) ++{ ++ struct fd_context *ctx = fd_context(pctx); ++ enum pipe_reset_status status_list[] = { ++ [FD_RESET_NO_ERROR] = PIPE_NO_RESET, ++ [FD_RESET_GUILTY] = PIPE_GUILTY_CONTEXT_RESET, ++ [FD_RESET_INNOCENT] = PIPE_INNOCENT_CONTEXT_RESET, ++ [FD_RESET_UNKNOWN] = PIPE_UNKNOWN_CONTEXT_RESET, ++ }; ++ enum fd_reset_status fd_status; ++ ASSERTED int ret = fd_pipe_get_reset_status(ctx->pipe, &fd_status); ++ assert(!ret); ++ return status_list[fd_status]; ++} ++ + static void + fd_trace_record_ts(struct u_trace *ut, void *cs, void *timestamps, + uint64_t offset_B, uint32_t flags) +@@ -643,11 +659,6 @@ fd_context_init(struct fd_context *ctx, struct pipe_screen *pscreen, + + ctx->in_fence_fd = -1; + +- if (fd_device_version(screen->dev) >= FD_VERSION_ROBUSTNESS) { +- ctx->context_reset_count = fd_get_reset_count(ctx, true); +- ctx->global_reset_count = fd_get_reset_count(ctx, false); +- } +- + simple_mtx_init(&ctx->gmem_lock, mtx_plain); + + /* need some sane default in case gallium frontends don't +@@ -662,13 +673,20 @@ fd_context_init(struct fd_context *ctx, struct pipe_screen *pscreen, + pctx->flush = fd_context_flush; + pctx->emit_string_marker = fd_emit_string_marker; + pctx->set_debug_callback = fd_set_debug_callback; +- pctx->get_device_reset_status = fd_get_device_reset_status; + pctx->create_fence_fd = fd_create_pipe_fence_fd; + pctx->fence_server_sync = fd_pipe_fence_server_sync; + pctx->fence_server_signal = fd_pipe_fence_server_signal; + pctx->texture_barrier = fd_texture_barrier; + pctx->memory_barrier = fd_memory_barrier; + ++ if (fd_get_features(screen->dev) & FD_FEATURE_DIRECT_RESET) { ++ pctx->get_device_reset_status = fd_get_device_reset_status_direct; ++ } else if(fd_device_version(screen->dev) >= FD_VERSION_ROBUSTNESS) { ++ ctx->context_reset_count = fd_get_reset_count(ctx, true); ++ ctx->global_reset_count = fd_get_reset_count(ctx, false); ++ pctx->get_device_reset_status = fd_get_device_reset_status; ++ } ++ + pctx->stream_uploader = u_upload_create_default(pctx); + if (!pctx->stream_uploader) + goto fail; +diff --git a/src/gallium/drivers/freedreno/freedreno_screen.c b/src/gallium/drivers/freedreno/freedreno_screen.c +index e41699a..6abe33a 100644 +--- a/src/gallium/drivers/freedreno/freedreno_screen.c ++++ b/src/gallium/drivers/freedreno/freedreno_screen.c +@@ -678,7 +678,7 @@ fd_init_screen_caps(struct fd_screen *screen) + caps->query_timestamp = + caps->query_time_elapsed = + /* only a4xx, requires new enough kernel so we know max_freq: */ +- (screen->max_freq > 0) && (is_a4xx(screen) || is_a5xx(screen) || is_a6xx(screen)); ++ (is_a4xx(screen) || is_a5xx(screen) || is_a6xx(screen)); + caps->timer_resolution = ticks_to_ns(1); + caps->query_buffer_object = + caps->query_so_overflow = +diff --git a/src/gallium/drivers/zink/zink_compiler.c b/src/gallium/drivers/zink/zink_compiler.c +index 5613724..9d96cc6 100644 +--- a/src/gallium/drivers/zink/zink_compiler.c ++++ b/src/gallium/drivers/zink/zink_compiler.c +@@ -4078,6 +4078,10 @@ zink_shader_compile(struct zink_screen *screen, bool can_shobj, struct zink_shad + NIR_PASS_V(nir, nir_remove_dead_variables, nir_var_shader_temp, NULL); + need_optimize = true; + } ++ if (zink_driverid(screen) == VK_DRIVER_ID_QUALCOMM_PROPRIETARY) { ++ NIR_PASS_V(nir, nir_lower_io_to_vector, nir_var_shader_in); ++ need_optimize = true; ++ } + break; + case MESA_SHADER_COMPUTE: + if (zink_cs_key(key)->robust_access) +diff --git a/src/gallium/drivers/zink/zink_screen.c b/src/gallium/drivers/zink/zink_screen.c +index bc0cc58..67b6b04 100644 +--- a/src/gallium/drivers/zink/zink_screen.c ++++ b/src/gallium/drivers/zink/zink_screen.c +@@ -2356,6 +2356,10 @@ zink_screen_export_dmabuf_semaphore(struct zink_screen *screen, struct zink_reso + { + VkSemaphore sem = VK_NULL_HANDLE; + #if defined(HAVE_LIBDRM) && (DETECT_OS_LINUX || DETECT_OS_BSD) ++ static bool no_dma_buf_sync_file = false; ++ if (no_dma_buf_sync_file) ++ return sem; ++ + struct dma_buf_export_sync_file export = { + .flags = DMA_BUF_SYNC_RW, + .fd = -1, +@@ -2380,7 +2384,7 @@ zink_screen_export_dmabuf_semaphore(struct zink_screen *screen, struct zink_reso + int ret = drmIoctl(fd, DMA_BUF_IOCTL_EXPORT_SYNC_FILE, &export); + if (ret) { + if (errno == ENOTTY || errno == EBADF || errno == ENOSYS) { +- assert(!"how did this fail?"); ++ no_dma_buf_sync_file = true; + return VK_NULL_HANDLE; + } else { + mesa_loge("MESA: failed to import sync file '%s'", strerror(errno)); +@@ -2411,6 +2415,10 @@ bool + zink_screen_import_dmabuf_semaphore(struct zink_screen *screen, struct zink_resource *res, VkSemaphore sem) + { + #if defined(HAVE_LIBDRM) && (DETECT_OS_LINUX || DETECT_OS_BSD) ++ static bool no_dma_buf_sync_file = false; ++ if (no_dma_buf_sync_file) ++ return sem; ++ + const VkSemaphoreGetFdInfoKHR get_fd_info = { + .sType = VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR, + .semaphore = sem, +@@ -2442,7 +2450,8 @@ zink_screen_import_dmabuf_semaphore(struct zink_screen *screen, struct zink_reso + int ioctl_ret = drmIoctl(fd, DMA_BUF_IOCTL_IMPORT_SYNC_FILE, &import); + if (ioctl_ret) { + if (errno == ENOTTY || errno == EBADF || errno == ENOSYS) { +- assert(!"how did this fail?"); ++ no_dma_buf_sync_file = true; ++ ret = true; + } else { + ret = true; + } +diff --git a/src/gallium/frontends/dri/loader_dri3_helper.c b/src/gallium/frontends/dri/loader_dri3_helper.c +index 9e4ca3f..0f08c37 100644 +--- a/src/gallium/frontends/dri/loader_dri3_helper.c ++++ b/src/gallium/frontends/dri/loader_dri3_helper.c +@@ -26,11 +26,9 @@ + #include + #include + +-#include + #include + #include + #include +-#include + + #include + +@@ -247,19 +245,16 @@ loader_dri3_blit_image(struct loader_dri3_drawable *draw, + static inline void + dri3_fence_reset(xcb_connection_t *c, struct loader_dri3_buffer *buffer) + { +- xshmfence_reset(buffer->shm_fence); + } + + static inline void + dri3_fence_set(struct loader_dri3_buffer *buffer) + { +- xshmfence_trigger(buffer->shm_fence); + } + + static inline void + dri3_fence_trigger(xcb_connection_t *c, struct loader_dri3_buffer *buffer) + { +- xcb_sync_trigger_fence(c, buffer->sync_fence); + } + + static inline void +@@ -267,7 +262,6 @@ dri3_fence_await(xcb_connection_t *c, struct loader_dri3_drawable *draw, + struct loader_dri3_buffer *buffer) + { + xcb_flush(c); +- xshmfence_await(buffer->shm_fence); + if (draw) { + mtx_lock(&draw->mtx); + dri3_flush_present_events(draw); +@@ -343,8 +337,6 @@ dri3_free_render_buffer(struct loader_dri3_drawable *draw, + + if (buffer->own_pixmap) + xcb_free_pixmap(draw->conn, buffer->pixmap); +- xcb_sync_destroy_fence(draw->conn, buffer->sync_fence); +- xshmfence_unmap_shm(buffer->shm_fence); + dri2_destroy_image(buffer->image); + if (buffer->linear_buffer) + dri2_destroy_image(buffer->linear_buffer); +@@ -1143,26 +1135,7 @@ loader_dri3_swap_buffers_msc(struct loader_dri3_drawable *draw, + back->busy = 1; + back->last_swap = draw->send_sbc; + +- if (!draw->region) { +- draw->region = xcb_generate_id(draw->conn); +- xcb_xfixes_create_region(draw->conn, draw->region, 0, NULL); +- } +- + xcb_xfixes_region_t region = 0; +- xcb_rectangle_t xcb_rects[64]; +- +- if (n_rects > 0 && n_rects <= ARRAY_SIZE(xcb_rects)) { +- for (int i = 0; i < n_rects; i++) { +- const int *rect = &rects[i * 4]; +- xcb_rects[i].x = rect[0]; +- xcb_rects[i].y = draw->height - rect[1] - rect[3]; +- xcb_rects[i].width = rect[2]; +- xcb_rects[i].height = rect[3]; +- } +- +- region = draw->region; +- xcb_xfixes_set_region(draw->conn, region, n_rects, xcb_rects); +- } + + xcb_present_pixmap(draw->conn, + draw->drawable, +@@ -1392,27 +1365,13 @@ dri3_alloc_render_buffer(struct loader_dri3_drawable *draw, unsigned int fourcc, + struct dri_image *pixmap_buffer = NULL, *linear_buffer_display_gpu = NULL; + int format = loader_fourcc_to_image_format(fourcc); + xcb_pixmap_t pixmap; +- xcb_sync_fence_t sync_fence; +- struct xshmfence *shm_fence; +- int buffer_fds[4], fence_fd; ++ int buffer_fds[4]; + int num_planes = 0; + uint64_t *modifiers = NULL; + uint32_t count = 0; + int i, mod; + int ret; + +- /* Create an xshmfence object and +- * prepare to send that to the X server +- */ +- +- fence_fd = xshmfence_alloc_shm(); +- if (fence_fd < 0) +- return NULL; +- +- shm_fence = xshmfence_map_shm(fence_fd); +- if (shm_fence == NULL) +- goto no_shm_fence; +- + /* Allocate the image from the driver + */ + buffer = calloc(1, sizeof *buffer); +@@ -1612,7 +1571,7 @@ dri3_alloc_render_buffer(struct loader_dri3_drawable *draw, unsigned int fourcc, + buffer->strides[2], buffer->offsets[2], + buffer->strides[3], buffer->offsets[3], + depth, buffer->cpp * 8, +- buffer->modifier, ++ buffer->modifier ? buffer->modifier : 1274, + buffer_fds); + } else + #endif +@@ -1625,21 +1584,13 @@ dri3_alloc_render_buffer(struct loader_dri3_drawable *draw, unsigned int fourcc, + depth, buffer->cpp * 8, + buffer_fds[0]); + } +- cookie_fence = xcb_dri3_fence_from_fd_checked(draw->conn, +- pixmap, +- (sync_fence = xcb_generate_id(draw->conn)), +- false, +- fence_fd); ++ + /* Group error checking to limit round-trips. */ + if (!check_xcb_error(cookie_pix, "xcb_dri3_pixmap_from_buffer[s]")) + goto no_buffer_attrib; +- if (!check_xcb_error(cookie_fence, "xcb_dri3_fence_from_fd")) +- goto no_buffer_attrib; + + buffer->pixmap = pixmap; + buffer->own_pixmap = true; +- buffer->sync_fence = sync_fence; +- buffer->shm_fence = shm_fence; + buffer->width = width; + buffer->height = height; + +@@ -1661,9 +1612,6 @@ no_linear_buffer: + no_image: + free(buffer); + no_buffer: +- xshmfence_unmap_shm(shm_fence); +-no_shm_fence: +- close(fence_fd); + return NULL; + } + +@@ -1933,11 +1881,8 @@ dri3_get_pixmap_buffer(struct dri_drawable *driDrawable, unsigned int fourcc, + struct loader_dri3_buffer *buffer = draw->buffers[buf_id]; + xcb_drawable_t pixmap; + xcb_void_cookie_t cookie; +- xcb_sync_fence_t sync_fence; +- struct xshmfence *shm_fence; + int width; + int height; +- int fence_fd; + struct dri_screen *cur_screen; + + if (buffer) +@@ -1949,15 +1894,6 @@ dri3_get_pixmap_buffer(struct dri_drawable *driDrawable, unsigned int fourcc, + if (!buffer) + goto no_buffer; + +- fence_fd = xshmfence_alloc_shm(); +- if (fence_fd < 0) +- goto no_fence; +- shm_fence = xshmfence_map_shm(fence_fd); +- if (shm_fence == NULL) { +- close (fence_fd); +- goto no_fence; +- } +- + /* Get the currently-bound screen or revert to using the drawable's screen if + * no contexts are currently bound. The latter case is at least necessary for + * obs-studio, when using Window Capture (Xcomposite) as a Source. +@@ -1967,14 +1903,6 @@ dri3_get_pixmap_buffer(struct dri_drawable *driDrawable, unsigned int fourcc, + cur_screen = draw->dri_screen_render_gpu; + } + +- cookie = xcb_dri3_fence_from_fd_checked(draw->conn, +- pixmap, +- (sync_fence = xcb_generate_id(draw->conn)), +- false, +- fence_fd); +- if (!check_xcb_error(cookie, "xcb_dri3_fence_from_fd")) +- goto no_image; +- + buffer->image = loader_dri3_get_pixmap_buffer(draw->conn, pixmap, cur_screen, fourcc, + draw->multiplanes_available, &width, &height, buffer); + +@@ -1985,17 +1913,12 @@ dri3_get_pixmap_buffer(struct dri_drawable *driDrawable, unsigned int fourcc, + buffer->own_pixmap = false; + buffer->width = width; + buffer->height = height; +- buffer->shm_fence = shm_fence; +- buffer->sync_fence = sync_fence; + + dri3_set_render_buffer(draw, buf_id, buffer); + + return buffer; + + no_image: +- xcb_sync_destroy_fence(draw->conn, sync_fence); +- xshmfence_unmap_shm(shm_fence); +-no_fence: + free(buffer); + no_buffer: + return NULL; +diff --git a/src/x11/loader_x11.c b/src/x11/loader_x11.c +index 75eb560..6a488d9 100644 +--- a/src/x11/loader_x11.c ++++ b/src/x11/loader_x11.c +@@ -30,6 +30,7 @@ + #include + #include + #include "loader_x11.h" ++#include + /** x11_dri3_open + * + * Wrapper around xcb_dri3_open +@@ -46,6 +47,10 @@ x11_dri3_open(xcb_connection_t *conn, + int fd; + const xcb_query_extension_reply_t *extension; + ++ const char *env = getenv("MESA_LOADER_DRIVER_OVERRIDE"); ++ if (env && !strcmp(env, "kgsl")) ++ return open("/dev/kgsl-3d0", O_RDWR); ++ + xcb_prefetch_extension_data(conn, &xcb_dri3_id); + extension = xcb_get_extension_data(conn, &xcb_dri3_id); + if (!(extension && extension->present)) diff --git a/debian/patches/Revert-hasvk-elk-stop-turning-load_push_constants-in.patch b/debian/patches/Revert-hasvk-elk-stop-turning-load_push_constants-in.patch index bf70026ea4ae..f79244549a05 100644 --- a/debian/patches/Revert-hasvk-elk-stop-turning-load_push_constants-in.patch +++ b/debian/patches/Revert-hasvk-elk-stop-turning-load_push_constants-in.patch @@ -1,4 +1,3 @@ -From 37438a83a748f591c8ecdf20390a90312eebbff8 Mon Sep 17 00:00:00 2001 From: Dave Airlie Date: Mon, 9 Jun 2025 09:19:28 +1000 Subject: [PATCH] Revert "hasvk/elk: stop turning load_push_constants into @@ -21,7 +20,7 @@ Part-of: 3 files changed, 6 insertions(+), 7 deletions(-) diff --git a/src/intel/compiler/elk/elk_fs_nir.cpp b/src/intel/compiler/elk/elk_fs_nir.cpp -index 459e2d966b7..6b78d6cf9f8 100644 +index 459e2d9..6b78d6c 100644 --- a/src/intel/compiler/elk/elk_fs_nir.cpp +++ b/src/intel/compiler/elk/elk_fs_nir.cpp @@ -4969,8 +4969,7 @@ fs_nir_emit_intrinsic(nir_to_elk_state &ntb, @@ -40,7 +39,7 @@ index 459e2d966b7..6b78d6cf9f8 100644 } + diff --git a/src/intel/vulkan_hasvk/anv_nir_apply_pipeline_layout.c b/src/intel/vulkan_hasvk/anv_nir_apply_pipeline_layout.c -index 2bedf9017ed..1c613a9ebe7 100644 +index 2bedf90..1c613a9 100644 --- a/src/intel/vulkan_hasvk/anv_nir_apply_pipeline_layout.c +++ b/src/intel/vulkan_hasvk/anv_nir_apply_pipeline_layout.c @@ -463,9 +463,9 @@ build_buffer_addr_for_res_index(nir_builder *b, @@ -57,7 +56,7 @@ index 2bedf9017ed..1c613a9ebe7 100644 nir_def *dynamic_offset = nir_bcsel(b, nir_ieq_imm(b, res.dyn_offset_base, 0xff), diff --git a/src/intel/vulkan_hasvk/anv_nir_compute_push_layout.c b/src/intel/vulkan_hasvk/anv_nir_compute_push_layout.c -index ed314af8b98..8a3f83f2c26 100644 +index ed314af..8a3f83f 100644 --- a/src/intel/vulkan_hasvk/anv_nir_compute_push_layout.c +++ b/src/intel/vulkan_hasvk/anv_nir_compute_push_layout.c @@ -55,7 +55,6 @@ anv_nir_compute_push_layout(nir_shader *nir, @@ -84,6 +83,3 @@ index ed314af8b98..8a3f83f2c26 100644 nir_intrinsic_set_base(intrin, nir_intrinsic_base(intrin) - base_offset); --- -2.48.1 - diff --git a/debian/patches/disable_ppc64el_assembly.diff b/debian/patches/disable_ppc64el_assembly.diff index 1d3c23526620..d327d9af7e0b 100644 --- a/debian/patches/disable_ppc64el_assembly.diff +++ b/debian/patches/disable_ppc64el_assembly.diff @@ -1,11 +1,18 @@ -Description: disable use of ppc64el assembly code -Author: Dmitry Shachnev +From: Dmitry Shachnev +Date: Wed, 26 Nov 2025 20:56:04 +0800 +Subject: disable use of ppc64el assembly code + Bug-Debian: https://bugs.debian.org/1092890 Last-Update: 2025-02-02 +--- + meson.build | 5 ----- + 1 file changed, 5 deletions(-) +diff --git a/meson.build b/meson.build +index 095aec5..38292d8 100644 --- a/meson.build +++ b/meson.build -@@ -1319,11 +1319,6 @@ elif host_machine.cpu_family() == 'sparc +@@ -1356,11 +1356,6 @@ elif host_machine.cpu_family() == 'sparc64' with_asm_arch = 'sparc' pre_args += ['-DUSE_SPARC_ASM'] endif diff --git a/debian/patches/etnaviv-add-support-for-texelfetch.patch b/debian/patches/etnaviv-add-support-for-texelfetch.patch index 31b8feb2b1da..bcd957894d46 100644 --- a/debian/patches/etnaviv-add-support-for-texelfetch.patch +++ b/debian/patches/etnaviv-add-support-for-texelfetch.patch @@ -1,4 +1,3 @@ -From da90fca6093dd58cc351b0ac624ea8c0d83a81f9 Mon Sep 17 00:00:00 2001 From: Christian Gmeiner Date: Fri, 18 Apr 2025 23:35:20 +0200 Subject: [PATCH 1/3] etnaviv: isa: Add txf instruction @@ -11,15 +10,17 @@ dEQP-GLES3.functional.shaders.texture_functions.texelfetch.+ Signed-off-by: Christian Gmeiner Part-of: --- - src/etnaviv/isa/etnaviv.xml | 5 +++++ - src/etnaviv/isa/tests/disasm.cpp | 1 + - 2 files changed, 6 insertions(+) + src/etnaviv/isa/etnaviv.xml | 5 +++++ + src/etnaviv/isa/tests/disasm.cpp | 1 + + .../drivers/etnaviv/etnaviv_compiler_nir_emit.c | 4 ++++ + .../drivers/etnaviv/etnaviv_nir_lower_texture.c | 25 ++++++++++++++++++++++ + 4 files changed, 35 insertions(+) diff --git a/src/etnaviv/isa/etnaviv.xml b/src/etnaviv/isa/etnaviv.xml -index a337c1e9d0762..42f551238bf1b 100644 +index 9893aab..aa36a3b 100644 --- a/src/etnaviv/isa/etnaviv.xml +++ b/src/etnaviv/isa/etnaviv.xml -@@ -1359,6 +1359,11 @@ SPDX-License-Identifier: MIT +@@ -1350,6 +1350,11 @@ SPDX-License-Identifier: MIT 1 @@ -32,10 +33,10 @@ index a337c1e9d0762..42f551238bf1b 100644 001100 1 diff --git a/src/etnaviv/isa/tests/disasm.cpp b/src/etnaviv/isa/tests/disasm.cpp -index aa027618aa40a..3d4ebec8a49be 100644 +index dc0a26a..dddd83d 100644 --- a/src/etnaviv/isa/tests/disasm.cpp +++ b/src/etnaviv/isa/tests/disasm.cpp -@@ -166,6 +166,7 @@ INSTANTIATE_TEST_SUITE_P(Opcodes, DisasmTest, +@@ -165,6 +165,7 @@ INSTANTIATE_TEST_SUITE_P(Opcodes, DisasmTest, disasm_state{ {0x00801036, 0x15400804, 0x01540050, 0x00000002}, "clamp0_max t0.x___, u0.yyyy, u0.zzzz, void\n"}, disasm_state{ {0x0080103b, 0x00001804, 0x40000000, 0x00400028}, "iaddsat.s32 t0.x___, t1.xxxx, void, -t2.xxxx\n"}, disasm_state{ {0x01001008, 0x15400804, 0xd00100c0, 0x00000007}, "imod.u16 t0._y__, t0.yyyy, 1, void\n"}, @@ -43,26 +44,23 @@ index aa027618aa40a..3d4ebec8a49be 100644 disasm_state{ {0x0080103c, 0x00001804, 0x40000140, 0x00000000}, "imullo0.s32 t0.x___, t1.xxxx, t2.xxxx, void\n"}, disasm_state{ {0x00801000, 0x00001804, 0x40010140, 0x00000000}, "imulhi0.s32 t0.x___, t1.xxxx, t2.xxxx, void\n"}, disasm_state{ {0x00801004, 0x00201804, 0x40010040, 0x00000000}, "idiv0.s16 t0.x___, t1.xxxx, t0.xxxx, void\n"}, --- -GitLab - - -From eefe486533eb58d3d1e81daa5abd16e63ee4c7a9 Mon Sep 17 00:00:00 2001 -From: Christian Gmeiner -Date: Fri, 18 Apr 2025 23:37:19 +0200 -Subject: [PATCH 2/3] etnaviv: nir: Legalize txf lod src - -The LOD must be a float, unlike the GLSL function, which expects an integer. - -Signed-off-by: Christian Gmeiner -Reviewed-by: Faith Ekstrand -Part-of: ---- - .../etnaviv/etnaviv_nir_lower_texture.c | 25 +++++++++++++++++++ - 1 file changed, 25 insertions(+) - +diff --git a/src/gallium/drivers/etnaviv/etnaviv_compiler_nir_emit.c b/src/gallium/drivers/etnaviv/etnaviv_compiler_nir_emit.c +index 08a5ab5..708f0788 100644 +--- a/src/gallium/drivers/etnaviv/etnaviv_compiler_nir_emit.c ++++ b/src/gallium/drivers/etnaviv/etnaviv_compiler_nir_emit.c +@@ -212,6 +212,10 @@ etna_emit_tex(struct etna_compile *c, nir_texop op, unsigned texid, unsigned dst + case nir_texop_txb: inst.opcode = ISA_OPC_TEXLDB; break; + case nir_texop_txd: inst.opcode = ISA_OPC_TEXLDD; break; + case nir_texop_txl: inst.opcode = ISA_OPC_TEXLDL; break; ++ case nir_texop_txf: ++ inst.opcode = ISA_OPC_TXF; ++ inst.src[2] = etna_immediate_int(0x1100); ++ break; + default: + compile_error(c, "Unhandled NIR tex type: %d\n", op); + } diff --git a/src/gallium/drivers/etnaviv/etnaviv_nir_lower_texture.c b/src/gallium/drivers/etnaviv/etnaviv_nir_lower_texture.c -index d0462ead016dc..d20d175da79a8 100644 +index d0462ea..d20d175 100644 --- a/src/gallium/drivers/etnaviv/etnaviv_nir_lower_texture.c +++ b/src/gallium/drivers/etnaviv/etnaviv_nir_lower_texture.c @@ -26,6 +26,28 @@ lower_txs(nir_builder *b, nir_instr *instr, UNUSED void *data) @@ -103,42 +101,3 @@ index d0462ead016dc..d20d175da79a8 100644 + return progress; } --- -GitLab - - -From 614b66529de2832575cdb0c97581d0d5f791ed72 Mon Sep 17 00:00:00 2001 -From: Christian Gmeiner -Date: Fri, 18 Apr 2025 23:42:14 +0200 -Subject: [PATCH 3/3] etnaviv: nir: Add support for txf texture operation - -The src[2] value 0x1100 is set based on observed behavior of the blob driver, -though its exact meaning remains to be documented. - -Passes all dEQP-GLES3.functional.shaders.texture_functions.texelfetch.* -tests on GC7000. - -Signed-off-by: Christian Gmeiner -Part-of: ---- - src/gallium/drivers/etnaviv/etnaviv_compiler_nir_emit.c | 4 ++++ - 1 file changed, 4 insertions(+) - -diff --git a/src/gallium/drivers/etnaviv/etnaviv_compiler_nir_emit.c b/src/gallium/drivers/etnaviv/etnaviv_compiler_nir_emit.c -index 08a5ab5fb7bc3..708f0788b580d 100644 ---- a/src/gallium/drivers/etnaviv/etnaviv_compiler_nir_emit.c -+++ b/src/gallium/drivers/etnaviv/etnaviv_compiler_nir_emit.c -@@ -212,6 +212,10 @@ etna_emit_tex(struct etna_compile *c, nir_texop op, unsigned texid, unsigned dst - case nir_texop_txb: inst.opcode = ISA_OPC_TEXLDB; break; - case nir_texop_txd: inst.opcode = ISA_OPC_TEXLDD; break; - case nir_texop_txl: inst.opcode = ISA_OPC_TEXLDL; break; -+ case nir_texop_txf: -+ inst.opcode = ISA_OPC_TXF; -+ inst.src[2] = etna_immediate_int(0x1100); -+ break; - default: - compile_error(c, "Unhandled NIR tex type: %d\n", op); - } --- -GitLab - diff --git a/debian/patches/kopper-Revert-kopper-Explicitly-choose-zink.patch b/debian/patches/kopper-Revert-kopper-Explicitly-choose-zink.patch index 28463f13ffb1..822153dd2fe7 100644 --- a/debian/patches/kopper-Revert-kopper-Explicitly-choose-zink.patch +++ b/debian/patches/kopper-Revert-kopper-Explicitly-choose-zink.patch @@ -1,4 +1,3 @@ -From 747b170d4643bbc8334b07785916bf6160a0ffbf Mon Sep 17 00:00:00 2001 From: Yiwei Zhang Date: Sat, 17 May 2025 12:50:28 -0700 Subject: [PATCH] kopper: Revert "kopper: Explicitly choose zink" @@ -19,13 +18,13 @@ Part-of: (cherry picked from commit e6481d3f42e0cd735fda38fb3029e6f8abf5a0e6) --- src/gallium/frontends/dri/kopper.c | 2 +- - 1 files changed, 1 insertions(+), 1 deletions(-) + 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/gallium/frontends/dri/kopper.c b/src/gallium/frontends/dri/kopper.c -index 54a754c919d..5d84b1b8f98 100644 +index a1d7dcb..3bdb560 100644 --- a/src/gallium/frontends/dri/kopper.c +++ b/src/gallium/frontends/dri/kopper.c -@@ -69,7 +69,7 @@ kopper_init_screen(struct dri_screen *screen, bool driver_name_is_inferred) +@@ -73,7 +73,7 @@ kopper_init_screen(struct dri_screen *screen, bool driver_name_is_inferred) bool success; #ifdef HAVE_LIBDRM if (screen->fd != -1) @@ -34,6 +33,3 @@ index 54a754c919d..5d84b1b8f98 100644 else success = pipe_loader_vk_probe_dri(&screen->dev); #else --- -2.48.1 - diff --git a/debian/patches/pan-genxml-Add-missing-parenthesis-on-pan_cast_and_p.patch b/debian/patches/pan-genxml-Add-missing-parenthesis-on-pan_cast_and_p.patch index 26344feba8ac..0785d468e19c 100644 --- a/debian/patches/pan-genxml-Add-missing-parenthesis-on-pan_cast_and_p.patch +++ b/debian/patches/pan-genxml-Add-missing-parenthesis-on-pan_cast_and_p.patch @@ -12,10 +12,15 @@ Reviewed-by: Erik Faye-Lund Part-of: Origin: https://gitlab.freedesktop.org/mesa/mesa/-/commit/455b93601a19536bed7195b3fde8d7cf13a48e6a Bug-Debian: https://bugs.debian.org/1116427 +--- + src/panfrost/lib/genxml/pan_pack_helpers.h | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) +diff --git a/src/panfrost/lib/genxml/pan_pack_helpers.h b/src/panfrost/lib/genxml/pan_pack_helpers.h +index 6355420..bc71317 100644 --- a/src/panfrost/lib/genxml/pan_pack_helpers.h +++ b/src/panfrost/lib/genxml/pan_pack_helpers.h -@@ -98,10 +98,10 @@ __gen_padded(uint32_t v, uint32_t start, +@@ -98,10 +98,10 @@ __gen_padded(uint32_t v, uint32_t start, uint32_t end) })) #define pan_cast_and_pack(dst, T, name) \ diff --git a/debian/patches/path_max.diff b/debian/patches/path_max.diff index aa4909bced75..0a00aba67aaa 100644 --- a/debian/patches/path_max.diff +++ b/debian/patches/path_max.diff @@ -1,6 +1,33 @@ +From: Debian X Strike Force +Date: Wed, 26 Nov 2025 20:56:04 +0800 +Subject: path_max + +--- + src/gallium/auxiliary/pipe-loader/pipe_loader.c | 4 ++++ + src/util/tests/cache_test.cpp | 4 ++-- + src/util/tests/process_test.c | 4 ++++ + 3 files changed, 10 insertions(+), 2 deletions(-) + +diff --git a/src/gallium/auxiliary/pipe-loader/pipe_loader.c b/src/gallium/auxiliary/pipe-loader/pipe_loader.c +index 721204d..b97b2a4 100644 +--- a/src/gallium/auxiliary/pipe-loader/pipe_loader.c ++++ b/src/gallium/auxiliary/pipe-loader/pipe_loader.c +@@ -42,6 +42,10 @@ + #define PATH_MAX _MAX_PATH + #endif + ++#if !defined(PATH_MAX) && defined(__GNU__) ++#define PATH_MAX (4096) ++#endif ++ + #define MODULE_PREFIX "pipe_" + + static int (*backends[])(struct pipe_loader_device **, int) = { +diff --git a/src/util/tests/cache_test.cpp b/src/util/tests/cache_test.cpp +index f181178..0e94303 100644 --- a/src/util/tests/cache_test.cpp +++ b/src/util/tests/cache_test.cpp -@@ -84,8 +84,8 @@ check_directories_created(void *mem_ctx, +@@ -88,8 +88,8 @@ check_directories_created(void *mem_ctx, const char *cache_dir) { bool sub_dirs_created = false; @@ -11,6 +38,8 @@ char *full_path = ralloc_asprintf(mem_ctx, "%s%s", buf, ++cache_dir); struct stat sb; if (stat(full_path, &sb) != -1 && S_ISDIR(sb.st_mode)) +diff --git a/src/util/tests/process_test.c b/src/util/tests/process_test.c +index dd4e7bf..0e937e2 100644 --- a/src/util/tests/process_test.c +++ b/src/util/tests/process_test.c @@ -36,6 +36,10 @@ @@ -24,16 +53,3 @@ static bool error = false; static void ---- a/src/gallium/auxiliary/pipe-loader/pipe_loader.c -+++ b/src/gallium/auxiliary/pipe-loader/pipe_loader.c -@@ -42,6 +42,10 @@ - #define PATH_MAX _MAX_PATH - #endif - -+#if !defined(PATH_MAX) && defined(__GNU__) -+#define PATH_MAX (4096) -+#endif -+ - #define MODULE_PREFIX "pipe_" - - static int (*backends[])(struct pipe_loader_device **, int) = { diff --git a/debian/patches/series b/debian/patches/series index 652f214b9a25..70e099e3203b 100644 --- a/debian/patches/series +++ b/debian/patches/series @@ -5,3 +5,4 @@ etnaviv-add-support-for-texelfetch.patch Revert-hasvk-elk-stop-turning-load_push_constants-in.patch kopper-Revert-kopper-Explicitly-choose-zink.patch pan-genxml-Add-missing-parenthesis-on-pan_cast_and_p.patch +0008-Add-experimental-KGSL-support.patch diff --git a/debian/patches/src_glx_dri_common.h.diff b/debian/patches/src_glx_dri_common.h.diff index f62a6e07e160..7835504b2e60 100644 --- a/debian/patches/src_glx_dri_common.h.diff +++ b/debian/patches/src_glx_dri_common.h.diff @@ -1,6 +1,16 @@ +From: Debian X Strike Force +Date: Wed, 26 Nov 2025 20:56:04 +0800 +Subject: src_glx_dri_common.h + +--- + src/glx/dri_common.h | 4 ++++ + 1 file changed, 4 insertions(+) + +diff --git a/src/glx/dri_common.h b/src/glx/dri_common.h +index ff7fce9..e26f247 100644 --- a/src/glx/dri_common.h +++ b/src/glx/dri_common.h -@@ -56,6 +56,10 @@ extern struct glx_config *driConvertConf +@@ -56,6 +56,10 @@ extern struct glx_config *driConvertConfigs(struct glx_config * modes, extern void driDestroyConfigs(const struct dri_config **configs); From c3c7f13102eab9fd2da2614dbda608f39ff78c17 Mon Sep 17 00:00:00 2001 From: lfdevs <109842948+lfdevs@users.noreply.github.com> Date: Tue, 2 Dec 2025 15:22:33 +0800 Subject: [PATCH 3/6] Fix build errors --- debian/patches/0009-Fix-build-errors.patch | 24 ++++++++++++++++++++++ debian/patches/series | 1 + 2 files changed, 25 insertions(+) create mode 100644 debian/patches/0009-Fix-build-errors.patch diff --git a/debian/patches/0009-Fix-build-errors.patch b/debian/patches/0009-Fix-build-errors.patch new file mode 100644 index 000000000000..88c22f782835 --- /dev/null +++ b/debian/patches/0009-Fix-build-errors.patch @@ -0,0 +1,24 @@ +From: lfdevs <109842948+lfdevs@users.noreply.github.com> +Date: Tue, 2 Dec 2025 00:30:06 +0800 +Subject: Fix build errors + +--- + src/freedreno/vulkan/msm_kgsl.h | 5 +++++ + 1 file changed, 5 insertions(+) + +diff --git a/src/freedreno/vulkan/msm_kgsl.h b/src/freedreno/vulkan/msm_kgsl.h +index 361d3b7..3247907 100644 +--- a/src/freedreno/vulkan/msm_kgsl.h ++++ b/src/freedreno/vulkan/msm_kgsl.h +@@ -544,6 +544,11 @@ struct kgsl_cmdbatch_profiling_buffer { + /* ioctls */ + #define KGSL_IOC_TYPE 0x09 + ++/* user space structures */ ++#ifndef __user ++#define __user ++#endif ++ + /* + * get misc info about the GPU + * type should be a value from enum kgsl_property_type diff --git a/debian/patches/series b/debian/patches/series index 70e099e3203b..73927a1fb3a3 100644 --- a/debian/patches/series +++ b/debian/patches/series @@ -6,3 +6,4 @@ Revert-hasvk-elk-stop-turning-load_push_constants-in.patch kopper-Revert-kopper-Explicitly-choose-zink.patch pan-genxml-Add-missing-parenthesis-on-pan_cast_and_p.patch 0008-Add-experimental-KGSL-support.patch +0009-Fix-build-errors.patch From 39c9e97900b80c62f89ffa6c1def0f226a429ab0 Mon Sep 17 00:00:00 2001 From: lfdevs <109842948+lfdevs@users.noreply.github.com> Date: Tue, 2 Dec 2025 15:23:17 +0800 Subject: [PATCH 4/6] Modify meson build options --- .github/workflows/macos.yml | 60 ------------------------------------- debian/rules | 30 +++++++++++++++---- 2 files changed, 24 insertions(+), 66 deletions(-) delete mode 100644 .github/workflows/macos.yml diff --git a/.github/workflows/macos.yml b/.github/workflows/macos.yml deleted file mode 100644 index d1b66ef4cadd..000000000000 --- a/.github/workflows/macos.yml +++ /dev/null @@ -1,60 +0,0 @@ -name: macOS-CI -on: push - -permissions: - contents: read - -jobs: - macOS-CI: - strategy: - matrix: - glx_option: ['dri', 'xlib'] - runs-on: macos-11 - env: - GALLIUM_DUMP_CPU: true - MESON_EXEC: /Users/runner/Library/Python/3.11/bin/meson - steps: - - name: Checkout - uses: actions/checkout@v3 - - name: Install Dependencies - run: | - cat > Brewfile < native_config < Date: Wed, 3 Dec 2025 22:54:15 +0800 Subject: [PATCH 5/6] Ignore un-built files --- debian/control | 72 -------------------- debian/control.in | 72 -------------------- debian/libd3dadapter9-mesa-dev.install | 5 -- debian/libd3dadapter9-mesa.install | 1 - debian/mesa-drm-shim.install | 1 - debian/mesa-drm-shim.lintian-overrides | 4 -- debian/mesa-drm-shim.triggers | 1 - debian/mesa-opencl-icd.install | 3 - debian/mesa-opencl-icd.lintian-overrides | 4 -- debian/mesa-teflon-delegate.install | 1 - debian/mesa-vulkan-drivers.install | 10 +-- debian/mesa-vulkan-drivers.lintian-overrides | 16 +---- debian/not-installed | 1 + debian/rules | 3 + 14 files changed, 12 insertions(+), 182 deletions(-) delete mode 100644 debian/libd3dadapter9-mesa-dev.install delete mode 100644 debian/libd3dadapter9-mesa.install delete mode 100644 debian/mesa-drm-shim.install delete mode 100644 debian/mesa-drm-shim.lintian-overrides delete mode 100644 debian/mesa-drm-shim.triggers delete mode 100644 debian/mesa-opencl-icd.install delete mode 100644 debian/mesa-opencl-icd.lintian-overrides delete mode 100644 debian/mesa-teflon-delegate.install create mode 100644 debian/not-installed diff --git a/debian/control b/debian/control index 62831c7d3841..291c92ccc702 100644 --- a/debian/control +++ b/debian/control @@ -101,36 +101,6 @@ Description: X acceleration library -- development files This package provides the development environment for compiling programs against the xatracker library. -Package: libd3dadapter9-mesa -Section: libs -Architecture: amd64 arm64 armel armhf i386 -Depends: - ${shlibs:Depends}, - ${misc:Depends}, - libudev1 [linux-any], -Pre-Depends: ${misc:Pre-Depends} -Multi-Arch: same -Description: state-tracker for Direct3D9 - This package contains a Gallium3D state tracker that implements the Direct3D9 - API. Combined with the gallium-nine branch of Wine, programs using D3D9 can - achieve native (or better) graphics performance. - -Package: libd3dadapter9-mesa-dev -Section: libdevel -Architecture: amd64 arm64 armel armhf i386 -Depends: - libd3dadapter9-mesa (= ${binary:Version}), - libudev1 [linux-any], - ${misc:Depends}, -Pre-Depends: ${misc:Pre-Depends} -Multi-Arch: same -Description: state-tracker for Direct3D9 -- development files - This package contains a Gallium3D state tracker that implements the Direct3D9 - API. Combined with the gallium-nine branch of Wine, programs using D3D9 can - achieve native (or better) graphics performance. - . - Development files - Package: libgbm1 Section: libs Architecture: linux-any @@ -333,19 +303,6 @@ Description: Mesa Off-screen rendering extension -- development files . For more information on OSmesa see the libosmesa6 package. -Package: mesa-teflon-delegate -Section: libs -Architecture: arm64 -Depends: - ${shlibs:Depends}, - ${misc:Depends}, -Pre-Depends: ${misc:Pre-Depends} -Multi-Arch: same -Description: Mesa TensorFlow Lite external delegate - TensorFlow Lite delegate which can make use of NPUs to accelerate ML - inference. It is implemented in the form of a external delegate, a shared - library which the TensorFlow Lite runtime can load at startup. - Package: mesa-va-drivers Section: libs Architecture: linux-any @@ -403,33 +360,4 @@ Description: Mesa Vulkan graphics drivers Vulkan is a low-overhead 3D graphics and compute API. This package includes Vulkan drivers provided by the Mesa project. -Package: mesa-opencl-icd -Section: libs -Architecture: amd64 arm64 armel armhf i386 loong64 mips64el powerpc ppc64 ppc64el riscv64 s390x sparc64 x32 -Pre-Depends: ${misc:Pre-Depends} -Depends: - libclc-19, - ocl-icd-libopencl1 | libopencl1, - ${shlibs:Depends}, - ${misc:Depends}, -Provides: opencl-icd -Multi-Arch: same -Description: free implementation of the OpenCL API -- ICD runtime - This package contains the mesa implementation of the OpenCL (Open Compute - Language) library, which is intended for use with an ICD loader. OpenCL - provides a standardized interface for computational analysis on graphical - processing units. - -Package: mesa-drm-shim -Section: libs -Architecture: amd64 arm64 armel armhf i386 mips64el powerpc ppc64 ppc64el s390x sparc64 -Pre-Depends: ${misc:Pre-Depends} -Depends: - ${shlibs:Depends}, - ${misc:Depends}, -Multi-Arch: same -Description: DRM shim libraries - This package provides drm-shim libraries which can be used for testing DRM - drivers when none exists on the host. - # vim: tw=0 diff --git a/debian/control.in b/debian/control.in index 4ec4bbcdd5cd..eaa8a213a6d4 100644 --- a/debian/control.in +++ b/debian/control.in @@ -101,36 +101,6 @@ Description: X acceleration library -- development files This package provides the development environment for compiling programs against the xatracker library. -Package: libd3dadapter9-mesa -Section: libs -Architecture: @WINE_ARCHS@ -Depends: - ${shlibs:Depends}, - ${misc:Depends}, - libudev1 [linux-any], -Pre-Depends: ${misc:Pre-Depends} -Multi-Arch: same -Description: state-tracker for Direct3D9 - This package contains a Gallium3D state tracker that implements the Direct3D9 - API. Combined with the gallium-nine branch of Wine, programs using D3D9 can - achieve native (or better) graphics performance. - -Package: libd3dadapter9-mesa-dev -Section: libdevel -Architecture: @WINE_ARCHS@ -Depends: - libd3dadapter9-mesa (= ${binary:Version}), - libudev1 [linux-any], - ${misc:Depends}, -Pre-Depends: ${misc:Pre-Depends} -Multi-Arch: same -Description: state-tracker for Direct3D9 -- development files - This package contains a Gallium3D state tracker that implements the Direct3D9 - API. Combined with the gallium-nine branch of Wine, programs using D3D9 can - achieve native (or better) graphics performance. - . - Development files - Package: libgbm1 Section: libs Architecture: linux-any @@ -333,19 +303,6 @@ Description: Mesa Off-screen rendering extension -- development files . For more information on OSmesa see the libosmesa6 package. -Package: mesa-teflon-delegate -Section: libs -Architecture: arm64 -Depends: - ${shlibs:Depends}, - ${misc:Depends}, -Pre-Depends: ${misc:Pre-Depends} -Multi-Arch: same -Description: Mesa TensorFlow Lite external delegate - TensorFlow Lite delegate which can make use of NPUs to accelerate ML - inference. It is implemented in the form of a external delegate, a shared - library which the TensorFlow Lite runtime can load at startup. - Package: mesa-va-drivers Section: libs Architecture: linux-any @@ -403,33 +360,4 @@ Description: Mesa Vulkan graphics drivers Vulkan is a low-overhead 3D graphics and compute API. This package includes Vulkan drivers provided by the Mesa project. -Package: mesa-opencl-icd -Section: libs -Architecture: @LLVM_ARCHS@ -Pre-Depends: ${misc:Pre-Depends} -Depends: - libclc-@LLVM_VERSION@, - ocl-icd-libopencl1 | libopencl1, - ${shlibs:Depends}, - ${misc:Depends}, -Provides: opencl-icd -Multi-Arch: same -Description: free implementation of the OpenCL API -- ICD runtime - This package contains the mesa implementation of the OpenCL (Open Compute - Language) library, which is intended for use with an ICD loader. OpenCL - provides a standardized interface for computational analysis on graphical - processing units. - -Package: mesa-drm-shim -Section: libs -Architecture: amd64 arm64 armel armhf i386 mips64el powerpc ppc64 ppc64el s390x sparc64 -Pre-Depends: ${misc:Pre-Depends} -Depends: - ${shlibs:Depends}, - ${misc:Depends}, -Multi-Arch: same -Description: DRM shim libraries - This package provides drm-shim libraries which can be used for testing DRM - drivers when none exists on the host. - # vim: tw=0 diff --git a/debian/libd3dadapter9-mesa-dev.install b/debian/libd3dadapter9-mesa-dev.install deleted file mode 100644 index 174eb60429be..000000000000 --- a/debian/libd3dadapter9-mesa-dev.install +++ /dev/null @@ -1,5 +0,0 @@ -usr/lib/*/pkgconfig/d3d.pc -usr/include/d3dadapter/d3dadapter9.h -usr/include/d3dadapter/drm.h -usr/include/d3dadapter/present.h - diff --git a/debian/libd3dadapter9-mesa.install b/debian/libd3dadapter9-mesa.install deleted file mode 100644 index 24b62ee27d5d..000000000000 --- a/debian/libd3dadapter9-mesa.install +++ /dev/null @@ -1 +0,0 @@ -usr/lib/*/d3d/d3dadapter9.so* diff --git a/debian/mesa-drm-shim.install b/debian/mesa-drm-shim.install deleted file mode 100644 index 1d3aa880b71b..000000000000 --- a/debian/mesa-drm-shim.install +++ /dev/null @@ -1 +0,0 @@ -usr/lib/*/lib*_drm_shim.so diff --git a/debian/mesa-drm-shim.lintian-overrides b/debian/mesa-drm-shim.lintian-overrides deleted file mode 100644 index 1c65a5fa07a8..000000000000 --- a/debian/mesa-drm-shim.lintian-overrides +++ /dev/null @@ -1,4 +0,0 @@ -package-name-doesnt-match-sonames libamdgpu-noop-drm-shim libnouveau-noop-drm-shim libradeon-noop-drm-shim -shared-library-lacks-version usr/lib/x86_64-linux-gnu/libamdgpu_noop_drm_shim.so libamdgpu_noop_drm_shim.so -shared-library-lacks-version usr/lib/x86_64-linux-gnu/libnouveau_noop_drm_shim.so libnouveau_noop_drm_shim.so -shared-library-lacks-version usr/lib/x86_64-linux-gnu/libradeon_noop_drm_shim.so libradeon_noop_drm_shim.so diff --git a/debian/mesa-drm-shim.triggers b/debian/mesa-drm-shim.triggers deleted file mode 100644 index dd8660367847..000000000000 --- a/debian/mesa-drm-shim.triggers +++ /dev/null @@ -1 +0,0 @@ -activate-noawait ldconfig diff --git a/debian/mesa-opencl-icd.install b/debian/mesa-opencl-icd.install deleted file mode 100644 index 07846386975a..000000000000 --- a/debian/mesa-opencl-icd.install +++ /dev/null @@ -1,3 +0,0 @@ -etc/OpenCL/vendors/mesa.icd -usr/lib/*/gallium-pipe/*.so -usr/lib/*/libMesaOpenCL* diff --git a/debian/mesa-opencl-icd.lintian-overrides b/debian/mesa-opencl-icd.lintian-overrides deleted file mode 100644 index 71ed4bc28b0f..000000000000 --- a/debian/mesa-opencl-icd.lintian-overrides +++ /dev/null @@ -1,4 +0,0 @@ -link-to-shared-library-in-wrong-package usr/lib/*/libMesaOpenCL.so.1.0.0 [usr/lib/*/libMesaOpenCL.so] -link-to-shared-library-in-wrong-package usr/lib/*/libRusticlOpenCL.so.1.0.0 [usr/lib/*/libRusticlOpenCL.so] -package-name-doesnt-match-sonames libMesaOpenCL1 libRusticlOpenCL1 -shared-library-lacks-prerequisites [usr/lib/x86_64-linux-gnu/gallium-pipe/pipe_i915.so] diff --git a/debian/mesa-teflon-delegate.install b/debian/mesa-teflon-delegate.install deleted file mode 100644 index 9849c16a0b2f..000000000000 --- a/debian/mesa-teflon-delegate.install +++ /dev/null @@ -1 +0,0 @@ -usr/lib/*/libteflon.so usr/lib/teflon diff --git a/debian/mesa-vulkan-drivers.install b/debian/mesa-vulkan-drivers.install index 12f72b2ebb26..d5624bb9ec67 100644 --- a/debian/mesa-vulkan-drivers.install +++ b/debian/mesa-vulkan-drivers.install @@ -1,7 +1,7 @@ -usr/bin/mesa-overlay-control.py -usr/share/drirc.d/00-radv-defaults.conf -usr/share/vulkan/explicit_layer.d/*.json +# usr/bin/mesa-overlay-control.py +# usr/share/drirc.d/00-radv-defaults.conf +# usr/share/vulkan/explicit_layer.d/*.json usr/share/vulkan/icd.d/*.json -usr/share/vulkan/implicit_layer.d/*.json +# usr/share/vulkan/implicit_layer.d/*.json usr/lib/*/libvulkan_*.so -usr/lib/*/libVkLayer_*.so +# usr/lib/*/libVkLayer_*.so diff --git a/debian/mesa-vulkan-drivers.lintian-overrides b/debian/mesa-vulkan-drivers.lintian-overrides index dc5606630f42..b06632fd4986 100644 --- a/debian/mesa-vulkan-drivers.lintian-overrides +++ b/debian/mesa-vulkan-drivers.lintian-overrides @@ -1,13 +1,3 @@ -no-manual-page [usr/bin/mesa-overlay-control.py] -package-name-doesnt-match-sonames libVkLayer-INTEL-nullhw libVkLayer-MESA-device-select libVkLayer-MESA-overlay libvulkan-intel libvulkan-intel-hasvk libvulkan-lvp libvulkan-nouveau libvulkan-radeon libvulkan-virtio -script-with-language-extension [usr/bin/mesa-overlay-control.py] -python3-script-but-no-python3-dep python3 (does not satisfy python3:any | python3-minimal:any) [usr/bin/mesa-overlay-control.py] -shared-library-lacks-version usr/lib/x86_64-linux-gnu/libVkLayer_INTEL_nullhw.so libVkLayer_INTEL_nullhw.so -shared-library-lacks-version usr/lib/x86_64-linux-gnu/libVkLayer_MESA_device_select.so libVkLayer_MESA_device_select.so -shared-library-lacks-version usr/lib/x86_64-linux-gnu/libVkLayer_MESA_overlay.so libVkLayer_MESA_overlay.so -shared-library-lacks-version usr/lib/x86_64-linux-gnu/libvulkan_intel_hasvk.so libvulkan_intel_hasvk.so -shared-library-lacks-version usr/lib/x86_64-linux-gnu/libvulkan_lvp.so libvulkan_lvp.so -shared-library-lacks-version usr/lib/x86_64-linux-gnu/libvulkan_nouveau.so libvulkan_nouveau.so -shared-library-lacks-version usr/lib/x86_64-linux-gnu/libvulkan_virtio.so libvulkan_virtio.so -shlib-without-versioned-soname usr/lib/*/libvulkan_intel.so libvulkan_intel.so -shlib-without-versioned-soname usr/lib/*/libvulkan_radeon.so libvulkan_radeon.so +package-name-doesnt-match-sonames libvulkan-freedreno +shared-library-lacks-version usr/lib/aarch64-linux-gnu/libvulkan_freedreno.so libvulkan_freedreno.so +shlib-without-versioned-soname usr/lib/*/libvulkan_freedreno.so libvulkan_freedreno.so \ No newline at end of file diff --git a/debian/not-installed b/debian/not-installed new file mode 100644 index 000000000000..4b5604532c85 --- /dev/null +++ b/debian/not-installed @@ -0,0 +1 @@ +usr/lib/${DEB_HOST_MULTIARCH}/gallium-pipe/pipe_*.so \ No newline at end of file diff --git a/debian/rules b/debian/rules index 7a7611ca22eb..c8466bde79e9 100755 --- a/debian/rules +++ b/debian/rules @@ -317,6 +317,9 @@ override_dh_install: install -m 755 debian/local/script debian/$$p/usr/share/bug/$$p; \ done +override_dh_shlibdeps: + dh_shlibdeps -- --ignore-missing-info + override_dh_makeshlibs: dh_makeshlibs -a -- -c4 From c832def73227d86ea55f1ef4f642b1bb26f82ffe Mon Sep 17 00:00:00 2001 From: Anmol Singh <162159622+Anmol6002@users.noreply.github.com> Date: Sun, 21 Jun 2026 16:32:27 +0530 Subject: [PATCH 6/6] Update added GPUId(613) to this GPUId(605), GPUId(608), GPUId(610), GPUId(612)freedreno_devices.py --- src/freedreno/common/freedreno_devices.py | 1 + 1 file changed, 1 insertion(+) diff --git a/src/freedreno/common/freedreno_devices.py b/src/freedreno/common/freedreno_devices.py index db779ff40dae..c34aa84b960f 100644 --- a/src/freedreno/common/freedreno_devices.py +++ b/src/freedreno/common/freedreno_devices.py @@ -447,6 +447,7 @@ def apply_props(self, gpu_info): GPUId(608), # TODO: Test it, based only on libwrapfake dumps GPUId(610), GPUId(612), # TODO: Test it, based only on libwrapfake dumps + GPUId(613) ], A6xxGPUInfo( CHIP.A6XX, [a6xx_base, a6xx_gen1_low],