From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-16.7 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 519FAC47078 for ; Fri, 21 May 2021 15:33:34 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 1B99E613D6 for ; Fri, 21 May 2021 15:33:34 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 1B99E613D6 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=linux.intel.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=dri-devel-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id DF1466EE35; Fri, 21 May 2021 15:33:27 +0000 (UTC) Received: from mga07.intel.com (mga07.intel.com [134.134.136.100]) by gabe.freedesktop.org (Postfix) with ESMTPS id 9EA5D8975F; Fri, 21 May 2021 15:33:19 +0000 (UTC) IronPort-SDR: 9n4jkAV1hdD5HRkwoXc/EHgXnWoL2vl59XGvawJWP9JxNY3Ela+AMj52EOt+/3KW5TTITi07Uw 39dqkOXhy4cg== X-IronPort-AV: E=McAfee;i="6200,9189,9990"; a="265415717" X-IronPort-AV: E=Sophos;i="5.82,319,1613462400"; d="scan'208";a="265415717" Received: from fmsmga008.fm.intel.com ([10.253.24.58]) by orsmga105.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 21 May 2021 08:33:19 -0700 IronPort-SDR: an/rbP3i3Qw7qyUIpMsR4IWeilaSxHGLq/+9poV62qH+jD0gxDpxoULZxYppY1gq0Ke9agU4bX I+l6C/GNMQWQ== X-IronPort-AV: E=Sophos;i="5.82,319,1613462400"; d="scan'208";a="441125443" Received: from imarinmo-mobl1.ger.corp.intel.com (HELO thellst-mobl1.intel.com) ([10.249.254.34]) by fmsmga008-auth.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 21 May 2021 08:33:17 -0700 From: =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= To: intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org Subject: [PATCH v3 07/12] drm, drm/i915: Move the memcpy_from_wc functionality to core drm Date: Fri, 21 May 2021 17:32:48 +0200 Message-Id: <20210521153253.518037-8-thomas.hellstrom@linux.intel.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210521153253.518037-1-thomas.hellstrom@linux.intel.com> References: <20210521153253.518037-1-thomas.hellstrom@linux.intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= , =?UTF-8?q?Christian=20K=C3=B6nig?= , Daniel Vetter Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" Memcpy from wc will be used as well by TTM memcpy. Move it to core drm, and make the interface do the right thing even on !X86. Cc: Christian König Cc: Daniel Vetter Cc: Dave Airlie Signed-off-by: Thomas Hellström --- drivers/gpu/drm/Makefile | 2 +- drivers/gpu/drm/drm_drv.c | 2 + .../drm/{i915/i915_memcpy.c => drm_memcpy.c} | 63 ++++++++++++++----- drivers/gpu/drm/i915/Makefile | 1 - .../gpu/drm/i915/gem/i915_gem_execbuffer.c | 4 +- drivers/gpu/drm/i915/gem/i915_gem_object.c | 5 +- drivers/gpu/drm/i915/gt/selftest_reset.c | 7 ++- drivers/gpu/drm/i915/gt/uc/intel_guc_log.c | 11 ++-- drivers/gpu/drm/i915/i915_cmd_parser.c | 4 +- drivers/gpu/drm/i915/i915_drv.c | 2 - drivers/gpu/drm/i915/i915_gpu_error.c | 8 +-- drivers/gpu/drm/i915/i915_memcpy.h | 34 ---------- .../drm/i915/selftests/intel_memory_region.c | 7 ++- include/drm/drm_memcpy.h | 47 ++++++++++++++ 14 files changed, 121 insertions(+), 76 deletions(-) rename drivers/gpu/drm/{i915/i915_memcpy.c => drm_memcpy.c} (70%) delete mode 100644 drivers/gpu/drm/i915/i915_memcpy.h create mode 100644 include/drm/drm_memcpy.h diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile index a91cc7684904..f3ab8586c3d7 100644 --- a/drivers/gpu/drm/Makefile +++ b/drivers/gpu/drm/Makefile @@ -18,7 +18,7 @@ drm-y := drm_aperture.o drm_auth.o drm_cache.o \ drm_dumb_buffers.o drm_mode_config.o drm_vblank.o \ drm_syncobj.o drm_lease.o drm_writeback.o drm_client.o \ drm_client_modeset.o drm_atomic_uapi.o drm_hdcp.o \ - drm_managed.o drm_vblank_work.o + drm_managed.o drm_vblank_work.o drm_memcpy.o \ drm-$(CONFIG_DRM_LEGACY) += drm_agpsupport.o drm_bufs.o drm_context.o drm_dma.o \ drm_legacy_misc.o drm_lock.o drm_memory.o drm_scatter.o \ diff --git a/drivers/gpu/drm/drm_drv.c b/drivers/gpu/drm/drm_drv.c index 3d8d68a98b95..351cc2900cf1 100644 --- a/drivers/gpu/drm/drm_drv.c +++ b/drivers/gpu/drm/drm_drv.c @@ -40,6 +40,7 @@ #include #include #include +#include #include #include @@ -1041,6 +1042,7 @@ static int __init drm_core_init(void) drm_connector_ida_init(); idr_init(&drm_minors_idr); + drm_memcpy_init_early(); ret = drm_sysfs_init(); if (ret < 0) { diff --git a/drivers/gpu/drm/i915/i915_memcpy.c b/drivers/gpu/drm/drm_memcpy.c similarity index 70% rename from drivers/gpu/drm/i915/i915_memcpy.c rename to drivers/gpu/drm/drm_memcpy.c index 1b021a4902de..740377749caa 100644 --- a/drivers/gpu/drm/i915/i915_memcpy.c +++ b/drivers/gpu/drm/drm_memcpy.c @@ -1,3 +1,4 @@ +// SPDX-License-Identifier: MIT /* * Copyright © 2016 Intel Corporation * @@ -22,16 +23,12 @@ * */ +#ifdef CONFIG_X86 +#include #include #include -#include "i915_memcpy.h" - -#if IS_ENABLED(CONFIG_DRM_I915_DEBUG) -#define CI_BUG_ON(expr) BUG_ON(expr) -#else -#define CI_BUG_ON(expr) BUILD_BUG_ON_INVALID(expr) -#endif +#include "drm/drm_memcpy.h" static DEFINE_STATIC_KEY_FALSE(has_movntdqa); @@ -94,23 +91,24 @@ static void __memcpy_ntdqu(void *dst, const void *src, unsigned long len) } /** - * i915_memcpy_from_wc: perform an accelerated *aligned* read from WC + * drm_memcpy_from_wc: perform an accelerated *aligned* read from WC * @dst: destination pointer * @src: source pointer * @len: how many bytes to copy * - * i915_memcpy_from_wc copies @len bytes from @src to @dst using + * drm_memcpy_from_wc copies @len bytes from @src to @dst using * non-temporal instructions where available. Note that all arguments * (@src, @dst) must be aligned to 16 bytes and @len must be a multiple * of 16. * * To test whether accelerated reads from WC are supported, use - * i915_memcpy_from_wc(NULL, NULL, 0); + * drm_memcpy_from_wc(NULL, NULL, 0); + * This interface is intended for memremapped memory without the __iomem tag. * * Returns true if the copy was successful, false if the preconditions * are not met. */ -bool i915_memcpy_from_wc(void *dst, const void *src, unsigned long len) +bool drm_memcpy_from_wc(void *dst, const void *src, unsigned long len) { if (unlikely(((unsigned long)dst | (unsigned long)src | len) & 15)) return false; @@ -123,24 +121,53 @@ bool i915_memcpy_from_wc(void *dst, const void *src, unsigned long len) return false; } +EXPORT_SYMBOL(drm_memcpy_from_wc); /** - * i915_unaligned_memcpy_from_wc: perform a mostly accelerated read from WC + * drm_memcpy_from_wc_dbm: perform an accelerated *aligned* read from WC with + * struct dma_buf_map arguments. + * @dst: destination map + * @src: source map + * @len: how many bytes to copy + * + * This is identical to drm_memcpy_from_wc, except it's intended for + * potentially ioremapped memory rather than memremapped memory. + * + * Returns true if the copy was successful, false if the preconditions + * are not met. + */ +bool drm_memcpy_from_wc_dbm(struct dma_buf_map *dst, + const struct dma_buf_map *src, + unsigned long len) +{ + /* For X86 we can safely drop __iomem */ + return drm_memcpy_from_wc(dst->is_iomem ? + (void __force *)dst->vaddr_iomem : + dst->vaddr, + src->is_iomem ? + (void const __force *)src->vaddr_iomem : + src->vaddr, + len); +} +EXPORT_SYMBOL(drm_memcpy_from_wc_dbm); + +/** + * drm_unaligned_memcpy_from_wc: perform a mostly accelerated read from WC * @dst: destination pointer * @src: source pointer * @len: how many bytes to copy * - * Like i915_memcpy_from_wc(), the unaligned variant copies @len bytes from + * Like drm_memcpy_from_wc(), the unaligned variant copies @len bytes from * @src to @dst using * non-temporal instructions where available, but * accepts that its arguments may not be aligned, but are valid for the * potential 16-byte read past the end. + * + * This interface is intended for mremapped memory without the __iomem tag. */ -void i915_unaligned_memcpy_from_wc(void *dst, const void *src, unsigned long len) +void drm_unaligned_memcpy_from_wc(void *dst, const void *src, unsigned long len) { unsigned long addr; - CI_BUG_ON(!i915_has_memcpy_from_wc()); - addr = (unsigned long)src; if (!IS_ALIGNED(addr, 16)) { unsigned long x = min(ALIGN(addr, 16) - addr, len); @@ -155,8 +182,9 @@ void i915_unaligned_memcpy_from_wc(void *dst, const void *src, unsigned long len if (likely(len)) __memcpy_ntdqu(dst, src, DIV_ROUND_UP(len, 16)); } +EXPORT_SYMBOL(drm_unaligned_memcpy_from_wc); -void i915_memcpy_init_early(struct drm_i915_private *dev_priv) +void drm_memcpy_init_early(void) { /* * Some hypervisors (e.g. KVM) don't support VEX-prefix instructions @@ -166,3 +194,4 @@ void i915_memcpy_init_early(struct drm_i915_private *dev_priv) !boot_cpu_has(X86_FEATURE_HYPERVISOR)) static_branch_enable(&has_movntdqa); } +#endif diff --git a/drivers/gpu/drm/i915/Makefile b/drivers/gpu/drm/i915/Makefile index cb8823570996..998606b7f49f 100644 --- a/drivers/gpu/drm/i915/Makefile +++ b/drivers/gpu/drm/i915/Makefile @@ -61,7 +61,6 @@ i915-y += i915_drv.o \ # core library code i915-y += \ dma_resv_utils.o \ - i915_memcpy.o \ i915_mm.o \ i915_sw_fence.o \ i915_sw_fence_work.o \ diff --git a/drivers/gpu/drm/i915/gem/i915_gem_execbuffer.c b/drivers/gpu/drm/i915/gem/i915_gem_execbuffer.c index 297143511f99..77285e421fb8 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_execbuffer.c +++ b/drivers/gpu/drm/i915/gem/i915_gem_execbuffer.c @@ -10,6 +10,7 @@ #include #include +#include #include "display/intel_frontbuffer.h" @@ -28,7 +29,6 @@ #include "i915_sw_fence_work.h" #include "i915_trace.h" #include "i915_user_extensions.h" -#include "i915_memcpy.h" struct eb_vma { struct i915_vma *vma; @@ -2503,7 +2503,7 @@ static int eb_parse_pipeline(struct i915_execbuffer *eb, !(batch->cache_coherent & I915_BO_CACHE_COHERENT_FOR_READ); pw->batch_map = ERR_PTR(-ENODEV); - if (needs_clflush && i915_has_memcpy_from_wc()) + if (needs_clflush && drm_has_memcpy_from_wc()) pw->batch_map = i915_gem_object_pin_map(batch, I915_MAP_WC); if (IS_ERR(pw->batch_map)) { diff --git a/drivers/gpu/drm/i915/gem/i915_gem_object.c b/drivers/gpu/drm/i915/gem/i915_gem_object.c index 5706d471692d..e9247afb0320 100644 --- a/drivers/gpu/drm/i915/gem/i915_gem_object.c +++ b/drivers/gpu/drm/i915/gem/i915_gem_object.c @@ -24,6 +24,8 @@ #include +#include + #include "display/intel_frontbuffer.h" #include "i915_drv.h" #include "i915_gem_clflush.h" @@ -31,7 +33,6 @@ #include "i915_gem_mman.h" #include "i915_gem_object.h" #include "i915_globals.h" -#include "i915_memcpy.h" #include "i915_trace.h" static struct i915_global_object { @@ -374,7 +375,7 @@ i915_gem_object_read_from_page_iomap(struct drm_i915_gem_object *obj, u64 offset PAGE_SIZE); src_ptr = src_map + offset_in_page(offset); - if (!i915_memcpy_from_wc(dst, (void __force *)src_ptr, size)) + if (!drm_memcpy_from_wc(dst, (void __force *)src_ptr, size)) memcpy_fromio(dst, src_ptr, size); io_mapping_unmap(src_map); diff --git a/drivers/gpu/drm/i915/gt/selftest_reset.c b/drivers/gpu/drm/i915/gt/selftest_reset.c index 8784257ec808..92ada67a3835 100644 --- a/drivers/gpu/drm/i915/gt/selftest_reset.c +++ b/drivers/gpu/drm/i915/gt/selftest_reset.c @@ -5,9 +5,10 @@ #include +#include + #include "gem/i915_gem_stolen.h" -#include "i915_memcpy.h" #include "i915_selftest.h" #include "intel_gpu_commands.h" #include "selftests/igt_reset.h" @@ -99,7 +100,7 @@ __igt_reset_stolen(struct intel_gt *gt, memset_io(s, STACK_MAGIC, PAGE_SIZE); in = (void __force *)s; - if (i915_memcpy_from_wc(tmp, in, PAGE_SIZE)) + if (drm_memcpy_from_wc(tmp, in, PAGE_SIZE)) in = tmp; crc[page] = crc32_le(0, in, PAGE_SIZE); @@ -135,7 +136,7 @@ __igt_reset_stolen(struct intel_gt *gt, PAGE_SIZE); in = (void __force *)s; - if (i915_memcpy_from_wc(tmp, in, PAGE_SIZE)) + if (drm_memcpy_from_wc(tmp, in, PAGE_SIZE)) in = tmp; x = crc32_le(0, in, PAGE_SIZE); diff --git a/drivers/gpu/drm/i915/gt/uc/intel_guc_log.c b/drivers/gpu/drm/i915/gt/uc/intel_guc_log.c index c36d5eb5bbb9..f045e42be6ca 100644 --- a/drivers/gpu/drm/i915/gt/uc/intel_guc_log.c +++ b/drivers/gpu/drm/i915/gt/uc/intel_guc_log.c @@ -5,9 +5,10 @@ #include +#include + #include "gt/intel_gt.h" #include "i915_drv.h" -#include "i915_memcpy.h" #include "intel_guc_log.h" static void guc_log_capture_logs(struct intel_guc_log *log); @@ -295,13 +296,13 @@ static void guc_read_update_log_buffer(struct intel_guc_log *log) /* Just copy the newly written data */ if (read_offset > write_offset) { - i915_memcpy_from_wc(dst_data, src_data, write_offset); + drm_memcpy_from_wc(dst_data, src_data, write_offset); bytes_to_copy = buffer_size - read_offset; } else { bytes_to_copy = write_offset - read_offset; } - i915_memcpy_from_wc(dst_data + read_offset, - src_data + read_offset, bytes_to_copy); + drm_memcpy_from_wc(dst_data + read_offset, + src_data + read_offset, bytes_to_copy); src_data += buffer_size; dst_data += buffer_size; @@ -569,7 +570,7 @@ int intel_guc_log_relay_open(struct intel_guc_log *log) * it should be present on the chipsets supporting GuC based * submisssions. */ - if (!i915_has_memcpy_from_wc()) { + if (!drm_has_memcpy_from_wc()) { ret = -ENXIO; goto out_unlock; } diff --git a/drivers/gpu/drm/i915/i915_cmd_parser.c b/drivers/gpu/drm/i915/i915_cmd_parser.c index 5b4b2bd46e7c..98653f1a2b1d 100644 --- a/drivers/gpu/drm/i915/i915_cmd_parser.c +++ b/drivers/gpu/drm/i915/i915_cmd_parser.c @@ -24,12 +24,12 @@ * Brad Volkin * */ +#include #include "gt/intel_engine.h" #include "gt/intel_gpu_commands.h" #include "i915_drv.h" -#include "i915_memcpy.h" /** * DOC: batch buffer command parser @@ -1152,7 +1152,7 @@ static u32 *copy_batch(struct drm_i915_gem_object *dst_obj, if (src) { GEM_BUG_ON(!needs_clflush); - i915_unaligned_memcpy_from_wc(dst, src + offset, length); + drm_unaligned_memcpy_from_wc(dst, src + offset, length); } else { struct scatterlist *sg; void *ptr; diff --git a/drivers/gpu/drm/i915/i915_drv.c b/drivers/gpu/drm/i915/i915_drv.c index 122dd297b6af..0df9dd62c717 100644 --- a/drivers/gpu/drm/i915/i915_drv.c +++ b/drivers/gpu/drm/i915/i915_drv.c @@ -72,7 +72,6 @@ #include "i915_drv.h" #include "i915_ioc32.h" #include "i915_irq.h" -#include "i915_memcpy.h" #include "i915_perf.h" #include "i915_query.h" #include "i915_suspend.h" @@ -325,7 +324,6 @@ static int i915_driver_early_probe(struct drm_i915_private *dev_priv) mutex_init(&dev_priv->pps_mutex); mutex_init(&dev_priv->hdcp_comp_mutex); - i915_memcpy_init_early(dev_priv); intel_runtime_pm_init_early(&dev_priv->runtime_pm); ret = i915_workqueues_init(dev_priv); diff --git a/drivers/gpu/drm/i915/i915_gpu_error.c b/drivers/gpu/drm/i915/i915_gpu_error.c index 99ca242ec13b..ee11920fbea5 100644 --- a/drivers/gpu/drm/i915/i915_gpu_error.c +++ b/drivers/gpu/drm/i915/i915_gpu_error.c @@ -34,6 +34,7 @@ #include #include +#include #include #include "display/intel_csr.h" @@ -46,7 +47,6 @@ #include "i915_drv.h" #include "i915_gpu_error.h" -#include "i915_memcpy.h" #include "i915_scatterlist.h" #define ALLOW_FAIL (GFP_KERNEL | __GFP_RETRY_MAYFAIL | __GFP_NOWARN) @@ -255,7 +255,7 @@ static bool compress_init(struct i915_vma_compress *c) } c->tmp = NULL; - if (i915_has_memcpy_from_wc()) + if (drm_has_memcpy_from_wc()) c->tmp = pool_alloc(&c->pool, ALLOW_FAIL); return true; @@ -295,7 +295,7 @@ static int compress_page(struct i915_vma_compress *c, struct z_stream_s *zstream = &c->zstream; zstream->next_in = src; - if (wc && c->tmp && i915_memcpy_from_wc(c->tmp, src, PAGE_SIZE)) + if (wc && c->tmp && drm_memcpy_from_wc(c->tmp, src, PAGE_SIZE)) zstream->next_in = c->tmp; zstream->avail_in = PAGE_SIZE; @@ -395,7 +395,7 @@ static int compress_page(struct i915_vma_compress *c, if (!ptr) return -ENOMEM; - if (!(wc && i915_memcpy_from_wc(ptr, src, PAGE_SIZE))) + if (!(wc && drm_memcpy_from_wc(ptr, src, PAGE_SIZE))) memcpy(ptr, src, PAGE_SIZE); dst->pages[dst->page_count++] = ptr; cond_resched(); diff --git a/drivers/gpu/drm/i915/i915_memcpy.h b/drivers/gpu/drm/i915/i915_memcpy.h deleted file mode 100644 index 3df063a3293b..000000000000 --- a/drivers/gpu/drm/i915/i915_memcpy.h +++ /dev/null @@ -1,34 +0,0 @@ -/* SPDX-License-Identifier: MIT */ -/* - * Copyright © 2019 Intel Corporation - */ - -#ifndef __I915_MEMCPY_H__ -#define __I915_MEMCPY_H__ - -#include - -struct drm_i915_private; - -void i915_memcpy_init_early(struct drm_i915_private *i915); - -bool i915_memcpy_from_wc(void *dst, const void *src, unsigned long len); -void i915_unaligned_memcpy_from_wc(void *dst, const void *src, unsigned long len); - -/* The movntdqa instructions used for memcpy-from-wc require 16-byte alignment, - * as well as SSE4.1 support. i915_memcpy_from_wc() will report if it cannot - * perform the operation. To check beforehand, pass in the parameters to - * to i915_can_memcpy_from_wc() - since we only care about the low 4 bits, - * you only need to pass in the minor offsets, page-aligned pointers are - * always valid. - * - * For just checking for SSE4.1, in the foreknowledge that the future use - * will be correctly aligned, just use i915_has_memcpy_from_wc(). - */ -#define i915_can_memcpy_from_wc(dst, src, len) \ - i915_memcpy_from_wc((void *)((unsigned long)(dst) | (unsigned long)(src) | (len)), NULL, 0) - -#define i915_has_memcpy_from_wc() \ - i915_memcpy_from_wc(NULL, NULL, 0) - -#endif /* __I915_MEMCPY_H__ */ diff --git a/drivers/gpu/drm/i915/selftests/intel_memory_region.c b/drivers/gpu/drm/i915/selftests/intel_memory_region.c index c85d516b85cd..6bb399e9be78 100644 --- a/drivers/gpu/drm/i915/selftests/intel_memory_region.c +++ b/drivers/gpu/drm/i915/selftests/intel_memory_region.c @@ -6,6 +6,8 @@ #include #include +#include + #include "../i915_selftest.h" #include "mock_drm.h" @@ -20,7 +22,6 @@ #include "gem/selftests/mock_context.h" #include "gt/intel_engine_user.h" #include "gt/intel_gt.h" -#include "i915_memcpy.h" #include "selftests/igt_flush_test.h" #include "selftests/i915_random.h" @@ -901,7 +902,7 @@ static inline void igt_memcpy(void *dst, const void *src, size_t size) static inline void igt_memcpy_from_wc(void *dst, const void *src, size_t size) { - i915_memcpy_from_wc(dst, src, size); + drm_memcpy_from_wc(dst, src, size); } static int _perf_memcpy(struct intel_memory_region *src_mr, @@ -925,7 +926,7 @@ static int _perf_memcpy(struct intel_memory_region *src_mr, { "memcpy_from_wc", igt_memcpy_from_wc, - !i915_has_memcpy_from_wc(), + !drm_has_memcpy_from_wc(), }, }; struct drm_i915_gem_object *src, *dst; diff --git a/include/drm/drm_memcpy.h b/include/drm/drm_memcpy.h new file mode 100644 index 000000000000..b1d709753b4d --- /dev/null +++ b/include/drm/drm_memcpy.h @@ -0,0 +1,47 @@ +/* SPDX-License-Identifier: MIT */ +/* + * Copyright © 2019 Intel Corporation + */ + +#ifndef __DRM_MEMCPY_H__ +#define __DRM_MEMCPY_H__ + +#include + +struct dma_buf_map; + +#ifdef CONFIG_X86 +bool drm_memcpy_from_wc(void *dst, const void *src, unsigned long len); +bool drm_memcpy_from_wc_dbm(struct dma_buf_map *dst, + const struct dma_buf_map *src, + unsigned long len); +void drm_unaligned_memcpy_from_wc(void *dst, const void *src, unsigned long len); + +/* The movntdqa instructions used for memcpy-from-wc require 16-byte alignment, + * as well as SSE4.1 support. drm_memcpy_from_wc() will report if it cannot + * perform the operation. To check beforehand, pass in the parameters to + * drm_can_memcpy_from_wc() - since we only care about the low 4 bits, + * you only need to pass in the minor offsets, page-aligned pointers are + * always valid. + * + * For just checking for SSE4.1, in the foreknowledge that the future use + * will be correctly aligned, just use drm_has_memcpy_from_wc(). + */ +#define drm_can_memcpy_from_wc(dst, src, len) \ + drm_memcpy_from_wc((void *)((unsigned long)(dst) | (unsigned long)(src) | (len)), NULL, 0) + +#define drm_has_memcpy_from_wc() \ + drm_memcpy_from_wc(NULL, NULL, 0) + +void drm_memcpy_init_early(void); + +#else + +#define drm_memcpy_from_wc(_dst, _src, _len) (false) +#define drm_memcpy_from_wc_dbm(_dst, _src, _len) (false) +#define drm_can_memcpy_from_wc(_dst, _src, _len) (false) +#define drm_has_memcpy_from_wc() (false) +#define drm_unaligned_memcpy_from_wc(_dst, _src, _len) WARN_ON(1) +#define drm_memcpy_init_early() do {} while (0) +#endif /* CONFIG_X86 */ +#endif /* __DRM_MEMCPY_H__ */ -- 2.31.1 From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-16.7 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id CDE3EC4707C for ; Fri, 21 May 2021 15:33:27 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 93E456135B for ; Fri, 21 May 2021 15:33:27 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 93E456135B Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=linux.intel.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=intel-gfx-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 341A96EC56; Fri, 21 May 2021 15:33:21 +0000 (UTC) Received: from mga07.intel.com (mga07.intel.com [134.134.136.100]) by gabe.freedesktop.org (Postfix) with ESMTPS id 9EA5D8975F; Fri, 21 May 2021 15:33:19 +0000 (UTC) IronPort-SDR: 9n4jkAV1hdD5HRkwoXc/EHgXnWoL2vl59XGvawJWP9JxNY3Ela+AMj52EOt+/3KW5TTITi07Uw 39dqkOXhy4cg== X-IronPort-AV: E=McAfee;i="6200,9189,9990"; a="265415717" X-IronPort-AV: E=Sophos;i="5.82,319,1613462400"; d="scan'208";a="265415717" Received: from fmsmga008.fm.intel.com ([10.253.24.58]) by orsmga105.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 21 May 2021 08:33:19 -0700 IronPort-SDR: an/rbP3i3Qw7qyUIpMsR4IWeilaSxHGLq/+9poV62qH+jD0gxDpxoULZxYppY1gq0Ke9agU4bX I+l6C/GNMQWQ== X-IronPort-AV: E=Sophos;i="5.82,319,1613462400"; d="scan'208";a="441125443" Received: from imarinmo-mobl1.ger.corp.intel.com (HELO thellst-mobl1.intel.com) ([10.249.254.34]) by fmsmga008-auth.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 21 May 2021 08:33:17 -0700 From: =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= To: intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org Date: Fri, 21 May 2021 17:32:48 +0200 Message-Id: <20210521153253.518037-8-thomas.hellstrom@linux.intel.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210521153253.518037-1-thomas.hellstrom@linux.intel.com> References: <20210521153253.518037-1-thomas.hellstrom@linux.intel.com> MIME-Version: 1.0 Subject: [Intel-gfx] [PATCH v3 07/12] drm, drm/i915: Move the memcpy_from_wc functionality to core drm X-BeenThere: intel-gfx@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Intel graphics driver community testing & development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= , =?UTF-8?q?Christian=20K=C3=B6nig?= , Daniel Vetter Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" TWVtY3B5IGZyb20gd2Mgd2lsbCBiZSB1c2VkIGFzIHdlbGwgYnkgVFRNIG1lbWNweS4KTW92ZSBp dCB0byBjb3JlIGRybSwgYW5kIG1ha2UgdGhlIGludGVyZmFjZSBkbyB0aGUgcmlnaHQgdGhpbmcK ZXZlbiBvbiAhWDg2LgoKQ2M6IENocmlzdGlhbiBLw7ZuaWcgPGNocmlzdGlhbi5rb2VuaWdAYW1k LmNvbT4KQ2M6IERhbmllbCBWZXR0ZXIgPGRhbmllbC52ZXR0ZXJAZmZ3bGwuY2g+CkNjOiBEYXZl IEFpcmxpZSA8YWlybGllZEBnbWFpbC5jb20+ClNpZ25lZC1vZmYtYnk6IFRob21hcyBIZWxsc3Ry w7ZtIDx0aG9tYXMuaGVsbHN0cm9tQGxpbnV4LmludGVsLmNvbT4KLS0tCiBkcml2ZXJzL2dwdS9k cm0vTWFrZWZpbGUgICAgICAgICAgICAgICAgICAgICAgfCAgMiArLQogZHJpdmVycy9ncHUvZHJt L2RybV9kcnYuYyAgICAgICAgICAgICAgICAgICAgIHwgIDIgKwogLi4uL2RybS97aTkxNS9pOTE1 X21lbWNweS5jID0+IGRybV9tZW1jcHkuY30gIHwgNjMgKysrKysrKysrKysrKystLS0tLQogZHJp dmVycy9ncHUvZHJtL2k5MTUvTWFrZWZpbGUgICAgICAgICAgICAgICAgIHwgIDEgLQogLi4uL2dw dS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fZXhlY2J1ZmZlci5jICAgIHwgIDQgKy0KIGRyaXZlcnMv Z3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9vYmplY3QuYyAgICB8ICA1ICstCiBkcml2ZXJzL2dw dS9kcm0vaTkxNS9ndC9zZWxmdGVzdF9yZXNldC5jICAgICAgfCAgNyArKy0KIGRyaXZlcnMvZ3B1 L2RybS9pOTE1L2d0L3VjL2ludGVsX2d1Y19sb2cuYyAgICB8IDExICsrLS0KIGRyaXZlcnMvZ3B1 L2RybS9pOTE1L2k5MTVfY21kX3BhcnNlci5jICAgICAgICB8ICA0ICstCiBkcml2ZXJzL2dwdS9k cm0vaTkxNS9pOTE1X2Rydi5jICAgICAgICAgICAgICAgfCAgMiAtCiBkcml2ZXJzL2dwdS9kcm0v aTkxNS9pOTE1X2dwdV9lcnJvci5jICAgICAgICAgfCAgOCArLS0KIGRyaXZlcnMvZ3B1L2RybS9p OTE1L2k5MTVfbWVtY3B5LmggICAgICAgICAgICB8IDM0IC0tLS0tLS0tLS0KIC4uLi9kcm0vaTkx NS9zZWxmdGVzdHMvaW50ZWxfbWVtb3J5X3JlZ2lvbi5jICB8ICA3ICsrLQogaW5jbHVkZS9kcm0v ZHJtX21lbWNweS5oICAgICAgICAgICAgICAgICAgICAgIHwgNDcgKysrKysrKysrKysrKysKIDE0 IGZpbGVzIGNoYW5nZWQsIDEyMSBpbnNlcnRpb25zKCspLCA3NiBkZWxldGlvbnMoLSkKIHJlbmFt ZSBkcml2ZXJzL2dwdS9kcm0ve2k5MTUvaTkxNV9tZW1jcHkuYyA9PiBkcm1fbWVtY3B5LmN9ICg3 MCUpCiBkZWxldGUgbW9kZSAxMDA2NDQgZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9tZW1jcHku aAogY3JlYXRlIG1vZGUgMTAwNjQ0IGluY2x1ZGUvZHJtL2RybV9tZW1jcHkuaAoKZGlmZiAtLWdp dCBhL2RyaXZlcnMvZ3B1L2RybS9NYWtlZmlsZSBiL2RyaXZlcnMvZ3B1L2RybS9NYWtlZmlsZQpp bmRleCBhOTFjYzc2ODQ5MDQuLmYzYWI4NTg2YzNkNyAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUv ZHJtL01ha2VmaWxlCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9NYWtlZmlsZQpAQCAtMTgsNyArMTgs NyBAQCBkcm0teSAgICAgICA6PQlkcm1fYXBlcnR1cmUubyBkcm1fYXV0aC5vIGRybV9jYWNoZS5v IFwKIAkJZHJtX2R1bWJfYnVmZmVycy5vIGRybV9tb2RlX2NvbmZpZy5vIGRybV92YmxhbmsubyBc CiAJCWRybV9zeW5jb2JqLm8gZHJtX2xlYXNlLm8gZHJtX3dyaXRlYmFjay5vIGRybV9jbGllbnQu byBcCiAJCWRybV9jbGllbnRfbW9kZXNldC5vIGRybV9hdG9taWNfdWFwaS5vIGRybV9oZGNwLm8g XAotCQlkcm1fbWFuYWdlZC5vIGRybV92Ymxhbmtfd29yay5vCisJCWRybV9tYW5hZ2VkLm8gZHJt X3ZibGFua193b3JrLm8gZHJtX21lbWNweS5vIFwKIAogZHJtLSQoQ09ORklHX0RSTV9MRUdBQ1kp ICs9IGRybV9hZ3BzdXBwb3J0Lm8gZHJtX2J1ZnMubyBkcm1fY29udGV4dC5vIGRybV9kbWEubyBc CiAJCQkgICAgZHJtX2xlZ2FjeV9taXNjLm8gZHJtX2xvY2subyBkcm1fbWVtb3J5Lm8gZHJtX3Nj YXR0ZXIubyBcCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vZHJtX2Rydi5jIGIvZHJpdmVy cy9ncHUvZHJtL2RybV9kcnYuYwppbmRleCAzZDhkNjhhOThiOTUuLjM1MWNjMjkwMGNmMSAxMDA2 NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2RybV9kcnYuYworKysgYi9kcml2ZXJzL2dwdS9kcm0v ZHJtX2Rydi5jCkBAIC00MCw2ICs0MCw3IEBACiAjaW5jbHVkZSA8ZHJtL2RybV9kcnYuaD4KICNp bmNsdWRlIDxkcm0vZHJtX2ZpbGUuaD4KICNpbmNsdWRlIDxkcm0vZHJtX21hbmFnZWQuaD4KKyNp bmNsdWRlIDxkcm0vZHJtX21lbWNweS5oPgogI2luY2x1ZGUgPGRybS9kcm1fbW9kZV9vYmplY3Qu aD4KICNpbmNsdWRlIDxkcm0vZHJtX3ByaW50Lmg+CiAKQEAgLTEwNDEsNiArMTA0Miw3IEBAIHN0 YXRpYyBpbnQgX19pbml0IGRybV9jb3JlX2luaXQodm9pZCkKIAogCWRybV9jb25uZWN0b3JfaWRh X2luaXQoKTsKIAlpZHJfaW5pdCgmZHJtX21pbm9yc19pZHIpOworCWRybV9tZW1jcHlfaW5pdF9l YXJseSgpOwogCiAJcmV0ID0gZHJtX3N5c2ZzX2luaXQoKTsKIAlpZiAocmV0IDwgMCkgewpkaWZm IC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9tZW1jcHkuYyBiL2RyaXZlcnMvZ3B1 L2RybS9kcm1fbWVtY3B5LmMKc2ltaWxhcml0eSBpbmRleCA3MCUKcmVuYW1lIGZyb20gZHJpdmVy cy9ncHUvZHJtL2k5MTUvaTkxNV9tZW1jcHkuYwpyZW5hbWUgdG8gZHJpdmVycy9ncHUvZHJtL2Ry bV9tZW1jcHkuYwppbmRleCAxYjAyMWE0OTAyZGUuLjc0MDM3Nzc0OWNhYSAxMDA2NDQKLS0tIGEv ZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9tZW1jcHkuYworKysgYi9kcml2ZXJzL2dwdS9kcm0v ZHJtX21lbWNweS5jCkBAIC0xLDMgKzEsNCBAQAorLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6 IE1JVAogLyoKICAqIENvcHlyaWdodCDCqSAyMDE2IEludGVsIENvcnBvcmF0aW9uCiAgKgpAQCAt MjIsMTYgKzIzLDEyIEBACiAgKgogICovCiAKKyNpZmRlZiBDT05GSUdfWDg2CisjaW5jbHVkZSA8 bGludXgvZG1hLWJ1Zi1tYXAuaD4KICNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KICNpbmNsdWRl IDxhc20vZnB1L2FwaS5oPgogCi0jaW5jbHVkZSAiaTkxNV9tZW1jcHkuaCIKLQotI2lmIElTX0VO QUJMRUQoQ09ORklHX0RSTV9JOTE1X0RFQlVHKQotI2RlZmluZSBDSV9CVUdfT04oZXhwcikgQlVH X09OKGV4cHIpCi0jZWxzZQotI2RlZmluZSBDSV9CVUdfT04oZXhwcikgQlVJTERfQlVHX09OX0lO VkFMSUQoZXhwcikKLSNlbmRpZgorI2luY2x1ZGUgImRybS9kcm1fbWVtY3B5LmgiCiAKIHN0YXRp YyBERUZJTkVfU1RBVElDX0tFWV9GQUxTRShoYXNfbW92bnRkcWEpOwogCkBAIC05NCwyMyArOTEs MjQgQEAgc3RhdGljIHZvaWQgX19tZW1jcHlfbnRkcXUodm9pZCAqZHN0LCBjb25zdCB2b2lkICpz cmMsIHVuc2lnbmVkIGxvbmcgbGVuKQogfQogCiAvKioKLSAqIGk5MTVfbWVtY3B5X2Zyb21fd2M6 IHBlcmZvcm0gYW4gYWNjZWxlcmF0ZWQgKmFsaWduZWQqIHJlYWQgZnJvbSBXQworICogZHJtX21l bWNweV9mcm9tX3djOiBwZXJmb3JtIGFuIGFjY2VsZXJhdGVkICphbGlnbmVkKiByZWFkIGZyb20g V0MKICAqIEBkc3Q6IGRlc3RpbmF0aW9uIHBvaW50ZXIKICAqIEBzcmM6IHNvdXJjZSBwb2ludGVy CiAgKiBAbGVuOiBob3cgbWFueSBieXRlcyB0byBjb3B5CiAgKgotICogaTkxNV9tZW1jcHlfZnJv bV93YyBjb3BpZXMgQGxlbiBieXRlcyBmcm9tIEBzcmMgdG8gQGRzdCB1c2luZworICogZHJtX21l bWNweV9mcm9tX3djIGNvcGllcyBAbGVuIGJ5dGVzIGZyb20gQHNyYyB0byBAZHN0IHVzaW5nCiAg KiBub24tdGVtcG9yYWwgaW5zdHJ1Y3Rpb25zIHdoZXJlIGF2YWlsYWJsZS4gTm90ZSB0aGF0IGFs bCBhcmd1bWVudHMKICAqIChAc3JjLCBAZHN0KSBtdXN0IGJlIGFsaWduZWQgdG8gMTYgYnl0ZXMg YW5kIEBsZW4gbXVzdCBiZSBhIG11bHRpcGxlCiAgKiBvZiAxNi4KICAqCiAgKiBUbyB0ZXN0IHdo ZXRoZXIgYWNjZWxlcmF0ZWQgcmVhZHMgZnJvbSBXQyBhcmUgc3VwcG9ydGVkLCB1c2UKLSAqIGk5 MTVfbWVtY3B5X2Zyb21fd2MoTlVMTCwgTlVMTCwgMCk7CisgKiBkcm1fbWVtY3B5X2Zyb21fd2Mo TlVMTCwgTlVMTCwgMCk7CisgKiBUaGlzIGludGVyZmFjZSBpcyBpbnRlbmRlZCBmb3IgbWVtcmVt YXBwZWQgbWVtb3J5IHdpdGhvdXQgdGhlIF9faW9tZW0gdGFnLgogICoKICAqIFJldHVybnMgdHJ1 ZSBpZiB0aGUgY29weSB3YXMgc3VjY2Vzc2Z1bCwgZmFsc2UgaWYgdGhlIHByZWNvbmRpdGlvbnMK ICAqIGFyZSBub3QgbWV0LgogICovCi1ib29sIGk5MTVfbWVtY3B5X2Zyb21fd2Modm9pZCAqZHN0 LCBjb25zdCB2b2lkICpzcmMsIHVuc2lnbmVkIGxvbmcgbGVuKQorYm9vbCBkcm1fbWVtY3B5X2Zy b21fd2Modm9pZCAqZHN0LCBjb25zdCB2b2lkICpzcmMsIHVuc2lnbmVkIGxvbmcgbGVuKQogewog CWlmICh1bmxpa2VseSgoKHVuc2lnbmVkIGxvbmcpZHN0IHwgKHVuc2lnbmVkIGxvbmcpc3JjIHwg bGVuKSAmIDE1KSkKIAkJcmV0dXJuIGZhbHNlOwpAQCAtMTIzLDI0ICsxMjEsNTMgQEAgYm9vbCBp OTE1X21lbWNweV9mcm9tX3djKHZvaWQgKmRzdCwgY29uc3Qgdm9pZCAqc3JjLCB1bnNpZ25lZCBs b25nIGxlbikKIAogCXJldHVybiBmYWxzZTsKIH0KK0VYUE9SVF9TWU1CT0woZHJtX21lbWNweV9m cm9tX3djKTsKIAogLyoqCi0gKiBpOTE1X3VuYWxpZ25lZF9tZW1jcHlfZnJvbV93YzogcGVyZm9y bSBhIG1vc3RseSBhY2NlbGVyYXRlZCByZWFkIGZyb20gV0MKKyAqIGRybV9tZW1jcHlfZnJvbV93 Y19kYm06IHBlcmZvcm0gYW4gYWNjZWxlcmF0ZWQgKmFsaWduZWQqIHJlYWQgZnJvbSBXQyB3aXRo CisgKiBzdHJ1Y3QgZG1hX2J1Zl9tYXAgYXJndW1lbnRzLgorICogQGRzdDogZGVzdGluYXRpb24g bWFwCisgKiBAc3JjOiBzb3VyY2UgbWFwCisgKiBAbGVuOiBob3cgbWFueSBieXRlcyB0byBjb3B5 CisgKgorICogVGhpcyBpcyBpZGVudGljYWwgdG8gZHJtX21lbWNweV9mcm9tX3djLCBleGNlcHQg aXQncyBpbnRlbmRlZCBmb3IKKyAqIHBvdGVudGlhbGx5IGlvcmVtYXBwZWQgbWVtb3J5IHJhdGhl ciB0aGFuIG1lbXJlbWFwcGVkIG1lbW9yeS4KKyAqCisgKiBSZXR1cm5zIHRydWUgaWYgdGhlIGNv cHkgd2FzIHN1Y2Nlc3NmdWwsIGZhbHNlIGlmIHRoZSBwcmVjb25kaXRpb25zCisgKiBhcmUgbm90 IG1ldC4KKyAqLworYm9vbCBkcm1fbWVtY3B5X2Zyb21fd2NfZGJtKHN0cnVjdCBkbWFfYnVmX21h cCAqZHN0LAorCQkJICAgIGNvbnN0IHN0cnVjdCBkbWFfYnVmX21hcCAqc3JjLAorCQkJICAgIHVu c2lnbmVkIGxvbmcgbGVuKQoreworCS8qIEZvciBYODYgd2UgY2FuIHNhZmVseSBkcm9wIF9faW9t ZW0gKi8KKwlyZXR1cm4gZHJtX21lbWNweV9mcm9tX3djKGRzdC0+aXNfaW9tZW0gPworCQkJCSAg KHZvaWQgX19mb3JjZSAqKWRzdC0+dmFkZHJfaW9tZW0gOgorCQkJCSAgZHN0LT52YWRkciwKKwkJ CQkgIHNyYy0+aXNfaW9tZW0gPworCQkJCSAgKHZvaWQgY29uc3QgX19mb3JjZSAqKXNyYy0+dmFk ZHJfaW9tZW0gOgorCQkJCSAgc3JjLT52YWRkciwKKwkJCQkgIGxlbik7Cit9CitFWFBPUlRfU1lN Qk9MKGRybV9tZW1jcHlfZnJvbV93Y19kYm0pOworCisvKioKKyAqIGRybV91bmFsaWduZWRfbWVt Y3B5X2Zyb21fd2M6IHBlcmZvcm0gYSBtb3N0bHkgYWNjZWxlcmF0ZWQgcmVhZCBmcm9tIFdDCiAg KiBAZHN0OiBkZXN0aW5hdGlvbiBwb2ludGVyCiAgKiBAc3JjOiBzb3VyY2UgcG9pbnRlcgogICog QGxlbjogaG93IG1hbnkgYnl0ZXMgdG8gY29weQogICoKLSAqIExpa2UgaTkxNV9tZW1jcHlfZnJv bV93YygpLCB0aGUgdW5hbGlnbmVkIHZhcmlhbnQgY29waWVzIEBsZW4gYnl0ZXMgZnJvbQorICog TGlrZSBkcm1fbWVtY3B5X2Zyb21fd2MoKSwgdGhlIHVuYWxpZ25lZCB2YXJpYW50IGNvcGllcyBA bGVuIGJ5dGVzIGZyb20KICAqIEBzcmMgdG8gQGRzdCB1c2luZyAqIG5vbi10ZW1wb3JhbCBpbnN0 cnVjdGlvbnMgd2hlcmUgYXZhaWxhYmxlLCBidXQKICAqIGFjY2VwdHMgdGhhdCBpdHMgYXJndW1l bnRzIG1heSBub3QgYmUgYWxpZ25lZCwgYnV0IGFyZSB2YWxpZCBmb3IgdGhlCiAgKiBwb3RlbnRp YWwgMTYtYnl0ZSByZWFkIHBhc3QgdGhlIGVuZC4KKyAqCisgKiBUaGlzIGludGVyZmFjZSBpcyBp bnRlbmRlZCBmb3IgbXJlbWFwcGVkIG1lbW9yeSB3aXRob3V0IHRoZSBfX2lvbWVtIHRhZy4KICAq Lwotdm9pZCBpOTE1X3VuYWxpZ25lZF9tZW1jcHlfZnJvbV93Yyh2b2lkICpkc3QsIGNvbnN0IHZv aWQgKnNyYywgdW5zaWduZWQgbG9uZyBsZW4pCit2b2lkIGRybV91bmFsaWduZWRfbWVtY3B5X2Zy b21fd2Modm9pZCAqZHN0LCBjb25zdCB2b2lkICpzcmMsIHVuc2lnbmVkIGxvbmcgbGVuKQogewog CXVuc2lnbmVkIGxvbmcgYWRkcjsKIAotCUNJX0JVR19PTighaTkxNV9oYXNfbWVtY3B5X2Zyb21f d2MoKSk7Ci0KIAlhZGRyID0gKHVuc2lnbmVkIGxvbmcpc3JjOwogCWlmICghSVNfQUxJR05FRChh ZGRyLCAxNikpIHsKIAkJdW5zaWduZWQgbG9uZyB4ID0gbWluKEFMSUdOKGFkZHIsIDE2KSAtIGFk ZHIsIGxlbik7CkBAIC0xNTUsOCArMTgyLDkgQEAgdm9pZCBpOTE1X3VuYWxpZ25lZF9tZW1jcHlf ZnJvbV93Yyh2b2lkICpkc3QsIGNvbnN0IHZvaWQgKnNyYywgdW5zaWduZWQgbG9uZyBsZW4KIAlp ZiAobGlrZWx5KGxlbikpCiAJCV9fbWVtY3B5X250ZHF1KGRzdCwgc3JjLCBESVZfUk9VTkRfVVAo bGVuLCAxNikpOwogfQorRVhQT1JUX1NZTUJPTChkcm1fdW5hbGlnbmVkX21lbWNweV9mcm9tX3dj KTsKIAotdm9pZCBpOTE1X21lbWNweV9pbml0X2Vhcmx5KHN0cnVjdCBkcm1faTkxNV9wcml2YXRl ICpkZXZfcHJpdikKK3ZvaWQgZHJtX21lbWNweV9pbml0X2Vhcmx5KHZvaWQpCiB7CiAJLyoKIAkg KiBTb21lIGh5cGVydmlzb3JzIChlLmcuIEtWTSkgZG9uJ3Qgc3VwcG9ydCBWRVgtcHJlZml4IGlu c3RydWN0aW9ucwpAQCAtMTY2LDMgKzE5NCw0IEBAIHZvaWQgaTkxNV9tZW1jcHlfaW5pdF9lYXJs eShzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYpCiAJICAgICFib290X2NwdV9oYXMo WDg2X0ZFQVRVUkVfSFlQRVJWSVNPUikpCiAJCXN0YXRpY19icmFuY2hfZW5hYmxlKCZoYXNfbW92 bnRkcWEpOwogfQorI2VuZGlmCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9NYWtl ZmlsZSBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L01ha2VmaWxlCmluZGV4IGNiODgyMzU3MDk5Ni4u OTk4NjA2YjdmNDlmIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9NYWtlZmlsZQor KysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9NYWtlZmlsZQpAQCAtNjEsNyArNjEsNiBAQCBpOTE1 LXkgKz0gaTkxNV9kcnYubyBcCiAjIGNvcmUgbGlicmFyeSBjb2RlCiBpOTE1LXkgKz0gXAogCWRt YV9yZXN2X3V0aWxzLm8gXAotCWk5MTVfbWVtY3B5Lm8gXAogCWk5MTVfbW0ubyBcCiAJaTkxNV9z d19mZW5jZS5vIFwKIAlpOTE1X3N3X2ZlbmNlX3dvcmsubyBcCmRpZmYgLS1naXQgYS9kcml2ZXJz L2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fZXhlY2J1ZmZlci5jIGIvZHJpdmVycy9ncHUvZHJt L2k5MTUvZ2VtL2k5MTVfZ2VtX2V4ZWNidWZmZXIuYwppbmRleCAyOTcxNDM1MTFmOTkuLjc3Mjg1 ZTQyMWZiOCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX2V4 ZWNidWZmZXIuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9nZW0vaTkxNV9nZW1fZXhlY2J1 ZmZlci5jCkBAIC0xMCw2ICsxMCw3IEBACiAjaW5jbHVkZSA8bGludXgvdWFjY2Vzcy5oPgogCiAj aW5jbHVkZSA8ZHJtL2RybV9zeW5jb2JqLmg+CisjaW5jbHVkZSA8ZHJtL2RybV9tZW1jcHkuaD4K IAogI2luY2x1ZGUgImRpc3BsYXkvaW50ZWxfZnJvbnRidWZmZXIuaCIKIApAQCAtMjgsNyArMjks NiBAQAogI2luY2x1ZGUgImk5MTVfc3dfZmVuY2Vfd29yay5oIgogI2luY2x1ZGUgImk5MTVfdHJh Y2UuaCIKICNpbmNsdWRlICJpOTE1X3VzZXJfZXh0ZW5zaW9ucy5oIgotI2luY2x1ZGUgImk5MTVf bWVtY3B5LmgiCiAKIHN0cnVjdCBlYl92bWEgewogCXN0cnVjdCBpOTE1X3ZtYSAqdm1hOwpAQCAt MjUwMyw3ICsyNTAzLDcgQEAgc3RhdGljIGludCBlYl9wYXJzZV9waXBlbGluZShzdHJ1Y3QgaTkx NV9leGVjYnVmZmVyICplYiwKIAkJIShiYXRjaC0+Y2FjaGVfY29oZXJlbnQgJiBJOTE1X0JPX0NB Q0hFX0NPSEVSRU5UX0ZPUl9SRUFEKTsKIAogCXB3LT5iYXRjaF9tYXAgPSBFUlJfUFRSKC1FTk9E RVYpOwotCWlmIChuZWVkc19jbGZsdXNoICYmIGk5MTVfaGFzX21lbWNweV9mcm9tX3djKCkpCisJ aWYgKG5lZWRzX2NsZmx1c2ggJiYgZHJtX2hhc19tZW1jcHlfZnJvbV93YygpKQogCQlwdy0+YmF0 Y2hfbWFwID0gaTkxNV9nZW1fb2JqZWN0X3Bpbl9tYXAoYmF0Y2gsIEk5MTVfTUFQX1dDKTsKIAog CWlmIChJU19FUlIocHctPmJhdGNoX21hcCkpIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2Ry bS9pOTE1L2dlbS9pOTE1X2dlbV9vYmplY3QuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9p OTE1X2dlbV9vYmplY3QuYwppbmRleCA1NzA2ZDQ3MTY5MmQuLmU5MjQ3YWZiMDMyMCAxMDA2NDQK LS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ2VtL2k5MTVfZ2VtX29iamVjdC5jCisrKyBiL2Ry aXZlcnMvZ3B1L2RybS9pOTE1L2dlbS9pOTE1X2dlbV9vYmplY3QuYwpAQCAtMjQsNiArMjQsOCBA QAogCiAjaW5jbHVkZSA8bGludXgvc2NoZWQvbW0uaD4KIAorI2luY2x1ZGUgPGRybS9kcm1fbWVt Y3B5Lmg+CisKICNpbmNsdWRlICJkaXNwbGF5L2ludGVsX2Zyb250YnVmZmVyLmgiCiAjaW5jbHVk ZSAiaTkxNV9kcnYuaCIKICNpbmNsdWRlICJpOTE1X2dlbV9jbGZsdXNoLmgiCkBAIC0zMSw3ICsz Myw2IEBACiAjaW5jbHVkZSAiaTkxNV9nZW1fbW1hbi5oIgogI2luY2x1ZGUgImk5MTVfZ2VtX29i amVjdC5oIgogI2luY2x1ZGUgImk5MTVfZ2xvYmFscy5oIgotI2luY2x1ZGUgImk5MTVfbWVtY3B5 LmgiCiAjaW5jbHVkZSAiaTkxNV90cmFjZS5oIgogCiBzdGF0aWMgc3RydWN0IGk5MTVfZ2xvYmFs X29iamVjdCB7CkBAIC0zNzQsNyArMzc1LDcgQEAgaTkxNV9nZW1fb2JqZWN0X3JlYWRfZnJvbV9w YWdlX2lvbWFwKHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmosIHU2NCBvZmZzZXQKIAkJ CQkgICAgUEFHRV9TSVpFKTsKIAogCXNyY19wdHIgPSBzcmNfbWFwICsgb2Zmc2V0X2luX3BhZ2Uo b2Zmc2V0KTsKLQlpZiAoIWk5MTVfbWVtY3B5X2Zyb21fd2MoZHN0LCAodm9pZCBfX2ZvcmNlICop c3JjX3B0ciwgc2l6ZSkpCisJaWYgKCFkcm1fbWVtY3B5X2Zyb21fd2MoZHN0LCAodm9pZCBfX2Zv cmNlICopc3JjX3B0ciwgc2l6ZSkpCiAJCW1lbWNweV9mcm9taW8oZHN0LCBzcmNfcHRyLCBzaXpl KTsKIAogCWlvX21hcHBpbmdfdW5tYXAoc3JjX21hcCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dw dS9kcm0vaTkxNS9ndC9zZWxmdGVzdF9yZXNldC5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3Qv c2VsZnRlc3RfcmVzZXQuYwppbmRleCA4Nzg0MjU3ZWM4MDguLjkyYWRhNjdhMzgzNSAxMDA2NDQK LS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3Qvc2VsZnRlc3RfcmVzZXQuYworKysgYi9kcml2 ZXJzL2dwdS9kcm0vaTkxNS9ndC9zZWxmdGVzdF9yZXNldC5jCkBAIC01LDkgKzUsMTAgQEAKIAog I2luY2x1ZGUgPGxpbnV4L2NyYzMyLmg+CiAKKyNpbmNsdWRlIDxkcm0vZHJtX21lbWNweS5oPgor CiAjaW5jbHVkZSAiZ2VtL2k5MTVfZ2VtX3N0b2xlbi5oIgogCi0jaW5jbHVkZSAiaTkxNV9tZW1j cHkuaCIKICNpbmNsdWRlICJpOTE1X3NlbGZ0ZXN0LmgiCiAjaW5jbHVkZSAiaW50ZWxfZ3B1X2Nv bW1hbmRzLmgiCiAjaW5jbHVkZSAic2VsZnRlc3RzL2lndF9yZXNldC5oIgpAQCAtOTksNyArMTAw LDcgQEAgX19pZ3RfcmVzZXRfc3RvbGVuKHN0cnVjdCBpbnRlbF9ndCAqZ3QsCiAJCQltZW1zZXRf aW8ocywgU1RBQ0tfTUFHSUMsIFBBR0VfU0laRSk7CiAKIAkJaW4gPSAodm9pZCBfX2ZvcmNlICop czsKLQkJaWYgKGk5MTVfbWVtY3B5X2Zyb21fd2ModG1wLCBpbiwgUEFHRV9TSVpFKSkKKwkJaWYg KGRybV9tZW1jcHlfZnJvbV93Yyh0bXAsIGluLCBQQUdFX1NJWkUpKQogCQkJaW4gPSB0bXA7CiAJ CWNyY1twYWdlXSA9IGNyYzMyX2xlKDAsIGluLCBQQUdFX1NJWkUpOwogCkBAIC0xMzUsNyArMTM2 LDcgQEAgX19pZ3RfcmVzZXRfc3RvbGVuKHN0cnVjdCBpbnRlbF9ndCAqZ3QsCiAJCQkJICAgICAg UEFHRV9TSVpFKTsKIAogCQlpbiA9ICh2b2lkIF9fZm9yY2UgKilzOwotCQlpZiAoaTkxNV9tZW1j cHlfZnJvbV93Yyh0bXAsIGluLCBQQUdFX1NJWkUpKQorCQlpZiAoZHJtX21lbWNweV9mcm9tX3dj KHRtcCwgaW4sIFBBR0VfU0laRSkpCiAJCQlpbiA9IHRtcDsKIAkJeCA9IGNyYzMyX2xlKDAsIGlu LCBQQUdFX1NJWkUpOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC91Yy9p bnRlbF9ndWNfbG9nLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC91Yy9pbnRlbF9ndWNfbG9n LmMKaW5kZXggYzM2ZDVlYjViYmI5Li5mMDQ1ZTQyYmU2Y2EgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMv Z3B1L2RybS9pOTE1L2d0L3VjL2ludGVsX2d1Y19sb2cuYworKysgYi9kcml2ZXJzL2dwdS9kcm0v aTkxNS9ndC91Yy9pbnRlbF9ndWNfbG9nLmMKQEAgLTUsOSArNSwxMCBAQAogCiAjaW5jbHVkZSA8 bGludXgvZGVidWdmcy5oPgogCisjaW5jbHVkZSA8ZHJtL2RybV9tZW1jcHkuaD4KKwogI2luY2x1 ZGUgImd0L2ludGVsX2d0LmgiCiAjaW5jbHVkZSAiaTkxNV9kcnYuaCIKLSNpbmNsdWRlICJpOTE1 X21lbWNweS5oIgogI2luY2x1ZGUgImludGVsX2d1Y19sb2cuaCIKIAogc3RhdGljIHZvaWQgZ3Vj X2xvZ19jYXB0dXJlX2xvZ3Moc3RydWN0IGludGVsX2d1Y19sb2cgKmxvZyk7CkBAIC0yOTUsMTMg KzI5NiwxMyBAQCBzdGF0aWMgdm9pZCBndWNfcmVhZF91cGRhdGVfbG9nX2J1ZmZlcihzdHJ1Y3Qg aW50ZWxfZ3VjX2xvZyAqbG9nKQogCiAJCS8qIEp1c3QgY29weSB0aGUgbmV3bHkgd3JpdHRlbiBk YXRhICovCiAJCWlmIChyZWFkX29mZnNldCA+IHdyaXRlX29mZnNldCkgewotCQkJaTkxNV9tZW1j cHlfZnJvbV93Yyhkc3RfZGF0YSwgc3JjX2RhdGEsIHdyaXRlX29mZnNldCk7CisJCQlkcm1fbWVt Y3B5X2Zyb21fd2MoZHN0X2RhdGEsIHNyY19kYXRhLCB3cml0ZV9vZmZzZXQpOwogCQkJYnl0ZXNf dG9fY29weSA9IGJ1ZmZlcl9zaXplIC0gcmVhZF9vZmZzZXQ7CiAJCX0gZWxzZSB7CiAJCQlieXRl c190b19jb3B5ID0gd3JpdGVfb2Zmc2V0IC0gcmVhZF9vZmZzZXQ7CiAJCX0KLQkJaTkxNV9tZW1j cHlfZnJvbV93Yyhkc3RfZGF0YSArIHJlYWRfb2Zmc2V0LAotCQkJCSAgICBzcmNfZGF0YSArIHJl YWRfb2Zmc2V0LCBieXRlc190b19jb3B5KTsKKwkJZHJtX21lbWNweV9mcm9tX3djKGRzdF9kYXRh ICsgcmVhZF9vZmZzZXQsCisJCQkJICAgc3JjX2RhdGEgKyByZWFkX29mZnNldCwgYnl0ZXNfdG9f Y29weSk7CiAKIAkJc3JjX2RhdGEgKz0gYnVmZmVyX3NpemU7CiAJCWRzdF9kYXRhICs9IGJ1ZmZl cl9zaXplOwpAQCAtNTY5LDcgKzU3MCw3IEBAIGludCBpbnRlbF9ndWNfbG9nX3JlbGF5X29wZW4o c3RydWN0IGludGVsX2d1Y19sb2cgKmxvZykKIAkgKiBpdCBzaG91bGQgYmUgcHJlc2VudCBvbiB0 aGUgY2hpcHNldHMgc3VwcG9ydGluZyBHdUMgYmFzZWQKIAkgKiBzdWJtaXNzc2lvbnMuCiAJICov Ci0JaWYgKCFpOTE1X2hhc19tZW1jcHlfZnJvbV93YygpKSB7CisJaWYgKCFkcm1faGFzX21lbWNw eV9mcm9tX3djKCkpIHsKIAkJcmV0ID0gLUVOWElPOwogCQlnb3RvIG91dF91bmxvY2s7CiAJfQpk aWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9jbWRfcGFyc2VyLmMgYi9kcml2 ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2NtZF9wYXJzZXIuYwppbmRleCA1YjRiMmJkNDZlN2MuLjk4 NjUzZjFhMmIxZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9jbWRfcGFy c2VyLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9jbWRfcGFyc2VyLmMKQEAgLTI0 LDEyICsyNCwxMiBAQAogICogICAgQnJhZCBWb2xraW4gPGJyYWRsZXkuZC52b2xraW5AaW50ZWwu Y29tPgogICoKICAqLworI2luY2x1ZGUgPGRybS9kcm1fbWVtY3B5Lmg+CiAKICNpbmNsdWRlICJn dC9pbnRlbF9lbmdpbmUuaCIKICNpbmNsdWRlICJndC9pbnRlbF9ncHVfY29tbWFuZHMuaCIKIAog I2luY2x1ZGUgImk5MTVfZHJ2LmgiCi0jaW5jbHVkZSAiaTkxNV9tZW1jcHkuaCIKIAogLyoqCiAg KiBET0M6IGJhdGNoIGJ1ZmZlciBjb21tYW5kIHBhcnNlcgpAQCAtMTE1Miw3ICsxMTUyLDcgQEAg c3RhdGljIHUzMiAqY29weV9iYXRjaChzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqZHN0X29i aiwKIAogCWlmIChzcmMpIHsKIAkJR0VNX0JVR19PTighbmVlZHNfY2xmbHVzaCk7Ci0JCWk5MTVf dW5hbGlnbmVkX21lbWNweV9mcm9tX3djKGRzdCwgc3JjICsgb2Zmc2V0LCBsZW5ndGgpOworCQlk cm1fdW5hbGlnbmVkX21lbWNweV9mcm9tX3djKGRzdCwgc3JjICsgb2Zmc2V0LCBsZW5ndGgpOwog CX0gZWxzZSB7CiAJCXN0cnVjdCBzY2F0dGVybGlzdCAqc2c7CiAJCXZvaWQgKnB0cjsKZGlmZiAt LWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZHJ2LmMgYi9kcml2ZXJzL2dwdS9kcm0v aTkxNS9pOTE1X2Rydi5jCmluZGV4IDEyMmRkMjk3YjZhZi4uMGRmOWRkNjJjNzE3IDEwMDY0NAot LS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2Rydi5jCisrKyBiL2RyaXZlcnMvZ3B1L2Ry bS9pOTE1L2k5MTVfZHJ2LmMKQEAgLTcyLDcgKzcyLDYgQEAKICNpbmNsdWRlICJpOTE1X2Rydi5o IgogI2luY2x1ZGUgImk5MTVfaW9jMzIuaCIKICNpbmNsdWRlICJpOTE1X2lycS5oIgotI2luY2x1 ZGUgImk5MTVfbWVtY3B5LmgiCiAjaW5jbHVkZSAiaTkxNV9wZXJmLmgiCiAjaW5jbHVkZSAiaTkx NV9xdWVyeS5oIgogI2luY2x1ZGUgImk5MTVfc3VzcGVuZC5oIgpAQCAtMzI1LDcgKzMyNCw2IEBA IHN0YXRpYyBpbnQgaTkxNV9kcml2ZXJfZWFybHlfcHJvYmUoc3RydWN0IGRybV9pOTE1X3ByaXZh dGUgKmRldl9wcml2KQogCW11dGV4X2luaXQoJmRldl9wcml2LT5wcHNfbXV0ZXgpOwogCW11dGV4 X2luaXQoJmRldl9wcml2LT5oZGNwX2NvbXBfbXV0ZXgpOwogCi0JaTkxNV9tZW1jcHlfaW5pdF9l YXJseShkZXZfcHJpdik7CiAJaW50ZWxfcnVudGltZV9wbV9pbml0X2Vhcmx5KCZkZXZfcHJpdi0+ cnVudGltZV9wbSk7CiAKIAlyZXQgPSBpOTE1X3dvcmtxdWV1ZXNfaW5pdChkZXZfcHJpdik7CmRp ZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2dwdV9lcnJvci5jIGIvZHJpdmVy cy9ncHUvZHJtL2k5MTUvaTkxNV9ncHVfZXJyb3IuYwppbmRleCA5OWNhMjQyZWMxM2IuLmVlMTE5 MjBmYmVhNSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9ncHVfZXJyb3Iu YworKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2dwdV9lcnJvci5jCkBAIC0zNCw2ICsz NCw3IEBACiAjaW5jbHVkZSA8bGludXgvdXRzbmFtZS5oPgogI2luY2x1ZGUgPGxpbnV4L3psaWIu aD4KIAorI2luY2x1ZGUgPGRybS9kcm1fbWVtY3B5Lmg+CiAjaW5jbHVkZSA8ZHJtL2RybV9wcmlu dC5oPgogCiAjaW5jbHVkZSAiZGlzcGxheS9pbnRlbF9jc3IuaCIKQEAgLTQ2LDcgKzQ3LDYgQEAK IAogI2luY2x1ZGUgImk5MTVfZHJ2LmgiCiAjaW5jbHVkZSAiaTkxNV9ncHVfZXJyb3IuaCIKLSNp bmNsdWRlICJpOTE1X21lbWNweS5oIgogI2luY2x1ZGUgImk5MTVfc2NhdHRlcmxpc3QuaCIKIAog I2RlZmluZSBBTExPV19GQUlMIChHRlBfS0VSTkVMIHwgX19HRlBfUkVUUllfTUFZRkFJTCB8IF9f R0ZQX05PV0FSTikKQEAgLTI1NSw3ICsyNTUsNyBAQCBzdGF0aWMgYm9vbCBjb21wcmVzc19pbml0 KHN0cnVjdCBpOTE1X3ZtYV9jb21wcmVzcyAqYykKIAl9CiAKIAljLT50bXAgPSBOVUxMOwotCWlm IChpOTE1X2hhc19tZW1jcHlfZnJvbV93YygpKQorCWlmIChkcm1faGFzX21lbWNweV9mcm9tX3dj KCkpCiAJCWMtPnRtcCA9IHBvb2xfYWxsb2MoJmMtPnBvb2wsIEFMTE9XX0ZBSUwpOwogCiAJcmV0 dXJuIHRydWU7CkBAIC0yOTUsNyArMjk1LDcgQEAgc3RhdGljIGludCBjb21wcmVzc19wYWdlKHN0 cnVjdCBpOTE1X3ZtYV9jb21wcmVzcyAqYywKIAlzdHJ1Y3Qgel9zdHJlYW1fcyAqenN0cmVhbSA9 ICZjLT56c3RyZWFtOwogCiAJenN0cmVhbS0+bmV4dF9pbiA9IHNyYzsKLQlpZiAod2MgJiYgYy0+ dG1wICYmIGk5MTVfbWVtY3B5X2Zyb21fd2MoYy0+dG1wLCBzcmMsIFBBR0VfU0laRSkpCisJaWYg KHdjICYmIGMtPnRtcCAmJiBkcm1fbWVtY3B5X2Zyb21fd2MoYy0+dG1wLCBzcmMsIFBBR0VfU0la RSkpCiAJCXpzdHJlYW0tPm5leHRfaW4gPSBjLT50bXA7CiAJenN0cmVhbS0+YXZhaWxfaW4gPSBQ QUdFX1NJWkU7CiAKQEAgLTM5NSw3ICszOTUsNyBAQCBzdGF0aWMgaW50IGNvbXByZXNzX3BhZ2Uo c3RydWN0IGk5MTVfdm1hX2NvbXByZXNzICpjLAogCWlmICghcHRyKQogCQlyZXR1cm4gLUVOT01F TTsKIAotCWlmICghKHdjICYmIGk5MTVfbWVtY3B5X2Zyb21fd2MocHRyLCBzcmMsIFBBR0VfU0la RSkpKQorCWlmICghKHdjICYmIGRybV9tZW1jcHlfZnJvbV93YyhwdHIsIHNyYywgUEFHRV9TSVpF KSkpCiAJCW1lbWNweShwdHIsIHNyYywgUEFHRV9TSVpFKTsKIAlkc3QtPnBhZ2VzW2RzdC0+cGFn ZV9jb3VudCsrXSA9IHB0cjsKIAljb25kX3Jlc2NoZWQoKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMv Z3B1L2RybS9pOTE1L2k5MTVfbWVtY3B5LmggYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X21l bWNweS5oCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAzZGYwNjNhMzI5M2IuLjAwMDAw MDAwMDAwMAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X21lbWNweS5oCisrKyAvZGV2 L251bGwKQEAgLTEsMzQgKzAsMCBAQAotLyogU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IE1JVCAq LwotLyoKLSAqIENvcHlyaWdodCDCqSAyMDE5IEludGVsIENvcnBvcmF0aW9uCi0gKi8KLQotI2lm bmRlZiBfX0k5MTVfTUVNQ1BZX0hfXwotI2RlZmluZSBfX0k5MTVfTUVNQ1BZX0hfXwotCi0jaW5j bHVkZSA8bGludXgvdHlwZXMuaD4KLQotc3RydWN0IGRybV9pOTE1X3ByaXZhdGU7Ci0KLXZvaWQg aTkxNV9tZW1jcHlfaW5pdF9lYXJseShzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqaTkxNSk7Ci0K LWJvb2wgaTkxNV9tZW1jcHlfZnJvbV93Yyh2b2lkICpkc3QsIGNvbnN0IHZvaWQgKnNyYywgdW5z aWduZWQgbG9uZyBsZW4pOwotdm9pZCBpOTE1X3VuYWxpZ25lZF9tZW1jcHlfZnJvbV93Yyh2b2lk ICpkc3QsIGNvbnN0IHZvaWQgKnNyYywgdW5zaWduZWQgbG9uZyBsZW4pOwotCi0vKiBUaGUgbW92 bnRkcWEgaW5zdHJ1Y3Rpb25zIHVzZWQgZm9yIG1lbWNweS1mcm9tLXdjIHJlcXVpcmUgMTYtYnl0 ZSBhbGlnbm1lbnQsCi0gKiBhcyB3ZWxsIGFzIFNTRTQuMSBzdXBwb3J0LiBpOTE1X21lbWNweV9m cm9tX3djKCkgd2lsbCByZXBvcnQgaWYgaXQgY2Fubm90Ci0gKiBwZXJmb3JtIHRoZSBvcGVyYXRp b24uIFRvIGNoZWNrIGJlZm9yZWhhbmQsIHBhc3MgaW4gdGhlIHBhcmFtZXRlcnMgdG8KLSAqIHRv IGk5MTVfY2FuX21lbWNweV9mcm9tX3djKCkgLSBzaW5jZSB3ZSBvbmx5IGNhcmUgYWJvdXQgdGhl IGxvdyA0IGJpdHMsCi0gKiB5b3Ugb25seSBuZWVkIHRvIHBhc3MgaW4gdGhlIG1pbm9yIG9mZnNl dHMsIHBhZ2UtYWxpZ25lZCBwb2ludGVycyBhcmUKLSAqIGFsd2F5cyB2YWxpZC4KLSAqCi0gKiBG b3IganVzdCBjaGVja2luZyBmb3IgU1NFNC4xLCBpbiB0aGUgZm9yZWtub3dsZWRnZSB0aGF0IHRo ZSBmdXR1cmUgdXNlCi0gKiB3aWxsIGJlIGNvcnJlY3RseSBhbGlnbmVkLCBqdXN0IHVzZSBpOTE1 X2hhc19tZW1jcHlfZnJvbV93YygpLgotICovCi0jZGVmaW5lIGk5MTVfY2FuX21lbWNweV9mcm9t X3djKGRzdCwgc3JjLCBsZW4pIFwKLQlpOTE1X21lbWNweV9mcm9tX3djKCh2b2lkICopKCh1bnNp Z25lZCBsb25nKShkc3QpIHwgKHVuc2lnbmVkIGxvbmcpKHNyYykgfCAobGVuKSksIE5VTEwsIDAp Ci0KLSNkZWZpbmUgaTkxNV9oYXNfbWVtY3B5X2Zyb21fd2MoKSBcCi0JaTkxNV9tZW1jcHlfZnJv bV93YyhOVUxMLCBOVUxMLCAwKQotCi0jZW5kaWYgLyogX19JOTE1X01FTUNQWV9IX18gKi8KZGlm ZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L3NlbGZ0ZXN0cy9pbnRlbF9tZW1vcnlfcmVn aW9uLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9zZWxmdGVzdHMvaW50ZWxfbWVtb3J5X3JlZ2lv bi5jCmluZGV4IGM4NWQ1MTZiODVjZC4uNmJiMzk5ZTliZTc4IDEwMDY0NAotLS0gYS9kcml2ZXJz L2dwdS9kcm0vaTkxNS9zZWxmdGVzdHMvaW50ZWxfbWVtb3J5X3JlZ2lvbi5jCisrKyBiL2RyaXZl cnMvZ3B1L2RybS9pOTE1L3NlbGZ0ZXN0cy9pbnRlbF9tZW1vcnlfcmVnaW9uLmMKQEAgLTYsNiAr Niw4IEBACiAjaW5jbHVkZSA8bGludXgvcHJpbWVfbnVtYmVycy5oPgogI2luY2x1ZGUgPGxpbnV4 L3NvcnQuaD4KIAorI2luY2x1ZGUgPGRybS9kcm1fbWVtY3B5Lmg+CisKICNpbmNsdWRlICIuLi9p OTE1X3NlbGZ0ZXN0LmgiCiAKICNpbmNsdWRlICJtb2NrX2RybS5oIgpAQCAtMjAsNyArMjIsNiBA QAogI2luY2x1ZGUgImdlbS9zZWxmdGVzdHMvbW9ja19jb250ZXh0LmgiCiAjaW5jbHVkZSAiZ3Qv aW50ZWxfZW5naW5lX3VzZXIuaCIKICNpbmNsdWRlICJndC9pbnRlbF9ndC5oIgotI2luY2x1ZGUg Imk5MTVfbWVtY3B5LmgiCiAjaW5jbHVkZSAic2VsZnRlc3RzL2lndF9mbHVzaF90ZXN0LmgiCiAj aW5jbHVkZSAic2VsZnRlc3RzL2k5MTVfcmFuZG9tLmgiCiAKQEAgLTkwMSw3ICs5MDIsNyBAQCBz dGF0aWMgaW5saW5lIHZvaWQgaWd0X21lbWNweSh2b2lkICpkc3QsIGNvbnN0IHZvaWQgKnNyYywg c2l6ZV90IHNpemUpCiAKIHN0YXRpYyBpbmxpbmUgdm9pZCBpZ3RfbWVtY3B5X2Zyb21fd2Modm9p ZCAqZHN0LCBjb25zdCB2b2lkICpzcmMsIHNpemVfdCBzaXplKQogewotCWk5MTVfbWVtY3B5X2Zy b21fd2MoZHN0LCBzcmMsIHNpemUpOworCWRybV9tZW1jcHlfZnJvbV93Yyhkc3QsIHNyYywgc2l6 ZSk7CiB9CiAKIHN0YXRpYyBpbnQgX3BlcmZfbWVtY3B5KHN0cnVjdCBpbnRlbF9tZW1vcnlfcmVn aW9uICpzcmNfbXIsCkBAIC05MjUsNyArOTI2LDcgQEAgc3RhdGljIGludCBfcGVyZl9tZW1jcHko c3RydWN0IGludGVsX21lbW9yeV9yZWdpb24gKnNyY19tciwKIAkJewogCQkJIm1lbWNweV9mcm9t X3djIiwKIAkJCWlndF9tZW1jcHlfZnJvbV93YywKLQkJCSFpOTE1X2hhc19tZW1jcHlfZnJvbV93 YygpLAorCQkJIWRybV9oYXNfbWVtY3B5X2Zyb21fd2MoKSwKIAkJfSwKIAl9OwogCXN0cnVjdCBk cm1faTkxNV9nZW1fb2JqZWN0ICpzcmMsICpkc3Q7CmRpZmYgLS1naXQgYS9pbmNsdWRlL2RybS9k cm1fbWVtY3B5LmggYi9pbmNsdWRlL2RybS9kcm1fbWVtY3B5LmgKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMDAwMDAwLi5iMWQ3MDk3NTNiNGQKLS0tIC9kZXYvbnVsbAorKysgYi9p bmNsdWRlL2RybS9kcm1fbWVtY3B5LmgKQEAgLTAsMCArMSw0NyBAQAorLyogU1BEWC1MaWNlbnNl LUlkZW50aWZpZXI6IE1JVCAqLworLyoKKyAqIENvcHlyaWdodCDCqSAyMDE5IEludGVsIENvcnBv cmF0aW9uCisgKi8KKworI2lmbmRlZiBfX0RSTV9NRU1DUFlfSF9fCisjZGVmaW5lIF9fRFJNX01F TUNQWV9IX18KKworI2luY2x1ZGUgPGxpbnV4L3R5cGVzLmg+CisKK3N0cnVjdCBkbWFfYnVmX21h cDsKKworI2lmZGVmIENPTkZJR19YODYKK2Jvb2wgZHJtX21lbWNweV9mcm9tX3djKHZvaWQgKmRz dCwgY29uc3Qgdm9pZCAqc3JjLCB1bnNpZ25lZCBsb25nIGxlbik7Citib29sIGRybV9tZW1jcHlf ZnJvbV93Y19kYm0oc3RydWN0IGRtYV9idWZfbWFwICpkc3QsCisJCQkgICAgY29uc3Qgc3RydWN0 IGRtYV9idWZfbWFwICpzcmMsCisJCQkgICAgdW5zaWduZWQgbG9uZyBsZW4pOwordm9pZCBkcm1f dW5hbGlnbmVkX21lbWNweV9mcm9tX3djKHZvaWQgKmRzdCwgY29uc3Qgdm9pZCAqc3JjLCB1bnNp Z25lZCBsb25nIGxlbik7CisKKy8qIFRoZSBtb3ZudGRxYSBpbnN0cnVjdGlvbnMgdXNlZCBmb3Ig bWVtY3B5LWZyb20td2MgcmVxdWlyZSAxNi1ieXRlIGFsaWdubWVudCwKKyAqIGFzIHdlbGwgYXMg U1NFNC4xIHN1cHBvcnQuIGRybV9tZW1jcHlfZnJvbV93YygpIHdpbGwgcmVwb3J0IGlmIGl0IGNh bm5vdAorICogcGVyZm9ybSB0aGUgb3BlcmF0aW9uLiBUbyBjaGVjayBiZWZvcmVoYW5kLCBwYXNz IGluIHRoZSBwYXJhbWV0ZXJzIHRvCisgKiBkcm1fY2FuX21lbWNweV9mcm9tX3djKCkgLSBzaW5j ZSB3ZSBvbmx5IGNhcmUgYWJvdXQgdGhlIGxvdyA0IGJpdHMsCisgKiB5b3Ugb25seSBuZWVkIHRv IHBhc3MgaW4gdGhlIG1pbm9yIG9mZnNldHMsIHBhZ2UtYWxpZ25lZCBwb2ludGVycyBhcmUKKyAq IGFsd2F5cyB2YWxpZC4KKyAqCisgKiBGb3IganVzdCBjaGVja2luZyBmb3IgU1NFNC4xLCBpbiB0 aGUgZm9yZWtub3dsZWRnZSB0aGF0IHRoZSBmdXR1cmUgdXNlCisgKiB3aWxsIGJlIGNvcnJlY3Rs eSBhbGlnbmVkLCBqdXN0IHVzZSBkcm1faGFzX21lbWNweV9mcm9tX3djKCkuCisgKi8KKyNkZWZp bmUgZHJtX2Nhbl9tZW1jcHlfZnJvbV93Yyhkc3QsIHNyYywgbGVuKSBcCisJZHJtX21lbWNweV9m cm9tX3djKCh2b2lkICopKCh1bnNpZ25lZCBsb25nKShkc3QpIHwgKHVuc2lnbmVkIGxvbmcpKHNy YykgfCAobGVuKSksIE5VTEwsIDApCisKKyNkZWZpbmUgZHJtX2hhc19tZW1jcHlfZnJvbV93Yygp IFwKKwlkcm1fbWVtY3B5X2Zyb21fd2MoTlVMTCwgTlVMTCwgMCkKKwordm9pZCBkcm1fbWVtY3B5 X2luaXRfZWFybHkodm9pZCk7CisKKyNlbHNlCisKKyNkZWZpbmUgZHJtX21lbWNweV9mcm9tX3dj KF9kc3QsIF9zcmMsIF9sZW4pIChmYWxzZSkKKyNkZWZpbmUgZHJtX21lbWNweV9mcm9tX3djX2Ri bShfZHN0LCBfc3JjLCBfbGVuKSAoZmFsc2UpCisjZGVmaW5lIGRybV9jYW5fbWVtY3B5X2Zyb21f d2MoX2RzdCwgX3NyYywgX2xlbikgKGZhbHNlKQorI2RlZmluZSBkcm1faGFzX21lbWNweV9mcm9t X3djKCkgKGZhbHNlKQorI2RlZmluZSBkcm1fdW5hbGlnbmVkX21lbWNweV9mcm9tX3djKF9kc3Qs IF9zcmMsIF9sZW4pIFdBUk5fT04oMSkKKyNkZWZpbmUgZHJtX21lbWNweV9pbml0X2Vhcmx5KCkg ZG8ge30gd2hpbGUgKDApCisjZW5kaWYgLyogQ09ORklHX1g4NiAqLworI2VuZGlmIC8qIF9fRFJN X01FTUNQWV9IX18gKi8KLS0gCjIuMzEuMQoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX18KSW50ZWwtZ2Z4IG1haWxpbmcgbGlzdApJbnRlbC1nZnhAbGlzdHMu ZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlz dGluZm8vaW50ZWwtZ2Z4Cg==