From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-16.8 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 565FCC43461 for ; Thu, 6 May 2021 19:00:01 +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 1539261001 for ; Thu, 6 May 2021 19:00:01 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 1539261001 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=intel.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=dri-devel-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id B02A86EDF2; Thu, 6 May 2021 18:57:43 +0000 (UTC) Received: from mga14.intel.com (mga14.intel.com [192.55.52.115]) by gabe.freedesktop.org (Postfix) with ESMTPS id 348BC6ED64; Thu, 6 May 2021 18:57:14 +0000 (UTC) IronPort-SDR: 9a/caSm+OR5Phqywdyl1rfcEw7fW7Eke4fKAcGPJQatDJoSCqsTHRyjM1OeYE4gJAPj3W2VIOx 1/uURYSxNhwA== X-IronPort-AV: E=McAfee;i="6200,9189,9976"; a="198195459" X-IronPort-AV: E=Sophos;i="5.82,278,1613462400"; d="scan'208";a="198195459" Received: from orsmga001.jf.intel.com ([10.7.209.18]) by fmsmga103.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 06 May 2021 11:57:13 -0700 IronPort-SDR: /+C/Va8twf2OO9wblpJRSDDZNIG++em/5lrNS7K1Vy9AQtkWSgGzKMRpAFeBj7wjlsqtyt824e B4ajBqleD9vA== X-IronPort-AV: E=Sophos;i="5.82,278,1613462400"; d="scan'208";a="469583591" Received: from dhiatt-server.jf.intel.com ([10.54.81.3]) by orsmga001-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 06 May 2021 11:57:12 -0700 From: Matthew Brost To: , Subject: [RFC PATCH 71/97] drm/i915/guc: Provide mmio list to be saved/restored on engine reset Date: Thu, 6 May 2021 12:14:25 -0700 Message-Id: <20210506191451.77768-72-matthew.brost@intel.com> X-Mailer: git-send-email 2.28.0 In-Reply-To: <20210506191451.77768-1-matthew.brost@intel.com> References: <20210506191451.77768-1-matthew.brost@intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 8bit X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: matthew.brost@intel.com, tvrtko.ursulin@intel.com, daniele.ceraolospurio@intel.com, jason.ekstrand@intel.com, jon.bloomfield@intel.com, daniel.vetter@intel.com, john.c.harrison@intel.com Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" From: John Harrison The driver must provide GuC with a list of mmio registers that should be saved/restored during a GuC-based engine reset. Unfortunately, the list must be dynamically allocated as its size is variable. That means the driver must generate the list twice - once to work out the size and a second time to actually save it. Signed-off-by: John Harrison Signed-off-by: Fernando Pacheco Signed-off-by: Matthew Brost Cc: Daniele Ceraolo Spurio Cc: Tvrtko Ursulin --- drivers/gpu/drm/i915/gt/intel_workarounds.c | 46 ++-- .../gpu/drm/i915/gt/intel_workarounds_types.h | 1 + drivers/gpu/drm/i915/gt/uc/intel_guc.h | 1 + drivers/gpu/drm/i915/gt/uc/intel_guc_ads.c | 199 +++++++++++++++++- drivers/gpu/drm/i915/i915_reg.h | 1 + 5 files changed, 222 insertions(+), 26 deletions(-) diff --git a/drivers/gpu/drm/i915/gt/intel_workarounds.c b/drivers/gpu/drm/i915/gt/intel_workarounds.c index 5a03a76bb9e2..05d21476d140 100644 --- a/drivers/gpu/drm/i915/gt/intel_workarounds.c +++ b/drivers/gpu/drm/i915/gt/intel_workarounds.c @@ -150,13 +150,14 @@ static void _wa_add(struct i915_wa_list *wal, const struct i915_wa *wa) } static void wa_add(struct i915_wa_list *wal, i915_reg_t reg, - u32 clear, u32 set, u32 read_mask) + u32 clear, u32 set, u32 read_mask, bool masked_reg) { struct i915_wa wa = { .reg = reg, .clr = clear, .set = set, .read = read_mask, + .masked_reg = masked_reg, }; _wa_add(wal, &wa); @@ -165,7 +166,7 @@ static void wa_add(struct i915_wa_list *wal, i915_reg_t reg, static void wa_write_clr_set(struct i915_wa_list *wal, i915_reg_t reg, u32 clear, u32 set) { - wa_add(wal, reg, clear, set, clear); + wa_add(wal, reg, clear, set, clear, false); } static void @@ -200,20 +201,20 @@ wa_write_clr(struct i915_wa_list *wal, i915_reg_t reg, u32 clr) static void wa_masked_en(struct i915_wa_list *wal, i915_reg_t reg, u32 val) { - wa_add(wal, reg, 0, _MASKED_BIT_ENABLE(val), val); + wa_add(wal, reg, 0, _MASKED_BIT_ENABLE(val), val, true); } static void wa_masked_dis(struct i915_wa_list *wal, i915_reg_t reg, u32 val) { - wa_add(wal, reg, 0, _MASKED_BIT_DISABLE(val), val); + wa_add(wal, reg, 0, _MASKED_BIT_DISABLE(val), val, true); } static void wa_masked_field_set(struct i915_wa_list *wal, i915_reg_t reg, u32 mask, u32 val) { - wa_add(wal, reg, 0, _MASKED_FIELD(mask, val), mask); + wa_add(wal, reg, 0, _MASKED_FIELD(mask, val), mask, true); } static void gen6_ctx_workarounds_init(struct intel_engine_cs *engine, @@ -583,10 +584,10 @@ static void icl_ctx_workarounds_init(struct intel_engine_cs *engine, GEN11_BLEND_EMB_FIX_DISABLE_IN_RCC); /* WaEnableFloatBlendOptimization:icl */ - wa_write_clr_set(wal, - GEN10_CACHE_MODE_SS, - 0, /* write-only, so skip validation */ - _MASKED_BIT_ENABLE(FLOAT_BLEND_OPTIMIZATION_ENABLE)); + wa_add(wal, GEN10_CACHE_MODE_SS, 0, + _MASKED_BIT_ENABLE(FLOAT_BLEND_OPTIMIZATION_ENABLE), + 0 /* write-only, so skip validation */, + true); /* WaDisableGPGPUMidThreadPreemption:icl */ wa_masked_field_set(wal, GEN8_CS_CHICKEN1, @@ -631,7 +632,7 @@ static void gen12_ctx_gt_tuning_init(struct intel_engine_cs *engine, FF_MODE2, FF_MODE2_TDS_TIMER_MASK, FF_MODE2_TDS_TIMER_128, - 0); + 0, false); } static void gen12_ctx_workarounds_init(struct intel_engine_cs *engine, @@ -668,7 +669,7 @@ static void gen12_ctx_workarounds_init(struct intel_engine_cs *engine, FF_MODE2, FF_MODE2_GS_TIMER_MASK, FF_MODE2_GS_TIMER_224, - 0); + 0, false); } static void dg1_ctx_workarounds_init(struct intel_engine_cs *engine, @@ -839,7 +840,7 @@ hsw_gt_workarounds_init(struct drm_i915_private *i915, struct i915_wa_list *wal) wa_add(wal, HSW_ROW_CHICKEN3, 0, _MASKED_BIT_ENABLE(HSW_ROW_CHICKEN3_L3_GLOBAL_ATOMICS_DISABLE), - 0 /* XXX does this reg exist? */); + 0 /* XXX does this reg exist? */, true); /* WaVSRefCountFullforceMissDisable:hsw */ wa_write_clr(wal, GEN7_FF_THREAD_MODE, GEN7_FF_VS_REF_CNT_FFME); @@ -1950,10 +1951,10 @@ rcs_engine_wa_init(struct intel_engine_cs *engine, struct i915_wa_list *wal) * disable bit, which we don't touch here, but it's good * to keep in mind (see 3DSTATE_PS and 3DSTATE_WM). */ - wa_add(wal, GEN7_GT_MODE, 0, - _MASKED_FIELD(GEN6_WIZ_HASHING_MASK, - GEN6_WIZ_HASHING_16x4), - GEN6_WIZ_HASHING_16x4); + wa_masked_field_set(wal, + GEN7_GT_MODE, + GEN6_WIZ_HASHING_MASK, + GEN6_WIZ_HASHING_16x4); } if (IS_GEN_RANGE(i915, 6, 7)) @@ -2003,10 +2004,10 @@ rcs_engine_wa_init(struct intel_engine_cs *engine, struct i915_wa_list *wal) * disable bit, which we don't touch here, but it's good * to keep in mind (see 3DSTATE_PS and 3DSTATE_WM). */ - wa_add(wal, - GEN6_GT_MODE, 0, - _MASKED_FIELD(GEN6_WIZ_HASHING_MASK, GEN6_WIZ_HASHING_16x4), - GEN6_WIZ_HASHING_16x4); + wa_masked_field_set(wal, + GEN7_GT_MODE, + GEN6_WIZ_HASHING_MASK, + GEN6_WIZ_HASHING_16x4); /* WaDisable_RenderCache_OperationalFlush:snb */ wa_masked_dis(wal, CACHE_MODE_0, RC_OP_FLUSH_ENABLE); @@ -2027,7 +2028,7 @@ rcs_engine_wa_init(struct intel_engine_cs *engine, struct i915_wa_list *wal) wa_add(wal, MI_MODE, 0, _MASKED_BIT_ENABLE(VS_TIMER_DISPATCH), /* XXX bit doesn't stick on Broadwater */ - IS_I965G(i915) ? 0 : VS_TIMER_DISPATCH); + IS_I965G(i915) ? 0 : VS_TIMER_DISPATCH, true); if (IS_GEN(i915, 4)) /* @@ -2042,7 +2043,8 @@ rcs_engine_wa_init(struct intel_engine_cs *engine, struct i915_wa_list *wal) */ wa_add(wal, ECOSKPD, 0, _MASKED_BIT_ENABLE(ECO_CONSTANT_BUFFER_SR_DISABLE), - 0 /* XXX bit doesn't stick on Broadwater */); + 0 /* XXX bit doesn't stick on Broadwater */, + true); } static void diff --git a/drivers/gpu/drm/i915/gt/intel_workarounds_types.h b/drivers/gpu/drm/i915/gt/intel_workarounds_types.h index c214111ea367..1e873681795d 100644 --- a/drivers/gpu/drm/i915/gt/intel_workarounds_types.h +++ b/drivers/gpu/drm/i915/gt/intel_workarounds_types.h @@ -15,6 +15,7 @@ struct i915_wa { u32 clr; u32 set; u32 read; + bool masked_reg; }; struct i915_wa_list { diff --git a/drivers/gpu/drm/i915/gt/uc/intel_guc.h b/drivers/gpu/drm/i915/gt/uc/intel_guc.h index e118d8217e77..097687937cec 100644 --- a/drivers/gpu/drm/i915/gt/uc/intel_guc.h +++ b/drivers/gpu/drm/i915/gt/uc/intel_guc.h @@ -59,6 +59,7 @@ struct intel_guc { struct i915_vma *ads_vma; struct __guc_ads_blob *ads_blob; + u32 ads_regset_size; struct i915_vma *lrc_desc_pool; void *lrc_desc_pool_vaddr; diff --git a/drivers/gpu/drm/i915/gt/uc/intel_guc_ads.c b/drivers/gpu/drm/i915/gt/uc/intel_guc_ads.c index ecd18531b40a..cd65ff42657d 100644 --- a/drivers/gpu/drm/i915/gt/uc/intel_guc_ads.c +++ b/drivers/gpu/drm/i915/gt/uc/intel_guc_ads.c @@ -3,6 +3,8 @@ * Copyright © 2014-2019 Intel Corporation */ +#include + #include "gt/intel_gt.h" #include "gt/intel_lrc.h" #include "intel_guc_ads.h" @@ -25,7 +27,12 @@ * | guc_gt_system_info | * +---------------------------------------+ * | guc_clients_info | - * +---------------------------------------+ + * +---------------------------------------+ <== static + * | guc_mmio_reg[countA] (engine 0.0) | + * | guc_mmio_reg[countB] (engine 0.1) | + * | guc_mmio_reg[countC] (engine 1.0) | + * | ... | + * +---------------------------------------+ <== dynamic * | padding | * +---------------------------------------+ <== 4K aligned * | private data | @@ -38,16 +45,33 @@ struct __guc_ads_blob { struct guc_policies policies; struct guc_gt_system_info system_info; struct guc_clients_info clients_info; + /* From here on, location is dynamic! Refer to above diagram. */ + struct guc_mmio_reg regset[0]; } __packed; +static u32 guc_ads_regset_size(struct intel_guc *guc) +{ + GEM_BUG_ON(!guc->ads_regset_size); + return guc->ads_regset_size; +} + static u32 guc_ads_private_data_size(struct intel_guc *guc) { return PAGE_ALIGN(guc->fw.private_data_size); } +static u32 guc_ads_regset_offset(struct intel_guc *guc) +{ + return offsetof(struct __guc_ads_blob, regset); +} + static u32 guc_ads_private_data_offset(struct intel_guc *guc) { - return PAGE_ALIGN(sizeof(struct __guc_ads_blob)); + u32 offset; + + offset = guc_ads_regset_offset(guc) + + guc_ads_regset_size(guc); + return PAGE_ALIGN(offset); } static u32 guc_ads_blob_size(struct intel_guc *guc) @@ -86,6 +110,165 @@ static void guc_mapping_table_init(struct intel_gt *gt, } } +/* + * The save/restore register list must be pre-calculated to a temporary + * buffer of driver defined size before it can be generated in place + * inside the ADS. + */ +#define MAX_MMIO_REGS 128 /* Arbitrary size, increase as needed */ +struct temp_regset { + struct guc_mmio_reg *registers; + u32 used; + u32 size; +}; + +static int guc_mmio_reg_cmp(const void *a, const void *b) +{ + const struct guc_mmio_reg *ra = a; + const struct guc_mmio_reg *rb = b; + + return (int)ra->offset - (int)rb->offset; +} + +static void guc_mmio_reg_add(struct temp_regset *regset, + u32 offset, u32 flags) +{ + u32 count = regset->used; + struct guc_mmio_reg reg = { + .offset = offset, + .flags = flags, + }; + struct guc_mmio_reg *slot; + + GEM_BUG_ON(count >= regset->size); + + /* + * The mmio list is built using separate lists within the driver. + * It's possible that at some point we may attempt to add the same + * register more than once. Do not consider this an error; silently + * move on if the register is already in the list. + */ + if (bsearch(®, regset->registers, count, + sizeof(reg), guc_mmio_reg_cmp)) + return; + + slot = ®set->registers[count]; + regset->used++; + *slot = reg; + + while (slot-- > regset->registers) { + GEM_BUG_ON(slot[0].offset == slot[1].offset); + if (slot[1].offset > slot[0].offset) + break; + + swap(slot[1], slot[0]); + } +} + +#define GUC_MMIO_REG_ADD(regset, reg, masked) \ + guc_mmio_reg_add(regset, \ + i915_mmio_reg_offset((reg)), \ + (masked) ? GUC_REGSET_MASKED : 0) + +static void guc_mmio_regset_init(struct temp_regset *regset, + struct intel_engine_cs *engine) +{ + const u32 base = engine->mmio_base; + struct i915_wa_list *wal = &engine->wa_list; + struct i915_wa *wa; + unsigned int i; + + regset->used = 0; + + GUC_MMIO_REG_ADD(regset, RING_MODE_GEN7(base), true); + GUC_MMIO_REG_ADD(regset, RING_HWS_PGA(base), false); + GUC_MMIO_REG_ADD(regset, RING_IMR(base), false); + + for (i = 0, wa = wal->list; i < wal->count; i++, wa++) + GUC_MMIO_REG_ADD(regset, wa->reg, wa->masked_reg); + + /* Be extra paranoid and include all whitelist registers. */ + for (i = 0; i < RING_MAX_NONPRIV_SLOTS; i++) + GUC_MMIO_REG_ADD(regset, + RING_FORCE_TO_NONPRIV(base, i), + false); + + /* add in local MOCS registers */ + for (i = 0; i < GEN9_LNCFCMOCS_REG_COUNT; i++) + GUC_MMIO_REG_ADD(regset, GEN9_LNCFCMOCS(i), false); +} + +static int guc_mmio_reg_state_query(struct intel_guc *guc) +{ + struct intel_gt *gt = guc_to_gt(guc); + struct intel_engine_cs *engine; + enum intel_engine_id id; + struct temp_regset temp_set; + u32 total; + + /* + * Need to actually build the list in order to filter out + * duplicates and other such data dependent constructions. + */ + temp_set.size = MAX_MMIO_REGS; + temp_set.registers = kmalloc_array(temp_set.size, + sizeof(*temp_set.registers), + GFP_KERNEL); + if (!temp_set.registers) + return -ENOMEM; + + total = 0; + for_each_engine(engine, gt, id) { + guc_mmio_regset_init(&temp_set, engine); + total += temp_set.used; + } + + kfree(temp_set.registers); + + return total * sizeof(struct guc_mmio_reg); +} + +static void guc_mmio_reg_state_init(struct intel_guc *guc, + struct __guc_ads_blob *blob) +{ + struct intel_gt *gt = guc_to_gt(guc); + struct intel_engine_cs *engine; + enum intel_engine_id id; + struct temp_regset temp_set; + struct guc_mmio_reg_set *ads_reg_set; + u32 addr_ggtt, offset; + u8 guc_class; + + offset = guc_ads_regset_offset(guc); + addr_ggtt = intel_guc_ggtt_offset(guc, guc->ads_vma) + offset; + temp_set.registers = (struct guc_mmio_reg *) (((u8 *) blob) + offset); + temp_set.size = guc->ads_regset_size / sizeof(temp_set.registers[0]); + + for_each_engine(engine, gt, id) { + /* Class index is checked in class converter */ + GEM_BUG_ON(engine->instance >= GUC_MAX_INSTANCES_PER_CLASS); + + guc_class = engine_class_to_guc_class(engine->class); + ads_reg_set = &blob->ads.reg_state_list[guc_class][engine->instance]; + + guc_mmio_regset_init(&temp_set, engine); + if (!temp_set.used) { + ads_reg_set->address = 0; + ads_reg_set->count = 0; + continue; + } + + ads_reg_set->address = addr_ggtt; + ads_reg_set->count = temp_set.used; + + temp_set.size -= temp_set.used; + temp_set.registers += temp_set.used; + addr_ggtt += temp_set.used * sizeof(struct guc_mmio_reg); + } + + GEM_BUG_ON(temp_set.size); +} + /* * The first 80 dwords of the register state context, containing the * execlists and ppgtt registers. @@ -124,8 +307,7 @@ static void __guc_ads_init(struct intel_guc *guc) */ blob->ads.golden_context_lrca[guc_class] = 0; blob->ads.eng_state_size[guc_class] = - intel_engine_context_size(guc_to_gt(guc), - engine_class) - + intel_engine_context_size(gt, engine_class) - skipped_size; } @@ -160,6 +342,9 @@ static void __guc_ads_init(struct intel_guc *guc) blob->ads.gt_system_info = base + ptr_offset(blob, system_info); blob->ads.clients_info = base + ptr_offset(blob, clients_info); + /* MMIO save/restore list */ + guc_mmio_reg_state_init(guc, blob); + /* Private Data */ blob->ads.private_data = base + guc_ads_private_data_offset(guc); @@ -180,6 +365,12 @@ int intel_guc_ads_create(struct intel_guc *guc) GEM_BUG_ON(guc->ads_vma); + /* Need to calculate the reg state size dynamically: */ + ret = guc_mmio_reg_state_query(guc); + if (ret < 0) + return ret; + guc->ads_regset_size = ret; + size = guc_ads_blob_size(guc); ret = intel_guc_allocate_and_map_vma(guc, size, &guc->ads_vma, diff --git a/drivers/gpu/drm/i915/i915_reg.h b/drivers/gpu/drm/i915/i915_reg.h index db151b522825..e7988b4812f3 100644 --- a/drivers/gpu/drm/i915/i915_reg.h +++ b/drivers/gpu/drm/i915/i915_reg.h @@ -12166,6 +12166,7 @@ enum skl_power_gate { /* MOCS (Memory Object Control State) registers */ #define GEN9_LNCFCMOCS(i) _MMIO(0xb020 + (i) * 4) /* L3 Cache Control */ +#define GEN9_LNCFCMOCS_REG_COUNT 32 #define __GEN9_RCS0_MOCS0 0xc800 #define GEN9_GFX_MOCS(i) _MMIO(__GEN9_RCS0_MOCS0 + (i) * 4) -- 2.28.0 From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-16.8 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 22307C433B4 for ; Thu, 6 May 2021 19:00:25 +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 E380B610D2 for ; Thu, 6 May 2021 19:00:24 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org E380B610D2 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=intel.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=intel-gfx-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 35EF66EE06; Thu, 6 May 2021 18:57:50 +0000 (UTC) Received: from mga14.intel.com (mga14.intel.com [192.55.52.115]) by gabe.freedesktop.org (Postfix) with ESMTPS id 348BC6ED64; Thu, 6 May 2021 18:57:14 +0000 (UTC) IronPort-SDR: 9a/caSm+OR5Phqywdyl1rfcEw7fW7Eke4fKAcGPJQatDJoSCqsTHRyjM1OeYE4gJAPj3W2VIOx 1/uURYSxNhwA== X-IronPort-AV: E=McAfee;i="6200,9189,9976"; a="198195459" X-IronPort-AV: E=Sophos;i="5.82,278,1613462400"; d="scan'208";a="198195459" Received: from orsmga001.jf.intel.com ([10.7.209.18]) by fmsmga103.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 06 May 2021 11:57:13 -0700 IronPort-SDR: /+C/Va8twf2OO9wblpJRSDDZNIG++em/5lrNS7K1Vy9AQtkWSgGzKMRpAFeBj7wjlsqtyt824e B4ajBqleD9vA== X-IronPort-AV: E=Sophos;i="5.82,278,1613462400"; d="scan'208";a="469583591" Received: from dhiatt-server.jf.intel.com ([10.54.81.3]) by orsmga001-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 06 May 2021 11:57:12 -0700 From: Matthew Brost To: , Date: Thu, 6 May 2021 12:14:25 -0700 Message-Id: <20210506191451.77768-72-matthew.brost@intel.com> X-Mailer: git-send-email 2.28.0 In-Reply-To: <20210506191451.77768-1-matthew.brost@intel.com> References: <20210506191451.77768-1-matthew.brost@intel.com> MIME-Version: 1.0 Subject: [Intel-gfx] [RFC PATCH 71/97] drm/i915/guc: Provide mmio list to be saved/restored on engine reset X-BeenThere: intel-gfx@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Intel graphics driver community testing & development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: jason.ekstrand@intel.com, daniel.vetter@intel.com Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" RnJvbTogSm9obiBIYXJyaXNvbiA8Sm9obi5DLkhhcnJpc29uQEludGVsLmNvbT4KClRoZSBkcml2 ZXIgbXVzdCBwcm92aWRlIEd1QyB3aXRoIGEgbGlzdCBvZiBtbWlvIHJlZ2lzdGVycwp0aGF0IHNo b3VsZCBiZSBzYXZlZC9yZXN0b3JlZCBkdXJpbmcgYSBHdUMtYmFzZWQgZW5naW5lIHJlc2V0LgpV bmZvcnR1bmF0ZWx5LCB0aGUgbGlzdCBtdXN0IGJlIGR5bmFtaWNhbGx5IGFsbG9jYXRlZCBhcyBp dHMgc2l6ZSBpcwp2YXJpYWJsZS4gVGhhdCBtZWFucyB0aGUgZHJpdmVyIG11c3QgZ2VuZXJhdGUg dGhlIGxpc3QgdHdpY2UgLSBvbmNlIHRvCndvcmsgb3V0IHRoZSBzaXplIGFuZCBhIHNlY29uZCB0 aW1lIHRvIGFjdHVhbGx5IHNhdmUgaXQuCgpTaWduZWQtb2ZmLWJ5OiBKb2huIEhhcnJpc29uIDxK b2huLkMuSGFycmlzb25ASW50ZWwuY29tPgpTaWduZWQtb2ZmLWJ5OiBGZXJuYW5kbyBQYWNoZWNv IDxmZXJuYW5kby5wYWNoZWNvQGludGVsLmNvbT4KU2lnbmVkLW9mZi1ieTogTWF0dGhldyBCcm9z dCA8bWF0dGhldy5icm9zdEBpbnRlbC5jb20+CkNjOiBEYW5pZWxlIENlcmFvbG8gU3B1cmlvIDxk YW5pZWxlLmNlcmFvbG9zcHVyaW9AaW50ZWwuY29tPgpDYzogVHZydGtvIFVyc3VsaW4gPHR2cnRr by51cnN1bGluQGludGVsLmNvbT4KLS0tCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF93 b3JrYXJvdW5kcy5jICAgfCAgNDYgKystLQogLi4uL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF93b3Jr YXJvdW5kc190eXBlcy5oIHwgICAxICsKIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L3VjL2ludGVs X2d1Yy5oICAgICAgICB8ICAgMSArCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC91Yy9pbnRlbF9n dWNfYWRzLmMgICAgfCAxOTkgKysrKysrKysrKysrKysrKystCiBkcml2ZXJzL2dwdS9kcm0vaTkx NS9pOTE1X3JlZy5oICAgICAgICAgICAgICAgfCAgIDEgKwogNSBmaWxlcyBjaGFuZ2VkLCAyMjIg aW5zZXJ0aW9ucygrKSwgMjYgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUv ZHJtL2k5MTUvZ3QvaW50ZWxfd29ya2Fyb3VuZHMuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0 L2ludGVsX3dvcmthcm91bmRzLmMKaW5kZXggNWEwM2E3NmJiOWUyLi4wNWQyMTQ3NmQxNDAgMTAw NjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L2ludGVsX3dvcmthcm91bmRzLmMKKysr IGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfd29ya2Fyb3VuZHMuYwpAQCAtMTUwLDEz ICsxNTAsMTQgQEAgc3RhdGljIHZvaWQgX3dhX2FkZChzdHJ1Y3QgaTkxNV93YV9saXN0ICp3YWws IGNvbnN0IHN0cnVjdCBpOTE1X3dhICp3YSkKIH0KIAogc3RhdGljIHZvaWQgd2FfYWRkKHN0cnVj dCBpOTE1X3dhX2xpc3QgKndhbCwgaTkxNV9yZWdfdCByZWcsCi0JCSAgIHUzMiBjbGVhciwgdTMy IHNldCwgdTMyIHJlYWRfbWFzaykKKwkJICAgdTMyIGNsZWFyLCB1MzIgc2V0LCB1MzIgcmVhZF9t YXNrLCBib29sIG1hc2tlZF9yZWcpCiB7CiAJc3RydWN0IGk5MTVfd2Egd2EgPSB7CiAJCS5yZWcg ID0gcmVnLAogCQkuY2xyICA9IGNsZWFyLAogCQkuc2V0ICA9IHNldCwKIAkJLnJlYWQgPSByZWFk X21hc2ssCisJCS5tYXNrZWRfcmVnID0gbWFza2VkX3JlZywKIAl9OwogCiAJX3dhX2FkZCh3YWws ICZ3YSk7CkBAIC0xNjUsNyArMTY2LDcgQEAgc3RhdGljIHZvaWQgd2FfYWRkKHN0cnVjdCBpOTE1 X3dhX2xpc3QgKndhbCwgaTkxNV9yZWdfdCByZWcsCiBzdGF0aWMgdm9pZAogd2Ffd3JpdGVfY2xy X3NldChzdHJ1Y3QgaTkxNV93YV9saXN0ICp3YWwsIGk5MTVfcmVnX3QgcmVnLCB1MzIgY2xlYXIs IHUzMiBzZXQpCiB7Ci0Jd2FfYWRkKHdhbCwgcmVnLCBjbGVhciwgc2V0LCBjbGVhcik7CisJd2Ff YWRkKHdhbCwgcmVnLCBjbGVhciwgc2V0LCBjbGVhciwgZmFsc2UpOwogfQogCiBzdGF0aWMgdm9p ZApAQCAtMjAwLDIwICsyMDEsMjAgQEAgd2Ffd3JpdGVfY2xyKHN0cnVjdCBpOTE1X3dhX2xpc3Qg KndhbCwgaTkxNV9yZWdfdCByZWcsIHUzMiBjbHIpCiBzdGF0aWMgdm9pZAogd2FfbWFza2VkX2Vu KHN0cnVjdCBpOTE1X3dhX2xpc3QgKndhbCwgaTkxNV9yZWdfdCByZWcsIHUzMiB2YWwpCiB7Ci0J d2FfYWRkKHdhbCwgcmVnLCAwLCBfTUFTS0VEX0JJVF9FTkFCTEUodmFsKSwgdmFsKTsKKwl3YV9h ZGQod2FsLCByZWcsIDAsIF9NQVNLRURfQklUX0VOQUJMRSh2YWwpLCB2YWwsIHRydWUpOwogfQog CiBzdGF0aWMgdm9pZAogd2FfbWFza2VkX2RpcyhzdHJ1Y3QgaTkxNV93YV9saXN0ICp3YWwsIGk5 MTVfcmVnX3QgcmVnLCB1MzIgdmFsKQogewotCXdhX2FkZCh3YWwsIHJlZywgMCwgX01BU0tFRF9C SVRfRElTQUJMRSh2YWwpLCB2YWwpOworCXdhX2FkZCh3YWwsIHJlZywgMCwgX01BU0tFRF9CSVRf RElTQUJMRSh2YWwpLCB2YWwsIHRydWUpOwogfQogCiBzdGF0aWMgdm9pZAogd2FfbWFza2VkX2Zp ZWxkX3NldChzdHJ1Y3QgaTkxNV93YV9saXN0ICp3YWwsIGk5MTVfcmVnX3QgcmVnLAogCQkgICAg dTMyIG1hc2ssIHUzMiB2YWwpCiB7Ci0Jd2FfYWRkKHdhbCwgcmVnLCAwLCBfTUFTS0VEX0ZJRUxE KG1hc2ssIHZhbCksIG1hc2spOworCXdhX2FkZCh3YWwsIHJlZywgMCwgX01BU0tFRF9GSUVMRCht YXNrLCB2YWwpLCBtYXNrLCB0cnVlKTsKIH0KIAogc3RhdGljIHZvaWQgZ2VuNl9jdHhfd29ya2Fy b3VuZHNfaW5pdChzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzICplbmdpbmUsCkBAIC01ODMsMTAgKzU4 NCwxMCBAQCBzdGF0aWMgdm9pZCBpY2xfY3R4X3dvcmthcm91bmRzX2luaXQoc3RydWN0IGludGVs X2VuZ2luZV9jcyAqZW5naW5lLAogCQkJICAgICBHRU4xMV9CTEVORF9FTUJfRklYX0RJU0FCTEVf SU5fUkNDKTsKIAogCS8qIFdhRW5hYmxlRmxvYXRCbGVuZE9wdGltaXphdGlvbjppY2wgKi8KLQl3 YV93cml0ZV9jbHJfc2V0KHdhbCwKLQkJCSBHRU4xMF9DQUNIRV9NT0RFX1NTLAotCQkJIDAsIC8q IHdyaXRlLW9ubHksIHNvIHNraXAgdmFsaWRhdGlvbiAqLwotCQkJIF9NQVNLRURfQklUX0VOQUJM RShGTE9BVF9CTEVORF9PUFRJTUlaQVRJT05fRU5BQkxFKSk7CisJd2FfYWRkKHdhbCwgR0VOMTBf Q0FDSEVfTU9ERV9TUywgMCwKKwkgICAgICAgX01BU0tFRF9CSVRfRU5BQkxFKEZMT0FUX0JMRU5E X09QVElNSVpBVElPTl9FTkFCTEUpLAorCSAgICAgICAwIC8qIHdyaXRlLW9ubHksIHNvIHNraXAg dmFsaWRhdGlvbiAqLywKKwkgICAgICAgdHJ1ZSk7CiAKIAkvKiBXYURpc2FibGVHUEdQVU1pZFRo cmVhZFByZWVtcHRpb246aWNsICovCiAJd2FfbWFza2VkX2ZpZWxkX3NldCh3YWwsIEdFTjhfQ1Nf Q0hJQ0tFTjEsCkBAIC02MzEsNyArNjMyLDcgQEAgc3RhdGljIHZvaWQgZ2VuMTJfY3R4X2d0X3R1 bmluZ19pbml0KHN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmVuZ2luZSwKIAkgICAgICAgRkZfTU9E RTIsCiAJICAgICAgIEZGX01PREUyX1REU19USU1FUl9NQVNLLAogCSAgICAgICBGRl9NT0RFMl9U RFNfVElNRVJfMTI4LAotCSAgICAgICAwKTsKKwkgICAgICAgMCwgZmFsc2UpOwogfQogCiBzdGF0 aWMgdm9pZCBnZW4xMl9jdHhfd29ya2Fyb3VuZHNfaW5pdChzdHJ1Y3QgaW50ZWxfZW5naW5lX2Nz ICplbmdpbmUsCkBAIC02NjgsNyArNjY5LDcgQEAgc3RhdGljIHZvaWQgZ2VuMTJfY3R4X3dvcmth cm91bmRzX2luaXQoc3RydWN0IGludGVsX2VuZ2luZV9jcyAqZW5naW5lLAogCSAgICAgICBGRl9N T0RFMiwKIAkgICAgICAgRkZfTU9ERTJfR1NfVElNRVJfTUFTSywKIAkgICAgICAgRkZfTU9ERTJf R1NfVElNRVJfMjI0LAotCSAgICAgICAwKTsKKwkgICAgICAgMCwgZmFsc2UpOwogfQogCiBzdGF0 aWMgdm9pZCBkZzFfY3R4X3dvcmthcm91bmRzX2luaXQoc3RydWN0IGludGVsX2VuZ2luZV9jcyAq ZW5naW5lLApAQCAtODM5LDcgKzg0MCw3IEBAIGhzd19ndF93b3JrYXJvdW5kc19pbml0KHN0cnVj dCBkcm1faTkxNV9wcml2YXRlICppOTE1LCBzdHJ1Y3QgaTkxNV93YV9saXN0ICp3YWwpCiAJd2Ff YWRkKHdhbCwKIAkgICAgICAgSFNXX1JPV19DSElDS0VOMywgMCwKIAkgICAgICAgX01BU0tFRF9C SVRfRU5BQkxFKEhTV19ST1dfQ0hJQ0tFTjNfTDNfR0xPQkFMX0FUT01JQ1NfRElTQUJMRSksCi0J CTAgLyogWFhYIGRvZXMgdGhpcyByZWcgZXhpc3Q/ICovKTsKKwkgICAgICAgMCAvKiBYWFggZG9l cyB0aGlzIHJlZyBleGlzdD8gKi8sIHRydWUpOwogCiAJLyogV2FWU1JlZkNvdW50RnVsbGZvcmNl TWlzc0Rpc2FibGU6aHN3ICovCiAJd2Ffd3JpdGVfY2xyKHdhbCwgR0VON19GRl9USFJFQURfTU9E RSwgR0VON19GRl9WU19SRUZfQ05UX0ZGTUUpOwpAQCAtMTk1MCwxMCArMTk1MSwxMCBAQCByY3Nf ZW5naW5lX3dhX2luaXQoc3RydWN0IGludGVsX2VuZ2luZV9jcyAqZW5naW5lLCBzdHJ1Y3QgaTkx NV93YV9saXN0ICp3YWwpCiAJCSAqIGRpc2FibGUgYml0LCB3aGljaCB3ZSBkb24ndCB0b3VjaCBo ZXJlLCBidXQgaXQncyBnb29kCiAJCSAqIHRvIGtlZXAgaW4gbWluZCAoc2VlIDNEU1RBVEVfUFMg YW5kIDNEU1RBVEVfV00pLgogCQkgKi8KLQkJd2FfYWRkKHdhbCwgR0VON19HVF9NT0RFLCAwLAot CQkgICAgICAgX01BU0tFRF9GSUVMRChHRU42X1dJWl9IQVNISU5HX01BU0ssCi0JCQkJICAgICBH RU42X1dJWl9IQVNISU5HXzE2eDQpLAotCQkgICAgICAgR0VONl9XSVpfSEFTSElOR18xNng0KTsK KwkJd2FfbWFza2VkX2ZpZWxkX3NldCh3YWwsCisJCQkJICAgIEdFTjdfR1RfTU9ERSwKKwkJCQkg ICAgR0VONl9XSVpfSEFTSElOR19NQVNLLAorCQkJCSAgICBHRU42X1dJWl9IQVNISU5HXzE2eDQp OwogCX0KIAogCWlmIChJU19HRU5fUkFOR0UoaTkxNSwgNiwgNykpCkBAIC0yMDAzLDEwICsyMDA0 LDEwIEBAIHJjc19lbmdpbmVfd2FfaW5pdChzdHJ1Y3QgaW50ZWxfZW5naW5lX2NzICplbmdpbmUs IHN0cnVjdCBpOTE1X3dhX2xpc3QgKndhbCkKIAkJICogZGlzYWJsZSBiaXQsIHdoaWNoIHdlIGRv bid0IHRvdWNoIGhlcmUsIGJ1dCBpdCdzIGdvb2QKIAkJICogdG8ga2VlcCBpbiBtaW5kIChzZWUg M0RTVEFURV9QUyBhbmQgM0RTVEFURV9XTSkuCiAJCSAqLwotCQl3YV9hZGQod2FsLAotCQkgICAg ICAgR0VONl9HVF9NT0RFLCAwLAotCQkgICAgICAgX01BU0tFRF9GSUVMRChHRU42X1dJWl9IQVNI SU5HX01BU0ssIEdFTjZfV0laX0hBU0hJTkdfMTZ4NCksCi0JCSAgICAgICBHRU42X1dJWl9IQVNI SU5HXzE2eDQpOworCQl3YV9tYXNrZWRfZmllbGRfc2V0KHdhbCwKKwkJCQkgICAgR0VON19HVF9N T0RFLAorCQkJCSAgICBHRU42X1dJWl9IQVNISU5HX01BU0ssCisJCQkJICAgIEdFTjZfV0laX0hB U0hJTkdfMTZ4NCk7CiAKIAkJLyogV2FEaXNhYmxlX1JlbmRlckNhY2hlX09wZXJhdGlvbmFsRmx1 c2g6c25iICovCiAJCXdhX21hc2tlZF9kaXMod2FsLCBDQUNIRV9NT0RFXzAsIFJDX09QX0ZMVVNI X0VOQUJMRSk7CkBAIC0yMDI3LDcgKzIwMjgsNyBAQCByY3NfZW5naW5lX3dhX2luaXQoc3RydWN0 IGludGVsX2VuZ2luZV9jcyAqZW5naW5lLCBzdHJ1Y3QgaTkxNV93YV9saXN0ICp3YWwpCiAJCXdh X2FkZCh3YWwsIE1JX01PREUsCiAJCSAgICAgICAwLCBfTUFTS0VEX0JJVF9FTkFCTEUoVlNfVElN RVJfRElTUEFUQ0gpLAogCQkgICAgICAgLyogWFhYIGJpdCBkb2Vzbid0IHN0aWNrIG9uIEJyb2Fk d2F0ZXIgKi8KLQkJICAgICAgIElTX0k5NjVHKGk5MTUpID8gMCA6IFZTX1RJTUVSX0RJU1BBVENI KTsKKwkJICAgICAgIElTX0k5NjVHKGk5MTUpID8gMCA6IFZTX1RJTUVSX0RJU1BBVENILCB0cnVl KTsKIAogCWlmIChJU19HRU4oaTkxNSwgNCkpCiAJCS8qCkBAIC0yMDQyLDcgKzIwNDMsOCBAQCBy Y3NfZW5naW5lX3dhX2luaXQoc3RydWN0IGludGVsX2VuZ2luZV9jcyAqZW5naW5lLCBzdHJ1Y3Qg aTkxNV93YV9saXN0ICp3YWwpCiAJCSAqLwogCQl3YV9hZGQod2FsLCBFQ09TS1BELAogCQkgICAg ICAgMCwgX01BU0tFRF9CSVRfRU5BQkxFKEVDT19DT05TVEFOVF9CVUZGRVJfU1JfRElTQUJMRSks Ci0JCSAgICAgICAwIC8qIFhYWCBiaXQgZG9lc24ndCBzdGljayBvbiBCcm9hZHdhdGVyICovKTsK KwkJICAgICAgIDAgLyogWFhYIGJpdCBkb2Vzbid0IHN0aWNrIG9uIEJyb2Fkd2F0ZXIgKi8sCisJ CSAgICAgICB0cnVlKTsKIH0KIAogc3RhdGljIHZvaWQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1 L2RybS9pOTE1L2d0L2ludGVsX3dvcmthcm91bmRzX3R5cGVzLmggYi9kcml2ZXJzL2dwdS9kcm0v aTkxNS9ndC9pbnRlbF93b3JrYXJvdW5kc190eXBlcy5oCmluZGV4IGMyMTQxMTFlYTM2Ny4uMWU4 NzM2ODE3OTVkIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF93b3Jr YXJvdW5kc190eXBlcy5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L2ludGVsX3dvcmth cm91bmRzX3R5cGVzLmgKQEAgLTE1LDYgKzE1LDcgQEAgc3RydWN0IGk5MTVfd2EgewogCXUzMgkJ Y2xyOwogCXUzMgkJc2V0OwogCXUzMgkJcmVhZDsKKwlib29sCQltYXNrZWRfcmVnOwogfTsKIAog c3RydWN0IGk5MTVfd2FfbGlzdCB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9n dC91Yy9pbnRlbF9ndWMuaCBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L3VjL2ludGVsX2d1Yy5o CmluZGV4IGUxMThkODIxN2U3Ny4uMDk3Njg3OTM3Y2VjIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dw dS9kcm0vaTkxNS9ndC91Yy9pbnRlbF9ndWMuaAorKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9n dC91Yy9pbnRlbF9ndWMuaApAQCAtNTksNiArNTksNyBAQCBzdHJ1Y3QgaW50ZWxfZ3VjIHsKIAog CXN0cnVjdCBpOTE1X3ZtYSAqYWRzX3ZtYTsKIAlzdHJ1Y3QgX19ndWNfYWRzX2Jsb2IgKmFkc19i bG9iOworCXUzMiBhZHNfcmVnc2V0X3NpemU7CiAKIAlzdHJ1Y3QgaTkxNV92bWEgKmxyY19kZXNj X3Bvb2w7CiAJdm9pZCAqbHJjX2Rlc2NfcG9vbF92YWRkcjsKZGlmZiAtLWdpdCBhL2RyaXZlcnMv Z3B1L2RybS9pOTE1L2d0L3VjL2ludGVsX2d1Y19hZHMuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1 L2d0L3VjL2ludGVsX2d1Y19hZHMuYwppbmRleCBlY2QxODUzMWI0MGEuLmNkNjVmZjQyNjU3ZCAx MDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvdWMvaW50ZWxfZ3VjX2Fkcy5jCisr KyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L3VjL2ludGVsX2d1Y19hZHMuYwpAQCAtMyw2ICsz LDggQEAKICAqIENvcHlyaWdodCDCqSAyMDE0LTIwMTkgSW50ZWwgQ29ycG9yYXRpb24KICAqLwog CisjaW5jbHVkZSA8bGludXgvYnNlYXJjaC5oPgorCiAjaW5jbHVkZSAiZ3QvaW50ZWxfZ3QuaCIK ICNpbmNsdWRlICJndC9pbnRlbF9scmMuaCIKICNpbmNsdWRlICJpbnRlbF9ndWNfYWRzLmgiCkBA IC0yNSw3ICsyNywxMiBAQAogICogICAgICB8IGd1Y19ndF9zeXN0ZW1faW5mbyAgICAgICAgICAg ICAgICAgICAgfAogICogICAgICArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tKwogICogICAgICB8IGd1Y19jbGllbnRzX2luZm8gICAgICAgICAgICAgICAgICAgICAgfAot ICogICAgICArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKworICogICAg ICArLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKyA8PT0gc3RhdGljCisg KiAgICAgIHwgZ3VjX21taW9fcmVnW2NvdW50QV0gKGVuZ2luZSAwLjApICAgICB8CisgKiAgICAg IHwgZ3VjX21taW9fcmVnW2NvdW50Ql0gKGVuZ2luZSAwLjEpICAgICB8CisgKiAgICAgIHwgZ3Vj X21taW9fcmVnW2NvdW50Q10gKGVuZ2luZSAxLjApICAgICB8CisgKiAgICAgIHwgICAuLi4gICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8CisgKiAgICAgICstLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rIDw9PSBkeW5hbWljCiAgKiAgICAgIHwgcGFkZGluZyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8CiAgKiAgICAgICstLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rIDw9PSA0SyBhbGlnbmVkCiAgKiAgICAgIHwgcHJpdmF0 ZSBkYXRhICAgICAgICAgICAgICAgICAgICAgICAgICB8CkBAIC0zOCwxNiArNDUsMzMgQEAgc3Ry dWN0IF9fZ3VjX2Fkc19ibG9iIHsKIAlzdHJ1Y3QgZ3VjX3BvbGljaWVzIHBvbGljaWVzOwogCXN0 cnVjdCBndWNfZ3Rfc3lzdGVtX2luZm8gc3lzdGVtX2luZm87CiAJc3RydWN0IGd1Y19jbGllbnRz X2luZm8gY2xpZW50c19pbmZvOworCS8qIEZyb20gaGVyZSBvbiwgbG9jYXRpb24gaXMgZHluYW1p YyEgUmVmZXIgdG8gYWJvdmUgZGlhZ3JhbS4gKi8KKwlzdHJ1Y3QgZ3VjX21taW9fcmVnIHJlZ3Nl dFswXTsKIH0gX19wYWNrZWQ7CiAKK3N0YXRpYyB1MzIgZ3VjX2Fkc19yZWdzZXRfc2l6ZShzdHJ1 Y3QgaW50ZWxfZ3VjICpndWMpCit7CisJR0VNX0JVR19PTighZ3VjLT5hZHNfcmVnc2V0X3NpemUp OworCXJldHVybiBndWMtPmFkc19yZWdzZXRfc2l6ZTsKK30KKwogc3RhdGljIHUzMiBndWNfYWRz X3ByaXZhdGVfZGF0YV9zaXplKHN0cnVjdCBpbnRlbF9ndWMgKmd1YykKIHsKIAlyZXR1cm4gUEFH RV9BTElHTihndWMtPmZ3LnByaXZhdGVfZGF0YV9zaXplKTsKIH0KIAorc3RhdGljIHUzMiBndWNf YWRzX3JlZ3NldF9vZmZzZXQoc3RydWN0IGludGVsX2d1YyAqZ3VjKQoreworCXJldHVybiBvZmZz ZXRvZihzdHJ1Y3QgX19ndWNfYWRzX2Jsb2IsIHJlZ3NldCk7Cit9CisKIHN0YXRpYyB1MzIgZ3Vj X2Fkc19wcml2YXRlX2RhdGFfb2Zmc2V0KHN0cnVjdCBpbnRlbF9ndWMgKmd1YykKIHsKLQlyZXR1 cm4gUEFHRV9BTElHTihzaXplb2Yoc3RydWN0IF9fZ3VjX2Fkc19ibG9iKSk7CisJdTMyIG9mZnNl dDsKKworCW9mZnNldCA9IGd1Y19hZHNfcmVnc2V0X29mZnNldChndWMpICsKKwkJIGd1Y19hZHNf cmVnc2V0X3NpemUoZ3VjKTsKKwlyZXR1cm4gUEFHRV9BTElHTihvZmZzZXQpOwogfQogCiBzdGF0 aWMgdTMyIGd1Y19hZHNfYmxvYl9zaXplKHN0cnVjdCBpbnRlbF9ndWMgKmd1YykKQEAgLTg2LDYg KzExMCwxNjUgQEAgc3RhdGljIHZvaWQgZ3VjX21hcHBpbmdfdGFibGVfaW5pdChzdHJ1Y3QgaW50 ZWxfZ3QgKmd0LAogCX0KIH0KIAorLyoKKyAqIFRoZSBzYXZlL3Jlc3RvcmUgcmVnaXN0ZXIgbGlz dCBtdXN0IGJlIHByZS1jYWxjdWxhdGVkIHRvIGEgdGVtcG9yYXJ5CisgKiBidWZmZXIgb2YgZHJp dmVyIGRlZmluZWQgc2l6ZSBiZWZvcmUgaXQgY2FuIGJlIGdlbmVyYXRlZCBpbiBwbGFjZQorICog aW5zaWRlIHRoZSBBRFMuCisgKi8KKyNkZWZpbmUgTUFYX01NSU9fUkVHUwkxMjgJLyogQXJiaXRy YXJ5IHNpemUsIGluY3JlYXNlIGFzIG5lZWRlZCAqLworc3RydWN0IHRlbXBfcmVnc2V0IHsKKwlz dHJ1Y3QgZ3VjX21taW9fcmVnICpyZWdpc3RlcnM7CisJdTMyIHVzZWQ7CisJdTMyIHNpemU7Cit9 OworCitzdGF0aWMgaW50IGd1Y19tbWlvX3JlZ19jbXAoY29uc3Qgdm9pZCAqYSwgY29uc3Qgdm9p ZCAqYikKK3sKKwljb25zdCBzdHJ1Y3QgZ3VjX21taW9fcmVnICpyYSA9IGE7CisJY29uc3Qgc3Ry dWN0IGd1Y19tbWlvX3JlZyAqcmIgPSBiOworCisJcmV0dXJuIChpbnQpcmEtPm9mZnNldCAtIChp bnQpcmItPm9mZnNldDsKK30KKworc3RhdGljIHZvaWQgZ3VjX21taW9fcmVnX2FkZChzdHJ1Y3Qg dGVtcF9yZWdzZXQgKnJlZ3NldCwKKwkJCSAgICAgdTMyIG9mZnNldCwgdTMyIGZsYWdzKQorewor CXUzMiBjb3VudCA9IHJlZ3NldC0+dXNlZDsKKwlzdHJ1Y3QgZ3VjX21taW9fcmVnIHJlZyA9IHsK KwkJLm9mZnNldCA9IG9mZnNldCwKKwkJLmZsYWdzID0gZmxhZ3MsCisJfTsKKwlzdHJ1Y3QgZ3Vj X21taW9fcmVnICpzbG90OworCisJR0VNX0JVR19PTihjb3VudCA+PSByZWdzZXQtPnNpemUpOwor CisJLyoKKwkgKiBUaGUgbW1pbyBsaXN0IGlzIGJ1aWx0IHVzaW5nIHNlcGFyYXRlIGxpc3RzIHdp dGhpbiB0aGUgZHJpdmVyLgorCSAqIEl0J3MgcG9zc2libGUgdGhhdCBhdCBzb21lIHBvaW50IHdl IG1heSBhdHRlbXB0IHRvIGFkZCB0aGUgc2FtZQorCSAqIHJlZ2lzdGVyIG1vcmUgdGhhbiBvbmNl LiBEbyBub3QgY29uc2lkZXIgdGhpcyBhbiBlcnJvcjsgc2lsZW50bHkKKwkgKiBtb3ZlIG9uIGlm IHRoZSByZWdpc3RlciBpcyBhbHJlYWR5IGluIHRoZSBsaXN0LgorCSAqLworCWlmIChic2VhcmNo KCZyZWcsIHJlZ3NldC0+cmVnaXN0ZXJzLCBjb3VudCwKKwkJICAgIHNpemVvZihyZWcpLCBndWNf bW1pb19yZWdfY21wKSkKKwkJcmV0dXJuOworCisJc2xvdCA9ICZyZWdzZXQtPnJlZ2lzdGVyc1tj b3VudF07CisJcmVnc2V0LT51c2VkKys7CisJKnNsb3QgPSByZWc7CisKKwl3aGlsZSAoc2xvdC0t ID4gcmVnc2V0LT5yZWdpc3RlcnMpIHsKKwkJR0VNX0JVR19PTihzbG90WzBdLm9mZnNldCA9PSBz bG90WzFdLm9mZnNldCk7CisJCWlmIChzbG90WzFdLm9mZnNldCA+IHNsb3RbMF0ub2Zmc2V0KQor CQkJYnJlYWs7CisKKwkJc3dhcChzbG90WzFdLCBzbG90WzBdKTsKKwl9Cit9CisKKyNkZWZpbmUg R1VDX01NSU9fUkVHX0FERChyZWdzZXQsIHJlZywgbWFza2VkKSBcCisJZ3VjX21taW9fcmVnX2Fk ZChyZWdzZXQsIFwKKwkJCSBpOTE1X21taW9fcmVnX29mZnNldCgocmVnKSksIFwKKwkJCSAobWFz a2VkKSA/IEdVQ19SRUdTRVRfTUFTS0VEIDogMCkKKworc3RhdGljIHZvaWQgZ3VjX21taW9fcmVn c2V0X2luaXQoc3RydWN0IHRlbXBfcmVnc2V0ICpyZWdzZXQsCisJCQkJIHN0cnVjdCBpbnRlbF9l bmdpbmVfY3MgKmVuZ2luZSkKK3sKKwljb25zdCB1MzIgYmFzZSA9IGVuZ2luZS0+bW1pb19iYXNl OworCXN0cnVjdCBpOTE1X3dhX2xpc3QgKndhbCA9ICZlbmdpbmUtPndhX2xpc3Q7CisJc3RydWN0 IGk5MTVfd2EgKndhOworCXVuc2lnbmVkIGludCBpOworCisJcmVnc2V0LT51c2VkID0gMDsKKwor CUdVQ19NTUlPX1JFR19BREQocmVnc2V0LCBSSU5HX01PREVfR0VONyhiYXNlKSwgdHJ1ZSk7CisJ R1VDX01NSU9fUkVHX0FERChyZWdzZXQsIFJJTkdfSFdTX1BHQShiYXNlKSwgZmFsc2UpOworCUdV Q19NTUlPX1JFR19BREQocmVnc2V0LCBSSU5HX0lNUihiYXNlKSwgZmFsc2UpOworCisJZm9yIChp ID0gMCwgd2EgPSB3YWwtPmxpc3Q7IGkgPCB3YWwtPmNvdW50OyBpKyssIHdhKyspCisJCUdVQ19N TUlPX1JFR19BREQocmVnc2V0LCB3YS0+cmVnLCB3YS0+bWFza2VkX3JlZyk7CisKKwkvKiBCZSBl eHRyYSBwYXJhbm9pZCBhbmQgaW5jbHVkZSBhbGwgd2hpdGVsaXN0IHJlZ2lzdGVycy4gKi8KKwlm b3IgKGkgPSAwOyBpIDwgUklOR19NQVhfTk9OUFJJVl9TTE9UUzsgaSsrKQorCQlHVUNfTU1JT19S RUdfQUREKHJlZ3NldCwKKwkJCQkgUklOR19GT1JDRV9UT19OT05QUklWKGJhc2UsIGkpLAorCQkJ CSBmYWxzZSk7CisKKwkvKiBhZGQgaW4gbG9jYWwgTU9DUyByZWdpc3RlcnMgKi8KKwlmb3IgKGkg PSAwOyBpIDwgR0VOOV9MTkNGQ01PQ1NfUkVHX0NPVU5UOyBpKyspCisJCUdVQ19NTUlPX1JFR19B REQocmVnc2V0LCBHRU45X0xOQ0ZDTU9DUyhpKSwgZmFsc2UpOworfQorCitzdGF0aWMgaW50IGd1 Y19tbWlvX3JlZ19zdGF0ZV9xdWVyeShzdHJ1Y3QgaW50ZWxfZ3VjICpndWMpCit7CisJc3RydWN0 IGludGVsX2d0ICpndCA9IGd1Y190b19ndChndWMpOworCXN0cnVjdCBpbnRlbF9lbmdpbmVfY3Mg KmVuZ2luZTsKKwllbnVtIGludGVsX2VuZ2luZV9pZCBpZDsKKwlzdHJ1Y3QgdGVtcF9yZWdzZXQg dGVtcF9zZXQ7CisJdTMyIHRvdGFsOworCisJLyoKKwkgKiBOZWVkIHRvIGFjdHVhbGx5IGJ1aWxk IHRoZSBsaXN0IGluIG9yZGVyIHRvIGZpbHRlciBvdXQKKwkgKiBkdXBsaWNhdGVzIGFuZCBvdGhl ciBzdWNoIGRhdGEgZGVwZW5kZW50IGNvbnN0cnVjdGlvbnMuCisJICovCisJdGVtcF9zZXQuc2l6 ZSA9IE1BWF9NTUlPX1JFR1M7CisJdGVtcF9zZXQucmVnaXN0ZXJzID0ga21hbGxvY19hcnJheSh0 ZW1wX3NldC5zaXplLAorCQkJCQkgIHNpemVvZigqdGVtcF9zZXQucmVnaXN0ZXJzKSwKKwkJCQkJ ICBHRlBfS0VSTkVMKTsKKwlpZiAoIXRlbXBfc2V0LnJlZ2lzdGVycykKKwkJcmV0dXJuIC1FTk9N RU07CisKKwl0b3RhbCA9IDA7CisJZm9yX2VhY2hfZW5naW5lKGVuZ2luZSwgZ3QsIGlkKSB7CisJ CWd1Y19tbWlvX3JlZ3NldF9pbml0KCZ0ZW1wX3NldCwgZW5naW5lKTsKKwkJdG90YWwgKz0gdGVt cF9zZXQudXNlZDsKKwl9CisKKwlrZnJlZSh0ZW1wX3NldC5yZWdpc3RlcnMpOworCisJcmV0dXJu IHRvdGFsICogc2l6ZW9mKHN0cnVjdCBndWNfbW1pb19yZWcpOworfQorCitzdGF0aWMgdm9pZCBn dWNfbW1pb19yZWdfc3RhdGVfaW5pdChzdHJ1Y3QgaW50ZWxfZ3VjICpndWMsCisJCQkJICAgIHN0 cnVjdCBfX2d1Y19hZHNfYmxvYiAqYmxvYikKK3sKKwlzdHJ1Y3QgaW50ZWxfZ3QgKmd0ID0gZ3Vj X3RvX2d0KGd1Yyk7CisJc3RydWN0IGludGVsX2VuZ2luZV9jcyAqZW5naW5lOworCWVudW0gaW50 ZWxfZW5naW5lX2lkIGlkOworCXN0cnVjdCB0ZW1wX3JlZ3NldCB0ZW1wX3NldDsKKwlzdHJ1Y3Qg Z3VjX21taW9fcmVnX3NldCAqYWRzX3JlZ19zZXQ7CisJdTMyIGFkZHJfZ2d0dCwgb2Zmc2V0Owor CXU4IGd1Y19jbGFzczsKKworCW9mZnNldCA9IGd1Y19hZHNfcmVnc2V0X29mZnNldChndWMpOwor CWFkZHJfZ2d0dCA9IGludGVsX2d1Y19nZ3R0X29mZnNldChndWMsIGd1Yy0+YWRzX3ZtYSkgKyBv ZmZzZXQ7CisJdGVtcF9zZXQucmVnaXN0ZXJzID0gKHN0cnVjdCBndWNfbW1pb19yZWcgKikgKCgo dTggKikgYmxvYikgKyBvZmZzZXQpOworCXRlbXBfc2V0LnNpemUgPSBndWMtPmFkc19yZWdzZXRf c2l6ZSAvIHNpemVvZih0ZW1wX3NldC5yZWdpc3RlcnNbMF0pOworCisJZm9yX2VhY2hfZW5naW5l KGVuZ2luZSwgZ3QsIGlkKSB7CisJCS8qIENsYXNzIGluZGV4IGlzIGNoZWNrZWQgaW4gY2xhc3Mg Y29udmVydGVyICovCisJCUdFTV9CVUdfT04oZW5naW5lLT5pbnN0YW5jZSA+PSBHVUNfTUFYX0lO U1RBTkNFU19QRVJfQ0xBU1MpOworCisJCWd1Y19jbGFzcyA9IGVuZ2luZV9jbGFzc190b19ndWNf Y2xhc3MoZW5naW5lLT5jbGFzcyk7CisJCWFkc19yZWdfc2V0ID0gJmJsb2ItPmFkcy5yZWdfc3Rh dGVfbGlzdFtndWNfY2xhc3NdW2VuZ2luZS0+aW5zdGFuY2VdOworCisJCWd1Y19tbWlvX3JlZ3Nl dF9pbml0KCZ0ZW1wX3NldCwgZW5naW5lKTsKKwkJaWYgKCF0ZW1wX3NldC51c2VkKSB7CisJCQlh ZHNfcmVnX3NldC0+YWRkcmVzcyA9IDA7CisJCQlhZHNfcmVnX3NldC0+Y291bnQgPSAwOworCQkJ Y29udGludWU7CisJCX0KKworCQlhZHNfcmVnX3NldC0+YWRkcmVzcyA9IGFkZHJfZ2d0dDsKKwkJ YWRzX3JlZ19zZXQtPmNvdW50ID0gdGVtcF9zZXQudXNlZDsKKworCQl0ZW1wX3NldC5zaXplIC09 IHRlbXBfc2V0LnVzZWQ7CisJCXRlbXBfc2V0LnJlZ2lzdGVycyArPSB0ZW1wX3NldC51c2VkOwor CQlhZGRyX2dndHQgKz0gdGVtcF9zZXQudXNlZCAqIHNpemVvZihzdHJ1Y3QgZ3VjX21taW9fcmVn KTsKKwl9CisKKwlHRU1fQlVHX09OKHRlbXBfc2V0LnNpemUpOworfQorCiAvKgogICogVGhlIGZp cnN0IDgwIGR3b3JkcyBvZiB0aGUgcmVnaXN0ZXIgc3RhdGUgY29udGV4dCwgY29udGFpbmluZyB0 aGUKICAqIGV4ZWNsaXN0cyBhbmQgcHBndHQgcmVnaXN0ZXJzLgpAQCAtMTI0LDggKzMwNyw3IEBA IHN0YXRpYyB2b2lkIF9fZ3VjX2Fkc19pbml0KHN0cnVjdCBpbnRlbF9ndWMgKmd1YykKIAkJICov CiAJCWJsb2ItPmFkcy5nb2xkZW5fY29udGV4dF9scmNhW2d1Y19jbGFzc10gPSAwOwogCQlibG9i LT5hZHMuZW5nX3N0YXRlX3NpemVbZ3VjX2NsYXNzXSA9Ci0JCQlpbnRlbF9lbmdpbmVfY29udGV4 dF9zaXplKGd1Y190b19ndChndWMpLAotCQkJCQkJICBlbmdpbmVfY2xhc3MpIC0KKwkJCWludGVs X2VuZ2luZV9jb250ZXh0X3NpemUoZ3QsIGVuZ2luZV9jbGFzcykgLQogCQkJc2tpcHBlZF9zaXpl OwogCX0KIApAQCAtMTYwLDYgKzM0Miw5IEBAIHN0YXRpYyB2b2lkIF9fZ3VjX2Fkc19pbml0KHN0 cnVjdCBpbnRlbF9ndWMgKmd1YykKIAlibG9iLT5hZHMuZ3Rfc3lzdGVtX2luZm8gPSBiYXNlICsg cHRyX29mZnNldChibG9iLCBzeXN0ZW1faW5mbyk7CiAJYmxvYi0+YWRzLmNsaWVudHNfaW5mbyA9 IGJhc2UgKyBwdHJfb2Zmc2V0KGJsb2IsIGNsaWVudHNfaW5mbyk7CiAKKwkvKiBNTUlPIHNhdmUv cmVzdG9yZSBsaXN0ICovCisJZ3VjX21taW9fcmVnX3N0YXRlX2luaXQoZ3VjLCBibG9iKTsKKwog CS8qIFByaXZhdGUgRGF0YSAqLwogCWJsb2ItPmFkcy5wcml2YXRlX2RhdGEgPSBiYXNlICsgZ3Vj X2Fkc19wcml2YXRlX2RhdGFfb2Zmc2V0KGd1Yyk7CiAKQEAgLTE4MCw2ICszNjUsMTIgQEAgaW50 IGludGVsX2d1Y19hZHNfY3JlYXRlKHN0cnVjdCBpbnRlbF9ndWMgKmd1YykKIAogCUdFTV9CVUdf T04oZ3VjLT5hZHNfdm1hKTsKIAorCS8qIE5lZWQgdG8gY2FsY3VsYXRlIHRoZSByZWcgc3RhdGUg c2l6ZSBkeW5hbWljYWxseTogKi8KKwlyZXQgPSBndWNfbW1pb19yZWdfc3RhdGVfcXVlcnkoZ3Vj KTsKKwlpZiAocmV0IDwgMCkKKwkJcmV0dXJuIHJldDsKKwlndWMtPmFkc19yZWdzZXRfc2l6ZSA9 IHJldDsKKwogCXNpemUgPSBndWNfYWRzX2Jsb2Jfc2l6ZShndWMpOwogCiAJcmV0ID0gaW50ZWxf Z3VjX2FsbG9jYXRlX2FuZF9tYXBfdm1hKGd1Yywgc2l6ZSwgJmd1Yy0+YWRzX3ZtYSwKZGlmZiAt LWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfcmVnLmggYi9kcml2ZXJzL2dwdS9kcm0v aTkxNS9pOTE1X3JlZy5oCmluZGV4IGRiMTUxYjUyMjgyNS4uZTc5ODhiNDgxMmYzIDEwMDY0NAot LS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X3JlZy5oCisrKyBiL2RyaXZlcnMvZ3B1L2Ry bS9pOTE1L2k5MTVfcmVnLmgKQEAgLTEyMTY2LDYgKzEyMTY2LDcgQEAgZW51bSBza2xfcG93ZXJf Z2F0ZSB7CiAKIC8qIE1PQ1MgKE1lbW9yeSBPYmplY3QgQ29udHJvbCBTdGF0ZSkgcmVnaXN0ZXJz ICovCiAjZGVmaW5lIEdFTjlfTE5DRkNNT0NTKGkpCV9NTUlPKDB4YjAyMCArIChpKSAqIDQpCS8q IEwzIENhY2hlIENvbnRyb2wgKi8KKyNkZWZpbmUgR0VOOV9MTkNGQ01PQ1NfUkVHX0NPVU5UCTMy CiAKICNkZWZpbmUgX19HRU45X1JDUzBfTU9DUzAJMHhjODAwCiAjZGVmaW5lIEdFTjlfR0ZYX01P Q1MoaSkJX01NSU8oX19HRU45X1JDUzBfTU9DUzAgKyAoaSkgKiA0KQotLSAKMi4yOC4wCgpfX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpJbnRlbC1nZnggbWFp bGluZyBsaXN0CkludGVsLWdmeEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5m cmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9pbnRlbC1nZngK