From mboxrd@z Thu Jan 1 00:00:00 1970 From: Boris Brezillon Subject: Re: [PATCH v3] drm/bridge/sii902x: Fix EDID readback Date: Wed, 7 Nov 2018 20:17:19 +0100 Message-ID: <20181107201719.5f2f9fdf@bbrezillon> References: <1541505156-8097-1-git-send-email-fabrizio.castro@bp.renesas.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1541505156-8097-1-git-send-email-fabrizio.castro@bp.renesas.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Fabrizio Castro Cc: Geert Uytterhoeven , Simon Horman , Wolfram Sang , David Airlie , Boris Brezillon , Chris Paterson , dri-devel@lists.freedesktop.org, Biju Das , linux-renesas-soc@vger.kernel.org, Mark Brown , Laurent Pinchart , Peter Rosin , linux-i2c@vger.kernel.org List-Id: linux-i2c@vger.kernel.org T24gVHVlLCAgNiBOb3YgMjAxOCAxMTo1MjozNiArMDAwMApGYWJyaXppbyBDYXN0cm8gPGZhYnJp emlvLmNhc3Ryb0BicC5yZW5lc2FzLmNvbT4gd3JvdGU6Cgo+IFdoaWxlIGFkZGluZyBTaUk5MDIy QSBzdXBwb3J0IHRvIHRoZSBpd2cyM3MgYm9hcmQsIGl0IGNhbWUKPiB1cCB0aGF0IHdoZW4gdGhl IEhETUkgdHJhbnNtaXR0ZXIgaXMgaW4gcGFzcyB0aHJvdWdoIG1vZGUgdGhlCj4gZGV2aWNlIGlz IG5vdCBjb21wbGlhbnQgd2l0aCB0aGUgSTJDIHNwZWNpZmljYXRpb24gYW55bW9yZSwKPiBhcyBp dCByZXF1aXJlcyBhIGZhciBiaWdnZXIgdGJ1ZiwgZHVlIHRvIGEgZGVsYXkgdGhlIEhETUkKPiB0 cmFuc21pdHRlciBpcyBhZGRpbmcgd2hlbiByZWxheWluZyB0aGUgU1RPUCBjb25kaXRpb24gb24g dGhlCj4gbW9uaXRvciBpMmMgc2lkZSBvZiB0aGluZ3MuCj4gCj4gV2hlbiBub3QgcHJvdmlkaW5n IGFuIGFwcHJvcHJpYXRlIGRlbGF5IGFmdGVyIHRoZSBTVE9QIGNvbmRpdGlvbgo+IHRoZSBpMmMg YnVzIHdvdWxkIGdldCBzdHVjay4gQWxzbywgYW55IG90aGVyIHRyYWZmaWMgb24gdGhlIGJ1cwo+ IHdoaWxlIHRhbGtpbmcgdG8gdGhlIG1vbml0b3IgbWF5IGNhdXNlIHRoZSB0cmFuc2FjdGlvbiB0 byBmYWlsCj4gb3IgZXZlbiBjYXVzZSBpc3N1ZXMgd2l0aCB0aGUgaTJjIGJ1cyBhcyB3ZWxsLgo+ IAo+IEkyYy1nYXRlcyBzZWVtZWQgdG8gcmVhY2ggY29uc2VudCBhcyBhIHBvc3NpYmxlIHdheSB0 byBhZGRyZXNzCj4gdGhlc2UgaXNzdWVzLCBhbmQgYXMgc3VjaCB0aGlzIHBhdGNoIGlzIGltcGxl bWVudGluZyBhIHNvbHV0aW9uCj4gYmFzZWQgb24gdGhhdC4gU2luY2Ugb3RoZXJzIGFyZSBjbGVh cmx5IHJlbHlpbmcgb24gdGhlIGN1cnJlbnQKPiBpbXBsZW1lbnRhdGlvbiBvZiB0aGUgZHJpdmVy LCB0aGlzIHBhdGNoIHdvbid0IHJlcXVpcmUgYW55IERUCj4gY2hhbmdlcy4KPiAKPiBTaW5jZSB3 ZSBkb24ndCB3YW50IGFueSBpbnRlcmZlcmVuY2UgZHVyaW5nIHRoZSBEREMgQnVzCj4gUmVxdWVz dC9HcmFudCBwcm9jZWR1cmUgYW5kIHdoaWxlIHRhbGtpbmcgdG8gdGhlIG1vbml0b3IsIHdlCj4g aGF2ZSB0byB1c2UgdGhlIGFkYXB0ZXIgbG9ja2luZyBwcmltaXRpdmVzIHJhdGhlciB0aGFuIHRo ZQo+IGkyYy1tdXggbG9ja2luZyBwcmltaXRpdmVzLgo+IAo+IFNpZ25lZC1vZmYtYnk6IEZhYnJp emlvIENhc3RybyA8ZmFicml6aW8uY2FzdHJvQGJwLnJlbmVzYXMuY29tPgoKQWNrZWQtYnk6IEJv cmlzIEJyZXppbGxvbiA8Ym9yaXMuYnJlemlsbG9uQGJvb3RsaW4uY29tPgoKPiAKPiAtLS0KPiB2 Mi0+djM6Cj4gKiBJbmNvcnBvcmF0ZWQgY29tbWVudHMgZnJvbSBCb3JpcyBCcmV6aWxsb24gYW5k IFBldGVyIFJvc2luCj4gCj4gdjEtPnYyOgo+ICogSW5jb3Jwb3JhdGVkIGNvbW1lbnRzIGZyb20g UGV0ZXIgUm9zaW4KPiAKPiAgZHJpdmVycy9ncHUvZHJtL2JyaWRnZS9zaWk5MDJ4LmMgfCAyNDcg KysrKysrKysrKysrKysrKysrKysrKysrKysrKy0tLS0tLS0tLS0tCj4gIDEgZmlsZSBjaGFuZ2Vk LCAxNzggaW5zZXJ0aW9ucygrKSwgNjkgZGVsZXRpb25zKC0pCj4gCj4gZGlmZiAtLWdpdCBhL2Ry aXZlcnMvZ3B1L2RybS9icmlkZ2Uvc2lpOTAyeC5jIGIvZHJpdmVycy9ncHUvZHJtL2JyaWRnZS9z aWk5MDJ4LmMKPiBpbmRleCBlNTlhMTM1Li5iZmE5MDIwIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMv Z3B1L2RybS9icmlkZ2Uvc2lpOTAyeC5jCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2JyaWRnZS9z aWk5MDJ4LmMKPiBAQCAtMSw0ICsxLDYgQEAKPiAgLyoKPiArICogQ29weXJpZ2h0IChDKSAyMDE4 IFJlbmVzYXMgRWxlY3Ryb25pY3MKPiArICoKPiAgICogQ29weXJpZ2h0IChDKSAyMDE2IEF0bWVs Cj4gICAqCQkgICAgICBCbyBTaGVuIDx2b2ljZS5zaGVuQGF0bWVsLmNvbT4KPiAgICoKPiBAQCAt MjEsNiArMjMsNyBAQAo+ICAgKi8KPiAgCj4gICNpbmNsdWRlIDxsaW51eC9ncGlvL2NvbnN1bWVy Lmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9pMmMtbXV4Lmg+Cj4gICNpbmNsdWRlIDxsaW51eC9pMmMu aD4KPiAgI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgo+ICAjaW5jbHVkZSA8bGludXgvcmVnbWFw Lmg+Cj4gQEAgLTg2LDggKzg5LDQ5IEBAIHN0cnVjdCBzaWk5MDJ4IHsKPiAgCXN0cnVjdCBkcm1f YnJpZGdlIGJyaWRnZTsKPiAgCXN0cnVjdCBkcm1fY29ubmVjdG9yIGNvbm5lY3RvcjsKPiAgCXN0 cnVjdCBncGlvX2Rlc2MgKnJlc2V0X2dwaW87Cj4gKwlzdHJ1Y3QgaTJjX211eF9jb3JlICppMmNt dXg7Cj4gIH07Cj4gIAo+ICtzdGF0aWMgaW50IHNpaTkwMnhfcmVhZF91bmxvY2tlZChzdHJ1Y3Qg aTJjX2NsaWVudCAqaTJjLCB1OCByZWcsIHU4ICp2YWwpCj4gK3sKPiArCXVuaW9uIGkyY19zbWJ1 c19kYXRhIGRhdGE7Cj4gKwlpbnQgcmV0Owo+ICsKPiArCXJldCA9IF9faTJjX3NtYnVzX3hmZXIo aTJjLT5hZGFwdGVyLCBpMmMtPmFkZHIsIGkyYy0+ZmxhZ3MsCj4gKwkJCSAgICAgICBJMkNfU01C VVNfUkVBRCwgcmVnLCBJMkNfU01CVVNfQllURV9EQVRBLCAmZGF0YSk7Cj4gKwo+ICsJaWYgKHJl dCA8IDApCj4gKwkJcmV0dXJuIHJldDsKPiArCj4gKwkqdmFsID0gZGF0YS5ieXRlOwo+ICsJcmV0 dXJuIDA7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgc2lpOTAyeF93cml0ZV91bmxvY2tlZChzdHJ1 Y3QgaTJjX2NsaWVudCAqaTJjLCB1OCByZWcsIHU4IHZhbCkKPiArewo+ICsJdW5pb24gaTJjX3Nt YnVzX2RhdGEgZGF0YTsKPiArCj4gKwlkYXRhLmJ5dGUgPSB2YWw7Cj4gKwo+ICsJcmV0dXJuIF9f aTJjX3NtYnVzX3hmZXIoaTJjLT5hZGFwdGVyLCBpMmMtPmFkZHIsIGkyYy0+ZmxhZ3MsCj4gKwkJ CQlJMkNfU01CVVNfV1JJVEUsIHJlZywgSTJDX1NNQlVTX0JZVEVfREFUQSwKPiArCQkJCSZkYXRh KTsKPiArfQo+ICsKPiArc3RhdGljIGludCBzaWk5MDJ4X3VwZGF0ZV9iaXRzX3VubG9ja2VkKHN0 cnVjdCBpMmNfY2xpZW50ICppMmMsIHU4IHJlZywgdTggbWFzaywKPiArCQkJCQl1OCB2YWwpCj4g K3sKPiArCWludCByZXQ7Cj4gKwl1OCBzdGF0dXM7Cj4gKwo+ICsJcmV0ID0gc2lpOTAyeF9yZWFk X3VubG9ja2VkKGkyYywgcmVnLCAmc3RhdHVzKTsKPiArCWlmIChyZXQpCj4gKwkJcmV0dXJuIHJl dDsKPiArCXN0YXR1cyAmPSB+bWFzazsKPiArCXN0YXR1cyB8PSB2YWwgJiBtYXNrOwo+ICsJcmV0 dXJuIHNpaTkwMnhfd3JpdGVfdW5sb2NrZWQoaTJjLCByZWcsIHN0YXR1cyk7Cj4gK30KPiArCj4g IHN0YXRpYyBpbmxpbmUgc3RydWN0IHNpaTkwMnggKmJyaWRnZV90b19zaWk5MDJ4KHN0cnVjdCBk cm1fYnJpZGdlICpicmlkZ2UpCj4gIHsKPiAgCXJldHVybiBjb250YWluZXJfb2YoYnJpZGdlLCBz dHJ1Y3Qgc2lpOTAyeCwgYnJpZGdlKTsKPiBAQCAtMTM1LDQxICsxNzksMTEgQEAgc3RhdGljIGNv bnN0IHN0cnVjdCBkcm1fY29ubmVjdG9yX2Z1bmNzIHNpaTkwMnhfY29ubmVjdG9yX2Z1bmNzID0g ewo+ICBzdGF0aWMgaW50IHNpaTkwMnhfZ2V0X21vZGVzKHN0cnVjdCBkcm1fY29ubmVjdG9yICpj b25uZWN0b3IpCj4gIHsKPiAgCXN0cnVjdCBzaWk5MDJ4ICpzaWk5MDJ4ID0gY29ubmVjdG9yX3Rv X3NpaTkwMngoY29ubmVjdG9yKTsKPiAtCXN0cnVjdCByZWdtYXAgKnJlZ21hcCA9IHNpaTkwMngt PnJlZ21hcDsKPiAgCXUzMiBidXNfZm9ybWF0ID0gTUVESUFfQlVTX0ZNVF9SR0I4ODhfMVgyNDsK PiAtCXN0cnVjdCBkZXZpY2UgKmRldiA9ICZzaWk5MDJ4LT5pMmMtPmRldjsKPiAtCXVuc2lnbmVk IGxvbmcgdGltZW91dDsKPiAtCXVuc2lnbmVkIGludCByZXRyaWVzOwo+IC0JdW5zaWduZWQgaW50 IHN0YXR1czsKPiAgCXN0cnVjdCBlZGlkICplZGlkOwo+IC0JaW50IG51bSA9IDA7Cj4gLQlpbnQg cmV0Owo+IC0KPiAtCXJldCA9IHJlZ21hcF91cGRhdGVfYml0cyhyZWdtYXAsIFNJSTkwMlhfU1lT X0NUUkxfREFUQSwKPiAtCQkJCSBTSUk5MDJYX1NZU19DVFJMX0REQ19CVVNfUkVRLAo+IC0JCQkJ IFNJSTkwMlhfU1lTX0NUUkxfRERDX0JVU19SRVEpOwo+IC0JaWYgKHJldCkKPiAtCQlyZXR1cm4g cmV0Owo+IC0KPiAtCXRpbWVvdXQgPSBqaWZmaWVzICsKPiAtCQkgIG1zZWNzX3RvX2ppZmZpZXMo U0lJOTAyWF9JMkNfQlVTX0FDUVVJU0lUSU9OX1RJTUVPVVRfTVMpOwo+IC0JZG8gewo+IC0JCXJl dCA9IHJlZ21hcF9yZWFkKHJlZ21hcCwgU0lJOTAyWF9TWVNfQ1RSTF9EQVRBLCAmc3RhdHVzKTsK PiAtCQlpZiAocmV0KQo+IC0JCQlyZXR1cm4gcmV0Owo+IC0JfSB3aGlsZSAoIShzdGF0dXMgJiBT SUk5MDJYX1NZU19DVFJMX0REQ19CVVNfR1JURCkgJiYKPiAtCQkgdGltZV9iZWZvcmUoamlmZmll cywgdGltZW91dCkpOwo+ICsJaW50IG51bSA9IDAsIHJldDsKPiAgCj4gLQlpZiAoIShzdGF0dXMg JiBTSUk5MDJYX1NZU19DVFJMX0REQ19CVVNfR1JURCkpIHsKPiAtCQlkZXZfZXJyKGRldiwgImZh aWxlZCB0byBhY3F1aXJlIHRoZSBpMmMgYnVzXG4iKTsKPiAtCQlyZXR1cm4gLUVUSU1FRE9VVDsK PiAtCX0KPiAtCj4gLQlyZXQgPSByZWdtYXBfd3JpdGUocmVnbWFwLCBTSUk5MDJYX1NZU19DVFJM X0RBVEEsIHN0YXR1cyk7Cj4gLQlpZiAocmV0KQo+IC0JCXJldHVybiByZXQ7Cj4gLQo+IC0JZWRp ZCA9IGRybV9nZXRfZWRpZChjb25uZWN0b3IsIHNpaTkwMngtPmkyYy0+YWRhcHRlcik7Cj4gKwll ZGlkID0gZHJtX2dldF9lZGlkKGNvbm5lY3Rvciwgc2lpOTAyeC0+aTJjbXV4LT5hZGFwdGVyWzBd KTsKPiAgCWRybV9jb25uZWN0b3JfdXBkYXRlX2VkaWRfcHJvcGVydHkoY29ubmVjdG9yLCBlZGlk KTsKPiAgCWlmIChlZGlkKSB7Cj4gIAkJbnVtID0gZHJtX2FkZF9lZGlkX21vZGVzKGNvbm5lY3Rv ciwgZWRpZCk7Cj4gQEAgLTE4MSw0MiArMTk1LDYgQEAgc3RhdGljIGludCBzaWk5MDJ4X2dldF9t b2RlcyhzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9yKQo+ICAJaWYgKHJldCkKPiAgCQly ZXR1cm4gcmV0Owo+ICAKPiAtCS8qCj4gLQkgKiBTb21ldGltZXMgdGhlIEkyQyBidXMgY2FuIHN0 YWxsIGFmdGVyIGZhaWx1cmUgdG8gdXNlIHRoZQo+IC0JICogRURJRCBjaGFubmVsLiBSZXRyeSBh IGZldyB0aW1lcyB0byBzZWUgaWYgdGhpbmdzIGNsZWFyCj4gLQkgKiB1cCwgZWxzZSBjb250aW51 ZSBhbnl3YXkuCj4gLQkgKi8KPiAtCXJldHJpZXMgPSA1Owo+IC0JZG8gewo+IC0JCXJldCA9IHJl Z21hcF9yZWFkKHJlZ21hcCwgU0lJOTAyWF9TWVNfQ1RSTF9EQVRBLAo+IC0JCQkJICAmc3RhdHVz KTsKPiAtCQlyZXRyaWVzLS07Cj4gLQl9IHdoaWxlIChyZXQgJiYgcmV0cmllcyk7Cj4gLQlpZiAo cmV0KQo+IC0JCWRldl9lcnIoZGV2LCAiZmFpbGVkIHRvIHJlYWQgc3RhdHVzICglZClcbiIsIHJl dCk7Cj4gLQo+IC0JcmV0ID0gcmVnbWFwX3VwZGF0ZV9iaXRzKHJlZ21hcCwgU0lJOTAyWF9TWVNf Q1RSTF9EQVRBLAo+IC0JCQkJIFNJSTkwMlhfU1lTX0NUUkxfRERDX0JVU19SRVEgfAo+IC0JCQkJ IFNJSTkwMlhfU1lTX0NUUkxfRERDX0JVU19HUlRELCAwKTsKPiAtCWlmIChyZXQpCj4gLQkJcmV0 dXJuIHJldDsKPiAtCj4gLQl0aW1lb3V0ID0gamlmZmllcyArCj4gLQkJICBtc2Vjc190b19qaWZm aWVzKFNJSTkwMlhfSTJDX0JVU19BQ1FVSVNJVElPTl9USU1FT1VUX01TKTsKPiAtCWRvIHsKPiAt CQlyZXQgPSByZWdtYXBfcmVhZChyZWdtYXAsIFNJSTkwMlhfU1lTX0NUUkxfREFUQSwgJnN0YXR1 cyk7Cj4gLQkJaWYgKHJldCkKPiAtCQkJcmV0dXJuIHJldDsKPiAtCX0gd2hpbGUgKHN0YXR1cyAm IChTSUk5MDJYX1NZU19DVFJMX0REQ19CVVNfUkVRIHwKPiAtCQkJICAgU0lJOTAyWF9TWVNfQ1RS TF9ERENfQlVTX0dSVEQpICYmCj4gLQkJIHRpbWVfYmVmb3JlKGppZmZpZXMsIHRpbWVvdXQpKTsK PiAtCj4gLQlpZiAoc3RhdHVzICYgKFNJSTkwMlhfU1lTX0NUUkxfRERDX0JVU19SRVEgfAo+IC0J CSAgICAgIFNJSTkwMlhfU1lTX0NUUkxfRERDX0JVU19HUlREKSkgewo+IC0JCWRldl9lcnIoZGV2 LCAiZmFpbGVkIHRvIHJlbGVhc2UgdGhlIGkyYyBidXNcbiIpOwo+IC0JCXJldHVybiAtRVRJTUVE T1VUOwo+IC0JfQo+IC0KPiAgCXJldHVybiBudW07Cj4gIH0KPiAgCj4gQEAgLTM2Niw2ICszNDQs MTIxIEBAIHN0YXRpYyBpcnFyZXR1cm5fdCBzaWk5MDJ4X2ludGVycnVwdChpbnQgaXJxLCB2b2lk ICpkYXRhKQo+ICAJcmV0dXJuIElSUV9IQU5ETEVEOwo+ICB9Cj4gIAo+ICsvKgo+ICsgKiBUaGUg cHVycG9zZSBvZiBzaWk5MDJ4X2kyY19ieXBhc3Nfc2VsZWN0IGlzIHRvIGVuYWJsZSB0aGUgcGFz cyB0aHJvdWdoCj4gKyAqIG1vZGUgb2YgdGhlIEhETUkgdHJhbnNtaXR0ZXIuIERvIG5vdCB1c2Ug cmVnbWFwIGZyb20gd2l0aGluIHRoaXMgZnVuY3Rpb24sCj4gKyAqIG9ubHkgdXNlIHNpaTkwMnhf Kl91bmxvY2tlZCBmdW5jdGlvbnMgdG8gcmVhZC9tb2RpZnkvd3JpdGUgcmVnaXN0ZXJzLgo+ICsg KiBXZSBhcmUgaG9sZGluZyB0aGUgcGFyZW50IGFkYXB0ZXIgbG9jayBoZXJlLCBrZWVwIHRoaXMg aW4gbWluZCBiZWZvcmUKPiArICogYWRkaW5nIG1vcmUgaTJjIHRyYW5zYWN0aW9ucy4KPiArICoK PiArICogQWxzbywgc2luY2UgU0lJOTAyWF9TWVNfQ1RSTF9EQVRBIGlzIHVzZWQgd2l0aCByZWdt YXBfdXBkYXRlX2JpdHMgZWxzZXdoZXJlCj4gKyAqIGluIHRoaXMgZHJpdmVyLCB3ZSBuZWVkIHRv IG1ha2Ugc3VyZSB0aGF0IHdlIG9ubHkgdG91Y2ggMHgxQVsyOjFdIGZyb20KPiArICogd2l0aGlu IHNpaTkwMnhfaTJjX2J5cGFzc19zZWxlY3QgYW5kIHNpaTkwMnhfaTJjX2J5cGFzc19kZXNlbGVj dCwgYW5kIHRoYXQKPiArICogd2UgbGVhdmUgdGhlIHJlbWFpbmluZyBiaXRzIGFzIHdlIGhhdmUg Zm91bmQgdGhlbS4KPiArICovCj4gK3N0YXRpYyBpbnQgc2lpOTAyeF9pMmNfYnlwYXNzX3NlbGVj dChzdHJ1Y3QgaTJjX211eF9jb3JlICptdXgsIHUzMiBjaGFuX2lkKQo+ICt7Cj4gKwlzdHJ1Y3Qg c2lpOTAyeCAqc2lpOTAyeCA9IGkyY19tdXhfcHJpdihtdXgpOwo+ICsJc3RydWN0IGRldmljZSAq ZGV2ID0gJnNpaTkwMngtPmkyYy0+ZGV2Owo+ICsJdW5zaWduZWQgbG9uZyB0aW1lb3V0Owo+ICsJ dTggc3RhdHVzOwo+ICsJaW50IHJldDsKPiArCj4gKwlyZXQgPSBzaWk5MDJ4X3VwZGF0ZV9iaXRz X3VubG9ja2VkKHNpaTkwMngtPmkyYywgU0lJOTAyWF9TWVNfQ1RSTF9EQVRBLAo+ICsJCQkJCSAg IFNJSTkwMlhfU1lTX0NUUkxfRERDX0JVU19SRVEsCj4gKwkJCQkJICAgU0lJOTAyWF9TWVNfQ1RS TF9ERENfQlVTX1JFUSk7Cj4gKwlpZiAocmV0KQo+ICsJCXJldHVybiByZXQ7Cj4gKwo+ICsJdGlt ZW91dCA9IGppZmZpZXMgKwo+ICsJCSAgbXNlY3NfdG9famlmZmllcyhTSUk5MDJYX0kyQ19CVVNf QUNRVUlTSVRJT05fVElNRU9VVF9NUyk7Cj4gKwlkbyB7Cj4gKwkJcmV0ID0gc2lpOTAyeF9yZWFk X3VubG9ja2VkKHNpaTkwMngtPmkyYywgU0lJOTAyWF9TWVNfQ1RSTF9EQVRBLAo+ICsJCQkJCSAg ICAmc3RhdHVzKTsKPiArCQlpZiAocmV0KQo+ICsJCQlyZXR1cm4gcmV0Owo+ICsJfSB3aGlsZSAo IShzdGF0dXMgJiBTSUk5MDJYX1NZU19DVFJMX0REQ19CVVNfR1JURCkgJiYKPiArCQkgdGltZV9i ZWZvcmUoamlmZmllcywgdGltZW91dCkpOwo+ICsKPiArCWlmICghKHN0YXR1cyAmIFNJSTkwMlhf U1lTX0NUUkxfRERDX0JVU19HUlREKSkgewo+ICsJCWRldl9lcnIoZGV2LCAiRmFpbGVkIHRvIGFj cXVpcmUgdGhlIGkyYyBidXNcbiIpOwo+ICsJCXJldHVybiAtRVRJTUVET1VUOwo+ICsJfQo+ICsK PiArCXJldHVybiBzaWk5MDJ4X3dyaXRlX3VubG9ja2VkKHNpaTkwMngtPmkyYywgU0lJOTAyWF9T WVNfQ1RSTF9EQVRBLAo+ICsJCQkJICAgICAgc3RhdHVzKTsKPiArfQo+ICsKPiArLyoKPiArICog VGhlIHB1cnBvc2Ugb2Ygc2lpOTAyeF9pMmNfYnlwYXNzX2Rlc2VsZWN0IGlzIHRvIGRpc2FibGUg dGhlIHBhc3MgdGhyb3VnaAo+ICsgKiBtb2RlIG9mIHRoZSBIRE1JIHRyYW5zbWl0dGVyLiBEbyBu b3QgdXNlIHJlZ21hcCBmcm9tIHdpdGhpbiB0aGlzIGZ1bmN0aW9uLAo+ICsgKiBvbmx5IHVzZSBz aWk5MDJ4XypfdW5sb2NrZWQgZnVuY3Rpb25zIHRvIHJlYWQvbW9kaWZ5L3dyaXRlIHJlZ2lzdGVy cy4KPiArICogV2UgYXJlIGhvbGRpbmcgdGhlIHBhcmVudCBhZGFwdGVyIGxvY2sgaGVyZSwga2Vl cCB0aGlzIGluIG1pbmQgYmVmb3JlCj4gKyAqIGFkZGluZyBtb3JlIGkyYyB0cmFuc2FjdGlvbnMu Cj4gKyAqCj4gKyAqIEFsc28sIHNpbmNlIFNJSTkwMlhfU1lTX0NUUkxfREFUQSBpcyB1c2VkIHdp dGggcmVnbWFwX3VwZGF0ZV9iaXRzIGVsc2V3aGVyZQo+ICsgKiBpbiB0aGlzIGRyaXZlciwgd2Ug bmVlZCB0byBtYWtlIHN1cmUgdGhhdCB3ZSBvbmx5IHRvdWNoIDB4MUFbMjoxXSBmcm9tCj4gKyAq IHdpdGhpbiBzaWk5MDJ4X2kyY19ieXBhc3Nfc2VsZWN0IGFuZCBzaWk5MDJ4X2kyY19ieXBhc3Nf ZGVzZWxlY3QsIGFuZCB0aGF0Cj4gKyAqIHdlIGxlYXZlIHRoZSByZW1haW5pbmcgYml0cyBhcyB3 ZSBoYXZlIGZvdW5kIHRoZW0uCj4gKyAqLwo+ICtzdGF0aWMgaW50IHNpaTkwMnhfaTJjX2J5cGFz c19kZXNlbGVjdChzdHJ1Y3QgaTJjX211eF9jb3JlICptdXgsIHUzMiBjaGFuX2lkKQo+ICt7Cj4g KwlzdHJ1Y3Qgc2lpOTAyeCAqc2lpOTAyeCA9IGkyY19tdXhfcHJpdihtdXgpOwo+ICsJc3RydWN0 IGRldmljZSAqZGV2ID0gJnNpaTkwMngtPmkyYy0+ZGV2Owo+ICsJdW5zaWduZWQgbG9uZyB0aW1l b3V0Owo+ICsJdW5zaWduZWQgaW50IHJldHJpZXM7Cj4gKwl1OCBzdGF0dXM7Cj4gKwlpbnQgcmV0 Owo+ICsKPiArCS8qCj4gKwkgKiBXaGVuIHRoZSBIRE1JIHRyYW5zbWl0dGVyIGlzIGluIHBhc3Mg dGhyb3VnaCBtb2RlLCB3ZSBuZWVkIGFuCj4gKwkgKiAodW5kb2N1bWVudGVkKSBhZGRpdGlvbmFs IGRlbGF5IGJldHdlZW4gU1RPUCBhbmQgU1RBUlQgY29uZGl0aW9ucwo+ICsJICogdG8gZ3VhcmFu dGVlIHRoZSBidXMgd29uJ3QgZ2V0IHN0dWNrLgo+ICsJICovCj4gKwl1ZGVsYXkoMzApOwo+ICsK PiArCS8qCj4gKwkgKiBTb21ldGltZXMgdGhlIEkyQyBidXMgY2FuIHN0YWxsIGFmdGVyIGZhaWx1 cmUgdG8gdXNlIHRoZQo+ICsJICogRURJRCBjaGFubmVsLiBSZXRyeSBhIGZldyB0aW1lcyB0byBz ZWUgaWYgdGhpbmdzIGNsZWFyCj4gKwkgKiB1cCwgZWxzZSBjb250aW51ZSBhbnl3YXkuCj4gKwkg Ki8KPiArCXJldHJpZXMgPSA1Owo+ICsJZG8gewo+ICsJCXJldCA9IHNpaTkwMnhfcmVhZF91bmxv Y2tlZChzaWk5MDJ4LT5pMmMsIFNJSTkwMlhfU1lTX0NUUkxfREFUQSwKPiArCQkJCQkgICAgJnN0 YXR1cyk7Cj4gKwkJcmV0cmllcy0tOwo+ICsJfSB3aGlsZSAocmV0ICYmIHJldHJpZXMpOwo+ICsJ aWYgKHJldCkgewo+ICsJCWRldl9lcnIoZGV2LCAiZmFpbGVkIHRvIHJlYWQgc3RhdHVzICglZClc biIsIHJldCk7Cj4gKwkJcmV0dXJuIHJldDsKPiArCX0KPiArCj4gKwlyZXQgPSBzaWk5MDJ4X3Vw ZGF0ZV9iaXRzX3VubG9ja2VkKHNpaTkwMngtPmkyYywgU0lJOTAyWF9TWVNfQ1RSTF9EQVRBLAo+ ICsJCQkJCSAgIFNJSTkwMlhfU1lTX0NUUkxfRERDX0JVU19SRVEgfAo+ICsJCQkJCSAgIFNJSTkw MlhfU1lTX0NUUkxfRERDX0JVU19HUlRELCAwKTsKPiArCWlmIChyZXQpCj4gKwkJcmV0dXJuIHJl dDsKPiArCj4gKwl0aW1lb3V0ID0gamlmZmllcyArCj4gKwkJICBtc2Vjc190b19qaWZmaWVzKFNJ STkwMlhfSTJDX0JVU19BQ1FVSVNJVElPTl9USU1FT1VUX01TKTsKPiArCWRvIHsKPiArCQlyZXQg PSBzaWk5MDJ4X3JlYWRfdW5sb2NrZWQoc2lpOTAyeC0+aTJjLCBTSUk5MDJYX1NZU19DVFJMX0RB VEEsCj4gKwkJCQkJICAgICZzdGF0dXMpOwo+ICsJCWlmIChyZXQpCj4gKwkJCXJldHVybiByZXQ7 Cj4gKwl9IHdoaWxlIChzdGF0dXMgJiAoU0lJOTAyWF9TWVNfQ1RSTF9ERENfQlVTX1JFUSB8Cj4g KwkJCSAgIFNJSTkwMlhfU1lTX0NUUkxfRERDX0JVU19HUlREKSAmJgo+ICsJCSB0aW1lX2JlZm9y ZShqaWZmaWVzLCB0aW1lb3V0KSk7Cj4gKwo+ICsJaWYgKHN0YXR1cyAmIChTSUk5MDJYX1NZU19D VFJMX0REQ19CVVNfUkVRIHwKPiArCQkgICAgICBTSUk5MDJYX1NZU19DVFJMX0REQ19CVVNfR1JU RCkpIHsKPiArCQlkZXZfZXJyKGRldiwgImZhaWxlZCB0byByZWxlYXNlIHRoZSBpMmMgYnVzXG4i KTsKPiArCQlyZXR1cm4gLUVUSU1FRE9VVDsKPiArCX0KPiArCj4gKwlyZXR1cm4gMDsKPiArfQo+ ICsKPiAgc3RhdGljIGludCBzaWk5MDJ4X3Byb2JlKHN0cnVjdCBpMmNfY2xpZW50ICpjbGllbnQs Cj4gIAkJCSBjb25zdCBzdHJ1Y3QgaTJjX2RldmljZV9pZCAqaWQpCj4gIHsKPiBAQCAtMzc1LDYg KzQ2OCwxMyBAQCBzdGF0aWMgaW50IHNpaTkwMnhfcHJvYmUoc3RydWN0IGkyY19jbGllbnQgKmNs aWVudCwKPiAgCXU4IGNoaXBpZFs0XTsKPiAgCWludCByZXQ7Cj4gIAo+ICsJcmV0ID0gaTJjX2No ZWNrX2Z1bmN0aW9uYWxpdHkoY2xpZW50LT5hZGFwdGVyLAo+ICsJCQkJICAgICAgSTJDX0ZVTkNf U01CVVNfQllURV9EQVRBKTsKPiArCWlmICghcmV0KSB7Cj4gKwkJZGV2X2VycihkZXYsICJJMkMg YWRhcHRlciBub3Qgc3VpdGFibGVcbiIpOwo+ICsJCXJldHVybiAtRUlPOwo+ICsJfQo+ICsKPiAg CXNpaTkwMnggPSBkZXZtX2t6YWxsb2MoZGV2LCBzaXplb2YoKnNpaTkwMngpLCBHRlBfS0VSTkVM KTsKPiAgCWlmICghc2lpOTAyeCkKPiAgCQlyZXR1cm4gLUVOT01FTTsKPiBAQCAtNDMzLDcgKzUz MywxNSBAQCBzdGF0aWMgaW50IHNpaTkwMnhfcHJvYmUoc3RydWN0IGkyY19jbGllbnQgKmNsaWVu dCwKPiAgCj4gIAlpMmNfc2V0X2NsaWVudGRhdGEoY2xpZW50LCBzaWk5MDJ4KTsKPiAgCj4gLQly ZXR1cm4gMDsKPiArCXNpaTkwMngtPmkyY211eCA9IGkyY19tdXhfYWxsb2MoY2xpZW50LT5hZGFw dGVyLCBkZXYsCj4gKwkJCQkJMSwgMCwgSTJDX01VWF9HQVRFLAo+ICsJCQkJCXNpaTkwMnhfaTJj X2J5cGFzc19zZWxlY3QsCj4gKwkJCQkJc2lpOTAyeF9pMmNfYnlwYXNzX2Rlc2VsZWN0KTsKPiAr CWlmICghc2lpOTAyeC0+aTJjbXV4KQo+ICsJCXJldHVybiAtRU5PTUVNOwo+ICsKPiArCXNpaTkw MngtPmkyY211eC0+cHJpdiA9IHNpaTkwMng7Cj4gKwlyZXR1cm4gaTJjX211eF9hZGRfYWRhcHRl cihzaWk5MDJ4LT5pMmNtdXgsIDAsIDAsIDApOwo+ICB9Cj4gIAo+ICBzdGF0aWMgaW50IHNpaTkw MnhfcmVtb3ZlKHN0cnVjdCBpMmNfY2xpZW50ICpjbGllbnQpCj4gQEAgLTQ0MSw2ICs1NDksNyBA QCBzdGF0aWMgaW50IHNpaTkwMnhfcmVtb3ZlKHN0cnVjdCBpMmNfY2xpZW50ICpjbGllbnQpCj4g IHsKPiAgCXN0cnVjdCBzaWk5MDJ4ICpzaWk5MDJ4ID0gaTJjX2dldF9jbGllbnRkYXRhKGNsaWVu dCk7Cj4gIAo+ICsJaTJjX211eF9kZWxfYWRhcHRlcnMoc2lpOTAyeC0+aTJjbXV4KTsKPiAgCWRy bV9icmlkZ2VfcmVtb3ZlKCZzaWk5MDJ4LT5icmlkZ2UpOwo+ICAKPiAgCXJldHVybiAwOwoKX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1h aWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMu ZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVsCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Date: Wed, 7 Nov 2018 20:17:19 +0100 From: Boris Brezillon To: Fabrizio Castro Cc: Archit Taneja , Andrzej Hajda , David Airlie , Peter Rosin , Wolfram Sang , Mark Brown , Laurent Pinchart , dri-devel@lists.freedesktop.org, Simon Horman , Geert Uytterhoeven , Chris Paterson , Biju Das , linux-renesas-soc@vger.kernel.org, linux-i2c@vger.kernel.org, Inki Dae , Boris Brezillon , Linus Walleij Subject: Re: [PATCH v3] drm/bridge/sii902x: Fix EDID readback Message-ID: <20181107201719.5f2f9fdf@bbrezillon> In-Reply-To: <1541505156-8097-1-git-send-email-fabrizio.castro@bp.renesas.com> References: <1541505156-8097-1-git-send-email-fabrizio.castro@bp.renesas.com> MIME-Version: 1.0 Content-Type: text/plain; charset=US-ASCII Content-Transfer-Encoding: 7bit Sender: linux-i2c-owner@vger.kernel.org List-ID: On Tue, 6 Nov 2018 11:52:36 +0000 Fabrizio Castro wrote: > While adding SiI9022A support to the iwg23s board, it came > up that when the HDMI transmitter is in pass through mode the > device is not compliant with the I2C specification anymore, > as it requires a far bigger tbuf, due to a delay the HDMI > transmitter is adding when relaying the STOP condition on the > monitor i2c side of things. > > When not providing an appropriate delay after the STOP condition > the i2c bus would get stuck. Also, any other traffic on the bus > while talking to the monitor may cause the transaction to fail > or even cause issues with the i2c bus as well. > > I2c-gates seemed to reach consent as a possible way to address > these issues, and as such this patch is implementing a solution > based on that. Since others are clearly relying on the current > implementation of the driver, this patch won't require any DT > changes. > > Since we don't want any interference during the DDC Bus > Request/Grant procedure and while talking to the monitor, we > have to use the adapter locking primitives rather than the > i2c-mux locking primitives. > > Signed-off-by: Fabrizio Castro Acked-by: Boris Brezillon > > --- > v2->v3: > * Incorporated comments from Boris Brezillon and Peter Rosin > > v1->v2: > * Incorporated comments from Peter Rosin > > drivers/gpu/drm/bridge/sii902x.c | 247 ++++++++++++++++++++++++++++----------- > 1 file changed, 178 insertions(+), 69 deletions(-) > > diff --git a/drivers/gpu/drm/bridge/sii902x.c b/drivers/gpu/drm/bridge/sii902x.c > index e59a135..bfa9020 100644 > --- a/drivers/gpu/drm/bridge/sii902x.c > +++ b/drivers/gpu/drm/bridge/sii902x.c > @@ -1,4 +1,6 @@ > /* > + * Copyright (C) 2018 Renesas Electronics > + * > * Copyright (C) 2016 Atmel > * Bo Shen > * > @@ -21,6 +23,7 @@ > */ > > #include > +#include > #include > #include > #include > @@ -86,8 +89,49 @@ struct sii902x { > struct drm_bridge bridge; > struct drm_connector connector; > struct gpio_desc *reset_gpio; > + struct i2c_mux_core *i2cmux; > }; > > +static int sii902x_read_unlocked(struct i2c_client *i2c, u8 reg, u8 *val) > +{ > + union i2c_smbus_data data; > + int ret; > + > + ret = __i2c_smbus_xfer(i2c->adapter, i2c->addr, i2c->flags, > + I2C_SMBUS_READ, reg, I2C_SMBUS_BYTE_DATA, &data); > + > + if (ret < 0) > + return ret; > + > + *val = data.byte; > + return 0; > +} > + > +static int sii902x_write_unlocked(struct i2c_client *i2c, u8 reg, u8 val) > +{ > + union i2c_smbus_data data; > + > + data.byte = val; > + > + return __i2c_smbus_xfer(i2c->adapter, i2c->addr, i2c->flags, > + I2C_SMBUS_WRITE, reg, I2C_SMBUS_BYTE_DATA, > + &data); > +} > + > +static int sii902x_update_bits_unlocked(struct i2c_client *i2c, u8 reg, u8 mask, > + u8 val) > +{ > + int ret; > + u8 status; > + > + ret = sii902x_read_unlocked(i2c, reg, &status); > + if (ret) > + return ret; > + status &= ~mask; > + status |= val & mask; > + return sii902x_write_unlocked(i2c, reg, status); > +} > + > static inline struct sii902x *bridge_to_sii902x(struct drm_bridge *bridge) > { > return container_of(bridge, struct sii902x, bridge); > @@ -135,41 +179,11 @@ static const struct drm_connector_funcs sii902x_connector_funcs = { > static int sii902x_get_modes(struct drm_connector *connector) > { > struct sii902x *sii902x = connector_to_sii902x(connector); > - struct regmap *regmap = sii902x->regmap; > u32 bus_format = MEDIA_BUS_FMT_RGB888_1X24; > - struct device *dev = &sii902x->i2c->dev; > - unsigned long timeout; > - unsigned int retries; > - unsigned int status; > struct edid *edid; > - int num = 0; > - int ret; > - > - ret = regmap_update_bits(regmap, SII902X_SYS_CTRL_DATA, > - SII902X_SYS_CTRL_DDC_BUS_REQ, > - SII902X_SYS_CTRL_DDC_BUS_REQ); > - if (ret) > - return ret; > - > - timeout = jiffies + > - msecs_to_jiffies(SII902X_I2C_BUS_ACQUISITION_TIMEOUT_MS); > - do { > - ret = regmap_read(regmap, SII902X_SYS_CTRL_DATA, &status); > - if (ret) > - return ret; > - } while (!(status & SII902X_SYS_CTRL_DDC_BUS_GRTD) && > - time_before(jiffies, timeout)); > + int num = 0, ret; > > - if (!(status & SII902X_SYS_CTRL_DDC_BUS_GRTD)) { > - dev_err(dev, "failed to acquire the i2c bus\n"); > - return -ETIMEDOUT; > - } > - > - ret = regmap_write(regmap, SII902X_SYS_CTRL_DATA, status); > - if (ret) > - return ret; > - > - edid = drm_get_edid(connector, sii902x->i2c->adapter); > + edid = drm_get_edid(connector, sii902x->i2cmux->adapter[0]); > drm_connector_update_edid_property(connector, edid); > if (edid) { > num = drm_add_edid_modes(connector, edid); > @@ -181,42 +195,6 @@ static int sii902x_get_modes(struct drm_connector *connector) > if (ret) > return ret; > > - /* > - * Sometimes the I2C bus can stall after failure to use the > - * EDID channel. Retry a few times to see if things clear > - * up, else continue anyway. > - */ > - retries = 5; > - do { > - ret = regmap_read(regmap, SII902X_SYS_CTRL_DATA, > - &status); > - retries--; > - } while (ret && retries); > - if (ret) > - dev_err(dev, "failed to read status (%d)\n", ret); > - > - ret = regmap_update_bits(regmap, SII902X_SYS_CTRL_DATA, > - SII902X_SYS_CTRL_DDC_BUS_REQ | > - SII902X_SYS_CTRL_DDC_BUS_GRTD, 0); > - if (ret) > - return ret; > - > - timeout = jiffies + > - msecs_to_jiffies(SII902X_I2C_BUS_ACQUISITION_TIMEOUT_MS); > - do { > - ret = regmap_read(regmap, SII902X_SYS_CTRL_DATA, &status); > - if (ret) > - return ret; > - } while (status & (SII902X_SYS_CTRL_DDC_BUS_REQ | > - SII902X_SYS_CTRL_DDC_BUS_GRTD) && > - time_before(jiffies, timeout)); > - > - if (status & (SII902X_SYS_CTRL_DDC_BUS_REQ | > - SII902X_SYS_CTRL_DDC_BUS_GRTD)) { > - dev_err(dev, "failed to release the i2c bus\n"); > - return -ETIMEDOUT; > - } > - > return num; > } > > @@ -366,6 +344,121 @@ static irqreturn_t sii902x_interrupt(int irq, void *data) > return IRQ_HANDLED; > } > > +/* > + * The purpose of sii902x_i2c_bypass_select is to enable the pass through > + * mode of the HDMI transmitter. Do not use regmap from within this function, > + * only use sii902x_*_unlocked functions to read/modify/write registers. > + * We are holding the parent adapter lock here, keep this in mind before > + * adding more i2c transactions. > + * > + * Also, since SII902X_SYS_CTRL_DATA is used with regmap_update_bits elsewhere > + * in this driver, we need to make sure that we only touch 0x1A[2:1] from > + * within sii902x_i2c_bypass_select and sii902x_i2c_bypass_deselect, and that > + * we leave the remaining bits as we have found them. > + */ > +static int sii902x_i2c_bypass_select(struct i2c_mux_core *mux, u32 chan_id) > +{ > + struct sii902x *sii902x = i2c_mux_priv(mux); > + struct device *dev = &sii902x->i2c->dev; > + unsigned long timeout; > + u8 status; > + int ret; > + > + ret = sii902x_update_bits_unlocked(sii902x->i2c, SII902X_SYS_CTRL_DATA, > + SII902X_SYS_CTRL_DDC_BUS_REQ, > + SII902X_SYS_CTRL_DDC_BUS_REQ); > + if (ret) > + return ret; > + > + timeout = jiffies + > + msecs_to_jiffies(SII902X_I2C_BUS_ACQUISITION_TIMEOUT_MS); > + do { > + ret = sii902x_read_unlocked(sii902x->i2c, SII902X_SYS_CTRL_DATA, > + &status); > + if (ret) > + return ret; > + } while (!(status & SII902X_SYS_CTRL_DDC_BUS_GRTD) && > + time_before(jiffies, timeout)); > + > + if (!(status & SII902X_SYS_CTRL_DDC_BUS_GRTD)) { > + dev_err(dev, "Failed to acquire the i2c bus\n"); > + return -ETIMEDOUT; > + } > + > + return sii902x_write_unlocked(sii902x->i2c, SII902X_SYS_CTRL_DATA, > + status); > +} > + > +/* > + * The purpose of sii902x_i2c_bypass_deselect is to disable the pass through > + * mode of the HDMI transmitter. Do not use regmap from within this function, > + * only use sii902x_*_unlocked functions to read/modify/write registers. > + * We are holding the parent adapter lock here, keep this in mind before > + * adding more i2c transactions. > + * > + * Also, since SII902X_SYS_CTRL_DATA is used with regmap_update_bits elsewhere > + * in this driver, we need to make sure that we only touch 0x1A[2:1] from > + * within sii902x_i2c_bypass_select and sii902x_i2c_bypass_deselect, and that > + * we leave the remaining bits as we have found them. > + */ > +static int sii902x_i2c_bypass_deselect(struct i2c_mux_core *mux, u32 chan_id) > +{ > + struct sii902x *sii902x = i2c_mux_priv(mux); > + struct device *dev = &sii902x->i2c->dev; > + unsigned long timeout; > + unsigned int retries; > + u8 status; > + int ret; > + > + /* > + * When the HDMI transmitter is in pass through mode, we need an > + * (undocumented) additional delay between STOP and START conditions > + * to guarantee the bus won't get stuck. > + */ > + udelay(30); > + > + /* > + * Sometimes the I2C bus can stall after failure to use the > + * EDID channel. Retry a few times to see if things clear > + * up, else continue anyway. > + */ > + retries = 5; > + do { > + ret = sii902x_read_unlocked(sii902x->i2c, SII902X_SYS_CTRL_DATA, > + &status); > + retries--; > + } while (ret && retries); > + if (ret) { > + dev_err(dev, "failed to read status (%d)\n", ret); > + return ret; > + } > + > + ret = sii902x_update_bits_unlocked(sii902x->i2c, SII902X_SYS_CTRL_DATA, > + SII902X_SYS_CTRL_DDC_BUS_REQ | > + SII902X_SYS_CTRL_DDC_BUS_GRTD, 0); > + if (ret) > + return ret; > + > + timeout = jiffies + > + msecs_to_jiffies(SII902X_I2C_BUS_ACQUISITION_TIMEOUT_MS); > + do { > + ret = sii902x_read_unlocked(sii902x->i2c, SII902X_SYS_CTRL_DATA, > + &status); > + if (ret) > + return ret; > + } while (status & (SII902X_SYS_CTRL_DDC_BUS_REQ | > + SII902X_SYS_CTRL_DDC_BUS_GRTD) && > + time_before(jiffies, timeout)); > + > + if (status & (SII902X_SYS_CTRL_DDC_BUS_REQ | > + SII902X_SYS_CTRL_DDC_BUS_GRTD)) { > + dev_err(dev, "failed to release the i2c bus\n"); > + return -ETIMEDOUT; > + } > + > + return 0; > +} > + > static int sii902x_probe(struct i2c_client *client, > const struct i2c_device_id *id) > { > @@ -375,6 +468,13 @@ static int sii902x_probe(struct i2c_client *client, > u8 chipid[4]; > int ret; > > + ret = i2c_check_functionality(client->adapter, > + I2C_FUNC_SMBUS_BYTE_DATA); > + if (!ret) { > + dev_err(dev, "I2C adapter not suitable\n"); > + return -EIO; > + } > + > sii902x = devm_kzalloc(dev, sizeof(*sii902x), GFP_KERNEL); > if (!sii902x) > return -ENOMEM; > @@ -433,7 +533,15 @@ static int sii902x_probe(struct i2c_client *client, > > i2c_set_clientdata(client, sii902x); > > - return 0; > + sii902x->i2cmux = i2c_mux_alloc(client->adapter, dev, > + 1, 0, I2C_MUX_GATE, > + sii902x_i2c_bypass_select, > + sii902x_i2c_bypass_deselect); > + if (!sii902x->i2cmux) > + return -ENOMEM; > + > + sii902x->i2cmux->priv = sii902x; > + return i2c_mux_add_adapter(sii902x->i2cmux, 0, 0, 0); > } > > static int sii902x_remove(struct i2c_client *client) > @@ -441,6 +549,7 @@ static int sii902x_remove(struct i2c_client *client) > { > struct sii902x *sii902x = i2c_get_clientdata(client); > > + i2c_mux_del_adapters(sii902x->i2cmux); > drm_bridge_remove(&sii902x->bridge); > > return 0;