From mboxrd@z Thu Jan 1 00:00:00 1970 From: Ville =?iso-8859-1?Q?Syrj=E4l=E4?= Subject: Re: [PATCH v2] drm/i915: Pass down rc in intel_encoder->compute_config() Date: Tue, 15 Jan 2019 22:19:19 +0200 Message-ID: <20190115201919.GO20097@intel.com> References: <20190115200800.3121-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: <20190115200800.3121-1-lyude@redhat.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" To: Lyude Paul Cc: David Airlie , intel-gfx@lists.freedesktop.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org List-Id: dri-devel@lists.freedesktop.org T24gVHVlLCBKYW4gMTUsIDIwMTkgYXQgMDM6MDg6MDBQTSAtMDUwMCwgTHl1ZGUgUGF1bCB3cm90 ZToKPiBTb21ldGhpbmcgdGhhdCBJIGNvbXBsZXRlbHkgbWlzc2VkIHdoZW4gaW1wbGVtZW50aW5n IHRoZSBuZXcgTVNUIFZDUEkKPiBhdG9taWMgaGVscGVycyBpcyB0aGF0IHdpdGggdGhvc2UgaGVs cGVycywgdGhlcmUncyB0ZWNobmljYWxseSBhIGNoYW5jZQo+IG9mIHVzIGhhdmluZyB0byBncmFi IGFkZGl0aW9uYWwgbW9kZXNldCBsb2NrcyBpbiAtPmNvbXB1dGVfY29uZmlnKCkgYW5kCj4gZnVy dGhlcm1vcmUsIHRoYXQgbWVhbnMgd2UgaGF2ZSB0aGUgcG90ZW50aWFsIHRvIGhpdCBhIG5vcm1h bCBtb2Rlc2V0Cj4gZGVhZGxvY2suIEhvd2V2ZXIsIGJlY2F1c2UgLT5jb21wdXRlX2NvbmZpZygp IG9ubHkgcmV0dXJucyBhIGJvb2wgdGhpcwo+IG1lYW5zIHdlIGNhbid0IHJldHVybiAtRURFQURM SyB3aGVuIHdlIG5lZWQgdG8gZHJvcCBsb2NrcyBhbmQgdHJ5IGFnYWluCj4gd2hpY2ggbWVhbnMg d2UgZW5kIHVwIGp1c3QgZmFpbGluZyB0aGUgYXRvbWljIGNoZWNrIHBlcm1hbmVudGx5LiBXaG9v cHMuCj4gCj4gU28sIGZpeCB0aGlzIGJ5IG1vZGlmeWluZyAtPmNvbXB1dGVfY29uZmlnKCkgdG8g cGFzcyBkb3duIGFuIGFjdHVhbAo+IGVycm9yIGNvZGUgaW5zdGVhZCBvZiBhIGJvb2wgc28gdGhh dCB0aGUgYXRvbWljIGNoZWNrIGNhbiBiZSByZXN0YXJ0ZWQKPiBvbiBtb2Rlc2V0IGRlYWRsb2Nr cy4KPiAKPiBUaGFua3MgdG8gVmlsbGUgU3lyasOkbMOkIGZvciBwb2ludGluZyB0aGlzIG91dCEK PiAKPiBDaGFuZ2VzIHNpbmNlIHYxOgo+ICogQWRkIHNvbWUgbmV3bGluZXMKPiAqIFJldHVybiBv bmx5IC1FSU5WQUwgZnJvbSBoc3dfY3J0X2NvbXB1dGVfY29uZmlnKCkKPiAqIFByb3BvZ2F0ZSBy ZXR1cm4gY29kZSBmcm9tIGludGVsX2RwX2NvbXB1dGVfZHNjX3BhcmFtcygpCj4gKiBDaGFuZ2Ug YWxsIG9mIHRoZSBpbnRlbF9kcF9jb21wdXRlX2xpbmtfY29uZmlnKigpIHZhcmlhbnRzCj4gKiBE b24ndCBtaXNzIGlmIChoZG1pX3BvcnRfY2xvY2tfdmFsaWQoKSkgYnJhbmNoIGluCj4gICBpbnRl bF9oZG1pX2NvbXB1dGVfY29uZmlnKCkKPiAKPiBTaWduZWQtb2ZmLWJ5OiBMeXVkZSBQYXVsIDxs eXVkZUByZWRoYXQuY29tPgo+IENjOiBWaWxsZSBTeXJqw6Rsw6QgPHZpbGxlLnN5cmphbGFAbGlu dXguaW50ZWwuY29tPgo+IEZpeGVzOiBlY2VhZTE0NzI0NjcgKCJkcm0vZHBfbXN0OiBTdGFydCB0 cmFja2luZyBwZXItcG9ydCBWQ1BJIGFsbG9jYXRpb25zIikKPiBCdWd6aWxsYTogaHR0cHM6Ly9i dWdzLmZyZWVkZXNrdG9wLm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTA5MzIwCgpQYXRjaCBsb29rcyBn cmVhdC4gSG9wZWZ1bGx5IHdlIGdvdCB0aGVtIGFsbC4KClJldmlld2VkLWJ5OiBWaWxsZSBTeXJq w6Rsw6QgPHZpbGxlLnN5cmphbGFAbGludXguaW50ZWwuY29tPgoKPiAtLS0KPiAgZHJpdmVycy9n cHUvZHJtL2k5MTUvaWNsX2RzaS5jICAgICAgIHwgIDggKystLQo+ICBkcml2ZXJzL2dwdS9kcm0v aTkxNS9pbnRlbF9jcnQuYyAgICAgfCAzNSArKysrKysrLS0tLS0tLQo+ICBkcml2ZXJzL2dwdS9k cm0vaTkxNS9pbnRlbF9kZGkuYyAgICAgfCAgNiArLS0KPiAgZHJpdmVycy9ncHUvZHJtL2k5MTUv aW50ZWxfZGlzcGxheS5jIHwgMTEgKysrLS0KPiAgZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxf ZHAuYyAgICAgIHwgNzEgKysrKysrKysrKysrKysrLS0tLS0tLS0tLS0tLQo+ICBkcml2ZXJzL2dw dS9kcm0vaTkxNS9pbnRlbF9kcF9tc3QuYyAgfCAxMiArKy0tLQo+ICBkcml2ZXJzL2dwdS9kcm0v aTkxNS9pbnRlbF9kcnYuaCAgICAgfCAxOCArKystLS0tCj4gIGRyaXZlcnMvZ3B1L2RybS9pOTE1 L2ludGVsX2R2by5jICAgICB8IDExICsrKy0tCj4gIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVs X2hkbWkuYyAgICB8IDE0ICsrKy0tLQo+ICBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9sdmRz LmMgICAgfCAxMiArKy0tLQo+ICBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9zZHZvLmMgICAg fCAxNCArKystLS0KPiAgZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfdHYuYyAgICAgIHwgIDgg KystLQo+ICBkcml2ZXJzL2dwdS9kcm0vaTkxNS92bHZfZHNpLmMgICAgICAgfCAxNCArKystLS0K PiAgMTMgZmlsZXMgY2hhbmdlZCwgMTIyIGluc2VydGlvbnMoKyksIDExMiBkZWxldGlvbnMoLSkK PiAKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaWNsX2RzaS5jIGIvZHJpdmVy cy9ncHUvZHJtL2k5MTUvaWNsX2RzaS5jCj4gaW5kZXggZjNhNWYwMzY0NmNlLi4zNTViNDhkMWM5 MzcgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaWNsX2RzaS5jCj4gKysrIGIv ZHJpdmVycy9ncHUvZHJtL2k5MTUvaWNsX2RzaS5jCj4gQEAgLTExODgsOSArMTE4OCw5IEBAIHN0 YXRpYyB2b2lkIGdlbjExX2RzaV9nZXRfY29uZmlnKHN0cnVjdCBpbnRlbF9lbmNvZGVyICplbmNv ZGVyLAo+ICAJcGlwZV9jb25maWctPm91dHB1dF90eXBlcyB8PSBCSVQoSU5URUxfT1VUUFVUX0RT SSk7Cj4gIH0KPiAgCj4gLXN0YXRpYyBib29sIGdlbjExX2RzaV9jb21wdXRlX2NvbmZpZyhzdHJ1 Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2RlciwKPiAtCQkJCSAgICAgc3RydWN0IGludGVsX2NydGNf c3RhdGUgKnBpcGVfY29uZmlnLAo+IC0JCQkJICAgICBzdHJ1Y3QgZHJtX2Nvbm5lY3Rvcl9zdGF0 ZSAqY29ubl9zdGF0ZSkKPiArc3RhdGljIGludCBnZW4xMV9kc2lfY29tcHV0ZV9jb25maWcoc3Ry dWN0IGludGVsX2VuY29kZXIgKmVuY29kZXIsCj4gKwkJCQkgICAgc3RydWN0IGludGVsX2NydGNf c3RhdGUgKnBpcGVfY29uZmlnLAo+ICsJCQkJICAgIHN0cnVjdCBkcm1fY29ubmVjdG9yX3N0YXRl ICpjb25uX3N0YXRlKQo+ICB7Cj4gIAlzdHJ1Y3QgaW50ZWxfZHNpICppbnRlbF9kc2kgPSBjb250 YWluZXJfb2YoZW5jb2Rlciwgc3RydWN0IGludGVsX2RzaSwKPiAgCQkJCQkJICAgYmFzZSk7Cj4g QEAgLTEyMTUsNyArMTIxNSw3IEBAIHN0YXRpYyBib29sIGdlbjExX2RzaV9jb21wdXRlX2NvbmZp ZyhzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2RlciwKPiAgCXBpcGVfY29uZmlnLT5jbG9ja19z ZXQgPSB0cnVlOwo+ICAJcGlwZV9jb25maWctPnBvcnRfY2xvY2sgPSBpbnRlbF9kc2lfYml0cmF0 ZShpbnRlbF9kc2kpIC8gNTsKPiAgCj4gLQlyZXR1cm4gdHJ1ZTsKPiArCXJldHVybiAwOwo+ICB9 Cj4gIAo+ICBzdGF0aWMgdTY0IGdlbjExX2RzaV9nZXRfcG93ZXJfZG9tYWlucyhzdHJ1Y3QgaW50 ZWxfZW5jb2RlciAqZW5jb2RlciwKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUv aW50ZWxfY3J0LmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9jcnQuYwo+IGluZGV4IDMz YmQyYWRkY2JkZC4uMDgxYzMzM2YzMGQyIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9p OTE1L2ludGVsX2NydC5jCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfY3J0LmMK PiBAQCAtMzQ1LDUxICszNDUsNTIgQEAgaW50ZWxfY3J0X21vZGVfdmFsaWQoc3RydWN0IGRybV9j b25uZWN0b3IgKmNvbm5lY3RvciwKPiAgCXJldHVybiBNT0RFX09LOwo+ICB9Cj4gIAo+IC1zdGF0 aWMgYm9vbCBpbnRlbF9jcnRfY29tcHV0ZV9jb25maWcoc3RydWN0IGludGVsX2VuY29kZXIgKmVu Y29kZXIsCj4gLQkJCQkgICAgIHN0cnVjdCBpbnRlbF9jcnRjX3N0YXRlICpwaXBlX2NvbmZpZywK PiAtCQkJCSAgICAgc3RydWN0IGRybV9jb25uZWN0b3Jfc3RhdGUgKmNvbm5fc3RhdGUpCj4gK3N0 YXRpYyBpbnQgaW50ZWxfY3J0X2NvbXB1dGVfY29uZmlnKHN0cnVjdCBpbnRlbF9lbmNvZGVyICpl bmNvZGVyLAo+ICsJCQkJICAgIHN0cnVjdCBpbnRlbF9jcnRjX3N0YXRlICpwaXBlX2NvbmZpZywK PiArCQkJCSAgICBzdHJ1Y3QgZHJtX2Nvbm5lY3Rvcl9zdGF0ZSAqY29ubl9zdGF0ZSkKPiAgewo+ ICAJc3RydWN0IGRybV9kaXNwbGF5X21vZGUgKmFkanVzdGVkX21vZGUgPQo+ICAJCSZwaXBlX2Nv bmZpZy0+YmFzZS5hZGp1c3RlZF9tb2RlOwo+ICAKPiAgCWlmIChhZGp1c3RlZF9tb2RlLT5mbGFn cyAmIERSTV9NT0RFX0ZMQUdfREJMU0NBTikKPiAtCQlyZXR1cm4gZmFsc2U7Cj4gKwkJcmV0dXJu IC1FSU5WQUw7Cj4gIAo+ICAJcGlwZV9jb25maWctPm91dHB1dF9mb3JtYXQgPSBJTlRFTF9PVVRQ VVRfRk9STUFUX1JHQjsKPiAtCXJldHVybiB0cnVlOwo+ICsKPiArCXJldHVybiAwOwo+ICB9Cj4g IAo+IC1zdGF0aWMgYm9vbCBwY2hfY3J0X2NvbXB1dGVfY29uZmlnKHN0cnVjdCBpbnRlbF9lbmNv ZGVyICplbmNvZGVyLAo+IC0JCQkJICAgc3RydWN0IGludGVsX2NydGNfc3RhdGUgKnBpcGVfY29u ZmlnLAo+IC0JCQkJICAgc3RydWN0IGRybV9jb25uZWN0b3Jfc3RhdGUgKmNvbm5fc3RhdGUpCj4g K3N0YXRpYyBpbnQgcGNoX2NydF9jb21wdXRlX2NvbmZpZyhzdHJ1Y3QgaW50ZWxfZW5jb2RlciAq ZW5jb2RlciwKPiArCQkJCSAgc3RydWN0IGludGVsX2NydGNfc3RhdGUgKnBpcGVfY29uZmlnLAo+ ICsJCQkJICBzdHJ1Y3QgZHJtX2Nvbm5lY3Rvcl9zdGF0ZSAqY29ubl9zdGF0ZSkKPiAgewo+ICAJ c3RydWN0IGRybV9kaXNwbGF5X21vZGUgKmFkanVzdGVkX21vZGUgPQo+ICAJCSZwaXBlX2NvbmZp Zy0+YmFzZS5hZGp1c3RlZF9tb2RlOwo+ICAKPiAgCWlmIChhZGp1c3RlZF9tb2RlLT5mbGFncyAm IERSTV9NT0RFX0ZMQUdfREJMU0NBTikKPiAtCQlyZXR1cm4gZmFsc2U7Cj4gKwkJcmV0dXJuIC1F SU5WQUw7Cj4gIAo+ICAJcGlwZV9jb25maWctPmhhc19wY2hfZW5jb2RlciA9IHRydWU7Cj4gIAlw aXBlX2NvbmZpZy0+b3V0cHV0X2Zvcm1hdCA9IElOVEVMX09VVFBVVF9GT1JNQVRfUkdCOwo+ICAK PiAtCXJldHVybiB0cnVlOwo+ICsJcmV0dXJuIDA7Cj4gIH0KPiAgCj4gLXN0YXRpYyBib29sIGhz d19jcnRfY29tcHV0ZV9jb25maWcoc3RydWN0IGludGVsX2VuY29kZXIgKmVuY29kZXIsCj4gLQkJ CQkgICBzdHJ1Y3QgaW50ZWxfY3J0Y19zdGF0ZSAqcGlwZV9jb25maWcsCj4gLQkJCQkgICBzdHJ1 Y3QgZHJtX2Nvbm5lY3Rvcl9zdGF0ZSAqY29ubl9zdGF0ZSkKPiArc3RhdGljIGludCBoc3dfY3J0 X2NvbXB1dGVfY29uZmlnKHN0cnVjdCBpbnRlbF9lbmNvZGVyICplbmNvZGVyLAo+ICsJCQkJICBz dHJ1Y3QgaW50ZWxfY3J0Y19zdGF0ZSAqcGlwZV9jb25maWcsCj4gKwkJCQkgIHN0cnVjdCBkcm1f Y29ubmVjdG9yX3N0YXRlICpjb25uX3N0YXRlKQo+ICB7Cj4gIAlzdHJ1Y3QgZHJtX2k5MTVfcHJp dmF0ZSAqZGV2X3ByaXYgPSB0b19pOTE1KGVuY29kZXItPmJhc2UuZGV2KTsKPiAgCXN0cnVjdCBk cm1fZGlzcGxheV9tb2RlICphZGp1c3RlZF9tb2RlID0KPiAgCQkmcGlwZV9jb25maWctPmJhc2Uu YWRqdXN0ZWRfbW9kZTsKPiAgCj4gIAlpZiAoYWRqdXN0ZWRfbW9kZS0+ZmxhZ3MgJiBEUk1fTU9E RV9GTEFHX0RCTFNDQU4pCj4gLQkJcmV0dXJuIGZhbHNlOwo+ICsJCXJldHVybiAtRUlOVkFMOwo+ ICAKPiAgCS8qIEhTVy9CRFcgRkRJIGxpbWl0ZWQgdG8gNGsgKi8KPiAgCWlmIChhZGp1c3RlZF9t b2RlLT5jcnRjX2hkaXNwbGF5ID4gNDA5NiB8fAo+ICAJICAgIGFkanVzdGVkX21vZGUtPmNydGNf aGJsYW5rX3N0YXJ0ID4gNDA5NikKPiAtCQlyZXR1cm4gZmFsc2U7Cj4gKwkJcmV0dXJuIC1FSU5W QUw7Cj4gIAo+ICAJcGlwZV9jb25maWctPmhhc19wY2hfZW5jb2RlciA9IHRydWU7Cj4gIAlwaXBl X2NvbmZpZy0+b3V0cHV0X2Zvcm1hdCA9IElOVEVMX09VVFBVVF9GT1JNQVRfUkdCOwo+IEBAIC0z OTgsNyArMzk5LDcgQEAgc3RhdGljIGJvb2wgaHN3X2NydF9jb21wdXRlX2NvbmZpZyhzdHJ1Y3Qg aW50ZWxfZW5jb2RlciAqZW5jb2RlciwKPiAgCWlmIChIQVNfUENIX0xQVChkZXZfcHJpdikpIHsK PiAgCQlpZiAocGlwZV9jb25maWctPmJ3X2NvbnN0cmFpbmVkICYmIHBpcGVfY29uZmlnLT5waXBl X2JwcCA8IDI0KSB7Cj4gIAkJCURSTV9ERUJVR19LTVMoIkxQVCBvbmx5IHN1cHBvcnRzIDI0YnBw XG4iKTsKPiAtCQkJcmV0dXJuIGZhbHNlOwo+ICsJCQlyZXR1cm4gLUVJTlZBTDsKPiAgCQl9Cj4g IAo+ICAJCXBpcGVfY29uZmlnLT5waXBlX2JwcCA9IDI0Owo+IEBAIC00MDcsNyArNDA4LDcgQEAg c3RhdGljIGJvb2wgaHN3X2NydF9jb21wdXRlX2NvbmZpZyhzdHJ1Y3QgaW50ZWxfZW5jb2RlciAq ZW5jb2RlciwKPiAgCS8qIEZESSBtdXN0IGFsd2F5cyBiZSAyLjcgR0h6ICovCj4gIAlwaXBlX2Nv bmZpZy0+cG9ydF9jbG9jayA9IDEzNTAwMCAqIDI7Cj4gIAo+IC0JcmV0dXJuIHRydWU7Cj4gKwly ZXR1cm4gMDsKPiAgfQo+ICAKPiAgc3RhdGljIGJvb2wgaW50ZWxfaXJvbmxha2VfY3J0X2RldGVj dF9ob3RwbHVnKHN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3IpCj4gZGlmZiAtLWdpdCBh L2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2RkaS5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUv aW50ZWxfZGRpLmMKPiBpbmRleCA3ZjNjZDA1NWRlNTAuLmNlNDQ3NDRhNWY5ZCAxMDA2NDQKPiAt LS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kZGkuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1 L2RybS9pOTE1L2ludGVsX2RkaS5jCj4gQEAgLTM4MzcsOSArMzgzNyw5IEBAIGludGVsX2RkaV9j b21wdXRlX291dHB1dF90eXBlKHN0cnVjdCBpbnRlbF9lbmNvZGVyICplbmNvZGVyLAo+ICAJfQo+ ICB9Cj4gIAo+IC1zdGF0aWMgYm9vbCBpbnRlbF9kZGlfY29tcHV0ZV9jb25maWcoc3RydWN0IGlu dGVsX2VuY29kZXIgKmVuY29kZXIsCj4gLQkJCQkgICAgIHN0cnVjdCBpbnRlbF9jcnRjX3N0YXRl ICpwaXBlX2NvbmZpZywKPiAtCQkJCSAgICAgc3RydWN0IGRybV9jb25uZWN0b3Jfc3RhdGUgKmNv bm5fc3RhdGUpCj4gK3N0YXRpYyBpbnQgaW50ZWxfZGRpX2NvbXB1dGVfY29uZmlnKHN0cnVjdCBp bnRlbF9lbmNvZGVyICplbmNvZGVyLAo+ICsJCQkJICAgIHN0cnVjdCBpbnRlbF9jcnRjX3N0YXRl ICpwaXBlX2NvbmZpZywKPiArCQkJCSAgICBzdHJ1Y3QgZHJtX2Nvbm5lY3Rvcl9zdGF0ZSAqY29u bl9zdGF0ZSkKPiAgewo+ICAJc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2ID0gdG9f aTkxNShlbmNvZGVyLT5iYXNlLmRldik7Cj4gIAllbnVtIHBvcnQgcG9ydCA9IGVuY29kZXItPnBv cnQ7Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rpc3BsYXkuYyBi L2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rpc3BsYXkuYwo+IGluZGV4IDBhNWJhNDVmNWVi MC4uYWYxNjRkNzEyZTllIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVs X2Rpc3BsYXkuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rpc3BsYXkuYwo+ IEBAIC0xMTU1MywxMCArMTE1NTMsMTMgQEAgaW50ZWxfbW9kZXNldF9waXBlX2NvbmZpZyhzdHJ1 Y3QgZHJtX2NydGMgKmNydGMsCj4gIAkJCWNvbnRpbnVlOwo+ICAKPiAgCQllbmNvZGVyID0gdG9f aW50ZWxfZW5jb2Rlcihjb25uZWN0b3Jfc3RhdGUtPmJlc3RfZW5jb2Rlcik7Cj4gLQo+IC0JCWlm ICghKGVuY29kZXItPmNvbXB1dGVfY29uZmlnKGVuY29kZXIsIHBpcGVfY29uZmlnLCBjb25uZWN0 b3Jfc3RhdGUpKSkgewo+IC0JCQlEUk1fREVCVUdfS01TKCJFbmNvZGVyIGNvbmZpZyBmYWlsdXJl XG4iKTsKPiAtCQkJcmV0dXJuIC1FSU5WQUw7Cj4gKwkJcmV0ID0gZW5jb2Rlci0+Y29tcHV0ZV9j b25maWcoZW5jb2RlciwgcGlwZV9jb25maWcsCj4gKwkJCQkJICAgICAgY29ubmVjdG9yX3N0YXRl KTsKPiArCQlpZiAocmV0IDwgMCkgewo+ICsJCQlpZiAocmV0ICE9IC1FREVBRExLKQo+ICsJCQkJ RFJNX0RFQlVHX0tNUygiRW5jb2RlciBjb25maWcgZmFpbHVyZTogJWRcbiIsCj4gKwkJCQkJICAg ICAgcmV0KTsKPiArCQkJcmV0dXJuIHJldDsKPiAgCQl9Cj4gIAl9Cj4gIAo+IGRpZmYgLS1naXQg YS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kcC5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUv aW50ZWxfZHAuYwo+IGluZGV4IDBhM2FjOThhNzc5ZS4uZGY0MjkyYmIxYTRmIDEwMDY0NAo+IC0t LSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2RwLmMKPiArKysgYi9kcml2ZXJzL2dwdS9k cm0vaTkxNS9pbnRlbF9kcC5jCj4gQEAgLTE4MTksNyArMTgxOSw3IEBAIGludGVsX2RwX2FkanVz dF9jb21wbGlhbmNlX2NvbmZpZyhzdHJ1Y3QgaW50ZWxfZHAgKmludGVsX2RwLAo+ICB9Cj4gIAo+ ICAvKiBPcHRpbWl6ZSBsaW5rIGNvbmZpZyBpbiBvcmRlcjogbWF4IGJwcCwgbWluIGNsb2NrLCBt aW4gbGFuZXMgKi8KPiAtc3RhdGljIGJvb2wKPiArc3RhdGljIGludAo+ICBpbnRlbF9kcF9jb21w dXRlX2xpbmtfY29uZmlnX3dpZGUoc3RydWN0IGludGVsX2RwICppbnRlbF9kcCwKPiAgCQkJCSAg c3RydWN0IGludGVsX2NydGNfc3RhdGUgKnBpcGVfY29uZmlnLAo+ICAJCQkJICBjb25zdCBzdHJ1 Y3QgbGlua19jb25maWdfbGltaXRzICpsaW1pdHMpCj4gQEAgLTE4NDUsMTcgKzE4NDUsMTcgQEAg aW50ZWxfZHBfY29tcHV0ZV9saW5rX2NvbmZpZ193aWRlKHN0cnVjdCBpbnRlbF9kcCAqaW50ZWxf ZHAsCj4gIAkJCQkJcGlwZV9jb25maWctPnBpcGVfYnBwID0gYnBwOwo+ICAJCQkJCXBpcGVfY29u ZmlnLT5wb3J0X2Nsb2NrID0gbGlua19jbG9jazsKPiAgCj4gLQkJCQkJcmV0dXJuIHRydWU7Cj4g KwkJCQkJcmV0dXJuIDA7Cj4gIAkJCQl9Cj4gIAkJCX0KPiAgCQl9Cj4gIAl9Cj4gIAo+IC0JcmV0 dXJuIGZhbHNlOwo+ICsJcmV0dXJuIC1FSU5WQUw7Cj4gIH0KPiAgCj4gIC8qIE9wdGltaXplIGxp bmsgY29uZmlnIGluIG9yZGVyOiBtYXggYnBwLCBtaW4gbGFuZXMsIG1pbiBjbG9jayAqLwo+IC1z dGF0aWMgYm9vbAo+ICtzdGF0aWMgaW50Cj4gIGludGVsX2RwX2NvbXB1dGVfbGlua19jb25maWdf ZmFzdChzdHJ1Y3QgaW50ZWxfZHAgKmludGVsX2RwLAo+ICAJCQkJICBzdHJ1Y3QgaW50ZWxfY3J0 Y19zdGF0ZSAqcGlwZV9jb25maWcsCj4gIAkJCQkgIGNvbnN0IHN0cnVjdCBsaW5rX2NvbmZpZ19s aW1pdHMgKmxpbWl0cykKPiBAQCAtMTg4MSwxMyArMTg4MSwxMyBAQCBpbnRlbF9kcF9jb21wdXRl X2xpbmtfY29uZmlnX2Zhc3Qoc3RydWN0IGludGVsX2RwICppbnRlbF9kcCwKPiAgCQkJCQlwaXBl X2NvbmZpZy0+cGlwZV9icHAgPSBicHA7Cj4gIAkJCQkJcGlwZV9jb25maWctPnBvcnRfY2xvY2sg PSBsaW5rX2Nsb2NrOwo+ICAKPiAtCQkJCQlyZXR1cm4gdHJ1ZTsKPiArCQkJCQlyZXR1cm4gMDsK PiAgCQkJCX0KPiAgCQkJfQo+ICAJCX0KPiAgCX0KPiAgCj4gLQlyZXR1cm4gZmFsc2U7Cj4gKwly ZXR1cm4gLUVJTlZBTDsKPiAgfQo+ICAKPiAgc3RhdGljIGludCBpbnRlbF9kcF9kc2NfY29tcHV0 ZV9icHAoc3RydWN0IGludGVsX2RwICppbnRlbF9kcCwgdTggZHNjX21heF9icGMpCj4gQEAgLTE5 MDUsMTkgKzE5MDUsMjAgQEAgc3RhdGljIGludCBpbnRlbF9kcF9kc2NfY29tcHV0ZV9icHAoc3Ry dWN0IGludGVsX2RwICppbnRlbF9kcCwgdTggZHNjX21heF9icGMpCj4gIAlyZXR1cm4gMDsKPiAg fQo+ICAKPiAtc3RhdGljIGJvb2wgaW50ZWxfZHBfZHNjX2NvbXB1dGVfY29uZmlnKHN0cnVjdCBp bnRlbF9kcCAqaW50ZWxfZHAsCj4gLQkJCQkJc3RydWN0IGludGVsX2NydGNfc3RhdGUgKnBpcGVf Y29uZmlnLAo+IC0JCQkJCXN0cnVjdCBkcm1fY29ubmVjdG9yX3N0YXRlICpjb25uX3N0YXRlLAo+ IC0JCQkJCXN0cnVjdCBsaW5rX2NvbmZpZ19saW1pdHMgKmxpbWl0cykKPiArc3RhdGljIGludCBp bnRlbF9kcF9kc2NfY29tcHV0ZV9jb25maWcoc3RydWN0IGludGVsX2RwICppbnRlbF9kcCwKPiAr CQkJCSAgICAgICBzdHJ1Y3QgaW50ZWxfY3J0Y19zdGF0ZSAqcGlwZV9jb25maWcsCj4gKwkJCQkg ICAgICAgc3RydWN0IGRybV9jb25uZWN0b3Jfc3RhdGUgKmNvbm5fc3RhdGUsCj4gKwkJCQkgICAg ICAgc3RydWN0IGxpbmtfY29uZmlnX2xpbWl0cyAqbGltaXRzKQo+ICB7Cj4gIAlzdHJ1Y3QgaW50 ZWxfZGlnaXRhbF9wb3J0ICpkaWdfcG9ydCA9IGRwX3RvX2RpZ19wb3J0KGludGVsX2RwKTsKPiAg CXN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiA9IHRvX2k5MTUoZGlnX3BvcnQtPmJh c2UuYmFzZS5kZXYpOwo+ICAJc3RydWN0IGRybV9kaXNwbGF5X21vZGUgKmFkanVzdGVkX21vZGUg PSAmcGlwZV9jb25maWctPmJhc2UuYWRqdXN0ZWRfbW9kZTsKPiAgCXU4IGRzY19tYXhfYnBjOwo+ ICAJaW50IHBpcGVfYnBwOwo+ICsJaW50IHJldDsKPiAgCj4gIAlpZiAoIWludGVsX2RwX3N1cHBv cnRzX2RzYyhpbnRlbF9kcCwgcGlwZV9jb25maWcpKQo+IC0JCXJldHVybiBmYWxzZTsKPiArCQly ZXR1cm4gLUVJTlZBTDsKPiAgCj4gIAlkc2NfbWF4X2JwYyA9IG1pbl90KHU4LCBEUF9EU0NfTUFY X1NVUFBPUlRFRF9CUEMsCj4gIAkJCSAgICBjb25uX3N0YXRlLT5tYXhfcmVxdWVzdGVkX2JwYyk7 Cj4gQEAgLTE5MjUsNyArMTkyNiw3IEBAIHN0YXRpYyBib29sIGludGVsX2RwX2RzY19jb21wdXRl X2NvbmZpZyhzdHJ1Y3QgaW50ZWxfZHAgKmludGVsX2RwLAo+ICAJcGlwZV9icHAgPSBpbnRlbF9k cF9kc2NfY29tcHV0ZV9icHAoaW50ZWxfZHAsIGRzY19tYXhfYnBjKTsKPiAgCWlmIChwaXBlX2Jw cCA8IERQX0RTQ19NSU5fU1VQUE9SVEVEX0JQQyAqIDMpIHsKPiAgCQlEUk1fREVCVUdfS01TKCJO byBEU0Mgc3VwcG9ydCBmb3IgbGVzcyB0aGFuIDhicGNcbiIpOwo+IC0JCXJldHVybiBmYWxzZTsK PiArCQlyZXR1cm4gLUVJTlZBTDsKPiAgCX0KPiAgCj4gIAkvKgo+IEBAIC0xOTU5LDcgKzE5NjAs NyBAQCBzdGF0aWMgYm9vbCBpbnRlbF9kcF9kc2NfY29tcHV0ZV9jb25maWcoc3RydWN0IGludGVs X2RwICppbnRlbF9kcCwKPiAgCQkJCQkJICAgICBhZGp1c3RlZF9tb2RlLT5jcnRjX2hkaXNwbGF5 KTsKPiAgCQlpZiAoIWRzY19tYXhfb3V0cHV0X2JwcCB8fCAhZHNjX2RwX3NsaWNlX2NvdW50KSB7 Cj4gIAkJCURSTV9ERUJVR19LTVMoIkNvbXByZXNzZWQgQlBQL1NsaWNlIENvdW50IG5vdCBzdXBw b3J0ZWRcbiIpOwo+IC0JCQlyZXR1cm4gZmFsc2U7Cj4gKwkJCXJldHVybiAtRUlOVkFMOwo+ICAJ CX0KPiAgCQlwaXBlX2NvbmZpZy0+ZHNjX3BhcmFtcy5jb21wcmVzc2VkX2JwcCA9IG1pbl90KHUx NiwKPiAgCQkJCQkJCSAgICAgICBkc2NfbWF4X291dHB1dF9icHAgPj4gNCwKPiBAQCAtMTk3Niwx NiArMTk3NywxOSBAQCBzdGF0aWMgYm9vbCBpbnRlbF9kcF9kc2NfY29tcHV0ZV9jb25maWcoc3Ry dWN0IGludGVsX2RwICppbnRlbF9kcCwKPiAgCQkJcGlwZV9jb25maWctPmRzY19wYXJhbXMuZHNj X3NwbGl0ID0gdHJ1ZTsKPiAgCQl9IGVsc2Ugewo+ICAJCQlEUk1fREVCVUdfS01TKCJDYW5ub3Qg c3BsaXQgc3RyZWFtIHRvIHVzZSAyIFZEU0MgaW5zdGFuY2VzXG4iKTsKPiAtCQkJcmV0dXJuIGZh bHNlOwo+ICsJCQlyZXR1cm4gLUVJTlZBTDsKPiAgCQl9Cj4gIAl9Cj4gLQlpZiAoaW50ZWxfZHBf Y29tcHV0ZV9kc2NfcGFyYW1zKGludGVsX2RwLCBwaXBlX2NvbmZpZykgPCAwKSB7Cj4gKwo+ICsJ cmV0ID0gaW50ZWxfZHBfY29tcHV0ZV9kc2NfcGFyYW1zKGludGVsX2RwLCBwaXBlX2NvbmZpZyk7 Cj4gKwlpZiAocmV0IDwgMCkgewo+ICAJCURSTV9ERUJVR19LTVMoIkNhbm5vdCBjb21wdXRlIHZh bGlkIERTQyBwYXJhbWV0ZXJzIGZvciBJbnB1dCBCcHAgPSAlZCAiCj4gIAkJCSAgICAgICJDb21w cmVzc2VkIEJQUCA9ICVkXG4iLAo+ICAJCQkgICAgICBwaXBlX2NvbmZpZy0+cGlwZV9icHAsCj4g IAkJCSAgICAgIHBpcGVfY29uZmlnLT5kc2NfcGFyYW1zLmNvbXByZXNzZWRfYnBwKTsKPiAtCQly ZXR1cm4gZmFsc2U7Cj4gKwkJcmV0dXJuIHJldDsKPiAgCX0KPiArCj4gIAlwaXBlX2NvbmZpZy0+ ZHNjX3BhcmFtcy5jb21wcmVzc2lvbl9lbmFibGUgPSB0cnVlOwo+ICAJRFJNX0RFQlVHX0tNUygi RFAgRFNDIGNvbXB1dGVkIHdpdGggSW5wdXQgQnBwID0gJWQgIgo+ICAJCSAgICAgICJDb21wcmVz c2VkIEJwcCA9ICVkIFNsaWNlIENvdW50ID0gJWRcbiIsCj4gQEAgLTE5OTMsMTAgKzE5OTcsMTAg QEAgc3RhdGljIGJvb2wgaW50ZWxfZHBfZHNjX2NvbXB1dGVfY29uZmlnKHN0cnVjdCBpbnRlbF9k cCAqaW50ZWxfZHAsCj4gIAkJICAgICAgcGlwZV9jb25maWctPmRzY19wYXJhbXMuY29tcHJlc3Nl ZF9icHAsCj4gIAkJICAgICAgcGlwZV9jb25maWctPmRzY19wYXJhbXMuc2xpY2VfY291bnQpOwo+ ICAKPiAtCXJldHVybiB0cnVlOwo+ICsJcmV0dXJuIDA7Cj4gIH0KPiAgCj4gLXN0YXRpYyBib29s Cj4gK3N0YXRpYyBpbnQKPiAgaW50ZWxfZHBfY29tcHV0ZV9saW5rX2NvbmZpZyhzdHJ1Y3QgaW50 ZWxfZW5jb2RlciAqZW5jb2RlciwKPiAgCQkJICAgICBzdHJ1Y3QgaW50ZWxfY3J0Y19zdGF0ZSAq cGlwZV9jb25maWcsCj4gIAkJCSAgICAgc3RydWN0IGRybV9jb25uZWN0b3Jfc3RhdGUgKmNvbm5f c3RhdGUpCj4gQEAgLTIwMDUsNyArMjAwOSw3IEBAIGludGVsX2RwX2NvbXB1dGVfbGlua19jb25m aWcoc3RydWN0IGludGVsX2VuY29kZXIgKmVuY29kZXIsCj4gIAlzdHJ1Y3QgaW50ZWxfZHAgKmlu dGVsX2RwID0gZW5jX3RvX2ludGVsX2RwKCZlbmNvZGVyLT5iYXNlKTsKPiAgCXN0cnVjdCBsaW5r X2NvbmZpZ19saW1pdHMgbGltaXRzOwo+ICAJaW50IGNvbW1vbl9sZW47Cj4gLQlib29sIHJldDsK PiArCWludCByZXQ7Cj4gIAo+ICAJY29tbW9uX2xlbiA9IGludGVsX2RwX2NvbW1vbl9sZW5fcmF0 ZV9saW1pdChpbnRlbF9kcCwKPiAgCQkJCQkJICAgIGludGVsX2RwLT5tYXhfbGlua19yYXRlKTsK PiBAQCAtMjA2MywxMCArMjA2NywxMSBAQCBpbnRlbF9kcF9jb21wdXRlX2xpbmtfY29uZmlnKHN0 cnVjdCBpbnRlbF9lbmNvZGVyICplbmNvZGVyLAo+ICAKPiAgCS8qIGVuYWJsZSBjb21wcmVzc2lv biBpZiB0aGUgbW9kZSBkb2Vzbid0IGZpdCBhdmFpbGFibGUgQlcgKi8KPiAgCURSTV9ERUJVR19L TVMoIkZvcmNlIERTQyBlbiA9ICVkXG4iLCBpbnRlbF9kcC0+Zm9yY2VfZHNjX2VuKTsKPiAtCWlm ICghcmV0IHx8IGludGVsX2RwLT5mb3JjZV9kc2NfZW4pIHsKPiAtCQlpZiAoIWludGVsX2RwX2Rz Y19jb21wdXRlX2NvbmZpZyhpbnRlbF9kcCwgcGlwZV9jb25maWcsCj4gLQkJCQkJCSBjb25uX3N0 YXRlLCAmbGltaXRzKSkKPiAtCQkJcmV0dXJuIGZhbHNlOwo+ICsJaWYgKHJldCB8fCBpbnRlbF9k cC0+Zm9yY2VfZHNjX2VuKSB7Cj4gKwkJcmV0ID0gaW50ZWxfZHBfZHNjX2NvbXB1dGVfY29uZmln KGludGVsX2RwLCBwaXBlX2NvbmZpZywKPiArCQkJCQkJICBjb25uX3N0YXRlLCAmbGltaXRzKTsK PiArCQlpZiAocmV0IDwgMCkKPiArCQkJcmV0dXJuIHJldDsKPiAgCX0KPiAgCj4gIAlpZiAocGlw ZV9jb25maWctPmRzY19wYXJhbXMuY29tcHJlc3Npb25fZW5hYmxlKSB7Cj4gQEAgLTIwOTEsMTAg KzIwOTYsMTAgQEAgaW50ZWxfZHBfY29tcHV0ZV9saW5rX2NvbmZpZyhzdHJ1Y3QgaW50ZWxfZW5j b2RlciAqZW5jb2RlciwKPiAgCQkJICAgICAgaW50ZWxfZHBfbWF4X2RhdGFfcmF0ZShwaXBlX2Nv bmZpZy0+cG9ydF9jbG9jaywKPiAgCQkJCQkJICAgICBwaXBlX2NvbmZpZy0+bGFuZV9jb3VudCkp Owo+ICAJfQo+IC0JcmV0dXJuIHRydWU7Cj4gKwlyZXR1cm4gMDsKPiAgfQo+ICAKPiAtYm9vbAo+ ICtpbnQKPiAgaW50ZWxfZHBfY29tcHV0ZV9jb25maWcoc3RydWN0IGludGVsX2VuY29kZXIgKmVu Y29kZXIsCj4gIAkJCXN0cnVjdCBpbnRlbF9jcnRjX3N0YXRlICpwaXBlX2NvbmZpZywKPiAgCQkJ c3RydWN0IGRybV9jb25uZWN0b3Jfc3RhdGUgKmNvbm5fc3RhdGUpCj4gQEAgLTIxMTAsNiArMjEx NSw3IEBAIGludGVsX2RwX2NvbXB1dGVfY29uZmlnKHN0cnVjdCBpbnRlbF9lbmNvZGVyICplbmNv ZGVyLAo+ICAJCXRvX2ludGVsX2RpZ2l0YWxfY29ubmVjdG9yX3N0YXRlKGNvbm5fc3RhdGUpOwo+ ICAJYm9vbCBjb25zdGFudF9uID0gZHJtX2RwX2hhc19xdWlyaygmaW50ZWxfZHAtPmRlc2MsCj4g IAkJCQkJICAgRFBfRFBDRF9RVUlSS19DT05TVEFOVF9OKTsKPiArCWludCByZXQ7Cj4gIAo+ICAJ aWYgKEhBU19QQ0hfU1BMSVQoZGV2X3ByaXYpICYmICFIQVNfRERJKGRldl9wcml2KSAmJiBwb3J0 ICE9IFBPUlRfQSkKPiAgCQlwaXBlX2NvbmZpZy0+aGFzX3BjaF9lbmNvZGVyID0gdHJ1ZTsKPiBA QCAtMjEzMSw4ICsyMTM3LDYgQEAgaW50ZWxfZHBfY29tcHV0ZV9jb25maWcoc3RydWN0IGludGVs X2VuY29kZXIgKmVuY29kZXIsCj4gIAkJCQkgICAgICAgYWRqdXN0ZWRfbW9kZSk7Cj4gIAo+ICAJ CWlmIChJTlRFTF9HRU4oZGV2X3ByaXYpID49IDkpIHsKPiAtCQkJaW50IHJldDsKPiAtCj4gIAkJ CXJldCA9IHNrbF91cGRhdGVfc2NhbGVyX2NydGMocGlwZV9jb25maWcpOwo+ICAJCQlpZiAocmV0 KQo+ICAJCQkJcmV0dXJuIHJldDsKPiBAQCAtMjE0NywyMCArMjE1MSwyMSBAQCBpbnRlbF9kcF9j b21wdXRlX2NvbmZpZyhzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2RlciwKPiAgCX0KPiAgCj4g IAlpZiAoYWRqdXN0ZWRfbW9kZS0+ZmxhZ3MgJiBEUk1fTU9ERV9GTEFHX0RCTFNDQU4pCj4gLQkJ cmV0dXJuIGZhbHNlOwo+ICsJCXJldHVybiAtRUlOVkFMOwo+ICAKPiAgCWlmIChIQVNfR01DSF9E SVNQTEFZKGRldl9wcml2KSAmJgo+ICAJICAgIGFkanVzdGVkX21vZGUtPmZsYWdzICYgRFJNX01P REVfRkxBR19JTlRFUkxBQ0UpCj4gLQkJcmV0dXJuIGZhbHNlOwo+ICsJCXJldHVybiAtRUlOVkFM Owo+ICAKPiAgCWlmIChhZGp1c3RlZF9tb2RlLT5mbGFncyAmIERSTV9NT0RFX0ZMQUdfREJMQ0xL KQo+IC0JCXJldHVybiBmYWxzZTsKPiArCQlyZXR1cm4gLUVJTlZBTDsKPiAgCj4gIAlwaXBlX2Nv bmZpZy0+ZmVjX2VuYWJsZSA9ICFpbnRlbF9kcF9pc19lZHAoaW50ZWxfZHApICYmCj4gIAkJCQkg IGludGVsX2RwX3N1cHBvcnRzX2ZlYyhpbnRlbF9kcCwgcGlwZV9jb25maWcpOwo+ICAKPiAtCWlm ICghaW50ZWxfZHBfY29tcHV0ZV9saW5rX2NvbmZpZyhlbmNvZGVyLCBwaXBlX2NvbmZpZywgY29u bl9zdGF0ZSkpCj4gLQkJcmV0dXJuIGZhbHNlOwo+ICsJcmV0ID0gaW50ZWxfZHBfY29tcHV0ZV9s aW5rX2NvbmZpZyhlbmNvZGVyLCBwaXBlX2NvbmZpZywgY29ubl9zdGF0ZSk7Cj4gKwlpZiAocmV0 IDwgMCkKPiArCQlyZXR1cm4gcmV0Owo+ICAKPiAgCWlmIChpbnRlbF9jb25uX3N0YXRlLT5icm9h ZGNhc3RfcmdiID09IElOVEVMX0JST0FEQ0FTVF9SR0JfQVVUTykgewo+ICAJCS8qCj4gQEAgLTIy MDgsNyArMjIxMyw3IEBAIGludGVsX2RwX2NvbXB1dGVfY29uZmlnKHN0cnVjdCBpbnRlbF9lbmNv ZGVyICplbmNvZGVyLAo+ICAKPiAgCWludGVsX3Bzcl9jb21wdXRlX2NvbmZpZyhpbnRlbF9kcCwg cGlwZV9jb25maWcpOwo+ICAKPiAtCXJldHVybiB0cnVlOwo+ICsJcmV0dXJuIDA7Cj4gIH0KPiAg Cj4gIHZvaWQgaW50ZWxfZHBfc2V0X2xpbmtfcGFyYW1zKHN0cnVjdCBpbnRlbF9kcCAqaW50ZWxf ZHAsCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2RwX21zdC5jIGIv ZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHBfbXN0LmMKPiBpbmRleCAzZjgzNDI5MzMzYzcu LmExOTY5OTAyM2RiMSAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9k cF9tc3QuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2RwX21zdC5jCj4gQEAg LTI5LDkgKzI5LDkgQEAKPiAgI2luY2x1ZGUgPGRybS9kcm1fY3J0Y19oZWxwZXIuaD4KPiAgI2lu Y2x1ZGUgPGRybS9kcm1fZWRpZC5oPgo+ICAKPiAtc3RhdGljIGJvb2wgaW50ZWxfZHBfbXN0X2Nv bXB1dGVfY29uZmlnKHN0cnVjdCBpbnRlbF9lbmNvZGVyICplbmNvZGVyLAo+IC0JCQkJCXN0cnVj dCBpbnRlbF9jcnRjX3N0YXRlICpwaXBlX2NvbmZpZywKPiAtCQkJCQlzdHJ1Y3QgZHJtX2Nvbm5l Y3Rvcl9zdGF0ZSAqY29ubl9zdGF0ZSkKPiArc3RhdGljIGludCBpbnRlbF9kcF9tc3RfY29tcHV0 ZV9jb25maWcoc3RydWN0IGludGVsX2VuY29kZXIgKmVuY29kZXIsCj4gKwkJCQkgICAgICAgc3Ry dWN0IGludGVsX2NydGNfc3RhdGUgKnBpcGVfY29uZmlnLAo+ICsJCQkJICAgICAgIHN0cnVjdCBk cm1fY29ubmVjdG9yX3N0YXRlICpjb25uX3N0YXRlKQo+ICB7Cj4gIAlzdHJ1Y3QgZHJtX2k5MTVf cHJpdmF0ZSAqZGV2X3ByaXYgPSB0b19pOTE1KGVuY29kZXItPmJhc2UuZGV2KTsKPiAgCXN0cnVj dCBpbnRlbF9kcF9tc3RfZW5jb2RlciAqaW50ZWxfbXN0ID0gZW5jX3RvX21zdCgmZW5jb2Rlci0+ YmFzZSk7Cj4gQEAgLTUyLDcgKzUyLDcgQEAgc3RhdGljIGJvb2wgaW50ZWxfZHBfbXN0X2NvbXB1 dGVfY29uZmlnKHN0cnVjdCBpbnRlbF9lbmNvZGVyICplbmNvZGVyLAo+ICAJCQkJCSAgIERQX0RQ Q0RfUVVJUktfQ09OU1RBTlRfTik7Cj4gIAo+ICAJaWYgKGFkanVzdGVkX21vZGUtPmZsYWdzICYg RFJNX01PREVfRkxBR19EQkxTQ0FOKQo+IC0JCXJldHVybiBmYWxzZTsKPiArCQlyZXR1cm4gLUVJ TlZBTDsKPiAgCj4gIAlwaXBlX2NvbmZpZy0+b3V0cHV0X2Zvcm1hdCA9IElOVEVMX09VVFBVVF9G T1JNQVRfUkdCOwo+ICAJcGlwZV9jb25maWctPmhhc19wY2hfZW5jb2RlciA9IGZhbHNlOwo+IEBA IC04OSw3ICs4OSw3IEBAIHN0YXRpYyBib29sIGludGVsX2RwX21zdF9jb21wdXRlX2NvbmZpZyhz dHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2RlciwKPiAgCQlpZiAoc2xvdHMgPCAwKSB7Cj4gIAkJ CURSTV9ERUJVR19LTVMoImZhaWxlZCBmaW5kaW5nIHZjcGkgc2xvdHM6JWRcbiIsCj4gIAkJCQkg ICAgICBzbG90cyk7Cj4gLQkJCXJldHVybiBmYWxzZTsKPiArCQkJcmV0dXJuIHNsb3RzOwo+ICAJ CX0KPiAgCX0KPiAgCj4gQEAgLTEwNyw3ICsxMDcsNyBAQCBzdGF0aWMgYm9vbCBpbnRlbF9kcF9t c3RfY29tcHV0ZV9jb25maWcoc3RydWN0IGludGVsX2VuY29kZXIgKmVuY29kZXIsCj4gIAo+ICAJ aW50ZWxfZGRpX2NvbXB1dGVfbWluX3ZvbHRhZ2VfbGV2ZWwoZGV2X3ByaXYsIHBpcGVfY29uZmln KTsKPiAgCj4gLQlyZXR1cm4gdHJ1ZTsKPiArCXJldHVybiAwOwo+ICB9Cj4gIAo+ICBzdGF0aWMg aW50Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rydi5oIGIvZHJp dmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHJ2LmgKPiBpbmRleCA3OTc3ODQzY2UyNmEuLmU1YTQz NmMzMzMwNyAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kcnYuaAo+ ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rydi5oCj4gQEAgLTIyNSw5ICsyMjUs OSBAQCBzdHJ1Y3QgaW50ZWxfZW5jb2RlciB7Cj4gIAllbnVtIGludGVsX291dHB1dF90eXBlICgq Y29tcHV0ZV9vdXRwdXRfdHlwZSkoc3RydWN0IGludGVsX2VuY29kZXIgKiwKPiAgCQkJCQkJICAg ICAgc3RydWN0IGludGVsX2NydGNfc3RhdGUgKiwKPiAgCQkJCQkJICAgICAgc3RydWN0IGRybV9j b25uZWN0b3Jfc3RhdGUgKik7Cj4gLQlib29sICgqY29tcHV0ZV9jb25maWcpKHN0cnVjdCBpbnRl bF9lbmNvZGVyICosCj4gLQkJCSAgICAgICBzdHJ1Y3QgaW50ZWxfY3J0Y19zdGF0ZSAqLAo+IC0J CQkgICAgICAgc3RydWN0IGRybV9jb25uZWN0b3Jfc3RhdGUgKik7Cj4gKwlpbnQgKCpjb21wdXRl X2NvbmZpZykoc3RydWN0IGludGVsX2VuY29kZXIgKiwKPiArCQkJICAgICAgc3RydWN0IGludGVs X2NydGNfc3RhdGUgKiwKPiArCQkJICAgICAgc3RydWN0IGRybV9jb25uZWN0b3Jfc3RhdGUgKik7 Cj4gIAl2b2lkICgqcHJlX3BsbF9lbmFibGUpKHN0cnVjdCBpbnRlbF9lbmNvZGVyICosCj4gIAkJ CSAgICAgICBjb25zdCBzdHJ1Y3QgaW50ZWxfY3J0Y19zdGF0ZSAqLAo+ICAJCQkgICAgICAgY29u c3Qgc3RydWN0IGRybV9jb25uZWN0b3Jfc3RhdGUgKik7Cj4gQEAgLTE4MTYsOSArMTgxNiw5IEBA IHZvaWQgaW50ZWxfZHBfc2lua19zZXRfZGVjb21wcmVzc2lvbl9zdGF0ZShzdHJ1Y3QgaW50ZWxf ZHAgKmludGVsX2RwLAo+ICB2b2lkIGludGVsX2RwX2VuY29kZXJfcmVzZXQoc3RydWN0IGRybV9l bmNvZGVyICplbmNvZGVyKTsKPiAgdm9pZCBpbnRlbF9kcF9lbmNvZGVyX3N1c3BlbmQoc3RydWN0 IGludGVsX2VuY29kZXIgKmludGVsX2VuY29kZXIpOwo+ICB2b2lkIGludGVsX2RwX2VuY29kZXJf Zmx1c2hfd29yayhzdHJ1Y3QgZHJtX2VuY29kZXIgKmVuY29kZXIpOwo+IC1ib29sIGludGVsX2Rw X2NvbXB1dGVfY29uZmlnKHN0cnVjdCBpbnRlbF9lbmNvZGVyICplbmNvZGVyLAo+IC0JCQkgICAg IHN0cnVjdCBpbnRlbF9jcnRjX3N0YXRlICpwaXBlX2NvbmZpZywKPiAtCQkJICAgICBzdHJ1Y3Qg ZHJtX2Nvbm5lY3Rvcl9zdGF0ZSAqY29ubl9zdGF0ZSk7Cj4gK2ludCBpbnRlbF9kcF9jb21wdXRl X2NvbmZpZyhzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2RlciwKPiArCQkJICAgIHN0cnVjdCBp bnRlbF9jcnRjX3N0YXRlICpwaXBlX2NvbmZpZywKPiArCQkJICAgIHN0cnVjdCBkcm1fY29ubmVj dG9yX3N0YXRlICpjb25uX3N0YXRlKTsKPiAgYm9vbCBpbnRlbF9kcF9pc19lZHAoc3RydWN0IGlu dGVsX2RwICppbnRlbF9kcCk7Cj4gIGJvb2wgaW50ZWxfZHBfaXNfcG9ydF9lZHAoc3RydWN0IGRy bV9pOTE1X3ByaXZhdGUgKmRldl9wcml2LCBlbnVtIHBvcnQgcG9ydCk7Cj4gIGVudW0gaXJxcmV0 dXJuIGludGVsX2RwX2hwZF9wdWxzZShzdHJ1Y3QgaW50ZWxfZGlnaXRhbF9wb3J0ICppbnRlbF9k aWdfcG9ydCwKPiBAQCAtMTk3OCw5ICsxOTc4LDkgQEAgdm9pZCBpbnRlbF9oZG1pX2luaXQoc3Ry dWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2LCBpOTE1X3JlZ190IGhkbWlfcmVnLAo+ICB2 b2lkIGludGVsX2hkbWlfaW5pdF9jb25uZWN0b3Ioc3RydWN0IGludGVsX2RpZ2l0YWxfcG9ydCAq aW50ZWxfZGlnX3BvcnQsCj4gIAkJCSAgICAgICBzdHJ1Y3QgaW50ZWxfY29ubmVjdG9yICppbnRl bF9jb25uZWN0b3IpOwo+ICBzdHJ1Y3QgaW50ZWxfaGRtaSAqZW5jX3RvX2ludGVsX2hkbWkoc3Ry dWN0IGRybV9lbmNvZGVyICplbmNvZGVyKTsKPiAtYm9vbCBpbnRlbF9oZG1pX2NvbXB1dGVfY29u ZmlnKHN0cnVjdCBpbnRlbF9lbmNvZGVyICplbmNvZGVyLAo+IC0JCQkgICAgICAgc3RydWN0IGlu dGVsX2NydGNfc3RhdGUgKnBpcGVfY29uZmlnLAo+IC0JCQkgICAgICAgc3RydWN0IGRybV9jb25u ZWN0b3Jfc3RhdGUgKmNvbm5fc3RhdGUpOwo+ICtpbnQgaW50ZWxfaGRtaV9jb21wdXRlX2NvbmZp ZyhzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2RlciwKPiArCQkJICAgICAgc3RydWN0IGludGVs X2NydGNfc3RhdGUgKnBpcGVfY29uZmlnLAo+ICsJCQkgICAgICBzdHJ1Y3QgZHJtX2Nvbm5lY3Rv cl9zdGF0ZSAqY29ubl9zdGF0ZSk7Cj4gIGJvb2wgaW50ZWxfaGRtaV9oYW5kbGVfc2lua19zY3Jh bWJsaW5nKHN0cnVjdCBpbnRlbF9lbmNvZGVyICplbmNvZGVyLAo+ICAJCQkJICAgICAgIHN0cnVj dCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3IsCj4gIAkJCQkgICAgICAgYm9vbCBoaWdoX3RtZHNf Y2xvY2tfcmF0aW8sCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2R2 by5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHZvLmMKPiBpbmRleCBiYzNjM2NiNTdl YzYuLmE2YzgyNDgyYTg0MSAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRl bF9kdm8uYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2R2by5jCj4gQEAgLTIz NCw5ICsyMzQsOSBAQCBpbnRlbF9kdm9fbW9kZV92YWxpZChzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAq Y29ubmVjdG9yLAo+ICAJcmV0dXJuIGludGVsX2R2by0+ZGV2LmRldl9vcHMtPm1vZGVfdmFsaWQo JmludGVsX2R2by0+ZGV2LCBtb2RlKTsKPiAgfQo+ICAKPiAtc3RhdGljIGJvb2wgaW50ZWxfZHZv X2NvbXB1dGVfY29uZmlnKHN0cnVjdCBpbnRlbF9lbmNvZGVyICplbmNvZGVyLAo+IC0JCQkJICAg ICBzdHJ1Y3QgaW50ZWxfY3J0Y19zdGF0ZSAqcGlwZV9jb25maWcsCj4gLQkJCQkgICAgIHN0cnVj dCBkcm1fY29ubmVjdG9yX3N0YXRlICpjb25uX3N0YXRlKQo+ICtzdGF0aWMgaW50IGludGVsX2R2 b19jb21wdXRlX2NvbmZpZyhzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2RlciwKPiArCQkJCSAg ICBzdHJ1Y3QgaW50ZWxfY3J0Y19zdGF0ZSAqcGlwZV9jb25maWcsCj4gKwkJCQkgICAgc3RydWN0 IGRybV9jb25uZWN0b3Jfc3RhdGUgKmNvbm5fc3RhdGUpCj4gIHsKPiAgCXN0cnVjdCBpbnRlbF9k dm8gKmludGVsX2R2byA9IGVuY190b19kdm8oZW5jb2Rlcik7Cj4gIAljb25zdCBzdHJ1Y3QgZHJt X2Rpc3BsYXlfbW9kZSAqZml4ZWRfbW9kZSA9Cj4gQEAgLTI1MywxMCArMjUzLDExIEBAIHN0YXRp YyBib29sIGludGVsX2R2b19jb21wdXRlX2NvbmZpZyhzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5j b2RlciwKPiAgCQlpbnRlbF9maXhlZF9wYW5lbF9tb2RlKGZpeGVkX21vZGUsIGFkanVzdGVkX21v ZGUpOwo+ICAKPiAgCWlmIChhZGp1c3RlZF9tb2RlLT5mbGFncyAmIERSTV9NT0RFX0ZMQUdfREJM U0NBTikKPiAtCQlyZXR1cm4gZmFsc2U7Cj4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4gIAo+ICAJcGlw ZV9jb25maWctPm91dHB1dF9mb3JtYXQgPSBJTlRFTF9PVVRQVVRfRk9STUFUX1JHQjsKPiAtCXJl dHVybiB0cnVlOwo+ICsKPiArCXJldHVybiAwOwo+ICB9Cj4gIAo+ICBzdGF0aWMgdm9pZCBpbnRl bF9kdm9fcHJlX2VuYWJsZShzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2RlciwKPiBkaWZmIC0t Z2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfaGRtaS5jIGIvZHJpdmVycy9ncHUvZHJt L2k5MTUvaW50ZWxfaGRtaS5jCj4gaW5kZXggNzRmNDAyMWI3NjBjLi45N2E5OGUxYmVhNTYgMTAw NjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfaGRtaS5jCj4gKysrIGIvZHJp dmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfaGRtaS5jCj4gQEAgLTE3MDQsOSArMTcwNCw5IEBAIGlu dGVsX2hkbWlfeWNiY3I0MjBfY29uZmlnKHN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3Is Cj4gIAlyZXR1cm4gdHJ1ZTsKPiAgfQo+ICAKPiAtYm9vbCBpbnRlbF9oZG1pX2NvbXB1dGVfY29u ZmlnKHN0cnVjdCBpbnRlbF9lbmNvZGVyICplbmNvZGVyLAo+IC0JCQkgICAgICAgc3RydWN0IGlu dGVsX2NydGNfc3RhdGUgKnBpcGVfY29uZmlnLAo+IC0JCQkgICAgICAgc3RydWN0IGRybV9jb25u ZWN0b3Jfc3RhdGUgKmNvbm5fc3RhdGUpCj4gK2ludCBpbnRlbF9oZG1pX2NvbXB1dGVfY29uZmln KHN0cnVjdCBpbnRlbF9lbmNvZGVyICplbmNvZGVyLAo+ICsJCQkgICAgICBzdHJ1Y3QgaW50ZWxf Y3J0Y19zdGF0ZSAqcGlwZV9jb25maWcsCj4gKwkJCSAgICAgIHN0cnVjdCBkcm1fY29ubmVjdG9y X3N0YXRlICpjb25uX3N0YXRlKQo+ICB7Cj4gIAlzdHJ1Y3QgaW50ZWxfaGRtaSAqaW50ZWxfaGRt aSA9IGVuY190b19pbnRlbF9oZG1pKCZlbmNvZGVyLT5iYXNlKTsKPiAgCXN0cnVjdCBkcm1faTkx NV9wcml2YXRlICpkZXZfcHJpdiA9IHRvX2k5MTUoZW5jb2Rlci0+YmFzZS5kZXYpOwo+IEBAIC0x NzIyLDcgKzE3MjIsNyBAQCBib29sIGludGVsX2hkbWlfY29tcHV0ZV9jb25maWcoc3RydWN0IGlu dGVsX2VuY29kZXIgKmVuY29kZXIsCj4gIAlib29sIGZvcmNlX2R2aSA9IGludGVsX2Nvbm5fc3Rh dGUtPmZvcmNlX2F1ZGlvID09IEhETUlfQVVESU9fT0ZGX0RWSTsKPiAgCj4gIAlpZiAoYWRqdXN0 ZWRfbW9kZS0+ZmxhZ3MgJiBEUk1fTU9ERV9GTEFHX0RCTFNDQU4pCj4gLQkJcmV0dXJuIGZhbHNl Owo+ICsJCXJldHVybiAtRUlOVkFMOwo+ICAKPiAgCXBpcGVfY29uZmlnLT5vdXRwdXRfZm9ybWF0 ID0gSU5URUxfT1VUUFVUX0ZPUk1BVF9SR0I7Cj4gIAlwaXBlX2NvbmZpZy0+aGFzX2hkbWlfc2lu ayA9ICFmb3JjZV9kdmkgJiYgaW50ZWxfaGRtaS0+aGFzX2hkbWlfc2luazsKPiBAQCAtMTc1Myw3 ICsxNzUzLDcgQEAgYm9vbCBpbnRlbF9oZG1pX2NvbXB1dGVfY29uZmlnKHN0cnVjdCBpbnRlbF9l bmNvZGVyICplbmNvZGVyLAo+ICAJCQkJCQkmY2xvY2tfMTJicGMsICZjbG9ja18xMGJwYywKPiAg CQkJCQkJJmNsb2NrXzhicGMpKSB7Cj4gIAkJCURSTV9FUlJPUigiQ2FuJ3Qgc3VwcG9ydCBZQ0JD UjQyMCBvdXRwdXRcbiIpOwo+IC0JCQlyZXR1cm4gZmFsc2U7Cj4gKwkJCXJldHVybiAtRUlOVkFM Owo+ICAJCX0KPiAgCX0KPiAgCj4gQEAgLTE4MDMsNyArMTgwMyw3IEBAIGJvb2wgaW50ZWxfaGRt aV9jb21wdXRlX2NvbmZpZyhzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2RlciwKPiAgCWlmICho ZG1pX3BvcnRfY2xvY2tfdmFsaWQoaW50ZWxfaGRtaSwgcGlwZV9jb25maWctPnBvcnRfY2xvY2ss Cj4gIAkJCQkgIGZhbHNlLCBmb3JjZV9kdmkpICE9IE1PREVfT0spIHsKPiAgCQlEUk1fREVCVUdf S01TKCJ1bnN1cHBvcnRlZCBIRE1JIGNsb2NrLCByZWplY3RpbmcgbW9kZVxuIik7Cj4gLQkJcmV0 dXJuIGZhbHNlOwo+ICsJCXJldHVybiAtRUlOVkFMOwo+ICAJfQo+ICAKPiAgCS8qIFNldCB1c2Vy IHNlbGVjdGVkIFBBUiB0byBpbmNvbWluZyBtb2RlJ3MgbWVtYmVyICovCj4gQEAgLTE4MjIsNyAr MTgyMiw3IEBAIGJvb2wgaW50ZWxfaGRtaV9jb21wdXRlX2NvbmZpZyhzdHJ1Y3QgaW50ZWxfZW5j b2RlciAqZW5jb2RlciwKPiAgCQl9Cj4gIAl9Cj4gIAo+IC0JcmV0dXJuIHRydWU7Cj4gKwlyZXR1 cm4gMDsKPiAgfQo+ICAKPiAgc3RhdGljIHZvaWQKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUv ZHJtL2k5MTUvaW50ZWxfbHZkcy5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfbHZkcy5j Cj4gaW5kZXggYjAxYWFjYjVkNzNkLi40NmE1ZGZkNWNkZjcgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVy cy9ncHUvZHJtL2k5MTUvaW50ZWxfbHZkcy5jCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUv aW50ZWxfbHZkcy5jCj4gQEAgLTM4MCw5ICszODAsOSBAQCBpbnRlbF9sdmRzX21vZGVfdmFsaWQo c3RydWN0IGRybV9jb25uZWN0b3IgKmNvbm5lY3RvciwKPiAgCXJldHVybiBNT0RFX09LOwo+ICB9 Cj4gIAo+IC1zdGF0aWMgYm9vbCBpbnRlbF9sdmRzX2NvbXB1dGVfY29uZmlnKHN0cnVjdCBpbnRl bF9lbmNvZGVyICppbnRlbF9lbmNvZGVyLAo+IC0JCQkJICAgICAgc3RydWN0IGludGVsX2NydGNf c3RhdGUgKnBpcGVfY29uZmlnLAo+IC0JCQkJICAgICAgc3RydWN0IGRybV9jb25uZWN0b3Jfc3Rh dGUgKmNvbm5fc3RhdGUpCj4gK3N0YXRpYyBpbnQgaW50ZWxfbHZkc19jb21wdXRlX2NvbmZpZyhz dHJ1Y3QgaW50ZWxfZW5jb2RlciAqaW50ZWxfZW5jb2RlciwKPiArCQkJCSAgICAgc3RydWN0IGlu dGVsX2NydGNfc3RhdGUgKnBpcGVfY29uZmlnLAo+ICsJCQkJICAgICBzdHJ1Y3QgZHJtX2Nvbm5l Y3Rvcl9zdGF0ZSAqY29ubl9zdGF0ZSkKPiAgewo+ICAJc3RydWN0IGRybV9pOTE1X3ByaXZhdGUg KmRldl9wcml2ID0gdG9faTkxNShpbnRlbF9lbmNvZGVyLT5iYXNlLmRldik7Cj4gIAlzdHJ1Y3Qg aW50ZWxfbHZkc19lbmNvZGVyICpsdmRzX2VuY29kZXIgPQo+IEBAIC0zOTYsNyArMzk2LDcgQEAg c3RhdGljIGJvb2wgaW50ZWxfbHZkc19jb21wdXRlX2NvbmZpZyhzdHJ1Y3QgaW50ZWxfZW5jb2Rl ciAqaW50ZWxfZW5jb2RlciwKPiAgCS8qIFNob3VsZCBuZXZlciBoYXBwZW4hISAqLwo+ICAJaWYg KElOVEVMX0dFTihkZXZfcHJpdikgPCA0ICYmIGludGVsX2NydGMtPnBpcGUgPT0gMCkgewo+ICAJ CURSTV9FUlJPUigiQ2FuJ3Qgc3VwcG9ydCBMVkRTIG9uIHBpcGUgQVxuIik7Cj4gLQkJcmV0dXJu IGZhbHNlOwo+ICsJCXJldHVybiAtRUlOVkFMOwo+ICAJfQo+ICAKPiAgCWlmIChsdmRzX2VuY29k ZXItPmEzX3Bvd2VyID09IExWRFNfQTNfUE9XRVJfVVApCj4gQEAgLTQyMiw3ICs0MjIsNyBAQCBz dGF0aWMgYm9vbCBpbnRlbF9sdmRzX2NvbXB1dGVfY29uZmlnKHN0cnVjdCBpbnRlbF9lbmNvZGVy ICppbnRlbF9lbmNvZGVyLAo+ICAJCQkgICAgICAgYWRqdXN0ZWRfbW9kZSk7Cj4gIAo+ICAJaWYg KGFkanVzdGVkX21vZGUtPmZsYWdzICYgRFJNX01PREVfRkxBR19EQkxTQ0FOKQo+IC0JCXJldHVy biBmYWxzZTsKPiArCQlyZXR1cm4gLUVJTlZBTDsKPiAgCj4gIAlpZiAoSEFTX1BDSF9TUExJVChk ZXZfcHJpdikpIHsKPiAgCQlwaXBlX2NvbmZpZy0+aGFzX3BjaF9lbmNvZGVyID0gdHJ1ZTsKPiBA QCAtNDQxLDcgKzQ0MSw3IEBAIHN0YXRpYyBib29sIGludGVsX2x2ZHNfY29tcHV0ZV9jb25maWco c3RydWN0IGludGVsX2VuY29kZXIgKmludGVsX2VuY29kZXIsCj4gIAkgKiB1c2VyJ3MgcmVxdWVz dGVkIHJlZnJlc2ggcmF0ZS4KPiAgCSAqLwo+ICAKPiAtCXJldHVybiB0cnVlOwo+ICsJcmV0dXJu IDA7Cj4gIH0KPiAgCj4gIHN0YXRpYyBlbnVtIGRybV9jb25uZWN0b3Jfc3RhdHVzCj4gZGlmZiAt LWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3Nkdm8uYyBiL2RyaXZlcnMvZ3B1L2Ry bS9pOTE1L2ludGVsX3Nkdm8uYwo+IGluZGV4IDRkYjdhZWZhODhmOS4uZGYyZDgzMGE3NDA1IDEw MDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3Nkdm8uYwo+ICsrKyBiL2Ry aXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3Nkdm8uYwo+IEBAIC0xMTA3LDkgKzExMDcsOSBAQCBz dGF0aWMgdm9pZCBpOXh4X2FkanVzdF9zZHZvX3R2X2Nsb2NrKHN0cnVjdCBpbnRlbF9jcnRjX3N0 YXRlICpwaXBlX2NvbmZpZykKPiAgCXBpcGVfY29uZmlnLT5jbG9ja19zZXQgPSB0cnVlOwo+ICB9 Cj4gIAo+IC1zdGF0aWMgYm9vbCBpbnRlbF9zZHZvX2NvbXB1dGVfY29uZmlnKHN0cnVjdCBpbnRl bF9lbmNvZGVyICplbmNvZGVyLAo+IC0JCQkJICAgICAgc3RydWN0IGludGVsX2NydGNfc3RhdGUg KnBpcGVfY29uZmlnLAo+IC0JCQkJICAgICAgc3RydWN0IGRybV9jb25uZWN0b3Jfc3RhdGUgKmNv bm5fc3RhdGUpCj4gK3N0YXRpYyBpbnQgaW50ZWxfc2R2b19jb21wdXRlX2NvbmZpZyhzdHJ1Y3Qg aW50ZWxfZW5jb2RlciAqZW5jb2RlciwKPiArCQkJCSAgICAgc3RydWN0IGludGVsX2NydGNfc3Rh dGUgKnBpcGVfY29uZmlnLAo+ICsJCQkJICAgICBzdHJ1Y3QgZHJtX2Nvbm5lY3Rvcl9zdGF0ZSAq Y29ubl9zdGF0ZSkKPiAgewo+ICAJc3RydWN0IGludGVsX3Nkdm8gKmludGVsX3Nkdm8gPSB0b19z ZHZvKGVuY29kZXIpOwo+ICAJc3RydWN0IGludGVsX3Nkdm9fY29ubmVjdG9yX3N0YXRlICppbnRl bF9zZHZvX3N0YXRlID0KPiBAQCAtMTEzNCw3ICsxMTM0LDcgQEAgc3RhdGljIGJvb2wgaW50ZWxf c2R2b19jb21wdXRlX2NvbmZpZyhzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2RlciwKPiAgCSAq Lwo+ICAJaWYgKElTX1RWKGludGVsX3Nkdm9fY29ubmVjdG9yKSkgewo+ICAJCWlmICghaW50ZWxf c2R2b19zZXRfb3V0cHV0X3RpbWluZ3NfZnJvbV9tb2RlKGludGVsX3Nkdm8sIG1vZGUpKQo+IC0J CQlyZXR1cm4gZmFsc2U7Cj4gKwkJCXJldHVybiAtRUlOVkFMOwo+ICAKPiAgCQkodm9pZCkgaW50 ZWxfc2R2b19nZXRfcHJlZmVycmVkX2lucHV0X21vZGUoaW50ZWxfc2R2bywKPiAgCQkJCQkJCSAg IGludGVsX3Nkdm9fY29ubmVjdG9yLAo+IEBAIC0xMTQ0LDcgKzExNDQsNyBAQCBzdGF0aWMgYm9v bCBpbnRlbF9zZHZvX2NvbXB1dGVfY29uZmlnKHN0cnVjdCBpbnRlbF9lbmNvZGVyICplbmNvZGVy LAo+ICAJfSBlbHNlIGlmIChJU19MVkRTKGludGVsX3Nkdm9fY29ubmVjdG9yKSkgewo+ICAJCWlm ICghaW50ZWxfc2R2b19zZXRfb3V0cHV0X3RpbWluZ3NfZnJvbV9tb2RlKGludGVsX3Nkdm8sCj4g IAkJCQkJCQkgICAgIGludGVsX3Nkdm9fY29ubmVjdG9yLT5iYXNlLnBhbmVsLmZpeGVkX21vZGUp KQo+IC0JCQlyZXR1cm4gZmFsc2U7Cj4gKwkJCXJldHVybiAtRUlOVkFMOwo+ICAKPiAgCQkodm9p ZCkgaW50ZWxfc2R2b19nZXRfcHJlZmVycmVkX2lucHV0X21vZGUoaW50ZWxfc2R2bywKPiAgCQkJ CQkJCSAgIGludGVsX3Nkdm9fY29ubmVjdG9yLAo+IEBAIC0xMTUzLDcgKzExNTMsNyBAQCBzdGF0 aWMgYm9vbCBpbnRlbF9zZHZvX2NvbXB1dGVfY29uZmlnKHN0cnVjdCBpbnRlbF9lbmNvZGVyICpl bmNvZGVyLAo+ICAJfQo+ICAKPiAgCWlmIChhZGp1c3RlZF9tb2RlLT5mbGFncyAmIERSTV9NT0RF X0ZMQUdfREJMU0NBTikKPiAtCQlyZXR1cm4gZmFsc2U7Cj4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4g IAo+ICAJLyoKPiAgCSAqIE1ha2UgdGhlIENSVEMgY29kZSBmYWN0b3IgaW4gdGhlIFNEVk8gcGl4 ZWwgbXVsdGlwbGllci4gIFRoZQo+IEBAIC0xMTkzLDcgKzExOTMsNyBAQCBzdGF0aWMgYm9vbCBp bnRlbF9zZHZvX2NvbXB1dGVfY29uZmlnKHN0cnVjdCBpbnRlbF9lbmNvZGVyICplbmNvZGVyLAo+ ICAJaWYgKGludGVsX3Nkdm9fY29ubmVjdG9yLT5pc19oZG1pKQo+ICAJCWFkanVzdGVkX21vZGUt PnBpY3R1cmVfYXNwZWN0X3JhdGlvID0gY29ubl9zdGF0ZS0+cGljdHVyZV9hc3BlY3RfcmF0aW87 Cj4gIAo+IC0JcmV0dXJuIHRydWU7Cj4gKwlyZXR1cm4gMDsKPiAgfQo+ICAKPiAgI2RlZmluZSBV UERBVEVfUFJPUEVSVFkoaW5wdXQsIE5BTUUpIFwKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUv ZHJtL2k5MTUvaW50ZWxfdHYuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3R2LmMKPiBp bmRleCBkN2E0MTRjZTI3NzQuLmJkNTUzNmYwZWM5MiAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dw dS9kcm0vaTkxNS9pbnRlbF90di5jCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxf dHYuYwo+IEBAIC04NjksNyArODY5LDcgQEAgaW50ZWxfdHZfZ2V0X2NvbmZpZyhzdHJ1Y3QgaW50 ZWxfZW5jb2RlciAqZW5jb2RlciwKPiAgCXBpcGVfY29uZmlnLT5iYXNlLmFkanVzdGVkX21vZGUu Y3J0Y19jbG9jayA9IHBpcGVfY29uZmlnLT5wb3J0X2Nsb2NrOwo+ICB9Cj4gIAo+IC1zdGF0aWMg Ym9vbAo+ICtzdGF0aWMgaW50Cj4gIGludGVsX3R2X2NvbXB1dGVfY29uZmlnKHN0cnVjdCBpbnRl bF9lbmNvZGVyICplbmNvZGVyLAo+ICAJCQlzdHJ1Y3QgaW50ZWxfY3J0Y19zdGF0ZSAqcGlwZV9j b25maWcsCj4gIAkJCXN0cnVjdCBkcm1fY29ubmVjdG9yX3N0YXRlICpjb25uX3N0YXRlKQo+IEBA IC04NzksMTAgKzg3OSwxMCBAQCBpbnRlbF90dl9jb21wdXRlX2NvbmZpZyhzdHJ1Y3QgaW50ZWxf ZW5jb2RlciAqZW5jb2RlciwKPiAgCQkmcGlwZV9jb25maWctPmJhc2UuYWRqdXN0ZWRfbW9kZTsK PiAgCj4gIAlpZiAoIXR2X21vZGUpCj4gLQkJcmV0dXJuIGZhbHNlOwo+ICsJCXJldHVybiAtRUlO VkFMOwo+ICAKPiAgCWlmIChhZGp1c3RlZF9tb2RlLT5mbGFncyAmIERSTV9NT0RFX0ZMQUdfREJM U0NBTikKPiAtCQlyZXR1cm4gZmFsc2U7Cj4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4gIAo+ICAJcGlw ZV9jb25maWctPm91dHB1dF9mb3JtYXQgPSBJTlRFTF9PVVRQVVRfRk9STUFUX1JHQjsKPiAgCWFk anVzdGVkX21vZGUtPmNydGNfY2xvY2sgPSB0dl9tb2RlLT5jbG9jazsKPiBAQCAtODk3LDcgKzg5 Nyw3IEBAIGludGVsX3R2X2NvbXB1dGVfY29uZmlnKHN0cnVjdCBpbnRlbF9lbmNvZGVyICplbmNv ZGVyLAo+ICAJICogb3Igd2hldGhlciB1c2Vyc3BhY2UgaXMgZG9pbmcgc29tZXRoaW5nIHN0dXBp ZC4KPiAgCSAqLwo+ICAKPiAtCXJldHVybiB0cnVlOwo+ICsJcmV0dXJuIDA7Cj4gIH0KPiAgCj4g IHN0YXRpYyB2b2lkCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L3Zsdl9kc2ku YyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L3Zsdl9kc2kuYwo+IGluZGV4IGQxMTZmZWFkODUxNC4u YzI0N2NlNzRiNzFhIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L3Zsdl9kc2ku Ywo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L3Zsdl9kc2kuYwo+IEBAIC0yNTYsOSArMjU2 LDkgQEAgc3RhdGljIHZvaWQgYmFuZF9nYXBfcmVzZXQoc3RydWN0IGRybV9pOTE1X3ByaXZhdGUg KmRldl9wcml2KQo+ICAJbXV0ZXhfdW5sb2NrKCZkZXZfcHJpdi0+c2JfbG9jayk7Cj4gIH0KPiAg Cj4gLXN0YXRpYyBib29sIGludGVsX2RzaV9jb21wdXRlX2NvbmZpZyhzdHJ1Y3QgaW50ZWxfZW5j b2RlciAqZW5jb2RlciwKPiAtCQkJCSAgICAgc3RydWN0IGludGVsX2NydGNfc3RhdGUgKnBpcGVf Y29uZmlnLAo+IC0JCQkJICAgICBzdHJ1Y3QgZHJtX2Nvbm5lY3Rvcl9zdGF0ZSAqY29ubl9zdGF0 ZSkKPiArc3RhdGljIGludCBpbnRlbF9kc2lfY29tcHV0ZV9jb25maWcoc3RydWN0IGludGVsX2Vu Y29kZXIgKmVuY29kZXIsCj4gKwkJCQkgICAgc3RydWN0IGludGVsX2NydGNfc3RhdGUgKnBpcGVf Y29uZmlnLAo+ICsJCQkJICAgIHN0cnVjdCBkcm1fY29ubmVjdG9yX3N0YXRlICpjb25uX3N0YXRl KQo+ICB7Cj4gIAlzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYgPSB0b19pOTE1KGVu Y29kZXItPmJhc2UuZGV2KTsKPiAgCXN0cnVjdCBpbnRlbF9kc2kgKmludGVsX2RzaSA9IGNvbnRh aW5lcl9vZihlbmNvZGVyLCBzdHJ1Y3QgaW50ZWxfZHNpLAo+IEBAIC0yODQsNyArMjg0LDcgQEAg c3RhdGljIGJvb2wgaW50ZWxfZHNpX2NvbXB1dGVfY29uZmlnKHN0cnVjdCBpbnRlbF9lbmNvZGVy ICplbmNvZGVyLAo+ICAJfQo+ICAKPiAgCWlmIChhZGp1c3RlZF9tb2RlLT5mbGFncyAmIERSTV9N T0RFX0ZMQUdfREJMU0NBTikKPiAtCQlyZXR1cm4gZmFsc2U7Cj4gKwkJcmV0dXJuIC1FSU5WQUw7 Cj4gIAo+ICAJLyogRFNJIHVzZXMgc2hvcnQgcGFja2V0cyBmb3Igc3luYyBldmVudHMsIHNvIGNs ZWFyIG1vZGUgZmxhZ3MgZm9yIERTSSAqLwo+ICAJYWRqdXN0ZWRfbW9kZS0+ZmxhZ3MgPSAwOwo+ IEBAIC0zMDIsMTYgKzMwMiwxNiBAQCBzdGF0aWMgYm9vbCBpbnRlbF9kc2lfY29tcHV0ZV9jb25m aWcoc3RydWN0IGludGVsX2VuY29kZXIgKmVuY29kZXIsCj4gIAo+ICAJCXJldCA9IGJ4dF9kc2lf cGxsX2NvbXB1dGUoZW5jb2RlciwgcGlwZV9jb25maWcpOwo+ICAJCWlmIChyZXQpCj4gLQkJCXJl dHVybiBmYWxzZTsKPiArCQkJcmV0dXJuIC1FSU5WQUw7Cj4gIAl9IGVsc2Ugewo+ICAJCXJldCA9 IHZsdl9kc2lfcGxsX2NvbXB1dGUoZW5jb2RlciwgcGlwZV9jb25maWcpOwo+ICAJCWlmIChyZXQp Cj4gLQkJCXJldHVybiBmYWxzZTsKPiArCQkJcmV0dXJuIC1FSU5WQUw7Cj4gIAl9Cj4gIAo+ICAJ cGlwZV9jb25maWctPmNsb2NrX3NldCA9IHRydWU7Cj4gIAo+IC0JcmV0dXJuIHRydWU7Cj4gKwly ZXR1cm4gMDsKPiAgfQo+ICAKPiAgc3RhdGljIGJvb2wgZ2xrX2RzaV9lbmFibGVfaW8oc3RydWN0 IGludGVsX2VuY29kZXIgKmVuY29kZXIpCj4gLS0gCj4gMi4yMC4xCgotLSAKVmlsbGUgU3lyasOk bMOkCkludGVsCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f CkludGVsLWdmeCBtYWlsaW5nIGxpc3QKSW50ZWwtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpo dHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2ludGVsLWdmeAo= 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 E843EC43387 for ; Tue, 15 Jan 2019 20:19:26 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 906C820866 for ; Tue, 15 Jan 2019 20:19:26 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2389750AbfAOUTY (ORCPT ); Tue, 15 Jan 2019 15:19:24 -0500 Received: from mga05.intel.com ([192.55.52.43]:28569 "EHLO mga05.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1728612AbfAOUTX (ORCPT ); Tue, 15 Jan 2019 15:19:23 -0500 X-Amp-Result: UNKNOWN X-Amp-Original-Verdict: FILE UNKNOWN X-Amp-File-Uploaded: False Received: from fmsmga003.fm.intel.com ([10.253.24.29]) by fmsmga105.fm.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 15 Jan 2019 12:19:23 -0800 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.56,483,1539673200"; d="scan'208";a="126138066" Received: from stinkbox.fi.intel.com (HELO stinkbox) ([10.237.72.174]) by FMSMGA003.fm.intel.com with SMTP; 15 Jan 2019 12:19:19 -0800 Received: by stinkbox (sSMTP sendmail emulation); Tue, 15 Jan 2019 22:19:19 +0200 Date: Tue, 15 Jan 2019 22:19:19 +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 v2] drm/i915: Pass down rc in intel_encoder->compute_config() Message-ID: <20190115201919.GO20097@intel.com> References: <20190115200800.3121-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: <20190115200800.3121-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 Tue, Jan 15, 2019 at 03:08:00PM -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! > > Changes since v1: > * Add some newlines > * Return only -EINVAL from hsw_crt_compute_config() > * Propogate return code from intel_dp_compute_dsc_params() > * Change all of the intel_dp_compute_link_config*() variants > * Don't miss if (hdmi_port_clock_valid()) branch in > intel_hdmi_compute_config() > > 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 Patch looks great. Hopefully we got them all. Reviewed-by: Ville Syrjälä > --- > drivers/gpu/drm/i915/icl_dsi.c | 8 ++-- > drivers/gpu/drm/i915/intel_crt.c | 35 +++++++------- > drivers/gpu/drm/i915/intel_ddi.c | 6 +-- > drivers/gpu/drm/i915/intel_display.c | 11 +++-- > drivers/gpu/drm/i915/intel_dp.c | 71 +++++++++++++++------------- > drivers/gpu/drm/i915/intel_dp_mst.c | 12 ++--- > drivers/gpu/drm/i915/intel_drv.h | 18 +++---- > drivers/gpu/drm/i915/intel_dvo.c | 11 +++-- > drivers/gpu/drm/i915/intel_hdmi.c | 14 +++--- > 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, 122 insertions(+), 112 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..081c333f30d2 100644 > --- a/drivers/gpu/drm/i915/intel_crt.c > +++ b/drivers/gpu/drm/i915/intel_crt.c > @@ -345,51 +345,52 @@ 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; > - 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 -EINVAL; > > pipe_config->has_pch_encoder = true; > pipe_config->output_format = INTEL_OUTPUT_FORMAT_RGB; > @@ -398,7 +399,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 +408,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; > diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c > index 0a5ba45f5eb0..af164d712e9e 100644 > --- a/drivers/gpu/drm/i915/intel_display.c > +++ b/drivers/gpu/drm/i915/intel_display.c > @@ -11553,10 +11553,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..df4292bb1a4f 100644 > --- a/drivers/gpu/drm/i915/intel_dp.c > +++ b/drivers/gpu/drm/i915/intel_dp.c > @@ -1819,7 +1819,7 @@ intel_dp_adjust_compliance_config(struct intel_dp *intel_dp, > } > > /* Optimize link config in order: max bpp, min clock, min lanes */ > -static bool > +static int > intel_dp_compute_link_config_wide(struct intel_dp *intel_dp, > struct intel_crtc_state *pipe_config, > const struct link_config_limits *limits) > @@ -1845,17 +1845,17 @@ intel_dp_compute_link_config_wide(struct intel_dp *intel_dp, > pipe_config->pipe_bpp = bpp; > pipe_config->port_clock = link_clock; > > - return true; > + return 0; > } > } > } > } > > - return false; > + return -EINVAL; > } > > /* Optimize link config in order: max bpp, min lanes, min clock */ > -static bool > +static int > intel_dp_compute_link_config_fast(struct intel_dp *intel_dp, > struct intel_crtc_state *pipe_config, > const struct link_config_limits *limits) > @@ -1881,13 +1881,13 @@ intel_dp_compute_link_config_fast(struct intel_dp *intel_dp, > pipe_config->pipe_bpp = bpp; > pipe_config->port_clock = link_clock; > > - return true; > + return 0; > } > } > } > } > > - return false; > + return -EINVAL; > } > > static int intel_dp_dsc_compute_bpp(struct intel_dp *intel_dp, u8 dsc_max_bpc) > @@ -1905,19 +1905,20 @@ 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); > struct drm_display_mode *adjusted_mode = &pipe_config->base.adjusted_mode; > u8 dsc_max_bpc; > int pipe_bpp; > + int ret; > > 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 +1926,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 +1960,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,16 +1977,19 @@ 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) { > + > + ret = intel_dp_compute_dsc_params(intel_dp, pipe_config); > + if (ret < 0) { > DRM_DEBUG_KMS("Cannot compute valid DSC parameters for Input Bpp = %d " > "Compressed BPP = %d\n", > pipe_config->pipe_bpp, > pipe_config->dsc_params.compressed_bpp); > - return false; > + return ret; > } > + > pipe_config->dsc_params.compression_enable = true; > DRM_DEBUG_KMS("DP DSC computed with Input Bpp = %d " > "Compressed Bpp = %d Slice Count = %d\n", > @@ -1993,10 +1997,10 @@ 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 > +static int > intel_dp_compute_link_config(struct intel_encoder *encoder, > struct intel_crtc_state *pipe_config, > struct drm_connector_state *conn_state) > @@ -2005,7 +2009,7 @@ intel_dp_compute_link_config(struct intel_encoder *encoder, > struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base); > struct link_config_limits limits; > int common_len; > - bool ret; > + int ret; > > common_len = intel_dp_common_len_rate_limit(intel_dp, > intel_dp->max_link_rate); > @@ -2063,10 +2067,11 @@ intel_dp_compute_link_config(struct intel_encoder *encoder, > > /* enable compression if the mode doesn't fit available BW */ > DRM_DEBUG_KMS("Force DSC en = %d\n", intel_dp->force_dsc_en); > - if (!ret || intel_dp->force_dsc_en) { > - if (!intel_dp_dsc_compute_config(intel_dp, pipe_config, > - conn_state, &limits)) > - return false; > + if (ret || intel_dp->force_dsc_en) { > + ret = intel_dp_dsc_compute_config(intel_dp, pipe_config, > + conn_state, &limits); > + if (ret < 0) > + return ret; > } > > if (pipe_config->dsc_params.compression_enable) { > @@ -2091,10 +2096,10 @@ intel_dp_compute_link_config(struct intel_encoder *encoder, > intel_dp_max_data_rate(pipe_config->port_clock, > pipe_config->lane_count)); > } > - return true; > + return 0; > } > > -bool > +int > intel_dp_compute_config(struct intel_encoder *encoder, > struct intel_crtc_state *pipe_config, > struct drm_connector_state *conn_state) > @@ -2110,6 +2115,7 @@ intel_dp_compute_config(struct intel_encoder *encoder, > to_intel_digital_connector_state(conn_state); > bool constant_n = drm_dp_has_quirk(&intel_dp->desc, > DP_DPCD_QUIRK_CONSTANT_N); > + int ret; > > if (HAS_PCH_SPLIT(dev_priv) && !HAS_DDI(dev_priv) && port != PORT_A) > pipe_config->has_pch_encoder = true; > @@ -2131,8 +2137,6 @@ intel_dp_compute_config(struct intel_encoder *encoder, > adjusted_mode); > > if (INTEL_GEN(dev_priv) >= 9) { > - int ret; > - > ret = skl_update_scaler_crtc(pipe_config); > if (ret) > return ret; > @@ -2147,20 +2151,21 @@ intel_dp_compute_config(struct intel_encoder *encoder, > } > > 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; > + ret = intel_dp_compute_link_config(encoder, pipe_config, conn_state); > + if (ret < 0) > + return ret; > > if (intel_conn_state->broadcast_rgb == INTEL_BROADCAST_RGB_AUTO) { > /* > @@ -2208,7 +2213,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..a6c82482a841 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,11 @@ 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; > - 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..97a98e1bea56 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; > } > } > > @@ -1803,7 +1803,7 @@ bool intel_hdmi_compute_config(struct intel_encoder *encoder, > if (hdmi_port_clock_valid(intel_hdmi, pipe_config->port_clock, > false, force_dvi) != MODE_OK) { > DRM_DEBUG_KMS("unsupported HDMI clock, rejecting mode\n"); > - return false; > + return -EINVAL; > } > > /* Set user selected PAR to incoming mode's member */ > @@ -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