From mboxrd@z Thu Jan 1 00:00:00 1970 From: Gwan-gyeong Mun Date: Mon, 03 Feb 2020 23:20:03 +0000 Subject: [PATCH v3 06/17] drm/i915/dp: Read out DP SDPs (Secondary Data Packet) Message-Id: <20200203232014.906651-7-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="utf-8" Content-Transfer-Encoding: 8bit To: intel-gfx@lists.freedesktop.org Cc: linux-fbdev@vger.kernel.org, dri-devel@lists.freedesktop.org It adds code to read the DP SDPs from the video DIP and unpack them into the crtc state. It adds routines that read out DP VSC SDP and DP HDR Metadata Infoframe SDP In order to unpack DP VSC SDP, it adds intel_dp_vsc_sdp_unpack() 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 unpack DP HDR Metadata Infoframe SDP, it adds intel_dp_hdr_metadata_infoframe_sdp_unpack(). 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 nameing rule and style of intel_read_dp_sdp() function references intel_read_infoframe() function of intel_hdmi.c v2: Minor style fix v3: 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 | 170 ++++++++++++++++++++++++ drivers/gpu/drm/i915/display/intel_dp.h | 3 + 2 files changed, 173 insertions(+) diff --git a/drivers/gpu/drm/i915/display/intel_dp.c b/drivers/gpu/drm/i915/display/intel_dp.c index dd7e5588001e..d4ece0a824c0 100644 --- a/drivers/gpu/drm/i915/display/intel_dp.c +++ b/drivers/gpu/drm/i915/display/intel_dp.c @@ -4925,6 +4925,176 @@ void intel_dp_set_infoframes(struct intel_encoder *encoder, intel_write_dp_sdp(encoder, crtc_state, HDMI_PACKET_TYPE_GAMUT_METADATA); } +static int intel_dp_vsc_sdp_unpack(struct drm_dp_vsc_sdp *vsc, + const void *buffer, size_t size) +{ + const struct dp_sdp *sdp = buffer; + + if (size < sizeof(struct dp_sdp)) + return -EINVAL; + + memset(vsc, 0, size); + + if (sdp->sdp_header.HB0 != 0) + return -EINVAL; + + if (sdp->sdp_header.HB1 != DP_SDP_VSC) + return -EINVAL; + vsc->sdp_type = sdp->sdp_header.HB1; + + if (sdp->sdp_header.HB2 = 0x2 && sdp->sdp_header.HB3 = 0x8) { + vsc->revision = sdp->sdp_header.HB2; + vsc->length = sdp->sdp_header.HB3; + } else if (sdp->sdp_header.HB2 = 0x4 && sdp->sdp_header.HB3 = 0xe) { + vsc->revision = sdp->sdp_header.HB2; + vsc->length = sdp->sdp_header.HB3; + } else if (sdp->sdp_header.HB2 = 0x5 && sdp->sdp_header.HB3 = 0x13) { + vsc->revision = sdp->sdp_header.HB2; + vsc->length = sdp->sdp_header.HB3; + vsc->colorspace = (sdp->db[16] >> 4) & 0xf; + vsc->colorimetry = sdp->db[16] & 0xf; + vsc->dynamic_range = (sdp->db[17] >> 7) & 0x1; + + switch (sdp->db[17] & 0x7) { + case 0x1: + vsc->bpc = 8; + break; + case 0x2: + vsc->bpc = 10; + break; + case 0x3: + vsc->bpc = 12; + break; + case 0x4: + vsc->bpc = 16; + break; + default: + MISSING_CASE(sdp->db[17] & 0x7); + return -EINVAL; + } + + vsc->content_type = sdp->db[18] & 0x7; + } else { + return -EINVAL; + } + + return 0; +} + +static int +intel_dp_hdr_metadata_infoframe_sdp_unpack(struct hdmi_drm_infoframe *drm_infoframe, + const void *buffer, size_t size) +{ + int ret; + + const struct dp_sdp *sdp = buffer; + + if (size < sizeof(struct dp_sdp)) + return -EINVAL; + + if (sdp->sdp_header.HB0 != 0) + return -EINVAL; + + if (sdp->sdp_header.HB1 != HDMI_INFOFRAME_TYPE_DRM) + return -EINVAL; + + /* + * Least Significant Eight Bits of (Data Byte Count – 1) + * 1Dh (i.e., Data Byte Count = 30 bytes). + */ + if (sdp->sdp_header.HB2 != 0x1D) + return -EINVAL; + + /* Most Significant Two Bits of (Data Byte Count – 1), Clear to 00b. */ + if ((sdp->sdp_header.HB3 & 0x3) != 0) + return -EINVAL; + + /* INFOFRAME SDP Version Number */ + if (((sdp->sdp_header.HB3 >> 2) & 0x3f) != 0x13) + return -EINVAL; + + /* CTA Header Byte 2 (INFOFRAME Version Number) */ + if (sdp->db[0] != 1) + return -EINVAL; + + /* CTA Header Byte 3 (Length of INFOFRAME): HDMI_DRM_INFOFRAME_SIZE */ + if (sdp->db[1] != HDMI_DRM_INFOFRAME_SIZE) + return -EINVAL; + + ret = hdmi_drm_infoframe_unpack_only(drm_infoframe, &sdp->db[2], + HDMI_DRM_INFOFRAME_SIZE); + + return ret; +} + +static void intel_read_dp_vsc_sdp(struct intel_encoder *encoder, + struct intel_crtc_state *crtc_state, + struct drm_dp_vsc_sdp *vsc) +{ + struct intel_digital_port *intel_dig_port = enc_to_dig_port(encoder); + struct intel_dp *intel_dp = enc_to_intel_dp(encoder); + unsigned int type = DP_SDP_VSC; + struct dp_sdp sdp = {}; + int ret; + + /* When PSR is enabled, VSC SDP is handled by PSR routine */ + if (intel_psr_enabled(intel_dp)) + return; + + if ((crtc_state->infoframes.enable & + intel_hdmi_infoframe_enable(type)) = 0) + return; + + intel_dig_port->read_infoframe(encoder, crtc_state, type, &sdp, sizeof(sdp)); + + ret = intel_dp_vsc_sdp_unpack(vsc, &sdp, sizeof(sdp)); + + if (ret) + DRM_DEBUG_KMS("Failed to unpack DP VSC SDP\n"); +} + +static void intel_read_dp_hdr_metadata_infoframe_sdp(struct intel_encoder *encoder, + struct intel_crtc_state *crtc_state, + struct hdmi_drm_infoframe *drm_infoframe) +{ + struct intel_digital_port *intel_dig_port = enc_to_dig_port(encoder); + unsigned int type = HDMI_PACKET_TYPE_GAMUT_METADATA; + struct dp_sdp sdp = {}; + int ret; + + if ((crtc_state->infoframes.enable & + intel_hdmi_infoframe_enable(type)) = 0) + return; + + intel_dig_port->read_infoframe(encoder, crtc_state, type, &sdp, + sizeof(sdp)); + + ret = intel_dp_hdr_metadata_infoframe_sdp_unpack(drm_infoframe, &sdp, + sizeof(sdp)); + + if (ret) + DRM_DEBUG_KMS("Failed to unpack DP HDR Metadata Infoframe SDP\n"); +} + +void intel_read_dp_sdp(struct intel_encoder *encoder, + struct intel_crtc_state *crtc_state, + unsigned int type) +{ + switch (type) { + case DP_SDP_VSC: + intel_read_dp_vsc_sdp(encoder, crtc_state, + &crtc_state->infoframes.vsc); + break; + case HDMI_PACKET_TYPE_GAMUT_METADATA: + intel_read_dp_hdr_metadata_infoframe_sdp(encoder, crtc_state, + &crtc_state->infoframes.drm.drm); + break; + default: + MISSING_CASE(type); + break; + } +} + 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 0dc09a463ee1..e8f9ba962d09 100644 --- a/drivers/gpu/drm/i915/display/intel_dp.h +++ b/drivers/gpu/drm/i915/display/intel_dp.h @@ -119,6 +119,9 @@ void intel_dp_hdr_metadata_enable(struct intel_dp *intel_dp, 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); +void intel_read_dp_sdp(struct intel_encoder *encoder, + struct intel_crtc_state *crtc_state, + unsigned int type); bool intel_digital_port_connected(struct intel_encoder *encoder); static inline unsigned int intel_dp_unused_lane_mask(int lane_count) -- 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=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 7AEC0C35249 for ; Mon, 3 Feb 2020 23:20:43 +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 418C620721 for ; Mon, 3 Feb 2020 23:20:43 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 418C620721 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 3833A6ED38; Mon, 3 Feb 2020 23:20:29 +0000 (UTC) Received: from mga17.intel.com (mga17.intel.com [192.55.52.151]) by gabe.freedesktop.org (Postfix) with ESMTPS id 84D886ED2D; Mon, 3 Feb 2020 23:20:27 +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:27 -0800 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.70,398,1574150400"; d="scan'208";a="310866822" Received: from helsinki.fi.intel.com ([10.237.66.150]) by orsmga001.jf.intel.com with ESMTP; 03 Feb 2020 15:20:25 -0800 From: Gwan-gyeong Mun To: intel-gfx@lists.freedesktop.org Subject: [PATCH v3 06/17] drm/i915/dp: Read out DP SDPs (Secondary Data Packet) Date: Tue, 4 Feb 2020 01:20:03 +0200 Message-Id: <20200203232014.906651-7-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" SXQgYWRkcyBjb2RlIHRvIHJlYWQgdGhlIERQIFNEUHMgZnJvbSB0aGUgdmlkZW8gRElQIGFuZCB1 bnBhY2sgdGhlbSBpbnRvCnRoZSBjcnRjIHN0YXRlLgoKSXQgYWRkcyByb3V0aW5lcyB0aGF0IHJl YWQgb3V0IERQIFZTQyBTRFAgYW5kIERQIEhEUiBNZXRhZGF0YSBJbmZvZnJhbWUgU0RQCkluIG9y ZGVyIHRvIHVucGFjayBEUCBWU0MgU0RQLCBpdCBhZGRzIGludGVsX2RwX3ZzY19zZHBfdW5wYWNr KCkgZnVuY3Rpb24uCkl0IGZvbGxvd3MgRFAgMS40YSBzcGVjLiBbVGFibGUgMi0xMTY6IFZTQyBT RFAgSGVhZGVyIEJ5dGVzXSBhbmQKW1RhYmxlIDItMTE3OiBWU0MgU0RQIFBheWxvYWQgZm9yIERC MTYgdGhyb3VnaCBEQjE4XQoKSW4gb3JkZXIgdG8gdW5wYWNrIERQIEhEUiBNZXRhZGF0YSBJbmZv ZnJhbWUgU0RQLCBpdCBhZGRzCmludGVsX2RwX2hkcl9tZXRhZGF0YV9pbmZvZnJhbWVfc2RwX3Vu cGFjaygpLiBBbmQgaXQgZm9sbG93cyBEUCAxLjRhIHNwZWMuCihbVGFibGUgMi0xMjU6IElORk9G UkFNRSBTRFAgdjEuMiBIZWFkZXIgQnl0ZXNdIGFuZApbVGFibGUgMi0xMjY6IElORk9GUkFNRSBT RFAgdjEuMiBQYXlsb2FkIERhdGEgQnl0ZXMgLSBEQjAgdGhyb3VnaCBEQjMxXSkKYW5kIENUQS04 NjEtRyBzcGVjLiBbVGFibGUtNDIgRHluYW1pYyBSYW5nZSBhbmQgTWFzdGVyaW5nIEluZm9GcmFt ZV0uCgpBIG5hbWVpbmcgcnVsZSBhbmQgc3R5bGUgb2YgaW50ZWxfcmVhZF9kcF9zZHAoKSBmdW5j dGlvbiByZWZlcmVuY2VzCmludGVsX3JlYWRfaW5mb2ZyYW1lKCkgZnVuY3Rpb24gb2YgaW50ZWxf aGRtaS5jCgp2MjogTWlub3Igc3R5bGUgZml4CnYzOiBSZXBsYWNlIGEgc3RydWN0dXJlIG5hbWUg dG8gZHJtX2RwX3ZzY19zZHAgZnJvbSBpbnRlbF9kcF92c2Nfc2RwCgpTaWduZWQtb2ZmLWJ5OiBH d2FuLWd5ZW9uZyBNdW4gPGd3YW4tZ3llb25nLm11bkBpbnRlbC5jb20+Ci0tLQogZHJpdmVycy9n cHUvZHJtL2k5MTUvZGlzcGxheS9pbnRlbF9kcC5jIHwgMTcwICsrKysrKysrKysrKysrKysrKysr KysrKwogZHJpdmVycy9ncHUvZHJtL2k5MTUvZGlzcGxheS9pbnRlbF9kcC5oIHwgICAzICsKIDIg ZmlsZXMgY2hhbmdlZCwgMTczIGluc2VydGlvbnMoKykKCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dw dS9kcm0vaTkxNS9kaXNwbGF5L2ludGVsX2RwLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9kaXNw bGF5L2ludGVsX2RwLmMKaW5kZXggZGQ3ZTU1ODgwMDFlLi5kNGVjZTBhODI0YzAgMTAwNjQ0Ci0t LSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2Rpc3BsYXkvaW50ZWxfZHAuYworKysgYi9kcml2ZXJz L2dwdS9kcm0vaTkxNS9kaXNwbGF5L2ludGVsX2RwLmMKQEAgLTQ5MjUsNiArNDkyNSwxNzYgQEAg dm9pZCBpbnRlbF9kcF9zZXRfaW5mb2ZyYW1lcyhzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2Rl ciwKIAlpbnRlbF93cml0ZV9kcF9zZHAoZW5jb2RlciwgY3J0Y19zdGF0ZSwgSERNSV9QQUNLRVRf VFlQRV9HQU1VVF9NRVRBREFUQSk7CiB9CiAKK3N0YXRpYyBpbnQgaW50ZWxfZHBfdnNjX3NkcF91 bnBhY2soc3RydWN0IGRybV9kcF92c2Nfc2RwICp2c2MsCisJCQkJICAgY29uc3Qgdm9pZCAqYnVm ZmVyLCBzaXplX3Qgc2l6ZSkKK3sKKwljb25zdCBzdHJ1Y3QgZHBfc2RwICpzZHAgPSBidWZmZXI7 CisKKwlpZiAoc2l6ZSA8IHNpemVvZihzdHJ1Y3QgZHBfc2RwKSkKKwkJcmV0dXJuIC1FSU5WQUw7 CisKKwltZW1zZXQodnNjLCAwLCBzaXplKTsKKworCWlmIChzZHAtPnNkcF9oZWFkZXIuSEIwICE9 IDApCisJCXJldHVybiAtRUlOVkFMOworCisJaWYgKHNkcC0+c2RwX2hlYWRlci5IQjEgIT0gRFBf U0RQX1ZTQykKKwkJcmV0dXJuIC1FSU5WQUw7CisJdnNjLT5zZHBfdHlwZSA9IHNkcC0+c2RwX2hl YWRlci5IQjE7CisKKwlpZiAoc2RwLT5zZHBfaGVhZGVyLkhCMiA9PSAweDIgJiYgc2RwLT5zZHBf aGVhZGVyLkhCMyA9PSAweDgpIHsKKwkJdnNjLT5yZXZpc2lvbiA9IHNkcC0+c2RwX2hlYWRlci5I QjI7CisJCXZzYy0+bGVuZ3RoID0gc2RwLT5zZHBfaGVhZGVyLkhCMzsKKwl9IGVsc2UgaWYgKHNk cC0+c2RwX2hlYWRlci5IQjIgPT0gMHg0ICYmIHNkcC0+c2RwX2hlYWRlci5IQjMgPT0gMHhlKSB7 CisJCXZzYy0+cmV2aXNpb24gPSBzZHAtPnNkcF9oZWFkZXIuSEIyOworCQl2c2MtPmxlbmd0aCA9 IHNkcC0+c2RwX2hlYWRlci5IQjM7CisJfSBlbHNlIGlmIChzZHAtPnNkcF9oZWFkZXIuSEIyID09 IDB4NSAmJiBzZHAtPnNkcF9oZWFkZXIuSEIzID09IDB4MTMpIHsKKwkJdnNjLT5yZXZpc2lvbiA9 IHNkcC0+c2RwX2hlYWRlci5IQjI7CisJCXZzYy0+bGVuZ3RoID0gc2RwLT5zZHBfaGVhZGVyLkhC MzsKKwkJdnNjLT5jb2xvcnNwYWNlID0gKHNkcC0+ZGJbMTZdID4+IDQpICYgMHhmOworCQl2c2Mt PmNvbG9yaW1ldHJ5ID0gc2RwLT5kYlsxNl0gJiAweGY7CisJCXZzYy0+ZHluYW1pY19yYW5nZSA9 IChzZHAtPmRiWzE3XSA+PiA3KSAmIDB4MTsKKworCQlzd2l0Y2ggKHNkcC0+ZGJbMTddICYgMHg3 KSB7CisJCWNhc2UgMHgxOgorCQkJdnNjLT5icGMgPSA4OworCQkJYnJlYWs7CisJCWNhc2UgMHgy OgorCQkJdnNjLT5icGMgPSAxMDsKKwkJCWJyZWFrOworCQljYXNlIDB4MzoKKwkJCXZzYy0+YnBj ID0gMTI7CisJCQlicmVhazsKKwkJY2FzZSAweDQ6CisJCQl2c2MtPmJwYyA9IDE2OworCQkJYnJl YWs7CisJCWRlZmF1bHQ6CisJCQlNSVNTSU5HX0NBU0Uoc2RwLT5kYlsxN10gJiAweDcpOworCQkJ cmV0dXJuIC1FSU5WQUw7CisJCX0KKworCQl2c2MtPmNvbnRlbnRfdHlwZSA9IHNkcC0+ZGJbMThd ICYgMHg3OworCX0gZWxzZSB7CisJCXJldHVybiAtRUlOVkFMOworCX0KKworCXJldHVybiAwOwor fQorCitzdGF0aWMgaW50CitpbnRlbF9kcF9oZHJfbWV0YWRhdGFfaW5mb2ZyYW1lX3NkcF91bnBh Y2soc3RydWN0IGhkbWlfZHJtX2luZm9mcmFtZSAqZHJtX2luZm9mcmFtZSwKKwkJCQkJICAgY29u c3Qgdm9pZCAqYnVmZmVyLCBzaXplX3Qgc2l6ZSkKK3sKKwlpbnQgcmV0OworCisJY29uc3Qgc3Ry dWN0IGRwX3NkcCAqc2RwID0gYnVmZmVyOworCisJaWYgKHNpemUgPCBzaXplb2Yoc3RydWN0IGRw X3NkcCkpCisJCXJldHVybiAtRUlOVkFMOworCisJaWYgKHNkcC0+c2RwX2hlYWRlci5IQjAgIT0g MCkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlpZiAoc2RwLT5zZHBfaGVhZGVyLkhCMSAhPSBIRE1J X0lORk9GUkFNRV9UWVBFX0RSTSkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwkvKgorCSAqIExlYXN0 IFNpZ25pZmljYW50IEVpZ2h0IEJpdHMgb2YgKERhdGEgQnl0ZSBDb3VudCDigJMgMSkKKwkgKiAx RGggKGkuZS4sIERhdGEgQnl0ZSBDb3VudCA9IDMwIGJ5dGVzKS4KKwkgKi8KKwlpZiAoc2RwLT5z ZHBfaGVhZGVyLkhCMiAhPSAweDFEKQorCQlyZXR1cm4gLUVJTlZBTDsKKworCS8qIE1vc3QgU2ln bmlmaWNhbnQgVHdvIEJpdHMgb2YgKERhdGEgQnl0ZSBDb3VudCDigJMgMSksIENsZWFyIHRvIDAw Yi4gKi8KKwlpZiAoKHNkcC0+c2RwX2hlYWRlci5IQjMgJiAweDMpICE9IDApCisJCXJldHVybiAt RUlOVkFMOworCisJLyogSU5GT0ZSQU1FIFNEUCBWZXJzaW9uIE51bWJlciAqLworCWlmICgoKHNk cC0+c2RwX2hlYWRlci5IQjMgPj4gMikgJiAweDNmKSAhPSAweDEzKQorCQlyZXR1cm4gLUVJTlZB TDsKKworCS8qIENUQSBIZWFkZXIgQnl0ZSAyIChJTkZPRlJBTUUgVmVyc2lvbiBOdW1iZXIpICov CisJaWYgKHNkcC0+ZGJbMF0gIT0gMSkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwkvKiBDVEEgSGVh ZGVyIEJ5dGUgMyAoTGVuZ3RoIG9mIElORk9GUkFNRSk6IEhETUlfRFJNX0lORk9GUkFNRV9TSVpF ICovCisJaWYgKHNkcC0+ZGJbMV0gIT0gSERNSV9EUk1fSU5GT0ZSQU1FX1NJWkUpCisJCXJldHVy biAtRUlOVkFMOworCisJcmV0ID0gaGRtaV9kcm1faW5mb2ZyYW1lX3VucGFja19vbmx5KGRybV9p bmZvZnJhbWUsICZzZHAtPmRiWzJdLAorCQkJCQkgICAgIEhETUlfRFJNX0lORk9GUkFNRV9TSVpF KTsKKworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyB2b2lkIGludGVsX3JlYWRfZHBfdnNjX3Nk cChzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2RlciwKKwkJCQkgIHN0cnVjdCBpbnRlbF9jcnRj X3N0YXRlICpjcnRjX3N0YXRlLAorCQkJCSAgc3RydWN0IGRybV9kcF92c2Nfc2RwICp2c2MpCit7 CisJc3RydWN0IGludGVsX2RpZ2l0YWxfcG9ydCAqaW50ZWxfZGlnX3BvcnQgPSBlbmNfdG9fZGln X3BvcnQoZW5jb2Rlcik7CisJc3RydWN0IGludGVsX2RwICppbnRlbF9kcCA9IGVuY190b19pbnRl bF9kcChlbmNvZGVyKTsKKwl1bnNpZ25lZCBpbnQgdHlwZSA9IERQX1NEUF9WU0M7CisJc3RydWN0 IGRwX3NkcCBzZHAgPSB7fTsKKwlpbnQgcmV0OworCisJLyogV2hlbiBQU1IgaXMgZW5hYmxlZCwg VlNDIFNEUCBpcyBoYW5kbGVkIGJ5IFBTUiByb3V0aW5lICovCisJaWYgKGludGVsX3Bzcl9lbmFi bGVkKGludGVsX2RwKSkKKwkJcmV0dXJuOworCisJaWYgKChjcnRjX3N0YXRlLT5pbmZvZnJhbWVz LmVuYWJsZSAmCisJICAgICBpbnRlbF9oZG1pX2luZm9mcmFtZV9lbmFibGUodHlwZSkpID09IDAp CisJCXJldHVybjsKKworCWludGVsX2RpZ19wb3J0LT5yZWFkX2luZm9mcmFtZShlbmNvZGVyLCBj cnRjX3N0YXRlLCB0eXBlLCAmc2RwLCBzaXplb2Yoc2RwKSk7CisKKwlyZXQgPSBpbnRlbF9kcF92 c2Nfc2RwX3VucGFjayh2c2MsICZzZHAsIHNpemVvZihzZHApKTsKKworCWlmIChyZXQpCisJCURS TV9ERUJVR19LTVMoIkZhaWxlZCB0byB1bnBhY2sgRFAgVlNDIFNEUFxuIik7Cit9CisKK3N0YXRp YyB2b2lkIGludGVsX3JlYWRfZHBfaGRyX21ldGFkYXRhX2luZm9mcmFtZV9zZHAoc3RydWN0IGlu dGVsX2VuY29kZXIgKmVuY29kZXIsCisJCQkJCQkgICAgIHN0cnVjdCBpbnRlbF9jcnRjX3N0YXRl ICpjcnRjX3N0YXRlLAorCQkJCQkJICAgICBzdHJ1Y3QgaGRtaV9kcm1faW5mb2ZyYW1lICpkcm1f aW5mb2ZyYW1lKQoreworCXN0cnVjdCBpbnRlbF9kaWdpdGFsX3BvcnQgKmludGVsX2RpZ19wb3J0 ID0gZW5jX3RvX2RpZ19wb3J0KGVuY29kZXIpOworCXVuc2lnbmVkIGludCB0eXBlID0gSERNSV9Q QUNLRVRfVFlQRV9HQU1VVF9NRVRBREFUQTsKKwlzdHJ1Y3QgZHBfc2RwIHNkcCA9IHt9OworCWlu dCByZXQ7CisKKwlpZiAoKGNydGNfc3RhdGUtPmluZm9mcmFtZXMuZW5hYmxlICYKKwkgICAgaW50 ZWxfaGRtaV9pbmZvZnJhbWVfZW5hYmxlKHR5cGUpKSA9PSAwKQorCQlyZXR1cm47CisKKwlpbnRl bF9kaWdfcG9ydC0+cmVhZF9pbmZvZnJhbWUoZW5jb2RlciwgY3J0Y19zdGF0ZSwgdHlwZSwgJnNk cCwKKwkJCQkgICAgICAgc2l6ZW9mKHNkcCkpOworCisJcmV0ID0gaW50ZWxfZHBfaGRyX21ldGFk YXRhX2luZm9mcmFtZV9zZHBfdW5wYWNrKGRybV9pbmZvZnJhbWUsICZzZHAsCisJCQkJCQkJIHNp emVvZihzZHApKTsKKworCWlmIChyZXQpCisJCURSTV9ERUJVR19LTVMoIkZhaWxlZCB0byB1bnBh Y2sgRFAgSERSIE1ldGFkYXRhIEluZm9mcmFtZSBTRFBcbiIpOworfQorCit2b2lkIGludGVsX3Jl YWRfZHBfc2RwKHN0cnVjdCBpbnRlbF9lbmNvZGVyICplbmNvZGVyLAorCQkgICAgICAgc3RydWN0 IGludGVsX2NydGNfc3RhdGUgKmNydGNfc3RhdGUsCisJCSAgICAgICB1bnNpZ25lZCBpbnQgdHlw ZSkKK3sKKwlzd2l0Y2ggKHR5cGUpIHsKKwljYXNlIERQX1NEUF9WU0M6CisJCWludGVsX3JlYWRf ZHBfdnNjX3NkcChlbmNvZGVyLCBjcnRjX3N0YXRlLAorCQkJCSAgICAgICZjcnRjX3N0YXRlLT5p bmZvZnJhbWVzLnZzYyk7CisJCWJyZWFrOworCWNhc2UgSERNSV9QQUNLRVRfVFlQRV9HQU1VVF9N RVRBREFUQToKKwkJaW50ZWxfcmVhZF9kcF9oZHJfbWV0YWRhdGFfaW5mb2ZyYW1lX3NkcChlbmNv ZGVyLCBjcnRjX3N0YXRlLAorCQkJCQkJCSAmY3J0Y19zdGF0ZS0+aW5mb2ZyYW1lcy5kcm0uZHJt KTsKKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJTUlTU0lOR19DQVNFKHR5cGUpOworCQlicmVhazsK Kwl9Cit9CisKIHN0YXRpYyB2b2lkCiBpbnRlbF9kcF9zZXR1cF92c2Nfc2RwKHN0cnVjdCBpbnRl bF9kcCAqaW50ZWxfZHAsCiAJCSAgICAgICBjb25zdCBzdHJ1Y3QgaW50ZWxfY3J0Y19zdGF0ZSAq Y3J0Y19zdGF0ZSwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2Rpc3BsYXkvaW50 ZWxfZHAuaCBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2Rpc3BsYXkvaW50ZWxfZHAuaAppbmRleCAw ZGMwOWE0NjNlZTEuLmU4ZjliYTk2MmQwOSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5 MTUvZGlzcGxheS9pbnRlbF9kcC5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2Rpc3BsYXkv aW50ZWxfZHAuaApAQCAtMTE5LDYgKzExOSw5IEBAIHZvaWQgaW50ZWxfZHBfaGRyX21ldGFkYXRh X2VuYWJsZShzdHJ1Y3QgaW50ZWxfZHAgKmludGVsX2RwLAogdm9pZCBpbnRlbF9kcF9zZXRfaW5m b2ZyYW1lcyhzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2RlciwgYm9vbCBlbmFibGUsCiAJCQkg ICAgIGNvbnN0IHN0cnVjdCBpbnRlbF9jcnRjX3N0YXRlICpjcnRjX3N0YXRlLAogCQkJICAgICBj b25zdCBzdHJ1Y3QgZHJtX2Nvbm5lY3Rvcl9zdGF0ZSAqY29ubl9zdGF0ZSk7Cit2b2lkIGludGVs X3JlYWRfZHBfc2RwKHN0cnVjdCBpbnRlbF9lbmNvZGVyICplbmNvZGVyLAorCQkgICAgICAgc3Ry dWN0IGludGVsX2NydGNfc3RhdGUgKmNydGNfc3RhdGUsCisJCSAgICAgICB1bnNpZ25lZCBpbnQg dHlwZSk7CiBib29sIGludGVsX2RpZ2l0YWxfcG9ydF9jb25uZWN0ZWQoc3RydWN0IGludGVsX2Vu Y29kZXIgKmVuY29kZXIpOwogCiBzdGF0aWMgaW5saW5lIHVuc2lnbmVkIGludCBpbnRlbF9kcF91 bnVzZWRfbGFuZV9tYXNrKGludCBsYW5lX2NvdW50KQotLSAKMi4yNC4xCgpfX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0 CmRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3Rv cC5vcmcvbWFpbG1hbi9saXN0aW5mby9kcmktZGV2ZWwK 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 99815C35247 for ; Mon, 3 Feb 2020 23:20:45 +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 6127520721 for ; Mon, 3 Feb 2020 23:20:45 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 6127520721 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 DBEBC6ED2D; Mon, 3 Feb 2020 23:20:29 +0000 (UTC) Received: from mga17.intel.com (mga17.intel.com [192.55.52.151]) by gabe.freedesktop.org (Postfix) with ESMTPS id 84D886ED2D; Mon, 3 Feb 2020 23:20:27 +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:27 -0800 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.70,398,1574150400"; d="scan'208";a="310866822" Received: from helsinki.fi.intel.com ([10.237.66.150]) by orsmga001.jf.intel.com with ESMTP; 03 Feb 2020 15:20:25 -0800 From: Gwan-gyeong Mun To: intel-gfx@lists.freedesktop.org Date: Tue, 4 Feb 2020 01:20:03 +0200 Message-Id: <20200203232014.906651-7-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 06/17] drm/i915/dp: Read out 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" SXQgYWRkcyBjb2RlIHRvIHJlYWQgdGhlIERQIFNEUHMgZnJvbSB0aGUgdmlkZW8gRElQIGFuZCB1 bnBhY2sgdGhlbSBpbnRvCnRoZSBjcnRjIHN0YXRlLgoKSXQgYWRkcyByb3V0aW5lcyB0aGF0IHJl YWQgb3V0IERQIFZTQyBTRFAgYW5kIERQIEhEUiBNZXRhZGF0YSBJbmZvZnJhbWUgU0RQCkluIG9y ZGVyIHRvIHVucGFjayBEUCBWU0MgU0RQLCBpdCBhZGRzIGludGVsX2RwX3ZzY19zZHBfdW5wYWNr KCkgZnVuY3Rpb24uCkl0IGZvbGxvd3MgRFAgMS40YSBzcGVjLiBbVGFibGUgMi0xMTY6IFZTQyBT RFAgSGVhZGVyIEJ5dGVzXSBhbmQKW1RhYmxlIDItMTE3OiBWU0MgU0RQIFBheWxvYWQgZm9yIERC MTYgdGhyb3VnaCBEQjE4XQoKSW4gb3JkZXIgdG8gdW5wYWNrIERQIEhEUiBNZXRhZGF0YSBJbmZv ZnJhbWUgU0RQLCBpdCBhZGRzCmludGVsX2RwX2hkcl9tZXRhZGF0YV9pbmZvZnJhbWVfc2RwX3Vu cGFjaygpLiBBbmQgaXQgZm9sbG93cyBEUCAxLjRhIHNwZWMuCihbVGFibGUgMi0xMjU6IElORk9G UkFNRSBTRFAgdjEuMiBIZWFkZXIgQnl0ZXNdIGFuZApbVGFibGUgMi0xMjY6IElORk9GUkFNRSBT RFAgdjEuMiBQYXlsb2FkIERhdGEgQnl0ZXMgLSBEQjAgdGhyb3VnaCBEQjMxXSkKYW5kIENUQS04 NjEtRyBzcGVjLiBbVGFibGUtNDIgRHluYW1pYyBSYW5nZSBhbmQgTWFzdGVyaW5nIEluZm9GcmFt ZV0uCgpBIG5hbWVpbmcgcnVsZSBhbmQgc3R5bGUgb2YgaW50ZWxfcmVhZF9kcF9zZHAoKSBmdW5j dGlvbiByZWZlcmVuY2VzCmludGVsX3JlYWRfaW5mb2ZyYW1lKCkgZnVuY3Rpb24gb2YgaW50ZWxf aGRtaS5jCgp2MjogTWlub3Igc3R5bGUgZml4CnYzOiBSZXBsYWNlIGEgc3RydWN0dXJlIG5hbWUg dG8gZHJtX2RwX3ZzY19zZHAgZnJvbSBpbnRlbF9kcF92c2Nfc2RwCgpTaWduZWQtb2ZmLWJ5OiBH d2FuLWd5ZW9uZyBNdW4gPGd3YW4tZ3llb25nLm11bkBpbnRlbC5jb20+Ci0tLQogZHJpdmVycy9n cHUvZHJtL2k5MTUvZGlzcGxheS9pbnRlbF9kcC5jIHwgMTcwICsrKysrKysrKysrKysrKysrKysr KysrKwogZHJpdmVycy9ncHUvZHJtL2k5MTUvZGlzcGxheS9pbnRlbF9kcC5oIHwgICAzICsKIDIg ZmlsZXMgY2hhbmdlZCwgMTczIGluc2VydGlvbnMoKykKCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dw dS9kcm0vaTkxNS9kaXNwbGF5L2ludGVsX2RwLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9kaXNw bGF5L2ludGVsX2RwLmMKaW5kZXggZGQ3ZTU1ODgwMDFlLi5kNGVjZTBhODI0YzAgMTAwNjQ0Ci0t LSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2Rpc3BsYXkvaW50ZWxfZHAuYworKysgYi9kcml2ZXJz L2dwdS9kcm0vaTkxNS9kaXNwbGF5L2ludGVsX2RwLmMKQEAgLTQ5MjUsNiArNDkyNSwxNzYgQEAg dm9pZCBpbnRlbF9kcF9zZXRfaW5mb2ZyYW1lcyhzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2Rl ciwKIAlpbnRlbF93cml0ZV9kcF9zZHAoZW5jb2RlciwgY3J0Y19zdGF0ZSwgSERNSV9QQUNLRVRf VFlQRV9HQU1VVF9NRVRBREFUQSk7CiB9CiAKK3N0YXRpYyBpbnQgaW50ZWxfZHBfdnNjX3NkcF91 bnBhY2soc3RydWN0IGRybV9kcF92c2Nfc2RwICp2c2MsCisJCQkJICAgY29uc3Qgdm9pZCAqYnVm ZmVyLCBzaXplX3Qgc2l6ZSkKK3sKKwljb25zdCBzdHJ1Y3QgZHBfc2RwICpzZHAgPSBidWZmZXI7 CisKKwlpZiAoc2l6ZSA8IHNpemVvZihzdHJ1Y3QgZHBfc2RwKSkKKwkJcmV0dXJuIC1FSU5WQUw7 CisKKwltZW1zZXQodnNjLCAwLCBzaXplKTsKKworCWlmIChzZHAtPnNkcF9oZWFkZXIuSEIwICE9 IDApCisJCXJldHVybiAtRUlOVkFMOworCisJaWYgKHNkcC0+c2RwX2hlYWRlci5IQjEgIT0gRFBf U0RQX1ZTQykKKwkJcmV0dXJuIC1FSU5WQUw7CisJdnNjLT5zZHBfdHlwZSA9IHNkcC0+c2RwX2hl YWRlci5IQjE7CisKKwlpZiAoc2RwLT5zZHBfaGVhZGVyLkhCMiA9PSAweDIgJiYgc2RwLT5zZHBf aGVhZGVyLkhCMyA9PSAweDgpIHsKKwkJdnNjLT5yZXZpc2lvbiA9IHNkcC0+c2RwX2hlYWRlci5I QjI7CisJCXZzYy0+bGVuZ3RoID0gc2RwLT5zZHBfaGVhZGVyLkhCMzsKKwl9IGVsc2UgaWYgKHNk cC0+c2RwX2hlYWRlci5IQjIgPT0gMHg0ICYmIHNkcC0+c2RwX2hlYWRlci5IQjMgPT0gMHhlKSB7 CisJCXZzYy0+cmV2aXNpb24gPSBzZHAtPnNkcF9oZWFkZXIuSEIyOworCQl2c2MtPmxlbmd0aCA9 IHNkcC0+c2RwX2hlYWRlci5IQjM7CisJfSBlbHNlIGlmIChzZHAtPnNkcF9oZWFkZXIuSEIyID09 IDB4NSAmJiBzZHAtPnNkcF9oZWFkZXIuSEIzID09IDB4MTMpIHsKKwkJdnNjLT5yZXZpc2lvbiA9 IHNkcC0+c2RwX2hlYWRlci5IQjI7CisJCXZzYy0+bGVuZ3RoID0gc2RwLT5zZHBfaGVhZGVyLkhC MzsKKwkJdnNjLT5jb2xvcnNwYWNlID0gKHNkcC0+ZGJbMTZdID4+IDQpICYgMHhmOworCQl2c2Mt PmNvbG9yaW1ldHJ5ID0gc2RwLT5kYlsxNl0gJiAweGY7CisJCXZzYy0+ZHluYW1pY19yYW5nZSA9 IChzZHAtPmRiWzE3XSA+PiA3KSAmIDB4MTsKKworCQlzd2l0Y2ggKHNkcC0+ZGJbMTddICYgMHg3 KSB7CisJCWNhc2UgMHgxOgorCQkJdnNjLT5icGMgPSA4OworCQkJYnJlYWs7CisJCWNhc2UgMHgy OgorCQkJdnNjLT5icGMgPSAxMDsKKwkJCWJyZWFrOworCQljYXNlIDB4MzoKKwkJCXZzYy0+YnBj ID0gMTI7CisJCQlicmVhazsKKwkJY2FzZSAweDQ6CisJCQl2c2MtPmJwYyA9IDE2OworCQkJYnJl YWs7CisJCWRlZmF1bHQ6CisJCQlNSVNTSU5HX0NBU0Uoc2RwLT5kYlsxN10gJiAweDcpOworCQkJ cmV0dXJuIC1FSU5WQUw7CisJCX0KKworCQl2c2MtPmNvbnRlbnRfdHlwZSA9IHNkcC0+ZGJbMThd ICYgMHg3OworCX0gZWxzZSB7CisJCXJldHVybiAtRUlOVkFMOworCX0KKworCXJldHVybiAwOwor fQorCitzdGF0aWMgaW50CitpbnRlbF9kcF9oZHJfbWV0YWRhdGFfaW5mb2ZyYW1lX3NkcF91bnBh Y2soc3RydWN0IGhkbWlfZHJtX2luZm9mcmFtZSAqZHJtX2luZm9mcmFtZSwKKwkJCQkJICAgY29u c3Qgdm9pZCAqYnVmZmVyLCBzaXplX3Qgc2l6ZSkKK3sKKwlpbnQgcmV0OworCisJY29uc3Qgc3Ry dWN0IGRwX3NkcCAqc2RwID0gYnVmZmVyOworCisJaWYgKHNpemUgPCBzaXplb2Yoc3RydWN0IGRw X3NkcCkpCisJCXJldHVybiAtRUlOVkFMOworCisJaWYgKHNkcC0+c2RwX2hlYWRlci5IQjAgIT0g MCkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlpZiAoc2RwLT5zZHBfaGVhZGVyLkhCMSAhPSBIRE1J X0lORk9GUkFNRV9UWVBFX0RSTSkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwkvKgorCSAqIExlYXN0 IFNpZ25pZmljYW50IEVpZ2h0IEJpdHMgb2YgKERhdGEgQnl0ZSBDb3VudCDigJMgMSkKKwkgKiAx RGggKGkuZS4sIERhdGEgQnl0ZSBDb3VudCA9IDMwIGJ5dGVzKS4KKwkgKi8KKwlpZiAoc2RwLT5z ZHBfaGVhZGVyLkhCMiAhPSAweDFEKQorCQlyZXR1cm4gLUVJTlZBTDsKKworCS8qIE1vc3QgU2ln bmlmaWNhbnQgVHdvIEJpdHMgb2YgKERhdGEgQnl0ZSBDb3VudCDigJMgMSksIENsZWFyIHRvIDAw Yi4gKi8KKwlpZiAoKHNkcC0+c2RwX2hlYWRlci5IQjMgJiAweDMpICE9IDApCisJCXJldHVybiAt RUlOVkFMOworCisJLyogSU5GT0ZSQU1FIFNEUCBWZXJzaW9uIE51bWJlciAqLworCWlmICgoKHNk cC0+c2RwX2hlYWRlci5IQjMgPj4gMikgJiAweDNmKSAhPSAweDEzKQorCQlyZXR1cm4gLUVJTlZB TDsKKworCS8qIENUQSBIZWFkZXIgQnl0ZSAyIChJTkZPRlJBTUUgVmVyc2lvbiBOdW1iZXIpICov CisJaWYgKHNkcC0+ZGJbMF0gIT0gMSkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwkvKiBDVEEgSGVh ZGVyIEJ5dGUgMyAoTGVuZ3RoIG9mIElORk9GUkFNRSk6IEhETUlfRFJNX0lORk9GUkFNRV9TSVpF ICovCisJaWYgKHNkcC0+ZGJbMV0gIT0gSERNSV9EUk1fSU5GT0ZSQU1FX1NJWkUpCisJCXJldHVy biAtRUlOVkFMOworCisJcmV0ID0gaGRtaV9kcm1faW5mb2ZyYW1lX3VucGFja19vbmx5KGRybV9p bmZvZnJhbWUsICZzZHAtPmRiWzJdLAorCQkJCQkgICAgIEhETUlfRFJNX0lORk9GUkFNRV9TSVpF KTsKKworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyB2b2lkIGludGVsX3JlYWRfZHBfdnNjX3Nk cChzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2RlciwKKwkJCQkgIHN0cnVjdCBpbnRlbF9jcnRj X3N0YXRlICpjcnRjX3N0YXRlLAorCQkJCSAgc3RydWN0IGRybV9kcF92c2Nfc2RwICp2c2MpCit7 CisJc3RydWN0IGludGVsX2RpZ2l0YWxfcG9ydCAqaW50ZWxfZGlnX3BvcnQgPSBlbmNfdG9fZGln X3BvcnQoZW5jb2Rlcik7CisJc3RydWN0IGludGVsX2RwICppbnRlbF9kcCA9IGVuY190b19pbnRl bF9kcChlbmNvZGVyKTsKKwl1bnNpZ25lZCBpbnQgdHlwZSA9IERQX1NEUF9WU0M7CisJc3RydWN0 IGRwX3NkcCBzZHAgPSB7fTsKKwlpbnQgcmV0OworCisJLyogV2hlbiBQU1IgaXMgZW5hYmxlZCwg VlNDIFNEUCBpcyBoYW5kbGVkIGJ5IFBTUiByb3V0aW5lICovCisJaWYgKGludGVsX3Bzcl9lbmFi bGVkKGludGVsX2RwKSkKKwkJcmV0dXJuOworCisJaWYgKChjcnRjX3N0YXRlLT5pbmZvZnJhbWVz LmVuYWJsZSAmCisJICAgICBpbnRlbF9oZG1pX2luZm9mcmFtZV9lbmFibGUodHlwZSkpID09IDAp CisJCXJldHVybjsKKworCWludGVsX2RpZ19wb3J0LT5yZWFkX2luZm9mcmFtZShlbmNvZGVyLCBj cnRjX3N0YXRlLCB0eXBlLCAmc2RwLCBzaXplb2Yoc2RwKSk7CisKKwlyZXQgPSBpbnRlbF9kcF92 c2Nfc2RwX3VucGFjayh2c2MsICZzZHAsIHNpemVvZihzZHApKTsKKworCWlmIChyZXQpCisJCURS TV9ERUJVR19LTVMoIkZhaWxlZCB0byB1bnBhY2sgRFAgVlNDIFNEUFxuIik7Cit9CisKK3N0YXRp YyB2b2lkIGludGVsX3JlYWRfZHBfaGRyX21ldGFkYXRhX2luZm9mcmFtZV9zZHAoc3RydWN0IGlu dGVsX2VuY29kZXIgKmVuY29kZXIsCisJCQkJCQkgICAgIHN0cnVjdCBpbnRlbF9jcnRjX3N0YXRl ICpjcnRjX3N0YXRlLAorCQkJCQkJICAgICBzdHJ1Y3QgaGRtaV9kcm1faW5mb2ZyYW1lICpkcm1f aW5mb2ZyYW1lKQoreworCXN0cnVjdCBpbnRlbF9kaWdpdGFsX3BvcnQgKmludGVsX2RpZ19wb3J0 ID0gZW5jX3RvX2RpZ19wb3J0KGVuY29kZXIpOworCXVuc2lnbmVkIGludCB0eXBlID0gSERNSV9Q QUNLRVRfVFlQRV9HQU1VVF9NRVRBREFUQTsKKwlzdHJ1Y3QgZHBfc2RwIHNkcCA9IHt9OworCWlu dCByZXQ7CisKKwlpZiAoKGNydGNfc3RhdGUtPmluZm9mcmFtZXMuZW5hYmxlICYKKwkgICAgaW50 ZWxfaGRtaV9pbmZvZnJhbWVfZW5hYmxlKHR5cGUpKSA9PSAwKQorCQlyZXR1cm47CisKKwlpbnRl bF9kaWdfcG9ydC0+cmVhZF9pbmZvZnJhbWUoZW5jb2RlciwgY3J0Y19zdGF0ZSwgdHlwZSwgJnNk cCwKKwkJCQkgICAgICAgc2l6ZW9mKHNkcCkpOworCisJcmV0ID0gaW50ZWxfZHBfaGRyX21ldGFk YXRhX2luZm9mcmFtZV9zZHBfdW5wYWNrKGRybV9pbmZvZnJhbWUsICZzZHAsCisJCQkJCQkJIHNp emVvZihzZHApKTsKKworCWlmIChyZXQpCisJCURSTV9ERUJVR19LTVMoIkZhaWxlZCB0byB1bnBh Y2sgRFAgSERSIE1ldGFkYXRhIEluZm9mcmFtZSBTRFBcbiIpOworfQorCit2b2lkIGludGVsX3Jl YWRfZHBfc2RwKHN0cnVjdCBpbnRlbF9lbmNvZGVyICplbmNvZGVyLAorCQkgICAgICAgc3RydWN0 IGludGVsX2NydGNfc3RhdGUgKmNydGNfc3RhdGUsCisJCSAgICAgICB1bnNpZ25lZCBpbnQgdHlw ZSkKK3sKKwlzd2l0Y2ggKHR5cGUpIHsKKwljYXNlIERQX1NEUF9WU0M6CisJCWludGVsX3JlYWRf ZHBfdnNjX3NkcChlbmNvZGVyLCBjcnRjX3N0YXRlLAorCQkJCSAgICAgICZjcnRjX3N0YXRlLT5p bmZvZnJhbWVzLnZzYyk7CisJCWJyZWFrOworCWNhc2UgSERNSV9QQUNLRVRfVFlQRV9HQU1VVF9N RVRBREFUQToKKwkJaW50ZWxfcmVhZF9kcF9oZHJfbWV0YWRhdGFfaW5mb2ZyYW1lX3NkcChlbmNv ZGVyLCBjcnRjX3N0YXRlLAorCQkJCQkJCSAmY3J0Y19zdGF0ZS0+aW5mb2ZyYW1lcy5kcm0uZHJt KTsKKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJTUlTU0lOR19DQVNFKHR5cGUpOworCQlicmVhazsK Kwl9Cit9CisKIHN0YXRpYyB2b2lkCiBpbnRlbF9kcF9zZXR1cF92c2Nfc2RwKHN0cnVjdCBpbnRl bF9kcCAqaW50ZWxfZHAsCiAJCSAgICAgICBjb25zdCBzdHJ1Y3QgaW50ZWxfY3J0Y19zdGF0ZSAq Y3J0Y19zdGF0ZSwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2Rpc3BsYXkvaW50 ZWxfZHAuaCBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2Rpc3BsYXkvaW50ZWxfZHAuaAppbmRleCAw ZGMwOWE0NjNlZTEuLmU4ZjliYTk2MmQwOSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5 MTUvZGlzcGxheS9pbnRlbF9kcC5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2Rpc3BsYXkv aW50ZWxfZHAuaApAQCAtMTE5LDYgKzExOSw5IEBAIHZvaWQgaW50ZWxfZHBfaGRyX21ldGFkYXRh X2VuYWJsZShzdHJ1Y3QgaW50ZWxfZHAgKmludGVsX2RwLAogdm9pZCBpbnRlbF9kcF9zZXRfaW5m b2ZyYW1lcyhzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2RlciwgYm9vbCBlbmFibGUsCiAJCQkg ICAgIGNvbnN0IHN0cnVjdCBpbnRlbF9jcnRjX3N0YXRlICpjcnRjX3N0YXRlLAogCQkJICAgICBj b25zdCBzdHJ1Y3QgZHJtX2Nvbm5lY3Rvcl9zdGF0ZSAqY29ubl9zdGF0ZSk7Cit2b2lkIGludGVs X3JlYWRfZHBfc2RwKHN0cnVjdCBpbnRlbF9lbmNvZGVyICplbmNvZGVyLAorCQkgICAgICAgc3Ry dWN0IGludGVsX2NydGNfc3RhdGUgKmNydGNfc3RhdGUsCisJCSAgICAgICB1bnNpZ25lZCBpbnQg dHlwZSk7CiBib29sIGludGVsX2RpZ2l0YWxfcG9ydF9jb25uZWN0ZWQoc3RydWN0IGludGVsX2Vu Y29kZXIgKmVuY29kZXIpOwogCiBzdGF0aWMgaW5saW5lIHVuc2lnbmVkIGludCBpbnRlbF9kcF91 bnVzZWRfbGFuZV9tYXNrKGludCBsYW5lX2NvdW50KQotLSAKMi4yNC4xCgpfX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpJbnRlbC1nZnggbWFpbGluZyBsaXN0 CkludGVsLWdmeEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3Rv cC5vcmcvbWFpbG1hbi9saXN0aW5mby9pbnRlbC1nZngK