From mboxrd@z Thu Jan 1 00:00:00 1970 From: Archit Taneja Subject: Re: [RFC PATCH 1/2] drm: bridge: anx7688: Add anx7688 bridge driver support. Date: Tue, 21 Jun 2016 21:09:00 +0530 Message-ID: <57695F94.7030801@codeaurora.org> References: <1466406853-26465-1-git-send-email-drinkcat@chromium.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8"; Format="flowed" Content-Transfer-Encoding: base64 Return-path: Received: from smtp.codeaurora.org (smtp.codeaurora.org [198.145.29.96]) by gabe.freedesktop.org (Postfix) with ESMTPS id 452FC6E74E for ; Tue, 21 Jun 2016 15:39:07 +0000 (UTC) In-Reply-To: <1466406853-26465-1-git-send-email-drinkcat@chromium.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Nicolas Boichat , dri-devel@lists.freedesktop.org Cc: Enric Balletbo i Serra , marcheu@chromium.org, Thierry Reding , linux-kernel@vger.kernel.org, Russell King List-Id: dri-devel@lists.freedesktop.org SGksCgpPbiA2LzIwLzIwMTYgMTI6NDQgUE0sIE5pY29sYXMgQm9pY2hhdCB3cm90ZToKPiBBTlg3 Njg4IGlzIGEgSERNSSB0byBEUCBjb252ZXJ0ZXIgKGFzIHdlbGwgYXMgVVNCLUMgcG9ydCBjb250 cm9sbGVyKSwKPiB0aGF0IGhhcyBhbiBpbnRlcm5hbCBtaWNyb2NvbnRyb2xsZXIuCj4KPiBUaGUg b25seSByZWFzb24gYSBMaW51eCBrZXJuZWwgZHJpdmVyIGlzIG5lY2Vzc2FyeSBpcyB0byByZWpl Y3QKPiByZXNvbHV0aW9ucyB0aGF0IHJlcXVpcmUgbW9yZSBiYW5kd2lkdGggdGhhbiB3aGF0IGlz IGF2YWlsYWJsZSBvbgo+IHRoZSBEUCBzaWRlLiBEUCBiYW5kd2lkdGggYW5kIGxhbmUgY291bnQg YXJlIHJlcG9ydGVkIGJ5IHRoZSBicmlkZ2UKPiB2aWEgMiByZWdpc3RlcnMgb24gSTJDLgoKSG93 IGRvZXMgdGhlIGNoaXAga25vdyB3aGVuIHRvIGVuYWJsZS9kaXNhYmxlIGl0c2VsZj8gRG9lcyBp dCBzaHV0b2ZmCml0c2VsZiBpZiB0aGVyZSBpc24ndCBhbnl0aGluZyBvbiB0aGUgSERNSSBsaW5r PwoKPgo+IFNpZ25lZC1vZmYtYnk6IE5pY29sYXMgQm9pY2hhdCA8ZHJpbmtjYXRAY2hyb21pdW0u b3JnPgo+IC0tLQo+Cj4gSGksCj4KPiBJIHRlc3RlZCB0aGlzIGRyaXZlciB1c2luZyB0aGUgTWVk aWF0ZWsgSERNSSBjb250cm9sbGVyIChNVDgxNzMpIHVwc3RyZWFtCj4gb2YgdGhlIEFOWCBicmlk Z2UgY2hpcCAoUGhpbGxpcCBzZW50IGEgUFVMTCByZXF1ZXN0IG9uIEp1bmUgMTM6Cj4gZ2l0Oi8v Z2l0LnBlbmd1dHJvbml4LmRlL2dpdC9wemEvbGludXguZ2l0IHRhZ3MvbWVkaWF0ZWstZHJtLTIw MTYtMDYtMTMKPiApLgo+Cj4gSSBoYXZlIDIgY29uY2VybnMsIHRoYXQgSSdtIG5vdCBzdXJlIGhv dyB0byBhZGRyZXNzIHdpdGhpbiB0aGUga2VybmVsIERSTQo+IGZyYW1ld29yazoKPiAgIDEuIEFs bCBvdGhlciBicmlkZ2UgZHJpdmVycyBhbHNvIGhhdmUgYSBjb25uZWN0b3IgYXR0YWNoZWQgdG8g aXQuIEhvd2V2ZXIsIGluCj4gICAgICB0aGlzIGNhc2UsIHdlIGNhbm5vdCByZWFkIHRoZSBtb25p dG9yIEVESUQgZGlyZWN0bHksIHNvIEknbSBub3Qgc3VyZSB3aGF0Cj4gICAgICBJIGNvdWxkIHB1 dCBpbiBhICJnZXRfbW9kZXMiIGZ1bmN0aW9uLiBJbnN0ZWFkLCBBTlg3Njg4IHByb3ZpZGVzIGEg STJDCj4gICAgICBwYXNzdGhydS9yZXBlYXRlciwgc28gdGhlIEVESUQgaXMgcmVhZCBvbiB0aGUg TWVkaWF0ZWsgSERNSSBjb250cm9sbGVyIHNpZGUuCj4KPiAgICAgIFRoYXQgbGVhZHMgdG8gYSBz b21ld2hhdCBzdHJhbmdlIGxheW91dCwgd2hlcmUgd2UgaGF2ZToKPiAgICAgIC0gTVRLIEhETUkg YnJpZGdlL2VuY29kZXIKPiAgICAgICAgLSBNVEsgY29ubmVjdG9yIChIRE1JKQo+ICAgICAgICAt IEFOWDc2ODggYnJpZGdlCj4gICAgICAgICAgLSBObyBjb25uZWN0b3IKCgpZb3Ugc2hvdWxkIGlk ZWFsbHkgaGF2ZSBvbmUgRFAgY29ubmVjdG9yIGF0IHRoZSBlbmQgb2YgdGhlIGNoYWluOgoKCS0g TVRLIEhETUkgYnJpZGdlL2VuY29kZXIKICAgICAgICAgICAgIC0gQU5YNzY4OCBicmlkZ2UKICAg ICAgICAgICAgICAgIC0gQ29ubmVjdG9yIChEUCkKCkluIHRoZSBkdC1iaW5kaW5ncyBmb3IgdGhp cyBib2FyZCwgaGRtaSdzIG91dHB1dCBwb3J0IHNob3VsZG4ndCBiZQpjb25uZWN0ZWQgdG8gYSBo ZG1pIGNvbm5lY3RvciwgYnV0IHRoZSBpbnB1dCBwb3J0IG9mIHRoZSBBTlg3Njg4CkRQIGJyaWRn ZS4gVGhlIG91dHB1dCBwb3J0IG9mIHRoZSBicmlkZ2Ugc2hvdWxkIGJlIHRoZSBvbmUgdGhhdApj b25uZWN0cyB0byB0aGUgRFAgY29ubmVjdG9yLgoKT25lIHdheSBJIGNhbiB0aGluayBvZiBmaXhp bmcgdGhpcyBpcyB0byBtYWtlIG1ha2UgdGhlIE1USyBoZG1pCmVuY29kZXIgZHJpdmVyIGEgYml0 IHNtYXJ0ZXIgYnkgb2JzZXJ2aW5nIHRoZSBEVCBjb25uZWN0aW9ucy4gSWYKaXQncyBvdXRwdXQg cG9ydCBpcyBjb25uZWN0ZWQgdG8ganVzdCBhIGhkbWktY29ubmVjdG9yLCB0aGVuCnRoaW5ncyBz aG91bGQgYmUgYXMgYmVmb3JlLiBJZiB0aGUgb3V0cHV0IGlzIGNvbm5lY3RlZCB0byB0aGUgRFAK YnJpZGdlLCB0aGVuIGl0IHNob3VsZCBjcmVhdGUgYSBEUCBjb25uZWN0b3IuIFRoZSBjb25uZWN0 b3Igb3BzCmZvciB0aGUgRFAgY29ubmVjdG9yIGNhbiBzdGlsbCBiZSB0aGUgc2FtZSBhcyB0aGF0 IG9mIHRoZSBIRE1JCmNvbm5lY3RvciBiZWZvcmUsIGJ1dCB0aGUgcGhhbmRsZSB0byB0aGUgRERD IGJ1cyB3b3VsZCBiZSBpbiB0aGUKRFAgZGV2aWNlIG5vZGUgaW4gdGhpcyBjYXNlLgoKVGhpcyB3 YXksIHlvdSBjYW4gZ2V0IGFyb3VuZCBoYXZpbmcgdGhlIGNvcnJlY3QgbGF5b3V0LgoKSWRlYWxs eSwgYSBicmlkZ2UgZHJpdmVyIHNob3VsZG4ndCBiZSB0aGUgb25lIHRoYXQgY3JlYXRlcyBhCmNv bm5lY3Rvci4gSXQgbWF5IGNvbnRhaW4gc29tZSBvZiB0aGUgY29ubmVjdG9yIGZ1bmN0aW9uYWxp dHksIGJ1dAp0aGUgY29ubmVjdG9yIGNyZWF0aW9uIHNob3VsZCBiZSBtYW5hZ2VkIGJ5IHRoZSBr bXMgZHJpdmVyLgpBbG1vc3QgYWxsIGJyaWRnZSBkcml2ZXJzIGNyZWF0aW5nIGEgY29ubmVjdG9y IGluIHRoZWlyIC5hdHRhY2gKY2FsbGJhY2tzIHNpbmNlIHRoZXkgb3duIHNvbWUgb2YgdGhlIGNv bm5lY3RvciBmdW5jdGlvbmFsaXR5IChsaWtlCnJlYWRpbmcgRURJRCkuIFRoYXQncyBzb21ldGhp bmcgd2UncmUgdHJ5aW5nIHRvIGZpeCBieSBwcm92aWRpbmcKc29tZSBtb3JlIGJyaWRnZSBhcGkg dGhhdCBrbXMgZHJpdmVycyBjYW4gdXNlLgoKU2luY2UgdGhpcyBicmlkZ2UgZHJpdmVyIGRvZXNu J3QgaGF2ZSBhbnkgY29ubmVjdG9yIGZ1bmN0aW9uYWxpdHkKYW55d2F5LCB5b3Ugc2hvdWxkIGJl IG9rYXkuCgo+Cj4gICAgICBSZXNvbHV0aW9uIGZpbHRlcmluZyB3b3JrcyBmaW5lIHRob3VnaCwg dGhhbmtzIHRvIG1vZGVfZml4dXAgY2FsbGJhY2sgb24gdGhlCj4gICAgICBicmlkZ2UuIEl0IGFs c28gaGVscHMgdGhhdCBNZWRpYXRlayBIRE1JIGJyaWRnZSBjYWxscyBtb2RlX2ZpeHVwIGZyb20g aXRzCj4gICAgICBjb25uZWN0b3IgbW9kZV92YWxpZCBjYWxsYmFjaywgc28gdGhhdCBpbnZhbGlk IG1vZGVzIGFyZSBub3QgZXZlbiBwcmVzZW50ZWQKPiAgICAgIHRvIHVzZXJzcGFjZS4KPgo+ICAg Mi4gSW4gdGhlIGJhbmR3aWR0aCBjb21wdXRhdGlvbiwgSSBoYXJkLWNvZGUgOC1iaXQgcGVyIGNo YW5uZWwgKGJwYykuIGJwYyBkb2VzCj4gICAgICBub3Qgc2VlbSB0byBiZSBpbmNsdWRlZCBpbiB0 aGUgbW9kZSBzZXR0aW5nIGl0c2VsZi4gV2UgY291bGQgcG9zc2libHkgaXRlcmF0ZQo+ICAgICAg b3ZlciBjb25uZWN0b3JzIG9uIHRoZSBEUk0gZGV2aWNlLCBidXQgdGhlbiwgSUlVQywgY29ubmVj dG9yLT5kaXNwbGF5X2luZm8uYnBjCj4gICAgICBpbmRpY2F0ZXMgdGhlIF9tYXhpbXVtXyBicGMg c3VwcG9ydGVkIGJ5IHRoZSBtb25pdG9yLgoKSSdtIG5vdCBjbGVhciBhYm91dCB0aGlzIGVpdGhl ci4gU29tZSBkcml2ZXJzIHNldCBhIGJ1cyBmb3JtYXQKb24gdGhlIGNvbm5lY3RvciB2aWEgZHJt X2Rpc3BsYXlfaW5mb19zZXRfYnVzX2Zvcm1hdHMgaW4gdGhlaXIKZ2V0X21vZGVzIGNvbm5lY3Rv ciBvcCwgYW5kIHRoZW4gcmV0cmlldmUgaXQgbGF0ZXIuCgo+Cj4gQW55IHBvaW50ZXJzPyBUaGFu a3MhCj4KPiBCZXN0LAo+Cj4gTmljb2xhcwo+Cj4gICBkcml2ZXJzL2dwdS9kcm0vYnJpZGdlL0tj b25maWcgICAgICAgICAgICB8ICAgOSArKwo+ICAgZHJpdmVycy9ncHUvZHJtL2JyaWRnZS9NYWtl ZmlsZSAgICAgICAgICAgfCAgIDEgKwo+ICAgZHJpdmVycy9ncHUvZHJtL2JyaWRnZS9hbmFsb2dp eC1hbng3Njg4LmMgfCAyMjcgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCj4gICAzIGZp bGVzIGNoYW5nZWQsIDIzNyBpbnNlcnRpb25zKCspCj4gICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJp dmVycy9ncHUvZHJtL2JyaWRnZS9hbmFsb2dpeC1hbng3Njg4LmMKPgo+IGRpZmYgLS1naXQgYS9k cml2ZXJzL2dwdS9kcm0vYnJpZGdlL0tjb25maWcgYi9kcml2ZXJzL2dwdS9kcm0vYnJpZGdlL0tj b25maWcKPiBpbmRleCA4Zjc0MjNmLi4wYzFlYjQxIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1 L2RybS9icmlkZ2UvS2NvbmZpZwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9icmlkZ2UvS2NvbmZp Zwo+IEBAIC03LDYgKzcsMTUgQEAgY29uZmlnIERSTV9CUklER0UKPiAgIG1lbnUgIkRpc3BsYXkg SW50ZXJmYWNlIEJyaWRnZXMiCj4gICAJZGVwZW5kcyBvbiBEUk0gJiYgRFJNX0JSSURHRQo+Cj4g K2NvbmZpZyBEUk1fQU5BTE9HSVhfQU5YNzY4OAo+ICsJdHJpc3RhdGUgIkFuYWxvZ2l4IEFOWDc2 ODggYnJpZGdlIgo+ICsJZGVwZW5kcyBvbiBEUk0KPiArCXNlbGVjdCBEUk1fS01TX0hFTFBFUgo+ ICsJLS0taGVscC0tLQo+ICsJICBBTlg3Njg4IGlzIGEgdHJhbnNtaXR0ZXIgdG8gc3VwcG9ydCBE aXNwbGF5UG9ydCBvdmVyIFVTQi1DIGZvcgo+ICsJICBzbWFydHBob25lIGFuZCB0YWJsZXRzLgo+ ICsJICBUaGlzIGRyaXZlciBvbmx5IHN1cHBvcnRzIHRoZSBIRE1JIHRvIERQIGNvbXBvbmVudCBv ZiB0aGUgY2hpcC4KPiArCj4gICBjb25maWcgRFJNX0FOQUxPR0lYX0FOWDc4WFgKPiAgIAl0cmlz dGF0ZSAiQW5hbG9naXggQU5YNzhYWCBicmlkZ2UiCj4gICAJc2VsZWN0IERSTV9LTVNfSEVMUEVS Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9icmlkZ2UvTWFrZWZpbGUgYi9kcml2ZXJz L2dwdS9kcm0vYnJpZGdlL01ha2VmaWxlCj4gaW5kZXggOTZiMTNiMy4uZDc0NGM2YyAxMDA2NDQK PiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vYnJpZGdlL01ha2VmaWxlCj4gKysrIGIvZHJpdmVycy9n cHUvZHJtL2JyaWRnZS9NYWtlZmlsZQo+IEBAIC0xLDUgKzEsNiBAQAo+ICAgY2NmbGFncy15IDo9 IC1JaW5jbHVkZS9kcm0KPgo+ICtvYmotJChDT05GSUdfRFJNX0FOQUxPR0lYX0FOWDc2ODgpICs9 IGFuYWxvZ2l4LWFueDc2ODgubwo+ICAgb2JqLSQoQ09ORklHX0RSTV9BTkFMT0dJWF9BTlg3OFhY KSArPSBhbmFsb2dpeC1hbng3OHh4Lm8KPiAgIG9iai0kKENPTkZJR19EUk1fRFdfSERNSSkgKz0g ZHctaGRtaS5vCj4gICBvYmotJChDT05GSUdfRFJNX0RXX0hETUlfQUhCX0FVRElPKSArPSBkdy1o ZG1pLWFoYi1hdWRpby5vCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9icmlkZ2UvYW5h bG9naXgtYW54NzY4OC5jIGIvZHJpdmVycy9ncHUvZHJtL2JyaWRnZS9hbmFsb2dpeC1hbng3Njg4 LmMKPiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+IGluZGV4IDAwMDAwMDAuLjJjMzQwMjkKPiAtLS0g L2Rldi9udWxsCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2JyaWRnZS9hbmFsb2dpeC1hbng3Njg4 LmMKPiBAQCAtMCwwICsxLDIyNyBAQAo+ICsvKgo+ICsgKiBBTlg3Njg4IEhETUktPkRQIGJyaWRn ZSBkcml2ZXIKPiArICoKPiArICogQ29weXJpZ2h0IChDKSAyMDE2IEdvb2dsZSwgSW5jLgo+ICsg Kgo+ICsgKiBUaGlzIHNvZnR3YXJlIGlzIGxpY2Vuc2VkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUg R05VIEdlbmVyYWwgUHVibGljCj4gKyAqIExpY2Vuc2UgdmVyc2lvbiAyLCBhcyBwdWJsaXNoZWQg YnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgYW5kCj4gKyAqIG1heSBiZSBjb3BpZWQs IGRpc3RyaWJ1dGVkLCBhbmQgbW9kaWZpZWQgdW5kZXIgdGhvc2UgdGVybXMuCj4gKyAqCj4gKyAq IFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUg dXNlZnVsLAo+ICsgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUg aW1wbGllZCB3YXJyYW50eSBvZgo+ICsgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1Ig QSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCj4gKyAqIEdOVSBHZW5lcmFsIFB1YmxpYyBM aWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCj4gKyAqLwo+ICsKPiArI2luY2x1ZGUgPGxpbnV4L2Rl bGF5Lmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9ncGlvLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9pMmMu aD4KPiArI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgo+ICsjaW5jbHVkZSA8bGludXgvb2YuaD4K PiArI2luY2x1ZGUgPGxpbnV4L29mX2dwaW8uaD4KPiArI2luY2x1ZGUgPGRybS9kcm1QLmg+CgpU aGUgMyBoZWFkZXJzIGFib3ZlIGFyZW4ndCBuZWVkZWQuCgo+ICsjaW5jbHVkZSA8ZHJtL2RybV9j cnRjLmg+Cj4gKwo+ICsvKiBSZWdpc3RlciBhZGRyZXNzZXMgKi8KPiArI2RlZmluZSBWRU5ET1Jf SURfUkVHIDB4MDAKPiArI2RlZmluZSBERVZJQ0VfSURfUkVHIDB4MDIKPiArCj4gKyNkZWZpbmUg RldfVkVSU0lPTl9SRUcgMHg4MAo+ICsKPiArI2RlZmluZSBEUF9CQU5EV0lEVEhfUkVHIDB4ODUK PiArI2RlZmluZSBEUF9MQU5FX0NPVU5UX1JFRyAweDg2Cj4gKwo+ICsjZGVmaW5lIFZFTkRPUl9J RCAweDFmMjkKPiArI2RlZmluZSBERVZJQ0VfSUQgMHg3Njg4Cj4gKwo+ICsvKiBGaXJzdCBzdXBw b3J0ZWQgZmlybXdhcmUgdmVyc2lvbiAoMC44NSkgKi8KPiArI2RlZmluZSBNSU5JTVVNX0ZXX1ZF UlNJT04gMHgwMDg1Cj4gKwo+ICtzdHJ1Y3QgYW54NzY4OCB7Cj4gKwlzdHJ1Y3QgZHJtX2JyaWRn ZSBicmlkZ2U7Cj4gKwlzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50Owo+ICsKPiArCWJvb2wgZmls dGVyOwo+ICt9Owo+ICsKPiArc3RhdGljIGludCBhbng3Njg4X3JlYWQoc3RydWN0IGkyY19jbGll bnQgKmNsaWVudCwgdTggcmVnLCB1OCAqZGF0YSwKPiArCQkJdTE2IGRhdGFfbGVuKQo+ICt7Cj4g KwlpbnQgcmV0Owo+ICsJc3RydWN0IGkyY19tc2cgbXNnc1tdID0gewo+ICsJCXsKPiArCQkgLmFk ZHIgPSBjbGllbnQtPmFkZHIsCj4gKwkJIC5mbGFncyA9IDAsCj4gKwkJIC5sZW4gPSAxLAo+ICsJ CSAuYnVmID0gJnJlZywKPiArCQkgfSwKPiArCQl7Cj4gKwkJIC5hZGRyID0gY2xpZW50LT5hZGRy LAo+ICsJCSAuZmxhZ3MgPSBJMkNfTV9SRCwKPiArCQkgLmxlbiA9IGRhdGFfbGVuLAo+ICsJCSAu YnVmID0gZGF0YSwKPiArCQkgfQo+ICsJfTsKPiArCj4gKwlyZXQgPSBpMmNfdHJhbnNmZXIoY2xp ZW50LT5hZGFwdGVyLCBtc2dzLCAyKTsKPiArCj4gKwlpZiAocmV0ID09IDIpCj4gKwkJcmV0dXJu IDA7Cj4gKwlpZiAocmV0IDwgMCkKPiArCQlyZXR1cm4gcmV0Owo+ICsJZWxzZQo+ICsJCXJldHVy biAtRUlPOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW5saW5lIHN0cnVjdCBhbng3Njg4ICpicmlkZ2Vf dG9fYW54NzY4OChzdHJ1Y3QgZHJtX2JyaWRnZSAqYnJpZGdlKQo+ICt7Cj4gKwlyZXR1cm4gY29u dGFpbmVyX29mKGJyaWRnZSwgc3RydWN0IGFueDc2ODgsIGJyaWRnZSk7Cj4gK30KPiArCj4gK3N0 YXRpYyBib29sIGFueDc2ODhfYnJpZGdlX21vZGVfZml4dXAoc3RydWN0IGRybV9icmlkZ2UgKmJy aWRnZSwKPiArCQkJCSAgICAgIGNvbnN0IHN0cnVjdCBkcm1fZGlzcGxheV9tb2RlICptb2RlLAo+ ICsJCQkJICAgICAgc3RydWN0IGRybV9kaXNwbGF5X21vZGUgKmFkanVzdGVkX21vZGUpCj4gK3sK PiArCXN0cnVjdCBhbng3Njg4ICphbng3Njg4ID0gYnJpZGdlX3RvX2FueDc2ODgoYnJpZGdlKTsK PiArCXU4IHJlZ3NbMl07Cj4gKwlpbnQgdG90YWxidywgcmVxdWlyZWRidzsKCkl0IG1pZ2h0IG1h a2Ugc2Vuc2UgdG8gdXNlIGEgdTMyIG9yIGxvbmcgb3Igc29tZXRoaW5nIGhlcmUgdG8gcHJldmVu dApyaXNrIG9mIG92ZXJmbG93LgoKPiArCWludCByZXQ7Cj4gKwo+ICsJaWYgKCFhbng3Njg4LT5m aWx0ZXIpCj4gKwkJcmV0dXJuIHRydWU7Cj4gKwo+ICsJLyogUmVhZCBib3RoIHJlZ3MgMHg4NSAo YmFuZHdpZHRoKSBhbmQgMHg4NiAobGFuZSBjb3VudCkuICovCj4gKwlyZXQgPSBhbng3Njg4X3Jl YWQoYW54NzY4OC0+Y2xpZW50LCBEUF9CQU5EV0lEVEhfUkVHLCByZWdzLCAyKTsKCldobyBwcm9n cmFtbWVkIHRoZXNlIHJlZ2lzdGVycyBpbiB0aGUgZmlyc3QgcGxhY2U/IElzIHRoZSBsYW5lIGNv dW50CnNvbWUgc29ydCBvZiByZXNldCB2YWx1ZT8gT3IgaXMgaXQgc29tZXRoaW5nIHRoYXQgY2hh bmdlcyBkeW5hbWljYWxseT8KCj4gKwlpZiAocmV0IDwgMCkgewo+ICsJCWRldl9lcnIoJmFueDc2 ODgtPmNsaWVudC0+ZGV2LAo+ICsJCQkiRmFpbGVkIHRvIHJlYWQgYmFuZHdpZHRoL2xhbmUgY291 bnRcbiIpOwo+ICsJCXJldHVybiBmYWxzZTsKPiArCX0KPiArCj4gKwkvKiBDb21wdXRlIGF2YWls YWJsZSByYXRlIChrSHopICovCj4gKwl0b3RhbGJ3ID0gcmVnc1swXSAqIHJlZ3NbMV0gKiAyNzAw MDAgKiA4IC8gMTA7Cj4gKwo+ICsJLyogUmVxdWlyZWQgYmFuZHdpZHRoICg4IGJwYykgKi8KPiAr CXJlcXVpcmVkYncgPSBtb2RlLT5jbG9jayAqIDggKiAzOwo+ICsKPiArCWRldl9kYmcoJmFueDc2 ODgtPmNsaWVudC0+ZGV2LAo+ICsJCSJEUCBiYW5kd2lkdGg6ICVkIGtIeiAoJTAyeC8lZCk7IG1v ZGUgcmVxdWlyZXMgJWQgS2h6XG4iLAo+ICsJCXRvdGFsYncsIHJlZ3NbMF0sIHJlZ3NbMV0sIHJl cXVpcmVkYncpOwo+ICsKPiArCWlmICh0b3RhbGJ3ID09IDApIHsKPiArCQlkZXZfd2FybigmYW54 NzY4OC0+Y2xpZW50LT5kZXYsCj4gKwkJCSAiQmFuZHdpZHRoL2xhbmUgY291bnQgYXJlIDAsIG5v dCByZWplY3RpbmcgbW9kZXNcbiIpOwo+ICsJCXJldHVybiB0cnVlOwo+ICsJfQo+ICsKPiArCXJl dHVybiB0b3RhbGJ3ID49IHJlcXVpcmVkYnc7Cj4gK30KPiArCj4gK3N0YXRpYyBjb25zdCBzdHJ1 Y3QgZHJtX2JyaWRnZV9mdW5jcyBhbng3Njg4X2JyaWRnZV9mdW5jcyA9IHsKPiArCS5tb2RlX2Zp eHVwCT0gYW54NzY4OF9icmlkZ2VfbW9kZV9maXh1cCwKPiArfTsKPiArCj4gK3N0YXRpYyBpbnQg YW54NzY4OF9pMmNfcHJvYmUoc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCwKPiArCQkJICAgICBj b25zdCBzdHJ1Y3QgaTJjX2RldmljZV9pZCAqaWQpCj4gK3sKPiArCXN0cnVjdCBhbng3Njg4ICph bng3Njg4Owo+ICsJaW50IHJldDsKPiArCXU4IGJ1ZmZlcls0XTsKPiArCXUxNiB2ZW5kb3IsIGRl dmljZSwgZnd2ZXJzaW9uOwo+ICsKPiArCWFueDc2ODggPSBkZXZtX2t6YWxsb2MoJmNsaWVudC0+ ZGV2LCBzaXplb2YoKmFueDc2ODgpLCBHRlBfS0VSTkVMKTsKPiArCWlmICghYW54NzY4OCkKPiAr CQlyZXR1cm4gLUVOT01FTTsKPiArCj4gKyNpZiBJU19FTkFCTEVEKENPTkZJR19PRikKPiArCWFu eDc2ODgtPmJyaWRnZS5vZl9ub2RlID0gY2xpZW50LT5kZXYub2Zfbm9kZTsKPiArI2VuZGlmCj4g Kwo+ICsJYW54NzY4OC0+Y2xpZW50ID0gY2xpZW50Owo+ICsJaTJjX3NldF9jbGllbnRkYXRhKGNs aWVudCwgYW54NzY4OCk7Cj4gKwo+ICsJLyogUmVhZCBib3RoIHZlbmRvciBhbmQgZGV2aWNlIGlk ICg0IGJ5dGVzKS4gKi8KPiArCXJldCA9IGFueDc2ODhfcmVhZChjbGllbnQsIFZFTkRPUl9JRF9S RUcsIGJ1ZmZlciwgNCk7Cj4gKwlpZiAocmV0KSB7Cj4gKwkJZGV2X2VycigmY2xpZW50LT5kZXYs ICJGYWlsZWQgdG8gcmVhZCBjaGlwIHZlbmRvci9kZXZpY2UgaWRcbiIpOwo+ICsJCXJldHVybiBy ZXQ7Cj4gKwl9Cj4gKwo+ICsJdmVuZG9yID0gKHUxNilidWZmZXJbMV0gPDwgOCB8IGJ1ZmZlclsw XTsKPiArCWRldmljZSA9ICh1MTYpYnVmZmVyWzNdIDw8IDggfCBidWZmZXJbMl07Cj4gKwlpZiAo dmVuZG9yICE9IFZFTkRPUl9JRCB8fCBkZXZpY2UgIT0gREVWSUNFX0lEKSB7Cj4gKwkJZGV2X2Vy cigmY2xpZW50LT5kZXYsCj4gKwkJCSJJbnZhbGlkIHZlbmRvci9kZXZpY2UgaWQgJTA0eC8lMDR4 XG4iLAo+ICsJCQl2ZW5kb3IsIGRldmljZSk7Cj4gKwkJcmV0dXJuIC1FTk9ERVY7Cj4gKwl9Cj4g Kwo+ICsJcmV0ID0gYW54NzY4OF9yZWFkKGNsaWVudCwgRldfVkVSU0lPTl9SRUcsIGJ1ZmZlciwg Mik7Cj4gKwlpZiAocmV0KSB7Cj4gKwkJZGV2X2VycigmY2xpZW50LT5kZXYsICJGYWlsZWQgdG8g cmVhZCBmaXJtd2FyZSB2ZXJzaW9uXG4iKTsKPiArCQlyZXR1cm4gcmV0Owo+ICsJfQo+ICsKPiAr CWZ3dmVyc2lvbiA9ICh1MTYpYnVmZmVyWzBdIDw8IDggfCBidWZmZXJbMV07Cj4gKwlkZXZfaW5m bygmY2xpZW50LT5kZXYsICJBTlg3Njg4IGZpcndtYXJlIHZlcnNpb24gJTAyeC4lMDJ4XG4iLAo+ ICsJCSBidWZmZXJbMF0sIGJ1ZmZlclsxXSk7Cj4gKwo+ICsJLyogRlcgdmVyc2lvbiA+PSAwLjg1 IHN1cHBvcnRzIGJhbmR3aWR0aC9sYW5lIGNvdW50IHJlZ2lzdGVycyAqLwo+ICsJaWYgKGZ3dmVy c2lvbiA+PSBNSU5JTVVNX0ZXX1ZFUlNJT04pIHsKPiArCQlhbng3Njg4LT5maWx0ZXIgPSB0cnVl Owo+ICsJfSBlbHNlIHsKPiArCQkvKiBXYXJuLCBidXQgbm90IGZhaWwsIGZvciBiYWNrd2FyZHMg Y29tcGF0aWJsaXR5LiAqLwoKcy9jb21wYXRpYmxpdHkvY29tcGF0aWJpbGl0eQoKPiArCQlkZXZf d2FybigmY2xpZW50LT5kZXYsCj4gKwkJCSAiT2xkIEFOWDc2ODggRlcgdmVyc2lvbiAoJTA0eCks IG5vdCBmaWx0ZXJpbmdcbiIsCj4gKwkJCSBmd3ZlcnNpb24pOwo+ICsJfQo+ICsKPiArCWFueDc2 ODgtPmJyaWRnZS5mdW5jcyA9ICZhbng3Njg4X2JyaWRnZV9mdW5jczsKPiArCXJldCA9IGRybV9i cmlkZ2VfYWRkKCZhbng3Njg4LT5icmlkZ2UpOwo+ICsJaWYgKHJldCA8IDApIHsKPiArCQlkZXZf ZXJyKCZjbGllbnQtPmRldiwgIkZhaWxlZCB0byBhZGQgZHJtIGJyaWRnZVxuIik7Cj4gKwkJcmV0 dXJuIHJldDsKPiArCX0KPiArCj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiArc3RhdGljIGludCBh bng3Njg4X2kyY19yZW1vdmUoc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCkKPiArewo+ICsJc3Ry dWN0IGFueDc2ODggKmFueDc2ODggPSBpMmNfZ2V0X2NsaWVudGRhdGEoY2xpZW50KTsKPiArCj4g Kwlkcm1fYnJpZGdlX3JlbW92ZSgmYW54NzY4OC0+YnJpZGdlKTsKPiArCj4gKwlyZXR1cm4gMDsK PiArfQo+ICsKPiArc3RhdGljIGNvbnN0IHN0cnVjdCBpMmNfZGV2aWNlX2lkIGFueDc2ODhfaWRb XSA9IHsKPiArCXsgImFueDc2ODgiLCAwIH0sCj4gKwl7IC8qIHNlbnRpbmVsICovIH0KPiArfTsK PiArCj4gK01PRFVMRV9ERVZJQ0VfVEFCTEUoaTJjLCBhbng3Njg4X2lkKTsKPiArCj4gKyNpZiBJ U19FTkFCTEVEKENPTkZJR19PRikKPiArc3RhdGljIGNvbnN0IHN0cnVjdCBvZl9kZXZpY2VfaWQg YW54NzY4OF9tYXRjaF90YWJsZVtdID0gewo+ICsJeyAuY29tcGF0aWJsZSA9ICJhbmFsb2dpeCxh bng3Njg4IiwgfSwKPiArCXsgLyogc2VudGluZWwgKi8gfSwKPiArfTsKPiArTU9EVUxFX0RFVklD RV9UQUJMRShvZiwgYW54NzY4OF9tYXRjaF90YWJsZSk7Cj4gKyNlbmRpZgo+ICsKPiArc3RhdGlj IHN0cnVjdCBpMmNfZHJpdmVyIGFueDc2ODhfZHJpdmVyID0gewo+ICsJLmRyaXZlciA9IHsKPiAr CQkgICAubmFtZSA9ICJhbng3Njg4IiwKPiArCQkgICAub2ZfbWF0Y2hfdGFibGUgPSBvZl9tYXRj aF9wdHIoYW54NzY4OF9tYXRjaF90YWJsZSksCj4gKwkJICB9LAo+ICsJLnByb2JlID0gYW54NzY4 OF9pMmNfcHJvYmUsCj4gKwkucmVtb3ZlID0gYW54NzY4OF9pMmNfcmVtb3ZlLAo+ICsJLmlkX3Rh YmxlID0gYW54NzY4OF9pZCwKPiArfTsKPiArCj4gK21vZHVsZV9pMmNfZHJpdmVyKGFueDc2ODhf ZHJpdmVyKTsKPiArCj4gK01PRFVMRV9ERVNDUklQVElPTigiQU5YNzY4OCBTbGltUG9ydCBUcmFu c21pdHRlciBkcml2ZXIiKTsKPiArTU9EVUxFX0FVVEhPUigiTmljb2xhcyBCb2ljaGF0IDxkcmlu a2NhdEBjaHJvbWl1bS5vcmc+Iik7Cj4gK01PRFVMRV9MSUNFTlNFKCJHUEwgdjIiKTsKPgoKLS0g ClF1YWxjb21tIElubm92YXRpb24gQ2VudGVyLCBJbmMuIGlzIGEgbWVtYmVyIG9mIENvZGUgQXVy b3JhIEZvcnVtLAphIExpbnV4IEZvdW5kYXRpb24gQ29sbGFib3JhdGl2ZSBQcm9qZWN0Cl9fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmRyaS1kZXZlbCBtYWls aW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZy ZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZlbAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752211AbcFUPjx (ORCPT ); Tue, 21 Jun 2016 11:39:53 -0400 Received: from smtp.codeaurora.org ([198.145.29.96]:44095 "EHLO smtp.codeaurora.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1750731AbcFUPjc (ORCPT ); Tue, 21 Jun 2016 11:39:32 -0400 Subject: Re: [RFC PATCH 1/2] drm: bridge: anx7688: Add anx7688 bridge driver support. To: Nicolas Boichat , dri-devel@lists.freedesktop.org References: <1466406853-26465-1-git-send-email-drinkcat@chromium.org> Cc: marcheu@chromium.org, linux-kernel@vger.kernel.org, Enric Balletbo i Serra , Russell King , Thierry Reding From: Archit Taneja Message-ID: <57695F94.7030801@codeaurora.org> Date: Tue, 21 Jun 2016 21:09:00 +0530 User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64; rv:38.0) Gecko/20100101 Thunderbird/38.7.0 MIME-Version: 1.0 In-Reply-To: <1466406853-26465-1-git-send-email-drinkcat@chromium.org> Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 7bit Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Hi, On 6/20/2016 12:44 PM, Nicolas Boichat wrote: > ANX7688 is a HDMI to DP converter (as well as USB-C port controller), > that has an internal microcontroller. > > The only reason a Linux kernel driver is necessary is to reject > resolutions that require more bandwidth than what is available on > the DP side. DP bandwidth and lane count are reported by the bridge > via 2 registers on I2C. How does the chip know when to enable/disable itself? Does it shutoff itself if there isn't anything on the HDMI link? > > Signed-off-by: Nicolas Boichat > --- > > Hi, > > I tested this driver using the Mediatek HDMI controller (MT8173) upstream > of the ANX bridge chip (Phillip sent a PULL request on June 13: > git://git.pengutronix.de/git/pza/linux.git tags/mediatek-drm-2016-06-13 > ). > > I have 2 concerns, that I'm not sure how to address within the kernel DRM > framework: > 1. All other bridge drivers also have a connector attached to it. However, in > this case, we cannot read the monitor EDID directly, so I'm not sure what > I could put in a "get_modes" function. Instead, ANX7688 provides a I2C > passthru/repeater, so the EDID is read on the Mediatek HDMI controller side. > > That leads to a somewhat strange layout, where we have: > - MTK HDMI bridge/encoder > - MTK connector (HDMI) > - ANX7688 bridge > - No connector You should ideally have one DP connector at the end of the chain: - MTK HDMI bridge/encoder - ANX7688 bridge - Connector (DP) In the dt-bindings for this board, hdmi's output port shouldn't be connected to a hdmi connector, but the input port of the ANX7688 DP bridge. The output port of the bridge should be the one that connects to the DP connector. One way I can think of fixing this is to make make the MTK hdmi encoder driver a bit smarter by observing the DT connections. If it's output port is connected to just a hdmi-connector, then things should be as before. If the output is connected to the DP bridge, then it should create a DP connector. The connector ops for the DP connector can still be the same as that of the HDMI connector before, but the phandle to the DDC bus would be in the DP device node in this case. This way, you can get around having the correct layout. Ideally, a bridge driver shouldn't be the one that creates a connector. It may contain some of the connector functionality, but the connector creation should be managed by the kms driver. Almost all bridge drivers creating a connector in their .attach callbacks since they own some of the connector functionality (like reading EDID). That's something we're trying to fix by providing some more bridge api that kms drivers can use. Since this bridge driver doesn't have any connector functionality anyway, you should be okay. > > Resolution filtering works fine though, thanks to mode_fixup callback on the > bridge. It also helps that Mediatek HDMI bridge calls mode_fixup from its > connector mode_valid callback, so that invalid modes are not even presented > to userspace. > > 2. In the bandwidth computation, I hard-code 8-bit per channel (bpc). bpc does > not seem to be included in the mode setting itself. We could possibly iterate > over connectors on the DRM device, but then, IIUC, connector->display_info.bpc > indicates the _maximum_ bpc supported by the monitor. I'm not clear about this either. Some drivers set a bus format on the connector via drm_display_info_set_bus_formats in their get_modes connector op, and then retrieve it later. > > Any pointers? Thanks! > > Best, > > Nicolas > > drivers/gpu/drm/bridge/Kconfig | 9 ++ > drivers/gpu/drm/bridge/Makefile | 1 + > drivers/gpu/drm/bridge/analogix-anx7688.c | 227 ++++++++++++++++++++++++++++++ > 3 files changed, 237 insertions(+) > create mode 100644 drivers/gpu/drm/bridge/analogix-anx7688.c > > diff --git a/drivers/gpu/drm/bridge/Kconfig b/drivers/gpu/drm/bridge/Kconfig > index 8f7423f..0c1eb41 100644 > --- a/drivers/gpu/drm/bridge/Kconfig > +++ b/drivers/gpu/drm/bridge/Kconfig > @@ -7,6 +7,15 @@ config DRM_BRIDGE > menu "Display Interface Bridges" > depends on DRM && DRM_BRIDGE > > +config DRM_ANALOGIX_ANX7688 > + tristate "Analogix ANX7688 bridge" > + depends on DRM > + select DRM_KMS_HELPER > + ---help--- > + ANX7688 is a transmitter to support DisplayPort over USB-C for > + smartphone and tablets. > + This driver only supports the HDMI to DP component of the chip. > + > config DRM_ANALOGIX_ANX78XX > tristate "Analogix ANX78XX bridge" > select DRM_KMS_HELPER > diff --git a/drivers/gpu/drm/bridge/Makefile b/drivers/gpu/drm/bridge/Makefile > index 96b13b3..d744c6c 100644 > --- a/drivers/gpu/drm/bridge/Makefile > +++ b/drivers/gpu/drm/bridge/Makefile > @@ -1,5 +1,6 @@ > ccflags-y := -Iinclude/drm > > +obj-$(CONFIG_DRM_ANALOGIX_ANX7688) += analogix-anx7688.o > obj-$(CONFIG_DRM_ANALOGIX_ANX78XX) += analogix-anx78xx.o > obj-$(CONFIG_DRM_DW_HDMI) += dw-hdmi.o > obj-$(CONFIG_DRM_DW_HDMI_AHB_AUDIO) += dw-hdmi-ahb-audio.o > diff --git a/drivers/gpu/drm/bridge/analogix-anx7688.c b/drivers/gpu/drm/bridge/analogix-anx7688.c > new file mode 100644 > index 0000000..2c34029 > --- /dev/null > +++ b/drivers/gpu/drm/bridge/analogix-anx7688.c > @@ -0,0 +1,227 @@ > +/* > + * ANX7688 HDMI->DP bridge driver > + * > + * Copyright (C) 2016 Google, Inc. > + * > + * This software is licensed under the terms of the GNU General Public > + * License version 2, as published by the Free Software Foundation, and > + * may be copied, distributed, and modified under those terms. > + * > + * This program is distributed in the hope that it will be useful, > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > + * GNU General Public License for more details. > + */ > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include The 3 headers above aren't needed. > +#include > + > +/* Register addresses */ > +#define VENDOR_ID_REG 0x00 > +#define DEVICE_ID_REG 0x02 > + > +#define FW_VERSION_REG 0x80 > + > +#define DP_BANDWIDTH_REG 0x85 > +#define DP_LANE_COUNT_REG 0x86 > + > +#define VENDOR_ID 0x1f29 > +#define DEVICE_ID 0x7688 > + > +/* First supported firmware version (0.85) */ > +#define MINIMUM_FW_VERSION 0x0085 > + > +struct anx7688 { > + struct drm_bridge bridge; > + struct i2c_client *client; > + > + bool filter; > +}; > + > +static int anx7688_read(struct i2c_client *client, u8 reg, u8 *data, > + u16 data_len) > +{ > + int ret; > + struct i2c_msg msgs[] = { > + { > + .addr = client->addr, > + .flags = 0, > + .len = 1, > + .buf = ®, > + }, > + { > + .addr = client->addr, > + .flags = I2C_M_RD, > + .len = data_len, > + .buf = data, > + } > + }; > + > + ret = i2c_transfer(client->adapter, msgs, 2); > + > + if (ret == 2) > + return 0; > + if (ret < 0) > + return ret; > + else > + return -EIO; > +} > + > +static inline struct anx7688 *bridge_to_anx7688(struct drm_bridge *bridge) > +{ > + return container_of(bridge, struct anx7688, bridge); > +} > + > +static bool anx7688_bridge_mode_fixup(struct drm_bridge *bridge, > + const struct drm_display_mode *mode, > + struct drm_display_mode *adjusted_mode) > +{ > + struct anx7688 *anx7688 = bridge_to_anx7688(bridge); > + u8 regs[2]; > + int totalbw, requiredbw; It might make sense to use a u32 or long or something here to prevent risk of overflow. > + int ret; > + > + if (!anx7688->filter) > + return true; > + > + /* Read both regs 0x85 (bandwidth) and 0x86 (lane count). */ > + ret = anx7688_read(anx7688->client, DP_BANDWIDTH_REG, regs, 2); Who programmed these registers in the first place? Is the lane count some sort of reset value? Or is it something that changes dynamically? > + if (ret < 0) { > + dev_err(&anx7688->client->dev, > + "Failed to read bandwidth/lane count\n"); > + return false; > + } > + > + /* Compute available rate (kHz) */ > + totalbw = regs[0] * regs[1] * 270000 * 8 / 10; > + > + /* Required bandwidth (8 bpc) */ > + requiredbw = mode->clock * 8 * 3; > + > + dev_dbg(&anx7688->client->dev, > + "DP bandwidth: %d kHz (%02x/%d); mode requires %d Khz\n", > + totalbw, regs[0], regs[1], requiredbw); > + > + if (totalbw == 0) { > + dev_warn(&anx7688->client->dev, > + "Bandwidth/lane count are 0, not rejecting modes\n"); > + return true; > + } > + > + return totalbw >= requiredbw; > +} > + > +static const struct drm_bridge_funcs anx7688_bridge_funcs = { > + .mode_fixup = anx7688_bridge_mode_fixup, > +}; > + > +static int anx7688_i2c_probe(struct i2c_client *client, > + const struct i2c_device_id *id) > +{ > + struct anx7688 *anx7688; > + int ret; > + u8 buffer[4]; > + u16 vendor, device, fwversion; > + > + anx7688 = devm_kzalloc(&client->dev, sizeof(*anx7688), GFP_KERNEL); > + if (!anx7688) > + return -ENOMEM; > + > +#if IS_ENABLED(CONFIG_OF) > + anx7688->bridge.of_node = client->dev.of_node; > +#endif > + > + anx7688->client = client; > + i2c_set_clientdata(client, anx7688); > + > + /* Read both vendor and device id (4 bytes). */ > + ret = anx7688_read(client, VENDOR_ID_REG, buffer, 4); > + if (ret) { > + dev_err(&client->dev, "Failed to read chip vendor/device id\n"); > + return ret; > + } > + > + vendor = (u16)buffer[1] << 8 | buffer[0]; > + device = (u16)buffer[3] << 8 | buffer[2]; > + if (vendor != VENDOR_ID || device != DEVICE_ID) { > + dev_err(&client->dev, > + "Invalid vendor/device id %04x/%04x\n", > + vendor, device); > + return -ENODEV; > + } > + > + ret = anx7688_read(client, FW_VERSION_REG, buffer, 2); > + if (ret) { > + dev_err(&client->dev, "Failed to read firmware version\n"); > + return ret; > + } > + > + fwversion = (u16)buffer[0] << 8 | buffer[1]; > + dev_info(&client->dev, "ANX7688 firwmare version %02x.%02x\n", > + buffer[0], buffer[1]); > + > + /* FW version >= 0.85 supports bandwidth/lane count registers */ > + if (fwversion >= MINIMUM_FW_VERSION) { > + anx7688->filter = true; > + } else { > + /* Warn, but not fail, for backwards compatiblity. */ s/compatiblity/compatibility > + dev_warn(&client->dev, > + "Old ANX7688 FW version (%04x), not filtering\n", > + fwversion); > + } > + > + anx7688->bridge.funcs = &anx7688_bridge_funcs; > + ret = drm_bridge_add(&anx7688->bridge); > + if (ret < 0) { > + dev_err(&client->dev, "Failed to add drm bridge\n"); > + return ret; > + } > + > + return 0; > +} > + > +static int anx7688_i2c_remove(struct i2c_client *client) > +{ > + struct anx7688 *anx7688 = i2c_get_clientdata(client); > + > + drm_bridge_remove(&anx7688->bridge); > + > + return 0; > +} > + > +static const struct i2c_device_id anx7688_id[] = { > + { "anx7688", 0 }, > + { /* sentinel */ } > +}; > + > +MODULE_DEVICE_TABLE(i2c, anx7688_id); > + > +#if IS_ENABLED(CONFIG_OF) > +static const struct of_device_id anx7688_match_table[] = { > + { .compatible = "analogix,anx7688", }, > + { /* sentinel */ }, > +}; > +MODULE_DEVICE_TABLE(of, anx7688_match_table); > +#endif > + > +static struct i2c_driver anx7688_driver = { > + .driver = { > + .name = "anx7688", > + .of_match_table = of_match_ptr(anx7688_match_table), > + }, > + .probe = anx7688_i2c_probe, > + .remove = anx7688_i2c_remove, > + .id_table = anx7688_id, > +}; > + > +module_i2c_driver(anx7688_driver); > + > +MODULE_DESCRIPTION("ANX7688 SlimPort Transmitter driver"); > +MODULE_AUTHOR("Nicolas Boichat "); > +MODULE_LICENSE("GPL v2"); > -- Qualcomm Innovation Center, Inc. is a member of Code Aurora Forum, a Linux Foundation Collaborative Project