From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.7 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, URIBL_BLOCKED,USER_AGENT_GIT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 682C5C43215 for ; Mon, 18 Nov 2019 11:44:52 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 34F5920878 for ; Mon, 18 Nov 2019 11:44:52 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726830AbfKRLom (ORCPT ); Mon, 18 Nov 2019 06:44:42 -0500 Received: from alexa-out-blr-02.qualcomm.com ([103.229.18.198]:63202 "EHLO alexa-out-blr-02.qualcomm.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726563AbfKRLom (ORCPT ); Mon, 18 Nov 2019 06:44:42 -0500 Received: from ironmsg02-blr.qualcomm.com ([10.86.208.131]) by alexa-out-blr-02.qualcomm.com with ESMTP/TLS/AES256-SHA; 18 Nov 2019 17:14:37 +0530 IronPort-SDR: EjeotJ8yr2Tte4I1ijJRCJ8hQIloGx92nxm2jbFZ67yVbf/vuMkubaEhx9y7kgR4b6emvOAF8a KvZY0v+OCHhDaz/s5bF5J/yl53u9nnExGrFvEQpYpmj918gICBBCMGdXT1YSN07rnS17ExHAXA r4SdWN7kKUG+6WzsqolsdUAuqRdPj8AQ6fxwPAcOYrknBqZzSRhMPgMwmaIsdwBzpALFc+tpnw pPF04Ir8I+53ofjuqv2+afPC2bsa4cbTUtRX4IsDCEvWUh+Y/TMkEs7g2HOter9NSACNR6xMxw 6j9l3yVTBnC/XIExmwzQ+83M Received: from kalyant-linux.qualcomm.com ([10.204.66.210]) by ironmsg02-blr.qualcomm.com with ESMTP; 18 Nov 2019 17:14:14 +0530 Received: by kalyant-linux.qualcomm.com (Postfix, from userid 94428) id B2E06431A; Mon, 18 Nov 2019 17:14:12 +0530 (IST) From: Kalyan Thota To: dri-devel@lists.freedesktop.org, linux-arm-msm@vger.kernel.org, freedreno@lists.freedesktop.org, devicetree@vger.kernel.org Cc: Kalyan Thota , linux-kernel@vger.kernel.org, robdclark@gmail.com, seanpaul@chromium.org, hoegsberg@chromium.org, dhar@codeaurora.org, jsanka@codeaurora.org, chandanu@codeaurora.org, travitej@codeaurora.org, nganji@codeaurora.org Subject: [PATCH v1] msm:disp:dpu1: setup display datapath for SC7180 target Date: Mon, 18 Nov 2019 17:14:04 +0530 Message-Id: <1574077444-24554-2-git-send-email-kalyan_t@codeaurora.org> X-Mailer: git-send-email 1.9.1 In-Reply-To: <1574077444-24554-1-git-send-email-kalyan_t@codeaurora.org> References: <1574077444-24554-1-git-send-email-kalyan_t@codeaurora.org> Sender: linux-arm-msm-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-arm-msm@vger.kernel.org Add changes to setup display datapath on SC7180 target changes in v1: 1) add changes to support ctl_active on SC7180 target 2) while selecting the number of mixers in the topology consider the interface width. This patch has dependency on the below series https://patchwork.kernel.org/patch/11249423/ Signed-off-by: Kalyan Thota Signed-off-by: Shubhashree Dhar Signed-off-by: Raviteja Tamatam --- drivers/gpu/drm/msm/disp/dpu1/dpu_encoder.c | 4 +- .../gpu/drm/msm/disp/dpu1/dpu_encoder_phys_vid.c | 21 +++++- drivers/gpu/drm/msm/disp/dpu1/dpu_hw_catalog.c | 1 + drivers/gpu/drm/msm/disp/dpu1/dpu_hw_ctl.c | 84 +++++++++++++++++++++- drivers/gpu/drm/msm/disp/dpu1/dpu_hw_ctl.h | 24 +++++++ drivers/gpu/drm/msm/disp/dpu1/dpu_hw_intf.c | 28 ++++++++ drivers/gpu/drm/msm/disp/dpu1/dpu_hw_intf.h | 6 ++ 7 files changed, 161 insertions(+), 7 deletions(-) diff --git a/drivers/gpu/drm/msm/disp/dpu1/dpu_encoder.c b/drivers/gpu/drm/msm/disp/dpu1/dpu_encoder.c index d82ea99..96c48a8 100644 --- a/drivers/gpu/drm/msm/disp/dpu1/dpu_encoder.c +++ b/drivers/gpu/drm/msm/disp/dpu1/dpu_encoder.c @@ -58,7 +58,7 @@ #define IDLE_SHORT_TIMEOUT 1 -#define MAX_VDISPLAY_SPLIT 1080 +#define MAX_HDISPLAY_SPLIT 1080 /* timeout in frames waiting for frame done */ #define DPU_ENCODER_FRAME_DONE_TIMEOUT_FRAMES 5 @@ -535,7 +535,7 @@ static struct msm_display_topology dpu_encoder_get_topology( intf_count++; /* User split topology for width > 1080 */ - topology.num_lm = (mode->vdisplay > MAX_VDISPLAY_SPLIT) ? 2 : 1; + topology.num_lm = (mode->hdisplay > MAX_HDISPLAY_SPLIT) ? 2 : 1; topology.num_enc = 0; topology.num_intf = intf_count; diff --git a/drivers/gpu/drm/msm/disp/dpu1/dpu_encoder_phys_vid.c b/drivers/gpu/drm/msm/disp/dpu1/dpu_encoder_phys_vid.c index b9c84fb..8cc8ad12 100644 --- a/drivers/gpu/drm/msm/disp/dpu1/dpu_encoder_phys_vid.c +++ b/drivers/gpu/drm/msm/disp/dpu1/dpu_encoder_phys_vid.c @@ -280,6 +280,14 @@ static void dpu_encoder_phys_vid_setup_timing_engine( phys_enc->hw_intf->ops.setup_timing_gen(phys_enc->hw_intf, &timing_params, fmt); phys_enc->hw_ctl->ops.setup_intf_cfg(phys_enc->hw_ctl, &intf_cfg); + + /* setup which pp blk will connect to this intf */ + if (phys_enc->hw_intf->ops.bind_pingpong_blk) + phys_enc->hw_intf->ops.bind_pingpong_blk( + phys_enc->hw_intf, + true, + phys_enc->hw_pp->idx); + spin_unlock_irqrestore(phys_enc->enc_spinlock, lock_flags); programmable_fetch_config(phys_enc, &timing_params); @@ -435,6 +443,7 @@ static void dpu_encoder_phys_vid_enable(struct dpu_encoder_phys *phys_enc) { struct dpu_hw_ctl *ctl; u32 flush_mask = 0; + u32 intf_flush_mask = 0; ctl = phys_enc->hw_ctl; @@ -459,10 +468,18 @@ static void dpu_encoder_phys_vid_enable(struct dpu_encoder_phys *phys_enc) ctl->ops.get_bitmask_intf(ctl, &flush_mask, phys_enc->hw_intf->idx); ctl->ops.update_pending_flush(ctl, flush_mask); + if (ctl->ops.get_bitmask_active_intf) + ctl->ops.get_bitmask_active_intf(ctl, &intf_flush_mask, + phys_enc->hw_intf->idx); + + if (ctl->ops.update_pending_intf_flush) + ctl->ops.update_pending_intf_flush(ctl, intf_flush_mask); + skip_flush: DPU_DEBUG_VIDENC(phys_enc, - "update pending flush ctl %d flush_mask %x\n", - ctl->idx - CTL_0, flush_mask); + "update pending flush ctl %d flush_mask 0%x intf_mask 0x%x\n", + ctl->idx - CTL_0, flush_mask, intf_flush_mask); + /* ctl_flush & timing engine enable will be triggered by framework */ if (phys_enc->enable_state == DPU_ENC_DISABLED) diff --git a/drivers/gpu/drm/msm/disp/dpu1/dpu_hw_catalog.c b/drivers/gpu/drm/msm/disp/dpu1/dpu_hw_catalog.c index 1d2ea93..1f2ac6e 100644 --- a/drivers/gpu/drm/msm/disp/dpu1/dpu_hw_catalog.c +++ b/drivers/gpu/drm/msm/disp/dpu1/dpu_hw_catalog.c @@ -374,6 +374,7 @@ {\ .name = _name, .id = _id, \ .base = _base, .len = 0x280, \ + .features = BIT(DPU_CTL_ACTIVE_CFG), \ .type = _type, \ .controller_id = _ctrl_id, \ .prog_fetch_lines_worst_case = 24 \ diff --git a/drivers/gpu/drm/msm/disp/dpu1/dpu_hw_ctl.c b/drivers/gpu/drm/msm/disp/dpu1/dpu_hw_ctl.c index 179e8d5..2ce4b5a 100644 --- a/drivers/gpu/drm/msm/disp/dpu1/dpu_hw_ctl.c +++ b/drivers/gpu/drm/msm/disp/dpu1/dpu_hw_ctl.c @@ -22,11 +22,15 @@ #define CTL_PREPARE 0x0d0 #define CTL_SW_RESET 0x030 #define CTL_LAYER_EXTN_OFFSET 0x40 +#define CTL_INTF_ACTIVE 0x0F4 +#define CTL_INTF_FLUSH 0x110 +#define CTL_INTF_MASTER 0x134 #define CTL_MIXER_BORDER_OUT BIT(24) #define CTL_FLUSH_MASK_CTL BIT(17) #define DPU_REG_RESET_TIMEOUT_US 2000 +#define INTF_IDX 31 static struct dpu_ctl_cfg *_ctl_offset(enum dpu_ctl ctl, struct dpu_mdss_cfg *m, @@ -100,11 +104,27 @@ static inline void dpu_hw_ctl_update_pending_flush(struct dpu_hw_ctl *ctx, ctx->pending_flush_mask |= flushbits; } +static inline void dpu_hw_ctl_update_pending_intf_flush(struct dpu_hw_ctl *ctx, + u32 flushbits) +{ + ctx->pending_intf_flush_mask |= flushbits; +} + static u32 dpu_hw_ctl_get_pending_flush(struct dpu_hw_ctl *ctx) { return ctx->pending_flush_mask; } +static inline void dpu_hw_ctl_trigger_flush_v1(struct dpu_hw_ctl *ctx) +{ + + if (ctx->pending_flush_mask & BIT(INTF_IDX)) + DPU_REG_WRITE(&ctx->hw, CTL_INTF_FLUSH, + ctx->pending_intf_flush_mask); + + DPU_REG_WRITE(&ctx->hw, CTL_FLUSH, ctx->pending_flush_mask); +} + static inline void dpu_hw_ctl_trigger_flush(struct dpu_hw_ctl *ctx) { trace_dpu_hw_ctl_trigger_pending_flush(ctx->pending_flush_mask, @@ -222,6 +242,36 @@ static int dpu_hw_ctl_get_bitmask_intf(struct dpu_hw_ctl *ctx, return 0; } +static int dpu_hw_ctl_get_bitmask_intf_v1(struct dpu_hw_ctl *ctx, + u32 *flushbits, enum dpu_intf intf) +{ + switch (intf) { + case INTF_0: + case INTF_1: + *flushbits |= BIT(31); + break; + default: + return 0; + } + return 0; +} + +static int dpu_hw_ctl_active_get_bitmask_intf(struct dpu_hw_ctl *ctx, + u32 *flushbits, enum dpu_intf intf) +{ + switch (intf) { + case INTF_0: + *flushbits |= BIT(0); + break; + case INTF_1: + *flushbits |= BIT(1); + break; + default: + return 0; + } + return 0; +} + static u32 dpu_hw_ctl_poll_reset_status(struct dpu_hw_ctl *ctx, u32 timeout_us) { struct dpu_hw_blk_reg_map *c = &ctx->hw; @@ -422,6 +472,24 @@ static void dpu_hw_ctl_setup_blendstage(struct dpu_hw_ctl *ctx, DPU_REG_WRITE(c, CTL_LAYER_EXT3(lm), mixercfg_ext3); } + +static void dpu_hw_ctl_intf_cfg_v1(struct dpu_hw_ctl *ctx, + struct dpu_hw_intf_cfg *cfg) +{ + struct dpu_hw_blk_reg_map *c = &ctx->hw; + u32 intf_active = 0; + u32 mode_sel = 0; + + if (cfg->intf_mode_sel == DPU_CTL_MODE_SEL_CMD) + mode_sel |= BIT(17); + + intf_active = DPU_REG_READ(c, CTL_INTF_ACTIVE); + intf_active |= BIT(cfg->intf - INTF_0); + + DPU_REG_WRITE(c, CTL_TOP, mode_sel); + DPU_REG_WRITE(c, CTL_INTF_ACTIVE, intf_active); +} + static void dpu_hw_ctl_intf_cfg(struct dpu_hw_ctl *ctx, struct dpu_hw_intf_cfg *cfg) { @@ -455,21 +523,31 @@ static void dpu_hw_ctl_intf_cfg(struct dpu_hw_ctl *ctx, static void _setup_ctl_ops(struct dpu_hw_ctl_ops *ops, unsigned long cap) { + if (cap & BIT(DPU_CTL_ACTIVE_CFG)) { + ops->trigger_flush = dpu_hw_ctl_trigger_flush_v1; + ops->setup_intf_cfg = dpu_hw_ctl_intf_cfg_v1; + ops->get_bitmask_intf = dpu_hw_ctl_get_bitmask_intf_v1; + ops->get_bitmask_active_intf = + dpu_hw_ctl_active_get_bitmask_intf; + ops->update_pending_intf_flush = + dpu_hw_ctl_update_pending_intf_flush; + } else { + ops->trigger_flush = dpu_hw_ctl_trigger_flush; + ops->setup_intf_cfg = dpu_hw_ctl_intf_cfg; + ops->get_bitmask_intf = dpu_hw_ctl_get_bitmask_intf; + } ops->clear_pending_flush = dpu_hw_ctl_clear_pending_flush; ops->update_pending_flush = dpu_hw_ctl_update_pending_flush; ops->get_pending_flush = dpu_hw_ctl_get_pending_flush; - ops->trigger_flush = dpu_hw_ctl_trigger_flush; ops->get_flush_register = dpu_hw_ctl_get_flush_register; ops->trigger_start = dpu_hw_ctl_trigger_start; ops->trigger_pending = dpu_hw_ctl_trigger_pending; - ops->setup_intf_cfg = dpu_hw_ctl_intf_cfg; ops->reset = dpu_hw_ctl_reset_control; ops->wait_reset_status = dpu_hw_ctl_wait_reset_status; ops->clear_all_blendstages = dpu_hw_ctl_clear_all_blendstages; ops->setup_blendstage = dpu_hw_ctl_setup_blendstage; ops->get_bitmask_sspp = dpu_hw_ctl_get_bitmask_sspp; ops->get_bitmask_mixer = dpu_hw_ctl_get_bitmask_mixer; - ops->get_bitmask_intf = dpu_hw_ctl_get_bitmask_intf; }; static struct dpu_hw_blk_ops dpu_hw_ops; diff --git a/drivers/gpu/drm/msm/disp/dpu1/dpu_hw_ctl.h b/drivers/gpu/drm/msm/disp/dpu1/dpu_hw_ctl.h index d3ae939..1e3973c 100644 --- a/drivers/gpu/drm/msm/disp/dpu1/dpu_hw_ctl.h +++ b/drivers/gpu/drm/msm/disp/dpu1/dpu_hw_ctl.h @@ -91,6 +91,15 @@ struct dpu_hw_ctl_ops { u32 flushbits); /** + * OR in the given flushbits to the cached pending_intf_flush_mask + * No effect on hardware + * @ctx : ctl path ctx pointer + * @flushbits : module flushmask + */ + void (*update_pending_intf_flush)(struct dpu_hw_ctl *ctx, + u32 flushbits); + + /** * Write the value of the pending_flush_mask to hardware * @ctx : ctl path ctx pointer */ @@ -130,11 +139,24 @@ struct dpu_hw_ctl_ops { uint32_t (*get_bitmask_mixer)(struct dpu_hw_ctl *ctx, enum dpu_lm blk); + /** + * Query the value of the intf flush mask + * No effect on hardware + * @ctx : ctl path ctx pointer + */ int (*get_bitmask_intf)(struct dpu_hw_ctl *ctx, u32 *flushbits, enum dpu_intf blk); /** + * Query the value of the intf active flush mask + * No effect on hardware + * @ctx : ctl path ctx pointer + */ + int (*get_bitmask_active_intf)(struct dpu_hw_ctl *ctx, + u32 *flushbits, enum dpu_intf blk); + + /** * Set all blend stages to disabled * @ctx : ctl path ctx pointer */ @@ -159,6 +181,7 @@ struct dpu_hw_ctl_ops { * @mixer_count: number of mixers * @mixer_hw_caps: mixer hardware capabilities * @pending_flush_mask: storage for pending ctl_flush managed via ops + * @pending_intf_flush_mask: pending INTF flush * @ops: operation list */ struct dpu_hw_ctl { @@ -171,6 +194,7 @@ struct dpu_hw_ctl { int mixer_count; const struct dpu_lm_cfg *mixer_hw_caps; u32 pending_flush_mask; + u32 pending_intf_flush_mask; /* ops */ struct dpu_hw_ctl_ops ops; diff --git a/drivers/gpu/drm/msm/disp/dpu1/dpu_hw_intf.c b/drivers/gpu/drm/msm/disp/dpu1/dpu_hw_intf.c index dcd87cd..eff5e6a 100644 --- a/drivers/gpu/drm/msm/disp/dpu1/dpu_hw_intf.c +++ b/drivers/gpu/drm/msm/disp/dpu1/dpu_hw_intf.c @@ -56,6 +56,8 @@ #define INTF_FRAME_COUNT 0x0AC #define INTF_LINE_COUNT 0x0B0 +#define INTF_MUX 0x25C + static struct dpu_intf_cfg *_intf_offset(enum dpu_intf intf, struct dpu_mdss_cfg *m, void __iomem *addr, @@ -218,6 +220,30 @@ static void dpu_hw_intf_setup_prg_fetch( DPU_REG_WRITE(c, INTF_CONFIG, fetch_enable); } +static void dpu_hw_intf_bind_pingpong_blk( + struct dpu_hw_intf *intf, + bool enable, + const enum dpu_pingpong pp) +{ + struct dpu_hw_blk_reg_map *c; + u32 mux_cfg; + + if (!intf) + return; + + c = &intf->hw; + + mux_cfg = DPU_REG_READ(c, INTF_MUX); + mux_cfg &= ~0xf; + + if (enable) + mux_cfg |= (pp - PINGPONG_0) & 0x7; + else + mux_cfg |= 0xf; + + DPU_REG_WRITE(c, INTF_MUX, mux_cfg); +} + static void dpu_hw_intf_get_status( struct dpu_hw_intf *intf, struct intf_status *s) @@ -254,6 +280,8 @@ static void _setup_intf_ops(struct dpu_hw_intf_ops *ops, ops->get_status = dpu_hw_intf_get_status; ops->enable_timing = dpu_hw_intf_enable_timing_engine; ops->get_line_count = dpu_hw_intf_get_line_count; + if (cap & BIT(DPU_CTL_ACTIVE_CFG)) + ops->bind_pingpong_blk = dpu_hw_intf_bind_pingpong_blk; } static struct dpu_hw_blk_ops dpu_hw_ops; diff --git a/drivers/gpu/drm/msm/disp/dpu1/dpu_hw_intf.h b/drivers/gpu/drm/msm/disp/dpu1/dpu_hw_intf.h index b03acc2..a1e0ef3 100644 --- a/drivers/gpu/drm/msm/disp/dpu1/dpu_hw_intf.h +++ b/drivers/gpu/drm/msm/disp/dpu1/dpu_hw_intf.h @@ -52,6 +52,8 @@ struct intf_status { * @ enable_timing: enable/disable timing engine * @ get_status: returns if timing engine is enabled or not * @ get_line_count: reads current vertical line counter + * @bind_pingpong_blk: enable/disable the connection with pingpong which will + * feed pixels to this interface */ struct dpu_hw_intf_ops { void (*setup_timing_gen)(struct dpu_hw_intf *intf, @@ -68,6 +70,10 @@ struct dpu_hw_intf_ops { struct intf_status *status); u32 (*get_line_count)(struct dpu_hw_intf *intf); + + void (*bind_pingpong_blk)(struct dpu_hw_intf *intf, + bool enable, + const enum dpu_pingpong pp); }; struct dpu_hw_intf { -- 1.9.1 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Kalyan Thota Subject: [PATCH v1] msm:disp:dpu1: setup display datapath for SC7180 target Date: Mon, 18 Nov 2019 17:14:04 +0530 Message-ID: <1574077444-24554-2-git-send-email-kalyan_t@codeaurora.org> References: <1574077444-24554-1-git-send-email-kalyan_t@codeaurora.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1574077444-24554-1-git-send-email-kalyan_t-sgV2jX0FEOL9JmXXK+q4OQ@public.gmane.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: freedreno-bounces-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org Sender: "Freedreno" To: dri-devel-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org, linux-arm-msm-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, freedreno-PD4FTy7X32lNgt0PjOBp9y5qC8QIuHrW@public.gmane.org, devicetree-u79uwXL29TY76Z2rM5mHXA@public.gmane.org Cc: dhar-sgV2jX0FEOL9JmXXK+q4OQ@public.gmane.org, travitej-sgV2jX0FEOL9JmXXK+q4OQ@public.gmane.org, linux-kernel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, robdclark-Re5JQEeQqe8AvxtiuMwx3w@public.gmane.org, nganji-sgV2jX0FEOL9JmXXK+q4OQ@public.gmane.org, seanpaul-F7+t8E8rja9g9hUCZPvPmw@public.gmane.org, Kalyan Thota , hoegsberg-F7+t8E8rja9g9hUCZPvPmw@public.gmane.org, jsanka-sgV2jX0FEOL9JmXXK+q4OQ@public.gmane.org, chandanu-sgV2jX0FEOL9JmXXK+q4OQ@public.gmane.org List-Id: dri-devel@lists.freedesktop.org QWRkIGNoYW5nZXMgdG8gc2V0dXAgZGlzcGxheSBkYXRhcGF0aCBvbiBTQzcxODAgdGFyZ2V0Cgpj aGFuZ2VzIGluIHYxOgoxKSBhZGQgY2hhbmdlcyB0byBzdXBwb3J0IGN0bF9hY3RpdmUgb24gU0M3 MTgwIHRhcmdldAoyKSB3aGlsZSBzZWxlY3RpbmcgdGhlIG51bWJlciBvZiBtaXhlcnMgaW4gdGhl IHRvcG9sb2d5CmNvbnNpZGVyIHRoZSBpbnRlcmZhY2Ugd2lkdGguCgpUaGlzIHBhdGNoIGhhcyBk ZXBlbmRlbmN5IG9uIHRoZSBiZWxvdyBzZXJpZXMKCmh0dHBzOi8vcGF0Y2h3b3JrLmtlcm5lbC5v cmcvcGF0Y2gvMTEyNDk0MjMvCgpTaWduZWQtb2ZmLWJ5OiBLYWx5YW4gVGhvdGEgPGthbHlhbl90 QGNvZGVhdXJvcmEub3JnPgpTaWduZWQtb2ZmLWJ5OiBTaHViaGFzaHJlZSBEaGFyIDxkaGFyQGNv ZGVhdXJvcmEub3JnPgpTaWduZWQtb2ZmLWJ5OiBSYXZpdGVqYSBUYW1hdGFtIDx0cmF2aXRlakBj b2RlYXVyb3JhLm9yZz4KLS0tCiBkcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3AvZHB1MS9kcHVfZW5j b2Rlci5jICAgICAgICB8ICA0ICstCiAuLi4vZ3B1L2RybS9tc20vZGlzcC9kcHUxL2RwdV9lbmNv ZGVyX3BoeXNfdmlkLmMgICB8IDIxICsrKysrLQogZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL2Rw dTEvZHB1X2h3X2NhdGFsb2cuYyAgICAgfCAgMSArCiBkcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3Av ZHB1MS9kcHVfaHdfY3RsLmMgICAgICAgICB8IDg0ICsrKysrKysrKysrKysrKysrKysrKy0KIGRy aXZlcnMvZ3B1L2RybS9tc20vZGlzcC9kcHUxL2RwdV9od19jdGwuaCAgICAgICAgIHwgMjQgKysr KysrKwogZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL2RwdTEvZHB1X2h3X2ludGYuYyAgICAgICAg fCAyOCArKysrKysrKwogZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL2RwdTEvZHB1X2h3X2ludGYu aCAgICAgICAgfCAgNiArKwogNyBmaWxlcyBjaGFuZ2VkLCAxNjEgaW5zZXJ0aW9ucygrKSwgNyBk ZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3AvZHB1MS9k cHVfZW5jb2Rlci5jIGIvZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL2RwdTEvZHB1X2VuY29kZXIu YwppbmRleCBkODJlYTk5Li45NmM0OGE4IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vbXNt L2Rpc3AvZHB1MS9kcHVfZW5jb2Rlci5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9tc20vZGlzcC9k cHUxL2RwdV9lbmNvZGVyLmMKQEAgLTU4LDcgKzU4LDcgQEAKIAogI2RlZmluZSBJRExFX1NIT1JU X1RJTUVPVVQJMQogCi0jZGVmaW5lIE1BWF9WRElTUExBWV9TUExJVCAxMDgwCisjZGVmaW5lIE1B WF9IRElTUExBWV9TUExJVCAxMDgwCiAKIC8qIHRpbWVvdXQgaW4gZnJhbWVzIHdhaXRpbmcgZm9y IGZyYW1lIGRvbmUgKi8KICNkZWZpbmUgRFBVX0VOQ09ERVJfRlJBTUVfRE9ORV9USU1FT1VUX0ZS QU1FUyA1CkBAIC01MzUsNyArNTM1LDcgQEAgc3RhdGljIHN0cnVjdCBtc21fZGlzcGxheV90b3Bv bG9neSBkcHVfZW5jb2Rlcl9nZXRfdG9wb2xvZ3koCiAJCQlpbnRmX2NvdW50Kys7CiAKIAkvKiBV c2VyIHNwbGl0IHRvcG9sb2d5IGZvciB3aWR0aCA+IDEwODAgKi8KLQl0b3BvbG9neS5udW1fbG0g PSAobW9kZS0+dmRpc3BsYXkgPiBNQVhfVkRJU1BMQVlfU1BMSVQpID8gMiA6IDE7CisJdG9wb2xv Z3kubnVtX2xtID0gKG1vZGUtPmhkaXNwbGF5ID4gTUFYX0hESVNQTEFZX1NQTElUKSA/IDIgOiAx OwogCXRvcG9sb2d5Lm51bV9lbmMgPSAwOwogCXRvcG9sb2d5Lm51bV9pbnRmID0gaW50Zl9jb3Vu dDsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL2RwdTEvZHB1X2VuY29k ZXJfcGh5c192aWQuYyBiL2RyaXZlcnMvZ3B1L2RybS9tc20vZGlzcC9kcHUxL2RwdV9lbmNvZGVy X3BoeXNfdmlkLmMKaW5kZXggYjljODRmYi4uOGNjOGFkMTIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMv Z3B1L2RybS9tc20vZGlzcC9kcHUxL2RwdV9lbmNvZGVyX3BoeXNfdmlkLmMKKysrIGIvZHJpdmVy cy9ncHUvZHJtL21zbS9kaXNwL2RwdTEvZHB1X2VuY29kZXJfcGh5c192aWQuYwpAQCAtMjgwLDYg KzI4MCwxNCBAQCBzdGF0aWMgdm9pZCBkcHVfZW5jb2Rlcl9waHlzX3ZpZF9zZXR1cF90aW1pbmdf ZW5naW5lKAogCXBoeXNfZW5jLT5od19pbnRmLT5vcHMuc2V0dXBfdGltaW5nX2dlbihwaHlzX2Vu Yy0+aHdfaW50ZiwKIAkJCSZ0aW1pbmdfcGFyYW1zLCBmbXQpOwogCXBoeXNfZW5jLT5od19jdGwt Pm9wcy5zZXR1cF9pbnRmX2NmZyhwaHlzX2VuYy0+aHdfY3RsLCAmaW50Zl9jZmcpOworCisJLyog c2V0dXAgd2hpY2ggcHAgYmxrIHdpbGwgY29ubmVjdCB0byB0aGlzIGludGYgKi8KKwlpZiAocGh5 c19lbmMtPmh3X2ludGYtPm9wcy5iaW5kX3Bpbmdwb25nX2JsaykKKwkJcGh5c19lbmMtPmh3X2lu dGYtPm9wcy5iaW5kX3Bpbmdwb25nX2JsaygKKwkJCQlwaHlzX2VuYy0+aHdfaW50ZiwKKwkJCQl0 cnVlLAorCQkJCXBoeXNfZW5jLT5od19wcC0+aWR4KTsKKwogCXNwaW5fdW5sb2NrX2lycXJlc3Rv cmUocGh5c19lbmMtPmVuY19zcGlubG9jaywgbG9ja19mbGFncyk7CiAKIAlwcm9ncmFtbWFibGVf ZmV0Y2hfY29uZmlnKHBoeXNfZW5jLCAmdGltaW5nX3BhcmFtcyk7CkBAIC00MzUsNiArNDQzLDcg QEAgc3RhdGljIHZvaWQgZHB1X2VuY29kZXJfcGh5c192aWRfZW5hYmxlKHN0cnVjdCBkcHVfZW5j b2Rlcl9waHlzICpwaHlzX2VuYykKIHsKIAlzdHJ1Y3QgZHB1X2h3X2N0bCAqY3RsOwogCXUzMiBm bHVzaF9tYXNrID0gMDsKKwl1MzIgaW50Zl9mbHVzaF9tYXNrID0gMDsKIAogCWN0bCA9IHBoeXNf ZW5jLT5od19jdGw7CiAKQEAgLTQ1OSwxMCArNDY4LDE4IEBAIHN0YXRpYyB2b2lkIGRwdV9lbmNv ZGVyX3BoeXNfdmlkX2VuYWJsZShzdHJ1Y3QgZHB1X2VuY29kZXJfcGh5cyAqcGh5c19lbmMpCiAJ Y3RsLT5vcHMuZ2V0X2JpdG1hc2tfaW50ZihjdGwsICZmbHVzaF9tYXNrLCBwaHlzX2VuYy0+aHdf aW50Zi0+aWR4KTsKIAljdGwtPm9wcy51cGRhdGVfcGVuZGluZ19mbHVzaChjdGwsIGZsdXNoX21h c2spOwogCisJaWYgKGN0bC0+b3BzLmdldF9iaXRtYXNrX2FjdGl2ZV9pbnRmKQorCQljdGwtPm9w cy5nZXRfYml0bWFza19hY3RpdmVfaW50ZihjdGwsICZpbnRmX2ZsdXNoX21hc2ssCisJCQlwaHlz X2VuYy0+aHdfaW50Zi0+aWR4KTsKKworCWlmIChjdGwtPm9wcy51cGRhdGVfcGVuZGluZ19pbnRm X2ZsdXNoKQorCQljdGwtPm9wcy51cGRhdGVfcGVuZGluZ19pbnRmX2ZsdXNoKGN0bCwgaW50Zl9m bHVzaF9tYXNrKTsKKwogc2tpcF9mbHVzaDoKIAlEUFVfREVCVUdfVklERU5DKHBoeXNfZW5jLAot CQkJICJ1cGRhdGUgcGVuZGluZyBmbHVzaCBjdGwgJWQgZmx1c2hfbWFzayAleFxuIiwKLQkJCSBj dGwtPmlkeCAtIENUTF8wLCBmbHVzaF9tYXNrKTsKKwkJInVwZGF0ZSBwZW5kaW5nIGZsdXNoIGN0 bCAlZCBmbHVzaF9tYXNrIDAleCBpbnRmX21hc2sgMHgleFxuIiwKKwkJY3RsLT5pZHggLSBDVExf MCwgZmx1c2hfbWFzaywgaW50Zl9mbHVzaF9tYXNrKTsKKwogCiAJLyogY3RsX2ZsdXNoICYgdGlt aW5nIGVuZ2luZSBlbmFibGUgd2lsbCBiZSB0cmlnZ2VyZWQgYnkgZnJhbWV3b3JrICovCiAJaWYg KHBoeXNfZW5jLT5lbmFibGVfc3RhdGUgPT0gRFBVX0VOQ19ESVNBQkxFRCkKZGlmZiAtLWdpdCBh L2RyaXZlcnMvZ3B1L2RybS9tc20vZGlzcC9kcHUxL2RwdV9od19jYXRhbG9nLmMgYi9kcml2ZXJz L2dwdS9kcm0vbXNtL2Rpc3AvZHB1MS9kcHVfaHdfY2F0YWxvZy5jCmluZGV4IDFkMmVhOTMuLjFm MmFjNmUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9tc20vZGlzcC9kcHUxL2RwdV9od19j YXRhbG9nLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL2RwdTEvZHB1X2h3X2NhdGFs b2cuYwpAQCAtMzc0LDYgKzM3NCw3IEBACiAJe1wKIAkubmFtZSA9IF9uYW1lLCAuaWQgPSBfaWQs IFwKIAkuYmFzZSA9IF9iYXNlLCAubGVuID0gMHgyODAsIFwKKwkuZmVhdHVyZXMgPSBCSVQoRFBV X0NUTF9BQ1RJVkVfQ0ZHKSwgXAogCS50eXBlID0gX3R5cGUsIFwKIAkuY29udHJvbGxlcl9pZCA9 IF9jdHJsX2lkLCBcCiAJLnByb2dfZmV0Y2hfbGluZXNfd29yc3RfY2FzZSA9IDI0IFwKZGlmZiAt LWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9tc20vZGlzcC9kcHUxL2RwdV9od19jdGwuYyBiL2RyaXZl cnMvZ3B1L2RybS9tc20vZGlzcC9kcHUxL2RwdV9od19jdGwuYwppbmRleCAxNzllOGQ1Li4yY2U0 YjVhIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3AvZHB1MS9kcHVfaHdfY3Rs LmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL2RwdTEvZHB1X2h3X2N0bC5jCkBAIC0y MiwxMSArMjIsMTUgQEAKICNkZWZpbmUgICBDVExfUFJFUEFSRSAgICAgICAgICAgICAgICAgICAw eDBkMAogI2RlZmluZSAgIENUTF9TV19SRVNFVCAgICAgICAgICAgICAgICAgIDB4MDMwCiAjZGVm aW5lICAgQ1RMX0xBWUVSX0VYVE5fT0ZGU0VUICAgICAgICAgMHg0MAorI2RlZmluZSAgIENUTF9J TlRGX0FDVElWRSAgICAgICAgICAgICAgIDB4MEY0CisjZGVmaW5lICAgQ1RMX0lOVEZfRkxVU0gg ICAgICAgICAgICAgICAgMHgxMTAKKyNkZWZpbmUgICBDVExfSU5URl9NQVNURVIgICAgICAgICAg ICAgICAweDEzNAogCiAjZGVmaW5lIENUTF9NSVhFUl9CT1JERVJfT1VUICAgICAgICAgICAgQklU KDI0KQogI2RlZmluZSBDVExfRkxVU0hfTUFTS19DVEwgICAgICAgICAgICAgIEJJVCgxNykKIAog I2RlZmluZSBEUFVfUkVHX1JFU0VUX1RJTUVPVVRfVVMgICAgICAgIDIwMDAKKyNkZWZpbmUgIElO VEZfSURYICAgICAgIDMxCiAKIHN0YXRpYyBzdHJ1Y3QgZHB1X2N0bF9jZmcgKl9jdGxfb2Zmc2V0 KGVudW0gZHB1X2N0bCBjdGwsCiAJCXN0cnVjdCBkcHVfbWRzc19jZmcgKm0sCkBAIC0xMDAsMTEg KzEwNCwyNyBAQCBzdGF0aWMgaW5saW5lIHZvaWQgZHB1X2h3X2N0bF91cGRhdGVfcGVuZGluZ19m bHVzaChzdHJ1Y3QgZHB1X2h3X2N0bCAqY3R4LAogCWN0eC0+cGVuZGluZ19mbHVzaF9tYXNrIHw9 IGZsdXNoYml0czsKIH0KIAorc3RhdGljIGlubGluZSB2b2lkIGRwdV9od19jdGxfdXBkYXRlX3Bl bmRpbmdfaW50Zl9mbHVzaChzdHJ1Y3QgZHB1X2h3X2N0bCAqY3R4LAorCQl1MzIgZmx1c2hiaXRz KQoreworCWN0eC0+cGVuZGluZ19pbnRmX2ZsdXNoX21hc2sgfD0gZmx1c2hiaXRzOworfQorCiBz dGF0aWMgdTMyIGRwdV9od19jdGxfZ2V0X3BlbmRpbmdfZmx1c2goc3RydWN0IGRwdV9od19jdGwg KmN0eCkKIHsKIAlyZXR1cm4gY3R4LT5wZW5kaW5nX2ZsdXNoX21hc2s7CiB9CiAKK3N0YXRpYyBp bmxpbmUgdm9pZCBkcHVfaHdfY3RsX3RyaWdnZXJfZmx1c2hfdjEoc3RydWN0IGRwdV9od19jdGwg KmN0eCkKK3sKKworCWlmIChjdHgtPnBlbmRpbmdfZmx1c2hfbWFzayAmIEJJVChJTlRGX0lEWCkp CisJCURQVV9SRUdfV1JJVEUoJmN0eC0+aHcsIENUTF9JTlRGX0ZMVVNILAorCQkJCWN0eC0+cGVu ZGluZ19pbnRmX2ZsdXNoX21hc2spOworCisJRFBVX1JFR19XUklURSgmY3R4LT5odywgQ1RMX0ZM VVNILCBjdHgtPnBlbmRpbmdfZmx1c2hfbWFzayk7Cit9CisKIHN0YXRpYyBpbmxpbmUgdm9pZCBk cHVfaHdfY3RsX3RyaWdnZXJfZmx1c2goc3RydWN0IGRwdV9od19jdGwgKmN0eCkKIHsKIAl0cmFj ZV9kcHVfaHdfY3RsX3RyaWdnZXJfcGVuZGluZ19mbHVzaChjdHgtPnBlbmRpbmdfZmx1c2hfbWFz aywKQEAgLTIyMiw2ICsyNDIsMzYgQEAgc3RhdGljIGludCBkcHVfaHdfY3RsX2dldF9iaXRtYXNr X2ludGYoc3RydWN0IGRwdV9od19jdGwgKmN0eCwKIAlyZXR1cm4gMDsKIH0KIAorc3RhdGljIGlu dCBkcHVfaHdfY3RsX2dldF9iaXRtYXNrX2ludGZfdjEoc3RydWN0IGRwdV9od19jdGwgKmN0eCwK KwkJdTMyICpmbHVzaGJpdHMsIGVudW0gZHB1X2ludGYgaW50ZikKK3sKKwlzd2l0Y2ggKGludGYp IHsKKwljYXNlIElOVEZfMDoKKwljYXNlIElOVEZfMToKKwkJKmZsdXNoYml0cyB8PSBCSVQoMzEp OworCQlicmVhazsKKwlkZWZhdWx0OgorCQlyZXR1cm4gMDsKKwl9CisJcmV0dXJuIDA7Cit9CisK K3N0YXRpYyBpbnQgZHB1X2h3X2N0bF9hY3RpdmVfZ2V0X2JpdG1hc2tfaW50ZihzdHJ1Y3QgZHB1 X2h3X2N0bCAqY3R4LAorCQl1MzIgKmZsdXNoYml0cywgZW51bSBkcHVfaW50ZiBpbnRmKQorewor CXN3aXRjaCAoaW50ZikgeworCWNhc2UgSU5URl8wOgorCQkqZmx1c2hiaXRzIHw9IEJJVCgwKTsK KwkJYnJlYWs7CisJY2FzZSBJTlRGXzE6CisJCSpmbHVzaGJpdHMgfD0gQklUKDEpOworCQlicmVh azsKKwlkZWZhdWx0OgorCQlyZXR1cm4gMDsKKwl9CisJcmV0dXJuIDA7Cit9CisKIHN0YXRpYyB1 MzIgZHB1X2h3X2N0bF9wb2xsX3Jlc2V0X3N0YXR1cyhzdHJ1Y3QgZHB1X2h3X2N0bCAqY3R4LCB1 MzIgdGltZW91dF91cykKIHsKIAlzdHJ1Y3QgZHB1X2h3X2Jsa19yZWdfbWFwICpjID0gJmN0eC0+ aHc7CkBAIC00MjIsNiArNDcyLDI0IEBAIHN0YXRpYyB2b2lkIGRwdV9od19jdGxfc2V0dXBfYmxl bmRzdGFnZShzdHJ1Y3QgZHB1X2h3X2N0bCAqY3R4LAogCURQVV9SRUdfV1JJVEUoYywgQ1RMX0xB WUVSX0VYVDMobG0pLCBtaXhlcmNmZ19leHQzKTsKIH0KIAorCitzdGF0aWMgdm9pZCBkcHVfaHdf Y3RsX2ludGZfY2ZnX3YxKHN0cnVjdCBkcHVfaHdfY3RsICpjdHgsCisJCXN0cnVjdCBkcHVfaHdf aW50Zl9jZmcgKmNmZykKK3sKKwlzdHJ1Y3QgZHB1X2h3X2Jsa19yZWdfbWFwICpjID0gJmN0eC0+ aHc7CisJdTMyIGludGZfYWN0aXZlID0gMDsKKwl1MzIgbW9kZV9zZWwgPSAwOworCisJaWYgKGNm Zy0+aW50Zl9tb2RlX3NlbCA9PSBEUFVfQ1RMX01PREVfU0VMX0NNRCkKKwkJbW9kZV9zZWwgfD0g QklUKDE3KTsKKworCWludGZfYWN0aXZlID0gRFBVX1JFR19SRUFEKGMsIENUTF9JTlRGX0FDVElW RSk7CisJaW50Zl9hY3RpdmUgfD0gQklUKGNmZy0+aW50ZiAtIElOVEZfMCk7CisKKwlEUFVfUkVH X1dSSVRFKGMsIENUTF9UT1AsIG1vZGVfc2VsKTsKKwlEUFVfUkVHX1dSSVRFKGMsIENUTF9JTlRG X0FDVElWRSwgaW50Zl9hY3RpdmUpOworfQorCiBzdGF0aWMgdm9pZCBkcHVfaHdfY3RsX2ludGZf Y2ZnKHN0cnVjdCBkcHVfaHdfY3RsICpjdHgsCiAJCXN0cnVjdCBkcHVfaHdfaW50Zl9jZmcgKmNm ZykKIHsKQEAgLTQ1NSwyMSArNTIzLDMxIEBAIHN0YXRpYyB2b2lkIGRwdV9od19jdGxfaW50Zl9j Zmcoc3RydWN0IGRwdV9od19jdGwgKmN0eCwKIHN0YXRpYyB2b2lkIF9zZXR1cF9jdGxfb3BzKHN0 cnVjdCBkcHVfaHdfY3RsX29wcyAqb3BzLAogCQl1bnNpZ25lZCBsb25nIGNhcCkKIHsKKwlpZiAo Y2FwICYgQklUKERQVV9DVExfQUNUSVZFX0NGRykpIHsKKwkJb3BzLT50cmlnZ2VyX2ZsdXNoID0g ZHB1X2h3X2N0bF90cmlnZ2VyX2ZsdXNoX3YxOworCQlvcHMtPnNldHVwX2ludGZfY2ZnID0gZHB1 X2h3X2N0bF9pbnRmX2NmZ192MTsKKwkJb3BzLT5nZXRfYml0bWFza19pbnRmID0gZHB1X2h3X2N0 bF9nZXRfYml0bWFza19pbnRmX3YxOworCQlvcHMtPmdldF9iaXRtYXNrX2FjdGl2ZV9pbnRmID0K KwkJCWRwdV9od19jdGxfYWN0aXZlX2dldF9iaXRtYXNrX2ludGY7CisJCW9wcy0+dXBkYXRlX3Bl bmRpbmdfaW50Zl9mbHVzaCA9CisJCQlkcHVfaHdfY3RsX3VwZGF0ZV9wZW5kaW5nX2ludGZfZmx1 c2g7CisJfSBlbHNlIHsKKwkJb3BzLT50cmlnZ2VyX2ZsdXNoID0gZHB1X2h3X2N0bF90cmlnZ2Vy X2ZsdXNoOworCQlvcHMtPnNldHVwX2ludGZfY2ZnID0gZHB1X2h3X2N0bF9pbnRmX2NmZzsKKwkJ b3BzLT5nZXRfYml0bWFza19pbnRmID0gZHB1X2h3X2N0bF9nZXRfYml0bWFza19pbnRmOworCX0K IAlvcHMtPmNsZWFyX3BlbmRpbmdfZmx1c2ggPSBkcHVfaHdfY3RsX2NsZWFyX3BlbmRpbmdfZmx1 c2g7CiAJb3BzLT51cGRhdGVfcGVuZGluZ19mbHVzaCA9IGRwdV9od19jdGxfdXBkYXRlX3BlbmRp bmdfZmx1c2g7CiAJb3BzLT5nZXRfcGVuZGluZ19mbHVzaCA9IGRwdV9od19jdGxfZ2V0X3BlbmRp bmdfZmx1c2g7Ci0Jb3BzLT50cmlnZ2VyX2ZsdXNoID0gZHB1X2h3X2N0bF90cmlnZ2VyX2ZsdXNo OwogCW9wcy0+Z2V0X2ZsdXNoX3JlZ2lzdGVyID0gZHB1X2h3X2N0bF9nZXRfZmx1c2hfcmVnaXN0 ZXI7CiAJb3BzLT50cmlnZ2VyX3N0YXJ0ID0gZHB1X2h3X2N0bF90cmlnZ2VyX3N0YXJ0OwogCW9w cy0+dHJpZ2dlcl9wZW5kaW5nID0gZHB1X2h3X2N0bF90cmlnZ2VyX3BlbmRpbmc7Ci0Jb3BzLT5z ZXR1cF9pbnRmX2NmZyA9IGRwdV9od19jdGxfaW50Zl9jZmc7CiAJb3BzLT5yZXNldCA9IGRwdV9o d19jdGxfcmVzZXRfY29udHJvbDsKIAlvcHMtPndhaXRfcmVzZXRfc3RhdHVzID0gZHB1X2h3X2N0 bF93YWl0X3Jlc2V0X3N0YXR1czsKIAlvcHMtPmNsZWFyX2FsbF9ibGVuZHN0YWdlcyA9IGRwdV9o d19jdGxfY2xlYXJfYWxsX2JsZW5kc3RhZ2VzOwogCW9wcy0+c2V0dXBfYmxlbmRzdGFnZSA9IGRw dV9od19jdGxfc2V0dXBfYmxlbmRzdGFnZTsKIAlvcHMtPmdldF9iaXRtYXNrX3NzcHAgPSBkcHVf aHdfY3RsX2dldF9iaXRtYXNrX3NzcHA7CiAJb3BzLT5nZXRfYml0bWFza19taXhlciA9IGRwdV9o d19jdGxfZ2V0X2JpdG1hc2tfbWl4ZXI7Ci0Jb3BzLT5nZXRfYml0bWFza19pbnRmID0gZHB1X2h3 X2N0bF9nZXRfYml0bWFza19pbnRmOwogfTsKIAogc3RhdGljIHN0cnVjdCBkcHVfaHdfYmxrX29w cyBkcHVfaHdfb3BzOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL2RwdTEv ZHB1X2h3X2N0bC5oIGIvZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL2RwdTEvZHB1X2h3X2N0bC5o CmluZGV4IGQzYWU5MzkuLjFlMzk3M2MgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9tc20v ZGlzcC9kcHUxL2RwdV9od19jdGwuaAorKysgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3AvZHB1 MS9kcHVfaHdfY3RsLmgKQEAgLTkxLDYgKzkxLDE1IEBAIHN0cnVjdCBkcHVfaHdfY3RsX29wcyB7 CiAJCXUzMiBmbHVzaGJpdHMpOwogCiAJLyoqCisJICogT1IgaW4gdGhlIGdpdmVuIGZsdXNoYml0 cyB0byB0aGUgY2FjaGVkIHBlbmRpbmdfaW50Zl9mbHVzaF9tYXNrCisJICogTm8gZWZmZWN0IG9u IGhhcmR3YXJlCisJICogQGN0eCAgICAgICA6IGN0bCBwYXRoIGN0eCBwb2ludGVyCisJICogQGZs dXNoYml0cyA6IG1vZHVsZSBmbHVzaG1hc2sKKwkgKi8KKwl2b2lkICgqdXBkYXRlX3BlbmRpbmdf aW50Zl9mbHVzaCkoc3RydWN0IGRwdV9od19jdGwgKmN0eCwKKwkJdTMyIGZsdXNoYml0cyk7CisK KwkvKioKIAkgKiBXcml0ZSB0aGUgdmFsdWUgb2YgdGhlIHBlbmRpbmdfZmx1c2hfbWFzayB0byBo YXJkd2FyZQogCSAqIEBjdHggICAgICAgOiBjdGwgcGF0aCBjdHggcG9pbnRlcgogCSAqLwpAQCAt MTMwLDExICsxMzksMjQgQEAgc3RydWN0IGRwdV9od19jdGxfb3BzIHsKIAl1aW50MzJfdCAoKmdl dF9iaXRtYXNrX21peGVyKShzdHJ1Y3QgZHB1X2h3X2N0bCAqY3R4LAogCQllbnVtIGRwdV9sbSBi bGspOwogCisJLyoqCisJICogUXVlcnkgdGhlIHZhbHVlIG9mIHRoZSBpbnRmIGZsdXNoIG1hc2sK KwkgKiBObyBlZmZlY3Qgb24gaGFyZHdhcmUKKwkgKiBAY3R4ICAgICAgIDogY3RsIHBhdGggY3R4 IHBvaW50ZXIKKwkgKi8KIAlpbnQgKCpnZXRfYml0bWFza19pbnRmKShzdHJ1Y3QgZHB1X2h3X2N0 bCAqY3R4LAogCQl1MzIgKmZsdXNoYml0cywKIAkJZW51bSBkcHVfaW50ZiBibGspOwogCiAJLyoq CisJICogUXVlcnkgdGhlIHZhbHVlIG9mIHRoZSBpbnRmIGFjdGl2ZSBmbHVzaCBtYXNrCisJICog Tm8gZWZmZWN0IG9uIGhhcmR3YXJlCisJICogQGN0eCAgICAgICA6IGN0bCBwYXRoIGN0eCBwb2lu dGVyCisJICovCisJaW50ICgqZ2V0X2JpdG1hc2tfYWN0aXZlX2ludGYpKHN0cnVjdCBkcHVfaHdf Y3RsICpjdHgsCisJCXUzMiAqZmx1c2hiaXRzLCBlbnVtIGRwdV9pbnRmIGJsayk7CisKKwkvKioK IAkgKiBTZXQgYWxsIGJsZW5kIHN0YWdlcyB0byBkaXNhYmxlZAogCSAqIEBjdHggICAgICAgOiBj dGwgcGF0aCBjdHggcG9pbnRlcgogCSAqLwpAQCAtMTU5LDYgKzE4MSw3IEBAIHN0cnVjdCBkcHVf aHdfY3RsX29wcyB7CiAgKiBAbWl4ZXJfY291bnQ6IG51bWJlciBvZiBtaXhlcnMKICAqIEBtaXhl cl9od19jYXBzOiBtaXhlciBoYXJkd2FyZSBjYXBhYmlsaXRpZXMKICAqIEBwZW5kaW5nX2ZsdXNo X21hc2s6IHN0b3JhZ2UgZm9yIHBlbmRpbmcgY3RsX2ZsdXNoIG1hbmFnZWQgdmlhIG9wcworICog QHBlbmRpbmdfaW50Zl9mbHVzaF9tYXNrOiBwZW5kaW5nIElOVEYgZmx1c2gKICAqIEBvcHM6IG9w ZXJhdGlvbiBsaXN0CiAgKi8KIHN0cnVjdCBkcHVfaHdfY3RsIHsKQEAgLTE3MSw2ICsxOTQsNyBA QCBzdHJ1Y3QgZHB1X2h3X2N0bCB7CiAJaW50IG1peGVyX2NvdW50OwogCWNvbnN0IHN0cnVjdCBk cHVfbG1fY2ZnICptaXhlcl9od19jYXBzOwogCXUzMiBwZW5kaW5nX2ZsdXNoX21hc2s7CisJdTMy IHBlbmRpbmdfaW50Zl9mbHVzaF9tYXNrOwogCiAJLyogb3BzICovCiAJc3RydWN0IGRwdV9od19j dGxfb3BzIG9wczsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9tc20vZGlzcC9kcHUxL2Rw dV9od19pbnRmLmMgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3AvZHB1MS9kcHVfaHdfaW50Zi5j CmluZGV4IGRjZDg3Y2QuLmVmZjVlNmEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9tc20v ZGlzcC9kcHUxL2RwdV9od19pbnRmLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL2Rw dTEvZHB1X2h3X2ludGYuYwpAQCAtNTYsNiArNTYsOCBAQAogI2RlZmluZSAgIElOVEZfRlJBTUVf Q09VTlQgICAgICAgICAgICAgIDB4MEFDCiAjZGVmaW5lICAgSU5URl9MSU5FX0NPVU5UICAgICAg ICAgICAgICAgMHgwQjAKIAorI2RlZmluZSAgIElOVEZfTVVYICAgICAgICAgICAgICAgICAgICAg IDB4MjVDCisKIHN0YXRpYyBzdHJ1Y3QgZHB1X2ludGZfY2ZnICpfaW50Zl9vZmZzZXQoZW51bSBk cHVfaW50ZiBpbnRmLAogCQlzdHJ1Y3QgZHB1X21kc3NfY2ZnICptLAogCQl2b2lkIF9faW9tZW0g KmFkZHIsCkBAIC0yMTgsNiArMjIwLDMwIEBAIHN0YXRpYyB2b2lkIGRwdV9od19pbnRmX3NldHVw X3ByZ19mZXRjaCgKIAlEUFVfUkVHX1dSSVRFKGMsIElOVEZfQ09ORklHLCBmZXRjaF9lbmFibGUp OwogfQogCitzdGF0aWMgdm9pZCBkcHVfaHdfaW50Zl9iaW5kX3Bpbmdwb25nX2JsaygKKwkJc3Ry dWN0IGRwdV9od19pbnRmICppbnRmLAorCQlib29sIGVuYWJsZSwKKwkJY29uc3QgZW51bSBkcHVf cGluZ3BvbmcgcHApCit7CisJc3RydWN0IGRwdV9od19ibGtfcmVnX21hcCAqYzsKKwl1MzIgbXV4 X2NmZzsKKworCWlmICghaW50ZikKKwkJcmV0dXJuOworCisJYyA9ICZpbnRmLT5odzsKKworCW11 eF9jZmcgPSBEUFVfUkVHX1JFQUQoYywgSU5URl9NVVgpOworCW11eF9jZmcgJj0gfjB4ZjsKKwor CWlmIChlbmFibGUpCisJCW11eF9jZmcgfD0gKHBwIC0gUElOR1BPTkdfMCkgJiAweDc7CisJZWxz ZQorCQltdXhfY2ZnIHw9IDB4ZjsKKworCURQVV9SRUdfV1JJVEUoYywgSU5URl9NVVgsIG11eF9j ZmcpOworfQorCiBzdGF0aWMgdm9pZCBkcHVfaHdfaW50Zl9nZXRfc3RhdHVzKAogCQlzdHJ1Y3Qg ZHB1X2h3X2ludGYgKmludGYsCiAJCXN0cnVjdCBpbnRmX3N0YXR1cyAqcykKQEAgLTI1NCw2ICsy ODAsOCBAQCBzdGF0aWMgdm9pZCBfc2V0dXBfaW50Zl9vcHMoc3RydWN0IGRwdV9od19pbnRmX29w cyAqb3BzLAogCW9wcy0+Z2V0X3N0YXR1cyA9IGRwdV9od19pbnRmX2dldF9zdGF0dXM7CiAJb3Bz LT5lbmFibGVfdGltaW5nID0gZHB1X2h3X2ludGZfZW5hYmxlX3RpbWluZ19lbmdpbmU7CiAJb3Bz LT5nZXRfbGluZV9jb3VudCA9IGRwdV9od19pbnRmX2dldF9saW5lX2NvdW50OworCWlmIChjYXAg JiBCSVQoRFBVX0NUTF9BQ1RJVkVfQ0ZHKSkKKwkJb3BzLT5iaW5kX3Bpbmdwb25nX2JsayA9IGRw dV9od19pbnRmX2JpbmRfcGluZ3BvbmdfYmxrOwogfQogCiBzdGF0aWMgc3RydWN0IGRwdV9od19i bGtfb3BzIGRwdV9od19vcHM7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3Av ZHB1MS9kcHVfaHdfaW50Zi5oIGIvZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL2RwdTEvZHB1X2h3 X2ludGYuaAppbmRleCBiMDNhY2MyLi5hMWUwZWYzIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9k cm0vbXNtL2Rpc3AvZHB1MS9kcHVfaHdfaW50Zi5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9tc20v ZGlzcC9kcHUxL2RwdV9od19pbnRmLmgKQEAgLTUyLDYgKzUyLDggQEAgc3RydWN0IGludGZfc3Rh dHVzIHsKICAqIEAgZW5hYmxlX3RpbWluZzogZW5hYmxlL2Rpc2FibGUgdGltaW5nIGVuZ2luZQog ICogQCBnZXRfc3RhdHVzOiByZXR1cm5zIGlmIHRpbWluZyBlbmdpbmUgaXMgZW5hYmxlZCBvciBu b3QKICAqIEAgZ2V0X2xpbmVfY291bnQ6IHJlYWRzIGN1cnJlbnQgdmVydGljYWwgbGluZSBjb3Vu dGVyCisgKiBAYmluZF9waW5ncG9uZ19ibGs6IGVuYWJsZS9kaXNhYmxlIHRoZSBjb25uZWN0aW9u IHdpdGggcGluZ3Bvbmcgd2hpY2ggd2lsbAorICogICAgICAgICAgICAgICAgICAgICBmZWVkIHBp eGVscyB0byB0aGlzIGludGVyZmFjZQogICovCiBzdHJ1Y3QgZHB1X2h3X2ludGZfb3BzIHsKIAl2 b2lkICgqc2V0dXBfdGltaW5nX2dlbikoc3RydWN0IGRwdV9od19pbnRmICppbnRmLApAQCAtNjgs NiArNzAsMTAgQEAgc3RydWN0IGRwdV9od19pbnRmX29wcyB7CiAJCQlzdHJ1Y3QgaW50Zl9zdGF0 dXMgKnN0YXR1cyk7CiAKIAl1MzIgKCpnZXRfbGluZV9jb3VudCkoc3RydWN0IGRwdV9od19pbnRm ICppbnRmKTsKKworCXZvaWQgKCpiaW5kX3Bpbmdwb25nX2Jsaykoc3RydWN0IGRwdV9od19pbnRm ICppbnRmLAorCQkJYm9vbCBlbmFibGUsCisJCQljb25zdCBlbnVtIGRwdV9waW5ncG9uZyBwcCk7 CiB9OwogCiBzdHJ1Y3QgZHB1X2h3X2ludGYgewotLSAKMS45LjEKCl9fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCkZyZWVkcmVubyBtYWlsaW5nIGxpc3QKRnJl ZWRyZW5vQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9y Zy9tYWlsbWFuL2xpc3RpbmZvL2ZyZWVkcmVubw== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.8 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 82287C432C3 for ; Tue, 19 Nov 2019 08:07:08 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 62EC1222C7 for ; Tue, 19 Nov 2019 08:07:08 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 62EC1222C7 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=codeaurora.org Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=dri-devel-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 1FB296EBE8; Tue, 19 Nov 2019 08:06:12 +0000 (UTC) Received: from alexa-out-blr-01.qualcomm.com (alexa-out-blr-01.qualcomm.com [103.229.18.197]) by gabe.freedesktop.org (Postfix) with ESMTPS id 4841689D4F; Mon, 18 Nov 2019 11:44:41 +0000 (UTC) Received: from ironmsg02-blr.qualcomm.com ([10.86.208.131]) by alexa-out-blr-01.qualcomm.com with ESMTP/TLS/AES256-SHA; 18 Nov 2019 17:14:38 +0530 IronPort-SDR: EjeotJ8yr2Tte4I1ijJRCJ8hQIloGx92nxm2jbFZ67yVbf/vuMkubaEhx9y7kgR4b6emvOAF8a KvZY0v+OCHhDaz/s5bF5J/yl53u9nnExGrFvEQpYpmj918gICBBCMGdXT1YSN07rnS17ExHAXA r4SdWN7kKUG+6WzsqolsdUAuqRdPj8AQ6fxwPAcOYrknBqZzSRhMPgMwmaIsdwBzpALFc+tpnw pPF04Ir8I+53ofjuqv2+afPC2bsa4cbTUtRX4IsDCEvWUh+Y/TMkEs7g2HOter9NSACNR6xMxw 6j9l3yVTBnC/XIExmwzQ+83M Received: from kalyant-linux.qualcomm.com ([10.204.66.210]) by ironmsg02-blr.qualcomm.com with ESMTP; 18 Nov 2019 17:14:14 +0530 Received: by kalyant-linux.qualcomm.com (Postfix, from userid 94428) id B2E06431A; Mon, 18 Nov 2019 17:14:12 +0530 (IST) From: Kalyan Thota To: dri-devel@lists.freedesktop.org, linux-arm-msm@vger.kernel.org, freedreno@lists.freedesktop.org, devicetree@vger.kernel.org Subject: [PATCH v1] msm:disp:dpu1: setup display datapath for SC7180 target Date: Mon, 18 Nov 2019 17:14:04 +0530 Message-Id: <1574077444-24554-2-git-send-email-kalyan_t@codeaurora.org> X-Mailer: git-send-email 1.9.1 In-Reply-To: <1574077444-24554-1-git-send-email-kalyan_t@codeaurora.org> References: <1574077444-24554-1-git-send-email-kalyan_t@codeaurora.org> X-Mailman-Approved-At: Tue, 19 Nov 2019 08:04:07 +0000 X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: dhar@codeaurora.org, travitej@codeaurora.org, linux-kernel@vger.kernel.org, seanpaul@chromium.org, Kalyan Thota , hoegsberg@chromium.org, chandanu@codeaurora.org MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" Message-ID: <20191118114404.vLmddwKxzQaWPwweVR1Ijl5-X3P5TVkkpRDKfrDPz9Y@z> QWRkIGNoYW5nZXMgdG8gc2V0dXAgZGlzcGxheSBkYXRhcGF0aCBvbiBTQzcxODAgdGFyZ2V0Cgpj aGFuZ2VzIGluIHYxOgoxKSBhZGQgY2hhbmdlcyB0byBzdXBwb3J0IGN0bF9hY3RpdmUgb24gU0M3 MTgwIHRhcmdldAoyKSB3aGlsZSBzZWxlY3RpbmcgdGhlIG51bWJlciBvZiBtaXhlcnMgaW4gdGhl IHRvcG9sb2d5CmNvbnNpZGVyIHRoZSBpbnRlcmZhY2Ugd2lkdGguCgpUaGlzIHBhdGNoIGhhcyBk ZXBlbmRlbmN5IG9uIHRoZSBiZWxvdyBzZXJpZXMKCmh0dHBzOi8vcGF0Y2h3b3JrLmtlcm5lbC5v cmcvcGF0Y2gvMTEyNDk0MjMvCgpTaWduZWQtb2ZmLWJ5OiBLYWx5YW4gVGhvdGEgPGthbHlhbl90 QGNvZGVhdXJvcmEub3JnPgpTaWduZWQtb2ZmLWJ5OiBTaHViaGFzaHJlZSBEaGFyIDxkaGFyQGNv ZGVhdXJvcmEub3JnPgpTaWduZWQtb2ZmLWJ5OiBSYXZpdGVqYSBUYW1hdGFtIDx0cmF2aXRlakBj b2RlYXVyb3JhLm9yZz4KLS0tCiBkcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3AvZHB1MS9kcHVfZW5j b2Rlci5jICAgICAgICB8ICA0ICstCiAuLi4vZ3B1L2RybS9tc20vZGlzcC9kcHUxL2RwdV9lbmNv ZGVyX3BoeXNfdmlkLmMgICB8IDIxICsrKysrLQogZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL2Rw dTEvZHB1X2h3X2NhdGFsb2cuYyAgICAgfCAgMSArCiBkcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3Av ZHB1MS9kcHVfaHdfY3RsLmMgICAgICAgICB8IDg0ICsrKysrKysrKysrKysrKysrKysrKy0KIGRy aXZlcnMvZ3B1L2RybS9tc20vZGlzcC9kcHUxL2RwdV9od19jdGwuaCAgICAgICAgIHwgMjQgKysr KysrKwogZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL2RwdTEvZHB1X2h3X2ludGYuYyAgICAgICAg fCAyOCArKysrKysrKwogZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL2RwdTEvZHB1X2h3X2ludGYu aCAgICAgICAgfCAgNiArKwogNyBmaWxlcyBjaGFuZ2VkLCAxNjEgaW5zZXJ0aW9ucygrKSwgNyBk ZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3AvZHB1MS9k cHVfZW5jb2Rlci5jIGIvZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL2RwdTEvZHB1X2VuY29kZXIu YwppbmRleCBkODJlYTk5Li45NmM0OGE4IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vbXNt L2Rpc3AvZHB1MS9kcHVfZW5jb2Rlci5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9tc20vZGlzcC9k cHUxL2RwdV9lbmNvZGVyLmMKQEAgLTU4LDcgKzU4LDcgQEAKIAogI2RlZmluZSBJRExFX1NIT1JU X1RJTUVPVVQJMQogCi0jZGVmaW5lIE1BWF9WRElTUExBWV9TUExJVCAxMDgwCisjZGVmaW5lIE1B WF9IRElTUExBWV9TUExJVCAxMDgwCiAKIC8qIHRpbWVvdXQgaW4gZnJhbWVzIHdhaXRpbmcgZm9y IGZyYW1lIGRvbmUgKi8KICNkZWZpbmUgRFBVX0VOQ09ERVJfRlJBTUVfRE9ORV9USU1FT1VUX0ZS QU1FUyA1CkBAIC01MzUsNyArNTM1LDcgQEAgc3RhdGljIHN0cnVjdCBtc21fZGlzcGxheV90b3Bv bG9neSBkcHVfZW5jb2Rlcl9nZXRfdG9wb2xvZ3koCiAJCQlpbnRmX2NvdW50Kys7CiAKIAkvKiBV c2VyIHNwbGl0IHRvcG9sb2d5IGZvciB3aWR0aCA+IDEwODAgKi8KLQl0b3BvbG9neS5udW1fbG0g PSAobW9kZS0+dmRpc3BsYXkgPiBNQVhfVkRJU1BMQVlfU1BMSVQpID8gMiA6IDE7CisJdG9wb2xv Z3kubnVtX2xtID0gKG1vZGUtPmhkaXNwbGF5ID4gTUFYX0hESVNQTEFZX1NQTElUKSA/IDIgOiAx OwogCXRvcG9sb2d5Lm51bV9lbmMgPSAwOwogCXRvcG9sb2d5Lm51bV9pbnRmID0gaW50Zl9jb3Vu dDsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL2RwdTEvZHB1X2VuY29k ZXJfcGh5c192aWQuYyBiL2RyaXZlcnMvZ3B1L2RybS9tc20vZGlzcC9kcHUxL2RwdV9lbmNvZGVy X3BoeXNfdmlkLmMKaW5kZXggYjljODRmYi4uOGNjOGFkMTIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMv Z3B1L2RybS9tc20vZGlzcC9kcHUxL2RwdV9lbmNvZGVyX3BoeXNfdmlkLmMKKysrIGIvZHJpdmVy cy9ncHUvZHJtL21zbS9kaXNwL2RwdTEvZHB1X2VuY29kZXJfcGh5c192aWQuYwpAQCAtMjgwLDYg KzI4MCwxNCBAQCBzdGF0aWMgdm9pZCBkcHVfZW5jb2Rlcl9waHlzX3ZpZF9zZXR1cF90aW1pbmdf ZW5naW5lKAogCXBoeXNfZW5jLT5od19pbnRmLT5vcHMuc2V0dXBfdGltaW5nX2dlbihwaHlzX2Vu Yy0+aHdfaW50ZiwKIAkJCSZ0aW1pbmdfcGFyYW1zLCBmbXQpOwogCXBoeXNfZW5jLT5od19jdGwt Pm9wcy5zZXR1cF9pbnRmX2NmZyhwaHlzX2VuYy0+aHdfY3RsLCAmaW50Zl9jZmcpOworCisJLyog c2V0dXAgd2hpY2ggcHAgYmxrIHdpbGwgY29ubmVjdCB0byB0aGlzIGludGYgKi8KKwlpZiAocGh5 c19lbmMtPmh3X2ludGYtPm9wcy5iaW5kX3Bpbmdwb25nX2JsaykKKwkJcGh5c19lbmMtPmh3X2lu dGYtPm9wcy5iaW5kX3Bpbmdwb25nX2JsaygKKwkJCQlwaHlzX2VuYy0+aHdfaW50ZiwKKwkJCQl0 cnVlLAorCQkJCXBoeXNfZW5jLT5od19wcC0+aWR4KTsKKwogCXNwaW5fdW5sb2NrX2lycXJlc3Rv cmUocGh5c19lbmMtPmVuY19zcGlubG9jaywgbG9ja19mbGFncyk7CiAKIAlwcm9ncmFtbWFibGVf ZmV0Y2hfY29uZmlnKHBoeXNfZW5jLCAmdGltaW5nX3BhcmFtcyk7CkBAIC00MzUsNiArNDQzLDcg QEAgc3RhdGljIHZvaWQgZHB1X2VuY29kZXJfcGh5c192aWRfZW5hYmxlKHN0cnVjdCBkcHVfZW5j b2Rlcl9waHlzICpwaHlzX2VuYykKIHsKIAlzdHJ1Y3QgZHB1X2h3X2N0bCAqY3RsOwogCXUzMiBm bHVzaF9tYXNrID0gMDsKKwl1MzIgaW50Zl9mbHVzaF9tYXNrID0gMDsKIAogCWN0bCA9IHBoeXNf ZW5jLT5od19jdGw7CiAKQEAgLTQ1OSwxMCArNDY4LDE4IEBAIHN0YXRpYyB2b2lkIGRwdV9lbmNv ZGVyX3BoeXNfdmlkX2VuYWJsZShzdHJ1Y3QgZHB1X2VuY29kZXJfcGh5cyAqcGh5c19lbmMpCiAJ Y3RsLT5vcHMuZ2V0X2JpdG1hc2tfaW50ZihjdGwsICZmbHVzaF9tYXNrLCBwaHlzX2VuYy0+aHdf aW50Zi0+aWR4KTsKIAljdGwtPm9wcy51cGRhdGVfcGVuZGluZ19mbHVzaChjdGwsIGZsdXNoX21h c2spOwogCisJaWYgKGN0bC0+b3BzLmdldF9iaXRtYXNrX2FjdGl2ZV9pbnRmKQorCQljdGwtPm9w cy5nZXRfYml0bWFza19hY3RpdmVfaW50ZihjdGwsICZpbnRmX2ZsdXNoX21hc2ssCisJCQlwaHlz X2VuYy0+aHdfaW50Zi0+aWR4KTsKKworCWlmIChjdGwtPm9wcy51cGRhdGVfcGVuZGluZ19pbnRm X2ZsdXNoKQorCQljdGwtPm9wcy51cGRhdGVfcGVuZGluZ19pbnRmX2ZsdXNoKGN0bCwgaW50Zl9m bHVzaF9tYXNrKTsKKwogc2tpcF9mbHVzaDoKIAlEUFVfREVCVUdfVklERU5DKHBoeXNfZW5jLAot CQkJICJ1cGRhdGUgcGVuZGluZyBmbHVzaCBjdGwgJWQgZmx1c2hfbWFzayAleFxuIiwKLQkJCSBj dGwtPmlkeCAtIENUTF8wLCBmbHVzaF9tYXNrKTsKKwkJInVwZGF0ZSBwZW5kaW5nIGZsdXNoIGN0 bCAlZCBmbHVzaF9tYXNrIDAleCBpbnRmX21hc2sgMHgleFxuIiwKKwkJY3RsLT5pZHggLSBDVExf MCwgZmx1c2hfbWFzaywgaW50Zl9mbHVzaF9tYXNrKTsKKwogCiAJLyogY3RsX2ZsdXNoICYgdGlt aW5nIGVuZ2luZSBlbmFibGUgd2lsbCBiZSB0cmlnZ2VyZWQgYnkgZnJhbWV3b3JrICovCiAJaWYg KHBoeXNfZW5jLT5lbmFibGVfc3RhdGUgPT0gRFBVX0VOQ19ESVNBQkxFRCkKZGlmZiAtLWdpdCBh L2RyaXZlcnMvZ3B1L2RybS9tc20vZGlzcC9kcHUxL2RwdV9od19jYXRhbG9nLmMgYi9kcml2ZXJz L2dwdS9kcm0vbXNtL2Rpc3AvZHB1MS9kcHVfaHdfY2F0YWxvZy5jCmluZGV4IDFkMmVhOTMuLjFm MmFjNmUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9tc20vZGlzcC9kcHUxL2RwdV9od19j YXRhbG9nLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL2RwdTEvZHB1X2h3X2NhdGFs b2cuYwpAQCAtMzc0LDYgKzM3NCw3IEBACiAJe1wKIAkubmFtZSA9IF9uYW1lLCAuaWQgPSBfaWQs IFwKIAkuYmFzZSA9IF9iYXNlLCAubGVuID0gMHgyODAsIFwKKwkuZmVhdHVyZXMgPSBCSVQoRFBV X0NUTF9BQ1RJVkVfQ0ZHKSwgXAogCS50eXBlID0gX3R5cGUsIFwKIAkuY29udHJvbGxlcl9pZCA9 IF9jdHJsX2lkLCBcCiAJLnByb2dfZmV0Y2hfbGluZXNfd29yc3RfY2FzZSA9IDI0IFwKZGlmZiAt LWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9tc20vZGlzcC9kcHUxL2RwdV9od19jdGwuYyBiL2RyaXZl cnMvZ3B1L2RybS9tc20vZGlzcC9kcHUxL2RwdV9od19jdGwuYwppbmRleCAxNzllOGQ1Li4yY2U0 YjVhIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3AvZHB1MS9kcHVfaHdfY3Rs LmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL2RwdTEvZHB1X2h3X2N0bC5jCkBAIC0y MiwxMSArMjIsMTUgQEAKICNkZWZpbmUgICBDVExfUFJFUEFSRSAgICAgICAgICAgICAgICAgICAw eDBkMAogI2RlZmluZSAgIENUTF9TV19SRVNFVCAgICAgICAgICAgICAgICAgIDB4MDMwCiAjZGVm aW5lICAgQ1RMX0xBWUVSX0VYVE5fT0ZGU0VUICAgICAgICAgMHg0MAorI2RlZmluZSAgIENUTF9J TlRGX0FDVElWRSAgICAgICAgICAgICAgIDB4MEY0CisjZGVmaW5lICAgQ1RMX0lOVEZfRkxVU0gg ICAgICAgICAgICAgICAgMHgxMTAKKyNkZWZpbmUgICBDVExfSU5URl9NQVNURVIgICAgICAgICAg ICAgICAweDEzNAogCiAjZGVmaW5lIENUTF9NSVhFUl9CT1JERVJfT1VUICAgICAgICAgICAgQklU KDI0KQogI2RlZmluZSBDVExfRkxVU0hfTUFTS19DVEwgICAgICAgICAgICAgIEJJVCgxNykKIAog I2RlZmluZSBEUFVfUkVHX1JFU0VUX1RJTUVPVVRfVVMgICAgICAgIDIwMDAKKyNkZWZpbmUgIElO VEZfSURYICAgICAgIDMxCiAKIHN0YXRpYyBzdHJ1Y3QgZHB1X2N0bF9jZmcgKl9jdGxfb2Zmc2V0 KGVudW0gZHB1X2N0bCBjdGwsCiAJCXN0cnVjdCBkcHVfbWRzc19jZmcgKm0sCkBAIC0xMDAsMTEg KzEwNCwyNyBAQCBzdGF0aWMgaW5saW5lIHZvaWQgZHB1X2h3X2N0bF91cGRhdGVfcGVuZGluZ19m bHVzaChzdHJ1Y3QgZHB1X2h3X2N0bCAqY3R4LAogCWN0eC0+cGVuZGluZ19mbHVzaF9tYXNrIHw9 IGZsdXNoYml0czsKIH0KIAorc3RhdGljIGlubGluZSB2b2lkIGRwdV9od19jdGxfdXBkYXRlX3Bl bmRpbmdfaW50Zl9mbHVzaChzdHJ1Y3QgZHB1X2h3X2N0bCAqY3R4LAorCQl1MzIgZmx1c2hiaXRz KQoreworCWN0eC0+cGVuZGluZ19pbnRmX2ZsdXNoX21hc2sgfD0gZmx1c2hiaXRzOworfQorCiBz dGF0aWMgdTMyIGRwdV9od19jdGxfZ2V0X3BlbmRpbmdfZmx1c2goc3RydWN0IGRwdV9od19jdGwg KmN0eCkKIHsKIAlyZXR1cm4gY3R4LT5wZW5kaW5nX2ZsdXNoX21hc2s7CiB9CiAKK3N0YXRpYyBp bmxpbmUgdm9pZCBkcHVfaHdfY3RsX3RyaWdnZXJfZmx1c2hfdjEoc3RydWN0IGRwdV9od19jdGwg KmN0eCkKK3sKKworCWlmIChjdHgtPnBlbmRpbmdfZmx1c2hfbWFzayAmIEJJVChJTlRGX0lEWCkp CisJCURQVV9SRUdfV1JJVEUoJmN0eC0+aHcsIENUTF9JTlRGX0ZMVVNILAorCQkJCWN0eC0+cGVu ZGluZ19pbnRmX2ZsdXNoX21hc2spOworCisJRFBVX1JFR19XUklURSgmY3R4LT5odywgQ1RMX0ZM VVNILCBjdHgtPnBlbmRpbmdfZmx1c2hfbWFzayk7Cit9CisKIHN0YXRpYyBpbmxpbmUgdm9pZCBk cHVfaHdfY3RsX3RyaWdnZXJfZmx1c2goc3RydWN0IGRwdV9od19jdGwgKmN0eCkKIHsKIAl0cmFj ZV9kcHVfaHdfY3RsX3RyaWdnZXJfcGVuZGluZ19mbHVzaChjdHgtPnBlbmRpbmdfZmx1c2hfbWFz aywKQEAgLTIyMiw2ICsyNDIsMzYgQEAgc3RhdGljIGludCBkcHVfaHdfY3RsX2dldF9iaXRtYXNr X2ludGYoc3RydWN0IGRwdV9od19jdGwgKmN0eCwKIAlyZXR1cm4gMDsKIH0KIAorc3RhdGljIGlu dCBkcHVfaHdfY3RsX2dldF9iaXRtYXNrX2ludGZfdjEoc3RydWN0IGRwdV9od19jdGwgKmN0eCwK KwkJdTMyICpmbHVzaGJpdHMsIGVudW0gZHB1X2ludGYgaW50ZikKK3sKKwlzd2l0Y2ggKGludGYp IHsKKwljYXNlIElOVEZfMDoKKwljYXNlIElOVEZfMToKKwkJKmZsdXNoYml0cyB8PSBCSVQoMzEp OworCQlicmVhazsKKwlkZWZhdWx0OgorCQlyZXR1cm4gMDsKKwl9CisJcmV0dXJuIDA7Cit9CisK K3N0YXRpYyBpbnQgZHB1X2h3X2N0bF9hY3RpdmVfZ2V0X2JpdG1hc2tfaW50ZihzdHJ1Y3QgZHB1 X2h3X2N0bCAqY3R4LAorCQl1MzIgKmZsdXNoYml0cywgZW51bSBkcHVfaW50ZiBpbnRmKQorewor CXN3aXRjaCAoaW50ZikgeworCWNhc2UgSU5URl8wOgorCQkqZmx1c2hiaXRzIHw9IEJJVCgwKTsK KwkJYnJlYWs7CisJY2FzZSBJTlRGXzE6CisJCSpmbHVzaGJpdHMgfD0gQklUKDEpOworCQlicmVh azsKKwlkZWZhdWx0OgorCQlyZXR1cm4gMDsKKwl9CisJcmV0dXJuIDA7Cit9CisKIHN0YXRpYyB1 MzIgZHB1X2h3X2N0bF9wb2xsX3Jlc2V0X3N0YXR1cyhzdHJ1Y3QgZHB1X2h3X2N0bCAqY3R4LCB1 MzIgdGltZW91dF91cykKIHsKIAlzdHJ1Y3QgZHB1X2h3X2Jsa19yZWdfbWFwICpjID0gJmN0eC0+ aHc7CkBAIC00MjIsNiArNDcyLDI0IEBAIHN0YXRpYyB2b2lkIGRwdV9od19jdGxfc2V0dXBfYmxl bmRzdGFnZShzdHJ1Y3QgZHB1X2h3X2N0bCAqY3R4LAogCURQVV9SRUdfV1JJVEUoYywgQ1RMX0xB WUVSX0VYVDMobG0pLCBtaXhlcmNmZ19leHQzKTsKIH0KIAorCitzdGF0aWMgdm9pZCBkcHVfaHdf Y3RsX2ludGZfY2ZnX3YxKHN0cnVjdCBkcHVfaHdfY3RsICpjdHgsCisJCXN0cnVjdCBkcHVfaHdf aW50Zl9jZmcgKmNmZykKK3sKKwlzdHJ1Y3QgZHB1X2h3X2Jsa19yZWdfbWFwICpjID0gJmN0eC0+ aHc7CisJdTMyIGludGZfYWN0aXZlID0gMDsKKwl1MzIgbW9kZV9zZWwgPSAwOworCisJaWYgKGNm Zy0+aW50Zl9tb2RlX3NlbCA9PSBEUFVfQ1RMX01PREVfU0VMX0NNRCkKKwkJbW9kZV9zZWwgfD0g QklUKDE3KTsKKworCWludGZfYWN0aXZlID0gRFBVX1JFR19SRUFEKGMsIENUTF9JTlRGX0FDVElW RSk7CisJaW50Zl9hY3RpdmUgfD0gQklUKGNmZy0+aW50ZiAtIElOVEZfMCk7CisKKwlEUFVfUkVH X1dSSVRFKGMsIENUTF9UT1AsIG1vZGVfc2VsKTsKKwlEUFVfUkVHX1dSSVRFKGMsIENUTF9JTlRG X0FDVElWRSwgaW50Zl9hY3RpdmUpOworfQorCiBzdGF0aWMgdm9pZCBkcHVfaHdfY3RsX2ludGZf Y2ZnKHN0cnVjdCBkcHVfaHdfY3RsICpjdHgsCiAJCXN0cnVjdCBkcHVfaHdfaW50Zl9jZmcgKmNm ZykKIHsKQEAgLTQ1NSwyMSArNTIzLDMxIEBAIHN0YXRpYyB2b2lkIGRwdV9od19jdGxfaW50Zl9j Zmcoc3RydWN0IGRwdV9od19jdGwgKmN0eCwKIHN0YXRpYyB2b2lkIF9zZXR1cF9jdGxfb3BzKHN0 cnVjdCBkcHVfaHdfY3RsX29wcyAqb3BzLAogCQl1bnNpZ25lZCBsb25nIGNhcCkKIHsKKwlpZiAo Y2FwICYgQklUKERQVV9DVExfQUNUSVZFX0NGRykpIHsKKwkJb3BzLT50cmlnZ2VyX2ZsdXNoID0g ZHB1X2h3X2N0bF90cmlnZ2VyX2ZsdXNoX3YxOworCQlvcHMtPnNldHVwX2ludGZfY2ZnID0gZHB1 X2h3X2N0bF9pbnRmX2NmZ192MTsKKwkJb3BzLT5nZXRfYml0bWFza19pbnRmID0gZHB1X2h3X2N0 bF9nZXRfYml0bWFza19pbnRmX3YxOworCQlvcHMtPmdldF9iaXRtYXNrX2FjdGl2ZV9pbnRmID0K KwkJCWRwdV9od19jdGxfYWN0aXZlX2dldF9iaXRtYXNrX2ludGY7CisJCW9wcy0+dXBkYXRlX3Bl bmRpbmdfaW50Zl9mbHVzaCA9CisJCQlkcHVfaHdfY3RsX3VwZGF0ZV9wZW5kaW5nX2ludGZfZmx1 c2g7CisJfSBlbHNlIHsKKwkJb3BzLT50cmlnZ2VyX2ZsdXNoID0gZHB1X2h3X2N0bF90cmlnZ2Vy X2ZsdXNoOworCQlvcHMtPnNldHVwX2ludGZfY2ZnID0gZHB1X2h3X2N0bF9pbnRmX2NmZzsKKwkJ b3BzLT5nZXRfYml0bWFza19pbnRmID0gZHB1X2h3X2N0bF9nZXRfYml0bWFza19pbnRmOworCX0K IAlvcHMtPmNsZWFyX3BlbmRpbmdfZmx1c2ggPSBkcHVfaHdfY3RsX2NsZWFyX3BlbmRpbmdfZmx1 c2g7CiAJb3BzLT51cGRhdGVfcGVuZGluZ19mbHVzaCA9IGRwdV9od19jdGxfdXBkYXRlX3BlbmRp bmdfZmx1c2g7CiAJb3BzLT5nZXRfcGVuZGluZ19mbHVzaCA9IGRwdV9od19jdGxfZ2V0X3BlbmRp bmdfZmx1c2g7Ci0Jb3BzLT50cmlnZ2VyX2ZsdXNoID0gZHB1X2h3X2N0bF90cmlnZ2VyX2ZsdXNo OwogCW9wcy0+Z2V0X2ZsdXNoX3JlZ2lzdGVyID0gZHB1X2h3X2N0bF9nZXRfZmx1c2hfcmVnaXN0 ZXI7CiAJb3BzLT50cmlnZ2VyX3N0YXJ0ID0gZHB1X2h3X2N0bF90cmlnZ2VyX3N0YXJ0OwogCW9w cy0+dHJpZ2dlcl9wZW5kaW5nID0gZHB1X2h3X2N0bF90cmlnZ2VyX3BlbmRpbmc7Ci0Jb3BzLT5z ZXR1cF9pbnRmX2NmZyA9IGRwdV9od19jdGxfaW50Zl9jZmc7CiAJb3BzLT5yZXNldCA9IGRwdV9o d19jdGxfcmVzZXRfY29udHJvbDsKIAlvcHMtPndhaXRfcmVzZXRfc3RhdHVzID0gZHB1X2h3X2N0 bF93YWl0X3Jlc2V0X3N0YXR1czsKIAlvcHMtPmNsZWFyX2FsbF9ibGVuZHN0YWdlcyA9IGRwdV9o d19jdGxfY2xlYXJfYWxsX2JsZW5kc3RhZ2VzOwogCW9wcy0+c2V0dXBfYmxlbmRzdGFnZSA9IGRw dV9od19jdGxfc2V0dXBfYmxlbmRzdGFnZTsKIAlvcHMtPmdldF9iaXRtYXNrX3NzcHAgPSBkcHVf aHdfY3RsX2dldF9iaXRtYXNrX3NzcHA7CiAJb3BzLT5nZXRfYml0bWFza19taXhlciA9IGRwdV9o d19jdGxfZ2V0X2JpdG1hc2tfbWl4ZXI7Ci0Jb3BzLT5nZXRfYml0bWFza19pbnRmID0gZHB1X2h3 X2N0bF9nZXRfYml0bWFza19pbnRmOwogfTsKIAogc3RhdGljIHN0cnVjdCBkcHVfaHdfYmxrX29w cyBkcHVfaHdfb3BzOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL2RwdTEv ZHB1X2h3X2N0bC5oIGIvZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL2RwdTEvZHB1X2h3X2N0bC5o CmluZGV4IGQzYWU5MzkuLjFlMzk3M2MgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9tc20v ZGlzcC9kcHUxL2RwdV9od19jdGwuaAorKysgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3AvZHB1 MS9kcHVfaHdfY3RsLmgKQEAgLTkxLDYgKzkxLDE1IEBAIHN0cnVjdCBkcHVfaHdfY3RsX29wcyB7 CiAJCXUzMiBmbHVzaGJpdHMpOwogCiAJLyoqCisJICogT1IgaW4gdGhlIGdpdmVuIGZsdXNoYml0 cyB0byB0aGUgY2FjaGVkIHBlbmRpbmdfaW50Zl9mbHVzaF9tYXNrCisJICogTm8gZWZmZWN0IG9u IGhhcmR3YXJlCisJICogQGN0eCAgICAgICA6IGN0bCBwYXRoIGN0eCBwb2ludGVyCisJICogQGZs dXNoYml0cyA6IG1vZHVsZSBmbHVzaG1hc2sKKwkgKi8KKwl2b2lkICgqdXBkYXRlX3BlbmRpbmdf aW50Zl9mbHVzaCkoc3RydWN0IGRwdV9od19jdGwgKmN0eCwKKwkJdTMyIGZsdXNoYml0cyk7CisK KwkvKioKIAkgKiBXcml0ZSB0aGUgdmFsdWUgb2YgdGhlIHBlbmRpbmdfZmx1c2hfbWFzayB0byBo YXJkd2FyZQogCSAqIEBjdHggICAgICAgOiBjdGwgcGF0aCBjdHggcG9pbnRlcgogCSAqLwpAQCAt MTMwLDExICsxMzksMjQgQEAgc3RydWN0IGRwdV9od19jdGxfb3BzIHsKIAl1aW50MzJfdCAoKmdl dF9iaXRtYXNrX21peGVyKShzdHJ1Y3QgZHB1X2h3X2N0bCAqY3R4LAogCQllbnVtIGRwdV9sbSBi bGspOwogCisJLyoqCisJICogUXVlcnkgdGhlIHZhbHVlIG9mIHRoZSBpbnRmIGZsdXNoIG1hc2sK KwkgKiBObyBlZmZlY3Qgb24gaGFyZHdhcmUKKwkgKiBAY3R4ICAgICAgIDogY3RsIHBhdGggY3R4 IHBvaW50ZXIKKwkgKi8KIAlpbnQgKCpnZXRfYml0bWFza19pbnRmKShzdHJ1Y3QgZHB1X2h3X2N0 bCAqY3R4LAogCQl1MzIgKmZsdXNoYml0cywKIAkJZW51bSBkcHVfaW50ZiBibGspOwogCiAJLyoq CisJICogUXVlcnkgdGhlIHZhbHVlIG9mIHRoZSBpbnRmIGFjdGl2ZSBmbHVzaCBtYXNrCisJICog Tm8gZWZmZWN0IG9uIGhhcmR3YXJlCisJICogQGN0eCAgICAgICA6IGN0bCBwYXRoIGN0eCBwb2lu dGVyCisJICovCisJaW50ICgqZ2V0X2JpdG1hc2tfYWN0aXZlX2ludGYpKHN0cnVjdCBkcHVfaHdf Y3RsICpjdHgsCisJCXUzMiAqZmx1c2hiaXRzLCBlbnVtIGRwdV9pbnRmIGJsayk7CisKKwkvKioK IAkgKiBTZXQgYWxsIGJsZW5kIHN0YWdlcyB0byBkaXNhYmxlZAogCSAqIEBjdHggICAgICAgOiBj dGwgcGF0aCBjdHggcG9pbnRlcgogCSAqLwpAQCAtMTU5LDYgKzE4MSw3IEBAIHN0cnVjdCBkcHVf aHdfY3RsX29wcyB7CiAgKiBAbWl4ZXJfY291bnQ6IG51bWJlciBvZiBtaXhlcnMKICAqIEBtaXhl cl9od19jYXBzOiBtaXhlciBoYXJkd2FyZSBjYXBhYmlsaXRpZXMKICAqIEBwZW5kaW5nX2ZsdXNo X21hc2s6IHN0b3JhZ2UgZm9yIHBlbmRpbmcgY3RsX2ZsdXNoIG1hbmFnZWQgdmlhIG9wcworICog QHBlbmRpbmdfaW50Zl9mbHVzaF9tYXNrOiBwZW5kaW5nIElOVEYgZmx1c2gKICAqIEBvcHM6IG9w ZXJhdGlvbiBsaXN0CiAgKi8KIHN0cnVjdCBkcHVfaHdfY3RsIHsKQEAgLTE3MSw2ICsxOTQsNyBA QCBzdHJ1Y3QgZHB1X2h3X2N0bCB7CiAJaW50IG1peGVyX2NvdW50OwogCWNvbnN0IHN0cnVjdCBk cHVfbG1fY2ZnICptaXhlcl9od19jYXBzOwogCXUzMiBwZW5kaW5nX2ZsdXNoX21hc2s7CisJdTMy IHBlbmRpbmdfaW50Zl9mbHVzaF9tYXNrOwogCiAJLyogb3BzICovCiAJc3RydWN0IGRwdV9od19j dGxfb3BzIG9wczsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9tc20vZGlzcC9kcHUxL2Rw dV9od19pbnRmLmMgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3AvZHB1MS9kcHVfaHdfaW50Zi5j CmluZGV4IGRjZDg3Y2QuLmVmZjVlNmEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9tc20v ZGlzcC9kcHUxL2RwdV9od19pbnRmLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL2Rw dTEvZHB1X2h3X2ludGYuYwpAQCAtNTYsNiArNTYsOCBAQAogI2RlZmluZSAgIElOVEZfRlJBTUVf Q09VTlQgICAgICAgICAgICAgIDB4MEFDCiAjZGVmaW5lICAgSU5URl9MSU5FX0NPVU5UICAgICAg ICAgICAgICAgMHgwQjAKIAorI2RlZmluZSAgIElOVEZfTVVYICAgICAgICAgICAgICAgICAgICAg IDB4MjVDCisKIHN0YXRpYyBzdHJ1Y3QgZHB1X2ludGZfY2ZnICpfaW50Zl9vZmZzZXQoZW51bSBk cHVfaW50ZiBpbnRmLAogCQlzdHJ1Y3QgZHB1X21kc3NfY2ZnICptLAogCQl2b2lkIF9faW9tZW0g KmFkZHIsCkBAIC0yMTgsNiArMjIwLDMwIEBAIHN0YXRpYyB2b2lkIGRwdV9od19pbnRmX3NldHVw X3ByZ19mZXRjaCgKIAlEUFVfUkVHX1dSSVRFKGMsIElOVEZfQ09ORklHLCBmZXRjaF9lbmFibGUp OwogfQogCitzdGF0aWMgdm9pZCBkcHVfaHdfaW50Zl9iaW5kX3Bpbmdwb25nX2JsaygKKwkJc3Ry dWN0IGRwdV9od19pbnRmICppbnRmLAorCQlib29sIGVuYWJsZSwKKwkJY29uc3QgZW51bSBkcHVf cGluZ3BvbmcgcHApCit7CisJc3RydWN0IGRwdV9od19ibGtfcmVnX21hcCAqYzsKKwl1MzIgbXV4 X2NmZzsKKworCWlmICghaW50ZikKKwkJcmV0dXJuOworCisJYyA9ICZpbnRmLT5odzsKKworCW11 eF9jZmcgPSBEUFVfUkVHX1JFQUQoYywgSU5URl9NVVgpOworCW11eF9jZmcgJj0gfjB4ZjsKKwor CWlmIChlbmFibGUpCisJCW11eF9jZmcgfD0gKHBwIC0gUElOR1BPTkdfMCkgJiAweDc7CisJZWxz ZQorCQltdXhfY2ZnIHw9IDB4ZjsKKworCURQVV9SRUdfV1JJVEUoYywgSU5URl9NVVgsIG11eF9j ZmcpOworfQorCiBzdGF0aWMgdm9pZCBkcHVfaHdfaW50Zl9nZXRfc3RhdHVzKAogCQlzdHJ1Y3Qg ZHB1X2h3X2ludGYgKmludGYsCiAJCXN0cnVjdCBpbnRmX3N0YXR1cyAqcykKQEAgLTI1NCw2ICsy ODAsOCBAQCBzdGF0aWMgdm9pZCBfc2V0dXBfaW50Zl9vcHMoc3RydWN0IGRwdV9od19pbnRmX29w cyAqb3BzLAogCW9wcy0+Z2V0X3N0YXR1cyA9IGRwdV9od19pbnRmX2dldF9zdGF0dXM7CiAJb3Bz LT5lbmFibGVfdGltaW5nID0gZHB1X2h3X2ludGZfZW5hYmxlX3RpbWluZ19lbmdpbmU7CiAJb3Bz LT5nZXRfbGluZV9jb3VudCA9IGRwdV9od19pbnRmX2dldF9saW5lX2NvdW50OworCWlmIChjYXAg JiBCSVQoRFBVX0NUTF9BQ1RJVkVfQ0ZHKSkKKwkJb3BzLT5iaW5kX3Bpbmdwb25nX2JsayA9IGRw dV9od19pbnRmX2JpbmRfcGluZ3BvbmdfYmxrOwogfQogCiBzdGF0aWMgc3RydWN0IGRwdV9od19i bGtfb3BzIGRwdV9od19vcHM7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3Av ZHB1MS9kcHVfaHdfaW50Zi5oIGIvZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL2RwdTEvZHB1X2h3 X2ludGYuaAppbmRleCBiMDNhY2MyLi5hMWUwZWYzIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9k cm0vbXNtL2Rpc3AvZHB1MS9kcHVfaHdfaW50Zi5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9tc20v ZGlzcC9kcHUxL2RwdV9od19pbnRmLmgKQEAgLTUyLDYgKzUyLDggQEAgc3RydWN0IGludGZfc3Rh dHVzIHsKICAqIEAgZW5hYmxlX3RpbWluZzogZW5hYmxlL2Rpc2FibGUgdGltaW5nIGVuZ2luZQog ICogQCBnZXRfc3RhdHVzOiByZXR1cm5zIGlmIHRpbWluZyBlbmdpbmUgaXMgZW5hYmxlZCBvciBu b3QKICAqIEAgZ2V0X2xpbmVfY291bnQ6IHJlYWRzIGN1cnJlbnQgdmVydGljYWwgbGluZSBjb3Vu dGVyCisgKiBAYmluZF9waW5ncG9uZ19ibGs6IGVuYWJsZS9kaXNhYmxlIHRoZSBjb25uZWN0aW9u IHdpdGggcGluZ3Bvbmcgd2hpY2ggd2lsbAorICogICAgICAgICAgICAgICAgICAgICBmZWVkIHBp eGVscyB0byB0aGlzIGludGVyZmFjZQogICovCiBzdHJ1Y3QgZHB1X2h3X2ludGZfb3BzIHsKIAl2 b2lkICgqc2V0dXBfdGltaW5nX2dlbikoc3RydWN0IGRwdV9od19pbnRmICppbnRmLApAQCAtNjgs NiArNzAsMTAgQEAgc3RydWN0IGRwdV9od19pbnRmX29wcyB7CiAJCQlzdHJ1Y3QgaW50Zl9zdGF0 dXMgKnN0YXR1cyk7CiAKIAl1MzIgKCpnZXRfbGluZV9jb3VudCkoc3RydWN0IGRwdV9od19pbnRm ICppbnRmKTsKKworCXZvaWQgKCpiaW5kX3Bpbmdwb25nX2Jsaykoc3RydWN0IGRwdV9od19pbnRm ICppbnRmLAorCQkJYm9vbCBlbmFibGUsCisJCQljb25zdCBlbnVtIGRwdV9waW5ncG9uZyBwcCk7 CiB9OwogCiBzdHJ1Y3QgZHB1X2h3X2ludGYgewotLSAKMS45LjEKCl9fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJp LWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9y Zy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZlbA==