From mboxrd@z Thu Jan 1 00:00:00 1970 From: Jani Nikula Subject: Re: [PATCH v2] drm/i915: Pass down rc in intel_encoder->compute_config() Date: Wed, 16 Jan 2019 09:47:17 +0200 Message-ID: <87r2dd59iy.fsf@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: 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 , intel-gfx@lists.freedesktop.org Cc: David Airlie , linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org List-Id: dri-devel@lists.freedesktop.org T24gVHVlLCAxNSBKYW4gMjAxOSwgTHl1ZGUgUGF1bCA8bHl1ZGVAcmVkaGF0LmNvbT4gd3JvdGU6 Cj4gU29tZXRoaW5nIHRoYXQgSSBjb21wbGV0ZWx5IG1pc3NlZCB3aGVuIGltcGxlbWVudGluZyB0 aGUgbmV3IE1TVCBWQ1BJCj4gYXRvbWljIGhlbHBlcnMgaXMgdGhhdCB3aXRoIHRob3NlIGhlbHBl cnMsIHRoZXJlJ3MgdGVjaG5pY2FsbHkgYSBjaGFuY2UKPiBvZiB1cyBoYXZpbmcgdG8gZ3JhYiBh ZGRpdGlvbmFsIG1vZGVzZXQgbG9ja3MgaW4gLT5jb21wdXRlX2NvbmZpZygpIGFuZAo+IGZ1cnRo ZXJtb3JlLCB0aGF0IG1lYW5zIHdlIGhhdmUgdGhlIHBvdGVudGlhbCB0byBoaXQgYSBub3JtYWwg bW9kZXNldAo+IGRlYWRsb2NrLiBIb3dldmVyLCBiZWNhdXNlIC0+Y29tcHV0ZV9jb25maWcoKSBv bmx5IHJldHVybnMgYSBib29sIHRoaXMKPiBtZWFucyB3ZSBjYW4ndCByZXR1cm4gLUVERUFETEsg d2hlbiB3ZSBuZWVkIHRvIGRyb3AgbG9ja3MgYW5kIHRyeSBhZ2Fpbgo+IHdoaWNoIG1lYW5zIHdl IGVuZCB1cCBqdXN0IGZhaWxpbmcgdGhlIGF0b21pYyBjaGVjayBwZXJtYW5lbnRseS4gV2hvb3Bz Lgo+Cj4gU28sIGZpeCB0aGlzIGJ5IG1vZGlmeWluZyAtPmNvbXB1dGVfY29uZmlnKCkgdG8gcGFz cyBkb3duIGFuIGFjdHVhbAo+IGVycm9yIGNvZGUgaW5zdGVhZCBvZiBhIGJvb2wgc28gdGhhdCB0 aGUgYXRvbWljIGNoZWNrIGNhbiBiZSByZXN0YXJ0ZWQKPiBvbiBtb2Rlc2V0IGRlYWRsb2Nrcy4K Pgo+IFRoYW5rcyB0byBWaWxsZSBTeXJqw6Rsw6QgZm9yIHBvaW50aW5nIHRoaXMgb3V0IQo+Cj4g Q2hhbmdlcyBzaW5jZSB2MToKPiAqIEFkZCBzb21lIG5ld2xpbmVzCj4gKiBSZXR1cm4gb25seSAt RUlOVkFMIGZyb20gaHN3X2NydF9jb21wdXRlX2NvbmZpZygpCj4gKiBQcm9wb2dhdGUgcmV0dXJu IGNvZGUgZnJvbSBpbnRlbF9kcF9jb21wdXRlX2RzY19wYXJhbXMoKQo+ICogQ2hhbmdlIGFsbCBv ZiB0aGUgaW50ZWxfZHBfY29tcHV0ZV9saW5rX2NvbmZpZyooKSB2YXJpYW50cwo+ICogRG9uJ3Qg bWlzcyBpZiAoaGRtaV9wb3J0X2Nsb2NrX3ZhbGlkKCkpIGJyYW5jaCBpbgo+ICAgaW50ZWxfaGRt aV9jb21wdXRlX2NvbmZpZygpCj4KPiBTaWduZWQtb2ZmLWJ5OiBMeXVkZSBQYXVsIDxseXVkZUBy ZWRoYXQuY29tPgo+IENjOiBWaWxsZSBTeXJqw6Rsw6QgPHZpbGxlLnN5cmphbGFAbGludXguaW50 ZWwuY29tPgo+IEZpeGVzOiBlY2VhZTE0NzI0NjcgKCJkcm0vZHBfbXN0OiBTdGFydCB0cmFja2lu ZyBwZXItcG9ydCBWQ1BJIGFsbG9jYXRpb25zIikKPiBCdWd6aWxsYTogaHR0cHM6Ly9idWdzLmZy ZWVkZXNrdG9wLm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTA5MzIwCj4gLS0tCj4gIGRyaXZlcnMvZ3B1 L2RybS9pOTE1L2ljbF9kc2kuYyAgICAgICB8ICA4ICsrLS0KPiAgZHJpdmVycy9ncHUvZHJtL2k5 MTUvaW50ZWxfY3J0LmMgICAgIHwgMzUgKysrKysrKy0tLS0tLS0KPiAgZHJpdmVycy9ncHUvZHJt L2k5MTUvaW50ZWxfZGRpLmMgICAgIHwgIDYgKy0tCj4gIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2lu dGVsX2Rpc3BsYXkuYyB8IDExICsrKy0tCj4gIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rw LmMgICAgICB8IDcxICsrKysrKysrKysrKysrKy0tLS0tLS0tLS0tLS0KPiAgZHJpdmVycy9ncHUv ZHJtL2k5MTUvaW50ZWxfZHBfbXN0LmMgIHwgMTIgKystLS0KPiAgZHJpdmVycy9ncHUvZHJtL2k5 MTUvaW50ZWxfZHJ2LmggICAgIHwgMTggKysrLS0tLQo+ICBkcml2ZXJzL2dwdS9kcm0vaTkxNS9p bnRlbF9kdm8uYyAgICAgfCAxMSArKystLQo+ICBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9o ZG1pLmMgICAgfCAxNCArKystLS0KPiAgZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfbHZkcy5j ICAgIHwgMTIgKystLS0KPiAgZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfc2R2by5jICAgIHwg MTQgKysrLS0tCj4gIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3R2LmMgICAgICB8ICA4ICsr LS0KPiAgZHJpdmVycy9ncHUvZHJtL2k5MTUvdmx2X2RzaS5jICAgICAgIHwgMTQgKysrLS0tCj4g IDEzIGZpbGVzIGNoYW5nZWQsIDEyMiBpbnNlcnRpb25zKCspLCAxMTIgZGVsZXRpb25zKC0pCgpE ZXNwaXRlIGJlaW5nIGFuIGFsbCBpOTE1IHBhdGNoLCB0aGlzIGdvdCBhcHBsaWVkIHRvIGRybS1t aXNjLW5leHQsCmNhdXNpbmcgY29uZmxpY3RzIHdoZXJlIHRoZXJlIHJlYWxseSBzaG91bGQgaGF2 ZSBiZWVuIG5vbmUuIDooCgpJIGFtIHRlbXB0ZWQgdG8gc3VnZ2VzdCByZXZlcnRpbmcgYW5kIHJl LWFwcGx5aW5nIHRvIGRybS1pbnRlbCwgYmVjYXVzZQppdCB3aWxsIHRha2Ugd2Vla3MgdG8gc3lu YyBib3RoIHRvIGRybS1uZXh0IGFuZCBiYWNrbWVyZ2UsIGFuZCBhcHBseWluZwpmdXJ0aGVyIHdv cmsgb24gdG9wIGluIGRybS1pbnRlbCB3aWxsIGp1c3QgY2F1c2UgbW9yZSB0cm91YmxlLgoKT3Ro ZXIgaWRlYXM/CgpCUiwKSmFuaS4KCgo+Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9p OTE1L2ljbF9kc2kuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ljbF9kc2kuYwo+IGluZGV4IGYz YTVmMDM2NDZjZS4uMzU1YjQ4ZDFjOTM3IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9p OTE1L2ljbF9kc2kuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ljbF9kc2kuYwo+IEBA IC0xMTg4LDkgKzExODgsOSBAQCBzdGF0aWMgdm9pZCBnZW4xMV9kc2lfZ2V0X2NvbmZpZyhzdHJ1 Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2RlciwKPiAgCXBpcGVfY29uZmlnLT5vdXRwdXRfdHlwZXMg fD0gQklUKElOVEVMX09VVFBVVF9EU0kpOwo+ICB9Cj4gIAo+IC1zdGF0aWMgYm9vbCBnZW4xMV9k c2lfY29tcHV0ZV9jb25maWcoc3RydWN0IGludGVsX2VuY29kZXIgKmVuY29kZXIsCj4gLQkJCQkg ICAgIHN0cnVjdCBpbnRlbF9jcnRjX3N0YXRlICpwaXBlX2NvbmZpZywKPiAtCQkJCSAgICAgc3Ry dWN0IGRybV9jb25uZWN0b3Jfc3RhdGUgKmNvbm5fc3RhdGUpCj4gK3N0YXRpYyBpbnQgZ2VuMTFf ZHNpX2NvbXB1dGVfY29uZmlnKHN0cnVjdCBpbnRlbF9lbmNvZGVyICplbmNvZGVyLAo+ICsJCQkJ ICAgIHN0cnVjdCBpbnRlbF9jcnRjX3N0YXRlICpwaXBlX2NvbmZpZywKPiArCQkJCSAgICBzdHJ1 Y3QgZHJtX2Nvbm5lY3Rvcl9zdGF0ZSAqY29ubl9zdGF0ZSkKPiAgewo+ICAJc3RydWN0IGludGVs X2RzaSAqaW50ZWxfZHNpID0gY29udGFpbmVyX29mKGVuY29kZXIsIHN0cnVjdCBpbnRlbF9kc2ks Cj4gIAkJCQkJCSAgIGJhc2UpOwo+IEBAIC0xMjE1LDcgKzEyMTUsNyBAQCBzdGF0aWMgYm9vbCBn ZW4xMV9kc2lfY29tcHV0ZV9jb25maWcoc3RydWN0IGludGVsX2VuY29kZXIgKmVuY29kZXIsCj4g IAlwaXBlX2NvbmZpZy0+Y2xvY2tfc2V0ID0gdHJ1ZTsKPiAgCXBpcGVfY29uZmlnLT5wb3J0X2Ns b2NrID0gaW50ZWxfZHNpX2JpdHJhdGUoaW50ZWxfZHNpKSAvIDU7Cj4gIAo+IC0JcmV0dXJuIHRy dWU7Cj4gKwlyZXR1cm4gMDsKPiAgfQo+ICAKPiAgc3RhdGljIHU2NCBnZW4xMV9kc2lfZ2V0X3Bv d2VyX2RvbWFpbnMoc3RydWN0IGludGVsX2VuY29kZXIgKmVuY29kZXIsCj4gZGlmZiAtLWdpdCBh L2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2NydC5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUv aW50ZWxfY3J0LmMKPiBpbmRleCAzM2JkMmFkZGNiZGQuLjA4MWMzMzNmMzBkMiAxMDA2NDQKPiAt LS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9jcnQuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1 L2RybS9pOTE1L2ludGVsX2NydC5jCj4gQEAgLTM0NSw1MSArMzQ1LDUyIEBAIGludGVsX2NydF9t b2RlX3ZhbGlkKHN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3IsCj4gIAlyZXR1cm4gTU9E RV9PSzsKPiAgfQo+ICAKPiAtc3RhdGljIGJvb2wgaW50ZWxfY3J0X2NvbXB1dGVfY29uZmlnKHN0 cnVjdCBpbnRlbF9lbmNvZGVyICplbmNvZGVyLAo+IC0JCQkJICAgICBzdHJ1Y3QgaW50ZWxfY3J0 Y19zdGF0ZSAqcGlwZV9jb25maWcsCj4gLQkJCQkgICAgIHN0cnVjdCBkcm1fY29ubmVjdG9yX3N0 YXRlICpjb25uX3N0YXRlKQo+ICtzdGF0aWMgaW50IGludGVsX2NydF9jb21wdXRlX2NvbmZpZyhz dHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2RlciwKPiArCQkJCSAgICBzdHJ1Y3QgaW50ZWxfY3J0 Y19zdGF0ZSAqcGlwZV9jb25maWcsCj4gKwkJCQkgICAgc3RydWN0IGRybV9jb25uZWN0b3Jfc3Rh dGUgKmNvbm5fc3RhdGUpCj4gIHsKPiAgCXN0cnVjdCBkcm1fZGlzcGxheV9tb2RlICphZGp1c3Rl ZF9tb2RlID0KPiAgCQkmcGlwZV9jb25maWctPmJhc2UuYWRqdXN0ZWRfbW9kZTsKPiAgCj4gIAlp ZiAoYWRqdXN0ZWRfbW9kZS0+ZmxhZ3MgJiBEUk1fTU9ERV9GTEFHX0RCTFNDQU4pCj4gLQkJcmV0 dXJuIGZhbHNlOwo+ICsJCXJldHVybiAtRUlOVkFMOwo+ICAKPiAgCXBpcGVfY29uZmlnLT5vdXRw dXRfZm9ybWF0ID0gSU5URUxfT1VUUFVUX0ZPUk1BVF9SR0I7Cj4gLQlyZXR1cm4gdHJ1ZTsKPiAr Cj4gKwlyZXR1cm4gMDsKPiAgfQo+ICAKPiAtc3RhdGljIGJvb2wgcGNoX2NydF9jb21wdXRlX2Nv bmZpZyhzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2RlciwKPiAtCQkJCSAgIHN0cnVjdCBpbnRl bF9jcnRjX3N0YXRlICpwaXBlX2NvbmZpZywKPiAtCQkJCSAgIHN0cnVjdCBkcm1fY29ubmVjdG9y X3N0YXRlICpjb25uX3N0YXRlKQo+ICtzdGF0aWMgaW50IHBjaF9jcnRfY29tcHV0ZV9jb25maWco c3RydWN0IGludGVsX2VuY29kZXIgKmVuY29kZXIsCj4gKwkJCQkgIHN0cnVjdCBpbnRlbF9jcnRj X3N0YXRlICpwaXBlX2NvbmZpZywKPiArCQkJCSAgc3RydWN0IGRybV9jb25uZWN0b3Jfc3RhdGUg KmNvbm5fc3RhdGUpCj4gIHsKPiAgCXN0cnVjdCBkcm1fZGlzcGxheV9tb2RlICphZGp1c3RlZF9t b2RlID0KPiAgCQkmcGlwZV9jb25maWctPmJhc2UuYWRqdXN0ZWRfbW9kZTsKPiAgCj4gIAlpZiAo YWRqdXN0ZWRfbW9kZS0+ZmxhZ3MgJiBEUk1fTU9ERV9GTEFHX0RCTFNDQU4pCj4gLQkJcmV0dXJu IGZhbHNlOwo+ICsJCXJldHVybiAtRUlOVkFMOwo+ICAKPiAgCXBpcGVfY29uZmlnLT5oYXNfcGNo X2VuY29kZXIgPSB0cnVlOwo+ICAJcGlwZV9jb25maWctPm91dHB1dF9mb3JtYXQgPSBJTlRFTF9P VVRQVVRfRk9STUFUX1JHQjsKPiAgCj4gLQlyZXR1cm4gdHJ1ZTsKPiArCXJldHVybiAwOwo+ICB9 Cj4gIAo+IC1zdGF0aWMgYm9vbCBoc3dfY3J0X2NvbXB1dGVfY29uZmlnKHN0cnVjdCBpbnRlbF9l bmNvZGVyICplbmNvZGVyLAo+IC0JCQkJICAgc3RydWN0IGludGVsX2NydGNfc3RhdGUgKnBpcGVf Y29uZmlnLAo+IC0JCQkJICAgc3RydWN0IGRybV9jb25uZWN0b3Jfc3RhdGUgKmNvbm5fc3RhdGUp Cj4gK3N0YXRpYyBpbnQgaHN3X2NydF9jb21wdXRlX2NvbmZpZyhzdHJ1Y3QgaW50ZWxfZW5jb2Rl ciAqZW5jb2RlciwKPiArCQkJCSAgc3RydWN0IGludGVsX2NydGNfc3RhdGUgKnBpcGVfY29uZmln LAo+ICsJCQkJICBzdHJ1Y3QgZHJtX2Nvbm5lY3Rvcl9zdGF0ZSAqY29ubl9zdGF0ZSkKPiAgewo+ ICAJc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2ID0gdG9faTkxNShlbmNvZGVyLT5i YXNlLmRldik7Cj4gIAlzdHJ1Y3QgZHJtX2Rpc3BsYXlfbW9kZSAqYWRqdXN0ZWRfbW9kZSA9Cj4g IAkJJnBpcGVfY29uZmlnLT5iYXNlLmFkanVzdGVkX21vZGU7Cj4gIAo+ICAJaWYgKGFkanVzdGVk X21vZGUtPmZsYWdzICYgRFJNX01PREVfRkxBR19EQkxTQ0FOKQo+IC0JCXJldHVybiBmYWxzZTsK PiArCQlyZXR1cm4gLUVJTlZBTDsKPiAgCj4gIAkvKiBIU1cvQkRXIEZESSBsaW1pdGVkIHRvIDRr ICovCj4gIAlpZiAoYWRqdXN0ZWRfbW9kZS0+Y3J0Y19oZGlzcGxheSA+IDQwOTYgfHwKPiAgCSAg ICBhZGp1c3RlZF9tb2RlLT5jcnRjX2hibGFua19zdGFydCA+IDQwOTYpCj4gLQkJcmV0dXJuIGZh bHNlOwo+ICsJCXJldHVybiAtRUlOVkFMOwo+ICAKPiAgCXBpcGVfY29uZmlnLT5oYXNfcGNoX2Vu Y29kZXIgPSB0cnVlOwo+ICAJcGlwZV9jb25maWctPm91dHB1dF9mb3JtYXQgPSBJTlRFTF9PVVRQ VVRfRk9STUFUX1JHQjsKPiBAQCAtMzk4LDcgKzM5OSw3IEBAIHN0YXRpYyBib29sIGhzd19jcnRf Y29tcHV0ZV9jb25maWcoc3RydWN0IGludGVsX2VuY29kZXIgKmVuY29kZXIsCj4gIAlpZiAoSEFT X1BDSF9MUFQoZGV2X3ByaXYpKSB7Cj4gIAkJaWYgKHBpcGVfY29uZmlnLT5id19jb25zdHJhaW5l ZCAmJiBwaXBlX2NvbmZpZy0+cGlwZV9icHAgPCAyNCkgewo+ICAJCQlEUk1fREVCVUdfS01TKCJM UFQgb25seSBzdXBwb3J0cyAyNGJwcFxuIik7Cj4gLQkJCXJldHVybiBmYWxzZTsKPiArCQkJcmV0 dXJuIC1FSU5WQUw7Cj4gIAkJfQo+ICAKPiAgCQlwaXBlX2NvbmZpZy0+cGlwZV9icHAgPSAyNDsK PiBAQCAtNDA3LDcgKzQwOCw3IEBAIHN0YXRpYyBib29sIGhzd19jcnRfY29tcHV0ZV9jb25maWco c3RydWN0IGludGVsX2VuY29kZXIgKmVuY29kZXIsCj4gIAkvKiBGREkgbXVzdCBhbHdheXMgYmUg Mi43IEdIeiAqLwo+ICAJcGlwZV9jb25maWctPnBvcnRfY2xvY2sgPSAxMzUwMDAgKiAyOwo+ICAK PiAtCXJldHVybiB0cnVlOwo+ICsJcmV0dXJuIDA7Cj4gIH0KPiAgCj4gIHN0YXRpYyBib29sIGlu dGVsX2lyb25sYWtlX2NydF9kZXRlY3RfaG90cGx1ZyhzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29u bmVjdG9yKQo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kZGkuYyBi L2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2RkaS5jCj4gaW5kZXggN2YzY2QwNTVkZTUwLi5j ZTQ0NzQ0YTVmOWQgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZGRp LmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kZGkuYwo+IEBAIC0zODM3LDkg KzM4MzcsOSBAQCBpbnRlbF9kZGlfY29tcHV0ZV9vdXRwdXRfdHlwZShzdHJ1Y3QgaW50ZWxfZW5j b2RlciAqZW5jb2RlciwKPiAgCX0KPiAgfQo+ICAKPiAtc3RhdGljIGJvb2wgaW50ZWxfZGRpX2Nv bXB1dGVfY29uZmlnKHN0cnVjdCBpbnRlbF9lbmNvZGVyICplbmNvZGVyLAo+IC0JCQkJICAgICBz dHJ1Y3QgaW50ZWxfY3J0Y19zdGF0ZSAqcGlwZV9jb25maWcsCj4gLQkJCQkgICAgIHN0cnVjdCBk cm1fY29ubmVjdG9yX3N0YXRlICpjb25uX3N0YXRlKQo+ICtzdGF0aWMgaW50IGludGVsX2RkaV9j b21wdXRlX2NvbmZpZyhzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2RlciwKPiArCQkJCSAgICBz dHJ1Y3QgaW50ZWxfY3J0Y19zdGF0ZSAqcGlwZV9jb25maWcsCj4gKwkJCQkgICAgc3RydWN0IGRy bV9jb25uZWN0b3Jfc3RhdGUgKmNvbm5fc3RhdGUpCj4gIHsKPiAgCXN0cnVjdCBkcm1faTkxNV9w cml2YXRlICpkZXZfcHJpdiA9IHRvX2k5MTUoZW5jb2Rlci0+YmFzZS5kZXYpOwo+ICAJZW51bSBw b3J0IHBvcnQgPSBlbmNvZGVyLT5wb3J0Owo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0v aTkxNS9pbnRlbF9kaXNwbGF5LmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kaXNwbGF5 LmMKPiBpbmRleCAwYTViYTQ1ZjVlYjAuLmFmMTY0ZDcxMmU5ZSAxMDA2NDQKPiAtLS0gYS9kcml2 ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kaXNwbGF5LmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0v aTkxNS9pbnRlbF9kaXNwbGF5LmMKPiBAQCAtMTE1NTMsMTAgKzExNTUzLDEzIEBAIGludGVsX21v ZGVzZXRfcGlwZV9jb25maWcoc3RydWN0IGRybV9jcnRjICpjcnRjLAo+ICAJCQljb250aW51ZTsK PiAgCj4gIAkJZW5jb2RlciA9IHRvX2ludGVsX2VuY29kZXIoY29ubmVjdG9yX3N0YXRlLT5iZXN0 X2VuY29kZXIpOwo+IC0KPiAtCQlpZiAoIShlbmNvZGVyLT5jb21wdXRlX2NvbmZpZyhlbmNvZGVy LCBwaXBlX2NvbmZpZywgY29ubmVjdG9yX3N0YXRlKSkpIHsKPiAtCQkJRFJNX0RFQlVHX0tNUygi RW5jb2RlciBjb25maWcgZmFpbHVyZVxuIik7Cj4gLQkJCXJldHVybiAtRUlOVkFMOwo+ICsJCXJl dCA9IGVuY29kZXItPmNvbXB1dGVfY29uZmlnKGVuY29kZXIsIHBpcGVfY29uZmlnLAo+ICsJCQkJ CSAgICAgIGNvbm5lY3Rvcl9zdGF0ZSk7Cj4gKwkJaWYgKHJldCA8IDApIHsKPiArCQkJaWYgKHJl dCAhPSAtRURFQURMSykKPiArCQkJCURSTV9ERUJVR19LTVMoIkVuY29kZXIgY29uZmlnIGZhaWx1 cmU6ICVkXG4iLAo+ICsJCQkJCSAgICAgIHJldCk7Cj4gKwkJCXJldHVybiByZXQ7Cj4gIAkJfQo+ ICAJfQo+ICAKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHAuYyBi L2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2RwLmMKPiBpbmRleCAwYTNhYzk4YTc3OWUuLmRm NDI5MmJiMWE0ZiAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kcC5j Cj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHAuYwo+IEBAIC0xODE5LDcgKzE4 MTksNyBAQCBpbnRlbF9kcF9hZGp1c3RfY29tcGxpYW5jZV9jb25maWcoc3RydWN0IGludGVsX2Rw ICppbnRlbF9kcCwKPiAgfQo+ICAKPiAgLyogT3B0aW1pemUgbGluayBjb25maWcgaW4gb3JkZXI6 IG1heCBicHAsIG1pbiBjbG9jaywgbWluIGxhbmVzICovCj4gLXN0YXRpYyBib29sCj4gK3N0YXRp YyBpbnQKPiAgaW50ZWxfZHBfY29tcHV0ZV9saW5rX2NvbmZpZ193aWRlKHN0cnVjdCBpbnRlbF9k cCAqaW50ZWxfZHAsCj4gIAkJCQkgIHN0cnVjdCBpbnRlbF9jcnRjX3N0YXRlICpwaXBlX2NvbmZp ZywKPiAgCQkJCSAgY29uc3Qgc3RydWN0IGxpbmtfY29uZmlnX2xpbWl0cyAqbGltaXRzKQo+IEBA IC0xODQ1LDE3ICsxODQ1LDE3IEBAIGludGVsX2RwX2NvbXB1dGVfbGlua19jb25maWdfd2lkZShz dHJ1Y3QgaW50ZWxfZHAgKmludGVsX2RwLAo+ICAJCQkJCXBpcGVfY29uZmlnLT5waXBlX2JwcCA9 IGJwcDsKPiAgCQkJCQlwaXBlX2NvbmZpZy0+cG9ydF9jbG9jayA9IGxpbmtfY2xvY2s7Cj4gIAo+ IC0JCQkJCXJldHVybiB0cnVlOwo+ICsJCQkJCXJldHVybiAwOwo+ICAJCQkJfQo+ICAJCQl9Cj4g IAkJfQo+ICAJfQo+ICAKPiAtCXJldHVybiBmYWxzZTsKPiArCXJldHVybiAtRUlOVkFMOwo+ICB9 Cj4gIAo+ICAvKiBPcHRpbWl6ZSBsaW5rIGNvbmZpZyBpbiBvcmRlcjogbWF4IGJwcCwgbWluIGxh bmVzLCBtaW4gY2xvY2sgKi8KPiAtc3RhdGljIGJvb2wKPiArc3RhdGljIGludAo+ICBpbnRlbF9k cF9jb21wdXRlX2xpbmtfY29uZmlnX2Zhc3Qoc3RydWN0IGludGVsX2RwICppbnRlbF9kcCwKPiAg CQkJCSAgc3RydWN0IGludGVsX2NydGNfc3RhdGUgKnBpcGVfY29uZmlnLAo+ICAJCQkJICBjb25z dCBzdHJ1Y3QgbGlua19jb25maWdfbGltaXRzICpsaW1pdHMpCj4gQEAgLTE4ODEsMTMgKzE4ODEs MTMgQEAgaW50ZWxfZHBfY29tcHV0ZV9saW5rX2NvbmZpZ19mYXN0KHN0cnVjdCBpbnRlbF9kcCAq aW50ZWxfZHAsCj4gIAkJCQkJcGlwZV9jb25maWctPnBpcGVfYnBwID0gYnBwOwo+ICAJCQkJCXBp cGVfY29uZmlnLT5wb3J0X2Nsb2NrID0gbGlua19jbG9jazsKPiAgCj4gLQkJCQkJcmV0dXJuIHRy dWU7Cj4gKwkJCQkJcmV0dXJuIDA7Cj4gIAkJCQl9Cj4gIAkJCX0KPiAgCQl9Cj4gIAl9Cj4gIAo+ IC0JcmV0dXJuIGZhbHNlOwo+ICsJcmV0dXJuIC1FSU5WQUw7Cj4gIH0KPiAgCj4gIHN0YXRpYyBp bnQgaW50ZWxfZHBfZHNjX2NvbXB1dGVfYnBwKHN0cnVjdCBpbnRlbF9kcCAqaW50ZWxfZHAsIHU4 IGRzY19tYXhfYnBjKQo+IEBAIC0xOTA1LDE5ICsxOTA1LDIwIEBAIHN0YXRpYyBpbnQgaW50ZWxf ZHBfZHNjX2NvbXB1dGVfYnBwKHN0cnVjdCBpbnRlbF9kcCAqaW50ZWxfZHAsIHU4IGRzY19tYXhf YnBjKQo+ICAJcmV0dXJuIDA7Cj4gIH0KPiAgCj4gLXN0YXRpYyBib29sIGludGVsX2RwX2RzY19j b21wdXRlX2NvbmZpZyhzdHJ1Y3QgaW50ZWxfZHAgKmludGVsX2RwLAo+IC0JCQkJCXN0cnVjdCBp bnRlbF9jcnRjX3N0YXRlICpwaXBlX2NvbmZpZywKPiAtCQkJCQlzdHJ1Y3QgZHJtX2Nvbm5lY3Rv cl9zdGF0ZSAqY29ubl9zdGF0ZSwKPiAtCQkJCQlzdHJ1Y3QgbGlua19jb25maWdfbGltaXRzICps aW1pdHMpCj4gK3N0YXRpYyBpbnQgaW50ZWxfZHBfZHNjX2NvbXB1dGVfY29uZmlnKHN0cnVjdCBp bnRlbF9kcCAqaW50ZWxfZHAsCj4gKwkJCQkgICAgICAgc3RydWN0IGludGVsX2NydGNfc3RhdGUg KnBpcGVfY29uZmlnLAo+ICsJCQkJICAgICAgIHN0cnVjdCBkcm1fY29ubmVjdG9yX3N0YXRlICpj b25uX3N0YXRlLAo+ICsJCQkJICAgICAgIHN0cnVjdCBsaW5rX2NvbmZpZ19saW1pdHMgKmxpbWl0 cykKPiAgewo+ICAJc3RydWN0IGludGVsX2RpZ2l0YWxfcG9ydCAqZGlnX3BvcnQgPSBkcF90b19k aWdfcG9ydChpbnRlbF9kcCk7Cj4gIAlzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYg PSB0b19pOTE1KGRpZ19wb3J0LT5iYXNlLmJhc2UuZGV2KTsKPiAgCXN0cnVjdCBkcm1fZGlzcGxh eV9tb2RlICphZGp1c3RlZF9tb2RlID0gJnBpcGVfY29uZmlnLT5iYXNlLmFkanVzdGVkX21vZGU7 Cj4gIAl1OCBkc2NfbWF4X2JwYzsKPiAgCWludCBwaXBlX2JwcDsKPiArCWludCByZXQ7Cj4gIAo+ ICAJaWYgKCFpbnRlbF9kcF9zdXBwb3J0c19kc2MoaW50ZWxfZHAsIHBpcGVfY29uZmlnKSkKPiAt CQlyZXR1cm4gZmFsc2U7Cj4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4gIAo+ICAJZHNjX21heF9icGMg PSBtaW5fdCh1OCwgRFBfRFNDX01BWF9TVVBQT1JURURfQlBDLAo+ICAJCQkgICAgY29ubl9zdGF0 ZS0+bWF4X3JlcXVlc3RlZF9icGMpOwo+IEBAIC0xOTI1LDcgKzE5MjYsNyBAQCBzdGF0aWMgYm9v bCBpbnRlbF9kcF9kc2NfY29tcHV0ZV9jb25maWcoc3RydWN0IGludGVsX2RwICppbnRlbF9kcCwK PiAgCXBpcGVfYnBwID0gaW50ZWxfZHBfZHNjX2NvbXB1dGVfYnBwKGludGVsX2RwLCBkc2NfbWF4 X2JwYyk7Cj4gIAlpZiAocGlwZV9icHAgPCBEUF9EU0NfTUlOX1NVUFBPUlRFRF9CUEMgKiAzKSB7 Cj4gIAkJRFJNX0RFQlVHX0tNUygiTm8gRFNDIHN1cHBvcnQgZm9yIGxlc3MgdGhhbiA4YnBjXG4i KTsKPiAtCQlyZXR1cm4gZmFsc2U7Cj4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4gIAl9Cj4gIAo+ICAJ LyoKPiBAQCAtMTk1OSw3ICsxOTYwLDcgQEAgc3RhdGljIGJvb2wgaW50ZWxfZHBfZHNjX2NvbXB1 dGVfY29uZmlnKHN0cnVjdCBpbnRlbF9kcCAqaW50ZWxfZHAsCj4gIAkJCQkJCSAgICAgYWRqdXN0 ZWRfbW9kZS0+Y3J0Y19oZGlzcGxheSk7Cj4gIAkJaWYgKCFkc2NfbWF4X291dHB1dF9icHAgfHwg IWRzY19kcF9zbGljZV9jb3VudCkgewo+ICAJCQlEUk1fREVCVUdfS01TKCJDb21wcmVzc2VkIEJQ UC9TbGljZSBDb3VudCBub3Qgc3VwcG9ydGVkXG4iKTsKPiAtCQkJcmV0dXJuIGZhbHNlOwo+ICsJ CQlyZXR1cm4gLUVJTlZBTDsKPiAgCQl9Cj4gIAkJcGlwZV9jb25maWctPmRzY19wYXJhbXMuY29t cHJlc3NlZF9icHAgPSBtaW5fdCh1MTYsCj4gIAkJCQkJCQkgICAgICAgZHNjX21heF9vdXRwdXRf YnBwID4+IDQsCj4gQEAgLTE5NzYsMTYgKzE5NzcsMTkgQEAgc3RhdGljIGJvb2wgaW50ZWxfZHBf ZHNjX2NvbXB1dGVfY29uZmlnKHN0cnVjdCBpbnRlbF9kcCAqaW50ZWxfZHAsCj4gIAkJCXBpcGVf Y29uZmlnLT5kc2NfcGFyYW1zLmRzY19zcGxpdCA9IHRydWU7Cj4gIAkJfSBlbHNlIHsKPiAgCQkJ RFJNX0RFQlVHX0tNUygiQ2Fubm90IHNwbGl0IHN0cmVhbSB0byB1c2UgMiBWRFNDIGluc3RhbmNl c1xuIik7Cj4gLQkJCXJldHVybiBmYWxzZTsKPiArCQkJcmV0dXJuIC1FSU5WQUw7Cj4gIAkJfQo+ ICAJfQo+IC0JaWYgKGludGVsX2RwX2NvbXB1dGVfZHNjX3BhcmFtcyhpbnRlbF9kcCwgcGlwZV9j b25maWcpIDwgMCkgewo+ICsKPiArCXJldCA9IGludGVsX2RwX2NvbXB1dGVfZHNjX3BhcmFtcyhp bnRlbF9kcCwgcGlwZV9jb25maWcpOwo+ICsJaWYgKHJldCA8IDApIHsKPiAgCQlEUk1fREVCVUdf S01TKCJDYW5ub3QgY29tcHV0ZSB2YWxpZCBEU0MgcGFyYW1ldGVycyBmb3IgSW5wdXQgQnBwID0g JWQgIgo+ICAJCQkgICAgICAiQ29tcHJlc3NlZCBCUFAgPSAlZFxuIiwKPiAgCQkJICAgICAgcGlw ZV9jb25maWctPnBpcGVfYnBwLAo+ICAJCQkgICAgICBwaXBlX2NvbmZpZy0+ZHNjX3BhcmFtcy5j b21wcmVzc2VkX2JwcCk7Cj4gLQkJcmV0dXJuIGZhbHNlOwo+ICsJCXJldHVybiByZXQ7Cj4gIAl9 Cj4gKwo+ICAJcGlwZV9jb25maWctPmRzY19wYXJhbXMuY29tcHJlc3Npb25fZW5hYmxlID0gdHJ1 ZTsKPiAgCURSTV9ERUJVR19LTVMoIkRQIERTQyBjb21wdXRlZCB3aXRoIElucHV0IEJwcCA9ICVk ICIKPiAgCQkgICAgICAiQ29tcHJlc3NlZCBCcHAgPSAlZCBTbGljZSBDb3VudCA9ICVkXG4iLAo+ IEBAIC0xOTkzLDEwICsxOTk3LDEwIEBAIHN0YXRpYyBib29sIGludGVsX2RwX2RzY19jb21wdXRl X2NvbmZpZyhzdHJ1Y3QgaW50ZWxfZHAgKmludGVsX2RwLAo+ICAJCSAgICAgIHBpcGVfY29uZmln LT5kc2NfcGFyYW1zLmNvbXByZXNzZWRfYnBwLAo+ICAJCSAgICAgIHBpcGVfY29uZmlnLT5kc2Nf cGFyYW1zLnNsaWNlX2NvdW50KTsKPiAgCj4gLQlyZXR1cm4gdHJ1ZTsKPiArCXJldHVybiAwOwo+ ICB9Cj4gIAo+IC1zdGF0aWMgYm9vbAo+ICtzdGF0aWMgaW50Cj4gIGludGVsX2RwX2NvbXB1dGVf bGlua19jb25maWcoc3RydWN0IGludGVsX2VuY29kZXIgKmVuY29kZXIsCj4gIAkJCSAgICAgc3Ry dWN0IGludGVsX2NydGNfc3RhdGUgKnBpcGVfY29uZmlnLAo+ICAJCQkgICAgIHN0cnVjdCBkcm1f Y29ubmVjdG9yX3N0YXRlICpjb25uX3N0YXRlKQo+IEBAIC0yMDA1LDcgKzIwMDksNyBAQCBpbnRl bF9kcF9jb21wdXRlX2xpbmtfY29uZmlnKHN0cnVjdCBpbnRlbF9lbmNvZGVyICplbmNvZGVyLAo+ ICAJc3RydWN0IGludGVsX2RwICppbnRlbF9kcCA9IGVuY190b19pbnRlbF9kcCgmZW5jb2Rlci0+ YmFzZSk7Cj4gIAlzdHJ1Y3QgbGlua19jb25maWdfbGltaXRzIGxpbWl0czsKPiAgCWludCBjb21t b25fbGVuOwo+IC0JYm9vbCByZXQ7Cj4gKwlpbnQgcmV0Owo+ICAKPiAgCWNvbW1vbl9sZW4gPSBp bnRlbF9kcF9jb21tb25fbGVuX3JhdGVfbGltaXQoaW50ZWxfZHAsCj4gIAkJCQkJCSAgICBpbnRl bF9kcC0+bWF4X2xpbmtfcmF0ZSk7Cj4gQEAgLTIwNjMsMTAgKzIwNjcsMTEgQEAgaW50ZWxfZHBf Y29tcHV0ZV9saW5rX2NvbmZpZyhzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2RlciwKPiAgCj4g IAkvKiBlbmFibGUgY29tcHJlc3Npb24gaWYgdGhlIG1vZGUgZG9lc24ndCBmaXQgYXZhaWxhYmxl IEJXICovCj4gIAlEUk1fREVCVUdfS01TKCJGb3JjZSBEU0MgZW4gPSAlZFxuIiwgaW50ZWxfZHAt PmZvcmNlX2RzY19lbik7Cj4gLQlpZiAoIXJldCB8fCBpbnRlbF9kcC0+Zm9yY2VfZHNjX2VuKSB7 Cj4gLQkJaWYgKCFpbnRlbF9kcF9kc2NfY29tcHV0ZV9jb25maWcoaW50ZWxfZHAsIHBpcGVfY29u ZmlnLAo+IC0JCQkJCQkgY29ubl9zdGF0ZSwgJmxpbWl0cykpCj4gLQkJCXJldHVybiBmYWxzZTsK PiArCWlmIChyZXQgfHwgaW50ZWxfZHAtPmZvcmNlX2RzY19lbikgewo+ICsJCXJldCA9IGludGVs X2RwX2RzY19jb21wdXRlX2NvbmZpZyhpbnRlbF9kcCwgcGlwZV9jb25maWcsCj4gKwkJCQkJCSAg Y29ubl9zdGF0ZSwgJmxpbWl0cyk7Cj4gKwkJaWYgKHJldCA8IDApCj4gKwkJCXJldHVybiByZXQ7 Cj4gIAl9Cj4gIAo+ICAJaWYgKHBpcGVfY29uZmlnLT5kc2NfcGFyYW1zLmNvbXByZXNzaW9uX2Vu YWJsZSkgewo+IEBAIC0yMDkxLDEwICsyMDk2LDEwIEBAIGludGVsX2RwX2NvbXB1dGVfbGlua19j b25maWcoc3RydWN0IGludGVsX2VuY29kZXIgKmVuY29kZXIsCj4gIAkJCSAgICAgIGludGVsX2Rw X21heF9kYXRhX3JhdGUocGlwZV9jb25maWctPnBvcnRfY2xvY2ssCj4gIAkJCQkJCSAgICAgcGlw ZV9jb25maWctPmxhbmVfY291bnQpKTsKPiAgCX0KPiAtCXJldHVybiB0cnVlOwo+ICsJcmV0dXJu IDA7Cj4gIH0KPiAgCj4gLWJvb2wKPiAraW50Cj4gIGludGVsX2RwX2NvbXB1dGVfY29uZmlnKHN0 cnVjdCBpbnRlbF9lbmNvZGVyICplbmNvZGVyLAo+ICAJCQlzdHJ1Y3QgaW50ZWxfY3J0Y19zdGF0 ZSAqcGlwZV9jb25maWcsCj4gIAkJCXN0cnVjdCBkcm1fY29ubmVjdG9yX3N0YXRlICpjb25uX3N0 YXRlKQo+IEBAIC0yMTEwLDYgKzIxMTUsNyBAQCBpbnRlbF9kcF9jb21wdXRlX2NvbmZpZyhzdHJ1 Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2RlciwKPiAgCQl0b19pbnRlbF9kaWdpdGFsX2Nvbm5lY3Rv cl9zdGF0ZShjb25uX3N0YXRlKTsKPiAgCWJvb2wgY29uc3RhbnRfbiA9IGRybV9kcF9oYXNfcXVp cmsoJmludGVsX2RwLT5kZXNjLAo+ICAJCQkJCSAgIERQX0RQQ0RfUVVJUktfQ09OU1RBTlRfTik7 Cj4gKwlpbnQgcmV0Owo+ICAKPiAgCWlmIChIQVNfUENIX1NQTElUKGRldl9wcml2KSAmJiAhSEFT X0RESShkZXZfcHJpdikgJiYgcG9ydCAhPSBQT1JUX0EpCj4gIAkJcGlwZV9jb25maWctPmhhc19w Y2hfZW5jb2RlciA9IHRydWU7Cj4gQEAgLTIxMzEsOCArMjEzNyw2IEBAIGludGVsX2RwX2NvbXB1 dGVfY29uZmlnKHN0cnVjdCBpbnRlbF9lbmNvZGVyICplbmNvZGVyLAo+ICAJCQkJICAgICAgIGFk anVzdGVkX21vZGUpOwo+ICAKPiAgCQlpZiAoSU5URUxfR0VOKGRldl9wcml2KSA+PSA5KSB7Cj4g LQkJCWludCByZXQ7Cj4gLQo+ICAJCQlyZXQgPSBza2xfdXBkYXRlX3NjYWxlcl9jcnRjKHBpcGVf Y29uZmlnKTsKPiAgCQkJaWYgKHJldCkKPiAgCQkJCXJldHVybiByZXQ7Cj4gQEAgLTIxNDcsMjAg KzIxNTEsMjEgQEAgaW50ZWxfZHBfY29tcHV0ZV9jb25maWcoc3RydWN0IGludGVsX2VuY29kZXIg KmVuY29kZXIsCj4gIAl9Cj4gIAo+ICAJaWYgKGFkanVzdGVkX21vZGUtPmZsYWdzICYgRFJNX01P REVfRkxBR19EQkxTQ0FOKQo+IC0JCXJldHVybiBmYWxzZTsKPiArCQlyZXR1cm4gLUVJTlZBTDsK PiAgCj4gIAlpZiAoSEFTX0dNQ0hfRElTUExBWShkZXZfcHJpdikgJiYKPiAgCSAgICBhZGp1c3Rl ZF9tb2RlLT5mbGFncyAmIERSTV9NT0RFX0ZMQUdfSU5URVJMQUNFKQo+IC0JCXJldHVybiBmYWxz ZTsKPiArCQlyZXR1cm4gLUVJTlZBTDsKPiAgCj4gIAlpZiAoYWRqdXN0ZWRfbW9kZS0+ZmxhZ3Mg JiBEUk1fTU9ERV9GTEFHX0RCTENMSykKPiAtCQlyZXR1cm4gZmFsc2U7Cj4gKwkJcmV0dXJuIC1F SU5WQUw7Cj4gIAo+ICAJcGlwZV9jb25maWctPmZlY19lbmFibGUgPSAhaW50ZWxfZHBfaXNfZWRw KGludGVsX2RwKSAmJgo+ICAJCQkJICBpbnRlbF9kcF9zdXBwb3J0c19mZWMoaW50ZWxfZHAsIHBp cGVfY29uZmlnKTsKPiAgCj4gLQlpZiAoIWludGVsX2RwX2NvbXB1dGVfbGlua19jb25maWcoZW5j b2RlciwgcGlwZV9jb25maWcsIGNvbm5fc3RhdGUpKQo+IC0JCXJldHVybiBmYWxzZTsKPiArCXJl dCA9IGludGVsX2RwX2NvbXB1dGVfbGlua19jb25maWcoZW5jb2RlciwgcGlwZV9jb25maWcsIGNv bm5fc3RhdGUpOwo+ICsJaWYgKHJldCA8IDApCj4gKwkJcmV0dXJuIHJldDsKPiAgCj4gIAlpZiAo aW50ZWxfY29ubl9zdGF0ZS0+YnJvYWRjYXN0X3JnYiA9PSBJTlRFTF9CUk9BRENBU1RfUkdCX0FV VE8pIHsKPiAgCQkvKgo+IEBAIC0yMjA4LDcgKzIyMTMsNyBAQCBpbnRlbF9kcF9jb21wdXRlX2Nv bmZpZyhzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2RlciwKPiAgCj4gIAlpbnRlbF9wc3JfY29t cHV0ZV9jb25maWcoaW50ZWxfZHAsIHBpcGVfY29uZmlnKTsKPiAgCj4gLQlyZXR1cm4gdHJ1ZTsK PiArCXJldHVybiAwOwo+ICB9Cj4gIAo+ICB2b2lkIGludGVsX2RwX3NldF9saW5rX3BhcmFtcyhz dHJ1Y3QgaW50ZWxfZHAgKmludGVsX2RwLAo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0v aTkxNS9pbnRlbF9kcF9tc3QuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2RwX21zdC5j Cj4gaW5kZXggM2Y4MzQyOTMzM2M3Li5hMTk2OTkwMjNkYjEgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVy cy9ncHUvZHJtL2k5MTUvaW50ZWxfZHBfbXN0LmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkx NS9pbnRlbF9kcF9tc3QuYwo+IEBAIC0yOSw5ICsyOSw5IEBACj4gICNpbmNsdWRlIDxkcm0vZHJt X2NydGNfaGVscGVyLmg+Cj4gICNpbmNsdWRlIDxkcm0vZHJtX2VkaWQuaD4KPiAgCj4gLXN0YXRp YyBib29sIGludGVsX2RwX21zdF9jb21wdXRlX2NvbmZpZyhzdHJ1Y3QgaW50ZWxfZW5jb2RlciAq ZW5jb2RlciwKPiAtCQkJCQlzdHJ1Y3QgaW50ZWxfY3J0Y19zdGF0ZSAqcGlwZV9jb25maWcsCj4g LQkJCQkJc3RydWN0IGRybV9jb25uZWN0b3Jfc3RhdGUgKmNvbm5fc3RhdGUpCj4gK3N0YXRpYyBp bnQgaW50ZWxfZHBfbXN0X2NvbXB1dGVfY29uZmlnKHN0cnVjdCBpbnRlbF9lbmNvZGVyICplbmNv ZGVyLAo+ICsJCQkJICAgICAgIHN0cnVjdCBpbnRlbF9jcnRjX3N0YXRlICpwaXBlX2NvbmZpZywK PiArCQkJCSAgICAgICBzdHJ1Y3QgZHJtX2Nvbm5lY3Rvcl9zdGF0ZSAqY29ubl9zdGF0ZSkKPiAg ewo+ICAJc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2ID0gdG9faTkxNShlbmNvZGVy LT5iYXNlLmRldik7Cj4gIAlzdHJ1Y3QgaW50ZWxfZHBfbXN0X2VuY29kZXIgKmludGVsX21zdCA9 IGVuY190b19tc3QoJmVuY29kZXItPmJhc2UpOwo+IEBAIC01Miw3ICs1Miw3IEBAIHN0YXRpYyBi b29sIGludGVsX2RwX21zdF9jb21wdXRlX2NvbmZpZyhzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5j b2RlciwKPiAgCQkJCQkgICBEUF9EUENEX1FVSVJLX0NPTlNUQU5UX04pOwo+ICAKPiAgCWlmIChh ZGp1c3RlZF9tb2RlLT5mbGFncyAmIERSTV9NT0RFX0ZMQUdfREJMU0NBTikKPiAtCQlyZXR1cm4g ZmFsc2U7Cj4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4gIAo+ICAJcGlwZV9jb25maWctPm91dHB1dF9m b3JtYXQgPSBJTlRFTF9PVVRQVVRfRk9STUFUX1JHQjsKPiAgCXBpcGVfY29uZmlnLT5oYXNfcGNo X2VuY29kZXIgPSBmYWxzZTsKPiBAQCAtODksNyArODksNyBAQCBzdGF0aWMgYm9vbCBpbnRlbF9k cF9tc3RfY29tcHV0ZV9jb25maWcoc3RydWN0IGludGVsX2VuY29kZXIgKmVuY29kZXIsCj4gIAkJ aWYgKHNsb3RzIDwgMCkgewo+ICAJCQlEUk1fREVCVUdfS01TKCJmYWlsZWQgZmluZGluZyB2Y3Bp IHNsb3RzOiVkXG4iLAo+ICAJCQkJICAgICAgc2xvdHMpOwo+IC0JCQlyZXR1cm4gZmFsc2U7Cj4g KwkJCXJldHVybiBzbG90czsKPiAgCQl9Cj4gIAl9Cj4gIAo+IEBAIC0xMDcsNyArMTA3LDcgQEAg c3RhdGljIGJvb2wgaW50ZWxfZHBfbXN0X2NvbXB1dGVfY29uZmlnKHN0cnVjdCBpbnRlbF9lbmNv ZGVyICplbmNvZGVyLAo+ICAKPiAgCWludGVsX2RkaV9jb21wdXRlX21pbl92b2x0YWdlX2xldmVs KGRldl9wcml2LCBwaXBlX2NvbmZpZyk7Cj4gIAo+IC0JcmV0dXJuIHRydWU7Cj4gKwlyZXR1cm4g MDsKPiAgfQo+ICAKPiAgc3RhdGljIGludAo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0v aTkxNS9pbnRlbF9kcnYuaCBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rydi5oCj4gaW5k ZXggNzk3Nzg0M2NlMjZhLi5lNWE0MzZjMzMzMDcgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUv ZHJtL2k5MTUvaW50ZWxfZHJ2LmgKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9k cnYuaAo+IEBAIC0yMjUsOSArMjI1LDkgQEAgc3RydWN0IGludGVsX2VuY29kZXIgewo+ICAJZW51 bSBpbnRlbF9vdXRwdXRfdHlwZSAoKmNvbXB1dGVfb3V0cHV0X3R5cGUpKHN0cnVjdCBpbnRlbF9l bmNvZGVyICosCj4gIAkJCQkJCSAgICAgIHN0cnVjdCBpbnRlbF9jcnRjX3N0YXRlICosCj4gIAkJ CQkJCSAgICAgIHN0cnVjdCBkcm1fY29ubmVjdG9yX3N0YXRlICopOwo+IC0JYm9vbCAoKmNvbXB1 dGVfY29uZmlnKShzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqLAo+IC0JCQkgICAgICAgc3RydWN0IGlu dGVsX2NydGNfc3RhdGUgKiwKPiAtCQkJICAgICAgIHN0cnVjdCBkcm1fY29ubmVjdG9yX3N0YXRl ICopOwo+ICsJaW50ICgqY29tcHV0ZV9jb25maWcpKHN0cnVjdCBpbnRlbF9lbmNvZGVyICosCj4g KwkJCSAgICAgIHN0cnVjdCBpbnRlbF9jcnRjX3N0YXRlICosCj4gKwkJCSAgICAgIHN0cnVjdCBk cm1fY29ubmVjdG9yX3N0YXRlICopOwo+ICAJdm9pZCAoKnByZV9wbGxfZW5hYmxlKShzdHJ1Y3Qg aW50ZWxfZW5jb2RlciAqLAo+ICAJCQkgICAgICAgY29uc3Qgc3RydWN0IGludGVsX2NydGNfc3Rh dGUgKiwKPiAgCQkJICAgICAgIGNvbnN0IHN0cnVjdCBkcm1fY29ubmVjdG9yX3N0YXRlICopOwo+ IEBAIC0xODE2LDkgKzE4MTYsOSBAQCB2b2lkIGludGVsX2RwX3Npbmtfc2V0X2RlY29tcHJlc3Np b25fc3RhdGUoc3RydWN0IGludGVsX2RwICppbnRlbF9kcCwKPiAgdm9pZCBpbnRlbF9kcF9lbmNv ZGVyX3Jlc2V0KHN0cnVjdCBkcm1fZW5jb2RlciAqZW5jb2Rlcik7Cj4gIHZvaWQgaW50ZWxfZHBf ZW5jb2Rlcl9zdXNwZW5kKHN0cnVjdCBpbnRlbF9lbmNvZGVyICppbnRlbF9lbmNvZGVyKTsKPiAg dm9pZCBpbnRlbF9kcF9lbmNvZGVyX2ZsdXNoX3dvcmsoc3RydWN0IGRybV9lbmNvZGVyICplbmNv ZGVyKTsKPiAtYm9vbCBpbnRlbF9kcF9jb21wdXRlX2NvbmZpZyhzdHJ1Y3QgaW50ZWxfZW5jb2Rl ciAqZW5jb2RlciwKPiAtCQkJICAgICBzdHJ1Y3QgaW50ZWxfY3J0Y19zdGF0ZSAqcGlwZV9jb25m aWcsCj4gLQkJCSAgICAgc3RydWN0IGRybV9jb25uZWN0b3Jfc3RhdGUgKmNvbm5fc3RhdGUpOwo+ ICtpbnQgaW50ZWxfZHBfY29tcHV0ZV9jb25maWcoc3RydWN0IGludGVsX2VuY29kZXIgKmVuY29k ZXIsCj4gKwkJCSAgICBzdHJ1Y3QgaW50ZWxfY3J0Y19zdGF0ZSAqcGlwZV9jb25maWcsCj4gKwkJ CSAgICBzdHJ1Y3QgZHJtX2Nvbm5lY3Rvcl9zdGF0ZSAqY29ubl9zdGF0ZSk7Cj4gIGJvb2wgaW50 ZWxfZHBfaXNfZWRwKHN0cnVjdCBpbnRlbF9kcCAqaW50ZWxfZHApOwo+ICBib29sIGludGVsX2Rw X2lzX3BvcnRfZWRwKHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiwgZW51bSBwb3J0 IHBvcnQpOwo+ICBlbnVtIGlycXJldHVybiBpbnRlbF9kcF9ocGRfcHVsc2Uoc3RydWN0IGludGVs X2RpZ2l0YWxfcG9ydCAqaW50ZWxfZGlnX3BvcnQsCj4gQEAgLTE5NzgsOSArMTk3OCw5IEBAIHZv aWQgaW50ZWxfaGRtaV9pbml0KHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiwgaTkx NV9yZWdfdCBoZG1pX3JlZywKPiAgdm9pZCBpbnRlbF9oZG1pX2luaXRfY29ubmVjdG9yKHN0cnVj dCBpbnRlbF9kaWdpdGFsX3BvcnQgKmludGVsX2RpZ19wb3J0LAo+ICAJCQkgICAgICAgc3RydWN0 IGludGVsX2Nvbm5lY3RvciAqaW50ZWxfY29ubmVjdG9yKTsKPiAgc3RydWN0IGludGVsX2hkbWkg KmVuY190b19pbnRlbF9oZG1pKHN0cnVjdCBkcm1fZW5jb2RlciAqZW5jb2Rlcik7Cj4gLWJvb2wg aW50ZWxfaGRtaV9jb21wdXRlX2NvbmZpZyhzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2RlciwK PiAtCQkJICAgICAgIHN0cnVjdCBpbnRlbF9jcnRjX3N0YXRlICpwaXBlX2NvbmZpZywKPiAtCQkJ ICAgICAgIHN0cnVjdCBkcm1fY29ubmVjdG9yX3N0YXRlICpjb25uX3N0YXRlKTsKPiAraW50IGlu dGVsX2hkbWlfY29tcHV0ZV9jb25maWcoc3RydWN0IGludGVsX2VuY29kZXIgKmVuY29kZXIsCj4g KwkJCSAgICAgIHN0cnVjdCBpbnRlbF9jcnRjX3N0YXRlICpwaXBlX2NvbmZpZywKPiArCQkJICAg ICAgc3RydWN0IGRybV9jb25uZWN0b3Jfc3RhdGUgKmNvbm5fc3RhdGUpOwo+ICBib29sIGludGVs X2hkbWlfaGFuZGxlX3Npbmtfc2NyYW1ibGluZyhzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2Rl ciwKPiAgCQkJCSAgICAgICBzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9yLAo+ICAJCQkJ ICAgICAgIGJvb2wgaGlnaF90bWRzX2Nsb2NrX3JhdGlvLAo+IGRpZmYgLS1naXQgYS9kcml2ZXJz L2dwdS9kcm0vaTkxNS9pbnRlbF9kdm8uYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2R2 by5jCj4gaW5kZXggYmMzYzNjYjU3ZWM2Li5hNmM4MjQ4MmE4NDEgMTAwNjQ0Cj4gLS0tIGEvZHJp dmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHZvLmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkx NS9pbnRlbF9kdm8uYwo+IEBAIC0yMzQsOSArMjM0LDkgQEAgaW50ZWxfZHZvX21vZGVfdmFsaWQo c3RydWN0IGRybV9jb25uZWN0b3IgKmNvbm5lY3RvciwKPiAgCXJldHVybiBpbnRlbF9kdm8tPmRl di5kZXZfb3BzLT5tb2RlX3ZhbGlkKCZpbnRlbF9kdm8tPmRldiwgbW9kZSk7Cj4gIH0KPiAgCj4g LXN0YXRpYyBib29sIGludGVsX2R2b19jb21wdXRlX2NvbmZpZyhzdHJ1Y3QgaW50ZWxfZW5jb2Rl ciAqZW5jb2RlciwKPiAtCQkJCSAgICAgc3RydWN0IGludGVsX2NydGNfc3RhdGUgKnBpcGVfY29u ZmlnLAo+IC0JCQkJICAgICBzdHJ1Y3QgZHJtX2Nvbm5lY3Rvcl9zdGF0ZSAqY29ubl9zdGF0ZSkK PiArc3RhdGljIGludCBpbnRlbF9kdm9fY29tcHV0ZV9jb25maWcoc3RydWN0IGludGVsX2VuY29k ZXIgKmVuY29kZXIsCj4gKwkJCQkgICAgc3RydWN0IGludGVsX2NydGNfc3RhdGUgKnBpcGVfY29u ZmlnLAo+ICsJCQkJICAgIHN0cnVjdCBkcm1fY29ubmVjdG9yX3N0YXRlICpjb25uX3N0YXRlKQo+ ICB7Cj4gIAlzdHJ1Y3QgaW50ZWxfZHZvICppbnRlbF9kdm8gPSBlbmNfdG9fZHZvKGVuY29kZXIp Owo+ICAJY29uc3Qgc3RydWN0IGRybV9kaXNwbGF5X21vZGUgKmZpeGVkX21vZGUgPQo+IEBAIC0y NTMsMTAgKzI1MywxMSBAQCBzdGF0aWMgYm9vbCBpbnRlbF9kdm9fY29tcHV0ZV9jb25maWcoc3Ry dWN0IGludGVsX2VuY29kZXIgKmVuY29kZXIsCj4gIAkJaW50ZWxfZml4ZWRfcGFuZWxfbW9kZShm aXhlZF9tb2RlLCBhZGp1c3RlZF9tb2RlKTsKPiAgCj4gIAlpZiAoYWRqdXN0ZWRfbW9kZS0+Zmxh Z3MgJiBEUk1fTU9ERV9GTEFHX0RCTFNDQU4pCj4gLQkJcmV0dXJuIGZhbHNlOwo+ICsJCXJldHVy biAtRUlOVkFMOwo+ICAKPiAgCXBpcGVfY29uZmlnLT5vdXRwdXRfZm9ybWF0ID0gSU5URUxfT1VU UFVUX0ZPUk1BVF9SR0I7Cj4gLQlyZXR1cm4gdHJ1ZTsKPiArCj4gKwlyZXR1cm4gMDsKPiAgfQo+ ICAKPiAgc3RhdGljIHZvaWQgaW50ZWxfZHZvX3ByZV9lbmFibGUoc3RydWN0IGludGVsX2VuY29k ZXIgKmVuY29kZXIsCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2hk bWkuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2hkbWkuYwo+IGluZGV4IDc0ZjQwMjFi NzYwYy4uOTdhOThlMWJlYTU2IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2lu dGVsX2hkbWkuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2hkbWkuYwo+IEBA IC0xNzA0LDkgKzE3MDQsOSBAQCBpbnRlbF9oZG1pX3ljYmNyNDIwX2NvbmZpZyhzdHJ1Y3QgZHJt X2Nvbm5lY3RvciAqY29ubmVjdG9yLAo+ICAJcmV0dXJuIHRydWU7Cj4gIH0KPiAgCj4gLWJvb2wg aW50ZWxfaGRtaV9jb21wdXRlX2NvbmZpZyhzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2RlciwK PiAtCQkJICAgICAgIHN0cnVjdCBpbnRlbF9jcnRjX3N0YXRlICpwaXBlX2NvbmZpZywKPiAtCQkJ ICAgICAgIHN0cnVjdCBkcm1fY29ubmVjdG9yX3N0YXRlICpjb25uX3N0YXRlKQo+ICtpbnQgaW50 ZWxfaGRtaV9jb21wdXRlX2NvbmZpZyhzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2RlciwKPiAr CQkJICAgICAgc3RydWN0IGludGVsX2NydGNfc3RhdGUgKnBpcGVfY29uZmlnLAo+ICsJCQkgICAg ICBzdHJ1Y3QgZHJtX2Nvbm5lY3Rvcl9zdGF0ZSAqY29ubl9zdGF0ZSkKPiAgewo+ICAJc3RydWN0 IGludGVsX2hkbWkgKmludGVsX2hkbWkgPSBlbmNfdG9faW50ZWxfaGRtaSgmZW5jb2Rlci0+YmFz ZSk7Cj4gIAlzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYgPSB0b19pOTE1KGVuY29k ZXItPmJhc2UuZGV2KTsKPiBAQCAtMTcyMiw3ICsxNzIyLDcgQEAgYm9vbCBpbnRlbF9oZG1pX2Nv bXB1dGVfY29uZmlnKHN0cnVjdCBpbnRlbF9lbmNvZGVyICplbmNvZGVyLAo+ICAJYm9vbCBmb3Jj ZV9kdmkgPSBpbnRlbF9jb25uX3N0YXRlLT5mb3JjZV9hdWRpbyA9PSBIRE1JX0FVRElPX09GRl9E Vkk7Cj4gIAo+ICAJaWYgKGFkanVzdGVkX21vZGUtPmZsYWdzICYgRFJNX01PREVfRkxBR19EQkxT Q0FOKQo+IC0JCXJldHVybiBmYWxzZTsKPiArCQlyZXR1cm4gLUVJTlZBTDsKPiAgCj4gIAlwaXBl X2NvbmZpZy0+b3V0cHV0X2Zvcm1hdCA9IElOVEVMX09VVFBVVF9GT1JNQVRfUkdCOwo+ICAJcGlw ZV9jb25maWctPmhhc19oZG1pX3NpbmsgPSAhZm9yY2VfZHZpICYmIGludGVsX2hkbWktPmhhc19o ZG1pX3Npbms7Cj4gQEAgLTE3NTMsNyArMTc1Myw3IEBAIGJvb2wgaW50ZWxfaGRtaV9jb21wdXRl X2NvbmZpZyhzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2RlciwKPiAgCQkJCQkJJmNsb2NrXzEy YnBjLCAmY2xvY2tfMTBicGMsCj4gIAkJCQkJCSZjbG9ja184YnBjKSkgewo+ICAJCQlEUk1fRVJS T1IoIkNhbid0IHN1cHBvcnQgWUNCQ1I0MjAgb3V0cHV0XG4iKTsKPiAtCQkJcmV0dXJuIGZhbHNl Owo+ICsJCQlyZXR1cm4gLUVJTlZBTDsKPiAgCQl9Cj4gIAl9Cj4gIAo+IEBAIC0xODAzLDcgKzE4 MDMsNyBAQCBib29sIGludGVsX2hkbWlfY29tcHV0ZV9jb25maWcoc3RydWN0IGludGVsX2VuY29k ZXIgKmVuY29kZXIsCj4gIAlpZiAoaGRtaV9wb3J0X2Nsb2NrX3ZhbGlkKGludGVsX2hkbWksIHBp cGVfY29uZmlnLT5wb3J0X2Nsb2NrLAo+ICAJCQkJICBmYWxzZSwgZm9yY2VfZHZpKSAhPSBNT0RF X09LKSB7Cj4gIAkJRFJNX0RFQlVHX0tNUygidW5zdXBwb3J0ZWQgSERNSSBjbG9jaywgcmVqZWN0 aW5nIG1vZGVcbiIpOwo+IC0JCXJldHVybiBmYWxzZTsKPiArCQlyZXR1cm4gLUVJTlZBTDsKPiAg CX0KPiAgCj4gIAkvKiBTZXQgdXNlciBzZWxlY3RlZCBQQVIgdG8gaW5jb21pbmcgbW9kZSdzIG1l bWJlciAqLwo+IEBAIC0xODIyLDcgKzE4MjIsNyBAQCBib29sIGludGVsX2hkbWlfY29tcHV0ZV9j b25maWcoc3RydWN0IGludGVsX2VuY29kZXIgKmVuY29kZXIsCj4gIAkJfQo+ICAJfQo+ICAKPiAt CXJldHVybiB0cnVlOwo+ICsJcmV0dXJuIDA7Cj4gIH0KPiAgCj4gIHN0YXRpYyB2b2lkCj4gZGlm ZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2x2ZHMuYyBiL2RyaXZlcnMvZ3B1 L2RybS9pOTE1L2ludGVsX2x2ZHMuYwo+IGluZGV4IGIwMWFhY2I1ZDczZC4uNDZhNWRmZDVjZGY3 IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2x2ZHMuYwo+ICsrKyBi L2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2x2ZHMuYwo+IEBAIC0zODAsOSArMzgwLDkgQEAg aW50ZWxfbHZkc19tb2RlX3ZhbGlkKHN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3IsCj4g IAlyZXR1cm4gTU9ERV9PSzsKPiAgfQo+ICAKPiAtc3RhdGljIGJvb2wgaW50ZWxfbHZkc19jb21w dXRlX2NvbmZpZyhzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqaW50ZWxfZW5jb2RlciwKPiAtCQkJCSAg ICAgIHN0cnVjdCBpbnRlbF9jcnRjX3N0YXRlICpwaXBlX2NvbmZpZywKPiAtCQkJCSAgICAgIHN0 cnVjdCBkcm1fY29ubmVjdG9yX3N0YXRlICpjb25uX3N0YXRlKQo+ICtzdGF0aWMgaW50IGludGVs X2x2ZHNfY29tcHV0ZV9jb25maWcoc3RydWN0IGludGVsX2VuY29kZXIgKmludGVsX2VuY29kZXIs Cj4gKwkJCQkgICAgIHN0cnVjdCBpbnRlbF9jcnRjX3N0YXRlICpwaXBlX2NvbmZpZywKPiArCQkJ CSAgICAgc3RydWN0IGRybV9jb25uZWN0b3Jfc3RhdGUgKmNvbm5fc3RhdGUpCj4gIHsKPiAgCXN0 cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiA9IHRvX2k5MTUoaW50ZWxfZW5jb2Rlci0+ YmFzZS5kZXYpOwo+ICAJc3RydWN0IGludGVsX2x2ZHNfZW5jb2RlciAqbHZkc19lbmNvZGVyID0K PiBAQCAtMzk2LDcgKzM5Niw3IEBAIHN0YXRpYyBib29sIGludGVsX2x2ZHNfY29tcHV0ZV9jb25m aWcoc3RydWN0IGludGVsX2VuY29kZXIgKmludGVsX2VuY29kZXIsCj4gIAkvKiBTaG91bGQgbmV2 ZXIgaGFwcGVuISEgKi8KPiAgCWlmIChJTlRFTF9HRU4oZGV2X3ByaXYpIDwgNCAmJiBpbnRlbF9j cnRjLT5waXBlID09IDApIHsKPiAgCQlEUk1fRVJST1IoIkNhbid0IHN1cHBvcnQgTFZEUyBvbiBw aXBlIEFcbiIpOwo+IC0JCXJldHVybiBmYWxzZTsKPiArCQlyZXR1cm4gLUVJTlZBTDsKPiAgCX0K PiAgCj4gIAlpZiAobHZkc19lbmNvZGVyLT5hM19wb3dlciA9PSBMVkRTX0EzX1BPV0VSX1VQKQo+ IEBAIC00MjIsNyArNDIyLDcgQEAgc3RhdGljIGJvb2wgaW50ZWxfbHZkc19jb21wdXRlX2NvbmZp ZyhzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqaW50ZWxfZW5jb2RlciwKPiAgCQkJICAgICAgIGFkanVz dGVkX21vZGUpOwo+ICAKPiAgCWlmIChhZGp1c3RlZF9tb2RlLT5mbGFncyAmIERSTV9NT0RFX0ZM QUdfREJMU0NBTikKPiAtCQlyZXR1cm4gZmFsc2U7Cj4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4gIAo+ ICAJaWYgKEhBU19QQ0hfU1BMSVQoZGV2X3ByaXYpKSB7Cj4gIAkJcGlwZV9jb25maWctPmhhc19w Y2hfZW5jb2RlciA9IHRydWU7Cj4gQEAgLTQ0MSw3ICs0NDEsNyBAQCBzdGF0aWMgYm9vbCBpbnRl bF9sdmRzX2NvbXB1dGVfY29uZmlnKHN0cnVjdCBpbnRlbF9lbmNvZGVyICppbnRlbF9lbmNvZGVy LAo+ICAJICogdXNlcidzIHJlcXVlc3RlZCByZWZyZXNoIHJhdGUuCj4gIAkgKi8KPiAgCj4gLQly ZXR1cm4gdHJ1ZTsKPiArCXJldHVybiAwOwo+ICB9Cj4gIAo+ICBzdGF0aWMgZW51bSBkcm1fY29u bmVjdG9yX3N0YXR1cwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9z ZHZvLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9zZHZvLmMKPiBpbmRleCA0ZGI3YWVm YTg4ZjkuLmRmMmQ4MzBhNzQwNSAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9p bnRlbF9zZHZvLmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9zZHZvLmMKPiBA QCAtMTEwNyw5ICsxMTA3LDkgQEAgc3RhdGljIHZvaWQgaTl4eF9hZGp1c3Rfc2R2b190dl9jbG9j ayhzdHJ1Y3QgaW50ZWxfY3J0Y19zdGF0ZSAqcGlwZV9jb25maWcpCj4gIAlwaXBlX2NvbmZpZy0+ Y2xvY2tfc2V0ID0gdHJ1ZTsKPiAgfQo+ICAKPiAtc3RhdGljIGJvb2wgaW50ZWxfc2R2b19jb21w dXRlX2NvbmZpZyhzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2RlciwKPiAtCQkJCSAgICAgIHN0 cnVjdCBpbnRlbF9jcnRjX3N0YXRlICpwaXBlX2NvbmZpZywKPiAtCQkJCSAgICAgIHN0cnVjdCBk cm1fY29ubmVjdG9yX3N0YXRlICpjb25uX3N0YXRlKQo+ICtzdGF0aWMgaW50IGludGVsX3Nkdm9f Y29tcHV0ZV9jb25maWcoc3RydWN0IGludGVsX2VuY29kZXIgKmVuY29kZXIsCj4gKwkJCQkgICAg IHN0cnVjdCBpbnRlbF9jcnRjX3N0YXRlICpwaXBlX2NvbmZpZywKPiArCQkJCSAgICAgc3RydWN0 IGRybV9jb25uZWN0b3Jfc3RhdGUgKmNvbm5fc3RhdGUpCj4gIHsKPiAgCXN0cnVjdCBpbnRlbF9z ZHZvICppbnRlbF9zZHZvID0gdG9fc2R2byhlbmNvZGVyKTsKPiAgCXN0cnVjdCBpbnRlbF9zZHZv X2Nvbm5lY3Rvcl9zdGF0ZSAqaW50ZWxfc2R2b19zdGF0ZSA9Cj4gQEAgLTExMzQsNyArMTEzNCw3 IEBAIHN0YXRpYyBib29sIGludGVsX3Nkdm9fY29tcHV0ZV9jb25maWcoc3RydWN0IGludGVsX2Vu Y29kZXIgKmVuY29kZXIsCj4gIAkgKi8KPiAgCWlmIChJU19UVihpbnRlbF9zZHZvX2Nvbm5lY3Rv cikpIHsKPiAgCQlpZiAoIWludGVsX3Nkdm9fc2V0X291dHB1dF90aW1pbmdzX2Zyb21fbW9kZShp bnRlbF9zZHZvLCBtb2RlKSkKPiAtCQkJcmV0dXJuIGZhbHNlOwo+ICsJCQlyZXR1cm4gLUVJTlZB TDsKPiAgCj4gIAkJKHZvaWQpIGludGVsX3Nkdm9fZ2V0X3ByZWZlcnJlZF9pbnB1dF9tb2RlKGlu dGVsX3Nkdm8sCj4gIAkJCQkJCQkgICBpbnRlbF9zZHZvX2Nvbm5lY3RvciwKPiBAQCAtMTE0NCw3 ICsxMTQ0LDcgQEAgc3RhdGljIGJvb2wgaW50ZWxfc2R2b19jb21wdXRlX2NvbmZpZyhzdHJ1Y3Qg aW50ZWxfZW5jb2RlciAqZW5jb2RlciwKPiAgCX0gZWxzZSBpZiAoSVNfTFZEUyhpbnRlbF9zZHZv X2Nvbm5lY3RvcikpIHsKPiAgCQlpZiAoIWludGVsX3Nkdm9fc2V0X291dHB1dF90aW1pbmdzX2Zy b21fbW9kZShpbnRlbF9zZHZvLAo+ICAJCQkJCQkJICAgICBpbnRlbF9zZHZvX2Nvbm5lY3Rvci0+ YmFzZS5wYW5lbC5maXhlZF9tb2RlKSkKPiAtCQkJcmV0dXJuIGZhbHNlOwo+ICsJCQlyZXR1cm4g LUVJTlZBTDsKPiAgCj4gIAkJKHZvaWQpIGludGVsX3Nkdm9fZ2V0X3ByZWZlcnJlZF9pbnB1dF9t b2RlKGludGVsX3Nkdm8sCj4gIAkJCQkJCQkgICBpbnRlbF9zZHZvX2Nvbm5lY3RvciwKPiBAQCAt MTE1Myw3ICsxMTUzLDcgQEAgc3RhdGljIGJvb2wgaW50ZWxfc2R2b19jb21wdXRlX2NvbmZpZyhz dHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2RlciwKPiAgCX0KPiAgCj4gIAlpZiAoYWRqdXN0ZWRf bW9kZS0+ZmxhZ3MgJiBEUk1fTU9ERV9GTEFHX0RCTFNDQU4pCj4gLQkJcmV0dXJuIGZhbHNlOwo+ ICsJCXJldHVybiAtRUlOVkFMOwo+ICAKPiAgCS8qCj4gIAkgKiBNYWtlIHRoZSBDUlRDIGNvZGUg ZmFjdG9yIGluIHRoZSBTRFZPIHBpeGVsIG11bHRpcGxpZXIuICBUaGUKPiBAQCAtMTE5Myw3ICsx MTkzLDcgQEAgc3RhdGljIGJvb2wgaW50ZWxfc2R2b19jb21wdXRlX2NvbmZpZyhzdHJ1Y3QgaW50 ZWxfZW5jb2RlciAqZW5jb2RlciwKPiAgCWlmIChpbnRlbF9zZHZvX2Nvbm5lY3Rvci0+aXNfaGRt aSkKPiAgCQlhZGp1c3RlZF9tb2RlLT5waWN0dXJlX2FzcGVjdF9yYXRpbyA9IGNvbm5fc3RhdGUt PnBpY3R1cmVfYXNwZWN0X3JhdGlvOwo+ICAKPiAtCXJldHVybiB0cnVlOwo+ICsJcmV0dXJuIDA7 Cj4gIH0KPiAgCj4gICNkZWZpbmUgVVBEQVRFX1BST1BFUlRZKGlucHV0LCBOQU1FKSBcCj4gZGlm ZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3R2LmMgYi9kcml2ZXJzL2dwdS9k cm0vaTkxNS9pbnRlbF90di5jCj4gaW5kZXggZDdhNDE0Y2UyNzc0Li5iZDU1MzZmMGVjOTIgMTAw NjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfdHYuYwo+ICsrKyBiL2RyaXZl cnMvZ3B1L2RybS9pOTE1L2ludGVsX3R2LmMKPiBAQCAtODY5LDcgKzg2OSw3IEBAIGludGVsX3R2 X2dldF9jb25maWcoc3RydWN0IGludGVsX2VuY29kZXIgKmVuY29kZXIsCj4gIAlwaXBlX2NvbmZp Zy0+YmFzZS5hZGp1c3RlZF9tb2RlLmNydGNfY2xvY2sgPSBwaXBlX2NvbmZpZy0+cG9ydF9jbG9j azsKPiAgfQo+ICAKPiAtc3RhdGljIGJvb2wKPiArc3RhdGljIGludAo+ICBpbnRlbF90dl9jb21w dXRlX2NvbmZpZyhzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2RlciwKPiAgCQkJc3RydWN0IGlu dGVsX2NydGNfc3RhdGUgKnBpcGVfY29uZmlnLAo+ICAJCQlzdHJ1Y3QgZHJtX2Nvbm5lY3Rvcl9z dGF0ZSAqY29ubl9zdGF0ZSkKPiBAQCAtODc5LDEwICs4NzksMTAgQEAgaW50ZWxfdHZfY29tcHV0 ZV9jb25maWcoc3RydWN0IGludGVsX2VuY29kZXIgKmVuY29kZXIsCj4gIAkJJnBpcGVfY29uZmln LT5iYXNlLmFkanVzdGVkX21vZGU7Cj4gIAo+ICAJaWYgKCF0dl9tb2RlKQo+IC0JCXJldHVybiBm YWxzZTsKPiArCQlyZXR1cm4gLUVJTlZBTDsKPiAgCj4gIAlpZiAoYWRqdXN0ZWRfbW9kZS0+Zmxh Z3MgJiBEUk1fTU9ERV9GTEFHX0RCTFNDQU4pCj4gLQkJcmV0dXJuIGZhbHNlOwo+ICsJCXJldHVy biAtRUlOVkFMOwo+ICAKPiAgCXBpcGVfY29uZmlnLT5vdXRwdXRfZm9ybWF0ID0gSU5URUxfT1VU UFVUX0ZPUk1BVF9SR0I7Cj4gIAlhZGp1c3RlZF9tb2RlLT5jcnRjX2Nsb2NrID0gdHZfbW9kZS0+ Y2xvY2s7Cj4gQEAgLTg5Nyw3ICs4OTcsNyBAQCBpbnRlbF90dl9jb21wdXRlX2NvbmZpZyhzdHJ1 Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2RlciwKPiAgCSAqIG9yIHdoZXRoZXIgdXNlcnNwYWNlIGlz IGRvaW5nIHNvbWV0aGluZyBzdHVwaWQuCj4gIAkgKi8KPiAgCj4gLQlyZXR1cm4gdHJ1ZTsKPiAr CXJldHVybiAwOwo+ICB9Cj4gIAo+ICBzdGF0aWMgdm9pZAo+IGRpZmYgLS1naXQgYS9kcml2ZXJz L2dwdS9kcm0vaTkxNS92bHZfZHNpLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS92bHZfZHNpLmMK PiBpbmRleCBkMTE2ZmVhZDg1MTQuLmMyNDdjZTc0YjcxYSAxMDA2NDQKPiAtLS0gYS9kcml2ZXJz L2dwdS9kcm0vaTkxNS92bHZfZHNpLmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS92bHZf ZHNpLmMKPiBAQCAtMjU2LDkgKzI1Niw5IEBAIHN0YXRpYyB2b2lkIGJhbmRfZ2FwX3Jlc2V0KHN0 cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdikKPiAgCW11dGV4X3VubG9jaygmZGV2X3By aXYtPnNiX2xvY2spOwo+ICB9Cj4gIAo+IC1zdGF0aWMgYm9vbCBpbnRlbF9kc2lfY29tcHV0ZV9j b25maWcoc3RydWN0IGludGVsX2VuY29kZXIgKmVuY29kZXIsCj4gLQkJCQkgICAgIHN0cnVjdCBp bnRlbF9jcnRjX3N0YXRlICpwaXBlX2NvbmZpZywKPiAtCQkJCSAgICAgc3RydWN0IGRybV9jb25u ZWN0b3Jfc3RhdGUgKmNvbm5fc3RhdGUpCj4gK3N0YXRpYyBpbnQgaW50ZWxfZHNpX2NvbXB1dGVf Y29uZmlnKHN0cnVjdCBpbnRlbF9lbmNvZGVyICplbmNvZGVyLAo+ICsJCQkJICAgIHN0cnVjdCBp bnRlbF9jcnRjX3N0YXRlICpwaXBlX2NvbmZpZywKPiArCQkJCSAgICBzdHJ1Y3QgZHJtX2Nvbm5l Y3Rvcl9zdGF0ZSAqY29ubl9zdGF0ZSkKPiAgewo+ICAJc3RydWN0IGRybV9pOTE1X3ByaXZhdGUg KmRldl9wcml2ID0gdG9faTkxNShlbmNvZGVyLT5iYXNlLmRldik7Cj4gIAlzdHJ1Y3QgaW50ZWxf ZHNpICppbnRlbF9kc2kgPSBjb250YWluZXJfb2YoZW5jb2Rlciwgc3RydWN0IGludGVsX2RzaSwK PiBAQCAtMjg0LDcgKzI4NCw3IEBAIHN0YXRpYyBib29sIGludGVsX2RzaV9jb21wdXRlX2NvbmZp ZyhzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2RlciwKPiAgCX0KPiAgCj4gIAlpZiAoYWRqdXN0 ZWRfbW9kZS0+ZmxhZ3MgJiBEUk1fTU9ERV9GTEFHX0RCTFNDQU4pCj4gLQkJcmV0dXJuIGZhbHNl Owo+ICsJCXJldHVybiAtRUlOVkFMOwo+ICAKPiAgCS8qIERTSSB1c2VzIHNob3J0IHBhY2tldHMg Zm9yIHN5bmMgZXZlbnRzLCBzbyBjbGVhciBtb2RlIGZsYWdzIGZvciBEU0kgKi8KPiAgCWFkanVz dGVkX21vZGUtPmZsYWdzID0gMDsKPiBAQCAtMzAyLDE2ICszMDIsMTYgQEAgc3RhdGljIGJvb2wg aW50ZWxfZHNpX2NvbXB1dGVfY29uZmlnKHN0cnVjdCBpbnRlbF9lbmNvZGVyICplbmNvZGVyLAo+ ICAKPiAgCQlyZXQgPSBieHRfZHNpX3BsbF9jb21wdXRlKGVuY29kZXIsIHBpcGVfY29uZmlnKTsK PiAgCQlpZiAocmV0KQo+IC0JCQlyZXR1cm4gZmFsc2U7Cj4gKwkJCXJldHVybiAtRUlOVkFMOwo+ ICAJfSBlbHNlIHsKPiAgCQlyZXQgPSB2bHZfZHNpX3BsbF9jb21wdXRlKGVuY29kZXIsIHBpcGVf Y29uZmlnKTsKPiAgCQlpZiAocmV0KQo+IC0JCQlyZXR1cm4gZmFsc2U7Cj4gKwkJCXJldHVybiAt RUlOVkFMOwo+ICAJfQo+ICAKPiAgCXBpcGVfY29uZmlnLT5jbG9ja19zZXQgPSB0cnVlOwo+ICAK PiAtCXJldHVybiB0cnVlOwo+ICsJcmV0dXJuIDA7Cj4gIH0KPiAgCj4gIHN0YXRpYyBib29sIGds a19kc2lfZW5hYmxlX2lvKHN0cnVjdCBpbnRlbF9lbmNvZGVyICplbmNvZGVyKQoKLS0gCkphbmkg TmlrdWxhLCBJbnRlbCBPcGVuIFNvdXJjZSBHcmFwaGljcyBDZW50ZXIKX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KSW50ZWwtZ2Z4IG1haWxpbmcgbGlzdApJ bnRlbC1nZnhAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Au b3JnL21haWxtYW4vbGlzdGluZm8vaW50ZWwtZ2Z4Cg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-7.0 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_PASS 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 6B518C43387 for ; Wed, 16 Jan 2019 07:45:36 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 0FFCD2082F for ; Wed, 16 Jan 2019 07:45:36 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2388477AbfAPHpe convert rfc822-to-8bit (ORCPT ); Wed, 16 Jan 2019 02:45:34 -0500 Received: from mga06.intel.com ([134.134.136.31]:18128 "EHLO mga06.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1731167AbfAPHpd (ORCPT ); Wed, 16 Jan 2019 02:45:33 -0500 X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from fmsmga001.fm.intel.com ([10.253.24.23]) by orsmga104.jf.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 15 Jan 2019 23:45:32 -0800 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.56,485,1539673200"; d="scan'208";a="138678887" Received: from jnikula-mobl3.fi.intel.com (HELO localhost) ([10.237.66.172]) by fmsmga001.fm.intel.com with ESMTP; 15 Jan 2019 23:45:28 -0800 From: Jani Nikula To: Lyude Paul , intel-gfx@lists.freedesktop.org Cc: Ville =?utf-8?B?U3lyasOkbMOk?= , 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() In-Reply-To: <20190115200800.3121-1-lyude@redhat.com> Organization: Intel Finland Oy - BIC 0357606-4 - Westendinkatu 7, 02160 Espoo References: <20190115200800.3121-1-lyude@redhat.com> Date: Wed, 16 Jan 2019 09:47:17 +0200 Message-ID: <87r2dd59iy.fsf@intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 8BIT Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Tue, 15 Jan 2019, 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 > --- > 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(-) Despite being an all i915 patch, this got applied to drm-misc-next, causing conflicts where there really should have been none. :( I am tempted to suggest reverting and re-applying to drm-intel, because it will take weeks to sync both to drm-next and backmerge, and applying further work on top in drm-intel will just cause more trouble. Other ideas? BR, Jani. > > 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) -- Jani Nikula, Intel Open Source Graphics Center