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=-8.8 required=3.0 tests=DKIM_INVALID,DKIM_SIGNED, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=unavailable 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 E3E45C28CC1 for ; Wed, 29 May 2019 20:56:04 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id A8FC7241CB for ; Wed, 29 May 2019 20:56:04 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="key not found in DNS" (0-bit key) header.d=codeaurora.org header.i=@codeaurora.org header.b="fbvQjTni"; dkim=fail reason="key not found in DNS" (0-bit key) header.d=codeaurora.org header.i=@codeaurora.org header.b="mMU42Z0D" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726604AbfE2Uzp (ORCPT ); Wed, 29 May 2019 16:55:45 -0400 Received: from smtp.codeaurora.org ([198.145.29.96]:58108 "EHLO smtp.codeaurora.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726944AbfE2Uzn (ORCPT ); Wed, 29 May 2019 16:55:43 -0400 Received: by smtp.codeaurora.org (Postfix, from userid 1000) id 1993861795; Wed, 29 May 2019 20:55:40 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=codeaurora.org; s=default; t=1559163341; bh=YSKIV6DFCr7JB08CB8IZHjgCrJtdnzcRYTSNMf5lgv8=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=fbvQjTnihQExgjwE53rY+mjWvZ9cz464+UmqWCjHukvj8PfK7b3608wy3zx2bpOLY +3OJAiw1ncx1qDztVtZoG+W60lekuPzYd55vy0fQXocSbitfx3Ode3oucvZTnD3Jwi mjQF+KVyWCHCqRAiHD5erFZEV1t/0+cE1r1+6fIo= Received: from jcrouse1-lnx.qualcomm.com (i-global254.qualcomm.com [199.106.103.254]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-SHA256 (128/128 bits)) (No client certificate requested) (Authenticated sender: jcrouse@smtp.codeaurora.org) by smtp.codeaurora.org (Postfix) with ESMTPSA id 3633861795; Wed, 29 May 2019 20:55:33 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=codeaurora.org; s=default; t=1559163337; bh=YSKIV6DFCr7JB08CB8IZHjgCrJtdnzcRYTSNMf5lgv8=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=mMU42Z0DjK6EOxT6wrMdqw+wv2PtWTVYWimS1JK4Y3L3YyDahGZi613pFXaDzYkjh BsCNhDXg1+HB1v+OX1QcEzQNm+hUH8XopPOfmfzTxyoZgsU2j65UVZz7q/dXZrhV7H CTXlx8x0xohDeYKssgM42RHb2zE7vYBHuUncYlzY= DMARC-Filter: OpenDMARC Filter v1.3.2 smtp.codeaurora.org 3633861795 Authentication-Results: pdx-caf-mail.web.codeaurora.org; dmarc=none (p=none dis=none) header.from=codeaurora.org Authentication-Results: pdx-caf-mail.web.codeaurora.org; spf=none smtp.mailfrom=jcrouse@codeaurora.org From: Jordan Crouse To: freedreno@lists.freedesktop.org Cc: jean-philippe.brucker@arm.com, linux-arm-msm@vger.kernel.org, hoegsberg@google.com, dianders@chromium.org, Sean Paul , Kees Cook , Thomas Zimmermann , Sharat Masetty , dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org, Rob Clark , David Airlie , Jonathan Marek , Mamta Shukla , Daniel Vetter Subject: [PATCH v3 10/16] drm/msm/gpu: Move address space setup to the GPU targets Date: Wed, 29 May 2019 14:54:46 -0600 Message-Id: <1559163292-4792-11-git-send-email-jcrouse@codeaurora.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1559163292-4792-1-git-send-email-jcrouse@codeaurora.org> References: <1559163292-4792-1-git-send-email-jcrouse@codeaurora.org> Sender: linux-arm-msm-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-arm-msm@vger.kernel.org Move the address space steup code out of the generic msm GPU code to to the individual GPU targets. This allows us to do target specific setup such as gpummu for a2xx or split pagetables and per-instance pagetables for newer a5xx and a6xx targets. All this is at the expense of duplicated code in some of the target files but I think it pays for itself in improved code flow and flexibility. v3: change NULl return to ERR_PTR in address space create functions Signed-off-by: Jordan Crouse --- drivers/gpu/drm/msm/adreno/a2xx_gpu.c | 37 ++++++++++++++++------ drivers/gpu/drm/msm/adreno/a3xx_gpu.c | 50 ++++++++++++++++++++++-------- drivers/gpu/drm/msm/adreno/a4xx_gpu.c | 51 +++++++++++++++++++++++-------- drivers/gpu/drm/msm/adreno/a5xx_gpu.c | 37 +++++++++++++++++++--- drivers/gpu/drm/msm/adreno/a6xx_gpu.c | 37 +++++++++++++++++++--- drivers/gpu/drm/msm/adreno/adreno_gpu.c | 7 ----- drivers/gpu/drm/msm/msm_gem.h | 1 + drivers/gpu/drm/msm/msm_gpu.c | 54 ++------------------------------- drivers/gpu/drm/msm/msm_gpu.h | 2 ++ 9 files changed, 173 insertions(+), 103 deletions(-) diff --git a/drivers/gpu/drm/msm/adreno/a2xx_gpu.c b/drivers/gpu/drm/msm/adreno/a2xx_gpu.c index 1f83bc1..49241d0 100644 --- a/drivers/gpu/drm/msm/adreno/a2xx_gpu.c +++ b/drivers/gpu/drm/msm/adreno/a2xx_gpu.c @@ -401,6 +401,30 @@ static struct msm_gpu_state *a2xx_gpu_state_get(struct msm_gpu *gpu) return state; } +static struct msm_gem_address_space * +a2xx_create_address_space(struct msm_gpu *gpu) +{ + struct msm_gem_address_space *aspace; + int ret; + + aspace = msm_gem_address_space_create_a2xx(&gpu->pdev->dev, gpu, + "gpu", SZ_16M, SZ_16M + 0xff * SZ_64K); + if (IS_ERR(aspace)) { + DRM_DEV_ERROR(gpu->dev->dev, + "No memory protection without MMU\n"); + return ERR_PTR(-ENXIO); + } + + ret = aspace->mmu->funcs->attach(aspace->mmu, NULL, 0); + if (ret) { + msm_gem_address_space_put(aspace); + return ERR_PTR(ret); + } + + return aspace; +} + + /* Register offset defines for A2XX - copy of A3XX */ static const unsigned int a2xx_register_offsets[REG_ADRENO_REGISTER_MAX] = { REG_ADRENO_DEFINE(REG_ADRENO_CP_RB_BASE, REG_AXXX_CP_RB_BASE), @@ -429,6 +453,7 @@ static const struct adreno_gpu_funcs funcs = { #endif .gpu_state_get = a2xx_gpu_state_get, .gpu_state_put = adreno_gpu_state_put, + .create_address_space = a2xx_create_address_space, }, }; @@ -473,16 +498,8 @@ struct msm_gpu *a2xx_gpu_init(struct drm_device *dev) adreno_gpu->reg_offsets = a2xx_register_offsets; ret = adreno_gpu_init(dev, pdev, adreno_gpu, &funcs, 1); - if (ret) - goto fail; - - if (!gpu->aspace) { - dev_err(dev->dev, "No memory protection without MMU\n"); - ret = -ENXIO; - goto fail; - } - - return gpu; + if (!ret) + return gpu; fail: if (a2xx_gpu) diff --git a/drivers/gpu/drm/msm/adreno/a3xx_gpu.c b/drivers/gpu/drm/msm/adreno/a3xx_gpu.c index c3b4bc6..33ab5e8 100644 --- a/drivers/gpu/drm/msm/adreno/a3xx_gpu.c +++ b/drivers/gpu/drm/msm/adreno/a3xx_gpu.c @@ -21,6 +21,7 @@ # include #endif +#include "msm_gem.h" #include "a3xx_gpu.h" #define A3XX_INT0_MASK \ @@ -433,6 +434,41 @@ static struct msm_gpu_state *a3xx_gpu_state_get(struct msm_gpu *gpu) return state; } +static struct msm_gem_address_space * +a3xx_create_address_space(struct msm_gpu *gpu) +{ + struct msm_gem_address_space *aspace; + struct iommu_domain *iommu; + int ret; + + iommu = iommu_domain_alloc(&platform_bus_type); + if (!iommu) { + DRM_DEV_ERROR(gpu->dev->dev, + "No memory protection without IOMMU\n"); + return ERR_PTR(-ENXIO); + } + + iommu->geometry.aperture_start = SZ_16M; + iommu->geometry.aperture_end = 0xffffffff; + + aspace = msm_gem_address_space_create(&gpu->pdev->dev, iommu, "gpu"); + if (IS_ERR(aspace)) { + iommu_domain_free(iommu); + DRM_DEV_ERROR(gpu->dev->dev, "failed to init mmu: %ld\n", + PTR_ERR(aspace)); + return aspace; + } + + ret = aspace->mmu->funcs->attach(aspace->mmu, NULL, 0); + if (ret) { + msm_gem_address_space_put(aspace); + return ERR_PTR(ret); + } + + return aspace; +} + + /* Register offset defines for A3XX */ static const unsigned int a3xx_register_offsets[REG_ADRENO_REGISTER_MAX] = { REG_ADRENO_DEFINE(REG_ADRENO_CP_RB_BASE, REG_AXXX_CP_RB_BASE), @@ -461,6 +497,7 @@ static const struct adreno_gpu_funcs funcs = { #endif .gpu_state_get = a3xx_gpu_state_get, .gpu_state_put = adreno_gpu_state_put, + .create_address_space = a3xx_create_address_space, }, }; @@ -520,19 +557,6 @@ struct msm_gpu *a3xx_gpu_init(struct drm_device *dev) #endif } - if (!gpu->aspace) { - /* TODO we think it is possible to configure the GPU to - * restrict access to VRAM carveout. But the required - * registers are unknown. For now just bail out and - * limp along with just modesetting. If it turns out - * to not be possible to restrict access, then we must - * implement a cmdstream validator. - */ - DRM_DEV_ERROR(dev->dev, "No memory protection without IOMMU\n"); - ret = -ENXIO; - goto fail; - } - return gpu; fail: diff --git a/drivers/gpu/drm/msm/adreno/a4xx_gpu.c b/drivers/gpu/drm/msm/adreno/a4xx_gpu.c index 18f9a8e..08a5729 100644 --- a/drivers/gpu/drm/msm/adreno/a4xx_gpu.c +++ b/drivers/gpu/drm/msm/adreno/a4xx_gpu.c @@ -15,6 +15,8 @@ # include #endif +#include "msm_gem.h" + #define A4XX_INT0_MASK \ (A4XX_INT0_RBBM_AHB_ERROR | \ A4XX_INT0_RBBM_ATB_BUS_OVERFLOW | \ @@ -530,6 +532,41 @@ static int a4xx_get_timestamp(struct msm_gpu *gpu, uint64_t *value) return 0; } +static struct msm_gem_address_space * +a4xx_create_address_space(struct msm_gpu *gpu) +{ + struct msm_gem_address_space *aspace; + struct iommu_domain *iommu; + int ret; + + iommu = iommu_domain_alloc(&platform_bus_type); + if (!iommu) { + DRM_DEV_ERROR(gpu->dev->dev, + "No memory protection without IOMMU\n"); + return ERR_PTR(-ENXIO); + } + + iommu->geometry.aperture_start = SZ_16M; + iommu->geometry.aperture_end = 0xffffffff; + + aspace = msm_gem_address_space_create(&gpu->pdev->dev, iommu, "gpu"); + if (IS_ERR(aspace)) { + iommu_domain_free(iommu); + DRM_DEV_ERROR(gpu->dev->dev, "failed to init mmu: %ld\n", + PTR_ERR(aspace)); + return aspace; + } + + ret = aspace->mmu->funcs->attach(aspace->mmu, NULL, 0); + if (ret) { + msm_gem_address_space_put(aspace); + return ERR_PTR(ret); + } + + return aspace; +} + + static const struct adreno_gpu_funcs funcs = { .base = { .get_param = adreno_get_param, @@ -547,6 +584,7 @@ static const struct adreno_gpu_funcs funcs = { #endif .gpu_state_get = a4xx_gpu_state_get, .gpu_state_put = adreno_gpu_state_put, + .create_address_space = a4xx_create_address_space, }, .get_timestamp = a4xx_get_timestamp, }; @@ -600,19 +638,6 @@ struct msm_gpu *a4xx_gpu_init(struct drm_device *dev) #endif } - if (!gpu->aspace) { - /* TODO we think it is possible to configure the GPU to - * restrict access to VRAM carveout. But the required - * registers are unknown. For now just bail out and - * limp along with just modesetting. If it turns out - * to not be possible to restrict access, then we must - * implement a cmdstream validator. - */ - DRM_DEV_ERROR(dev->dev, "No memory protection without IOMMU\n"); - ret = -ENXIO; - goto fail; - } - return gpu; fail: diff --git a/drivers/gpu/drm/msm/adreno/a5xx_gpu.c b/drivers/gpu/drm/msm/adreno/a5xx_gpu.c index 43a2b4a..2f87c3e 100644 --- a/drivers/gpu/drm/msm/adreno/a5xx_gpu.c +++ b/drivers/gpu/drm/msm/adreno/a5xx_gpu.c @@ -1349,6 +1349,38 @@ static unsigned long a5xx_gpu_busy(struct msm_gpu *gpu) return (unsigned long)busy_time; } +static struct msm_gem_address_space * +a5xx_create_address_space(struct msm_gpu *gpu) +{ + struct msm_gem_address_space *aspace; + struct iommu_domain *iommu; + int ret; + + iommu = iommu_domain_alloc(&platform_bus_type); + if (!iommu) + return ERR_PTR(-ENXIO); + + iommu->geometry.aperture_start = 0x100000000ULL; + iommu->geometry.aperture_end = 0x1ffffffffULL; + + aspace = msm_gem_address_space_create(&gpu->pdev->dev, iommu, "gpu"); + if (IS_ERR(aspace)) { + iommu_domain_free(iommu); + DRM_DEV_ERROR(gpu->dev->dev, "failed to init mmu: %ld\n", + PTR_ERR(aspace)); + return aspace; + } + + ret = aspace->mmu->funcs->attach(aspace->mmu, NULL, 0); + if (ret) { + msm_gem_address_space_put(aspace); + return ERR_PTR(ret); + } + + msm_mmu_set_fault_handler(aspace->mmu, gpu, a5xx_fault_handler); + return aspace; +} + static const struct adreno_gpu_funcs funcs = { .base = { .get_param = adreno_get_param, @@ -1370,6 +1402,7 @@ static const struct adreno_gpu_funcs funcs = { .gpu_busy = a5xx_gpu_busy, .gpu_state_get = a5xx_gpu_state_get, .gpu_state_put = a5xx_gpu_state_put, + .create_address_space = a5xx_create_address_space, }, .get_timestamp = a5xx_get_timestamp, }; @@ -1416,7 +1449,6 @@ struct msm_gpu *a5xx_gpu_init(struct drm_device *dev) adreno_gpu->registers = a5xx_registers; adreno_gpu->reg_offsets = a5xx_register_offsets; - a5xx_gpu->lm_leakage = 0x4E001A; check_speed_bin(&pdev->dev); @@ -1427,9 +1459,6 @@ struct msm_gpu *a5xx_gpu_init(struct drm_device *dev) return ERR_PTR(ret); } - if (gpu->aspace) - msm_mmu_set_fault_handler(gpu->aspace->mmu, gpu, a5xx_fault_handler); - /* Set up the preemption specific bits and pieces for each ringbuffer */ a5xx_preempt_init(gpu); diff --git a/drivers/gpu/drm/msm/adreno/a6xx_gpu.c b/drivers/gpu/drm/msm/adreno/a6xx_gpu.c index be39cf0..3d70588 100644 --- a/drivers/gpu/drm/msm/adreno/a6xx_gpu.c +++ b/drivers/gpu/drm/msm/adreno/a6xx_gpu.c @@ -810,6 +810,38 @@ static unsigned long a6xx_gpu_busy(struct msm_gpu *gpu) return (unsigned long)busy_time; } +static struct msm_gem_address_space * +a6xx_create_address_space(struct msm_gpu *gpu) +{ + struct msm_gem_address_space *aspace; + struct iommu_domain *iommu; + int ret; + + iommu = iommu_domain_alloc(&platform_bus_type); + if (!iommu) + return ERR_PTR(-ENXIO); + + iommu->geometry.aperture_start = 0x100000000ULL; + iommu->geometry.aperture_end = 0x1ffffffffULL; + + aspace = msm_gem_address_space_create(&gpu->pdev->dev, iommu, "gpu"); + if (IS_ERR(aspace)) { + iommu_domain_free(iommu); + DRM_DEV_ERROR(gpu->dev->dev, "failed to init mmu: %ld\n", + PTR_ERR(aspace)); + return aspace; + } + + ret = aspace->mmu->funcs->attach(aspace->mmu, NULL, 0); + if (ret) { + msm_gem_address_space_put(aspace); + return ERR_PTR(ret); + } + + msm_mmu_set_fault_handler(aspace->mmu, gpu, a6xx_fault_handler); + return aspace; +} + static const struct adreno_gpu_funcs funcs = { .base = { .get_param = adreno_get_param, @@ -832,6 +864,7 @@ static const struct adreno_gpu_funcs funcs = { .gpu_state_get = a6xx_gpu_state_get, .gpu_state_put = a6xx_gpu_state_put, #endif + .create_address_space = a6xx_create_address_space, }, .get_timestamp = a6xx_get_timestamp, }; @@ -874,9 +907,5 @@ struct msm_gpu *a6xx_gpu_init(struct drm_device *dev) return ERR_PTR(ret); } - if (gpu->aspace) - msm_mmu_set_fault_handler(gpu->aspace->mmu, gpu, - a6xx_fault_handler); - return gpu; } diff --git a/drivers/gpu/drm/msm/adreno/adreno_gpu.c b/drivers/gpu/drm/msm/adreno/adreno_gpu.c index 6f7f411..3ba7141 100644 --- a/drivers/gpu/drm/msm/adreno/adreno_gpu.c +++ b/drivers/gpu/drm/msm/adreno/adreno_gpu.c @@ -912,13 +912,6 @@ int adreno_gpu_init(struct drm_device *drm, struct platform_device *pdev, adreno_gpu->rev = config->rev; adreno_gpu_config.ioname = "kgsl_3d0_reg_memory"; - - adreno_gpu_config.va_start = SZ_16M; - adreno_gpu_config.va_end = 0xffffffff; - /* maximum range of a2xx mmu */ - if (adreno_is_a2xx(adreno_gpu)) - adreno_gpu_config.va_end = SZ_16M + 0xfff * SZ_64K; - adreno_gpu_config.nr_rings = nr_rings; adreno_get_pwrlevels(&pdev->dev, gpu); diff --git a/drivers/gpu/drm/msm/msm_gem.h b/drivers/gpu/drm/msm/msm_gem.h index 36aeb58..fd67153 100644 --- a/drivers/gpu/drm/msm/msm_gem.h +++ b/drivers/gpu/drm/msm/msm_gem.h @@ -21,6 +21,7 @@ #include #include #include "msm_drv.h" +#include "msm_mmu.h" /* Additional internal-use only BO flags: */ #define MSM_BO_STOLEN 0x10000000 /* try to use stolen/splash memory */ diff --git a/drivers/gpu/drm/msm/msm_gpu.c b/drivers/gpu/drm/msm/msm_gpu.c index 0a4c77f..e8a14b0 100644 --- a/drivers/gpu/drm/msm/msm_gpu.c +++ b/drivers/gpu/drm/msm/msm_gpu.c @@ -20,7 +20,6 @@ #include "msm_mmu.h" #include "msm_fence.h" #include "msm_gpu_trace.h" -#include "adreno/adreno_gpu.h" #include #include @@ -812,51 +811,6 @@ static int get_clocks(struct platform_device *pdev, struct msm_gpu *gpu) return 0; } -static struct msm_gem_address_space * -msm_gpu_create_address_space(struct msm_gpu *gpu, struct platform_device *pdev, - uint64_t va_start, uint64_t va_end) -{ - struct msm_gem_address_space *aspace; - int ret; - - /* - * Setup IOMMU.. eventually we will (I think) do this once per context - * and have separate page tables per context. For now, to keep things - * simple and to get something working, just use a single address space: - */ - if (!adreno_is_a2xx(to_adreno_gpu(gpu))) { - struct iommu_domain *iommu = iommu_domain_alloc(&platform_bus_type); - if (!iommu) - return NULL; - - iommu->geometry.aperture_start = va_start; - iommu->geometry.aperture_end = va_end; - - DRM_DEV_INFO(gpu->dev->dev, "%s: using IOMMU\n", gpu->name); - - aspace = msm_gem_address_space_create(&pdev->dev, iommu, "gpu"); - if (IS_ERR(aspace)) - iommu_domain_free(iommu); - } else { - aspace = msm_gem_address_space_create_a2xx(&pdev->dev, gpu, "gpu", - va_start, va_end); - } - - if (IS_ERR(aspace)) { - DRM_DEV_ERROR(gpu->dev->dev, "failed to init mmu: %ld\n", - PTR_ERR(aspace)); - return ERR_CAST(aspace); - } - - ret = aspace->mmu->funcs->attach(aspace->mmu, NULL, 0); - if (ret) { - msm_gem_address_space_put(aspace); - return ERR_PTR(ret); - } - - return aspace; -} - int msm_gpu_init(struct drm_device *drm, struct platform_device *pdev, struct msm_gpu *gpu, const struct msm_gpu_funcs *funcs, const char *name, struct msm_gpu_config *config) @@ -929,12 +883,8 @@ int msm_gpu_init(struct drm_device *drm, struct platform_device *pdev, msm_devfreq_init(gpu); - gpu->aspace = msm_gpu_create_address_space(gpu, pdev, - config->va_start, config->va_end); - - if (gpu->aspace == NULL) - DRM_DEV_INFO(drm->dev, "%s: no IOMMU, fallback to VRAM carveout!\n", name); - else if (IS_ERR(gpu->aspace)) { + gpu->aspace = gpu->funcs->create_address_space(gpu); + if (IS_ERR(gpu->aspace)) { ret = PTR_ERR(gpu->aspace); goto fail; } diff --git a/drivers/gpu/drm/msm/msm_gpu.h b/drivers/gpu/drm/msm/msm_gpu.h index f2739cd..d4bf051 100644 --- a/drivers/gpu/drm/msm/msm_gpu.h +++ b/drivers/gpu/drm/msm/msm_gpu.h @@ -75,6 +75,8 @@ struct msm_gpu_funcs { int (*gpu_state_put)(struct msm_gpu_state *state); unsigned long (*gpu_get_freq)(struct msm_gpu *gpu); void (*gpu_set_freq)(struct msm_gpu *gpu, unsigned long freq); + struct msm_gem_address_space *(*create_address_space) + (struct msm_gpu *gpu); }; struct msm_gpu { -- 2.7.4 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Jordan Crouse Subject: [PATCH v3 10/16] drm/msm/gpu: Move address space setup to the GPU targets Date: Wed, 29 May 2019 14:54:46 -0600 Message-ID: <1559163292-4792-11-git-send-email-jcrouse@codeaurora.org> References: <1559163292-4792-1-git-send-email-jcrouse@codeaurora.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1559163292-4792-1-git-send-email-jcrouse-sgV2jX0FEOL9JmXXK+q4OQ@public.gmane.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: freedreno-bounces-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org Sender: "Freedreno" To: freedreno-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org Cc: Kees Cook , Jonathan Marek , jean-philippe.brucker-5wv7dgnIgG8@public.gmane.org, linux-arm-msm-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, Sharat Masetty , dianders-F7+t8E8rja9g9hUCZPvPmw@public.gmane.org, dri-devel-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org, linux-kernel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, David Airlie , Rob Clark , hoegsberg-hpIqsD4AKlfQT0dZR+AlfA@public.gmane.org, Mamta Shukla , Thomas Zimmermann , Daniel Vetter , Sean Paul List-Id: dri-devel@lists.freedesktop.org TW92ZSB0aGUgYWRkcmVzcyBzcGFjZSBzdGV1cCBjb2RlIG91dCBvZiB0aGUgZ2VuZXJpYyBtc20g R1BVIGNvZGUgdG8KdG8gdGhlIGluZGl2aWR1YWwgR1BVIHRhcmdldHMuIFRoaXMgYWxsb3dzIHVz IHRvIGRvIHRhcmdldCBzcGVjaWZpYwpzZXR1cCBzdWNoIGFzIGdwdW1tdSBmb3IgYTJ4eCBvciBz cGxpdCBwYWdldGFibGVzIGFuZCBwZXItaW5zdGFuY2UKcGFnZXRhYmxlcyBmb3IgbmV3ZXIgYTV4 eCBhbmQgYTZ4eCB0YXJnZXRzLiBBbGwgdGhpcyBpcyBhdCB0aGUKZXhwZW5zZSBvZiBkdXBsaWNh dGVkIGNvZGUgaW4gc29tZSBvZiB0aGUgdGFyZ2V0IGZpbGVzIGJ1dCBJIHRoaW5rCml0IHBheXMg Zm9yIGl0c2VsZiBpbiBpbXByb3ZlZCBjb2RlIGZsb3cgYW5kIGZsZXhpYmlsaXR5LgoKdjM6IGNo YW5nZSBOVUxsIHJldHVybiB0byBFUlJfUFRSIGluIGFkZHJlc3Mgc3BhY2UgY3JlYXRlIGZ1bmN0 aW9ucwpTaWduZWQtb2ZmLWJ5OiBKb3JkYW4gQ3JvdXNlIDxqY3JvdXNlQGNvZGVhdXJvcmEub3Jn PgotLS0KCiBkcml2ZXJzL2dwdS9kcm0vbXNtL2FkcmVuby9hMnh4X2dwdS5jICAgfCAzNyArKysr KysrKysrKysrKysrLS0tLS0tCiBkcml2ZXJzL2dwdS9kcm0vbXNtL2FkcmVuby9hM3h4X2dwdS5j ICAgfCA1MCArKysrKysrKysrKysrKysrKysrKysrLS0tLS0tLS0KIGRyaXZlcnMvZ3B1L2RybS9t c20vYWRyZW5vL2E0eHhfZ3B1LmMgICB8IDUxICsrKysrKysrKysrKysrKysrKysrKysrLS0tLS0t LS0KIGRyaXZlcnMvZ3B1L2RybS9tc20vYWRyZW5vL2E1eHhfZ3B1LmMgICB8IDM3ICsrKysrKysr KysrKysrKysrKystLS0KIGRyaXZlcnMvZ3B1L2RybS9tc20vYWRyZW5vL2E2eHhfZ3B1LmMgICB8 IDM3ICsrKysrKysrKysrKysrKysrKystLS0KIGRyaXZlcnMvZ3B1L2RybS9tc20vYWRyZW5vL2Fk cmVub19ncHUuYyB8ICA3IC0tLS0tCiBkcml2ZXJzL2dwdS9kcm0vbXNtL21zbV9nZW0uaCAgICAg ICAgICAgfCAgMSArCiBkcml2ZXJzL2dwdS9kcm0vbXNtL21zbV9ncHUuYyAgICAgICAgICAgfCA1 NCArKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIGRyaXZlcnMvZ3B1L2RybS9tc20v bXNtX2dwdS5oICAgICAgICAgICB8ICAyICsrCiA5IGZpbGVzIGNoYW5nZWQsIDE3MyBpbnNlcnRp b25zKCspLCAxMDMgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL21z bS9hZHJlbm8vYTJ4eF9ncHUuYyBiL2RyaXZlcnMvZ3B1L2RybS9tc20vYWRyZW5vL2EyeHhfZ3B1 LmMKaW5kZXggMWY4M2JjMS4uNDkyNDFkMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL21z bS9hZHJlbm8vYTJ4eF9ncHUuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL2FkcmVuby9hMnh4 X2dwdS5jCkBAIC00MDEsNiArNDAxLDMwIEBAIHN0YXRpYyBzdHJ1Y3QgbXNtX2dwdV9zdGF0ZSAq YTJ4eF9ncHVfc3RhdGVfZ2V0KHN0cnVjdCBtc21fZ3B1ICpncHUpCiAJcmV0dXJuIHN0YXRlOwog fQogCitzdGF0aWMgc3RydWN0IG1zbV9nZW1fYWRkcmVzc19zcGFjZSAqCithMnh4X2NyZWF0ZV9h ZGRyZXNzX3NwYWNlKHN0cnVjdCBtc21fZ3B1ICpncHUpCit7CisJc3RydWN0IG1zbV9nZW1fYWRk cmVzc19zcGFjZSAqYXNwYWNlOworCWludCByZXQ7CisKKwlhc3BhY2UgPSBtc21fZ2VtX2FkZHJl c3Nfc3BhY2VfY3JlYXRlX2EyeHgoJmdwdS0+cGRldi0+ZGV2LCBncHUsCisJCSJncHUiLCBTWl8x Nk0sIFNaXzE2TSArIDB4ZmYgKiBTWl82NEspOworCWlmIChJU19FUlIoYXNwYWNlKSkgeworCQlE Uk1fREVWX0VSUk9SKGdwdS0+ZGV2LT5kZXYsCisJCQkiTm8gbWVtb3J5IHByb3RlY3Rpb24gd2l0 aG91dCBNTVVcbiIpOworCQlyZXR1cm4gRVJSX1BUUigtRU5YSU8pOworCX0KKworCXJldCA9IGFz cGFjZS0+bW11LT5mdW5jcy0+YXR0YWNoKGFzcGFjZS0+bW11LCBOVUxMLCAwKTsKKwlpZiAocmV0 KSB7CisJCW1zbV9nZW1fYWRkcmVzc19zcGFjZV9wdXQoYXNwYWNlKTsKKwkJcmV0dXJuIEVSUl9Q VFIocmV0KTsKKwl9CisKKwlyZXR1cm4gYXNwYWNlOworfQorCisKIC8qIFJlZ2lzdGVyIG9mZnNl dCBkZWZpbmVzIGZvciBBMlhYIC0gY29weSBvZiBBM1hYICovCiBzdGF0aWMgY29uc3QgdW5zaWdu ZWQgaW50IGEyeHhfcmVnaXN0ZXJfb2Zmc2V0c1tSRUdfQURSRU5PX1JFR0lTVEVSX01BWF0gPSB7 CiAJUkVHX0FEUkVOT19ERUZJTkUoUkVHX0FEUkVOT19DUF9SQl9CQVNFLCBSRUdfQVhYWF9DUF9S Ql9CQVNFKSwKQEAgLTQyOSw2ICs0NTMsNyBAQCBzdGF0aWMgY29uc3Qgc3RydWN0IGFkcmVub19n cHVfZnVuY3MgZnVuY3MgPSB7CiAjZW5kaWYKIAkJLmdwdV9zdGF0ZV9nZXQgPSBhMnh4X2dwdV9z dGF0ZV9nZXQsCiAJCS5ncHVfc3RhdGVfcHV0ID0gYWRyZW5vX2dwdV9zdGF0ZV9wdXQsCisJCS5j cmVhdGVfYWRkcmVzc19zcGFjZSA9IGEyeHhfY3JlYXRlX2FkZHJlc3Nfc3BhY2UsCiAJfSwKIH07 CiAKQEAgLTQ3MywxNiArNDk4LDggQEAgc3RydWN0IG1zbV9ncHUgKmEyeHhfZ3B1X2luaXQoc3Ry dWN0IGRybV9kZXZpY2UgKmRldikKIAlhZHJlbm9fZ3B1LT5yZWdfb2Zmc2V0cyA9IGEyeHhfcmVn aXN0ZXJfb2Zmc2V0czsKIAogCXJldCA9IGFkcmVub19ncHVfaW5pdChkZXYsIHBkZXYsIGFkcmVu b19ncHUsICZmdW5jcywgMSk7Ci0JaWYgKHJldCkKLQkJZ290byBmYWlsOwotCi0JaWYgKCFncHUt PmFzcGFjZSkgewotCQlkZXZfZXJyKGRldi0+ZGV2LCAiTm8gbWVtb3J5IHByb3RlY3Rpb24gd2l0 aG91dCBNTVVcbiIpOwotCQlyZXQgPSAtRU5YSU87Ci0JCWdvdG8gZmFpbDsKLQl9Ci0KLQlyZXR1 cm4gZ3B1OworCWlmICghcmV0KQorCQlyZXR1cm4gZ3B1OwogCiBmYWlsOgogCWlmIChhMnh4X2dw dSkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9tc20vYWRyZW5vL2EzeHhfZ3B1LmMgYi9k cml2ZXJzL2dwdS9kcm0vbXNtL2FkcmVuby9hM3h4X2dwdS5jCmluZGV4IGMzYjRiYzYuLjMzYWI1 ZTggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9tc20vYWRyZW5vL2EzeHhfZ3B1LmMKKysr IGIvZHJpdmVycy9ncHUvZHJtL21zbS9hZHJlbm8vYTN4eF9ncHUuYwpAQCAtMjEsNiArMjEsNyBA QAogIyAgaW5jbHVkZSA8bWFjaC9vY21lbS5oPgogI2VuZGlmCiAKKyNpbmNsdWRlICJtc21fZ2Vt LmgiCiAjaW5jbHVkZSAiYTN4eF9ncHUuaCIKIAogI2RlZmluZSBBM1hYX0lOVDBfTUFTSyBcCkBA IC00MzMsNiArNDM0LDQxIEBAIHN0YXRpYyBzdHJ1Y3QgbXNtX2dwdV9zdGF0ZSAqYTN4eF9ncHVf c3RhdGVfZ2V0KHN0cnVjdCBtc21fZ3B1ICpncHUpCiAJcmV0dXJuIHN0YXRlOwogfQogCitzdGF0 aWMgc3RydWN0IG1zbV9nZW1fYWRkcmVzc19zcGFjZSAqCithM3h4X2NyZWF0ZV9hZGRyZXNzX3Nw YWNlKHN0cnVjdCBtc21fZ3B1ICpncHUpCit7CisJc3RydWN0IG1zbV9nZW1fYWRkcmVzc19zcGFj ZSAqYXNwYWNlOworCXN0cnVjdCBpb21tdV9kb21haW4gKmlvbW11OworCWludCByZXQ7CisKKwlp b21tdSA9IGlvbW11X2RvbWFpbl9hbGxvYygmcGxhdGZvcm1fYnVzX3R5cGUpOworCWlmICghaW9t bXUpIHsKKwkJRFJNX0RFVl9FUlJPUihncHUtPmRldi0+ZGV2LAorCQkJIk5vIG1lbW9yeSBwcm90 ZWN0aW9uIHdpdGhvdXQgSU9NTVVcbiIpOworCQlyZXR1cm4gRVJSX1BUUigtRU5YSU8pOworCX0K KworCWlvbW11LT5nZW9tZXRyeS5hcGVydHVyZV9zdGFydCA9IFNaXzE2TTsKKwlpb21tdS0+Z2Vv bWV0cnkuYXBlcnR1cmVfZW5kID0gMHhmZmZmZmZmZjsKKworCWFzcGFjZSA9IG1zbV9nZW1fYWRk cmVzc19zcGFjZV9jcmVhdGUoJmdwdS0+cGRldi0+ZGV2LCBpb21tdSwgImdwdSIpOworCWlmIChJ U19FUlIoYXNwYWNlKSkgeworCQlpb21tdV9kb21haW5fZnJlZShpb21tdSk7CisJCURSTV9ERVZf RVJST1IoZ3B1LT5kZXYtPmRldiwgImZhaWxlZCB0byBpbml0IG1tdTogJWxkXG4iLAorCQkJUFRS X0VSUihhc3BhY2UpKTsKKwkJcmV0dXJuIGFzcGFjZTsKKwl9CisKKwlyZXQgPSBhc3BhY2UtPm1t dS0+ZnVuY3MtPmF0dGFjaChhc3BhY2UtPm1tdSwgTlVMTCwgMCk7CisJaWYgKHJldCkgeworCQlt c21fZ2VtX2FkZHJlc3Nfc3BhY2VfcHV0KGFzcGFjZSk7CisJCXJldHVybiBFUlJfUFRSKHJldCk7 CisJfQorCisJcmV0dXJuIGFzcGFjZTsKK30KKworCiAvKiBSZWdpc3RlciBvZmZzZXQgZGVmaW5l cyBmb3IgQTNYWCAqLwogc3RhdGljIGNvbnN0IHVuc2lnbmVkIGludCBhM3h4X3JlZ2lzdGVyX29m ZnNldHNbUkVHX0FEUkVOT19SRUdJU1RFUl9NQVhdID0gewogCVJFR19BRFJFTk9fREVGSU5FKFJF R19BRFJFTk9fQ1BfUkJfQkFTRSwgUkVHX0FYWFhfQ1BfUkJfQkFTRSksCkBAIC00NjEsNiArNDk3 LDcgQEAgc3RhdGljIGNvbnN0IHN0cnVjdCBhZHJlbm9fZ3B1X2Z1bmNzIGZ1bmNzID0gewogI2Vu ZGlmCiAJCS5ncHVfc3RhdGVfZ2V0ID0gYTN4eF9ncHVfc3RhdGVfZ2V0LAogCQkuZ3B1X3N0YXRl X3B1dCA9IGFkcmVub19ncHVfc3RhdGVfcHV0LAorCQkuY3JlYXRlX2FkZHJlc3Nfc3BhY2UgPSBh M3h4X2NyZWF0ZV9hZGRyZXNzX3NwYWNlLAogCX0sCiB9OwogCkBAIC01MjAsMTkgKzU1Nyw2IEBA IHN0cnVjdCBtc21fZ3B1ICphM3h4X2dwdV9pbml0KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYpCiAj ZW5kaWYKIAl9CiAKLQlpZiAoIWdwdS0+YXNwYWNlKSB7Ci0JCS8qIFRPRE8gd2UgdGhpbmsgaXQg aXMgcG9zc2libGUgdG8gY29uZmlndXJlIHRoZSBHUFUgdG8KLQkJICogcmVzdHJpY3QgYWNjZXNz IHRvIFZSQU0gY2FydmVvdXQuICBCdXQgdGhlIHJlcXVpcmVkCi0JCSAqIHJlZ2lzdGVycyBhcmUg dW5rbm93bi4gIEZvciBub3cganVzdCBiYWlsIG91dCBhbmQKLQkJICogbGltcCBhbG9uZyB3aXRo IGp1c3QgbW9kZXNldHRpbmcuICBJZiBpdCB0dXJucyBvdXQKLQkJICogdG8gbm90IGJlIHBvc3Np YmxlIHRvIHJlc3RyaWN0IGFjY2VzcywgdGhlbiB3ZSBtdXN0Ci0JCSAqIGltcGxlbWVudCBhIGNt ZHN0cmVhbSB2YWxpZGF0b3IuCi0JCSAqLwotCQlEUk1fREVWX0VSUk9SKGRldi0+ZGV2LCAiTm8g bWVtb3J5IHByb3RlY3Rpb24gd2l0aG91dCBJT01NVVxuIik7Ci0JCXJldCA9IC1FTlhJTzsKLQkJ Z290byBmYWlsOwotCX0KLQogCXJldHVybiBncHU7CiAKIGZhaWw6CmRpZmYgLS1naXQgYS9kcml2 ZXJzL2dwdS9kcm0vbXNtL2FkcmVuby9hNHh4X2dwdS5jIGIvZHJpdmVycy9ncHUvZHJtL21zbS9h ZHJlbm8vYTR4eF9ncHUuYwppbmRleCAxOGY5YThlLi4wOGE1NzI5IDEwMDY0NAotLS0gYS9kcml2 ZXJzL2dwdS9kcm0vbXNtL2FkcmVuby9hNHh4X2dwdS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9t c20vYWRyZW5vL2E0eHhfZ3B1LmMKQEAgLTE1LDYgKzE1LDggQEAKICMgIGluY2x1ZGUgPHNvYy9x Y29tL29jbWVtLmg+CiAjZW5kaWYKIAorI2luY2x1ZGUgIm1zbV9nZW0uaCIKKwogI2RlZmluZSBB NFhYX0lOVDBfTUFTSyBcCiAJKEE0WFhfSU5UMF9SQkJNX0FIQl9FUlJPUiB8ICAgICAgICBcCiAJ IEE0WFhfSU5UMF9SQkJNX0FUQl9CVVNfT1ZFUkZMT1cgfCBcCkBAIC01MzAsNiArNTMyLDQxIEBA IHN0YXRpYyBpbnQgYTR4eF9nZXRfdGltZXN0YW1wKHN0cnVjdCBtc21fZ3B1ICpncHUsIHVpbnQ2 NF90ICp2YWx1ZSkKIAlyZXR1cm4gMDsKIH0KIAorc3RhdGljIHN0cnVjdCBtc21fZ2VtX2FkZHJl c3Nfc3BhY2UgKgorYTR4eF9jcmVhdGVfYWRkcmVzc19zcGFjZShzdHJ1Y3QgbXNtX2dwdSAqZ3B1 KQoreworCXN0cnVjdCBtc21fZ2VtX2FkZHJlc3Nfc3BhY2UgKmFzcGFjZTsKKwlzdHJ1Y3QgaW9t bXVfZG9tYWluICppb21tdTsKKwlpbnQgcmV0OworCisJaW9tbXUgPSBpb21tdV9kb21haW5fYWxs b2MoJnBsYXRmb3JtX2J1c190eXBlKTsKKwlpZiAoIWlvbW11KSB7CisJCURSTV9ERVZfRVJST1Io Z3B1LT5kZXYtPmRldiwKKwkJCSJObyBtZW1vcnkgcHJvdGVjdGlvbiB3aXRob3V0IElPTU1VXG4i KTsKKwkJcmV0dXJuIEVSUl9QVFIoLUVOWElPKTsKKwl9CisKKwlpb21tdS0+Z2VvbWV0cnkuYXBl cnR1cmVfc3RhcnQgPSBTWl8xNk07CisJaW9tbXUtPmdlb21ldHJ5LmFwZXJ0dXJlX2VuZCA9IDB4 ZmZmZmZmZmY7CisKKwlhc3BhY2UgPSBtc21fZ2VtX2FkZHJlc3Nfc3BhY2VfY3JlYXRlKCZncHUt PnBkZXYtPmRldiwgaW9tbXUsICJncHUiKTsKKwlpZiAoSVNfRVJSKGFzcGFjZSkpIHsKKwkJaW9t bXVfZG9tYWluX2ZyZWUoaW9tbXUpOworCQlEUk1fREVWX0VSUk9SKGdwdS0+ZGV2LT5kZXYsICJm YWlsZWQgdG8gaW5pdCBtbXU6ICVsZFxuIiwKKwkJCVBUUl9FUlIoYXNwYWNlKSk7CisJCXJldHVy biBhc3BhY2U7CisJfQorCisJcmV0ID0gYXNwYWNlLT5tbXUtPmZ1bmNzLT5hdHRhY2goYXNwYWNl LT5tbXUsIE5VTEwsIDApOworCWlmIChyZXQpIHsKKwkJbXNtX2dlbV9hZGRyZXNzX3NwYWNlX3B1 dChhc3BhY2UpOworCQlyZXR1cm4gRVJSX1BUUihyZXQpOworCX0KKworCXJldHVybiBhc3BhY2U7 Cit9CisKKwogc3RhdGljIGNvbnN0IHN0cnVjdCBhZHJlbm9fZ3B1X2Z1bmNzIGZ1bmNzID0gewog CS5iYXNlID0gewogCQkuZ2V0X3BhcmFtID0gYWRyZW5vX2dldF9wYXJhbSwKQEAgLTU0Nyw2ICs1 ODQsNyBAQCBzdGF0aWMgY29uc3Qgc3RydWN0IGFkcmVub19ncHVfZnVuY3MgZnVuY3MgPSB7CiAj ZW5kaWYKIAkJLmdwdV9zdGF0ZV9nZXQgPSBhNHh4X2dwdV9zdGF0ZV9nZXQsCiAJCS5ncHVfc3Rh dGVfcHV0ID0gYWRyZW5vX2dwdV9zdGF0ZV9wdXQsCisJCS5jcmVhdGVfYWRkcmVzc19zcGFjZSA9 IGE0eHhfY3JlYXRlX2FkZHJlc3Nfc3BhY2UsCiAJfSwKIAkuZ2V0X3RpbWVzdGFtcCA9IGE0eHhf Z2V0X3RpbWVzdGFtcCwKIH07CkBAIC02MDAsMTkgKzYzOCw2IEBAIHN0cnVjdCBtc21fZ3B1ICph NHh4X2dwdV9pbml0KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYpCiAjZW5kaWYKIAl9CiAKLQlpZiAo IWdwdS0+YXNwYWNlKSB7Ci0JCS8qIFRPRE8gd2UgdGhpbmsgaXQgaXMgcG9zc2libGUgdG8gY29u ZmlndXJlIHRoZSBHUFUgdG8KLQkJICogcmVzdHJpY3QgYWNjZXNzIHRvIFZSQU0gY2FydmVvdXQu ICBCdXQgdGhlIHJlcXVpcmVkCi0JCSAqIHJlZ2lzdGVycyBhcmUgdW5rbm93bi4gIEZvciBub3cg anVzdCBiYWlsIG91dCBhbmQKLQkJICogbGltcCBhbG9uZyB3aXRoIGp1c3QgbW9kZXNldHRpbmcu ICBJZiBpdCB0dXJucyBvdXQKLQkJICogdG8gbm90IGJlIHBvc3NpYmxlIHRvIHJlc3RyaWN0IGFj Y2VzcywgdGhlbiB3ZSBtdXN0Ci0JCSAqIGltcGxlbWVudCBhIGNtZHN0cmVhbSB2YWxpZGF0b3Iu Ci0JCSAqLwotCQlEUk1fREVWX0VSUk9SKGRldi0+ZGV2LCAiTm8gbWVtb3J5IHByb3RlY3Rpb24g d2l0aG91dCBJT01NVVxuIik7Ci0JCXJldCA9IC1FTlhJTzsKLQkJZ290byBmYWlsOwotCX0KLQog CXJldHVybiBncHU7CiAKIGZhaWw6CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbXNtL2Fk cmVuby9hNXh4X2dwdS5jIGIvZHJpdmVycy9ncHUvZHJtL21zbS9hZHJlbm8vYTV4eF9ncHUuYwpp bmRleCA0M2EyYjRhLi4yZjg3YzNlIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vbXNtL2Fk cmVuby9hNXh4X2dwdS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9tc20vYWRyZW5vL2E1eHhfZ3B1 LmMKQEAgLTEzNDksNiArMTM0OSwzOCBAQCBzdGF0aWMgdW5zaWduZWQgbG9uZyBhNXh4X2dwdV9i dXN5KHN0cnVjdCBtc21fZ3B1ICpncHUpCiAJcmV0dXJuICh1bnNpZ25lZCBsb25nKWJ1c3lfdGlt ZTsKIH0KIAorc3RhdGljIHN0cnVjdCBtc21fZ2VtX2FkZHJlc3Nfc3BhY2UgKgorYTV4eF9jcmVh dGVfYWRkcmVzc19zcGFjZShzdHJ1Y3QgbXNtX2dwdSAqZ3B1KQoreworCXN0cnVjdCBtc21fZ2Vt X2FkZHJlc3Nfc3BhY2UgKmFzcGFjZTsKKwlzdHJ1Y3QgaW9tbXVfZG9tYWluICppb21tdTsKKwlp bnQgcmV0OworCisJaW9tbXUgPSBpb21tdV9kb21haW5fYWxsb2MoJnBsYXRmb3JtX2J1c190eXBl KTsKKwlpZiAoIWlvbW11KQorCQlyZXR1cm4gRVJSX1BUUigtRU5YSU8pOworCisJaW9tbXUtPmdl b21ldHJ5LmFwZXJ0dXJlX3N0YXJ0ID0gMHgxMDAwMDAwMDBVTEw7CisJaW9tbXUtPmdlb21ldHJ5 LmFwZXJ0dXJlX2VuZCA9IDB4MWZmZmZmZmZmVUxMOworCisJYXNwYWNlID0gbXNtX2dlbV9hZGRy ZXNzX3NwYWNlX2NyZWF0ZSgmZ3B1LT5wZGV2LT5kZXYsIGlvbW11LCAiZ3B1Iik7CisJaWYgKElT X0VSUihhc3BhY2UpKSB7CisJCWlvbW11X2RvbWFpbl9mcmVlKGlvbW11KTsKKwkJRFJNX0RFVl9F UlJPUihncHUtPmRldi0+ZGV2LCAiZmFpbGVkIHRvIGluaXQgbW11OiAlbGRcbiIsCisJCQlQVFJf RVJSKGFzcGFjZSkpOworCQlyZXR1cm4gYXNwYWNlOworCX0KKworCXJldCA9IGFzcGFjZS0+bW11 LT5mdW5jcy0+YXR0YWNoKGFzcGFjZS0+bW11LCBOVUxMLCAwKTsKKwlpZiAocmV0KSB7CisJCW1z bV9nZW1fYWRkcmVzc19zcGFjZV9wdXQoYXNwYWNlKTsKKwkJcmV0dXJuIEVSUl9QVFIocmV0KTsK Kwl9CisKKwltc21fbW11X3NldF9mYXVsdF9oYW5kbGVyKGFzcGFjZS0+bW11LCBncHUsIGE1eHhf ZmF1bHRfaGFuZGxlcik7CisJcmV0dXJuIGFzcGFjZTsKK30KKwogc3RhdGljIGNvbnN0IHN0cnVj dCBhZHJlbm9fZ3B1X2Z1bmNzIGZ1bmNzID0gewogCS5iYXNlID0gewogCQkuZ2V0X3BhcmFtID0g YWRyZW5vX2dldF9wYXJhbSwKQEAgLTEzNzAsNiArMTQwMiw3IEBAIHN0YXRpYyBjb25zdCBzdHJ1 Y3QgYWRyZW5vX2dwdV9mdW5jcyBmdW5jcyA9IHsKIAkJLmdwdV9idXN5ID0gYTV4eF9ncHVfYnVz eSwKIAkJLmdwdV9zdGF0ZV9nZXQgPSBhNXh4X2dwdV9zdGF0ZV9nZXQsCiAJCS5ncHVfc3RhdGVf cHV0ID0gYTV4eF9ncHVfc3RhdGVfcHV0LAorCQkuY3JlYXRlX2FkZHJlc3Nfc3BhY2UgPSBhNXh4 X2NyZWF0ZV9hZGRyZXNzX3NwYWNlLAogCX0sCiAJLmdldF90aW1lc3RhbXAgPSBhNXh4X2dldF90 aW1lc3RhbXAsCiB9OwpAQCAtMTQxNiw3ICsxNDQ5LDYgQEAgc3RydWN0IG1zbV9ncHUgKmE1eHhf Z3B1X2luaXQoc3RydWN0IGRybV9kZXZpY2UgKmRldikKIAogCWFkcmVub19ncHUtPnJlZ2lzdGVy cyA9IGE1eHhfcmVnaXN0ZXJzOwogCWFkcmVub19ncHUtPnJlZ19vZmZzZXRzID0gYTV4eF9yZWdp c3Rlcl9vZmZzZXRzOwotCiAJYTV4eF9ncHUtPmxtX2xlYWthZ2UgPSAweDRFMDAxQTsKIAogCWNo ZWNrX3NwZWVkX2JpbigmcGRldi0+ZGV2KTsKQEAgLTE0MjcsOSArMTQ1OSw2IEBAIHN0cnVjdCBt c21fZ3B1ICphNXh4X2dwdV9pbml0KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYpCiAJCXJldHVybiBF UlJfUFRSKHJldCk7CiAJfQogCi0JaWYgKGdwdS0+YXNwYWNlKQotCQltc21fbW11X3NldF9mYXVs dF9oYW5kbGVyKGdwdS0+YXNwYWNlLT5tbXUsIGdwdSwgYTV4eF9mYXVsdF9oYW5kbGVyKTsKLQog CS8qIFNldCB1cCB0aGUgcHJlZW1wdGlvbiBzcGVjaWZpYyBiaXRzIGFuZCBwaWVjZXMgZm9yIGVh Y2ggcmluZ2J1ZmZlciAqLwogCWE1eHhfcHJlZW1wdF9pbml0KGdwdSk7CiAKZGlmZiAtLWdpdCBh L2RyaXZlcnMvZ3B1L2RybS9tc20vYWRyZW5vL2E2eHhfZ3B1LmMgYi9kcml2ZXJzL2dwdS9kcm0v bXNtL2FkcmVuby9hNnh4X2dwdS5jCmluZGV4IGJlMzljZjAuLjNkNzA1ODggMTAwNjQ0Ci0tLSBh L2RyaXZlcnMvZ3B1L2RybS9tc20vYWRyZW5vL2E2eHhfZ3B1LmMKKysrIGIvZHJpdmVycy9ncHUv ZHJtL21zbS9hZHJlbm8vYTZ4eF9ncHUuYwpAQCAtODEwLDYgKzgxMCwzOCBAQCBzdGF0aWMgdW5z aWduZWQgbG9uZyBhNnh4X2dwdV9idXN5KHN0cnVjdCBtc21fZ3B1ICpncHUpCiAJcmV0dXJuICh1 bnNpZ25lZCBsb25nKWJ1c3lfdGltZTsKIH0KIAorc3RhdGljIHN0cnVjdCBtc21fZ2VtX2FkZHJl c3Nfc3BhY2UgKgorYTZ4eF9jcmVhdGVfYWRkcmVzc19zcGFjZShzdHJ1Y3QgbXNtX2dwdSAqZ3B1 KQoreworCXN0cnVjdCBtc21fZ2VtX2FkZHJlc3Nfc3BhY2UgKmFzcGFjZTsKKwlzdHJ1Y3QgaW9t bXVfZG9tYWluICppb21tdTsKKwlpbnQgcmV0OworCisJaW9tbXUgPSBpb21tdV9kb21haW5fYWxs b2MoJnBsYXRmb3JtX2J1c190eXBlKTsKKwlpZiAoIWlvbW11KQorCQlyZXR1cm4gRVJSX1BUUigt RU5YSU8pOworCisJaW9tbXUtPmdlb21ldHJ5LmFwZXJ0dXJlX3N0YXJ0ID0gMHgxMDAwMDAwMDBV TEw7CisJaW9tbXUtPmdlb21ldHJ5LmFwZXJ0dXJlX2VuZCA9IDB4MWZmZmZmZmZmVUxMOworCisJ YXNwYWNlID0gbXNtX2dlbV9hZGRyZXNzX3NwYWNlX2NyZWF0ZSgmZ3B1LT5wZGV2LT5kZXYsIGlv bW11LCAiZ3B1Iik7CisJaWYgKElTX0VSUihhc3BhY2UpKSB7CisJCWlvbW11X2RvbWFpbl9mcmVl KGlvbW11KTsKKwkJRFJNX0RFVl9FUlJPUihncHUtPmRldi0+ZGV2LCAiZmFpbGVkIHRvIGluaXQg bW11OiAlbGRcbiIsCisJCQlQVFJfRVJSKGFzcGFjZSkpOworCQlyZXR1cm4gYXNwYWNlOworCX0K KworCXJldCA9IGFzcGFjZS0+bW11LT5mdW5jcy0+YXR0YWNoKGFzcGFjZS0+bW11LCBOVUxMLCAw KTsKKwlpZiAocmV0KSB7CisJCW1zbV9nZW1fYWRkcmVzc19zcGFjZV9wdXQoYXNwYWNlKTsKKwkJ cmV0dXJuIEVSUl9QVFIocmV0KTsKKwl9CisKKwltc21fbW11X3NldF9mYXVsdF9oYW5kbGVyKGFz cGFjZS0+bW11LCBncHUsIGE2eHhfZmF1bHRfaGFuZGxlcik7CisJcmV0dXJuIGFzcGFjZTsKK30K Kwogc3RhdGljIGNvbnN0IHN0cnVjdCBhZHJlbm9fZ3B1X2Z1bmNzIGZ1bmNzID0gewogCS5iYXNl ID0gewogCQkuZ2V0X3BhcmFtID0gYWRyZW5vX2dldF9wYXJhbSwKQEAgLTgzMiw2ICs4NjQsNyBA QCBzdGF0aWMgY29uc3Qgc3RydWN0IGFkcmVub19ncHVfZnVuY3MgZnVuY3MgPSB7CiAJCS5ncHVf c3RhdGVfZ2V0ID0gYTZ4eF9ncHVfc3RhdGVfZ2V0LAogCQkuZ3B1X3N0YXRlX3B1dCA9IGE2eHhf Z3B1X3N0YXRlX3B1dCwKICNlbmRpZgorCQkuY3JlYXRlX2FkZHJlc3Nfc3BhY2UgPSBhNnh4X2Ny ZWF0ZV9hZGRyZXNzX3NwYWNlLAogCX0sCiAJLmdldF90aW1lc3RhbXAgPSBhNnh4X2dldF90aW1l c3RhbXAsCiB9OwpAQCAtODc0LDkgKzkwNyw1IEBAIHN0cnVjdCBtc21fZ3B1ICphNnh4X2dwdV9p bml0KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYpCiAJCXJldHVybiBFUlJfUFRSKHJldCk7CiAJfQog Ci0JaWYgKGdwdS0+YXNwYWNlKQotCQltc21fbW11X3NldF9mYXVsdF9oYW5kbGVyKGdwdS0+YXNw YWNlLT5tbXUsIGdwdSwKLQkJCQlhNnh4X2ZhdWx0X2hhbmRsZXIpOwotCiAJcmV0dXJuIGdwdTsK IH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9tc20vYWRyZW5vL2FkcmVub19ncHUuYyBi L2RyaXZlcnMvZ3B1L2RybS9tc20vYWRyZW5vL2FkcmVub19ncHUuYwppbmRleCA2ZjdmNDExLi4z YmE3MTQxIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vbXNtL2FkcmVuby9hZHJlbm9fZ3B1 LmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL21zbS9hZHJlbm8vYWRyZW5vX2dwdS5jCkBAIC05MTIs MTMgKzkxMiw2IEBAIGludCBhZHJlbm9fZ3B1X2luaXQoc3RydWN0IGRybV9kZXZpY2UgKmRybSwg c3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldiwKIAlhZHJlbm9fZ3B1LT5yZXYgPSBjb25maWct PnJldjsKIAogCWFkcmVub19ncHVfY29uZmlnLmlvbmFtZSA9ICJrZ3NsXzNkMF9yZWdfbWVtb3J5 IjsKLQotCWFkcmVub19ncHVfY29uZmlnLnZhX3N0YXJ0ID0gU1pfMTZNOwotCWFkcmVub19ncHVf Y29uZmlnLnZhX2VuZCA9IDB4ZmZmZmZmZmY7Ci0JLyogbWF4aW11bSByYW5nZSBvZiBhMnh4IG1t dSAqLwotCWlmIChhZHJlbm9faXNfYTJ4eChhZHJlbm9fZ3B1KSkKLQkJYWRyZW5vX2dwdV9jb25m aWcudmFfZW5kID0gU1pfMTZNICsgMHhmZmYgKiBTWl82NEs7Ci0KIAlhZHJlbm9fZ3B1X2NvbmZp Zy5ucl9yaW5ncyA9IG5yX3JpbmdzOwogCiAJYWRyZW5vX2dldF9wd3JsZXZlbHMoJnBkZXYtPmRl diwgZ3B1KTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9tc20vbXNtX2dlbS5oIGIvZHJp dmVycy9ncHUvZHJtL21zbS9tc21fZ2VtLmgKaW5kZXggMzZhZWI1OC4uZmQ2NzE1MyAxMDA2NDQK LS0tIGEvZHJpdmVycy9ncHUvZHJtL21zbS9tc21fZ2VtLmgKKysrIGIvZHJpdmVycy9ncHUvZHJt L21zbS9tc21fZ2VtLmgKQEAgLTIxLDYgKzIxLDcgQEAKICNpbmNsdWRlIDxsaW51eC9rcmVmLmg+ CiAjaW5jbHVkZSA8bGludXgvcmVzZXJ2YXRpb24uaD4KICNpbmNsdWRlICJtc21fZHJ2LmgiCisj aW5jbHVkZSAibXNtX21tdS5oIgogCiAvKiBBZGRpdGlvbmFsIGludGVybmFsLXVzZSBvbmx5IEJP IGZsYWdzOiAqLwogI2RlZmluZSBNU01fQk9fU1RPTEVOICAgICAgICAweDEwMDAwMDAwICAgIC8q IHRyeSB0byB1c2Ugc3RvbGVuL3NwbGFzaCBtZW1vcnkgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMv Z3B1L2RybS9tc20vbXNtX2dwdS5jIGIvZHJpdmVycy9ncHUvZHJtL21zbS9tc21fZ3B1LmMKaW5k ZXggMGE0Yzc3Zi4uZThhMTRiMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL21zbS9tc21f Z3B1LmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL21zbS9tc21fZ3B1LmMKQEAgLTIwLDcgKzIwLDYg QEAKICNpbmNsdWRlICJtc21fbW11LmgiCiAjaW5jbHVkZSAibXNtX2ZlbmNlLmgiCiAjaW5jbHVk ZSAibXNtX2dwdV90cmFjZS5oIgotI2luY2x1ZGUgImFkcmVuby9hZHJlbm9fZ3B1LmgiCiAKICNp bmNsdWRlIDxnZW5lcmF0ZWQvdXRzcmVsZWFzZS5oPgogI2luY2x1ZGUgPGxpbnV4L3N0cmluZ19o ZWxwZXJzLmg+CkBAIC04MTIsNTEgKzgxMSw2IEBAIHN0YXRpYyBpbnQgZ2V0X2Nsb2NrcyhzdHJ1 Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2LCBzdHJ1Y3QgbXNtX2dwdSAqZ3B1KQogCXJldHVybiAw OwogfQogCi1zdGF0aWMgc3RydWN0IG1zbV9nZW1fYWRkcmVzc19zcGFjZSAqCi1tc21fZ3B1X2Ny ZWF0ZV9hZGRyZXNzX3NwYWNlKHN0cnVjdCBtc21fZ3B1ICpncHUsIHN0cnVjdCBwbGF0Zm9ybV9k ZXZpY2UgKnBkZXYsCi0JCXVpbnQ2NF90IHZhX3N0YXJ0LCB1aW50NjRfdCB2YV9lbmQpCi17Ci0J c3RydWN0IG1zbV9nZW1fYWRkcmVzc19zcGFjZSAqYXNwYWNlOwotCWludCByZXQ7Ci0KLQkvKgot CSAqIFNldHVwIElPTU1VLi4gZXZlbnR1YWxseSB3ZSB3aWxsIChJIHRoaW5rKSBkbyB0aGlzIG9u Y2UgcGVyIGNvbnRleHQKLQkgKiBhbmQgaGF2ZSBzZXBhcmF0ZSBwYWdlIHRhYmxlcyBwZXIgY29u dGV4dC4gIEZvciBub3csIHRvIGtlZXAgdGhpbmdzCi0JICogc2ltcGxlIGFuZCB0byBnZXQgc29t ZXRoaW5nIHdvcmtpbmcsIGp1c3QgdXNlIGEgc2luZ2xlIGFkZHJlc3Mgc3BhY2U6Ci0JICovCi0J aWYgKCFhZHJlbm9faXNfYTJ4eCh0b19hZHJlbm9fZ3B1KGdwdSkpKSB7Ci0JCXN0cnVjdCBpb21t dV9kb21haW4gKmlvbW11ID0gaW9tbXVfZG9tYWluX2FsbG9jKCZwbGF0Zm9ybV9idXNfdHlwZSk7 Ci0JCWlmICghaW9tbXUpCi0JCQlyZXR1cm4gTlVMTDsKLQotCQlpb21tdS0+Z2VvbWV0cnkuYXBl cnR1cmVfc3RhcnQgPSB2YV9zdGFydDsKLQkJaW9tbXUtPmdlb21ldHJ5LmFwZXJ0dXJlX2VuZCA9 IHZhX2VuZDsKLQotCQlEUk1fREVWX0lORk8oZ3B1LT5kZXYtPmRldiwgIiVzOiB1c2luZyBJT01N VVxuIiwgZ3B1LT5uYW1lKTsKLQotCQlhc3BhY2UgPSBtc21fZ2VtX2FkZHJlc3Nfc3BhY2VfY3Jl YXRlKCZwZGV2LT5kZXYsIGlvbW11LCAiZ3B1Iik7Ci0JCWlmIChJU19FUlIoYXNwYWNlKSkKLQkJ CWlvbW11X2RvbWFpbl9mcmVlKGlvbW11KTsKLQl9IGVsc2UgewotCQlhc3BhY2UgPSBtc21fZ2Vt X2FkZHJlc3Nfc3BhY2VfY3JlYXRlX2EyeHgoJnBkZXYtPmRldiwgZ3B1LCAiZ3B1IiwKLQkJCXZh X3N0YXJ0LCB2YV9lbmQpOwotCX0KLQotCWlmIChJU19FUlIoYXNwYWNlKSkgewotCQlEUk1fREVW X0VSUk9SKGdwdS0+ZGV2LT5kZXYsICJmYWlsZWQgdG8gaW5pdCBtbXU6ICVsZFxuIiwKLQkJCVBU Ul9FUlIoYXNwYWNlKSk7Ci0JCXJldHVybiBFUlJfQ0FTVChhc3BhY2UpOwotCX0KLQotCXJldCA9 IGFzcGFjZS0+bW11LT5mdW5jcy0+YXR0YWNoKGFzcGFjZS0+bW11LCBOVUxMLCAwKTsKLQlpZiAo cmV0KSB7Ci0JCW1zbV9nZW1fYWRkcmVzc19zcGFjZV9wdXQoYXNwYWNlKTsKLQkJcmV0dXJuIEVS Ul9QVFIocmV0KTsKLQl9Ci0KLQlyZXR1cm4gYXNwYWNlOwotfQotCiBpbnQgbXNtX2dwdV9pbml0 KHN0cnVjdCBkcm1fZGV2aWNlICpkcm0sIHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYsCiAJ CXN0cnVjdCBtc21fZ3B1ICpncHUsIGNvbnN0IHN0cnVjdCBtc21fZ3B1X2Z1bmNzICpmdW5jcywK IAkJY29uc3QgY2hhciAqbmFtZSwgc3RydWN0IG1zbV9ncHVfY29uZmlnICpjb25maWcpCkBAIC05 MjksMTIgKzg4Myw4IEBAIGludCBtc21fZ3B1X2luaXQoc3RydWN0IGRybV9kZXZpY2UgKmRybSwg c3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldiwKIAogCW1zbV9kZXZmcmVxX2luaXQoZ3B1KTsK IAotCWdwdS0+YXNwYWNlID0gbXNtX2dwdV9jcmVhdGVfYWRkcmVzc19zcGFjZShncHUsIHBkZXYs Ci0JCWNvbmZpZy0+dmFfc3RhcnQsIGNvbmZpZy0+dmFfZW5kKTsKLQotCWlmIChncHUtPmFzcGFj ZSA9PSBOVUxMKQotCQlEUk1fREVWX0lORk8oZHJtLT5kZXYsICIlczogbm8gSU9NTVUsIGZhbGxi YWNrIHRvIFZSQU0gY2FydmVvdXQhXG4iLCBuYW1lKTsKLQllbHNlIGlmIChJU19FUlIoZ3B1LT5h c3BhY2UpKSB7CisJZ3B1LT5hc3BhY2UgPSBncHUtPmZ1bmNzLT5jcmVhdGVfYWRkcmVzc19zcGFj ZShncHUpOworCWlmIChJU19FUlIoZ3B1LT5hc3BhY2UpKSB7CiAJCXJldCA9IFBUUl9FUlIoZ3B1 LT5hc3BhY2UpOwogCQlnb3RvIGZhaWw7CiAJfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJt L21zbS9tc21fZ3B1LmggYi9kcml2ZXJzL2dwdS9kcm0vbXNtL21zbV9ncHUuaAppbmRleCBmMjcz OWNkLi5kNGJmMDUxIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vbXNtL21zbV9ncHUuaAor KysgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL21zbV9ncHUuaApAQCAtNzUsNiArNzUsOCBAQCBzdHJ1 Y3QgbXNtX2dwdV9mdW5jcyB7CiAJaW50ICgqZ3B1X3N0YXRlX3B1dCkoc3RydWN0IG1zbV9ncHVf c3RhdGUgKnN0YXRlKTsKIAl1bnNpZ25lZCBsb25nICgqZ3B1X2dldF9mcmVxKShzdHJ1Y3QgbXNt X2dwdSAqZ3B1KTsKIAl2b2lkICgqZ3B1X3NldF9mcmVxKShzdHJ1Y3QgbXNtX2dwdSAqZ3B1LCB1 bnNpZ25lZCBsb25nIGZyZXEpOworCXN0cnVjdCBtc21fZ2VtX2FkZHJlc3Nfc3BhY2UgKigqY3Jl YXRlX2FkZHJlc3Nfc3BhY2UpCisJCShzdHJ1Y3QgbXNtX2dwdSAqZ3B1KTsKIH07CiAKIHN0cnVj dCBtc21fZ3B1IHsKLS0gCjIuNy40CgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fXwpGcmVlZHJlbm8gbWFpbGluZyBsaXN0CkZyZWVkcmVub0BsaXN0cy5mcmVl ZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5m by9mcmVlZHJlbm8=