Module Name: xsrc Committed By: mrg Date: Sun Jul 11 00:31:55 UTC 2021
Modified Files: xsrc/external/mit/libdrm/dist: xf86drm.c xf86drm.h xf86drmMode.c xsrc/external/mit/libdrm/dist/amdgpu: amdgpu_vamgr.c xsrc/external/mit/libdrm/dist/tests/modetest: modetest.c xsrc/external/mit/xterm/dist: fontutils.c misc.c ptyx.h xterm.h xterm.man Removed Files: xsrc/external/mit/libdrm/dist/intel: .gitignore xsrc/external/mit/libdrm/dist/intel/tests: .gitignore xsrc/external/mit/libdrm/dist/tegra: .gitignore xsrc/external/mit/libdrm/dist/tests/nouveau: .gitignore xsrc/external/mit/libdrm/dist/tests/tegra: .gitignore Log Message: merge xterm 368 and libdrm 2.4.107. To generate a diff of this commit: cvs rdiff -u -r1.28 -r1.29 xsrc/external/mit/libdrm/dist/xf86drm.c cvs rdiff -u -r1.13 -r1.14 xsrc/external/mit/libdrm/dist/xf86drm.h cvs rdiff -u -r1.17 -r1.18 xsrc/external/mit/libdrm/dist/xf86drmMode.c cvs rdiff -u -r1.2 -r1.3 xsrc/external/mit/libdrm/dist/amdgpu/amdgpu_vamgr.c cvs rdiff -u -r1.1.1.1 -r0 xsrc/external/mit/libdrm/dist/intel/.gitignore cvs rdiff -u -r1.1.1.1 -r0 \ xsrc/external/mit/libdrm/dist/intel/tests/.gitignore cvs rdiff -u -r1.1.1.1 -r0 xsrc/external/mit/libdrm/dist/tegra/.gitignore cvs rdiff -u -r1.15 -r1.16 \ xsrc/external/mit/libdrm/dist/tests/modetest/modetest.c cvs rdiff -u -r1.1.1.1 -r0 \ xsrc/external/mit/libdrm/dist/tests/nouveau/.gitignore cvs rdiff -u -r1.1.1.1 -r0 \ xsrc/external/mit/libdrm/dist/tests/tegra/.gitignore cvs rdiff -u -r1.9 -r1.10 xsrc/external/mit/xterm/dist/fontutils.c cvs rdiff -u -r1.21 -r1.22 xsrc/external/mit/xterm/dist/misc.c cvs rdiff -u -r1.16 -r1.17 xsrc/external/mit/xterm/dist/ptyx.h cvs rdiff -u -r1.4 -r1.5 xsrc/external/mit/xterm/dist/xterm.h cvs rdiff -u -r1.18 -r1.19 xsrc/external/mit/xterm/dist/xterm.man Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.
Modified files: Index: xsrc/external/mit/libdrm/dist/xf86drm.c diff -u xsrc/external/mit/libdrm/dist/xf86drm.c:1.28 xsrc/external/mit/libdrm/dist/xf86drm.c:1.29 --- xsrc/external/mit/libdrm/dist/xf86drm.c:1.28 Tue Apr 27 03:02:37 2021 +++ xsrc/external/mit/libdrm/dist/xf86drm.c Sun Jul 11 00:31:53 2021 @@ -61,6 +61,7 @@ #include <sys/sysctl.h> #endif #include <math.h> +#include <inttypes.h> #if defined(__FreeBSD__) #include <sys/param.h> @@ -76,6 +77,7 @@ #include "xf86drm.h" #include "libdrm_macros.h" +#include "drm_fourcc.h" #include "util_math.h" @@ -128,6 +130,362 @@ static drmServerInfoPtr drm_server_info; static bool drmNodeIsDRM(int maj, int min); static char *drmGetMinorNameForFD(int fd, int type); +#define DRM_MODIFIER(v, f, f_name) \ + .modifier = DRM_FORMAT_MOD_##v ## _ ##f, \ + .modifier_name = #f_name + +#define DRM_MODIFIER_INVALID(v, f_name) \ + .modifier = DRM_FORMAT_MOD_INVALID, .modifier_name = #f_name + +#define DRM_MODIFIER_LINEAR(v, f_name) \ + .modifier = DRM_FORMAT_MOD_LINEAR, .modifier_name = #f_name + +/* Intel is abit special as the format doesn't follow other vendors naming + * scheme */ +#define DRM_MODIFIER_INTEL(f, f_name) \ + .modifier = I915_FORMAT_MOD_##f, .modifier_name = #f_name + +struct drmFormatModifierInfo { + uint64_t modifier; + const char *modifier_name; +}; + +struct drmFormatModifierVendorInfo { + uint8_t vendor; + const char *vendor_name; +}; + +#include "generated_static_table_fourcc.h" + +struct drmVendorInfo { + uint8_t vendor; + char *(*vendor_cb)(uint64_t modifier); +}; + +struct drmFormatVendorModifierInfo { + uint64_t modifier; + const char *modifier_name; +}; + +static char * +drmGetFormatModifierNameFromArm(uint64_t modifier); + +static char * +drmGetFormatModifierNameFromNvidia(uint64_t modifier); + +static char * +drmGetFormatModifierNameFromAmd(uint64_t modifier); + +static char * +drmGetFormatModifierNameFromAmlogic(uint64_t modifier); + +static const struct drmVendorInfo modifier_format_vendor_table[] = { + { DRM_FORMAT_MOD_VENDOR_ARM, drmGetFormatModifierNameFromArm }, + { DRM_FORMAT_MOD_VENDOR_NVIDIA, drmGetFormatModifierNameFromNvidia }, + { DRM_FORMAT_MOD_VENDOR_AMD, drmGetFormatModifierNameFromAmd }, + { DRM_FORMAT_MOD_VENDOR_AMLOGIC, drmGetFormatModifierNameFromAmlogic }, +}; + +#ifndef AFBC_FORMAT_MOD_MODE_VALUE_MASK +#define AFBC_FORMAT_MOD_MODE_VALUE_MASK 0x000fffffffffffffULL +#endif + +static const struct drmFormatVendorModifierInfo arm_mode_value_table[] = { + { AFBC_FORMAT_MOD_YTR, "YTR" }, + { AFBC_FORMAT_MOD_SPLIT, "SPLIT" }, + { AFBC_FORMAT_MOD_SPARSE, "SPARSE" }, + { AFBC_FORMAT_MOD_CBR, "CBR" }, + { AFBC_FORMAT_MOD_TILED, "TILED" }, + { AFBC_FORMAT_MOD_SC, "SC" }, + { AFBC_FORMAT_MOD_DB, "DB" }, + { AFBC_FORMAT_MOD_BCH, "BCH" }, + { AFBC_FORMAT_MOD_USM, "USM" }, +}; + +static bool is_x_t_amd_gfx9_tile(uint64_t tile) +{ + switch (tile) { + case AMD_FMT_MOD_TILE_GFX9_64K_S_X: + case AMD_FMT_MOD_TILE_GFX9_64K_D_X: + case AMD_FMT_MOD_TILE_GFX9_64K_R_X: + return true; + } + + return false; +} + +static char * +drmGetFormatModifierNameFromArm(uint64_t modifier) +{ + uint64_t type = (modifier >> 52) & 0xf; + uint64_t mode_value = modifier & AFBC_FORMAT_MOD_MODE_VALUE_MASK; + uint64_t block_size = mode_value & AFBC_FORMAT_MOD_BLOCK_SIZE_MASK; + + FILE *fp; + char *modifier_name = NULL; + size_t size = 0; + unsigned int i; + + const char *block = NULL; + const char *mode = NULL; + bool did_print_mode = false; + + /* misc type is already handled by the static table */ + if (type != DRM_FORMAT_MOD_ARM_TYPE_AFBC) + return NULL; + + fp = open_memstream(&modifier_name, &size); + if (!fp) + return NULL; + + /* add block, can only have a (single) block */ + switch (block_size) { + case AFBC_FORMAT_MOD_BLOCK_SIZE_16x16: + block = "16x16"; + break; + case AFBC_FORMAT_MOD_BLOCK_SIZE_32x8: + block = "32x8"; + break; + case AFBC_FORMAT_MOD_BLOCK_SIZE_64x4: + block = "64x4"; + break; + case AFBC_FORMAT_MOD_BLOCK_SIZE_32x8_64x4: + block = "32x8_64x4"; + break; + } + + if (!block) { + fclose(fp); + free(modifier_name); + return NULL; + } + + fprintf(fp, "BLOCK_SIZE=%s,", block); + + /* add mode */ + for (i = 0; i < ARRAY_SIZE(arm_mode_value_table); i++) { + if (arm_mode_value_table[i].modifier & mode_value) { + mode = arm_mode_value_table[i].modifier_name; + if (!did_print_mode) { + fprintf(fp, "MODE=%s", mode); + did_print_mode = true; + } else { + fprintf(fp, "|%s", mode); + } + } + } + + fclose(fp); + return modifier_name; +} + +static char * +drmGetFormatModifierNameFromNvidia(uint64_t modifier) +{ + uint64_t height, kind, gen, sector, compression; + + height = modifier & 0xf; + kind = (modifier >> 12) & 0xff; + + gen = (modifier >> 20) & 0x3; + sector = (modifier >> 22) & 0x1; + compression = (modifier >> 23) & 0x7; + + /* just in case there could other simpler modifiers, not yet added, avoid + * testing against TEGRA_TILE */ + if ((modifier & 0x10) == 0x10) { + char *mod_nvidia; + asprintf(&mod_nvidia, "BLOCK_LINEAR_2D,HEIGHT=%"PRIu64",KIND=%"PRIu64"," + "GEN=%"PRIu64",SECTOR=%"PRIu64",COMPRESSION=%"PRIu64"", height, + kind, gen, sector, compression); + return mod_nvidia; + } + + return NULL; +} + +static void +drmGetFormatModifierNameFromAmdDcc(uint64_t modifier, FILE *fp) +{ + uint64_t dcc_max_compressed_block = + AMD_FMT_MOD_GET(DCC_MAX_COMPRESSED_BLOCK, modifier); + uint64_t dcc_retile = AMD_FMT_MOD_GET(DCC_RETILE, modifier); + + const char *dcc_max_compressed_block_str = NULL; + + fprintf(fp, ",DCC"); + + if (dcc_retile) + fprintf(fp, ",DCC_RETILE"); + + if (!dcc_retile && AMD_FMT_MOD_GET(DCC_PIPE_ALIGN, modifier)) + fprintf(fp, ",DCC_PIPE_ALIGN"); + + if (AMD_FMT_MOD_GET(DCC_INDEPENDENT_64B, modifier)) + fprintf(fp, ",DCC_INDEPENDENT_64B"); + + if (AMD_FMT_MOD_GET(DCC_INDEPENDENT_128B, modifier)) + fprintf(fp, ",DCC_INDEPENDENT_128B"); + + switch (dcc_max_compressed_block) { + case AMD_FMT_MOD_DCC_BLOCK_64B: + dcc_max_compressed_block_str = "64B"; + break; + case AMD_FMT_MOD_DCC_BLOCK_128B: + dcc_max_compressed_block_str = "128B"; + break; + case AMD_FMT_MOD_DCC_BLOCK_256B: + dcc_max_compressed_block_str = "256B"; + break; + } + + if (dcc_max_compressed_block_str) + fprintf(fp, ",DCC_MAX_COMPRESSED_BLOCK=%s", + dcc_max_compressed_block_str); + + if (AMD_FMT_MOD_GET(DCC_CONSTANT_ENCODE, modifier)) + fprintf(fp, ",DCC_CONSTANT_ENCODE"); +} + +static void +drmGetFormatModifierNameFromAmdTile(uint64_t modifier, FILE *fp) +{ + uint64_t pipe_xor_bits, bank_xor_bits, packers, rb; + uint64_t pipe, pipe_align, dcc, dcc_retile, tile_version; + + pipe_align = AMD_FMT_MOD_GET(DCC_PIPE_ALIGN, modifier); + pipe_xor_bits = AMD_FMT_MOD_GET(PIPE_XOR_BITS, modifier); + dcc = AMD_FMT_MOD_GET(DCC, modifier); + dcc_retile = AMD_FMT_MOD_GET(DCC_RETILE, modifier); + tile_version = AMD_FMT_MOD_GET(TILE_VERSION, modifier); + + fprintf(fp, ",PIPE_XOR_BITS=%"PRIu64, pipe_xor_bits); + + if (tile_version == AMD_FMT_MOD_TILE_VER_GFX9) { + bank_xor_bits = AMD_FMT_MOD_GET(BANK_XOR_BITS, modifier); + fprintf(fp, ",BANK_XOR_BITS=%"PRIu64, bank_xor_bits); + } + + if (tile_version == AMD_FMT_MOD_TILE_VER_GFX10_RBPLUS) { + packers = AMD_FMT_MOD_GET(PACKERS, modifier); + fprintf(fp, ",PACKERS=%"PRIu64, packers); + } + + if (dcc && tile_version == AMD_FMT_MOD_TILE_VER_GFX9) { + rb = AMD_FMT_MOD_GET(RB, modifier); + fprintf(fp, ",RB=%"PRIu64, rb); + } + + if (dcc && tile_version == AMD_FMT_MOD_TILE_VER_GFX9 && + (dcc_retile || pipe_align)) { + pipe = AMD_FMT_MOD_GET(PIPE, modifier); + fprintf(fp, ",PIPE_%"PRIu64, pipe); + } +} + +static char * +drmGetFormatModifierNameFromAmd(uint64_t modifier) +{ + uint64_t tile, tile_version, dcc; + FILE *fp; + char *mod_amd = NULL; + size_t size = 0; + + const char *str_tile = NULL; + const char *str_tile_version = NULL; + + tile = AMD_FMT_MOD_GET(TILE, modifier); + tile_version = AMD_FMT_MOD_GET(TILE_VERSION, modifier); + dcc = AMD_FMT_MOD_GET(DCC, modifier); + + fp = open_memstream(&mod_amd, &size); + if (!fp) + return NULL; + + /* add tile */ + switch (tile_version) { + case AMD_FMT_MOD_TILE_VER_GFX9: + str_tile_version = "GFX9"; + break; + case AMD_FMT_MOD_TILE_VER_GFX10: + str_tile_version = "GFX10"; + break; + case AMD_FMT_MOD_TILE_VER_GFX10_RBPLUS: + str_tile_version = "GFX10_RBPLUS"; + break; + } + + if (str_tile_version) { + fprintf(fp, "%s", str_tile_version); + } else { + fclose(fp); + free(mod_amd); + return NULL; + } + + /* add tile str */ + switch (tile) { + case AMD_FMT_MOD_TILE_GFX9_64K_S: + str_tile = "GFX9_64K_S"; + break; + case AMD_FMT_MOD_TILE_GFX9_64K_D: + str_tile = "GFX9_64K_D"; + break; + case AMD_FMT_MOD_TILE_GFX9_64K_S_X: + str_tile = "GFX9_64K_S_X"; + break; + case AMD_FMT_MOD_TILE_GFX9_64K_D_X: + str_tile = "GFX9_64K_D_X"; + break; + case AMD_FMT_MOD_TILE_GFX9_64K_R_X: + str_tile = "GFX9_64K_R_X"; + break; + } + + if (str_tile) + fprintf(fp, ",%s", str_tile); + + if (dcc) + drmGetFormatModifierNameFromAmdDcc(modifier, fp); + + if (tile_version >= AMD_FMT_MOD_TILE_VER_GFX9 && is_x_t_amd_gfx9_tile(tile)) + drmGetFormatModifierNameFromAmdTile(modifier, fp); + + fclose(fp); + return mod_amd; +} + +static char * +drmGetFormatModifierNameFromAmlogic(uint64_t modifier) +{ + uint64_t layout = modifier & 0xff; + uint64_t options = (modifier >> 8) & 0xff; + char *mod_amlogic = NULL; + + const char *layout_str; + const char *opts_str; + + switch (layout) { + case AMLOGIC_FBC_LAYOUT_BASIC: + layout_str = "BASIC"; + break; + case AMLOGIC_FBC_LAYOUT_SCATTER: + layout_str = "SCATTER"; + break; + default: + layout_str = "INVALID_LAYOUT"; + break; + } + + if (options & AMLOGIC_FBC_OPTION_MEM_SAVING) + opts_str = "MEM_SAVING"; + else + opts_str = "0"; + + asprintf(&mod_amlogic, "FBC,LAYOUT=%s,OPTIONS=%s", layout_str, opts_str); + return mod_amlogic; +} + static unsigned log2_int(unsigned x) { unsigned l; @@ -4756,3 +5114,66 @@ drm_public int drmSyncobjTransfer(int fd return ret; } + +static char * +drmGetFormatModifierFromSimpleTokens(uint64_t modifier) +{ + unsigned int i; + + for (i = 0; i < ARRAY_SIZE(drm_format_modifier_table); i++) { + if (drm_format_modifier_table[i].modifier == modifier) + return strdup(drm_format_modifier_table[i].modifier_name); + } + + return NULL; +} + +/** Retrieves a human-readable representation of a vendor (as a string) from + * the format token modifier + * + * \param modifier the format modifier token + * \return a char pointer to the human-readable form of the vendor. Caller is + * responsible for freeing it. + */ +drm_public char * +drmGetFormatModifierVendor(uint64_t modifier) +{ + unsigned int i; + uint8_t vendor = fourcc_mod_get_vendor(modifier); + + for (i = 0; i < ARRAY_SIZE(drm_format_modifier_vendor_table); i++) { + if (drm_format_modifier_vendor_table[i].vendor == vendor) + return strdup(drm_format_modifier_vendor_table[i].vendor_name); + } + + return NULL; +} + +/** Retrieves a human-readable representation string from a format token + * modifier + * + * If the dedicated function was not able to extract a valid name or searching + * the format modifier was not in the table, this function would return NULL. + * + * \param modifier the token format + * \return a malloc'ed string representation of the modifier. Caller is + * responsible for freeing the string returned. + * + */ +drm_public char * +drmGetFormatModifierName(uint64_t modifier) +{ + uint8_t vendorid = fourcc_mod_get_vendor(modifier); + char *modifier_found = NULL; + unsigned int i; + + for (i = 0; i < ARRAY_SIZE(modifier_format_vendor_table); i++) { + if (modifier_format_vendor_table[i].vendor == vendorid) + modifier_found = modifier_format_vendor_table[i].vendor_cb(modifier); + } + + if (!modifier_found) + return drmGetFormatModifierFromSimpleTokens(modifier); + + return modifier_found; +} Index: xsrc/external/mit/libdrm/dist/xf86drm.h diff -u xsrc/external/mit/libdrm/dist/xf86drm.h:1.13 xsrc/external/mit/libdrm/dist/xf86drm.h:1.14 --- xsrc/external/mit/libdrm/dist/xf86drm.h:1.13 Tue Apr 27 03:02:37 2021 +++ xsrc/external/mit/libdrm/dist/xf86drm.h Sun Jul 11 00:31:53 2021 @@ -953,6 +953,17 @@ extern int drmSyncobjTransfer(int fd, uint32_t src_handle, uint64_t src_point, uint32_t flags); +extern char * +drmGetFormatModifierVendor(uint64_t modifier); + +extern char * +drmGetFormatModifierName(uint64_t modifier); + +#ifndef fourcc_mod_get_vendor +#define fourcc_mod_get_vendor(modifier) \ + (((modifier) >> 56) & 0xff) +#endif + #if defined(__cplusplus) } #endif Index: xsrc/external/mit/libdrm/dist/xf86drmMode.c diff -u xsrc/external/mit/libdrm/dist/xf86drmMode.c:1.17 xsrc/external/mit/libdrm/dist/xf86drmMode.c:1.18 --- xsrc/external/mit/libdrm/dist/xf86drmMode.c:1.17 Tue Apr 27 03:02:37 2021 +++ xsrc/external/mit/libdrm/dist/xf86drmMode.c Sun Jul 11 00:31:53 2021 @@ -38,6 +38,9 @@ #include <stdlib.h> #include <sys/ioctl.h> #if HAVE_SYS_SYSCTL_H +#ifdef __FreeBSD__ +#include <sys/types.h> +#endif #include <sys/sysctl.h> #endif #include <stdio.h> @@ -289,10 +292,8 @@ drm_public int drmModeAddFB2WithModifier memcpy(f.handles, bo_handles, 4 * sizeof(bo_handles[0])); memcpy(f.pitches, pitches, 4 * sizeof(pitches[0])); memcpy(f.offsets, offsets, 4 * sizeof(offsets[0])); - if (modifier) { - f.flags |= DRM_MODE_FB_MODIFIERS; + if (modifier) memcpy(f.modifier, modifier, 4 * sizeof(modifier[0])); - } if ((ret = DRM_IOCTL(fd, DRM_IOCTL_MODE_ADDFB2, &f))) return ret; Index: xsrc/external/mit/libdrm/dist/amdgpu/amdgpu_vamgr.c diff -u xsrc/external/mit/libdrm/dist/amdgpu/amdgpu_vamgr.c:1.2 xsrc/external/mit/libdrm/dist/amdgpu/amdgpu_vamgr.c:1.3 --- xsrc/external/mit/libdrm/dist/amdgpu/amdgpu_vamgr.c:1.2 Thu Jan 10 09:13:52 2019 +++ xsrc/external/mit/libdrm/dist/amdgpu/amdgpu_vamgr.c Sun Jul 11 00:31:54 2021 @@ -69,65 +69,99 @@ drm_private void amdgpu_vamgr_deinit(str 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; + } } - } - if (!waste && hole->size == size) { - offset = hole->offset; - list_del(&hole->list); - free(hole); + ret = amdgpu_vamgr_subtract_hole(hole, offset, offset + size); pthread_mutex_unlock(&mgr->bo_va_mutex); - return offset; + *va_out = offset; + return ret; } - 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); + } 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; + } } - 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; + + ret = amdgpu_vamgr_subtract_hole(hole, offset, offset + size); 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 @@ drm_public int amdgpu_va_range_alloc(amd 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 @@ drm_public int amdgpu_va_range_alloc(amd 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 @@ drm_public int amdgpu_va_range_alloc(amd 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) Index: xsrc/external/mit/libdrm/dist/tests/modetest/modetest.c diff -u xsrc/external/mit/libdrm/dist/tests/modetest/modetest.c:1.15 xsrc/external/mit/libdrm/dist/tests/modetest/modetest.c:1.16 --- xsrc/external/mit/libdrm/dist/tests/modetest/modetest.c:1.15 Tue Apr 27 03:02:37 2021 +++ xsrc/external/mit/libdrm/dist/tests/modetest/modetest.c Sun Jul 11 00:31:54 2021 @@ -265,52 +265,37 @@ static void dump_blob(struct device *dev 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) Index: xsrc/external/mit/xterm/dist/fontutils.c diff -u xsrc/external/mit/xterm/dist/fontutils.c:1.9 xsrc/external/mit/xterm/dist/fontutils.c:1.10 --- xsrc/external/mit/xterm/dist/fontutils.c:1.9 Tue Apr 27 01:58:18 2021 +++ xsrc/external/mit/xterm/dist/fontutils.c Sun Jul 11 00:31:54 2021 @@ -1,4 +1,4 @@ -/* $XTermId: fontutils.c,v 1.703 2021/03/02 00:25:24 tom Exp $ */ +/* $XTermId: fontutils.c,v 1.705 2021/06/02 23:49:10 tom Exp $ */ /* * Copyright 1998-2020,2021 by Thomas E. Dickey Index: xsrc/external/mit/xterm/dist/misc.c diff -u xsrc/external/mit/xterm/dist/misc.c:1.21 xsrc/external/mit/xterm/dist/misc.c:1.22 --- xsrc/external/mit/xterm/dist/misc.c:1.21 Sat May 15 19:30:15 2021 +++ xsrc/external/mit/xterm/dist/misc.c Sun Jul 11 00:31:54 2021 @@ -1,4 +1,4 @@ -/* $XTermId: misc.c,v 1.979 2021/03/24 00:27:48 tom Exp $ */ +/* $XTermId: misc.c,v 1.988 2021/06/07 23:19:42 tom Exp $ */ /* * Copyright 1999-2020,2021 by Thomas E. Dickey @@ -6991,11 +6991,73 @@ getXtermWidget(Widget w) } #if OPT_SESSION_MGT + +#if OPT_TRACE +static void +trace_1_SM(const char *tag, String name) +{ + Arg args[1]; + char *buf = 0; + + XtSetArg(args[0], name, &buf); + XtGetValues(toplevel, args, 1); + + if (strstr(name, "Path") || strstr(name, "Directory")) { + TRACE(("%s %s: %s\n", tag, name, NonNull(buf))); + } else if (strstr(name, "Command")) { + if (buf != NULL) { + char **vec = (char **) (void *) buf; + int n; + TRACE(("%s %s:\n", tag, name)); + for (n = 0; vec[n] != NULL; ++n) { + TRACE((" arg[%d] = %s\n", n, vec[n])); + } + } else { + TRACE(("%s %s: %p\n", tag, name, buf)); + } + } else { + TRACE(("%s %s: %p\n", tag, name, buf)); + } +} + +static void +trace_SM_props(void) +{ + /* *INDENT-OFF* */ + static struct { String app, cls; } table[] = { + { XtNcurrentDirectory, XtCCurrentDirectory }, + { XtNdieCallback, XtNdiscardCommand }, + { XtCDiscardCommand, XtNenvironment }, + { XtCEnvironment, XtNinteractCallback }, + { XtNjoinSession, XtCJoinSession }, + { XtNprogramPath, XtCProgramPath }, + { XtNresignCommand, XtCResignCommand }, + { XtNrestartCommand, XtCRestartCommand }, + { XtNrestartStyle, XtCRestartStyle }, + { XtNsaveCallback, XtNsaveCompleteCallback }, + { XtNsessionID, XtCSessionID }, + { XtNshutdownCommand, XtCShutdownCommand }, + }; + /* *INDENT-ON* */ + Cardinal n; + TRACE(("Session properties:\n")); + for (n = 0; n < XtNumber(table); ++n) { + trace_1_SM("app", table[n].app); + trace_1_SM("cls", table[n].cls); + } +} +#define TRACE_SM_PROPS() trace_SM_props() +#else +#define TRACE_SM_PROPS() /* nothing */ +#endif + static void die_callback(Widget w GCC_UNUSED, XtPointer client_data GCC_UNUSED, XtPointer call_data GCC_UNUSED) { + TRACE(("die_callback %p\n", die_callback)); + TRACE_SM_PROPS(); NormalExit(); } @@ -7005,7 +7067,19 @@ save_callback(Widget w GCC_UNUSED, XtPointer call_data) { XtCheckpointToken token = (XtCheckpointToken) call_data; - /* we have nothing to save */ + TRACE(("save_callback:\n")); + TRACE(("... save_type <-%d\n", token->save_type)); + TRACE(("... interact_style <-%d\n", token->interact_style)); + TRACE(("... shutdown <-%s\n", BtoS(token->shutdown))); + TRACE(("... fast <-%s\n", BtoS(token->fast))); + TRACE(("... cancel_shutdown <-%s\n", BtoS(token->cancel_shutdown))); + TRACE(("... phase <-%d\n", token->phase)); + TRACE(("... interact_dialog_type ->%d\n", token->interact_dialog_type)); + TRACE(("... request_cancel ->%s\n", BtoS(token->request_cancel))); + TRACE(("... request_next_phase ->%s\n", BtoS(token->request_next_phase))); + TRACE(("... save_success ->%s\n", BtoS(token->save_success))); + xtermUpdateRestartCommand(term); + /* we have nothing more to save */ token->save_success = True; } @@ -7031,6 +7105,8 @@ xtermOpenSession(void) TRACE(("Enabling session-management callbacks\n")); XtAddCallback(toplevel, XtNdieCallback, die_callback, NULL); XtAddCallback(toplevel, XtNsaveCallback, save_callback, NULL); + + TRACE_SM_PROPS(); } } @@ -7039,6 +7115,267 @@ xtermCloseSession(void) { IceRemoveConnectionWatch(icewatch, NULL); } + +typedef enum { + B_ARG = 0, + I_ARG, + D_ARG, + S_ARG +} ParamType; + +#define Barg(name, field) { name, B_ARG, XtOffsetOf(XtermWidgetRec, field) } +#define Iarg(name, field) { name, I_ARG, XtOffsetOf(XtermWidgetRec, field) } +#define Darg(name, field) { name, D_ARG, XtOffsetOf(XtermWidgetRec, field) } +#define Sarg(name, field) { name, S_ARG, XtOffsetOf(XtermWidgetRec, field) } + +typedef struct { + const char name[30]; + ParamType type; + Cardinal offset; +} FontParams; + +/* *INDENT-OFF* */ +static const FontParams fontParams[] = { + Iarg(XtNinitialFont, screen.menu_font_number), /* "-fc" */ + Barg(XtNallowBoldFonts, screen.allowBoldFonts), /* menu */ +#if OPT_BOX_CHARS + Barg(XtNforceBoxChars, screen.force_box_chars), /* "-fbx" */ + Barg(XtNforcePackedFont, screen.force_packed), /* menu */ +#endif +#if OPT_DEC_CHRSET + Barg(XtNfontDoublesize, screen.font_doublesize), /* menu */ +#endif +#if OPT_WIDE_CHARS + Barg(XtNutf8Fonts, screen.utf8_fonts), /* menu */ +#endif +#if OPT_RENDERFONT + Darg(XtNfaceSize, misc.face_size[0]), /* "-fs" */ + Sarg(XtNfaceName, misc.default_xft.f_n), /* "-fa" */ + Sarg(XtNrenderFont, misc.render_font_s), /* (resource) */ +#endif +}; +/* *INDENT-ON* */ + +#define RESTART_PARAMS (int)(XtNumber(fontParams) * 2) +#define TypedPtr(type) *(type *)(void *)((char *) xw + parameter->offset) + +/* + * If no widget is given, no value is used. + */ +static char * +formatFontParam(char *result, XtermWidget xw, const FontParams * parameter) +{ + sprintf(result, "%s*%s:", ProgramName, parameter->name); + if (xw != None) { + char *next = result + strlen(result); + switch (parameter->type) { + case B_ARG: + sprintf(next, "%s", *(Boolean *) ((char *) xw + parameter->offset) + ? "true" + : "false"); + break; + case I_ARG: + sprintf(next, "%d", TypedPtr(int)); + break; + case D_ARG: + sprintf(next, "%.1f", TypedPtr(float)); + break; + case S_ARG: + strcpy(next, TypedPtr(char *)); +#if OPT_RENDERFONT + if (!strcmp(parameter->name, XtNfaceName)) { + if (IsEmpty(next) + && xw->work.render_font) { + strcpy(next, DEFFACENAME_AUTO); + } + } else if (!strcmp(parameter->name, XtNrenderFont)) { + if (xw->work.render_font == erDefault + && IsEmpty(xw->misc.default_xft.f_n)) { + strcpy(next, "DefaultOff"); + } + } +#endif + break; + } + } + return result; +} + +#if OPT_TRACE +static void +dumpFontParams(XtermWidget xw) +{ + char buffer[1024]; + Cardinal n; + + TRACE(("FontParams:\n")); + for (n = 0; n < XtNumber(fontParams); ++n) { + TRACE(("%3d:%s\n", n, formatFontParam(buffer, xw, fontParams + n))); + } +} +#else +#define dumpFontParams(xw) /* nothing */ +#endif + +static Boolean +findFontParams(int argc, char **argv) +{ + Boolean result = False; + + if (argc > RESTART_PARAMS && (argc - restart_params) > RESTART_PARAMS) { + int n; + + for (n = 0; n < RESTART_PARAMS; ++n) { + int my_index = argc - restart_params - n - 1; + int my_param = (RESTART_PARAMS - n - 1) / 2; + char *actual = argv[my_index]; + char expect[1024]; + Boolean value = (Boolean) ((n % 2) == 0); + + result = False; + TRACE(("...index: %d\n", my_index)); + TRACE(("...param: %d\n", my_param)); + TRACE(("...actual %s\n", actual)); + if (IsEmpty(actual)) + break; + + if (value) { + formatFontParam(expect, None, fontParams + my_param); + } else { + strcpy(expect, "-xrm"); + } + + TRACE(("...expect %s\n", expect)); + + if (value) { + if (strlen(expect) >= strlen(actual)) + break; + if (strncmp(expect, actual, strlen(expect))) + break; + } else { + if (strcmp(actual, expect)) + break; + } + TRACE(("fixme/ok:%d\n", n)); + result = True; + } + TRACE(("findFontParams: %s (tested %d of %d parameters)\n", + BtoS(result), n + 1, RESTART_PARAMS)); + } + return result; +} + +static int +insertFontParams(XtermWidget xw, int *targetp, Boolean first) +{ + int changed = 0; + int n; + int target = *targetp; + char buffer[1024]; + const char *option = "-xrm"; + + for (n = 0; n < (int) XtNumber(fontParams); ++n) { + formatFontParam(buffer, xw, fontParams + n); + TRACE(("formatted %3d ->%3d:%s\n", n, target, buffer)); + if (restart_command[target] == NULL) + restart_command[target] = x_strdup(option); + ++target; + if (first) { + restart_command[target] = x_strdup(buffer); + ++changed; + } else if (restart_command[target] == NULL + || strcmp(restart_command[target], buffer)) { + free(restart_command[target]); + restart_command[target] = x_strdup(buffer); + ++changed; + } + ++target; + } + *targetp = target; + return changed; +} + +void +xtermUpdateRestartCommand(XtermWidget xw) +{ + if (resource.sessionMgt) { + Arg args[1]; + char **argv = 0; + + XtSetArg(args[0], XtNrestartCommand, &argv); + XtGetValues(toplevel, args, 1); + if (argv != NULL) { + static int my_params = 0; + + int changes = 0; + Boolean first = False; + int argc; + int want; + int source, target; + + TRACE(("xtermUpdateRestartCommand\n")); + dumpFontParams(xw); + for (argc = 0; argv[argc] != NULL; ++argc) { + TRACE((" arg[%d] = %s\n", argc, argv[argc])); + ; + } + want = argc - (restart_params + RESTART_PARAMS); + + TRACE((" argc: %d\n", argc)); + TRACE((" restart_params: %d\n", restart_params)); + TRACE((" want to insert: %d\n", want)); + + /* + * If we already have the font-choice option, do not add it again. + */ + if (findFontParams(argc, argv)) { + my_params = (want); + } else { + first = True; + my_params = (argc - restart_params); + } + TRACE((" my_params: %d\n", my_params)); + + if (my_params > argc) { + TRACE((" re-allocate restartCommand\n")); + FreeAndNull(restart_command); + } + + if (restart_command == NULL) { + int need = argc + RESTART_PARAMS + 1; + + restart_command = TypeCallocN(char *, need); + + TRACE(("..inserting font-parameters\n")); + for (source = target = 0; source < argc; ++source) { + if (source == my_params) { + changes += insertFontParams(xw, &target, first); + if (!first) { + source += (RESTART_PARAMS - 1); + continue; + } + } + if (argv[source] == NULL) + break; + restart_command[target++] = x_strdup(argv[source]); + } + restart_command[target] = NULL; + } else { + TRACE(("..replacing font-parameters\n")); + target = my_params; + changes += insertFontParams(xw, &target, first); + } + if (changes) { + TRACE(("..%d parameters changed\n", changes)); + XtSetArg(args[0], XtNrestartCommand, restart_command); + XtSetValues(toplevel, args, 1); + } else { + TRACE(("..NO parameters changed\n")); + } + } + TRACE_SM_PROPS(); + } +} #endif /* OPT_SESSION_MGT */ Widget @@ -7207,12 +7544,23 @@ update_winsize(int fd, int rows, int col #ifdef TTYSIZE_STRUCT static int last_rows = -1; static int last_cols = -1; + static int last_high = -1; + static int last_wide = -1; - if (rows != last_rows || cols != last_cols) { + TRACE(("update_winsize %dx%d (%dx%d) -> %dx%d (%dx%d)\n", + last_rows, last_cols, last_high, last_wide, + rows, cols, height, width)); + + if (rows != last_rows + || cols != last_cols + || last_high != height + || last_wide != width) { TTYSIZE_STRUCT ts; last_rows = rows; last_cols = cols; + last_high = height; + last_wide = width; setup_winsize(ts, rows, cols, height, width); TRACE_RC(code, SET_TTYSIZE(fd, ts)); trace_winsize(ts, "from SET_TTYSIZE"); Index: xsrc/external/mit/xterm/dist/ptyx.h diff -u xsrc/external/mit/xterm/dist/ptyx.h:1.16 xsrc/external/mit/xterm/dist/ptyx.h:1.17 --- xsrc/external/mit/xterm/dist/ptyx.h:1.16 Tue Apr 27 01:58:18 2021 +++ xsrc/external/mit/xterm/dist/ptyx.h Sun Jul 11 00:31:54 2021 @@ -1,4 +1,4 @@ -/* $XTermId: ptyx.h,v 1.1030 2021/03/21 22:11:10 tom Exp $ */ +/* $XTermId: ptyx.h,v 1.1032 2021/06/07 19:29:11 tom Exp $ */ /* * Copyright 1999-2020,2021 by Thomas E. Dickey @@ -1946,6 +1946,7 @@ typedef enum { erFalse = 0 , erTrue , erDefault + , erDefaultOff , erLast } RenderFont; @@ -2731,6 +2732,7 @@ typedef struct { #if OPT_SCROLL_LOCK Boolean allowScrollLock;/* ScrollLock mode */ Boolean allowScrollLock0;/* initial ScrollLock mode */ + Boolean autoScrollLock; /* Auto ScrollLock mode */ Boolean scroll_lock; /* true to keep buffer in view */ Boolean scroll_dirty; /* scrolling makes screen dirty */ #endif Index: xsrc/external/mit/xterm/dist/xterm.h diff -u xsrc/external/mit/xterm/dist/xterm.h:1.4 xsrc/external/mit/xterm/dist/xterm.h:1.5 --- xsrc/external/mit/xterm/dist/xterm.h:1.4 Tue Apr 27 01:58:18 2021 +++ xsrc/external/mit/xterm/dist/xterm.h Sun Jul 11 00:31:54 2021 @@ -1,4 +1,4 @@ -/* $XTermId: xterm.h,v 1.890 2021/03/21 22:44:36 tom Exp $ */ +/* $XTermId: xterm.h,v 1.893 2021/06/06 23:14:40 Stelios.Bounanos Exp $ */ /* * Copyright 1999-2020,2021 by Thomas E. Dickey @@ -454,6 +454,7 @@ extern char **environ; #define XtNappkeypadDefault "appkeypadDefault" #define XtNassumeAllChars "assumeAllChars" #define XtNautoWrap "autoWrap" +#define XtNautoScrollLock "autoScrollLock" #define XtNawaitInput "awaitInput" #define XtNbackarrowKey "backarrowKey" #define XtNbellIsUrgent "bellIsUrgent" @@ -668,6 +669,7 @@ extern char **environ; #define XtCAppkeypadDefault "AppkeypadDefault" #define XtCAssumeAllChars "AssumeAllChars" #define XtCAutoWrap "AutoWrap" +#define XtCAutoScrollLock "AutoScrollLock" #define XtCAwaitInput "AwaitInput" #define XtCBackarrowKey "BackarrowKey" #define XtCBellIsUrgent "BellIsUrgent" @@ -1300,9 +1302,11 @@ extern void HandleInsertSelectable P #if OPT_SESSION_MGT extern void xtermCloseSession (void); extern void xtermOpenSession (void); +extern void xtermUpdateRestartCommand(XtermWidget /* xw */); #else #define xtermCloseSession() /* nothing */ #define xtermOpenSession() /* nothing */ +#define xtermUpdateRestartCommand(xw) /* nothing */ #endif #if OPT_WIDE_CHARS Index: xsrc/external/mit/xterm/dist/xterm.man diff -u xsrc/external/mit/xterm/dist/xterm.man:1.18 xsrc/external/mit/xterm/dist/xterm.man:1.19 --- xsrc/external/mit/xterm/dist/xterm.man:1.18 Tue Apr 27 01:58:18 2021 +++ xsrc/external/mit/xterm/dist/xterm.man Sun Jul 11 00:31:54 2021 @@ -1,5 +1,5 @@ '\" t -.\" $XTermId: xterm.man,v 1.844 2021/03/26 23:11:13 tom Exp $ +.\" $XTermId: xterm.man,v 1.848 2021/06/07 21:00:31 tom Exp $ .\" .\" Copyright 1996-2020,2021 by Thomas E. Dickey .\" @@ -1628,7 +1628,8 @@ The default is and is limited to the range 1 through 100. .TP 8 .B "cursorTheme\fP (class\fB CursorTheme\fP)" -The Xcursor(__miscmansuffix__) library provides a way to +The Xcursor(__miscmansuffix__) library +provides a way to change the pointer shape and size. The X11 library uses this library to extend the font- and glyph-cursor calls used by applications such as \fI\*n\fP to substitute external files for the built-in \*(``core\*('' cursors provided by X. @@ -2286,6 +2287,8 @@ user surprise. This key is generally unused in keyboard configurations, and has not acquired a standard meaning even when it is used in that manner. Consequently, users have assigned it for ad hoc purposes. +.IP +See also the \fBautoScrollLock\fP resource. .TP 8 .B "allowSendEvents\fP (class\fB AllowSendEvents\fP)" Specifies whether or not synthetic key and button events (generated using @@ -2455,6 +2458,14 @@ certain quasi-automatically generated fo (such as the ISO-10646-1 encoding of Terminus) which have incorrect font-metrics. .TP 8 +.B "autoScrollLock\fP (class\fB AutoScrollLock\fP)" +If \*(``true\*('', \fI\*n\fR will maintain its viewport of displayed lines +whenever displaying scrollback, as if \fBallowScrollLock\fP were enabled +and the Scroll Lock key had been pressed. +The default is \*(``false\*(''. +This feature is only useful if the \fBscrollTtyOutput\fP resource is set to +\*(``false\*(''. +.TP 8 .B "autoWrap\fP (class\fB AutoWrap\fP)" Specifies whether or not auto-wraparound should be enabled. This is the same as the VT102 DECAWM. @@ -4811,6 +4822,12 @@ That is normally \*(``mono\*(''. If the \fBfaceName\fP resource is set, then start by using the TrueType font rather than the bitmap font. .RE +.TP 5 +defaultOff +.br +Enable the \*(``TrueType Fonts\*('' +menu entry to allow runtime switching to/from TrueType fonts, +but allow it to be initially unselected if no \fBfaceName\fP resource was given. .RE .TP 8 .B "resizeByPixel\fP (class\fB ResizeByPixel\fP)"