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 732A2C47094 for ; Thu, 10 Jun 2021 04:19:24 +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 45A446109E for ; Thu, 10 Jun 2021 04:19:24 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 45A446109E 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 93F476E822; Thu, 10 Jun 2021 04:19:04 +0000 (UTC) Received: from mga04.intel.com (mga04.intel.com [192.55.52.120]) by gabe.freedesktop.org (Postfix) with ESMTPS id 94F126E454; Thu, 10 Jun 2021 04:19:00 +0000 (UTC) IronPort-SDR: A0zbFesmtbweQSI2mlBMgedwhozaAA9EJNo+k2wueSkBdx9F03EoRzALARqPbone/cPWv+4tvf QQealIYS9I8A== X-IronPort-AV: E=McAfee;i="6200,9189,10010"; a="203373006" X-IronPort-AV: E=Sophos;i="5.83,262,1616482800"; d="scan'208";a="203373006" Received: from fmsmga002.fm.intel.com ([10.253.24.26]) by fmsmga104.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 09 Jun 2021 21:19:00 -0700 IronPort-SDR: BmEVoosAZu3yc5I7OFFtikk0mdrxBsBC7Y5z96q8qUh/qoc6DK+5j7H28+F/gHCpPrZ5IiWrWd sXkx/niwvO4Q== X-IronPort-AV: E=Sophos;i="5.83,262,1616482800"; d="scan'208";a="485997252" Received: from dhiatt-server.jf.intel.com ([10.54.81.3]) by fmsmga002-auth.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 09 Jun 2021 21:18:59 -0700 From: Matthew Brost To: , Subject: [PATCH 02/13] drm/i915/guc: Update MMIO based communication Date: Wed, 9 Jun 2021 21:36:38 -0700 Message-Id: <20210610043649.144416-3-matthew.brost@intel.com> X-Mailer: git-send-email 2.28.0 In-Reply-To: <20210610043649.144416-1-matthew.brost@intel.com> References: <20210610043649.144416-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: daniele.ceraolospurio@intel.com, john.c.harrison@intel.com, Michal.Wajdeczko@intel.com Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" From: Michal Wajdeczko The MMIO based Host-to-GuC communication protocol has been updated to use unified HXG messages. Update our intel_guc_send_mmio() function by correctly handle BUSY, RETRY and FAILURE replies. Also update our documentation. Since some of the new MMIO actions may use DATA0 from MMIO HXG response, we must update intel_guc_send_mmio() to copy full response, including HXG header. There will be no impact to existing users as all of them are only relying just on return code. v2: (Daniele) - preffered -> preferred - Max MMIO DW set to 4 - Update commit message GuC: 55.0.0 Signed-off-by: Matthew Brost Signed-off-by: Michal Wajdeczko Cc: Piotr Piórkowski Cc: Michal Winiarski #v3 --- .../gt/uc/abi/guc_communication_mmio_abi.h | 65 +++++++------ drivers/gpu/drm/i915/gt/uc/intel_guc.c | 92 ++++++++++++++----- 2 files changed, 98 insertions(+), 59 deletions(-) diff --git a/drivers/gpu/drm/i915/gt/uc/abi/guc_communication_mmio_abi.h b/drivers/gpu/drm/i915/gt/uc/abi/guc_communication_mmio_abi.h index be066a62e9e0..bbf1ddb77434 100644 --- a/drivers/gpu/drm/i915/gt/uc/abi/guc_communication_mmio_abi.h +++ b/drivers/gpu/drm/i915/gt/uc/abi/guc_communication_mmio_abi.h @@ -7,46 +7,43 @@ #define _ABI_GUC_COMMUNICATION_MMIO_ABI_H /** - * DOC: MMIO based communication + * DOC: GuC MMIO based communication * - * The MMIO based communication between Host and GuC uses software scratch - * registers, where first register holds data treated as message header, - * and other registers are used to hold message payload. + * The MMIO based communication between Host and GuC relies on special + * hardware registers which format could be defined by the software + * (so called scratch registers). * - * For Gen9+, GuC uses software scratch registers 0xC180-0xC1B8, - * but no H2G command takes more than 8 parameters and the GuC FW - * itself uses an 8-element array to store the H2G message. + * Each MMIO based message, both Host to GuC (H2G) and GuC to Host (G2H) + * messages, which maximum length depends on number of available scratch + * registers, is directly written into those scratch registers. * - * +-----------+---------+---------+---------+ - * | MMIO[0] | MMIO[1] | ... | MMIO[n] | - * +-----------+---------+---------+---------+ - * | header | optional payload | - * +======+====+=========+=========+=========+ - * | 31:28|type| | | | - * +------+----+ | | | - * | 27:16|data| | | | - * +------+----+ | | | - * | 15:0|code| | | | - * +------+----+---------+---------+---------+ + * For Gen9+, there are 16 software scratch registers 0xC180-0xC1B8, + * but no H2G command takes more than 4 parameters and the GuC firmware + * itself uses an 4-element array to store the H2G message. * - * The message header consists of: + * For Gen11+, there are additional 4 registers 0x190240-0x19024C, which + * are, regardless on lower count, preferred over legacy ones. * - * - **type**, indicates message type - * - **code**, indicates message code, is specific for **type** - * - **data**, indicates message data, optional, depends on **code** - * - * The following message **types** are supported: - * - * - **REQUEST**, indicates Host-to-GuC request, requested GuC action code - * must be priovided in **code** field. Optional action specific parameters - * can be provided in remaining payload registers or **data** field. - * - * - **RESPONSE**, indicates GuC-to-Host response from earlier GuC request, - * action response status will be provided in **code** field. Optional - * response data can be returned in remaining payload registers or **data** - * field. + * The MMIO based communication is mainly used during driver initialization + * phase to setup the `CTB based communication`_ that will be used afterwards. */ -#define GUC_MAX_MMIO_MSG_LEN 8 +#define GUC_MAX_MMIO_MSG_LEN 4 + +/** + * DOC: MMIO HXG Message + * + * Format of the MMIO messages follows definitions of `HXG Message`_. + * + * +---+-------+--------------------------------------------------------------+ + * | | Bits | Description | + * +===+=======+==============================================================+ + * | 0 | 31:0 | +--------------------------------------------------------+ | + * +---+-------+ | | | + * |...| | | Embedded `HXG Message`_ | | + * +---+-------+ | | | + * | n | 31:0 | +--------------------------------------------------------+ | + * +---+-------+--------------------------------------------------------------+ + */ #endif /* _ABI_GUC_COMMUNICATION_MMIO_ABI_H */ diff --git a/drivers/gpu/drm/i915/gt/uc/intel_guc.c b/drivers/gpu/drm/i915/gt/uc/intel_guc.c index f147cb389a20..b773567cb080 100644 --- a/drivers/gpu/drm/i915/gt/uc/intel_guc.c +++ b/drivers/gpu/drm/i915/gt/uc/intel_guc.c @@ -376,29 +376,27 @@ void intel_guc_fini(struct intel_guc *guc) /* * This function implements the MMIO based host to GuC interface. */ -int intel_guc_send_mmio(struct intel_guc *guc, const u32 *action, u32 len, +int intel_guc_send_mmio(struct intel_guc *guc, const u32 *request, u32 len, u32 *response_buf, u32 response_buf_size) { + struct drm_i915_private *i915 = guc_to_gt(guc)->i915; struct intel_uncore *uncore = guc_to_gt(guc)->uncore; - u32 status; + u32 header; int i; int ret; GEM_BUG_ON(!len); GEM_BUG_ON(len > guc->send_regs.count); - /* We expect only action code */ - GEM_BUG_ON(*action & ~INTEL_GUC_MSG_CODE_MASK); - - /* If CT is available, we expect to use MMIO only during init/fini */ - GEM_BUG_ON(*action != INTEL_GUC_ACTION_REGISTER_COMMAND_TRANSPORT_BUFFER && - *action != INTEL_GUC_ACTION_DEREGISTER_COMMAND_TRANSPORT_BUFFER); + GEM_BUG_ON(FIELD_GET(GUC_HXG_MSG_0_ORIGIN, request[0]) != GUC_HXG_ORIGIN_HOST); + GEM_BUG_ON(FIELD_GET(GUC_HXG_MSG_0_TYPE, request[0]) != GUC_HXG_TYPE_REQUEST); mutex_lock(&guc->send_mutex); intel_uncore_forcewake_get(uncore, guc->send_regs.fw_domains); +retry: for (i = 0; i < len; i++) - intel_uncore_write(uncore, guc_send_reg(guc, i), action[i]); + intel_uncore_write(uncore, guc_send_reg(guc, i), request[i]); intel_uncore_posting_read(uncore, guc_send_reg(guc, i - 1)); @@ -410,30 +408,74 @@ int intel_guc_send_mmio(struct intel_guc *guc, const u32 *action, u32 len, */ ret = __intel_wait_for_register_fw(uncore, guc_send_reg(guc, 0), - INTEL_GUC_MSG_TYPE_MASK, - INTEL_GUC_MSG_TYPE_RESPONSE << - INTEL_GUC_MSG_TYPE_SHIFT, - 10, 10, &status); - /* If GuC explicitly returned an error, convert it to -EIO */ - if (!ret && !INTEL_GUC_MSG_IS_RESPONSE_SUCCESS(status)) - ret = -EIO; + GUC_HXG_MSG_0_ORIGIN, + FIELD_PREP(GUC_HXG_MSG_0_ORIGIN, + GUC_HXG_ORIGIN_GUC), + 10, 10, &header); + if (unlikely(ret)) { +timeout: + drm_err(&i915->drm, "mmio request %#x: no reply %x\n", + request[0], header); + goto out; + } - if (ret) { - DRM_ERROR("MMIO: GuC action %#x failed with error %d %#x\n", - action[0], ret, status); + if (FIELD_GET(GUC_HXG_MSG_0_TYPE, header) == GUC_HXG_TYPE_NO_RESPONSE_BUSY) { +#define done ({ header = intel_uncore_read(uncore, guc_send_reg(guc, 0)); \ + FIELD_GET(GUC_HXG_MSG_0_ORIGIN, header) != GUC_HXG_ORIGIN_GUC || \ + FIELD_GET(GUC_HXG_MSG_0_TYPE, header) != GUC_HXG_TYPE_NO_RESPONSE_BUSY; }) + + ret = wait_for(done, 1000); + if (unlikely(ret)) + goto timeout; + if (unlikely(FIELD_GET(GUC_HXG_MSG_0_ORIGIN, header) != + GUC_HXG_ORIGIN_GUC)) + goto proto; +#undef done + } + + if (FIELD_GET(GUC_HXG_MSG_0_TYPE, header) == GUC_HXG_TYPE_NO_RESPONSE_RETRY) { + u32 reason = FIELD_GET(GUC_HXG_RETRY_MSG_0_REASON, header); + + drm_dbg(&i915->drm, "mmio request %#x: retrying, reason %u\n", + request[0], reason); + goto retry; + } + + if (FIELD_GET(GUC_HXG_MSG_0_TYPE, header) == GUC_HXG_TYPE_RESPONSE_FAILURE) { + u32 hint = FIELD_GET(GUC_HXG_FAILURE_MSG_0_HINT, header); + u32 error = FIELD_GET(GUC_HXG_FAILURE_MSG_0_ERROR, header); + + drm_err(&i915->drm, "mmio request %#x: failure %x/%u\n", + request[0], error, hint); + ret = -ENXIO; + goto out; + } + + if (FIELD_GET(GUC_HXG_MSG_0_TYPE, header) != GUC_HXG_TYPE_RESPONSE_SUCCESS) { +proto: + drm_err(&i915->drm, "mmio request %#x: unexpected reply %#x\n", + request[0], header); + ret = -EPROTO; goto out; } if (response_buf) { - int count = min(response_buf_size, guc->send_regs.count - 1); + int count = min(response_buf_size, guc->send_regs.count); - for (i = 0; i < count; i++) + GEM_BUG_ON(!count); + + response_buf[0] = header; + + for (i = 1; i < count; i++) response_buf[i] = intel_uncore_read(uncore, - guc_send_reg(guc, i + 1)); - } + guc_send_reg(guc, i)); - /* Use data from the GuC response as our return value */ - ret = INTEL_GUC_MSG_TO_DATA(status); + /* Use number of copied dwords as our return value */ + ret = count; + } else { + /* Use data from the GuC response as our return value */ + ret = FIELD_GET(GUC_HXG_RESPONSE_MSG_0_DATA0, header); + } out: intel_uncore_forcewake_put(uncore, guc->send_regs.fw_domains); -- 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 268BBC47094 for ; Thu, 10 Jun 2021 04:19:06 +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 E71D461019 for ; Thu, 10 Jun 2021 04:19:05 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org E71D461019 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 8BEE36E45D; Thu, 10 Jun 2021 04:19:01 +0000 (UTC) Received: from mga04.intel.com (mga04.intel.com [192.55.52.120]) by gabe.freedesktop.org (Postfix) with ESMTPS id 94F126E454; Thu, 10 Jun 2021 04:19:00 +0000 (UTC) IronPort-SDR: A0zbFesmtbweQSI2mlBMgedwhozaAA9EJNo+k2wueSkBdx9F03EoRzALARqPbone/cPWv+4tvf QQealIYS9I8A== X-IronPort-AV: E=McAfee;i="6200,9189,10010"; a="203373006" X-IronPort-AV: E=Sophos;i="5.83,262,1616482800"; d="scan'208";a="203373006" Received: from fmsmga002.fm.intel.com ([10.253.24.26]) by fmsmga104.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 09 Jun 2021 21:19:00 -0700 IronPort-SDR: BmEVoosAZu3yc5I7OFFtikk0mdrxBsBC7Y5z96q8qUh/qoc6DK+5j7H28+F/gHCpPrZ5IiWrWd sXkx/niwvO4Q== X-IronPort-AV: E=Sophos;i="5.83,262,1616482800"; d="scan'208";a="485997252" Received: from dhiatt-server.jf.intel.com ([10.54.81.3]) by fmsmga002-auth.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 09 Jun 2021 21:18:59 -0700 From: Matthew Brost To: , Date: Wed, 9 Jun 2021 21:36:38 -0700 Message-Id: <20210610043649.144416-3-matthew.brost@intel.com> X-Mailer: git-send-email 2.28.0 In-Reply-To: <20210610043649.144416-1-matthew.brost@intel.com> References: <20210610043649.144416-1-matthew.brost@intel.com> MIME-Version: 1.0 Subject: [Intel-gfx] [PATCH 02/13] drm/i915/guc: Update MMIO based communication 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: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" RnJvbTogTWljaGFsIFdhamRlY3prbyA8bWljaGFsLndhamRlY3prb0BpbnRlbC5jb20+CgpUaGUg TU1JTyBiYXNlZCBIb3N0LXRvLUd1QyBjb21tdW5pY2F0aW9uIHByb3RvY29sIGhhcyBiZWVuCnVw ZGF0ZWQgdG8gdXNlIHVuaWZpZWQgSFhHIG1lc3NhZ2VzLgoKVXBkYXRlIG91ciBpbnRlbF9ndWNf c2VuZF9tbWlvKCkgZnVuY3Rpb24gYnkgY29ycmVjdGx5IGhhbmRsZQpCVVNZLCBSRVRSWSBhbmQg RkFJTFVSRSByZXBsaWVzLiBBbHNvIHVwZGF0ZSBvdXIgZG9jdW1lbnRhdGlvbi4KClNpbmNlIHNv bWUgb2YgdGhlIG5ldyBNTUlPIGFjdGlvbnMgbWF5IHVzZSBEQVRBMCBmcm9tIE1NSU8gSFhHCnJl c3BvbnNlLCB3ZSBtdXN0IHVwZGF0ZSBpbnRlbF9ndWNfc2VuZF9tbWlvKCkgdG8gY29weSBmdWxs IHJlc3BvbnNlLAppbmNsdWRpbmcgSFhHIGhlYWRlci4gVGhlcmUgd2lsbCBiZSBubyBpbXBhY3Qg dG8gZXhpc3RpbmcgdXNlcnMgYXMgYWxsCm9mIHRoZW0gYXJlIG9ubHkgcmVseWluZyBqdXN0IG9u IHJldHVybiBjb2RlLgoKdjI6CiAoRGFuaWVsZSkKICAtIHByZWZmZXJlZCAtPiBwcmVmZXJyZWQK ICAtIE1heCBNTUlPIERXIHNldCB0byA0CiAgLSBVcGRhdGUgY29tbWl0IG1lc3NhZ2UKCkd1Qzog NTUuMC4wClNpZ25lZC1vZmYtYnk6IE1hdHRoZXcgQnJvc3QgPG1hdHRoZXcuYnJvc3RAaW50ZWwu Y29tPgpTaWduZWQtb2ZmLWJ5OiBNaWNoYWwgV2FqZGVjemtvIDxtaWNoYWwud2FqZGVjemtvQGlu dGVsLmNvbT4KQ2M6IFBpb3RyIFBpw7Nya293c2tpIDxwaW90ci5waW9ya293c2tpQGludGVsLmNv bT4KQ2M6IE1pY2hhbCBXaW5pYXJza2kgPG1pY2hhbC53aW5pYXJza2lAaW50ZWwuY29tPiAjdjMK LS0tCiAuLi4vZ3QvdWMvYWJpL2d1Y19jb21tdW5pY2F0aW9uX21taW9fYWJpLmggICAgfCA2NSAr KysrKysrLS0tLS0tCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC91Yy9pbnRlbF9ndWMuYyAgICAg ICAgfCA5MiArKysrKysrKysrKysrKy0tLS0tCiAyIGZpbGVzIGNoYW5nZWQsIDk4IGluc2VydGlv bnMoKyksIDU5IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1 L2d0L3VjL2FiaS9ndWNfY29tbXVuaWNhdGlvbl9tbWlvX2FiaS5oIGIvZHJpdmVycy9ncHUvZHJt L2k5MTUvZ3QvdWMvYWJpL2d1Y19jb21tdW5pY2F0aW9uX21taW9fYWJpLmgKaW5kZXggYmUwNjZh NjJlOWUwLi5iYmYxZGRiNzc0MzQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0 L3VjL2FiaS9ndWNfY29tbXVuaWNhdGlvbl9tbWlvX2FiaS5oCisrKyBiL2RyaXZlcnMvZ3B1L2Ry bS9pOTE1L2d0L3VjL2FiaS9ndWNfY29tbXVuaWNhdGlvbl9tbWlvX2FiaS5oCkBAIC03LDQ2ICs3 LDQzIEBACiAjZGVmaW5lIF9BQklfR1VDX0NPTU1VTklDQVRJT05fTU1JT19BQklfSAogCiAvKioK LSAqIERPQzogTU1JTyBiYXNlZCBjb21tdW5pY2F0aW9uCisgKiBET0M6IEd1QyBNTUlPIGJhc2Vk IGNvbW11bmljYXRpb24KICAqCi0gKiBUaGUgTU1JTyBiYXNlZCBjb21tdW5pY2F0aW9uIGJldHdl ZW4gSG9zdCBhbmQgR3VDIHVzZXMgc29mdHdhcmUgc2NyYXRjaAotICogcmVnaXN0ZXJzLCB3aGVy ZSBmaXJzdCByZWdpc3RlciBob2xkcyBkYXRhIHRyZWF0ZWQgYXMgbWVzc2FnZSBoZWFkZXIsCi0g KiBhbmQgb3RoZXIgcmVnaXN0ZXJzIGFyZSB1c2VkIHRvIGhvbGQgbWVzc2FnZSBwYXlsb2FkLgor ICogVGhlIE1NSU8gYmFzZWQgY29tbXVuaWNhdGlvbiBiZXR3ZWVuIEhvc3QgYW5kIEd1QyByZWxp ZXMgb24gc3BlY2lhbAorICogaGFyZHdhcmUgcmVnaXN0ZXJzIHdoaWNoIGZvcm1hdCBjb3VsZCBi ZSBkZWZpbmVkIGJ5IHRoZSBzb2Z0d2FyZQorICogKHNvIGNhbGxlZCBzY3JhdGNoIHJlZ2lzdGVy cykuCiAgKgotICogRm9yIEdlbjkrLCBHdUMgdXNlcyBzb2Z0d2FyZSBzY3JhdGNoIHJlZ2lzdGVy cyAweEMxODAtMHhDMUI4LAotICogYnV0IG5vIEgyRyBjb21tYW5kIHRha2VzIG1vcmUgdGhhbiA4 IHBhcmFtZXRlcnMgYW5kIHRoZSBHdUMgRlcKLSAqIGl0c2VsZiB1c2VzIGFuIDgtZWxlbWVudCBh cnJheSB0byBzdG9yZSB0aGUgSDJHIG1lc3NhZ2UuCisgKiBFYWNoIE1NSU8gYmFzZWQgbWVzc2Fn ZSwgYm90aCBIb3N0IHRvIEd1QyAoSDJHKSBhbmQgR3VDIHRvIEhvc3QgKEcySCkKKyAqIG1lc3Nh Z2VzLCB3aGljaCBtYXhpbXVtIGxlbmd0aCBkZXBlbmRzIG9uIG51bWJlciBvZiBhdmFpbGFibGUg c2NyYXRjaAorICogcmVnaXN0ZXJzLCBpcyBkaXJlY3RseSB3cml0dGVuIGludG8gdGhvc2Ugc2Ny YXRjaCByZWdpc3RlcnMuCiAgKgotICogICAgICArLS0tLS0tLS0tLS0rLS0tLS0tLS0tKy0tLS0t LS0tLSstLS0tLS0tLS0rCi0gKiAgICAgIHwgIE1NSU9bMF0gIHwgTU1JT1sxXSB8ICAgLi4uICAg fCBNTUlPW25dIHwKLSAqICAgICAgKy0tLS0tLS0tLS0tKy0tLS0tLS0tLSstLS0tLS0tLS0rLS0t LS0tLS0tKwotICogICAgICB8IGhlYWRlciAgICB8ICAgICAgb3B0aW9uYWwgcGF5bG9hZCAgICAg ICB8Ci0gKiAgICAgICs9PT09PT0rPT09PSs9PT09PT09PT0rPT09PT09PT09Kz09PT09PT09PSsK LSAqICAgICAgfCAzMToyOHx0eXBlfCAgICAgICAgIHwgICAgICAgICB8ICAgICAgICAgfAotICog ICAgICArLS0tLS0tKy0tLS0rICAgICAgICAgfCAgICAgICAgIHwgICAgICAgICB8Ci0gKiAgICAg IHwgMjc6MTZ8ZGF0YXwgICAgICAgICB8ICAgICAgICAgfCAgICAgICAgIHwKLSAqICAgICAgKy0t LS0tLSstLS0tKyAgICAgICAgIHwgICAgICAgICB8ICAgICAgICAgfAotICogICAgICB8ICAxNTow fGNvZGV8ICAgICAgICAgfCAgICAgICAgIHwgICAgICAgICB8Ci0gKiAgICAgICstLS0tLS0rLS0t LSstLS0tLS0tLS0rLS0tLS0tLS0tKy0tLS0tLS0tLSsKKyAqIEZvciBHZW45KywgdGhlcmUgYXJl IDE2IHNvZnR3YXJlIHNjcmF0Y2ggcmVnaXN0ZXJzIDB4QzE4MC0weEMxQjgsCisgKiBidXQgbm8g SDJHIGNvbW1hbmQgdGFrZXMgbW9yZSB0aGFuIDQgcGFyYW1ldGVycyBhbmQgdGhlIEd1QyBmaXJt d2FyZQorICogaXRzZWxmIHVzZXMgYW4gNC1lbGVtZW50IGFycmF5IHRvIHN0b3JlIHRoZSBIMkcg bWVzc2FnZS4KICAqCi0gKiBUaGUgbWVzc2FnZSBoZWFkZXIgY29uc2lzdHMgb2Y6CisgKiBGb3Ig R2VuMTErLCB0aGVyZSBhcmUgYWRkaXRpb25hbCA0IHJlZ2lzdGVycyAweDE5MDI0MC0weDE5MDI0 Qywgd2hpY2gKKyAqIGFyZSwgcmVnYXJkbGVzcyBvbiBsb3dlciBjb3VudCwgcHJlZmVycmVkIG92 ZXIgbGVnYWN5IG9uZXMuCiAgKgotICogLSAqKnR5cGUqKiwgaW5kaWNhdGVzIG1lc3NhZ2UgdHlw ZQotICogLSAqKmNvZGUqKiwgaW5kaWNhdGVzIG1lc3NhZ2UgY29kZSwgaXMgc3BlY2lmaWMgZm9y ICoqdHlwZSoqCi0gKiAtICoqZGF0YSoqLCBpbmRpY2F0ZXMgbWVzc2FnZSBkYXRhLCBvcHRpb25h bCwgZGVwZW5kcyBvbiAqKmNvZGUqKgotICoKLSAqIFRoZSBmb2xsb3dpbmcgbWVzc2FnZSAqKnR5 cGVzKiogYXJlIHN1cHBvcnRlZDoKLSAqCi0gKiAtICoqUkVRVUVTVCoqLCBpbmRpY2F0ZXMgSG9z dC10by1HdUMgcmVxdWVzdCwgcmVxdWVzdGVkIEd1QyBhY3Rpb24gY29kZQotICogICBtdXN0IGJl IHByaW92aWRlZCBpbiAqKmNvZGUqKiBmaWVsZC4gT3B0aW9uYWwgYWN0aW9uIHNwZWNpZmljIHBh cmFtZXRlcnMKLSAqICAgY2FuIGJlIHByb3ZpZGVkIGluIHJlbWFpbmluZyBwYXlsb2FkIHJlZ2lz dGVycyBvciAqKmRhdGEqKiBmaWVsZC4KLSAqCi0gKiAtICoqUkVTUE9OU0UqKiwgaW5kaWNhdGVz IEd1Qy10by1Ib3N0IHJlc3BvbnNlIGZyb20gZWFybGllciBHdUMgcmVxdWVzdCwKLSAqICAgYWN0 aW9uIHJlc3BvbnNlIHN0YXR1cyB3aWxsIGJlIHByb3ZpZGVkIGluICoqY29kZSoqIGZpZWxkLiBP cHRpb25hbAotICogICByZXNwb25zZSBkYXRhIGNhbiBiZSByZXR1cm5lZCBpbiByZW1haW5pbmcg cGF5bG9hZCByZWdpc3RlcnMgb3IgKipkYXRhKioKLSAqICAgZmllbGQuCisgKiBUaGUgTU1JTyBi YXNlZCBjb21tdW5pY2F0aW9uIGlzIG1haW5seSB1c2VkIGR1cmluZyBkcml2ZXIgaW5pdGlhbGl6 YXRpb24KKyAqIHBoYXNlIHRvIHNldHVwIHRoZSBgQ1RCIGJhc2VkIGNvbW11bmljYXRpb25gXyB0 aGF0IHdpbGwgYmUgdXNlZCBhZnRlcndhcmRzLgogICovCiAKLSNkZWZpbmUgR1VDX01BWF9NTUlP X01TR19MRU4JCTgKKyNkZWZpbmUgR1VDX01BWF9NTUlPX01TR19MRU4JCTQKKworLyoqCisgKiBE T0M6IE1NSU8gSFhHIE1lc3NhZ2UKKyAqCisgKiBGb3JtYXQgb2YgdGhlIE1NSU8gbWVzc2FnZXMg Zm9sbG93cyBkZWZpbml0aW9ucyBvZiBgSFhHIE1lc3NhZ2VgXy4KKyAqCisgKiAgKy0tLSstLS0t LS0tKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tKworICogIHwgICB8IEJpdHMgIHwgRGVzY3JpcHRpb24gICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwKKyAqICArPT09Kz09PT09PT0rPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0rCisgKiAgfCAwIHwgIDMxOjAgfCAgKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKyAgfAorICogICstLS0rLS0tLS0tLSsgIHwgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgIHwKKyAq ICB8Li4ufCAgICAgICB8ICB8ICBFbWJlZGRlZCBgSFhHIE1lc3NhZ2VgXyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICB8ICB8CisgKiAgKy0tLSstLS0tLS0tKyAgfCAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgfAorICogIHwgbiB8 ICAzMTowIHwgICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLSsgIHwKKyAqICArLS0tKy0tLS0tLS0rLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0rCisgKi8KIAogI2VuZGlmIC8q IF9BQklfR1VDX0NPTU1VTklDQVRJT05fTU1JT19BQklfSCAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVy cy9ncHUvZHJtL2k5MTUvZ3QvdWMvaW50ZWxfZ3VjLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9n dC91Yy9pbnRlbF9ndWMuYwppbmRleCBmMTQ3Y2IzODlhMjAuLmI3NzM1NjdjYjA4MCAxMDA2NDQK LS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvdWMvaW50ZWxfZ3VjLmMKKysrIGIvZHJpdmVy cy9ncHUvZHJtL2k5MTUvZ3QvdWMvaW50ZWxfZ3VjLmMKQEAgLTM3NiwyOSArMzc2LDI3IEBAIHZv aWQgaW50ZWxfZ3VjX2Zpbmkoc3RydWN0IGludGVsX2d1YyAqZ3VjKQogLyoKICAqIFRoaXMgZnVu Y3Rpb24gaW1wbGVtZW50cyB0aGUgTU1JTyBiYXNlZCBob3N0IHRvIEd1QyBpbnRlcmZhY2UuCiAg Ki8KLWludCBpbnRlbF9ndWNfc2VuZF9tbWlvKHN0cnVjdCBpbnRlbF9ndWMgKmd1YywgY29uc3Qg dTMyICphY3Rpb24sIHUzMiBsZW4sCitpbnQgaW50ZWxfZ3VjX3NlbmRfbW1pbyhzdHJ1Y3QgaW50 ZWxfZ3VjICpndWMsIGNvbnN0IHUzMiAqcmVxdWVzdCwgdTMyIGxlbiwKIAkJCXUzMiAqcmVzcG9u c2VfYnVmLCB1MzIgcmVzcG9uc2VfYnVmX3NpemUpCiB7CisJc3RydWN0IGRybV9pOTE1X3ByaXZh dGUgKmk5MTUgPSBndWNfdG9fZ3QoZ3VjKS0+aTkxNTsKIAlzdHJ1Y3QgaW50ZWxfdW5jb3JlICp1 bmNvcmUgPSBndWNfdG9fZ3QoZ3VjKS0+dW5jb3JlOwotCXUzMiBzdGF0dXM7CisJdTMyIGhlYWRl cjsKIAlpbnQgaTsKIAlpbnQgcmV0OwogCiAJR0VNX0JVR19PTighbGVuKTsKIAlHRU1fQlVHX09O KGxlbiA+IGd1Yy0+c2VuZF9yZWdzLmNvdW50KTsKIAotCS8qIFdlIGV4cGVjdCBvbmx5IGFjdGlv biBjb2RlICovCi0JR0VNX0JVR19PTigqYWN0aW9uICYgfklOVEVMX0dVQ19NU0dfQ09ERV9NQVNL KTsKLQotCS8qIElmIENUIGlzIGF2YWlsYWJsZSwgd2UgZXhwZWN0IHRvIHVzZSBNTUlPIG9ubHkg ZHVyaW5nIGluaXQvZmluaSAqLwotCUdFTV9CVUdfT04oKmFjdGlvbiAhPSBJTlRFTF9HVUNfQUNU SU9OX1JFR0lTVEVSX0NPTU1BTkRfVFJBTlNQT1JUX0JVRkZFUiAmJgotCQkgICAqYWN0aW9uICE9 IElOVEVMX0dVQ19BQ1RJT05fREVSRUdJU1RFUl9DT01NQU5EX1RSQU5TUE9SVF9CVUZGRVIpOwor CUdFTV9CVUdfT04oRklFTERfR0VUKEdVQ19IWEdfTVNHXzBfT1JJR0lOLCByZXF1ZXN0WzBdKSAh PSBHVUNfSFhHX09SSUdJTl9IT1NUKTsKKwlHRU1fQlVHX09OKEZJRUxEX0dFVChHVUNfSFhHX01T R18wX1RZUEUsIHJlcXVlc3RbMF0pICE9IEdVQ19IWEdfVFlQRV9SRVFVRVNUKTsKIAogCW11dGV4 X2xvY2soJmd1Yy0+c2VuZF9tdXRleCk7CiAJaW50ZWxfdW5jb3JlX2ZvcmNld2FrZV9nZXQodW5j b3JlLCBndWMtPnNlbmRfcmVncy5md19kb21haW5zKTsKIAorcmV0cnk6CiAJZm9yIChpID0gMDsg aSA8IGxlbjsgaSsrKQotCQlpbnRlbF91bmNvcmVfd3JpdGUodW5jb3JlLCBndWNfc2VuZF9yZWco Z3VjLCBpKSwgYWN0aW9uW2ldKTsKKwkJaW50ZWxfdW5jb3JlX3dyaXRlKHVuY29yZSwgZ3VjX3Nl bmRfcmVnKGd1YywgaSksIHJlcXVlc3RbaV0pOwogCiAJaW50ZWxfdW5jb3JlX3Bvc3RpbmdfcmVh ZCh1bmNvcmUsIGd1Y19zZW5kX3JlZyhndWMsIGkgLSAxKSk7CiAKQEAgLTQxMCwzMCArNDA4LDc0 IEBAIGludCBpbnRlbF9ndWNfc2VuZF9tbWlvKHN0cnVjdCBpbnRlbF9ndWMgKmd1YywgY29uc3Qg dTMyICphY3Rpb24sIHUzMiBsZW4sCiAJICovCiAJcmV0ID0gX19pbnRlbF93YWl0X2Zvcl9yZWdp c3Rlcl9mdyh1bmNvcmUsCiAJCQkJCSAgIGd1Y19zZW5kX3JlZyhndWMsIDApLAotCQkJCQkgICBJ TlRFTF9HVUNfTVNHX1RZUEVfTUFTSywKLQkJCQkJICAgSU5URUxfR1VDX01TR19UWVBFX1JFU1BP TlNFIDw8Ci0JCQkJCSAgIElOVEVMX0dVQ19NU0dfVFlQRV9TSElGVCwKLQkJCQkJICAgMTAsIDEw LCAmc3RhdHVzKTsKLQkvKiBJZiBHdUMgZXhwbGljaXRseSByZXR1cm5lZCBhbiBlcnJvciwgY29u dmVydCBpdCB0byAtRUlPICovCi0JaWYgKCFyZXQgJiYgIUlOVEVMX0dVQ19NU0dfSVNfUkVTUE9O U0VfU1VDQ0VTUyhzdGF0dXMpKQotCQlyZXQgPSAtRUlPOworCQkJCQkgICBHVUNfSFhHX01TR18w X09SSUdJTiwKKwkJCQkJICAgRklFTERfUFJFUChHVUNfSFhHX01TR18wX09SSUdJTiwKKwkJCQkJ CSAgICAgIEdVQ19IWEdfT1JJR0lOX0dVQyksCisJCQkJCSAgIDEwLCAxMCwgJmhlYWRlcik7CisJ aWYgKHVubGlrZWx5KHJldCkpIHsKK3RpbWVvdXQ6CisJCWRybV9lcnIoJmk5MTUtPmRybSwgIm1t aW8gcmVxdWVzdCAlI3g6IG5vIHJlcGx5ICV4XG4iLAorCQkJcmVxdWVzdFswXSwgaGVhZGVyKTsK KwkJZ290byBvdXQ7CisJfQogCi0JaWYgKHJldCkgewotCQlEUk1fRVJST1IoIk1NSU86IEd1QyBh Y3Rpb24gJSN4IGZhaWxlZCB3aXRoIGVycm9yICVkICUjeFxuIiwKLQkJCSAgYWN0aW9uWzBdLCBy ZXQsIHN0YXR1cyk7CisJaWYgKEZJRUxEX0dFVChHVUNfSFhHX01TR18wX1RZUEUsIGhlYWRlcikg PT0gR1VDX0hYR19UWVBFX05PX1JFU1BPTlNFX0JVU1kpIHsKKyNkZWZpbmUgZG9uZSAoeyBoZWFk ZXIgPSBpbnRlbF91bmNvcmVfcmVhZCh1bmNvcmUsIGd1Y19zZW5kX3JlZyhndWMsIDApKTsgXAor CQlGSUVMRF9HRVQoR1VDX0hYR19NU0dfMF9PUklHSU4sIGhlYWRlcikgIT0gR1VDX0hYR19PUklH SU5fR1VDIHx8IFwKKwkJRklFTERfR0VUKEdVQ19IWEdfTVNHXzBfVFlQRSwgaGVhZGVyKSAhPSBH VUNfSFhHX1RZUEVfTk9fUkVTUE9OU0VfQlVTWTsgfSkKKworCQlyZXQgPSB3YWl0X2Zvcihkb25l LCAxMDAwKTsKKwkJaWYgKHVubGlrZWx5KHJldCkpCisJCQlnb3RvIHRpbWVvdXQ7CisJCWlmICh1 bmxpa2VseShGSUVMRF9HRVQoR1VDX0hYR19NU0dfMF9PUklHSU4sIGhlYWRlcikgIT0KKwkJCQkg ICAgICAgR1VDX0hYR19PUklHSU5fR1VDKSkKKwkJCWdvdG8gcHJvdG87CisjdW5kZWYgZG9uZQor CX0KKworCWlmIChGSUVMRF9HRVQoR1VDX0hYR19NU0dfMF9UWVBFLCBoZWFkZXIpID09IEdVQ19I WEdfVFlQRV9OT19SRVNQT05TRV9SRVRSWSkgeworCQl1MzIgcmVhc29uID0gRklFTERfR0VUKEdV Q19IWEdfUkVUUllfTVNHXzBfUkVBU09OLCBoZWFkZXIpOworCisJCWRybV9kYmcoJmk5MTUtPmRy bSwgIm1taW8gcmVxdWVzdCAlI3g6IHJldHJ5aW5nLCByZWFzb24gJXVcbiIsCisJCQlyZXF1ZXN0 WzBdLCByZWFzb24pOworCQlnb3RvIHJldHJ5OworCX0KKworCWlmIChGSUVMRF9HRVQoR1VDX0hY R19NU0dfMF9UWVBFLCBoZWFkZXIpID09IEdVQ19IWEdfVFlQRV9SRVNQT05TRV9GQUlMVVJFKSB7 CisJCXUzMiBoaW50ID0gRklFTERfR0VUKEdVQ19IWEdfRkFJTFVSRV9NU0dfMF9ISU5ULCBoZWFk ZXIpOworCQl1MzIgZXJyb3IgPSBGSUVMRF9HRVQoR1VDX0hYR19GQUlMVVJFX01TR18wX0VSUk9S LCBoZWFkZXIpOworCisJCWRybV9lcnIoJmk5MTUtPmRybSwgIm1taW8gcmVxdWVzdCAlI3g6IGZh aWx1cmUgJXgvJXVcbiIsCisJCQlyZXF1ZXN0WzBdLCBlcnJvciwgaGludCk7CisJCXJldCA9IC1F TlhJTzsKKwkJZ290byBvdXQ7CisJfQorCisJaWYgKEZJRUxEX0dFVChHVUNfSFhHX01TR18wX1RZ UEUsIGhlYWRlcikgIT0gR1VDX0hYR19UWVBFX1JFU1BPTlNFX1NVQ0NFU1MpIHsKK3Byb3RvOgor CQlkcm1fZXJyKCZpOTE1LT5kcm0sICJtbWlvIHJlcXVlc3QgJSN4OiB1bmV4cGVjdGVkIHJlcGx5 ICUjeFxuIiwKKwkJCXJlcXVlc3RbMF0sIGhlYWRlcik7CisJCXJldCA9IC1FUFJPVE87CiAJCWdv dG8gb3V0OwogCX0KIAogCWlmIChyZXNwb25zZV9idWYpIHsKLQkJaW50IGNvdW50ID0gbWluKHJl c3BvbnNlX2J1Zl9zaXplLCBndWMtPnNlbmRfcmVncy5jb3VudCAtIDEpOworCQlpbnQgY291bnQg PSBtaW4ocmVzcG9uc2VfYnVmX3NpemUsIGd1Yy0+c2VuZF9yZWdzLmNvdW50KTsKIAotCQlmb3Ig KGkgPSAwOyBpIDwgY291bnQ7IGkrKykKKwkJR0VNX0JVR19PTighY291bnQpOworCisJCXJlc3Bv bnNlX2J1ZlswXSA9IGhlYWRlcjsKKworCQlmb3IgKGkgPSAxOyBpIDwgY291bnQ7IGkrKykKIAkJ CXJlc3BvbnNlX2J1ZltpXSA9IGludGVsX3VuY29yZV9yZWFkKHVuY29yZSwKLQkJCQkJCQkgICAg Z3VjX3NlbmRfcmVnKGd1YywgaSArIDEpKTsKLQl9CisJCQkJCQkJICAgIGd1Y19zZW5kX3JlZyhn dWMsIGkpKTsKIAotCS8qIFVzZSBkYXRhIGZyb20gdGhlIEd1QyByZXNwb25zZSBhcyBvdXIgcmV0 dXJuIHZhbHVlICovCi0JcmV0ID0gSU5URUxfR1VDX01TR19UT19EQVRBKHN0YXR1cyk7CisJCS8q IFVzZSBudW1iZXIgb2YgY29waWVkIGR3b3JkcyBhcyBvdXIgcmV0dXJuIHZhbHVlICovCisJCXJl dCA9IGNvdW50OworCX0gZWxzZSB7CisJCS8qIFVzZSBkYXRhIGZyb20gdGhlIEd1QyByZXNwb25z ZSBhcyBvdXIgcmV0dXJuIHZhbHVlICovCisJCXJldCA9IEZJRUxEX0dFVChHVUNfSFhHX1JFU1BP TlNFX01TR18wX0RBVEEwLCBoZWFkZXIpOworCX0KIAogb3V0OgogCWludGVsX3VuY29yZV9mb3Jj ZXdha2VfcHV0KHVuY29yZSwgZ3VjLT5zZW5kX3JlZ3MuZndfZG9tYWlucyk7Ci0tIAoyLjI4LjAK Cl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCkludGVsLWdm eCBtYWlsaW5nIGxpc3QKSW50ZWwtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xp c3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2ludGVsLWdmeAo=