From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S932570AbeCLVBL (ORCPT ); Mon, 12 Mar 2018 17:01:11 -0400 Received: from mga06.intel.com ([134.134.136.31]:45092 "EHLO mga06.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S932405AbeCLVBI (ORCPT ); Mon, 12 Mar 2018 17:01:08 -0400 X-Amp-Result: UNSCANNABLE X-Amp-File-Uploaded: False X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.47,463,1515484800"; d="scan'208";a="24028310" Date: Mon, 12 Mar 2018 23:01:02 +0200 From: Ville =?iso-8859-1?Q?Syrj=E4l=E4?= To: Lyude Paul Cc: intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org, Manasi Navare , Jani Nikula , Joonas Lahtinen , Rodrigo Vivi , David Airlie , linux-kernel@vger.kernel.org Subject: Re: [PATCH v3 1/5] drm/i915: Move DP modeset retry work into intel_dp Message-ID: <20180312210102.GR5453@intel.com> References: <20180308232421.14049-1-lyude@redhat.com> <20180309213232.19855-1-lyude@redhat.com> MIME-Version: 1.0 Content-Type: text/plain; charset=iso-8859-1 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <20180309213232.19855-1-lyude@redhat.com> User-Agent: Mutt/1.7.2 (2016-11-26) Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Fri, Mar 09, 2018 at 04:32:27PM -0500, Lyude Paul wrote: > While having the modeset_retry_work in intel_connector makes sense with > SST, this paradigm doesn't make a whole ton of sense when it comes to > MST since we have to deal with multiple connectors. In most cases, it's > more useful to just use the intel_dp struct since it indicates whether > or not we're dealing with an MST device, along with being able to easily > trace the intel_dp struct back to it's respective connector (if there is > any). So, move the modeset_retry_work function out of the > intel_connector struct and into intel_dp. > > Signed-off-by: Lyude Paul > Reviewed-by: Manasi Navare > Cc: Manasi Navare > Cc: Ville Syrjälä > > V2: > - Remove accidental duplicate modeset_retry_work in intel_connector > V3: > - Also check against eDP in intel_hpd_poll_fini() - mdnavare > Signed-off-by: Lyude Paul > --- > drivers/gpu/drm/i915/intel_display.c | 25 +++++++++++++++++++++++-- > drivers/gpu/drm/i915/intel_dp.c | 10 ++++------ > drivers/gpu/drm/i915/intel_dp_link_training.c | 2 +- > drivers/gpu/drm/i915/intel_drv.h | 6 +++--- > 4 files changed, 31 insertions(+), 12 deletions(-) > > diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c > index f424fff477f6..3b7fa430a84a 100644 > --- a/drivers/gpu/drm/i915/intel_display.c > +++ b/drivers/gpu/drm/i915/intel_display.c > @@ -15394,16 +15394,37 @@ static void intel_hpd_poll_fini(struct drm_device *dev) > { > struct intel_connector *connector; > struct drm_connector_list_iter conn_iter; > + struct work_struct *work; > + int conn_type; > > /* Kill all the work that may have been queued by hpd. */ > drm_connector_list_iter_begin(dev, &conn_iter); > for_each_intel_connector_iter(connector, &conn_iter) { > - if (connector->modeset_retry_work.func) > - cancel_work_sync(&connector->modeset_retry_work); > if (connector->hdcp_shim) { > cancel_delayed_work_sync(&connector->hdcp_check_work); > cancel_work_sync(&connector->hdcp_prop_work); > } > + > + conn_type = connector->base.connector_type; > + if (conn_type != DRM_MODE_CONNECTOR_eDP && > + conn_type != DRM_MODE_CONNECTOR_DisplayPort) > + continue; > + > + if (connector->mst_port) { > + work = &connector->mst_port->modeset_retry_work; > + } else { > + struct intel_encoder *intel_encoder = > + connector->encoder; > + struct intel_dp *intel_dp; > + > + if (!intel_encoder) > + continue; > + > + intel_dp = enc_to_intel_dp(&intel_encoder->base); > + work = &intel_dp->modeset_retry_work; > + } > + > + cancel_work_sync(work); Why are we even walking the connectors for this? Can't we just walk the encoders instead? > } > drm_connector_list_iter_end(&conn_iter); > } > diff --git a/drivers/gpu/drm/i915/intel_dp.c b/drivers/gpu/drm/i915/intel_dp.c > index 4dd1b2287dd6..5abf0c95725a 100644 > --- a/drivers/gpu/drm/i915/intel_dp.c > +++ b/drivers/gpu/drm/i915/intel_dp.c > @@ -6261,12 +6261,10 @@ static bool intel_edp_init_connector(struct intel_dp *intel_dp, > > static void intel_dp_modeset_retry_work_fn(struct work_struct *work) > { > - struct intel_connector *intel_connector; > - struct drm_connector *connector; > + struct intel_dp *intel_dp = container_of(work, typeof(*intel_dp), > + modeset_retry_work); > + struct drm_connector *connector = &intel_dp->attached_connector->base; > > - intel_connector = container_of(work, typeof(*intel_connector), > - modeset_retry_work); > - connector = &intel_connector->base; > DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n", connector->base.id, > connector->name); > > @@ -6295,7 +6293,7 @@ intel_dp_init_connector(struct intel_digital_port *intel_dig_port, > int type; > > /* Initialize the work for modeset in case of link train failure */ > - INIT_WORK(&intel_connector->modeset_retry_work, > + INIT_WORK(&intel_dp->modeset_retry_work, > intel_dp_modeset_retry_work_fn); > > if (WARN(intel_dig_port->max_lanes < 1, > diff --git a/drivers/gpu/drm/i915/intel_dp_link_training.c b/drivers/gpu/drm/i915/intel_dp_link_training.c > index f59b59bb0a21..2cfa58ce1f95 100644 > --- a/drivers/gpu/drm/i915/intel_dp_link_training.c > +++ b/drivers/gpu/drm/i915/intel_dp_link_training.c > @@ -340,7 +340,7 @@ intel_dp_start_link_train(struct intel_dp *intel_dp) > intel_dp->link_rate, > intel_dp->lane_count)) > /* Schedule a Hotplug Uevent to userspace to start modeset */ > - schedule_work(&intel_connector->modeset_retry_work); > + schedule_work(&intel_dp->modeset_retry_work); > } else { > DRM_ERROR("[CONNECTOR:%d:%s] Link Training failed at link rate = %d, lane count = %d", > intel_connector->base.base.id, > diff --git a/drivers/gpu/drm/i915/intel_drv.h b/drivers/gpu/drm/i915/intel_drv.h > index 83e5ca889d9c..3f19dc80997f 100644 > --- a/drivers/gpu/drm/i915/intel_drv.h > +++ b/drivers/gpu/drm/i915/intel_drv.h > @@ -406,9 +406,6 @@ struct intel_connector { > > struct intel_dp *mst_port; > > - /* Work struct to schedule a uevent on link train failure */ > - struct work_struct modeset_retry_work; > - > const struct intel_hdcp_shim *hdcp_shim; > struct mutex hdcp_mutex; > uint64_t hdcp_value; /* protected by hdcp_mutex */ > @@ -1135,6 +1132,9 @@ struct intel_dp { > > /* Displayport compliance testing */ > struct intel_dp_compliance compliance; > + > + /* Work struct to schedule a uevent on link train failure */ > + struct work_struct modeset_retry_work; > }; > > struct intel_lspcon { > -- > 2.14.3 -- Ville Syrjälä Intel OTC From mboxrd@z Thu Jan 1 00:00:00 1970 From: Ville =?iso-8859-1?Q?Syrj=E4l=E4?= Subject: Re: [PATCH v3 1/5] drm/i915: Move DP modeset retry work into intel_dp Date: Mon, 12 Mar 2018 23:01:02 +0200 Message-ID: <20180312210102.GR5453@intel.com> References: <20180308232421.14049-1-lyude@redhat.com> <20180309213232.19855-1-lyude@redhat.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Content-Disposition: inline In-Reply-To: <20180309213232.19855-1-lyude@redhat.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Lyude Paul Cc: David Airlie , intel-gfx@lists.freedesktop.org, linux-kernel@vger.kernel.org, Manasi Navare , dri-devel@lists.freedesktop.org, Rodrigo Vivi List-Id: dri-devel@lists.freedesktop.org T24gRnJpLCBNYXIgMDksIDIwMTggYXQgMDQ6MzI6MjdQTSAtMDUwMCwgTHl1ZGUgUGF1bCB3cm90 ZToKPiBXaGlsZSBoYXZpbmcgdGhlIG1vZGVzZXRfcmV0cnlfd29yayBpbiBpbnRlbF9jb25uZWN0 b3IgbWFrZXMgc2Vuc2Ugd2l0aAo+IFNTVCwgdGhpcyBwYXJhZGlnbSBkb2Vzbid0IG1ha2UgYSB3 aG9sZSB0b24gb2Ygc2Vuc2Ugd2hlbiBpdCBjb21lcyB0bwo+IE1TVCBzaW5jZSB3ZSBoYXZlIHRv IGRlYWwgd2l0aCBtdWx0aXBsZSBjb25uZWN0b3JzLiBJbiBtb3N0IGNhc2VzLCBpdCdzCj4gbW9y ZSB1c2VmdWwgdG8ganVzdCB1c2UgdGhlIGludGVsX2RwIHN0cnVjdCBzaW5jZSBpdCBpbmRpY2F0 ZXMgd2hldGhlcgo+IG9yIG5vdCB3ZSdyZSBkZWFsaW5nIHdpdGggYW4gTVNUIGRldmljZSwgYWxv bmcgd2l0aCBiZWluZyBhYmxlIHRvIGVhc2lseQo+IHRyYWNlIHRoZSBpbnRlbF9kcCBzdHJ1Y3Qg YmFjayB0byBpdCdzIHJlc3BlY3RpdmUgY29ubmVjdG9yIChpZiB0aGVyZSBpcwo+IGFueSkuIFNv LCBtb3ZlIHRoZSBtb2Rlc2V0X3JldHJ5X3dvcmsgZnVuY3Rpb24gb3V0IG9mIHRoZQo+IGludGVs X2Nvbm5lY3RvciBzdHJ1Y3QgYW5kIGludG8gaW50ZWxfZHAuCj4gCj4gU2lnbmVkLW9mZi1ieTog THl1ZGUgUGF1bCA8bHl1ZGVAcmVkaGF0LmNvbT4KPiBSZXZpZXdlZC1ieTogTWFuYXNpIE5hdmFy ZSA8bWFuYXNpLmQubmF2YXJlQGludGVsLmNvbT4KPiBDYzogTWFuYXNpIE5hdmFyZSA8bWFuYXNp LmQubmF2YXJlQGludGVsLmNvbT4KPiBDYzogVmlsbGUgU3lyasOkbMOkIDx2aWxsZS5zeXJqYWxh QGxpbnV4LmludGVsLmNvbT4KPiAKPiBWMjoKPiAgLSBSZW1vdmUgYWNjaWRlbnRhbCBkdXBsaWNh dGUgbW9kZXNldF9yZXRyeV93b3JrIGluIGludGVsX2Nvbm5lY3Rvcgo+IFYzOgo+ICAtIEFsc28g Y2hlY2sgYWdhaW5zdCBlRFAgaW4gaW50ZWxfaHBkX3BvbGxfZmluaSgpIC0gbWRuYXZhcmUKPiBT aWduZWQtb2ZmLWJ5OiBMeXVkZSBQYXVsIDxseXVkZUByZWRoYXQuY29tPgo+IC0tLQo+ICBkcml2 ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kaXNwbGF5LmMgICAgICAgICAgfCAyNSArKysrKysrKysr KysrKysrKysrKysrKy0tCj4gIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2RwLmMgICAgICAg ICAgICAgICB8IDEwICsrKystLS0tLS0KPiAgZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHBf bGlua190cmFpbmluZy5jIHwgIDIgKy0KPiAgZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHJ2 LmggICAgICAgICAgICAgIHwgIDYgKysrLS0tCj4gIDQgZmlsZXMgY2hhbmdlZCwgMzEgaW5zZXJ0 aW9ucygrKSwgMTIgZGVsZXRpb25zKC0pCj4gCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2Ry bS9pOTE1L2ludGVsX2Rpc3BsYXkuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rpc3Bs YXkuYwo+IGluZGV4IGY0MjRmZmY0NzdmNi4uM2I3ZmE0MzBhODRhIDEwMDY0NAo+IC0tLSBhL2Ry aXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rpc3BsYXkuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2Ry bS9pOTE1L2ludGVsX2Rpc3BsYXkuYwo+IEBAIC0xNTM5NCwxNiArMTUzOTQsMzcgQEAgc3RhdGlj IHZvaWQgaW50ZWxfaHBkX3BvbGxfZmluaShzdHJ1Y3QgZHJtX2RldmljZSAqZGV2KQo+ICB7Cj4g IAlzdHJ1Y3QgaW50ZWxfY29ubmVjdG9yICpjb25uZWN0b3I7Cj4gIAlzdHJ1Y3QgZHJtX2Nvbm5l Y3Rvcl9saXN0X2l0ZXIgY29ubl9pdGVyOwo+ICsJc3RydWN0IHdvcmtfc3RydWN0ICp3b3JrOwo+ ICsJaW50IGNvbm5fdHlwZTsKPiAgCj4gIAkvKiBLaWxsIGFsbCB0aGUgd29yayB0aGF0IG1heSBo YXZlIGJlZW4gcXVldWVkIGJ5IGhwZC4gKi8KPiAgCWRybV9jb25uZWN0b3JfbGlzdF9pdGVyX2Jl Z2luKGRldiwgJmNvbm5faXRlcik7Cj4gIAlmb3JfZWFjaF9pbnRlbF9jb25uZWN0b3JfaXRlcihj b25uZWN0b3IsICZjb25uX2l0ZXIpIHsKPiAtCQlpZiAoY29ubmVjdG9yLT5tb2Rlc2V0X3JldHJ5 X3dvcmsuZnVuYykKPiAtCQkJY2FuY2VsX3dvcmtfc3luYygmY29ubmVjdG9yLT5tb2Rlc2V0X3Jl dHJ5X3dvcmspOwo+ICAJCWlmIChjb25uZWN0b3ItPmhkY3Bfc2hpbSkgewo+ICAJCQljYW5jZWxf ZGVsYXllZF93b3JrX3N5bmMoJmNvbm5lY3Rvci0+aGRjcF9jaGVja193b3JrKTsKPiAgCQkJY2Fu Y2VsX3dvcmtfc3luYygmY29ubmVjdG9yLT5oZGNwX3Byb3Bfd29yayk7Cj4gIAkJfQo+ICsKPiAr CQljb25uX3R5cGUgPSBjb25uZWN0b3ItPmJhc2UuY29ubmVjdG9yX3R5cGU7Cj4gKwkJaWYgKGNv bm5fdHlwZSAhPSBEUk1fTU9ERV9DT05ORUNUT1JfZURQICYmCj4gKwkJICAgIGNvbm5fdHlwZSAh PSBEUk1fTU9ERV9DT05ORUNUT1JfRGlzcGxheVBvcnQpCj4gKwkJCWNvbnRpbnVlOwo+ICsKPiAr CQlpZiAoY29ubmVjdG9yLT5tc3RfcG9ydCkgewo+ICsJCQl3b3JrID0gJmNvbm5lY3Rvci0+bXN0 X3BvcnQtPm1vZGVzZXRfcmV0cnlfd29yazsKPiArCQl9IGVsc2Ugewo+ICsJCQlzdHJ1Y3QgaW50 ZWxfZW5jb2RlciAqaW50ZWxfZW5jb2RlciA9Cj4gKwkJCQljb25uZWN0b3ItPmVuY29kZXI7Cj4g KwkJCXN0cnVjdCBpbnRlbF9kcCAqaW50ZWxfZHA7Cj4gKwo+ICsJCQlpZiAoIWludGVsX2VuY29k ZXIpCj4gKwkJCQljb250aW51ZTsKPiArCj4gKwkJCWludGVsX2RwID0gZW5jX3RvX2ludGVsX2Rw KCZpbnRlbF9lbmNvZGVyLT5iYXNlKTsKPiArCQkJd29yayA9ICZpbnRlbF9kcC0+bW9kZXNldF9y ZXRyeV93b3JrOwo+ICsJCX0KPiArCj4gKwkJY2FuY2VsX3dvcmtfc3luYyh3b3JrKTsKCldoeSBh cmUgd2UgZXZlbiB3YWxraW5nIHRoZSBjb25uZWN0b3JzIGZvciB0aGlzPyBDYW4ndCB3ZSBqdXN0 CndhbGsgdGhlIGVuY29kZXJzIGluc3RlYWQ/Cgo+ICAJfQo+ICAJZHJtX2Nvbm5lY3Rvcl9saXN0 X2l0ZXJfZW5kKCZjb25uX2l0ZXIpOwo+ICB9Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2Ry bS9pOTE1L2ludGVsX2RwLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kcC5jCj4gaW5k ZXggNGRkMWIyMjg3ZGQ2Li41YWJmMGM5NTcyNWEgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUv ZHJtL2k5MTUvaW50ZWxfZHAuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rw LmMKPiBAQCAtNjI2MSwxMiArNjI2MSwxMCBAQCBzdGF0aWMgYm9vbCBpbnRlbF9lZHBfaW5pdF9j b25uZWN0b3Ioc3RydWN0IGludGVsX2RwICppbnRlbF9kcCwKPiAgCj4gIHN0YXRpYyB2b2lkIGlu dGVsX2RwX21vZGVzZXRfcmV0cnlfd29ya19mbihzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspCj4g IHsKPiAtCXN0cnVjdCBpbnRlbF9jb25uZWN0b3IgKmludGVsX2Nvbm5lY3RvcjsKPiAtCXN0cnVj dCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3I7Cj4gKwlzdHJ1Y3QgaW50ZWxfZHAgKmludGVsX2Rw ID0gY29udGFpbmVyX29mKHdvcmssIHR5cGVvZigqaW50ZWxfZHApLAo+ICsJCQkJCQkgbW9kZXNl dF9yZXRyeV93b3JrKTsKPiArCXN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3IgPSAmaW50 ZWxfZHAtPmF0dGFjaGVkX2Nvbm5lY3Rvci0+YmFzZTsKPiAgCj4gLQlpbnRlbF9jb25uZWN0b3Ig PSBjb250YWluZXJfb2Yod29yaywgdHlwZW9mKCppbnRlbF9jb25uZWN0b3IpLAo+IC0JCQkJICAg ICAgIG1vZGVzZXRfcmV0cnlfd29yayk7Cj4gLQljb25uZWN0b3IgPSAmaW50ZWxfY29ubmVjdG9y LT5iYXNlOwo+ICAJRFJNX0RFQlVHX0tNUygiW0NPTk5FQ1RPUjolZDolc11cbiIsIGNvbm5lY3Rv ci0+YmFzZS5pZCwKPiAgCQkgICAgICBjb25uZWN0b3ItPm5hbWUpOwo+ICAKPiBAQCAtNjI5NSw3 ICs2MjkzLDcgQEAgaW50ZWxfZHBfaW5pdF9jb25uZWN0b3Ioc3RydWN0IGludGVsX2RpZ2l0YWxf cG9ydCAqaW50ZWxfZGlnX3BvcnQsCj4gIAlpbnQgdHlwZTsKPiAgCj4gIAkvKiBJbml0aWFsaXpl IHRoZSB3b3JrIGZvciBtb2Rlc2V0IGluIGNhc2Ugb2YgbGluayB0cmFpbiBmYWlsdXJlICovCj4g LQlJTklUX1dPUksoJmludGVsX2Nvbm5lY3Rvci0+bW9kZXNldF9yZXRyeV93b3JrLAo+ICsJSU5J VF9XT1JLKCZpbnRlbF9kcC0+bW9kZXNldF9yZXRyeV93b3JrLAo+ICAJCSAgaW50ZWxfZHBfbW9k ZXNldF9yZXRyeV93b3JrX2ZuKTsKPiAgCj4gIAlpZiAoV0FSTihpbnRlbF9kaWdfcG9ydC0+bWF4 X2xhbmVzIDwgMSwKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHBf bGlua190cmFpbmluZy5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHBfbGlua190cmFp bmluZy5jCj4gaW5kZXggZjU5YjU5YmIwYTIxLi4yY2ZhNThjZTFmOTUgMTAwNjQ0Cj4gLS0tIGEv ZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHBfbGlua190cmFpbmluZy5jCj4gKysrIGIvZHJp dmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHBfbGlua190cmFpbmluZy5jCj4gQEAgLTM0MCw3ICsz NDAsNyBAQCBpbnRlbF9kcF9zdGFydF9saW5rX3RyYWluKHN0cnVjdCBpbnRlbF9kcCAqaW50ZWxf ZHApCj4gIAkJCQkJCQkgICAgIGludGVsX2RwLT5saW5rX3JhdGUsCj4gIAkJCQkJCQkgICAgIGlu dGVsX2RwLT5sYW5lX2NvdW50KSkKPiAgCQkJLyogU2NoZWR1bGUgYSBIb3RwbHVnIFVldmVudCB0 byB1c2Vyc3BhY2UgdG8gc3RhcnQgbW9kZXNldCAqLwo+IC0JCQlzY2hlZHVsZV93b3JrKCZpbnRl bF9jb25uZWN0b3ItPm1vZGVzZXRfcmV0cnlfd29yayk7Cj4gKwkJCXNjaGVkdWxlX3dvcmsoJmlu dGVsX2RwLT5tb2Rlc2V0X3JldHJ5X3dvcmspOwo+ICAJfSBlbHNlIHsKPiAgCQlEUk1fRVJST1Io IltDT05ORUNUT1I6JWQ6JXNdIExpbmsgVHJhaW5pbmcgZmFpbGVkIGF0IGxpbmsgcmF0ZSA9ICVk LCBsYW5lIGNvdW50ID0gJWQiLAo+ICAJCQkgIGludGVsX2Nvbm5lY3Rvci0+YmFzZS5iYXNlLmlk LAo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kcnYuaCBiL2RyaXZl cnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rydi5oCj4gaW5kZXggODNlNWNhODg5ZDljLi4zZjE5ZGM4 MDk5N2YgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHJ2LmgKPiAr KysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kcnYuaAo+IEBAIC00MDYsOSArNDA2LDYg QEAgc3RydWN0IGludGVsX2Nvbm5lY3RvciB7Cj4gIAo+ICAJc3RydWN0IGludGVsX2RwICptc3Rf cG9ydDsKPiAgCj4gLQkvKiBXb3JrIHN0cnVjdCB0byBzY2hlZHVsZSBhIHVldmVudCBvbiBsaW5r IHRyYWluIGZhaWx1cmUgKi8KPiAtCXN0cnVjdCB3b3JrX3N0cnVjdCBtb2Rlc2V0X3JldHJ5X3dv cms7Cj4gLQo+ICAJY29uc3Qgc3RydWN0IGludGVsX2hkY3Bfc2hpbSAqaGRjcF9zaGltOwo+ICAJ c3RydWN0IG11dGV4IGhkY3BfbXV0ZXg7Cj4gIAl1aW50NjRfdCBoZGNwX3ZhbHVlOyAvKiBwcm90 ZWN0ZWQgYnkgaGRjcF9tdXRleCAqLwo+IEBAIC0xMTM1LDYgKzExMzIsOSBAQCBzdHJ1Y3QgaW50 ZWxfZHAgewo+ICAKPiAgCS8qIERpc3BsYXlwb3J0IGNvbXBsaWFuY2UgdGVzdGluZyAqLwo+ICAJ c3RydWN0IGludGVsX2RwX2NvbXBsaWFuY2UgY29tcGxpYW5jZTsKPiArCj4gKwkvKiBXb3JrIHN0 cnVjdCB0byBzY2hlZHVsZSBhIHVldmVudCBvbiBsaW5rIHRyYWluIGZhaWx1cmUgKi8KPiArCXN0 cnVjdCB3b3JrX3N0cnVjdCBtb2Rlc2V0X3JldHJ5X3dvcms7Cj4gIH07Cj4gIAo+ICBzdHJ1Y3Qg aW50ZWxfbHNwY29uIHsKPiAtLSAKPiAyLjE0LjMKCi0tIApWaWxsZSBTeXJqw6Rsw6QKSW50ZWwg T1RDCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmRyaS1k ZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczov L2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZlbAo=