From mboxrd@z Thu Jan 1 00:00:00 1970 From: Ville =?iso-8859-1?Q?Syrj=E4l=E4?= Subject: Re: [PATCH] drm/i915: Pass down rc in intel_encoder->compute_config() Date: Tue, 15 Jan 2019 15:18:05 +0200 Message-ID: <20190115131805.GH20097@intel.com> References: <20190114222931.25711-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: <20190114222931.25711-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, dri-devel@lists.freedesktop.org, Rodrigo Vivi List-Id: dri-devel@lists.freedesktop.org T24gTW9uLCBKYW4gMTQsIDIwMTkgYXQgMDU6Mjk6MzFQTSAtMDUwMCwgTHl1ZGUgUGF1bCB3cm90 ZToKPiBTb21ldGhpbmcgdGhhdCBJIGNvbXBsZXRlbHkgbWlzc2VkIHdoZW4gaW1wbGVtZW50aW5n IHRoZSBuZXcgTVNUIFZDUEkKPiBhdG9taWMgaGVscGVycyBpcyB0aGF0IHdpdGggdGhvc2UgaGVs cGVycywgdGhlcmUncyB0ZWNobmljYWxseSBhIGNoYW5jZQo+IG9mIHVzIGhhdmluZyB0byBncmFi IGFkZGl0aW9uYWwgbW9kZXNldCBsb2NrcyBpbiAtPmNvbXB1dGVfY29uZmlnKCkgYW5kCj4gZnVy dGhlcm1vcmUsIHRoYXQgbWVhbnMgd2UgaGF2ZSB0aGUgcG90ZW50aWFsIHRvIGhpdCBhIG5vcm1h bCBtb2Rlc2V0Cj4gZGVhZGxvY2suIEhvd2V2ZXIsIGJlY2F1c2UgLT5jb21wdXRlX2NvbmZpZygp IG9ubHkgcmV0dXJucyBhIGJvb2wgdGhpcwo+IG1lYW5zIHdlIGNhbid0IHJldHVybiAtRURFQURM SyB3aGVuIHdlIG5lZWQgdG8gZHJvcCBsb2NrcyBhbmQgdHJ5IGFnYWluCj4gd2hpY2ggbWVhbnMg d2UgZW5kIHVwIGp1c3QgZmFpbGluZyB0aGUgYXRvbWljIGNoZWNrIHBlcm1hbmVudGx5LiBXaG9v cHMuCj4gCj4gU28sIGZpeCB0aGlzIGJ5IG1vZGlmeWluZyAtPmNvbXB1dGVfY29uZmlnKCkgdG8g cGFzcyBkb3duIGFuIGFjdHVhbAo+IGVycm9yIGNvZGUgaW5zdGVhZCBvZiBhIGJvb2wgc28gdGhh dCB0aGUgYXRvbWljIGNoZWNrIGNhbiBiZSByZXN0YXJ0ZWQKPiBvbiBtb2Rlc2V0IGRlYWRsb2Nr cy4KPiAKPiBUaGFua3MgdG8gVmlsbGUgU3lyasOkbMOkIGZvciBwb2ludGluZyB0aGlzIG91dCEK PiAKPiBTaWduZWQtb2ZmLWJ5OiBMeXVkZSBQYXVsIDxseXVkZUByZWRoYXQuY29tPgo+IENjOiBW aWxsZSBTeXJqw6Rsw6QgPHZpbGxlLnN5cmphbGFAbGludXguaW50ZWwuY29tPgo+IEZpeGVzOiBl Y2VhZTE0NzI0NjcgKCJkcm0vZHBfbXN0OiBTdGFydCB0cmFja2luZyBwZXItcG9ydCBWQ1BJIGFs bG9jYXRpb25zIikKPiBCdWd6aWxsYTogaHR0cHM6Ly9idWdzLmZyZWVkZXNrdG9wLm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9MTA5MzIwCj4gLS0tCj4gIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2ljbF9kc2ku YyAgICAgICB8ICA4ICsrKy0tLS0KPiAgZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfY3J0LmMg ICAgIHwgMzQgKysrKysrKysrKysrKystLS0tLS0tLS0tLS0tLQo+ICBkcml2ZXJzL2dwdS9kcm0v aTkxNS9pbnRlbF9kZGkuYyAgICAgfCAgNiArKy0tLQo+ICBkcml2ZXJzL2dwdS9kcm0vaTkxNS9p bnRlbF9kaXNwbGF5LmMgfCAxMSArKysrKy0tLS0KPiAgZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50 ZWxfZHAuYyAgICAgIHwgMzIgKysrKysrKysrKysrKy0tLS0tLS0tLS0tLS0KPiAgZHJpdmVycy9n cHUvZHJtL2k5MTUvaW50ZWxfZHBfbXN0LmMgIHwgMTIgKysrKystLS0tLQo+ICBkcml2ZXJzL2dw dS9kcm0vaTkxNS9pbnRlbF9kcnYuaCAgICAgfCAxOCArKysrKysrLS0tLS0tLS0KPiAgZHJpdmVy cy9ncHUvZHJtL2k5MTUvaW50ZWxfZHZvLmMgICAgIHwgMTAgKysrKy0tLS0KPiAgZHJpdmVycy9n cHUvZHJtL2k5MTUvaW50ZWxfaGRtaS5jICAgIHwgMTIgKysrKystLS0tLQo+ICBkcml2ZXJzL2dw dS9kcm0vaTkxNS9pbnRlbF9sdmRzLmMgICAgfCAxMiArKysrKy0tLS0tCj4gIGRyaXZlcnMvZ3B1 L2RybS9pOTE1L2ludGVsX3Nkdm8uYyAgICB8IDE0ICsrKysrKy0tLS0tLQo+ICBkcml2ZXJzL2dw dS9kcm0vaTkxNS9pbnRlbF90di5jICAgICAgfCAgOCArKystLS0tCj4gIGRyaXZlcnMvZ3B1L2Ry bS9pOTE1L3Zsdl9kc2kuYyAgICAgICB8IDE0ICsrKysrKy0tLS0tLQo+ICAxMyBmaWxlcyBjaGFu Z2VkLCA5NyBpbnNlcnRpb25zKCspLCA5NCBkZWxldGlvbnMoLSkKPiAKPiBkaWZmIC0tZ2l0IGEv ZHJpdmVycy9ncHUvZHJtL2k5MTUvaWNsX2RzaS5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaWNs X2RzaS5jCj4gaW5kZXggZjNhNWYwMzY0NmNlLi4zNTViNDhkMWM5MzcgMTAwNjQ0Cj4gLS0tIGEv ZHJpdmVycy9ncHUvZHJtL2k5MTUvaWNsX2RzaS5jCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5 MTUvaWNsX2RzaS5jCj4gQEAgLTExODgsOSArMTE4OCw5IEBAIHN0YXRpYyB2b2lkIGdlbjExX2Rz aV9nZXRfY29uZmlnKHN0cnVjdCBpbnRlbF9lbmNvZGVyICplbmNvZGVyLAo+ICAJcGlwZV9jb25m aWctPm91dHB1dF90eXBlcyB8PSBCSVQoSU5URUxfT1VUUFVUX0RTSSk7Cj4gIH0KPiAgCj4gLXN0 YXRpYyBib29sIGdlbjExX2RzaV9jb21wdXRlX2NvbmZpZyhzdHJ1Y3QgaW50ZWxfZW5jb2RlciAq ZW5jb2RlciwKPiAtCQkJCSAgICAgc3RydWN0IGludGVsX2NydGNfc3RhdGUgKnBpcGVfY29uZmln LAo+IC0JCQkJICAgICBzdHJ1Y3QgZHJtX2Nvbm5lY3Rvcl9zdGF0ZSAqY29ubl9zdGF0ZSkKPiAr c3RhdGljIGludCBnZW4xMV9kc2lfY29tcHV0ZV9jb25maWcoc3RydWN0IGludGVsX2VuY29kZXIg KmVuY29kZXIsCj4gKwkJCQkgICAgc3RydWN0IGludGVsX2NydGNfc3RhdGUgKnBpcGVfY29uZmln LAo+ICsJCQkJICAgIHN0cnVjdCBkcm1fY29ubmVjdG9yX3N0YXRlICpjb25uX3N0YXRlKQo+ICB7 Cj4gIAlzdHJ1Y3QgaW50ZWxfZHNpICppbnRlbF9kc2kgPSBjb250YWluZXJfb2YoZW5jb2Rlciwg c3RydWN0IGludGVsX2RzaSwKPiAgCQkJCQkJICAgYmFzZSk7Cj4gQEAgLTEyMTUsNyArMTIxNSw3 IEBAIHN0YXRpYyBib29sIGdlbjExX2RzaV9jb21wdXRlX2NvbmZpZyhzdHJ1Y3QgaW50ZWxfZW5j b2RlciAqZW5jb2RlciwKPiAgCXBpcGVfY29uZmlnLT5jbG9ja19zZXQgPSB0cnVlOwo+ICAJcGlw ZV9jb25maWctPnBvcnRfY2xvY2sgPSBpbnRlbF9kc2lfYml0cmF0ZShpbnRlbF9kc2kpIC8gNTsK PiAgCj4gLQlyZXR1cm4gdHJ1ZTsKPiArCXJldHVybiAwOwo+ICB9Cj4gIAo+ICBzdGF0aWMgdTY0 IGdlbjExX2RzaV9nZXRfcG93ZXJfZG9tYWlucyhzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2Rl ciwKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfY3J0LmMgYi9kcml2 ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9jcnQuYwo+IGluZGV4IDMzYmQyYWRkY2JkZC4uNjI1Nzk0 ODgzNDMzIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2NydC5jCj4g KysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfY3J0LmMKPiBAQCAtMzQ1LDUxICszNDUs NTEgQEAgaW50ZWxfY3J0X21vZGVfdmFsaWQoc3RydWN0IGRybV9jb25uZWN0b3IgKmNvbm5lY3Rv ciwKPiAgCXJldHVybiBNT0RFX09LOwo+ICB9Cj4gIAo+IC1zdGF0aWMgYm9vbCBpbnRlbF9jcnRf Y29tcHV0ZV9jb25maWcoc3RydWN0IGludGVsX2VuY29kZXIgKmVuY29kZXIsCj4gLQkJCQkgICAg IHN0cnVjdCBpbnRlbF9jcnRjX3N0YXRlICpwaXBlX2NvbmZpZywKPiAtCQkJCSAgICAgc3RydWN0 IGRybV9jb25uZWN0b3Jfc3RhdGUgKmNvbm5fc3RhdGUpCj4gK3N0YXRpYyBpbnQgaW50ZWxfY3J0 X2NvbXB1dGVfY29uZmlnKHN0cnVjdCBpbnRlbF9lbmNvZGVyICplbmNvZGVyLAo+ICsJCQkJICAg IHN0cnVjdCBpbnRlbF9jcnRjX3N0YXRlICpwaXBlX2NvbmZpZywKPiArCQkJCSAgICBzdHJ1Y3Qg ZHJtX2Nvbm5lY3Rvcl9zdGF0ZSAqY29ubl9zdGF0ZSkKPiAgewo+ICAJc3RydWN0IGRybV9kaXNw bGF5X21vZGUgKmFkanVzdGVkX21vZGUgPQo+ICAJCSZwaXBlX2NvbmZpZy0+YmFzZS5hZGp1c3Rl ZF9tb2RlOwo+ICAKPiAgCWlmIChhZGp1c3RlZF9tb2RlLT5mbGFncyAmIERSTV9NT0RFX0ZMQUdf REJMU0NBTikKPiAtCQlyZXR1cm4gZmFsc2U7Cj4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4gIAo+ICAJ cGlwZV9jb25maWctPm91dHB1dF9mb3JtYXQgPSBJTlRFTF9PVVRQVVRfRk9STUFUX1JHQjsKClBs ZWFzZSBhZGQgYSBuZXdsaW5lIGhlcmUgd2hpbGUgYXQgaXQuCgo+IC0JcmV0dXJuIHRydWU7Cj4g KwlyZXR1cm4gMDsKPiAgfQo+ICAKPiAtc3RhdGljIGJvb2wgcGNoX2NydF9jb21wdXRlX2NvbmZp ZyhzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2RlciwKPiAtCQkJCSAgIHN0cnVjdCBpbnRlbF9j cnRjX3N0YXRlICpwaXBlX2NvbmZpZywKPiAtCQkJCSAgIHN0cnVjdCBkcm1fY29ubmVjdG9yX3N0 YXRlICpjb25uX3N0YXRlKQo+ICtzdGF0aWMgaW50IHBjaF9jcnRfY29tcHV0ZV9jb25maWcoc3Ry dWN0IGludGVsX2VuY29kZXIgKmVuY29kZXIsCj4gKwkJCQkgIHN0cnVjdCBpbnRlbF9jcnRjX3N0 YXRlICpwaXBlX2NvbmZpZywKPiArCQkJCSAgc3RydWN0IGRybV9jb25uZWN0b3Jfc3RhdGUgKmNv bm5fc3RhdGUpCj4gIHsKPiAgCXN0cnVjdCBkcm1fZGlzcGxheV9tb2RlICphZGp1c3RlZF9tb2Rl ID0KPiAgCQkmcGlwZV9jb25maWctPmJhc2UuYWRqdXN0ZWRfbW9kZTsKPiAgCj4gIAlpZiAoYWRq dXN0ZWRfbW9kZS0+ZmxhZ3MgJiBEUk1fTU9ERV9GTEFHX0RCTFNDQU4pCj4gLQkJcmV0dXJuIGZh bHNlOwo+ICsJCXJldHVybiAtRUlOVkFMOwo+ICAKPiAgCXBpcGVfY29uZmlnLT5oYXNfcGNoX2Vu Y29kZXIgPSB0cnVlOwo+ICAJcGlwZV9jb25maWctPm91dHB1dF9mb3JtYXQgPSBJTlRFTF9PVVRQ VVRfRk9STUFUX1JHQjsKPiAgCj4gLQlyZXR1cm4gdHJ1ZTsKPiArCXJldHVybiAwOwo+ICB9Cj4g IAo+IC1zdGF0aWMgYm9vbCBoc3dfY3J0X2NvbXB1dGVfY29uZmlnKHN0cnVjdCBpbnRlbF9lbmNv ZGVyICplbmNvZGVyLAo+IC0JCQkJICAgc3RydWN0IGludGVsX2NydGNfc3RhdGUgKnBpcGVfY29u ZmlnLAo+IC0JCQkJICAgc3RydWN0IGRybV9jb25uZWN0b3Jfc3RhdGUgKmNvbm5fc3RhdGUpCj4g K3N0YXRpYyBpbnQgaHN3X2NydF9jb21wdXRlX2NvbmZpZyhzdHJ1Y3QgaW50ZWxfZW5jb2RlciAq ZW5jb2RlciwKPiArCQkJCSAgc3RydWN0IGludGVsX2NydGNfc3RhdGUgKnBpcGVfY29uZmlnLAo+ ICsJCQkJICBzdHJ1Y3QgZHJtX2Nvbm5lY3Rvcl9zdGF0ZSAqY29ubl9zdGF0ZSkKPiAgewo+ICAJ c3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2ID0gdG9faTkxNShlbmNvZGVyLT5iYXNl LmRldik7Cj4gIAlzdHJ1Y3QgZHJtX2Rpc3BsYXlfbW9kZSAqYWRqdXN0ZWRfbW9kZSA9Cj4gIAkJ JnBpcGVfY29uZmlnLT5iYXNlLmFkanVzdGVkX21vZGU7Cj4gIAo+ICAJaWYgKGFkanVzdGVkX21v ZGUtPmZsYWdzICYgRFJNX01PREVfRkxBR19EQkxTQ0FOKQo+IC0JCXJldHVybiBmYWxzZTsKPiAr CQlyZXR1cm4gLUVJTlZBTDsKPiAgCj4gIAkvKiBIU1cvQkRXIEZESSBsaW1pdGVkIHRvIDRrICov Cj4gIAlpZiAoYWRqdXN0ZWRfbW9kZS0+Y3J0Y19oZGlzcGxheSA+IDQwOTYgfHwKPiAgCSAgICBh ZGp1c3RlZF9tb2RlLT5jcnRjX2hibGFua19zdGFydCA+IDQwOTYpCj4gLQkJcmV0dXJuIGZhbHNl Owo+ICsJCXJldHVybiAtRU5PU1BDOwoKSSdkIGdvIHdpdGggLUVJTlZBTCBoZXJlLgoKPiAgCj4g IAlwaXBlX2NvbmZpZy0+aGFzX3BjaF9lbmNvZGVyID0gdHJ1ZTsKPiAgCXBpcGVfY29uZmlnLT5v dXRwdXRfZm9ybWF0ID0gSU5URUxfT1VUUFVUX0ZPUk1BVF9SR0I7Cj4gQEAgLTM5OCw3ICszOTgs NyBAQCBzdGF0aWMgYm9vbCBoc3dfY3J0X2NvbXB1dGVfY29uZmlnKHN0cnVjdCBpbnRlbF9lbmNv ZGVyICplbmNvZGVyLAo+ICAJaWYgKEhBU19QQ0hfTFBUKGRldl9wcml2KSkgewo+ICAJCWlmIChw aXBlX2NvbmZpZy0+YndfY29uc3RyYWluZWQgJiYgcGlwZV9jb25maWctPnBpcGVfYnBwIDwgMjQp IHsKPiAgCQkJRFJNX0RFQlVHX0tNUygiTFBUIG9ubHkgc3VwcG9ydHMgMjRicHBcbiIpOwo+IC0J CQlyZXR1cm4gZmFsc2U7Cj4gKwkJCXJldHVybiAtRUlOVkFMOwo+ICAJCX0KPiAgCj4gIAkJcGlw ZV9jb25maWctPnBpcGVfYnBwID0gMjQ7Cj4gQEAgLTQwNyw3ICs0MDcsNyBAQCBzdGF0aWMgYm9v bCBoc3dfY3J0X2NvbXB1dGVfY29uZmlnKHN0cnVjdCBpbnRlbF9lbmNvZGVyICplbmNvZGVyLAo+ ICAJLyogRkRJIG11c3QgYWx3YXlzIGJlIDIuNyBHSHogKi8KPiAgCXBpcGVfY29uZmlnLT5wb3J0 X2Nsb2NrID0gMTM1MDAwICogMjsKPiAgCj4gLQlyZXR1cm4gdHJ1ZTsKPiArCXJldHVybiAwOwo+ ICB9Cj4gIAo+ICBzdGF0aWMgYm9vbCBpbnRlbF9pcm9ubGFrZV9jcnRfZGV0ZWN0X2hvdHBsdWco c3RydWN0IGRybV9jb25uZWN0b3IgKmNvbm5lY3RvcikKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9n cHUvZHJtL2k5MTUvaW50ZWxfZGRpLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kZGku Ywo+IGluZGV4IDdmM2NkMDU1ZGU1MC4uY2U0NDc0NGE1ZjlkIDEwMDY0NAo+IC0tLSBhL2RyaXZl cnMvZ3B1L2RybS9pOTE1L2ludGVsX2RkaS5jCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUv aW50ZWxfZGRpLmMKPiBAQCAtMzgzNyw5ICszODM3LDkgQEAgaW50ZWxfZGRpX2NvbXB1dGVfb3V0 cHV0X3R5cGUoc3RydWN0IGludGVsX2VuY29kZXIgKmVuY29kZXIsCj4gIAl9Cj4gIH0KPiAgCj4g LXN0YXRpYyBib29sIGludGVsX2RkaV9jb21wdXRlX2NvbmZpZyhzdHJ1Y3QgaW50ZWxfZW5jb2Rl ciAqZW5jb2RlciwKPiAtCQkJCSAgICAgc3RydWN0IGludGVsX2NydGNfc3RhdGUgKnBpcGVfY29u ZmlnLAo+IC0JCQkJICAgICBzdHJ1Y3QgZHJtX2Nvbm5lY3Rvcl9zdGF0ZSAqY29ubl9zdGF0ZSkK PiArc3RhdGljIGludCBpbnRlbF9kZGlfY29tcHV0ZV9jb25maWcoc3RydWN0IGludGVsX2VuY29k ZXIgKmVuY29kZXIsCj4gKwkJCQkgICAgc3RydWN0IGludGVsX2NydGNfc3RhdGUgKnBpcGVfY29u ZmlnLAo+ICsJCQkJICAgIHN0cnVjdCBkcm1fY29ubmVjdG9yX3N0YXRlICpjb25uX3N0YXRlKQo+ ICB7Cj4gIAlzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYgPSB0b19pOTE1KGVuY29k ZXItPmJhc2UuZGV2KTsKPiAgCWVudW0gcG9ydCBwb3J0ID0gZW5jb2Rlci0+cG9ydDsKCkhtbS4g QXQgZmlyc3QgZ2xhbmNlIEkgd2FzIHJhdGhlciBjb25mdXNlZCB0aGF0IHlvdSBkaWRuJ3QgY2hh bmdlCmFueXRoaW5nIGhlcmUsIGJ1dCBpbmRlZWQgdGhpcyBndXkgYWxyZWFkeSBkb2VzIHdoYXQg d2Ugd2FudC4KCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rpc3Bs YXkuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rpc3BsYXkuYwo+IGluZGV4IGVlODVj YTg0ZDBmNy4uZjYzMjRmZTc0YjE5IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1 L2ludGVsX2Rpc3BsYXkuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rpc3Bs YXkuYwo+IEBAIC0xMTU1MCwxMCArMTE1NTAsMTMgQEAgaW50ZWxfbW9kZXNldF9waXBlX2NvbmZp ZyhzdHJ1Y3QgZHJtX2NydGMgKmNydGMsCj4gIAkJCWNvbnRpbnVlOwo+ICAKPiAgCQllbmNvZGVy ID0gdG9faW50ZWxfZW5jb2Rlcihjb25uZWN0b3Jfc3RhdGUtPmJlc3RfZW5jb2Rlcik7Cj4gLQo+ IC0JCWlmICghKGVuY29kZXItPmNvbXB1dGVfY29uZmlnKGVuY29kZXIsIHBpcGVfY29uZmlnLCBj b25uZWN0b3Jfc3RhdGUpKSkgewo+IC0JCQlEUk1fREVCVUdfS01TKCJFbmNvZGVyIGNvbmZpZyBm YWlsdXJlXG4iKTsKPiAtCQkJcmV0dXJuIC1FSU5WQUw7Cj4gKwkJcmV0ID0gZW5jb2Rlci0+Y29t cHV0ZV9jb25maWcoZW5jb2RlciwgcGlwZV9jb25maWcsCj4gKwkJCQkJICAgICAgY29ubmVjdG9y X3N0YXRlKTsKPiArCQlpZiAocmV0IDwgMCkgewo+ICsJCQlpZiAocmV0ICE9IC1FREVBRExLKQo+ ICsJCQkJRFJNX0RFQlVHX0tNUygiRW5jb2RlciBjb25maWcgZmFpbHVyZTogJWRcbiIsCj4gKwkJ CQkJICAgICAgcmV0KTsKPiArCQkJcmV0dXJuIHJldDsKPiAgCQl9Cj4gIAl9Cj4gIAo+IGRpZmYg LS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kcC5jIGIvZHJpdmVycy9ncHUvZHJt L2k5MTUvaW50ZWxfZHAuYwo+IGluZGV4IDBhM2FjOThhNzc5ZS4uOWU0YzJjNmJiMWYwIDEwMDY0 NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2RwLmMKPiArKysgYi9kcml2ZXJz L2dwdS9kcm0vaTkxNS9pbnRlbF9kcC5jCj4gQEAgLTE5MDUsMTAgKzE5MDUsMTAgQEAgc3RhdGlj IGludCBpbnRlbF9kcF9kc2NfY29tcHV0ZV9icHAoc3RydWN0IGludGVsX2RwICppbnRlbF9kcCwg dTggZHNjX21heF9icGMpCj4gIAlyZXR1cm4gMDsKPiAgfQo+ICAKPiAtc3RhdGljIGJvb2wgaW50 ZWxfZHBfZHNjX2NvbXB1dGVfY29uZmlnKHN0cnVjdCBpbnRlbF9kcCAqaW50ZWxfZHAsCj4gLQkJ CQkJc3RydWN0IGludGVsX2NydGNfc3RhdGUgKnBpcGVfY29uZmlnLAo+IC0JCQkJCXN0cnVjdCBk cm1fY29ubmVjdG9yX3N0YXRlICpjb25uX3N0YXRlLAo+IC0JCQkJCXN0cnVjdCBsaW5rX2NvbmZp Z19saW1pdHMgKmxpbWl0cykKPiArc3RhdGljIGludCBpbnRlbF9kcF9kc2NfY29tcHV0ZV9jb25m aWcoc3RydWN0IGludGVsX2RwICppbnRlbF9kcCwKPiArCQkJCSAgICAgICBzdHJ1Y3QgaW50ZWxf Y3J0Y19zdGF0ZSAqcGlwZV9jb25maWcsCj4gKwkJCQkgICAgICAgc3RydWN0IGRybV9jb25uZWN0 b3Jfc3RhdGUgKmNvbm5fc3RhdGUsCj4gKwkJCQkgICAgICAgc3RydWN0IGxpbmtfY29uZmlnX2xp bWl0cyAqbGltaXRzKQo+ICB7Cj4gIAlzdHJ1Y3QgaW50ZWxfZGlnaXRhbF9wb3J0ICpkaWdfcG9y dCA9IGRwX3RvX2RpZ19wb3J0KGludGVsX2RwKTsKPiAgCXN0cnVjdCBkcm1faTkxNV9wcml2YXRl ICpkZXZfcHJpdiA9IHRvX2k5MTUoZGlnX3BvcnQtPmJhc2UuYmFzZS5kZXYpOwo+IEBAIC0xOTE3 LDcgKzE5MTcsNyBAQCBzdGF0aWMgYm9vbCBpbnRlbF9kcF9kc2NfY29tcHV0ZV9jb25maWcoc3Ry dWN0IGludGVsX2RwICppbnRlbF9kcCwKPiAgCWludCBwaXBlX2JwcDsKPiAgCj4gIAlpZiAoIWlu dGVsX2RwX3N1cHBvcnRzX2RzYyhpbnRlbF9kcCwgcGlwZV9jb25maWcpKQo+IC0JCXJldHVybiBm YWxzZTsKPiArCQlyZXR1cm4gLUVJTlZBTDsKPiAgCj4gIAlkc2NfbWF4X2JwYyA9IG1pbl90KHU4 LCBEUF9EU0NfTUFYX1NVUFBPUlRFRF9CUEMsCj4gIAkJCSAgICBjb25uX3N0YXRlLT5tYXhfcmVx dWVzdGVkX2JwYyk7Cj4gQEAgLTE5MjUsNyArMTkyNSw3IEBAIHN0YXRpYyBib29sIGludGVsX2Rw X2RzY19jb21wdXRlX2NvbmZpZyhzdHJ1Y3QgaW50ZWxfZHAgKmludGVsX2RwLAo+ICAJcGlwZV9i cHAgPSBpbnRlbF9kcF9kc2NfY29tcHV0ZV9icHAoaW50ZWxfZHAsIGRzY19tYXhfYnBjKTsKPiAg CWlmIChwaXBlX2JwcCA8IERQX0RTQ19NSU5fU1VQUE9SVEVEX0JQQyAqIDMpIHsKPiAgCQlEUk1f REVCVUdfS01TKCJObyBEU0Mgc3VwcG9ydCBmb3IgbGVzcyB0aGFuIDhicGNcbiIpOwo+IC0JCXJl dHVybiBmYWxzZTsKPiArCQlyZXR1cm4gLUVJTlZBTDsKPiAgCX0KPiAgCj4gIAkvKgo+IEBAIC0x OTU5LDcgKzE5NTksNyBAQCBzdGF0aWMgYm9vbCBpbnRlbF9kcF9kc2NfY29tcHV0ZV9jb25maWco c3RydWN0IGludGVsX2RwICppbnRlbF9kcCwKPiAgCQkJCQkJICAgICBhZGp1c3RlZF9tb2RlLT5j cnRjX2hkaXNwbGF5KTsKPiAgCQlpZiAoIWRzY19tYXhfb3V0cHV0X2JwcCB8fCAhZHNjX2RwX3Ns aWNlX2NvdW50KSB7Cj4gIAkJCURSTV9ERUJVR19LTVMoIkNvbXByZXNzZWQgQlBQL1NsaWNlIENv dW50IG5vdCBzdXBwb3J0ZWRcbiIpOwo+IC0JCQlyZXR1cm4gZmFsc2U7Cj4gKwkJCXJldHVybiAt RUlOVkFMOwo+ICAJCX0KPiAgCQlwaXBlX2NvbmZpZy0+ZHNjX3BhcmFtcy5jb21wcmVzc2VkX2Jw cCA9IG1pbl90KHUxNiwKPiAgCQkJCQkJCSAgICAgICBkc2NfbWF4X291dHB1dF9icHAgPj4gNCwK PiBAQCAtMTk3Niw3ICsxOTc2LDcgQEAgc3RhdGljIGJvb2wgaW50ZWxfZHBfZHNjX2NvbXB1dGVf Y29uZmlnKHN0cnVjdCBpbnRlbF9kcCAqaW50ZWxfZHAsCj4gIAkJCXBpcGVfY29uZmlnLT5kc2Nf cGFyYW1zLmRzY19zcGxpdCA9IHRydWU7Cj4gIAkJfSBlbHNlIHsKPiAgCQkJRFJNX0RFQlVHX0tN UygiQ2Fubm90IHNwbGl0IHN0cmVhbSB0byB1c2UgMiBWRFNDIGluc3RhbmNlc1xuIik7Cj4gLQkJ CXJldHVybiBmYWxzZTsKPiArCQkJcmV0dXJuIC1FSU5WQUw7Cj4gIAkJfQo+ICAJfQo+ICAJaWYg KGludGVsX2RwX2NvbXB1dGVfZHNjX3BhcmFtcyhpbnRlbF9kcCwgcGlwZV9jb25maWcpIDwgMCkg ewo+IEBAIC0xOTg0LDcgKzE5ODQsNyBAQCBzdGF0aWMgYm9vbCBpbnRlbF9kcF9kc2NfY29tcHV0 ZV9jb25maWcoc3RydWN0IGludGVsX2RwICppbnRlbF9kcCwKPiAgCQkJICAgICAgIkNvbXByZXNz ZWQgQlBQID0gJWRcbiIsCj4gIAkJCSAgICAgIHBpcGVfY29uZmlnLT5waXBlX2JwcCwKPiAgCQkJ ICAgICAgcGlwZV9jb25maWctPmRzY19wYXJhbXMuY29tcHJlc3NlZF9icHApOwo+IC0JCXJldHVy biBmYWxzZTsKPiArCQlyZXR1cm4gLUVJTlZBTDsKCkhlcmUgd2UgY2FuIHByb3BhZ2F0ZSB0aGUg cmV0dXJuIHZhbHVlIGZyb20KaW50ZWxfZHBfY29tcHV0ZV9kc2NfcGFyYW1zKCkgdXB3YXJkcy4K Cj4gIAl9Cj4gIAlwaXBlX2NvbmZpZy0+ZHNjX3BhcmFtcy5jb21wcmVzc2lvbl9lbmFibGUgPSB0 cnVlOwo+ICAJRFJNX0RFQlVHX0tNUygiRFAgRFNDIGNvbXB1dGVkIHdpdGggSW5wdXQgQnBwID0g JWQgIgo+IEBAIC0xOTkzLDcgKzE5OTMsNyBAQCBzdGF0aWMgYm9vbCBpbnRlbF9kcF9kc2NfY29t cHV0ZV9jb25maWcoc3RydWN0IGludGVsX2RwICppbnRlbF9kcCwKPiAgCQkgICAgICBwaXBlX2Nv bmZpZy0+ZHNjX3BhcmFtcy5jb21wcmVzc2VkX2JwcCwKPiAgCQkgICAgICBwaXBlX2NvbmZpZy0+ ZHNjX3BhcmFtcy5zbGljZV9jb3VudCk7Cj4gIAo+IC0JcmV0dXJuIHRydWU7Cj4gKwlyZXR1cm4g MDsKPiAgfQo+ICAKPiAgc3RhdGljIGJvb2wKPiBAQCAtMjA5NCw3ICsyMDk0LDcgQEAgaW50ZWxf ZHBfY29tcHV0ZV9saW5rX2NvbmZpZyhzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2RlciwKPiAg CXJldHVybiB0cnVlOwo+ICB9CgpZb3UgY2hhbmdlZCBpbnRlbF9kcF9kc2NfY29tcHV0ZV9jb25m aWcoKSBidXQgZGlkbid0IHVwZGF0ZSB0aGUgY2FsbGVyPwpQcm9iYWJseSBiZXN0IHRvIGNoYW5n ZSBhbGwgdGhlIGludGVsX2RwX2NvbXB1dGVfbGlua19jb25maWcqKCkgZnVuY3Rpb25zCnRvIHJl dHVybiBhbiBpbnQgYXMgd2VsbCBmb3IgY29uc2lzdGVuY3kuCgo+ICAKPiAtYm9vbAo+ICtpbnQK PiAgaW50ZWxfZHBfY29tcHV0ZV9jb25maWcoc3RydWN0IGludGVsX2VuY29kZXIgKmVuY29kZXIs Cj4gIAkJCXN0cnVjdCBpbnRlbF9jcnRjX3N0YXRlICpwaXBlX2NvbmZpZywKPiAgCQkJc3RydWN0 IGRybV9jb25uZWN0b3Jfc3RhdGUgKmNvbm5fc3RhdGUpCj4gQEAgLTIxNDcsMjAgKzIxNDcsMjAg QEAgaW50ZWxfZHBfY29tcHV0ZV9jb25maWcoc3RydWN0IGludGVsX2VuY29kZXIgKmVuY29kZXIs CgpPaCB3b3cuIEkganVzdCBub3RpY2VkIHRoYXQgYTFiMjI3OGU0ZGZjICgiZHJtL2k5MTU6IHNr eWxha2UgcGFuZWwgZml0dGluZwp1c2luZyBzaGFyZWQgc2NhbGVycyIpIGFscmVhZHkgYXNzdW1l ZCB0aGF0IC5jb21wdXRlX2NvbmZpZygpIHJldHVybnMKYW4gaW50LiBUaGF0IG1pZ2h0IGV2ZW4g ZXhwbGFpbiBzb21lIG9kZGJhbGwgc2NhbGVyIGZhaWxzIHBlb3BsZSBoYXZlCnNlZW4uCgo+ICAJ fQo+ICAKPiAgCWlmIChhZGp1c3RlZF9tb2RlLT5mbGFncyAmIERSTV9NT0RFX0ZMQUdfREJMU0NB TikKPiAtCQlyZXR1cm4gZmFsc2U7Cj4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4gIAo+ICAJaWYgKEhB U19HTUNIX0RJU1BMQVkoZGV2X3ByaXYpICYmCj4gIAkgICAgYWRqdXN0ZWRfbW9kZS0+ZmxhZ3Mg JiBEUk1fTU9ERV9GTEFHX0lOVEVSTEFDRSkKPiAtCQlyZXR1cm4gZmFsc2U7Cj4gKwkJcmV0dXJu IC1FSU5WQUw7Cj4gIAo+ICAJaWYgKGFkanVzdGVkX21vZGUtPmZsYWdzICYgRFJNX01PREVfRkxB R19EQkxDTEspCj4gLQkJcmV0dXJuIGZhbHNlOwo+ICsJCXJldHVybiAtRUlOVkFMOwo+ICAKPiAg CXBpcGVfY29uZmlnLT5mZWNfZW5hYmxlID0gIWludGVsX2RwX2lzX2VkcChpbnRlbF9kcCkgJiYK PiAgCQkJCSAgaW50ZWxfZHBfc3VwcG9ydHNfZmVjKGludGVsX2RwLCBwaXBlX2NvbmZpZyk7Cj4g IAo+ICAJaWYgKCFpbnRlbF9kcF9jb21wdXRlX2xpbmtfY29uZmlnKGVuY29kZXIsIHBpcGVfY29u ZmlnLCBjb25uX3N0YXRlKSkKPiAtCQlyZXR1cm4gZmFsc2U7Cj4gKwkJcmV0dXJuIC1FTk9TUEM7 Cj4gIAo+ICAJaWYgKGludGVsX2Nvbm5fc3RhdGUtPmJyb2FkY2FzdF9yZ2IgPT0gSU5URUxfQlJP QURDQVNUX1JHQl9BVVRPKSB7Cj4gIAkJLyoKPiBAQCAtMjIwOCw3ICsyMjA4LDcgQEAgaW50ZWxf ZHBfY29tcHV0ZV9jb25maWcoc3RydWN0IGludGVsX2VuY29kZXIgKmVuY29kZXIsCj4gIAo+ICAJ aW50ZWxfcHNyX2NvbXB1dGVfY29uZmlnKGludGVsX2RwLCBwaXBlX2NvbmZpZyk7Cj4gIAo+IC0J cmV0dXJuIHRydWU7Cj4gKwlyZXR1cm4gMDsKPiAgfQo+ICAKPiAgdm9pZCBpbnRlbF9kcF9zZXRf bGlua19wYXJhbXMoc3RydWN0IGludGVsX2RwICppbnRlbF9kcCwKPiBkaWZmIC0tZ2l0IGEvZHJp dmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHBfbXN0LmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9p bnRlbF9kcF9tc3QuYwo+IGluZGV4IDNmODM0MjkzMzNjNy4uYTE5Njk5MDIzZGIxIDEwMDY0NAo+ IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2RwX21zdC5jCj4gKysrIGIvZHJpdmVy cy9ncHUvZHJtL2k5MTUvaW50ZWxfZHBfbXN0LmMKPiBAQCAtMjksOSArMjksOSBAQAo+ICAjaW5j bHVkZSA8ZHJtL2RybV9jcnRjX2hlbHBlci5oPgo+ICAjaW5jbHVkZSA8ZHJtL2RybV9lZGlkLmg+ Cj4gIAo+IC1zdGF0aWMgYm9vbCBpbnRlbF9kcF9tc3RfY29tcHV0ZV9jb25maWcoc3RydWN0IGlu dGVsX2VuY29kZXIgKmVuY29kZXIsCj4gLQkJCQkJc3RydWN0IGludGVsX2NydGNfc3RhdGUgKnBp cGVfY29uZmlnLAo+IC0JCQkJCXN0cnVjdCBkcm1fY29ubmVjdG9yX3N0YXRlICpjb25uX3N0YXRl KQo+ICtzdGF0aWMgaW50IGludGVsX2RwX21zdF9jb21wdXRlX2NvbmZpZyhzdHJ1Y3QgaW50ZWxf ZW5jb2RlciAqZW5jb2RlciwKPiArCQkJCSAgICAgICBzdHJ1Y3QgaW50ZWxfY3J0Y19zdGF0ZSAq cGlwZV9jb25maWcsCj4gKwkJCQkgICAgICAgc3RydWN0IGRybV9jb25uZWN0b3Jfc3RhdGUgKmNv bm5fc3RhdGUpCj4gIHsKPiAgCXN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiA9IHRv X2k5MTUoZW5jb2Rlci0+YmFzZS5kZXYpOwo+ICAJc3RydWN0IGludGVsX2RwX21zdF9lbmNvZGVy ICppbnRlbF9tc3QgPSBlbmNfdG9fbXN0KCZlbmNvZGVyLT5iYXNlKTsKPiBAQCAtNTIsNyArNTIs NyBAQCBzdGF0aWMgYm9vbCBpbnRlbF9kcF9tc3RfY29tcHV0ZV9jb25maWcoc3RydWN0IGludGVs X2VuY29kZXIgKmVuY29kZXIsCj4gIAkJCQkJICAgRFBfRFBDRF9RVUlSS19DT05TVEFOVF9OKTsK PiAgCj4gIAlpZiAoYWRqdXN0ZWRfbW9kZS0+ZmxhZ3MgJiBEUk1fTU9ERV9GTEFHX0RCTFNDQU4p Cj4gLQkJcmV0dXJuIGZhbHNlOwo+ICsJCXJldHVybiAtRUlOVkFMOwo+ICAKPiAgCXBpcGVfY29u ZmlnLT5vdXRwdXRfZm9ybWF0ID0gSU5URUxfT1VUUFVUX0ZPUk1BVF9SR0I7Cj4gIAlwaXBlX2Nv bmZpZy0+aGFzX3BjaF9lbmNvZGVyID0gZmFsc2U7Cj4gQEAgLTg5LDcgKzg5LDcgQEAgc3RhdGlj IGJvb2wgaW50ZWxfZHBfbXN0X2NvbXB1dGVfY29uZmlnKHN0cnVjdCBpbnRlbF9lbmNvZGVyICpl bmNvZGVyLAo+ICAJCWlmIChzbG90cyA8IDApIHsKPiAgCQkJRFJNX0RFQlVHX0tNUygiZmFpbGVk IGZpbmRpbmcgdmNwaSBzbG90czolZFxuIiwKPiAgCQkJCSAgICAgIHNsb3RzKTsKPiAtCQkJcmV0 dXJuIGZhbHNlOwo+ICsJCQlyZXR1cm4gc2xvdHM7Cj4gIAkJfQo+ICAJfQo+ICAKPiBAQCAtMTA3 LDcgKzEwNyw3IEBAIHN0YXRpYyBib29sIGludGVsX2RwX21zdF9jb21wdXRlX2NvbmZpZyhzdHJ1 Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2RlciwKPiAgCj4gIAlpbnRlbF9kZGlfY29tcHV0ZV9taW5f dm9sdGFnZV9sZXZlbChkZXZfcHJpdiwgcGlwZV9jb25maWcpOwo+ICAKPiAtCXJldHVybiB0cnVl Owo+ICsJcmV0dXJuIDA7Cj4gIH0KPiAgCj4gIHN0YXRpYyBpbnQKPiBkaWZmIC0tZ2l0IGEvZHJp dmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHJ2LmggYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRl bF9kcnYuaAo+IGluZGV4IDc5Nzc4NDNjZTI2YS4uZTVhNDM2YzMzMzA3IDEwMDY0NAo+IC0tLSBh L2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rydi5oCj4gKysrIGIvZHJpdmVycy9ncHUvZHJt L2k5MTUvaW50ZWxfZHJ2LmgKPiBAQCAtMjI1LDkgKzIyNSw5IEBAIHN0cnVjdCBpbnRlbF9lbmNv ZGVyIHsKPiAgCWVudW0gaW50ZWxfb3V0cHV0X3R5cGUgKCpjb21wdXRlX291dHB1dF90eXBlKShz dHJ1Y3QgaW50ZWxfZW5jb2RlciAqLAo+ICAJCQkJCQkgICAgICBzdHJ1Y3QgaW50ZWxfY3J0Y19z dGF0ZSAqLAo+ICAJCQkJCQkgICAgICBzdHJ1Y3QgZHJtX2Nvbm5lY3Rvcl9zdGF0ZSAqKTsKPiAt CWJvb2wgKCpjb21wdXRlX2NvbmZpZykoc3RydWN0IGludGVsX2VuY29kZXIgKiwKPiAtCQkJICAg ICAgIHN0cnVjdCBpbnRlbF9jcnRjX3N0YXRlICosCj4gLQkJCSAgICAgICBzdHJ1Y3QgZHJtX2Nv bm5lY3Rvcl9zdGF0ZSAqKTsKPiArCWludCAoKmNvbXB1dGVfY29uZmlnKShzdHJ1Y3QgaW50ZWxf ZW5jb2RlciAqLAo+ICsJCQkgICAgICBzdHJ1Y3QgaW50ZWxfY3J0Y19zdGF0ZSAqLAo+ICsJCQkg ICAgICBzdHJ1Y3QgZHJtX2Nvbm5lY3Rvcl9zdGF0ZSAqKTsKPiAgCXZvaWQgKCpwcmVfcGxsX2Vu YWJsZSkoc3RydWN0IGludGVsX2VuY29kZXIgKiwKPiAgCQkJICAgICAgIGNvbnN0IHN0cnVjdCBp bnRlbF9jcnRjX3N0YXRlICosCj4gIAkJCSAgICAgICBjb25zdCBzdHJ1Y3QgZHJtX2Nvbm5lY3Rv cl9zdGF0ZSAqKTsKPiBAQCAtMTgxNiw5ICsxODE2LDkgQEAgdm9pZCBpbnRlbF9kcF9zaW5rX3Nl dF9kZWNvbXByZXNzaW9uX3N0YXRlKHN0cnVjdCBpbnRlbF9kcCAqaW50ZWxfZHAsCj4gIHZvaWQg aW50ZWxfZHBfZW5jb2Rlcl9yZXNldChzdHJ1Y3QgZHJtX2VuY29kZXIgKmVuY29kZXIpOwo+ICB2 b2lkIGludGVsX2RwX2VuY29kZXJfc3VzcGVuZChzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqaW50ZWxf ZW5jb2Rlcik7Cj4gIHZvaWQgaW50ZWxfZHBfZW5jb2Rlcl9mbHVzaF93b3JrKHN0cnVjdCBkcm1f ZW5jb2RlciAqZW5jb2Rlcik7Cj4gLWJvb2wgaW50ZWxfZHBfY29tcHV0ZV9jb25maWcoc3RydWN0 IGludGVsX2VuY29kZXIgKmVuY29kZXIsCj4gLQkJCSAgICAgc3RydWN0IGludGVsX2NydGNfc3Rh dGUgKnBpcGVfY29uZmlnLAo+IC0JCQkgICAgIHN0cnVjdCBkcm1fY29ubmVjdG9yX3N0YXRlICpj b25uX3N0YXRlKTsKPiAraW50IGludGVsX2RwX2NvbXB1dGVfY29uZmlnKHN0cnVjdCBpbnRlbF9l bmNvZGVyICplbmNvZGVyLAo+ICsJCQkgICAgc3RydWN0IGludGVsX2NydGNfc3RhdGUgKnBpcGVf Y29uZmlnLAo+ICsJCQkgICAgc3RydWN0IGRybV9jb25uZWN0b3Jfc3RhdGUgKmNvbm5fc3RhdGUp Owo+ICBib29sIGludGVsX2RwX2lzX2VkcChzdHJ1Y3QgaW50ZWxfZHAgKmludGVsX2RwKTsKPiAg Ym9vbCBpbnRlbF9kcF9pc19wb3J0X2VkcChzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3By aXYsIGVudW0gcG9ydCBwb3J0KTsKPiAgZW51bSBpcnFyZXR1cm4gaW50ZWxfZHBfaHBkX3B1bHNl KHN0cnVjdCBpbnRlbF9kaWdpdGFsX3BvcnQgKmludGVsX2RpZ19wb3J0LAo+IEBAIC0xOTc4LDkg KzE5NzgsOSBAQCB2b2lkIGludGVsX2hkbWlfaW5pdChzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAq ZGV2X3ByaXYsIGk5MTVfcmVnX3QgaGRtaV9yZWcsCj4gIHZvaWQgaW50ZWxfaGRtaV9pbml0X2Nv bm5lY3RvcihzdHJ1Y3QgaW50ZWxfZGlnaXRhbF9wb3J0ICppbnRlbF9kaWdfcG9ydCwKPiAgCQkJ ICAgICAgIHN0cnVjdCBpbnRlbF9jb25uZWN0b3IgKmludGVsX2Nvbm5lY3Rvcik7Cj4gIHN0cnVj dCBpbnRlbF9oZG1pICplbmNfdG9faW50ZWxfaGRtaShzdHJ1Y3QgZHJtX2VuY29kZXIgKmVuY29k ZXIpOwo+IC1ib29sIGludGVsX2hkbWlfY29tcHV0ZV9jb25maWcoc3RydWN0IGludGVsX2VuY29k ZXIgKmVuY29kZXIsCj4gLQkJCSAgICAgICBzdHJ1Y3QgaW50ZWxfY3J0Y19zdGF0ZSAqcGlwZV9j b25maWcsCj4gLQkJCSAgICAgICBzdHJ1Y3QgZHJtX2Nvbm5lY3Rvcl9zdGF0ZSAqY29ubl9zdGF0 ZSk7Cj4gK2ludCBpbnRlbF9oZG1pX2NvbXB1dGVfY29uZmlnKHN0cnVjdCBpbnRlbF9lbmNvZGVy ICplbmNvZGVyLAo+ICsJCQkgICAgICBzdHJ1Y3QgaW50ZWxfY3J0Y19zdGF0ZSAqcGlwZV9jb25m aWcsCj4gKwkJCSAgICAgIHN0cnVjdCBkcm1fY29ubmVjdG9yX3N0YXRlICpjb25uX3N0YXRlKTsK PiAgYm9vbCBpbnRlbF9oZG1pX2hhbmRsZV9zaW5rX3NjcmFtYmxpbmcoc3RydWN0IGludGVsX2Vu Y29kZXIgKmVuY29kZXIsCj4gIAkJCQkgICAgICAgc3RydWN0IGRybV9jb25uZWN0b3IgKmNvbm5l Y3RvciwKPiAgCQkJCSAgICAgICBib29sIGhpZ2hfdG1kc19jbG9ja19yYXRpbywKPiBkaWZmIC0t Z2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHZvLmMgYi9kcml2ZXJzL2dwdS9kcm0v aTkxNS9pbnRlbF9kdm8uYwo+IGluZGV4IGJjM2MzY2I1N2VjNi4uMmFjNDg4NTAwZWE1IDEwMDY0 NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2R2by5jCj4gKysrIGIvZHJpdmVy cy9ncHUvZHJtL2k5MTUvaW50ZWxfZHZvLmMKPiBAQCAtMjM0LDkgKzIzNCw5IEBAIGludGVsX2R2 b19tb2RlX3ZhbGlkKHN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3IsCj4gIAlyZXR1cm4g aW50ZWxfZHZvLT5kZXYuZGV2X29wcy0+bW9kZV92YWxpZCgmaW50ZWxfZHZvLT5kZXYsIG1vZGUp Owo+ICB9Cj4gIAo+IC1zdGF0aWMgYm9vbCBpbnRlbF9kdm9fY29tcHV0ZV9jb25maWcoc3RydWN0 IGludGVsX2VuY29kZXIgKmVuY29kZXIsCj4gLQkJCQkgICAgIHN0cnVjdCBpbnRlbF9jcnRjX3N0 YXRlICpwaXBlX2NvbmZpZywKPiAtCQkJCSAgICAgc3RydWN0IGRybV9jb25uZWN0b3Jfc3RhdGUg KmNvbm5fc3RhdGUpCj4gK3N0YXRpYyBpbnQgaW50ZWxfZHZvX2NvbXB1dGVfY29uZmlnKHN0cnVj dCBpbnRlbF9lbmNvZGVyICplbmNvZGVyLAo+ICsJCQkJICAgIHN0cnVjdCBpbnRlbF9jcnRjX3N0 YXRlICpwaXBlX2NvbmZpZywKPiArCQkJCSAgICBzdHJ1Y3QgZHJtX2Nvbm5lY3Rvcl9zdGF0ZSAq Y29ubl9zdGF0ZSkKPiAgewo+ICAJc3RydWN0IGludGVsX2R2byAqaW50ZWxfZHZvID0gZW5jX3Rv X2R2byhlbmNvZGVyKTsKPiAgCWNvbnN0IHN0cnVjdCBkcm1fZGlzcGxheV9tb2RlICpmaXhlZF9t b2RlID0KPiBAQCAtMjUzLDEwICsyNTMsMTAgQEAgc3RhdGljIGJvb2wgaW50ZWxfZHZvX2NvbXB1 dGVfY29uZmlnKHN0cnVjdCBpbnRlbF9lbmNvZGVyICplbmNvZGVyLAo+ICAJCWludGVsX2ZpeGVk X3BhbmVsX21vZGUoZml4ZWRfbW9kZSwgYWRqdXN0ZWRfbW9kZSk7Cj4gIAo+ICAJaWYgKGFkanVz dGVkX21vZGUtPmZsYWdzICYgRFJNX01PREVfRkxBR19EQkxTQ0FOKQo+IC0JCXJldHVybiBmYWxz ZTsKPiArCQlyZXR1cm4gLUVJTlZBTDsKPiAgCj4gIAlwaXBlX2NvbmZpZy0+b3V0cHV0X2Zvcm1h dCA9IElOVEVMX09VVFBVVF9GT1JNQVRfUkdCOwoKUGxlYXNlIGFkZCBhIG5ld2xpbmUgaGVyZSB3 aGlsZSBhdCBpdC4KCj4gLQlyZXR1cm4gdHJ1ZTsKPiArCXJldHVybiAwOwo+ICB9Cj4gIAo+ICBz dGF0aWMgdm9pZCBpbnRlbF9kdm9fcHJlX2VuYWJsZShzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5j b2RlciwKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfaGRtaS5jIGIv ZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfaGRtaS5jCj4gaW5kZXggNzRmNDAyMWI3NjBjLi4x NDdhMzY3YzlhYmIgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfaGRt aS5jCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfaGRtaS5jCj4gQEAgLTE3MDQs OSArMTcwNCw5IEBAIGludGVsX2hkbWlfeWNiY3I0MjBfY29uZmlnKHN0cnVjdCBkcm1fY29ubmVj dG9yICpjb25uZWN0b3IsCj4gIAlyZXR1cm4gdHJ1ZTsKPiAgfQo+ICAKPiAtYm9vbCBpbnRlbF9o ZG1pX2NvbXB1dGVfY29uZmlnKHN0cnVjdCBpbnRlbF9lbmNvZGVyICplbmNvZGVyLAo+IC0JCQkg ICAgICAgc3RydWN0IGludGVsX2NydGNfc3RhdGUgKnBpcGVfY29uZmlnLAo+IC0JCQkgICAgICAg c3RydWN0IGRybV9jb25uZWN0b3Jfc3RhdGUgKmNvbm5fc3RhdGUpCj4gK2ludCBpbnRlbF9oZG1p X2NvbXB1dGVfY29uZmlnKHN0cnVjdCBpbnRlbF9lbmNvZGVyICplbmNvZGVyLAo+ICsJCQkgICAg ICBzdHJ1Y3QgaW50ZWxfY3J0Y19zdGF0ZSAqcGlwZV9jb25maWcsCj4gKwkJCSAgICAgIHN0cnVj dCBkcm1fY29ubmVjdG9yX3N0YXRlICpjb25uX3N0YXRlKQo+ICB7Cj4gIAlzdHJ1Y3QgaW50ZWxf aGRtaSAqaW50ZWxfaGRtaSA9IGVuY190b19pbnRlbF9oZG1pKCZlbmNvZGVyLT5iYXNlKTsKPiAg CXN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiA9IHRvX2k5MTUoZW5jb2Rlci0+YmFz ZS5kZXYpOwo+IEBAIC0xNzIyLDcgKzE3MjIsNyBAQCBib29sIGludGVsX2hkbWlfY29tcHV0ZV9j b25maWcoc3RydWN0IGludGVsX2VuY29kZXIgKmVuY29kZXIsCj4gIAlib29sIGZvcmNlX2R2aSA9 IGludGVsX2Nvbm5fc3RhdGUtPmZvcmNlX2F1ZGlvID09IEhETUlfQVVESU9fT0ZGX0RWSTsKPiAg Cj4gIAlpZiAoYWRqdXN0ZWRfbW9kZS0+ZmxhZ3MgJiBEUk1fTU9ERV9GTEFHX0RCTFNDQU4pCj4g LQkJcmV0dXJuIGZhbHNlOwo+ICsJCXJldHVybiAtRUlOVkFMOwo+ICAKPiAgCXBpcGVfY29uZmln LT5vdXRwdXRfZm9ybWF0ID0gSU5URUxfT1VUUFVUX0ZPUk1BVF9SR0I7Cj4gIAlwaXBlX2NvbmZp Zy0+aGFzX2hkbWlfc2luayA9ICFmb3JjZV9kdmkgJiYgaW50ZWxfaGRtaS0+aGFzX2hkbWlfc2lu azsKPiBAQCAtMTc1Myw3ICsxNzUzLDcgQEAgYm9vbCBpbnRlbF9oZG1pX2NvbXB1dGVfY29uZmln KHN0cnVjdCBpbnRlbF9lbmNvZGVyICplbmNvZGVyLAo+ICAJCQkJCQkmY2xvY2tfMTJicGMsICZj bG9ja18xMGJwYywKPiAgCQkJCQkJJmNsb2NrXzhicGMpKSB7Cj4gIAkJCURSTV9FUlJPUigiQ2Fu J3Qgc3VwcG9ydCBZQ0JDUjQyMCBvdXRwdXRcbiIpOwo+IC0JCQlyZXR1cm4gZmFsc2U7Cj4gKwkJ CXJldHVybiAtRUlOVkFMOwo+ICAJCX0KPiAgCX0KPiAgCgpMb29rcyBsaWtlIHlvdSBtaXNzZWQg dGhlIGlmKGhkbWlfcG9ydF9jbG9ja192YWxpZCgpKSBicmFuY2ggaGVyZS4KCj4gQEAgLTE4MjIs NyArMTgyMiw3IEBAIGJvb2wgaW50ZWxfaGRtaV9jb21wdXRlX2NvbmZpZyhzdHJ1Y3QgaW50ZWxf ZW5jb2RlciAqZW5jb2RlciwKPiAgCQl9Cj4gIAl9Cj4gIAo+IC0JcmV0dXJuIHRydWU7Cj4gKwly ZXR1cm4gMDsKPiAgfQo+ICAKPiAgc3RhdGljIHZvaWQKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9n cHUvZHJtL2k5MTUvaW50ZWxfbHZkcy5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfbHZk cy5jCj4gaW5kZXggYjAxYWFjYjVkNzNkLi40NmE1ZGZkNWNkZjcgMTAwNjQ0Cj4gLS0tIGEvZHJp dmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfbHZkcy5jCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5 MTUvaW50ZWxfbHZkcy5jCj4gQEAgLTM4MCw5ICszODAsOSBAQCBpbnRlbF9sdmRzX21vZGVfdmFs aWQoc3RydWN0IGRybV9jb25uZWN0b3IgKmNvbm5lY3RvciwKPiAgCXJldHVybiBNT0RFX09LOwo+ ICB9Cj4gIAo+IC1zdGF0aWMgYm9vbCBpbnRlbF9sdmRzX2NvbXB1dGVfY29uZmlnKHN0cnVjdCBp bnRlbF9lbmNvZGVyICppbnRlbF9lbmNvZGVyLAo+IC0JCQkJICAgICAgc3RydWN0IGludGVsX2Ny dGNfc3RhdGUgKnBpcGVfY29uZmlnLAo+IC0JCQkJICAgICAgc3RydWN0IGRybV9jb25uZWN0b3Jf c3RhdGUgKmNvbm5fc3RhdGUpCj4gK3N0YXRpYyBpbnQgaW50ZWxfbHZkc19jb21wdXRlX2NvbmZp ZyhzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqaW50ZWxfZW5jb2RlciwKPiArCQkJCSAgICAgc3RydWN0 IGludGVsX2NydGNfc3RhdGUgKnBpcGVfY29uZmlnLAo+ICsJCQkJICAgICBzdHJ1Y3QgZHJtX2Nv bm5lY3Rvcl9zdGF0ZSAqY29ubl9zdGF0ZSkKPiAgewo+ICAJc3RydWN0IGRybV9pOTE1X3ByaXZh dGUgKmRldl9wcml2ID0gdG9faTkxNShpbnRlbF9lbmNvZGVyLT5iYXNlLmRldik7Cj4gIAlzdHJ1 Y3QgaW50ZWxfbHZkc19lbmNvZGVyICpsdmRzX2VuY29kZXIgPQo+IEBAIC0zOTYsNyArMzk2LDcg QEAgc3RhdGljIGJvb2wgaW50ZWxfbHZkc19jb21wdXRlX2NvbmZpZyhzdHJ1Y3QgaW50ZWxfZW5j b2RlciAqaW50ZWxfZW5jb2RlciwKPiAgCS8qIFNob3VsZCBuZXZlciBoYXBwZW4hISAqLwo+ICAJ aWYgKElOVEVMX0dFTihkZXZfcHJpdikgPCA0ICYmIGludGVsX2NydGMtPnBpcGUgPT0gMCkgewo+ ICAJCURSTV9FUlJPUigiQ2FuJ3Qgc3VwcG9ydCBMVkRTIG9uIHBpcGUgQVxuIik7Cj4gLQkJcmV0 dXJuIGZhbHNlOwo+ICsJCXJldHVybiAtRUlOVkFMOwo+ICAJfQo+ICAKPiAgCWlmIChsdmRzX2Vu Y29kZXItPmEzX3Bvd2VyID09IExWRFNfQTNfUE9XRVJfVVApCj4gQEAgLTQyMiw3ICs0MjIsNyBA QCBzdGF0aWMgYm9vbCBpbnRlbF9sdmRzX2NvbXB1dGVfY29uZmlnKHN0cnVjdCBpbnRlbF9lbmNv ZGVyICppbnRlbF9lbmNvZGVyLAo+ICAJCQkgICAgICAgYWRqdXN0ZWRfbW9kZSk7Cj4gIAo+ICAJ aWYgKGFkanVzdGVkX21vZGUtPmZsYWdzICYgRFJNX01PREVfRkxBR19EQkxTQ0FOKQo+IC0JCXJl dHVybiBmYWxzZTsKPiArCQlyZXR1cm4gLUVJTlZBTDsKPiAgCj4gIAlpZiAoSEFTX1BDSF9TUExJ VChkZXZfcHJpdikpIHsKPiAgCQlwaXBlX2NvbmZpZy0+aGFzX3BjaF9lbmNvZGVyID0gdHJ1ZTsK PiBAQCAtNDQxLDcgKzQ0MSw3IEBAIHN0YXRpYyBib29sIGludGVsX2x2ZHNfY29tcHV0ZV9jb25m aWcoc3RydWN0IGludGVsX2VuY29kZXIgKmludGVsX2VuY29kZXIsCj4gIAkgKiB1c2VyJ3MgcmVx dWVzdGVkIHJlZnJlc2ggcmF0ZS4KPiAgCSAqLwo+ICAKPiAtCXJldHVybiB0cnVlOwo+ICsJcmV0 dXJuIDA7Cj4gIH0KPiAgCj4gIHN0YXRpYyBlbnVtIGRybV9jb25uZWN0b3Jfc3RhdHVzCj4gZGlm ZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3Nkdm8uYyBiL2RyaXZlcnMvZ3B1 L2RybS9pOTE1L2ludGVsX3Nkdm8uYwo+IGluZGV4IDRkYjdhZWZhODhmOS4uZGYyZDgzMGE3NDA1 IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3Nkdm8uYwo+ICsrKyBi L2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3Nkdm8uYwo+IEBAIC0xMTA3LDkgKzExMDcsOSBA QCBzdGF0aWMgdm9pZCBpOXh4X2FkanVzdF9zZHZvX3R2X2Nsb2NrKHN0cnVjdCBpbnRlbF9jcnRj X3N0YXRlICpwaXBlX2NvbmZpZykKPiAgCXBpcGVfY29uZmlnLT5jbG9ja19zZXQgPSB0cnVlOwo+ ICB9Cj4gIAo+IC1zdGF0aWMgYm9vbCBpbnRlbF9zZHZvX2NvbXB1dGVfY29uZmlnKHN0cnVjdCBp bnRlbF9lbmNvZGVyICplbmNvZGVyLAo+IC0JCQkJICAgICAgc3RydWN0IGludGVsX2NydGNfc3Rh dGUgKnBpcGVfY29uZmlnLAo+IC0JCQkJICAgICAgc3RydWN0IGRybV9jb25uZWN0b3Jfc3RhdGUg KmNvbm5fc3RhdGUpCj4gK3N0YXRpYyBpbnQgaW50ZWxfc2R2b19jb21wdXRlX2NvbmZpZyhzdHJ1 Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2RlciwKPiArCQkJCSAgICAgc3RydWN0IGludGVsX2NydGNf c3RhdGUgKnBpcGVfY29uZmlnLAo+ICsJCQkJICAgICBzdHJ1Y3QgZHJtX2Nvbm5lY3Rvcl9zdGF0 ZSAqY29ubl9zdGF0ZSkKPiAgewo+ICAJc3RydWN0IGludGVsX3Nkdm8gKmludGVsX3Nkdm8gPSB0 b19zZHZvKGVuY29kZXIpOwo+ICAJc3RydWN0IGludGVsX3Nkdm9fY29ubmVjdG9yX3N0YXRlICpp bnRlbF9zZHZvX3N0YXRlID0KPiBAQCAtMTEzNCw3ICsxMTM0LDcgQEAgc3RhdGljIGJvb2wgaW50 ZWxfc2R2b19jb21wdXRlX2NvbmZpZyhzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2RlciwKPiAg CSAqLwo+ICAJaWYgKElTX1RWKGludGVsX3Nkdm9fY29ubmVjdG9yKSkgewo+ICAJCWlmICghaW50 ZWxfc2R2b19zZXRfb3V0cHV0X3RpbWluZ3NfZnJvbV9tb2RlKGludGVsX3Nkdm8sIG1vZGUpKQo+ IC0JCQlyZXR1cm4gZmFsc2U7Cj4gKwkJCXJldHVybiAtRUlOVkFMOwo+ICAKPiAgCQkodm9pZCkg aW50ZWxfc2R2b19nZXRfcHJlZmVycmVkX2lucHV0X21vZGUoaW50ZWxfc2R2bywKPiAgCQkJCQkJ CSAgIGludGVsX3Nkdm9fY29ubmVjdG9yLAo+IEBAIC0xMTQ0LDcgKzExNDQsNyBAQCBzdGF0aWMg Ym9vbCBpbnRlbF9zZHZvX2NvbXB1dGVfY29uZmlnKHN0cnVjdCBpbnRlbF9lbmNvZGVyICplbmNv ZGVyLAo+ICAJfSBlbHNlIGlmIChJU19MVkRTKGludGVsX3Nkdm9fY29ubmVjdG9yKSkgewo+ICAJ CWlmICghaW50ZWxfc2R2b19zZXRfb3V0cHV0X3RpbWluZ3NfZnJvbV9tb2RlKGludGVsX3Nkdm8s Cj4gIAkJCQkJCQkgICAgIGludGVsX3Nkdm9fY29ubmVjdG9yLT5iYXNlLnBhbmVsLmZpeGVkX21v ZGUpKQo+IC0JCQlyZXR1cm4gZmFsc2U7Cj4gKwkJCXJldHVybiAtRUlOVkFMOwo+ICAKPiAgCQko dm9pZCkgaW50ZWxfc2R2b19nZXRfcHJlZmVycmVkX2lucHV0X21vZGUoaW50ZWxfc2R2bywKPiAg CQkJCQkJCSAgIGludGVsX3Nkdm9fY29ubmVjdG9yLAo+IEBAIC0xMTUzLDcgKzExNTMsNyBAQCBz dGF0aWMgYm9vbCBpbnRlbF9zZHZvX2NvbXB1dGVfY29uZmlnKHN0cnVjdCBpbnRlbF9lbmNvZGVy ICplbmNvZGVyLAo+ICAJfQo+ICAKPiAgCWlmIChhZGp1c3RlZF9tb2RlLT5mbGFncyAmIERSTV9N T0RFX0ZMQUdfREJMU0NBTikKPiAtCQlyZXR1cm4gZmFsc2U7Cj4gKwkJcmV0dXJuIC1FSU5WQUw7 Cj4gIAo+ICAJLyoKPiAgCSAqIE1ha2UgdGhlIENSVEMgY29kZSBmYWN0b3IgaW4gdGhlIFNEVk8g cGl4ZWwgbXVsdGlwbGllci4gIFRoZQo+IEBAIC0xMTkzLDcgKzExOTMsNyBAQCBzdGF0aWMgYm9v bCBpbnRlbF9zZHZvX2NvbXB1dGVfY29uZmlnKHN0cnVjdCBpbnRlbF9lbmNvZGVyICplbmNvZGVy LAo+ICAJaWYgKGludGVsX3Nkdm9fY29ubmVjdG9yLT5pc19oZG1pKQo+ICAJCWFkanVzdGVkX21v ZGUtPnBpY3R1cmVfYXNwZWN0X3JhdGlvID0gY29ubl9zdGF0ZS0+cGljdHVyZV9hc3BlY3RfcmF0 aW87Cj4gIAo+IC0JcmV0dXJuIHRydWU7Cj4gKwlyZXR1cm4gMDsKPiAgfQo+ICAKPiAgI2RlZmlu ZSBVUERBVEVfUFJPUEVSVFkoaW5wdXQsIE5BTUUpIFwKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9n cHUvZHJtL2k5MTUvaW50ZWxfdHYuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3R2LmMK PiBpbmRleCBkN2E0MTRjZTI3NzQuLmJkNTUzNmYwZWM5MiAxMDA2NDQKPiAtLS0gYS9kcml2ZXJz L2dwdS9kcm0vaTkxNS9pbnRlbF90di5jCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50 ZWxfdHYuYwo+IEBAIC04NjksNyArODY5LDcgQEAgaW50ZWxfdHZfZ2V0X2NvbmZpZyhzdHJ1Y3Qg aW50ZWxfZW5jb2RlciAqZW5jb2RlciwKPiAgCXBpcGVfY29uZmlnLT5iYXNlLmFkanVzdGVkX21v ZGUuY3J0Y19jbG9jayA9IHBpcGVfY29uZmlnLT5wb3J0X2Nsb2NrOwo+ICB9Cj4gIAo+IC1zdGF0 aWMgYm9vbAo+ICtzdGF0aWMgaW50Cj4gIGludGVsX3R2X2NvbXB1dGVfY29uZmlnKHN0cnVjdCBp bnRlbF9lbmNvZGVyICplbmNvZGVyLAo+ICAJCQlzdHJ1Y3QgaW50ZWxfY3J0Y19zdGF0ZSAqcGlw ZV9jb25maWcsCj4gIAkJCXN0cnVjdCBkcm1fY29ubmVjdG9yX3N0YXRlICpjb25uX3N0YXRlKQo+ IEBAIC04NzksMTAgKzg3OSwxMCBAQCBpbnRlbF90dl9jb21wdXRlX2NvbmZpZyhzdHJ1Y3QgaW50 ZWxfZW5jb2RlciAqZW5jb2RlciwKPiAgCQkmcGlwZV9jb25maWctPmJhc2UuYWRqdXN0ZWRfbW9k ZTsKPiAgCj4gIAlpZiAoIXR2X21vZGUpCj4gLQkJcmV0dXJuIGZhbHNlOwo+ICsJCXJldHVybiAt RUlOVkFMOwo+ICAKPiAgCWlmIChhZGp1c3RlZF9tb2RlLT5mbGFncyAmIERSTV9NT0RFX0ZMQUdf REJMU0NBTikKPiAtCQlyZXR1cm4gZmFsc2U7Cj4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4gIAo+ICAJ cGlwZV9jb25maWctPm91dHB1dF9mb3JtYXQgPSBJTlRFTF9PVVRQVVRfRk9STUFUX1JHQjsKPiAg CWFkanVzdGVkX21vZGUtPmNydGNfY2xvY2sgPSB0dl9tb2RlLT5jbG9jazsKPiBAQCAtODk3LDcg Kzg5Nyw3IEBAIGludGVsX3R2X2NvbXB1dGVfY29uZmlnKHN0cnVjdCBpbnRlbF9lbmNvZGVyICpl bmNvZGVyLAo+ICAJICogb3Igd2hldGhlciB1c2Vyc3BhY2UgaXMgZG9pbmcgc29tZXRoaW5nIHN0 dXBpZC4KPiAgCSAqLwo+ICAKPiAtCXJldHVybiB0cnVlOwo+ICsJcmV0dXJuIDA7Cj4gIH0KPiAg Cj4gIHN0YXRpYyB2b2lkCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L3Zsdl9k c2kuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L3Zsdl9kc2kuYwo+IGluZGV4IGQxMTZmZWFkODUx NC4uYzI0N2NlNzRiNzFhIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L3Zsdl9k c2kuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L3Zsdl9kc2kuYwo+IEBAIC0yNTYsOSAr MjU2LDkgQEAgc3RhdGljIHZvaWQgYmFuZF9nYXBfcmVzZXQoc3RydWN0IGRybV9pOTE1X3ByaXZh dGUgKmRldl9wcml2KQo+ICAJbXV0ZXhfdW5sb2NrKCZkZXZfcHJpdi0+c2JfbG9jayk7Cj4gIH0K PiAgCj4gLXN0YXRpYyBib29sIGludGVsX2RzaV9jb21wdXRlX2NvbmZpZyhzdHJ1Y3QgaW50ZWxf ZW5jb2RlciAqZW5jb2RlciwKPiAtCQkJCSAgICAgc3RydWN0IGludGVsX2NydGNfc3RhdGUgKnBp cGVfY29uZmlnLAo+IC0JCQkJICAgICBzdHJ1Y3QgZHJtX2Nvbm5lY3Rvcl9zdGF0ZSAqY29ubl9z dGF0ZSkKPiArc3RhdGljIGludCBpbnRlbF9kc2lfY29tcHV0ZV9jb25maWcoc3RydWN0IGludGVs X2VuY29kZXIgKmVuY29kZXIsCj4gKwkJCQkgICAgc3RydWN0IGludGVsX2NydGNfc3RhdGUgKnBp cGVfY29uZmlnLAo+ICsJCQkJICAgIHN0cnVjdCBkcm1fY29ubmVjdG9yX3N0YXRlICpjb25uX3N0 YXRlKQo+ICB7Cj4gIAlzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYgPSB0b19pOTE1 KGVuY29kZXItPmJhc2UuZGV2KTsKPiAgCXN0cnVjdCBpbnRlbF9kc2kgKmludGVsX2RzaSA9IGNv bnRhaW5lcl9vZihlbmNvZGVyLCBzdHJ1Y3QgaW50ZWxfZHNpLAo+IEBAIC0yODQsNyArMjg0LDcg QEAgc3RhdGljIGJvb2wgaW50ZWxfZHNpX2NvbXB1dGVfY29uZmlnKHN0cnVjdCBpbnRlbF9lbmNv ZGVyICplbmNvZGVyLAo+ICAJfQo+ICAKPiAgCWlmIChhZGp1c3RlZF9tb2RlLT5mbGFncyAmIERS TV9NT0RFX0ZMQUdfREJMU0NBTikKPiAtCQlyZXR1cm4gZmFsc2U7Cj4gKwkJcmV0dXJuIC1FSU5W QUw7Cj4gIAo+ICAJLyogRFNJIHVzZXMgc2hvcnQgcGFja2V0cyBmb3Igc3luYyBldmVudHMsIHNv IGNsZWFyIG1vZGUgZmxhZ3MgZm9yIERTSSAqLwo+ICAJYWRqdXN0ZWRfbW9kZS0+ZmxhZ3MgPSAw Owo+IEBAIC0zMDIsMTYgKzMwMiwxNiBAQCBzdGF0aWMgYm9vbCBpbnRlbF9kc2lfY29tcHV0ZV9j b25maWcoc3RydWN0IGludGVsX2VuY29kZXIgKmVuY29kZXIsCj4gIAo+ICAJCXJldCA9IGJ4dF9k c2lfcGxsX2NvbXB1dGUoZW5jb2RlciwgcGlwZV9jb25maWcpOwo+ICAJCWlmIChyZXQpCj4gLQkJ CXJldHVybiBmYWxzZTsKPiArCQkJcmV0dXJuIC1FSU5WQUw7Cj4gIAl9IGVsc2Ugewo+ICAJCXJl dCA9IHZsdl9kc2lfcGxsX2NvbXB1dGUoZW5jb2RlciwgcGlwZV9jb25maWcpOwo+ICAJCWlmIChy ZXQpCj4gLQkJCXJldHVybiBmYWxzZTsKPiArCQkJcmV0dXJuIC1FSU5WQUw7Cj4gIAl9Cj4gIAo+ ICAJcGlwZV9jb25maWctPmNsb2NrX3NldCA9IHRydWU7Cj4gIAo+IC0JcmV0dXJuIHRydWU7Cj4g KwlyZXR1cm4gMDsKPiAgfQo+ICAKPiAgc3RhdGljIGJvb2wgZ2xrX2RzaV9lbmFibGVfaW8oc3Ry dWN0IGludGVsX2VuY29kZXIgKmVuY29kZXIpCj4gLS0gCj4gMi4yMC4xCgotLSAKVmlsbGUgU3ly asOkbMOkCkludGVsCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fCmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9y ZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZl bAo= 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=-8.5 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_PASS,URIBL_BLOCKED, USER_AGENT_MUTT 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 8627AC43387 for ; Tue, 15 Jan 2019 13:18:13 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 359F620657 for ; Tue, 15 Jan 2019 13:18:13 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1729639AbfAONSL (ORCPT ); Tue, 15 Jan 2019 08:18:11 -0500 Received: from mga09.intel.com ([134.134.136.24]:49248 "EHLO mga09.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1729626AbfAONSL (ORCPT ); Tue, 15 Jan 2019 08:18:11 -0500 X-Amp-Result: UNSCANNABLE X-Amp-File-Uploaded: False Received: from fmsmga008.fm.intel.com ([10.253.24.58]) by orsmga102.jf.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 15 Jan 2019 05:18:09 -0800 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.56,481,1539673200"; d="scan'208";a="116907910" Received: from stinkbox.fi.intel.com (HELO stinkbox) ([10.237.72.174]) by fmsmga008.fm.intel.com with SMTP; 15 Jan 2019 05:18:06 -0800 Received: by stinkbox (sSMTP sendmail emulation); Tue, 15 Jan 2019 15:18:05 +0200 Date: Tue, 15 Jan 2019 15:18:05 +0200 From: Ville =?iso-8859-1?Q?Syrj=E4l=E4?= To: Lyude Paul Cc: intel-gfx@lists.freedesktop.org, Jani Nikula , Joonas Lahtinen , Rodrigo Vivi , David Airlie , Daniel Vetter , dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org Subject: Re: [PATCH] drm/i915: Pass down rc in intel_encoder->compute_config() Message-ID: <20190115131805.GH20097@intel.com> References: <20190114222931.25711-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: <20190114222931.25711-1-lyude@redhat.com> User-Agent: Mutt/1.10.1 (2018-07-13) Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Mon, Jan 14, 2019 at 05:29:31PM -0500, Lyude Paul wrote: > Something that I completely missed when implementing the new MST VCPI > atomic helpers is that with those helpers, there's technically a chance > of us having to grab additional modeset locks in ->compute_config() and > furthermore, that means we have the potential to hit a normal modeset > deadlock. However, because ->compute_config() only returns a bool this > means we can't return -EDEADLK when we need to drop locks and try again > which means we end up just failing the atomic check permanently. Whoops. > > So, fix this by modifying ->compute_config() to pass down an actual > error code instead of a bool so that the atomic check can be restarted > on modeset deadlocks. > > Thanks to Ville Syrjälä for pointing this out! > > Signed-off-by: Lyude Paul > Cc: Ville Syrjälä > Fixes: eceae1472467 ("drm/dp_mst: Start tracking per-port VCPI allocations") > Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=109320 > --- > drivers/gpu/drm/i915/icl_dsi.c | 8 +++---- > drivers/gpu/drm/i915/intel_crt.c | 34 ++++++++++++++-------------- > drivers/gpu/drm/i915/intel_ddi.c | 6 ++--- > drivers/gpu/drm/i915/intel_display.c | 11 +++++---- > drivers/gpu/drm/i915/intel_dp.c | 32 +++++++++++++------------- > drivers/gpu/drm/i915/intel_dp_mst.c | 12 +++++----- > drivers/gpu/drm/i915/intel_drv.h | 18 +++++++-------- > drivers/gpu/drm/i915/intel_dvo.c | 10 ++++---- > drivers/gpu/drm/i915/intel_hdmi.c | 12 +++++----- > drivers/gpu/drm/i915/intel_lvds.c | 12 +++++----- > drivers/gpu/drm/i915/intel_sdvo.c | 14 ++++++------ > drivers/gpu/drm/i915/intel_tv.c | 8 +++---- > drivers/gpu/drm/i915/vlv_dsi.c | 14 ++++++------ > 13 files changed, 97 insertions(+), 94 deletions(-) > > diff --git a/drivers/gpu/drm/i915/icl_dsi.c b/drivers/gpu/drm/i915/icl_dsi.c > index f3a5f03646ce..355b48d1c937 100644 > --- a/drivers/gpu/drm/i915/icl_dsi.c > +++ b/drivers/gpu/drm/i915/icl_dsi.c > @@ -1188,9 +1188,9 @@ static void gen11_dsi_get_config(struct intel_encoder *encoder, > pipe_config->output_types |= BIT(INTEL_OUTPUT_DSI); > } > > -static bool gen11_dsi_compute_config(struct intel_encoder *encoder, > - struct intel_crtc_state *pipe_config, > - struct drm_connector_state *conn_state) > +static int gen11_dsi_compute_config(struct intel_encoder *encoder, > + struct intel_crtc_state *pipe_config, > + struct drm_connector_state *conn_state) > { > struct intel_dsi *intel_dsi = container_of(encoder, struct intel_dsi, > base); > @@ -1215,7 +1215,7 @@ static bool gen11_dsi_compute_config(struct intel_encoder *encoder, > pipe_config->clock_set = true; > pipe_config->port_clock = intel_dsi_bitrate(intel_dsi) / 5; > > - return true; > + return 0; > } > > static u64 gen11_dsi_get_power_domains(struct intel_encoder *encoder, > diff --git a/drivers/gpu/drm/i915/intel_crt.c b/drivers/gpu/drm/i915/intel_crt.c > index 33bd2addcbdd..625794883433 100644 > --- a/drivers/gpu/drm/i915/intel_crt.c > +++ b/drivers/gpu/drm/i915/intel_crt.c > @@ -345,51 +345,51 @@ intel_crt_mode_valid(struct drm_connector *connector, > return MODE_OK; > } > > -static bool intel_crt_compute_config(struct intel_encoder *encoder, > - struct intel_crtc_state *pipe_config, > - struct drm_connector_state *conn_state) > +static int intel_crt_compute_config(struct intel_encoder *encoder, > + struct intel_crtc_state *pipe_config, > + struct drm_connector_state *conn_state) > { > struct drm_display_mode *adjusted_mode = > &pipe_config->base.adjusted_mode; > > if (adjusted_mode->flags & DRM_MODE_FLAG_DBLSCAN) > - return false; > + return -EINVAL; > > pipe_config->output_format = INTEL_OUTPUT_FORMAT_RGB; Please add a newline here while at it. > - return true; > + return 0; > } > > -static bool pch_crt_compute_config(struct intel_encoder *encoder, > - struct intel_crtc_state *pipe_config, > - struct drm_connector_state *conn_state) > +static int pch_crt_compute_config(struct intel_encoder *encoder, > + struct intel_crtc_state *pipe_config, > + struct drm_connector_state *conn_state) > { > struct drm_display_mode *adjusted_mode = > &pipe_config->base.adjusted_mode; > > if (adjusted_mode->flags & DRM_MODE_FLAG_DBLSCAN) > - return false; > + return -EINVAL; > > pipe_config->has_pch_encoder = true; > pipe_config->output_format = INTEL_OUTPUT_FORMAT_RGB; > > - return true; > + return 0; > } > > -static bool hsw_crt_compute_config(struct intel_encoder *encoder, > - struct intel_crtc_state *pipe_config, > - struct drm_connector_state *conn_state) > +static int hsw_crt_compute_config(struct intel_encoder *encoder, > + struct intel_crtc_state *pipe_config, > + struct drm_connector_state *conn_state) > { > struct drm_i915_private *dev_priv = to_i915(encoder->base.dev); > struct drm_display_mode *adjusted_mode = > &pipe_config->base.adjusted_mode; > > if (adjusted_mode->flags & DRM_MODE_FLAG_DBLSCAN) > - return false; > + return -EINVAL; > > /* HSW/BDW FDI limited to 4k */ > if (adjusted_mode->crtc_hdisplay > 4096 || > adjusted_mode->crtc_hblank_start > 4096) > - return false; > + return -ENOSPC; I'd go with -EINVAL here. > > pipe_config->has_pch_encoder = true; > pipe_config->output_format = INTEL_OUTPUT_FORMAT_RGB; > @@ -398,7 +398,7 @@ static bool hsw_crt_compute_config(struct intel_encoder *encoder, > if (HAS_PCH_LPT(dev_priv)) { > if (pipe_config->bw_constrained && pipe_config->pipe_bpp < 24) { > DRM_DEBUG_KMS("LPT only supports 24bpp\n"); > - return false; > + return -EINVAL; > } > > pipe_config->pipe_bpp = 24; > @@ -407,7 +407,7 @@ static bool hsw_crt_compute_config(struct intel_encoder *encoder, > /* FDI must always be 2.7 GHz */ > pipe_config->port_clock = 135000 * 2; > > - return true; > + return 0; > } > > static bool intel_ironlake_crt_detect_hotplug(struct drm_connector *connector) > diff --git a/drivers/gpu/drm/i915/intel_ddi.c b/drivers/gpu/drm/i915/intel_ddi.c > index 7f3cd055de50..ce44744a5f9d 100644 > --- a/drivers/gpu/drm/i915/intel_ddi.c > +++ b/drivers/gpu/drm/i915/intel_ddi.c > @@ -3837,9 +3837,9 @@ intel_ddi_compute_output_type(struct intel_encoder *encoder, > } > } > > -static bool intel_ddi_compute_config(struct intel_encoder *encoder, > - struct intel_crtc_state *pipe_config, > - struct drm_connector_state *conn_state) > +static int intel_ddi_compute_config(struct intel_encoder *encoder, > + struct intel_crtc_state *pipe_config, > + struct drm_connector_state *conn_state) > { > struct drm_i915_private *dev_priv = to_i915(encoder->base.dev); > enum port port = encoder->port; Hmm. At first glance I was rather confused that you didn't change anything here, but indeed this guy already does what we want. > diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c > index ee85ca84d0f7..f6324fe74b19 100644 > --- a/drivers/gpu/drm/i915/intel_display.c > +++ b/drivers/gpu/drm/i915/intel_display.c > @@ -11550,10 +11550,13 @@ intel_modeset_pipe_config(struct drm_crtc *crtc, > continue; > > encoder = to_intel_encoder(connector_state->best_encoder); > - > - if (!(encoder->compute_config(encoder, pipe_config, connector_state))) { > - DRM_DEBUG_KMS("Encoder config failure\n"); > - return -EINVAL; > + ret = encoder->compute_config(encoder, pipe_config, > + connector_state); > + if (ret < 0) { > + if (ret != -EDEADLK) > + DRM_DEBUG_KMS("Encoder config failure: %d\n", > + ret); > + return ret; > } > } > > diff --git a/drivers/gpu/drm/i915/intel_dp.c b/drivers/gpu/drm/i915/intel_dp.c > index 0a3ac98a779e..9e4c2c6bb1f0 100644 > --- a/drivers/gpu/drm/i915/intel_dp.c > +++ b/drivers/gpu/drm/i915/intel_dp.c > @@ -1905,10 +1905,10 @@ static int intel_dp_dsc_compute_bpp(struct intel_dp *intel_dp, u8 dsc_max_bpc) > return 0; > } > > -static bool intel_dp_dsc_compute_config(struct intel_dp *intel_dp, > - struct intel_crtc_state *pipe_config, > - struct drm_connector_state *conn_state, > - struct link_config_limits *limits) > +static int intel_dp_dsc_compute_config(struct intel_dp *intel_dp, > + struct intel_crtc_state *pipe_config, > + struct drm_connector_state *conn_state, > + struct link_config_limits *limits) > { > struct intel_digital_port *dig_port = dp_to_dig_port(intel_dp); > struct drm_i915_private *dev_priv = to_i915(dig_port->base.base.dev); > @@ -1917,7 +1917,7 @@ static bool intel_dp_dsc_compute_config(struct intel_dp *intel_dp, > int pipe_bpp; > > if (!intel_dp_supports_dsc(intel_dp, pipe_config)) > - return false; > + return -EINVAL; > > dsc_max_bpc = min_t(u8, DP_DSC_MAX_SUPPORTED_BPC, > conn_state->max_requested_bpc); > @@ -1925,7 +1925,7 @@ static bool intel_dp_dsc_compute_config(struct intel_dp *intel_dp, > pipe_bpp = intel_dp_dsc_compute_bpp(intel_dp, dsc_max_bpc); > if (pipe_bpp < DP_DSC_MIN_SUPPORTED_BPC * 3) { > DRM_DEBUG_KMS("No DSC support for less than 8bpc\n"); > - return false; > + return -EINVAL; > } > > /* > @@ -1959,7 +1959,7 @@ static bool intel_dp_dsc_compute_config(struct intel_dp *intel_dp, > adjusted_mode->crtc_hdisplay); > if (!dsc_max_output_bpp || !dsc_dp_slice_count) { > DRM_DEBUG_KMS("Compressed BPP/Slice Count not supported\n"); > - return false; > + return -EINVAL; > } > pipe_config->dsc_params.compressed_bpp = min_t(u16, > dsc_max_output_bpp >> 4, > @@ -1976,7 +1976,7 @@ static bool intel_dp_dsc_compute_config(struct intel_dp *intel_dp, > pipe_config->dsc_params.dsc_split = true; > } else { > DRM_DEBUG_KMS("Cannot split stream to use 2 VDSC instances\n"); > - return false; > + return -EINVAL; > } > } > if (intel_dp_compute_dsc_params(intel_dp, pipe_config) < 0) { > @@ -1984,7 +1984,7 @@ static bool intel_dp_dsc_compute_config(struct intel_dp *intel_dp, > "Compressed BPP = %d\n", > pipe_config->pipe_bpp, > pipe_config->dsc_params.compressed_bpp); > - return false; > + return -EINVAL; Here we can propagate the return value from intel_dp_compute_dsc_params() upwards. > } > pipe_config->dsc_params.compression_enable = true; > DRM_DEBUG_KMS("DP DSC computed with Input Bpp = %d " > @@ -1993,7 +1993,7 @@ static bool intel_dp_dsc_compute_config(struct intel_dp *intel_dp, > pipe_config->dsc_params.compressed_bpp, > pipe_config->dsc_params.slice_count); > > - return true; > + return 0; > } > > static bool > @@ -2094,7 +2094,7 @@ intel_dp_compute_link_config(struct intel_encoder *encoder, > return true; > } You changed intel_dp_dsc_compute_config() but didn't update the caller? Probably best to change all the intel_dp_compute_link_config*() functions to return an int as well for consistency. > > -bool > +int > intel_dp_compute_config(struct intel_encoder *encoder, > struct intel_crtc_state *pipe_config, > struct drm_connector_state *conn_state) > @@ -2147,20 +2147,20 @@ intel_dp_compute_config(struct intel_encoder *encoder, Oh wow. I just noticed that a1b2278e4dfc ("drm/i915: skylake panel fitting using shared scalers") already assumed that .compute_config() returns an int. That might even explain some oddball scaler fails people have seen. > } > > if (adjusted_mode->flags & DRM_MODE_FLAG_DBLSCAN) > - return false; > + return -EINVAL; > > if (HAS_GMCH_DISPLAY(dev_priv) && > adjusted_mode->flags & DRM_MODE_FLAG_INTERLACE) > - return false; > + return -EINVAL; > > if (adjusted_mode->flags & DRM_MODE_FLAG_DBLCLK) > - return false; > + return -EINVAL; > > pipe_config->fec_enable = !intel_dp_is_edp(intel_dp) && > intel_dp_supports_fec(intel_dp, pipe_config); > > if (!intel_dp_compute_link_config(encoder, pipe_config, conn_state)) > - return false; > + return -ENOSPC; > > if (intel_conn_state->broadcast_rgb == INTEL_BROADCAST_RGB_AUTO) { > /* > @@ -2208,7 +2208,7 @@ intel_dp_compute_config(struct intel_encoder *encoder, > > intel_psr_compute_config(intel_dp, pipe_config); > > - return true; > + return 0; > } > > void intel_dp_set_link_params(struct intel_dp *intel_dp, > diff --git a/drivers/gpu/drm/i915/intel_dp_mst.c b/drivers/gpu/drm/i915/intel_dp_mst.c > index 3f83429333c7..a19699023db1 100644 > --- a/drivers/gpu/drm/i915/intel_dp_mst.c > +++ b/drivers/gpu/drm/i915/intel_dp_mst.c > @@ -29,9 +29,9 @@ > #include > #include > > -static bool intel_dp_mst_compute_config(struct intel_encoder *encoder, > - struct intel_crtc_state *pipe_config, > - struct drm_connector_state *conn_state) > +static int intel_dp_mst_compute_config(struct intel_encoder *encoder, > + struct intel_crtc_state *pipe_config, > + struct drm_connector_state *conn_state) > { > struct drm_i915_private *dev_priv = to_i915(encoder->base.dev); > struct intel_dp_mst_encoder *intel_mst = enc_to_mst(&encoder->base); > @@ -52,7 +52,7 @@ static bool intel_dp_mst_compute_config(struct intel_encoder *encoder, > DP_DPCD_QUIRK_CONSTANT_N); > > if (adjusted_mode->flags & DRM_MODE_FLAG_DBLSCAN) > - return false; > + return -EINVAL; > > pipe_config->output_format = INTEL_OUTPUT_FORMAT_RGB; > pipe_config->has_pch_encoder = false; > @@ -89,7 +89,7 @@ static bool intel_dp_mst_compute_config(struct intel_encoder *encoder, > if (slots < 0) { > DRM_DEBUG_KMS("failed finding vcpi slots:%d\n", > slots); > - return false; > + return slots; > } > } > > @@ -107,7 +107,7 @@ static bool intel_dp_mst_compute_config(struct intel_encoder *encoder, > > intel_ddi_compute_min_voltage_level(dev_priv, pipe_config); > > - return true; > + return 0; > } > > static int > diff --git a/drivers/gpu/drm/i915/intel_drv.h b/drivers/gpu/drm/i915/intel_drv.h > index 7977843ce26a..e5a436c33307 100644 > --- a/drivers/gpu/drm/i915/intel_drv.h > +++ b/drivers/gpu/drm/i915/intel_drv.h > @@ -225,9 +225,9 @@ struct intel_encoder { > enum intel_output_type (*compute_output_type)(struct intel_encoder *, > struct intel_crtc_state *, > struct drm_connector_state *); > - bool (*compute_config)(struct intel_encoder *, > - struct intel_crtc_state *, > - struct drm_connector_state *); > + int (*compute_config)(struct intel_encoder *, > + struct intel_crtc_state *, > + struct drm_connector_state *); > void (*pre_pll_enable)(struct intel_encoder *, > const struct intel_crtc_state *, > const struct drm_connector_state *); > @@ -1816,9 +1816,9 @@ void intel_dp_sink_set_decompression_state(struct intel_dp *intel_dp, > void intel_dp_encoder_reset(struct drm_encoder *encoder); > void intel_dp_encoder_suspend(struct intel_encoder *intel_encoder); > void intel_dp_encoder_flush_work(struct drm_encoder *encoder); > -bool intel_dp_compute_config(struct intel_encoder *encoder, > - struct intel_crtc_state *pipe_config, > - struct drm_connector_state *conn_state); > +int intel_dp_compute_config(struct intel_encoder *encoder, > + struct intel_crtc_state *pipe_config, > + struct drm_connector_state *conn_state); > bool intel_dp_is_edp(struct intel_dp *intel_dp); > bool intel_dp_is_port_edp(struct drm_i915_private *dev_priv, enum port port); > enum irqreturn intel_dp_hpd_pulse(struct intel_digital_port *intel_dig_port, > @@ -1978,9 +1978,9 @@ void intel_hdmi_init(struct drm_i915_private *dev_priv, i915_reg_t hdmi_reg, > void intel_hdmi_init_connector(struct intel_digital_port *intel_dig_port, > struct intel_connector *intel_connector); > struct intel_hdmi *enc_to_intel_hdmi(struct drm_encoder *encoder); > -bool intel_hdmi_compute_config(struct intel_encoder *encoder, > - struct intel_crtc_state *pipe_config, > - struct drm_connector_state *conn_state); > +int intel_hdmi_compute_config(struct intel_encoder *encoder, > + struct intel_crtc_state *pipe_config, > + struct drm_connector_state *conn_state); > bool intel_hdmi_handle_sink_scrambling(struct intel_encoder *encoder, > struct drm_connector *connector, > bool high_tmds_clock_ratio, > diff --git a/drivers/gpu/drm/i915/intel_dvo.c b/drivers/gpu/drm/i915/intel_dvo.c > index bc3c3cb57ec6..2ac488500ea5 100644 > --- a/drivers/gpu/drm/i915/intel_dvo.c > +++ b/drivers/gpu/drm/i915/intel_dvo.c > @@ -234,9 +234,9 @@ intel_dvo_mode_valid(struct drm_connector *connector, > return intel_dvo->dev.dev_ops->mode_valid(&intel_dvo->dev, mode); > } > > -static bool intel_dvo_compute_config(struct intel_encoder *encoder, > - struct intel_crtc_state *pipe_config, > - struct drm_connector_state *conn_state) > +static int intel_dvo_compute_config(struct intel_encoder *encoder, > + struct intel_crtc_state *pipe_config, > + struct drm_connector_state *conn_state) > { > struct intel_dvo *intel_dvo = enc_to_dvo(encoder); > const struct drm_display_mode *fixed_mode = > @@ -253,10 +253,10 @@ static bool intel_dvo_compute_config(struct intel_encoder *encoder, > intel_fixed_panel_mode(fixed_mode, adjusted_mode); > > if (adjusted_mode->flags & DRM_MODE_FLAG_DBLSCAN) > - return false; > + return -EINVAL; > > pipe_config->output_format = INTEL_OUTPUT_FORMAT_RGB; Please add a newline here while at it. > - return true; > + return 0; > } > > static void intel_dvo_pre_enable(struct intel_encoder *encoder, > diff --git a/drivers/gpu/drm/i915/intel_hdmi.c b/drivers/gpu/drm/i915/intel_hdmi.c > index 74f4021b760c..147a367c9abb 100644 > --- a/drivers/gpu/drm/i915/intel_hdmi.c > +++ b/drivers/gpu/drm/i915/intel_hdmi.c > @@ -1704,9 +1704,9 @@ intel_hdmi_ycbcr420_config(struct drm_connector *connector, > return true; > } > > -bool intel_hdmi_compute_config(struct intel_encoder *encoder, > - struct intel_crtc_state *pipe_config, > - struct drm_connector_state *conn_state) > +int intel_hdmi_compute_config(struct intel_encoder *encoder, > + struct intel_crtc_state *pipe_config, > + struct drm_connector_state *conn_state) > { > struct intel_hdmi *intel_hdmi = enc_to_intel_hdmi(&encoder->base); > struct drm_i915_private *dev_priv = to_i915(encoder->base.dev); > @@ -1722,7 +1722,7 @@ bool intel_hdmi_compute_config(struct intel_encoder *encoder, > bool force_dvi = intel_conn_state->force_audio == HDMI_AUDIO_OFF_DVI; > > if (adjusted_mode->flags & DRM_MODE_FLAG_DBLSCAN) > - return false; > + return -EINVAL; > > pipe_config->output_format = INTEL_OUTPUT_FORMAT_RGB; > pipe_config->has_hdmi_sink = !force_dvi && intel_hdmi->has_hdmi_sink; > @@ -1753,7 +1753,7 @@ bool intel_hdmi_compute_config(struct intel_encoder *encoder, > &clock_12bpc, &clock_10bpc, > &clock_8bpc)) { > DRM_ERROR("Can't support YCBCR420 output\n"); > - return false; > + return -EINVAL; > } > } > Looks like you missed the if(hdmi_port_clock_valid()) branch here. > @@ -1822,7 +1822,7 @@ bool intel_hdmi_compute_config(struct intel_encoder *encoder, > } > } > > - return true; > + return 0; > } > > static void > diff --git a/drivers/gpu/drm/i915/intel_lvds.c b/drivers/gpu/drm/i915/intel_lvds.c > index b01aacb5d73d..46a5dfd5cdf7 100644 > --- a/drivers/gpu/drm/i915/intel_lvds.c > +++ b/drivers/gpu/drm/i915/intel_lvds.c > @@ -380,9 +380,9 @@ intel_lvds_mode_valid(struct drm_connector *connector, > return MODE_OK; > } > > -static bool intel_lvds_compute_config(struct intel_encoder *intel_encoder, > - struct intel_crtc_state *pipe_config, > - struct drm_connector_state *conn_state) > +static int intel_lvds_compute_config(struct intel_encoder *intel_encoder, > + struct intel_crtc_state *pipe_config, > + struct drm_connector_state *conn_state) > { > struct drm_i915_private *dev_priv = to_i915(intel_encoder->base.dev); > struct intel_lvds_encoder *lvds_encoder = > @@ -396,7 +396,7 @@ static bool intel_lvds_compute_config(struct intel_encoder *intel_encoder, > /* Should never happen!! */ > if (INTEL_GEN(dev_priv) < 4 && intel_crtc->pipe == 0) { > DRM_ERROR("Can't support LVDS on pipe A\n"); > - return false; > + return -EINVAL; > } > > if (lvds_encoder->a3_power == LVDS_A3_POWER_UP) > @@ -422,7 +422,7 @@ static bool intel_lvds_compute_config(struct intel_encoder *intel_encoder, > adjusted_mode); > > if (adjusted_mode->flags & DRM_MODE_FLAG_DBLSCAN) > - return false; > + return -EINVAL; > > if (HAS_PCH_SPLIT(dev_priv)) { > pipe_config->has_pch_encoder = true; > @@ -441,7 +441,7 @@ static bool intel_lvds_compute_config(struct intel_encoder *intel_encoder, > * user's requested refresh rate. > */ > > - return true; > + return 0; > } > > static enum drm_connector_status > diff --git a/drivers/gpu/drm/i915/intel_sdvo.c b/drivers/gpu/drm/i915/intel_sdvo.c > index 4db7aefa88f9..df2d830a7405 100644 > --- a/drivers/gpu/drm/i915/intel_sdvo.c > +++ b/drivers/gpu/drm/i915/intel_sdvo.c > @@ -1107,9 +1107,9 @@ static void i9xx_adjust_sdvo_tv_clock(struct intel_crtc_state *pipe_config) > pipe_config->clock_set = true; > } > > -static bool intel_sdvo_compute_config(struct intel_encoder *encoder, > - struct intel_crtc_state *pipe_config, > - struct drm_connector_state *conn_state) > +static int intel_sdvo_compute_config(struct intel_encoder *encoder, > + struct intel_crtc_state *pipe_config, > + struct drm_connector_state *conn_state) > { > struct intel_sdvo *intel_sdvo = to_sdvo(encoder); > struct intel_sdvo_connector_state *intel_sdvo_state = > @@ -1134,7 +1134,7 @@ static bool intel_sdvo_compute_config(struct intel_encoder *encoder, > */ > if (IS_TV(intel_sdvo_connector)) { > if (!intel_sdvo_set_output_timings_from_mode(intel_sdvo, mode)) > - return false; > + return -EINVAL; > > (void) intel_sdvo_get_preferred_input_mode(intel_sdvo, > intel_sdvo_connector, > @@ -1144,7 +1144,7 @@ static bool intel_sdvo_compute_config(struct intel_encoder *encoder, > } else if (IS_LVDS(intel_sdvo_connector)) { > if (!intel_sdvo_set_output_timings_from_mode(intel_sdvo, > intel_sdvo_connector->base.panel.fixed_mode)) > - return false; > + return -EINVAL; > > (void) intel_sdvo_get_preferred_input_mode(intel_sdvo, > intel_sdvo_connector, > @@ -1153,7 +1153,7 @@ static bool intel_sdvo_compute_config(struct intel_encoder *encoder, > } > > if (adjusted_mode->flags & DRM_MODE_FLAG_DBLSCAN) > - return false; > + return -EINVAL; > > /* > * Make the CRTC code factor in the SDVO pixel multiplier. The > @@ -1193,7 +1193,7 @@ static bool intel_sdvo_compute_config(struct intel_encoder *encoder, > if (intel_sdvo_connector->is_hdmi) > adjusted_mode->picture_aspect_ratio = conn_state->picture_aspect_ratio; > > - return true; > + return 0; > } > > #define UPDATE_PROPERTY(input, NAME) \ > diff --git a/drivers/gpu/drm/i915/intel_tv.c b/drivers/gpu/drm/i915/intel_tv.c > index d7a414ce2774..bd5536f0ec92 100644 > --- a/drivers/gpu/drm/i915/intel_tv.c > +++ b/drivers/gpu/drm/i915/intel_tv.c > @@ -869,7 +869,7 @@ intel_tv_get_config(struct intel_encoder *encoder, > pipe_config->base.adjusted_mode.crtc_clock = pipe_config->port_clock; > } > > -static bool > +static int > intel_tv_compute_config(struct intel_encoder *encoder, > struct intel_crtc_state *pipe_config, > struct drm_connector_state *conn_state) > @@ -879,10 +879,10 @@ intel_tv_compute_config(struct intel_encoder *encoder, > &pipe_config->base.adjusted_mode; > > if (!tv_mode) > - return false; > + return -EINVAL; > > if (adjusted_mode->flags & DRM_MODE_FLAG_DBLSCAN) > - return false; > + return -EINVAL; > > pipe_config->output_format = INTEL_OUTPUT_FORMAT_RGB; > adjusted_mode->crtc_clock = tv_mode->clock; > @@ -897,7 +897,7 @@ intel_tv_compute_config(struct intel_encoder *encoder, > * or whether userspace is doing something stupid. > */ > > - return true; > + return 0; > } > > static void > diff --git a/drivers/gpu/drm/i915/vlv_dsi.c b/drivers/gpu/drm/i915/vlv_dsi.c > index d116fead8514..c247ce74b71a 100644 > --- a/drivers/gpu/drm/i915/vlv_dsi.c > +++ b/drivers/gpu/drm/i915/vlv_dsi.c > @@ -256,9 +256,9 @@ static void band_gap_reset(struct drm_i915_private *dev_priv) > mutex_unlock(&dev_priv->sb_lock); > } > > -static bool intel_dsi_compute_config(struct intel_encoder *encoder, > - struct intel_crtc_state *pipe_config, > - struct drm_connector_state *conn_state) > +static int intel_dsi_compute_config(struct intel_encoder *encoder, > + struct intel_crtc_state *pipe_config, > + struct drm_connector_state *conn_state) > { > struct drm_i915_private *dev_priv = to_i915(encoder->base.dev); > struct intel_dsi *intel_dsi = container_of(encoder, struct intel_dsi, > @@ -284,7 +284,7 @@ static bool intel_dsi_compute_config(struct intel_encoder *encoder, > } > > if (adjusted_mode->flags & DRM_MODE_FLAG_DBLSCAN) > - return false; > + return -EINVAL; > > /* DSI uses short packets for sync events, so clear mode flags for DSI */ > adjusted_mode->flags = 0; > @@ -302,16 +302,16 @@ static bool intel_dsi_compute_config(struct intel_encoder *encoder, > > ret = bxt_dsi_pll_compute(encoder, pipe_config); > if (ret) > - return false; > + return -EINVAL; > } else { > ret = vlv_dsi_pll_compute(encoder, pipe_config); > if (ret) > - return false; > + return -EINVAL; > } > > pipe_config->clock_set = true; > > - return true; > + return 0; > } > > static bool glk_dsi_enable_io(struct intel_encoder *encoder) > -- > 2.20.1 -- Ville Syrjälä Intel