From mboxrd@z Thu Jan 1 00:00:00 1970 From: Gwan-gyeong Mun Date: Mon, 03 Feb 2020 23:20:01 +0000 Subject: [PATCH v3 04/17] drm/i915/dp: Add writing of DP SDPs (Secondary Data Packet) Message-Id: <20200203232014.906651-5-gwan-gyeong.mun@intel.com> List-Id: References: <20200203232014.906651-1-gwan-gyeong.mun@intel.com> In-Reply-To: <20200203232014.906651-1-gwan-gyeong.mun@intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset="windows-1252" Content-Transfer-Encoding: quoted-printable To: intel-gfx@lists.freedesktop.org Cc: linux-fbdev@vger.kernel.org, dri-devel@lists.freedesktop.org It adds routines that write DP VSC SDP and DP HDR Metadata Infoframe SDP. In order to pack DP VSC SDP, it adds intel_dp_vsc_sdp_pack() function. It follows DP 1.4a spec. [Table 2-116: VSC SDP Header Bytes] and [Table 2-117: VSC SDP Payload for DB16 through DB18] In order to pack DP HDR Metadata Infoframe SDP, it adds intel_dp_hdr_metadata_infoframe_sdp_pack() function. And it follows DP 1.4a spec. ([Table 2-125: INFOFRAME SDP v1.2 Header Bytes] and [Table 2-126: INFOFRAME SDP v1.2 Payload Data Bytes - DB0 through DB31]) and CTA-861-G spec. [Table-42 Dynamic Range and Mastering InfoFrame]. A machanism and a naming rule of intel_dp_set_infoframes() function references intel_encoder->set_infoframes() of intel_hdmi.c . VSC SDP is used for PSR and Pixel Encoding and Colorimetry Formats cases. Because PSR routine has its own routine of writing a VSC SDP, when the PSR is enabled, intel_dp_set_infoframes() does not write a VSC SDP. v3: - Explicitly disable unused DIPs (AVI, GCP, VS, SPD, DRM. They will be used for HDMI), when intel_dp_set_infoframes() function will be called. - Replace a structure name to drm_dp_vsc_sdp from intel_dp_vsc_sdp. Signed-off-by: Gwan-gyeong Mun --- drivers/gpu/drm/i915/display/intel_dp.c | 194 ++++++++++++++++++++++++ drivers/gpu/drm/i915/display/intel_dp.h | 3 + 2 files changed, 197 insertions(+) diff --git a/drivers/gpu/drm/i915/display/intel_dp.c b/drivers/gpu/drm/i915= /display/intel_dp.c index b265b5c599f2..dd7e5588001e 100644 --- a/drivers/gpu/drm/i915/display/intel_dp.c +++ b/drivers/gpu/drm/i915/display/intel_dp.c @@ -4731,6 +4731,200 @@ intel_dp_needs_vsc_sdp(const struct intel_crtc_stat= e *crtc_state, return false; } =20 +static ssize_t intel_dp_vsc_sdp_pack(const struct drm_dp_vsc_sdp *vsc, + struct dp_sdp *sdp, size_t size) +{ + size_t length =3D sizeof(struct dp_sdp); + + if (size < length) + return -ENOSPC; + + memset(sdp, 0, size); + + /* + * Prepare VSC Header for SU as per DP 1.4a spec, Table 2-119 + * VSC SDP Header Bytes + */ + sdp->sdp_header.HB0 =3D 0; /* Secondary-Data Packet ID =3D 0 */ + sdp->sdp_header.HB1 =3D vsc->sdp_type; /* Secondary-data Packet Type */ + sdp->sdp_header.HB2 =3D vsc->revision; /* Revision Number */ + sdp->sdp_header.HB3 =3D vsc->length; /* Number of Valid Data Bytes */ + + /* VSC SDP Payload for DB16 through DB18 */ + /* Pixel Encoding and Colorimetry Formats */ + sdp->db[16] =3D (vsc->colorspace & 0xf) << 4; /* DB16[7:4] */ + sdp->db[16] |=3D vsc->colorimetry & 0xf; /* DB16[3:0] */ + + switch (vsc->bpc) { + case 8: + sdp->db[17] =3D 0x1; /* DB17[3:0] */ + break; + case 10: + sdp->db[17] =3D 0x2; + break; + case 12: + sdp->db[17] =3D 0x3; + break; + case 16: + sdp->db[17] =3D 0x4; + break; + default: + MISSING_CASE(vsc->bpc); + break; + } + /* Dynamic Range and Component Bit Depth */ + if (vsc->dynamic_range =3D DP_DYNAMIC_RANGE_CTA) + sdp->db[17] |=3D 0x80; /* DB17[7] */ + + /* Content Type */ + sdp->db[18] =3D vsc->content_type & 0x7; + + return length; +} + +static ssize_t +intel_dp_hdr_metadata_infoframe_sdp_pack(const struct hdmi_drm_infoframe *= drm_infoframe, + struct dp_sdp *sdp, + size_t size) +{ + size_t length =3D sizeof(struct dp_sdp); + const int infoframe_size =3D HDMI_INFOFRAME_HEADER_SIZE + HDMI_DRM_INFOFR= AME_SIZE; + unsigned char buf[HDMI_INFOFRAME_HEADER_SIZE + HDMI_DRM_INFOFRAME_SIZE]; + ssize_t len; + + if (size < length) + return -ENOSPC; + + memset(sdp, 0, size); + + len =3D hdmi_drm_infoframe_pack_only(drm_infoframe, buf, sizeof(buf)); + if (len < 0) { + DRM_DEBUG_KMS("buffer size is smaller than hdr metadata infoframe\n"); + return -ENOSPC; + } + + if (len !=3D infoframe_size) { + DRM_DEBUG_KMS("wrong static hdr metadata size\n"); + return -ENOSPC; + } + + /* + * Set up the infoframe sdp packet for HDR static metadata. + * Prepare VSC Header for SU as per DP 1.4a spec, + * Table 2-100 and Table 2-101 + */ + + /* Secondary-Data Packet ID, 00h for non-Audio INFOFRAME */ + sdp->sdp_header.HB0 =3D 0; + /* + * Packet Type 80h + Non-audio INFOFRAME Type value + * HDMI_INFOFRAME_TYPE_DRM: 0x87 + * - 80h + Non-audio INFOFRAME Type value + * - InfoFrame Type: 0x07 + * [CTA-861-G Table-42 Dynamic Range and Mastering InfoFrame] + */ + sdp->sdp_header.HB1 =3D drm_infoframe->type; + /* + * Least Significant Eight Bits of (Data Byte Count =E2=80=93 1) + * infoframe_size - 1 + */ + sdp->sdp_header.HB2 =3D 0x1D; + /* INFOFRAME SDP Version Number */ + sdp->sdp_header.HB3 =3D (0x13 << 2); + /* CTA Header Byte 2 (INFOFRAME Version Number) */ + sdp->db[0] =3D drm_infoframe->version; + /* CTA Header Byte 3 (Length of INFOFRAME): HDMI_DRM_INFOFRAME_SIZE */ + sdp->db[1] =3D drm_infoframe->length; + /* + * Copy HDMI_DRM_INFOFRAME_SIZE size from a buffer after + */ + BUILD_BUG_ON(sizeof(sdp->db) < HDMI_DRM_INFOFRAME_SIZE + 2); + memcpy(&sdp->db[2], &buf[HDMI_INFOFRAME_HEADER_SIZE], + HDMI_DRM_INFOFRAME_SIZE); + + /* + * Size of DP infoframe sdp packet for HDR static metadata is consist of + * - DP SDP Header(struct dp_sdp_header): 4 bytes + * - Two Data Blocks: 2 bytes + * CTA Header Byte2 (INFOFRAME Version Number) + * CTA Header Byte3 (Length of INFOFRAME) + * - HDMI_DRM_INFOFRAME_SIZE: 26 bytes + * + * Prior to GEN11's GMP register size is identical to DP HDR static metad= ata + * infoframe size. But GEN11+ has larger than that size, write_infoframe + * will pad rest of the size. + */ + return sizeof(struct dp_sdp_header) + 2 + HDMI_DRM_INFOFRAME_SIZE; +} + +static void intel_write_dp_sdp(struct intel_encoder *encoder, + const struct intel_crtc_state *crtc_state, + unsigned int type) +{ + struct intel_digital_port *intel_dig_port =3D enc_to_dig_port(encoder); + struct dp_sdp sdp =3D {}; + ssize_t len; + + if ((crtc_state->infoframes.enable & + intel_hdmi_infoframe_enable(type)) =3D 0) + return; + + switch (type) { + case DP_SDP_VSC: + len =3D intel_dp_vsc_sdp_pack(&crtc_state->infoframes.vsc, &sdp, + sizeof(sdp)); + break; + case HDMI_PACKET_TYPE_GAMUT_METADATA: + len =3D intel_dp_hdr_metadata_infoframe_sdp_pack(&crtc_state->infoframes= .drm.drm, + &sdp, sizeof(sdp)); + break; + default: + MISSING_CASE(type); + break; + } + + if (WARN_ON(len < 0)) + return; + + intel_dig_port->write_infoframe(encoder, crtc_state, type, &sdp, len); +} + +void intel_dp_set_infoframes(struct intel_encoder *encoder, + bool enable, + const struct intel_crtc_state *crtc_state, + const struct drm_connector_state *conn_state) +{ + struct drm_i915_private *dev_priv =3D to_i915(encoder->base.dev); + struct intel_dp *intel_dp =3D enc_to_intel_dp(encoder); + i915_reg_t reg =3D HSW_TVIDEO_DIP_CTL(crtc_state->cpu_transcoder); + u32 dip_enable =3D VIDEO_DIP_ENABLE_AVI_HSW | VIDEO_DIP_ENABLE_GCP_HSW | + VIDEO_DIP_ENABLE_VS_HSW | VIDEO_DIP_ENABLE_GMP_HSW | + VIDEO_DIP_ENABLE_SPD_HSW | VIDEO_DIP_ENABLE_DRM_GLK; + u32 val =3D I915_READ(reg); + + /* TODO: Add DSC case (DIP_ENABLE_PPS) */ + /* When PSR is enabled, this routine doesn't disable VSC DIP */ + if (intel_psr_enabled(intel_dp)) + val &=3D ~dip_enable; + else + val &=3D ~(dip_enable | VIDEO_DIP_ENABLE_VSC_HSW); + + if (!enable) { + I915_WRITE(reg, val); + POSTING_READ(reg); + return; + } + + I915_WRITE(reg, val); + POSTING_READ(reg); + + /* When PSR is enabled, VSC SDP is handled by PSR routine */ + if (!intel_psr_enabled(intel_dp)) + intel_write_dp_sdp(encoder, crtc_state, DP_SDP_VSC); + + intel_write_dp_sdp(encoder, crtc_state, HDMI_PACKET_TYPE_GAMUT_METADATA); +} + static void intel_dp_setup_vsc_sdp(struct intel_dp *intel_dp, const struct intel_crtc_state *crtc_state, diff --git a/drivers/gpu/drm/i915/display/intel_dp.h b/drivers/gpu/drm/i915= /display/intel_dp.h index 3da166054788..0dc09a463ee1 100644 --- a/drivers/gpu/drm/i915/display/intel_dp.h +++ b/drivers/gpu/drm/i915/display/intel_dp.h @@ -116,6 +116,9 @@ void intel_dp_vsc_enable(struct intel_dp *intel_dp, void intel_dp_hdr_metadata_enable(struct intel_dp *intel_dp, const struct intel_crtc_state *crtc_state, const struct drm_connector_state *conn_state); +void intel_dp_set_infoframes(struct intel_encoder *encoder, bool enable, + const struct intel_crtc_state *crtc_state, + const struct drm_connector_state *conn_state); bool intel_digital_port_connected(struct intel_encoder *encoder); =20 static inline unsigned int intel_dp_unused_lane_mask(int lane_count) --=20 2.24.1 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=-7.0 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, UNWANTED_LANGUAGE_BODY,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 B8807C35247 for ; Mon, 3 Feb 2020 23:20:38 +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 7F0AF20721 for ; Mon, 3 Feb 2020 23:20:38 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 7F0AF20721 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 E27A06ED33; Mon, 3 Feb 2020 23:20:26 +0000 (UTC) Received: from mga17.intel.com (mga17.intel.com [192.55.52.151]) by gabe.freedesktop.org (Postfix) with ESMTPS id 67FE36ED29; Mon, 3 Feb 2020 23:20:24 +0000 (UTC) X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from orsmga001.jf.intel.com ([10.7.209.18]) by fmsmga107.fm.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 03 Feb 2020 15:20:24 -0800 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.70,398,1574150400"; d="scan'208";a="310866797" Received: from helsinki.fi.intel.com ([10.237.66.150]) by orsmga001.jf.intel.com with ESMTP; 03 Feb 2020 15:20:22 -0800 From: Gwan-gyeong Mun To: intel-gfx@lists.freedesktop.org Subject: [PATCH v3 04/17] drm/i915/dp: Add writing of DP SDPs (Secondary Data Packet) Date: Tue, 4 Feb 2020 01:20:01 +0200 Message-Id: <20200203232014.906651-5-gwan-gyeong.mun@intel.com> X-Mailer: git-send-email 2.24.1 In-Reply-To: <20200203232014.906651-1-gwan-gyeong.mun@intel.com> References: <20200203232014.906651-1-gwan-gyeong.mun@intel.com> MIME-Version: 1.0 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: linux-fbdev@vger.kernel.org, dri-devel@lists.freedesktop.org Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" SXQgYWRkcyByb3V0aW5lcyB0aGF0IHdyaXRlIERQIFZTQyBTRFAgYW5kIERQIEhEUiBNZXRhZGF0 YSBJbmZvZnJhbWUgU0RQLgpJbiBvcmRlciB0byBwYWNrIERQIFZTQyBTRFAsIGl0IGFkZHMgaW50 ZWxfZHBfdnNjX3NkcF9wYWNrKCkgZnVuY3Rpb24uCkl0IGZvbGxvd3MgRFAgMS40YSBzcGVjLiBb VGFibGUgMi0xMTY6IFZTQyBTRFAgSGVhZGVyIEJ5dGVzXSBhbmQKW1RhYmxlIDItMTE3OiBWU0Mg U0RQIFBheWxvYWQgZm9yIERCMTYgdGhyb3VnaCBEQjE4XQoKSW4gb3JkZXIgdG8gcGFjayBEUCBI RFIgTWV0YWRhdGEgSW5mb2ZyYW1lIFNEUCwgaXQgYWRkcwppbnRlbF9kcF9oZHJfbWV0YWRhdGFf aW5mb2ZyYW1lX3NkcF9wYWNrKCkgZnVuY3Rpb24uCkFuZCBpdCBmb2xsb3dzIERQIDEuNGEgc3Bl Yy4KKFtUYWJsZSAyLTEyNTogSU5GT0ZSQU1FIFNEUCB2MS4yIEhlYWRlciBCeXRlc10gYW5kCltU YWJsZSAyLTEyNjogSU5GT0ZSQU1FIFNEUCB2MS4yIFBheWxvYWQgRGF0YSBCeXRlcyAtIERCMCB0 aHJvdWdoIERCMzFdKQphbmQgQ1RBLTg2MS1HIHNwZWMuIFtUYWJsZS00MiBEeW5hbWljIFJhbmdl IGFuZCBNYXN0ZXJpbmcgSW5mb0ZyYW1lXS4KCkEgbWFjaGFuaXNtIGFuZCBhIG5hbWluZyBydWxl IG9mIGludGVsX2RwX3NldF9pbmZvZnJhbWVzKCkgZnVuY3Rpb24KcmVmZXJlbmNlcyBpbnRlbF9l bmNvZGVyLT5zZXRfaW5mb2ZyYW1lcygpIG9mIGludGVsX2hkbWkuYyAuClZTQyBTRFAgaXMgdXNl ZCBmb3IgUFNSIGFuZCBQaXhlbCBFbmNvZGluZyBhbmQgQ29sb3JpbWV0cnkgRm9ybWF0cyBjYXNl cy4KQmVjYXVzZSBQU1Igcm91dGluZSBoYXMgaXRzIG93biByb3V0aW5lIG9mIHdyaXRpbmcgYSBW U0MgU0RQLCB3aGVuIHRoZSBQU1IKaXMgZW5hYmxlZCwgaW50ZWxfZHBfc2V0X2luZm9mcmFtZXMo KSBkb2VzIG5vdCB3cml0ZSBhIFZTQyBTRFAuCgp2MzoKICAtIEV4cGxpY2l0bHkgZGlzYWJsZSB1 bnVzZWQgRElQcyAoQVZJLCBHQ1AsIFZTLCBTUEQsIERSTS4gVGhleSB3aWxsIGJlCiAgICB1c2Vk IGZvciBIRE1JKSwgd2hlbiBpbnRlbF9kcF9zZXRfaW5mb2ZyYW1lcygpIGZ1bmN0aW9uIHdpbGwg YmUgY2FsbGVkLgogIC0gUmVwbGFjZSBhIHN0cnVjdHVyZSBuYW1lIHRvIGRybV9kcF92c2Nfc2Rw IGZyb20gaW50ZWxfZHBfdnNjX3NkcC4KClNpZ25lZC1vZmYtYnk6IEd3YW4tZ3llb25nIE11biA8 Z3dhbi1neWVvbmcubXVuQGludGVsLmNvbT4KLS0tCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9kaXNw bGF5L2ludGVsX2RwLmMgfCAxOTQgKysrKysrKysrKysrKysrKysrKysrKysrCiBkcml2ZXJzL2dw dS9kcm0vaTkxNS9kaXNwbGF5L2ludGVsX2RwLmggfCAgIDMgKwogMiBmaWxlcyBjaGFuZ2VkLCAx OTcgaW5zZXJ0aW9ucygrKQoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2Rpc3Bs YXkvaW50ZWxfZHAuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2Rpc3BsYXkvaW50ZWxfZHAuYwpp bmRleCBiMjY1YjVjNTk5ZjIuLmRkN2U1NTg4MDAxZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUv ZHJtL2k5MTUvZGlzcGxheS9pbnRlbF9kcC5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2Rp c3BsYXkvaW50ZWxfZHAuYwpAQCAtNDczMSw2ICs0NzMxLDIwMCBAQCBpbnRlbF9kcF9uZWVkc192 c2Nfc2RwKGNvbnN0IHN0cnVjdCBpbnRlbF9jcnRjX3N0YXRlICpjcnRjX3N0YXRlLAogCXJldHVy biBmYWxzZTsKIH0KIAorc3RhdGljIHNzaXplX3QgaW50ZWxfZHBfdnNjX3NkcF9wYWNrKGNvbnN0 IHN0cnVjdCBkcm1fZHBfdnNjX3NkcCAqdnNjLAorCQkJCSAgICAgc3RydWN0IGRwX3NkcCAqc2Rw LCBzaXplX3Qgc2l6ZSkKK3sKKwlzaXplX3QgbGVuZ3RoID0gc2l6ZW9mKHN0cnVjdCBkcF9zZHAp OworCisJaWYgKHNpemUgPCBsZW5ndGgpCisJCXJldHVybiAtRU5PU1BDOworCisJbWVtc2V0KHNk cCwgMCwgc2l6ZSk7CisKKwkvKgorCSAqIFByZXBhcmUgVlNDIEhlYWRlciBmb3IgU1UgYXMgcGVy IERQIDEuNGEgc3BlYywgVGFibGUgMi0xMTkKKwkgKiBWU0MgU0RQIEhlYWRlciBCeXRlcworCSAq LworCXNkcC0+c2RwX2hlYWRlci5IQjAgPSAwOyAvKiBTZWNvbmRhcnktRGF0YSBQYWNrZXQgSUQg PSAwICovCisJc2RwLT5zZHBfaGVhZGVyLkhCMSA9IHZzYy0+c2RwX3R5cGU7IC8qIFNlY29uZGFy eS1kYXRhIFBhY2tldCBUeXBlICovCisJc2RwLT5zZHBfaGVhZGVyLkhCMiA9IHZzYy0+cmV2aXNp b247IC8qIFJldmlzaW9uIE51bWJlciAqLworCXNkcC0+c2RwX2hlYWRlci5IQjMgPSB2c2MtPmxl bmd0aDsgLyogTnVtYmVyIG9mIFZhbGlkIERhdGEgQnl0ZXMgKi8KKworCS8qIFZTQyBTRFAgUGF5 bG9hZCBmb3IgREIxNiB0aHJvdWdoIERCMTggKi8KKwkvKiBQaXhlbCBFbmNvZGluZyBhbmQgQ29s b3JpbWV0cnkgRm9ybWF0cyAgKi8KKwlzZHAtPmRiWzE2XSA9ICh2c2MtPmNvbG9yc3BhY2UgJiAw eGYpIDw8IDQ7IC8qIERCMTZbNzo0XSAqLworCXNkcC0+ZGJbMTZdIHw9IHZzYy0+Y29sb3JpbWV0 cnkgJiAweGY7IC8qIERCMTZbMzowXSAqLworCisJc3dpdGNoICh2c2MtPmJwYykgeworCWNhc2Ug ODoKKwkJc2RwLT5kYlsxN10gPSAweDE7IC8qIERCMTdbMzowXSAqLworCQlicmVhazsKKwljYXNl IDEwOgorCQlzZHAtPmRiWzE3XSA9IDB4MjsKKwkJYnJlYWs7CisJY2FzZSAxMjoKKwkJc2RwLT5k YlsxN10gPSAweDM7CisJCWJyZWFrOworCWNhc2UgMTY6CisJCXNkcC0+ZGJbMTddID0gMHg0Owor CQlicmVhazsKKwlkZWZhdWx0OgorCQlNSVNTSU5HX0NBU0UodnNjLT5icGMpOworCQlicmVhazsK Kwl9CisJLyogRHluYW1pYyBSYW5nZSBhbmQgQ29tcG9uZW50IEJpdCBEZXB0aCAqLworCWlmICh2 c2MtPmR5bmFtaWNfcmFuZ2UgPT0gRFBfRFlOQU1JQ19SQU5HRV9DVEEpCisJCXNkcC0+ZGJbMTdd IHw9IDB4ODA7ICAvKiBEQjE3WzddICovCisKKwkvKiBDb250ZW50IFR5cGUgKi8KKwlzZHAtPmRi WzE4XSA9IHZzYy0+Y29udGVudF90eXBlICYgMHg3OworCisJcmV0dXJuIGxlbmd0aDsKK30KKwor c3RhdGljIHNzaXplX3QKK2ludGVsX2RwX2hkcl9tZXRhZGF0YV9pbmZvZnJhbWVfc2RwX3BhY2so Y29uc3Qgc3RydWN0IGhkbWlfZHJtX2luZm9mcmFtZSAqZHJtX2luZm9mcmFtZSwKKwkJCQkJIHN0 cnVjdCBkcF9zZHAgKnNkcCwKKwkJCQkJIHNpemVfdCBzaXplKQoreworCXNpemVfdCBsZW5ndGgg PSBzaXplb2Yoc3RydWN0IGRwX3NkcCk7CisJY29uc3QgaW50IGluZm9mcmFtZV9zaXplID0gSERN SV9JTkZPRlJBTUVfSEVBREVSX1NJWkUgKyBIRE1JX0RSTV9JTkZPRlJBTUVfU0laRTsKKwl1bnNp Z25lZCBjaGFyIGJ1ZltIRE1JX0lORk9GUkFNRV9IRUFERVJfU0laRSArIEhETUlfRFJNX0lORk9G UkFNRV9TSVpFXTsKKwlzc2l6ZV90IGxlbjsKKworCWlmIChzaXplIDwgbGVuZ3RoKQorCQlyZXR1 cm4gLUVOT1NQQzsKKworCW1lbXNldChzZHAsIDAsIHNpemUpOworCisJbGVuID0gaGRtaV9kcm1f aW5mb2ZyYW1lX3BhY2tfb25seShkcm1faW5mb2ZyYW1lLCBidWYsIHNpemVvZihidWYpKTsKKwlp ZiAobGVuIDwgMCkgeworCQlEUk1fREVCVUdfS01TKCJidWZmZXIgc2l6ZSBpcyBzbWFsbGVyIHRo YW4gaGRyIG1ldGFkYXRhIGluZm9mcmFtZVxuIik7CisJCXJldHVybiAtRU5PU1BDOworCX0KKwor CWlmIChsZW4gIT0gaW5mb2ZyYW1lX3NpemUpIHsKKwkJRFJNX0RFQlVHX0tNUygid3Jvbmcgc3Rh dGljIGhkciBtZXRhZGF0YSBzaXplXG4iKTsKKwkJcmV0dXJuIC1FTk9TUEM7CisJfQorCisJLyoK KwkgKiBTZXQgdXAgdGhlIGluZm9mcmFtZSBzZHAgcGFja2V0IGZvciBIRFIgc3RhdGljIG1ldGFk YXRhLgorCSAqIFByZXBhcmUgVlNDIEhlYWRlciBmb3IgU1UgYXMgcGVyIERQIDEuNGEgc3BlYywK KwkgKiBUYWJsZSAyLTEwMCBhbmQgVGFibGUgMi0xMDEKKwkgKi8KKworCS8qIFNlY29uZGFyeS1E YXRhIFBhY2tldCBJRCwgMDBoIGZvciBub24tQXVkaW8gSU5GT0ZSQU1FICovCisJc2RwLT5zZHBf aGVhZGVyLkhCMCA9IDA7CisJLyoKKwkgKiBQYWNrZXQgVHlwZSA4MGggKyBOb24tYXVkaW8gSU5G T0ZSQU1FIFR5cGUgdmFsdWUKKwkgKiBIRE1JX0lORk9GUkFNRV9UWVBFX0RSTTogMHg4NworCSAq IC0gODBoICsgTm9uLWF1ZGlvIElORk9GUkFNRSBUeXBlIHZhbHVlCisJICogLSBJbmZvRnJhbWUg VHlwZTogMHgwNworCSAqICAgIFtDVEEtODYxLUcgVGFibGUtNDIgRHluYW1pYyBSYW5nZSBhbmQg TWFzdGVyaW5nIEluZm9GcmFtZV0KKwkgKi8KKwlzZHAtPnNkcF9oZWFkZXIuSEIxID0gZHJtX2lu Zm9mcmFtZS0+dHlwZTsKKwkvKgorCSAqIExlYXN0IFNpZ25pZmljYW50IEVpZ2h0IEJpdHMgb2Yg KERhdGEgQnl0ZSBDb3VudCDigJMgMSkKKwkgKiBpbmZvZnJhbWVfc2l6ZSAtIDEKKwkgKi8KKwlz ZHAtPnNkcF9oZWFkZXIuSEIyID0gMHgxRDsKKwkvKiBJTkZPRlJBTUUgU0RQIFZlcnNpb24gTnVt YmVyICovCisJc2RwLT5zZHBfaGVhZGVyLkhCMyA9ICgweDEzIDw8IDIpOworCS8qIENUQSBIZWFk ZXIgQnl0ZSAyIChJTkZPRlJBTUUgVmVyc2lvbiBOdW1iZXIpICovCisJc2RwLT5kYlswXSA9IGRy bV9pbmZvZnJhbWUtPnZlcnNpb247CisJLyogQ1RBIEhlYWRlciBCeXRlIDMgKExlbmd0aCBvZiBJ TkZPRlJBTUUpOiBIRE1JX0RSTV9JTkZPRlJBTUVfU0laRSAqLworCXNkcC0+ZGJbMV0gPSBkcm1f aW5mb2ZyYW1lLT5sZW5ndGg7CisJLyoKKwkgKiBDb3B5IEhETUlfRFJNX0lORk9GUkFNRV9TSVpF IHNpemUgZnJvbSBhIGJ1ZmZlciBhZnRlcgorCSAqLworCUJVSUxEX0JVR19PTihzaXplb2Yoc2Rw LT5kYikgPCBIRE1JX0RSTV9JTkZPRlJBTUVfU0laRSArIDIpOworCW1lbWNweSgmc2RwLT5kYlsy XSwgJmJ1ZltIRE1JX0lORk9GUkFNRV9IRUFERVJfU0laRV0sCisJICAgICAgIEhETUlfRFJNX0lO Rk9GUkFNRV9TSVpFKTsKKworCS8qCisJICogU2l6ZSBvZiBEUCBpbmZvZnJhbWUgc2RwIHBhY2tl dCBmb3IgSERSIHN0YXRpYyBtZXRhZGF0YSBpcyBjb25zaXN0IG9mCisJICogLSBEUCBTRFAgSGVh ZGVyKHN0cnVjdCBkcF9zZHBfaGVhZGVyKTogNCBieXRlcworCSAqIC0gVHdvIERhdGEgQmxvY2tz OiAyIGJ5dGVzCisJICogICAgQ1RBIEhlYWRlciBCeXRlMiAoSU5GT0ZSQU1FIFZlcnNpb24gTnVt YmVyKQorCSAqICAgIENUQSBIZWFkZXIgQnl0ZTMgKExlbmd0aCBvZiBJTkZPRlJBTUUpCisJICog LSBIRE1JX0RSTV9JTkZPRlJBTUVfU0laRTogMjYgYnl0ZXMKKwkgKgorCSAqIFByaW9yIHRvIEdF TjExJ3MgR01QIHJlZ2lzdGVyIHNpemUgaXMgaWRlbnRpY2FsIHRvIERQIEhEUiBzdGF0aWMgbWV0 YWRhdGEKKwkgKiBpbmZvZnJhbWUgc2l6ZS4gQnV0IEdFTjExKyBoYXMgbGFyZ2VyIHRoYW4gdGhh dCBzaXplLCB3cml0ZV9pbmZvZnJhbWUKKwkgKiB3aWxsIHBhZCByZXN0IG9mIHRoZSBzaXplLgor CSAqLworCXJldHVybiBzaXplb2Yoc3RydWN0IGRwX3NkcF9oZWFkZXIpICsgMiArIEhETUlfRFJN X0lORk9GUkFNRV9TSVpFOworfQorCitzdGF0aWMgdm9pZCBpbnRlbF93cml0ZV9kcF9zZHAoc3Ry dWN0IGludGVsX2VuY29kZXIgKmVuY29kZXIsCisJCQkgICAgICAgY29uc3Qgc3RydWN0IGludGVs X2NydGNfc3RhdGUgKmNydGNfc3RhdGUsCisJCQkgICAgICAgdW5zaWduZWQgaW50IHR5cGUpCit7 CisJc3RydWN0IGludGVsX2RpZ2l0YWxfcG9ydCAqaW50ZWxfZGlnX3BvcnQgPSBlbmNfdG9fZGln X3BvcnQoZW5jb2Rlcik7CisJc3RydWN0IGRwX3NkcCBzZHAgPSB7fTsKKwlzc2l6ZV90IGxlbjsK KworCWlmICgoY3J0Y19zdGF0ZS0+aW5mb2ZyYW1lcy5lbmFibGUgJgorCSAgICAgaW50ZWxfaGRt aV9pbmZvZnJhbWVfZW5hYmxlKHR5cGUpKSA9PSAwKQorCQlyZXR1cm47CisKKwlzd2l0Y2ggKHR5 cGUpIHsKKwljYXNlIERQX1NEUF9WU0M6CisJCWxlbiA9IGludGVsX2RwX3ZzY19zZHBfcGFjaygm Y3J0Y19zdGF0ZS0+aW5mb2ZyYW1lcy52c2MsICZzZHAsCisJCQkJCSAgICBzaXplb2Yoc2RwKSk7 CisJCWJyZWFrOworCWNhc2UgSERNSV9QQUNLRVRfVFlQRV9HQU1VVF9NRVRBREFUQToKKwkJbGVu ID0gaW50ZWxfZHBfaGRyX21ldGFkYXRhX2luZm9mcmFtZV9zZHBfcGFjaygmY3J0Y19zdGF0ZS0+ aW5mb2ZyYW1lcy5kcm0uZHJtLAorCQkJCQkJCSAgICAgICAmc2RwLCBzaXplb2Yoc2RwKSk7CisJ CWJyZWFrOworCWRlZmF1bHQ6CisJCU1JU1NJTkdfQ0FTRSh0eXBlKTsKKwkJYnJlYWs7CisJfQor CisJaWYgKFdBUk5fT04obGVuIDwgMCkpCisJCXJldHVybjsKKworCWludGVsX2RpZ19wb3J0LT53 cml0ZV9pbmZvZnJhbWUoZW5jb2RlciwgY3J0Y19zdGF0ZSwgdHlwZSwgJnNkcCwgbGVuKTsKK30K Kwordm9pZCBpbnRlbF9kcF9zZXRfaW5mb2ZyYW1lcyhzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5j b2RlciwKKwkJCSAgICAgYm9vbCBlbmFibGUsCisJCQkgICAgIGNvbnN0IHN0cnVjdCBpbnRlbF9j cnRjX3N0YXRlICpjcnRjX3N0YXRlLAorCQkJICAgICBjb25zdCBzdHJ1Y3QgZHJtX2Nvbm5lY3Rv cl9zdGF0ZSAqY29ubl9zdGF0ZSkKK3sKKwlzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3By aXYgPSB0b19pOTE1KGVuY29kZXItPmJhc2UuZGV2KTsKKwlzdHJ1Y3QgaW50ZWxfZHAgKmludGVs X2RwID0gZW5jX3RvX2ludGVsX2RwKGVuY29kZXIpOworCWk5MTVfcmVnX3QgcmVnID0gSFNXX1RW SURFT19ESVBfQ1RMKGNydGNfc3RhdGUtPmNwdV90cmFuc2NvZGVyKTsKKwl1MzIgZGlwX2VuYWJs ZSA9IFZJREVPX0RJUF9FTkFCTEVfQVZJX0hTVyB8IFZJREVPX0RJUF9FTkFCTEVfR0NQX0hTVyB8 CisJCQkgVklERU9fRElQX0VOQUJMRV9WU19IU1cgfCBWSURFT19ESVBfRU5BQkxFX0dNUF9IU1cg fAorCQkJIFZJREVPX0RJUF9FTkFCTEVfU1BEX0hTVyB8IFZJREVPX0RJUF9FTkFCTEVfRFJNX0dM SzsKKwl1MzIgdmFsID0gSTkxNV9SRUFEKHJlZyk7CisKKwkvKiBUT0RPOiBBZGQgRFNDIGNhc2Ug KERJUF9FTkFCTEVfUFBTKSAqLworCS8qIFdoZW4gUFNSIGlzIGVuYWJsZWQsIHRoaXMgcm91dGlu ZSBkb2Vzbid0IGRpc2FibGUgVlNDIERJUCAqLworCWlmIChpbnRlbF9wc3JfZW5hYmxlZChpbnRl bF9kcCkpCisJCXZhbCAmPSB+ZGlwX2VuYWJsZTsKKwllbHNlCisJCXZhbCAmPSB+KGRpcF9lbmFi bGUgfCBWSURFT19ESVBfRU5BQkxFX1ZTQ19IU1cpOworCisJaWYgKCFlbmFibGUpIHsKKwkJSTkx NV9XUklURShyZWcsIHZhbCk7CisJCVBPU1RJTkdfUkVBRChyZWcpOworCQlyZXR1cm47CisJfQor CisJSTkxNV9XUklURShyZWcsIHZhbCk7CisJUE9TVElOR19SRUFEKHJlZyk7CisKKwkvKiBXaGVu IFBTUiBpcyBlbmFibGVkLCBWU0MgU0RQIGlzIGhhbmRsZWQgYnkgUFNSIHJvdXRpbmUgKi8KKwlp ZiAoIWludGVsX3Bzcl9lbmFibGVkKGludGVsX2RwKSkKKwkJaW50ZWxfd3JpdGVfZHBfc2RwKGVu Y29kZXIsIGNydGNfc3RhdGUsIERQX1NEUF9WU0MpOworCisJaW50ZWxfd3JpdGVfZHBfc2RwKGVu Y29kZXIsIGNydGNfc3RhdGUsIEhETUlfUEFDS0VUX1RZUEVfR0FNVVRfTUVUQURBVEEpOworfQor CiBzdGF0aWMgdm9pZAogaW50ZWxfZHBfc2V0dXBfdnNjX3NkcChzdHJ1Y3QgaW50ZWxfZHAgKmlu dGVsX2RwLAogCQkgICAgICAgY29uc3Qgc3RydWN0IGludGVsX2NydGNfc3RhdGUgKmNydGNfc3Rh dGUsCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9kaXNwbGF5L2ludGVsX2RwLmgg Yi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9kaXNwbGF5L2ludGVsX2RwLmgKaW5kZXggM2RhMTY2MDU0 Nzg4Li4wZGMwOWE0NjNlZTEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2Rpc3Bs YXkvaW50ZWxfZHAuaAorKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9kaXNwbGF5L2ludGVsX2Rw LmgKQEAgLTExNiw2ICsxMTYsOSBAQCB2b2lkIGludGVsX2RwX3ZzY19lbmFibGUoc3RydWN0IGlu dGVsX2RwICppbnRlbF9kcCwKIHZvaWQgaW50ZWxfZHBfaGRyX21ldGFkYXRhX2VuYWJsZShzdHJ1 Y3QgaW50ZWxfZHAgKmludGVsX2RwLAogCQkJCSAgY29uc3Qgc3RydWN0IGludGVsX2NydGNfc3Rh dGUgKmNydGNfc3RhdGUsCiAJCQkJICBjb25zdCBzdHJ1Y3QgZHJtX2Nvbm5lY3Rvcl9zdGF0ZSAq Y29ubl9zdGF0ZSk7Cit2b2lkIGludGVsX2RwX3NldF9pbmZvZnJhbWVzKHN0cnVjdCBpbnRlbF9l bmNvZGVyICplbmNvZGVyLCBib29sIGVuYWJsZSwKKwkJCSAgICAgY29uc3Qgc3RydWN0IGludGVs X2NydGNfc3RhdGUgKmNydGNfc3RhdGUsCisJCQkgICAgIGNvbnN0IHN0cnVjdCBkcm1fY29ubmVj dG9yX3N0YXRlICpjb25uX3N0YXRlKTsKIGJvb2wgaW50ZWxfZGlnaXRhbF9wb3J0X2Nvbm5lY3Rl ZChzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2Rlcik7CiAKIHN0YXRpYyBpbmxpbmUgdW5zaWdu ZWQgaW50IGludGVsX2RwX3VudXNlZF9sYW5lX21hc2soaW50IGxhbmVfY291bnQpCi0tIAoyLjI0 LjEKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmRyaS1k ZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczov L2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZlbAo= 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=-7.0 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, UNWANTED_LANGUAGE_BODY,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 B068AC35247 for ; Mon, 3 Feb 2020 23:20:36 +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 6F10D20721 for ; Mon, 3 Feb 2020 23:20:36 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 6F10D20721 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 109B66ED2A; Mon, 3 Feb 2020 23:20:26 +0000 (UTC) Received: from mga17.intel.com (mga17.intel.com [192.55.52.151]) by gabe.freedesktop.org (Postfix) with ESMTPS id 67FE36ED29; Mon, 3 Feb 2020 23:20:24 +0000 (UTC) X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from orsmga001.jf.intel.com ([10.7.209.18]) by fmsmga107.fm.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 03 Feb 2020 15:20:24 -0800 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.70,398,1574150400"; d="scan'208";a="310866797" Received: from helsinki.fi.intel.com ([10.237.66.150]) by orsmga001.jf.intel.com with ESMTP; 03 Feb 2020 15:20:22 -0800 From: Gwan-gyeong Mun To: intel-gfx@lists.freedesktop.org Date: Tue, 4 Feb 2020 01:20:01 +0200 Message-Id: <20200203232014.906651-5-gwan-gyeong.mun@intel.com> X-Mailer: git-send-email 2.24.1 In-Reply-To: <20200203232014.906651-1-gwan-gyeong.mun@intel.com> References: <20200203232014.906651-1-gwan-gyeong.mun@intel.com> MIME-Version: 1.0 Subject: [Intel-gfx] [PATCH v3 04/17] drm/i915/dp: Add writing of DP SDPs (Secondary Data Packet) 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: linux-fbdev@vger.kernel.org, dri-devel@lists.freedesktop.org Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" SXQgYWRkcyByb3V0aW5lcyB0aGF0IHdyaXRlIERQIFZTQyBTRFAgYW5kIERQIEhEUiBNZXRhZGF0 YSBJbmZvZnJhbWUgU0RQLgpJbiBvcmRlciB0byBwYWNrIERQIFZTQyBTRFAsIGl0IGFkZHMgaW50 ZWxfZHBfdnNjX3NkcF9wYWNrKCkgZnVuY3Rpb24uCkl0IGZvbGxvd3MgRFAgMS40YSBzcGVjLiBb VGFibGUgMi0xMTY6IFZTQyBTRFAgSGVhZGVyIEJ5dGVzXSBhbmQKW1RhYmxlIDItMTE3OiBWU0Mg U0RQIFBheWxvYWQgZm9yIERCMTYgdGhyb3VnaCBEQjE4XQoKSW4gb3JkZXIgdG8gcGFjayBEUCBI RFIgTWV0YWRhdGEgSW5mb2ZyYW1lIFNEUCwgaXQgYWRkcwppbnRlbF9kcF9oZHJfbWV0YWRhdGFf aW5mb2ZyYW1lX3NkcF9wYWNrKCkgZnVuY3Rpb24uCkFuZCBpdCBmb2xsb3dzIERQIDEuNGEgc3Bl Yy4KKFtUYWJsZSAyLTEyNTogSU5GT0ZSQU1FIFNEUCB2MS4yIEhlYWRlciBCeXRlc10gYW5kCltU YWJsZSAyLTEyNjogSU5GT0ZSQU1FIFNEUCB2MS4yIFBheWxvYWQgRGF0YSBCeXRlcyAtIERCMCB0 aHJvdWdoIERCMzFdKQphbmQgQ1RBLTg2MS1HIHNwZWMuIFtUYWJsZS00MiBEeW5hbWljIFJhbmdl IGFuZCBNYXN0ZXJpbmcgSW5mb0ZyYW1lXS4KCkEgbWFjaGFuaXNtIGFuZCBhIG5hbWluZyBydWxl IG9mIGludGVsX2RwX3NldF9pbmZvZnJhbWVzKCkgZnVuY3Rpb24KcmVmZXJlbmNlcyBpbnRlbF9l bmNvZGVyLT5zZXRfaW5mb2ZyYW1lcygpIG9mIGludGVsX2hkbWkuYyAuClZTQyBTRFAgaXMgdXNl ZCBmb3IgUFNSIGFuZCBQaXhlbCBFbmNvZGluZyBhbmQgQ29sb3JpbWV0cnkgRm9ybWF0cyBjYXNl cy4KQmVjYXVzZSBQU1Igcm91dGluZSBoYXMgaXRzIG93biByb3V0aW5lIG9mIHdyaXRpbmcgYSBW U0MgU0RQLCB3aGVuIHRoZSBQU1IKaXMgZW5hYmxlZCwgaW50ZWxfZHBfc2V0X2luZm9mcmFtZXMo KSBkb2VzIG5vdCB3cml0ZSBhIFZTQyBTRFAuCgp2MzoKICAtIEV4cGxpY2l0bHkgZGlzYWJsZSB1 bnVzZWQgRElQcyAoQVZJLCBHQ1AsIFZTLCBTUEQsIERSTS4gVGhleSB3aWxsIGJlCiAgICB1c2Vk IGZvciBIRE1JKSwgd2hlbiBpbnRlbF9kcF9zZXRfaW5mb2ZyYW1lcygpIGZ1bmN0aW9uIHdpbGwg YmUgY2FsbGVkLgogIC0gUmVwbGFjZSBhIHN0cnVjdHVyZSBuYW1lIHRvIGRybV9kcF92c2Nfc2Rw IGZyb20gaW50ZWxfZHBfdnNjX3NkcC4KClNpZ25lZC1vZmYtYnk6IEd3YW4tZ3llb25nIE11biA8 Z3dhbi1neWVvbmcubXVuQGludGVsLmNvbT4KLS0tCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9kaXNw bGF5L2ludGVsX2RwLmMgfCAxOTQgKysrKysrKysrKysrKysrKysrKysrKysrCiBkcml2ZXJzL2dw dS9kcm0vaTkxNS9kaXNwbGF5L2ludGVsX2RwLmggfCAgIDMgKwogMiBmaWxlcyBjaGFuZ2VkLCAx OTcgaW5zZXJ0aW9ucygrKQoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2Rpc3Bs YXkvaW50ZWxfZHAuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2Rpc3BsYXkvaW50ZWxfZHAuYwpp bmRleCBiMjY1YjVjNTk5ZjIuLmRkN2U1NTg4MDAxZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUv ZHJtL2k5MTUvZGlzcGxheS9pbnRlbF9kcC5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2Rp c3BsYXkvaW50ZWxfZHAuYwpAQCAtNDczMSw2ICs0NzMxLDIwMCBAQCBpbnRlbF9kcF9uZWVkc192 c2Nfc2RwKGNvbnN0IHN0cnVjdCBpbnRlbF9jcnRjX3N0YXRlICpjcnRjX3N0YXRlLAogCXJldHVy biBmYWxzZTsKIH0KIAorc3RhdGljIHNzaXplX3QgaW50ZWxfZHBfdnNjX3NkcF9wYWNrKGNvbnN0 IHN0cnVjdCBkcm1fZHBfdnNjX3NkcCAqdnNjLAorCQkJCSAgICAgc3RydWN0IGRwX3NkcCAqc2Rw LCBzaXplX3Qgc2l6ZSkKK3sKKwlzaXplX3QgbGVuZ3RoID0gc2l6ZW9mKHN0cnVjdCBkcF9zZHAp OworCisJaWYgKHNpemUgPCBsZW5ndGgpCisJCXJldHVybiAtRU5PU1BDOworCisJbWVtc2V0KHNk cCwgMCwgc2l6ZSk7CisKKwkvKgorCSAqIFByZXBhcmUgVlNDIEhlYWRlciBmb3IgU1UgYXMgcGVy IERQIDEuNGEgc3BlYywgVGFibGUgMi0xMTkKKwkgKiBWU0MgU0RQIEhlYWRlciBCeXRlcworCSAq LworCXNkcC0+c2RwX2hlYWRlci5IQjAgPSAwOyAvKiBTZWNvbmRhcnktRGF0YSBQYWNrZXQgSUQg PSAwICovCisJc2RwLT5zZHBfaGVhZGVyLkhCMSA9IHZzYy0+c2RwX3R5cGU7IC8qIFNlY29uZGFy eS1kYXRhIFBhY2tldCBUeXBlICovCisJc2RwLT5zZHBfaGVhZGVyLkhCMiA9IHZzYy0+cmV2aXNp b247IC8qIFJldmlzaW9uIE51bWJlciAqLworCXNkcC0+c2RwX2hlYWRlci5IQjMgPSB2c2MtPmxl bmd0aDsgLyogTnVtYmVyIG9mIFZhbGlkIERhdGEgQnl0ZXMgKi8KKworCS8qIFZTQyBTRFAgUGF5 bG9hZCBmb3IgREIxNiB0aHJvdWdoIERCMTggKi8KKwkvKiBQaXhlbCBFbmNvZGluZyBhbmQgQ29s b3JpbWV0cnkgRm9ybWF0cyAgKi8KKwlzZHAtPmRiWzE2XSA9ICh2c2MtPmNvbG9yc3BhY2UgJiAw eGYpIDw8IDQ7IC8qIERCMTZbNzo0XSAqLworCXNkcC0+ZGJbMTZdIHw9IHZzYy0+Y29sb3JpbWV0 cnkgJiAweGY7IC8qIERCMTZbMzowXSAqLworCisJc3dpdGNoICh2c2MtPmJwYykgeworCWNhc2Ug ODoKKwkJc2RwLT5kYlsxN10gPSAweDE7IC8qIERCMTdbMzowXSAqLworCQlicmVhazsKKwljYXNl IDEwOgorCQlzZHAtPmRiWzE3XSA9IDB4MjsKKwkJYnJlYWs7CisJY2FzZSAxMjoKKwkJc2RwLT5k YlsxN10gPSAweDM7CisJCWJyZWFrOworCWNhc2UgMTY6CisJCXNkcC0+ZGJbMTddID0gMHg0Owor CQlicmVhazsKKwlkZWZhdWx0OgorCQlNSVNTSU5HX0NBU0UodnNjLT5icGMpOworCQlicmVhazsK Kwl9CisJLyogRHluYW1pYyBSYW5nZSBhbmQgQ29tcG9uZW50IEJpdCBEZXB0aCAqLworCWlmICh2 c2MtPmR5bmFtaWNfcmFuZ2UgPT0gRFBfRFlOQU1JQ19SQU5HRV9DVEEpCisJCXNkcC0+ZGJbMTdd IHw9IDB4ODA7ICAvKiBEQjE3WzddICovCisKKwkvKiBDb250ZW50IFR5cGUgKi8KKwlzZHAtPmRi WzE4XSA9IHZzYy0+Y29udGVudF90eXBlICYgMHg3OworCisJcmV0dXJuIGxlbmd0aDsKK30KKwor c3RhdGljIHNzaXplX3QKK2ludGVsX2RwX2hkcl9tZXRhZGF0YV9pbmZvZnJhbWVfc2RwX3BhY2so Y29uc3Qgc3RydWN0IGhkbWlfZHJtX2luZm9mcmFtZSAqZHJtX2luZm9mcmFtZSwKKwkJCQkJIHN0 cnVjdCBkcF9zZHAgKnNkcCwKKwkJCQkJIHNpemVfdCBzaXplKQoreworCXNpemVfdCBsZW5ndGgg PSBzaXplb2Yoc3RydWN0IGRwX3NkcCk7CisJY29uc3QgaW50IGluZm9mcmFtZV9zaXplID0gSERN SV9JTkZPRlJBTUVfSEVBREVSX1NJWkUgKyBIRE1JX0RSTV9JTkZPRlJBTUVfU0laRTsKKwl1bnNp Z25lZCBjaGFyIGJ1ZltIRE1JX0lORk9GUkFNRV9IRUFERVJfU0laRSArIEhETUlfRFJNX0lORk9G UkFNRV9TSVpFXTsKKwlzc2l6ZV90IGxlbjsKKworCWlmIChzaXplIDwgbGVuZ3RoKQorCQlyZXR1 cm4gLUVOT1NQQzsKKworCW1lbXNldChzZHAsIDAsIHNpemUpOworCisJbGVuID0gaGRtaV9kcm1f aW5mb2ZyYW1lX3BhY2tfb25seShkcm1faW5mb2ZyYW1lLCBidWYsIHNpemVvZihidWYpKTsKKwlp ZiAobGVuIDwgMCkgeworCQlEUk1fREVCVUdfS01TKCJidWZmZXIgc2l6ZSBpcyBzbWFsbGVyIHRo YW4gaGRyIG1ldGFkYXRhIGluZm9mcmFtZVxuIik7CisJCXJldHVybiAtRU5PU1BDOworCX0KKwor CWlmIChsZW4gIT0gaW5mb2ZyYW1lX3NpemUpIHsKKwkJRFJNX0RFQlVHX0tNUygid3Jvbmcgc3Rh dGljIGhkciBtZXRhZGF0YSBzaXplXG4iKTsKKwkJcmV0dXJuIC1FTk9TUEM7CisJfQorCisJLyoK KwkgKiBTZXQgdXAgdGhlIGluZm9mcmFtZSBzZHAgcGFja2V0IGZvciBIRFIgc3RhdGljIG1ldGFk YXRhLgorCSAqIFByZXBhcmUgVlNDIEhlYWRlciBmb3IgU1UgYXMgcGVyIERQIDEuNGEgc3BlYywK KwkgKiBUYWJsZSAyLTEwMCBhbmQgVGFibGUgMi0xMDEKKwkgKi8KKworCS8qIFNlY29uZGFyeS1E YXRhIFBhY2tldCBJRCwgMDBoIGZvciBub24tQXVkaW8gSU5GT0ZSQU1FICovCisJc2RwLT5zZHBf aGVhZGVyLkhCMCA9IDA7CisJLyoKKwkgKiBQYWNrZXQgVHlwZSA4MGggKyBOb24tYXVkaW8gSU5G T0ZSQU1FIFR5cGUgdmFsdWUKKwkgKiBIRE1JX0lORk9GUkFNRV9UWVBFX0RSTTogMHg4NworCSAq IC0gODBoICsgTm9uLWF1ZGlvIElORk9GUkFNRSBUeXBlIHZhbHVlCisJICogLSBJbmZvRnJhbWUg VHlwZTogMHgwNworCSAqICAgIFtDVEEtODYxLUcgVGFibGUtNDIgRHluYW1pYyBSYW5nZSBhbmQg TWFzdGVyaW5nIEluZm9GcmFtZV0KKwkgKi8KKwlzZHAtPnNkcF9oZWFkZXIuSEIxID0gZHJtX2lu Zm9mcmFtZS0+dHlwZTsKKwkvKgorCSAqIExlYXN0IFNpZ25pZmljYW50IEVpZ2h0IEJpdHMgb2Yg KERhdGEgQnl0ZSBDb3VudCDigJMgMSkKKwkgKiBpbmZvZnJhbWVfc2l6ZSAtIDEKKwkgKi8KKwlz ZHAtPnNkcF9oZWFkZXIuSEIyID0gMHgxRDsKKwkvKiBJTkZPRlJBTUUgU0RQIFZlcnNpb24gTnVt YmVyICovCisJc2RwLT5zZHBfaGVhZGVyLkhCMyA9ICgweDEzIDw8IDIpOworCS8qIENUQSBIZWFk ZXIgQnl0ZSAyIChJTkZPRlJBTUUgVmVyc2lvbiBOdW1iZXIpICovCisJc2RwLT5kYlswXSA9IGRy bV9pbmZvZnJhbWUtPnZlcnNpb247CisJLyogQ1RBIEhlYWRlciBCeXRlIDMgKExlbmd0aCBvZiBJ TkZPRlJBTUUpOiBIRE1JX0RSTV9JTkZPRlJBTUVfU0laRSAqLworCXNkcC0+ZGJbMV0gPSBkcm1f aW5mb2ZyYW1lLT5sZW5ndGg7CisJLyoKKwkgKiBDb3B5IEhETUlfRFJNX0lORk9GUkFNRV9TSVpF IHNpemUgZnJvbSBhIGJ1ZmZlciBhZnRlcgorCSAqLworCUJVSUxEX0JVR19PTihzaXplb2Yoc2Rw LT5kYikgPCBIRE1JX0RSTV9JTkZPRlJBTUVfU0laRSArIDIpOworCW1lbWNweSgmc2RwLT5kYlsy XSwgJmJ1ZltIRE1JX0lORk9GUkFNRV9IRUFERVJfU0laRV0sCisJICAgICAgIEhETUlfRFJNX0lO Rk9GUkFNRV9TSVpFKTsKKworCS8qCisJICogU2l6ZSBvZiBEUCBpbmZvZnJhbWUgc2RwIHBhY2tl dCBmb3IgSERSIHN0YXRpYyBtZXRhZGF0YSBpcyBjb25zaXN0IG9mCisJICogLSBEUCBTRFAgSGVh ZGVyKHN0cnVjdCBkcF9zZHBfaGVhZGVyKTogNCBieXRlcworCSAqIC0gVHdvIERhdGEgQmxvY2tz OiAyIGJ5dGVzCisJICogICAgQ1RBIEhlYWRlciBCeXRlMiAoSU5GT0ZSQU1FIFZlcnNpb24gTnVt YmVyKQorCSAqICAgIENUQSBIZWFkZXIgQnl0ZTMgKExlbmd0aCBvZiBJTkZPRlJBTUUpCisJICog LSBIRE1JX0RSTV9JTkZPRlJBTUVfU0laRTogMjYgYnl0ZXMKKwkgKgorCSAqIFByaW9yIHRvIEdF TjExJ3MgR01QIHJlZ2lzdGVyIHNpemUgaXMgaWRlbnRpY2FsIHRvIERQIEhEUiBzdGF0aWMgbWV0 YWRhdGEKKwkgKiBpbmZvZnJhbWUgc2l6ZS4gQnV0IEdFTjExKyBoYXMgbGFyZ2VyIHRoYW4gdGhh dCBzaXplLCB3cml0ZV9pbmZvZnJhbWUKKwkgKiB3aWxsIHBhZCByZXN0IG9mIHRoZSBzaXplLgor CSAqLworCXJldHVybiBzaXplb2Yoc3RydWN0IGRwX3NkcF9oZWFkZXIpICsgMiArIEhETUlfRFJN X0lORk9GUkFNRV9TSVpFOworfQorCitzdGF0aWMgdm9pZCBpbnRlbF93cml0ZV9kcF9zZHAoc3Ry dWN0IGludGVsX2VuY29kZXIgKmVuY29kZXIsCisJCQkgICAgICAgY29uc3Qgc3RydWN0IGludGVs X2NydGNfc3RhdGUgKmNydGNfc3RhdGUsCisJCQkgICAgICAgdW5zaWduZWQgaW50IHR5cGUpCit7 CisJc3RydWN0IGludGVsX2RpZ2l0YWxfcG9ydCAqaW50ZWxfZGlnX3BvcnQgPSBlbmNfdG9fZGln X3BvcnQoZW5jb2Rlcik7CisJc3RydWN0IGRwX3NkcCBzZHAgPSB7fTsKKwlzc2l6ZV90IGxlbjsK KworCWlmICgoY3J0Y19zdGF0ZS0+aW5mb2ZyYW1lcy5lbmFibGUgJgorCSAgICAgaW50ZWxfaGRt aV9pbmZvZnJhbWVfZW5hYmxlKHR5cGUpKSA9PSAwKQorCQlyZXR1cm47CisKKwlzd2l0Y2ggKHR5 cGUpIHsKKwljYXNlIERQX1NEUF9WU0M6CisJCWxlbiA9IGludGVsX2RwX3ZzY19zZHBfcGFjaygm Y3J0Y19zdGF0ZS0+aW5mb2ZyYW1lcy52c2MsICZzZHAsCisJCQkJCSAgICBzaXplb2Yoc2RwKSk7 CisJCWJyZWFrOworCWNhc2UgSERNSV9QQUNLRVRfVFlQRV9HQU1VVF9NRVRBREFUQToKKwkJbGVu ID0gaW50ZWxfZHBfaGRyX21ldGFkYXRhX2luZm9mcmFtZV9zZHBfcGFjaygmY3J0Y19zdGF0ZS0+ aW5mb2ZyYW1lcy5kcm0uZHJtLAorCQkJCQkJCSAgICAgICAmc2RwLCBzaXplb2Yoc2RwKSk7CisJ CWJyZWFrOworCWRlZmF1bHQ6CisJCU1JU1NJTkdfQ0FTRSh0eXBlKTsKKwkJYnJlYWs7CisJfQor CisJaWYgKFdBUk5fT04obGVuIDwgMCkpCisJCXJldHVybjsKKworCWludGVsX2RpZ19wb3J0LT53 cml0ZV9pbmZvZnJhbWUoZW5jb2RlciwgY3J0Y19zdGF0ZSwgdHlwZSwgJnNkcCwgbGVuKTsKK30K Kwordm9pZCBpbnRlbF9kcF9zZXRfaW5mb2ZyYW1lcyhzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5j b2RlciwKKwkJCSAgICAgYm9vbCBlbmFibGUsCisJCQkgICAgIGNvbnN0IHN0cnVjdCBpbnRlbF9j cnRjX3N0YXRlICpjcnRjX3N0YXRlLAorCQkJICAgICBjb25zdCBzdHJ1Y3QgZHJtX2Nvbm5lY3Rv cl9zdGF0ZSAqY29ubl9zdGF0ZSkKK3sKKwlzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3By aXYgPSB0b19pOTE1KGVuY29kZXItPmJhc2UuZGV2KTsKKwlzdHJ1Y3QgaW50ZWxfZHAgKmludGVs X2RwID0gZW5jX3RvX2ludGVsX2RwKGVuY29kZXIpOworCWk5MTVfcmVnX3QgcmVnID0gSFNXX1RW SURFT19ESVBfQ1RMKGNydGNfc3RhdGUtPmNwdV90cmFuc2NvZGVyKTsKKwl1MzIgZGlwX2VuYWJs ZSA9IFZJREVPX0RJUF9FTkFCTEVfQVZJX0hTVyB8IFZJREVPX0RJUF9FTkFCTEVfR0NQX0hTVyB8 CisJCQkgVklERU9fRElQX0VOQUJMRV9WU19IU1cgfCBWSURFT19ESVBfRU5BQkxFX0dNUF9IU1cg fAorCQkJIFZJREVPX0RJUF9FTkFCTEVfU1BEX0hTVyB8IFZJREVPX0RJUF9FTkFCTEVfRFJNX0dM SzsKKwl1MzIgdmFsID0gSTkxNV9SRUFEKHJlZyk7CisKKwkvKiBUT0RPOiBBZGQgRFNDIGNhc2Ug KERJUF9FTkFCTEVfUFBTKSAqLworCS8qIFdoZW4gUFNSIGlzIGVuYWJsZWQsIHRoaXMgcm91dGlu ZSBkb2Vzbid0IGRpc2FibGUgVlNDIERJUCAqLworCWlmIChpbnRlbF9wc3JfZW5hYmxlZChpbnRl bF9kcCkpCisJCXZhbCAmPSB+ZGlwX2VuYWJsZTsKKwllbHNlCisJCXZhbCAmPSB+KGRpcF9lbmFi bGUgfCBWSURFT19ESVBfRU5BQkxFX1ZTQ19IU1cpOworCisJaWYgKCFlbmFibGUpIHsKKwkJSTkx NV9XUklURShyZWcsIHZhbCk7CisJCVBPU1RJTkdfUkVBRChyZWcpOworCQlyZXR1cm47CisJfQor CisJSTkxNV9XUklURShyZWcsIHZhbCk7CisJUE9TVElOR19SRUFEKHJlZyk7CisKKwkvKiBXaGVu IFBTUiBpcyBlbmFibGVkLCBWU0MgU0RQIGlzIGhhbmRsZWQgYnkgUFNSIHJvdXRpbmUgKi8KKwlp ZiAoIWludGVsX3Bzcl9lbmFibGVkKGludGVsX2RwKSkKKwkJaW50ZWxfd3JpdGVfZHBfc2RwKGVu Y29kZXIsIGNydGNfc3RhdGUsIERQX1NEUF9WU0MpOworCisJaW50ZWxfd3JpdGVfZHBfc2RwKGVu Y29kZXIsIGNydGNfc3RhdGUsIEhETUlfUEFDS0VUX1RZUEVfR0FNVVRfTUVUQURBVEEpOworfQor CiBzdGF0aWMgdm9pZAogaW50ZWxfZHBfc2V0dXBfdnNjX3NkcChzdHJ1Y3QgaW50ZWxfZHAgKmlu dGVsX2RwLAogCQkgICAgICAgY29uc3Qgc3RydWN0IGludGVsX2NydGNfc3RhdGUgKmNydGNfc3Rh dGUsCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9kaXNwbGF5L2ludGVsX2RwLmgg Yi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9kaXNwbGF5L2ludGVsX2RwLmgKaW5kZXggM2RhMTY2MDU0 Nzg4Li4wZGMwOWE0NjNlZTEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2Rpc3Bs YXkvaW50ZWxfZHAuaAorKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9kaXNwbGF5L2ludGVsX2Rw LmgKQEAgLTExNiw2ICsxMTYsOSBAQCB2b2lkIGludGVsX2RwX3ZzY19lbmFibGUoc3RydWN0IGlu dGVsX2RwICppbnRlbF9kcCwKIHZvaWQgaW50ZWxfZHBfaGRyX21ldGFkYXRhX2VuYWJsZShzdHJ1 Y3QgaW50ZWxfZHAgKmludGVsX2RwLAogCQkJCSAgY29uc3Qgc3RydWN0IGludGVsX2NydGNfc3Rh dGUgKmNydGNfc3RhdGUsCiAJCQkJICBjb25zdCBzdHJ1Y3QgZHJtX2Nvbm5lY3Rvcl9zdGF0ZSAq Y29ubl9zdGF0ZSk7Cit2b2lkIGludGVsX2RwX3NldF9pbmZvZnJhbWVzKHN0cnVjdCBpbnRlbF9l bmNvZGVyICplbmNvZGVyLCBib29sIGVuYWJsZSwKKwkJCSAgICAgY29uc3Qgc3RydWN0IGludGVs X2NydGNfc3RhdGUgKmNydGNfc3RhdGUsCisJCQkgICAgIGNvbnN0IHN0cnVjdCBkcm1fY29ubmVj dG9yX3N0YXRlICpjb25uX3N0YXRlKTsKIGJvb2wgaW50ZWxfZGlnaXRhbF9wb3J0X2Nvbm5lY3Rl ZChzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2Rlcik7CiAKIHN0YXRpYyBpbmxpbmUgdW5zaWdu ZWQgaW50IGludGVsX2RwX3VudXNlZF9sYW5lX21hc2soaW50IGxhbmVfY291bnQpCi0tIAoyLjI0 LjEKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCkludGVs LWdmeCBtYWlsaW5nIGxpc3QKSW50ZWwtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczov L2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2ludGVsLWdmeAo=