Source-Changes-HG archive

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index][Old Index]

[xsrc/trunk]: xsrc/external/mit merge xterm 368 and libdrm 2.4.107.



details:   https://anonhg.NetBSD.org/xsrc/rev/126d7703ff84
branches:  trunk
changeset: 10758:126d7703ff84
user:      mrg <mrg%NetBSD.org@localhost>
date:      Sun Jul 11 00:31:53 2021 +0000

description:
merge xterm 368 and libdrm 2.4.107.

diffstat:

 external/mit/libdrm/dist/amdgpu/amdgpu_vamgr.c     |  137 ++++--
 external/mit/libdrm/dist/intel/.gitignore          |    1 -
 external/mit/libdrm/dist/intel/tests/.gitignore    |    1 -
 external/mit/libdrm/dist/tegra/.gitignore          |    1 -
 external/mit/libdrm/dist/tests/modetest/modetest.c |   75 +--
 external/mit/libdrm/dist/tests/nouveau/.gitignore  |    1 -
 external/mit/libdrm/dist/tests/tegra/.gitignore    |    1 -
 external/mit/libdrm/dist/xf86drm.c                 |  421 +++++++++++++++++++++
 external/mit/libdrm/dist/xf86drm.h                 |   11 +
 external/mit/libdrm/dist/xf86drmMode.c             |    7 +-
 external/mit/xterm/dist/fontutils.c                |    2 +-
 external/mit/xterm/dist/misc.c                     |  356 +++++++++++++++++-
 external/mit/xterm/dist/ptyx.h                     |    4 +-
 external/mit/xterm/dist/xterm.h                    |    6 +-
 external/mit/xterm/dist/xterm.man                  |   21 +-
 15 files changed, 932 insertions(+), 113 deletions(-)

diffs (truncated from 1337 to 300 lines):

diff -r 433277d12bf6 -r 126d7703ff84 external/mit/libdrm/dist/amdgpu/amdgpu_vamgr.c
--- a/external/mit/libdrm/dist/amdgpu/amdgpu_vamgr.c    Sun Jul 11 00:27:23 2021 +0000
+++ b/external/mit/libdrm/dist/amdgpu/amdgpu_vamgr.c    Sun Jul 11 00:31:53 2021 +0000
@@ -69,65 +69,99 @@
        pthread_mutex_destroy(&mgr->bo_va_mutex);
 }
 
-static uint64_t
+static drm_private int
+amdgpu_vamgr_subtract_hole(struct amdgpu_bo_va_hole *hole, uint64_t start_va,
+                          uint64_t end_va)
+{
+       if (start_va > hole->offset && end_va - hole->offset < hole->size) {
+               struct amdgpu_bo_va_hole *n = calloc(1, sizeof(struct amdgpu_bo_va_hole));
+               if (!n)
+                       return -ENOMEM;
+
+               n->size = start_va - hole->offset;
+               n->offset = hole->offset;
+               list_add(&n->list, &hole->list);
+
+               hole->size -= (end_va - hole->offset);
+               hole->offset = end_va;
+       } else if (start_va > hole->offset) {
+               hole->size = start_va - hole->offset;
+       } else if (end_va - hole->offset < hole->size) {
+               hole->size -= (end_va - hole->offset);
+               hole->offset = end_va;
+       } else {
+               list_del(&hole->list);
+               free(hole);
+       }
+
+       return 0;
+}
+
+static drm_private int
 amdgpu_vamgr_find_va(struct amdgpu_bo_va_mgr *mgr, uint64_t size,
-                    uint64_t alignment, uint64_t base_required)
+                    uint64_t alignment, uint64_t base_required,
+                    bool search_from_top, uint64_t *va_out)
 {
        struct amdgpu_bo_va_hole *hole, *n;
-       uint64_t offset = 0, waste = 0;
+       uint64_t offset = 0;
+       int ret;
 
 
        alignment = MAX2(alignment, mgr->va_alignment);
        size = ALIGN(size, mgr->va_alignment);
 
        if (base_required % alignment)
-               return AMDGPU_INVALID_VA_ADDRESS;
+               return -EINVAL;
 
        pthread_mutex_lock(&mgr->bo_va_mutex);
-       LIST_FOR_EACH_ENTRY_SAFE_REV(hole, n, &mgr->va_holes, list) {
-               if (base_required) {
-                       if (hole->offset > base_required ||
-                           (hole->offset + hole->size) < (base_required + size))
-                               continue;
-                       waste = base_required - hole->offset;
-                       offset = base_required;
-               } else {
-                       offset = hole->offset;
-                       waste = offset % alignment;
-                       waste = waste ? alignment - waste : 0;
-                       offset += waste;
-                       if (offset >= (hole->offset + hole->size)) {
-                               continue;
+       if (!search_from_top) {
+               LIST_FOR_EACH_ENTRY_SAFE_REV(hole, n, &mgr->va_holes, list) {
+                       if (base_required) {
+                               if (hole->offset > base_required ||
+                                  (hole->offset + hole->size) < (base_required + size))
+                                       continue;
+                               offset = base_required;
+                       } else {
+                               uint64_t waste = hole->offset % alignment;
+                               waste = waste ? alignment - waste : 0;
+                               offset = hole->offset + waste;
+                               if (offset >= (hole->offset + hole->size) ||
+                                   size > (hole->offset + hole->size) - offset) {
+                                       continue;
+                               }
                        }
+                       ret = amdgpu_vamgr_subtract_hole(hole, offset, offset + size);
+                       pthread_mutex_unlock(&mgr->bo_va_mutex);
+                       *va_out = offset;
+                       return ret;
                }
-               if (!waste && hole->size == size) {
-                       offset = hole->offset;
-                       list_del(&hole->list);
-                       free(hole);
+       } else {
+               LIST_FOR_EACH_ENTRY_SAFE(hole, n, &mgr->va_holes, list) {
+                       if (base_required) {
+                               if (hole->offset > base_required ||
+                                  (hole->offset + hole->size) < (base_required + size))
+                                       continue;
+                               offset = base_required;
+                       } else {
+                               if (size > hole->size)
+                                       continue;
+
+                               offset = hole->offset + hole->size - size;
+                               offset -= offset % alignment;
+                               if (offset < hole->offset) {
+                                       continue;
+                               }
+                       }
+
+                       ret = amdgpu_vamgr_subtract_hole(hole, offset, offset + size);
                        pthread_mutex_unlock(&mgr->bo_va_mutex);
-                       return offset;
-               }
-               if ((hole->size - waste) > size) {
-                       if (waste) {
-                               n = calloc(1, sizeof(struct amdgpu_bo_va_hole));
-                               n->size = waste;
-                               n->offset = hole->offset;
-                               list_add(&n->list, &hole->list);
-                       }
-                       hole->size -= (size + waste);
-                       hole->offset += size + waste;
-                       pthread_mutex_unlock(&mgr->bo_va_mutex);
-                       return offset;
-               }
-               if ((hole->size - waste) == size) {
-                       hole->size = waste;
-                       pthread_mutex_unlock(&mgr->bo_va_mutex);
-                       return offset;
+                       *va_out = offset;
+                       return ret;
                }
        }
 
        pthread_mutex_unlock(&mgr->bo_va_mutex);
-       return AMDGPU_INVALID_VA_ADDRESS;
+       return -ENOMEM;
 }
 
 static void
@@ -196,6 +230,8 @@
                                     uint64_t flags)
 {
        struct amdgpu_bo_va_mgr *vamgr;
+       bool search_from_top = !!(flags & AMDGPU_VA_RANGE_REPLAYABLE);
+       int ret;
 
        /* Clear the flag when the high VA manager is not initialized */
        if (flags & AMDGPU_VA_RANGE_HIGH && !dev->vamgr_high_32.va_max)
@@ -216,21 +252,22 @@
        va_base_alignment = MAX2(va_base_alignment, vamgr->va_alignment);
        size = ALIGN(size, vamgr->va_alignment);
 
-       *va_base_allocated = amdgpu_vamgr_find_va(vamgr, size,
-                                       va_base_alignment, va_base_required);
+       ret = amdgpu_vamgr_find_va(vamgr, size,
+                                  va_base_alignment, va_base_required,
+                                  search_from_top, va_base_allocated);
 
-       if (!(flags & AMDGPU_VA_RANGE_32_BIT) &&
-           (*va_base_allocated == AMDGPU_INVALID_VA_ADDRESS)) {
+       if (!(flags & AMDGPU_VA_RANGE_32_BIT) && ret) {
                /* fallback to 32bit address */
                if (flags & AMDGPU_VA_RANGE_HIGH)
                        vamgr = &dev->vamgr_high_32;
                else
                        vamgr = &dev->vamgr_32;
-               *va_base_allocated = amdgpu_vamgr_find_va(vamgr, size,
-                                       va_base_alignment, va_base_required);
+               ret = amdgpu_vamgr_find_va(vamgr, size,
+                                          va_base_alignment, va_base_required,
+                                          search_from_top, va_base_allocated);
        }
 
-       if (*va_base_allocated != AMDGPU_INVALID_VA_ADDRESS) {
+       if (!ret) {
                struct amdgpu_va* va;
                va = calloc(1, sizeof(struct amdgpu_va));
                if(!va){
@@ -243,11 +280,9 @@
                va->range = va_range_type;
                va->vamgr = vamgr;
                *va_range_handle = va;
-       } else {
-               return -EINVAL;
        }
 
-       return 0;
+       return ret;
 }
 
 drm_public int amdgpu_va_range_free(amdgpu_va_handle va_range_handle)
diff -r 433277d12bf6 -r 126d7703ff84 external/mit/libdrm/dist/intel/.gitignore
--- a/external/mit/libdrm/dist/intel/.gitignore Sun Jul 11 00:27:23 2021 +0000
+++ /dev/null   Thu Jan 01 00:00:00 1970 +0000
@@ -1,1 +0,0 @@
-test_decode
diff -r 433277d12bf6 -r 126d7703ff84 external/mit/libdrm/dist/intel/tests/.gitignore
--- a/external/mit/libdrm/dist/intel/tests/.gitignore   Sun Jul 11 00:27:23 2021 +0000
+++ /dev/null   Thu Jan 01 00:00:00 1970 +0000
@@ -1,1 +0,0 @@
-*-new.txt
diff -r 433277d12bf6 -r 126d7703ff84 external/mit/libdrm/dist/tegra/.gitignore
--- a/external/mit/libdrm/dist/tegra/.gitignore Sun Jul 11 00:27:23 2021 +0000
+++ /dev/null   Thu Jan 01 00:00:00 1970 +0000
@@ -1,1 +0,0 @@
-libdrm_tegra.pc
diff -r 433277d12bf6 -r 126d7703ff84 external/mit/libdrm/dist/tests/modetest/modetest.c
--- a/external/mit/libdrm/dist/tests/modetest/modetest.c        Sun Jul 11 00:27:23 2021 +0000
+++ b/external/mit/libdrm/dist/tests/modetest/modetest.c        Sun Jul 11 00:31:53 2021 +0000
@@ -265,52 +265,37 @@
 
 static const char *modifier_to_string(uint64_t modifier)
 {
-       switch (modifier) {
-       case DRM_FORMAT_MOD_INVALID:
-               return "INVALID";
-       case DRM_FORMAT_MOD_LINEAR:
-               return "LINEAR";
-       case I915_FORMAT_MOD_X_TILED:
-               return "X_TILED";
-       case I915_FORMAT_MOD_Y_TILED:
-               return "Y_TILED";
-       case I915_FORMAT_MOD_Yf_TILED:
-               return "Yf_TILED";
-       case I915_FORMAT_MOD_Y_TILED_CCS:
-               return "Y_TILED_CCS";
-       case I915_FORMAT_MOD_Yf_TILED_CCS:
-               return "Yf_TILED_CCS";
-       case DRM_FORMAT_MOD_SAMSUNG_64_32_TILE:
-               return "SAMSUNG_64_32_TILE";
-       case DRM_FORMAT_MOD_VIVANTE_TILED:
-               return "VIVANTE_TILED";
-       case DRM_FORMAT_MOD_VIVANTE_SUPER_TILED:
-               return "VIVANTE_SUPER_TILED";
-       case DRM_FORMAT_MOD_VIVANTE_SPLIT_TILED:
-               return "VIVANTE_SPLIT_TILED";
-       case DRM_FORMAT_MOD_VIVANTE_SPLIT_SUPER_TILED:
-               return "VIVANTE_SPLIT_SUPER_TILED";
-       case DRM_FORMAT_MOD_NVIDIA_TEGRA_TILED:
-               return "NVIDIA_TEGRA_TILED";
-       case DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK(0):
-               return "NVIDIA_16BX2_BLOCK(0)";
-       case DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK(1):
-               return "NVIDIA_16BX2_BLOCK(1)";
-       case DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK(2):
-               return "NVIDIA_16BX2_BLOCK(2)";
-       case DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK(3):
-               return "NVIDIA_16BX2_BLOCK(3)";
-       case DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK(4):
-               return "NVIDIA_16BX2_BLOCK(4)";
-       case DRM_FORMAT_MOD_NVIDIA_16BX2_BLOCK(5):
-               return "NVIDIA_16BX2_BLOCK(5)";
-       case DRM_FORMAT_MOD_BROADCOM_VC4_T_TILED:
-               return "MOD_BROADCOM_VC4_T_TILED";
-       case DRM_FORMAT_MOD_QCOM_COMPRESSED:
-               return "QCOM_COMPRESSED";
-       default:
-               return "(UNKNOWN MODIFIER)";
+       static char mod_string[4096];
+
+       char *modifier_name = drmGetFormatModifierName(modifier);
+       char *vendor_name = drmGetFormatModifierVendor(modifier);
+       memset(mod_string, 0x00, sizeof(mod_string));
+
+       if (!modifier_name) {
+               if (vendor_name)
+                       snprintf(mod_string, sizeof(mod_string), "%s_%s",
+                                vendor_name, "UNKNOWN_MODIFIER");
+               else
+                       snprintf(mod_string, sizeof(mod_string), "%s_%s",
+                                "UNKNOWN_VENDOR", "UNKNOWN_MODIFIER");
+               /* safe, as free is no-op for NULL */
+               free(vendor_name);
+               return mod_string;
        }
+
+       if (modifier == DRM_FORMAT_MOD_LINEAR) {
+               snprintf(mod_string, sizeof(mod_string), "%s", modifier_name);
+               free(modifier_name);
+               free(vendor_name);
+               return mod_string;
+       }
+
+       snprintf(mod_string, sizeof(mod_string), "%s_%s",
+                vendor_name, modifier_name);
+
+       free(modifier_name);
+       free(vendor_name);
+       return mod_string;
 }
 
 static void dump_in_formats(struct device *dev, uint32_t blob_id)
diff -r 433277d12bf6 -r 126d7703ff84 external/mit/libdrm/dist/tests/nouveau/.gitignore
--- a/external/mit/libdrm/dist/tests/nouveau/.gitignore Sun Jul 11 00:27:23 2021 +0000
+++ /dev/null   Thu Jan 01 00:00:00 1970 +0000



Home | Main Index | Thread Index | Old Index