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=-9.5 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 9E872C3A589 for ; Tue, 20 Aug 2019 19:06:59 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 6F067230F2 for ; Tue, 20 Aug 2019 19:06:59 +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="lWOCEi3K"; dkim=fail reason="key not found in DNS" (0-bit key) header.d=codeaurora.org header.i=@codeaurora.org header.b="Tx9htx/6" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1730720AbfHTTGv (ORCPT ); Tue, 20 Aug 2019 15:06:51 -0400 Received: from smtp.codeaurora.org ([198.145.29.96]:46074 "EHLO smtp.codeaurora.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1730719AbfHTTGu (ORCPT ); Tue, 20 Aug 2019 15:06:50 -0400 Received: by smtp.codeaurora.org (Postfix, from userid 1000) id 4FD016133A; Tue, 20 Aug 2019 19:06:47 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=codeaurora.org; s=default; t=1566328009; bh=BTULzgBXdASQzomLewVPCgr+sGXMAc1VTRtKvsQjMRk=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=lWOCEi3Ku/T7r6qxzHRparumMRY1PjPssmAQXhczgC47Xp9poNYqTxyHJdzWhq+uc 9pvIFDKr9CZrbgIe74fVkPjt8SezlJptWGIKSpg5EB/o/ktB+QVIiUonS4bKTIcnwX rBiIVaHBZVbyo4tombZY+pRrWUrRC8XdWqsbeqjE= 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 AA1B66118D; Tue, 20 Aug 2019 19:06:44 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=codeaurora.org; s=default; t=1566328006; bh=BTULzgBXdASQzomLewVPCgr+sGXMAc1VTRtKvsQjMRk=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=Tx9htx/6jkI2jUdpnALCcdZUkdOQ+vSM1iwN1HAv5z58BNpxxzMzKLuBXj6u7TQUf FQHJuEq3nXpQ6Q9zEiRaijjgMjMfAhWVlWbvId7cmIq0Y2goBfcDJfuAJLV9+Rw2m0 WXpAmq8Vmm/ueOiGX+9adpWi36bP4WgYb/5Y4f8I= DMARC-Filter: OpenDMARC Filter v1.3.2 smtp.codeaurora.org AA1B66118D 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: linux-arm-msm@vger.kernel.org, Sean Paul , Bjorn Andersson , dri-devel@lists.freedesktop.org, Fritz Koenig , David Airlie , Allison Randal , Thomas Gleixner , Rob Clark , Jeffrey Hugo , Jeykumar Sankaran , Sravanthi Kollukuduru , Bruce Wang , linux-kernel@vger.kernel.org, Boris Brezillon , Abhinav Kumar , Jonathan Marek , Georgi Djakov , Mamta Shukla , Daniel Vetter Subject: [PATCH 6/7] drm/msm: Create the msm_mmu object independently from the address space Date: Tue, 20 Aug 2019 13:06:31 -0600 Message-Id: <1566327992-362-7-git-send-email-jcrouse@codeaurora.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1566327992-362-1-git-send-email-jcrouse@codeaurora.org> References: <1566327992-362-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 Instead of creating the msm_mmu object along with the address space initialize it separately and pass it into the address space create function. This gives us the flexibility of attaching the IOMMU device and querying it before creating the address space which will come in handy in the next patch that takes advantage of split pagetables if available. Signed-off-by: Jordan Crouse --- drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c | 16 ++++++++++------ drivers/gpu/drm/msm/disp/mdp4/mdp4_kms.c | 16 ++++++++++------ drivers/gpu/drm/msm/disp/mdp5/mdp5_cfg.c | 4 ---- drivers/gpu/drm/msm/disp/mdp5/mdp5_kms.c | 13 +++++++++++-- drivers/gpu/drm/msm/msm_drv.h | 8 ++------ drivers/gpu/drm/msm/msm_gem_vma.c | 30 +++--------------------------- drivers/gpu/drm/msm/msm_gpu.c | 19 ++++++++++++------- 7 files changed, 48 insertions(+), 58 deletions(-) diff --git a/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c b/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c index bb9d44e..8bf2639 100644 --- a/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c +++ b/drivers/gpu/drm/msm/disp/dpu1/dpu_kms.c @@ -722,23 +722,27 @@ static int _dpu_kms_mmu_init(struct dpu_kms *dpu_kms) { struct iommu_domain *domain; struct msm_gem_address_space *aspace; + struct msm_mmu *mmu; int ret; domain = iommu_domain_alloc(&platform_bus_type); if (!domain) return 0; - domain->geometry.aperture_start = 0x1000; - domain->geometry.aperture_end = 0xffffffff; + mmu = msm_iommu_new(dpu_kms->dev->dev, domain); + if (IS_ERR(mmu)) { + iommu_domain_free(domain); + return PTR_ERR(mmu); + } - aspace = msm_gem_address_space_create(dpu_kms->dev->dev, - domain, "dpu1"); + aspace = msm_gem_address_space_create(mmu, "dpu1", + 0x1000, 0xffffffff); if (IS_ERR(aspace)) { - iommu_domain_free(domain); + mmu->funcs->destroy(mmu); return PTR_ERR(aspace); } - ret = aspace->mmu->funcs->attach(aspace->mmu, iommu_ports, + ret = mmu->funcs->attach(mmu, iommu_ports, ARRAY_SIZE(iommu_ports)); if (ret) { DPU_ERROR("failed to attach iommu %d\n", ret); diff --git a/drivers/gpu/drm/msm/disp/mdp4/mdp4_kms.c b/drivers/gpu/drm/msm/disp/mdp4/mdp4_kms.c index 7a9ab55..af5a7a4 100644 --- a/drivers/gpu/drm/msm/disp/mdp4/mdp4_kms.c +++ b/drivers/gpu/drm/msm/disp/mdp4/mdp4_kms.c @@ -498,9 +498,17 @@ struct msm_kms *mdp4_kms_init(struct drm_device *dev) mdelay(16); if (config->iommu) { - aspace = msm_gem_address_space_create(&pdev->dev, - config->iommu, "mdp4"); + struct msm_mmu *mmu = msm_iommu_new(&pdev->dev, config->iommu); + + if (IS_ERR(mmu)) { + ret = PTR_ERR(mmu); + goto fail; + } + + aspace = msm_gem_address_space_create(mmu, "mdp4", + 0x1000, 0xfffffffff); if (IS_ERR(aspace)) { + mmu->funcs->destroy(mmu); ret = PTR_ERR(aspace); goto fail; } @@ -558,10 +566,6 @@ static struct mdp4_platform_config *mdp4_get_config(struct platform_device *dev) /* TODO: Chips that aren't apq8064 have a 200 Mhz max_clk */ config.max_clk = 266667000; config.iommu = iommu_domain_alloc(&platform_bus_type); - if (config.iommu) { - config.iommu->geometry.aperture_start = 0x1000; - config.iommu->geometry.aperture_end = 0xffffffff; - } return &config; } diff --git a/drivers/gpu/drm/msm/disp/mdp5/mdp5_cfg.c b/drivers/gpu/drm/msm/disp/mdp5/mdp5_cfg.c index dd1daf0..23265f7 100644 --- a/drivers/gpu/drm/msm/disp/mdp5/mdp5_cfg.c +++ b/drivers/gpu/drm/msm/disp/mdp5/mdp5_cfg.c @@ -721,10 +721,6 @@ static struct mdp5_cfg_platform *mdp5_get_config(struct platform_device *dev) static struct mdp5_cfg_platform config = {}; config.iommu = iommu_domain_alloc(&platform_bus_type); - if (config.iommu) { - config.iommu->geometry.aperture_start = 0x1000; - config.iommu->geometry.aperture_end = 0xffffffff; - } return &config; } diff --git a/drivers/gpu/drm/msm/disp/mdp5/mdp5_kms.c b/drivers/gpu/drm/msm/disp/mdp5/mdp5_kms.c index 4a60f5f..36115fd 100644 --- a/drivers/gpu/drm/msm/disp/mdp5/mdp5_kms.c +++ b/drivers/gpu/drm/msm/disp/mdp5/mdp5_kms.c @@ -702,9 +702,18 @@ struct msm_kms *mdp5_kms_init(struct drm_device *dev) mdelay(16); if (config->platform.iommu) { - aspace = msm_gem_address_space_create(&pdev->dev, - config->platform.iommu, "mdp5"); + struct msm_mmu *mmu = msm_iommu_new(&pdev->dev, + config->platform.iommu); + + if (IS_ERR(mmu)) { + ret = PTR_ERR(mmu); + goto fail; + } + + aspace = msm_gem_address_space_create(mmu, "mdp5", + 0x1000, 0xffffffff); if (IS_ERR(aspace)) { + mmu->funcs->destroy(mmu); ret = PTR_ERR(aspace); goto fail; } diff --git a/drivers/gpu/drm/msm/msm_drv.h b/drivers/gpu/drm/msm/msm_drv.h index ee7b512..c2502b2 100644 --- a/drivers/gpu/drm/msm/msm_drv.h +++ b/drivers/gpu/drm/msm/msm_drv.h @@ -244,12 +244,8 @@ void msm_gem_close_vma(struct msm_gem_address_space *aspace, void msm_gem_address_space_put(struct msm_gem_address_space *aspace); struct msm_gem_address_space * -msm_gem_address_space_create(struct device *dev, struct iommu_domain *domain, - const char *name); - -struct msm_gem_address_space * -msm_gem_address_space_create_a2xx(struct device *dev, struct msm_gpu *gpu, - const char *name, uint64_t va_start, uint64_t va_end); +msm_gem_address_space_create(struct msm_mmu *mmu, const char *name, + u64 va_start, u64 va_end); int msm_register_mmu(struct drm_device *dev, struct msm_mmu *mmu); void msm_unregister_mmu(struct drm_device *dev, struct msm_mmu *mmu); diff --git a/drivers/gpu/drm/msm/msm_gem_vma.c b/drivers/gpu/drm/msm/msm_gem_vma.c index 1af5354..45d4a63 100644 --- a/drivers/gpu/drm/msm/msm_gem_vma.c +++ b/drivers/gpu/drm/msm/msm_gem_vma.c @@ -127,32 +127,8 @@ int msm_gem_init_vma(struct msm_gem_address_space *aspace, struct msm_gem_address_space * -msm_gem_address_space_create(struct device *dev, struct iommu_domain *domain, - const char *name) -{ - struct msm_gem_address_space *aspace; - u64 size = domain->geometry.aperture_end - - domain->geometry.aperture_start; - - aspace = kzalloc(sizeof(*aspace), GFP_KERNEL); - if (!aspace) - return ERR_PTR(-ENOMEM); - - spin_lock_init(&aspace->lock); - aspace->name = name; - aspace->mmu = msm_iommu_new(dev, domain); - - drm_mm_init(&aspace->mm, (domain->geometry.aperture_start >> PAGE_SHIFT), - size >> PAGE_SHIFT); - - kref_init(&aspace->kref); - - return aspace; -} - -struct msm_gem_address_space * -msm_gem_address_space_create_a2xx(struct device *dev, struct msm_gpu *gpu, - const char *name, uint64_t va_start, uint64_t va_end) +msm_gem_address_space_create(struct msm_mmu *mmu, const char *name, + u64 va_start, u64 va_end) { struct msm_gem_address_space *aspace; u64 size = va_end - va_start; @@ -163,7 +139,7 @@ msm_gem_address_space_create_a2xx(struct device *dev, struct msm_gpu *gpu, spin_lock_init(&aspace->lock); aspace->name = name; - aspace->mmu = msm_gpummu_new(dev, gpu); + aspace->mmu = mmu; drm_mm_init(&aspace->mm, (va_start >> PAGE_SHIFT), size >> PAGE_SHIFT); diff --git a/drivers/gpu/drm/msm/msm_gpu.c b/drivers/gpu/drm/msm/msm_gpu.c index 4edb874..9271f39 100644 --- a/drivers/gpu/drm/msm/msm_gpu.c +++ b/drivers/gpu/drm/msm/msm_gpu.c @@ -806,6 +806,7 @@ 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; + struct msm_mmu *mmu; int ret; /* @@ -818,20 +819,24 @@ msm_gpu_create_address_space(struct msm_gpu *gpu, struct platform_device *pdev, if (!iommu) return NULL; - iommu->geometry.aperture_start = va_start; - iommu->geometry.aperture_end = va_end; + mmu = msm_iommu_new(&pdev->dev, iommu); + if (IS_ERR(mmu)) { + iommu_domain_free(iommu); + return ERR_CAST(mmu); + } 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); + mmu = msm_gpummu_new(&pdev->dev, gpu); + if (IS_ERR(mmu)) + return ERR_CAST(mmu); } + aspace = msm_gem_address_space_create(mmu, "gpu", va_start, va_end); if (IS_ERR(aspace)) { + mmu->funcs->destroy(mmu); + DRM_DEV_ERROR(gpu->dev->dev, "failed to init mmu: %ld\n", PTR_ERR(aspace)); return ERR_CAST(aspace); -- 2.7.4 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Jordan Crouse Subject: [PATCH 6/7] drm/msm: Create the msm_mmu object independently from the address space Date: Tue, 20 Aug 2019 13:06:31 -0600 Message-ID: <1566327992-362-7-git-send-email-jcrouse@codeaurora.org> References: <1566327992-362-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: <1566327992-362-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: Fritz Koenig , Jonathan Marek , Jeffrey Hugo , David Airlie , linux-arm-msm-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, Boris Brezillon , Abhinav Kumar , linux-kernel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, dri-devel-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org, Bjorn Andersson , Bruce Wang , Rob Clark , Mamta Shukla , Sravanthi Kollukuduru , Daniel Vetter , Thomas Gleixner , Sean Paul , Jeykumar Sankaran , Allison Randal , Georgi Djakov List-Id: dri-devel@lists.freedesktop.org SW5zdGVhZCBvZiBjcmVhdGluZyB0aGUgbXNtX21tdSBvYmplY3QgYWxvbmcgd2l0aCB0aGUgYWRk cmVzcyBzcGFjZQppbml0aWFsaXplIGl0IHNlcGFyYXRlbHkgYW5kIHBhc3MgaXQgaW50byB0aGUg YWRkcmVzcyBzcGFjZSBjcmVhdGUKZnVuY3Rpb24uIFRoaXMgZ2l2ZXMgdXMgdGhlIGZsZXhpYmls aXR5IG9mIGF0dGFjaGluZyB0aGUgSU9NTVUgZGV2aWNlCmFuZCBxdWVyeWluZyBpdCBiZWZvcmUg Y3JlYXRpbmcgdGhlIGFkZHJlc3Mgc3BhY2Ugd2hpY2ggd2lsbCBjb21lCmluIGhhbmR5IGluIHRo ZSBuZXh0IHBhdGNoIHRoYXQgdGFrZXMgYWR2YW50YWdlIG9mIHNwbGl0IHBhZ2V0YWJsZXMKaWYg YXZhaWxhYmxlLgoKU2lnbmVkLW9mZi1ieTogSm9yZGFuIENyb3VzZSA8amNyb3VzZUBjb2RlYXVy b3JhLm9yZz4KLS0tCgogZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL2RwdTEvZHB1X2ttcy5jICB8 IDE2ICsrKysrKysrKystLS0tLS0KIGRyaXZlcnMvZ3B1L2RybS9tc20vZGlzcC9tZHA0L21kcDRf a21zLmMgfCAxNiArKysrKysrKysrLS0tLS0tCiBkcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3AvbWRw NS9tZHA1X2NmZy5jIHwgIDQgLS0tLQogZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL21kcDUvbWRw NV9rbXMuYyB8IDEzICsrKysrKysrKysrLS0KIGRyaXZlcnMvZ3B1L2RybS9tc20vbXNtX2Rydi5o ICAgICAgICAgICAgfCAgOCArKy0tLS0tLQogZHJpdmVycy9ncHUvZHJtL21zbS9tc21fZ2VtX3Zt YS5jICAgICAgICB8IDMwICsrKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogZHJpdmVycy9n cHUvZHJtL21zbS9tc21fZ3B1LmMgICAgICAgICAgICB8IDE5ICsrKysrKysrKysrKy0tLS0tLS0K IDcgZmlsZXMgY2hhbmdlZCwgNDggaW5zZXJ0aW9ucygrKSwgNTggZGVsZXRpb25zKC0pCgpkaWZm IC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL2RwdTEvZHB1X2ttcy5jIGIvZHJpdmVy cy9ncHUvZHJtL21zbS9kaXNwL2RwdTEvZHB1X2ttcy5jCmluZGV4IGJiOWQ0NGUuLjhiZjI2Mzkg MTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9tc20vZGlzcC9kcHUxL2RwdV9rbXMuYworKysg Yi9kcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3AvZHB1MS9kcHVfa21zLmMKQEAgLTcyMiwyMyArNzIy LDI3IEBAIHN0YXRpYyBpbnQgX2RwdV9rbXNfbW11X2luaXQoc3RydWN0IGRwdV9rbXMgKmRwdV9r bXMpCiB7CiAJc3RydWN0IGlvbW11X2RvbWFpbiAqZG9tYWluOwogCXN0cnVjdCBtc21fZ2VtX2Fk ZHJlc3Nfc3BhY2UgKmFzcGFjZTsKKwlzdHJ1Y3QgbXNtX21tdSAqbW11OwogCWludCByZXQ7CiAK IAlkb21haW4gPSBpb21tdV9kb21haW5fYWxsb2MoJnBsYXRmb3JtX2J1c190eXBlKTsKIAlpZiAo IWRvbWFpbikKIAkJcmV0dXJuIDA7CiAKLQlkb21haW4tPmdlb21ldHJ5LmFwZXJ0dXJlX3N0YXJ0 ID0gMHgxMDAwOwotCWRvbWFpbi0+Z2VvbWV0cnkuYXBlcnR1cmVfZW5kID0gMHhmZmZmZmZmZjsK KwltbXUgPSBtc21faW9tbXVfbmV3KGRwdV9rbXMtPmRldi0+ZGV2LCBkb21haW4pOworCWlmIChJ U19FUlIobW11KSkgeworCQlpb21tdV9kb21haW5fZnJlZShkb21haW4pOworCQlyZXR1cm4gUFRS X0VSUihtbXUpOworCX0KIAotCWFzcGFjZSA9IG1zbV9nZW1fYWRkcmVzc19zcGFjZV9jcmVhdGUo ZHB1X2ttcy0+ZGV2LT5kZXYsCi0JCQlkb21haW4sICJkcHUxIik7CisJYXNwYWNlID0gbXNtX2dl bV9hZGRyZXNzX3NwYWNlX2NyZWF0ZShtbXUsICJkcHUxIiwKKwkJMHgxMDAwLCAweGZmZmZmZmZm KTsKIAlpZiAoSVNfRVJSKGFzcGFjZSkpIHsKLQkJaW9tbXVfZG9tYWluX2ZyZWUoZG9tYWluKTsK KwkJbW11LT5mdW5jcy0+ZGVzdHJveShtbXUpOwogCQlyZXR1cm4gUFRSX0VSUihhc3BhY2UpOwog CX0KIAotCXJldCA9IGFzcGFjZS0+bW11LT5mdW5jcy0+YXR0YWNoKGFzcGFjZS0+bW11LCBpb21t dV9wb3J0cywKKwlyZXQgPSBtbXUtPmZ1bmNzLT5hdHRhY2gobW11LCBpb21tdV9wb3J0cywKIAkJ CUFSUkFZX1NJWkUoaW9tbXVfcG9ydHMpKTsKIAlpZiAocmV0KSB7CiAJCURQVV9FUlJPUigiZmFp bGVkIHRvIGF0dGFjaCBpb21tdSAlZFxuIiwgcmV0KTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1 L2RybS9tc20vZGlzcC9tZHA0L21kcDRfa21zLmMgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3Av bWRwNC9tZHA0X2ttcy5jCmluZGV4IDdhOWFiNTUuLmFmNWE3YTQgMTAwNjQ0Ci0tLSBhL2RyaXZl cnMvZ3B1L2RybS9tc20vZGlzcC9tZHA0L21kcDRfa21zLmMKKysrIGIvZHJpdmVycy9ncHUvZHJt L21zbS9kaXNwL21kcDQvbWRwNF9rbXMuYwpAQCAtNDk4LDkgKzQ5OCwxNyBAQCBzdHJ1Y3QgbXNt X2ttcyAqbWRwNF9rbXNfaW5pdChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2KQogCW1kZWxheSgxNik7 CiAKIAlpZiAoY29uZmlnLT5pb21tdSkgewotCQlhc3BhY2UgPSBtc21fZ2VtX2FkZHJlc3Nfc3Bh Y2VfY3JlYXRlKCZwZGV2LT5kZXYsCi0JCQkJY29uZmlnLT5pb21tdSwgIm1kcDQiKTsKKwkJc3Ry dWN0IG1zbV9tbXUgKm1tdSA9IG1zbV9pb21tdV9uZXcoJnBkZXYtPmRldiwgY29uZmlnLT5pb21t dSk7CisKKwkJaWYgKElTX0VSUihtbXUpKSB7CisJCQlyZXQgPSBQVFJfRVJSKG1tdSk7CisJCQln b3RvIGZhaWw7CisJCX0KKworCQlhc3BhY2UgPSBtc21fZ2VtX2FkZHJlc3Nfc3BhY2VfY3JlYXRl KG1tdSwgIm1kcDQiLAorCQkJMHgxMDAwLCAweGZmZmZmZmZmZik7CiAJCWlmIChJU19FUlIoYXNw YWNlKSkgeworCQkJbW11LT5mdW5jcy0+ZGVzdHJveShtbXUpOwogCQkJcmV0ID0gUFRSX0VSUihh c3BhY2UpOwogCQkJZ290byBmYWlsOwogCQl9CkBAIC01NTgsMTAgKzU2Niw2IEBAIHN0YXRpYyBz dHJ1Y3QgbWRwNF9wbGF0Zm9ybV9jb25maWcgKm1kcDRfZ2V0X2NvbmZpZyhzdHJ1Y3QgcGxhdGZv cm1fZGV2aWNlICpkZXYpCiAJLyogVE9ETzogQ2hpcHMgdGhhdCBhcmVuJ3QgYXBxODA2NCBoYXZl IGEgMjAwIE1oeiBtYXhfY2xrICovCiAJY29uZmlnLm1heF9jbGsgPSAyNjY2NjcwMDA7CiAJY29u ZmlnLmlvbW11ID0gaW9tbXVfZG9tYWluX2FsbG9jKCZwbGF0Zm9ybV9idXNfdHlwZSk7Ci0JaWYg KGNvbmZpZy5pb21tdSkgewotCQljb25maWcuaW9tbXUtPmdlb21ldHJ5LmFwZXJ0dXJlX3N0YXJ0 ID0gMHgxMDAwOwotCQljb25maWcuaW9tbXUtPmdlb21ldHJ5LmFwZXJ0dXJlX2VuZCA9IDB4ZmZm ZmZmZmY7Ci0JfQogCiAJcmV0dXJuICZjb25maWc7CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dw dS9kcm0vbXNtL2Rpc3AvbWRwNS9tZHA1X2NmZy5jIGIvZHJpdmVycy9ncHUvZHJtL21zbS9kaXNw L21kcDUvbWRwNV9jZmcuYwppbmRleCBkZDFkYWYwLi4yMzI2NWY3IDEwMDY0NAotLS0gYS9kcml2 ZXJzL2dwdS9kcm0vbXNtL2Rpc3AvbWRwNS9tZHA1X2NmZy5jCisrKyBiL2RyaXZlcnMvZ3B1L2Ry bS9tc20vZGlzcC9tZHA1L21kcDVfY2ZnLmMKQEAgLTcyMSwxMCArNzIxLDYgQEAgc3RhdGljIHN0 cnVjdCBtZHA1X2NmZ19wbGF0Zm9ybSAqbWRwNV9nZXRfY29uZmlnKHN0cnVjdCBwbGF0Zm9ybV9k ZXZpY2UgKmRldikKIAlzdGF0aWMgc3RydWN0IG1kcDVfY2ZnX3BsYXRmb3JtIGNvbmZpZyA9IHt9 OwogCiAJY29uZmlnLmlvbW11ID0gaW9tbXVfZG9tYWluX2FsbG9jKCZwbGF0Zm9ybV9idXNfdHlw ZSk7Ci0JaWYgKGNvbmZpZy5pb21tdSkgewotCQljb25maWcuaW9tbXUtPmdlb21ldHJ5LmFwZXJ0 dXJlX3N0YXJ0ID0gMHgxMDAwOwotCQljb25maWcuaW9tbXUtPmdlb21ldHJ5LmFwZXJ0dXJlX2Vu ZCA9IDB4ZmZmZmZmZmY7Ci0JfQogCiAJcmV0dXJuICZjb25maWc7CiB9CmRpZmYgLS1naXQgYS9k cml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3AvbWRwNS9tZHA1X2ttcy5jIGIvZHJpdmVycy9ncHUvZHJt L21zbS9kaXNwL21kcDUvbWRwNV9rbXMuYwppbmRleCA0YTYwZjVmLi4zNjExNWZkIDEwMDY0NAot LS0gYS9kcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3AvbWRwNS9tZHA1X2ttcy5jCisrKyBiL2RyaXZl cnMvZ3B1L2RybS9tc20vZGlzcC9tZHA1L21kcDVfa21zLmMKQEAgLTcwMiw5ICs3MDIsMTggQEAg c3RydWN0IG1zbV9rbXMgKm1kcDVfa21zX2luaXQoc3RydWN0IGRybV9kZXZpY2UgKmRldikKIAlt ZGVsYXkoMTYpOwogCiAJaWYgKGNvbmZpZy0+cGxhdGZvcm0uaW9tbXUpIHsKLQkJYXNwYWNlID0g bXNtX2dlbV9hZGRyZXNzX3NwYWNlX2NyZWF0ZSgmcGRldi0+ZGV2LAotCQkJCWNvbmZpZy0+cGxh dGZvcm0uaW9tbXUsICJtZHA1Iik7CisJCXN0cnVjdCBtc21fbW11ICptbXUgPSBtc21faW9tbXVf bmV3KCZwZGV2LT5kZXYsCisJCQljb25maWctPnBsYXRmb3JtLmlvbW11KTsKKworCQlpZiAoSVNf RVJSKG1tdSkpIHsKKwkJCXJldCA9IFBUUl9FUlIobW11KTsKKwkJCWdvdG8gZmFpbDsKKwkJfQor CisJCWFzcGFjZSA9IG1zbV9nZW1fYWRkcmVzc19zcGFjZV9jcmVhdGUobW11LCAibWRwNSIsCisJ CQkweDEwMDAsIDB4ZmZmZmZmZmYpOwogCQlpZiAoSVNfRVJSKGFzcGFjZSkpIHsKKwkJCW1tdS0+ ZnVuY3MtPmRlc3Ryb3kobW11KTsKIAkJCXJldCA9IFBUUl9FUlIoYXNwYWNlKTsKIAkJCWdvdG8g ZmFpbDsKIAkJfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL21zbS9tc21fZHJ2LmggYi9k cml2ZXJzL2dwdS9kcm0vbXNtL21zbV9kcnYuaAppbmRleCBlZTdiNTEyLi5jMjUwMmIyIDEwMDY0 NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vbXNtL21zbV9kcnYuaAorKysgYi9kcml2ZXJzL2dwdS9k cm0vbXNtL21zbV9kcnYuaApAQCAtMjQ0LDEyICsyNDQsOCBAQCB2b2lkIG1zbV9nZW1fY2xvc2Vf dm1hKHN0cnVjdCBtc21fZ2VtX2FkZHJlc3Nfc3BhY2UgKmFzcGFjZSwKIHZvaWQgbXNtX2dlbV9h ZGRyZXNzX3NwYWNlX3B1dChzdHJ1Y3QgbXNtX2dlbV9hZGRyZXNzX3NwYWNlICphc3BhY2UpOwog CiBzdHJ1Y3QgbXNtX2dlbV9hZGRyZXNzX3NwYWNlICoKLW1zbV9nZW1fYWRkcmVzc19zcGFjZV9j cmVhdGUoc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgaW9tbXVfZG9tYWluICpkb21haW4sCi0J CWNvbnN0IGNoYXIgKm5hbWUpOwotCi1zdHJ1Y3QgbXNtX2dlbV9hZGRyZXNzX3NwYWNlICoKLW1z bV9nZW1fYWRkcmVzc19zcGFjZV9jcmVhdGVfYTJ4eChzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVj dCBtc21fZ3B1ICpncHUsCi0JCWNvbnN0IGNoYXIgKm5hbWUsIHVpbnQ2NF90IHZhX3N0YXJ0LCB1 aW50NjRfdCB2YV9lbmQpOworbXNtX2dlbV9hZGRyZXNzX3NwYWNlX2NyZWF0ZShzdHJ1Y3QgbXNt X21tdSAqbW11LCBjb25zdCBjaGFyICpuYW1lLAorCQl1NjQgdmFfc3RhcnQsIHU2NCB2YV9lbmQp OwogCiBpbnQgbXNtX3JlZ2lzdGVyX21tdShzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LCBzdHJ1Y3Qg bXNtX21tdSAqbW11KTsKIHZvaWQgbXNtX3VucmVnaXN0ZXJfbW11KHN0cnVjdCBkcm1fZGV2aWNl ICpkZXYsIHN0cnVjdCBtc21fbW11ICptbXUpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJt L21zbS9tc21fZ2VtX3ZtYS5jIGIvZHJpdmVycy9ncHUvZHJtL21zbS9tc21fZ2VtX3ZtYS5jCmlu ZGV4IDFhZjUzNTQuLjQ1ZDRhNjMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9tc20vbXNt X2dlbV92bWEuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL21zbV9nZW1fdm1hLmMKQEAgLTEy NywzMiArMTI3LDggQEAgaW50IG1zbV9nZW1faW5pdF92bWEoc3RydWN0IG1zbV9nZW1fYWRkcmVz c19zcGFjZSAqYXNwYWNlLAogCiAKIHN0cnVjdCBtc21fZ2VtX2FkZHJlc3Nfc3BhY2UgKgotbXNt X2dlbV9hZGRyZXNzX3NwYWNlX2NyZWF0ZShzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBpb21t dV9kb21haW4gKmRvbWFpbiwKLQkJY29uc3QgY2hhciAqbmFtZSkKLXsKLQlzdHJ1Y3QgbXNtX2dl bV9hZGRyZXNzX3NwYWNlICphc3BhY2U7Ci0JdTY0IHNpemUgPSBkb21haW4tPmdlb21ldHJ5LmFw ZXJ0dXJlX2VuZCAtCi0JCWRvbWFpbi0+Z2VvbWV0cnkuYXBlcnR1cmVfc3RhcnQ7Ci0KLQlhc3Bh Y2UgPSBremFsbG9jKHNpemVvZigqYXNwYWNlKSwgR0ZQX0tFUk5FTCk7Ci0JaWYgKCFhc3BhY2Up Ci0JCXJldHVybiBFUlJfUFRSKC1FTk9NRU0pOwotCi0Jc3Bpbl9sb2NrX2luaXQoJmFzcGFjZS0+ bG9jayk7Ci0JYXNwYWNlLT5uYW1lID0gbmFtZTsKLQlhc3BhY2UtPm1tdSA9IG1zbV9pb21tdV9u ZXcoZGV2LCBkb21haW4pOwotCi0JZHJtX21tX2luaXQoJmFzcGFjZS0+bW0sIChkb21haW4tPmdl b21ldHJ5LmFwZXJ0dXJlX3N0YXJ0ID4+IFBBR0VfU0hJRlQpLAotCQlzaXplID4+IFBBR0VfU0hJ RlQpOwotCi0Ja3JlZl9pbml0KCZhc3BhY2UtPmtyZWYpOwotCi0JcmV0dXJuIGFzcGFjZTsKLX0K LQotc3RydWN0IG1zbV9nZW1fYWRkcmVzc19zcGFjZSAqCi1tc21fZ2VtX2FkZHJlc3Nfc3BhY2Vf Y3JlYXRlX2EyeHgoc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgbXNtX2dwdSAqZ3B1LAotCQlj b25zdCBjaGFyICpuYW1lLCB1aW50NjRfdCB2YV9zdGFydCwgdWludDY0X3QgdmFfZW5kKQorbXNt X2dlbV9hZGRyZXNzX3NwYWNlX2NyZWF0ZShzdHJ1Y3QgbXNtX21tdSAqbW11LCBjb25zdCBjaGFy ICpuYW1lLAorCQl1NjQgdmFfc3RhcnQsIHU2NCB2YV9lbmQpCiB7CiAJc3RydWN0IG1zbV9nZW1f YWRkcmVzc19zcGFjZSAqYXNwYWNlOwogCXU2NCBzaXplID0gdmFfZW5kIC0gdmFfc3RhcnQ7CkBA IC0xNjMsNyArMTM5LDcgQEAgbXNtX2dlbV9hZGRyZXNzX3NwYWNlX2NyZWF0ZV9hMnh4KHN0cnVj dCBkZXZpY2UgKmRldiwgc3RydWN0IG1zbV9ncHUgKmdwdSwKIAogCXNwaW5fbG9ja19pbml0KCZh c3BhY2UtPmxvY2spOwogCWFzcGFjZS0+bmFtZSA9IG5hbWU7Ci0JYXNwYWNlLT5tbXUgPSBtc21f Z3B1bW11X25ldyhkZXYsIGdwdSk7CisJYXNwYWNlLT5tbXUgPSBtbXU7CiAKIAlkcm1fbW1faW5p dCgmYXNwYWNlLT5tbSwgKHZhX3N0YXJ0ID4+IFBBR0VfU0hJRlQpLAogCQlzaXplID4+IFBBR0Vf U0hJRlQpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL21zbS9tc21fZ3B1LmMgYi9kcml2 ZXJzL2dwdS9kcm0vbXNtL21zbV9ncHUuYwppbmRleCA0ZWRiODc0Li45MjcxZjM5IDEwMDY0NAot LS0gYS9kcml2ZXJzL2dwdS9kcm0vbXNtL21zbV9ncHUuYworKysgYi9kcml2ZXJzL2dwdS9kcm0v bXNtL21zbV9ncHUuYwpAQCAtODA2LDYgKzgwNiw3IEBAIG1zbV9ncHVfY3JlYXRlX2FkZHJlc3Nf c3BhY2Uoc3RydWN0IG1zbV9ncHUgKmdwdSwgc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldiwK IAkJdWludDY0X3QgdmFfc3RhcnQsIHVpbnQ2NF90IHZhX2VuZCkKIHsKIAlzdHJ1Y3QgbXNtX2dl bV9hZGRyZXNzX3NwYWNlICphc3BhY2U7CisJc3RydWN0IG1zbV9tbXUgKm1tdTsKIAlpbnQgcmV0 OwogCiAJLyoKQEAgLTgxOCwyMCArODE5LDI0IEBAIG1zbV9ncHVfY3JlYXRlX2FkZHJlc3Nfc3Bh Y2Uoc3RydWN0IG1zbV9ncHUgKmdwdSwgc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldiwKIAkJ aWYgKCFpb21tdSkKIAkJCXJldHVybiBOVUxMOwogCi0JCWlvbW11LT5nZW9tZXRyeS5hcGVydHVy ZV9zdGFydCA9IHZhX3N0YXJ0OwotCQlpb21tdS0+Z2VvbWV0cnkuYXBlcnR1cmVfZW5kID0gdmFf ZW5kOworCQltbXUgPSBtc21faW9tbXVfbmV3KCZwZGV2LT5kZXYsIGlvbW11KTsKKwkJaWYgKElT X0VSUihtbXUpKSB7CisJCQlpb21tdV9kb21haW5fZnJlZShpb21tdSk7CisJCQlyZXR1cm4gRVJS X0NBU1QobW11KTsKKwkJfQogCiAJCURSTV9ERVZfSU5GTyhncHUtPmRldi0+ZGV2LCAiJXM6IHVz aW5nIElPTU1VXG4iLCBncHUtPm5hbWUpOwogCi0JCWFzcGFjZSA9IG1zbV9nZW1fYWRkcmVzc19z cGFjZV9jcmVhdGUoJnBkZXYtPmRldiwgaW9tbXUsICJncHUiKTsKLQkJaWYgKElTX0VSUihhc3Bh Y2UpKQotCQkJaW9tbXVfZG9tYWluX2ZyZWUoaW9tbXUpOwogCX0gZWxzZSB7Ci0JCWFzcGFjZSA9 IG1zbV9nZW1fYWRkcmVzc19zcGFjZV9jcmVhdGVfYTJ4eCgmcGRldi0+ZGV2LCBncHUsICJncHUi LAotCQkJdmFfc3RhcnQsIHZhX2VuZCk7CisJCW1tdSA9IG1zbV9ncHVtbXVfbmV3KCZwZGV2LT5k ZXYsIGdwdSk7CisJCWlmIChJU19FUlIobW11KSkKKwkJCXJldHVybiBFUlJfQ0FTVChtbXUpOwog CX0KIAorCWFzcGFjZSA9IG1zbV9nZW1fYWRkcmVzc19zcGFjZV9jcmVhdGUobW11LCAiZ3B1Iiwg dmFfc3RhcnQsIHZhX2VuZCk7CiAJaWYgKElTX0VSUihhc3BhY2UpKSB7CisJCW1tdS0+ZnVuY3Mt PmRlc3Ryb3kobW11KTsKKwogCQlEUk1fREVWX0VSUk9SKGdwdS0+ZGV2LT5kZXYsICJmYWlsZWQg dG8gaW5pdCBtbXU6ICVsZFxuIiwKIAkJCVBUUl9FUlIoYXNwYWNlKSk7CiAJCXJldHVybiBFUlJf Q0FTVChhc3BhY2UpOwotLSAKMi43LjQKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fCkZyZWVkcmVubyBtYWlsaW5nIGxpc3QKRnJlZWRyZW5vQGxpc3RzLmZy ZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3Rp bmZvL2ZyZWVkcmVubw==