From mboxrd@z Thu Jan 1 00:00:00 1970 X-GM-THRID: 6614497774807285760 X-Received: by 2002:a24:7907:: with SMTP id z7-v6mr7125251itc.4.1540057774775; Sat, 20 Oct 2018 10:49:34 -0700 (PDT) X-BeenThere: outreachy-kernel@googlegroups.com Received: by 2002:a02:f05:: with SMTP id h5-v6ls11726948jad.1.gmail; Sat, 20 Oct 2018 10:49:33 -0700 (PDT) X-Google-Smtp-Source: ACcGV62iSzBF898XFddX2IPLZaq3iGFS9FtjxqLXs36hFyZ4qu5pEuR2qnNZwtcIOqO0sZs2nTjB X-Received: by 2002:a02:298c:: with SMTP id p134-v6mr2117997jap.11.1540057773393; Sat, 20 Oct 2018 10:49:33 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1540057773; cv=none; d=google.com; s=arc-20160816; b=WAQS92kTXodrC4bCpX8Mnlbgm7rFwGqVk7trWM4EAuJ86T3chjrYb4Of9owJV+4s4t oetJDqI5gNvc2xBMBXJB2ToomSWyvVFlS/FG0Akb3/DZEH8Gr84vxhVaPjBdx5s0IxiV e3mYRUAmDiklgpxGUXDrpBvXx2XifeWeumlju5reWsc2shykIPssrEE2ZXb0H3VUjiL9 LNlL6GvIrHxZQCUc3nF5J3hqqzzdRksyMSkLOEImn+mMFwQi25LIjHraGzz+YqFIBs6K A28MtnHs0i1ktm+lUShkiqsLMosKXnIHU6QSKVB2qgYCnaCJT7Y8ZJz/n2uq3PSGKKL2 d2BA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=user-agent:content-disposition:mime-version:message-id:subject:cc :to:from:date:dkim-signature; bh=tH7Hc0pD4m5OiZL5mzN8cmNaFGkGs+etzcz4b+kTjho=; b=pz4Z6U2SD62gSv2ZaWfhLg4e4WpNqFkjgcwtsCWORQJi8K6DHcAEEf95lbidJnn2Yz BuYzkzeEIbSGokYysKJDkpmZUmksFekyjWNQ855gPOyyqG5hw4K5+dJcgbC59uoC4U/R rKgviktDyi4vBuTgaK0X4Tf5wFc6RjI61ohs5WMxKMAU50zsJx+CLAHZZvTnERXRte9/ /axMi+lSrWqF7Gc/2lMHQqpavPXkjyulOBngq+qGLMxESWXDrAEDtGwrotfK64Zc6GXY MDHWzJf0I45gjeA5WLcr1Gg5+QFeeLXclRPIh+wdkcsbUtzgn5jWDsRpbrDjsaJ44a7u eJZA== ARC-Authentication-Results: i=1; gmr-mx.google.com; dkim=pass header.i=@gmail.com header.s=20161025 header.b=hUNyeRqe; spf=pass (google.com: domain of mamtashukla555@gmail.com designates 2607:f8b0:4864:20::544 as permitted sender) smtp.mailfrom=mamtashukla555@gmail.com; dmarc=pass (p=NONE sp=QUARANTINE dis=NONE) header.from=gmail.com Return-Path: Received: from mail-pg1-x544.google.com (mail-pg1-x544.google.com. [2607:f8b0:4864:20::544]) by gmr-mx.google.com with ESMTPS id h10-v6si273394ith.2.2018.10.20.10.49.33 for (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Sat, 20 Oct 2018 10:49:33 -0700 (PDT) Received-SPF: pass (google.com: domain of mamtashukla555@gmail.com designates 2607:f8b0:4864:20::544 as permitted sender) client-ip=2607:f8b0:4864:20::544; Authentication-Results: gmr-mx.google.com; dkim=pass header.i=@gmail.com header.s=20161025 header.b=hUNyeRqe; spf=pass (google.com: domain of mamtashukla555@gmail.com designates 2607:f8b0:4864:20::544 as permitted sender) smtp.mailfrom=mamtashukla555@gmail.com; dmarc=pass (p=NONE sp=QUARANTINE dis=NONE) header.from=gmail.com Received: by mail-pg1-x544.google.com with SMTP id f8-v6so17148481pgq.5 for ; Sat, 20 Oct 2018 10:49:33 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=date:from:to:cc:subject:message-id:mime-version:content-disposition :user-agent; bh=tH7Hc0pD4m5OiZL5mzN8cmNaFGkGs+etzcz4b+kTjho=; b=hUNyeRqe+IfStxS2rVQ+Paa+pIky9dbGFxJ9Pn0hAOKh/Q8bhyoN0nuTO+R/WQpgKA Trvn7ztPsOA2daQwOHYh/eb8i3nH5KzQQeRBU+42iRqlNWI/b/vMhU0bYIAuSuI/LaEe ME54IuC9u9I+9dki3w+c+uauRcmyE/DXvKdPD7LfWldrn4EAu5k7B1URBMYxVc2kJNdZ WbVVpWGD1MVo7GZu32CEHmi6D8bfMTq5qIaL64h/k3zdMXSRqPUIdAKyqydYAA7Gfg44 hTZjdilbQ9l838i4QYdgB6FxRMx4BBPtLJGel7bDnGOiUmY3Mb4LTbMbD3I4wd6bK0I6 hidw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:date:from:to:cc:subject:message-id:mime-version :content-disposition:user-agent; bh=tH7Hc0pD4m5OiZL5mzN8cmNaFGkGs+etzcz4b+kTjho=; b=LPxTilnfEFXDUxlxHV8e49AgQiTdWyrzgDqFmELp6TlhbQvRQj1xB8BFFXg9BaimS1 d0JIUYmVxWvsHy1GMRgPHgwYco/g0kxI4h41g9qYEcqaaKNSEDe5pnw7xvOtWsBLEew1 Ky3jC+OqFKUj74+WcNQpDP9kWDrIMKr7XtIvTA+4JOfgqQw3ZU8j5YXg09+BCeeBAL5y q5AcjLQjiGDqVGkVQKwj9sfmJZxzc+clo09w+Nm2wWau8XDFMTks8ud+PPZQDpGHmx/N LYP2f4A+8pUcbU5pZOKi77sFlCjw54WaS5JfCj3trThGH1uhzCGShI/95qegfT4BhhOz YsxA== X-Gm-Message-State: AGRZ1gJp5A5eAMXzvzxv+1TYC/dG3ibKDhhKCyHsej1apaDA1e538lBv aIImp44lSDlg0MNxr2CvuZE= X-Received: by 2002:a63:d24d:: with SMTP id t13-v6mr1245786pgi.133.1540057770833; Sat, 20 Oct 2018 10:49:30 -0700 (PDT) Return-Path: Received: from armorer ([59.97.10.197]) by smtp.gmail.com with ESMTPSA id r1-v6sm42011935pff.145.2018.10.20.10.49.28 (version=TLS1 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Sat, 20 Oct 2018 10:49:30 -0700 (PDT) Date: Sat, 20 Oct 2018 23:19:26 +0530 From: Mamta Shukla To: outreachy-kernel@googlegroups.com Cc: dri-devel@lists.freedesktop.org, daniel.vetter@ffwll.ch, robdclark@gmail.com, airlied@linux.ie, sean@poorly.run Subject: [PATCH DRM] drm: msm: Use DRM_DEV_* instead of dev_* Message-ID: <20181020174926.GA32333@armorer> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline User-Agent: Mutt/1.5.21 (2010-09-15) Use DRM_DEV_INFO/ERROR/WARN instead of dev_info/err/debug to generate drm-formatted specific log messages so that it will be easy to differentiate in case of multiple instances of driver. Signed-off-by: Mamta Shukla --- drivers/gpu/drm/msm/adreno/a3xx_gpu.c | 4 +-- drivers/gpu/drm/msm/adreno/a4xx_gpu.c | 4 +-- drivers/gpu/drm/msm/adreno/a5xx_debugfs.c | 2 +- drivers/gpu/drm/msm/adreno/a5xx_gpu.c | 10 +++--- drivers/gpu/drm/msm/adreno/a5xx_preempt.c | 4 +-- drivers/gpu/drm/msm/adreno/a6xx_gmu.c | 38 ++++++++++---------- drivers/gpu/drm/msm/adreno/a6xx_gpu.c | 4 +-- drivers/gpu/drm/msm/adreno/a6xx_hfi.c | 14 ++++---- drivers/gpu/drm/msm/adreno/adreno_device.c | 6 ++-- drivers/gpu/drm/msm/adreno/adreno_gpu.c | 22 ++++++------ drivers/gpu/drm/msm/disp/dpu1/dpu_dbg.c | 28 +++++++-------- drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.c | 6 ++-- drivers/gpu/drm/msm/disp/mdp4/mdp4_crtc.c | 2 +- drivers/gpu/drm/msm/disp/mdp4/mdp4_dtv_encoder.c | 12 +++---- drivers/gpu/drm/msm/disp/mdp4/mdp4_kms.c | 44 +++++++++++------------ drivers/gpu/drm/msm/disp/mdp4/mdp4_lcdc_encoder.c | 22 ++++++------ drivers/gpu/drm/msm/disp/mdp4/mdp4_plane.c | 8 ++--- drivers/gpu/drm/msm/disp/mdp5/mdp5_cfg.c | 4 +-- drivers/gpu/drm/msm/disp/mdp5/mdp5_cmd_encoder.c | 10 +++--- drivers/gpu/drm/msm/disp/mdp5/mdp5_crtc.c | 8 ++--- drivers/gpu/drm/msm/disp/mdp5/mdp5_ctl.c | 16 ++++----- drivers/gpu/drm/msm/disp/mdp5/mdp5_kms.c | 30 ++++++++-------- drivers/gpu/drm/msm/disp/mdp5/mdp5_mdss.c | 10 +++--- drivers/gpu/drm/msm/disp/mdp5/mdp5_plane.c | 8 ++--- drivers/gpu/drm/msm/disp/mdp5/mdp5_smp.c | 4 +-- drivers/gpu/drm/msm/dsi/dsi.c | 10 +++--- drivers/gpu/drm/msm/dsi/dsi_host.c | 22 ++++++------ drivers/gpu/drm/msm/dsi/phy/dsi_phy.c | 28 +++++++-------- drivers/gpu/drm/msm/dsi/phy/dsi_phy_10nm.c | 6 ++-- drivers/gpu/drm/msm/dsi/phy/dsi_phy_14nm.c | 6 ++-- drivers/gpu/drm/msm/dsi/phy/dsi_phy_20nm.c | 2 +- drivers/gpu/drm/msm/dsi/phy/dsi_phy_28nm.c | 2 +- drivers/gpu/drm/msm/dsi/phy/dsi_phy_28nm_8960.c | 2 +- drivers/gpu/drm/msm/dsi/pll/dsi_pll.c | 2 +- drivers/gpu/drm/msm/dsi/pll/dsi_pll_10nm.c | 8 ++--- drivers/gpu/drm/msm/dsi/pll/dsi_pll_14nm.c | 12 +++---- drivers/gpu/drm/msm/dsi/pll/dsi_pll_28nm.c | 16 ++++----- drivers/gpu/drm/msm/dsi/pll/dsi_pll_28nm_8960.c | 10 +++--- drivers/gpu/drm/msm/edp/edp.c | 8 ++--- drivers/gpu/drm/msm/hdmi/hdmi.c | 32 ++++++++--------- drivers/gpu/drm/msm/hdmi/hdmi_bridge.c | 10 +++--- drivers/gpu/drm/msm/hdmi/hdmi_connector.c | 12 +++---- drivers/gpu/drm/msm/hdmi/hdmi_i2c.c | 2 +- drivers/gpu/drm/msm/hdmi/hdmi_phy.c | 12 +++---- drivers/gpu/drm/msm/hdmi/hdmi_phy_8996.c | 6 ++-- drivers/gpu/drm/msm/hdmi/hdmi_pll_8960.c | 4 +-- drivers/gpu/drm/msm/msm_debugfs.c | 6 ++-- drivers/gpu/drm/msm/msm_drv.c | 28 +++++++-------- drivers/gpu/drm/msm/msm_fb.c | 8 ++--- drivers/gpu/drm/msm/msm_fbdev.c | 8 ++--- drivers/gpu/drm/msm/msm_gem.c | 12 +++---- drivers/gpu/drm/msm/msm_gpu.c | 30 ++++++++-------- 52 files changed, 312 insertions(+), 312 deletions(-) diff --git a/drivers/gpu/drm/msm/adreno/a3xx_gpu.c b/drivers/gpu/drm/msm/adreno/a3xx_gpu.c index 669c2d4..c3b4bc6 100644 --- a/drivers/gpu/drm/msm/adreno/a3xx_gpu.c +++ b/drivers/gpu/drm/msm/adreno/a3xx_gpu.c @@ -481,7 +481,7 @@ struct msm_gpu *a3xx_gpu_init(struct drm_device *dev) int ret; if (!pdev) { - dev_err(dev->dev, "no a3xx device\n"); + DRM_DEV_ERROR(dev->dev, "no a3xx device\n"); ret = -ENXIO; goto fail; } @@ -528,7 +528,7 @@ struct msm_gpu *a3xx_gpu_init(struct drm_device *dev) * to not be possible to restrict access, then we must * implement a cmdstream validator. */ - dev_err(dev->dev, "No memory protection without IOMMU\n"); + DRM_DEV_ERROR(dev->dev, "No memory protection without IOMMU\n"); ret = -ENXIO; goto fail; } diff --git a/drivers/gpu/drm/msm/adreno/a4xx_gpu.c b/drivers/gpu/drm/msm/adreno/a4xx_gpu.c index 7c4e6dc..18f9a8e 100644 --- a/drivers/gpu/drm/msm/adreno/a4xx_gpu.c +++ b/drivers/gpu/drm/msm/adreno/a4xx_gpu.c @@ -561,7 +561,7 @@ struct msm_gpu *a4xx_gpu_init(struct drm_device *dev) int ret; if (!pdev) { - dev_err(dev->dev, "no a4xx device\n"); + DRM_DEV_ERROR(dev->dev, "no a4xx device\n"); ret = -ENXIO; goto fail; } @@ -608,7 +608,7 @@ struct msm_gpu *a4xx_gpu_init(struct drm_device *dev) * to not be possible to restrict access, then we must * implement a cmdstream validator. */ - dev_err(dev->dev, "No memory protection without IOMMU\n"); + DRM_DEV_ERROR(dev->dev, "No memory protection without IOMMU\n"); ret = -ENXIO; goto fail; } diff --git a/drivers/gpu/drm/msm/adreno/a5xx_debugfs.c b/drivers/gpu/drm/msm/adreno/a5xx_debugfs.c index d2127b1..6983cd9 100644 --- a/drivers/gpu/drm/msm/adreno/a5xx_debugfs.c +++ b/drivers/gpu/drm/msm/adreno/a5xx_debugfs.c @@ -173,7 +173,7 @@ int a5xx_debugfs_init(struct msm_gpu *gpu, struct drm_minor *minor) minor->debugfs_root, minor); if (ret) { - dev_err(dev->dev, "could not install a5xx_debugfs_list\n"); + DRM_DEV_ERROR(dev->dev, "could not install a5xx_debugfs_list\n"); return ret; } diff --git a/drivers/gpu/drm/msm/adreno/a5xx_gpu.c b/drivers/gpu/drm/msm/adreno/a5xx_gpu.c index b751b76..d07ef99 100644 --- a/drivers/gpu/drm/msm/adreno/a5xx_gpu.c +++ b/drivers/gpu/drm/msm/adreno/a5xx_gpu.c @@ -514,7 +514,7 @@ static int a5xx_ucode_init(struct msm_gpu *gpu) if (IS_ERR(a5xx_gpu->pm4_bo)) { ret = PTR_ERR(a5xx_gpu->pm4_bo); a5xx_gpu->pm4_bo = NULL; - dev_err(gpu->dev->dev, "could not allocate PM4: %d\n", + DRM_DEV_ERROR(gpu->dev->dev, "could not allocate PM4: %d\n", ret); return ret; } @@ -527,7 +527,7 @@ static int a5xx_ucode_init(struct msm_gpu *gpu) if (IS_ERR(a5xx_gpu->pfp_bo)) { ret = PTR_ERR(a5xx_gpu->pfp_bo); a5xx_gpu->pfp_bo = NULL; - dev_err(gpu->dev->dev, "could not allocate PFP: %d\n", + DRM_DEV_ERROR(gpu->dev->dev, "could not allocate PFP: %d\n", ret); return ret; } @@ -1028,7 +1028,7 @@ static void a5xx_fault_detect_irq(struct msm_gpu *gpu) struct msm_drm_private *priv = dev->dev_private; struct msm_ringbuffer *ring = gpu->funcs->active_ring(gpu); - dev_err(dev->dev, "gpu fault ring %d fence %x status %8.8X rb %4.4x/%4.4x ib1 %16.16llX/%4.4x ib2 %16.16llX/%4.4x\n", + DRM_DEV_ERROR(dev->dev, "gpu fault ring %d fence %x status %8.8X rb %4.4x/%4.4x ib1 %16.16llX/%4.4x ib2 %16.16llX/%4.4x\n", ring ? ring->id : -1, ring ? ring->seqno : 0, gpu_read(gpu, REG_A5XX_RBBM_STATUS), gpu_read(gpu, REG_A5XX_CP_RB_RPTR), @@ -1134,7 +1134,7 @@ static irqreturn_t a5xx_irq(struct msm_gpu *gpu) static void a5xx_dump(struct msm_gpu *gpu) { - dev_info(gpu->dev->dev, "status: %08x\n", + DRM_DEV_INFO(gpu->dev->dev, "status: %08x\n", gpu_read(gpu, REG_A5XX_RBBM_STATUS)); adreno_dump(gpu); } @@ -1495,7 +1495,7 @@ struct msm_gpu *a5xx_gpu_init(struct drm_device *dev) int ret; if (!pdev) { - dev_err(dev->dev, "No A5XX device is defined\n"); + DRM_DEV_ERROR(dev->dev, "No A5XX device is defined\n"); return ERR_PTR(-ENXIO); } diff --git a/drivers/gpu/drm/msm/adreno/a5xx_preempt.c b/drivers/gpu/drm/msm/adreno/a5xx_preempt.c index f3c21f8..3314112 100644 --- a/drivers/gpu/drm/msm/adreno/a5xx_preempt.c +++ b/drivers/gpu/drm/msm/adreno/a5xx_preempt.c @@ -92,7 +92,7 @@ static void a5xx_preempt_timer(struct timer_list *t) if (!try_preempt_state(a5xx_gpu, PREEMPT_TRIGGERED, PREEMPT_FAULTED)) return; - dev_err(dev->dev, "%s: preemption timed out\n", gpu->name); + DRM_DEV_ERROR(dev->dev, "%s: preemption timed out\n", gpu->name); queue_work(priv->wq, &gpu->recover_work); } @@ -188,7 +188,7 @@ void a5xx_preempt_irq(struct msm_gpu *gpu) status = gpu_read(gpu, REG_A5XX_CP_CONTEXT_SWITCH_CNTL); if (unlikely(status)) { set_preempt_state(a5xx_gpu, PREEMPT_FAULTED); - dev_err(dev->dev, "%s: Preemption failed to complete\n", + DRM_DEV_ERROR(dev->dev, "%s: Preemption failed to complete\n", gpu->name); queue_work(priv->wq, &gpu->recover_work); return; diff --git a/drivers/gpu/drm/msm/adreno/a6xx_gmu.c b/drivers/gpu/drm/msm/adreno/a6xx_gmu.c index bbb8126..d1e23f9 100644 --- a/drivers/gpu/drm/msm/adreno/a6xx_gmu.c +++ b/drivers/gpu/drm/msm/adreno/a6xx_gmu.c @@ -125,7 +125,7 @@ static int a6xx_gmu_start(struct a6xx_gmu *gmu) val == 0xbabeface, 100, 10000); if (ret) - dev_err(gmu->dev, "GMU firmware initialization timed out\n"); + DRM_DEV_ERROR(gmu->dev, "GMU firmware initialization timed out\n"); return ret; } @@ -143,7 +143,7 @@ static int a6xx_gmu_hfi_start(struct a6xx_gmu *gmu) ret = gmu_poll_timeout(gmu, REG_A6XX_GMU_HFI_CTRL_STATUS, val, val & 1, 100, 10000); if (ret) - dev_err(gmu->dev, "Unable to start the HFI queues\n"); + DRM_DEV_ERROR(gmu->dev, "Unable to start the HFI queues\n"); return ret; } @@ -184,7 +184,7 @@ int a6xx_gmu_set_oob(struct a6xx_gmu *gmu, enum a6xx_gmu_oob_state state) val & (1 << ack), 100, 10000); if (ret) - dev_err(gmu->dev, + DRM_DEV_ERROR(gmu->dev, "Timeout waiting for GMU OOB set %s: 0x%x\n", name, gmu_read(gmu, REG_A6XX_GMU_GMU2HOST_INTR_INFO)); @@ -226,7 +226,7 @@ static int a6xx_sptprac_enable(struct a6xx_gmu *gmu) (val & 0x38) == 0x28, 1, 100); if (ret) { - dev_err(gmu->dev, "Unable to power on SPTPRAC: 0x%x\n", + DRM_DEV_ERROR(gmu->dev, "Unable to power on SPTPRAC: 0x%x\n", gmu_read(gmu, REG_A6XX_GMU_SPTPRAC_PWR_CLK_STATUS)); } @@ -248,7 +248,7 @@ static void a6xx_sptprac_disable(struct a6xx_gmu *gmu) (val & 0x04), 100, 10000); if (ret) - dev_err(gmu->dev, "failed to power off SPTPRAC: 0x%x\n", + DRM_DEV_ERROR(gmu->dev, "failed to power off SPTPRAC: 0x%x\n", gmu_read(gmu, REG_A6XX_GMU_SPTPRAC_PWR_CLK_STATUS)); } @@ -292,7 +292,7 @@ static int a6xx_gmu_notify_slumber(struct a6xx_gmu *gmu) /* Check to see if the GMU really did slumber */ if (gmu_read(gmu, REG_A6XX_GPU_GMU_CX_GMU_RPMH_POWER_STATE) != 0x0f) { - dev_err(gmu->dev, "The GMU did not go into slumber\n"); + DRM_DEV_ERROR(gmu->dev, "The GMU did not go into slumber\n"); ret = -ETIMEDOUT; } } @@ -314,7 +314,7 @@ static int a6xx_rpmh_start(struct a6xx_gmu *gmu) ret = gmu_poll_timeout(gmu, REG_A6XX_GMU_RSCC_CONTROL_ACK, val, val & (1 << 1), 100, 10000); if (ret) { - dev_err(gmu->dev, "Unable to power on the GPU RSC\n"); + DRM_DEV_ERROR(gmu->dev, "Unable to power on the GPU RSC\n"); return ret; } @@ -329,7 +329,7 @@ static int a6xx_rpmh_start(struct a6xx_gmu *gmu) return 0; } - dev_err(gmu->dev, "GPU RSC sequence stuck while waking up the GPU\n"); + DRM_DEV_ERROR(gmu->dev, "GPU RSC sequence stuck while waking up the GPU\n"); return ret; } @@ -343,7 +343,7 @@ static void a6xx_rpmh_stop(struct a6xx_gmu *gmu) ret = gmu_poll_timeout(gmu, REG_A6XX_GPU_RSCC_RSC_STATUS0_DRV0, val, val & (1 << 16), 100, 10000); if (ret) - dev_err(gmu->dev, "Unable to power off the GPU RSC\n"); + DRM_DEV_ERROR(gmu->dev, "Unable to power off the GPU RSC\n"); gmu_write(gmu, REG_A6XX_GMU_RSCC_CONTROL_REQ, 0); } @@ -476,7 +476,7 @@ static int a6xx_gmu_fw_start(struct a6xx_gmu *gmu, unsigned int state) /* Sanity check the size of the firmware that was loaded */ if (adreno_gpu->fw[ADRENO_FW_GMU]->size > 0x8000) { - dev_err(gmu->dev, + DRM_DEV_ERROR(gmu->dev, "GMU firmware is bigger than the available region\n"); return -EINVAL; } @@ -721,7 +721,7 @@ int a6xx_gmu_stop(struct a6xx_gpu *a6xx_gpu) */ if (ret) - dev_err(gmu->dev, + DRM_DEV_ERROR(gmu->dev, "Unable to slumber GMU: status = 0%x/0%x\n", gmu_read(gmu, REG_A6XX_GPU_GMU_AO_GPU_CX_BUSY_STATUS), @@ -800,7 +800,7 @@ static struct a6xx_gmu_bo *a6xx_gmu_memory_alloc(struct a6xx_gmu *gmu, IOMMU_READ | IOMMU_WRITE); if (ret) { - dev_err(gmu->dev, "Unable to map GMU buffer object\n"); + DRM_DEV_ERROR(gmu->dev, "Unable to map GMU buffer object\n"); for (i = i - 1 ; i >= 0; i--) iommu_unmap(gmu->domain, @@ -926,12 +926,12 @@ static int a6xx_gmu_rpmh_arc_votes_init(struct device *dev, u32 *votes, } if (j == pri_count) { - dev_err(dev, + DRM_DEV_ERROR(dev, "Level %u not found in in the RPMh list\n", level); - dev_err(dev, "Available levels:\n"); + DRM_DEV_ERROR(dev, "Available levels:\n"); for (j = 0; j < pri_count; j++) - dev_err(dev, " %u\n", pri[j]); + DRM_DEV_ERROR(dev, " %u\n", pri[j]); return -EINVAL; } @@ -1038,7 +1038,7 @@ static int a6xx_gmu_pwrlevels_probe(struct a6xx_gmu *gmu) */ ret = dev_pm_opp_of_add_table(gmu->dev); if (ret) { - dev_err(gmu->dev, "Unable to set the OPP table for the GMU\n"); + DRM_DEV_ERROR(gmu->dev, "Unable to set the OPP table for the GMU\n"); return ret; } @@ -1079,13 +1079,13 @@ static void __iomem *a6xx_gmu_get_mmio(struct platform_device *pdev, IORESOURCE_MEM, name); if (!res) { - dev_err(&pdev->dev, "Unable to find the %s registers\n", name); + DRM_DEV_ERROR(&pdev->dev, "Unable to find the %s registers\n", name); return ERR_PTR(-EINVAL); } ret = devm_ioremap(&pdev->dev, res->start, resource_size(res)); if (!ret) { - dev_err(&pdev->dev, "Unable to map the %s registers\n", name); + DRM_DEV_ERROR(&pdev->dev, "Unable to map the %s registers\n", name); return ERR_PTR(-EINVAL); } @@ -1102,7 +1102,7 @@ static int a6xx_gmu_get_irq(struct a6xx_gmu *gmu, struct platform_device *pdev, ret = devm_request_irq(&pdev->dev, irq, handler, IRQF_TRIGGER_HIGH, name, gmu); if (ret) { - dev_err(&pdev->dev, "Unable to get interrupt %s\n", name); + DRM_DEV_ERROR(&pdev->dev, "Unable to get interrupt %s\n", name); return ret; } diff --git a/drivers/gpu/drm/msm/adreno/a6xx_gpu.c b/drivers/gpu/drm/msm/adreno/a6xx_gpu.c index 53b9061..70de786 100644 --- a/drivers/gpu/drm/msm/adreno/a6xx_gpu.c +++ b/drivers/gpu/drm/msm/adreno/a6xx_gpu.c @@ -481,7 +481,7 @@ static int a6xx_hw_init(struct msm_gpu *gpu) static void a6xx_dump(struct msm_gpu *gpu) { - dev_info(&gpu->pdev->dev, "status: %08x\n", + DRM_DEV_INFO(&gpu->pdev->dev, "status: %08x\n", gpu_read(gpu, REG_A6XX_RBBM_STATUS)); adreno_dump(gpu); } @@ -498,7 +498,7 @@ static void a6xx_recover(struct msm_gpu *gpu) adreno_dump_info(gpu); for (i = 0; i < 8; i++) - dev_info(&gpu->pdev->dev, "CP_SCRATCH_REG%d: %u\n", i, + DRM_DEV_INFO(&gpu->pdev->dev, "CP_SCRATCH_REG%d: %u\n", i, gpu_read(gpu, REG_A6XX_CP_SCRATCH_REG(i))); if (hang_debug) diff --git a/drivers/gpu/drm/msm/adreno/a6xx_hfi.c b/drivers/gpu/drm/msm/adreno/a6xx_hfi.c index f19ef4c..5858e79 100644 --- a/drivers/gpu/drm/msm/adreno/a6xx_hfi.c +++ b/drivers/gpu/drm/msm/adreno/a6xx_hfi.c @@ -120,7 +120,7 @@ static void a6xx_hfi_handle_ack(struct a6xx_gmu *gmu, } spin_unlock(&hfi_ack_lock); - dev_err(gmu->dev, "Nobody was waiting for HFI message %d\n", seqnum); + DRM_DEV_ERROR(gmu->dev, "Nobody was waiting for HFI message %d\n", seqnum); } static void a6xx_hfi_handle_error(struct a6xx_gmu *gmu, @@ -128,7 +128,7 @@ static void a6xx_hfi_handle_error(struct a6xx_gmu *gmu, { struct a6xx_hfi_msg_error *error = (struct a6xx_hfi_msg_error *) msg; - dev_err(gmu->dev, "GMU firmware error %d\n", error->code); + DRM_DEV_ERROR(gmu->dev, "GMU firmware error %d\n", error->code); } void a6xx_hfi_task(unsigned long data) @@ -145,7 +145,7 @@ void a6xx_hfi_task(unsigned long data) /* Returns the number of bytes copied or negative on error */ if (ret <= 0) { if (ret < 0) - dev_err(gmu->dev, + DRM_DEV_ERROR(gmu->dev, "Unable to read the HFI message queue\n"); break; } @@ -183,7 +183,7 @@ static int a6xx_hfi_send_msg(struct a6xx_gmu *gmu, int id, ret = a6xx_hfi_queue_write(gmu, queue, data, dwords); if (ret) { - dev_err(gmu->dev, "Unable to send message %s id %d\n", + DRM_DEV_ERROR(gmu->dev, "Unable to send message %s id %d\n", a6xx_hfi_msg_id[id], seqnum); goto out; } @@ -192,7 +192,7 @@ static int a6xx_hfi_send_msg(struct a6xx_gmu *gmu, int id, ret = wait_for_completion_timeout(&resp.complete, msecs_to_jiffies(5000)); if (!ret) { - dev_err(gmu->dev, + DRM_DEV_ERROR(gmu->dev, "Message %s id %d timed out waiting for response\n", a6xx_hfi_msg_id[id], seqnum); ret = -ETIMEDOUT; @@ -208,7 +208,7 @@ static int a6xx_hfi_send_msg(struct a6xx_gmu *gmu, int id, return ret; if (resp.error) { - dev_err(gmu->dev, "Message %s id %d returned error %d\n", + DRM_DEV_ERROR(gmu->dev, "Message %s id %d returned error %d\n", a6xx_hfi_msg_id[id], seqnum, resp.error); return -EINVAL; } @@ -368,7 +368,7 @@ void a6xx_hfi_stop(struct a6xx_gmu *gmu) continue; if (queue->header->read_index != queue->header->write_index) - dev_err(gmu->dev, "HFI queue %d is not empty\n", i); + DRM_DEV_ERROR(gmu->dev, "HFI queue %d is not empty\n", i); queue->header->read_index = 0; queue->header->write_index = 0; diff --git a/drivers/gpu/drm/msm/adreno/adreno_device.c b/drivers/gpu/drm/msm/adreno/adreno_device.c index 7d3e9a1..78bfa11 100644 --- a/drivers/gpu/drm/msm/adreno/adreno_device.c +++ b/drivers/gpu/drm/msm/adreno/adreno_device.c @@ -195,7 +195,7 @@ struct msm_gpu *adreno_load_gpu(struct drm_device *dev) ret = pm_runtime_get_sync(&pdev->dev); if (ret < 0) { - dev_err(dev->dev, "Couldn't power up the GPU: %d\n", ret); + DRM_DEV_ERROR(dev->dev, "Couldn't power up the GPU: %d\n", ret); return NULL; } @@ -204,7 +204,7 @@ struct msm_gpu *adreno_load_gpu(struct drm_device *dev) mutex_unlock(&dev->struct_mutex); pm_runtime_put_autosuspend(&pdev->dev); if (ret) { - dev_err(dev->dev, "gpu hw init failed: %d\n", ret); + DRM_DEV_ERROR(dev->dev, "gpu hw init failed: %d\n", ret); return NULL; } @@ -252,7 +252,7 @@ static int find_chipid(struct device *dev, struct adreno_rev *rev) /* and if that fails, fall back to legacy "qcom,chipid" property: */ ret = of_property_read_u32(node, "qcom,chipid", &chipid); if (ret) { - dev_err(dev, "could not parse qcom,chipid: %d\n", ret); + DRM_DEV_ERROR(dev, "could not parse qcom,chipid: %d\n", ret); return ret; } diff --git a/drivers/gpu/drm/msm/adreno/adreno_gpu.c b/drivers/gpu/drm/msm/adreno/adreno_gpu.c index da1363a..141062f 100644 --- a/drivers/gpu/drm/msm/adreno/adreno_gpu.c +++ b/drivers/gpu/drm/msm/adreno/adreno_gpu.c @@ -89,12 +89,12 @@ int adreno_get_param(struct msm_gpu *gpu, uint32_t param, uint64_t *value) ret = request_firmware_direct(&fw, newname, drm->dev); if (!ret) { - dev_info(drm->dev, "loaded %s from new location\n", + DRM_DEV_INFO(drm->dev, "loaded %s from new location\n", newname); adreno_gpu->fwloc = FW_LOCATION_NEW; goto out; } else if (adreno_gpu->fwloc != FW_LOCATION_UNKNOWN) { - dev_err(drm->dev, "failed to load %s: %d\n", + DRM_DEV_ERROR(drm->dev, "failed to load %s: %d\n", newname, ret); fw = ERR_PTR(ret); goto out; @@ -109,12 +109,12 @@ int adreno_get_param(struct msm_gpu *gpu, uint32_t param, uint64_t *value) ret = request_firmware_direct(&fw, fwname, drm->dev); if (!ret) { - dev_info(drm->dev, "loaded %s from legacy location\n", + DRM_DEV_INFO(drm->dev, "loaded %s from legacy location\n", newname); adreno_gpu->fwloc = FW_LOCATION_LEGACY; goto out; } else if (adreno_gpu->fwloc != FW_LOCATION_UNKNOWN) { - dev_err(drm->dev, "failed to load %s: %d\n", + DRM_DEV_ERROR(drm->dev, "failed to load %s: %d\n", fwname, ret); fw = ERR_PTR(ret); goto out; @@ -130,19 +130,19 @@ int adreno_get_param(struct msm_gpu *gpu, uint32_t param, uint64_t *value) ret = request_firmware(&fw, newname, drm->dev); if (!ret) { - dev_info(drm->dev, "loaded %s with helper\n", + DRM_DEV_INFO(drm->dev, "loaded %s with helper\n", newname); adreno_gpu->fwloc = FW_LOCATION_HELPER; goto out; } else if (adreno_gpu->fwloc != FW_LOCATION_UNKNOWN) { - dev_err(drm->dev, "failed to load %s: %d\n", + DRM_DEV_ERROR(drm->dev, "failed to load %s: %d\n", newname, ret); fw = ERR_PTR(ret); goto out; } } - dev_err(drm->dev, "failed to load %s\n", fwname); + DRM_DEV_ERROR(drm->dev, "failed to load %s\n", fwname); fw = ERR_PTR(-ENOENT); out: kfree(newname); @@ -212,7 +212,7 @@ int adreno_hw_init(struct msm_gpu *gpu) ret = msm_gem_get_iova(ring->bo, gpu->aspace, &ring->iova); if (ret) { ring->iova = 0; - dev_err(gpu->dev->dev, + DRM_DEV_ERROR(gpu->dev->dev, "could not map ringbuffer %d: %d\n", i, ret); return ret; } @@ -277,7 +277,7 @@ void adreno_recover(struct msm_gpu *gpu) ret = msm_gpu_hw_init(gpu); if (ret) { - dev_err(dev->dev, "gpu hw init failed: %d\n", ret); + DRM_DEV_ERROR(dev->dev, "gpu hw init failed: %d\n", ret); /* hmm, oh well? */ } } @@ -636,7 +636,7 @@ static int adreno_get_legacy_pwrlevels(struct device *dev) node = of_find_compatible_node(dev->of_node, NULL, "qcom,gpu-pwrlevels"); if (!node) { - dev_err(dev, "Could not find the GPU powerlevels\n"); + DRM_DEV_ERROR(dev, "Could not find the GPU powerlevels\n"); return -ENXIO; } @@ -673,7 +673,7 @@ static int adreno_get_pwrlevels(struct device *dev, else { ret = dev_pm_opp_of_add_table(dev); if (ret) - dev_err(dev, "Unable to set the OPP table\n"); + DRM_DEV_ERROR(dev, "Unable to set the OPP table\n"); } if (!ret) { diff --git a/drivers/gpu/drm/msm/disp/dpu1/dpu_dbg.c b/drivers/gpu/drm/msm/disp/dpu1/dpu_dbg.c index ae2aee7..a850781 100644 --- a/drivers/gpu/drm/msm/disp/dpu1/dpu_dbg.c +++ b/drivers/gpu/drm/msm/disp/dpu1/dpu_dbg.c @@ -144,7 +144,7 @@ struct dpu_dbg_vbif_debug_bus { static void _dpu_debug_bus_xbar_dump(void __iomem *mem_base, struct dpu_debug_bus_entry *entry, u32 val) { - dev_err(dpu_dbg_base.dev, "xbar 0x%x %d %d 0x%x\n", + DRM_DEV_ERROR(dpu_dbg_base.dev, "xbar 0x%x %d %d 0x%x\n", entry->wr_addr, entry->block_id, entry->test_id, val); } @@ -154,7 +154,7 @@ static void _dpu_debug_bus_lm_dump(void __iomem *mem_base, if (!(val & 0xFFF000)) return; - dev_err(dpu_dbg_base.dev, "lm 0x%x %d %d 0x%x\n", + DRM_DEV_ERROR(dpu_dbg_base.dev, "lm 0x%x %d %d 0x%x\n", entry->wr_addr, entry->block_id, entry->test_id, val); } @@ -164,7 +164,7 @@ static void _dpu_debug_bus_ppb0_dump(void __iomem *mem_base, if (!(val & BIT(15))) return; - dev_err(dpu_dbg_base.dev, "ppb0 0x%x %d %d 0x%x\n", + DRM_DEV_ERROR(dpu_dbg_base.dev, "ppb0 0x%x %d %d 0x%x\n", entry->wr_addr, entry->block_id, entry->test_id, val); } @@ -174,7 +174,7 @@ static void _dpu_debug_bus_ppb1_dump(void __iomem *mem_base, if (!(val & BIT(15))) return; - dev_err(dpu_dbg_base.dev, "ppb1 0x%x %d %d 0x%x\n", + DRM_DEV_ERROR(dpu_dbg_base.dev, "ppb1 0x%x %d %d 0x%x\n", entry->wr_addr, entry->block_id, entry->test_id, val); } @@ -1994,7 +1994,7 @@ static void _dpu_dbg_dump_dpu_dbg_bus(struct dpu_dbg_dpu_debug_bus *bus) if (!in_log && !in_mem) return; - dev_info(dpu_dbg_base.dev, "======== start %s dump =========\n", + DRM_DEV_INFO(dpu_dbg_base.dev, "======== start %s dump =========\n", bus->cmn.name); if (in_mem) { @@ -2004,7 +2004,7 @@ static void _dpu_dbg_dump_dpu_dbg_bus(struct dpu_dbg_dpu_debug_bus *bus) if (*dump_mem) { dump_addr = *dump_mem; - dev_info(dpu_dbg_base.dev, + DRM_DEV_INFO(dpu_dbg_base.dev, "%s: start_addr:0x%pK len:0x%x\n", __func__, dump_addr, list_size); } else { @@ -2032,7 +2032,7 @@ static void _dpu_dbg_dump_dpu_dbg_bus(struct dpu_dbg_dpu_debug_bus *bus) status = readl_relaxed(mem_base + offset); if (in_log) - dev_info(dpu_dbg_base.dev, + DRM_DEV_INFO(dpu_dbg_base.dev, "waddr=0x%x blk=%d tst=%d val=0x%x\n", head->wr_addr, head->block_id, head->test_id, status); @@ -2055,7 +2055,7 @@ static void _dpu_dbg_dump_dpu_dbg_bus(struct dpu_dbg_dpu_debug_bus *bus) } _dpu_dbg_enable_power(false); - dev_info(dpu_dbg_base.dev, "======== end %s dump =========\n", + DRM_DEV_INFO(dpu_dbg_base.dev, "======== end %s dump =========\n", bus->cmn.name); } @@ -2086,7 +2086,7 @@ static void _dpu_dbg_dump_vbif_debug_bus_entry( *dump_addr++ = val; } if (in_log) - dev_info(dpu_dbg_base.dev, + DRM_DEV_INFO(dpu_dbg_base.dev, "testpoint:%x arb/xin id=%d index=%d val=0x%x\n", head->block_bus_addr, i, j, val); } @@ -2127,7 +2127,7 @@ static void _dpu_dbg_dump_vbif_dbg_bus(struct dpu_dbg_vbif_debug_bus *bus) list_size = bus->cmn.entries_size; dump_mem = &bus->cmn.dumped_content; - dev_info(dpu_dbg_base.dev, "======== start %s dump =========\n", + DRM_DEV_INFO(dpu_dbg_base.dev, "======== start %s dump =========\n", bus->cmn.name); if (!dump_mem || !dbg_bus || !bus_size || !list_size) @@ -2155,7 +2155,7 @@ static void _dpu_dbg_dump_vbif_dbg_bus(struct dpu_dbg_vbif_debug_bus *bus) if (*dump_mem) { dump_addr = *dump_mem; - dev_info(dpu_dbg_base.dev, + DRM_DEV_INFO(dpu_dbg_base.dev, "%s: start_addr:0x%pK len:0x%x\n", __func__, dump_addr, list_size); } else { @@ -2180,7 +2180,7 @@ static void _dpu_dbg_dump_vbif_dbg_bus(struct dpu_dbg_vbif_debug_bus *bus) reg = readl_relaxed(mem_base + MMSS_VBIF_XIN_HALT_CTRL1); reg1 = readl_relaxed(mem_base + MMSS_VBIF_PND_ERR); reg2 = readl_relaxed(mem_base + MMSS_VBIF_SRC_ERR); - dev_err(dpu_dbg_base.dev, + DRM_DEV_ERROR(dpu_dbg_base.dev, "XIN HALT:0x%lX, PND ERR:0x%lX, SRC ERR:0x%lX\n", reg, reg1, reg2); reg >>= 16; @@ -2194,7 +2194,7 @@ static void _dpu_dbg_dump_vbif_dbg_bus(struct dpu_dbg_vbif_debug_bus *bus) d0 = readl_relaxed(mem_base + MMSS_VBIF_ERR_INFO); d1 = readl_relaxed(mem_base + MMSS_VBIF_ERR_INFO_1); - dev_err(dpu_dbg_base.dev, + DRM_DEV_ERROR(dpu_dbg_base.dev, "Client:%d, errinfo=0x%X, errinfo1=0x%X\n", i, d0, d1); } @@ -2217,7 +2217,7 @@ static void _dpu_dbg_dump_vbif_dbg_bus(struct dpu_dbg_vbif_debug_bus *bus) _dpu_dbg_enable_power(false); - dev_info(dpu_dbg_base.dev, "======== end %s dump =========\n", + DRM_DEV_INFO(dpu_dbg_base.dev, "======== end %s dump =========\n", bus->cmn.name); } diff --git a/drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.c b/drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.c index 790d39f..676e9c3 100644 --- a/drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.c +++ b/drivers/gpu/drm/msm/disp/dpu1/dpu_io_util.c @@ -164,7 +164,7 @@ int msm_dss_parse_clock(struct platform_device *pdev, "clock-names", i, &clock_name); if (rc) { - dev_err(&pdev->dev, "Failed to get clock name for %d\n", + DRM_DEV_ERROR(&pdev->dev, "Failed to get clock name for %d\n", i); break; } @@ -176,13 +176,13 @@ int msm_dss_parse_clock(struct platform_device *pdev, rc = msm_dss_get_clk(&pdev->dev, mp->clk_config, num_clk); if (rc) { - dev_err(&pdev->dev, "Failed to get clock refs %d\n", rc); + DRM_DEV_ERROR(&pdev->dev, "Failed to get clock refs %d\n", rc); goto err; } rc = of_clk_set_defaults(pdev->dev.of_node, false); if (rc) { - dev_err(&pdev->dev, "Failed to set clock defaults %d\n", rc); + DRM_DEV_ERROR(&pdev->dev, "Failed to set clock defaults %d\n", rc); goto err; } diff --git a/drivers/gpu/drm/msm/disp/mdp4/mdp4_crtc.c b/drivers/gpu/drm/msm/disp/mdp4/mdp4_crtc.c index 457c29d..b91706c 100644 --- a/drivers/gpu/drm/msm/disp/mdp4/mdp4_crtc.c +++ b/drivers/gpu/drm/msm/disp/mdp4/mdp4_crtc.c @@ -429,7 +429,7 @@ static int mdp4_crtc_cursor_set(struct drm_crtc *crtc, int ret; if ((width > CURSOR_WIDTH) || (height > CURSOR_HEIGHT)) { - dev_err(dev->dev, "bad cursor size: %dx%d\n", width, height); + DRM_DEV_ERROR(dev->dev, "bad cursor size: %dx%d\n", width, height); return -EINVAL; } diff --git a/drivers/gpu/drm/msm/disp/mdp4/mdp4_dtv_encoder.c b/drivers/gpu/drm/msm/disp/mdp4/mdp4_dtv_encoder.c index ba8e587..a8fd14d 100644 --- a/drivers/gpu/drm/msm/disp/mdp4/mdp4_dtv_encoder.c +++ b/drivers/gpu/drm/msm/disp/mdp4/mdp4_dtv_encoder.c @@ -45,7 +45,7 @@ static void bs_init(struct mdp4_dtv_encoder *mdp4_dtv_encoder) struct lcdc_platform_data *dtv_pdata = mdp4_find_pdata("dtv.0"); if (!dtv_pdata) { - dev_err(dev->dev, "could not find dtv pdata\n"); + DRM_DEV_ERROR(dev->dev, "could not find dtv pdata\n"); return; } @@ -209,16 +209,16 @@ static void mdp4_dtv_encoder_enable(struct drm_encoder *encoder) ret = clk_set_rate(mdp4_dtv_encoder->mdp_clk, pc); if (ret) - dev_err(dev->dev, "failed to set mdp_clk to %lu: %d\n", + DRM_DEV_ERROR(dev->dev, "failed to set mdp_clk to %lu: %d\n", pc, ret); ret = clk_prepare_enable(mdp4_dtv_encoder->mdp_clk); if (ret) - dev_err(dev->dev, "failed to enabled mdp_clk: %d\n", ret); + DRM_DEV_ERROR(dev->dev, "failed to enabled mdp_clk: %d\n", ret); ret = clk_prepare_enable(mdp4_dtv_encoder->hdmi_clk); if (ret) - dev_err(dev->dev, "failed to enable hdmi_clk: %d\n", ret); + DRM_DEV_ERROR(dev->dev, "failed to enable hdmi_clk: %d\n", ret); mdp4_write(mdp4_kms, REG_MDP4_DTV_ENABLE, 1); @@ -258,14 +258,14 @@ struct drm_encoder *mdp4_dtv_encoder_init(struct drm_device *dev) mdp4_dtv_encoder->hdmi_clk = devm_clk_get(dev->dev, "hdmi_clk"); if (IS_ERR(mdp4_dtv_encoder->hdmi_clk)) { - dev_err(dev->dev, "failed to get hdmi_clk\n"); + DRM_DEV_ERROR(dev->dev, "failed to get hdmi_clk\n"); ret = PTR_ERR(mdp4_dtv_encoder->hdmi_clk); goto fail; } mdp4_dtv_encoder->mdp_clk = devm_clk_get(dev->dev, "tv_clk"); if (IS_ERR(mdp4_dtv_encoder->mdp_clk)) { - dev_err(dev->dev, "failed to get tv_clk\n"); + DRM_DEV_ERROR(dev->dev, "failed to get tv_clk\n"); ret = PTR_ERR(mdp4_dtv_encoder->mdp_clk); goto fail; } diff --git a/drivers/gpu/drm/msm/disp/mdp4/mdp4_kms.c b/drivers/gpu/drm/msm/disp/mdp4/mdp4_kms.c index 44d1cda..481c0d2 100644 --- a/drivers/gpu/drm/msm/disp/mdp4/mdp4_kms.c +++ b/drivers/gpu/drm/msm/disp/mdp4/mdp4_kms.c @@ -43,7 +43,7 @@ static int mdp4_hw_init(struct msm_kms *kms) DBG("found MDP4 version v%d.%d", major, minor); if (major != 4) { - dev_err(dev->dev, "unexpected MDP version: v%d.%d\n", + DRM_DEV_ERROR(dev->dev, "unexpected MDP version: v%d.%d\n", major, minor); ret = -ENXIO; goto out; @@ -251,7 +251,7 @@ static int mdp4_modeset_init_intf(struct mdp4_kms *mdp4_kms, encoder = mdp4_lcdc_encoder_init(dev, panel_node); if (IS_ERR(encoder)) { - dev_err(dev->dev, "failed to construct LCDC encoder\n"); + DRM_DEV_ERROR(dev->dev, "failed to construct LCDC encoder\n"); return PTR_ERR(encoder); } @@ -260,7 +260,7 @@ static int mdp4_modeset_init_intf(struct mdp4_kms *mdp4_kms, connector = mdp4_lvds_connector_init(dev, panel_node, encoder); if (IS_ERR(connector)) { - dev_err(dev->dev, "failed to initialize LVDS connector\n"); + DRM_DEV_ERROR(dev->dev, "failed to initialize LVDS connector\n"); return PTR_ERR(connector); } @@ -271,7 +271,7 @@ static int mdp4_modeset_init_intf(struct mdp4_kms *mdp4_kms, case DRM_MODE_ENCODER_TMDS: encoder = mdp4_dtv_encoder_init(dev); if (IS_ERR(encoder)) { - dev_err(dev->dev, "failed to construct DTV encoder\n"); + DRM_DEV_ERROR(dev->dev, "failed to construct DTV encoder\n"); return PTR_ERR(encoder); } @@ -282,7 +282,7 @@ static int mdp4_modeset_init_intf(struct mdp4_kms *mdp4_kms, /* Construct bridge/connector for HDMI: */ ret = msm_hdmi_modeset_init(priv->hdmi, dev, encoder); if (ret) { - dev_err(dev->dev, "failed to initialize HDMI: %d\n", ret); + DRM_DEV_ERROR(dev->dev, "failed to initialize HDMI: %d\n", ret); return ret; } } @@ -300,7 +300,7 @@ static int mdp4_modeset_init_intf(struct mdp4_kms *mdp4_kms, encoder = mdp4_dsi_encoder_init(dev); if (IS_ERR(encoder)) { ret = PTR_ERR(encoder); - dev_err(dev->dev, + DRM_DEV_ERROR(dev->dev, "failed to construct DSI encoder: %d\n", ret); return ret; } @@ -311,14 +311,14 @@ static int mdp4_modeset_init_intf(struct mdp4_kms *mdp4_kms, ret = msm_dsi_modeset_init(priv->dsi[dsi_id], dev, encoder); if (ret) { - dev_err(dev->dev, "failed to initialize DSI: %d\n", + DRM_DEV_ERROR(dev->dev, "failed to initialize DSI: %d\n", ret); return ret; } break; default: - dev_err(dev->dev, "Invalid or unsupported interface\n"); + DRM_DEV_ERROR(dev->dev, "Invalid or unsupported interface\n"); return -EINVAL; } @@ -354,7 +354,7 @@ static int modeset_init(struct mdp4_kms *mdp4_kms) for (i = 0; i < ARRAY_SIZE(vg_planes); i++) { plane = mdp4_plane_init(dev, vg_planes[i], false); if (IS_ERR(plane)) { - dev_err(dev->dev, + DRM_DEV_ERROR(dev->dev, "failed to construct plane for VG%d\n", i + 1); ret = PTR_ERR(plane); goto fail; @@ -365,7 +365,7 @@ static int modeset_init(struct mdp4_kms *mdp4_kms) for (i = 0; i < ARRAY_SIZE(mdp4_crtcs); i++) { plane = mdp4_plane_init(dev, rgb_planes[i], true); if (IS_ERR(plane)) { - dev_err(dev->dev, + DRM_DEV_ERROR(dev->dev, "failed to construct plane for RGB%d\n", i + 1); ret = PTR_ERR(plane); goto fail; @@ -374,7 +374,7 @@ static int modeset_init(struct mdp4_kms *mdp4_kms) crtc = mdp4_crtc_init(dev, plane, priv->num_crtcs, i, mdp4_crtcs[i]); if (IS_ERR(crtc)) { - dev_err(dev->dev, "failed to construct crtc for %s\n", + DRM_DEV_ERROR(dev->dev, "failed to construct crtc for %s\n", mdp4_crtc_names[i]); ret = PTR_ERR(crtc); goto fail; @@ -396,7 +396,7 @@ static int modeset_init(struct mdp4_kms *mdp4_kms) for (i = 0; i < ARRAY_SIZE(mdp4_intfs); i++) { ret = mdp4_modeset_init_intf(mdp4_kms, mdp4_intfs[i]); if (ret) { - dev_err(dev->dev, "failed to initialize intf: %d, %d\n", + DRM_DEV_ERROR(dev->dev, "failed to initialize intf: %d, %d\n", i, ret); goto fail; } @@ -419,7 +419,7 @@ struct msm_kms *mdp4_kms_init(struct drm_device *dev) mdp4_kms = kzalloc(sizeof(*mdp4_kms), GFP_KERNEL); if (!mdp4_kms) { - dev_err(dev->dev, "failed to allocate kms\n"); + DRM_DEV_ERROR(dev->dev, "failed to allocate kms\n"); ret = -ENOMEM; goto fail; } @@ -439,7 +439,7 @@ struct msm_kms *mdp4_kms_init(struct drm_device *dev) irq = platform_get_irq(pdev, 0); if (irq < 0) { ret = irq; - dev_err(dev->dev, "failed to get irq: %d\n", ret); + DRM_DEV_ERROR(dev->dev, "failed to get irq: %d\n", ret); goto fail; } @@ -456,14 +456,14 @@ struct msm_kms *mdp4_kms_init(struct drm_device *dev) if (mdp4_kms->vdd) { ret = regulator_enable(mdp4_kms->vdd); if (ret) { - dev_err(dev->dev, "failed to enable regulator vdd: %d\n", ret); + DRM_DEV_ERROR(dev->dev, "failed to enable regulator vdd: %d\n", ret); goto fail; } } mdp4_kms->clk = devm_clk_get(&pdev->dev, "core_clk"); if (IS_ERR(mdp4_kms->clk)) { - dev_err(dev->dev, "failed to get core_clk\n"); + DRM_DEV_ERROR(dev->dev, "failed to get core_clk\n"); ret = PTR_ERR(mdp4_kms->clk); goto fail; } @@ -475,14 +475,14 @@ struct msm_kms *mdp4_kms_init(struct drm_device *dev) // XXX if (rev >= MDP_REV_42) { ??? mdp4_kms->lut_clk = devm_clk_get(&pdev->dev, "lut_clk"); if (IS_ERR(mdp4_kms->lut_clk)) { - dev_err(dev->dev, "failed to get lut_clk\n"); + DRM_DEV_ERROR(dev->dev, "failed to get lut_clk\n"); ret = PTR_ERR(mdp4_kms->lut_clk); goto fail; } mdp4_kms->axi_clk = devm_clk_get(&pdev->dev, "bus_clk"); if (IS_ERR(mdp4_kms->axi_clk)) { - dev_err(dev->dev, "failed to get axi_clk\n"); + DRM_DEV_ERROR(dev->dev, "failed to get axi_clk\n"); ret = PTR_ERR(mdp4_kms->axi_clk); goto fail; } @@ -519,21 +519,21 @@ struct msm_kms *mdp4_kms_init(struct drm_device *dev) if (ret) goto fail; } else { - dev_info(dev->dev, "no iommu, fallback to phys " + DRM_DEV_INFO(dev->dev, "no iommu, fallback to phys " "contig buffers for scanout\n"); aspace = NULL; } ret = modeset_init(mdp4_kms); if (ret) { - dev_err(dev->dev, "modeset_init failed: %d\n", ret); + DRM_DEV_ERROR(dev->dev, "modeset_init failed: %d\n", ret); goto fail; } mdp4_kms->blank_cursor_bo = msm_gem_new(dev, SZ_16K, MSM_BO_WC); if (IS_ERR(mdp4_kms->blank_cursor_bo)) { ret = PTR_ERR(mdp4_kms->blank_cursor_bo); - dev_err(dev->dev, "could not allocate blank-cursor bo: %d\n", ret); + DRM_DEV_ERROR(dev->dev, "could not allocate blank-cursor bo: %d\n", ret); mdp4_kms->blank_cursor_bo = NULL; goto fail; } @@ -541,7 +541,7 @@ struct msm_kms *mdp4_kms_init(struct drm_device *dev) ret = msm_gem_get_iova(mdp4_kms->blank_cursor_bo, kms->aspace, &mdp4_kms->blank_cursor_iova); if (ret) { - dev_err(dev->dev, "could not pin blank-cursor bo: %d\n", ret); + DRM_DEV_ERROR(dev->dev, "could not pin blank-cursor bo: %d\n", ret); goto fail; } diff --git a/drivers/gpu/drm/msm/disp/mdp4/mdp4_lcdc_encoder.c b/drivers/gpu/drm/msm/disp/mdp4/mdp4_lcdc_encoder.c index 2bfb390..9e08c2e 100644 --- a/drivers/gpu/drm/msm/disp/mdp4/mdp4_lcdc_encoder.c +++ b/drivers/gpu/drm/msm/disp/mdp4/mdp4_lcdc_encoder.c @@ -47,7 +47,7 @@ static void bs_init(struct mdp4_lcdc_encoder *mdp4_lcdc_encoder) struct lcdc_platform_data *lcdc_pdata = mdp4_find_pdata("lvds.0"); if (!lcdc_pdata) { - dev_err(dev->dev, "could not find lvds pdata\n"); + DRM_DEV_ERROR(dev->dev, "could not find lvds pdata\n"); return; } @@ -224,7 +224,7 @@ static void setup_phy(struct drm_encoder *encoder) break; default: - dev_err(dev->dev, "unknown bpp: %d\n", bpp); + DRM_DEV_ERROR(dev->dev, "unknown bpp: %d\n", bpp); return; } @@ -241,7 +241,7 @@ static void setup_phy(struct drm_encoder *encoder) MDP4_LCDC_LVDS_INTF_CTL_CH1_CLK_LANE_EN; break; default: - dev_err(dev->dev, "unknown # of channels: %d\n", nchan); + DRM_DEV_ERROR(dev->dev, "unknown # of channels: %d\n", nchan); return; } @@ -361,7 +361,7 @@ static void mdp4_lcdc_encoder_disable(struct drm_encoder *encoder) for (i = 0; i < ARRAY_SIZE(mdp4_lcdc_encoder->regs); i++) { ret = regulator_disable(mdp4_lcdc_encoder->regs[i]); if (ret) - dev_err(dev->dev, "failed to disable regulator: %d\n", ret); + DRM_DEV_ERROR(dev->dev, "failed to disable regulator: %d\n", ret); } bs_set(mdp4_lcdc_encoder, 0); @@ -398,16 +398,16 @@ static void mdp4_lcdc_encoder_enable(struct drm_encoder *encoder) for (i = 0; i < ARRAY_SIZE(mdp4_lcdc_encoder->regs); i++) { ret = regulator_enable(mdp4_lcdc_encoder->regs[i]); if (ret) - dev_err(dev->dev, "failed to enable regulator: %d\n", ret); + DRM_DEV_ERROR(dev->dev, "failed to enable regulator: %d\n", ret); } DBG("setting lcdc_clk=%lu", pc); ret = clk_set_rate(mdp4_lcdc_encoder->lcdc_clk, pc); if (ret) - dev_err(dev->dev, "failed to configure lcdc_clk: %d\n", ret); + DRM_DEV_ERROR(dev->dev, "failed to configure lcdc_clk: %d\n", ret); ret = clk_prepare_enable(mdp4_lcdc_encoder->lcdc_clk); if (ret) - dev_err(dev->dev, "failed to enable lcdc_clk: %d\n", ret); + DRM_DEV_ERROR(dev->dev, "failed to enable lcdc_clk: %d\n", ret); panel = of_drm_find_panel(mdp4_lcdc_encoder->panel_node); if (!IS_ERR(panel)) { @@ -461,7 +461,7 @@ struct drm_encoder *mdp4_lcdc_encoder_init(struct drm_device *dev, /* TODO: do we need different pll in other cases? */ mdp4_lcdc_encoder->lcdc_clk = mpd4_lvds_pll_init(dev); if (IS_ERR(mdp4_lcdc_encoder->lcdc_clk)) { - dev_err(dev->dev, "failed to get lvds_clk\n"); + DRM_DEV_ERROR(dev->dev, "failed to get lvds_clk\n"); ret = PTR_ERR(mdp4_lcdc_encoder->lcdc_clk); goto fail; } @@ -470,7 +470,7 @@ struct drm_encoder *mdp4_lcdc_encoder_init(struct drm_device *dev, reg = devm_regulator_get(dev->dev, "lvds-vccs-3p3v"); if (IS_ERR(reg)) { ret = PTR_ERR(reg); - dev_err(dev->dev, "failed to get lvds-vccs-3p3v: %d\n", ret); + DRM_DEV_ERROR(dev->dev, "failed to get lvds-vccs-3p3v: %d\n", ret); goto fail; } mdp4_lcdc_encoder->regs[0] = reg; @@ -478,7 +478,7 @@ struct drm_encoder *mdp4_lcdc_encoder_init(struct drm_device *dev, reg = devm_regulator_get(dev->dev, "lvds-pll-vdda"); if (IS_ERR(reg)) { ret = PTR_ERR(reg); - dev_err(dev->dev, "failed to get lvds-pll-vdda: %d\n", ret); + DRM_DEV_ERROR(dev->dev, "failed to get lvds-pll-vdda: %d\n", ret); goto fail; } mdp4_lcdc_encoder->regs[1] = reg; @@ -486,7 +486,7 @@ struct drm_encoder *mdp4_lcdc_encoder_init(struct drm_device *dev, reg = devm_regulator_get(dev->dev, "lvds-vdda"); if (IS_ERR(reg)) { ret = PTR_ERR(reg); - dev_err(dev->dev, "failed to get lvds-vdda: %d\n", ret); + DRM_DEV_ERROR(dev->dev, "failed to get lvds-vdda: %d\n", ret); goto fail; } mdp4_lcdc_encoder->regs[2] = reg; diff --git a/drivers/gpu/drm/msm/disp/mdp4/mdp4_plane.c b/drivers/gpu/drm/msm/disp/mdp4/mdp4_plane.c index 7a49973..005066f 100644 --- a/drivers/gpu/drm/msm/disp/mdp4/mdp4_plane.c +++ b/drivers/gpu/drm/msm/disp/mdp4/mdp4_plane.c @@ -234,22 +234,22 @@ static int mdp4_plane_mode_set(struct drm_plane *plane, format = to_mdp_format(msm_framebuffer_format(fb)); if (src_w > (crtc_w * DOWN_SCALE_MAX)) { - dev_err(dev->dev, "Width down scaling exceeds limits!\n"); + DRM_DEV_ERROR(dev->dev, "Width down scaling exceeds limits!\n"); return -ERANGE; } if (src_h > (crtc_h * DOWN_SCALE_MAX)) { - dev_err(dev->dev, "Height down scaling exceeds limits!\n"); + DRM_DEV_ERROR(dev->dev, "Height down scaling exceeds limits!\n"); return -ERANGE; } if (crtc_w > (src_w * UP_SCALE_MAX)) { - dev_err(dev->dev, "Width up scaling exceeds limits!\n"); + DRM_DEV_ERROR(dev->dev, "Width up scaling exceeds limits!\n"); return -ERANGE; } if (crtc_h > (src_h * UP_SCALE_MAX)) { - dev_err(dev->dev, "Height up scaling exceeds limits!\n"); + DRM_DEV_ERROR(dev->dev, "Height up scaling exceeds limits!\n"); return -ERANGE; } diff --git a/drivers/gpu/drm/msm/disp/mdp5/mdp5_cfg.c b/drivers/gpu/drm/msm/disp/mdp5/mdp5_cfg.c index 824067d..42f9e4b 100644 --- a/drivers/gpu/drm/msm/disp/mdp5/mdp5_cfg.c +++ b/drivers/gpu/drm/msm/disp/mdp5/mdp5_cfg.c @@ -600,7 +600,7 @@ struct mdp5_cfg_handler *mdp5_cfg_init(struct mdp5_kms *mdp5_kms, } if (major != 1) { - dev_err(dev->dev, "unexpected MDP major version: v%d.%d\n", + DRM_DEV_ERROR(dev->dev, "unexpected MDP major version: v%d.%d\n", major, minor); ret = -ENXIO; goto fail; @@ -615,7 +615,7 @@ struct mdp5_cfg_handler *mdp5_cfg_init(struct mdp5_kms *mdp5_kms, break; } if (unlikely(!mdp5_cfg)) { - dev_err(dev->dev, "unexpected MDP minor revision: v%d.%d\n", + DRM_DEV_ERROR(dev->dev, "unexpected MDP minor revision: v%d.%d\n", major, minor); ret = -ENXIO; goto fail; diff --git a/drivers/gpu/drm/msm/disp/mdp5/mdp5_cmd_encoder.c b/drivers/gpu/drm/msm/disp/mdp5/mdp5_cmd_encoder.c index d6f79dc..c1962f2 100644 --- a/drivers/gpu/drm/msm/disp/mdp5/mdp5_cmd_encoder.c +++ b/drivers/gpu/drm/msm/disp/mdp5/mdp5_cmd_encoder.c @@ -55,20 +55,20 @@ static int pingpong_tearcheck_setup(struct drm_encoder *encoder, int pp_id = mixer->pp; if (IS_ERR_OR_NULL(mdp5_kms->vsync_clk)) { - dev_err(dev, "vsync_clk is not initialized\n"); + DRM_DEV_ERROR(dev, "vsync_clk is not initialized\n"); return -EINVAL; } total_lines_x100 = mode->vtotal * mode->vrefresh; if (!total_lines_x100) { - dev_err(dev, "%s: vtotal(%d) or vrefresh(%d) is 0\n", + DRM_DEV_ERROR(dev, "%s: vtotal(%d) or vrefresh(%d) is 0\n", __func__, mode->vtotal, mode->vrefresh); return -EINVAL; } vsync_clk_speed = clk_round_rate(mdp5_kms->vsync_clk, VSYNC_CLK_RATE); if (vsync_clk_speed <= 0) { - dev_err(dev, "vsync_clk round rate failed %ld\n", + DRM_DEV_ERROR(dev, "vsync_clk round rate failed %ld\n", vsync_clk_speed); return -EINVAL; } @@ -102,13 +102,13 @@ static int pingpong_tearcheck_enable(struct drm_encoder *encoder) ret = clk_set_rate(mdp5_kms->vsync_clk, clk_round_rate(mdp5_kms->vsync_clk, VSYNC_CLK_RATE)); if (ret) { - dev_err(encoder->dev->dev, + DRM_DEV_ERROR(encoder->dev->dev, "vsync_clk clk_set_rate failed, %d\n", ret); return ret; } ret = clk_prepare_enable(mdp5_kms->vsync_clk); if (ret) { - dev_err(encoder->dev->dev, + DRM_DEV_ERROR(encoder->dev->dev, "vsync_clk clk_prepare_enable failed, %d\n", ret); return ret; } diff --git a/drivers/gpu/drm/msm/disp/mdp5/mdp5_crtc.c b/drivers/gpu/drm/msm/disp/mdp5/mdp5_crtc.c index b1da9ce..413b522 100644 --- a/drivers/gpu/drm/msm/disp/mdp5/mdp5_crtc.c +++ b/drivers/gpu/drm/msm/disp/mdp5/mdp5_crtc.c @@ -662,7 +662,7 @@ static int mdp5_crtc_atomic_check(struct drm_crtc *crtc, ret = mdp5_crtc_setup_pipeline(crtc, state, need_right_mixer); if (ret) { - dev_err(dev->dev, "couldn't assign mixers %d\n", ret); + DRM_DEV_ERROR(dev->dev, "couldn't assign mixers %d\n", ret); return ret; } @@ -679,7 +679,7 @@ static int mdp5_crtc_atomic_check(struct drm_crtc *crtc, * and that we don't have conflicting mixer stages: */ if ((cnt + start - 1) >= hw_cfg->lm.nb_stages) { - dev_err(dev->dev, "too many planes! cnt=%d, start stage=%d\n", + DRM_DEV_ERROR(dev->dev, "too many planes! cnt=%d, start stage=%d\n", cnt, start); return -EINVAL; } @@ -879,7 +879,7 @@ static int mdp5_crtc_cursor_set(struct drm_crtc *crtc, } if ((width > CURSOR_WIDTH) || (height > CURSOR_HEIGHT)) { - dev_err(dev->dev, "bad cursor size: %dx%d\n", width, height); + DRM_DEV_ERROR(dev->dev, "bad cursor size: %dx%d\n", width, height); return -EINVAL; } @@ -924,7 +924,7 @@ static int mdp5_crtc_cursor_set(struct drm_crtc *crtc, set_cursor: ret = mdp5_ctl_set_cursor(ctl, pipeline, 0, cursor_enable); if (ret) { - dev_err(dev->dev, "failed to %sable cursor: %d\n", + DRM_DEV_ERROR(dev->dev, "failed to %sable cursor: %d\n", cursor_enable ? "en" : "dis", ret); goto end; } diff --git a/drivers/gpu/drm/msm/disp/mdp5/mdp5_ctl.c b/drivers/gpu/drm/msm/disp/mdp5/mdp5_ctl.c index f93d568..65a871f 100644 --- a/drivers/gpu/drm/msm/disp/mdp5/mdp5_ctl.c +++ b/drivers/gpu/drm/msm/disp/mdp5/mdp5_ctl.c @@ -262,13 +262,13 @@ int mdp5_ctl_set_cursor(struct mdp5_ctl *ctl, struct mdp5_pipeline *pipeline, struct mdp5_hw_mixer *mixer = pipeline->mixer; if (unlikely(WARN_ON(!mixer))) { - dev_err(ctl_mgr->dev->dev, "CTL %d cannot find LM", + DRM_DEV_ERROR(ctl_mgr->dev->dev, "CTL %d cannot find LM", ctl->id); return -EINVAL; } if (pipeline->r_mixer) { - dev_err(ctl_mgr->dev->dev, "unsupported configuration"); + DRM_DEV_ERROR(ctl_mgr->dev->dev, "unsupported configuration"); return -EINVAL; } @@ -604,10 +604,10 @@ int mdp5_ctl_pair(struct mdp5_ctl *ctlx, struct mdp5_ctl *ctly, bool enable) mdp5_write(mdp5_kms, REG_MDP5_SPARE_0, 0); return 0; } else if ((ctlx->pair != NULL) || (ctly->pair != NULL)) { - dev_err(ctl_mgr->dev->dev, "CTLs already paired\n"); + DRM_DEV_ERROR(ctl_mgr->dev->dev, "CTLs already paired\n"); return -EINVAL; } else if (!(ctlx->status & ctly->status & CTL_STAT_BOOKED)) { - dev_err(ctl_mgr->dev->dev, "Only pair booked CTLs\n"); + DRM_DEV_ERROR(ctl_mgr->dev->dev, "Only pair booked CTLs\n"); return -EINVAL; } @@ -652,7 +652,7 @@ struct mdp5_ctl *mdp5_ctlm_request(struct mdp5_ctl_manager *ctl_mgr, if ((ctl_mgr->ctls[c].status & checkm) == match) goto found; - dev_err(ctl_mgr->dev->dev, "No more CTL available!"); + DRM_DEV_ERROR(ctl_mgr->dev->dev, "No more CTL available!"); goto unlock; found: @@ -698,13 +698,13 @@ struct mdp5_ctl_manager *mdp5_ctlm_init(struct drm_device *dev, ctl_mgr = kzalloc(sizeof(*ctl_mgr), GFP_KERNEL); if (!ctl_mgr) { - dev_err(dev->dev, "failed to allocate CTL manager\n"); + DRM_DEV_ERROR(dev->dev, "failed to allocate CTL manager\n"); ret = -ENOMEM; goto fail; } if (unlikely(WARN_ON(ctl_cfg->count > MAX_CTL))) { - dev_err(dev->dev, "Increase static pool size to at least %d\n", + DRM_DEV_ERROR(dev->dev, "Increase static pool size to at least %d\n", ctl_cfg->count); ret = -ENOSPC; goto fail; @@ -723,7 +723,7 @@ struct mdp5_ctl_manager *mdp5_ctlm_init(struct drm_device *dev, struct mdp5_ctl *ctl = &ctl_mgr->ctls[c]; if (WARN_ON(!ctl_cfg->base[c])) { - dev_err(dev->dev, "CTL_%d: base is null!\n", c); + DRM_DEV_ERROR(dev->dev, "CTL_%d: base is null!\n", c); ret = -EINVAL; spin_unlock_irqrestore(&ctl_mgr->pool_lock, flags); goto fail; diff --git a/drivers/gpu/drm/msm/disp/mdp5/mdp5_kms.c b/drivers/gpu/drm/msm/disp/mdp5/mdp5_kms.c index bddd625..d27e35a 100644 --- a/drivers/gpu/drm/msm/disp/mdp5/mdp5_kms.c +++ b/drivers/gpu/drm/msm/disp/mdp5/mdp5_kms.c @@ -264,7 +264,7 @@ static int mdp5_kms_debugfs_init(struct msm_kms *kms, struct drm_minor *minor) minor->debugfs_root, minor); if (ret) { - dev_err(dev->dev, "could not install mdp5_debugfs_list\n"); + DRM_DEV_ERROR(dev->dev, "could not install mdp5_debugfs_list\n"); return ret; } @@ -337,7 +337,7 @@ static struct drm_encoder *construct_encoder(struct mdp5_kms *mdp5_kms, encoder = mdp5_encoder_init(dev, intf, ctl); if (IS_ERR(encoder)) { - dev_err(dev->dev, "failed to construct encoder\n"); + DRM_DEV_ERROR(dev->dev, "failed to construct encoder\n"); return encoder; } @@ -418,7 +418,7 @@ static int modeset_init_intf(struct mdp5_kms *mdp5_kms, int dsi_id = get_dsi_id_from_intf(hw_cfg, intf->num); if ((dsi_id >= ARRAY_SIZE(priv->dsi)) || (dsi_id < 0)) { - dev_err(dev->dev, "failed to find dsi from intf %d\n", + DRM_DEV_ERROR(dev->dev, "failed to find dsi from intf %d\n", intf->num); ret = -EINVAL; break; @@ -443,7 +443,7 @@ static int modeset_init_intf(struct mdp5_kms *mdp5_kms, break; } default: - dev_err(dev->dev, "unknown intf: %d\n", intf->type); + DRM_DEV_ERROR(dev->dev, "unknown intf: %d\n", intf->type); ret = -EINVAL; break; } @@ -500,7 +500,7 @@ static int modeset_init(struct mdp5_kms *mdp5_kms) plane = mdp5_plane_init(dev, type); if (IS_ERR(plane)) { ret = PTR_ERR(plane); - dev_err(dev->dev, "failed to construct plane %d (%d)\n", i, ret); + DRM_DEV_ERROR(dev->dev, "failed to construct plane %d (%d)\n", i, ret); goto fail; } priv->planes[priv->num_planes++] = plane; @@ -517,7 +517,7 @@ static int modeset_init(struct mdp5_kms *mdp5_kms) crtc = mdp5_crtc_init(dev, primary[i], cursor[i], i); if (IS_ERR(crtc)) { ret = PTR_ERR(crtc); - dev_err(dev->dev, "failed to construct crtc %d (%d)\n", i, ret); + DRM_DEV_ERROR(dev->dev, "failed to construct crtc %d (%d)\n", i, ret); goto fail; } priv->crtcs[priv->num_crtcs++] = crtc; @@ -552,7 +552,7 @@ static void read_mdp_hw_revision(struct mdp5_kms *mdp5_kms, *major = FIELD(version, MDP5_HW_VERSION_MAJOR); *minor = FIELD(version, MDP5_HW_VERSION_MINOR); - dev_info(dev, "MDP5 version v%d.%d", *major, *minor); + DRM_DEV_INFO(dev, "MDP5 version v%d.%d", *major, *minor); } static int get_clk(struct platform_device *pdev, struct clk **clkp, @@ -561,7 +561,7 @@ static int get_clk(struct platform_device *pdev, struct clk **clkp, struct device *dev = &pdev->dev; struct clk *clk = msm_clk_get(pdev, name); if (IS_ERR(clk) && mandatory) { - dev_err(dev, "failed to get %s (%ld)\n", name, PTR_ERR(clk)); + DRM_DEV_ERROR(dev, "failed to get %s (%ld)\n", name, PTR_ERR(clk)); return PTR_ERR(clk); } if (IS_ERR(clk)) @@ -688,7 +688,7 @@ struct msm_kms *mdp5_kms_init(struct drm_device *dev) irq = irq_of_parse_and_map(pdev->dev.of_node, 0); if (irq < 0) { ret = irq; - dev_err(&pdev->dev, "failed to get irq: %d\n", ret); + DRM_DEV_ERROR(&pdev->dev, "failed to get irq: %d\n", ret); goto fail; } @@ -724,12 +724,12 @@ struct msm_kms *mdp5_kms_init(struct drm_device *dev) ret = aspace->mmu->funcs->attach(aspace->mmu, iommu_ports, ARRAY_SIZE(iommu_ports)); if (ret) { - dev_err(&pdev->dev, "failed to attach iommu: %d\n", + DRM_DEV_ERROR(&pdev->dev, "failed to attach iommu: %d\n", ret); goto fail; } } else { - dev_info(&pdev->dev, + DRM_DEV_INFO(&pdev->dev, "no iommu, fallback to phys contig buffers for scanout\n"); aspace = NULL; } @@ -738,7 +738,7 @@ struct msm_kms *mdp5_kms_init(struct drm_device *dev) ret = modeset_init(mdp5_kms); if (ret) { - dev_err(&pdev->dev, "modeset_init failed: %d\n", ret); + DRM_DEV_ERROR(&pdev->dev, "modeset_init failed: %d\n", ret); goto fail; } @@ -795,7 +795,7 @@ static int construct_pipes(struct mdp5_kms *mdp5_kms, int cnt, hwpipe = mdp5_pipe_init(pipes[i], offsets[i], caps); if (IS_ERR(hwpipe)) { ret = PTR_ERR(hwpipe); - dev_err(dev->dev, "failed to construct pipe for %s (%d)\n", + DRM_DEV_ERROR(dev->dev, "failed to construct pipe for %s (%d)\n", pipe2name(pipes[i]), ret); return ret; } @@ -867,7 +867,7 @@ static int hwmixer_init(struct mdp5_kms *mdp5_kms) mixer = mdp5_mixer_init(&hw_cfg->lm.instances[i]); if (IS_ERR(mixer)) { ret = PTR_ERR(mixer); - dev_err(dev->dev, "failed to construct LM%d (%d)\n", + DRM_DEV_ERROR(dev->dev, "failed to construct LM%d (%d)\n", i, ret); return ret; } @@ -897,7 +897,7 @@ static int interface_init(struct mdp5_kms *mdp5_kms) intf = kzalloc(sizeof(*intf), GFP_KERNEL); if (!intf) { - dev_err(dev->dev, "failed to construct INTF%d\n", i); + DRM_DEV_ERROR(dev->dev, "failed to construct INTF%d\n", i); return -ENOMEM; } diff --git a/drivers/gpu/drm/msm/disp/mdp5/mdp5_mdss.c b/drivers/gpu/drm/msm/disp/mdp5/mdp5_mdss.c index 1cc4e57..889c294 100644 --- a/drivers/gpu/drm/msm/disp/mdp5/mdp5_mdss.c +++ b/drivers/gpu/drm/msm/disp/mdp5/mdp5_mdss.c @@ -132,7 +132,7 @@ static int mdss_irq_domain_init(struct mdp5_mdss *mdp5_mdss) d = irq_domain_add_linear(dev->of_node, 32, &mdss_hw_irqdomain_ops, mdp5_mdss); if (!d) { - dev_err(dev, "mdss irq domain add failed\n"); + DRM_DEV_ERROR(dev, "mdss irq domain add failed\n"); return -ENXIO; } @@ -246,7 +246,7 @@ int mdp5_mdss_init(struct drm_device *dev) ret = msm_mdss_get_clocks(mdp5_mdss); if (ret) { - dev_err(dev->dev, "failed to get clocks: %d\n", ret); + DRM_DEV_ERROR(dev->dev, "failed to get clocks: %d\n", ret); goto fail; } @@ -259,7 +259,7 @@ int mdp5_mdss_init(struct drm_device *dev) ret = regulator_enable(mdp5_mdss->vdd); if (ret) { - dev_err(dev->dev, "failed to enable regulator vdd: %d\n", + DRM_DEV_ERROR(dev->dev, "failed to enable regulator vdd: %d\n", ret); goto fail; } @@ -267,13 +267,13 @@ int mdp5_mdss_init(struct drm_device *dev) ret = devm_request_irq(dev->dev, platform_get_irq(pdev, 0), mdss_irq, 0, "mdss_isr", mdp5_mdss); if (ret) { - dev_err(dev->dev, "failed to init irq: %d\n", ret); + DRM_DEV_ERROR(dev->dev, "failed to init irq: %d\n", ret); goto fail_irq; } ret = mdss_irq_domain_init(mdp5_mdss); if (ret) { - dev_err(dev->dev, "failed to init sub-block irqs: %d\n", ret); + DRM_DEV_ERROR(dev->dev, "failed to init sub-block irqs: %d\n", ret); goto fail_irq; } diff --git a/drivers/gpu/drm/msm/disp/mdp5/mdp5_plane.c b/drivers/gpu/drm/msm/disp/mdp5/mdp5_plane.c index 1d4bce1..f511158 100644 --- a/drivers/gpu/drm/msm/disp/mdp5/mdp5_plane.c +++ b/drivers/gpu/drm/msm/disp/mdp5/mdp5_plane.c @@ -125,7 +125,7 @@ static int mdp5_plane_atomic_set_property(struct drm_plane *plane, SET_PROPERTY(zpos, ZPOS, uint8_t); - dev_err(dev->dev, "Invalid property\n"); + DRM_DEV_ERROR(dev->dev, "Invalid property\n"); ret = -EINVAL; done: return ret; @@ -153,7 +153,7 @@ static int mdp5_plane_atomic_get_property(struct drm_plane *plane, GET_PROPERTY(zpos, ZPOS, uint8_t); - dev_err(dev->dev, "Invalid property\n"); + DRM_DEV_ERROR(dev->dev, "Invalid property\n"); ret = -EINVAL; done: return ret; @@ -659,7 +659,7 @@ static int calc_scalex_steps(struct drm_plane *plane, ret = calc_phase_step(src, dest, &phasex_step); if (ret) { - dev_err(dev, "X scaling (%d->%d) failed: %d\n", src, dest, ret); + DRM_DEV_ERROR(dev, "X scaling (%d->%d) failed: %d\n", src, dest, ret); return ret; } @@ -684,7 +684,7 @@ static int calc_scaley_steps(struct drm_plane *plane, ret = calc_phase_step(src, dest, &phasey_step); if (ret) { - dev_err(dev, "Y scaling (%d->%d) failed: %d\n", src, dest, ret); + DRM_DEV_ERROR(dev, "Y scaling (%d->%d) failed: %d\n", src, dest, ret); return ret; } diff --git a/drivers/gpu/drm/msm/disp/mdp5/mdp5_smp.c b/drivers/gpu/drm/msm/disp/mdp5/mdp5_smp.c index 96c2b82..7cebcb2 100644 --- a/drivers/gpu/drm/msm/disp/mdp5/mdp5_smp.c +++ b/drivers/gpu/drm/msm/disp/mdp5/mdp5_smp.c @@ -88,7 +88,7 @@ static int smp_request_block(struct mdp5_smp *smp, avail = cnt - bitmap_weight(state->state, cnt); if (nblks > avail) { - dev_err(smp->dev->dev, "out of blks (req=%d > avail=%d)\n", + DRM_DEV_ERROR(smp->dev->dev, "out of blks (req=%d > avail=%d)\n", nblks, avail); return -ENOSPC; } @@ -188,7 +188,7 @@ int mdp5_smp_assign(struct mdp5_smp *smp, struct mdp5_smp_state *state, DBG("%s[%d]: request %d SMP blocks", pipe2name(pipe), i, n); ret = smp_request_block(smp, state, cid, n); if (ret) { - dev_err(dev->dev, "Cannot allocate %d SMP blocks: %d\n", + DRM_DEV_ERROR(dev->dev, "Cannot allocate %d SMP blocks: %d\n", n, ret); return ret; } diff --git a/drivers/gpu/drm/msm/dsi/dsi.c b/drivers/gpu/drm/msm/dsi/dsi.c index ff8164c..43c09f7 100644 --- a/drivers/gpu/drm/msm/dsi/dsi.c +++ b/drivers/gpu/drm/msm/dsi/dsi.c @@ -29,7 +29,7 @@ static int dsi_get_phy(struct msm_dsi *msm_dsi) phy_node = of_parse_phandle(pdev->dev.of_node, "phys", 0); if (!phy_node) { - dev_err(&pdev->dev, "cannot find phy device\n"); + DRM_DEV_ERROR(&pdev->dev, "cannot find phy device\n"); return -ENXIO; } @@ -40,7 +40,7 @@ static int dsi_get_phy(struct msm_dsi *msm_dsi) of_node_put(phy_node); if (!phy_pdev || !msm_dsi->phy) { - dev_err(&pdev->dev, "%s: phy driver is not ready\n", __func__); + DRM_DEV_ERROR(&pdev->dev, "%s: phy driver is not ready\n", __func__); return -EPROBE_DEFER; } @@ -204,7 +204,7 @@ int msm_dsi_modeset_init(struct msm_dsi *msm_dsi, struct drm_device *dev, ret = msm_dsi_host_modeset_init(msm_dsi->host, dev); if (ret) { - dev_err(dev->dev, "failed to modeset init host: %d\n", ret); + DRM_DEV_ERROR(dev->dev, "failed to modeset init host: %d\n", ret); goto fail; } @@ -216,7 +216,7 @@ int msm_dsi_modeset_init(struct msm_dsi *msm_dsi, struct drm_device *dev, msm_dsi->bridge = msm_dsi_manager_bridge_init(msm_dsi->id); if (IS_ERR(msm_dsi->bridge)) { ret = PTR_ERR(msm_dsi->bridge); - dev_err(dev->dev, "failed to create dsi bridge: %d\n", ret); + DRM_DEV_ERROR(dev->dev, "failed to create dsi bridge: %d\n", ret); msm_dsi->bridge = NULL; goto fail; } @@ -238,7 +238,7 @@ int msm_dsi_modeset_init(struct msm_dsi *msm_dsi, struct drm_device *dev, if (IS_ERR(msm_dsi->connector)) { ret = PTR_ERR(msm_dsi->connector); - dev_err(dev->dev, + DRM_DEV_ERROR(dev->dev, "failed to create dsi connector: %d\n", ret); msm_dsi->connector = NULL; goto fail; diff --git a/drivers/gpu/drm/msm/dsi/dsi_host.c b/drivers/gpu/drm/msm/dsi/dsi_host.c index 96fb5f6..076ea9a 100644 --- a/drivers/gpu/drm/msm/dsi/dsi_host.c +++ b/drivers/gpu/drm/msm/dsi/dsi_host.c @@ -1050,7 +1050,7 @@ static void dsi_wait4video_done(struct msm_dsi_host *msm_host) msecs_to_jiffies(70)); if (ret <= 0) - dev_err(dev, "wait for video done timed out\n"); + DRM_DEV_ERROR(dev, "wait for video done timed out\n"); dsi_intr_ctrl(msm_host, DSI_IRQ_MASK_VIDEO_DONE, 0); } @@ -1673,7 +1673,7 @@ static int dsi_host_parse_lane_data(struct msm_dsi_host *msm_host, prop = of_find_property(ep, "data-lanes", &len); if (!prop) { - dev_dbg(dev, + DRM_DEV_DEBUG(dev, "failed to find data lane mapping, using default\n"); return 0; } @@ -1681,7 +1681,7 @@ static int dsi_host_parse_lane_data(struct msm_dsi_host *msm_host, num_lanes = len / sizeof(u32); if (num_lanes < 1 || num_lanes > 4) { - dev_err(dev, "bad number of data lanes\n"); + DRM_DEV_ERROR(dev, "bad number of data lanes\n"); return -EINVAL; } @@ -1690,7 +1690,7 @@ static int dsi_host_parse_lane_data(struct msm_dsi_host *msm_host, ret = of_property_read_u32_array(ep, "data-lanes", lane_map, num_lanes); if (ret) { - dev_err(dev, "failed to read lane data\n"); + DRM_DEV_ERROR(dev, "failed to read lane data\n"); return ret; } @@ -1711,7 +1711,7 @@ static int dsi_host_parse_lane_data(struct msm_dsi_host *msm_host, */ for (j = 0; j < num_lanes; j++) { if (lane_map[j] < 0 || lane_map[j] > 3) - dev_err(dev, "bad physical lane entry %u\n", + DRM_DEV_ERROR(dev, "bad physical lane entry %u\n", lane_map[j]); if (swap[lane_map[j]] != j) @@ -1742,13 +1742,13 @@ static int dsi_host_parse_dt(struct msm_dsi_host *msm_host) */ endpoint = of_graph_get_endpoint_by_regs(np, 1, -1); if (!endpoint) { - dev_dbg(dev, "%s: no endpoint\n", __func__); + DRM_DEV_DEBUG(dev, "%s: no endpoint\n", __func__); return 0; } ret = dsi_host_parse_lane_data(msm_host, endpoint); if (ret) { - dev_err(dev, "%s: invalid lane configuration %d\n", + DRM_DEV_ERROR(dev, "%s: invalid lane configuration %d\n", __func__, ret); goto err; } @@ -1756,7 +1756,7 @@ static int dsi_host_parse_dt(struct msm_dsi_host *msm_host) /* Get panel node from the output port's endpoint data */ device_node = of_graph_get_remote_node(np, 1, 0); if (!device_node) { - dev_dbg(dev, "%s: no valid device\n", __func__); + DRM_DEV_DEBUG(dev, "%s: no valid device\n", __func__); goto err; } @@ -1766,7 +1766,7 @@ static int dsi_host_parse_dt(struct msm_dsi_host *msm_host) msm_host->sfpb = syscon_regmap_lookup_by_phandle(np, "syscon-sfpb"); if (IS_ERR(msm_host->sfpb)) { - dev_err(dev, "%s: failed to get sfpb regmap\n", + DRM_DEV_ERROR(dev, "%s: failed to get sfpb regmap\n", __func__); ret = PTR_ERR(msm_host->sfpb); } @@ -1916,7 +1916,7 @@ int msm_dsi_host_modeset_init(struct mipi_dsi_host *host, msm_host->irq = irq_of_parse_and_map(pdev->dev.of_node, 0); if (msm_host->irq < 0) { ret = msm_host->irq; - dev_err(dev->dev, "failed to get irq: %d\n", ret); + DRM_DEV_ERROR(dev->dev, "failed to get irq: %d\n", ret); return ret; } @@ -1924,7 +1924,7 @@ int msm_dsi_host_modeset_init(struct mipi_dsi_host *host, dsi_host_irq, IRQF_TRIGGER_HIGH | IRQF_ONESHOT, "dsi_isr", msm_host); if (ret < 0) { - dev_err(&pdev->dev, "failed to request IRQ%u: %d\n", + DRM_DEV_ERROR(&pdev->dev, "failed to request IRQ%u: %d\n", msm_host->irq, ret); return ret; } diff --git a/drivers/gpu/drm/msm/dsi/phy/dsi_phy.c b/drivers/gpu/drm/msm/dsi/phy/dsi_phy.c index 9a9fa0c..1760483 100644 --- a/drivers/gpu/drm/msm/dsi/phy/dsi_phy.c +++ b/drivers/gpu/drm/msm/dsi/phy/dsi_phy.c @@ -404,7 +404,7 @@ static int dsi_phy_regulator_init(struct msm_dsi_phy *phy) ret = devm_regulator_bulk_get(dev, num, s); if (ret < 0) { - dev_err(dev, "%s: failed to init regulator, ret=%d\n", + DRM_DEV_ERROR(dev, "%s: failed to init regulator, ret=%d\n", __func__, ret); return ret; } @@ -441,7 +441,7 @@ static int dsi_phy_regulator_enable(struct msm_dsi_phy *phy) ret = regulator_set_load(s[i].consumer, regs[i].enable_load); if (ret < 0) { - dev_err(dev, + DRM_DEV_ERROR(dev, "regulator %d set op mode failed, %d\n", i, ret); goto fail; @@ -451,7 +451,7 @@ static int dsi_phy_regulator_enable(struct msm_dsi_phy *phy) ret = regulator_bulk_enable(num, s); if (ret < 0) { - dev_err(dev, "regulator enable failed, %d\n", ret); + DRM_DEV_ERROR(dev, "regulator enable failed, %d\n", ret); goto fail; } @@ -472,7 +472,7 @@ static int dsi_phy_enable_resource(struct msm_dsi_phy *phy) ret = clk_prepare_enable(phy->ahb_clk); if (ret) { - dev_err(dev, "%s: can't enable ahb clk, %d\n", __func__, ret); + DRM_DEV_ERROR(dev, "%s: can't enable ahb clk, %d\n", __func__, ret); pm_runtime_put_sync(dev); } @@ -543,7 +543,7 @@ int msm_dsi_phy_init_common(struct msm_dsi_phy *phy) phy->reg_base = msm_ioremap(pdev, "dsi_phy_regulator", "DSI_PHY_REG"); if (IS_ERR(phy->reg_base)) { - dev_err(&pdev->dev, "%s: failed to map phy regulator base\n", + DRM_DEV_ERROR(&pdev->dev, "%s: failed to map phy regulator base\n", __func__); ret = -ENOMEM; goto fail; @@ -574,7 +574,7 @@ static int dsi_phy_driver_probe(struct platform_device *pdev) phy->id = dsi_phy_get_id(phy); if (phy->id < 0) { ret = phy->id; - dev_err(dev, "%s: couldn't identify PHY index, %d\n", + DRM_DEV_ERROR(dev, "%s: couldn't identify PHY index, %d\n", __func__, ret); goto fail; } @@ -584,20 +584,20 @@ static int dsi_phy_driver_probe(struct platform_device *pdev) phy->base = msm_ioremap(pdev, "dsi_phy", "DSI_PHY"); if (IS_ERR(phy->base)) { - dev_err(dev, "%s: failed to map phy base\n", __func__); + DRM_DEV_ERROR(dev, "%s: failed to map phy base\n", __func__); ret = -ENOMEM; goto fail; } ret = dsi_phy_regulator_init(phy); if (ret) { - dev_err(dev, "%s: failed to init regulator\n", __func__); + DRM_DEV_ERROR(dev, "%s: failed to init regulator\n", __func__); goto fail; } phy->ahb_clk = msm_clk_get(pdev, "iface"); if (IS_ERR(phy->ahb_clk)) { - dev_err(dev, "%s: Unable to get ahb clk\n", __func__); + DRM_DEV_ERROR(dev, "%s: Unable to get ahb clk\n", __func__); ret = PTR_ERR(phy->ahb_clk); goto fail; } @@ -617,7 +617,7 @@ static int dsi_phy_driver_probe(struct platform_device *pdev) phy->pll = msm_dsi_pll_init(pdev, phy->cfg->type, phy->id); if (IS_ERR_OR_NULL(phy->pll)) - dev_info(dev, + DRM_DEV_INFO(dev, "%s: pll init failed: %ld, need separate pll clk driver\n", __func__, PTR_ERR(phy->pll)); @@ -675,21 +675,21 @@ int msm_dsi_phy_enable(struct msm_dsi_phy *phy, int src_pll_id, ret = dsi_phy_enable_resource(phy); if (ret) { - dev_err(dev, "%s: resource enable failed, %d\n", + DRM_DEV_ERROR(dev, "%s: resource enable failed, %d\n", __func__, ret); goto res_en_fail; } ret = dsi_phy_regulator_enable(phy); if (ret) { - dev_err(dev, "%s: regulator enable failed, %d\n", + DRM_DEV_ERROR(dev, "%s: regulator enable failed, %d\n", __func__, ret); goto reg_en_fail; } ret = phy->cfg->ops.enable(phy, src_pll_id, clk_req); if (ret) { - dev_err(dev, "%s: phy enable failed, %d\n", __func__, ret); + DRM_DEV_ERROR(dev, "%s: phy enable failed, %d\n", __func__, ret); goto phy_en_fail; } @@ -702,7 +702,7 @@ int msm_dsi_phy_enable(struct msm_dsi_phy *phy, int src_pll_id, if (phy->usecase != MSM_DSI_PHY_SLAVE) { ret = msm_dsi_pll_restore_state(phy->pll); if (ret) { - dev_err(dev, "%s: failed to restore pll state, %d\n", + DRM_DEV_ERROR(dev, "%s: failed to restore pll state, %d\n", __func__, ret); goto pll_restor_fail; } diff --git a/drivers/gpu/drm/msm/dsi/phy/dsi_phy_10nm.c b/drivers/gpu/drm/msm/dsi/phy/dsi_phy_10nm.c index b3fffc8..44959e79 100644 --- a/drivers/gpu/drm/msm/dsi/phy/dsi_phy_10nm.c +++ b/drivers/gpu/drm/msm/dsi/phy/dsi_phy_10nm.c @@ -93,7 +93,7 @@ static int dsi_10nm_phy_enable(struct msm_dsi_phy *phy, int src_pll_id, DBG(""); if (msm_dsi_dphy_timing_calc_v3(timing, clk_req)) { - dev_err(&phy->pdev->dev, + DRM_DEV_ERROR(&phy->pdev->dev, "%s: D-PHY timing calculation failed\n", __func__); return -EINVAL; } @@ -172,7 +172,7 @@ static int dsi_10nm_phy_enable(struct msm_dsi_phy *phy, int src_pll_id, ret = msm_dsi_pll_set_usecase(phy->pll, phy->usecase); if (ret) { - dev_err(&phy->pdev->dev, "%s: set pll usecase failed, %d\n", + DRM_DEV_ERROR(&phy->pdev->dev, "%s: set pll usecase failed, %d\n", __func__, ret); return ret; } @@ -196,7 +196,7 @@ static int dsi_10nm_phy_init(struct msm_dsi_phy *phy) phy->lane_base = msm_ioremap(pdev, "dsi_phy_lane", "DSI_PHY_LANE"); if (IS_ERR(phy->lane_base)) { - dev_err(&pdev->dev, "%s: failed to map phy lane base\n", + DRM_DEV_ERROR(&pdev->dev, "%s: failed to map phy lane base\n", __func__); return -ENOMEM; } diff --git a/drivers/gpu/drm/msm/dsi/phy/dsi_phy_14nm.c b/drivers/gpu/drm/msm/dsi/phy/dsi_phy_14nm.c index 513f423..a172c66 100644 --- a/drivers/gpu/drm/msm/dsi/phy/dsi_phy_14nm.c +++ b/drivers/gpu/drm/msm/dsi/phy/dsi_phy_14nm.c @@ -64,7 +64,7 @@ static int dsi_14nm_phy_enable(struct msm_dsi_phy *phy, int src_pll_id, void __iomem *lane_base = phy->lane_base; if (msm_dsi_dphy_timing_calc_v2(timing, clk_req)) { - dev_err(&phy->pdev->dev, + DRM_DEV_ERROR(&phy->pdev->dev, "%s: D-PHY timing calculation failed\n", __func__); return -EINVAL; } @@ -115,7 +115,7 @@ static int dsi_14nm_phy_enable(struct msm_dsi_phy *phy, int src_pll_id, ret = msm_dsi_pll_set_usecase(phy->pll, phy->usecase); if (ret) { - dev_err(&phy->pdev->dev, "%s: set pll usecase failed, %d\n", + DRM_DEV_ERROR(&phy->pdev->dev, "%s: set pll usecase failed, %d\n", __func__, ret); return ret; } @@ -142,7 +142,7 @@ static int dsi_14nm_phy_init(struct msm_dsi_phy *phy) phy->lane_base = msm_ioremap(pdev, "dsi_phy_lane", "DSI_PHY_LANE"); if (IS_ERR(phy->lane_base)) { - dev_err(&pdev->dev, "%s: failed to map phy lane base\n", + DRM_DEV_ERROR(&pdev->dev, "%s: failed to map phy lane base\n", __func__); return -ENOMEM; } diff --git a/drivers/gpu/drm/msm/dsi/phy/dsi_phy_20nm.c b/drivers/gpu/drm/msm/dsi/phy/dsi_phy_20nm.c index 1ca6c69..9ea9478 100644 --- a/drivers/gpu/drm/msm/dsi/phy/dsi_phy_20nm.c +++ b/drivers/gpu/drm/msm/dsi/phy/dsi_phy_20nm.c @@ -82,7 +82,7 @@ static int dsi_20nm_phy_enable(struct msm_dsi_phy *phy, int src_pll_id, DBG(""); if (msm_dsi_dphy_timing_calc(timing, clk_req)) { - dev_err(&phy->pdev->dev, + DRM_DEV_ERROR(&phy->pdev->dev, "%s: D-PHY timing calculation failed\n", __func__); return -EINVAL; } diff --git a/drivers/gpu/drm/msm/dsi/phy/dsi_phy_28nm.c b/drivers/gpu/drm/msm/dsi/phy/dsi_phy_28nm.c index 4972b52..c79505d 100644 --- a/drivers/gpu/drm/msm/dsi/phy/dsi_phy_28nm.c +++ b/drivers/gpu/drm/msm/dsi/phy/dsi_phy_28nm.c @@ -76,7 +76,7 @@ static int dsi_28nm_phy_enable(struct msm_dsi_phy *phy, int src_pll_id, DBG(""); if (msm_dsi_dphy_timing_calc(timing, clk_req)) { - dev_err(&phy->pdev->dev, + DRM_DEV_ERROR(&phy->pdev->dev, "%s: D-PHY timing calculation failed\n", __func__); return -EINVAL; } diff --git a/drivers/gpu/drm/msm/dsi/phy/dsi_phy_28nm_8960.c b/drivers/gpu/drm/msm/dsi/phy/dsi_phy_28nm_8960.c index 3980044..98790b4 100644 --- a/drivers/gpu/drm/msm/dsi/phy/dsi_phy_28nm_8960.c +++ b/drivers/gpu/drm/msm/dsi/phy/dsi_phy_28nm_8960.c @@ -132,7 +132,7 @@ static int dsi_28nm_phy_enable(struct msm_dsi_phy *phy, int src_pll_id, DBG(""); if (msm_dsi_dphy_timing_calc(timing, clk_req)) { - dev_err(&phy->pdev->dev, + DRM_DEV_ERROR(&phy->pdev->dev, "%s: D-PHY timing calculation failed\n", __func__); return -EINVAL; } diff --git a/drivers/gpu/drm/msm/dsi/pll/dsi_pll.c b/drivers/gpu/drm/msm/dsi/pll/dsi_pll.c index 613e206..7a1fb4d 100644 --- a/drivers/gpu/drm/msm/dsi/pll/dsi_pll.c +++ b/drivers/gpu/drm/msm/dsi/pll/dsi_pll.c @@ -175,7 +175,7 @@ struct msm_dsi_pll *msm_dsi_pll_init(struct platform_device *pdev, } if (IS_ERR(pll)) { - dev_err(dev, "%s: failed to init DSI PLL\n", __func__); + DRM_DEV_ERROR(dev, "%s: failed to init DSI PLL\n", __func__); return pll; } diff --git a/drivers/gpu/drm/msm/dsi/pll/dsi_pll_10nm.c b/drivers/gpu/drm/msm/dsi/pll/dsi_pll_10nm.c index 4c03f0b..f8819cc 100644 --- a/drivers/gpu/drm/msm/dsi/pll/dsi_pll_10nm.c +++ b/drivers/gpu/drm/msm/dsi/pll/dsi_pll_10nm.c @@ -760,7 +760,7 @@ static int pll_10nm_register(struct dsi_pll_10nm *pll_10nm) ret = of_clk_add_hw_provider(dev->of_node, of_clk_hw_onecell_get, pll_10nm->hw_data); if (ret) { - dev_err(dev, "failed to register clk provider: %d\n", ret); + DRM_DEV_ERROR(dev, "failed to register clk provider: %d\n", ret); return ret; } @@ -788,13 +788,13 @@ struct msm_dsi_pll *msm_dsi_pll_10nm_init(struct platform_device *pdev, int id) pll_10nm->phy_cmn_mmio = msm_ioremap(pdev, "dsi_phy", "DSI_PHY"); if (IS_ERR_OR_NULL(pll_10nm->phy_cmn_mmio)) { - dev_err(&pdev->dev, "failed to map CMN PHY base\n"); + DRM_DEV_ERROR(&pdev->dev, "failed to map CMN PHY base\n"); return ERR_PTR(-ENOMEM); } pll_10nm->mmio = msm_ioremap(pdev, "dsi_pll", "DSI_PLL"); if (IS_ERR_OR_NULL(pll_10nm->mmio)) { - dev_err(&pdev->dev, "failed to map PLL base\n"); + DRM_DEV_ERROR(&pdev->dev, "failed to map PLL base\n"); return ERR_PTR(-ENOMEM); } @@ -813,7 +813,7 @@ struct msm_dsi_pll *msm_dsi_pll_10nm_init(struct platform_device *pdev, int id) ret = pll_10nm_register(pll_10nm); if (ret) { - dev_err(&pdev->dev, "failed to register PLL: %d\n", ret); + DRM_DEV_ERROR(&pdev->dev, "failed to register PLL: %d\n", ret); return ERR_PTR(ret); } diff --git a/drivers/gpu/drm/msm/dsi/pll/dsi_pll_14nm.c b/drivers/gpu/drm/msm/dsi/pll/dsi_pll_14nm.c index 71fe60e..0e18cdd 100644 --- a/drivers/gpu/drm/msm/dsi/pll/dsi_pll_14nm.c +++ b/drivers/gpu/drm/msm/dsi/pll/dsi_pll_14nm.c @@ -783,7 +783,7 @@ static int dsi_pll_14nm_enable_seq(struct msm_dsi_pll *pll) POLL_TIMEOUT_US); if (unlikely(!locked)) - dev_err(&pll_14nm->pdev->dev, "DSI PLL lock failed\n"); + DRM_DEV_ERROR(&pll_14nm->pdev->dev, "DSI PLL lock failed\n"); else DBG("DSI PLL lock success"); @@ -829,7 +829,7 @@ static int dsi_pll_14nm_restore_state(struct msm_dsi_pll *pll) ret = dsi_pll_14nm_vco_set_rate(&pll->clk_hw, cached_state->vco_rate, 0); if (ret) { - dev_err(&pll_14nm->pdev->dev, + DRM_DEV_ERROR(&pll_14nm->pdev->dev, "restore vco rate failed. ret=%d\n", ret); return ret; } @@ -1039,7 +1039,7 @@ static int pll_14nm_register(struct dsi_pll_14nm *pll_14nm) ret = of_clk_add_hw_provider(dev->of_node, of_clk_hw_onecell_get, pll_14nm->hw_data); if (ret) { - dev_err(dev, "failed to register clk provider: %d\n", ret); + DRM_DEV_ERROR(dev, "failed to register clk provider: %d\n", ret); return ret; } @@ -1067,13 +1067,13 @@ struct msm_dsi_pll *msm_dsi_pll_14nm_init(struct platform_device *pdev, int id) pll_14nm->phy_cmn_mmio = msm_ioremap(pdev, "dsi_phy", "DSI_PHY"); if (IS_ERR_OR_NULL(pll_14nm->phy_cmn_mmio)) { - dev_err(&pdev->dev, "failed to map CMN PHY base\n"); + DRM_DEV_ERROR(&pdev->dev, "failed to map CMN PHY base\n"); return ERR_PTR(-ENOMEM); } pll_14nm->mmio = msm_ioremap(pdev, "dsi_pll", "DSI_PLL"); if (IS_ERR_OR_NULL(pll_14nm->mmio)) { - dev_err(&pdev->dev, "failed to map PLL base\n"); + DRM_DEV_ERROR(&pdev->dev, "failed to map PLL base\n"); return ERR_PTR(-ENOMEM); } @@ -1096,7 +1096,7 @@ struct msm_dsi_pll *msm_dsi_pll_14nm_init(struct platform_device *pdev, int id) ret = pll_14nm_register(pll_14nm); if (ret) { - dev_err(&pdev->dev, "failed to register PLL: %d\n", ret); + DRM_DEV_ERROR(&pdev->dev, "failed to register PLL: %d\n", ret); return ERR_PTR(ret); } diff --git a/drivers/gpu/drm/msm/dsi/pll/dsi_pll_28nm.c b/drivers/gpu/drm/msm/dsi/pll/dsi_pll_28nm.c index 26e3a01..dcbbaeb 100644 --- a/drivers/gpu/drm/msm/dsi/pll/dsi_pll_28nm.c +++ b/drivers/gpu/drm/msm/dsi/pll/dsi_pll_28nm.c @@ -156,7 +156,7 @@ static int dsi_pll_28nm_clk_set_rate(struct clk_hw *hw, unsigned long rate, if (rate <= lpfr_lut[i].vco_rate) break; if (i == LPFR_LUT_SIZE) { - dev_err(dev, "unable to get loop filter resistance. vco=%lu\n", + DRM_DEV_ERROR(dev, "unable to get loop filter resistance. vco=%lu\n", rate); return -EINVAL; } @@ -386,7 +386,7 @@ static int dsi_pll_28nm_enable_seq_hpm(struct msm_dsi_pll *pll) } if (unlikely(!locked)) - dev_err(dev, "DSI PLL lock failed\n"); + DRM_DEV_ERROR(dev, "DSI PLL lock failed\n"); else DBG("DSI PLL Lock success"); @@ -429,7 +429,7 @@ static int dsi_pll_28nm_enable_seq_lp(struct msm_dsi_pll *pll) locked = pll_28nm_poll_for_ready(pll_28nm, max_reads, timeout_us); if (unlikely(!locked)) - dev_err(dev, "DSI PLL lock failed\n"); + DRM_DEV_ERROR(dev, "DSI PLL lock failed\n"); else DBG("DSI PLL lock success"); @@ -468,7 +468,7 @@ static int dsi_pll_28nm_restore_state(struct msm_dsi_pll *pll) ret = dsi_pll_28nm_clk_set_rate(&pll->clk_hw, cached_state->vco_rate, 0); if (ret) { - dev_err(&pll_28nm->pdev->dev, + DRM_DEV_ERROR(&pll_28nm->pdev->dev, "restore vco rate failed. ret=%d\n", ret); return ret; } @@ -581,7 +581,7 @@ static int pll_28nm_register(struct dsi_pll_28nm *pll_28nm) ret = of_clk_add_provider(dev->of_node, of_clk_src_onecell_get, &pll_28nm->clk_data); if (ret) { - dev_err(dev, "failed to register clk provider: %d\n", ret); + DRM_DEV_ERROR(dev, "failed to register clk provider: %d\n", ret); return ret; } @@ -607,7 +607,7 @@ struct msm_dsi_pll *msm_dsi_pll_28nm_init(struct platform_device *pdev, pll_28nm->mmio = msm_ioremap(pdev, "dsi_pll", "DSI_PLL"); if (IS_ERR_OR_NULL(pll_28nm->mmio)) { - dev_err(&pdev->dev, "%s: failed to map pll base\n", __func__); + DRM_DEV_ERROR(&pdev->dev, "%s: failed to map pll base\n", __func__); return ERR_PTR(-ENOMEM); } @@ -633,13 +633,13 @@ struct msm_dsi_pll *msm_dsi_pll_28nm_init(struct platform_device *pdev, pll->en_seq_cnt = 1; pll->enable_seqs[0] = dsi_pll_28nm_enable_seq_lp; } else { - dev_err(&pdev->dev, "phy type (%d) is not 28nm\n", type); + DRM_DEV_ERROR(&pdev->dev, "phy type (%d) is not 28nm\n", type); return ERR_PTR(-EINVAL); } ret = pll_28nm_register(pll_28nm); if (ret) { - dev_err(&pdev->dev, "failed to register PLL: %d\n", ret); + DRM_DEV_ERROR(&pdev->dev, "failed to register PLL: %d\n", ret); return ERR_PTR(ret); } diff --git a/drivers/gpu/drm/msm/dsi/pll/dsi_pll_28nm_8960.c b/drivers/gpu/drm/msm/dsi/pll/dsi_pll_28nm_8960.c index 4900845..d689746 100644 --- a/drivers/gpu/drm/msm/dsi/pll/dsi_pll_28nm_8960.c +++ b/drivers/gpu/drm/msm/dsi/pll/dsi_pll_28nm_8960.c @@ -327,7 +327,7 @@ static int dsi_pll_28nm_enable_seq(struct msm_dsi_pll *pll) locked = pll_28nm_poll_for_ready(pll_28nm, max_reads, timeout_us); if (unlikely(!locked)) - dev_err(dev, "DSI PLL lock failed\n"); + DRM_DEV_ERROR(dev, "DSI PLL lock failed\n"); else DBG("DSI PLL lock success"); @@ -368,7 +368,7 @@ static int dsi_pll_28nm_restore_state(struct msm_dsi_pll *pll) ret = dsi_pll_28nm_clk_set_rate(&pll->clk_hw, cached_state->vco_rate, 0); if (ret) { - dev_err(&pll_28nm->pdev->dev, + DRM_DEV_ERROR(&pll_28nm->pdev->dev, "restore vco rate failed. ret=%d\n", ret); return ret; } @@ -482,7 +482,7 @@ static int pll_28nm_register(struct dsi_pll_28nm *pll_28nm) ret = of_clk_add_provider(dev->of_node, of_clk_src_onecell_get, &pll_28nm->clk_data); if (ret) { - dev_err(dev, "failed to register clk provider: %d\n", ret); + DRM_DEV_ERROR(dev, "failed to register clk provider: %d\n", ret); return ret; } @@ -508,7 +508,7 @@ struct msm_dsi_pll *msm_dsi_pll_28nm_8960_init(struct platform_device *pdev, pll_28nm->mmio = msm_ioremap(pdev, "dsi_pll", "DSI_PLL"); if (IS_ERR_OR_NULL(pll_28nm->mmio)) { - dev_err(&pdev->dev, "%s: failed to map pll base\n", __func__); + DRM_DEV_ERROR(&pdev->dev, "%s: failed to map pll base\n", __func__); return ERR_PTR(-ENOMEM); } @@ -526,7 +526,7 @@ struct msm_dsi_pll *msm_dsi_pll_28nm_8960_init(struct platform_device *pdev, ret = pll_28nm_register(pll_28nm); if (ret) { - dev_err(&pdev->dev, "failed to register PLL: %d\n", ret); + DRM_DEV_ERROR(&pdev->dev, "failed to register PLL: %d\n", ret); return ERR_PTR(ret); } diff --git a/drivers/gpu/drm/msm/edp/edp.c b/drivers/gpu/drm/msm/edp/edp.c index 0940e84..6a63aba 100644 --- a/drivers/gpu/drm/msm/edp/edp.c +++ b/drivers/gpu/drm/msm/edp/edp.c @@ -157,7 +157,7 @@ int msm_edp_modeset_init(struct msm_edp *edp, struct drm_device *dev, edp->bridge = msm_edp_bridge_init(edp); if (IS_ERR(edp->bridge)) { ret = PTR_ERR(edp->bridge); - dev_err(dev->dev, "failed to create eDP bridge: %d\n", ret); + DRM_DEV_ERROR(dev->dev, "failed to create eDP bridge: %d\n", ret); edp->bridge = NULL; goto fail; } @@ -165,7 +165,7 @@ int msm_edp_modeset_init(struct msm_edp *edp, struct drm_device *dev, edp->connector = msm_edp_connector_init(edp); if (IS_ERR(edp->connector)) { ret = PTR_ERR(edp->connector); - dev_err(dev->dev, "failed to create eDP connector: %d\n", ret); + DRM_DEV_ERROR(dev->dev, "failed to create eDP connector: %d\n", ret); edp->connector = NULL; goto fail; } @@ -173,7 +173,7 @@ int msm_edp_modeset_init(struct msm_edp *edp, struct drm_device *dev, edp->irq = irq_of_parse_and_map(pdev->dev.of_node, 0); if (edp->irq < 0) { ret = edp->irq; - dev_err(dev->dev, "failed to get IRQ: %d\n", ret); + DRM_DEV_ERROR(dev->dev, "failed to get IRQ: %d\n", ret); goto fail; } @@ -181,7 +181,7 @@ int msm_edp_modeset_init(struct msm_edp *edp, struct drm_device *dev, edp_irq, IRQF_TRIGGER_HIGH | IRQF_ONESHOT, "edp_isr", edp); if (ret < 0) { - dev_err(dev->dev, "failed to request IRQ%u: %d\n", + DRM_DEV_ERROR(dev->dev, "failed to request IRQ%u: %d\n", edp->irq, ret); goto fail; } diff --git a/drivers/gpu/drm/msm/hdmi/hdmi.c b/drivers/gpu/drm/msm/hdmi/hdmi.c index 2367090..f072576 100644 --- a/drivers/gpu/drm/msm/hdmi/hdmi.c +++ b/drivers/gpu/drm/msm/hdmi/hdmi.c @@ -98,7 +98,7 @@ static int msm_hdmi_get_phy(struct hdmi *hdmi) phy_node = of_parse_phandle(pdev->dev.of_node, "phys", 0); if (!phy_node) { - dev_err(&pdev->dev, "cannot find phy device\n"); + DRM_DEV_ERROR(&pdev->dev, "cannot find phy device\n"); return -ENXIO; } @@ -109,7 +109,7 @@ static int msm_hdmi_get_phy(struct hdmi *hdmi) of_node_put(phy_node); if (!phy_pdev || !hdmi->phy) { - dev_err(&pdev->dev, "phy driver is not ready\n"); + DRM_DEV_ERROR(&pdev->dev, "phy driver is not ready\n"); return -EPROBE_DEFER; } @@ -153,7 +153,7 @@ static struct hdmi *msm_hdmi_init(struct platform_device *pdev) hdmi->qfprom_mmio = msm_ioremap(pdev, config->qfprom_mmio_name, "HDMI_QFPROM"); if (IS_ERR(hdmi->qfprom_mmio)) { - dev_info(&pdev->dev, "can't find qfprom resource\n"); + DRM_DEV_INFO(&pdev->dev, "can't find qfprom resource\n"); hdmi->qfprom_mmio = NULL; } @@ -172,7 +172,7 @@ static struct hdmi *msm_hdmi_init(struct platform_device *pdev) config->hpd_reg_names[i]); if (IS_ERR(reg)) { ret = PTR_ERR(reg); - dev_err(&pdev->dev, "failed to get hpd regulator: %s (%d)\n", + DRM_DEV_ERROR(&pdev->dev, "failed to get hpd regulator: %s (%d)\n", config->hpd_reg_names[i], ret); goto fail; } @@ -195,7 +195,7 @@ static struct hdmi *msm_hdmi_init(struct platform_device *pdev) config->pwr_reg_names[i]); if (IS_ERR(reg)) { ret = PTR_ERR(reg); - dev_err(&pdev->dev, "failed to get pwr regulator: %s (%d)\n", + DRM_DEV_ERROR(&pdev->dev, "failed to get pwr regulator: %s (%d)\n", config->pwr_reg_names[i], ret); goto fail; } @@ -217,7 +217,7 @@ static struct hdmi *msm_hdmi_init(struct platform_device *pdev) clk = msm_clk_get(pdev, config->hpd_clk_names[i]); if (IS_ERR(clk)) { ret = PTR_ERR(clk); - dev_err(&pdev->dev, "failed to get hpd clk: %s (%d)\n", + DRM_DEV_ERROR(&pdev->dev, "failed to get hpd clk: %s (%d)\n", config->hpd_clk_names[i], ret); goto fail; } @@ -239,7 +239,7 @@ static struct hdmi *msm_hdmi_init(struct platform_device *pdev) clk = msm_clk_get(pdev, config->pwr_clk_names[i]); if (IS_ERR(clk)) { ret = PTR_ERR(clk); - dev_err(&pdev->dev, "failed to get pwr clk: %s (%d)\n", + DRM_DEV_ERROR(&pdev->dev, "failed to get pwr clk: %s (%d)\n", config->pwr_clk_names[i], ret); goto fail; } @@ -254,14 +254,14 @@ static struct hdmi *msm_hdmi_init(struct platform_device *pdev) hdmi->i2c = msm_hdmi_i2c_init(hdmi); if (IS_ERR(hdmi->i2c)) { ret = PTR_ERR(hdmi->i2c); - dev_err(&pdev->dev, "failed to get i2c: %d\n", ret); + DRM_DEV_ERROR(&pdev->dev, "failed to get i2c: %d\n", ret); hdmi->i2c = NULL; goto fail; } ret = msm_hdmi_get_phy(hdmi); if (ret) { - dev_err(&pdev->dev, "failed to get phy\n"); + DRM_DEV_ERROR(&pdev->dev, "failed to get phy\n"); goto fail; } @@ -303,7 +303,7 @@ int msm_hdmi_modeset_init(struct hdmi *hdmi, hdmi->bridge = msm_hdmi_bridge_init(hdmi); if (IS_ERR(hdmi->bridge)) { ret = PTR_ERR(hdmi->bridge); - dev_err(dev->dev, "failed to create HDMI bridge: %d\n", ret); + DRM_DEV_ERROR(dev->dev, "failed to create HDMI bridge: %d\n", ret); hdmi->bridge = NULL; goto fail; } @@ -311,7 +311,7 @@ int msm_hdmi_modeset_init(struct hdmi *hdmi, hdmi->connector = msm_hdmi_connector_init(hdmi); if (IS_ERR(hdmi->connector)) { ret = PTR_ERR(hdmi->connector); - dev_err(dev->dev, "failed to create HDMI connector: %d\n", ret); + DRM_DEV_ERROR(dev->dev, "failed to create HDMI connector: %d\n", ret); hdmi->connector = NULL; goto fail; } @@ -319,7 +319,7 @@ int msm_hdmi_modeset_init(struct hdmi *hdmi, hdmi->irq = irq_of_parse_and_map(pdev->dev.of_node, 0); if (hdmi->irq < 0) { ret = hdmi->irq; - dev_err(dev->dev, "failed to get irq: %d\n", ret); + DRM_DEV_ERROR(dev->dev, "failed to get irq: %d\n", ret); goto fail; } @@ -327,7 +327,7 @@ int msm_hdmi_modeset_init(struct hdmi *hdmi, msm_hdmi_irq, IRQF_TRIGGER_HIGH | IRQF_ONESHOT, "hdmi_isr", hdmi); if (ret < 0) { - dev_err(dev->dev, "failed to request IRQ%u: %d\n", + DRM_DEV_ERROR(dev->dev, "failed to request IRQ%u: %d\n", hdmi->irq, ret); goto fail; } @@ -476,7 +476,7 @@ static int msm_hdmi_audio_hw_params(struct device *dev, void *data, unsigned int level_shift = 0; /* 0dB */ bool down_mix = false; - dev_dbg(dev, "%u Hz, %d bit, %d channels\n", params->sample_rate, + DRM_DEV_DEBUG(dev, "%u Hz, %d bit, %d channels\n", params->sample_rate, params->sample_width, params->cea.channels); switch (params->cea.channels) { @@ -527,7 +527,7 @@ static int msm_hdmi_audio_hw_params(struct device *dev, void *data, rate = HDMI_SAMPLE_RATE_192KHZ; break; default: - dev_err(dev, "rate[%d] not supported!\n", + DRM_DEV_ERROR(dev, "rate[%d] not supported!\n", params->sample_rate); return -EINVAL; } @@ -579,7 +579,7 @@ static int msm_hdmi_bind(struct device *dev, struct device *master, void *data) hdmi_cfg = (struct hdmi_platform_config *) of_device_get_match_data(dev); if (!hdmi_cfg) { - dev_err(dev, "unknown hdmi_cfg: %pOFn\n", of_node); + DRM_DEV_ERROR(dev, "unknown hdmi_cfg: %pOFn\n", of_node); return -ENXIO; } diff --git a/drivers/gpu/drm/msm/hdmi/hdmi_bridge.c b/drivers/gpu/drm/msm/hdmi/hdmi_bridge.c index 7e35707..98d61c6 100644 --- a/drivers/gpu/drm/msm/hdmi/hdmi_bridge.c +++ b/drivers/gpu/drm/msm/hdmi/hdmi_bridge.c @@ -40,7 +40,7 @@ static void msm_hdmi_power_on(struct drm_bridge *bridge) for (i = 0; i < config->pwr_reg_cnt; i++) { ret = regulator_enable(hdmi->pwr_regs[i]); if (ret) { - dev_err(dev->dev, "failed to enable pwr regulator: %s (%d)\n", + DRM_DEV_ERROR(dev->dev, "failed to enable pwr regulator: %s (%d)\n", config->pwr_reg_names[i], ret); } } @@ -49,7 +49,7 @@ static void msm_hdmi_power_on(struct drm_bridge *bridge) DBG("pixclock: %lu", hdmi->pixclock); ret = clk_set_rate(hdmi->pwr_clks[0], hdmi->pixclock); if (ret) { - dev_err(dev->dev, "failed to set pixel clk: %s (%d)\n", + DRM_DEV_ERROR(dev->dev, "failed to set pixel clk: %s (%d)\n", config->pwr_clk_names[0], ret); } } @@ -57,7 +57,7 @@ static void msm_hdmi_power_on(struct drm_bridge *bridge) for (i = 0; i < config->pwr_clk_cnt; i++) { ret = clk_prepare_enable(hdmi->pwr_clks[i]); if (ret) { - dev_err(dev->dev, "failed to enable pwr clk: %s (%d)\n", + DRM_DEV_ERROR(dev->dev, "failed to enable pwr clk: %s (%d)\n", config->pwr_clk_names[i], ret); } } @@ -82,7 +82,7 @@ static void power_off(struct drm_bridge *bridge) for (i = 0; i < config->pwr_reg_cnt; i++) { ret = regulator_disable(hdmi->pwr_regs[i]); if (ret) { - dev_err(dev->dev, "failed to disable pwr regulator: %s (%d)\n", + DRM_DEV_ERROR(dev->dev, "failed to disable pwr regulator: %s (%d)\n", config->pwr_reg_names[i], ret); } } @@ -105,7 +105,7 @@ static void msm_hdmi_config_avi_infoframe(struct hdmi *hdmi) len = hdmi_infoframe_pack(&frame, buffer, sizeof(buffer)); if (len < 0) { - dev_err(&hdmi->pdev->dev, + DRM_DEV_ERROR(&hdmi->pdev->dev, "failed to configure avi infoframe\n"); return; } diff --git a/drivers/gpu/drm/msm/hdmi/hdmi_connector.c b/drivers/gpu/drm/msm/hdmi/hdmi_connector.c index e9c9a0a..9da7345 100644 --- a/drivers/gpu/drm/msm/hdmi/hdmi_connector.c +++ b/drivers/gpu/drm/msm/hdmi/hdmi_connector.c @@ -90,7 +90,7 @@ static int gpio_config(struct hdmi *hdmi, bool on) if (gpio.num != -1) { ret = gpio_request(gpio.num, gpio.label); if (ret) { - dev_err(dev, + DRM_DEV_ERROR(dev, "'%s'(%d) gpio_request failed: %d\n", gpio.label, gpio.num, ret); goto err; @@ -156,7 +156,7 @@ static void enable_hpd_clocks(struct hdmi *hdmi, bool enable) ret = clk_prepare_enable(hdmi->hpd_clks[i]); if (ret) { - dev_err(dev, + DRM_DEV_ERROR(dev, "failed to enable hpd clk: %s (%d)\n", config->hpd_clk_names[i], ret); } @@ -179,7 +179,7 @@ static int hpd_enable(struct hdmi_connector *hdmi_connector) for (i = 0; i < config->hpd_reg_cnt; i++) { ret = regulator_enable(hdmi->hpd_regs[i]); if (ret) { - dev_err(dev, "failed to enable hpd regulator: %s (%d)\n", + DRM_DEV_ERROR(dev, "failed to enable hpd regulator: %s (%d)\n", config->hpd_reg_names[i], ret); goto fail; } @@ -187,13 +187,13 @@ static int hpd_enable(struct hdmi_connector *hdmi_connector) ret = pinctrl_pm_select_default_state(dev); if (ret) { - dev_err(dev, "pinctrl state chg failed: %d\n", ret); + DRM_DEV_ERROR(dev, "pinctrl state chg failed: %d\n", ret); goto fail; } ret = gpio_config(hdmi, true); if (ret) { - dev_err(dev, "failed to configure GPIOs: %d\n", ret); + DRM_DEV_ERROR(dev, "failed to configure GPIOs: %d\n", ret); goto fail; } @@ -473,7 +473,7 @@ struct drm_connector *msm_hdmi_connector_init(struct hdmi *hdmi) ret = hpd_enable(hdmi_connector); if (ret) { - dev_err(&hdmi->pdev->dev, "failed to enable HPD: %d\n", ret); + DRM_DEV_ERROR(&hdmi->pdev->dev, "failed to enable HPD: %d\n", ret); return ERR_PTR(ret); } diff --git a/drivers/gpu/drm/msm/hdmi/hdmi_i2c.c b/drivers/gpu/drm/msm/hdmi/hdmi_i2c.c index 73e2021..25d2fe2 100644 --- a/drivers/gpu/drm/msm/hdmi/hdmi_i2c.c +++ b/drivers/gpu/drm/msm/hdmi/hdmi_i2c.c @@ -66,7 +66,7 @@ static int ddc_clear_irq(struct hdmi_i2c_adapter *hdmi_i2c) } while ((ddc_int_ctrl & HDMI_DDC_INT_CTRL_SW_DONE_INT) && retry); if (!retry) { - dev_err(dev->dev, "timeout waiting for DDC\n"); + DRM_DEV_ERROR(dev->dev, "timeout waiting for DDC\n"); return -ETIMEDOUT; } diff --git a/drivers/gpu/drm/msm/hdmi/hdmi_phy.c b/drivers/gpu/drm/msm/hdmi/hdmi_phy.c index 4157722..1f4331e 100644 --- a/drivers/gpu/drm/msm/hdmi/hdmi_phy.c +++ b/drivers/gpu/drm/msm/hdmi/hdmi_phy.c @@ -37,7 +37,7 @@ static int msm_hdmi_phy_resource_init(struct hdmi_phy *phy) reg = devm_regulator_get(dev, cfg->reg_names[i]); if (IS_ERR(reg)) { ret = PTR_ERR(reg); - dev_err(dev, "failed to get phy regulator: %s (%d)\n", + DRM_DEV_ERROR(dev, "failed to get phy regulator: %s (%d)\n", cfg->reg_names[i], ret); return ret; } @@ -51,7 +51,7 @@ static int msm_hdmi_phy_resource_init(struct hdmi_phy *phy) clk = msm_clk_get(phy->pdev, cfg->clk_names[i]); if (IS_ERR(clk)) { ret = PTR_ERR(clk); - dev_err(dev, "failed to get phy clock: %s (%d)\n", + DRM_DEV_ERROR(dev, "failed to get phy clock: %s (%d)\n", cfg->clk_names[i], ret); return ret; } @@ -73,14 +73,14 @@ int msm_hdmi_phy_resource_enable(struct hdmi_phy *phy) for (i = 0; i < cfg->num_regs; i++) { ret = regulator_enable(phy->regs[i]); if (ret) - dev_err(dev, "failed to enable regulator: %s (%d)\n", + DRM_DEV_ERROR(dev, "failed to enable regulator: %s (%d)\n", cfg->reg_names[i], ret); } for (i = 0; i < cfg->num_clks; i++) { ret = clk_prepare_enable(phy->clks[i]); if (ret) - dev_err(dev, "failed to enable clock: %s (%d)\n", + DRM_DEV_ERROR(dev, "failed to enable clock: %s (%d)\n", cfg->clk_names[i], ret); } @@ -159,7 +159,7 @@ static int msm_hdmi_phy_probe(struct platform_device *pdev) phy->mmio = msm_ioremap(pdev, "hdmi_phy", "HDMI_PHY"); if (IS_ERR(phy->mmio)) { - dev_err(dev, "%s: failed to map phy base\n", __func__); + DRM_DEV_ERROR(dev, "%s: failed to map phy base\n", __func__); return -ENOMEM; } @@ -177,7 +177,7 @@ static int msm_hdmi_phy_probe(struct platform_device *pdev) ret = msm_hdmi_phy_pll_init(pdev, phy->cfg->type); if (ret) { - dev_err(dev, "couldn't init PLL\n"); + DRM_DEV_ERROR(dev, "couldn't init PLL\n"); msm_hdmi_phy_resource_disable(phy); return ret; } diff --git a/drivers/gpu/drm/msm/hdmi/hdmi_phy_8996.c b/drivers/gpu/drm/msm/hdmi/hdmi_phy_8996.c index 0df504c..318708f 100644 --- a/drivers/gpu/drm/msm/hdmi/hdmi_phy_8996.c +++ b/drivers/gpu/drm/msm/hdmi/hdmi_phy_8996.c @@ -725,7 +725,7 @@ int msm_hdmi_pll_8996_init(struct platform_device *pdev) pll->mmio_qserdes_com = msm_ioremap(pdev, "hdmi_pll", "HDMI_PLL"); if (IS_ERR(pll->mmio_qserdes_com)) { - dev_err(dev, "failed to map pll base\n"); + DRM_DEV_ERROR(dev, "failed to map pll base\n"); return -ENOMEM; } @@ -737,7 +737,7 @@ int msm_hdmi_pll_8996_init(struct platform_device *pdev) pll->mmio_qserdes_tx[i] = msm_ioremap(pdev, name, label); if (IS_ERR(pll->mmio_qserdes_tx[i])) { - dev_err(dev, "failed to map pll base\n"); + DRM_DEV_ERROR(dev, "failed to map pll base\n"); return -ENOMEM; } } @@ -745,7 +745,7 @@ int msm_hdmi_pll_8996_init(struct platform_device *pdev) clk = devm_clk_register(dev, &pll->clk_hw); if (IS_ERR(clk)) { - dev_err(dev, "failed to register pll clock\n"); + DRM_DEV_ERROR(dev, "failed to register pll clock\n"); return -EINVAL; } diff --git a/drivers/gpu/drm/msm/hdmi/hdmi_pll_8960.c b/drivers/gpu/drm/msm/hdmi/hdmi_pll_8960.c index 9959075..c6dae6e 100644 --- a/drivers/gpu/drm/msm/hdmi/hdmi_pll_8960.c +++ b/drivers/gpu/drm/msm/hdmi/hdmi_pll_8960.c @@ -445,7 +445,7 @@ int msm_hdmi_pll_8960_init(struct platform_device *pdev) pll->mmio = msm_ioremap(pdev, "hdmi_pll", "HDMI_PLL"); if (IS_ERR(pll->mmio)) { - dev_err(dev, "failed to map pll base\n"); + DRM_DEV_ERROR(dev, "failed to map pll base\n"); return -ENOMEM; } @@ -454,7 +454,7 @@ int msm_hdmi_pll_8960_init(struct platform_device *pdev) clk = devm_clk_register(dev, &pll->clk_hw); if (IS_ERR(clk)) { - dev_err(dev, "failed to register pll clock\n"); + DRM_DEV_ERROR(dev, "failed to register pll clock\n"); return -EINVAL; } diff --git a/drivers/gpu/drm/msm/msm_debugfs.c b/drivers/gpu/drm/msm/msm_debugfs.c index f0da0d3..03210f4 100644 --- a/drivers/gpu/drm/msm/msm_debugfs.c +++ b/drivers/gpu/drm/msm/msm_debugfs.c @@ -194,13 +194,13 @@ static int late_init_minor(struct drm_minor *minor) ret = msm_rd_debugfs_init(minor); if (ret) { - dev_err(minor->dev->dev, "could not install rd debugfs\n"); + DRM_DEV_ERROR(minor->dev->dev, "could not install rd debugfs\n"); return ret; } ret = msm_perf_debugfs_init(minor); if (ret) { - dev_err(minor->dev->dev, "could not install perf debugfs\n"); + DRM_DEV_ERROR(minor->dev->dev, "could not install perf debugfs\n"); return ret; } @@ -228,7 +228,7 @@ int msm_debugfs_init(struct drm_minor *minor) minor->debugfs_root, minor); if (ret) { - dev_err(dev->dev, "could not install msm_debugfs_list\n"); + DRM_DEV_ERROR(dev->dev, "could not install msm_debugfs_list\n"); return ret; } diff --git a/drivers/gpu/drm/msm/msm_drv.c b/drivers/gpu/drm/msm/msm_drv.c index f1cacf9..88a2387 100644 --- a/drivers/gpu/drm/msm/msm_drv.c +++ b/drivers/gpu/drm/msm/msm_drv.c @@ -170,7 +170,7 @@ void __iomem *msm_ioremap(struct platform_device *pdev, const char *name, res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) { - dev_err(&pdev->dev, "failed to get memory resource: %s\n", name); + DRM_DEV_ERROR(&pdev->dev, "failed to get memory resource: %s\n", name); return ERR_PTR(-EINVAL); } @@ -178,7 +178,7 @@ void __iomem *msm_ioremap(struct platform_device *pdev, const char *name, ptr = devm_ioremap_nocache(&pdev->dev, res->start, size); if (!ptr) { - dev_err(&pdev->dev, "failed to ioremap: %s\n", name); + DRM_DEV_ERROR(&pdev->dev, "failed to ioremap: %s\n", name); return ERR_PTR(-ENOMEM); } @@ -419,12 +419,12 @@ static int msm_init_vram(struct drm_device *dev) p = dma_alloc_attrs(dev->dev, size, &priv->vram.paddr, GFP_KERNEL, attrs); if (!p) { - dev_err(dev->dev, "failed to allocate VRAM\n"); + DRM_DEV_ERROR(dev->dev, "failed to allocate VRAM\n"); priv->vram.paddr = 0; return -ENOMEM; } - dev_info(dev->dev, "VRAM: %08x->%08x\n", + DRM_DEV_INFO(dev->dev, "VRAM: %08x->%08x\n", (uint32_t)priv->vram.paddr, (uint32_t)(priv->vram.paddr + size)); } @@ -444,7 +444,7 @@ static int msm_drm_init(struct device *dev, struct drm_driver *drv) ddev = drm_dev_alloc(drv, dev); if (IS_ERR(ddev)) { - dev_err(dev, "failed to allocate drm_device\n"); + DRM_DEV_ERROR(dev, "failed to allocate drm_device\n"); return PTR_ERR(ddev); } @@ -519,7 +519,7 @@ static int msm_drm_init(struct device *dev, struct drm_driver *drv) * and (for example) use dmabuf/prime to share buffers with * imx drm driver on iMX5 */ - dev_err(dev, "failed to load kms\n"); + DRM_DEV_ERROR(dev, "failed to load kms\n"); ret = PTR_ERR(kms); goto err_msm_uninit; } @@ -530,7 +530,7 @@ static int msm_drm_init(struct device *dev, struct drm_driver *drv) if (kms) { ret = kms->funcs->hw_init(kms); if (ret) { - dev_err(dev, "kms hw init failed: %d\n", ret); + DRM_DEV_ERROR(dev, "kms hw init failed: %d\n", ret); goto err_msm_uninit; } } @@ -561,7 +561,7 @@ static int msm_drm_init(struct device *dev, struct drm_driver *drv) ret); if (IS_ERR(priv->disp_thread[i].thread)) { - dev_err(dev, "failed to create crtc_commit kthread\n"); + DRM_DEV_ERROR(dev, "failed to create crtc_commit kthread\n"); priv->disp_thread[i].thread = NULL; } @@ -587,7 +587,7 @@ static int msm_drm_init(struct device *dev, struct drm_driver *drv) ret); if (IS_ERR(priv->event_thread[i].thread)) { - dev_err(dev, "failed to create crtc_event kthread\n"); + DRM_DEV_ERROR(dev, "failed to create crtc_event kthread\n"); priv->event_thread[i].thread = NULL; } @@ -613,7 +613,7 @@ static int msm_drm_init(struct device *dev, struct drm_driver *drv) ret = drm_vblank_init(ddev, priv->num_crtcs); if (ret < 0) { - dev_err(dev, "failed to initialize vblank\n"); + DRM_DEV_ERROR(dev, "failed to initialize vblank\n"); goto err_msm_uninit; } @@ -622,7 +622,7 @@ static int msm_drm_init(struct device *dev, struct drm_driver *drv) ret = drm_irq_install(ddev, kms->irq); pm_runtime_put_sync(dev); if (ret < 0) { - dev_err(dev, "failed to install IRQ handler\n"); + DRM_DEV_ERROR(dev, "failed to install IRQ handler\n"); goto err_msm_uninit; } } @@ -1185,7 +1185,7 @@ static int add_components_mdp(struct device *mdp_dev, ret = of_graph_parse_endpoint(ep_node, &ep); if (ret) { - dev_err(mdp_dev, "unable to parse port endpoint\n"); + DRM_DEV_ERROR(mdp_dev, "unable to parse port endpoint\n"); of_node_put(ep_node); return ret; } @@ -1236,13 +1236,13 @@ static int add_display_components(struct device *dev, of_device_is_compatible(dev->of_node, "qcom,sdm845-mdss")) { ret = of_platform_populate(dev->of_node, NULL, NULL, dev); if (ret) { - dev_err(dev, "failed to populate children devices\n"); + DRM_DEV_ERROR(dev, "failed to populate children devices\n"); return ret; } mdp_dev = device_find_child(dev, NULL, compare_name_mdp); if (!mdp_dev) { - dev_err(dev, "failed to find MDSS MDP node\n"); + DRM_DEV_ERROR(dev, "failed to find MDSS MDP node\n"); of_platform_depopulate(dev); return -ENODEV; } diff --git a/drivers/gpu/drm/msm/msm_fb.c b/drivers/gpu/drm/msm/msm_fb.c index 2a7348a..475191f 100644 --- a/drivers/gpu/drm/msm/msm_fb.c +++ b/drivers/gpu/drm/msm/msm_fb.c @@ -154,7 +154,7 @@ static struct drm_framebuffer *msm_framebuffer_init(struct drm_device *dev, format = kms->funcs->get_format(kms, mode_cmd->pixel_format, mode_cmd->modifier[0]); if (!format) { - dev_err(dev->dev, "unsupported pixel format: %4.4s\n", + DRM_DEV_ERROR(dev->dev, "unsupported pixel format: %4.4s\n", (char *)&mode_cmd->pixel_format); ret = -EINVAL; goto fail; @@ -196,7 +196,7 @@ static struct drm_framebuffer *msm_framebuffer_init(struct drm_device *dev, ret = drm_framebuffer_init(dev, fb, &msm_framebuffer_funcs); if (ret) { - dev_err(dev->dev, "framebuffer init failed: %d\n", ret); + DRM_DEV_ERROR(dev->dev, "framebuffer init failed: %d\n", ret); goto fail; } @@ -233,13 +233,13 @@ struct drm_framebuffer * bo = msm_gem_new(dev, size, MSM_BO_SCANOUT | MSM_BO_WC); } if (IS_ERR(bo)) { - dev_err(dev->dev, "failed to allocate buffer object\n"); + DRM_DEV_ERROR(dev->dev, "failed to allocate buffer object\n"); return ERR_CAST(bo); } fb = msm_framebuffer_init(dev, &mode_cmd, &bo); if (IS_ERR(fb)) { - dev_err(dev->dev, "failed to allocate fb\n"); + DRM_DEV_ERROR(dev->dev, "failed to allocate fb\n"); /* note: if fb creation failed, we can't rely on fb destroy * to unref the bo: */ diff --git a/drivers/gpu/drm/msm/msm_fbdev.c b/drivers/gpu/drm/msm/msm_fbdev.c index 456622b..f94cbbb 100644 --- a/drivers/gpu/drm/msm/msm_fbdev.c +++ b/drivers/gpu/drm/msm/msm_fbdev.c @@ -91,7 +91,7 @@ static int msm_fbdev_create(struct drm_fb_helper *helper, sizes->surface_height, pitch, format); if (IS_ERR(fb)) { - dev_err(dev->dev, "failed to allocate fb\n"); + DRM_DEV_ERROR(dev->dev, "failed to allocate fb\n"); return PTR_ERR(fb); } @@ -106,13 +106,13 @@ static int msm_fbdev_create(struct drm_fb_helper *helper, */ ret = msm_gem_get_iova(bo, priv->kms->aspace, &paddr); if (ret) { - dev_err(dev->dev, "failed to get buffer obj iova: %d\n", ret); + DRM_DEV_ERROR(dev->dev, "failed to get buffer obj iova: %d\n", ret); goto fail_unlock; } fbi = drm_fb_helper_alloc_fbi(helper); if (IS_ERR(fbi)) { - dev_err(dev->dev, "failed to allocate fb info\n"); + DRM_DEV_ERROR(dev->dev, "failed to allocate fb info\n"); ret = PTR_ERR(fbi); goto fail_unlock; } @@ -176,7 +176,7 @@ struct drm_fb_helper *msm_fbdev_init(struct drm_device *dev) ret = drm_fb_helper_init(dev, helper, priv->num_connectors); if (ret) { - dev_err(dev->dev, "could not init fbdev: ret=%d\n", ret); + DRM_DEV_ERROR(dev->dev, "could not init fbdev: ret=%d\n", ret); goto fail; } diff --git a/drivers/gpu/drm/msm/msm_gem.c b/drivers/gpu/drm/msm/msm_gem.c index f59ca27..00c795c 100644 --- a/drivers/gpu/drm/msm/msm_gem.c +++ b/drivers/gpu/drm/msm/msm_gem.c @@ -88,7 +88,7 @@ static struct page **get_pages(struct drm_gem_object *obj) p = get_pages_vram(obj, npages); if (IS_ERR(p)) { - dev_err(dev->dev, "could not get pages: %ld\n", + DRM_DEV_ERROR(dev->dev, "could not get pages: %ld\n", PTR_ERR(p)); return p; } @@ -99,7 +99,7 @@ static struct page **get_pages(struct drm_gem_object *obj) if (IS_ERR(msm_obj->sgt)) { void *ptr = ERR_CAST(msm_obj->sgt); - dev_err(dev->dev, "failed to allocate sgt\n"); + DRM_DEV_ERROR(dev->dev, "failed to allocate sgt\n"); msm_obj->sgt = NULL; return ptr; } @@ -280,7 +280,7 @@ static uint64_t mmap_offset(struct drm_gem_object *obj) ret = drm_gem_create_mmap_offset(obj); if (ret) { - dev_err(dev->dev, "could not allocate mmap offset\n"); + DRM_DEV_ERROR(dev->dev, "could not allocate mmap offset\n"); return 0; } @@ -473,7 +473,7 @@ static void *get_vaddr(struct drm_gem_object *obj, unsigned madv) mutex_lock(&msm_obj->lock); if (WARN_ON(msm_obj->madv > madv)) { - dev_err(obj->dev->dev, "Invalid madv state: %u vs %u\n", + DRM_DEV_ERROR(obj->dev->dev, "Invalid madv state: %u vs %u\n", msm_obj->madv, madv); mutex_unlock(&msm_obj->lock); return ERR_PTR(-EBUSY); @@ -864,7 +864,7 @@ static int msm_gem_new_impl(struct drm_device *dev, case MSM_BO_WC: break; default: - dev_err(dev->dev, "invalid cache flag: %x\n", + DRM_DEV_ERROR(dev->dev, "invalid cache flag: %x\n", (flags & MSM_BO_CACHE_MASK)); return -EINVAL; } @@ -990,7 +990,7 @@ struct drm_gem_object *msm_gem_import(struct drm_device *dev, /* if we don't have IOMMU, don't bother pretending we can import: */ if (!iommu_present(&platform_bus_type)) { - dev_err(dev->dev, "cannot import without IOMMU\n"); + DRM_DEV_ERROR(dev->dev, "cannot import without IOMMU\n"); return ERR_PTR(-EINVAL); } diff --git a/drivers/gpu/drm/msm/msm_gpu.c b/drivers/gpu/drm/msm/msm_gpu.c index 5e808cf..d19e5a2 100644 --- a/drivers/gpu/drm/msm/msm_gpu.c +++ b/drivers/gpu/drm/msm/msm_gpu.c @@ -102,7 +102,7 @@ static void msm_devfreq_init(struct msm_gpu *gpu) &msm_devfreq_profile, "simple_ondemand", NULL); if (IS_ERR(gpu->devfreq.devfreq)) { - dev_err(&gpu->pdev->dev, "Couldn't initialize GPU devfreq\n"); + DRM_DEV_ERROR(&gpu->pdev->dev, "Couldn't initialize GPU devfreq\n"); gpu->devfreq.devfreq = NULL; } } @@ -115,7 +115,7 @@ static int enable_pwrrail(struct msm_gpu *gpu) if (gpu->gpu_reg) { ret = regulator_enable(gpu->gpu_reg); if (ret) { - dev_err(dev->dev, "failed to enable 'gpu_reg': %d\n", ret); + DRM_DEV_ERROR(dev->dev, "failed to enable 'gpu_reg': %d\n", ret); return ret; } } @@ -123,7 +123,7 @@ static int enable_pwrrail(struct msm_gpu *gpu) if (gpu->gpu_cx) { ret = regulator_enable(gpu->gpu_cx); if (ret) { - dev_err(dev->dev, "failed to enable 'gpu_cx': %d\n", ret); + DRM_DEV_ERROR(dev->dev, "failed to enable 'gpu_cx': %d\n", ret); return ret; } } @@ -419,7 +419,7 @@ static void recover_worker(struct work_struct *work) mutex_lock(&dev->struct_mutex); - dev_err(dev->dev, "%s: hangcheck recover!\n", gpu->name); + DRM_DEV_ERROR(dev->dev, "%s: hangcheck recover!\n", gpu->name); submit = find_submit(cur_ring, cur_ring->memptrs->fence + 1); if (submit) { @@ -447,7 +447,7 @@ static void recover_worker(struct work_struct *work) rcu_read_unlock(); if (comm && cmd) { - dev_err(dev->dev, "%s: offending task: %s (%s)\n", + DRM_DEV_ERROR(dev->dev, "%s: offending task: %s (%s)\n", gpu->name, comm, cmd); msm_rd_dump_submit(priv->hangrd, submit, @@ -530,11 +530,11 @@ static void hangcheck_handler(struct timer_list *t) } else if (fence < ring->seqno) { /* no progress and not done.. hung! */ ring->hangcheck_fence = fence; - dev_err(dev->dev, "%s: hangcheck detected gpu lockup rb %d!\n", + DRM_DEV_ERROR(dev->dev, "%s: hangcheck detected gpu lockup rb %d!\n", gpu->name, ring->id); - dev_err(dev->dev, "%s: completed fence: %u\n", + DRM_DEV_ERROR(dev->dev, "%s: completed fence: %u\n", gpu->name, fence); - dev_err(dev->dev, "%s: submitted fence: %u\n", + DRM_DEV_ERROR(dev->dev, "%s: submitted fence: %u\n", gpu->name, ring->seqno); queue_work(priv->wq, &gpu->recover_work); @@ -807,11 +807,11 @@ static int get_clocks(struct platform_device *pdev, struct msm_gpu *gpu) iommu->geometry.aperture_start = va_start; iommu->geometry.aperture_end = va_end; - dev_info(gpu->dev->dev, "%s: using IOMMU\n", gpu->name); + 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)) { - dev_err(gpu->dev->dev, "failed to init iommu: %ld\n", + DRM_DEV_ERROR(gpu->dev->dev, "failed to init iommu: %ld\n", PTR_ERR(aspace)); iommu_domain_free(iommu); return ERR_CAST(aspace); @@ -862,14 +862,14 @@ int msm_gpu_init(struct drm_device *drm, struct platform_device *pdev, gpu->irq = platform_get_irq_byname(pdev, config->irqname); if (gpu->irq < 0) { ret = gpu->irq; - dev_err(drm->dev, "failed to get irq: %d\n", ret); + DRM_DEV_ERROR(drm->dev, "failed to get irq: %d\n", ret); goto fail; } ret = devm_request_irq(&pdev->dev, gpu->irq, irq_handler, IRQF_TRIGGER_HIGH, gpu->name, gpu); if (ret) { - dev_err(drm->dev, "failed to request IRQ%u: %d\n", gpu->irq, ret); + DRM_DEV_ERROR(drm->dev, "failed to request IRQ%u: %d\n", gpu->irq, ret); goto fail; } @@ -902,7 +902,7 @@ int msm_gpu_init(struct drm_device *drm, struct platform_device *pdev, config->va_start, config->va_end); if (gpu->aspace == NULL) - dev_info(drm->dev, "%s: no IOMMU, fallback to VRAM carveout!\n", name); + DRM_DEV_INFO(drm->dev, "%s: no IOMMU, fallback to VRAM carveout!\n", name); else if (IS_ERR(gpu->aspace)) { ret = PTR_ERR(gpu->aspace); goto fail; @@ -914,7 +914,7 @@ int msm_gpu_init(struct drm_device *drm, struct platform_device *pdev, if (IS_ERR(memptrs)) { ret = PTR_ERR(memptrs); - dev_err(drm->dev, "could not allocate memptrs: %d\n", ret); + DRM_DEV_ERROR(drm->dev, "could not allocate memptrs: %d\n", ret); goto fail; } @@ -930,7 +930,7 @@ int msm_gpu_init(struct drm_device *drm, struct platform_device *pdev, if (IS_ERR(gpu->rb[i])) { ret = PTR_ERR(gpu->rb[i]); - dev_err(drm->dev, + DRM_DEV_ERROR(drm->dev, "could not create ringbuffer %d: %d\n", i, ret); goto fail; } -- 1.9.1 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Mamta Shukla Subject: [PATCH DRM] drm: msm: Use DRM_DEV_* instead of dev_* Date: Sat, 20 Oct 2018 23:19:26 +0530 Message-ID: <20181020174926.GA32333@armorer> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail-pg1-x544.google.com (mail-pg1-x544.google.com [IPv6:2607:f8b0:4864:20::544]) by gabe.freedesktop.org (Postfix) with ESMTPS id EAC7D89857 for ; Sat, 20 Oct 2018 17:49:32 +0000 (UTC) Received: by mail-pg1-x544.google.com with SMTP id f18-v6so17167709pgv.3 for ; Sat, 20 Oct 2018 10:49:32 -0700 (PDT) Content-Disposition: inline List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: outreachy-kernel@googlegroups.com Cc: airlied@linux.ie, daniel.vetter@ffwll.ch, sean@poorly.run, dri-devel@lists.freedesktop.org List-Id: dri-devel@lists.freedesktop.org VXNlIERSTV9ERVZfSU5GTy9FUlJPUi9XQVJOIGluc3RlYWQgb2YgZGV2X2luZm8vZXJyL2RlYnVn IHRvIGdlbmVyYXRlCmRybS1mb3JtYXR0ZWQgc3BlY2lmaWMgbG9nIG1lc3NhZ2VzIHNvIHRoYXQg aXQgd2lsbCBiZSBlYXN5IHRvCmRpZmZlcmVudGlhdGUgaW4gY2FzZSBvZiBtdWx0aXBsZSBpbnN0 YW5jZXMgb2YgZHJpdmVyLgoKU2lnbmVkLW9mZi1ieTogTWFtdGEgU2h1a2xhIDxtYW10YXNodWts YTU1NUBnbWFpbC5jb20+Ci0tLQogZHJpdmVycy9ncHUvZHJtL21zbS9hZHJlbm8vYTN4eF9ncHUu YyAgICAgICAgICAgICB8ICA0ICstLQogZHJpdmVycy9ncHUvZHJtL21zbS9hZHJlbm8vYTR4eF9n cHUuYyAgICAgICAgICAgICB8ICA0ICstLQogZHJpdmVycy9ncHUvZHJtL21zbS9hZHJlbm8vYTV4 eF9kZWJ1Z2ZzLmMgICAgICAgICB8ICAyICstCiBkcml2ZXJzL2dwdS9kcm0vbXNtL2FkcmVuby9h NXh4X2dwdS5jICAgICAgICAgICAgIHwgMTAgKysrLS0tCiBkcml2ZXJzL2dwdS9kcm0vbXNtL2Fk cmVuby9hNXh4X3ByZWVtcHQuYyAgICAgICAgIHwgIDQgKy0tCiBkcml2ZXJzL2dwdS9kcm0vbXNt L2FkcmVuby9hNnh4X2dtdS5jICAgICAgICAgICAgIHwgMzggKysrKysrKysrKy0tLS0tLS0tLS0K IGRyaXZlcnMvZ3B1L2RybS9tc20vYWRyZW5vL2E2eHhfZ3B1LmMgICAgICAgICAgICAgfCAgNCAr LS0KIGRyaXZlcnMvZ3B1L2RybS9tc20vYWRyZW5vL2E2eHhfaGZpLmMgICAgICAgICAgICAgfCAx NCArKysrLS0tLQogZHJpdmVycy9ncHUvZHJtL21zbS9hZHJlbm8vYWRyZW5vX2RldmljZS5jICAg ICAgICB8ICA2ICsrLS0KIGRyaXZlcnMvZ3B1L2RybS9tc20vYWRyZW5vL2FkcmVub19ncHUuYyAg ICAgICAgICAgfCAyMiArKysrKystLS0tLS0KIGRyaXZlcnMvZ3B1L2RybS9tc20vZGlzcC9kcHUx L2RwdV9kYmcuYyAgICAgICAgICAgfCAyOCArKysrKysrLS0tLS0tLS0KIGRyaXZlcnMvZ3B1L2Ry bS9tc20vZGlzcC9kcHUxL2RwdV9pb191dGlsLmMgICAgICAgfCAgNiArKy0tCiBkcml2ZXJzL2dw dS9kcm0vbXNtL2Rpc3AvbWRwNC9tZHA0X2NydGMuYyAgICAgICAgIHwgIDIgKy0KIGRyaXZlcnMv Z3B1L2RybS9tc20vZGlzcC9tZHA0L21kcDRfZHR2X2VuY29kZXIuYyAgfCAxMiArKystLS0tCiBk cml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3AvbWRwNC9tZHA0X2ttcy5jICAgICAgICAgIHwgNDQgKysr KysrKysrKystLS0tLS0tLS0tLS0KIGRyaXZlcnMvZ3B1L2RybS9tc20vZGlzcC9tZHA0L21kcDRf bGNkY19lbmNvZGVyLmMgfCAyMiArKysrKystLS0tLS0KIGRyaXZlcnMvZ3B1L2RybS9tc20vZGlz cC9tZHA0L21kcDRfcGxhbmUuYyAgICAgICAgfCAgOCArKy0tLQogZHJpdmVycy9ncHUvZHJtL21z bS9kaXNwL21kcDUvbWRwNV9jZmcuYyAgICAgICAgICB8ICA0ICstLQogZHJpdmVycy9ncHUvZHJt L21zbS9kaXNwL21kcDUvbWRwNV9jbWRfZW5jb2Rlci5jICB8IDEwICsrKy0tLQogZHJpdmVycy9n cHUvZHJtL21zbS9kaXNwL21kcDUvbWRwNV9jcnRjLmMgICAgICAgICB8ICA4ICsrLS0tCiBkcml2 ZXJzL2dwdS9kcm0vbXNtL2Rpc3AvbWRwNS9tZHA1X2N0bC5jICAgICAgICAgIHwgMTYgKysrKy0t LS0tCiBkcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3AvbWRwNS9tZHA1X2ttcy5jICAgICAgICAgIHwg MzAgKysrKysrKystLS0tLS0tLQogZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL21kcDUvbWRwNV9t ZHNzLmMgICAgICAgICB8IDEwICsrKy0tLQogZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL21kcDUv bWRwNV9wbGFuZS5jICAgICAgICB8ICA4ICsrLS0tCiBkcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3Av bWRwNS9tZHA1X3NtcC5jICAgICAgICAgIHwgIDQgKy0tCiBkcml2ZXJzL2dwdS9kcm0vbXNtL2Rz aS9kc2kuYyAgICAgICAgICAgICAgICAgICAgIHwgMTAgKysrLS0tCiBkcml2ZXJzL2dwdS9kcm0v bXNtL2RzaS9kc2lfaG9zdC5jICAgICAgICAgICAgICAgIHwgMjIgKysrKysrLS0tLS0tCiBkcml2 ZXJzL2dwdS9kcm0vbXNtL2RzaS9waHkvZHNpX3BoeS5jICAgICAgICAgICAgIHwgMjggKysrKysr Ky0tLS0tLS0tCiBkcml2ZXJzL2dwdS9kcm0vbXNtL2RzaS9waHkvZHNpX3BoeV8xMG5tLmMgICAg ICAgIHwgIDYgKystLQogZHJpdmVycy9ncHUvZHJtL21zbS9kc2kvcGh5L2RzaV9waHlfMTRubS5j ICAgICAgICB8ICA2ICsrLS0KIGRyaXZlcnMvZ3B1L2RybS9tc20vZHNpL3BoeS9kc2lfcGh5XzIw bm0uYyAgICAgICAgfCAgMiArLQogZHJpdmVycy9ncHUvZHJtL21zbS9kc2kvcGh5L2RzaV9waHlf MjhubS5jICAgICAgICB8ICAyICstCiBkcml2ZXJzL2dwdS9kcm0vbXNtL2RzaS9waHkvZHNpX3Bo eV8yOG5tXzg5NjAuYyAgIHwgIDIgKy0KIGRyaXZlcnMvZ3B1L2RybS9tc20vZHNpL3BsbC9kc2lf cGxsLmMgICAgICAgICAgICAgfCAgMiArLQogZHJpdmVycy9ncHUvZHJtL21zbS9kc2kvcGxsL2Rz aV9wbGxfMTBubS5jICAgICAgICB8ICA4ICsrLS0tCiBkcml2ZXJzL2dwdS9kcm0vbXNtL2RzaS9w bGwvZHNpX3BsbF8xNG5tLmMgICAgICAgIHwgMTIgKysrLS0tLQogZHJpdmVycy9ncHUvZHJtL21z bS9kc2kvcGxsL2RzaV9wbGxfMjhubS5jICAgICAgICB8IDE2ICsrKystLS0tLQogZHJpdmVycy9n cHUvZHJtL21zbS9kc2kvcGxsL2RzaV9wbGxfMjhubV84OTYwLmMgICB8IDEwICsrKy0tLQogZHJp dmVycy9ncHUvZHJtL21zbS9lZHAvZWRwLmMgICAgICAgICAgICAgICAgICAgICB8ICA4ICsrLS0t CiBkcml2ZXJzL2dwdS9kcm0vbXNtL2hkbWkvaGRtaS5jICAgICAgICAgICAgICAgICAgIHwgMzIg KysrKysrKystLS0tLS0tLS0KIGRyaXZlcnMvZ3B1L2RybS9tc20vaGRtaS9oZG1pX2JyaWRnZS5j ICAgICAgICAgICAgfCAxMCArKystLS0KIGRyaXZlcnMvZ3B1L2RybS9tc20vaGRtaS9oZG1pX2Nv bm5lY3Rvci5jICAgICAgICAgfCAxMiArKystLS0tCiBkcml2ZXJzL2dwdS9kcm0vbXNtL2hkbWkv aGRtaV9pMmMuYyAgICAgICAgICAgICAgIHwgIDIgKy0KIGRyaXZlcnMvZ3B1L2RybS9tc20vaGRt aS9oZG1pX3BoeS5jICAgICAgICAgICAgICAgfCAxMiArKystLS0tCiBkcml2ZXJzL2dwdS9kcm0v bXNtL2hkbWkvaGRtaV9waHlfODk5Ni5jICAgICAgICAgIHwgIDYgKystLQogZHJpdmVycy9ncHUv ZHJtL21zbS9oZG1pL2hkbWlfcGxsXzg5NjAuYyAgICAgICAgICB8ICA0ICstLQogZHJpdmVycy9n cHUvZHJtL21zbS9tc21fZGVidWdmcy5jICAgICAgICAgICAgICAgICB8ICA2ICsrLS0KIGRyaXZl cnMvZ3B1L2RybS9tc20vbXNtX2Rydi5jICAgICAgICAgICAgICAgICAgICAgfCAyOCArKysrKysr LS0tLS0tLS0KIGRyaXZlcnMvZ3B1L2RybS9tc20vbXNtX2ZiLmMgICAgICAgICAgICAgICAgICAg ICAgfCAgOCArKy0tLQogZHJpdmVycy9ncHUvZHJtL21zbS9tc21fZmJkZXYuYyAgICAgICAgICAg ICAgICAgICB8ICA4ICsrLS0tCiBkcml2ZXJzL2dwdS9kcm0vbXNtL21zbV9nZW0uYyAgICAgICAg ICAgICAgICAgICAgIHwgMTIgKysrLS0tLQogZHJpdmVycy9ncHUvZHJtL21zbS9tc21fZ3B1LmMg ICAgICAgICAgICAgICAgICAgICB8IDMwICsrKysrKysrLS0tLS0tLS0KIDUyIGZpbGVzIGNoYW5n ZWQsIDMxMiBpbnNlcnRpb25zKCspLCAzMTIgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvZHJp dmVycy9ncHUvZHJtL21zbS9hZHJlbm8vYTN4eF9ncHUuYyBiL2RyaXZlcnMvZ3B1L2RybS9tc20v YWRyZW5vL2EzeHhfZ3B1LmMKaW5kZXggNjY5YzJkNC4uYzNiNGJjNiAxMDA2NDQKLS0tIGEvZHJp dmVycy9ncHUvZHJtL21zbS9hZHJlbm8vYTN4eF9ncHUuYworKysgYi9kcml2ZXJzL2dwdS9kcm0v bXNtL2FkcmVuby9hM3h4X2dwdS5jCkBAIC00ODEsNyArNDgxLDcgQEAgc3RydWN0IG1zbV9ncHUg KmEzeHhfZ3B1X2luaXQoc3RydWN0IGRybV9kZXZpY2UgKmRldikKIAlpbnQgcmV0OwogCiAJaWYg KCFwZGV2KSB7Ci0JCWRldl9lcnIoZGV2LT5kZXYsICJubyBhM3h4IGRldmljZVxuIik7CisJCURS TV9ERVZfRVJST1IoZGV2LT5kZXYsICJubyBhM3h4IGRldmljZVxuIik7CiAJCXJldCA9IC1FTlhJ TzsKIAkJZ290byBmYWlsOwogCX0KQEAgLTUyOCw3ICs1MjgsNyBAQCBzdHJ1Y3QgbXNtX2dwdSAq YTN4eF9ncHVfaW5pdChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2KQogCQkgKiB0byBub3QgYmUgcG9z c2libGUgdG8gcmVzdHJpY3QgYWNjZXNzLCB0aGVuIHdlIG11c3QKIAkJICogaW1wbGVtZW50IGEg Y21kc3RyZWFtIHZhbGlkYXRvci4KIAkJICovCi0JCWRldl9lcnIoZGV2LT5kZXYsICJObyBtZW1v cnkgcHJvdGVjdGlvbiB3aXRob3V0IElPTU1VXG4iKTsKKwkJRFJNX0RFVl9FUlJPUihkZXYtPmRl diwgIk5vIG1lbW9yeSBwcm90ZWN0aW9uIHdpdGhvdXQgSU9NTVVcbiIpOwogCQlyZXQgPSAtRU5Y SU87CiAJCWdvdG8gZmFpbDsKIAl9CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbXNtL2Fk cmVuby9hNHh4X2dwdS5jIGIvZHJpdmVycy9ncHUvZHJtL21zbS9hZHJlbm8vYTR4eF9ncHUuYwpp bmRleCA3YzRlNmRjLi4xOGY5YThlIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vbXNtL2Fk cmVuby9hNHh4X2dwdS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9tc20vYWRyZW5vL2E0eHhfZ3B1 LmMKQEAgLTU2MSw3ICs1NjEsNyBAQCBzdHJ1Y3QgbXNtX2dwdSAqYTR4eF9ncHVfaW5pdChzdHJ1 Y3QgZHJtX2RldmljZSAqZGV2KQogCWludCByZXQ7CiAKIAlpZiAoIXBkZXYpIHsKLQkJZGV2X2Vy cihkZXYtPmRldiwgIm5vIGE0eHggZGV2aWNlXG4iKTsKKwkJRFJNX0RFVl9FUlJPUihkZXYtPmRl diwgIm5vIGE0eHggZGV2aWNlXG4iKTsKIAkJcmV0ID0gLUVOWElPOwogCQlnb3RvIGZhaWw7CiAJ fQpAQCAtNjA4LDcgKzYwOCw3IEBAIHN0cnVjdCBtc21fZ3B1ICphNHh4X2dwdV9pbml0KHN0cnVj dCBkcm1fZGV2aWNlICpkZXYpCiAJCSAqIHRvIG5vdCBiZSBwb3NzaWJsZSB0byByZXN0cmljdCBh Y2Nlc3MsIHRoZW4gd2UgbXVzdAogCQkgKiBpbXBsZW1lbnQgYSBjbWRzdHJlYW0gdmFsaWRhdG9y LgogCQkgKi8KLQkJZGV2X2VycihkZXYtPmRldiwgIk5vIG1lbW9yeSBwcm90ZWN0aW9uIHdpdGhv dXQgSU9NTVVcbiIpOworCQlEUk1fREVWX0VSUk9SKGRldi0+ZGV2LCAiTm8gbWVtb3J5IHByb3Rl Y3Rpb24gd2l0aG91dCBJT01NVVxuIik7CiAJCXJldCA9IC1FTlhJTzsKIAkJZ290byBmYWlsOwog CX0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9tc20vYWRyZW5vL2E1eHhfZGVidWdmcy5j IGIvZHJpdmVycy9ncHUvZHJtL21zbS9hZHJlbm8vYTV4eF9kZWJ1Z2ZzLmMKaW5kZXggZDIxMjdi MS4uNjk4M2NkOSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL21zbS9hZHJlbm8vYTV4eF9k ZWJ1Z2ZzLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL21zbS9hZHJlbm8vYTV4eF9kZWJ1Z2ZzLmMK QEAgLTE3Myw3ICsxNzMsNyBAQCBpbnQgYTV4eF9kZWJ1Z2ZzX2luaXQoc3RydWN0IG1zbV9ncHUg KmdwdSwgc3RydWN0IGRybV9taW5vciAqbWlub3IpCiAJCQltaW5vci0+ZGVidWdmc19yb290LCBt aW5vcik7CiAKIAlpZiAocmV0KSB7Ci0JCWRldl9lcnIoZGV2LT5kZXYsICJjb3VsZCBub3QgaW5z dGFsbCBhNXh4X2RlYnVnZnNfbGlzdFxuIik7CisJCURSTV9ERVZfRVJST1IoZGV2LT5kZXYsICJj b3VsZCBub3QgaW5zdGFsbCBhNXh4X2RlYnVnZnNfbGlzdFxuIik7CiAJCXJldHVybiByZXQ7CiAJ fQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbXNtL2FkcmVuby9hNXh4X2dwdS5jIGIv ZHJpdmVycy9ncHUvZHJtL21zbS9hZHJlbm8vYTV4eF9ncHUuYwppbmRleCBiNzUxYjc2Li5kMDdl Zjk5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vbXNtL2FkcmVuby9hNXh4X2dwdS5jCisr KyBiL2RyaXZlcnMvZ3B1L2RybS9tc20vYWRyZW5vL2E1eHhfZ3B1LmMKQEAgLTUxNCw3ICs1MTQs NyBAQCBzdGF0aWMgaW50IGE1eHhfdWNvZGVfaW5pdChzdHJ1Y3QgbXNtX2dwdSAqZ3B1KQogCQlp ZiAoSVNfRVJSKGE1eHhfZ3B1LT5wbTRfYm8pKSB7CiAJCQlyZXQgPSBQVFJfRVJSKGE1eHhfZ3B1 LT5wbTRfYm8pOwogCQkJYTV4eF9ncHUtPnBtNF9ibyA9IE5VTEw7Ci0JCQlkZXZfZXJyKGdwdS0+ ZGV2LT5kZXYsICJjb3VsZCBub3QgYWxsb2NhdGUgUE00OiAlZFxuIiwKKwkJCURSTV9ERVZfRVJS T1IoZ3B1LT5kZXYtPmRldiwgImNvdWxkIG5vdCBhbGxvY2F0ZSBQTTQ6ICVkXG4iLAogCQkJCXJl dCk7CiAJCQlyZXR1cm4gcmV0OwogCQl9CkBAIC01MjcsNyArNTI3LDcgQEAgc3RhdGljIGludCBh NXh4X3Vjb2RlX2luaXQoc3RydWN0IG1zbV9ncHUgKmdwdSkKIAkJaWYgKElTX0VSUihhNXh4X2dw dS0+cGZwX2JvKSkgewogCQkJcmV0ID0gUFRSX0VSUihhNXh4X2dwdS0+cGZwX2JvKTsKIAkJCWE1 eHhfZ3B1LT5wZnBfYm8gPSBOVUxMOwotCQkJZGV2X2VycihncHUtPmRldi0+ZGV2LCAiY291bGQg bm90IGFsbG9jYXRlIFBGUDogJWRcbiIsCisJCQlEUk1fREVWX0VSUk9SKGdwdS0+ZGV2LT5kZXYs ICJjb3VsZCBub3QgYWxsb2NhdGUgUEZQOiAlZFxuIiwKIAkJCQlyZXQpOwogCQkJcmV0dXJuIHJl dDsKIAkJfQpAQCAtMTAyOCw3ICsxMDI4LDcgQEAgc3RhdGljIHZvaWQgYTV4eF9mYXVsdF9kZXRl Y3RfaXJxKHN0cnVjdCBtc21fZ3B1ICpncHUpCiAJc3RydWN0IG1zbV9kcm1fcHJpdmF0ZSAqcHJp diA9IGRldi0+ZGV2X3ByaXZhdGU7CiAJc3RydWN0IG1zbV9yaW5nYnVmZmVyICpyaW5nID0gZ3B1 LT5mdW5jcy0+YWN0aXZlX3JpbmcoZ3B1KTsKIAotCWRldl9lcnIoZGV2LT5kZXYsICJncHUgZmF1 bHQgcmluZyAlZCBmZW5jZSAleCBzdGF0dXMgJTguOFggcmIgJTQuNHgvJTQuNHggaWIxICUxNi4x NmxsWC8lNC40eCBpYjIgJTE2LjE2bGxYLyU0LjR4XG4iLAorCURSTV9ERVZfRVJST1IoZGV2LT5k ZXYsICJncHUgZmF1bHQgcmluZyAlZCBmZW5jZSAleCBzdGF0dXMgJTguOFggcmIgJTQuNHgvJTQu NHggaWIxICUxNi4xNmxsWC8lNC40eCBpYjIgJTE2LjE2bGxYLyU0LjR4XG4iLAogCQlyaW5nID8g cmluZy0+aWQgOiAtMSwgcmluZyA/IHJpbmctPnNlcW5vIDogMCwKIAkJZ3B1X3JlYWQoZ3B1LCBS RUdfQTVYWF9SQkJNX1NUQVRVUyksCiAJCWdwdV9yZWFkKGdwdSwgUkVHX0E1WFhfQ1BfUkJfUlBU UiksCkBAIC0xMTM0LDcgKzExMzQsNyBAQCBzdGF0aWMgaXJxcmV0dXJuX3QgYTV4eF9pcnEoc3Ry dWN0IG1zbV9ncHUgKmdwdSkKIAogc3RhdGljIHZvaWQgYTV4eF9kdW1wKHN0cnVjdCBtc21fZ3B1 ICpncHUpCiB7Ci0JZGV2X2luZm8oZ3B1LT5kZXYtPmRldiwgInN0YXR1czogICAlMDh4XG4iLAor CURSTV9ERVZfSU5GTyhncHUtPmRldi0+ZGV2LCAic3RhdHVzOiAgICUwOHhcbiIsCiAJCWdwdV9y ZWFkKGdwdSwgUkVHX0E1WFhfUkJCTV9TVEFUVVMpKTsKIAlhZHJlbm9fZHVtcChncHUpOwogfQpA QCAtMTQ5NSw3ICsxNDk1LDcgQEAgc3RydWN0IG1zbV9ncHUgKmE1eHhfZ3B1X2luaXQoc3RydWN0 IGRybV9kZXZpY2UgKmRldikKIAlpbnQgcmV0OwogCiAJaWYgKCFwZGV2KSB7Ci0JCWRldl9lcnIo ZGV2LT5kZXYsICJObyBBNVhYIGRldmljZSBpcyBkZWZpbmVkXG4iKTsKKwkJRFJNX0RFVl9FUlJP UihkZXYtPmRldiwgIk5vIEE1WFggZGV2aWNlIGlzIGRlZmluZWRcbiIpOwogCQlyZXR1cm4gRVJS X1BUUigtRU5YSU8pOwogCX0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL21zbS9hZHJl bm8vYTV4eF9wcmVlbXB0LmMgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL2FkcmVuby9hNXh4X3ByZWVt cHQuYwppbmRleCBmM2MyMWY4Li4zMzE0MTEyIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0v bXNtL2FkcmVuby9hNXh4X3ByZWVtcHQuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL2FkcmVu by9hNXh4X3ByZWVtcHQuYwpAQCAtOTIsNyArOTIsNyBAQCBzdGF0aWMgdm9pZCBhNXh4X3ByZWVt cHRfdGltZXIoc3RydWN0IHRpbWVyX2xpc3QgKnQpCiAJaWYgKCF0cnlfcHJlZW1wdF9zdGF0ZShh NXh4X2dwdSwgUFJFRU1QVF9UUklHR0VSRUQsIFBSRUVNUFRfRkFVTFRFRCkpCiAJCXJldHVybjsK IAotCWRldl9lcnIoZGV2LT5kZXYsICIlczogcHJlZW1wdGlvbiB0aW1lZCBvdXRcbiIsIGdwdS0+ bmFtZSk7CisJRFJNX0RFVl9FUlJPUihkZXYtPmRldiwgIiVzOiBwcmVlbXB0aW9uIHRpbWVkIG91 dFxuIiwgZ3B1LT5uYW1lKTsKIAlxdWV1ZV93b3JrKHByaXYtPndxLCAmZ3B1LT5yZWNvdmVyX3dv cmspOwogfQogCkBAIC0xODgsNyArMTg4LDcgQEAgdm9pZCBhNXh4X3ByZWVtcHRfaXJxKHN0cnVj dCBtc21fZ3B1ICpncHUpCiAJc3RhdHVzID0gZ3B1X3JlYWQoZ3B1LCBSRUdfQTVYWF9DUF9DT05U RVhUX1NXSVRDSF9DTlRMKTsKIAlpZiAodW5saWtlbHkoc3RhdHVzKSkgewogCQlzZXRfcHJlZW1w dF9zdGF0ZShhNXh4X2dwdSwgUFJFRU1QVF9GQVVMVEVEKTsKLQkJZGV2X2VycihkZXYtPmRldiwg IiVzOiBQcmVlbXB0aW9uIGZhaWxlZCB0byBjb21wbGV0ZVxuIiwKKwkJRFJNX0RFVl9FUlJPUihk ZXYtPmRldiwgIiVzOiBQcmVlbXB0aW9uIGZhaWxlZCB0byBjb21wbGV0ZVxuIiwKIAkJCWdwdS0+ bmFtZSk7CiAJCXF1ZXVlX3dvcmsocHJpdi0+d3EsICZncHUtPnJlY292ZXJfd29yayk7CiAJCXJl dHVybjsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9tc20vYWRyZW5vL2E2eHhfZ211LmMg Yi9kcml2ZXJzL2dwdS9kcm0vbXNtL2FkcmVuby9hNnh4X2dtdS5jCmluZGV4IGJiYjgxMjYuLmQx ZTIzZjkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9tc20vYWRyZW5vL2E2eHhfZ211LmMK KysrIGIvZHJpdmVycy9ncHUvZHJtL21zbS9hZHJlbm8vYTZ4eF9nbXUuYwpAQCAtMTI1LDcgKzEy NSw3IEBAIHN0YXRpYyBpbnQgYTZ4eF9nbXVfc3RhcnQoc3RydWN0IGE2eHhfZ211ICpnbXUpCiAJ CXZhbCA9PSAweGJhYmVmYWNlLCAxMDAsIDEwMDAwKTsKIAogCWlmIChyZXQpCi0JCWRldl9lcnIo Z211LT5kZXYsICJHTVUgZmlybXdhcmUgaW5pdGlhbGl6YXRpb24gdGltZWQgb3V0XG4iKTsKKwkJ RFJNX0RFVl9FUlJPUihnbXUtPmRldiwgIkdNVSBmaXJtd2FyZSBpbml0aWFsaXphdGlvbiB0aW1l ZCBvdXRcbiIpOwogCiAJcmV0dXJuIHJldDsKIH0KQEAgLTE0Myw3ICsxNDMsNyBAQCBzdGF0aWMg aW50IGE2eHhfZ211X2hmaV9zdGFydChzdHJ1Y3QgYTZ4eF9nbXUgKmdtdSkKIAlyZXQgPSBnbXVf cG9sbF90aW1lb3V0KGdtdSwgUkVHX0E2WFhfR01VX0hGSV9DVFJMX1NUQVRVUywgdmFsLAogCQl2 YWwgJiAxLCAxMDAsIDEwMDAwKTsKIAlpZiAocmV0KQotCQlkZXZfZXJyKGdtdS0+ZGV2LCAiVW5h YmxlIHRvIHN0YXJ0IHRoZSBIRkkgcXVldWVzXG4iKTsKKwkJRFJNX0RFVl9FUlJPUihnbXUtPmRl diwgIlVuYWJsZSB0byBzdGFydCB0aGUgSEZJIHF1ZXVlc1xuIik7CiAKIAlyZXR1cm4gcmV0Owog fQpAQCAtMTg0LDcgKzE4NCw3IEBAIGludCBhNnh4X2dtdV9zZXRfb29iKHN0cnVjdCBhNnh4X2dt dSAqZ211LCBlbnVtIGE2eHhfZ211X29vYl9zdGF0ZSBzdGF0ZSkKIAkJdmFsICYgKDEgPDwgYWNr KSwgMTAwLCAxMDAwMCk7CiAKIAlpZiAocmV0KQotCQlkZXZfZXJyKGdtdS0+ZGV2LAorCQlEUk1f REVWX0VSUk9SKGdtdS0+ZGV2LAogCQkJIlRpbWVvdXQgd2FpdGluZyBmb3IgR01VIE9PQiBzZXQg JXM6IDB4JXhcbiIsCiAJCQkJbmFtZSwKIAkJCQlnbXVfcmVhZChnbXUsIFJFR19BNlhYX0dNVV9H TVUySE9TVF9JTlRSX0lORk8pKTsKQEAgLTIyNiw3ICsyMjYsNyBAQCBzdGF0aWMgaW50IGE2eHhf c3B0cHJhY19lbmFibGUoc3RydWN0IGE2eHhfZ211ICpnbXUpCiAJCSh2YWwgJiAweDM4KSA9PSAw eDI4LCAxLCAxMDApOwogCiAJaWYgKHJldCkgewotCQlkZXZfZXJyKGdtdS0+ZGV2LCAiVW5hYmxl IHRvIHBvd2VyIG9uIFNQVFBSQUM6IDB4JXhcbiIsCisJCURSTV9ERVZfRVJST1IoZ211LT5kZXYs ICJVbmFibGUgdG8gcG93ZXIgb24gU1BUUFJBQzogMHgleFxuIiwKIAkJCWdtdV9yZWFkKGdtdSwg UkVHX0E2WFhfR01VX1NQVFBSQUNfUFdSX0NMS19TVEFUVVMpKTsKIAl9CiAKQEAgLTI0OCw3ICsy NDgsNyBAQCBzdGF0aWMgdm9pZCBhNnh4X3NwdHByYWNfZGlzYWJsZShzdHJ1Y3QgYTZ4eF9nbXUg KmdtdSkKIAkJKHZhbCAmIDB4MDQpLCAxMDAsIDEwMDAwKTsKIAogCWlmIChyZXQpCi0JCWRldl9l cnIoZ211LT5kZXYsICJmYWlsZWQgdG8gcG93ZXIgb2ZmIFNQVFBSQUM6IDB4JXhcbiIsCisJCURS TV9ERVZfRVJST1IoZ211LT5kZXYsICJmYWlsZWQgdG8gcG93ZXIgb2ZmIFNQVFBSQUM6IDB4JXhc biIsCiAJCQlnbXVfcmVhZChnbXUsIFJFR19BNlhYX0dNVV9TUFRQUkFDX1BXUl9DTEtfU1RBVFVT KSk7CiB9CiAKQEAgLTI5Miw3ICsyOTIsNyBAQCBzdGF0aWMgaW50IGE2eHhfZ211X25vdGlmeV9z bHVtYmVyKHN0cnVjdCBhNnh4X2dtdSAqZ211KQogCQkvKiBDaGVjayB0byBzZWUgaWYgdGhlIEdN VSByZWFsbHkgZGlkIHNsdW1iZXIgKi8KIAkJaWYgKGdtdV9yZWFkKGdtdSwgUkVHX0E2WFhfR1BV X0dNVV9DWF9HTVVfUlBNSF9QT1dFUl9TVEFURSkKIAkJCSE9IDB4MGYpIHsKLQkJCWRldl9lcnIo Z211LT5kZXYsICJUaGUgR01VIGRpZCBub3QgZ28gaW50byBzbHVtYmVyXG4iKTsKKwkJCURSTV9E RVZfRVJST1IoZ211LT5kZXYsICJUaGUgR01VIGRpZCBub3QgZ28gaW50byBzbHVtYmVyXG4iKTsK IAkJCXJldCA9IC1FVElNRURPVVQ7CiAJCX0KIAl9CkBAIC0zMTQsNyArMzE0LDcgQEAgc3RhdGlj IGludCBhNnh4X3JwbWhfc3RhcnQoc3RydWN0IGE2eHhfZ211ICpnbXUpCiAJcmV0ID0gZ211X3Bv bGxfdGltZW91dChnbXUsIFJFR19BNlhYX0dNVV9SU0NDX0NPTlRST0xfQUNLLCB2YWwsCiAJCXZh bCAmICgxIDw8IDEpLCAxMDAsIDEwMDAwKTsKIAlpZiAocmV0KSB7Ci0JCWRldl9lcnIoZ211LT5k ZXYsICJVbmFibGUgdG8gcG93ZXIgb24gdGhlIEdQVSBSU0NcbiIpOworCQlEUk1fREVWX0VSUk9S KGdtdS0+ZGV2LCAiVW5hYmxlIHRvIHBvd2VyIG9uIHRoZSBHUFUgUlNDXG4iKTsKIAkJcmV0dXJu IHJldDsKIAl9CiAKQEAgLTMyOSw3ICszMjksNyBAQCBzdGF0aWMgaW50IGE2eHhfcnBtaF9zdGFy dChzdHJ1Y3QgYTZ4eF9nbXUgKmdtdSkKIAkJcmV0dXJuIDA7CiAJfQogCi0JZGV2X2VycihnbXUt PmRldiwgIkdQVSBSU0Mgc2VxdWVuY2Ugc3R1Y2sgd2hpbGUgd2FraW5nIHVwIHRoZSBHUFVcbiIp OworCURSTV9ERVZfRVJST1IoZ211LT5kZXYsICJHUFUgUlNDIHNlcXVlbmNlIHN0dWNrIHdoaWxl IHdha2luZyB1cCB0aGUgR1BVXG4iKTsKIAlyZXR1cm4gcmV0OwogfQogCkBAIC0zNDMsNyArMzQz LDcgQEAgc3RhdGljIHZvaWQgYTZ4eF9ycG1oX3N0b3Aoc3RydWN0IGE2eHhfZ211ICpnbXUpCiAJ cmV0ID0gZ211X3BvbGxfdGltZW91dChnbXUsIFJFR19BNlhYX0dQVV9SU0NDX1JTQ19TVEFUVVMw X0RSVjAsCiAJCXZhbCwgdmFsICYgKDEgPDwgMTYpLCAxMDAsIDEwMDAwKTsKIAlpZiAocmV0KQot CQlkZXZfZXJyKGdtdS0+ZGV2LCAiVW5hYmxlIHRvIHBvd2VyIG9mZiB0aGUgR1BVIFJTQ1xuIik7 CisJCURSTV9ERVZfRVJST1IoZ211LT5kZXYsICJVbmFibGUgdG8gcG93ZXIgb2ZmIHRoZSBHUFUg UlNDXG4iKTsKIAogCWdtdV93cml0ZShnbXUsIFJFR19BNlhYX0dNVV9SU0NDX0NPTlRST0xfUkVR LCAwKTsKIH0KQEAgLTQ3Niw3ICs0NzYsNyBAQCBzdGF0aWMgaW50IGE2eHhfZ211X2Z3X3N0YXJ0 KHN0cnVjdCBhNnh4X2dtdSAqZ211LCB1bnNpZ25lZCBpbnQgc3RhdGUpCiAKIAkJLyogU2FuaXR5 IGNoZWNrIHRoZSBzaXplIG9mIHRoZSBmaXJtd2FyZSB0aGF0IHdhcyBsb2FkZWQgKi8KIAkJaWYg KGFkcmVub19ncHUtPmZ3W0FEUkVOT19GV19HTVVdLT5zaXplID4gMHg4MDAwKSB7Ci0JCQlkZXZf ZXJyKGdtdS0+ZGV2LAorCQkJRFJNX0RFVl9FUlJPUihnbXUtPmRldiwKIAkJCQkiR01VIGZpcm13 YXJlIGlzIGJpZ2dlciB0aGFuIHRoZSBhdmFpbGFibGUgcmVnaW9uXG4iKTsKIAkJCXJldHVybiAt RUlOVkFMOwogCQl9CkBAIC03MjEsNyArNzIxLDcgQEAgaW50IGE2eHhfZ211X3N0b3Aoc3RydWN0 IGE2eHhfZ3B1ICphNnh4X2dwdSkKIAkJICovCiAKIAkJaWYgKHJldCkKLQkJCWRldl9lcnIoZ211 LT5kZXYsCisJCQlEUk1fREVWX0VSUk9SKGdtdS0+ZGV2LAogCQkJCSJVbmFibGUgdG8gc2x1bWJl ciBHTVU6IHN0YXR1cyA9IDAleC8wJXhcbiIsCiAJCQkJZ211X3JlYWQoZ211LAogCQkJCQlSRUdf QTZYWF9HUFVfR01VX0FPX0dQVV9DWF9CVVNZX1NUQVRVUyksCkBAIC04MDAsNyArODAwLDcgQEAg c3RhdGljIHN0cnVjdCBhNnh4X2dtdV9ibyAqYTZ4eF9nbXVfbWVtb3J5X2FsbG9jKHN0cnVjdCBh Nnh4X2dtdSAqZ211LAogCQkJSU9NTVVfUkVBRCB8IElPTU1VX1dSSVRFKTsKIAogCQlpZiAocmV0 KSB7Ci0JCQlkZXZfZXJyKGdtdS0+ZGV2LCAiVW5hYmxlIHRvIG1hcCBHTVUgYnVmZmVyIG9iamVj dFxuIik7CisJCQlEUk1fREVWX0VSUk9SKGdtdS0+ZGV2LCAiVW5hYmxlIHRvIG1hcCBHTVUgYnVm ZmVyIG9iamVjdFxuIik7CiAKIAkJCWZvciAoaSA9IGkgLSAxIDsgaSA+PSAwOyBpLS0pCiAJCQkJ aW9tbXVfdW5tYXAoZ211LT5kb21haW4sCkBAIC05MjYsMTIgKzkyNiwxMiBAQCBzdGF0aWMgaW50 IGE2eHhfZ211X3JwbWhfYXJjX3ZvdGVzX2luaXQoc3RydWN0IGRldmljZSAqZGV2LCB1MzIgKnZv dGVzLAogCQl9CiAKIAkJaWYgKGogPT0gcHJpX2NvdW50KSB7Ci0JCQlkZXZfZXJyKGRldiwKKwkJ CURSTV9ERVZfRVJST1IoZGV2LAogCQkJCSJMZXZlbCAldSBub3QgZm91bmQgaW4gaW4gdGhlIFJQ TWggbGlzdFxuIiwKIAkJCQkJbGV2ZWwpOwotCQkJZGV2X2VycihkZXYsICJBdmFpbGFibGUgbGV2 ZWxzOlxuIik7CisJCQlEUk1fREVWX0VSUk9SKGRldiwgIkF2YWlsYWJsZSBsZXZlbHM6XG4iKTsK IAkJCWZvciAoaiA9IDA7IGogPCBwcmlfY291bnQ7IGorKykKLQkJCQlkZXZfZXJyKGRldiwgIiAg JXVcbiIsIHByaVtqXSk7CisJCQkJRFJNX0RFVl9FUlJPUihkZXYsICIgICV1XG4iLCBwcmlbal0p OwogCiAJCQlyZXR1cm4gLUVJTlZBTDsKIAkJfQpAQCAtMTAzOCw3ICsxMDM4LDcgQEAgc3RhdGlj IGludCBhNnh4X2dtdV9wd3JsZXZlbHNfcHJvYmUoc3RydWN0IGE2eHhfZ211ICpnbXUpCiAJICov CiAJcmV0ID0gZGV2X3BtX29wcF9vZl9hZGRfdGFibGUoZ211LT5kZXYpOwogCWlmIChyZXQpIHsK LQkJZGV2X2VycihnbXUtPmRldiwgIlVuYWJsZSB0byBzZXQgdGhlIE9QUCB0YWJsZSBmb3IgdGhl IEdNVVxuIik7CisJCURSTV9ERVZfRVJST1IoZ211LT5kZXYsICJVbmFibGUgdG8gc2V0IHRoZSBP UFAgdGFibGUgZm9yIHRoZSBHTVVcbiIpOwogCQlyZXR1cm4gcmV0OwogCX0KIApAQCAtMTA3OSwx MyArMTA3OSwxMyBAQCBzdGF0aWMgdm9pZCBfX2lvbWVtICphNnh4X2dtdV9nZXRfbW1pbyhzdHJ1 Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2LAogCQkJSU9SRVNPVVJDRV9NRU0sIG5hbWUpOwogCiAJ aWYgKCFyZXMpIHsKLQkJZGV2X2VycigmcGRldi0+ZGV2LCAiVW5hYmxlIHRvIGZpbmQgdGhlICVz IHJlZ2lzdGVyc1xuIiwgbmFtZSk7CisJCURSTV9ERVZfRVJST1IoJnBkZXYtPmRldiwgIlVuYWJs ZSB0byBmaW5kIHRoZSAlcyByZWdpc3RlcnNcbiIsIG5hbWUpOwogCQlyZXR1cm4gRVJSX1BUUigt RUlOVkFMKTsKIAl9CiAKIAlyZXQgPSBkZXZtX2lvcmVtYXAoJnBkZXYtPmRldiwgcmVzLT5zdGFy dCwgcmVzb3VyY2Vfc2l6ZShyZXMpKTsKIAlpZiAoIXJldCkgewotCQlkZXZfZXJyKCZwZGV2LT5k ZXYsICJVbmFibGUgdG8gbWFwIHRoZSAlcyByZWdpc3RlcnNcbiIsIG5hbWUpOworCQlEUk1fREVW X0VSUk9SKCZwZGV2LT5kZXYsICJVbmFibGUgdG8gbWFwIHRoZSAlcyByZWdpc3RlcnNcbiIsIG5h bWUpOwogCQlyZXR1cm4gRVJSX1BUUigtRUlOVkFMKTsKIAl9CiAKQEAgLTExMDIsNyArMTEwMiw3 IEBAIHN0YXRpYyBpbnQgYTZ4eF9nbXVfZ2V0X2lycShzdHJ1Y3QgYTZ4eF9nbXUgKmdtdSwgc3Ry dWN0IHBsYXRmb3JtX2RldmljZSAqcGRldiwKIAlyZXQgPSBkZXZtX3JlcXVlc3RfaXJxKCZwZGV2 LT5kZXYsIGlycSwgaGFuZGxlciwgSVJRRl9UUklHR0VSX0hJR0gsCiAJCW5hbWUsIGdtdSk7CiAJ aWYgKHJldCkgewotCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJVbmFibGUgdG8gZ2V0IGludGVycnVw dCAlc1xuIiwgbmFtZSk7CisJCURSTV9ERVZfRVJST1IoJnBkZXYtPmRldiwgIlVuYWJsZSB0byBn ZXQgaW50ZXJydXB0ICVzXG4iLCBuYW1lKTsKIAkJcmV0dXJuIHJldDsKIAl9CiAKZGlmZiAtLWdp dCBhL2RyaXZlcnMvZ3B1L2RybS9tc20vYWRyZW5vL2E2eHhfZ3B1LmMgYi9kcml2ZXJzL2dwdS9k cm0vbXNtL2FkcmVuby9hNnh4X2dwdS5jCmluZGV4IDUzYjkwNjEuLjcwZGU3ODYgMTAwNjQ0Ci0t LSBhL2RyaXZlcnMvZ3B1L2RybS9tc20vYWRyZW5vL2E2eHhfZ3B1LmMKKysrIGIvZHJpdmVycy9n cHUvZHJtL21zbS9hZHJlbm8vYTZ4eF9ncHUuYwpAQCAtNDgxLDcgKzQ4MSw3IEBAIHN0YXRpYyBp bnQgYTZ4eF9od19pbml0KHN0cnVjdCBtc21fZ3B1ICpncHUpCiAKIHN0YXRpYyB2b2lkIGE2eHhf ZHVtcChzdHJ1Y3QgbXNtX2dwdSAqZ3B1KQogewotCWRldl9pbmZvKCZncHUtPnBkZXYtPmRldiwg InN0YXR1czogICAlMDh4XG4iLAorCURSTV9ERVZfSU5GTygmZ3B1LT5wZGV2LT5kZXYsICJzdGF0 dXM6ICAgJTA4eFxuIiwKIAkJCWdwdV9yZWFkKGdwdSwgUkVHX0E2WFhfUkJCTV9TVEFUVVMpKTsK IAlhZHJlbm9fZHVtcChncHUpOwogfQpAQCAtNDk4LDcgKzQ5OCw3IEBAIHN0YXRpYyB2b2lkIGE2 eHhfcmVjb3ZlcihzdHJ1Y3QgbXNtX2dwdSAqZ3B1KQogCWFkcmVub19kdW1wX2luZm8oZ3B1KTsK IAogCWZvciAoaSA9IDA7IGkgPCA4OyBpKyspCi0JCWRldl9pbmZvKCZncHUtPnBkZXYtPmRldiwg IkNQX1NDUkFUQ0hfUkVHJWQ6ICV1XG4iLCBpLAorCQlEUk1fREVWX0lORk8oJmdwdS0+cGRldi0+ ZGV2LCAiQ1BfU0NSQVRDSF9SRUclZDogJXVcbiIsIGksCiAJCQlncHVfcmVhZChncHUsIFJFR19B NlhYX0NQX1NDUkFUQ0hfUkVHKGkpKSk7CiAKIAlpZiAoaGFuZ19kZWJ1ZykKZGlmZiAtLWdpdCBh L2RyaXZlcnMvZ3B1L2RybS9tc20vYWRyZW5vL2E2eHhfaGZpLmMgYi9kcml2ZXJzL2dwdS9kcm0v bXNtL2FkcmVuby9hNnh4X2hmaS5jCmluZGV4IGYxOWVmNGMuLjU4NThlNzkgMTAwNjQ0Ci0tLSBh L2RyaXZlcnMvZ3B1L2RybS9tc20vYWRyZW5vL2E2eHhfaGZpLmMKKysrIGIvZHJpdmVycy9ncHUv ZHJtL21zbS9hZHJlbm8vYTZ4eF9oZmkuYwpAQCAtMTIwLDcgKzEyMCw3IEBAIHN0YXRpYyB2b2lk IGE2eHhfaGZpX2hhbmRsZV9hY2soc3RydWN0IGE2eHhfZ211ICpnbXUsCiAJfQogCXNwaW5fdW5s b2NrKCZoZmlfYWNrX2xvY2spOwogCi0JZGV2X2VycihnbXUtPmRldiwgIk5vYm9keSB3YXMgd2Fp dGluZyBmb3IgSEZJIG1lc3NhZ2UgJWRcbiIsIHNlcW51bSk7CisJRFJNX0RFVl9FUlJPUihnbXUt PmRldiwgIk5vYm9keSB3YXMgd2FpdGluZyBmb3IgSEZJIG1lc3NhZ2UgJWRcbiIsIHNlcW51bSk7 CiB9CiAKIHN0YXRpYyB2b2lkIGE2eHhfaGZpX2hhbmRsZV9lcnJvcihzdHJ1Y3QgYTZ4eF9nbXUg KmdtdSwKQEAgLTEyOCw3ICsxMjgsNyBAQCBzdGF0aWMgdm9pZCBhNnh4X2hmaV9oYW5kbGVfZXJy b3Ioc3RydWN0IGE2eHhfZ211ICpnbXUsCiB7CiAJc3RydWN0IGE2eHhfaGZpX21zZ19lcnJvciAq ZXJyb3IgPSAoc3RydWN0IGE2eHhfaGZpX21zZ19lcnJvciAqKSBtc2c7CiAKLQlkZXZfZXJyKGdt dS0+ZGV2LCAiR01VIGZpcm13YXJlIGVycm9yICVkXG4iLCBlcnJvci0+Y29kZSk7CisJRFJNX0RF Vl9FUlJPUihnbXUtPmRldiwgIkdNVSBmaXJtd2FyZSBlcnJvciAlZFxuIiwgZXJyb3ItPmNvZGUp OwogfQogCiB2b2lkIGE2eHhfaGZpX3Rhc2sodW5zaWduZWQgbG9uZyBkYXRhKQpAQCAtMTQ1LDcg KzE0NSw3IEBAIHZvaWQgYTZ4eF9oZmlfdGFzayh1bnNpZ25lZCBsb25nIGRhdGEpCiAJCS8qIFJl dHVybnMgdGhlIG51bWJlciBvZiBieXRlcyBjb3BpZWQgb3IgbmVnYXRpdmUgb24gZXJyb3IgKi8K IAkJaWYgKHJldCA8PSAwKSB7CiAJCQlpZiAocmV0IDwgMCkKLQkJCQlkZXZfZXJyKGdtdS0+ZGV2 LAorCQkJCURSTV9ERVZfRVJST1IoZ211LT5kZXYsCiAJCQkJCSJVbmFibGUgdG8gcmVhZCB0aGUg SEZJIG1lc3NhZ2UgcXVldWVcbiIpOwogCQkJYnJlYWs7CiAJCX0KQEAgLTE4Myw3ICsxODMsNyBA QCBzdGF0aWMgaW50IGE2eHhfaGZpX3NlbmRfbXNnKHN0cnVjdCBhNnh4X2dtdSAqZ211LCBpbnQg aWQsCiAKIAlyZXQgPSBhNnh4X2hmaV9xdWV1ZV93cml0ZShnbXUsIHF1ZXVlLCBkYXRhLCBkd29y ZHMpOwogCWlmIChyZXQpIHsKLQkJZGV2X2VycihnbXUtPmRldiwgIlVuYWJsZSB0byBzZW5kIG1l c3NhZ2UgJXMgaWQgJWRcbiIsCisJCURSTV9ERVZfRVJST1IoZ211LT5kZXYsICJVbmFibGUgdG8g c2VuZCBtZXNzYWdlICVzIGlkICVkXG4iLAogCQkJYTZ4eF9oZmlfbXNnX2lkW2lkXSwgc2VxbnVt KTsKIAkJZ290byBvdXQ7CiAJfQpAQCAtMTkyLDcgKzE5Miw3IEBAIHN0YXRpYyBpbnQgYTZ4eF9o Zmlfc2VuZF9tc2coc3RydWN0IGE2eHhfZ211ICpnbXUsIGludCBpZCwKIAlyZXQgPSB3YWl0X2Zv cl9jb21wbGV0aW9uX3RpbWVvdXQoJnJlc3AuY29tcGxldGUsCiAJCW1zZWNzX3RvX2ppZmZpZXMo NTAwMCkpOwogCWlmICghcmV0KSB7Ci0JCWRldl9lcnIoZ211LT5kZXYsCisJCURSTV9ERVZfRVJS T1IoZ211LT5kZXYsCiAJCQkiTWVzc2FnZSAlcyBpZCAlZCB0aW1lZCBvdXQgd2FpdGluZyBmb3Ig cmVzcG9uc2VcbiIsCiAJCQlhNnh4X2hmaV9tc2dfaWRbaWRdLCBzZXFudW0pOwogCQlyZXQgPSAt RVRJTUVET1VUOwpAQCAtMjA4LDcgKzIwOCw3IEBAIHN0YXRpYyBpbnQgYTZ4eF9oZmlfc2VuZF9t c2coc3RydWN0IGE2eHhfZ211ICpnbXUsIGludCBpZCwKIAkJcmV0dXJuIHJldDsKIAogCWlmIChy ZXNwLmVycm9yKSB7Ci0JCWRldl9lcnIoZ211LT5kZXYsICJNZXNzYWdlICVzIGlkICVkIHJldHVy bmVkIGVycm9yICVkXG4iLAorCQlEUk1fREVWX0VSUk9SKGdtdS0+ZGV2LCAiTWVzc2FnZSAlcyBp ZCAlZCByZXR1cm5lZCBlcnJvciAlZFxuIiwKIAkJCWE2eHhfaGZpX21zZ19pZFtpZF0sIHNlcW51 bSwgcmVzcC5lcnJvcik7CiAJCXJldHVybiAtRUlOVkFMOwogCX0KQEAgLTM2OCw3ICszNjgsNyBA QCB2b2lkIGE2eHhfaGZpX3N0b3Aoc3RydWN0IGE2eHhfZ211ICpnbXUpCiAJCQljb250aW51ZTsK IAogCQlpZiAocXVldWUtPmhlYWRlci0+cmVhZF9pbmRleCAhPSBxdWV1ZS0+aGVhZGVyLT53cml0 ZV9pbmRleCkKLQkJCWRldl9lcnIoZ211LT5kZXYsICJIRkkgcXVldWUgJWQgaXMgbm90IGVtcHR5 XG4iLCBpKTsKKwkJCURSTV9ERVZfRVJST1IoZ211LT5kZXYsICJIRkkgcXVldWUgJWQgaXMgbm90 IGVtcHR5XG4iLCBpKTsKIAogCQlxdWV1ZS0+aGVhZGVyLT5yZWFkX2luZGV4ID0gMDsKIAkJcXVl dWUtPmhlYWRlci0+d3JpdGVfaW5kZXggPSAwOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJt L21zbS9hZHJlbm8vYWRyZW5vX2RldmljZS5jIGIvZHJpdmVycy9ncHUvZHJtL21zbS9hZHJlbm8v YWRyZW5vX2RldmljZS5jCmluZGV4IDdkM2U5YTEuLjc4YmZhMTEgMTAwNjQ0Ci0tLSBhL2RyaXZl cnMvZ3B1L2RybS9tc20vYWRyZW5vL2FkcmVub19kZXZpY2UuYworKysgYi9kcml2ZXJzL2dwdS9k cm0vbXNtL2FkcmVuby9hZHJlbm9fZGV2aWNlLmMKQEAgLTE5NSw3ICsxOTUsNyBAQCBzdHJ1Y3Qg bXNtX2dwdSAqYWRyZW5vX2xvYWRfZ3B1KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYpCiAKIAlyZXQg PSBwbV9ydW50aW1lX2dldF9zeW5jKCZwZGV2LT5kZXYpOwogCWlmIChyZXQgPCAwKSB7Ci0JCWRl dl9lcnIoZGV2LT5kZXYsICJDb3VsZG4ndCBwb3dlciB1cCB0aGUgR1BVOiAlZFxuIiwgcmV0KTsK KwkJRFJNX0RFVl9FUlJPUihkZXYtPmRldiwgIkNvdWxkbid0IHBvd2VyIHVwIHRoZSBHUFU6ICVk XG4iLCByZXQpOwogCQlyZXR1cm4gTlVMTDsKIAl9CiAKQEAgLTIwNCw3ICsyMDQsNyBAQCBzdHJ1 Y3QgbXNtX2dwdSAqYWRyZW5vX2xvYWRfZ3B1KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYpCiAJbXV0 ZXhfdW5sb2NrKCZkZXYtPnN0cnVjdF9tdXRleCk7CiAJcG1fcnVudGltZV9wdXRfYXV0b3N1c3Bl bmQoJnBkZXYtPmRldik7CiAJaWYgKHJldCkgewotCQlkZXZfZXJyKGRldi0+ZGV2LCAiZ3B1IGh3 IGluaXQgZmFpbGVkOiAlZFxuIiwgcmV0KTsKKwkJRFJNX0RFVl9FUlJPUihkZXYtPmRldiwgImdw dSBodyBpbml0IGZhaWxlZDogJWRcbiIsIHJldCk7CiAJCXJldHVybiBOVUxMOwogCX0KIApAQCAt MjUyLDcgKzI1Miw3IEBAIHN0YXRpYyBpbnQgZmluZF9jaGlwaWQoc3RydWN0IGRldmljZSAqZGV2 LCBzdHJ1Y3QgYWRyZW5vX3JldiAqcmV2KQogCS8qIGFuZCBpZiB0aGF0IGZhaWxzLCBmYWxsIGJh Y2sgdG8gbGVnYWN5ICJxY29tLGNoaXBpZCIgcHJvcGVydHk6ICovCiAJcmV0ID0gb2ZfcHJvcGVy dHlfcmVhZF91MzIobm9kZSwgInFjb20sY2hpcGlkIiwgJmNoaXBpZCk7CiAJaWYgKHJldCkgewot CQlkZXZfZXJyKGRldiwgImNvdWxkIG5vdCBwYXJzZSBxY29tLGNoaXBpZDogJWRcbiIsIHJldCk7 CisJCURSTV9ERVZfRVJST1IoZGV2LCAiY291bGQgbm90IHBhcnNlIHFjb20sY2hpcGlkOiAlZFxu IiwgcmV0KTsKIAkJcmV0dXJuIHJldDsKIAl9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2Ry bS9tc20vYWRyZW5vL2FkcmVub19ncHUuYyBiL2RyaXZlcnMvZ3B1L2RybS9tc20vYWRyZW5vL2Fk cmVub19ncHUuYwppbmRleCBkYTEzNjNhLi4xNDEwNjJmIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dw dS9kcm0vbXNtL2FkcmVuby9hZHJlbm9fZ3B1LmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL21zbS9h ZHJlbm8vYWRyZW5vX2dwdS5jCkBAIC04OSwxMiArODksMTIgQEAgaW50IGFkcmVub19nZXRfcGFy YW0oc3RydWN0IG1zbV9ncHUgKmdwdSwgdWludDMyX3QgcGFyYW0sIHVpbnQ2NF90ICp2YWx1ZSkK IAogCQlyZXQgPSByZXF1ZXN0X2Zpcm13YXJlX2RpcmVjdCgmZncsIG5ld25hbWUsIGRybS0+ZGV2 KTsKIAkJaWYgKCFyZXQpIHsKLQkJCWRldl9pbmZvKGRybS0+ZGV2LCAibG9hZGVkICVzIGZyb20g bmV3IGxvY2F0aW9uXG4iLAorCQkJRFJNX0RFVl9JTkZPKGRybS0+ZGV2LCAibG9hZGVkICVzIGZy b20gbmV3IGxvY2F0aW9uXG4iLAogCQkJCW5ld25hbWUpOwogCQkJYWRyZW5vX2dwdS0+Zndsb2Mg PSBGV19MT0NBVElPTl9ORVc7CiAJCQlnb3RvIG91dDsKIAkJfSBlbHNlIGlmIChhZHJlbm9fZ3B1 LT5md2xvYyAhPSBGV19MT0NBVElPTl9VTktOT1dOKSB7Ci0JCQlkZXZfZXJyKGRybS0+ZGV2LCAi ZmFpbGVkIHRvIGxvYWQgJXM6ICVkXG4iLAorCQkJRFJNX0RFVl9FUlJPUihkcm0tPmRldiwgImZh aWxlZCB0byBsb2FkICVzOiAlZFxuIiwKIAkJCQluZXduYW1lLCByZXQpOwogCQkJZncgPSBFUlJf UFRSKHJldCk7CiAJCQlnb3RvIG91dDsKQEAgLTEwOSwxMiArMTA5LDEyIEBAIGludCBhZHJlbm9f Z2V0X3BhcmFtKHN0cnVjdCBtc21fZ3B1ICpncHUsIHVpbnQzMl90IHBhcmFtLCB1aW50NjRfdCAq dmFsdWUpCiAKIAkJcmV0ID0gcmVxdWVzdF9maXJtd2FyZV9kaXJlY3QoJmZ3LCBmd25hbWUsIGRy bS0+ZGV2KTsKIAkJaWYgKCFyZXQpIHsKLQkJCWRldl9pbmZvKGRybS0+ZGV2LCAibG9hZGVkICVz IGZyb20gbGVnYWN5IGxvY2F0aW9uXG4iLAorCQkJRFJNX0RFVl9JTkZPKGRybS0+ZGV2LCAibG9h ZGVkICVzIGZyb20gbGVnYWN5IGxvY2F0aW9uXG4iLAogCQkJCW5ld25hbWUpOwogCQkJYWRyZW5v X2dwdS0+Zndsb2MgPSBGV19MT0NBVElPTl9MRUdBQ1k7CiAJCQlnb3RvIG91dDsKIAkJfSBlbHNl IGlmIChhZHJlbm9fZ3B1LT5md2xvYyAhPSBGV19MT0NBVElPTl9VTktOT1dOKSB7Ci0JCQlkZXZf ZXJyKGRybS0+ZGV2LCAiZmFpbGVkIHRvIGxvYWQgJXM6ICVkXG4iLAorCQkJRFJNX0RFVl9FUlJP Uihkcm0tPmRldiwgImZhaWxlZCB0byBsb2FkICVzOiAlZFxuIiwKIAkJCQlmd25hbWUsIHJldCk7 CiAJCQlmdyA9IEVSUl9QVFIocmV0KTsKIAkJCWdvdG8gb3V0OwpAQCAtMTMwLDE5ICsxMzAsMTkg QEAgaW50IGFkcmVub19nZXRfcGFyYW0oc3RydWN0IG1zbV9ncHUgKmdwdSwgdWludDMyX3QgcGFy YW0sIHVpbnQ2NF90ICp2YWx1ZSkKIAogCQlyZXQgPSByZXF1ZXN0X2Zpcm13YXJlKCZmdywgbmV3 bmFtZSwgZHJtLT5kZXYpOwogCQlpZiAoIXJldCkgewotCQkJZGV2X2luZm8oZHJtLT5kZXYsICJs b2FkZWQgJXMgd2l0aCBoZWxwZXJcbiIsCisJCQlEUk1fREVWX0lORk8oZHJtLT5kZXYsICJsb2Fk ZWQgJXMgd2l0aCBoZWxwZXJcbiIsCiAJCQkJbmV3bmFtZSk7CiAJCQlhZHJlbm9fZ3B1LT5md2xv YyA9IEZXX0xPQ0FUSU9OX0hFTFBFUjsKIAkJCWdvdG8gb3V0OwogCQl9IGVsc2UgaWYgKGFkcmVu b19ncHUtPmZ3bG9jICE9IEZXX0xPQ0FUSU9OX1VOS05PV04pIHsKLQkJCWRldl9lcnIoZHJtLT5k ZXYsICJmYWlsZWQgdG8gbG9hZCAlczogJWRcbiIsCisJCQlEUk1fREVWX0VSUk9SKGRybS0+ZGV2 LCAiZmFpbGVkIHRvIGxvYWQgJXM6ICVkXG4iLAogCQkJCW5ld25hbWUsIHJldCk7CiAJCQlmdyA9 IEVSUl9QVFIocmV0KTsKIAkJCWdvdG8gb3V0OwogCQl9CiAJfQogCi0JZGV2X2Vycihkcm0tPmRl diwgImZhaWxlZCB0byBsb2FkICVzXG4iLCBmd25hbWUpOworCURSTV9ERVZfRVJST1IoZHJtLT5k ZXYsICJmYWlsZWQgdG8gbG9hZCAlc1xuIiwgZnduYW1lKTsKIAlmdyA9IEVSUl9QVFIoLUVOT0VO VCk7CiBvdXQ6CiAJa2ZyZWUobmV3bmFtZSk7CkBAIC0yMTIsNyArMjEyLDcgQEAgaW50IGFkcmVu b19od19pbml0KHN0cnVjdCBtc21fZ3B1ICpncHUpCiAJCXJldCA9IG1zbV9nZW1fZ2V0X2lvdmEo cmluZy0+Ym8sIGdwdS0+YXNwYWNlLCAmcmluZy0+aW92YSk7CiAJCWlmIChyZXQpIHsKIAkJCXJp bmctPmlvdmEgPSAwOwotCQkJZGV2X2VycihncHUtPmRldi0+ZGV2LAorCQkJRFJNX0RFVl9FUlJP UihncHUtPmRldi0+ZGV2LAogCQkJCSJjb3VsZCBub3QgbWFwIHJpbmdidWZmZXIgJWQ6ICVkXG4i LCBpLCByZXQpOwogCQkJcmV0dXJuIHJldDsKIAkJfQpAQCAtMjc3LDcgKzI3Nyw3IEBAIHZvaWQg YWRyZW5vX3JlY292ZXIoc3RydWN0IG1zbV9ncHUgKmdwdSkKIAogCXJldCA9IG1zbV9ncHVfaHdf aW5pdChncHUpOwogCWlmIChyZXQpIHsKLQkJZGV2X2VycihkZXYtPmRldiwgImdwdSBodyBpbml0 IGZhaWxlZDogJWRcbiIsIHJldCk7CisJCURSTV9ERVZfRVJST1IoZGV2LT5kZXYsICJncHUgaHcg aW5pdCBmYWlsZWQ6ICVkXG4iLCByZXQpOwogCQkvKiBobW0sIG9oIHdlbGw/ICovCiAJfQogfQpA QCAtNjM2LDcgKzYzNiw3IEBAIHN0YXRpYyBpbnQgYWRyZW5vX2dldF9sZWdhY3lfcHdybGV2ZWxz KHN0cnVjdCBkZXZpY2UgKmRldikKIAlub2RlID0gb2ZfZmluZF9jb21wYXRpYmxlX25vZGUoZGV2 LT5vZl9ub2RlLCBOVUxMLAogCQkicWNvbSxncHUtcHdybGV2ZWxzIik7CiAJaWYgKCFub2RlKSB7 Ci0JCWRldl9lcnIoZGV2LCAiQ291bGQgbm90IGZpbmQgdGhlIEdQVSBwb3dlcmxldmVsc1xuIik7 CisJCURSTV9ERVZfRVJST1IoZGV2LCAiQ291bGQgbm90IGZpbmQgdGhlIEdQVSBwb3dlcmxldmVs c1xuIik7CiAJCXJldHVybiAtRU5YSU87CiAJfQogCkBAIC02NzMsNyArNjczLDcgQEAgc3RhdGlj IGludCBhZHJlbm9fZ2V0X3B3cmxldmVscyhzdHJ1Y3QgZGV2aWNlICpkZXYsCiAJZWxzZSB7CiAJ CXJldCA9IGRldl9wbV9vcHBfb2ZfYWRkX3RhYmxlKGRldik7CiAJCWlmIChyZXQpCi0JCQlkZXZf ZXJyKGRldiwgIlVuYWJsZSB0byBzZXQgdGhlIE9QUCB0YWJsZVxuIik7CisJCQlEUk1fREVWX0VS Uk9SKGRldiwgIlVuYWJsZSB0byBzZXQgdGhlIE9QUCB0YWJsZVxuIik7CiAJfQogCiAJaWYgKCFy ZXQpIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9tc20vZGlzcC9kcHUxL2RwdV9kYmcu YyBiL2RyaXZlcnMvZ3B1L2RybS9tc20vZGlzcC9kcHUxL2RwdV9kYmcuYwppbmRleCBhZTJhZWU3 Li5hODUwNzgxIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3AvZHB1MS9kcHVf ZGJnLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL2RwdTEvZHB1X2RiZy5jCkBAIC0x NDQsNyArMTQ0LDcgQEAgc3RydWN0IGRwdV9kYmdfdmJpZl9kZWJ1Z19idXMgewogc3RhdGljIHZv aWQgX2RwdV9kZWJ1Z19idXNfeGJhcl9kdW1wKHZvaWQgX19pb21lbSAqbWVtX2Jhc2UsCiAJCXN0 cnVjdCBkcHVfZGVidWdfYnVzX2VudHJ5ICplbnRyeSwgdTMyIHZhbCkKIHsKLQlkZXZfZXJyKGRw dV9kYmdfYmFzZS5kZXYsICJ4YmFyIDB4JXggJWQgJWQgMHgleFxuIiwKKwlEUk1fREVWX0VSUk9S KGRwdV9kYmdfYmFzZS5kZXYsICJ4YmFyIDB4JXggJWQgJWQgMHgleFxuIiwKIAkJCWVudHJ5LT53 cl9hZGRyLCBlbnRyeS0+YmxvY2tfaWQsIGVudHJ5LT50ZXN0X2lkLCB2YWwpOwogfQogCkBAIC0x NTQsNyArMTU0LDcgQEAgc3RhdGljIHZvaWQgX2RwdV9kZWJ1Z19idXNfbG1fZHVtcCh2b2lkIF9f aW9tZW0gKm1lbV9iYXNlLAogCWlmICghKHZhbCAmIDB4RkZGMDAwKSkKIAkJcmV0dXJuOwogCi0J ZGV2X2VycihkcHVfZGJnX2Jhc2UuZGV2LCAibG0gMHgleCAlZCAlZCAweCV4XG4iLAorCURSTV9E RVZfRVJST1IoZHB1X2RiZ19iYXNlLmRldiwgImxtIDB4JXggJWQgJWQgMHgleFxuIiwKIAkJCWVu dHJ5LT53cl9hZGRyLCBlbnRyeS0+YmxvY2tfaWQsIGVudHJ5LT50ZXN0X2lkLCB2YWwpOwogfQog CkBAIC0xNjQsNyArMTY0LDcgQEAgc3RhdGljIHZvaWQgX2RwdV9kZWJ1Z19idXNfcHBiMF9kdW1w KHZvaWQgX19pb21lbSAqbWVtX2Jhc2UsCiAJaWYgKCEodmFsICYgQklUKDE1KSkpCiAJCXJldHVy bjsKIAotCWRldl9lcnIoZHB1X2RiZ19iYXNlLmRldiwgInBwYjAgMHgleCAlZCAlZCAweCV4XG4i LAorCURSTV9ERVZfRVJST1IoZHB1X2RiZ19iYXNlLmRldiwgInBwYjAgMHgleCAlZCAlZCAweCV4 XG4iLAogCQkJZW50cnktPndyX2FkZHIsIGVudHJ5LT5ibG9ja19pZCwgZW50cnktPnRlc3RfaWQs IHZhbCk7CiB9CiAKQEAgLTE3NCw3ICsxNzQsNyBAQCBzdGF0aWMgdm9pZCBfZHB1X2RlYnVnX2J1 c19wcGIxX2R1bXAodm9pZCBfX2lvbWVtICptZW1fYmFzZSwKIAlpZiAoISh2YWwgJiBCSVQoMTUp KSkKIAkJcmV0dXJuOwogCi0JZGV2X2VycihkcHVfZGJnX2Jhc2UuZGV2LCAicHBiMSAweCV4ICVk ICVkIDB4JXhcbiIsCisJRFJNX0RFVl9FUlJPUihkcHVfZGJnX2Jhc2UuZGV2LCAicHBiMSAweCV4 ICVkICVkIDB4JXhcbiIsCiAJCQllbnRyeS0+d3JfYWRkciwgZW50cnktPmJsb2NrX2lkLCBlbnRy eS0+dGVzdF9pZCwgdmFsKTsKIH0KIApAQCAtMTk5NCw3ICsxOTk0LDcgQEAgc3RhdGljIHZvaWQg X2RwdV9kYmdfZHVtcF9kcHVfZGJnX2J1cyhzdHJ1Y3QgZHB1X2RiZ19kcHVfZGVidWdfYnVzICpi dXMpCiAJaWYgKCFpbl9sb2cgJiYgIWluX21lbSkKIAkJcmV0dXJuOwogCi0JZGV2X2luZm8oZHB1 X2RiZ19iYXNlLmRldiwgIj09PT09PT09IHN0YXJ0ICVzIGR1bXAgPT09PT09PT09XG4iLAorCURS TV9ERVZfSU5GTyhkcHVfZGJnX2Jhc2UuZGV2LCAiPT09PT09PT0gc3RhcnQgJXMgZHVtcCA9PT09 PT09PT1cbiIsCiAJCQlidXMtPmNtbi5uYW1lKTsKIAogCWlmIChpbl9tZW0pIHsKQEAgLTIwMDQs NyArMjAwNCw3IEBAIHN0YXRpYyB2b2lkIF9kcHVfZGJnX2R1bXBfZHB1X2RiZ19idXMoc3RydWN0 IGRwdV9kYmdfZHB1X2RlYnVnX2J1cyAqYnVzKQogCiAJCWlmICgqZHVtcF9tZW0pIHsKIAkJCWR1 bXBfYWRkciA9ICpkdW1wX21lbTsKLQkJCWRldl9pbmZvKGRwdV9kYmdfYmFzZS5kZXYsCisJCQlE Uk1fREVWX0lORk8oZHB1X2RiZ19iYXNlLmRldiwKIAkJCQkiJXM6IHN0YXJ0X2FkZHI6MHglcEsg bGVuOjB4JXhcbiIsCiAJCQkJX19mdW5jX18sIGR1bXBfYWRkciwgbGlzdF9zaXplKTsKIAkJfSBl bHNlIHsKQEAgLTIwMzIsNyArMjAzMiw3IEBAIHN0YXRpYyB2b2lkIF9kcHVfZGJnX2R1bXBfZHB1 X2RiZ19idXMoc3RydWN0IGRwdV9kYmdfZHB1X2RlYnVnX2J1cyAqYnVzKQogCQlzdGF0dXMgPSBy ZWFkbF9yZWxheGVkKG1lbV9iYXNlICsgb2Zmc2V0KTsKIAogCQlpZiAoaW5fbG9nKQotCQkJZGV2 X2luZm8oZHB1X2RiZ19iYXNlLmRldiwKKwkJCURSTV9ERVZfSU5GTyhkcHVfZGJnX2Jhc2UuZGV2 LAogCQkJCQkid2FkZHI9MHgleCBibGs9JWQgdHN0PSVkIHZhbD0weCV4XG4iLAogCQkJCQloZWFk LT53cl9hZGRyLCBoZWFkLT5ibG9ja19pZCwKIAkJCQkJaGVhZC0+dGVzdF9pZCwgc3RhdHVzKTsK QEAgLTIwNTUsNyArMjA1NSw3IEBAIHN0YXRpYyB2b2lkIF9kcHVfZGJnX2R1bXBfZHB1X2RiZ19i dXMoc3RydWN0IGRwdV9kYmdfZHB1X2RlYnVnX2J1cyAqYnVzKQogCX0KIAlfZHB1X2RiZ19lbmFi bGVfcG93ZXIoZmFsc2UpOwogCi0JZGV2X2luZm8oZHB1X2RiZ19iYXNlLmRldiwgIj09PT09PT09 IGVuZCAlcyBkdW1wID09PT09PT09PVxuIiwKKwlEUk1fREVWX0lORk8oZHB1X2RiZ19iYXNlLmRl diwgIj09PT09PT09IGVuZCAlcyBkdW1wID09PT09PT09PVxuIiwKIAkJCWJ1cy0+Y21uLm5hbWUp OwogfQogCkBAIC0yMDg2LDcgKzIwODYsNyBAQCBzdGF0aWMgdm9pZCBfZHB1X2RiZ19kdW1wX3Zi aWZfZGVidWdfYnVzX2VudHJ5KAogCQkJCSpkdW1wX2FkZHIrKyA9IHZhbDsKIAkJCX0KIAkJCWlm IChpbl9sb2cpCi0JCQkJZGV2X2luZm8oZHB1X2RiZ19iYXNlLmRldiwKKwkJCQlEUk1fREVWX0lO Rk8oZHB1X2RiZ19iYXNlLmRldiwKIAkJCQkJInRlc3Rwb2ludDoleCBhcmIveGluIGlkPSVkIGlu ZGV4PSVkIHZhbD0weCV4XG4iLAogCQkJCQloZWFkLT5ibG9ja19idXNfYWRkciwgaSwgaiwgdmFs KTsKIAkJfQpAQCAtMjEyNyw3ICsyMTI3LDcgQEAgc3RhdGljIHZvaWQgX2RwdV9kYmdfZHVtcF92 YmlmX2RiZ19idXMoc3RydWN0IGRwdV9kYmdfdmJpZl9kZWJ1Z19idXMgKmJ1cykKIAlsaXN0X3Np emUgPSBidXMtPmNtbi5lbnRyaWVzX3NpemU7CiAJZHVtcF9tZW0gPSAmYnVzLT5jbW4uZHVtcGVk X2NvbnRlbnQ7CiAKLQlkZXZfaW5mbyhkcHVfZGJnX2Jhc2UuZGV2LCAiPT09PT09PT0gc3RhcnQg JXMgZHVtcCA9PT09PT09PT1cbiIsCisJRFJNX0RFVl9JTkZPKGRwdV9kYmdfYmFzZS5kZXYsICI9 PT09PT09PSBzdGFydCAlcyBkdW1wID09PT09PT09PVxuIiwKIAkJCWJ1cy0+Y21uLm5hbWUpOwog CiAJaWYgKCFkdW1wX21lbSB8fCAhZGJnX2J1cyB8fCAhYnVzX3NpemUgfHwgIWxpc3Rfc2l6ZSkK QEAgLTIxNTUsNyArMjE1NSw3IEBAIHN0YXRpYyB2b2lkIF9kcHVfZGJnX2R1bXBfdmJpZl9kYmdf YnVzKHN0cnVjdCBkcHVfZGJnX3ZiaWZfZGVidWdfYnVzICpidXMpCiAKIAkJaWYgKCpkdW1wX21l bSkgewogCQkJZHVtcF9hZGRyID0gKmR1bXBfbWVtOwotCQkJZGV2X2luZm8oZHB1X2RiZ19iYXNl LmRldiwKKwkJCURSTV9ERVZfSU5GTyhkcHVfZGJnX2Jhc2UuZGV2LAogCQkJCSIlczogc3RhcnRf YWRkcjoweCVwSyBsZW46MHgleFxuIiwKIAkJCQlfX2Z1bmNfXywgZHVtcF9hZGRyLCBsaXN0X3Np emUpOwogCQl9IGVsc2UgewpAQCAtMjE4MCw3ICsyMTgwLDcgQEAgc3RhdGljIHZvaWQgX2RwdV9k YmdfZHVtcF92YmlmX2RiZ19idXMoc3RydWN0IGRwdV9kYmdfdmJpZl9kZWJ1Z19idXMgKmJ1cykK IAlyZWcgPSByZWFkbF9yZWxheGVkKG1lbV9iYXNlICsgTU1TU19WQklGX1hJTl9IQUxUX0NUUkwx KTsKIAlyZWcxID0gcmVhZGxfcmVsYXhlZChtZW1fYmFzZSArIE1NU1NfVkJJRl9QTkRfRVJSKTsK IAlyZWcyID0gcmVhZGxfcmVsYXhlZChtZW1fYmFzZSArIE1NU1NfVkJJRl9TUkNfRVJSKTsKLQlk ZXZfZXJyKGRwdV9kYmdfYmFzZS5kZXYsCisJRFJNX0RFVl9FUlJPUihkcHVfZGJnX2Jhc2UuZGV2 LAogCQkJIlhJTiBIQUxUOjB4JWxYLCBQTkQgRVJSOjB4JWxYLCBTUkMgRVJSOjB4JWxYXG4iLAog CQkJcmVnLCByZWcxLCByZWcyKTsKIAlyZWcgPj49IDE2OwpAQCAtMjE5NCw3ICsyMTk0LDcgQEAg c3RhdGljIHZvaWQgX2RwdV9kYmdfZHVtcF92YmlmX2RiZ19idXMoc3RydWN0IGRwdV9kYmdfdmJp Zl9kZWJ1Z19idXMgKmJ1cykKIAkJCWQwID0gcmVhZGxfcmVsYXhlZChtZW1fYmFzZSArIE1NU1Nf VkJJRl9FUlJfSU5GTyk7CiAJCQlkMSA9IHJlYWRsX3JlbGF4ZWQobWVtX2Jhc2UgKyBNTVNTX1ZC SUZfRVJSX0lORk9fMSk7CiAKLQkJCWRldl9lcnIoZHB1X2RiZ19iYXNlLmRldiwKKwkJCURSTV9E RVZfRVJST1IoZHB1X2RiZ19iYXNlLmRldiwKIAkJCQkJIkNsaWVudDolZCwgZXJyaW5mbz0weCVY LCBlcnJpbmZvMT0weCVYXG4iLAogCQkJCQlpLCBkMCwgZDEpOwogCQl9CkBAIC0yMjE3LDcgKzIy MTcsNyBAQCBzdGF0aWMgdm9pZCBfZHB1X2RiZ19kdW1wX3ZiaWZfZGJnX2J1cyhzdHJ1Y3QgZHB1 X2RiZ192YmlmX2RlYnVnX2J1cyAqYnVzKQogCiAJX2RwdV9kYmdfZW5hYmxlX3Bvd2VyKGZhbHNl KTsKIAotCWRldl9pbmZvKGRwdV9kYmdfYmFzZS5kZXYsICI9PT09PT09PSBlbmQgJXMgZHVtcCA9 PT09PT09PT1cbiIsCisJRFJNX0RFVl9JTkZPKGRwdV9kYmdfYmFzZS5kZXYsICI9PT09PT09PSBl bmQgJXMgZHVtcCA9PT09PT09PT1cbiIsCiAJCQlidXMtPmNtbi5uYW1lKTsKIH0KIApkaWZmIC0t Z2l0IGEvZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL2RwdTEvZHB1X2lvX3V0aWwuYyBiL2RyaXZl cnMvZ3B1L2RybS9tc20vZGlzcC9kcHUxL2RwdV9pb191dGlsLmMKaW5kZXggNzkwZDM5Zi4uNjc2 ZTljMyAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL2RwdTEvZHB1X2lvX3V0 aWwuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3AvZHB1MS9kcHVfaW9fdXRpbC5jCkBA IC0xNjQsNyArMTY0LDcgQEAgaW50IG1zbV9kc3NfcGFyc2VfY2xvY2soc3RydWN0IHBsYXRmb3Jt X2RldmljZSAqcGRldiwKIAkJCQkJCSAgICJjbG9jay1uYW1lcyIsIGksCiAJCQkJCQkgICAmY2xv Y2tfbmFtZSk7CiAJCWlmIChyYykgewotCQkJZGV2X2VycigmcGRldi0+ZGV2LCAiRmFpbGVkIHRv IGdldCBjbG9jayBuYW1lIGZvciAlZFxuIiwKKwkJCURSTV9ERVZfRVJST1IoJnBkZXYtPmRldiwg IkZhaWxlZCB0byBnZXQgY2xvY2sgbmFtZSBmb3IgJWRcbiIsCiAJCQkJaSk7CiAJCQlicmVhazsK IAkJfQpAQCAtMTc2LDEzICsxNzYsMTMgQEAgaW50IG1zbV9kc3NfcGFyc2VfY2xvY2soc3RydWN0 IHBsYXRmb3JtX2RldmljZSAqcGRldiwKIAogCXJjID0gbXNtX2Rzc19nZXRfY2xrKCZwZGV2LT5k ZXYsIG1wLT5jbGtfY29uZmlnLCBudW1fY2xrKTsKIAlpZiAocmMpIHsKLQkJZGV2X2VycigmcGRl di0+ZGV2LCAiRmFpbGVkIHRvIGdldCBjbG9jayByZWZzICVkXG4iLCByYyk7CisJCURSTV9ERVZf RVJST1IoJnBkZXYtPmRldiwgIkZhaWxlZCB0byBnZXQgY2xvY2sgcmVmcyAlZFxuIiwgcmMpOwog CQlnb3RvIGVycjsKIAl9CiAKIAlyYyA9IG9mX2Nsa19zZXRfZGVmYXVsdHMocGRldi0+ZGV2Lm9m X25vZGUsIGZhbHNlKTsKIAlpZiAocmMpIHsKLQkJZGV2X2VycigmcGRldi0+ZGV2LCAiRmFpbGVk IHRvIHNldCBjbG9jayBkZWZhdWx0cyAlZFxuIiwgcmMpOworCQlEUk1fREVWX0VSUk9SKCZwZGV2 LT5kZXYsICJGYWlsZWQgdG8gc2V0IGNsb2NrIGRlZmF1bHRzICVkXG4iLCByYyk7CiAJCWdvdG8g ZXJyOwogCX0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL21kcDQvbWRw NF9jcnRjLmMgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3AvbWRwNC9tZHA0X2NydGMuYwppbmRl eCA0NTdjMjlkLi5iOTE3MDZjIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3Av bWRwNC9tZHA0X2NydGMuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3AvbWRwNC9tZHA0 X2NydGMuYwpAQCAtNDI5LDcgKzQyOSw3IEBAIHN0YXRpYyBpbnQgbWRwNF9jcnRjX2N1cnNvcl9z ZXQoc3RydWN0IGRybV9jcnRjICpjcnRjLAogCWludCByZXQ7CiAKIAlpZiAoKHdpZHRoID4gQ1VS U09SX1dJRFRIKSB8fCAoaGVpZ2h0ID4gQ1VSU09SX0hFSUdIVCkpIHsKLQkJZGV2X2VycihkZXYt PmRldiwgImJhZCBjdXJzb3Igc2l6ZTogJWR4JWRcbiIsIHdpZHRoLCBoZWlnaHQpOworCQlEUk1f REVWX0VSUk9SKGRldi0+ZGV2LCAiYmFkIGN1cnNvciBzaXplOiAlZHglZFxuIiwgd2lkdGgsIGhl aWdodCk7CiAJCXJldHVybiAtRUlOVkFMOwogCX0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUv ZHJtL21zbS9kaXNwL21kcDQvbWRwNF9kdHZfZW5jb2Rlci5jIGIvZHJpdmVycy9ncHUvZHJtL21z bS9kaXNwL21kcDQvbWRwNF9kdHZfZW5jb2Rlci5jCmluZGV4IGJhOGU1ODcuLmE4ZmQxNGQgMTAw NjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9tc20vZGlzcC9tZHA0L21kcDRfZHR2X2VuY29kZXIu YworKysgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3AvbWRwNC9tZHA0X2R0dl9lbmNvZGVyLmMK QEAgLTQ1LDcgKzQ1LDcgQEAgc3RhdGljIHZvaWQgYnNfaW5pdChzdHJ1Y3QgbWRwNF9kdHZfZW5j b2RlciAqbWRwNF9kdHZfZW5jb2RlcikKIAlzdHJ1Y3QgbGNkY19wbGF0Zm9ybV9kYXRhICpkdHZf cGRhdGEgPSBtZHA0X2ZpbmRfcGRhdGEoImR0di4wIik7CiAKIAlpZiAoIWR0dl9wZGF0YSkgewot CQlkZXZfZXJyKGRldi0+ZGV2LCAiY291bGQgbm90IGZpbmQgZHR2IHBkYXRhXG4iKTsKKwkJRFJN X0RFVl9FUlJPUihkZXYtPmRldiwgImNvdWxkIG5vdCBmaW5kIGR0diBwZGF0YVxuIik7CiAJCXJl dHVybjsKIAl9CiAKQEAgLTIwOSwxNiArMjA5LDE2IEBAIHN0YXRpYyB2b2lkIG1kcDRfZHR2X2Vu Y29kZXJfZW5hYmxlKHN0cnVjdCBkcm1fZW5jb2RlciAqZW5jb2RlcikKIAogCXJldCA9IGNsa19z ZXRfcmF0ZShtZHA0X2R0dl9lbmNvZGVyLT5tZHBfY2xrLCBwYyk7CiAJaWYgKHJldCkKLQkJZGV2 X2VycihkZXYtPmRldiwgImZhaWxlZCB0byBzZXQgbWRwX2NsayB0byAlbHU6ICVkXG4iLAorCQlE Uk1fREVWX0VSUk9SKGRldi0+ZGV2LCAiZmFpbGVkIHRvIHNldCBtZHBfY2xrIHRvICVsdTogJWRc biIsCiAJCQlwYywgcmV0KTsKIAogCXJldCA9IGNsa19wcmVwYXJlX2VuYWJsZShtZHA0X2R0dl9l bmNvZGVyLT5tZHBfY2xrKTsKIAlpZiAocmV0KQotCQlkZXZfZXJyKGRldi0+ZGV2LCAiZmFpbGVk IHRvIGVuYWJsZWQgbWRwX2NsazogJWRcbiIsIHJldCk7CisJCURSTV9ERVZfRVJST1IoZGV2LT5k ZXYsICJmYWlsZWQgdG8gZW5hYmxlZCBtZHBfY2xrOiAlZFxuIiwgcmV0KTsKIAogCXJldCA9IGNs a19wcmVwYXJlX2VuYWJsZShtZHA0X2R0dl9lbmNvZGVyLT5oZG1pX2Nsayk7CiAJaWYgKHJldCkK LQkJZGV2X2VycihkZXYtPmRldiwgImZhaWxlZCB0byBlbmFibGUgaGRtaV9jbGs6ICVkXG4iLCBy ZXQpOworCQlEUk1fREVWX0VSUk9SKGRldi0+ZGV2LCAiZmFpbGVkIHRvIGVuYWJsZSBoZG1pX2Ns azogJWRcbiIsIHJldCk7CiAKIAltZHA0X3dyaXRlKG1kcDRfa21zLCBSRUdfTURQNF9EVFZfRU5B QkxFLCAxKTsKIApAQCAtMjU4LDE0ICsyNTgsMTQgQEAgc3RydWN0IGRybV9lbmNvZGVyICptZHA0 X2R0dl9lbmNvZGVyX2luaXQoc3RydWN0IGRybV9kZXZpY2UgKmRldikKIAogCW1kcDRfZHR2X2Vu Y29kZXItPmhkbWlfY2xrID0gZGV2bV9jbGtfZ2V0KGRldi0+ZGV2LCAiaGRtaV9jbGsiKTsKIAlp ZiAoSVNfRVJSKG1kcDRfZHR2X2VuY29kZXItPmhkbWlfY2xrKSkgewotCQlkZXZfZXJyKGRldi0+ ZGV2LCAiZmFpbGVkIHRvIGdldCBoZG1pX2Nsa1xuIik7CisJCURSTV9ERVZfRVJST1IoZGV2LT5k ZXYsICJmYWlsZWQgdG8gZ2V0IGhkbWlfY2xrXG4iKTsKIAkJcmV0ID0gUFRSX0VSUihtZHA0X2R0 dl9lbmNvZGVyLT5oZG1pX2Nsayk7CiAJCWdvdG8gZmFpbDsKIAl9CiAKIAltZHA0X2R0dl9lbmNv ZGVyLT5tZHBfY2xrID0gZGV2bV9jbGtfZ2V0KGRldi0+ZGV2LCAidHZfY2xrIik7CiAJaWYgKElT X0VSUihtZHA0X2R0dl9lbmNvZGVyLT5tZHBfY2xrKSkgewotCQlkZXZfZXJyKGRldi0+ZGV2LCAi ZmFpbGVkIHRvIGdldCB0dl9jbGtcbiIpOworCQlEUk1fREVWX0VSUk9SKGRldi0+ZGV2LCAiZmFp bGVkIHRvIGdldCB0dl9jbGtcbiIpOwogCQlyZXQgPSBQVFJfRVJSKG1kcDRfZHR2X2VuY29kZXIt Pm1kcF9jbGspOwogCQlnb3RvIGZhaWw7CiAJfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJt L21zbS9kaXNwL21kcDQvbWRwNF9rbXMuYyBiL2RyaXZlcnMvZ3B1L2RybS9tc20vZGlzcC9tZHA0 L21kcDRfa21zLmMKaW5kZXggNDRkMWNkYS4uNDgxYzBkMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9n cHUvZHJtL21zbS9kaXNwL21kcDQvbWRwNF9rbXMuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vbXNt L2Rpc3AvbWRwNC9tZHA0X2ttcy5jCkBAIC00Myw3ICs0Myw3IEBAIHN0YXRpYyBpbnQgbWRwNF9o d19pbml0KHN0cnVjdCBtc21fa21zICprbXMpCiAJREJHKCJmb3VuZCBNRFA0IHZlcnNpb24gdiVk LiVkIiwgbWFqb3IsIG1pbm9yKTsKIAogCWlmIChtYWpvciAhPSA0KSB7Ci0JCWRldl9lcnIoZGV2 LT5kZXYsICJ1bmV4cGVjdGVkIE1EUCB2ZXJzaW9uOiB2JWQuJWRcbiIsCisJCURSTV9ERVZfRVJS T1IoZGV2LT5kZXYsICJ1bmV4cGVjdGVkIE1EUCB2ZXJzaW9uOiB2JWQuJWRcbiIsCiAJCQkJbWFq b3IsIG1pbm9yKTsKIAkJcmV0ID0gLUVOWElPOwogCQlnb3RvIG91dDsKQEAgLTI1MSw3ICsyNTEs NyBAQCBzdGF0aWMgaW50IG1kcDRfbW9kZXNldF9pbml0X2ludGYoc3RydWN0IG1kcDRfa21zICpt ZHA0X2ttcywKIAogCQllbmNvZGVyID0gbWRwNF9sY2RjX2VuY29kZXJfaW5pdChkZXYsIHBhbmVs X25vZGUpOwogCQlpZiAoSVNfRVJSKGVuY29kZXIpKSB7Ci0JCQlkZXZfZXJyKGRldi0+ZGV2LCAi ZmFpbGVkIHRvIGNvbnN0cnVjdCBMQ0RDIGVuY29kZXJcbiIpOworCQkJRFJNX0RFVl9FUlJPUihk ZXYtPmRldiwgImZhaWxlZCB0byBjb25zdHJ1Y3QgTENEQyBlbmNvZGVyXG4iKTsKIAkJCXJldHVy biBQVFJfRVJSKGVuY29kZXIpOwogCQl9CiAKQEAgLTI2MCw3ICsyNjAsNyBAQCBzdGF0aWMgaW50 IG1kcDRfbW9kZXNldF9pbml0X2ludGYoc3RydWN0IG1kcDRfa21zICptZHA0X2ttcywKIAogCQlj b25uZWN0b3IgPSBtZHA0X2x2ZHNfY29ubmVjdG9yX2luaXQoZGV2LCBwYW5lbF9ub2RlLCBlbmNv ZGVyKTsKIAkJaWYgKElTX0VSUihjb25uZWN0b3IpKSB7Ci0JCQlkZXZfZXJyKGRldi0+ZGV2LCAi ZmFpbGVkIHRvIGluaXRpYWxpemUgTFZEUyBjb25uZWN0b3JcbiIpOworCQkJRFJNX0RFVl9FUlJP UihkZXYtPmRldiwgImZhaWxlZCB0byBpbml0aWFsaXplIExWRFMgY29ubmVjdG9yXG4iKTsKIAkJ CXJldHVybiBQVFJfRVJSKGNvbm5lY3Rvcik7CiAJCX0KIApAQCAtMjcxLDcgKzI3MSw3IEBAIHN0 YXRpYyBpbnQgbWRwNF9tb2Rlc2V0X2luaXRfaW50ZihzdHJ1Y3QgbWRwNF9rbXMgKm1kcDRfa21z LAogCWNhc2UgRFJNX01PREVfRU5DT0RFUl9UTURTOgogCQllbmNvZGVyID0gbWRwNF9kdHZfZW5j b2Rlcl9pbml0KGRldik7CiAJCWlmIChJU19FUlIoZW5jb2RlcikpIHsKLQkJCWRldl9lcnIoZGV2 LT5kZXYsICJmYWlsZWQgdG8gY29uc3RydWN0IERUViBlbmNvZGVyXG4iKTsKKwkJCURSTV9ERVZf RVJST1IoZGV2LT5kZXYsICJmYWlsZWQgdG8gY29uc3RydWN0IERUViBlbmNvZGVyXG4iKTsKIAkJ CXJldHVybiBQVFJfRVJSKGVuY29kZXIpOwogCQl9CiAKQEAgLTI4Miw3ICsyODIsNyBAQCBzdGF0 aWMgaW50IG1kcDRfbW9kZXNldF9pbml0X2ludGYoc3RydWN0IG1kcDRfa21zICptZHA0X2ttcywK IAkJCS8qIENvbnN0cnVjdCBicmlkZ2UvY29ubmVjdG9yIGZvciBIRE1JOiAqLwogCQkJcmV0ID0g bXNtX2hkbWlfbW9kZXNldF9pbml0KHByaXYtPmhkbWksIGRldiwgZW5jb2Rlcik7CiAJCQlpZiAo cmV0KSB7Ci0JCQkJZGV2X2VycihkZXYtPmRldiwgImZhaWxlZCB0byBpbml0aWFsaXplIEhETUk6 ICVkXG4iLCByZXQpOworCQkJCURSTV9ERVZfRVJST1IoZGV2LT5kZXYsICJmYWlsZWQgdG8gaW5p dGlhbGl6ZSBIRE1JOiAlZFxuIiwgcmV0KTsKIAkJCQlyZXR1cm4gcmV0OwogCQkJfQogCQl9CkBA IC0zMDAsNyArMzAwLDcgQEAgc3RhdGljIGludCBtZHA0X21vZGVzZXRfaW5pdF9pbnRmKHN0cnVj dCBtZHA0X2ttcyAqbWRwNF9rbXMsCiAJCWVuY29kZXIgPSBtZHA0X2RzaV9lbmNvZGVyX2luaXQo ZGV2KTsKIAkJaWYgKElTX0VSUihlbmNvZGVyKSkgewogCQkJcmV0ID0gUFRSX0VSUihlbmNvZGVy KTsKLQkJCWRldl9lcnIoZGV2LT5kZXYsCisJCQlEUk1fREVWX0VSUk9SKGRldi0+ZGV2LAogCQkJ CSJmYWlsZWQgdG8gY29uc3RydWN0IERTSSBlbmNvZGVyOiAlZFxuIiwgcmV0KTsKIAkJCXJldHVy biByZXQ7CiAJCX0KQEAgLTMxMSwxNCArMzExLDE0IEBAIHN0YXRpYyBpbnQgbWRwNF9tb2Rlc2V0 X2luaXRfaW50ZihzdHJ1Y3QgbWRwNF9rbXMgKm1kcDRfa21zLAogCiAJCXJldCA9IG1zbV9kc2lf bW9kZXNldF9pbml0KHByaXYtPmRzaVtkc2lfaWRdLCBkZXYsIGVuY29kZXIpOwogCQlpZiAocmV0 KSB7Ci0JCQlkZXZfZXJyKGRldi0+ZGV2LCAiZmFpbGVkIHRvIGluaXRpYWxpemUgRFNJOiAlZFxu IiwKKwkJCURSTV9ERVZfRVJST1IoZGV2LT5kZXYsICJmYWlsZWQgdG8gaW5pdGlhbGl6ZSBEU0k6 ICVkXG4iLAogCQkJCXJldCk7CiAJCQlyZXR1cm4gcmV0OwogCQl9CiAKIAkJYnJlYWs7CiAJZGVm YXVsdDoKLQkJZGV2X2VycihkZXYtPmRldiwgIkludmFsaWQgb3IgdW5zdXBwb3J0ZWQgaW50ZXJm YWNlXG4iKTsKKwkJRFJNX0RFVl9FUlJPUihkZXYtPmRldiwgIkludmFsaWQgb3IgdW5zdXBwb3J0 ZWQgaW50ZXJmYWNlXG4iKTsKIAkJcmV0dXJuIC1FSU5WQUw7CiAJfQogCkBAIC0zNTQsNyArMzU0 LDcgQEAgc3RhdGljIGludCBtb2Rlc2V0X2luaXQoc3RydWN0IG1kcDRfa21zICptZHA0X2ttcykK IAlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRSh2Z19wbGFuZXMpOyBpKyspIHsKIAkJcGxhbmUg PSBtZHA0X3BsYW5lX2luaXQoZGV2LCB2Z19wbGFuZXNbaV0sIGZhbHNlKTsKIAkJaWYgKElTX0VS UihwbGFuZSkpIHsKLQkJCWRldl9lcnIoZGV2LT5kZXYsCisJCQlEUk1fREVWX0VSUk9SKGRldi0+ ZGV2LAogCQkJCSJmYWlsZWQgdG8gY29uc3RydWN0IHBsYW5lIGZvciBWRyVkXG4iLCBpICsgMSk7 CiAJCQlyZXQgPSBQVFJfRVJSKHBsYW5lKTsKIAkJCWdvdG8gZmFpbDsKQEAgLTM2NSw3ICszNjUs NyBAQCBzdGF0aWMgaW50IG1vZGVzZXRfaW5pdChzdHJ1Y3QgbWRwNF9rbXMgKm1kcDRfa21zKQog CWZvciAoaSA9IDA7IGkgPCBBUlJBWV9TSVpFKG1kcDRfY3J0Y3MpOyBpKyspIHsKIAkJcGxhbmUg PSBtZHA0X3BsYW5lX2luaXQoZGV2LCByZ2JfcGxhbmVzW2ldLCB0cnVlKTsKIAkJaWYgKElTX0VS UihwbGFuZSkpIHsKLQkJCWRldl9lcnIoZGV2LT5kZXYsCisJCQlEUk1fREVWX0VSUk9SKGRldi0+ ZGV2LAogCQkJCSJmYWlsZWQgdG8gY29uc3RydWN0IHBsYW5lIGZvciBSR0IlZFxuIiwgaSArIDEp OwogCQkJcmV0ID0gUFRSX0VSUihwbGFuZSk7CiAJCQlnb3RvIGZhaWw7CkBAIC0zNzQsNyArMzc0 LDcgQEAgc3RhdGljIGludCBtb2Rlc2V0X2luaXQoc3RydWN0IG1kcDRfa21zICptZHA0X2ttcykK IAkJY3J0YyAgPSBtZHA0X2NydGNfaW5pdChkZXYsIHBsYW5lLCBwcml2LT5udW1fY3J0Y3MsIGks CiAJCQkJbWRwNF9jcnRjc1tpXSk7CiAJCWlmIChJU19FUlIoY3J0YykpIHsKLQkJCWRldl9lcnIo ZGV2LT5kZXYsICJmYWlsZWQgdG8gY29uc3RydWN0IGNydGMgZm9yICVzXG4iLAorCQkJRFJNX0RF Vl9FUlJPUihkZXYtPmRldiwgImZhaWxlZCB0byBjb25zdHJ1Y3QgY3J0YyBmb3IgJXNcbiIsCiAJ CQkJbWRwNF9jcnRjX25hbWVzW2ldKTsKIAkJCXJldCA9IFBUUl9FUlIoY3J0Yyk7CiAJCQlnb3Rv IGZhaWw7CkBAIC0zOTYsNyArMzk2LDcgQEAgc3RhdGljIGludCBtb2Rlc2V0X2luaXQoc3RydWN0 IG1kcDRfa21zICptZHA0X2ttcykKIAlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRShtZHA0X2lu dGZzKTsgaSsrKSB7CiAJCXJldCA9IG1kcDRfbW9kZXNldF9pbml0X2ludGYobWRwNF9rbXMsIG1k cDRfaW50ZnNbaV0pOwogCQlpZiAocmV0KSB7Ci0JCQlkZXZfZXJyKGRldi0+ZGV2LCAiZmFpbGVk IHRvIGluaXRpYWxpemUgaW50ZjogJWQsICVkXG4iLAorCQkJRFJNX0RFVl9FUlJPUihkZXYtPmRl diwgImZhaWxlZCB0byBpbml0aWFsaXplIGludGY6ICVkLCAlZFxuIiwKIAkJCQlpLCByZXQpOwog CQkJZ290byBmYWlsOwogCQl9CkBAIC00MTksNyArNDE5LDcgQEAgc3RydWN0IG1zbV9rbXMgKm1k cDRfa21zX2luaXQoc3RydWN0IGRybV9kZXZpY2UgKmRldikKIAogCW1kcDRfa21zID0ga3phbGxv YyhzaXplb2YoKm1kcDRfa21zKSwgR0ZQX0tFUk5FTCk7CiAJaWYgKCFtZHA0X2ttcykgewotCQlk ZXZfZXJyKGRldi0+ZGV2LCAiZmFpbGVkIHRvIGFsbG9jYXRlIGttc1xuIik7CisJCURSTV9ERVZf RVJST1IoZGV2LT5kZXYsICJmYWlsZWQgdG8gYWxsb2NhdGUga21zXG4iKTsKIAkJcmV0ID0gLUVO T01FTTsKIAkJZ290byBmYWlsOwogCX0KQEAgLTQzOSw3ICs0MzksNyBAQCBzdHJ1Y3QgbXNtX2tt cyAqbWRwNF9rbXNfaW5pdChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2KQogCWlycSA9IHBsYXRmb3Jt X2dldF9pcnEocGRldiwgMCk7CiAJaWYgKGlycSA8IDApIHsKIAkJcmV0ID0gaXJxOwotCQlkZXZf ZXJyKGRldi0+ZGV2LCAiZmFpbGVkIHRvIGdldCBpcnE6ICVkXG4iLCByZXQpOworCQlEUk1fREVW X0VSUk9SKGRldi0+ZGV2LCAiZmFpbGVkIHRvIGdldCBpcnE6ICVkXG4iLCByZXQpOwogCQlnb3Rv IGZhaWw7CiAJfQogCkBAIC00NTYsMTQgKzQ1NiwxNCBAQCBzdHJ1Y3QgbXNtX2ttcyAqbWRwNF9r bXNfaW5pdChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2KQogCWlmIChtZHA0X2ttcy0+dmRkKSB7CiAJ CXJldCA9IHJlZ3VsYXRvcl9lbmFibGUobWRwNF9rbXMtPnZkZCk7CiAJCWlmIChyZXQpIHsKLQkJ CWRldl9lcnIoZGV2LT5kZXYsICJmYWlsZWQgdG8gZW5hYmxlIHJlZ3VsYXRvciB2ZGQ6ICVkXG4i LCByZXQpOworCQkJRFJNX0RFVl9FUlJPUihkZXYtPmRldiwgImZhaWxlZCB0byBlbmFibGUgcmVn dWxhdG9yIHZkZDogJWRcbiIsIHJldCk7CiAJCQlnb3RvIGZhaWw7CiAJCX0KIAl9CiAKIAltZHA0 X2ttcy0+Y2xrID0gZGV2bV9jbGtfZ2V0KCZwZGV2LT5kZXYsICJjb3JlX2NsayIpOwogCWlmIChJ U19FUlIobWRwNF9rbXMtPmNsaykpIHsKLQkJZGV2X2VycihkZXYtPmRldiwgImZhaWxlZCB0byBn ZXQgY29yZV9jbGtcbiIpOworCQlEUk1fREVWX0VSUk9SKGRldi0+ZGV2LCAiZmFpbGVkIHRvIGdl dCBjb3JlX2Nsa1xuIik7CiAJCXJldCA9IFBUUl9FUlIobWRwNF9rbXMtPmNsayk7CiAJCWdvdG8g ZmFpbDsKIAl9CkBAIC00NzUsMTQgKzQ3NSwxNCBAQCBzdHJ1Y3QgbXNtX2ttcyAqbWRwNF9rbXNf aW5pdChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2KQogCS8vIFhYWCBpZiAocmV2ID49IE1EUF9SRVZf NDIpIHsgPz8/CiAJbWRwNF9rbXMtPmx1dF9jbGsgPSBkZXZtX2Nsa19nZXQoJnBkZXYtPmRldiwg Imx1dF9jbGsiKTsKIAlpZiAoSVNfRVJSKG1kcDRfa21zLT5sdXRfY2xrKSkgewotCQlkZXZfZXJy KGRldi0+ZGV2LCAiZmFpbGVkIHRvIGdldCBsdXRfY2xrXG4iKTsKKwkJRFJNX0RFVl9FUlJPUihk ZXYtPmRldiwgImZhaWxlZCB0byBnZXQgbHV0X2Nsa1xuIik7CiAJCXJldCA9IFBUUl9FUlIobWRw NF9rbXMtPmx1dF9jbGspOwogCQlnb3RvIGZhaWw7CiAJfQogCiAJbWRwNF9rbXMtPmF4aV9jbGsg PSBkZXZtX2Nsa19nZXQoJnBkZXYtPmRldiwgImJ1c19jbGsiKTsKIAlpZiAoSVNfRVJSKG1kcDRf a21zLT5heGlfY2xrKSkgewotCQlkZXZfZXJyKGRldi0+ZGV2LCAiZmFpbGVkIHRvIGdldCBheGlf Y2xrXG4iKTsKKwkJRFJNX0RFVl9FUlJPUihkZXYtPmRldiwgImZhaWxlZCB0byBnZXQgYXhpX2Ns a1xuIik7CiAJCXJldCA9IFBUUl9FUlIobWRwNF9rbXMtPmF4aV9jbGspOwogCQlnb3RvIGZhaWw7 CiAJfQpAQCAtNTE5LDIxICs1MTksMjEgQEAgc3RydWN0IG1zbV9rbXMgKm1kcDRfa21zX2luaXQo c3RydWN0IGRybV9kZXZpY2UgKmRldikKIAkJaWYgKHJldCkKIAkJCWdvdG8gZmFpbDsKIAl9IGVs c2UgewotCQlkZXZfaW5mbyhkZXYtPmRldiwgIm5vIGlvbW11LCBmYWxsYmFjayB0byBwaHlzICIK KwkJRFJNX0RFVl9JTkZPKGRldi0+ZGV2LCAibm8gaW9tbXUsIGZhbGxiYWNrIHRvIHBoeXMgIgog CQkJCSJjb250aWcgYnVmZmVycyBmb3Igc2Nhbm91dFxuIik7CiAJCWFzcGFjZSA9IE5VTEw7CiAJ fQogCiAJcmV0ID0gbW9kZXNldF9pbml0KG1kcDRfa21zKTsKIAlpZiAocmV0KSB7Ci0JCWRldl9l cnIoZGV2LT5kZXYsICJtb2Rlc2V0X2luaXQgZmFpbGVkOiAlZFxuIiwgcmV0KTsKKwkJRFJNX0RF Vl9FUlJPUihkZXYtPmRldiwgIm1vZGVzZXRfaW5pdCBmYWlsZWQ6ICVkXG4iLCByZXQpOwogCQln b3RvIGZhaWw7CiAJfQogCiAJbWRwNF9rbXMtPmJsYW5rX2N1cnNvcl9ibyA9IG1zbV9nZW1fbmV3 KGRldiwgU1pfMTZLLCBNU01fQk9fV0MpOwogCWlmIChJU19FUlIobWRwNF9rbXMtPmJsYW5rX2N1 cnNvcl9ibykpIHsKIAkJcmV0ID0gUFRSX0VSUihtZHA0X2ttcy0+YmxhbmtfY3Vyc29yX2JvKTsK LQkJZGV2X2VycihkZXYtPmRldiwgImNvdWxkIG5vdCBhbGxvY2F0ZSBibGFuay1jdXJzb3IgYm86 ICVkXG4iLCByZXQpOworCQlEUk1fREVWX0VSUk9SKGRldi0+ZGV2LCAiY291bGQgbm90IGFsbG9j YXRlIGJsYW5rLWN1cnNvciBibzogJWRcbiIsIHJldCk7CiAJCW1kcDRfa21zLT5ibGFua19jdXJz b3JfYm8gPSBOVUxMOwogCQlnb3RvIGZhaWw7CiAJfQpAQCAtNTQxLDcgKzU0MSw3IEBAIHN0cnVj dCBtc21fa21zICptZHA0X2ttc19pbml0KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYpCiAJcmV0ID0g bXNtX2dlbV9nZXRfaW92YShtZHA0X2ttcy0+YmxhbmtfY3Vyc29yX2JvLCBrbXMtPmFzcGFjZSwK IAkJCSZtZHA0X2ttcy0+YmxhbmtfY3Vyc29yX2lvdmEpOwogCWlmIChyZXQpIHsKLQkJZGV2X2Vy cihkZXYtPmRldiwgImNvdWxkIG5vdCBwaW4gYmxhbmstY3Vyc29yIGJvOiAlZFxuIiwgcmV0KTsK KwkJRFJNX0RFVl9FUlJPUihkZXYtPmRldiwgImNvdWxkIG5vdCBwaW4gYmxhbmstY3Vyc29yIGJv OiAlZFxuIiwgcmV0KTsKIAkJZ290byBmYWlsOwogCX0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9n cHUvZHJtL21zbS9kaXNwL21kcDQvbWRwNF9sY2RjX2VuY29kZXIuYyBiL2RyaXZlcnMvZ3B1L2Ry bS9tc20vZGlzcC9tZHA0L21kcDRfbGNkY19lbmNvZGVyLmMKaW5kZXggMmJmYjM5MC4uOWUwOGMy ZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL21kcDQvbWRwNF9sY2RjX2Vu Y29kZXIuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3AvbWRwNC9tZHA0X2xjZGNfZW5j b2Rlci5jCkBAIC00Nyw3ICs0Nyw3IEBAIHN0YXRpYyB2b2lkIGJzX2luaXQoc3RydWN0IG1kcDRf bGNkY19lbmNvZGVyICptZHA0X2xjZGNfZW5jb2RlcikKIAlzdHJ1Y3QgbGNkY19wbGF0Zm9ybV9k YXRhICpsY2RjX3BkYXRhID0gbWRwNF9maW5kX3BkYXRhKCJsdmRzLjAiKTsKIAogCWlmICghbGNk Y19wZGF0YSkgewotCQlkZXZfZXJyKGRldi0+ZGV2LCAiY291bGQgbm90IGZpbmQgbHZkcyBwZGF0 YVxuIik7CisJCURSTV9ERVZfRVJST1IoZGV2LT5kZXYsICJjb3VsZCBub3QgZmluZCBsdmRzIHBk YXRhXG4iKTsKIAkJcmV0dXJuOwogCX0KIApAQCAtMjI0LDcgKzIyNCw3IEBAIHN0YXRpYyB2b2lk IHNldHVwX3BoeShzdHJ1Y3QgZHJtX2VuY29kZXIgKmVuY29kZXIpCiAJCWJyZWFrOwogCiAJZGVm YXVsdDoKLQkJZGV2X2VycihkZXYtPmRldiwgInVua25vd24gYnBwOiAlZFxuIiwgYnBwKTsKKwkJ RFJNX0RFVl9FUlJPUihkZXYtPmRldiwgInVua25vd24gYnBwOiAlZFxuIiwgYnBwKTsKIAkJcmV0 dXJuOwogCX0KIApAQCAtMjQxLDcgKzI0MSw3IEBAIHN0YXRpYyB2b2lkIHNldHVwX3BoeShzdHJ1 Y3QgZHJtX2VuY29kZXIgKmVuY29kZXIpCiAJCQkJTURQNF9MQ0RDX0xWRFNfSU5URl9DVExfQ0gx X0NMS19MQU5FX0VOOwogCQlicmVhazsKIAlkZWZhdWx0OgotCQlkZXZfZXJyKGRldi0+ZGV2LCAi dW5rbm93biAjIG9mIGNoYW5uZWxzOiAlZFxuIiwgbmNoYW4pOworCQlEUk1fREVWX0VSUk9SKGRl di0+ZGV2LCAidW5rbm93biAjIG9mIGNoYW5uZWxzOiAlZFxuIiwgbmNoYW4pOwogCQlyZXR1cm47 CiAJfQogCkBAIC0zNjEsNyArMzYxLDcgQEAgc3RhdGljIHZvaWQgbWRwNF9sY2RjX2VuY29kZXJf ZGlzYWJsZShzdHJ1Y3QgZHJtX2VuY29kZXIgKmVuY29kZXIpCiAJZm9yIChpID0gMDsgaSA8IEFS UkFZX1NJWkUobWRwNF9sY2RjX2VuY29kZXItPnJlZ3MpOyBpKyspIHsKIAkJcmV0ID0gcmVndWxh dG9yX2Rpc2FibGUobWRwNF9sY2RjX2VuY29kZXItPnJlZ3NbaV0pOwogCQlpZiAocmV0KQotCQkJ ZGV2X2VycihkZXYtPmRldiwgImZhaWxlZCB0byBkaXNhYmxlIHJlZ3VsYXRvcjogJWRcbiIsIHJl dCk7CisJCQlEUk1fREVWX0VSUk9SKGRldi0+ZGV2LCAiZmFpbGVkIHRvIGRpc2FibGUgcmVndWxh dG9yOiAlZFxuIiwgcmV0KTsKIAl9CiAKIAlic19zZXQobWRwNF9sY2RjX2VuY29kZXIsIDApOwpA QCAtMzk4LDE2ICszOTgsMTYgQEAgc3RhdGljIHZvaWQgbWRwNF9sY2RjX2VuY29kZXJfZW5hYmxl KHN0cnVjdCBkcm1fZW5jb2RlciAqZW5jb2RlcikKIAlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0la RShtZHA0X2xjZGNfZW5jb2Rlci0+cmVncyk7IGkrKykgewogCQlyZXQgPSByZWd1bGF0b3JfZW5h YmxlKG1kcDRfbGNkY19lbmNvZGVyLT5yZWdzW2ldKTsKIAkJaWYgKHJldCkKLQkJCWRldl9lcnIo ZGV2LT5kZXYsICJmYWlsZWQgdG8gZW5hYmxlIHJlZ3VsYXRvcjogJWRcbiIsIHJldCk7CisJCQlE Uk1fREVWX0VSUk9SKGRldi0+ZGV2LCAiZmFpbGVkIHRvIGVuYWJsZSByZWd1bGF0b3I6ICVkXG4i LCByZXQpOwogCX0KIAogCURCRygic2V0dGluZyBsY2RjX2Nsaz0lbHUiLCBwYyk7CiAJcmV0ID0g Y2xrX3NldF9yYXRlKG1kcDRfbGNkY19lbmNvZGVyLT5sY2RjX2NsaywgcGMpOwogCWlmIChyZXQp Ci0JCWRldl9lcnIoZGV2LT5kZXYsICJmYWlsZWQgdG8gY29uZmlndXJlIGxjZGNfY2xrOiAlZFxu IiwgcmV0KTsKKwkJRFJNX0RFVl9FUlJPUihkZXYtPmRldiwgImZhaWxlZCB0byBjb25maWd1cmUg bGNkY19jbGs6ICVkXG4iLCByZXQpOwogCXJldCA9IGNsa19wcmVwYXJlX2VuYWJsZShtZHA0X2xj ZGNfZW5jb2Rlci0+bGNkY19jbGspOwogCWlmIChyZXQpCi0JCWRldl9lcnIoZGV2LT5kZXYsICJm YWlsZWQgdG8gZW5hYmxlIGxjZGNfY2xrOiAlZFxuIiwgcmV0KTsKKwkJRFJNX0RFVl9FUlJPUihk ZXYtPmRldiwgImZhaWxlZCB0byBlbmFibGUgbGNkY19jbGs6ICVkXG4iLCByZXQpOwogCiAJcGFu ZWwgPSBvZl9kcm1fZmluZF9wYW5lbChtZHA0X2xjZGNfZW5jb2Rlci0+cGFuZWxfbm9kZSk7CiAJ aWYgKCFJU19FUlIocGFuZWwpKSB7CkBAIC00NjEsNyArNDYxLDcgQEAgc3RydWN0IGRybV9lbmNv ZGVyICptZHA0X2xjZGNfZW5jb2Rlcl9pbml0KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsCiAJLyog VE9ETzogZG8gd2UgbmVlZCBkaWZmZXJlbnQgcGxsIGluIG90aGVyIGNhc2VzPyAqLwogCW1kcDRf bGNkY19lbmNvZGVyLT5sY2RjX2NsayA9IG1wZDRfbHZkc19wbGxfaW5pdChkZXYpOwogCWlmIChJ U19FUlIobWRwNF9sY2RjX2VuY29kZXItPmxjZGNfY2xrKSkgewotCQlkZXZfZXJyKGRldi0+ZGV2 LCAiZmFpbGVkIHRvIGdldCBsdmRzX2Nsa1xuIik7CisJCURSTV9ERVZfRVJST1IoZGV2LT5kZXYs ICJmYWlsZWQgdG8gZ2V0IGx2ZHNfY2xrXG4iKTsKIAkJcmV0ID0gUFRSX0VSUihtZHA0X2xjZGNf ZW5jb2Rlci0+bGNkY19jbGspOwogCQlnb3RvIGZhaWw7CiAJfQpAQCAtNDcwLDcgKzQ3MCw3IEBA IHN0cnVjdCBkcm1fZW5jb2RlciAqbWRwNF9sY2RjX2VuY29kZXJfaW5pdChzdHJ1Y3QgZHJtX2Rl dmljZSAqZGV2LAogCXJlZyA9IGRldm1fcmVndWxhdG9yX2dldChkZXYtPmRldiwgImx2ZHMtdmNj cy0zcDN2Iik7CiAJaWYgKElTX0VSUihyZWcpKSB7CiAJCXJldCA9IFBUUl9FUlIocmVnKTsKLQkJ ZGV2X2VycihkZXYtPmRldiwgImZhaWxlZCB0byBnZXQgbHZkcy12Y2NzLTNwM3Y6ICVkXG4iLCBy ZXQpOworCQlEUk1fREVWX0VSUk9SKGRldi0+ZGV2LCAiZmFpbGVkIHRvIGdldCBsdmRzLXZjY3Mt M3AzdjogJWRcbiIsIHJldCk7CiAJCWdvdG8gZmFpbDsKIAl9CiAJbWRwNF9sY2RjX2VuY29kZXIt PnJlZ3NbMF0gPSByZWc7CkBAIC00NzgsNyArNDc4LDcgQEAgc3RydWN0IGRybV9lbmNvZGVyICpt ZHA0X2xjZGNfZW5jb2Rlcl9pbml0KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsCiAJcmVnID0gZGV2 bV9yZWd1bGF0b3JfZ2V0KGRldi0+ZGV2LCAibHZkcy1wbGwtdmRkYSIpOwogCWlmIChJU19FUlIo cmVnKSkgewogCQlyZXQgPSBQVFJfRVJSKHJlZyk7Ci0JCWRldl9lcnIoZGV2LT5kZXYsICJmYWls ZWQgdG8gZ2V0IGx2ZHMtcGxsLXZkZGE6ICVkXG4iLCByZXQpOworCQlEUk1fREVWX0VSUk9SKGRl di0+ZGV2LCAiZmFpbGVkIHRvIGdldCBsdmRzLXBsbC12ZGRhOiAlZFxuIiwgcmV0KTsKIAkJZ290 byBmYWlsOwogCX0KIAltZHA0X2xjZGNfZW5jb2Rlci0+cmVnc1sxXSA9IHJlZzsKQEAgLTQ4Niw3 ICs0ODYsNyBAQCBzdHJ1Y3QgZHJtX2VuY29kZXIgKm1kcDRfbGNkY19lbmNvZGVyX2luaXQoc3Ry dWN0IGRybV9kZXZpY2UgKmRldiwKIAlyZWcgPSBkZXZtX3JlZ3VsYXRvcl9nZXQoZGV2LT5kZXYs ICJsdmRzLXZkZGEiKTsKIAlpZiAoSVNfRVJSKHJlZykpIHsKIAkJcmV0ID0gUFRSX0VSUihyZWcp OwotCQlkZXZfZXJyKGRldi0+ZGV2LCAiZmFpbGVkIHRvIGdldCBsdmRzLXZkZGE6ICVkXG4iLCBy ZXQpOworCQlEUk1fREVWX0VSUk9SKGRldi0+ZGV2LCAiZmFpbGVkIHRvIGdldCBsdmRzLXZkZGE6 ICVkXG4iLCByZXQpOwogCQlnb3RvIGZhaWw7CiAJfQogCW1kcDRfbGNkY19lbmNvZGVyLT5yZWdz WzJdID0gcmVnOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL21kcDQvbWRw NF9wbGFuZS5jIGIvZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL21kcDQvbWRwNF9wbGFuZS5jCmlu ZGV4IDdhNDk5NzMuLjAwNTA2NmYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9tc20vZGlz cC9tZHA0L21kcDRfcGxhbmUuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3AvbWRwNC9t ZHA0X3BsYW5lLmMKQEAgLTIzNCwyMiArMjM0LDIyIEBAIHN0YXRpYyBpbnQgbWRwNF9wbGFuZV9t b2RlX3NldChzdHJ1Y3QgZHJtX3BsYW5lICpwbGFuZSwKIAlmb3JtYXQgPSB0b19tZHBfZm9ybWF0 KG1zbV9mcmFtZWJ1ZmZlcl9mb3JtYXQoZmIpKTsKIAogCWlmIChzcmNfdyA+IChjcnRjX3cgKiBE T1dOX1NDQUxFX01BWCkpIHsKLQkJZGV2X2VycihkZXYtPmRldiwgIldpZHRoIGRvd24gc2NhbGlu ZyBleGNlZWRzIGxpbWl0cyFcbiIpOworCQlEUk1fREVWX0VSUk9SKGRldi0+ZGV2LCAiV2lkdGgg ZG93biBzY2FsaW5nIGV4Y2VlZHMgbGltaXRzIVxuIik7CiAJCXJldHVybiAtRVJBTkdFOwogCX0K IAogCWlmIChzcmNfaCA+IChjcnRjX2ggKiBET1dOX1NDQUxFX01BWCkpIHsKLQkJZGV2X2Vycihk ZXYtPmRldiwgIkhlaWdodCBkb3duIHNjYWxpbmcgZXhjZWVkcyBsaW1pdHMhXG4iKTsKKwkJRFJN X0RFVl9FUlJPUihkZXYtPmRldiwgIkhlaWdodCBkb3duIHNjYWxpbmcgZXhjZWVkcyBsaW1pdHMh XG4iKTsKIAkJcmV0dXJuIC1FUkFOR0U7CiAJfQogCiAJaWYgKGNydGNfdyA+IChzcmNfdyAqIFVQ X1NDQUxFX01BWCkpIHsKLQkJZGV2X2VycihkZXYtPmRldiwgIldpZHRoIHVwIHNjYWxpbmcgZXhj ZWVkcyBsaW1pdHMhXG4iKTsKKwkJRFJNX0RFVl9FUlJPUihkZXYtPmRldiwgIldpZHRoIHVwIHNj YWxpbmcgZXhjZWVkcyBsaW1pdHMhXG4iKTsKIAkJcmV0dXJuIC1FUkFOR0U7CiAJfQogCiAJaWYg KGNydGNfaCA+IChzcmNfaCAqIFVQX1NDQUxFX01BWCkpIHsKLQkJZGV2X2VycihkZXYtPmRldiwg IkhlaWdodCB1cCBzY2FsaW5nIGV4Y2VlZHMgbGltaXRzIVxuIik7CisJCURSTV9ERVZfRVJST1Io ZGV2LT5kZXYsICJIZWlnaHQgdXAgc2NhbGluZyBleGNlZWRzIGxpbWl0cyFcbiIpOwogCQlyZXR1 cm4gLUVSQU5HRTsKIAl9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9tc20vZGlzcC9t ZHA1L21kcDVfY2ZnLmMgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3AvbWRwNS9tZHA1X2NmZy5j CmluZGV4IDgyNDA2N2QuLjQyZjllNGIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9tc20v ZGlzcC9tZHA1L21kcDVfY2ZnLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL21kcDUv bWRwNV9jZmcuYwpAQCAtNjAwLDcgKzYwMCw3IEBAIHN0cnVjdCBtZHA1X2NmZ19oYW5kbGVyICpt ZHA1X2NmZ19pbml0KHN0cnVjdCBtZHA1X2ttcyAqbWRwNV9rbXMsCiAJfQogCiAJaWYgKG1ham9y ICE9IDEpIHsKLQkJZGV2X2VycihkZXYtPmRldiwgInVuZXhwZWN0ZWQgTURQIG1ham9yIHZlcnNp b246IHYlZC4lZFxuIiwKKwkJRFJNX0RFVl9FUlJPUihkZXYtPmRldiwgInVuZXhwZWN0ZWQgTURQ IG1ham9yIHZlcnNpb246IHYlZC4lZFxuIiwKIAkJCQltYWpvciwgbWlub3IpOwogCQlyZXQgPSAt RU5YSU87CiAJCWdvdG8gZmFpbDsKQEAgLTYxNSw3ICs2MTUsNyBAQCBzdHJ1Y3QgbWRwNV9jZmdf aGFuZGxlciAqbWRwNV9jZmdfaW5pdChzdHJ1Y3QgbWRwNV9rbXMgKm1kcDVfa21zLAogCQlicmVh azsKIAl9CiAJaWYgKHVubGlrZWx5KCFtZHA1X2NmZykpIHsKLQkJZGV2X2VycihkZXYtPmRldiwg InVuZXhwZWN0ZWQgTURQIG1pbm9yIHJldmlzaW9uOiB2JWQuJWRcbiIsCisJCURSTV9ERVZfRVJS T1IoZGV2LT5kZXYsICJ1bmV4cGVjdGVkIE1EUCBtaW5vciByZXZpc2lvbjogdiVkLiVkXG4iLAog CQkJCW1ham9yLCBtaW5vcik7CiAJCXJldCA9IC1FTlhJTzsKIAkJZ290byBmYWlsOwpkaWZmIC0t Z2l0IGEvZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL21kcDUvbWRwNV9jbWRfZW5jb2Rlci5jIGIv ZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL21kcDUvbWRwNV9jbWRfZW5jb2Rlci5jCmluZGV4IGQ2 Zjc5ZGMuLmMxOTYyZjIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9tc20vZGlzcC9tZHA1 L21kcDVfY21kX2VuY29kZXIuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3AvbWRwNS9t ZHA1X2NtZF9lbmNvZGVyLmMKQEAgLTU1LDIwICs1NSwyMCBAQCBzdGF0aWMgaW50IHBpbmdwb25n X3RlYXJjaGVja19zZXR1cChzdHJ1Y3QgZHJtX2VuY29kZXIgKmVuY29kZXIsCiAJaW50IHBwX2lk ID0gbWl4ZXItPnBwOwogCiAJaWYgKElTX0VSUl9PUl9OVUxMKG1kcDVfa21zLT52c3luY19jbGsp KSB7Ci0JCWRldl9lcnIoZGV2LCAidnN5bmNfY2xrIGlzIG5vdCBpbml0aWFsaXplZFxuIik7CisJ CURSTV9ERVZfRVJST1IoZGV2LCAidnN5bmNfY2xrIGlzIG5vdCBpbml0aWFsaXplZFxuIik7CiAJ CXJldHVybiAtRUlOVkFMOwogCX0KIAogCXRvdGFsX2xpbmVzX3gxMDAgPSBtb2RlLT52dG90YWwg KiBtb2RlLT52cmVmcmVzaDsKIAlpZiAoIXRvdGFsX2xpbmVzX3gxMDApIHsKLQkJZGV2X2Vycihk ZXYsICIlczogdnRvdGFsKCVkKSBvciB2cmVmcmVzaCglZCkgaXMgMFxuIiwKKwkJRFJNX0RFVl9F UlJPUihkZXYsICIlczogdnRvdGFsKCVkKSBvciB2cmVmcmVzaCglZCkgaXMgMFxuIiwKIAkJCQlf X2Z1bmNfXywgbW9kZS0+dnRvdGFsLCBtb2RlLT52cmVmcmVzaCk7CiAJCXJldHVybiAtRUlOVkFM OwogCX0KIAogCXZzeW5jX2Nsa19zcGVlZCA9IGNsa19yb3VuZF9yYXRlKG1kcDVfa21zLT52c3lu Y19jbGssIFZTWU5DX0NMS19SQVRFKTsKIAlpZiAodnN5bmNfY2xrX3NwZWVkIDw9IDApIHsKLQkJ ZGV2X2VycihkZXYsICJ2c3luY19jbGsgcm91bmQgcmF0ZSBmYWlsZWQgJWxkXG4iLAorCQlEUk1f REVWX0VSUk9SKGRldiwgInZzeW5jX2NsayByb3VuZCByYXRlIGZhaWxlZCAlbGRcbiIsCiAJCQkJ CQkJdnN5bmNfY2xrX3NwZWVkKTsKIAkJcmV0dXJuIC1FSU5WQUw7CiAJfQpAQCAtMTAyLDEzICsx MDIsMTMgQEAgc3RhdGljIGludCBwaW5ncG9uZ190ZWFyY2hlY2tfZW5hYmxlKHN0cnVjdCBkcm1f ZW5jb2RlciAqZW5jb2RlcikKIAlyZXQgPSBjbGtfc2V0X3JhdGUobWRwNV9rbXMtPnZzeW5jX2Ns aywKIAkJY2xrX3JvdW5kX3JhdGUobWRwNV9rbXMtPnZzeW5jX2NsaywgVlNZTkNfQ0xLX1JBVEUp KTsKIAlpZiAocmV0KSB7Ci0JCWRldl9lcnIoZW5jb2Rlci0+ZGV2LT5kZXYsCisJCURSTV9ERVZf RVJST1IoZW5jb2Rlci0+ZGV2LT5kZXYsCiAJCQkidnN5bmNfY2xrIGNsa19zZXRfcmF0ZSBmYWls ZWQsICVkXG4iLCByZXQpOwogCQlyZXR1cm4gcmV0OwogCX0KIAlyZXQgPSBjbGtfcHJlcGFyZV9l bmFibGUobWRwNV9rbXMtPnZzeW5jX2Nsayk7CiAJaWYgKHJldCkgewotCQlkZXZfZXJyKGVuY29k ZXItPmRldi0+ZGV2LAorCQlEUk1fREVWX0VSUk9SKGVuY29kZXItPmRldi0+ZGV2LAogCQkJInZz eW5jX2NsayBjbGtfcHJlcGFyZV9lbmFibGUgZmFpbGVkLCAlZFxuIiwgcmV0KTsKIAkJcmV0dXJu IHJldDsKIAl9CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3AvbWRwNS9tZHA1 X2NydGMuYyBiL2RyaXZlcnMvZ3B1L2RybS9tc20vZGlzcC9tZHA1L21kcDVfY3J0Yy5jCmluZGV4 IGIxZGE5Y2UuLjQxM2I1MjIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9tc20vZGlzcC9t ZHA1L21kcDVfY3J0Yy5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9tc20vZGlzcC9tZHA1L21kcDVf Y3J0Yy5jCkBAIC02NjIsNyArNjYyLDcgQEAgc3RhdGljIGludCBtZHA1X2NydGNfYXRvbWljX2No ZWNrKHN0cnVjdCBkcm1fY3J0YyAqY3J0YywKIAogCXJldCA9IG1kcDVfY3J0Y19zZXR1cF9waXBl bGluZShjcnRjLCBzdGF0ZSwgbmVlZF9yaWdodF9taXhlcik7CiAJaWYgKHJldCkgewotCQlkZXZf ZXJyKGRldi0+ZGV2LCAiY291bGRuJ3QgYXNzaWduIG1peGVycyAlZFxuIiwgcmV0KTsKKwkJRFJN X0RFVl9FUlJPUihkZXYtPmRldiwgImNvdWxkbid0IGFzc2lnbiBtaXhlcnMgJWRcbiIsIHJldCk7 CiAJCXJldHVybiByZXQ7CiAJfQogCkBAIC02NzksNyArNjc5LDcgQEAgc3RhdGljIGludCBtZHA1 X2NydGNfYXRvbWljX2NoZWNrKHN0cnVjdCBkcm1fY3J0YyAqY3J0YywKIAkgKiBhbmQgdGhhdCB3 ZSBkb24ndCBoYXZlIGNvbmZsaWN0aW5nIG1peGVyIHN0YWdlczoKIAkgKi8KIAlpZiAoKGNudCAr IHN0YXJ0IC0gMSkgPj0gaHdfY2ZnLT5sbS5uYl9zdGFnZXMpIHsKLQkJZGV2X2VycihkZXYtPmRl diwgInRvbyBtYW55IHBsYW5lcyEgY250PSVkLCBzdGFydCBzdGFnZT0lZFxuIiwKKwkJRFJNX0RF Vl9FUlJPUihkZXYtPmRldiwgInRvbyBtYW55IHBsYW5lcyEgY250PSVkLCBzdGFydCBzdGFnZT0l ZFxuIiwKIAkJCWNudCwgc3RhcnQpOwogCQlyZXR1cm4gLUVJTlZBTDsKIAl9CkBAIC04NzksNyAr ODc5LDcgQEAgc3RhdGljIGludCBtZHA1X2NydGNfY3Vyc29yX3NldChzdHJ1Y3QgZHJtX2NydGMg KmNydGMsCiAJfQogCiAJaWYgKCh3aWR0aCA+IENVUlNPUl9XSURUSCkgfHwgKGhlaWdodCA+IENV UlNPUl9IRUlHSFQpKSB7Ci0JCWRldl9lcnIoZGV2LT5kZXYsICJiYWQgY3Vyc29yIHNpemU6ICVk eCVkXG4iLCB3aWR0aCwgaGVpZ2h0KTsKKwkJRFJNX0RFVl9FUlJPUihkZXYtPmRldiwgImJhZCBj dXJzb3Igc2l6ZTogJWR4JWRcbiIsIHdpZHRoLCBoZWlnaHQpOwogCQlyZXR1cm4gLUVJTlZBTDsK IAl9CiAKQEAgLTkyNCw3ICs5MjQsNyBAQCBzdGF0aWMgaW50IG1kcDVfY3J0Y19jdXJzb3Jfc2V0 KHN0cnVjdCBkcm1fY3J0YyAqY3J0YywKIHNldF9jdXJzb3I6CiAJcmV0ID0gbWRwNV9jdGxfc2V0 X2N1cnNvcihjdGwsIHBpcGVsaW5lLCAwLCBjdXJzb3JfZW5hYmxlKTsKIAlpZiAocmV0KSB7Ci0J CWRldl9lcnIoZGV2LT5kZXYsICJmYWlsZWQgdG8gJXNhYmxlIGN1cnNvcjogJWRcbiIsCisJCURS TV9ERVZfRVJST1IoZGV2LT5kZXYsICJmYWlsZWQgdG8gJXNhYmxlIGN1cnNvcjogJWRcbiIsCiAJ CQkJY3Vyc29yX2VuYWJsZSA/ICJlbiIgOiAiZGlzIiwgcmV0KTsKIAkJZ290byBlbmQ7CiAJfQpk aWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL21kcDUvbWRwNV9jdGwuYyBiL2Ry aXZlcnMvZ3B1L2RybS9tc20vZGlzcC9tZHA1L21kcDVfY3RsLmMKaW5kZXggZjkzZDU2OC4uNjVh ODcxZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL21kcDUvbWRwNV9jdGwu YworKysgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3AvbWRwNS9tZHA1X2N0bC5jCkBAIC0yNjIs MTMgKzI2MiwxMyBAQCBpbnQgbWRwNV9jdGxfc2V0X2N1cnNvcihzdHJ1Y3QgbWRwNV9jdGwgKmN0 bCwgc3RydWN0IG1kcDVfcGlwZWxpbmUgKnBpcGVsaW5lLAogCXN0cnVjdCBtZHA1X2h3X21peGVy ICptaXhlciA9IHBpcGVsaW5lLT5taXhlcjsKIAogCWlmICh1bmxpa2VseShXQVJOX09OKCFtaXhl cikpKSB7Ci0JCWRldl9lcnIoY3RsX21nci0+ZGV2LT5kZXYsICJDVEwgJWQgY2Fubm90IGZpbmQg TE0iLAorCQlEUk1fREVWX0VSUk9SKGN0bF9tZ3ItPmRldi0+ZGV2LCAiQ1RMICVkIGNhbm5vdCBm aW5kIExNIiwKIAkJCWN0bC0+aWQpOwogCQlyZXR1cm4gLUVJTlZBTDsKIAl9CiAKIAlpZiAocGlw ZWxpbmUtPnJfbWl4ZXIpIHsKLQkJZGV2X2VycihjdGxfbWdyLT5kZXYtPmRldiwgInVuc3VwcG9y dGVkIGNvbmZpZ3VyYXRpb24iKTsKKwkJRFJNX0RFVl9FUlJPUihjdGxfbWdyLT5kZXYtPmRldiwg InVuc3VwcG9ydGVkIGNvbmZpZ3VyYXRpb24iKTsKIAkJcmV0dXJuIC1FSU5WQUw7CiAJfQogCkBA IC02MDQsMTAgKzYwNCwxMCBAQCBpbnQgbWRwNV9jdGxfcGFpcihzdHJ1Y3QgbWRwNV9jdGwgKmN0 bHgsIHN0cnVjdCBtZHA1X2N0bCAqY3RseSwgYm9vbCBlbmFibGUpCiAJCW1kcDVfd3JpdGUobWRw NV9rbXMsIFJFR19NRFA1X1NQQVJFXzAsIDApOwogCQlyZXR1cm4gMDsKIAl9IGVsc2UgaWYgKChj dGx4LT5wYWlyICE9IE5VTEwpIHx8IChjdGx5LT5wYWlyICE9IE5VTEwpKSB7Ci0JCWRldl9lcnIo Y3RsX21nci0+ZGV2LT5kZXYsICJDVExzIGFscmVhZHkgcGFpcmVkXG4iKTsKKwkJRFJNX0RFVl9F UlJPUihjdGxfbWdyLT5kZXYtPmRldiwgIkNUTHMgYWxyZWFkeSBwYWlyZWRcbiIpOwogCQlyZXR1 cm4gLUVJTlZBTDsKIAl9IGVsc2UgaWYgKCEoY3RseC0+c3RhdHVzICYgY3RseS0+c3RhdHVzICYg Q1RMX1NUQVRfQk9PS0VEKSkgewotCQlkZXZfZXJyKGN0bF9tZ3ItPmRldi0+ZGV2LCAiT25seSBw YWlyIGJvb2tlZCBDVExzXG4iKTsKKwkJRFJNX0RFVl9FUlJPUihjdGxfbWdyLT5kZXYtPmRldiwg Ik9ubHkgcGFpciBib29rZWQgQ1RMc1xuIik7CiAJCXJldHVybiAtRUlOVkFMOwogCX0KIApAQCAt NjUyLDcgKzY1Miw3IEBAIHN0cnVjdCBtZHA1X2N0bCAqbWRwNV9jdGxtX3JlcXVlc3Qoc3RydWN0 IG1kcDVfY3RsX21hbmFnZXIgKmN0bF9tZ3IsCiAJCWlmICgoY3RsX21nci0+Y3Rsc1tjXS5zdGF0 dXMgJiBjaGVja20pID09IG1hdGNoKQogCQkJZ290byBmb3VuZDsKIAotCWRldl9lcnIoY3RsX21n ci0+ZGV2LT5kZXYsICJObyBtb3JlIENUTCBhdmFpbGFibGUhIik7CisJRFJNX0RFVl9FUlJPUihj dGxfbWdyLT5kZXYtPmRldiwgIk5vIG1vcmUgQ1RMIGF2YWlsYWJsZSEiKTsKIAlnb3RvIHVubG9j azsKIAogZm91bmQ6CkBAIC02OTgsMTMgKzY5OCwxMyBAQCBzdHJ1Y3QgbWRwNV9jdGxfbWFuYWdl ciAqbWRwNV9jdGxtX2luaXQoc3RydWN0IGRybV9kZXZpY2UgKmRldiwKIAogCWN0bF9tZ3IgPSBr emFsbG9jKHNpemVvZigqY3RsX21nciksIEdGUF9LRVJORUwpOwogCWlmICghY3RsX21ncikgewot CQlkZXZfZXJyKGRldi0+ZGV2LCAiZmFpbGVkIHRvIGFsbG9jYXRlIENUTCBtYW5hZ2VyXG4iKTsK KwkJRFJNX0RFVl9FUlJPUihkZXYtPmRldiwgImZhaWxlZCB0byBhbGxvY2F0ZSBDVEwgbWFuYWdl clxuIik7CiAJCXJldCA9IC1FTk9NRU07CiAJCWdvdG8gZmFpbDsKIAl9CiAKIAlpZiAodW5saWtl bHkoV0FSTl9PTihjdGxfY2ZnLT5jb3VudCA+IE1BWF9DVEwpKSkgewotCQlkZXZfZXJyKGRldi0+ ZGV2LCAiSW5jcmVhc2Ugc3RhdGljIHBvb2wgc2l6ZSB0byBhdCBsZWFzdCAlZFxuIiwKKwkJRFJN X0RFVl9FUlJPUihkZXYtPmRldiwgIkluY3JlYXNlIHN0YXRpYyBwb29sIHNpemUgdG8gYXQgbGVh c3QgJWRcbiIsCiAJCQkJY3RsX2NmZy0+Y291bnQpOwogCQlyZXQgPSAtRU5PU1BDOwogCQlnb3Rv IGZhaWw7CkBAIC03MjMsNyArNzIzLDcgQEAgc3RydWN0IG1kcDVfY3RsX21hbmFnZXIgKm1kcDVf Y3RsbV9pbml0KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsCiAJCXN0cnVjdCBtZHA1X2N0bCAqY3Rs ID0gJmN0bF9tZ3ItPmN0bHNbY107CiAKIAkJaWYgKFdBUk5fT04oIWN0bF9jZmctPmJhc2VbY10p KSB7Ci0JCQlkZXZfZXJyKGRldi0+ZGV2LCAiQ1RMXyVkOiBiYXNlIGlzIG51bGwhXG4iLCBjKTsK KwkJCURSTV9ERVZfRVJST1IoZGV2LT5kZXYsICJDVExfJWQ6IGJhc2UgaXMgbnVsbCFcbiIsIGMp OwogCQkJcmV0ID0gLUVJTlZBTDsKIAkJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmN0bF9tZ3It PnBvb2xfbG9jaywgZmxhZ3MpOwogCQkJZ290byBmYWlsOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9n cHUvZHJtL21zbS9kaXNwL21kcDUvbWRwNV9rbXMuYyBiL2RyaXZlcnMvZ3B1L2RybS9tc20vZGlz cC9tZHA1L21kcDVfa21zLmMKaW5kZXggYmRkZDYyNS4uZDI3ZTM1YSAxMDA2NDQKLS0tIGEvZHJp dmVycy9ncHUvZHJtL21zbS9kaXNwL21kcDUvbWRwNV9rbXMuYworKysgYi9kcml2ZXJzL2dwdS9k cm0vbXNtL2Rpc3AvbWRwNS9tZHA1X2ttcy5jCkBAIC0yNjQsNyArMjY0LDcgQEAgc3RhdGljIGlu dCBtZHA1X2ttc19kZWJ1Z2ZzX2luaXQoc3RydWN0IG1zbV9rbXMgKmttcywgc3RydWN0IGRybV9t aW5vciAqbWlub3IpCiAJCQltaW5vci0+ZGVidWdmc19yb290LCBtaW5vcik7CiAKIAlpZiAocmV0 KSB7Ci0JCWRldl9lcnIoZGV2LT5kZXYsICJjb3VsZCBub3QgaW5zdGFsbCBtZHA1X2RlYnVnZnNf bGlzdFxuIik7CisJCURSTV9ERVZfRVJST1IoZGV2LT5kZXYsICJjb3VsZCBub3QgaW5zdGFsbCBt ZHA1X2RlYnVnZnNfbGlzdFxuIik7CiAJCXJldHVybiByZXQ7CiAJfQogCkBAIC0zMzcsNyArMzM3 LDcgQEAgc3RhdGljIHN0cnVjdCBkcm1fZW5jb2RlciAqY29uc3RydWN0X2VuY29kZXIoc3RydWN0 IG1kcDVfa21zICptZHA1X2ttcywKIAogCWVuY29kZXIgPSBtZHA1X2VuY29kZXJfaW5pdChkZXYs IGludGYsIGN0bCk7CiAJaWYgKElTX0VSUihlbmNvZGVyKSkgewotCQlkZXZfZXJyKGRldi0+ZGV2 LCAiZmFpbGVkIHRvIGNvbnN0cnVjdCBlbmNvZGVyXG4iKTsKKwkJRFJNX0RFVl9FUlJPUihkZXYt PmRldiwgImZhaWxlZCB0byBjb25zdHJ1Y3QgZW5jb2RlclxuIik7CiAJCXJldHVybiBlbmNvZGVy OwogCX0KIApAQCAtNDE4LDcgKzQxOCw3IEBAIHN0YXRpYyBpbnQgbW9kZXNldF9pbml0X2ludGYo c3RydWN0IG1kcDVfa21zICptZHA1X2ttcywKIAkJaW50IGRzaV9pZCA9IGdldF9kc2lfaWRfZnJv bV9pbnRmKGh3X2NmZywgaW50Zi0+bnVtKTsKIAogCQlpZiAoKGRzaV9pZCA+PSBBUlJBWV9TSVpF KHByaXYtPmRzaSkpIHx8IChkc2lfaWQgPCAwKSkgewotCQkJZGV2X2VycihkZXYtPmRldiwgImZh aWxlZCB0byBmaW5kIGRzaSBmcm9tIGludGYgJWRcbiIsCisJCQlEUk1fREVWX0VSUk9SKGRldi0+ ZGV2LCAiZmFpbGVkIHRvIGZpbmQgZHNpIGZyb20gaW50ZiAlZFxuIiwKIAkJCQlpbnRmLT5udW0p OwogCQkJcmV0ID0gLUVJTlZBTDsKIAkJCWJyZWFrOwpAQCAtNDQzLDcgKzQ0Myw3IEBAIHN0YXRp YyBpbnQgbW9kZXNldF9pbml0X2ludGYoc3RydWN0IG1kcDVfa21zICptZHA1X2ttcywKIAkJYnJl YWs7CiAJfQogCWRlZmF1bHQ6Ci0JCWRldl9lcnIoZGV2LT5kZXYsICJ1bmtub3duIGludGY6ICVk XG4iLCBpbnRmLT50eXBlKTsKKwkJRFJNX0RFVl9FUlJPUihkZXYtPmRldiwgInVua25vd24gaW50 ZjogJWRcbiIsIGludGYtPnR5cGUpOwogCQlyZXQgPSAtRUlOVkFMOwogCQlicmVhazsKIAl9CkBA IC01MDAsNyArNTAwLDcgQEAgc3RhdGljIGludCBtb2Rlc2V0X2luaXQoc3RydWN0IG1kcDVfa21z ICptZHA1X2ttcykKIAkJcGxhbmUgPSBtZHA1X3BsYW5lX2luaXQoZGV2LCB0eXBlKTsKIAkJaWYg KElTX0VSUihwbGFuZSkpIHsKIAkJCXJldCA9IFBUUl9FUlIocGxhbmUpOwotCQkJZGV2X2Vycihk ZXYtPmRldiwgImZhaWxlZCB0byBjb25zdHJ1Y3QgcGxhbmUgJWQgKCVkKVxuIiwgaSwgcmV0KTsK KwkJCURSTV9ERVZfRVJST1IoZGV2LT5kZXYsICJmYWlsZWQgdG8gY29uc3RydWN0IHBsYW5lICVk ICglZClcbiIsIGksIHJldCk7CiAJCQlnb3RvIGZhaWw7CiAJCX0KIAkJcHJpdi0+cGxhbmVzW3By aXYtPm51bV9wbGFuZXMrK10gPSBwbGFuZTsKQEAgLTUxNyw3ICs1MTcsNyBAQCBzdGF0aWMgaW50 IG1vZGVzZXRfaW5pdChzdHJ1Y3QgbWRwNV9rbXMgKm1kcDVfa21zKQogCQljcnRjICA9IG1kcDVf Y3J0Y19pbml0KGRldiwgcHJpbWFyeVtpXSwgY3Vyc29yW2ldLCBpKTsKIAkJaWYgKElTX0VSUihj cnRjKSkgewogCQkJcmV0ID0gUFRSX0VSUihjcnRjKTsKLQkJCWRldl9lcnIoZGV2LT5kZXYsICJm YWlsZWQgdG8gY29uc3RydWN0IGNydGMgJWQgKCVkKVxuIiwgaSwgcmV0KTsKKwkJCURSTV9ERVZf RVJST1IoZGV2LT5kZXYsICJmYWlsZWQgdG8gY29uc3RydWN0IGNydGMgJWQgKCVkKVxuIiwgaSwg cmV0KTsKIAkJCWdvdG8gZmFpbDsKIAkJfQogCQlwcml2LT5jcnRjc1twcml2LT5udW1fY3J0Y3Mr K10gPSBjcnRjOwpAQCAtNTUyLDcgKzU1Miw3IEBAIHN0YXRpYyB2b2lkIHJlYWRfbWRwX2h3X3Jl dmlzaW9uKHN0cnVjdCBtZHA1X2ttcyAqbWRwNV9rbXMsCiAJKm1ham9yID0gRklFTEQodmVyc2lv biwgTURQNV9IV19WRVJTSU9OX01BSk9SKTsKIAkqbWlub3IgPSBGSUVMRCh2ZXJzaW9uLCBNRFA1 X0hXX1ZFUlNJT05fTUlOT1IpOwogCi0JZGV2X2luZm8oZGV2LCAiTURQNSB2ZXJzaW9uIHYlZC4l ZCIsICptYWpvciwgKm1pbm9yKTsKKwlEUk1fREVWX0lORk8oZGV2LCAiTURQNSB2ZXJzaW9uIHYl ZC4lZCIsICptYWpvciwgKm1pbm9yKTsKIH0KIAogc3RhdGljIGludCBnZXRfY2xrKHN0cnVjdCBw bGF0Zm9ybV9kZXZpY2UgKnBkZXYsIHN0cnVjdCBjbGsgKipjbGtwLApAQCAtNTYxLDcgKzU2MSw3 IEBAIHN0YXRpYyBpbnQgZ2V0X2NsayhzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2LCBzdHJ1 Y3QgY2xrICoqY2xrcCwKIAlzdHJ1Y3QgZGV2aWNlICpkZXYgPSAmcGRldi0+ZGV2OwogCXN0cnVj dCBjbGsgKmNsayA9IG1zbV9jbGtfZ2V0KHBkZXYsIG5hbWUpOwogCWlmIChJU19FUlIoY2xrKSAm JiBtYW5kYXRvcnkpIHsKLQkJZGV2X2VycihkZXYsICJmYWlsZWQgdG8gZ2V0ICVzICglbGQpXG4i LCBuYW1lLCBQVFJfRVJSKGNsaykpOworCQlEUk1fREVWX0VSUk9SKGRldiwgImZhaWxlZCB0byBn ZXQgJXMgKCVsZClcbiIsIG5hbWUsIFBUUl9FUlIoY2xrKSk7CiAJCXJldHVybiBQVFJfRVJSKGNs ayk7CiAJfQogCWlmIChJU19FUlIoY2xrKSkKQEAgLTY4OCw3ICs2ODgsNyBAQCBzdHJ1Y3QgbXNt X2ttcyAqbWRwNV9rbXNfaW5pdChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2KQogCWlycSA9IGlycV9v Zl9wYXJzZV9hbmRfbWFwKHBkZXYtPmRldi5vZl9ub2RlLCAwKTsKIAlpZiAoaXJxIDwgMCkgewog CQlyZXQgPSBpcnE7Ci0JCWRldl9lcnIoJnBkZXYtPmRldiwgImZhaWxlZCB0byBnZXQgaXJxOiAl ZFxuIiwgcmV0KTsKKwkJRFJNX0RFVl9FUlJPUigmcGRldi0+ZGV2LCAiZmFpbGVkIHRvIGdldCBp cnE6ICVkXG4iLCByZXQpOwogCQlnb3RvIGZhaWw7CiAJfQogCkBAIC03MjQsMTIgKzcyNCwxMiBA QCBzdHJ1Y3QgbXNtX2ttcyAqbWRwNV9rbXNfaW5pdChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2KQog CQlyZXQgPSBhc3BhY2UtPm1tdS0+ZnVuY3MtPmF0dGFjaChhc3BhY2UtPm1tdSwgaW9tbXVfcG9y dHMsCiAJCQkJQVJSQVlfU0laRShpb21tdV9wb3J0cykpOwogCQlpZiAocmV0KSB7Ci0JCQlkZXZf ZXJyKCZwZGV2LT5kZXYsICJmYWlsZWQgdG8gYXR0YWNoIGlvbW11OiAlZFxuIiwKKwkJCURSTV9E RVZfRVJST1IoJnBkZXYtPmRldiwgImZhaWxlZCB0byBhdHRhY2ggaW9tbXU6ICVkXG4iLAogCQkJ CXJldCk7CiAJCQlnb3RvIGZhaWw7CiAJCX0KIAl9IGVsc2UgewotCQlkZXZfaW5mbygmcGRldi0+ ZGV2LAorCQlEUk1fREVWX0lORk8oJnBkZXYtPmRldiwKIAkJCSAibm8gaW9tbXUsIGZhbGxiYWNr IHRvIHBoeXMgY29udGlnIGJ1ZmZlcnMgZm9yIHNjYW5vdXRcbiIpOwogCQlhc3BhY2UgPSBOVUxM OwogCX0KQEAgLTczOCw3ICs3MzgsNyBAQCBzdHJ1Y3QgbXNtX2ttcyAqbWRwNV9rbXNfaW5pdChz dHJ1Y3QgZHJtX2RldmljZSAqZGV2KQogCiAJcmV0ID0gbW9kZXNldF9pbml0KG1kcDVfa21zKTsK IAlpZiAocmV0KSB7Ci0JCWRldl9lcnIoJnBkZXYtPmRldiwgIm1vZGVzZXRfaW5pdCBmYWlsZWQ6 ICVkXG4iLCByZXQpOworCQlEUk1fREVWX0VSUk9SKCZwZGV2LT5kZXYsICJtb2Rlc2V0X2luaXQg ZmFpbGVkOiAlZFxuIiwgcmV0KTsKIAkJZ290byBmYWlsOwogCX0KIApAQCAtNzk1LDcgKzc5NSw3 IEBAIHN0YXRpYyBpbnQgY29uc3RydWN0X3BpcGVzKHN0cnVjdCBtZHA1X2ttcyAqbWRwNV9rbXMs IGludCBjbnQsCiAJCWh3cGlwZSA9IG1kcDVfcGlwZV9pbml0KHBpcGVzW2ldLCBvZmZzZXRzW2ld LCBjYXBzKTsKIAkJaWYgKElTX0VSUihod3BpcGUpKSB7CiAJCQlyZXQgPSBQVFJfRVJSKGh3cGlw ZSk7Ci0JCQlkZXZfZXJyKGRldi0+ZGV2LCAiZmFpbGVkIHRvIGNvbnN0cnVjdCBwaXBlIGZvciAl cyAoJWQpXG4iLAorCQkJRFJNX0RFVl9FUlJPUihkZXYtPmRldiwgImZhaWxlZCB0byBjb25zdHJ1 Y3QgcGlwZSBmb3IgJXMgKCVkKVxuIiwKIAkJCQkJcGlwZTJuYW1lKHBpcGVzW2ldKSwgcmV0KTsK IAkJCXJldHVybiByZXQ7CiAJCX0KQEAgLTg2Nyw3ICs4NjcsNyBAQCBzdGF0aWMgaW50IGh3bWl4 ZXJfaW5pdChzdHJ1Y3QgbWRwNV9rbXMgKm1kcDVfa21zKQogCQltaXhlciA9IG1kcDVfbWl4ZXJf aW5pdCgmaHdfY2ZnLT5sbS5pbnN0YW5jZXNbaV0pOwogCQlpZiAoSVNfRVJSKG1peGVyKSkgewog CQkJcmV0ID0gUFRSX0VSUihtaXhlcik7Ci0JCQlkZXZfZXJyKGRldi0+ZGV2LCAiZmFpbGVkIHRv IGNvbnN0cnVjdCBMTSVkICglZClcbiIsCisJCQlEUk1fREVWX0VSUk9SKGRldi0+ZGV2LCAiZmFp bGVkIHRvIGNvbnN0cnVjdCBMTSVkICglZClcbiIsCiAJCQkJaSwgcmV0KTsKIAkJCXJldHVybiBy ZXQ7CiAJCX0KQEAgLTg5Nyw3ICs4OTcsNyBAQCBzdGF0aWMgaW50IGludGVyZmFjZV9pbml0KHN0 cnVjdCBtZHA1X2ttcyAqbWRwNV9rbXMpCiAKIAkJaW50ZiA9IGt6YWxsb2Moc2l6ZW9mKCppbnRm KSwgR0ZQX0tFUk5FTCk7CiAJCWlmICghaW50ZikgewotCQkJZGV2X2VycihkZXYtPmRldiwgImZh aWxlZCB0byBjb25zdHJ1Y3QgSU5URiVkXG4iLCBpKTsKKwkJCURSTV9ERVZfRVJST1IoZGV2LT5k ZXYsICJmYWlsZWQgdG8gY29uc3RydWN0IElOVEYlZFxuIiwgaSk7CiAJCQlyZXR1cm4gLUVOT01F TTsKIAkJfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3AvbWRwNS9tZHA1 X21kc3MuYyBiL2RyaXZlcnMvZ3B1L2RybS9tc20vZGlzcC9tZHA1L21kcDVfbWRzcy5jCmluZGV4 IDFjYzRlNTcuLjg4OWMyOTQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9tc20vZGlzcC9t ZHA1L21kcDVfbWRzcy5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9tc20vZGlzcC9tZHA1L21kcDVf bWRzcy5jCkBAIC0xMzIsNyArMTMyLDcgQEAgc3RhdGljIGludCBtZHNzX2lycV9kb21haW5faW5p dChzdHJ1Y3QgbWRwNV9tZHNzICptZHA1X21kc3MpCiAJZCA9IGlycV9kb21haW5fYWRkX2xpbmVh cihkZXYtPm9mX25vZGUsIDMyLCAmbWRzc19od19pcnFkb21haW5fb3BzLAogCQkJCSAgbWRwNV9t ZHNzKTsKIAlpZiAoIWQpIHsKLQkJZGV2X2VycihkZXYsICJtZHNzIGlycSBkb21haW4gYWRkIGZh aWxlZFxuIik7CisJCURSTV9ERVZfRVJST1IoZGV2LCAibWRzcyBpcnEgZG9tYWluIGFkZCBmYWls ZWRcbiIpOwogCQlyZXR1cm4gLUVOWElPOwogCX0KIApAQCAtMjQ2LDcgKzI0Niw3IEBAIGludCBt ZHA1X21kc3NfaW5pdChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2KQogCiAJcmV0ID0gbXNtX21kc3Nf Z2V0X2Nsb2NrcyhtZHA1X21kc3MpOwogCWlmIChyZXQpIHsKLQkJZGV2X2VycihkZXYtPmRldiwg ImZhaWxlZCB0byBnZXQgY2xvY2tzOiAlZFxuIiwgcmV0KTsKKwkJRFJNX0RFVl9FUlJPUihkZXYt PmRldiwgImZhaWxlZCB0byBnZXQgY2xvY2tzOiAlZFxuIiwgcmV0KTsKIAkJZ290byBmYWlsOwog CX0KIApAQCAtMjU5LDcgKzI1OSw3IEBAIGludCBtZHA1X21kc3NfaW5pdChzdHJ1Y3QgZHJtX2Rl dmljZSAqZGV2KQogCiAJcmV0ID0gcmVndWxhdG9yX2VuYWJsZShtZHA1X21kc3MtPnZkZCk7CiAJ aWYgKHJldCkgewotCQlkZXZfZXJyKGRldi0+ZGV2LCAiZmFpbGVkIHRvIGVuYWJsZSByZWd1bGF0 b3IgdmRkOiAlZFxuIiwKKwkJRFJNX0RFVl9FUlJPUihkZXYtPmRldiwgImZhaWxlZCB0byBlbmFi bGUgcmVndWxhdG9yIHZkZDogJWRcbiIsCiAJCQlyZXQpOwogCQlnb3RvIGZhaWw7CiAJfQpAQCAt MjY3LDEzICsyNjcsMTMgQEAgaW50IG1kcDVfbWRzc19pbml0KHN0cnVjdCBkcm1fZGV2aWNlICpk ZXYpCiAJcmV0ID0gZGV2bV9yZXF1ZXN0X2lycShkZXYtPmRldiwgcGxhdGZvcm1fZ2V0X2lycShw ZGV2LCAwKSwKIAkJCSAgICAgICBtZHNzX2lycSwgMCwgIm1kc3NfaXNyIiwgbWRwNV9tZHNzKTsK IAlpZiAocmV0KSB7Ci0JCWRldl9lcnIoZGV2LT5kZXYsICJmYWlsZWQgdG8gaW5pdCBpcnE6ICVk XG4iLCByZXQpOworCQlEUk1fREVWX0VSUk9SKGRldi0+ZGV2LCAiZmFpbGVkIHRvIGluaXQgaXJx OiAlZFxuIiwgcmV0KTsKIAkJZ290byBmYWlsX2lycTsKIAl9CiAKIAlyZXQgPSBtZHNzX2lycV9k b21haW5faW5pdChtZHA1X21kc3MpOwogCWlmIChyZXQpIHsKLQkJZGV2X2VycihkZXYtPmRldiwg ImZhaWxlZCB0byBpbml0IHN1Yi1ibG9jayBpcnFzOiAlZFxuIiwgcmV0KTsKKwkJRFJNX0RFVl9F UlJPUihkZXYtPmRldiwgImZhaWxlZCB0byBpbml0IHN1Yi1ibG9jayBpcnFzOiAlZFxuIiwgcmV0 KTsKIAkJZ290byBmYWlsX2lycTsKIAl9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9t c20vZGlzcC9tZHA1L21kcDVfcGxhbmUuYyBiL2RyaXZlcnMvZ3B1L2RybS9tc20vZGlzcC9tZHA1 L21kcDVfcGxhbmUuYwppbmRleCAxZDRiY2UxLi5mNTExMTU4IDEwMDY0NAotLS0gYS9kcml2ZXJz L2dwdS9kcm0vbXNtL2Rpc3AvbWRwNS9tZHA1X3BsYW5lLmMKKysrIGIvZHJpdmVycy9ncHUvZHJt L21zbS9kaXNwL21kcDUvbWRwNV9wbGFuZS5jCkBAIC0xMjUsNyArMTI1LDcgQEAgc3RhdGljIGlu dCBtZHA1X3BsYW5lX2F0b21pY19zZXRfcHJvcGVydHkoc3RydWN0IGRybV9wbGFuZSAqcGxhbmUs CiAKIAlTRVRfUFJPUEVSVFkoenBvcywgWlBPUywgdWludDhfdCk7CiAKLQlkZXZfZXJyKGRldi0+ ZGV2LCAiSW52YWxpZCBwcm9wZXJ0eVxuIik7CisJRFJNX0RFVl9FUlJPUihkZXYtPmRldiwgIklu dmFsaWQgcHJvcGVydHlcbiIpOwogCXJldCA9IC1FSU5WQUw7CiBkb25lOgogCXJldHVybiByZXQ7 CkBAIC0xNTMsNyArMTUzLDcgQEAgc3RhdGljIGludCBtZHA1X3BsYW5lX2F0b21pY19nZXRfcHJv cGVydHkoc3RydWN0IGRybV9wbGFuZSAqcGxhbmUsCiAKIAlHRVRfUFJPUEVSVFkoenBvcywgWlBP UywgdWludDhfdCk7CiAKLQlkZXZfZXJyKGRldi0+ZGV2LCAiSW52YWxpZCBwcm9wZXJ0eVxuIik7 CisJRFJNX0RFVl9FUlJPUihkZXYtPmRldiwgIkludmFsaWQgcHJvcGVydHlcbiIpOwogCXJldCA9 IC1FSU5WQUw7CiBkb25lOgogCXJldHVybiByZXQ7CkBAIC02NTksNyArNjU5LDcgQEAgc3RhdGlj IGludCBjYWxjX3NjYWxleF9zdGVwcyhzdHJ1Y3QgZHJtX3BsYW5lICpwbGFuZSwKIAogCXJldCA9 IGNhbGNfcGhhc2Vfc3RlcChzcmMsIGRlc3QsICZwaGFzZXhfc3RlcCk7CiAJaWYgKHJldCkgewot CQlkZXZfZXJyKGRldiwgIlggc2NhbGluZyAoJWQtPiVkKSBmYWlsZWQ6ICVkXG4iLCBzcmMsIGRl c3QsIHJldCk7CisJCURSTV9ERVZfRVJST1IoZGV2LCAiWCBzY2FsaW5nICglZC0+JWQpIGZhaWxl ZDogJWRcbiIsIHNyYywgZGVzdCwgcmV0KTsKIAkJcmV0dXJuIHJldDsKIAl9CiAKQEAgLTY4NCw3 ICs2ODQsNyBAQCBzdGF0aWMgaW50IGNhbGNfc2NhbGV5X3N0ZXBzKHN0cnVjdCBkcm1fcGxhbmUg KnBsYW5lLAogCiAJcmV0ID0gY2FsY19waGFzZV9zdGVwKHNyYywgZGVzdCwgJnBoYXNleV9zdGVw KTsKIAlpZiAocmV0KSB7Ci0JCWRldl9lcnIoZGV2LCAiWSBzY2FsaW5nICglZC0+JWQpIGZhaWxl ZDogJWRcbiIsIHNyYywgZGVzdCwgcmV0KTsKKwkJRFJNX0RFVl9FUlJPUihkZXYsICJZIHNjYWxp bmcgKCVkLT4lZCkgZmFpbGVkOiAlZFxuIiwgc3JjLCBkZXN0LCByZXQpOwogCQlyZXR1cm4gcmV0 OwogCX0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL21kcDUvbWRwNV9z bXAuYyBiL2RyaXZlcnMvZ3B1L2RybS9tc20vZGlzcC9tZHA1L21kcDVfc21wLmMKaW5kZXggOTZj MmI4Mi4uN2NlYmNiMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL21kcDUv bWRwNV9zbXAuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3AvbWRwNS9tZHA1X3NtcC5j CkBAIC04OCw3ICs4OCw3IEBAIHN0YXRpYyBpbnQgc21wX3JlcXVlc3RfYmxvY2soc3RydWN0IG1k cDVfc21wICpzbXAsCiAKIAlhdmFpbCA9IGNudCAtIGJpdG1hcF93ZWlnaHQoc3RhdGUtPnN0YXRl LCBjbnQpOwogCWlmIChuYmxrcyA+IGF2YWlsKSB7Ci0JCWRldl9lcnIoc21wLT5kZXYtPmRldiwg Im91dCBvZiBibGtzIChyZXE9JWQgPiBhdmFpbD0lZClcbiIsCisJCURSTV9ERVZfRVJST1Ioc21w LT5kZXYtPmRldiwgIm91dCBvZiBibGtzIChyZXE9JWQgPiBhdmFpbD0lZClcbiIsCiAJCQkJbmJs a3MsIGF2YWlsKTsKIAkJcmV0dXJuIC1FTk9TUEM7CiAJfQpAQCAtMTg4LDcgKzE4OCw3IEBAIGlu dCBtZHA1X3NtcF9hc3NpZ24oc3RydWN0IG1kcDVfc21wICpzbXAsIHN0cnVjdCBtZHA1X3NtcF9z dGF0ZSAqc3RhdGUsCiAJCURCRygiJXNbJWRdOiByZXF1ZXN0ICVkIFNNUCBibG9ja3MiLCBwaXBl Mm5hbWUocGlwZSksIGksIG4pOwogCQlyZXQgPSBzbXBfcmVxdWVzdF9ibG9jayhzbXAsIHN0YXRl LCBjaWQsIG4pOwogCQlpZiAocmV0KSB7Ci0JCQlkZXZfZXJyKGRldi0+ZGV2LCAiQ2Fubm90IGFs bG9jYXRlICVkIFNNUCBibG9ja3M6ICVkXG4iLAorCQkJRFJNX0RFVl9FUlJPUihkZXYtPmRldiwg IkNhbm5vdCBhbGxvY2F0ZSAlZCBTTVAgYmxvY2tzOiAlZFxuIiwKIAkJCQkJbiwgcmV0KTsKIAkJ CXJldHVybiByZXQ7CiAJCX0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9tc20vZHNpL2Rz aS5jIGIvZHJpdmVycy9ncHUvZHJtL21zbS9kc2kvZHNpLmMKaW5kZXggZmY4MTY0Yy4uNDNjMDlm NyAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL21zbS9kc2kvZHNpLmMKKysrIGIvZHJpdmVy cy9ncHUvZHJtL21zbS9kc2kvZHNpLmMKQEAgLTI5LDcgKzI5LDcgQEAgc3RhdGljIGludCBkc2lf Z2V0X3BoeShzdHJ1Y3QgbXNtX2RzaSAqbXNtX2RzaSkKIAogCXBoeV9ub2RlID0gb2ZfcGFyc2Vf cGhhbmRsZShwZGV2LT5kZXYub2Zfbm9kZSwgInBoeXMiLCAwKTsKIAlpZiAoIXBoeV9ub2RlKSB7 Ci0JCWRldl9lcnIoJnBkZXYtPmRldiwgImNhbm5vdCBmaW5kIHBoeSBkZXZpY2VcbiIpOworCQlE Uk1fREVWX0VSUk9SKCZwZGV2LT5kZXYsICJjYW5ub3QgZmluZCBwaHkgZGV2aWNlXG4iKTsKIAkJ cmV0dXJuIC1FTlhJTzsKIAl9CiAKQEAgLTQwLDcgKzQwLDcgQEAgc3RhdGljIGludCBkc2lfZ2V0 X3BoeShzdHJ1Y3QgbXNtX2RzaSAqbXNtX2RzaSkKIAlvZl9ub2RlX3B1dChwaHlfbm9kZSk7CiAK IAlpZiAoIXBoeV9wZGV2IHx8ICFtc21fZHNpLT5waHkpIHsKLQkJZGV2X2VycigmcGRldi0+ZGV2 LCAiJXM6IHBoeSBkcml2ZXIgaXMgbm90IHJlYWR5XG4iLCBfX2Z1bmNfXyk7CisJCURSTV9ERVZf RVJST1IoJnBkZXYtPmRldiwgIiVzOiBwaHkgZHJpdmVyIGlzIG5vdCByZWFkeVxuIiwgX19mdW5j X18pOwogCQlyZXR1cm4gLUVQUk9CRV9ERUZFUjsKIAl9CiAKQEAgLTIwNCw3ICsyMDQsNyBAQCBp bnQgbXNtX2RzaV9tb2Rlc2V0X2luaXQoc3RydWN0IG1zbV9kc2kgKm1zbV9kc2ksIHN0cnVjdCBk cm1fZGV2aWNlICpkZXYsCiAKIAlyZXQgPSBtc21fZHNpX2hvc3RfbW9kZXNldF9pbml0KG1zbV9k c2ktPmhvc3QsIGRldik7CiAJaWYgKHJldCkgewotCQlkZXZfZXJyKGRldi0+ZGV2LCAiZmFpbGVk IHRvIG1vZGVzZXQgaW5pdCBob3N0OiAlZFxuIiwgcmV0KTsKKwkJRFJNX0RFVl9FUlJPUihkZXYt PmRldiwgImZhaWxlZCB0byBtb2Rlc2V0IGluaXQgaG9zdDogJWRcbiIsIHJldCk7CiAJCWdvdG8g ZmFpbDsKIAl9CiAKQEAgLTIxNiw3ICsyMTYsNyBAQCBpbnQgbXNtX2RzaV9tb2Rlc2V0X2luaXQo c3RydWN0IG1zbV9kc2kgKm1zbV9kc2ksIHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsCiAJbXNtX2Rz aS0+YnJpZGdlID0gbXNtX2RzaV9tYW5hZ2VyX2JyaWRnZV9pbml0KG1zbV9kc2ktPmlkKTsKIAlp ZiAoSVNfRVJSKG1zbV9kc2ktPmJyaWRnZSkpIHsKIAkJcmV0ID0gUFRSX0VSUihtc21fZHNpLT5i cmlkZ2UpOwotCQlkZXZfZXJyKGRldi0+ZGV2LCAiZmFpbGVkIHRvIGNyZWF0ZSBkc2kgYnJpZGdl OiAlZFxuIiwgcmV0KTsKKwkJRFJNX0RFVl9FUlJPUihkZXYtPmRldiwgImZhaWxlZCB0byBjcmVh dGUgZHNpIGJyaWRnZTogJWRcbiIsIHJldCk7CiAJCW1zbV9kc2ktPmJyaWRnZSA9IE5VTEw7CiAJ CWdvdG8gZmFpbDsKIAl9CkBAIC0yMzgsNyArMjM4LDcgQEAgaW50IG1zbV9kc2lfbW9kZXNldF9p bml0KHN0cnVjdCBtc21fZHNpICptc21fZHNpLCBzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LAogCiAJ aWYgKElTX0VSUihtc21fZHNpLT5jb25uZWN0b3IpKSB7CiAJCXJldCA9IFBUUl9FUlIobXNtX2Rz aS0+Y29ubmVjdG9yKTsKLQkJZGV2X2VycihkZXYtPmRldiwKKwkJRFJNX0RFVl9FUlJPUihkZXYt PmRldiwKIAkJCSJmYWlsZWQgdG8gY3JlYXRlIGRzaSBjb25uZWN0b3I6ICVkXG4iLCByZXQpOwog CQltc21fZHNpLT5jb25uZWN0b3IgPSBOVUxMOwogCQlnb3RvIGZhaWw7CmRpZmYgLS1naXQgYS9k cml2ZXJzL2dwdS9kcm0vbXNtL2RzaS9kc2lfaG9zdC5jIGIvZHJpdmVycy9ncHUvZHJtL21zbS9k c2kvZHNpX2hvc3QuYwppbmRleCA5NmZiNWY2Li4wNzZlYTlhIDEwMDY0NAotLS0gYS9kcml2ZXJz L2dwdS9kcm0vbXNtL2RzaS9kc2lfaG9zdC5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9tc20vZHNp L2RzaV9ob3N0LmMKQEAgLTEwNTAsNyArMTA1MCw3IEBAIHN0YXRpYyB2b2lkIGRzaV93YWl0NHZp ZGVvX2RvbmUoc3RydWN0IG1zbV9kc2lfaG9zdCAqbXNtX2hvc3QpCiAJCQltc2Vjc190b19qaWZm aWVzKDcwKSk7CiAKIAlpZiAocmV0IDw9IDApCi0JCWRldl9lcnIoZGV2LCAid2FpdCBmb3Igdmlk ZW8gZG9uZSB0aW1lZCBvdXRcbiIpOworCQlEUk1fREVWX0VSUk9SKGRldiwgIndhaXQgZm9yIHZp ZGVvIGRvbmUgdGltZWQgb3V0XG4iKTsKIAogCWRzaV9pbnRyX2N0cmwobXNtX2hvc3QsIERTSV9J UlFfTUFTS19WSURFT19ET05FLCAwKTsKIH0KQEAgLTE2NzMsNyArMTY3Myw3IEBAIHN0YXRpYyBp bnQgZHNpX2hvc3RfcGFyc2VfbGFuZV9kYXRhKHN0cnVjdCBtc21fZHNpX2hvc3QgKm1zbV9ob3N0 LAogCiAJcHJvcCA9IG9mX2ZpbmRfcHJvcGVydHkoZXAsICJkYXRhLWxhbmVzIiwgJmxlbik7CiAJ aWYgKCFwcm9wKSB7Ci0JCWRldl9kYmcoZGV2LAorCQlEUk1fREVWX0RFQlVHKGRldiwKIAkJCSJm YWlsZWQgdG8gZmluZCBkYXRhIGxhbmUgbWFwcGluZywgdXNpbmcgZGVmYXVsdFxuIik7CiAJCXJl dHVybiAwOwogCX0KQEAgLTE2ODEsNyArMTY4MSw3IEBAIHN0YXRpYyBpbnQgZHNpX2hvc3RfcGFy c2VfbGFuZV9kYXRhKHN0cnVjdCBtc21fZHNpX2hvc3QgKm1zbV9ob3N0LAogCW51bV9sYW5lcyA9 IGxlbiAvIHNpemVvZih1MzIpOwogCiAJaWYgKG51bV9sYW5lcyA8IDEgfHwgbnVtX2xhbmVzID4g NCkgewotCQlkZXZfZXJyKGRldiwgImJhZCBudW1iZXIgb2YgZGF0YSBsYW5lc1xuIik7CisJCURS TV9ERVZfRVJST1IoZGV2LCAiYmFkIG51bWJlciBvZiBkYXRhIGxhbmVzXG4iKTsKIAkJcmV0dXJu IC1FSU5WQUw7CiAJfQogCkBAIC0xNjkwLDcgKzE2OTAsNyBAQCBzdGF0aWMgaW50IGRzaV9ob3N0 X3BhcnNlX2xhbmVfZGF0YShzdHJ1Y3QgbXNtX2RzaV9ob3N0ICptc21faG9zdCwKIAlyZXQgPSBv Zl9wcm9wZXJ0eV9yZWFkX3UzMl9hcnJheShlcCwgImRhdGEtbGFuZXMiLCBsYW5lX21hcCwKIAkJ CQkJIG51bV9sYW5lcyk7CiAJaWYgKHJldCkgewotCQlkZXZfZXJyKGRldiwgImZhaWxlZCB0byBy ZWFkIGxhbmUgZGF0YVxuIik7CisJCURSTV9ERVZfRVJST1IoZGV2LCAiZmFpbGVkIHRvIHJlYWQg bGFuZSBkYXRhXG4iKTsKIAkJcmV0dXJuIHJldDsKIAl9CiAKQEAgLTE3MTEsNyArMTcxMSw3IEBA IHN0YXRpYyBpbnQgZHNpX2hvc3RfcGFyc2VfbGFuZV9kYXRhKHN0cnVjdCBtc21fZHNpX2hvc3Qg Km1zbV9ob3N0LAogCQkgKi8KIAkJZm9yIChqID0gMDsgaiA8IG51bV9sYW5lczsgaisrKSB7CiAJ CQlpZiAobGFuZV9tYXBbal0gPCAwIHx8IGxhbmVfbWFwW2pdID4gMykKLQkJCQlkZXZfZXJyKGRl diwgImJhZCBwaHlzaWNhbCBsYW5lIGVudHJ5ICV1XG4iLAorCQkJCURSTV9ERVZfRVJST1IoZGV2 LCAiYmFkIHBoeXNpY2FsIGxhbmUgZW50cnkgJXVcbiIsCiAJCQkJCWxhbmVfbWFwW2pdKTsKIAog CQkJaWYgKHN3YXBbbGFuZV9tYXBbal1dICE9IGopCkBAIC0xNzQyLDEzICsxNzQyLDEzIEBAIHN0 YXRpYyBpbnQgZHNpX2hvc3RfcGFyc2VfZHQoc3RydWN0IG1zbV9kc2lfaG9zdCAqbXNtX2hvc3Qp CiAJICovCiAJZW5kcG9pbnQgPSBvZl9ncmFwaF9nZXRfZW5kcG9pbnRfYnlfcmVncyhucCwgMSwg LTEpOwogCWlmICghZW5kcG9pbnQpIHsKLQkJZGV2X2RiZyhkZXYsICIlczogbm8gZW5kcG9pbnRc biIsIF9fZnVuY19fKTsKKwkJRFJNX0RFVl9ERUJVRyhkZXYsICIlczogbm8gZW5kcG9pbnRcbiIs IF9fZnVuY19fKTsKIAkJcmV0dXJuIDA7CiAJfQogCiAJcmV0ID0gZHNpX2hvc3RfcGFyc2VfbGFu ZV9kYXRhKG1zbV9ob3N0LCBlbmRwb2ludCk7CiAJaWYgKHJldCkgewotCQlkZXZfZXJyKGRldiwg IiVzOiBpbnZhbGlkIGxhbmUgY29uZmlndXJhdGlvbiAlZFxuIiwKKwkJRFJNX0RFVl9FUlJPUihk ZXYsICIlczogaW52YWxpZCBsYW5lIGNvbmZpZ3VyYXRpb24gJWRcbiIsCiAJCQlfX2Z1bmNfXywg cmV0KTsKIAkJZ290byBlcnI7CiAJfQpAQCAtMTc1Niw3ICsxNzU2LDcgQEAgc3RhdGljIGludCBk c2lfaG9zdF9wYXJzZV9kdChzdHJ1Y3QgbXNtX2RzaV9ob3N0ICptc21faG9zdCkKIAkvKiBHZXQg cGFuZWwgbm9kZSBmcm9tIHRoZSBvdXRwdXQgcG9ydCdzIGVuZHBvaW50IGRhdGEgKi8KIAlkZXZp Y2Vfbm9kZSA9IG9mX2dyYXBoX2dldF9yZW1vdGVfbm9kZShucCwgMSwgMCk7CiAJaWYgKCFkZXZp Y2Vfbm9kZSkgewotCQlkZXZfZGJnKGRldiwgIiVzOiBubyB2YWxpZCBkZXZpY2VcbiIsIF9fZnVu Y19fKTsKKwkJRFJNX0RFVl9ERUJVRyhkZXYsICIlczogbm8gdmFsaWQgZGV2aWNlXG4iLCBfX2Z1 bmNfXyk7CiAJCWdvdG8gZXJyOwogCX0KIApAQCAtMTc2Niw3ICsxNzY2LDcgQEAgc3RhdGljIGlu dCBkc2lfaG9zdF9wYXJzZV9kdChzdHJ1Y3QgbXNtX2RzaV9ob3N0ICptc21faG9zdCkKIAkJbXNt X2hvc3QtPnNmcGIgPSBzeXNjb25fcmVnbWFwX2xvb2t1cF9ieV9waGFuZGxlKG5wLAogCQkJCQki c3lzY29uLXNmcGIiKTsKIAkJaWYgKElTX0VSUihtc21faG9zdC0+c2ZwYikpIHsKLQkJCWRldl9l cnIoZGV2LCAiJXM6IGZhaWxlZCB0byBnZXQgc2ZwYiByZWdtYXBcbiIsCisJCQlEUk1fREVWX0VS Uk9SKGRldiwgIiVzOiBmYWlsZWQgdG8gZ2V0IHNmcGIgcmVnbWFwXG4iLAogCQkJCV9fZnVuY19f KTsKIAkJCXJldCA9IFBUUl9FUlIobXNtX2hvc3QtPnNmcGIpOwogCQl9CkBAIC0xOTE2LDcgKzE5 MTYsNyBAQCBpbnQgbXNtX2RzaV9ob3N0X21vZGVzZXRfaW5pdChzdHJ1Y3QgbWlwaV9kc2lfaG9z dCAqaG9zdCwKIAltc21faG9zdC0+aXJxID0gaXJxX29mX3BhcnNlX2FuZF9tYXAocGRldi0+ZGV2 Lm9mX25vZGUsIDApOwogCWlmIChtc21faG9zdC0+aXJxIDwgMCkgewogCQlyZXQgPSBtc21faG9z dC0+aXJxOwotCQlkZXZfZXJyKGRldi0+ZGV2LCAiZmFpbGVkIHRvIGdldCBpcnE6ICVkXG4iLCBy ZXQpOworCQlEUk1fREVWX0VSUk9SKGRldi0+ZGV2LCAiZmFpbGVkIHRvIGdldCBpcnE6ICVkXG4i LCByZXQpOwogCQlyZXR1cm4gcmV0OwogCX0KIApAQCAtMTkyNCw3ICsxOTI0LDcgQEAgaW50IG1z bV9kc2lfaG9zdF9tb2Rlc2V0X2luaXQoc3RydWN0IG1pcGlfZHNpX2hvc3QgKmhvc3QsCiAJCQlk c2lfaG9zdF9pcnEsIElSUUZfVFJJR0dFUl9ISUdIIHwgSVJRRl9PTkVTSE9ULAogCQkJImRzaV9p c3IiLCBtc21faG9zdCk7CiAJaWYgKHJldCA8IDApIHsKLQkJZGV2X2VycigmcGRldi0+ZGV2LCAi ZmFpbGVkIHRvIHJlcXVlc3QgSVJRJXU6ICVkXG4iLAorCQlEUk1fREVWX0VSUk9SKCZwZGV2LT5k ZXYsICJmYWlsZWQgdG8gcmVxdWVzdCBJUlEldTogJWRcbiIsCiAJCQkJbXNtX2hvc3QtPmlycSwg cmV0KTsKIAkJcmV0dXJuIHJldDsKIAl9CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbXNt L2RzaS9waHkvZHNpX3BoeS5jIGIvZHJpdmVycy9ncHUvZHJtL21zbS9kc2kvcGh5L2RzaV9waHku YwppbmRleCA5YTlmYTBjLi4xNzYwNDgzIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vbXNt L2RzaS9waHkvZHNpX3BoeS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9tc20vZHNpL3BoeS9kc2lf cGh5LmMKQEAgLTQwNCw3ICs0MDQsNyBAQCBzdGF0aWMgaW50IGRzaV9waHlfcmVndWxhdG9yX2lu aXQoc3RydWN0IG1zbV9kc2lfcGh5ICpwaHkpCiAKIAlyZXQgPSBkZXZtX3JlZ3VsYXRvcl9idWxr X2dldChkZXYsIG51bSwgcyk7CiAJaWYgKHJldCA8IDApIHsKLQkJZGV2X2VycihkZXYsICIlczog ZmFpbGVkIHRvIGluaXQgcmVndWxhdG9yLCByZXQ9JWRcbiIsCisJCURSTV9ERVZfRVJST1IoZGV2 LCAiJXM6IGZhaWxlZCB0byBpbml0IHJlZ3VsYXRvciwgcmV0PSVkXG4iLAogCQkJCQkJX19mdW5j X18sIHJldCk7CiAJCXJldHVybiByZXQ7CiAJfQpAQCAtNDQxLDcgKzQ0MSw3IEBAIHN0YXRpYyBp bnQgZHNpX3BoeV9yZWd1bGF0b3JfZW5hYmxlKHN0cnVjdCBtc21fZHNpX3BoeSAqcGh5KQogCQkJ cmV0ID0gcmVndWxhdG9yX3NldF9sb2FkKHNbaV0uY29uc3VtZXIsCiAJCQkJCQkJcmVnc1tpXS5l bmFibGVfbG9hZCk7CiAJCQlpZiAocmV0IDwgMCkgewotCQkJCWRldl9lcnIoZGV2LAorCQkJCURS TV9ERVZfRVJST1IoZGV2LAogCQkJCQkicmVndWxhdG9yICVkIHNldCBvcCBtb2RlIGZhaWxlZCwg JWRcbiIsCiAJCQkJCWksIHJldCk7CiAJCQkJZ290byBmYWlsOwpAQCAtNDUxLDcgKzQ1MSw3IEBA IHN0YXRpYyBpbnQgZHNpX3BoeV9yZWd1bGF0b3JfZW5hYmxlKHN0cnVjdCBtc21fZHNpX3BoeSAq cGh5KQogCiAJcmV0ID0gcmVndWxhdG9yX2J1bGtfZW5hYmxlKG51bSwgcyk7CiAJaWYgKHJldCA8 IDApIHsKLQkJZGV2X2VycihkZXYsICJyZWd1bGF0b3IgZW5hYmxlIGZhaWxlZCwgJWRcbiIsIHJl dCk7CisJCURSTV9ERVZfRVJST1IoZGV2LCAicmVndWxhdG9yIGVuYWJsZSBmYWlsZWQsICVkXG4i LCByZXQpOwogCQlnb3RvIGZhaWw7CiAJfQogCkBAIC00NzIsNyArNDcyLDcgQEAgc3RhdGljIGlu dCBkc2lfcGh5X2VuYWJsZV9yZXNvdXJjZShzdHJ1Y3QgbXNtX2RzaV9waHkgKnBoeSkKIAogCXJl dCA9IGNsa19wcmVwYXJlX2VuYWJsZShwaHktPmFoYl9jbGspOwogCWlmIChyZXQpIHsKLQkJZGV2 X2VycihkZXYsICIlczogY2FuJ3QgZW5hYmxlIGFoYiBjbGssICVkXG4iLCBfX2Z1bmNfXywgcmV0 KTsKKwkJRFJNX0RFVl9FUlJPUihkZXYsICIlczogY2FuJ3QgZW5hYmxlIGFoYiBjbGssICVkXG4i LCBfX2Z1bmNfXywgcmV0KTsKIAkJcG1fcnVudGltZV9wdXRfc3luYyhkZXYpOwogCX0KIApAQCAt NTQzLDcgKzU0Myw3IEBAIGludCBtc21fZHNpX3BoeV9pbml0X2NvbW1vbihzdHJ1Y3QgbXNtX2Rz aV9waHkgKnBoeSkKIAlwaHktPnJlZ19iYXNlID0gbXNtX2lvcmVtYXAocGRldiwgImRzaV9waHlf cmVndWxhdG9yIiwKIAkJCQkiRFNJX1BIWV9SRUciKTsKIAlpZiAoSVNfRVJSKHBoeS0+cmVnX2Jh c2UpKSB7Ci0JCWRldl9lcnIoJnBkZXYtPmRldiwgIiVzOiBmYWlsZWQgdG8gbWFwIHBoeSByZWd1 bGF0b3IgYmFzZVxuIiwKKwkJRFJNX0RFVl9FUlJPUigmcGRldi0+ZGV2LCAiJXM6IGZhaWxlZCB0 byBtYXAgcGh5IHJlZ3VsYXRvciBiYXNlXG4iLAogCQkJX19mdW5jX18pOwogCQlyZXQgPSAtRU5P TUVNOwogCQlnb3RvIGZhaWw7CkBAIC01NzQsNyArNTc0LDcgQEAgc3RhdGljIGludCBkc2lfcGh5 X2RyaXZlcl9wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQogCXBoeS0+aWQgPSBk c2lfcGh5X2dldF9pZChwaHkpOwogCWlmIChwaHktPmlkIDwgMCkgewogCQlyZXQgPSBwaHktPmlk OwotCQlkZXZfZXJyKGRldiwgIiVzOiBjb3VsZG4ndCBpZGVudGlmeSBQSFkgaW5kZXgsICVkXG4i LAorCQlEUk1fREVWX0VSUk9SKGRldiwgIiVzOiBjb3VsZG4ndCBpZGVudGlmeSBQSFkgaW5kZXgs ICVkXG4iLAogCQkJX19mdW5jX18sIHJldCk7CiAJCWdvdG8gZmFpbDsKIAl9CkBAIC01ODQsMjAg KzU4NCwyMCBAQCBzdGF0aWMgaW50IGRzaV9waHlfZHJpdmVyX3Byb2JlKHN0cnVjdCBwbGF0Zm9y bV9kZXZpY2UgKnBkZXYpCiAKIAlwaHktPmJhc2UgPSBtc21faW9yZW1hcChwZGV2LCAiZHNpX3Bo eSIsICJEU0lfUEhZIik7CiAJaWYgKElTX0VSUihwaHktPmJhc2UpKSB7Ci0JCWRldl9lcnIoZGV2 LCAiJXM6IGZhaWxlZCB0byBtYXAgcGh5IGJhc2VcbiIsIF9fZnVuY19fKTsKKwkJRFJNX0RFVl9F UlJPUihkZXYsICIlczogZmFpbGVkIHRvIG1hcCBwaHkgYmFzZVxuIiwgX19mdW5jX18pOwogCQly ZXQgPSAtRU5PTUVNOwogCQlnb3RvIGZhaWw7CiAJfQogCiAJcmV0ID0gZHNpX3BoeV9yZWd1bGF0 b3JfaW5pdChwaHkpOwogCWlmIChyZXQpIHsKLQkJZGV2X2VycihkZXYsICIlczogZmFpbGVkIHRv IGluaXQgcmVndWxhdG9yXG4iLCBfX2Z1bmNfXyk7CisJCURSTV9ERVZfRVJST1IoZGV2LCAiJXM6 IGZhaWxlZCB0byBpbml0IHJlZ3VsYXRvclxuIiwgX19mdW5jX18pOwogCQlnb3RvIGZhaWw7CiAJ fQogCiAJcGh5LT5haGJfY2xrID0gbXNtX2Nsa19nZXQocGRldiwgImlmYWNlIik7CiAJaWYgKElT X0VSUihwaHktPmFoYl9jbGspKSB7Ci0JCWRldl9lcnIoZGV2LCAiJXM6IFVuYWJsZSB0byBnZXQg YWhiIGNsa1xuIiwgX19mdW5jX18pOworCQlEUk1fREVWX0VSUk9SKGRldiwgIiVzOiBVbmFibGUg dG8gZ2V0IGFoYiBjbGtcbiIsIF9fZnVuY19fKTsKIAkJcmV0ID0gUFRSX0VSUihwaHktPmFoYl9j bGspOwogCQlnb3RvIGZhaWw7CiAJfQpAQCAtNjE3LDcgKzYxNyw3IEBAIHN0YXRpYyBpbnQgZHNp X3BoeV9kcml2ZXJfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKIAogCXBoeS0+ cGxsID0gbXNtX2RzaV9wbGxfaW5pdChwZGV2LCBwaHktPmNmZy0+dHlwZSwgcGh5LT5pZCk7CiAJ aWYgKElTX0VSUl9PUl9OVUxMKHBoeS0+cGxsKSkKLQkJZGV2X2luZm8oZGV2LAorCQlEUk1fREVW X0lORk8oZGV2LAogCQkJIiVzOiBwbGwgaW5pdCBmYWlsZWQ6ICVsZCwgbmVlZCBzZXBhcmF0ZSBw bGwgY2xrIGRyaXZlclxuIiwKIAkJCV9fZnVuY19fLCBQVFJfRVJSKHBoeS0+cGxsKSk7CiAKQEAg LTY3NSwyMSArNjc1LDIxIEBAIGludCBtc21fZHNpX3BoeV9lbmFibGUoc3RydWN0IG1zbV9kc2lf cGh5ICpwaHksIGludCBzcmNfcGxsX2lkLAogCiAJcmV0ID0gZHNpX3BoeV9lbmFibGVfcmVzb3Vy Y2UocGh5KTsKIAlpZiAocmV0KSB7Ci0JCWRldl9lcnIoZGV2LCAiJXM6IHJlc291cmNlIGVuYWJs ZSBmYWlsZWQsICVkXG4iLAorCQlEUk1fREVWX0VSUk9SKGRldiwgIiVzOiByZXNvdXJjZSBlbmFi bGUgZmFpbGVkLCAlZFxuIiwKIAkJCV9fZnVuY19fLCByZXQpOwogCQlnb3RvIHJlc19lbl9mYWls OwogCX0KIAogCXJldCA9IGRzaV9waHlfcmVndWxhdG9yX2VuYWJsZShwaHkpOwogCWlmIChyZXQp IHsKLQkJZGV2X2VycihkZXYsICIlczogcmVndWxhdG9yIGVuYWJsZSBmYWlsZWQsICVkXG4iLAor CQlEUk1fREVWX0VSUk9SKGRldiwgIiVzOiByZWd1bGF0b3IgZW5hYmxlIGZhaWxlZCwgJWRcbiIs CiAJCQlfX2Z1bmNfXywgcmV0KTsKIAkJZ290byByZWdfZW5fZmFpbDsKIAl9CiAKIAlyZXQgPSBw aHktPmNmZy0+b3BzLmVuYWJsZShwaHksIHNyY19wbGxfaWQsIGNsa19yZXEpOwogCWlmIChyZXQp IHsKLQkJZGV2X2VycihkZXYsICIlczogcGh5IGVuYWJsZSBmYWlsZWQsICVkXG4iLCBfX2Z1bmNf XywgcmV0KTsKKwkJRFJNX0RFVl9FUlJPUihkZXYsICIlczogcGh5IGVuYWJsZSBmYWlsZWQsICVk XG4iLCBfX2Z1bmNfXywgcmV0KTsKIAkJZ290byBwaHlfZW5fZmFpbDsKIAl9CiAKQEAgLTcwMiw3 ICs3MDIsNyBAQCBpbnQgbXNtX2RzaV9waHlfZW5hYmxlKHN0cnVjdCBtc21fZHNpX3BoeSAqcGh5 LCBpbnQgc3JjX3BsbF9pZCwKIAlpZiAocGh5LT51c2VjYXNlICE9IE1TTV9EU0lfUEhZX1NMQVZF KSB7CiAJCXJldCA9IG1zbV9kc2lfcGxsX3Jlc3RvcmVfc3RhdGUocGh5LT5wbGwpOwogCQlpZiAo cmV0KSB7Ci0JCQlkZXZfZXJyKGRldiwgIiVzOiBmYWlsZWQgdG8gcmVzdG9yZSBwbGwgc3RhdGUs ICVkXG4iLAorCQkJRFJNX0RFVl9FUlJPUihkZXYsICIlczogZmFpbGVkIHRvIHJlc3RvcmUgcGxs IHN0YXRlLCAlZFxuIiwKIAkJCQlfX2Z1bmNfXywgcmV0KTsKIAkJCWdvdG8gcGxsX3Jlc3Rvcl9m YWlsOwogCQl9CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbXNtL2RzaS9waHkvZHNpX3Bo eV8xMG5tLmMgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL2RzaS9waHkvZHNpX3BoeV8xMG5tLmMKaW5k ZXggYjNmZmZjOC4uNDQ5NTllNzkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9tc20vZHNp L3BoeS9kc2lfcGh5XzEwbm0uYworKysgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL2RzaS9waHkvZHNp X3BoeV8xMG5tLmMKQEAgLTkzLDcgKzkzLDcgQEAgc3RhdGljIGludCBkc2lfMTBubV9waHlfZW5h YmxlKHN0cnVjdCBtc21fZHNpX3BoeSAqcGh5LCBpbnQgc3JjX3BsbF9pZCwKIAlEQkcoIiIpOwog CiAJaWYgKG1zbV9kc2lfZHBoeV90aW1pbmdfY2FsY192Myh0aW1pbmcsIGNsa19yZXEpKSB7Ci0J CWRldl9lcnIoJnBoeS0+cGRldi0+ZGV2LAorCQlEUk1fREVWX0VSUk9SKCZwaHktPnBkZXYtPmRl diwKIAkJCSIlczogRC1QSFkgdGltaW5nIGNhbGN1bGF0aW9uIGZhaWxlZFxuIiwgX19mdW5jX18p OwogCQlyZXR1cm4gLUVJTlZBTDsKIAl9CkBAIC0xNzIsNyArMTcyLDcgQEAgc3RhdGljIGludCBk c2lfMTBubV9waHlfZW5hYmxlKHN0cnVjdCBtc21fZHNpX3BoeSAqcGh5LCBpbnQgc3JjX3BsbF9p ZCwKIAogCXJldCA9IG1zbV9kc2lfcGxsX3NldF91c2VjYXNlKHBoeS0+cGxsLCBwaHktPnVzZWNh c2UpOwogCWlmIChyZXQpIHsKLQkJZGV2X2VycigmcGh5LT5wZGV2LT5kZXYsICIlczogc2V0IHBs bCB1c2VjYXNlIGZhaWxlZCwgJWRcbiIsCisJCURSTV9ERVZfRVJST1IoJnBoeS0+cGRldi0+ZGV2 LCAiJXM6IHNldCBwbGwgdXNlY2FzZSBmYWlsZWQsICVkXG4iLAogCQkJX19mdW5jX18sIHJldCk7 CiAJCXJldHVybiByZXQ7CiAJfQpAQCAtMTk2LDcgKzE5Niw3IEBAIHN0YXRpYyBpbnQgZHNpXzEw bm1fcGh5X2luaXQoc3RydWN0IG1zbV9kc2lfcGh5ICpwaHkpCiAJcGh5LT5sYW5lX2Jhc2UgPSBt c21faW9yZW1hcChwZGV2LCAiZHNpX3BoeV9sYW5lIiwKIAkJCQkgICAgICJEU0lfUEhZX0xBTkUi KTsKIAlpZiAoSVNfRVJSKHBoeS0+bGFuZV9iYXNlKSkgewotCQlkZXZfZXJyKCZwZGV2LT5kZXYs ICIlczogZmFpbGVkIHRvIG1hcCBwaHkgbGFuZSBiYXNlXG4iLAorCQlEUk1fREVWX0VSUk9SKCZw ZGV2LT5kZXYsICIlczogZmFpbGVkIHRvIG1hcCBwaHkgbGFuZSBiYXNlXG4iLAogCQkJX19mdW5j X18pOwogCQlyZXR1cm4gLUVOT01FTTsKIAl9CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0v bXNtL2RzaS9waHkvZHNpX3BoeV8xNG5tLmMgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL2RzaS9waHkv ZHNpX3BoeV8xNG5tLmMKaW5kZXggNTEzZjQyMy4uYTE3MmM2NiAxMDA2NDQKLS0tIGEvZHJpdmVy cy9ncHUvZHJtL21zbS9kc2kvcGh5L2RzaV9waHlfMTRubS5jCisrKyBiL2RyaXZlcnMvZ3B1L2Ry bS9tc20vZHNpL3BoeS9kc2lfcGh5XzE0bm0uYwpAQCAtNjQsNyArNjQsNyBAQCBzdGF0aWMgaW50 IGRzaV8xNG5tX3BoeV9lbmFibGUoc3RydWN0IG1zbV9kc2lfcGh5ICpwaHksIGludCBzcmNfcGxs X2lkLAogCXZvaWQgX19pb21lbSAqbGFuZV9iYXNlID0gcGh5LT5sYW5lX2Jhc2U7CiAKIAlpZiAo bXNtX2RzaV9kcGh5X3RpbWluZ19jYWxjX3YyKHRpbWluZywgY2xrX3JlcSkpIHsKLQkJZGV2X2Vy cigmcGh5LT5wZGV2LT5kZXYsCisJCURSTV9ERVZfRVJST1IoJnBoeS0+cGRldi0+ZGV2LAogCQkJ IiVzOiBELVBIWSB0aW1pbmcgY2FsY3VsYXRpb24gZmFpbGVkXG4iLCBfX2Z1bmNfXyk7CiAJCXJl dHVybiAtRUlOVkFMOwogCX0KQEAgLTExNSw3ICsxMTUsNyBAQCBzdGF0aWMgaW50IGRzaV8xNG5t X3BoeV9lbmFibGUoc3RydWN0IG1zbV9kc2lfcGh5ICpwaHksIGludCBzcmNfcGxsX2lkLAogCiAJ cmV0ID0gbXNtX2RzaV9wbGxfc2V0X3VzZWNhc2UocGh5LT5wbGwsIHBoeS0+dXNlY2FzZSk7CiAJ aWYgKHJldCkgewotCQlkZXZfZXJyKCZwaHktPnBkZXYtPmRldiwgIiVzOiBzZXQgcGxsIHVzZWNh c2UgZmFpbGVkLCAlZFxuIiwKKwkJRFJNX0RFVl9FUlJPUigmcGh5LT5wZGV2LT5kZXYsICIlczog c2V0IHBsbCB1c2VjYXNlIGZhaWxlZCwgJWRcbiIsCiAJCQlfX2Z1bmNfXywgcmV0KTsKIAkJcmV0 dXJuIHJldDsKIAl9CkBAIC0xNDIsNyArMTQyLDcgQEAgc3RhdGljIGludCBkc2lfMTRubV9waHlf aW5pdChzdHJ1Y3QgbXNtX2RzaV9waHkgKnBoeSkKIAlwaHktPmxhbmVfYmFzZSA9IG1zbV9pb3Jl bWFwKHBkZXYsICJkc2lfcGh5X2xhbmUiLAogCQkJCSJEU0lfUEhZX0xBTkUiKTsKIAlpZiAoSVNf RVJSKHBoeS0+bGFuZV9iYXNlKSkgewotCQlkZXZfZXJyKCZwZGV2LT5kZXYsICIlczogZmFpbGVk IHRvIG1hcCBwaHkgbGFuZSBiYXNlXG4iLAorCQlEUk1fREVWX0VSUk9SKCZwZGV2LT5kZXYsICIl czogZmFpbGVkIHRvIG1hcCBwaHkgbGFuZSBiYXNlXG4iLAogCQkJX19mdW5jX18pOwogCQlyZXR1 cm4gLUVOT01FTTsKIAl9CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbXNtL2RzaS9waHkv ZHNpX3BoeV8yMG5tLmMgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL2RzaS9waHkvZHNpX3BoeV8yMG5t LmMKaW5kZXggMWNhNmM2OS4uOWVhOTQ3OCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL21z bS9kc2kvcGh5L2RzaV9waHlfMjBubS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9tc20vZHNpL3Bo eS9kc2lfcGh5XzIwbm0uYwpAQCAtODIsNyArODIsNyBAQCBzdGF0aWMgaW50IGRzaV8yMG5tX3Bo eV9lbmFibGUoc3RydWN0IG1zbV9kc2lfcGh5ICpwaHksIGludCBzcmNfcGxsX2lkLAogCURCRygi Iik7CiAKIAlpZiAobXNtX2RzaV9kcGh5X3RpbWluZ19jYWxjKHRpbWluZywgY2xrX3JlcSkpIHsK LQkJZGV2X2VycigmcGh5LT5wZGV2LT5kZXYsCisJCURSTV9ERVZfRVJST1IoJnBoeS0+cGRldi0+ ZGV2LAogCQkJIiVzOiBELVBIWSB0aW1pbmcgY2FsY3VsYXRpb24gZmFpbGVkXG4iLCBfX2Z1bmNf Xyk7CiAJCXJldHVybiAtRUlOVkFMOwogCX0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9t c20vZHNpL3BoeS9kc2lfcGh5XzI4bm0uYyBiL2RyaXZlcnMvZ3B1L2RybS9tc20vZHNpL3BoeS9k c2lfcGh5XzI4bm0uYwppbmRleCA0OTcyYjUyLi5jNzk1MDVkIDEwMDY0NAotLS0gYS9kcml2ZXJz L2dwdS9kcm0vbXNtL2RzaS9waHkvZHNpX3BoeV8yOG5tLmMKKysrIGIvZHJpdmVycy9ncHUvZHJt L21zbS9kc2kvcGh5L2RzaV9waHlfMjhubS5jCkBAIC03Niw3ICs3Niw3IEBAIHN0YXRpYyBpbnQg ZHNpXzI4bm1fcGh5X2VuYWJsZShzdHJ1Y3QgbXNtX2RzaV9waHkgKnBoeSwgaW50IHNyY19wbGxf aWQsCiAJREJHKCIiKTsKIAogCWlmIChtc21fZHNpX2RwaHlfdGltaW5nX2NhbGModGltaW5nLCBj bGtfcmVxKSkgewotCQlkZXZfZXJyKCZwaHktPnBkZXYtPmRldiwKKwkJRFJNX0RFVl9FUlJPUigm cGh5LT5wZGV2LT5kZXYsCiAJCQkiJXM6IEQtUEhZIHRpbWluZyBjYWxjdWxhdGlvbiBmYWlsZWRc biIsIF9fZnVuY19fKTsKIAkJcmV0dXJuIC1FSU5WQUw7CiAJfQpkaWZmIC0tZ2l0IGEvZHJpdmVy cy9ncHUvZHJtL21zbS9kc2kvcGh5L2RzaV9waHlfMjhubV84OTYwLmMgYi9kcml2ZXJzL2dwdS9k cm0vbXNtL2RzaS9waHkvZHNpX3BoeV8yOG5tXzg5NjAuYwppbmRleCAzOTgwMDQ0Li45ODc5MGI0 IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vbXNtL2RzaS9waHkvZHNpX3BoeV8yOG5tXzg5 NjAuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL2RzaS9waHkvZHNpX3BoeV8yOG5tXzg5NjAu YwpAQCAtMTMyLDcgKzEzMiw3IEBAIHN0YXRpYyBpbnQgZHNpXzI4bm1fcGh5X2VuYWJsZShzdHJ1 Y3QgbXNtX2RzaV9waHkgKnBoeSwgaW50IHNyY19wbGxfaWQsCiAJREJHKCIiKTsKIAogCWlmICht c21fZHNpX2RwaHlfdGltaW5nX2NhbGModGltaW5nLCBjbGtfcmVxKSkgewotCQlkZXZfZXJyKCZw aHktPnBkZXYtPmRldiwKKwkJRFJNX0RFVl9FUlJPUigmcGh5LT5wZGV2LT5kZXYsCiAJCQkiJXM6 IEQtUEhZIHRpbWluZyBjYWxjdWxhdGlvbiBmYWlsZWRcbiIsIF9fZnVuY19fKTsKIAkJcmV0dXJu IC1FSU5WQUw7CiAJfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL21zbS9kc2kvcGxsL2Rz aV9wbGwuYyBiL2RyaXZlcnMvZ3B1L2RybS9tc20vZHNpL3BsbC9kc2lfcGxsLmMKaW5kZXggNjEz ZTIwNi4uN2ExZmI0ZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL21zbS9kc2kvcGxsL2Rz aV9wbGwuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL2RzaS9wbGwvZHNpX3BsbC5jCkBAIC0x NzUsNyArMTc1LDcgQEAgc3RydWN0IG1zbV9kc2lfcGxsICptc21fZHNpX3BsbF9pbml0KHN0cnVj dCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYsCiAJfQogCiAJaWYgKElTX0VSUihwbGwpKSB7Ci0JCWRl dl9lcnIoZGV2LCAiJXM6IGZhaWxlZCB0byBpbml0IERTSSBQTExcbiIsIF9fZnVuY19fKTsKKwkJ RFJNX0RFVl9FUlJPUihkZXYsICIlczogZmFpbGVkIHRvIGluaXQgRFNJIFBMTFxuIiwgX19mdW5j X18pOwogCQlyZXR1cm4gcGxsOwogCX0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL21z bS9kc2kvcGxsL2RzaV9wbGxfMTBubS5jIGIvZHJpdmVycy9ncHUvZHJtL21zbS9kc2kvcGxsL2Rz aV9wbGxfMTBubS5jCmluZGV4IDRjMDNmMGIuLmY4ODE5Y2MgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMv Z3B1L2RybS9tc20vZHNpL3BsbC9kc2lfcGxsXzEwbm0uYworKysgYi9kcml2ZXJzL2dwdS9kcm0v bXNtL2RzaS9wbGwvZHNpX3BsbF8xMG5tLmMKQEAgLTc2MCw3ICs3NjAsNyBAQCBzdGF0aWMgaW50 IHBsbF8xMG5tX3JlZ2lzdGVyKHN0cnVjdCBkc2lfcGxsXzEwbm0gKnBsbF8xMG5tKQogCXJldCA9 IG9mX2Nsa19hZGRfaHdfcHJvdmlkZXIoZGV2LT5vZl9ub2RlLCBvZl9jbGtfaHdfb25lY2VsbF9n ZXQsCiAJCQkJICAgICBwbGxfMTBubS0+aHdfZGF0YSk7CiAJaWYgKHJldCkgewotCQlkZXZfZXJy KGRldiwgImZhaWxlZCB0byByZWdpc3RlciBjbGsgcHJvdmlkZXI6ICVkXG4iLCByZXQpOworCQlE Uk1fREVWX0VSUk9SKGRldiwgImZhaWxlZCB0byByZWdpc3RlciBjbGsgcHJvdmlkZXI6ICVkXG4i LCByZXQpOwogCQlyZXR1cm4gcmV0OwogCX0KIApAQCAtNzg4LDEzICs3ODgsMTMgQEAgc3RydWN0 IG1zbV9kc2lfcGxsICptc21fZHNpX3BsbF8xMG5tX2luaXQoc3RydWN0IHBsYXRmb3JtX2Rldmlj ZSAqcGRldiwgaW50IGlkKQogCiAJcGxsXzEwbm0tPnBoeV9jbW5fbW1pbyA9IG1zbV9pb3JlbWFw KHBkZXYsICJkc2lfcGh5IiwgIkRTSV9QSFkiKTsKIAlpZiAoSVNfRVJSX09SX05VTEwocGxsXzEw bm0tPnBoeV9jbW5fbW1pbykpIHsKLQkJZGV2X2VycigmcGRldi0+ZGV2LCAiZmFpbGVkIHRvIG1h cCBDTU4gUEhZIGJhc2VcbiIpOworCQlEUk1fREVWX0VSUk9SKCZwZGV2LT5kZXYsICJmYWlsZWQg dG8gbWFwIENNTiBQSFkgYmFzZVxuIik7CiAJCXJldHVybiBFUlJfUFRSKC1FTk9NRU0pOwogCX0K IAogCXBsbF8xMG5tLT5tbWlvID0gbXNtX2lvcmVtYXAocGRldiwgImRzaV9wbGwiLCAiRFNJX1BM TCIpOwogCWlmIChJU19FUlJfT1JfTlVMTChwbGxfMTBubS0+bW1pbykpIHsKLQkJZGV2X2Vycigm cGRldi0+ZGV2LCAiZmFpbGVkIHRvIG1hcCBQTEwgYmFzZVxuIik7CisJCURSTV9ERVZfRVJST1Io JnBkZXYtPmRldiwgImZhaWxlZCB0byBtYXAgUExMIGJhc2VcbiIpOwogCQlyZXR1cm4gRVJSX1BU UigtRU5PTUVNKTsKIAl9CiAKQEAgLTgxMyw3ICs4MTMsNyBAQCBzdHJ1Y3QgbXNtX2RzaV9wbGwg Km1zbV9kc2lfcGxsXzEwbm1faW5pdChzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2LCBpbnQg aWQpCiAKIAlyZXQgPSBwbGxfMTBubV9yZWdpc3RlcihwbGxfMTBubSk7CiAJaWYgKHJldCkgewot CQlkZXZfZXJyKCZwZGV2LT5kZXYsICJmYWlsZWQgdG8gcmVnaXN0ZXIgUExMOiAlZFxuIiwgcmV0 KTsKKwkJRFJNX0RFVl9FUlJPUigmcGRldi0+ZGV2LCAiZmFpbGVkIHRvIHJlZ2lzdGVyIFBMTDog JWRcbiIsIHJldCk7CiAJCXJldHVybiBFUlJfUFRSKHJldCk7CiAJfQogCmRpZmYgLS1naXQgYS9k cml2ZXJzL2dwdS9kcm0vbXNtL2RzaS9wbGwvZHNpX3BsbF8xNG5tLmMgYi9kcml2ZXJzL2dwdS9k cm0vbXNtL2RzaS9wbGwvZHNpX3BsbF8xNG5tLmMKaW5kZXggNzFmZTYwZS4uMGUxOGNkZCAxMDA2 NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL21zbS9kc2kvcGxsL2RzaV9wbGxfMTRubS5jCisrKyBi L2RyaXZlcnMvZ3B1L2RybS9tc20vZHNpL3BsbC9kc2lfcGxsXzE0bm0uYwpAQCAtNzgzLDcgKzc4 Myw3IEBAIHN0YXRpYyBpbnQgZHNpX3BsbF8xNG5tX2VuYWJsZV9zZXEoc3RydWN0IG1zbV9kc2lf cGxsICpwbGwpCiAJCQkJCSBQT0xMX1RJTUVPVVRfVVMpOwogCiAJaWYgKHVubGlrZWx5KCFsb2Nr ZWQpKQotCQlkZXZfZXJyKCZwbGxfMTRubS0+cGRldi0+ZGV2LCAiRFNJIFBMTCBsb2NrIGZhaWxl ZFxuIik7CisJCURSTV9ERVZfRVJST1IoJnBsbF8xNG5tLT5wZGV2LT5kZXYsICJEU0kgUExMIGxv Y2sgZmFpbGVkXG4iKTsKIAllbHNlCiAJCURCRygiRFNJIFBMTCBsb2NrIHN1Y2Nlc3MiKTsKIApA QCAtODI5LDcgKzgyOSw3IEBAIHN0YXRpYyBpbnQgZHNpX3BsbF8xNG5tX3Jlc3RvcmVfc3RhdGUo c3RydWN0IG1zbV9kc2lfcGxsICpwbGwpCiAJcmV0ID0gZHNpX3BsbF8xNG5tX3Zjb19zZXRfcmF0 ZSgmcGxsLT5jbGtfaHcsCiAJCQkJCWNhY2hlZF9zdGF0ZS0+dmNvX3JhdGUsIDApOwogCWlmIChy ZXQpIHsKLQkJZGV2X2VycigmcGxsXzE0bm0tPnBkZXYtPmRldiwKKwkJRFJNX0RFVl9FUlJPUigm cGxsXzE0bm0tPnBkZXYtPmRldiwKIAkJCSJyZXN0b3JlIHZjbyByYXRlIGZhaWxlZC4gcmV0PSVk XG4iLCByZXQpOwogCQlyZXR1cm4gcmV0OwogCX0KQEAgLTEwMzksNyArMTAzOSw3IEBAIHN0YXRp YyBpbnQgcGxsXzE0bm1fcmVnaXN0ZXIoc3RydWN0IGRzaV9wbGxfMTRubSAqcGxsXzE0bm0pCiAJ cmV0ID0gb2ZfY2xrX2FkZF9od19wcm92aWRlcihkZXYtPm9mX25vZGUsIG9mX2Nsa19od19vbmVj ZWxsX2dldCwKIAkJCQkgICAgIHBsbF8xNG5tLT5od19kYXRhKTsKIAlpZiAocmV0KSB7Ci0JCWRl dl9lcnIoZGV2LCAiZmFpbGVkIHRvIHJlZ2lzdGVyIGNsayBwcm92aWRlcjogJWRcbiIsIHJldCk7 CisJCURSTV9ERVZfRVJST1IoZGV2LCAiZmFpbGVkIHRvIHJlZ2lzdGVyIGNsayBwcm92aWRlcjog JWRcbiIsIHJldCk7CiAJCXJldHVybiByZXQ7CiAJfQogCkBAIC0xMDY3LDEzICsxMDY3LDEzIEBA IHN0cnVjdCBtc21fZHNpX3BsbCAqbXNtX2RzaV9wbGxfMTRubV9pbml0KHN0cnVjdCBwbGF0Zm9y bV9kZXZpY2UgKnBkZXYsIGludCBpZCkKIAogCXBsbF8xNG5tLT5waHlfY21uX21taW8gPSBtc21f aW9yZW1hcChwZGV2LCAiZHNpX3BoeSIsICJEU0lfUEhZIik7CiAJaWYgKElTX0VSUl9PUl9OVUxM KHBsbF8xNG5tLT5waHlfY21uX21taW8pKSB7Ci0JCWRldl9lcnIoJnBkZXYtPmRldiwgImZhaWxl ZCB0byBtYXAgQ01OIFBIWSBiYXNlXG4iKTsKKwkJRFJNX0RFVl9FUlJPUigmcGRldi0+ZGV2LCAi ZmFpbGVkIHRvIG1hcCBDTU4gUEhZIGJhc2VcbiIpOwogCQlyZXR1cm4gRVJSX1BUUigtRU5PTUVN KTsKIAl9CiAKIAlwbGxfMTRubS0+bW1pbyA9IG1zbV9pb3JlbWFwKHBkZXYsICJkc2lfcGxsIiwg IkRTSV9QTEwiKTsKIAlpZiAoSVNfRVJSX09SX05VTEwocGxsXzE0bm0tPm1taW8pKSB7Ci0JCWRl dl9lcnIoJnBkZXYtPmRldiwgImZhaWxlZCB0byBtYXAgUExMIGJhc2VcbiIpOworCQlEUk1fREVW X0VSUk9SKCZwZGV2LT5kZXYsICJmYWlsZWQgdG8gbWFwIFBMTCBiYXNlXG4iKTsKIAkJcmV0dXJu IEVSUl9QVFIoLUVOT01FTSk7CiAJfQogCkBAIC0xMDk2LDcgKzEwOTYsNyBAQCBzdHJ1Y3QgbXNt X2RzaV9wbGwgKm1zbV9kc2lfcGxsXzE0bm1faW5pdChzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpw ZGV2LCBpbnQgaWQpCiAKIAlyZXQgPSBwbGxfMTRubV9yZWdpc3RlcihwbGxfMTRubSk7CiAJaWYg KHJldCkgewotCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJmYWlsZWQgdG8gcmVnaXN0ZXIgUExMOiAl ZFxuIiwgcmV0KTsKKwkJRFJNX0RFVl9FUlJPUigmcGRldi0+ZGV2LCAiZmFpbGVkIHRvIHJlZ2lz dGVyIFBMTDogJWRcbiIsIHJldCk7CiAJCXJldHVybiBFUlJfUFRSKHJldCk7CiAJfQogCmRpZmYg LS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbXNtL2RzaS9wbGwvZHNpX3BsbF8yOG5tLmMgYi9kcml2 ZXJzL2dwdS9kcm0vbXNtL2RzaS9wbGwvZHNpX3BsbF8yOG5tLmMKaW5kZXggMjZlM2EwMS4uZGNi YmFlYiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL21zbS9kc2kvcGxsL2RzaV9wbGxfMjhu bS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9tc20vZHNpL3BsbC9kc2lfcGxsXzI4bm0uYwpAQCAt MTU2LDcgKzE1Niw3IEBAIHN0YXRpYyBpbnQgZHNpX3BsbF8yOG5tX2Nsa19zZXRfcmF0ZShzdHJ1 Y3QgY2xrX2h3ICpodywgdW5zaWduZWQgbG9uZyByYXRlLAogCQlpZiAocmF0ZSA8PSBscGZyX2x1 dFtpXS52Y29fcmF0ZSkKIAkJCWJyZWFrOwogCWlmIChpID09IExQRlJfTFVUX1NJWkUpIHsKLQkJ ZGV2X2VycihkZXYsICJ1bmFibGUgdG8gZ2V0IGxvb3AgZmlsdGVyIHJlc2lzdGFuY2UuIHZjbz0l bHVcbiIsCisJCURSTV9ERVZfRVJST1IoZGV2LCAidW5hYmxlIHRvIGdldCBsb29wIGZpbHRlciBy ZXNpc3RhbmNlLiB2Y289JWx1XG4iLAogCQkJCXJhdGUpOwogCQlyZXR1cm4gLUVJTlZBTDsKIAl9 CkBAIC0zODYsNyArMzg2LDcgQEAgc3RhdGljIGludCBkc2lfcGxsXzI4bm1fZW5hYmxlX3NlcV9o cG0oc3RydWN0IG1zbV9kc2lfcGxsICpwbGwpCiAJfQogCiAJaWYgKHVubGlrZWx5KCFsb2NrZWQp KQotCQlkZXZfZXJyKGRldiwgIkRTSSBQTEwgbG9jayBmYWlsZWRcbiIpOworCQlEUk1fREVWX0VS Uk9SKGRldiwgIkRTSSBQTEwgbG9jayBmYWlsZWRcbiIpOwogCWVsc2UKIAkJREJHKCJEU0kgUExM IExvY2sgc3VjY2VzcyIpOwogCkBAIC00MjksNyArNDI5LDcgQEAgc3RhdGljIGludCBkc2lfcGxs XzI4bm1fZW5hYmxlX3NlcV9scChzdHJ1Y3QgbXNtX2RzaV9wbGwgKnBsbCkKIAlsb2NrZWQgPSBw bGxfMjhubV9wb2xsX2Zvcl9yZWFkeShwbGxfMjhubSwgbWF4X3JlYWRzLCB0aW1lb3V0X3VzKTsK IAogCWlmICh1bmxpa2VseSghbG9ja2VkKSkKLQkJZGV2X2VycihkZXYsICJEU0kgUExMIGxvY2sg ZmFpbGVkXG4iKTsKKwkJRFJNX0RFVl9FUlJPUihkZXYsICJEU0kgUExMIGxvY2sgZmFpbGVkXG4i KTsKIAllbHNlCiAJCURCRygiRFNJIFBMTCBsb2NrIHN1Y2Nlc3MiKTsKIApAQCAtNDY4LDcgKzQ2 OCw3IEBAIHN0YXRpYyBpbnQgZHNpX3BsbF8yOG5tX3Jlc3RvcmVfc3RhdGUoc3RydWN0IG1zbV9k c2lfcGxsICpwbGwpCiAJcmV0ID0gZHNpX3BsbF8yOG5tX2Nsa19zZXRfcmF0ZSgmcGxsLT5jbGtf aHcsCiAJCQkJCWNhY2hlZF9zdGF0ZS0+dmNvX3JhdGUsIDApOwogCWlmIChyZXQpIHsKLQkJZGV2 X2VycigmcGxsXzI4bm0tPnBkZXYtPmRldiwKKwkJRFJNX0RFVl9FUlJPUigmcGxsXzI4bm0tPnBk ZXYtPmRldiwKIAkJCSJyZXN0b3JlIHZjbyByYXRlIGZhaWxlZC4gcmV0PSVkXG4iLCByZXQpOwog CQlyZXR1cm4gcmV0OwogCX0KQEAgLTU4MSw3ICs1ODEsNyBAQCBzdGF0aWMgaW50IHBsbF8yOG5t X3JlZ2lzdGVyKHN0cnVjdCBkc2lfcGxsXzI4bm0gKnBsbF8yOG5tKQogCXJldCA9IG9mX2Nsa19h ZGRfcHJvdmlkZXIoZGV2LT5vZl9ub2RlLAogCQkJb2ZfY2xrX3NyY19vbmVjZWxsX2dldCwgJnBs bF8yOG5tLT5jbGtfZGF0YSk7CiAJaWYgKHJldCkgewotCQlkZXZfZXJyKGRldiwgImZhaWxlZCB0 byByZWdpc3RlciBjbGsgcHJvdmlkZXI6ICVkXG4iLCByZXQpOworCQlEUk1fREVWX0VSUk9SKGRl diwgImZhaWxlZCB0byByZWdpc3RlciBjbGsgcHJvdmlkZXI6ICVkXG4iLCByZXQpOwogCQlyZXR1 cm4gcmV0OwogCX0KIApAQCAtNjA3LDcgKzYwNyw3IEBAIHN0cnVjdCBtc21fZHNpX3BsbCAqbXNt X2RzaV9wbGxfMjhubV9pbml0KHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYsCiAKIAlwbGxf MjhubS0+bW1pbyA9IG1zbV9pb3JlbWFwKHBkZXYsICJkc2lfcGxsIiwgIkRTSV9QTEwiKTsKIAlp ZiAoSVNfRVJSX09SX05VTEwocGxsXzI4bm0tPm1taW8pKSB7Ci0JCWRldl9lcnIoJnBkZXYtPmRl diwgIiVzOiBmYWlsZWQgdG8gbWFwIHBsbCBiYXNlXG4iLCBfX2Z1bmNfXyk7CisJCURSTV9ERVZf RVJST1IoJnBkZXYtPmRldiwgIiVzOiBmYWlsZWQgdG8gbWFwIHBsbCBiYXNlXG4iLCBfX2Z1bmNf Xyk7CiAJCXJldHVybiBFUlJfUFRSKC1FTk9NRU0pOwogCX0KIApAQCAtNjMzLDEzICs2MzMsMTMg QEAgc3RydWN0IG1zbV9kc2lfcGxsICptc21fZHNpX3BsbF8yOG5tX2luaXQoc3RydWN0IHBsYXRm b3JtX2RldmljZSAqcGRldiwKIAkJcGxsLT5lbl9zZXFfY250ID0gMTsKIAkJcGxsLT5lbmFibGVf c2Vxc1swXSA9IGRzaV9wbGxfMjhubV9lbmFibGVfc2VxX2xwOwogCX0gZWxzZSB7Ci0JCWRldl9l cnIoJnBkZXYtPmRldiwgInBoeSB0eXBlICglZCkgaXMgbm90IDI4bm1cbiIsIHR5cGUpOworCQlE Uk1fREVWX0VSUk9SKCZwZGV2LT5kZXYsICJwaHkgdHlwZSAoJWQpIGlzIG5vdCAyOG5tXG4iLCB0 eXBlKTsKIAkJcmV0dXJuIEVSUl9QVFIoLUVJTlZBTCk7CiAJfQogCiAJcmV0ID0gcGxsXzI4bm1f cmVnaXN0ZXIocGxsXzI4bm0pOwogCWlmIChyZXQpIHsKLQkJZGV2X2VycigmcGRldi0+ZGV2LCAi ZmFpbGVkIHRvIHJlZ2lzdGVyIFBMTDogJWRcbiIsIHJldCk7CisJCURSTV9ERVZfRVJST1IoJnBk ZXYtPmRldiwgImZhaWxlZCB0byByZWdpc3RlciBQTEw6ICVkXG4iLCByZXQpOwogCQlyZXR1cm4g RVJSX1BUUihyZXQpOwogCX0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL21zbS9kc2kv cGxsL2RzaV9wbGxfMjhubV84OTYwLmMgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL2RzaS9wbGwvZHNp X3BsbF8yOG5tXzg5NjAuYwppbmRleCA0OTAwODQ1Li5kNjg5NzQ2IDEwMDY0NAotLS0gYS9kcml2 ZXJzL2dwdS9kcm0vbXNtL2RzaS9wbGwvZHNpX3BsbF8yOG5tXzg5NjAuYworKysgYi9kcml2ZXJz L2dwdS9kcm0vbXNtL2RzaS9wbGwvZHNpX3BsbF8yOG5tXzg5NjAuYwpAQCAtMzI3LDcgKzMyNyw3 IEBAIHN0YXRpYyBpbnQgZHNpX3BsbF8yOG5tX2VuYWJsZV9zZXEoc3RydWN0IG1zbV9kc2lfcGxs ICpwbGwpCiAJbG9ja2VkID0gcGxsXzI4bm1fcG9sbF9mb3JfcmVhZHkocGxsXzI4bm0sIG1heF9y ZWFkcywgdGltZW91dF91cyk7CiAKIAlpZiAodW5saWtlbHkoIWxvY2tlZCkpCi0JCWRldl9lcnIo ZGV2LCAiRFNJIFBMTCBsb2NrIGZhaWxlZFxuIik7CisJCURSTV9ERVZfRVJST1IoZGV2LCAiRFNJ IFBMTCBsb2NrIGZhaWxlZFxuIik7CiAJZWxzZQogCQlEQkcoIkRTSSBQTEwgbG9jayBzdWNjZXNz Iik7CiAKQEAgLTM2OCw3ICszNjgsNyBAQCBzdGF0aWMgaW50IGRzaV9wbGxfMjhubV9yZXN0b3Jl X3N0YXRlKHN0cnVjdCBtc21fZHNpX3BsbCAqcGxsKQogCXJldCA9IGRzaV9wbGxfMjhubV9jbGtf c2V0X3JhdGUoJnBsbC0+Y2xrX2h3LAogCQkJCQljYWNoZWRfc3RhdGUtPnZjb19yYXRlLCAwKTsK IAlpZiAocmV0KSB7Ci0JCWRldl9lcnIoJnBsbF8yOG5tLT5wZGV2LT5kZXYsCisJCURSTV9ERVZf RVJST1IoJnBsbF8yOG5tLT5wZGV2LT5kZXYsCiAJCQkicmVzdG9yZSB2Y28gcmF0ZSBmYWlsZWQu IHJldD0lZFxuIiwgcmV0KTsKIAkJcmV0dXJuIHJldDsKIAl9CkBAIC00ODIsNyArNDgyLDcgQEAg c3RhdGljIGludCBwbGxfMjhubV9yZWdpc3RlcihzdHJ1Y3QgZHNpX3BsbF8yOG5tICpwbGxfMjhu bSkKIAlyZXQgPSBvZl9jbGtfYWRkX3Byb3ZpZGVyKGRldi0+b2Zfbm9kZSwKIAkJCW9mX2Nsa19z cmNfb25lY2VsbF9nZXQsICZwbGxfMjhubS0+Y2xrX2RhdGEpOwogCWlmIChyZXQpIHsKLQkJZGV2 X2VycihkZXYsICJmYWlsZWQgdG8gcmVnaXN0ZXIgY2xrIHByb3ZpZGVyOiAlZFxuIiwgcmV0KTsK KwkJRFJNX0RFVl9FUlJPUihkZXYsICJmYWlsZWQgdG8gcmVnaXN0ZXIgY2xrIHByb3ZpZGVyOiAl ZFxuIiwgcmV0KTsKIAkJcmV0dXJuIHJldDsKIAl9CiAKQEAgLTUwOCw3ICs1MDgsNyBAQCBzdHJ1 Y3QgbXNtX2RzaV9wbGwgKm1zbV9kc2lfcGxsXzI4bm1fODk2MF9pbml0KHN0cnVjdCBwbGF0Zm9y bV9kZXZpY2UgKnBkZXYsCiAKIAlwbGxfMjhubS0+bW1pbyA9IG1zbV9pb3JlbWFwKHBkZXYsICJk c2lfcGxsIiwgIkRTSV9QTEwiKTsKIAlpZiAoSVNfRVJSX09SX05VTEwocGxsXzI4bm0tPm1taW8p KSB7Ci0JCWRldl9lcnIoJnBkZXYtPmRldiwgIiVzOiBmYWlsZWQgdG8gbWFwIHBsbCBiYXNlXG4i LCBfX2Z1bmNfXyk7CisJCURSTV9ERVZfRVJST1IoJnBkZXYtPmRldiwgIiVzOiBmYWlsZWQgdG8g bWFwIHBsbCBiYXNlXG4iLCBfX2Z1bmNfXyk7CiAJCXJldHVybiBFUlJfUFRSKC1FTk9NRU0pOwog CX0KIApAQCAtNTI2LDcgKzUyNiw3IEBAIHN0cnVjdCBtc21fZHNpX3BsbCAqbXNtX2RzaV9wbGxf MjhubV84OTYwX2luaXQoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldiwKIAogCXJldCA9IHBs bF8yOG5tX3JlZ2lzdGVyKHBsbF8yOG5tKTsKIAlpZiAocmV0KSB7Ci0JCWRldl9lcnIoJnBkZXYt PmRldiwgImZhaWxlZCB0byByZWdpc3RlciBQTEw6ICVkXG4iLCByZXQpOworCQlEUk1fREVWX0VS Uk9SKCZwZGV2LT5kZXYsICJmYWlsZWQgdG8gcmVnaXN0ZXIgUExMOiAlZFxuIiwgcmV0KTsKIAkJ cmV0dXJuIEVSUl9QVFIocmV0KTsKIAl9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9t c20vZWRwL2VkcC5jIGIvZHJpdmVycy9ncHUvZHJtL21zbS9lZHAvZWRwLmMKaW5kZXggMDk0MGU4 NC4uNmE2M2FiYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL21zbS9lZHAvZWRwLmMKKysr IGIvZHJpdmVycy9ncHUvZHJtL21zbS9lZHAvZWRwLmMKQEAgLTE1Nyw3ICsxNTcsNyBAQCBpbnQg bXNtX2VkcF9tb2Rlc2V0X2luaXQoc3RydWN0IG1zbV9lZHAgKmVkcCwgc3RydWN0IGRybV9kZXZp Y2UgKmRldiwKIAllZHAtPmJyaWRnZSA9IG1zbV9lZHBfYnJpZGdlX2luaXQoZWRwKTsKIAlpZiAo SVNfRVJSKGVkcC0+YnJpZGdlKSkgewogCQlyZXQgPSBQVFJfRVJSKGVkcC0+YnJpZGdlKTsKLQkJ ZGV2X2VycihkZXYtPmRldiwgImZhaWxlZCB0byBjcmVhdGUgZURQIGJyaWRnZTogJWRcbiIsIHJl dCk7CisJCURSTV9ERVZfRVJST1IoZGV2LT5kZXYsICJmYWlsZWQgdG8gY3JlYXRlIGVEUCBicmlk Z2U6ICVkXG4iLCByZXQpOwogCQllZHAtPmJyaWRnZSA9IE5VTEw7CiAJCWdvdG8gZmFpbDsKIAl9 CkBAIC0xNjUsNyArMTY1LDcgQEAgaW50IG1zbV9lZHBfbW9kZXNldF9pbml0KHN0cnVjdCBtc21f ZWRwICplZHAsIHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsCiAJZWRwLT5jb25uZWN0b3IgPSBtc21f ZWRwX2Nvbm5lY3Rvcl9pbml0KGVkcCk7CiAJaWYgKElTX0VSUihlZHAtPmNvbm5lY3RvcikpIHsK IAkJcmV0ID0gUFRSX0VSUihlZHAtPmNvbm5lY3Rvcik7Ci0JCWRldl9lcnIoZGV2LT5kZXYsICJm YWlsZWQgdG8gY3JlYXRlIGVEUCBjb25uZWN0b3I6ICVkXG4iLCByZXQpOworCQlEUk1fREVWX0VS Uk9SKGRldi0+ZGV2LCAiZmFpbGVkIHRvIGNyZWF0ZSBlRFAgY29ubmVjdG9yOiAlZFxuIiwgcmV0 KTsKIAkJZWRwLT5jb25uZWN0b3IgPSBOVUxMOwogCQlnb3RvIGZhaWw7CiAJfQpAQCAtMTczLDcg KzE3Myw3IEBAIGludCBtc21fZWRwX21vZGVzZXRfaW5pdChzdHJ1Y3QgbXNtX2VkcCAqZWRwLCBz dHJ1Y3QgZHJtX2RldmljZSAqZGV2LAogCWVkcC0+aXJxID0gaXJxX29mX3BhcnNlX2FuZF9tYXAo cGRldi0+ZGV2Lm9mX25vZGUsIDApOwogCWlmIChlZHAtPmlycSA8IDApIHsKIAkJcmV0ID0gZWRw LT5pcnE7Ci0JCWRldl9lcnIoZGV2LT5kZXYsICJmYWlsZWQgdG8gZ2V0IElSUTogJWRcbiIsIHJl dCk7CisJCURSTV9ERVZfRVJST1IoZGV2LT5kZXYsICJmYWlsZWQgdG8gZ2V0IElSUTogJWRcbiIs IHJldCk7CiAJCWdvdG8gZmFpbDsKIAl9CiAKQEAgLTE4MSw3ICsxODEsNyBAQCBpbnQgbXNtX2Vk cF9tb2Rlc2V0X2luaXQoc3RydWN0IG1zbV9lZHAgKmVkcCwgc3RydWN0IGRybV9kZXZpY2UgKmRl diwKIAkJCWVkcF9pcnEsIElSUUZfVFJJR0dFUl9ISUdIIHwgSVJRRl9PTkVTSE9ULAogCQkJImVk cF9pc3IiLCBlZHApOwogCWlmIChyZXQgPCAwKSB7Ci0JCWRldl9lcnIoZGV2LT5kZXYsICJmYWls ZWQgdG8gcmVxdWVzdCBJUlEldTogJWRcbiIsCisJCURSTV9ERVZfRVJST1IoZGV2LT5kZXYsICJm YWlsZWQgdG8gcmVxdWVzdCBJUlEldTogJWRcbiIsCiAJCQkJZWRwLT5pcnEsIHJldCk7CiAJCWdv dG8gZmFpbDsKIAl9CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbXNtL2hkbWkvaGRtaS5j IGIvZHJpdmVycy9ncHUvZHJtL21zbS9oZG1pL2hkbWkuYwppbmRleCAyMzY3MDkwLi5mMDcyNTc2 IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vbXNtL2hkbWkvaGRtaS5jCisrKyBiL2RyaXZl cnMvZ3B1L2RybS9tc20vaGRtaS9oZG1pLmMKQEAgLTk4LDcgKzk4LDcgQEAgc3RhdGljIGludCBt c21faGRtaV9nZXRfcGh5KHN0cnVjdCBoZG1pICpoZG1pKQogCiAJcGh5X25vZGUgPSBvZl9wYXJz ZV9waGFuZGxlKHBkZXYtPmRldi5vZl9ub2RlLCAicGh5cyIsIDApOwogCWlmICghcGh5X25vZGUp IHsKLQkJZGV2X2VycigmcGRldi0+ZGV2LCAiY2Fubm90IGZpbmQgcGh5IGRldmljZVxuIik7CisJ CURSTV9ERVZfRVJST1IoJnBkZXYtPmRldiwgImNhbm5vdCBmaW5kIHBoeSBkZXZpY2VcbiIpOwog CQlyZXR1cm4gLUVOWElPOwogCX0KIApAQCAtMTA5LDcgKzEwOSw3IEBAIHN0YXRpYyBpbnQgbXNt X2hkbWlfZ2V0X3BoeShzdHJ1Y3QgaGRtaSAqaGRtaSkKIAlvZl9ub2RlX3B1dChwaHlfbm9kZSk7 CiAKIAlpZiAoIXBoeV9wZGV2IHx8ICFoZG1pLT5waHkpIHsKLQkJZGV2X2VycigmcGRldi0+ZGV2 LCAicGh5IGRyaXZlciBpcyBub3QgcmVhZHlcbiIpOworCQlEUk1fREVWX0VSUk9SKCZwZGV2LT5k ZXYsICJwaHkgZHJpdmVyIGlzIG5vdCByZWFkeVxuIik7CiAJCXJldHVybiAtRVBST0JFX0RFRkVS OwogCX0KIApAQCAtMTUzLDcgKzE1Myw3IEBAIHN0YXRpYyBzdHJ1Y3QgaGRtaSAqbXNtX2hkbWlf aW5pdChzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQogCWhkbWktPnFmcHJvbV9tbWlvID0g bXNtX2lvcmVtYXAocGRldiwKIAkJY29uZmlnLT5xZnByb21fbW1pb19uYW1lLCAiSERNSV9RRlBS T00iKTsKIAlpZiAoSVNfRVJSKGhkbWktPnFmcHJvbV9tbWlvKSkgewotCQlkZXZfaW5mbygmcGRl di0+ZGV2LCAiY2FuJ3QgZmluZCBxZnByb20gcmVzb3VyY2VcbiIpOworCQlEUk1fREVWX0lORk8o JnBkZXYtPmRldiwgImNhbid0IGZpbmQgcWZwcm9tIHJlc291cmNlXG4iKTsKIAkJaGRtaS0+cWZw cm9tX21taW8gPSBOVUxMOwogCX0KIApAQCAtMTcyLDcgKzE3Miw3IEBAIHN0YXRpYyBzdHJ1Y3Qg aGRtaSAqbXNtX2hkbWlfaW5pdChzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQogCQkJCWNv bmZpZy0+aHBkX3JlZ19uYW1lc1tpXSk7CiAJCWlmIChJU19FUlIocmVnKSkgewogCQkJcmV0ID0g UFRSX0VSUihyZWcpOwotCQkJZGV2X2VycigmcGRldi0+ZGV2LCAiZmFpbGVkIHRvIGdldCBocGQg cmVndWxhdG9yOiAlcyAoJWQpXG4iLAorCQkJRFJNX0RFVl9FUlJPUigmcGRldi0+ZGV2LCAiZmFp bGVkIHRvIGdldCBocGQgcmVndWxhdG9yOiAlcyAoJWQpXG4iLAogCQkJCQljb25maWctPmhwZF9y ZWdfbmFtZXNbaV0sIHJldCk7CiAJCQlnb3RvIGZhaWw7CiAJCX0KQEAgLTE5NSw3ICsxOTUsNyBA QCBzdGF0aWMgc3RydWN0IGhkbWkgKm1zbV9oZG1pX2luaXQoc3RydWN0IHBsYXRmb3JtX2Rldmlj ZSAqcGRldikKIAkJCQljb25maWctPnB3cl9yZWdfbmFtZXNbaV0pOwogCQlpZiAoSVNfRVJSKHJl ZykpIHsKIAkJCXJldCA9IFBUUl9FUlIocmVnKTsKLQkJCWRldl9lcnIoJnBkZXYtPmRldiwgImZh aWxlZCB0byBnZXQgcHdyIHJlZ3VsYXRvcjogJXMgKCVkKVxuIiwKKwkJCURSTV9ERVZfRVJST1Io JnBkZXYtPmRldiwgImZhaWxlZCB0byBnZXQgcHdyIHJlZ3VsYXRvcjogJXMgKCVkKVxuIiwKIAkJ CQkJY29uZmlnLT5wd3JfcmVnX25hbWVzW2ldLCByZXQpOwogCQkJZ290byBmYWlsOwogCQl9CkBA IC0yMTcsNyArMjE3LDcgQEAgc3RhdGljIHN0cnVjdCBoZG1pICptc21faGRtaV9pbml0KHN0cnVj dCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCiAJCWNsayA9IG1zbV9jbGtfZ2V0KHBkZXYsIGNvbmZp Zy0+aHBkX2Nsa19uYW1lc1tpXSk7CiAJCWlmIChJU19FUlIoY2xrKSkgewogCQkJcmV0ID0gUFRS X0VSUihjbGspOwotCQkJZGV2X2VycigmcGRldi0+ZGV2LCAiZmFpbGVkIHRvIGdldCBocGQgY2xr OiAlcyAoJWQpXG4iLAorCQkJRFJNX0RFVl9FUlJPUigmcGRldi0+ZGV2LCAiZmFpbGVkIHRvIGdl dCBocGQgY2xrOiAlcyAoJWQpXG4iLAogCQkJCQljb25maWctPmhwZF9jbGtfbmFtZXNbaV0sIHJl dCk7CiAJCQlnb3RvIGZhaWw7CiAJCX0KQEAgLTIzOSw3ICsyMzksNyBAQCBzdGF0aWMgc3RydWN0 IGhkbWkgKm1zbV9oZG1pX2luaXQoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKIAkJY2xr ID0gbXNtX2Nsa19nZXQocGRldiwgY29uZmlnLT5wd3JfY2xrX25hbWVzW2ldKTsKIAkJaWYgKElT X0VSUihjbGspKSB7CiAJCQlyZXQgPSBQVFJfRVJSKGNsayk7Ci0JCQlkZXZfZXJyKCZwZGV2LT5k ZXYsICJmYWlsZWQgdG8gZ2V0IHB3ciBjbGs6ICVzICglZClcbiIsCisJCQlEUk1fREVWX0VSUk9S KCZwZGV2LT5kZXYsICJmYWlsZWQgdG8gZ2V0IHB3ciBjbGs6ICVzICglZClcbiIsCiAJCQkJCWNv bmZpZy0+cHdyX2Nsa19uYW1lc1tpXSwgcmV0KTsKIAkJCWdvdG8gZmFpbDsKIAkJfQpAQCAtMjU0 LDE0ICsyNTQsMTQgQEAgc3RhdGljIHN0cnVjdCBoZG1pICptc21faGRtaV9pbml0KHN0cnVjdCBw bGF0Zm9ybV9kZXZpY2UgKnBkZXYpCiAJaGRtaS0+aTJjID0gbXNtX2hkbWlfaTJjX2luaXQoaGRt aSk7CiAJaWYgKElTX0VSUihoZG1pLT5pMmMpKSB7CiAJCXJldCA9IFBUUl9FUlIoaGRtaS0+aTJj KTsKLQkJZGV2X2VycigmcGRldi0+ZGV2LCAiZmFpbGVkIHRvIGdldCBpMmM6ICVkXG4iLCByZXQp OworCQlEUk1fREVWX0VSUk9SKCZwZGV2LT5kZXYsICJmYWlsZWQgdG8gZ2V0IGkyYzogJWRcbiIs IHJldCk7CiAJCWhkbWktPmkyYyA9IE5VTEw7CiAJCWdvdG8gZmFpbDsKIAl9CiAKIAlyZXQgPSBt c21faGRtaV9nZXRfcGh5KGhkbWkpOwogCWlmIChyZXQpIHsKLQkJZGV2X2VycigmcGRldi0+ZGV2 LCAiZmFpbGVkIHRvIGdldCBwaHlcbiIpOworCQlEUk1fREVWX0VSUk9SKCZwZGV2LT5kZXYsICJm YWlsZWQgdG8gZ2V0IHBoeVxuIik7CiAJCWdvdG8gZmFpbDsKIAl9CiAKQEAgLTMwMyw3ICszMDMs NyBAQCBpbnQgbXNtX2hkbWlfbW9kZXNldF9pbml0KHN0cnVjdCBoZG1pICpoZG1pLAogCWhkbWkt PmJyaWRnZSA9IG1zbV9oZG1pX2JyaWRnZV9pbml0KGhkbWkpOwogCWlmIChJU19FUlIoaGRtaS0+ YnJpZGdlKSkgewogCQlyZXQgPSBQVFJfRVJSKGhkbWktPmJyaWRnZSk7Ci0JCWRldl9lcnIoZGV2 LT5kZXYsICJmYWlsZWQgdG8gY3JlYXRlIEhETUkgYnJpZGdlOiAlZFxuIiwgcmV0KTsKKwkJRFJN X0RFVl9FUlJPUihkZXYtPmRldiwgImZhaWxlZCB0byBjcmVhdGUgSERNSSBicmlkZ2U6ICVkXG4i LCByZXQpOwogCQloZG1pLT5icmlkZ2UgPSBOVUxMOwogCQlnb3RvIGZhaWw7CiAJfQpAQCAtMzEx LDcgKzMxMSw3IEBAIGludCBtc21faGRtaV9tb2Rlc2V0X2luaXQoc3RydWN0IGhkbWkgKmhkbWks CiAJaGRtaS0+Y29ubmVjdG9yID0gbXNtX2hkbWlfY29ubmVjdG9yX2luaXQoaGRtaSk7CiAJaWYg KElTX0VSUihoZG1pLT5jb25uZWN0b3IpKSB7CiAJCXJldCA9IFBUUl9FUlIoaGRtaS0+Y29ubmVj dG9yKTsKLQkJZGV2X2VycihkZXYtPmRldiwgImZhaWxlZCB0byBjcmVhdGUgSERNSSBjb25uZWN0 b3I6ICVkXG4iLCByZXQpOworCQlEUk1fREVWX0VSUk9SKGRldi0+ZGV2LCAiZmFpbGVkIHRvIGNy ZWF0ZSBIRE1JIGNvbm5lY3RvcjogJWRcbiIsIHJldCk7CiAJCWhkbWktPmNvbm5lY3RvciA9IE5V TEw7CiAJCWdvdG8gZmFpbDsKIAl9CkBAIC0zMTksNyArMzE5LDcgQEAgaW50IG1zbV9oZG1pX21v ZGVzZXRfaW5pdChzdHJ1Y3QgaGRtaSAqaGRtaSwKIAloZG1pLT5pcnEgPSBpcnFfb2ZfcGFyc2Vf YW5kX21hcChwZGV2LT5kZXYub2Zfbm9kZSwgMCk7CiAJaWYgKGhkbWktPmlycSA8IDApIHsKIAkJ cmV0ID0gaGRtaS0+aXJxOwotCQlkZXZfZXJyKGRldi0+ZGV2LCAiZmFpbGVkIHRvIGdldCBpcnE6 ICVkXG4iLCByZXQpOworCQlEUk1fREVWX0VSUk9SKGRldi0+ZGV2LCAiZmFpbGVkIHRvIGdldCBp cnE6ICVkXG4iLCByZXQpOwogCQlnb3RvIGZhaWw7CiAJfQogCkBAIC0zMjcsNyArMzI3LDcgQEAg aW50IG1zbV9oZG1pX21vZGVzZXRfaW5pdChzdHJ1Y3QgaGRtaSAqaGRtaSwKIAkJCW1zbV9oZG1p X2lycSwgSVJRRl9UUklHR0VSX0hJR0ggfCBJUlFGX09ORVNIT1QsCiAJCQkiaGRtaV9pc3IiLCBo ZG1pKTsKIAlpZiAocmV0IDwgMCkgewotCQlkZXZfZXJyKGRldi0+ZGV2LCAiZmFpbGVkIHRvIHJl cXVlc3QgSVJRJXU6ICVkXG4iLAorCQlEUk1fREVWX0VSUk9SKGRldi0+ZGV2LCAiZmFpbGVkIHRv IHJlcXVlc3QgSVJRJXU6ICVkXG4iLAogCQkJCWhkbWktPmlycSwgcmV0KTsKIAkJZ290byBmYWls OwogCX0KQEAgLTQ3Niw3ICs0NzYsNyBAQCBzdGF0aWMgaW50IG1zbV9oZG1pX2F1ZGlvX2h3X3Bh cmFtcyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHZvaWQgKmRhdGEsCiAJdW5zaWduZWQgaW50IGxldmVs X3NoaWZ0ICA9IDA7IC8qIDBkQiAqLwogCWJvb2wgZG93bl9taXggPSBmYWxzZTsKIAotCWRldl9k YmcoZGV2LCAiJXUgSHosICVkIGJpdCwgJWQgY2hhbm5lbHNcbiIsIHBhcmFtcy0+c2FtcGxlX3Jh dGUsCisJRFJNX0RFVl9ERUJVRyhkZXYsICIldSBIeiwgJWQgYml0LCAlZCBjaGFubmVsc1xuIiwg cGFyYW1zLT5zYW1wbGVfcmF0ZSwKIAkJIHBhcmFtcy0+c2FtcGxlX3dpZHRoLCBwYXJhbXMtPmNl YS5jaGFubmVscyk7CiAKIAlzd2l0Y2ggKHBhcmFtcy0+Y2VhLmNoYW5uZWxzKSB7CkBAIC01Mjcs NyArNTI3LDcgQEAgc3RhdGljIGludCBtc21faGRtaV9hdWRpb19od19wYXJhbXMoc3RydWN0IGRl dmljZSAqZGV2LCB2b2lkICpkYXRhLAogCQlyYXRlID0gSERNSV9TQU1QTEVfUkFURV8xOTJLSFo7 CiAJCWJyZWFrOwogCWRlZmF1bHQ6Ci0JCWRldl9lcnIoZGV2LCAicmF0ZVslZF0gbm90IHN1cHBv cnRlZCFcbiIsCisJCURSTV9ERVZfRVJST1IoZGV2LCAicmF0ZVslZF0gbm90IHN1cHBvcnRlZCFc biIsCiAJCQlwYXJhbXMtPnNhbXBsZV9yYXRlKTsKIAkJcmV0dXJuIC1FSU5WQUw7CiAJfQpAQCAt NTc5LDcgKzU3OSw3IEBAIHN0YXRpYyBpbnQgbXNtX2hkbWlfYmluZChzdHJ1Y3QgZGV2aWNlICpk ZXYsIHN0cnVjdCBkZXZpY2UgKm1hc3Rlciwgdm9pZCAqZGF0YSkKIAloZG1pX2NmZyA9IChzdHJ1 Y3QgaGRtaV9wbGF0Zm9ybV9jb25maWcgKikKIAkJCW9mX2RldmljZV9nZXRfbWF0Y2hfZGF0YShk ZXYpOwogCWlmICghaGRtaV9jZmcpIHsKLQkJZGV2X2VycihkZXYsICJ1bmtub3duIGhkbWlfY2Zn OiAlcE9GblxuIiwgb2Zfbm9kZSk7CisJCURSTV9ERVZfRVJST1IoZGV2LCAidW5rbm93biBoZG1p X2NmZzogJXBPRm5cbiIsIG9mX25vZGUpOwogCQlyZXR1cm4gLUVOWElPOwogCX0KIApkaWZmIC0t Z2l0IGEvZHJpdmVycy9ncHUvZHJtL21zbS9oZG1pL2hkbWlfYnJpZGdlLmMgYi9kcml2ZXJzL2dw dS9kcm0vbXNtL2hkbWkvaGRtaV9icmlkZ2UuYwppbmRleCA3ZTM1NzA3Li45OGQ2MWM2IDEwMDY0 NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vbXNtL2hkbWkvaGRtaV9icmlkZ2UuYworKysgYi9kcml2 ZXJzL2dwdS9kcm0vbXNtL2hkbWkvaGRtaV9icmlkZ2UuYwpAQCAtNDAsNyArNDAsNyBAQCBzdGF0 aWMgdm9pZCBtc21faGRtaV9wb3dlcl9vbihzdHJ1Y3QgZHJtX2JyaWRnZSAqYnJpZGdlKQogCWZv ciAoaSA9IDA7IGkgPCBjb25maWctPnB3cl9yZWdfY250OyBpKyspIHsKIAkJcmV0ID0gcmVndWxh dG9yX2VuYWJsZShoZG1pLT5wd3JfcmVnc1tpXSk7CiAJCWlmIChyZXQpIHsKLQkJCWRldl9lcnIo ZGV2LT5kZXYsICJmYWlsZWQgdG8gZW5hYmxlIHB3ciByZWd1bGF0b3I6ICVzICglZClcbiIsCisJ CQlEUk1fREVWX0VSUk9SKGRldi0+ZGV2LCAiZmFpbGVkIHRvIGVuYWJsZSBwd3IgcmVndWxhdG9y OiAlcyAoJWQpXG4iLAogCQkJCQljb25maWctPnB3cl9yZWdfbmFtZXNbaV0sIHJldCk7CiAJCX0K IAl9CkBAIC00OSw3ICs0OSw3IEBAIHN0YXRpYyB2b2lkIG1zbV9oZG1pX3Bvd2VyX29uKHN0cnVj dCBkcm1fYnJpZGdlICpicmlkZ2UpCiAJCURCRygicGl4Y2xvY2s6ICVsdSIsIGhkbWktPnBpeGNs b2NrKTsKIAkJcmV0ID0gY2xrX3NldF9yYXRlKGhkbWktPnB3cl9jbGtzWzBdLCBoZG1pLT5waXhj bG9jayk7CiAJCWlmIChyZXQpIHsKLQkJCWRldl9lcnIoZGV2LT5kZXYsICJmYWlsZWQgdG8gc2V0 IHBpeGVsIGNsazogJXMgKCVkKVxuIiwKKwkJCURSTV9ERVZfRVJST1IoZGV2LT5kZXYsICJmYWls ZWQgdG8gc2V0IHBpeGVsIGNsazogJXMgKCVkKVxuIiwKIAkJCQkJY29uZmlnLT5wd3JfY2xrX25h bWVzWzBdLCByZXQpOwogCQl9CiAJfQpAQCAtNTcsNyArNTcsNyBAQCBzdGF0aWMgdm9pZCBtc21f aGRtaV9wb3dlcl9vbihzdHJ1Y3QgZHJtX2JyaWRnZSAqYnJpZGdlKQogCWZvciAoaSA9IDA7IGkg PCBjb25maWctPnB3cl9jbGtfY250OyBpKyspIHsKIAkJcmV0ID0gY2xrX3ByZXBhcmVfZW5hYmxl KGhkbWktPnB3cl9jbGtzW2ldKTsKIAkJaWYgKHJldCkgewotCQkJZGV2X2VycihkZXYtPmRldiwg ImZhaWxlZCB0byBlbmFibGUgcHdyIGNsazogJXMgKCVkKVxuIiwKKwkJCURSTV9ERVZfRVJST1Io ZGV2LT5kZXYsICJmYWlsZWQgdG8gZW5hYmxlIHB3ciBjbGs6ICVzICglZClcbiIsCiAJCQkJCWNv bmZpZy0+cHdyX2Nsa19uYW1lc1tpXSwgcmV0KTsKIAkJfQogCX0KQEAgLTgyLDcgKzgyLDcgQEAg c3RhdGljIHZvaWQgcG93ZXJfb2ZmKHN0cnVjdCBkcm1fYnJpZGdlICpicmlkZ2UpCiAJZm9yIChp ID0gMDsgaSA8IGNvbmZpZy0+cHdyX3JlZ19jbnQ7IGkrKykgewogCQlyZXQgPSByZWd1bGF0b3Jf ZGlzYWJsZShoZG1pLT5wd3JfcmVnc1tpXSk7CiAJCWlmIChyZXQpIHsKLQkJCWRldl9lcnIoZGV2 LT5kZXYsICJmYWlsZWQgdG8gZGlzYWJsZSBwd3IgcmVndWxhdG9yOiAlcyAoJWQpXG4iLAorCQkJ RFJNX0RFVl9FUlJPUihkZXYtPmRldiwgImZhaWxlZCB0byBkaXNhYmxlIHB3ciByZWd1bGF0b3I6 ICVzICglZClcbiIsCiAJCQkJCWNvbmZpZy0+cHdyX3JlZ19uYW1lc1tpXSwgcmV0KTsKIAkJfQog CX0KQEAgLTEwNSw3ICsxMDUsNyBAQCBzdGF0aWMgdm9pZCBtc21faGRtaV9jb25maWdfYXZpX2lu Zm9mcmFtZShzdHJ1Y3QgaGRtaSAqaGRtaSkKIAogCWxlbiA9IGhkbWlfaW5mb2ZyYW1lX3BhY2so JmZyYW1lLCBidWZmZXIsIHNpemVvZihidWZmZXIpKTsKIAlpZiAobGVuIDwgMCkgewotCQlkZXZf ZXJyKCZoZG1pLT5wZGV2LT5kZXYsCisJCURSTV9ERVZfRVJST1IoJmhkbWktPnBkZXYtPmRldiwK IAkJCSJmYWlsZWQgdG8gY29uZmlndXJlIGF2aSBpbmZvZnJhbWVcbiIpOwogCQlyZXR1cm47CiAJ fQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL21zbS9oZG1pL2hkbWlfY29ubmVjdG9yLmMg Yi9kcml2ZXJzL2dwdS9kcm0vbXNtL2hkbWkvaGRtaV9jb25uZWN0b3IuYwppbmRleCBlOWM5YTBh Li45ZGE3MzQ1IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vbXNtL2hkbWkvaGRtaV9jb25u ZWN0b3IuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL2hkbWkvaGRtaV9jb25uZWN0b3IuYwpA QCAtOTAsNyArOTAsNyBAQCBzdGF0aWMgaW50IGdwaW9fY29uZmlnKHN0cnVjdCBoZG1pICpoZG1p LCBib29sIG9uKQogCQkJaWYgKGdwaW8ubnVtICE9IC0xKSB7CiAJCQkJcmV0ID0gZ3Bpb19yZXF1 ZXN0KGdwaW8ubnVtLCBncGlvLmxhYmVsKTsKIAkJCQlpZiAocmV0KSB7Ci0JCQkJCWRldl9lcnIo ZGV2LAorCQkJCQlEUk1fREVWX0VSUk9SKGRldiwKIAkJCQkJCSInJXMnKCVkKSBncGlvX3JlcXVl c3QgZmFpbGVkOiAlZFxuIiwKIAkJCQkJCWdwaW8ubGFiZWwsIGdwaW8ubnVtLCByZXQpOwogCQkJ CQlnb3RvIGVycjsKQEAgLTE1Niw3ICsxNTYsNyBAQCBzdGF0aWMgdm9pZCBlbmFibGVfaHBkX2Ns b2NrcyhzdHJ1Y3QgaGRtaSAqaGRtaSwgYm9vbCBlbmFibGUpCiAKIAkJCXJldCA9IGNsa19wcmVw YXJlX2VuYWJsZShoZG1pLT5ocGRfY2xrc1tpXSk7CiAJCQlpZiAocmV0KSB7Ci0JCQkJZGV2X2Vy cihkZXYsCisJCQkJRFJNX0RFVl9FUlJPUihkZXYsCiAJCQkJCSJmYWlsZWQgdG8gZW5hYmxlIGhw ZCBjbGs6ICVzICglZClcbiIsCiAJCQkJCWNvbmZpZy0+aHBkX2Nsa19uYW1lc1tpXSwgcmV0KTsK IAkJCX0KQEAgLTE3OSw3ICsxNzksNyBAQCBzdGF0aWMgaW50IGhwZF9lbmFibGUoc3RydWN0IGhk bWlfY29ubmVjdG9yICpoZG1pX2Nvbm5lY3RvcikKIAlmb3IgKGkgPSAwOyBpIDwgY29uZmlnLT5o cGRfcmVnX2NudDsgaSsrKSB7CiAJCXJldCA9IHJlZ3VsYXRvcl9lbmFibGUoaGRtaS0+aHBkX3Jl Z3NbaV0pOwogCQlpZiAocmV0KSB7Ci0JCQlkZXZfZXJyKGRldiwgImZhaWxlZCB0byBlbmFibGUg aHBkIHJlZ3VsYXRvcjogJXMgKCVkKVxuIiwKKwkJCURSTV9ERVZfRVJST1IoZGV2LCAiZmFpbGVk IHRvIGVuYWJsZSBocGQgcmVndWxhdG9yOiAlcyAoJWQpXG4iLAogCQkJCQljb25maWctPmhwZF9y ZWdfbmFtZXNbaV0sIHJldCk7CiAJCQlnb3RvIGZhaWw7CiAJCX0KQEAgLTE4NywxMyArMTg3LDEz IEBAIHN0YXRpYyBpbnQgaHBkX2VuYWJsZShzdHJ1Y3QgaGRtaV9jb25uZWN0b3IgKmhkbWlfY29u bmVjdG9yKQogCiAJcmV0ID0gcGluY3RybF9wbV9zZWxlY3RfZGVmYXVsdF9zdGF0ZShkZXYpOwog CWlmIChyZXQpIHsKLQkJZGV2X2VycihkZXYsICJwaW5jdHJsIHN0YXRlIGNoZyBmYWlsZWQ6ICVk XG4iLCByZXQpOworCQlEUk1fREVWX0VSUk9SKGRldiwgInBpbmN0cmwgc3RhdGUgY2hnIGZhaWxl ZDogJWRcbiIsIHJldCk7CiAJCWdvdG8gZmFpbDsKIAl9CiAKIAlyZXQgPSBncGlvX2NvbmZpZyho ZG1pLCB0cnVlKTsKIAlpZiAocmV0KSB7Ci0JCWRldl9lcnIoZGV2LCAiZmFpbGVkIHRvIGNvbmZp Z3VyZSBHUElPczogJWRcbiIsIHJldCk7CisJCURSTV9ERVZfRVJST1IoZGV2LCAiZmFpbGVkIHRv IGNvbmZpZ3VyZSBHUElPczogJWRcbiIsIHJldCk7CiAJCWdvdG8gZmFpbDsKIAl9CiAKQEAgLTQ3 Myw3ICs0NzMsNyBAQCBzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqbXNtX2hkbWlfY29ubmVjdG9yX2lu aXQoc3RydWN0IGhkbWkgKmhkbWkpCiAKIAlyZXQgPSBocGRfZW5hYmxlKGhkbWlfY29ubmVjdG9y KTsKIAlpZiAocmV0KSB7Ci0JCWRldl9lcnIoJmhkbWktPnBkZXYtPmRldiwgImZhaWxlZCB0byBl bmFibGUgSFBEOiAlZFxuIiwgcmV0KTsKKwkJRFJNX0RFVl9FUlJPUigmaGRtaS0+cGRldi0+ZGV2 LCAiZmFpbGVkIHRvIGVuYWJsZSBIUEQ6ICVkXG4iLCByZXQpOwogCQlyZXR1cm4gRVJSX1BUUihy ZXQpOwogCX0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL21zbS9oZG1pL2hkbWlfaTJj LmMgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL2hkbWkvaGRtaV9pMmMuYwppbmRleCA3M2UyMDIxLi4y NWQyZmUyIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vbXNtL2hkbWkvaGRtaV9pMmMuYwor KysgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL2hkbWkvaGRtaV9pMmMuYwpAQCAtNjYsNyArNjYsNyBA QCBzdGF0aWMgaW50IGRkY19jbGVhcl9pcnEoc3RydWN0IGhkbWlfaTJjX2FkYXB0ZXIgKmhkbWlf aTJjKQogCX0gd2hpbGUgKChkZGNfaW50X2N0cmwgJiBIRE1JX0REQ19JTlRfQ1RSTF9TV19ET05F X0lOVCkgJiYgcmV0cnkpOwogCiAJaWYgKCFyZXRyeSkgewotCQlkZXZfZXJyKGRldi0+ZGV2LCAi dGltZW91dCB3YWl0aW5nIGZvciBERENcbiIpOworCQlEUk1fREVWX0VSUk9SKGRldi0+ZGV2LCAi dGltZW91dCB3YWl0aW5nIGZvciBERENcbiIpOwogCQlyZXR1cm4gLUVUSU1FRE9VVDsKIAl9CiAK ZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9tc20vaGRtaS9oZG1pX3BoeS5jIGIvZHJpdmVy cy9ncHUvZHJtL21zbS9oZG1pL2hkbWlfcGh5LmMKaW5kZXggNDE1NzcyMi4uMWY0MzMxZSAxMDA2 NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL21zbS9oZG1pL2hkbWlfcGh5LmMKKysrIGIvZHJpdmVy cy9ncHUvZHJtL21zbS9oZG1pL2hkbWlfcGh5LmMKQEAgLTM3LDcgKzM3LDcgQEAgc3RhdGljIGlu dCBtc21faGRtaV9waHlfcmVzb3VyY2VfaW5pdChzdHJ1Y3QgaGRtaV9waHkgKnBoeSkKIAkJcmVn ID0gZGV2bV9yZWd1bGF0b3JfZ2V0KGRldiwgY2ZnLT5yZWdfbmFtZXNbaV0pOwogCQlpZiAoSVNf RVJSKHJlZykpIHsKIAkJCXJldCA9IFBUUl9FUlIocmVnKTsKLQkJCWRldl9lcnIoZGV2LCAiZmFp bGVkIHRvIGdldCBwaHkgcmVndWxhdG9yOiAlcyAoJWQpXG4iLAorCQkJRFJNX0RFVl9FUlJPUihk ZXYsICJmYWlsZWQgdG8gZ2V0IHBoeSByZWd1bGF0b3I6ICVzICglZClcbiIsCiAJCQkJY2ZnLT5y ZWdfbmFtZXNbaV0sIHJldCk7CiAJCQlyZXR1cm4gcmV0OwogCQl9CkBAIC01MSw3ICs1MSw3IEBA IHN0YXRpYyBpbnQgbXNtX2hkbWlfcGh5X3Jlc291cmNlX2luaXQoc3RydWN0IGhkbWlfcGh5ICpw aHkpCiAJCWNsayA9IG1zbV9jbGtfZ2V0KHBoeS0+cGRldiwgY2ZnLT5jbGtfbmFtZXNbaV0pOwog CQlpZiAoSVNfRVJSKGNsaykpIHsKIAkJCXJldCA9IFBUUl9FUlIoY2xrKTsKLQkJCWRldl9lcnIo ZGV2LCAiZmFpbGVkIHRvIGdldCBwaHkgY2xvY2s6ICVzICglZClcbiIsCisJCQlEUk1fREVWX0VS Uk9SKGRldiwgImZhaWxlZCB0byBnZXQgcGh5IGNsb2NrOiAlcyAoJWQpXG4iLAogCQkJCWNmZy0+ Y2xrX25hbWVzW2ldLCByZXQpOwogCQkJcmV0dXJuIHJldDsKIAkJfQpAQCAtNzMsMTQgKzczLDE0 IEBAIGludCBtc21faGRtaV9waHlfcmVzb3VyY2VfZW5hYmxlKHN0cnVjdCBoZG1pX3BoeSAqcGh5 KQogCWZvciAoaSA9IDA7IGkgPCBjZmctPm51bV9yZWdzOyBpKyspIHsKIAkJcmV0ID0gcmVndWxh dG9yX2VuYWJsZShwaHktPnJlZ3NbaV0pOwogCQlpZiAocmV0KQotCQkJZGV2X2VycihkZXYsICJm YWlsZWQgdG8gZW5hYmxlIHJlZ3VsYXRvcjogJXMgKCVkKVxuIiwKKwkJCURSTV9ERVZfRVJST1Io ZGV2LCAiZmFpbGVkIHRvIGVuYWJsZSByZWd1bGF0b3I6ICVzICglZClcbiIsCiAJCQkJY2ZnLT5y ZWdfbmFtZXNbaV0sIHJldCk7CiAJfQogCiAJZm9yIChpID0gMDsgaSA8IGNmZy0+bnVtX2Nsa3M7 IGkrKykgewogCQlyZXQgPSBjbGtfcHJlcGFyZV9lbmFibGUocGh5LT5jbGtzW2ldKTsKIAkJaWYg KHJldCkKLQkJCWRldl9lcnIoZGV2LCAiZmFpbGVkIHRvIGVuYWJsZSBjbG9jazogJXMgKCVkKVxu IiwKKwkJCURSTV9ERVZfRVJST1IoZGV2LCAiZmFpbGVkIHRvIGVuYWJsZSBjbG9jazogJXMgKCVk KVxuIiwKIAkJCQljZmctPmNsa19uYW1lc1tpXSwgcmV0KTsKIAl9CiAKQEAgLTE1OSw3ICsxNTks NyBAQCBzdGF0aWMgaW50IG1zbV9oZG1pX3BoeV9wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNl ICpwZGV2KQogCiAJcGh5LT5tbWlvID0gbXNtX2lvcmVtYXAocGRldiwgImhkbWlfcGh5IiwgIkhE TUlfUEhZIik7CiAJaWYgKElTX0VSUihwaHktPm1taW8pKSB7Ci0JCWRldl9lcnIoZGV2LCAiJXM6 IGZhaWxlZCB0byBtYXAgcGh5IGJhc2VcbiIsIF9fZnVuY19fKTsKKwkJRFJNX0RFVl9FUlJPUihk ZXYsICIlczogZmFpbGVkIHRvIG1hcCBwaHkgYmFzZVxuIiwgX19mdW5jX18pOwogCQlyZXR1cm4g LUVOT01FTTsKIAl9CiAKQEAgLTE3Nyw3ICsxNzcsNyBAQCBzdGF0aWMgaW50IG1zbV9oZG1pX3Bo eV9wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQogCiAJcmV0ID0gbXNtX2hkbWlf cGh5X3BsbF9pbml0KHBkZXYsIHBoeS0+Y2ZnLT50eXBlKTsKIAlpZiAocmV0KSB7Ci0JCWRldl9l cnIoZGV2LCAiY291bGRuJ3QgaW5pdCBQTExcbiIpOworCQlEUk1fREVWX0VSUk9SKGRldiwgImNv dWxkbid0IGluaXQgUExMXG4iKTsKIAkJbXNtX2hkbWlfcGh5X3Jlc291cmNlX2Rpc2FibGUocGh5 KTsKIAkJcmV0dXJuIHJldDsKIAl9CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbXNtL2hk bWkvaGRtaV9waHlfODk5Ni5jIGIvZHJpdmVycy9ncHUvZHJtL21zbS9oZG1pL2hkbWlfcGh5Xzg5 OTYuYwppbmRleCAwZGY1MDRjLi4zMTg3MDhmIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0v bXNtL2hkbWkvaGRtaV9waHlfODk5Ni5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9tc20vaGRtaS9o ZG1pX3BoeV84OTk2LmMKQEAgLTcyNSw3ICs3MjUsNyBAQCBpbnQgbXNtX2hkbWlfcGxsXzg5OTZf aW5pdChzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQogCiAJcGxsLT5tbWlvX3FzZXJkZXNf Y29tID0gbXNtX2lvcmVtYXAocGRldiwgImhkbWlfcGxsIiwgIkhETUlfUExMIik7CiAJaWYgKElT X0VSUihwbGwtPm1taW9fcXNlcmRlc19jb20pKSB7Ci0JCWRldl9lcnIoZGV2LCAiZmFpbGVkIHRv IG1hcCBwbGwgYmFzZVxuIik7CisJCURSTV9ERVZfRVJST1IoZGV2LCAiZmFpbGVkIHRvIG1hcCBw bGwgYmFzZVxuIik7CiAJCXJldHVybiAtRU5PTUVNOwogCX0KIApAQCAtNzM3LDcgKzczNyw3IEBA IGludCBtc21faGRtaV9wbGxfODk5Nl9pbml0KHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYp CiAKIAkJcGxsLT5tbWlvX3FzZXJkZXNfdHhbaV0gPSBtc21faW9yZW1hcChwZGV2LCBuYW1lLCBs YWJlbCk7CiAJCWlmIChJU19FUlIocGxsLT5tbWlvX3FzZXJkZXNfdHhbaV0pKSB7Ci0JCQlkZXZf ZXJyKGRldiwgImZhaWxlZCB0byBtYXAgcGxsIGJhc2VcbiIpOworCQkJRFJNX0RFVl9FUlJPUihk ZXYsICJmYWlsZWQgdG8gbWFwIHBsbCBiYXNlXG4iKTsKIAkJCXJldHVybiAtRU5PTUVNOwogCQl9 CiAJfQpAQCAtNzQ1LDcgKzc0NSw3IEBAIGludCBtc21faGRtaV9wbGxfODk5Nl9pbml0KHN0cnVj dCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCiAKIAljbGsgPSBkZXZtX2Nsa19yZWdpc3RlcihkZXYs ICZwbGwtPmNsa19odyk7CiAJaWYgKElTX0VSUihjbGspKSB7Ci0JCWRldl9lcnIoZGV2LCAiZmFp bGVkIHRvIHJlZ2lzdGVyIHBsbCBjbG9ja1xuIik7CisJCURSTV9ERVZfRVJST1IoZGV2LCAiZmFp bGVkIHRvIHJlZ2lzdGVyIHBsbCBjbG9ja1xuIik7CiAJCXJldHVybiAtRUlOVkFMOwogCX0KIApk aWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL21zbS9oZG1pL2hkbWlfcGxsXzg5NjAuYyBiL2Ry aXZlcnMvZ3B1L2RybS9tc20vaGRtaS9oZG1pX3BsbF84OTYwLmMKaW5kZXggOTk1OTA3NS4uYzZk YWU2ZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL21zbS9oZG1pL2hkbWlfcGxsXzg5NjAu YworKysgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL2hkbWkvaGRtaV9wbGxfODk2MC5jCkBAIC00NDUs NyArNDQ1LDcgQEAgaW50IG1zbV9oZG1pX3BsbF84OTYwX2luaXQoc3RydWN0IHBsYXRmb3JtX2Rl dmljZSAqcGRldikKIAogCXBsbC0+bW1pbyA9IG1zbV9pb3JlbWFwKHBkZXYsICJoZG1pX3BsbCIs ICJIRE1JX1BMTCIpOwogCWlmIChJU19FUlIocGxsLT5tbWlvKSkgewotCQlkZXZfZXJyKGRldiwg ImZhaWxlZCB0byBtYXAgcGxsIGJhc2VcbiIpOworCQlEUk1fREVWX0VSUk9SKGRldiwgImZhaWxl ZCB0byBtYXAgcGxsIGJhc2VcbiIpOwogCQlyZXR1cm4gLUVOT01FTTsKIAl9CiAKQEAgLTQ1NCw3 ICs0NTQsNyBAQCBpbnQgbXNtX2hkbWlfcGxsXzg5NjBfaW5pdChzdHJ1Y3QgcGxhdGZvcm1fZGV2 aWNlICpwZGV2KQogCiAJY2xrID0gZGV2bV9jbGtfcmVnaXN0ZXIoZGV2LCAmcGxsLT5jbGtfaHcp OwogCWlmIChJU19FUlIoY2xrKSkgewotCQlkZXZfZXJyKGRldiwgImZhaWxlZCB0byByZWdpc3Rl ciBwbGwgY2xvY2tcbiIpOworCQlEUk1fREVWX0VSUk9SKGRldiwgImZhaWxlZCB0byByZWdpc3Rl ciBwbGwgY2xvY2tcbiIpOwogCQlyZXR1cm4gLUVJTlZBTDsKIAl9CiAKZGlmZiAtLWdpdCBhL2Ry aXZlcnMvZ3B1L2RybS9tc20vbXNtX2RlYnVnZnMuYyBiL2RyaXZlcnMvZ3B1L2RybS9tc20vbXNt X2RlYnVnZnMuYwppbmRleCBmMGRhMGQzLi4wMzIxMGY0IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dw dS9kcm0vbXNtL21zbV9kZWJ1Z2ZzLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL21zbS9tc21fZGVi dWdmcy5jCkBAIC0xOTQsMTMgKzE5NCwxMyBAQCBzdGF0aWMgaW50IGxhdGVfaW5pdF9taW5vcihz dHJ1Y3QgZHJtX21pbm9yICptaW5vcikKIAogCXJldCA9IG1zbV9yZF9kZWJ1Z2ZzX2luaXQobWlu b3IpOwogCWlmIChyZXQpIHsKLQkJZGV2X2VycihtaW5vci0+ZGV2LT5kZXYsICJjb3VsZCBub3Qg aW5zdGFsbCByZCBkZWJ1Z2ZzXG4iKTsKKwkJRFJNX0RFVl9FUlJPUihtaW5vci0+ZGV2LT5kZXYs ICJjb3VsZCBub3QgaW5zdGFsbCByZCBkZWJ1Z2ZzXG4iKTsKIAkJcmV0dXJuIHJldDsKIAl9CiAK IAlyZXQgPSBtc21fcGVyZl9kZWJ1Z2ZzX2luaXQobWlub3IpOwogCWlmIChyZXQpIHsKLQkJZGV2 X2VycihtaW5vci0+ZGV2LT5kZXYsICJjb3VsZCBub3QgaW5zdGFsbCBwZXJmIGRlYnVnZnNcbiIp OworCQlEUk1fREVWX0VSUk9SKG1pbm9yLT5kZXYtPmRldiwgImNvdWxkIG5vdCBpbnN0YWxsIHBl cmYgZGVidWdmc1xuIik7CiAJCXJldHVybiByZXQ7CiAJfQogCkBAIC0yMjgsNyArMjI4LDcgQEAg aW50IG1zbV9kZWJ1Z2ZzX2luaXQoc3RydWN0IGRybV9taW5vciAqbWlub3IpCiAJCQltaW5vci0+ ZGVidWdmc19yb290LCBtaW5vcik7CiAKIAlpZiAocmV0KSB7Ci0JCWRldl9lcnIoZGV2LT5kZXYs ICJjb3VsZCBub3QgaW5zdGFsbCBtc21fZGVidWdmc19saXN0XG4iKTsKKwkJRFJNX0RFVl9FUlJP UihkZXYtPmRldiwgImNvdWxkIG5vdCBpbnN0YWxsIG1zbV9kZWJ1Z2ZzX2xpc3RcbiIpOwogCQly ZXR1cm4gcmV0OwogCX0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL21zbS9tc21fZHJ2 LmMgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL21zbV9kcnYuYwppbmRleCBmMWNhY2Y5Li44OGEyMzg3 IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vbXNtL21zbV9kcnYuYworKysgYi9kcml2ZXJz L2dwdS9kcm0vbXNtL21zbV9kcnYuYwpAQCAtMTcwLDcgKzE3MCw3IEBAIHZvaWQgX19pb21lbSAq bXNtX2lvcmVtYXAoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldiwgY29uc3QgY2hhciAqbmFt ZSwKIAkJcmVzID0gcGxhdGZvcm1fZ2V0X3Jlc291cmNlKHBkZXYsIElPUkVTT1VSQ0VfTUVNLCAw KTsKIAogCWlmICghcmVzKSB7Ci0JCWRldl9lcnIoJnBkZXYtPmRldiwgImZhaWxlZCB0byBnZXQg bWVtb3J5IHJlc291cmNlOiAlc1xuIiwgbmFtZSk7CisJCURSTV9ERVZfRVJST1IoJnBkZXYtPmRl diwgImZhaWxlZCB0byBnZXQgbWVtb3J5IHJlc291cmNlOiAlc1xuIiwgbmFtZSk7CiAJCXJldHVy biBFUlJfUFRSKC1FSU5WQUwpOwogCX0KIApAQCAtMTc4LDcgKzE3OCw3IEBAIHZvaWQgX19pb21l bSAqbXNtX2lvcmVtYXAoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldiwgY29uc3QgY2hhciAq bmFtZSwKIAogCXB0ciA9IGRldm1faW9yZW1hcF9ub2NhY2hlKCZwZGV2LT5kZXYsIHJlcy0+c3Rh cnQsIHNpemUpOwogCWlmICghcHRyKSB7Ci0JCWRldl9lcnIoJnBkZXYtPmRldiwgImZhaWxlZCB0 byBpb3JlbWFwOiAlc1xuIiwgbmFtZSk7CisJCURSTV9ERVZfRVJST1IoJnBkZXYtPmRldiwgImZh aWxlZCB0byBpb3JlbWFwOiAlc1xuIiwgbmFtZSk7CiAJCXJldHVybiBFUlJfUFRSKC1FTk9NRU0p OwogCX0KIApAQCAtNDE5LDEyICs0MTksMTIgQEAgc3RhdGljIGludCBtc21faW5pdF92cmFtKHN0 cnVjdCBkcm1fZGV2aWNlICpkZXYpCiAJCXAgPSBkbWFfYWxsb2NfYXR0cnMoZGV2LT5kZXYsIHNp emUsCiAJCQkJJnByaXYtPnZyYW0ucGFkZHIsIEdGUF9LRVJORUwsIGF0dHJzKTsKIAkJaWYgKCFw KSB7Ci0JCQlkZXZfZXJyKGRldi0+ZGV2LCAiZmFpbGVkIHRvIGFsbG9jYXRlIFZSQU1cbiIpOwor CQkJRFJNX0RFVl9FUlJPUihkZXYtPmRldiwgImZhaWxlZCB0byBhbGxvY2F0ZSBWUkFNXG4iKTsK IAkJCXByaXYtPnZyYW0ucGFkZHIgPSAwOwogCQkJcmV0dXJuIC1FTk9NRU07CiAJCX0KIAotCQlk ZXZfaW5mbyhkZXYtPmRldiwgIlZSQU06ICUwOHgtPiUwOHhcbiIsCisJCURSTV9ERVZfSU5GTyhk ZXYtPmRldiwgIlZSQU06ICUwOHgtPiUwOHhcbiIsCiAJCQkJKHVpbnQzMl90KXByaXYtPnZyYW0u cGFkZHIsCiAJCQkJKHVpbnQzMl90KShwcml2LT52cmFtLnBhZGRyICsgc2l6ZSkpOwogCX0KQEAg LTQ0NCw3ICs0NDQsNyBAQCBzdGF0aWMgaW50IG1zbV9kcm1faW5pdChzdHJ1Y3QgZGV2aWNlICpk ZXYsIHN0cnVjdCBkcm1fZHJpdmVyICpkcnYpCiAKIAlkZGV2ID0gZHJtX2Rldl9hbGxvYyhkcnYs IGRldik7CiAJaWYgKElTX0VSUihkZGV2KSkgewotCQlkZXZfZXJyKGRldiwgImZhaWxlZCB0byBh bGxvY2F0ZSBkcm1fZGV2aWNlXG4iKTsKKwkJRFJNX0RFVl9FUlJPUihkZXYsICJmYWlsZWQgdG8g YWxsb2NhdGUgZHJtX2RldmljZVxuIik7CiAJCXJldHVybiBQVFJfRVJSKGRkZXYpOwogCX0KIApA QCAtNTE5LDcgKzUxOSw3IEBAIHN0YXRpYyBpbnQgbXNtX2RybV9pbml0KHN0cnVjdCBkZXZpY2Ug KmRldiwgc3RydWN0IGRybV9kcml2ZXIgKmRydikKIAkJICogYW5kIChmb3IgZXhhbXBsZSkgdXNl IGRtYWJ1Zi9wcmltZSB0byBzaGFyZSBidWZmZXJzIHdpdGgKIAkJICogaW14IGRybSBkcml2ZXIg b24gaU1YNQogCQkgKi8KLQkJZGV2X2VycihkZXYsICJmYWlsZWQgdG8gbG9hZCBrbXNcbiIpOwor CQlEUk1fREVWX0VSUk9SKGRldiwgImZhaWxlZCB0byBsb2FkIGttc1xuIik7CiAJCXJldCA9IFBU Ul9FUlIoa21zKTsKIAkJZ290byBlcnJfbXNtX3VuaW5pdDsKIAl9CkBAIC01MzAsNyArNTMwLDcg QEAgc3RhdGljIGludCBtc21fZHJtX2luaXQoc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgZHJt X2RyaXZlciAqZHJ2KQogCWlmIChrbXMpIHsKIAkJcmV0ID0ga21zLT5mdW5jcy0+aHdfaW5pdChr bXMpOwogCQlpZiAocmV0KSB7Ci0JCQlkZXZfZXJyKGRldiwgImttcyBodyBpbml0IGZhaWxlZDog JWRcbiIsIHJldCk7CisJCQlEUk1fREVWX0VSUk9SKGRldiwgImttcyBodyBpbml0IGZhaWxlZDog JWRcbiIsIHJldCk7CiAJCQlnb3RvIGVycl9tc21fdW5pbml0OwogCQl9CiAJfQpAQCAtNTYxLDcg KzU2MSw3IEBAIHN0YXRpYyBpbnQgbXNtX2RybV9pbml0KHN0cnVjdCBkZXZpY2UgKmRldiwgc3Ry dWN0IGRybV9kcml2ZXIgKmRydikKIAkJCQkJCQkJCXJldCk7CiAKIAkJaWYgKElTX0VSUihwcml2 LT5kaXNwX3RocmVhZFtpXS50aHJlYWQpKSB7Ci0JCQlkZXZfZXJyKGRldiwgImZhaWxlZCB0byBj cmVhdGUgY3J0Y19jb21taXQga3RocmVhZFxuIik7CisJCQlEUk1fREVWX0VSUk9SKGRldiwgImZh aWxlZCB0byBjcmVhdGUgY3J0Y19jb21taXQga3RocmVhZFxuIik7CiAJCQlwcml2LT5kaXNwX3Ro cmVhZFtpXS50aHJlYWQgPSBOVUxMOwogCQl9CiAKQEAgLTU4Nyw3ICs1ODcsNyBAQCBzdGF0aWMg aW50IG1zbV9kcm1faW5pdChzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkcm1fZHJpdmVyICpk cnYpCiAJCQkJCQkJCQlyZXQpOwogCiAJCWlmIChJU19FUlIocHJpdi0+ZXZlbnRfdGhyZWFkW2ld LnRocmVhZCkpIHsKLQkJCWRldl9lcnIoZGV2LCAiZmFpbGVkIHRvIGNyZWF0ZSBjcnRjX2V2ZW50 IGt0aHJlYWRcbiIpOworCQkJRFJNX0RFVl9FUlJPUihkZXYsICJmYWlsZWQgdG8gY3JlYXRlIGNy dGNfZXZlbnQga3RocmVhZFxuIik7CiAJCQlwcml2LT5ldmVudF90aHJlYWRbaV0udGhyZWFkID0g TlVMTDsKIAkJfQogCkBAIC02MTMsNyArNjEzLDcgQEAgc3RhdGljIGludCBtc21fZHJtX2luaXQo c3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgZHJtX2RyaXZlciAqZHJ2KQogCiAJcmV0ID0gZHJt X3ZibGFua19pbml0KGRkZXYsIHByaXYtPm51bV9jcnRjcyk7CiAJaWYgKHJldCA8IDApIHsKLQkJ ZGV2X2VycihkZXYsICJmYWlsZWQgdG8gaW5pdGlhbGl6ZSB2YmxhbmtcbiIpOworCQlEUk1fREVW X0VSUk9SKGRldiwgImZhaWxlZCB0byBpbml0aWFsaXplIHZibGFua1xuIik7CiAJCWdvdG8gZXJy X21zbV91bmluaXQ7CiAJfQogCkBAIC02MjIsNyArNjIyLDcgQEAgc3RhdGljIGludCBtc21fZHJt X2luaXQoc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgZHJtX2RyaXZlciAqZHJ2KQogCQlyZXQg PSBkcm1faXJxX2luc3RhbGwoZGRldiwga21zLT5pcnEpOwogCQlwbV9ydW50aW1lX3B1dF9zeW5j KGRldik7CiAJCWlmIChyZXQgPCAwKSB7Ci0JCQlkZXZfZXJyKGRldiwgImZhaWxlZCB0byBpbnN0 YWxsIElSUSBoYW5kbGVyXG4iKTsKKwkJCURSTV9ERVZfRVJST1IoZGV2LCAiZmFpbGVkIHRvIGlu c3RhbGwgSVJRIGhhbmRsZXJcbiIpOwogCQkJZ290byBlcnJfbXNtX3VuaW5pdDsKIAkJfQogCX0K QEAgLTExODUsNyArMTE4NSw3IEBAIHN0YXRpYyBpbnQgYWRkX2NvbXBvbmVudHNfbWRwKHN0cnVj dCBkZXZpY2UgKm1kcF9kZXYsCiAKIAkJcmV0ID0gb2ZfZ3JhcGhfcGFyc2VfZW5kcG9pbnQoZXBf bm9kZSwgJmVwKTsKIAkJaWYgKHJldCkgewotCQkJZGV2X2VycihtZHBfZGV2LCAidW5hYmxlIHRv IHBhcnNlIHBvcnQgZW5kcG9pbnRcbiIpOworCQkJRFJNX0RFVl9FUlJPUihtZHBfZGV2LCAidW5h YmxlIHRvIHBhcnNlIHBvcnQgZW5kcG9pbnRcbiIpOwogCQkJb2Zfbm9kZV9wdXQoZXBfbm9kZSk7 CiAJCQlyZXR1cm4gcmV0OwogCQl9CkBAIC0xMjM2LDEzICsxMjM2LDEzIEBAIHN0YXRpYyBpbnQg YWRkX2Rpc3BsYXlfY29tcG9uZW50cyhzdHJ1Y3QgZGV2aWNlICpkZXYsCiAJICAgIG9mX2Rldmlj ZV9pc19jb21wYXRpYmxlKGRldi0+b2Zfbm9kZSwgInFjb20sc2RtODQ1LW1kc3MiKSkgewogCQly ZXQgPSBvZl9wbGF0Zm9ybV9wb3B1bGF0ZShkZXYtPm9mX25vZGUsIE5VTEwsIE5VTEwsIGRldik7 CiAJCWlmIChyZXQpIHsKLQkJCWRldl9lcnIoZGV2LCAiZmFpbGVkIHRvIHBvcHVsYXRlIGNoaWxk cmVuIGRldmljZXNcbiIpOworCQkJRFJNX0RFVl9FUlJPUihkZXYsICJmYWlsZWQgdG8gcG9wdWxh dGUgY2hpbGRyZW4gZGV2aWNlc1xuIik7CiAJCQlyZXR1cm4gcmV0OwogCQl9CiAKIAkJbWRwX2Rl diA9IGRldmljZV9maW5kX2NoaWxkKGRldiwgTlVMTCwgY29tcGFyZV9uYW1lX21kcCk7CiAJCWlm ICghbWRwX2RldikgewotCQkJZGV2X2VycihkZXYsICJmYWlsZWQgdG8gZmluZCBNRFNTIE1EUCBu b2RlXG4iKTsKKwkJCURSTV9ERVZfRVJST1IoZGV2LCAiZmFpbGVkIHRvIGZpbmQgTURTUyBNRFAg bm9kZVxuIik7CiAJCQlvZl9wbGF0Zm9ybV9kZXBvcHVsYXRlKGRldik7CiAJCQlyZXR1cm4gLUVO T0RFVjsKIAkJfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL21zbS9tc21fZmIuYyBiL2Ry aXZlcnMvZ3B1L2RybS9tc20vbXNtX2ZiLmMKaW5kZXggMmE3MzQ4YS4uNDc1MTkxZiAxMDA2NDQK LS0tIGEvZHJpdmVycy9ncHUvZHJtL21zbS9tc21fZmIuYworKysgYi9kcml2ZXJzL2dwdS9kcm0v bXNtL21zbV9mYi5jCkBAIC0xNTQsNyArMTU0LDcgQEAgc3RhdGljIHN0cnVjdCBkcm1fZnJhbWVi dWZmZXIgKm1zbV9mcmFtZWJ1ZmZlcl9pbml0KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsCiAJZm9y bWF0ID0ga21zLT5mdW5jcy0+Z2V0X2Zvcm1hdChrbXMsIG1vZGVfY21kLT5waXhlbF9mb3JtYXQs CiAJCQltb2RlX2NtZC0+bW9kaWZpZXJbMF0pOwogCWlmICghZm9ybWF0KSB7Ci0JCWRldl9lcnIo ZGV2LT5kZXYsICJ1bnN1cHBvcnRlZCBwaXhlbCBmb3JtYXQ6ICU0LjRzXG4iLAorCQlEUk1fREVW X0VSUk9SKGRldi0+ZGV2LCAidW5zdXBwb3J0ZWQgcGl4ZWwgZm9ybWF0OiAlNC40c1xuIiwKIAkJ CQkoY2hhciAqKSZtb2RlX2NtZC0+cGl4ZWxfZm9ybWF0KTsKIAkJcmV0ID0gLUVJTlZBTDsKIAkJ Z290byBmYWlsOwpAQCAtMTk2LDcgKzE5Niw3IEBAIHN0YXRpYyBzdHJ1Y3QgZHJtX2ZyYW1lYnVm ZmVyICptc21fZnJhbWVidWZmZXJfaW5pdChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LAogCiAJcmV0 ID0gZHJtX2ZyYW1lYnVmZmVyX2luaXQoZGV2LCBmYiwgJm1zbV9mcmFtZWJ1ZmZlcl9mdW5jcyk7 CiAJaWYgKHJldCkgewotCQlkZXZfZXJyKGRldi0+ZGV2LCAiZnJhbWVidWZmZXIgaW5pdCBmYWls ZWQ6ICVkXG4iLCByZXQpOworCQlEUk1fREVWX0VSUk9SKGRldi0+ZGV2LCAiZnJhbWVidWZmZXIg aW5pdCBmYWlsZWQ6ICVkXG4iLCByZXQpOwogCQlnb3RvIGZhaWw7CiAJfQogCkBAIC0yMzMsMTMg KzIzMywxMyBAQCBzdHJ1Y3QgZHJtX2ZyYW1lYnVmZmVyICoKIAkJYm8gPSBtc21fZ2VtX25ldyhk ZXYsIHNpemUsIE1TTV9CT19TQ0FOT1VUIHwgTVNNX0JPX1dDKTsKIAl9CiAJaWYgKElTX0VSUihi bykpIHsKLQkJZGV2X2VycihkZXYtPmRldiwgImZhaWxlZCB0byBhbGxvY2F0ZSBidWZmZXIgb2Jq ZWN0XG4iKTsKKwkJRFJNX0RFVl9FUlJPUihkZXYtPmRldiwgImZhaWxlZCB0byBhbGxvY2F0ZSBi dWZmZXIgb2JqZWN0XG4iKTsKIAkJcmV0dXJuIEVSUl9DQVNUKGJvKTsKIAl9CiAKIAlmYiA9IG1z bV9mcmFtZWJ1ZmZlcl9pbml0KGRldiwgJm1vZGVfY21kLCAmYm8pOwogCWlmIChJU19FUlIoZmIp KSB7Ci0JCWRldl9lcnIoZGV2LT5kZXYsICJmYWlsZWQgdG8gYWxsb2NhdGUgZmJcbiIpOworCQlE Uk1fREVWX0VSUk9SKGRldi0+ZGV2LCAiZmFpbGVkIHRvIGFsbG9jYXRlIGZiXG4iKTsKIAkJLyog bm90ZTogaWYgZmIgY3JlYXRpb24gZmFpbGVkLCB3ZSBjYW4ndCByZWx5IG9uIGZiIGRlc3Ryb3kK IAkJICogdG8gdW5yZWYgdGhlIGJvOgogCQkgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2Ry bS9tc20vbXNtX2ZiZGV2LmMgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL21zbV9mYmRldi5jCmluZGV4 IDQ1NjYyMmIuLmY5NGNiYmIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9tc20vbXNtX2Zi ZGV2LmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL21zbS9tc21fZmJkZXYuYwpAQCAtOTEsNyArOTEs NyBAQCBzdGF0aWMgaW50IG1zbV9mYmRldl9jcmVhdGUoc3RydWN0IGRybV9mYl9oZWxwZXIgKmhl bHBlciwKIAkJCXNpemVzLT5zdXJmYWNlX2hlaWdodCwgcGl0Y2gsIGZvcm1hdCk7CiAKIAlpZiAo SVNfRVJSKGZiKSkgewotCQlkZXZfZXJyKGRldi0+ZGV2LCAiZmFpbGVkIHRvIGFsbG9jYXRlIGZi XG4iKTsKKwkJRFJNX0RFVl9FUlJPUihkZXYtPmRldiwgImZhaWxlZCB0byBhbGxvY2F0ZSBmYlxu Iik7CiAJCXJldHVybiBQVFJfRVJSKGZiKTsKIAl9CiAKQEAgLTEwNiwxMyArMTA2LDEzIEBAIHN0 YXRpYyBpbnQgbXNtX2ZiZGV2X2NyZWF0ZShzdHJ1Y3QgZHJtX2ZiX2hlbHBlciAqaGVscGVyLAog CSAqLwogCXJldCA9IG1zbV9nZW1fZ2V0X2lvdmEoYm8sIHByaXYtPmttcy0+YXNwYWNlLCAmcGFk ZHIpOwogCWlmIChyZXQpIHsKLQkJZGV2X2VycihkZXYtPmRldiwgImZhaWxlZCB0byBnZXQgYnVm ZmVyIG9iaiBpb3ZhOiAlZFxuIiwgcmV0KTsKKwkJRFJNX0RFVl9FUlJPUihkZXYtPmRldiwgImZh aWxlZCB0byBnZXQgYnVmZmVyIG9iaiBpb3ZhOiAlZFxuIiwgcmV0KTsKIAkJZ290byBmYWlsX3Vu bG9jazsKIAl9CiAKIAlmYmkgPSBkcm1fZmJfaGVscGVyX2FsbG9jX2ZiaShoZWxwZXIpOwogCWlm IChJU19FUlIoZmJpKSkgewotCQlkZXZfZXJyKGRldi0+ZGV2LCAiZmFpbGVkIHRvIGFsbG9jYXRl IGZiIGluZm9cbiIpOworCQlEUk1fREVWX0VSUk9SKGRldi0+ZGV2LCAiZmFpbGVkIHRvIGFsbG9j YXRlIGZiIGluZm9cbiIpOwogCQlyZXQgPSBQVFJfRVJSKGZiaSk7CiAJCWdvdG8gZmFpbF91bmxv Y2s7CiAJfQpAQCAtMTc2LDcgKzE3Niw3IEBAIHN0cnVjdCBkcm1fZmJfaGVscGVyICptc21fZmJk ZXZfaW5pdChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2KQogCiAJcmV0ID0gZHJtX2ZiX2hlbHBlcl9p bml0KGRldiwgaGVscGVyLCBwcml2LT5udW1fY29ubmVjdG9ycyk7CiAJaWYgKHJldCkgewotCQlk ZXZfZXJyKGRldi0+ZGV2LCAiY291bGQgbm90IGluaXQgZmJkZXY6IHJldD0lZFxuIiwgcmV0KTsK KwkJRFJNX0RFVl9FUlJPUihkZXYtPmRldiwgImNvdWxkIG5vdCBpbml0IGZiZGV2OiByZXQ9JWRc biIsIHJldCk7CiAJCWdvdG8gZmFpbDsKIAl9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2Ry bS9tc20vbXNtX2dlbS5jIGIvZHJpdmVycy9ncHUvZHJtL21zbS9tc21fZ2VtLmMKaW5kZXggZjU5 Y2EyNy4uMDBjNzk1YyAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL21zbS9tc21fZ2VtLmMK KysrIGIvZHJpdmVycy9ncHUvZHJtL21zbS9tc21fZ2VtLmMKQEAgLTg4LDcgKzg4LDcgQEAgc3Rh dGljIHN0cnVjdCBwYWdlICoqZ2V0X3BhZ2VzKHN0cnVjdCBkcm1fZ2VtX29iamVjdCAqb2JqKQog CQkJcCA9IGdldF9wYWdlc192cmFtKG9iaiwgbnBhZ2VzKTsKIAogCQlpZiAoSVNfRVJSKHApKSB7 Ci0JCQlkZXZfZXJyKGRldi0+ZGV2LCAiY291bGQgbm90IGdldCBwYWdlczogJWxkXG4iLAorCQkJ RFJNX0RFVl9FUlJPUihkZXYtPmRldiwgImNvdWxkIG5vdCBnZXQgcGFnZXM6ICVsZFxuIiwKIAkJ CQkJUFRSX0VSUihwKSk7CiAJCQlyZXR1cm4gcDsKIAkJfQpAQCAtOTksNyArOTksNyBAQCBzdGF0 aWMgc3RydWN0IHBhZ2UgKipnZXRfcGFnZXMoc3RydWN0IGRybV9nZW1fb2JqZWN0ICpvYmopCiAJ CWlmIChJU19FUlIobXNtX29iai0+c2d0KSkgewogCQkJdm9pZCAqcHRyID0gRVJSX0NBU1QobXNt X29iai0+c2d0KTsKIAotCQkJZGV2X2VycihkZXYtPmRldiwgImZhaWxlZCB0byBhbGxvY2F0ZSBz Z3RcbiIpOworCQkJRFJNX0RFVl9FUlJPUihkZXYtPmRldiwgImZhaWxlZCB0byBhbGxvY2F0ZSBz Z3RcbiIpOwogCQkJbXNtX29iai0+c2d0ID0gTlVMTDsKIAkJCXJldHVybiBwdHI7CiAJCX0KQEAg LTI4MCw3ICsyODAsNyBAQCBzdGF0aWMgdWludDY0X3QgbW1hcF9vZmZzZXQoc3RydWN0IGRybV9n ZW1fb2JqZWN0ICpvYmopCiAJcmV0ID0gZHJtX2dlbV9jcmVhdGVfbW1hcF9vZmZzZXQob2JqKTsK IAogCWlmIChyZXQpIHsKLQkJZGV2X2VycihkZXYtPmRldiwgImNvdWxkIG5vdCBhbGxvY2F0ZSBt bWFwIG9mZnNldFxuIik7CisJCURSTV9ERVZfRVJST1IoZGV2LT5kZXYsICJjb3VsZCBub3QgYWxs b2NhdGUgbW1hcCBvZmZzZXRcbiIpOwogCQlyZXR1cm4gMDsKIAl9CiAKQEAgLTQ3Myw3ICs0NzMs NyBAQCBzdGF0aWMgdm9pZCAqZ2V0X3ZhZGRyKHN0cnVjdCBkcm1fZ2VtX29iamVjdCAqb2JqLCB1 bnNpZ25lZCBtYWR2KQogCW11dGV4X2xvY2soJm1zbV9vYmotPmxvY2spOwogCiAJaWYgKFdBUk5f T04obXNtX29iai0+bWFkdiA+IG1hZHYpKSB7Ci0JCWRldl9lcnIob2JqLT5kZXYtPmRldiwgIklu dmFsaWQgbWFkdiBzdGF0ZTogJXUgdnMgJXVcbiIsCisJCURSTV9ERVZfRVJST1Iob2JqLT5kZXYt PmRldiwgIkludmFsaWQgbWFkdiBzdGF0ZTogJXUgdnMgJXVcbiIsCiAJCQltc21fb2JqLT5tYWR2 LCBtYWR2KTsKIAkJbXV0ZXhfdW5sb2NrKCZtc21fb2JqLT5sb2NrKTsKIAkJcmV0dXJuIEVSUl9Q VFIoLUVCVVNZKTsKQEAgLTg2NCw3ICs4NjQsNyBAQCBzdGF0aWMgaW50IG1zbV9nZW1fbmV3X2lt cGwoc3RydWN0IGRybV9kZXZpY2UgKmRldiwKIAljYXNlIE1TTV9CT19XQzoKIAkJYnJlYWs7CiAJ ZGVmYXVsdDoKLQkJZGV2X2VycihkZXYtPmRldiwgImludmFsaWQgY2FjaGUgZmxhZzogJXhcbiIs CisJCURSTV9ERVZfRVJST1IoZGV2LT5kZXYsICJpbnZhbGlkIGNhY2hlIGZsYWc6ICV4XG4iLAog CQkJCShmbGFncyAmIE1TTV9CT19DQUNIRV9NQVNLKSk7CiAJCXJldHVybiAtRUlOVkFMOwogCX0K QEAgLTk5MCw3ICs5OTAsNyBAQCBzdHJ1Y3QgZHJtX2dlbV9vYmplY3QgKm1zbV9nZW1faW1wb3J0 KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsCiAKIAkvKiBpZiB3ZSBkb24ndCBoYXZlIElPTU1VLCBk b24ndCBib3RoZXIgcHJldGVuZGluZyB3ZSBjYW4gaW1wb3J0OiAqLwogCWlmICghaW9tbXVfcHJl c2VudCgmcGxhdGZvcm1fYnVzX3R5cGUpKSB7Ci0JCWRldl9lcnIoZGV2LT5kZXYsICJjYW5ub3Qg aW1wb3J0IHdpdGhvdXQgSU9NTVVcbiIpOworCQlEUk1fREVWX0VSUk9SKGRldi0+ZGV2LCAiY2Fu bm90IGltcG9ydCB3aXRob3V0IElPTU1VXG4iKTsKIAkJcmV0dXJuIEVSUl9QVFIoLUVJTlZBTCk7 CiAJfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbXNtL21zbV9ncHUuYyBiL2RyaXZl cnMvZ3B1L2RybS9tc20vbXNtX2dwdS5jCmluZGV4IDVlODA4Y2YuLmQxOWU1YTIgMTAwNjQ0Ci0t LSBhL2RyaXZlcnMvZ3B1L2RybS9tc20vbXNtX2dwdS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9t c20vbXNtX2dwdS5jCkBAIC0xMDIsNyArMTAyLDcgQEAgc3RhdGljIHZvaWQgbXNtX2RldmZyZXFf aW5pdChzdHJ1Y3QgbXNtX2dwdSAqZ3B1KQogCQkJJm1zbV9kZXZmcmVxX3Byb2ZpbGUsICJzaW1w bGVfb25kZW1hbmQiLCBOVUxMKTsKIAogCWlmIChJU19FUlIoZ3B1LT5kZXZmcmVxLmRldmZyZXEp KSB7Ci0JCWRldl9lcnIoJmdwdS0+cGRldi0+ZGV2LCAiQ291bGRuJ3QgaW5pdGlhbGl6ZSBHUFUg ZGV2ZnJlcVxuIik7CisJCURSTV9ERVZfRVJST1IoJmdwdS0+cGRldi0+ZGV2LCAiQ291bGRuJ3Qg aW5pdGlhbGl6ZSBHUFUgZGV2ZnJlcVxuIik7CiAJCWdwdS0+ZGV2ZnJlcS5kZXZmcmVxID0gTlVM TDsKIAl9CiB9CkBAIC0xMTUsNyArMTE1LDcgQEAgc3RhdGljIGludCBlbmFibGVfcHdycmFpbChz dHJ1Y3QgbXNtX2dwdSAqZ3B1KQogCWlmIChncHUtPmdwdV9yZWcpIHsKIAkJcmV0ID0gcmVndWxh dG9yX2VuYWJsZShncHUtPmdwdV9yZWcpOwogCQlpZiAocmV0KSB7Ci0JCQlkZXZfZXJyKGRldi0+ ZGV2LCAiZmFpbGVkIHRvIGVuYWJsZSAnZ3B1X3JlZyc6ICVkXG4iLCByZXQpOworCQkJRFJNX0RF Vl9FUlJPUihkZXYtPmRldiwgImZhaWxlZCB0byBlbmFibGUgJ2dwdV9yZWcnOiAlZFxuIiwgcmV0 KTsKIAkJCXJldHVybiByZXQ7CiAJCX0KIAl9CkBAIC0xMjMsNyArMTIzLDcgQEAgc3RhdGljIGlu dCBlbmFibGVfcHdycmFpbChzdHJ1Y3QgbXNtX2dwdSAqZ3B1KQogCWlmIChncHUtPmdwdV9jeCkg ewogCQlyZXQgPSByZWd1bGF0b3JfZW5hYmxlKGdwdS0+Z3B1X2N4KTsKIAkJaWYgKHJldCkgewot CQkJZGV2X2VycihkZXYtPmRldiwgImZhaWxlZCB0byBlbmFibGUgJ2dwdV9jeCc6ICVkXG4iLCBy ZXQpOworCQkJRFJNX0RFVl9FUlJPUihkZXYtPmRldiwgImZhaWxlZCB0byBlbmFibGUgJ2dwdV9j eCc6ICVkXG4iLCByZXQpOwogCQkJcmV0dXJuIHJldDsKIAkJfQogCX0KQEAgLTQxOSw3ICs0MTks NyBAQCBzdGF0aWMgdm9pZCByZWNvdmVyX3dvcmtlcihzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmsp CiAKIAltdXRleF9sb2NrKCZkZXYtPnN0cnVjdF9tdXRleCk7CiAKLQlkZXZfZXJyKGRldi0+ZGV2 LCAiJXM6IGhhbmdjaGVjayByZWNvdmVyIVxuIiwgZ3B1LT5uYW1lKTsKKwlEUk1fREVWX0VSUk9S KGRldi0+ZGV2LCAiJXM6IGhhbmdjaGVjayByZWNvdmVyIVxuIiwgZ3B1LT5uYW1lKTsKIAogCXN1 Ym1pdCA9IGZpbmRfc3VibWl0KGN1cl9yaW5nLCBjdXJfcmluZy0+bWVtcHRycy0+ZmVuY2UgKyAx KTsKIAlpZiAoc3VibWl0KSB7CkBAIC00NDcsNyArNDQ3LDcgQEAgc3RhdGljIHZvaWQgcmVjb3Zl cl93b3JrZXIoc3RydWN0IHdvcmtfc3RydWN0ICp3b3JrKQogCQlyY3VfcmVhZF91bmxvY2soKTsK IAogCQlpZiAoY29tbSAmJiBjbWQpIHsKLQkJCWRldl9lcnIoZGV2LT5kZXYsICIlczogb2ZmZW5k aW5nIHRhc2s6ICVzICglcylcbiIsCisJCQlEUk1fREVWX0VSUk9SKGRldi0+ZGV2LCAiJXM6IG9m ZmVuZGluZyB0YXNrOiAlcyAoJXMpXG4iLAogCQkJCWdwdS0+bmFtZSwgY29tbSwgY21kKTsKIAog CQkJbXNtX3JkX2R1bXBfc3VibWl0KHByaXYtPmhhbmdyZCwgc3VibWl0LApAQCAtNTMwLDExICs1 MzAsMTEgQEAgc3RhdGljIHZvaWQgaGFuZ2NoZWNrX2hhbmRsZXIoc3RydWN0IHRpbWVyX2xpc3Qg KnQpCiAJfSBlbHNlIGlmIChmZW5jZSA8IHJpbmctPnNlcW5vKSB7CiAJCS8qIG5vIHByb2dyZXNz IGFuZCBub3QgZG9uZS4uIGh1bmchICovCiAJCXJpbmctPmhhbmdjaGVja19mZW5jZSA9IGZlbmNl OwotCQlkZXZfZXJyKGRldi0+ZGV2LCAiJXM6IGhhbmdjaGVjayBkZXRlY3RlZCBncHUgbG9ja3Vw IHJiICVkIVxuIiwKKwkJRFJNX0RFVl9FUlJPUihkZXYtPmRldiwgIiVzOiBoYW5nY2hlY2sgZGV0 ZWN0ZWQgZ3B1IGxvY2t1cCByYiAlZCFcbiIsCiAJCQkJZ3B1LT5uYW1lLCByaW5nLT5pZCk7Ci0J CWRldl9lcnIoZGV2LT5kZXYsICIlczogICAgIGNvbXBsZXRlZCBmZW5jZTogJXVcbiIsCisJCURS TV9ERVZfRVJST1IoZGV2LT5kZXYsICIlczogICAgIGNvbXBsZXRlZCBmZW5jZTogJXVcbiIsCiAJ CQkJZ3B1LT5uYW1lLCBmZW5jZSk7Ci0JCWRldl9lcnIoZGV2LT5kZXYsICIlczogICAgIHN1Ym1p dHRlZCBmZW5jZTogJXVcbiIsCisJCURSTV9ERVZfRVJST1IoZGV2LT5kZXYsICIlczogICAgIHN1 Ym1pdHRlZCBmZW5jZTogJXVcbiIsCiAJCQkJZ3B1LT5uYW1lLCByaW5nLT5zZXFubyk7CiAKIAkJ cXVldWVfd29yayhwcml2LT53cSwgJmdwdS0+cmVjb3Zlcl93b3JrKTsKQEAgLTgwNywxMSArODA3 LDExIEBAIHN0YXRpYyBpbnQgZ2V0X2Nsb2NrcyhzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2 LCBzdHJ1Y3QgbXNtX2dwdSAqZ3B1KQogCWlvbW11LT5nZW9tZXRyeS5hcGVydHVyZV9zdGFydCA9 IHZhX3N0YXJ0OwogCWlvbW11LT5nZW9tZXRyeS5hcGVydHVyZV9lbmQgPSB2YV9lbmQ7CiAKLQlk ZXZfaW5mbyhncHUtPmRldi0+ZGV2LCAiJXM6IHVzaW5nIElPTU1VXG4iLCBncHUtPm5hbWUpOwor CURSTV9ERVZfSU5GTyhncHUtPmRldi0+ZGV2LCAiJXM6IHVzaW5nIElPTU1VXG4iLCBncHUtPm5h bWUpOwogCiAJYXNwYWNlID0gbXNtX2dlbV9hZGRyZXNzX3NwYWNlX2NyZWF0ZSgmcGRldi0+ZGV2 LCBpb21tdSwgImdwdSIpOwogCWlmIChJU19FUlIoYXNwYWNlKSkgewotCQlkZXZfZXJyKGdwdS0+ ZGV2LT5kZXYsICJmYWlsZWQgdG8gaW5pdCBpb21tdTogJWxkXG4iLAorCQlEUk1fREVWX0VSUk9S KGdwdS0+ZGV2LT5kZXYsICJmYWlsZWQgdG8gaW5pdCBpb21tdTogJWxkXG4iLAogCQkJUFRSX0VS Uihhc3BhY2UpKTsKIAkJaW9tbXVfZG9tYWluX2ZyZWUoaW9tbXUpOwogCQlyZXR1cm4gRVJSX0NB U1QoYXNwYWNlKTsKQEAgLTg2MiwxNCArODYyLDE0IEBAIGludCBtc21fZ3B1X2luaXQoc3RydWN0 IGRybV9kZXZpY2UgKmRybSwgc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldiwKIAlncHUtPmly cSA9IHBsYXRmb3JtX2dldF9pcnFfYnluYW1lKHBkZXYsIGNvbmZpZy0+aXJxbmFtZSk7CiAJaWYg KGdwdS0+aXJxIDwgMCkgewogCQlyZXQgPSBncHUtPmlycTsKLQkJZGV2X2Vycihkcm0tPmRldiwg ImZhaWxlZCB0byBnZXQgaXJxOiAlZFxuIiwgcmV0KTsKKwkJRFJNX0RFVl9FUlJPUihkcm0tPmRl diwgImZhaWxlZCB0byBnZXQgaXJxOiAlZFxuIiwgcmV0KTsKIAkJZ290byBmYWlsOwogCX0KIAog CXJldCA9IGRldm1fcmVxdWVzdF9pcnEoJnBkZXYtPmRldiwgZ3B1LT5pcnEsIGlycV9oYW5kbGVy LAogCQkJSVJRRl9UUklHR0VSX0hJR0gsIGdwdS0+bmFtZSwgZ3B1KTsKIAlpZiAocmV0KSB7Ci0J CWRldl9lcnIoZHJtLT5kZXYsICJmYWlsZWQgdG8gcmVxdWVzdCBJUlEldTogJWRcbiIsIGdwdS0+ aXJxLCByZXQpOworCQlEUk1fREVWX0VSUk9SKGRybS0+ZGV2LCAiZmFpbGVkIHRvIHJlcXVlc3Qg SVJRJXU6ICVkXG4iLCBncHUtPmlycSwgcmV0KTsKIAkJZ290byBmYWlsOwogCX0KIApAQCAtOTAy LDcgKzkwMiw3IEBAIGludCBtc21fZ3B1X2luaXQoc3RydWN0IGRybV9kZXZpY2UgKmRybSwgc3Ry dWN0IHBsYXRmb3JtX2RldmljZSAqcGRldiwKIAkJY29uZmlnLT52YV9zdGFydCwgY29uZmlnLT52 YV9lbmQpOwogCiAJaWYgKGdwdS0+YXNwYWNlID09IE5VTEwpCi0JCWRldl9pbmZvKGRybS0+ZGV2 LCAiJXM6IG5vIElPTU1VLCBmYWxsYmFjayB0byBWUkFNIGNhcnZlb3V0IVxuIiwgbmFtZSk7CisJ CURSTV9ERVZfSU5GTyhkcm0tPmRldiwgIiVzOiBubyBJT01NVSwgZmFsbGJhY2sgdG8gVlJBTSBj YXJ2ZW91dCFcbiIsIG5hbWUpOwogCWVsc2UgaWYgKElTX0VSUihncHUtPmFzcGFjZSkpIHsKIAkJ cmV0ID0gUFRSX0VSUihncHUtPmFzcGFjZSk7CiAJCWdvdG8gZmFpbDsKQEAgLTkxNCw3ICs5MTQs NyBAQCBpbnQgbXNtX2dwdV9pbml0KHN0cnVjdCBkcm1fZGV2aWNlICpkcm0sIHN0cnVjdCBwbGF0 Zm9ybV9kZXZpY2UgKnBkZXYsCiAKIAlpZiAoSVNfRVJSKG1lbXB0cnMpKSB7CiAJCXJldCA9IFBU Ul9FUlIobWVtcHRycyk7Ci0JCWRldl9lcnIoZHJtLT5kZXYsICJjb3VsZCBub3QgYWxsb2NhdGUg bWVtcHRyczogJWRcbiIsIHJldCk7CisJCURSTV9ERVZfRVJST1IoZHJtLT5kZXYsICJjb3VsZCBu b3QgYWxsb2NhdGUgbWVtcHRyczogJWRcbiIsIHJldCk7CiAJCWdvdG8gZmFpbDsKIAl9CiAKQEAg LTkzMCw3ICs5MzAsNyBAQCBpbnQgbXNtX2dwdV9pbml0KHN0cnVjdCBkcm1fZGV2aWNlICpkcm0s IHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYsCiAKIAkJaWYgKElTX0VSUihncHUtPnJiW2ld KSkgewogCQkJcmV0ID0gUFRSX0VSUihncHUtPnJiW2ldKTsKLQkJCWRldl9lcnIoZHJtLT5kZXYs CisJCQlEUk1fREVWX0VSUk9SKGRybS0+ZGV2LAogCQkJCSJjb3VsZCBub3QgY3JlYXRlIHJpbmdi dWZmZXIgJWQ6ICVkXG4iLCBpLCByZXQpOwogCQkJZ290byBmYWlsOwogCQl9Ci0tIAoxLjkuMQoK X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVs IG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlz dHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVsCg==