From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S932418AbeCLUm0 (ORCPT ); Mon, 12 Mar 2018 16:42:26 -0400 Received: from mga18.intel.com ([134.134.136.126]:41821 "EHLO mga18.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S932171AbeCLUmY (ORCPT ); Mon, 12 Mar 2018 16:42:24 -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="36709274" Date: Mon, 12 Mar 2018 13:45:27 -0700 From: Manasi Navare To: Lyude Paul Cc: intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org, Ville =?iso-8859-1?Q?Syrj=E4l=E4?= , Jani Nikula , Joonas Lahtinen , Rodrigo Vivi , David Airlie , linux-kernel@vger.kernel.org Subject: Re: [PATCH v3 2/5] drm/i915: Only use one link bw config for MST topologies Message-ID: <20180312204526.GA3022@intel.com> References: <20180308232421.14049-1-lyude@redhat.com> <20180309213232.19855-1-lyude@redhat.com> <20180309213232.19855-2-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-2-lyude@redhat.com> User-Agent: Mutt/1.5.24 (2015-08-30) 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:28PM -0500, Lyude Paul wrote: > When a DP MST link needs retraining, sometimes the hub will detect that > the current link bw config is impossible and will update it's RX caps in > the DPCD to reflect the new maximum link rate. Currently, we make the > assumption that the RX caps in the dpcd will never change like this. > This means if the sink changes it's RX caps after we've already set up > an MST link and we attempt to add or remove another sink from the > topology, we could put ourselves into an invalid state where we've tried > to configure different sinks on the same MST topology with different > link rates. We could also run into this situation if a sink reports a > higher link rate after suspend, usually from us having trained it with a > fallback bw configuration before suspending. > > So: "lock" the bw config by only using the max DP link rate/lane count > on the first modeset for an MST topology. For every modeset following, > we instead use the last configured link bw for this topology. We only > unlock the bw config when we've detected a new MST sink. > Just a nit here on commit message about where we unlock the link bw. So we also unlock it meaning set the mst_link_bw_locked to false when we read the dpcd again and obtain the fallback values since at that time the RX cap could have changed and so we do unlock the link_bw so that during retraining it reads the new max link rate and lane count during the mst compute config. Isnt that the case or am I missing something here? Manasi > Signed-off-by: Lyude Paul > Cc: Manasi Navare > Cc: Ville Syrjälä > --- > drivers/gpu/drm/i915/intel_dp.c | 11 +++++++++-- > drivers/gpu/drm/i915/intel_dp_mst.c | 22 +++++++++++++++------- > drivers/gpu/drm/i915/intel_drv.h | 6 ++++++ > 3 files changed, 30 insertions(+), 9 deletions(-) > > diff --git a/drivers/gpu/drm/i915/intel_dp.c b/drivers/gpu/drm/i915/intel_dp.c > index 5abf0c95725a..5645a194de92 100644 > --- a/drivers/gpu/drm/i915/intel_dp.c > +++ b/drivers/gpu/drm/i915/intel_dp.c > @@ -3871,18 +3871,25 @@ intel_dp_can_mst(struct intel_dp *intel_dp) > static void > intel_dp_configure_mst(struct intel_dp *intel_dp) > { > + bool was_mst; > + > if (!i915_modparams.enable_dp_mst) > return; > > if (!intel_dp->can_mst) > return; > > + was_mst = intel_dp->is_mst; > intel_dp->is_mst = intel_dp_can_mst(intel_dp); > > - if (intel_dp->is_mst) > + if (intel_dp->is_mst) { > DRM_DEBUG_KMS("Sink is MST capable\n"); > - else > + > + if (!was_mst) > + intel_dp->mst_bw_locked = false; > + } else { > DRM_DEBUG_KMS("Sink is not MST capable\n"); > + } > > drm_dp_mst_topology_mgr_set_mst(&intel_dp->mst_mgr, > intel_dp->is_mst); > diff --git a/drivers/gpu/drm/i915/intel_dp_mst.c b/drivers/gpu/drm/i915/intel_dp_mst.c > index c3de0918ee13..c0553456b18e 100644 > --- a/drivers/gpu/drm/i915/intel_dp_mst.c > +++ b/drivers/gpu/drm/i915/intel_dp_mst.c > @@ -42,7 +42,7 @@ static bool intel_dp_mst_compute_config(struct intel_encoder *encoder, > to_intel_connector(conn_state->connector); > struct drm_atomic_state *state = pipe_config->base.state; > int bpp; > - int lane_count, slots; > + int lane_count, link_rate, slots; > const struct drm_display_mode *adjusted_mode = &pipe_config->base.adjusted_mode; > int mst_pbn; > bool reduce_m_n = drm_dp_has_quirk(&intel_dp->desc, > @@ -56,16 +56,22 @@ static bool intel_dp_mst_compute_config(struct intel_encoder *encoder, > bpp); > } > /* > - * for MST we always configure max link bw - the spec doesn't > - * seem to suggest we should do otherwise. > + * for MST we always configure max link bw if we don't know better - > + * the spec doesn't seem to suggest we should do otherwise. But, > + * ensure it always stays consistent with the rest of this hub's > + * state. > */ > - lane_count = intel_dp_max_lane_count(intel_dp); > + if (intel_dp->mst_bw_locked) { > + lane_count = intel_dp->lane_count; > + link_rate = intel_dp->link_rate; > + } else { > + lane_count = intel_dp_max_lane_count(intel_dp); > + link_rate = intel_dp_max_link_rate(intel_dp); > + } > > pipe_config->lane_count = lane_count; > - > pipe_config->pipe_bpp = bpp; > - > - pipe_config->port_clock = intel_dp_max_link_rate(intel_dp); > + pipe_config->port_clock = link_rate; > > if (drm_dp_mst_port_has_audio(&intel_dp->mst_mgr, connector->port)) > pipe_config->has_audio = true; > @@ -221,6 +227,8 @@ static void intel_mst_pre_enable_dp(struct intel_encoder *encoder, > connector->encoder = encoder; > intel_mst->connector = connector; > > + intel_dp->mst_bw_locked = true; > + > DRM_DEBUG_KMS("active links %d\n", intel_dp->active_mst_links); > > drm_dp_send_power_updown_phy(&intel_dp->mst_mgr, connector->port, true); > diff --git a/drivers/gpu/drm/i915/intel_drv.h b/drivers/gpu/drm/i915/intel_drv.h > index 3f19dc80997f..fc338529e918 100644 > --- a/drivers/gpu/drm/i915/intel_drv.h > +++ b/drivers/gpu/drm/i915/intel_drv.h > @@ -1107,6 +1107,12 @@ struct intel_dp { > bool can_mst; /* this port supports mst */ > bool is_mst; > int active_mst_links; > + /* Set when we've already decided on a link bw for mst, to prevent us > + * from setting different link bandwiths if the hub tries to confuse > + * us by changing it later > + */ > + bool mst_bw_locked; > + > /* connector directly attached - won't be use for modeset in mst world */ > struct intel_connector *attached_connector; > > -- > 2.14.3 > From mboxrd@z Thu Jan 1 00:00:00 1970 From: Manasi Navare Subject: Re: [PATCH v3 2/5] drm/i915: Only use one link bw config for MST topologies Date: Mon, 12 Mar 2018 13:45:27 -0700 Message-ID: <20180312204526.GA3022@intel.com> References: <20180308232421.14049-1-lyude@redhat.com> <20180309213232.19855-1-lyude@redhat.com> <20180309213232.19855-2-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-2-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, dri-devel@lists.freedesktop.org, Rodrigo Vivi List-Id: dri-devel@lists.freedesktop.org T24gRnJpLCBNYXIgMDksIDIwMTggYXQgMDQ6MzI6MjhQTSAtMDUwMCwgTHl1ZGUgUGF1bCB3cm90 ZToKPiBXaGVuIGEgRFAgTVNUIGxpbmsgbmVlZHMgcmV0cmFpbmluZywgc29tZXRpbWVzIHRoZSBo dWIgd2lsbCBkZXRlY3QgdGhhdAo+IHRoZSBjdXJyZW50IGxpbmsgYncgY29uZmlnIGlzIGltcG9z c2libGUgYW5kIHdpbGwgdXBkYXRlIGl0J3MgUlggY2FwcyBpbgo+IHRoZSBEUENEIHRvIHJlZmxl Y3QgdGhlIG5ldyBtYXhpbXVtIGxpbmsgcmF0ZS4gQ3VycmVudGx5LCB3ZSBtYWtlIHRoZQo+IGFz c3VtcHRpb24gdGhhdCB0aGUgUlggY2FwcyBpbiB0aGUgZHBjZCB3aWxsIG5ldmVyIGNoYW5nZSBs aWtlIHRoaXMuCj4gVGhpcyBtZWFucyBpZiB0aGUgc2luayBjaGFuZ2VzIGl0J3MgUlggY2FwcyBh ZnRlciB3ZSd2ZSBhbHJlYWR5IHNldCB1cAo+IGFuIE1TVCBsaW5rIGFuZCB3ZSBhdHRlbXB0IHRv IGFkZCBvciByZW1vdmUgYW5vdGhlciBzaW5rIGZyb20gdGhlCj4gdG9wb2xvZ3ksIHdlIGNvdWxk IHB1dCBvdXJzZWx2ZXMgaW50byBhbiBpbnZhbGlkIHN0YXRlIHdoZXJlIHdlJ3ZlIHRyaWVkCj4g dG8gY29uZmlndXJlIGRpZmZlcmVudCBzaW5rcyBvbiB0aGUgc2FtZSBNU1QgdG9wb2xvZ3kgd2l0 aCBkaWZmZXJlbnQKPiBsaW5rIHJhdGVzLiBXZSBjb3VsZCBhbHNvIHJ1biBpbnRvIHRoaXMgc2l0 dWF0aW9uIGlmIGEgc2luayByZXBvcnRzIGEKPiBoaWdoZXIgbGluayByYXRlIGFmdGVyIHN1c3Bl bmQsIHVzdWFsbHkgZnJvbSB1cyBoYXZpbmcgdHJhaW5lZCBpdCB3aXRoIGEKPiBmYWxsYmFjayBi dyBjb25maWd1cmF0aW9uIGJlZm9yZSBzdXNwZW5kaW5nLgo+IAo+IFNvOiAibG9jayIgdGhlIGJ3 IGNvbmZpZyBieSBvbmx5IHVzaW5nIHRoZSBtYXggRFAgbGluayByYXRlL2xhbmUgY291bnQKPiBv biB0aGUgZmlyc3QgbW9kZXNldCBmb3IgYW4gTVNUIHRvcG9sb2d5LiBGb3IgZXZlcnkgbW9kZXNl dCBmb2xsb3dpbmcsCj4gd2UgaW5zdGVhZCB1c2UgdGhlIGxhc3QgY29uZmlndXJlZCBsaW5rIGJ3 IGZvciB0aGlzIHRvcG9sb2d5LiBXZSBvbmx5Cj4gdW5sb2NrIHRoZSBidyBjb25maWcgd2hlbiB3 ZSd2ZSBkZXRlY3RlZCBhIG5ldyBNU1Qgc2luay4KPgoKSnVzdCBhIG5pdCBoZXJlIG9uIGNvbW1p dCBtZXNzYWdlIGFib3V0IHdoZXJlIHdlIHVubG9jayB0aGUgbGluayBidy4gU28gd2UgYWxzbyB1 bmxvY2sgaXQKbWVhbmluZyBzZXQgdGhlIG1zdF9saW5rX2J3X2xvY2tlZCB0byBmYWxzZSB3aGVu IHdlIHJlYWQgdGhlIGRwY2QgYWdhaW4KYW5kIG9idGFpbiB0aGUgZmFsbGJhY2sgdmFsdWVzIHNp bmNlIGF0IHRoYXQgdGltZSB0aGUgUlggY2FwIGNvdWxkIGhhdmUKY2hhbmdlZCBhbmQgc28gd2Ug ZG8gdW5sb2NrIHRoZSBsaW5rX2J3IHNvIHRoYXQgZHVyaW5nIHJldHJhaW5pbmcgaXQgcmVhZHMK dGhlIG5ldyBtYXggbGluayByYXRlIGFuZCBsYW5lIGNvdW50IGR1cmluZyB0aGUgbXN0IGNvbXB1 dGUgY29uZmlnLgpJc250IHRoYXQgdGhlIGNhc2Ugb3IgYW0gSSBtaXNzaW5nIHNvbWV0aGluZyBo ZXJlPwoKTWFuYXNpCgo+IFNpZ25lZC1vZmYtYnk6IEx5dWRlIFBhdWwgPGx5dWRlQHJlZGhhdC5j b20+Cj4gQ2M6IE1hbmFzaSBOYXZhcmUgPG1hbmFzaS5kLm5hdmFyZUBpbnRlbC5jb20+Cj4gQ2M6 IFZpbGxlIFN5cmrDpGzDpCA8dmlsbGUuc3lyamFsYUBsaW51eC5pbnRlbC5jb20+Cj4gLS0tCj4g IGRyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2RwLmMgICAgIHwgMTEgKysrKysrKysrLS0KPiAg ZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHBfbXN0LmMgfCAyMiArKysrKysrKysrKysrKyst LS0tLS0tCj4gIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rydi5oICAgIHwgIDYgKysrKysr Cj4gIDMgZmlsZXMgY2hhbmdlZCwgMzAgaW5zZXJ0aW9ucygrKSwgOSBkZWxldGlvbnMoLSkKPiAK PiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHAuYyBiL2RyaXZlcnMv Z3B1L2RybS9pOTE1L2ludGVsX2RwLmMKPiBpbmRleCA1YWJmMGM5NTcyNWEuLjU2NDVhMTk0ZGU5 MiAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kcC5jCj4gKysrIGIv ZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHAuYwo+IEBAIC0zODcxLDE4ICszODcxLDI1IEBA IGludGVsX2RwX2Nhbl9tc3Qoc3RydWN0IGludGVsX2RwICppbnRlbF9kcCkKPiAgc3RhdGljIHZv aWQKPiAgaW50ZWxfZHBfY29uZmlndXJlX21zdChzdHJ1Y3QgaW50ZWxfZHAgKmludGVsX2RwKQo+ ICB7Cj4gKwlib29sIHdhc19tc3Q7Cj4gKwo+ICAJaWYgKCFpOTE1X21vZHBhcmFtcy5lbmFibGVf ZHBfbXN0KQo+ICAJCXJldHVybjsKPiAgCj4gIAlpZiAoIWludGVsX2RwLT5jYW5fbXN0KQo+ICAJ CXJldHVybjsKPiAgCj4gKwl3YXNfbXN0ID0gaW50ZWxfZHAtPmlzX21zdDsKPiAgCWludGVsX2Rw LT5pc19tc3QgPSBpbnRlbF9kcF9jYW5fbXN0KGludGVsX2RwKTsKPiAgCj4gLQlpZiAoaW50ZWxf ZHAtPmlzX21zdCkKPiArCWlmIChpbnRlbF9kcC0+aXNfbXN0KSB7Cj4gIAkJRFJNX0RFQlVHX0tN UygiU2luayBpcyBNU1QgY2FwYWJsZVxuIik7Cj4gLQllbHNlCj4gKwo+ICsJCWlmICghd2FzX21z dCkKPiArCQkJaW50ZWxfZHAtPm1zdF9id19sb2NrZWQgPSBmYWxzZTsKPiArCX0gZWxzZSB7Cj4g IAkJRFJNX0RFQlVHX0tNUygiU2luayBpcyBub3QgTVNUIGNhcGFibGVcbiIpOwo+ICsJfQo+ICAK PiAgCWRybV9kcF9tc3RfdG9wb2xvZ3lfbWdyX3NldF9tc3QoJmludGVsX2RwLT5tc3RfbWdyLAo+ ICAJCQkJCWludGVsX2RwLT5pc19tc3QpOwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0v aTkxNS9pbnRlbF9kcF9tc3QuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2RwX21zdC5j Cj4gaW5kZXggYzNkZTA5MThlZTEzLi5jMDU1MzQ1NmIxOGUgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVy cy9ncHUvZHJtL2k5MTUvaW50ZWxfZHBfbXN0LmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkx NS9pbnRlbF9kcF9tc3QuYwo+IEBAIC00Miw3ICs0Miw3IEBAIHN0YXRpYyBib29sIGludGVsX2Rw X21zdF9jb21wdXRlX2NvbmZpZyhzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2RlciwKPiAgCQl0 b19pbnRlbF9jb25uZWN0b3IoY29ubl9zdGF0ZS0+Y29ubmVjdG9yKTsKPiAgCXN0cnVjdCBkcm1f YXRvbWljX3N0YXRlICpzdGF0ZSA9IHBpcGVfY29uZmlnLT5iYXNlLnN0YXRlOwo+ICAJaW50IGJw cDsKPiAtCWludCBsYW5lX2NvdW50LCBzbG90czsKPiArCWludCBsYW5lX2NvdW50LCBsaW5rX3Jh dGUsIHNsb3RzOwo+ICAJY29uc3Qgc3RydWN0IGRybV9kaXNwbGF5X21vZGUgKmFkanVzdGVkX21v ZGUgPSAmcGlwZV9jb25maWctPmJhc2UuYWRqdXN0ZWRfbW9kZTsKPiAgCWludCBtc3RfcGJuOwo+ ICAJYm9vbCByZWR1Y2VfbV9uID0gZHJtX2RwX2hhc19xdWlyaygmaW50ZWxfZHAtPmRlc2MsCj4g QEAgLTU2LDE2ICs1NiwyMiBAQCBzdGF0aWMgYm9vbCBpbnRlbF9kcF9tc3RfY29tcHV0ZV9jb25m aWcoc3RydWN0IGludGVsX2VuY29kZXIgKmVuY29kZXIsCj4gIAkJCSAgICAgIGJwcCk7Cj4gIAl9 Cj4gIAkvKgo+IC0JICogZm9yIE1TVCB3ZSBhbHdheXMgY29uZmlndXJlIG1heCBsaW5rIGJ3IC0g dGhlIHNwZWMgZG9lc24ndAo+IC0JICogc2VlbSB0byBzdWdnZXN0IHdlIHNob3VsZCBkbyBvdGhl cndpc2UuCj4gKwkgKiBmb3IgTVNUIHdlIGFsd2F5cyBjb25maWd1cmUgbWF4IGxpbmsgYncgaWYg d2UgZG9uJ3Qga25vdyBiZXR0ZXIgLQo+ICsJICogdGhlIHNwZWMgZG9lc24ndCBzZWVtIHRvIHN1 Z2dlc3Qgd2Ugc2hvdWxkIGRvIG90aGVyd2lzZS4gQnV0LAo+ICsJICogZW5zdXJlIGl0IGFsd2F5 cyBzdGF5cyBjb25zaXN0ZW50IHdpdGggdGhlIHJlc3Qgb2YgdGhpcyBodWIncwo+ICsJICogc3Rh dGUuCj4gIAkgKi8KPiAtCWxhbmVfY291bnQgPSBpbnRlbF9kcF9tYXhfbGFuZV9jb3VudChpbnRl bF9kcCk7Cj4gKwlpZiAoaW50ZWxfZHAtPm1zdF9id19sb2NrZWQpIHsKPiArCQlsYW5lX2NvdW50 ID0gaW50ZWxfZHAtPmxhbmVfY291bnQ7Cj4gKwkJbGlua19yYXRlID0gaW50ZWxfZHAtPmxpbmtf cmF0ZTsKPiArCX0gZWxzZSB7Cj4gKwkJbGFuZV9jb3VudCA9IGludGVsX2RwX21heF9sYW5lX2Nv dW50KGludGVsX2RwKTsKPiArCQlsaW5rX3JhdGUgPSBpbnRlbF9kcF9tYXhfbGlua19yYXRlKGlu dGVsX2RwKTsKPiArCX0KPiAgCj4gIAlwaXBlX2NvbmZpZy0+bGFuZV9jb3VudCA9IGxhbmVfY291 bnQ7Cj4gLQo+ICAJcGlwZV9jb25maWctPnBpcGVfYnBwID0gYnBwOwo+IC0KPiAtCXBpcGVfY29u ZmlnLT5wb3J0X2Nsb2NrID0gaW50ZWxfZHBfbWF4X2xpbmtfcmF0ZShpbnRlbF9kcCk7Cj4gKwlw aXBlX2NvbmZpZy0+cG9ydF9jbG9jayA9IGxpbmtfcmF0ZTsKPiAgCj4gIAlpZiAoZHJtX2RwX21z dF9wb3J0X2hhc19hdWRpbygmaW50ZWxfZHAtPm1zdF9tZ3IsIGNvbm5lY3Rvci0+cG9ydCkpCj4g IAkJcGlwZV9jb25maWctPmhhc19hdWRpbyA9IHRydWU7Cj4gQEAgLTIyMSw2ICsyMjcsOCBAQCBz dGF0aWMgdm9pZCBpbnRlbF9tc3RfcHJlX2VuYWJsZV9kcChzdHJ1Y3QgaW50ZWxfZW5jb2RlciAq ZW5jb2RlciwKPiAgCWNvbm5lY3Rvci0+ZW5jb2RlciA9IGVuY29kZXI7Cj4gIAlpbnRlbF9tc3Qt PmNvbm5lY3RvciA9IGNvbm5lY3RvcjsKPiAgCj4gKwlpbnRlbF9kcC0+bXN0X2J3X2xvY2tlZCA9 IHRydWU7Cj4gKwo+ICAJRFJNX0RFQlVHX0tNUygiYWN0aXZlIGxpbmtzICVkXG4iLCBpbnRlbF9k cC0+YWN0aXZlX21zdF9saW5rcyk7Cj4gIAo+ICAJZHJtX2RwX3NlbmRfcG93ZXJfdXBkb3duX3Bo eSgmaW50ZWxfZHAtPm1zdF9tZ3IsIGNvbm5lY3Rvci0+cG9ydCwgdHJ1ZSk7Cj4gZGlmZiAtLWdp dCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rydi5oIGIvZHJpdmVycy9ncHUvZHJtL2k5 MTUvaW50ZWxfZHJ2LmgKPiBpbmRleCAzZjE5ZGM4MDk5N2YuLmZjMzM4NTI5ZTkxOCAxMDA2NDQK PiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kcnYuaAo+ICsrKyBiL2RyaXZlcnMv Z3B1L2RybS9pOTE1L2ludGVsX2Rydi5oCj4gQEAgLTExMDcsNiArMTEwNywxMiBAQCBzdHJ1Y3Qg aW50ZWxfZHAgewo+ICAJYm9vbCBjYW5fbXN0OyAvKiB0aGlzIHBvcnQgc3VwcG9ydHMgbXN0ICov Cj4gIAlib29sIGlzX21zdDsKPiAgCWludCBhY3RpdmVfbXN0X2xpbmtzOwo+ICsJLyogU2V0IHdo ZW4gd2UndmUgYWxyZWFkeSBkZWNpZGVkIG9uIGEgbGluayBidyBmb3IgbXN0LCB0byBwcmV2ZW50 IHVzCj4gKwkgKiBmcm9tIHNldHRpbmcgZGlmZmVyZW50IGxpbmsgYmFuZHdpdGhzIGlmIHRoZSBo dWIgdHJpZXMgdG8gY29uZnVzZQo+ICsJICogdXMgYnkgY2hhbmdpbmcgaXQgbGF0ZXIKPiArCSAq Lwo+ICsJYm9vbCBtc3RfYndfbG9ja2VkOwo+ICsKPiAgCS8qIGNvbm5lY3RvciBkaXJlY3RseSBh dHRhY2hlZCAtIHdvbid0IGJlIHVzZSBmb3IgbW9kZXNldCBpbiBtc3Qgd29ybGQgKi8KPiAgCXN0 cnVjdCBpbnRlbF9jb25uZWN0b3IgKmF0dGFjaGVkX2Nvbm5lY3RvcjsKPiAgCj4gLS0gCj4gMi4x NC4zCj4gCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmRy aS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRw czovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZlbAo=