From mboxrd@z Thu Jan 1 00:00:00 1970 From: yannick fertre Subject: [PATCH v2 06/10] video: add support of STM32 MIPI DSI controller driver Date: Fri, 2 Mar 2018 16:44:07 +0100 Message-ID: <1520005451-23217-7-git-send-email-yannick.fertre@st.com> References: <1520005451-23217-1-git-send-email-yannick.fertre@st.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mx07-00178001.pphosted.com (mx08-00178001.pphosted.com [91.207.212.93]) by gabe.freedesktop.org (Postfix) with ESMTPS id 5DFEC6E17F for ; Fri, 2 Mar 2018 15:44:37 +0000 (UTC) In-Reply-To: <1520005451-23217-1-git-send-email-yannick.fertre@st.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Vikas Manocha , Benjamin Gaignard , Yannick Fertre , Philippe Cornu , Patrice Chotard , Patrick DELAUNAY , Christophe KERELLO , Archit Taneja , Andrzej Hajda , Laurent Pinchart , David Airlie , Brian Norris , Bhumika Goyal , Gustavo Padovan , Maarten Lankhorst , Sean Paul , Albert Aribaud , Simon Glass , Anatolij Gustschin , Thierry Reding Cc: u-boot@lists.denx.de, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org List-Id: dri-devel@lists.freedesktop.org QWRkIHRoZSBTVE0zMiBEU0kgY29udHJvbGxlciBkcml2ZXIgdGhhdCB1c2VzIHRoZSBTeW5vcHN5 cyBEZXNpZ25XYXJlCk1JUEkgRFNJIGhvc3QgY29udHJvbGxlciBicmlkZ2UuCgpTaWduZWQtb2Zm LWJ5OiB5YW5uaWNrIGZlcnRyZSA8eWFubmljay5mZXJ0cmVAc3QuY29tPgotLS0KIGRyaXZlcnMv dmlkZW8vc3RtMzIvS2NvbmZpZyAgICAgfCAgMTAgKwogZHJpdmVycy92aWRlby9zdG0zMi9NYWtl ZmlsZSAgICB8ICAgMSArCiBkcml2ZXJzL3ZpZGVvL3N0bTMyL3N0bTMyX2RzaS5jIHwgNDI3ICsr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysKIDMgZmlsZXMgY2hhbmdlZCwg NDM4IGluc2VydGlvbnMoKykKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL3ZpZGVvL3N0bTMy L3N0bTMyX2RzaS5jCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy92aWRlby9zdG0zMi9LY29uZmlnIGIv ZHJpdmVycy92aWRlby9zdG0zMi9LY29uZmlnCmluZGV4IDExM2EyYmIuLjJlYTZmMTggMTAwNjQ0 Ci0tLSBhL2RyaXZlcnMvdmlkZW8vc3RtMzIvS2NvbmZpZworKysgYi9kcml2ZXJzL3ZpZGVvL3N0 bTMyL0tjb25maWcKQEAgLTE1LDYgKzE1LDE2IEBAIG1lbnVjb25maWcgVklERU9fU1RNMzIKIAkg IERTSS4gVGhpcyBvcHRpb24gZW5hYmxlcyB0aGVzZSBzdXBwb3J0cyB3aGljaCBjYW4gYmUgdXNl ZCBvbgogCSAgZGV2aWNlcyB3aGljaCBoYXZlIFJHQiBURlQgb3IgRFNJIGRpc3BsYXkgY29ubmVj dGVkLgogCitjb25maWcgVklERU9fU1RNMzJfRFNJCisJYm9vbCAiRW5hYmxlIFNUTTMyIERTSSB2 aWRlbyBzdXBwb3J0IgorCWRlcGVuZHMgb24gVklERU9fU1RNMzIKKwlzZWxlY3QgVklERU9fTUlQ SV9EU0kKKwlzZWxlY3QgVklERU9fQlJJREdFCisJc2VsZWN0IFZJREVPX0RXX01JUElfRFNJCisJ aGVscAorCSAgVGhpcyBvcHRpb24gZW5hYmxlcyBzdXBwb3J0IERTSSBpbnRlcm5hbCBicmlkZ2Ug d2hpY2ggY2FuIGJlIHVzZWQgb24KKwkgIGRldmljZXMgd2hpY2ggaGF2ZSBEU0kgZGlzcGxheSBj b25uZWN0ZWQuCisKIGNvbmZpZyBWSURFT19TVE0zMl9NQVhfWFJFUwogCWludCAiTWF4aW11bSBo b3Jpem9udGFsIHJlc29sdXRpb24gKGZvciBtZW1vcnkgYWxsb2NhdGlvbiBwdXJwb3NlcykiCiAJ ZGVwZW5kcyBvbiBWSURFT19TVE0zMgpkaWZmIC0tZ2l0IGEvZHJpdmVycy92aWRlby9zdG0zMi9N YWtlZmlsZSBiL2RyaXZlcnMvdmlkZW8vc3RtMzIvTWFrZWZpbGUKaW5kZXggMzcyYTJlMS4uZjhj M2ZmNyAxMDA2NDQKLS0tIGEvZHJpdmVycy92aWRlby9zdG0zMi9NYWtlZmlsZQorKysgYi9kcml2 ZXJzL3ZpZGVvL3N0bTMyL01ha2VmaWxlCkBAIC04LDMgKzgsNCBAQAogIwogCiBvYmotJHtDT05G SUdfVklERU9fU1RNMzJ9ID0gc3RtMzJfbHRkYy5vCitvYmotJHtDT05GSUdfVklERU9fU1RNMzJf RFNJfSArPSBzdG0zMl9kc2kubwpkaWZmIC0tZ2l0IGEvZHJpdmVycy92aWRlby9zdG0zMi9zdG0z Ml9kc2kuYyBiL2RyaXZlcnMvdmlkZW8vc3RtMzIvc3RtMzJfZHNpLmMKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMC4uM2UyNjQzMwotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMv dmlkZW8vc3RtMzIvc3RtMzJfZHNpLmMKQEAgLTAsMCArMSw0MjcgQEAKKy8qCisgKiBDb3B5cmln aHQgKEMpIDIwMTggU1RNaWNyb2VsZWN0cm9uaWNzIC0gQWxsIFJpZ2h0cyBSZXNlcnZlZAorICog QXV0aG9yKHMpOiBQaGlsaXBwZSBDb3JudSA8cGhpbGlwcGUuY29ybnVAc3QuY29tPiBmb3IgU1RN aWNyb2VsZWN0cm9uaWNzLgorICoJICAgICAgWWFubmljayBGZXJ0cmUgPHlhbm5pY2suZmVydHJl QHN0LmNvbT4gZm9yIFNUTWljcm9lbGVjdHJvbmljcy4KKyAqCisgKiBUaGlzIGRyaXZlciBpcyBi YXNlZCBvbiB0aGUgbWlwaSBkc2kgZHJpdmVyIGZyb20KKyAqIGRyaXZlcnMvZ3B1L2RybS9zdG0v ZHdfbWlwaV9kc2ktc3RtLmMgKGtlcm5lbCBsaW51eCkuCisgKgorICogU1BEWC1MaWNlbnNlLUlk ZW50aWZpZXI6IEdQTC0yLjAKKyAqLworCisjaW5jbHVkZSA8YXNtL2lvLmg+CisjaW5jbHVkZSA8 YXNtL2FyY2gvZ3Bpby5oPgorI2luY2x1ZGUgPGNvbW1vbi5oPgorI2luY2x1ZGUgPGNsay5oPgor I2luY2x1ZGUgPGRtLmg+CisjaW5jbHVkZSA8ZG0vZGV2aWNlLWludGVybmFsLmg+CisjaW5jbHVk ZSA8bWlwaV9kaXNwbGF5Lmg+CisjaW5jbHVkZSA8ZHdfbWlwaV9kc2kuaD4KKyNpbmNsdWRlIDxs aW51eC9pb3BvbGwuaD4KKyNpbmNsdWRlIDxwYW5lbC5oPgorI2luY2x1ZGUgPHJlc2V0Lmg+Cisj aW5jbHVkZSA8dmlkZW8uaD4KKyNpbmNsdWRlIDx2aWRlb19icmlkZ2UuaD4KKworREVDTEFSRV9H TE9CQUxfREFUQV9QVFI7CisKKyNkZWZpbmUgSFdWRVJfMTMwCQkJMHgzMTMzMzAwMAkvKiBJUCB2 ZXJzaW9uIDEuMzAgKi8KKyNkZWZpbmUgSFdWRVJfMTMxCQkJMHgzMTMzMzEwMAkvKiBJUCB2ZXJz aW9uIDEuMzEgKi8KKworLyogRFNJIGRpZ2l0YWwgcmVnaXN0ZXJzICYgYml0IGRlZmluaXRpb25z ICovCisjZGVmaW5lIERTSV9WRVJTSU9OCQkJMHgwMAorI2RlZmluZSBWRVJTSU9OCQkJCUdFTk1B U0soMzEsIDgpCisKKy8qCisgKiBEU0kgd3JhcHBlciByZWdpc3RlcnMgJiBiaXQgZGVmaW5pdGlv bnMKKyAqIE5vdGU6IHJlZ2lzdGVycyBhcmUgbmFtZWQgYXMgaW4gdGhlIFJlZmVyZW5jZSBNYW51 YWwKKyAqLworI2RlZmluZSBEU0lfV0NGR1IJMHgwNDAwCQkvKiBXcmFwcGVyIENvbkZpR3VyYXRp b24gUmVnICovCisjZGVmaW5lIFdDRkdSX0RTSU0JQklUKDApCQkvKiBEU0kgTW9kZSAqLworI2Rl ZmluZSBXQ0ZHUl9DT0xNVVgJR0VOTUFTSygzLCAxKQkvKiBDT0xvciBNVWx0aXBsZVhpbmcgKi8K KworI2RlZmluZSBEU0lfV0NSCQkweDA0MDQJCS8qIFdyYXBwZXIgQ29udHJvbCBSZWcgKi8KKyNk ZWZpbmUgV0NSX0RTSUVOCUJJVCgzKQkJLyogRFNJIEVOYWJsZSAqLworCisjZGVmaW5lIERTSV9X SVNSCTB4MDQwQwkJLyogV3JhcHBlciBJbnRlcnJ1cHQgYW5kIFN0YXR1cyBSZWcgKi8KKyNkZWZp bmUgV0lTUl9QTExMUwlCSVQoOCkJCS8qIFBMTCBMb2NrIFN0YXR1cyAqLworI2RlZmluZSBXSVNS X1JSUwlCSVQoMTIpCQkvKiBSZWd1bGF0b3IgUmVhZHkgU3RhdHVzICovCisKKyNkZWZpbmUgRFNJ X1dQQ1IwCTB4MDQxOAkJLyogV3JhcHBlciBQaHkgQ29uZiBSZWcgMCAqLworI2RlZmluZSBXUENS MF9VSVg0CUdFTk1BU0soNSwgMCkJLyogVW5pdCBJbnRlcnZhbCBYIDQgKi8KKyNkZWZpbmUgV1BD UjBfVERETAlCSVQoMTYpCQkvKiBUdXJuIERpc2FibGUgRGF0YSBMYW5lcyAqLworCisjZGVmaW5l IERTSV9XUlBDUgkweDA0MzAJCS8qIFdyYXBwZXIgUmVndWxhdG9yICYgUGxsIEN0cmwgUmVnICov CisjZGVmaW5lIFdSUENSX1BMTEVOCUJJVCgwKQkJLyogUExMIEVOYWJsZSAqLworI2RlZmluZSBX UlBDUl9ORElWCUdFTk1BU0soOCwgMikJLyogcGxsIGxvb3AgRElWaXNpb24gRmFjdG9yICovCisj ZGVmaW5lIFdSUENSX0lERglHRU5NQVNLKDE0LCAxMSkJLyogcGxsIElucHV0IERpdmlzaW9uIEZh Y3RvciAqLworI2RlZmluZSBXUlBDUl9PREYJR0VOTUFTSygxNywgMTYpCS8qIHBsbCBPdXRwdXQg RGl2aXNpb24gRmFjdG9yICovCisjZGVmaW5lIFdSUENSX1JFR0VOCUJJVCgyNCkJCS8qIFJFR3Vs YXRvciBFTmFibGUgKi8KKyNkZWZpbmUgV1JQQ1JfQkdSRU4JQklUKDI4KQkJLyogQmFuZEdhcCBS ZWZlcmVuY2UgRU5hYmxlICovCisjZGVmaW5lIElERl9NSU4JCTEKKyNkZWZpbmUgSURGX01BWAkJ NworI2RlZmluZSBORElWX01JTgkxMAorI2RlZmluZSBORElWX01BWAkxMjUKKyNkZWZpbmUgT0RG X01JTgkJMQorI2RlZmluZSBPREZfTUFYCQk4CisKKy8qIGRzaSBjb2xvciBmb3JtYXQgY29kaW5n IGFjY29yZGluZyB0byB0aGUgZGF0YXNoZWV0ICovCitlbnVtIGRzaV9jb2xvciB7CisJRFNJX1JH QjU2NV9DT05GMSwKKwlEU0lfUkdCNTY1X0NPTkYyLAorCURTSV9SR0I1NjVfQ09ORjMsCisJRFNJ X1JHQjY2Nl9DT05GMSwKKwlEU0lfUkdCNjY2X0NPTkYyLAorCURTSV9SR0I4ODgsCit9OworCisj ZGVmaW5lIExBTkVfTUlOX0tCUFMJMzEyNTAKKyNkZWZpbmUgTEFORV9NQVhfS0JQUwk1MDAwMDAK KworLyogVGltZW91dCBmb3IgcmVndWxhdG9yIG9uL29mZiwgcGxsIGxvY2svdW5sb2NrICYgZmlm byBlbXB0eSAqLworI2RlZmluZSBUSU1FT1VUX1VTCTIwMDAwMAorCitzdHJ1Y3Qgc3RtMzJfZHNp X3ByaXYgeworCXN0cnVjdCBtaXBpX2RzaV9kZXZpY2UgZGV2aWNlOworCXZvaWQgX19pb21lbSAq YmFzZTsKKwlzdHJ1Y3QgdWRldmljZSAqcGFuZWw7CisJdTMyIHBsbHJlZl9jbGs7CisJdTMyIGh3 X3ZlcnNpb247CisJaW50IGxhbmVfbWluX2ticHM7CisJaW50IGxhbmVfbWF4X2ticHM7Cit9Owor CitzdGF0aWMgaW5saW5lIHZvaWQgZHNpX3dyaXRlKHN0cnVjdCBzdG0zMl9kc2lfcHJpdiAqZHNp LCB1MzIgcmVnLCB1MzIgdmFsKQoreworCXdyaXRlbCh2YWwsIGRzaS0+YmFzZSArIHJlZyk7Cit9 CisKK3N0YXRpYyBpbmxpbmUgdTMyIGRzaV9yZWFkKHN0cnVjdCBzdG0zMl9kc2lfcHJpdiAqZHNp LCB1MzIgcmVnKQoreworCXJldHVybiByZWFkbChkc2ktPmJhc2UgKyByZWcpOworfQorCitzdGF0 aWMgaW5saW5lIHZvaWQgZHNpX3NldChzdHJ1Y3Qgc3RtMzJfZHNpX3ByaXYgKmRzaSwgdTMyIHJl ZywgdTMyIG1hc2spCit7CisJZHNpX3dyaXRlKGRzaSwgcmVnLCBkc2lfcmVhZChkc2ksIHJlZykg fCBtYXNrKTsKK30KKworc3RhdGljIGlubGluZSB2b2lkIGRzaV9jbGVhcihzdHJ1Y3Qgc3RtMzJf ZHNpX3ByaXYgKmRzaSwgdTMyIHJlZywgdTMyIG1hc2spCit7CisJZHNpX3dyaXRlKGRzaSwgcmVn LCBkc2lfcmVhZChkc2ksIHJlZykgJiB+bWFzayk7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBk c2lfdXBkYXRlX2JpdHMoc3RydWN0IHN0bTMyX2RzaV9wcml2ICpkc2ksIHUzMiByZWcsCisJCQkJ ICAgdTMyIG1hc2ssIHUzMiB2YWwpCit7CisJZHNpX3dyaXRlKGRzaSwgcmVnLCAoZHNpX3JlYWQo ZHNpLCByZWcpICYgfm1hc2spIHwgdmFsKTsKK30KKworc3RhdGljIGVudW0gZHNpX2NvbG9yIGRz aV9jb2xvcl9mcm9tX21pcGkodTMyIGZtdCkKK3sKKwlzd2l0Y2ggKGZtdCkgeworCWNhc2UgTUlQ SV9EU0lfRk1UX1JHQjg4ODoKKwkJcmV0dXJuIERTSV9SR0I4ODg7CisJY2FzZSBNSVBJX0RTSV9G TVRfUkdCNjY2OgorCQlyZXR1cm4gRFNJX1JHQjY2Nl9DT05GMjsKKwljYXNlIE1JUElfRFNJX0ZN VF9SR0I2NjZfUEFDS0VEOgorCQlyZXR1cm4gRFNJX1JHQjY2Nl9DT05GMTsKKwljYXNlIE1JUElf RFNJX0ZNVF9SR0I1NjU6CisJCXJldHVybiBEU0lfUkdCNTY1X0NPTkYxOworCWRlZmF1bHQ6CisJ CXByX2VycigiTUlQSSBjb2xvciBpbnZhbGlkLCBzbyB3ZSB1c2UgcmdiODg4XG4iKTsKKwl9CisJ cmV0dXJuIERTSV9SR0I4ODg7Cit9CisKK3N0YXRpYyBpbnQgZHNpX3BsbF9nZXRfY2xrb3V0X2to eihpbnQgY2xraW5fa2h6LCBpbnQgaWRmLCBpbnQgbmRpdiwgaW50IG9kZikKK3sKKwlpbnQgZGl2 aXNvciA9IGlkZiAqIG9kZjsKKworCS8qIHByZXZlbnQgZnJvbSBkaXZpc2lvbiBieSAwICovCisJ aWYgKCFkaXZpc29yKQorCQlyZXR1cm4gMDsKKworCXJldHVybiBESVZfUk9VTkRfQ0xPU0VTVChj bGtpbl9raHogKiBuZGl2LCBkaXZpc29yKTsKK30KKworc3RhdGljIGludCBkc2lfcGxsX2dldF9w YXJhbXMoc3RydWN0IHN0bTMyX2RzaV9wcml2ICpkc2ksCisJCQkgICAgICBpbnQgY2xraW5fa2h6 LCBpbnQgY2xrb3V0X2toeiwKKwkJCSAgICAgIGludCAqaWRmLCBpbnQgKm5kaXYsIGludCAqb2Rm KQoreworCWludCBpLCBvLCBuLCBuX21pbiwgbl9tYXg7CisJaW50IGZ2Y29fbWluLCBmdmNvX21h eCwgZGVsdGEsIGJlc3RfZGVsdGE7IC8qIGFsbCBpbiBraHogKi8KKworCS8qIEVhcmx5IGNoZWNr cyBwcmV2ZW50aW5nIGRpdmlzaW9uIGJ5IDAgJiBvZGQgcmVzdWx0cyAqLworCWlmIChjbGtpbl9r aHogPD0gMCB8fCBjbGtvdXRfa2h6IDw9IDApCisJCXJldHVybiAtRUlOVkFMOworCisJZnZjb19t aW4gPSBkc2ktPmxhbmVfbWluX2ticHMgKiAyICogT0RGX01BWDsKKwlmdmNvX21heCA9IGRzaS0+ bGFuZV9tYXhfa2JwcyAqIDIgKiBPREZfTUlOOworCisJYmVzdF9kZWx0YSA9IDEwMDAwMDA7IC8q IGJpZyBzdGFydGVkIHZhbHVlICgxMDAwMDAwa2h6KSAqLworCisJZm9yIChpID0gSURGX01JTjsg aSA8PSBJREZfTUFYOyBpKyspIHsKKwkJLyogQ29tcHV0ZSBuZGl2IHJhbmdlIGFjY29yZGluZyB0 byBGdmNvICovCisJCW5fbWluID0gKChmdmNvX21pbiAqIGkpIC8gKDIgKiBjbGtpbl9raHopKSAr IDE7CisJCW5fbWF4ID0gKGZ2Y29fbWF4ICogaSkgLyAoMiAqIGNsa2luX2toeik7CisKKwkJLyog Tm8gbmVlZCB0byBjb250aW51ZSBpZGYgbG9vcCBpZiB3ZSByZWFjaCBuZGl2IG1heCAqLworCQlp ZiAobl9taW4gPj0gTkRJVl9NQVgpCisJCQlicmVhazsKKworCQkvKiBDbGFtcCBuZGl2IHRvIHZh bGlkIHZhbHVlcyAqLworCQlpZiAobl9taW4gPCBORElWX01JTikKKwkJCW5fbWluID0gTkRJVl9N SU47CisJCWlmIChuX21heCA+IE5ESVZfTUFYKQorCQkJbl9tYXggPSBORElWX01BWDsKKworCQlm b3IgKG8gPSBPREZfTUlOOyBvIDw9IE9ERl9NQVg7IG8gKj0gMikgeworCQkJbiA9IERJVl9ST1VO RF9DTE9TRVNUKGkgKiBvICogY2xrb3V0X2toeiwgY2xraW5fa2h6KTsKKwkJCS8qIENoZWNrIG5k aXYgYWNjb3JkaW5nIHRvIHZjbyByYW5nZSAqLworCQkJaWYgKG4gPCBuX21pbiB8fCBuID4gbl9t YXgpCisJCQkJY29udGludWU7CisJCQkvKiBDaGVjayBpZiBuZXcgZGVsdGEgaXMgYmV0dGVyICYg c2F2ZXMgcGFyYW1ldGVycyAqLworCQkJZGVsdGEgPSBkc2lfcGxsX2dldF9jbGtvdXRfa2h6KGNs a2luX2toeiwgaSwgbiwgbykgLQorCQkJCWNsa291dF9raHo7CisJCQlpZiAoZGVsdGEgPCAwKQor CQkJCWRlbHRhID0gLWRlbHRhOworCQkJaWYgKGRlbHRhIDwgYmVzdF9kZWx0YSkgeworCQkJCSpp ZGYgPSBpOworCQkJCSpuZGl2ID0gbjsKKwkJCQkqb2RmID0gbzsKKwkJCQliZXN0X2RlbHRhID0g ZGVsdGE7CisJCQl9CisJCQkvKiBmYXN0IHJldHVybiBpbiBjYXNlIG9mICJwZXJmZWN0IHJlc3Vs dCIgKi8KKwkJCWlmICghZGVsdGEpCisJCQkJcmV0dXJuIDA7CisJCX0KKwl9CisKKwlyZXR1cm4g MDsKK30KKworc3RhdGljIGludCBkc2lfcGh5X2luaXQodm9pZCAqcHJpdl9kYXRhKQoreworCXN0 cnVjdCBtaXBpX2RzaV9kZXZpY2UgKmRldmljZSA9IHByaXZfZGF0YTsKKwlzdHJ1Y3Qgc3RtMzJf ZHNpX3ByaXYgKmRzaSA9IGRldl9nZXRfcHJpdihkZXZpY2UtPmRldik7CisJdTMyIHZhbDsKKwlp bnQgcmV0OworCisJLyogRW5hYmxlIHRoZSByZWd1bGF0b3IgKi8KKwlkc2lfc2V0KGRzaSwgRFNJ X1dSUENSLCBXUlBDUl9SRUdFTiB8IFdSUENSX0JHUkVOKTsKKwlyZXQgPSByZWFkbF9wb2xsX3Rp bWVvdXQoZHNpLT5iYXNlICsgRFNJX1dJU1IsIHZhbCwgdmFsICYgV0lTUl9SUlMsCisJCQkJIFRJ TUVPVVRfVVMpOworCWlmIChyZXQpIHsKKwkJcHJfZXJyKCIhVElNRU9VVCEgd2FpdGluZyBSRUdV XG4iKTsKKwkJcmV0dXJuIHJldDsKKwl9CisKKwkvKiBFbmFibGUgdGhlIERTSSBQTEwgJiB3YWl0 IGZvciBpdHMgbG9jayAqLworCWRzaV9zZXQoZHNpLCBEU0lfV1JQQ1IsIFdSUENSX1BMTEVOKTsK KwlyZXQgPSByZWFkbF9wb2xsX3RpbWVvdXQoZHNpLT5iYXNlICsgRFNJX1dJU1IsIHZhbCwgdmFs ICYgV0lTUl9QTExMUywKKwkJCQkgVElNRU9VVF9VUyk7CisJaWYgKHJldCkgeworCQlwcl9lcnIo IiFUSU1FT1VUISB3YWl0aW5nIFBMTFxuIik7CisJCXJldHVybiByZXQ7CisJfQorCisJLyogRW5h YmxlIHRoZSBEU0kgd3JhcHBlciAqLworCWRzaV9zZXQoZHNpLCBEU0lfV0NSLCBXQ1JfRFNJRU4p OworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgZHNpX2dldF9sYW5lX21icHModm9pZCAq cHJpdl9kYXRhLCBzdHJ1Y3QgZGlzcGxheV90aW1pbmcgKnRpbWluZ3MsCisJCQkgICAgIHUzMiBs YW5lcywgdTMyIGZvcm1hdCwgdW5zaWduZWQgaW50ICpsYW5lX21icHMpCit7CisJc3RydWN0IG1p cGlfZHNpX2RldmljZSAqZGV2aWNlID0gcHJpdl9kYXRhOworCXN0cnVjdCBzdG0zMl9kc2lfcHJp diAqZHNpID0gZGV2X2dldF9wcml2KGRldmljZS0+ZGV2KTsKKwlpbnQgaWRmLCBuZGl2LCBvZGYs IHBsbF9pbl9raHosIHBsbF9vdXRfa2h6OworCWludCByZXQsIGJwcDsKKwl1MzIgdmFsOworCisJ LyogVXBkYXRlIGxhbmUgY2FwYWJpbGl0aWVzIGFjY29yZGluZyB0byBodyB2ZXJzaW9uICovCisJ ZHNpLT5od192ZXJzaW9uID0gZHNpX3JlYWQoZHNpLCBEU0lfVkVSU0lPTikgJiBWRVJTSU9OOwor CWRzaS0+bGFuZV9taW5fa2JwcyA9IExBTkVfTUlOX0tCUFM7CisJZHNpLT5sYW5lX21heF9rYnBz ID0gTEFORV9NQVhfS0JQUzsKKwlpZiAoZHNpLT5od192ZXJzaW9uID09IEhXVkVSXzEzMSkgewor CQlkc2ktPmxhbmVfbWluX2ticHMgKj0gMjsKKwkJZHNpLT5sYW5lX21heF9rYnBzICo9IDI7CisJ fQorCisJcGxsX2luX2toeiA9IGRzaS0+cGxscmVmX2NsayAvIDEwMDA7CisKKwkvKiBDb21wdXRl IHJlcXVlc3RlZCBwbGwgb3V0ICovCisJYnBwID0gbWlwaV9kc2lfcGl4ZWxfZm9ybWF0X3RvX2Jw cChmb3JtYXQpOworCXBsbF9vdXRfa2h6ID0gKHRpbWluZ3MtPnBpeGVsY2xvY2sudHlwIC8gMTAw MCkgKiBicHAgLyBsYW5lczsKKwkvKiBBZGQgMjAlIHRvIHBsbCBvdXQgdG8gYmUgaGlnaGVyIHRo YW4gcGl4ZWwgYncgKGJ1cnN0IG1vZGUgb25seSkgKi8KKwlwbGxfb3V0X2toeiA9IChwbGxfb3V0 X2toeiAqIDEyKSAvIDEwOworCWlmIChwbGxfb3V0X2toeiA+IGRzaS0+bGFuZV9tYXhfa2Jwcykg eworCQlwbGxfb3V0X2toeiA9IGRzaS0+bGFuZV9tYXhfa2JwczsKKwkJcHJfd2FybigiV2Fybmlu ZyBtYXggcGh5IG1icHMgaXMgdXNlZFxuIik7CisJfQorCWlmIChwbGxfb3V0X2toeiA8IGRzaS0+ bGFuZV9taW5fa2JwcykgeworCQlwbGxfb3V0X2toeiA9IGRzaS0+bGFuZV9taW5fa2JwczsKKwkJ cHJfd2FybigiV2FybmluZyBtaW4gcGh5IG1icHMgaXMgdXNlZFxuIik7CisJfQorCisJLyogQ29t cHV0ZSBiZXN0IHBsbCBwYXJhbWV0ZXJzICovCisJaWRmID0gMDsKKwluZGl2ID0gMDsKKwlvZGYg PSAwOworCXJldCA9IGRzaV9wbGxfZ2V0X3BhcmFtcyhkc2ksIHBsbF9pbl9raHosIHBsbF9vdXRf a2h6LAorCQkJCSAmaWRmLCAmbmRpdiwgJm9kZik7CisJaWYgKHJldCkgeworCQlwcl93YXJuKCJX YXJuaW5nIGRzaV9wbGxfZ2V0X3BhcmFtcygpOiBiYWQgcGFyYW1zXG4iKTsKKwkJcmV0dXJuIHJl dDsKKwl9CisKKwkvKiBHZXQgdGhlIGFkanVzdGVkIHBsbCBvdXQgdmFsdWUgKi8KKwlwbGxfb3V0 X2toeiA9IGRzaV9wbGxfZ2V0X2Nsa291dF9raHoocGxsX2luX2toeiwgaWRmLCBuZGl2LCBvZGYp OworCisJLyogU2V0IHRoZSBQTEwgZGl2aXNpb24gZmFjdG9ycyAqLworCWRzaV91cGRhdGVfYml0 cyhkc2ksIERTSV9XUlBDUiwJV1JQQ1JfTkRJViB8IFdSUENSX0lERiB8IFdSUENSX09ERiwKKwkJ CShuZGl2IDw8IDIpIHwgKGlkZiA8PCAxMSkgfCAoKGZmcyhvZGYpIC0gMSkgPDwgMTYpKTsKKwor CS8qIENvbXB1dGUgdWl4NCAmIHNldCB0aGUgYml0IHBlcmlvZCBpbiBoaWdoLXNwZWVkIG1vZGUg Ki8KKwl2YWwgPSA0MDAwMDAwIC8gcGxsX291dF9raHo7CisJZHNpX3VwZGF0ZV9iaXRzKGRzaSwg RFNJX1dQQ1IwLCBXUENSMF9VSVg0LCB2YWwpOworCisJLyogU2VsZWN0IHZpZGVvIG1vZGUgYnkg cmVzZXR0aW5nIERTSU0gYml0ICovCisJZHNpX2NsZWFyKGRzaSwgRFNJX1dDRkdSLCBXQ0ZHUl9E U0lNKTsKKworCS8qIFNlbGVjdCB0aGUgY29sb3IgY29kaW5nICovCisJZHNpX3VwZGF0ZV9iaXRz KGRzaSwgRFNJX1dDRkdSLCBXQ0ZHUl9DT0xNVVgsCisJCQlkc2lfY29sb3JfZnJvbV9taXBpKGZv cm1hdCkgPDwgMSk7CisKKwkqbGFuZV9tYnBzID0gcGxsX291dF9raHogLyAxMDAwOworCisJcHJf aW5mbygicGxsX2luICV1a0h6IHBsbF9vdXQgJXVrSHogbGFuZV9tYnBzICV1TUh6XG4iLAorCQlw bGxfaW5fa2h6LCBwbGxfb3V0X2toeiwgKmxhbmVfbWJwcyk7CisKKwlyZXR1cm4gMDsKK30KKwor c3RhdGljIGNvbnN0IHN0cnVjdCBkd19taXBpX2RzaV9waHlfb3BzIGR3X21pcGlfZHNpX3N0bV9w aHlfb3BzID0geworCS5pbml0ID0gZHNpX3BoeV9pbml0LAorCS5nZXRfbGFuZV9tYnBzID0gZHNp X2dldF9sYW5lX21icHMsCit9OworCitzdGF0aWMgaW50IHN0bTMyX2RzaV9hdHRhY2goc3RydWN0 IHVkZXZpY2UgKmRldikKK3sKKwlzdHJ1Y3Qgc3RtMzJfZHNpX3ByaXYgKnByaXYgPSBkZXZfZ2V0 X3ByaXYoZGV2KTsKKwlzdHJ1Y3QgZHdfbWlwaV9kc2lfcGxhdF9kYXRhICpwbGF0ZGF0YSA9IGRl dl9nZXRfcGxhdGRhdGEoZGV2KTsKKwlzdHJ1Y3QgbWlwaV9kc2lfZGV2aWNlICpkZXZpY2UgPSAm cHJpdi0+ZGV2aWNlOworCWludCByZXQ7CisKKwlwbGF0ZGF0YS0+bWF4X2RhdGFfbGFuZXMgPSAy OworCXBsYXRkYXRhLT5waHlfb3BzID0gJmR3X21pcGlfZHNpX3N0bV9waHlfb3BzOworCisJcmV0 ID0gdWNsYXNzX2ZpcnN0X2RldmljZShVQ0xBU1NfUEFORUwsICZwbGF0ZGF0YS0+cGFuZWwpOwor CWlmIChyZXQpIHsKKwkJcHJfZXJyKCIlczogcGFuZWwgZGV2aWNlIGVycm9yICVkXG4iLCBfX2Z1 bmNfXywgcmV0KTsKKwkJcmV0dXJuIHJldDsKKwl9CisKKwlyZXQgPSBkd19taXBpX2RzaV9pbml0 X2JyaWRnZShkZXZpY2UpOworCWlmIChyZXQpIHsKKwkJcHJfZXJyKCJGYWlsZWQgdG8gaW5pdGlh bGl6ZSBtaXBpIGRzaSBob3N0XG4iKTsKKwkJcmV0dXJuIHJldDsKKwl9CisKKwlyZXR1cm4gMDsK K30KKworc3RhdGljIGludCBzdG0zMl9kc2lfc2V0X2JhY2tsaWdodChzdHJ1Y3QgdWRldmljZSAq ZGV2LCBpbnQgcGVyY2VudCkKK3sKKwlzdHJ1Y3QgZHdfbWlwaV9kc2lfcGxhdF9kYXRhICpkcGxh dCA9IGRldl9nZXRfcGxhdGRhdGEoZGV2KTsKKwlzdHJ1Y3Qgc3RtMzJfZHNpX3ByaXYgKnByaXYg PSBkZXZfZ2V0X3ByaXYoZGV2KTsKKwlzdHJ1Y3QgbWlwaV9kc2lfZGV2aWNlICpkZXZpY2UgPSAm cHJpdi0+ZGV2aWNlOworCXN0cnVjdCB1ZGV2aWNlICpwYW5lbCA9IGRwbGF0LT5wYW5lbDsKKwlz dHJ1Y3QgbWlwaV9kc2lfcGFuZWxfcGxhdCAqbXBsYXQ7CisJaW50IHJldDsKKworCW1wbGF0ID0g ZGV2X2dldF9wbGF0ZGF0YShwYW5lbCk7CisJbXBsYXQtPmRldmljZSA9IGRldmljZTsKKworCXJl dCA9IHBhbmVsX2VuYWJsZV9iYWNrbGlnaHQocGFuZWwpOworCWlmIChyZXQpIHsKKwkJcHJfZXJy KCIlczogcGFuZWwgJXMgZW5hYmxlIGJhY2tsaWdodCBlcnJvciAlZFxuIiwKKwkJICAgICAgIF9f ZnVuY19fLCBwYW5lbC0+bmFtZSwgcmV0KTsKKwkJcmV0dXJuIHJldDsKKwl9CisKKwlkd19taXBp X2RzaV9icmlkZ2VfZW5hYmxlKGRldmljZSk7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGlu dCBzdG0zMl9kc2lfcHJvYmUoc3RydWN0IHVkZXZpY2UgKmRldikKK3sKKwlzdHJ1Y3Qgc3RtMzJf ZHNpX3ByaXYgKnByaXYgPSBkZXZfZ2V0X3ByaXYoZGV2KTsKKwlzdHJ1Y3QgbWlwaV9kc2lfZGV2 aWNlICpkZXZpY2UgPSAmcHJpdi0+ZGV2aWNlOworCXN0cnVjdCByZXNldF9jdGwgcnN0OworCXN0 cnVjdCBjbGsgY2xrOworCWludCByZXQ7CisKKwlkZXZpY2UtPmRldiA9IGRldjsKKworCXByaXYt PmJhc2UgPSAodm9pZCAqKWRldl9yZWFkX2FkZHIoZGV2KTsKKwlpZiAoKGZkdF9hZGRyX3QpcHJp di0+YmFzZSA9PSBGRFRfQUREUl9UX05PTkUpIHsKKwkJcHJfZXJyKCIlczogZHNpIGR0IHJlZ2lz dGVyIGFkZHJlc3MgZXJyb3JcbiIsIF9fZnVuY19fKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQor CisJcmV0ID0gY2xrX2dldF9ieV9uYW1lKGRldmljZS0+ZGV2LCAicGNsayIsICZjbGspOworCWlm IChyZXQpIHsKKwkJcHJfZXJyKCIlczogcGVyaXBoZXJhbCBjbG9jayBnZXQgZXJyb3IgJWRcbiIs IF9fZnVuY19fLCByZXQpOworCQlyZXR1cm4gLUVOT0RFVjsKKwl9CisKKwlyZXQgPSBjbGtfZW5h YmxlKCZjbGspOworCWlmIChyZXQpIHsKKwkJcHJfZXJyKCIlczogcGVyaXBoZXJhbCBjbG9jayBl bmFibGUgZXJyb3IgJWRcbiIsIF9fZnVuY19fLCByZXQpOworCQlyZXR1cm4gLUVOT0RFVjsKKwl9 CisKKwlyZXQgPSBjbGtfZ2V0X2J5X25hbWUoZGV2LCAicmVmIiwgJmNsayk7CisJaWYgKHJldCkg eworCQlwcl9lcnIoIiVzOiBwbGwgcmVmZXJlbmNlIGNsb2NrIGdldCBlcnJvciAlZFxuIiwgX19m dW5jX18sIHJldCk7CisJCXJldHVybiByZXQ7CisJfQorCisJcHJpdi0+cGxscmVmX2NsayA9ICh1 bnNpZ25lZCBpbnQpY2xrX2dldF9yYXRlKCZjbGspOworCisJcmV0ID0gcmVzZXRfZ2V0X2J5X2lu ZGV4KGRldmljZS0+ZGV2LCAwLCAmcnN0KTsKKwlpZiAocmV0KSB7CisJCXByX2VycigiJXM6IG1p c3NpbmcgZHNpIGhhcmR3YXJlIHJlc2V0XG4iLCBfX2Z1bmNfXyk7CisJCXJldHVybiAtRU5PREVW OworCX0KKworCS8qIFJlc2V0ICovCisJcmVzZXRfZGVhc3NlcnQoJnJzdCk7CisKKwlyZXR1cm4g MDsKK30KKworc3RydWN0IHZpZGVvX2JyaWRnZV9vcHMgc3RtMzJfZHNpX29wcyA9IHsKKwkuYXR0 YWNoID0gc3RtMzJfZHNpX2F0dGFjaCwKKwkuc2V0X2JhY2tsaWdodCA9IHN0bTMyX2RzaV9zZXRf YmFja2xpZ2h0LAorfTsKKworc3RhdGljIGNvbnN0IHN0cnVjdCB1ZGV2aWNlX2lkIHN0bTMyX2Rz aV9pZHNbXSA9IHsKKwl7IC5jb21wYXRpYmxlID0gInN0LHN0bTMyLWRzaSJ9LAorCXsgfQorfTsK KworVV9CT09UX0RSSVZFUihzdG0zMl9kc2kpID0geworCS5uYW1lCQkJCT0gInN0bTMyLWRpc3Bs YXktZHNpIiwKKwkuaWQJCQkJPSBVQ0xBU1NfVklERU9fQlJJREdFLAorCS5vZl9tYXRjaAkJCT0g c3RtMzJfZHNpX2lkcywKKwkuYmluZAkJCQk9IGRtX3NjYW5fZmR0X2RldiwKKwkucHJvYmUJCQkJ PSBzdG0zMl9kc2lfcHJvYmUsCisJLm9wcwkJCQk9ICZzdG0zMl9kc2lfb3BzLAorCS5wcml2X2F1 dG9fYWxsb2Nfc2l6ZQkJPSBzaXplb2Yoc3RydWN0IHN0bTMyX2RzaV9wcml2KSwKKwkucGxhdGRh dGFfYXV0b19hbGxvY19zaXplCT0gc2l6ZW9mKHN0cnVjdCBkd19taXBpX2RzaV9wbGF0X2RhdGEp LAorfTsKLS0gCjEuOS4xCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3Rv cC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9kcmkt ZGV2ZWwK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1427854AbeCBPtX (ORCPT ); Fri, 2 Mar 2018 10:49:23 -0500 Received: from mx08-00178001.pphosted.com ([91.207.212.93]:33823 "EHLO mx07-00178001.pphosted.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S936277AbeCBPon (ORCPT ); Fri, 2 Mar 2018 10:44:43 -0500 From: yannick fertre To: Vikas Manocha , Benjamin Gaignard , Yannick Fertre , Philippe Cornu , Patrice Chotard , Patrick DELAUNAY , Christophe KERELLO , Archit Taneja , Andrzej Hajda , "Laurent Pinchart" , David Airlie , Brian Norris , Bhumika Goyal , Gustavo Padovan , "Maarten Lankhorst" , Sean Paul , Albert Aribaud , "Simon Glass" , Anatolij Gustschin , Thierry Reding CC: , , Subject: [PATCH v2 06/10] video: add support of STM32 MIPI DSI controller driver Date: Fri, 2 Mar 2018 16:44:07 +0100 Message-ID: <1520005451-23217-7-git-send-email-yannick.fertre@st.com> X-Mailer: git-send-email 1.9.1 In-Reply-To: <1520005451-23217-1-git-send-email-yannick.fertre@st.com> References: <1520005451-23217-1-git-send-email-yannick.fertre@st.com> MIME-Version: 1.0 Content-Type: text/plain X-Originating-IP: [10.201.23.68] X-Proofpoint-Virus-Version: vendor=fsecure engine=2.50.10432:,, definitions=2018-03-02_08:,, signatures=0 Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Add the STM32 DSI controller driver that uses the Synopsys DesignWare MIPI DSI host controller bridge. Signed-off-by: yannick fertre --- drivers/video/stm32/Kconfig | 10 + drivers/video/stm32/Makefile | 1 + drivers/video/stm32/stm32_dsi.c | 427 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 438 insertions(+) create mode 100644 drivers/video/stm32/stm32_dsi.c diff --git a/drivers/video/stm32/Kconfig b/drivers/video/stm32/Kconfig index 113a2bb..2ea6f18 100644 --- a/drivers/video/stm32/Kconfig +++ b/drivers/video/stm32/Kconfig @@ -15,6 +15,16 @@ menuconfig VIDEO_STM32 DSI. This option enables these supports which can be used on devices which have RGB TFT or DSI display connected. +config VIDEO_STM32_DSI + bool "Enable STM32 DSI video support" + depends on VIDEO_STM32 + select VIDEO_MIPI_DSI + select VIDEO_BRIDGE + select VIDEO_DW_MIPI_DSI + help + This option enables support DSI internal bridge which can be used on + devices which have DSI display connected. + config VIDEO_STM32_MAX_XRES int "Maximum horizontal resolution (for memory allocation purposes)" depends on VIDEO_STM32 diff --git a/drivers/video/stm32/Makefile b/drivers/video/stm32/Makefile index 372a2e1..f8c3ff7 100644 --- a/drivers/video/stm32/Makefile +++ b/drivers/video/stm32/Makefile @@ -8,3 +8,4 @@ # obj-${CONFIG_VIDEO_STM32} = stm32_ltdc.o +obj-${CONFIG_VIDEO_STM32_DSI} += stm32_dsi.o diff --git a/drivers/video/stm32/stm32_dsi.c b/drivers/video/stm32/stm32_dsi.c new file mode 100644 index 0000000..3e26433 --- /dev/null +++ b/drivers/video/stm32/stm32_dsi.c @@ -0,0 +1,427 @@ +/* + * Copyright (C) 2018 STMicroelectronics - All Rights Reserved + * Author(s): Philippe Cornu for STMicroelectronics. + * Yannick Fertre for STMicroelectronics. + * + * This driver is based on the mipi dsi driver from + * drivers/gpu/drm/stm/dw_mipi_dsi-stm.c (kernel linux). + * + * SPDX-License-Identifier: GPL-2.0 + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +DECLARE_GLOBAL_DATA_PTR; + +#define HWVER_130 0x31333000 /* IP version 1.30 */ +#define HWVER_131 0x31333100 /* IP version 1.31 */ + +/* DSI digital registers & bit definitions */ +#define DSI_VERSION 0x00 +#define VERSION GENMASK(31, 8) + +/* + * DSI wrapper registers & bit definitions + * Note: registers are named as in the Reference Manual + */ +#define DSI_WCFGR 0x0400 /* Wrapper ConFiGuration Reg */ +#define WCFGR_DSIM BIT(0) /* DSI Mode */ +#define WCFGR_COLMUX GENMASK(3, 1) /* COLor MUltipleXing */ + +#define DSI_WCR 0x0404 /* Wrapper Control Reg */ +#define WCR_DSIEN BIT(3) /* DSI ENable */ + +#define DSI_WISR 0x040C /* Wrapper Interrupt and Status Reg */ +#define WISR_PLLLS BIT(8) /* PLL Lock Status */ +#define WISR_RRS BIT(12) /* Regulator Ready Status */ + +#define DSI_WPCR0 0x0418 /* Wrapper Phy Conf Reg 0 */ +#define WPCR0_UIX4 GENMASK(5, 0) /* Unit Interval X 4 */ +#define WPCR0_TDDL BIT(16) /* Turn Disable Data Lanes */ + +#define DSI_WRPCR 0x0430 /* Wrapper Regulator & Pll Ctrl Reg */ +#define WRPCR_PLLEN BIT(0) /* PLL ENable */ +#define WRPCR_NDIV GENMASK(8, 2) /* pll loop DIVision Factor */ +#define WRPCR_IDF GENMASK(14, 11) /* pll Input Division Factor */ +#define WRPCR_ODF GENMASK(17, 16) /* pll Output Division Factor */ +#define WRPCR_REGEN BIT(24) /* REGulator ENable */ +#define WRPCR_BGREN BIT(28) /* BandGap Reference ENable */ +#define IDF_MIN 1 +#define IDF_MAX 7 +#define NDIV_MIN 10 +#define NDIV_MAX 125 +#define ODF_MIN 1 +#define ODF_MAX 8 + +/* dsi color format coding according to the datasheet */ +enum dsi_color { + DSI_RGB565_CONF1, + DSI_RGB565_CONF2, + DSI_RGB565_CONF3, + DSI_RGB666_CONF1, + DSI_RGB666_CONF2, + DSI_RGB888, +}; + +#define LANE_MIN_KBPS 31250 +#define LANE_MAX_KBPS 500000 + +/* Timeout for regulator on/off, pll lock/unlock & fifo empty */ +#define TIMEOUT_US 200000 + +struct stm32_dsi_priv { + struct mipi_dsi_device device; + void __iomem *base; + struct udevice *panel; + u32 pllref_clk; + u32 hw_version; + int lane_min_kbps; + int lane_max_kbps; +}; + +static inline void dsi_write(struct stm32_dsi_priv *dsi, u32 reg, u32 val) +{ + writel(val, dsi->base + reg); +} + +static inline u32 dsi_read(struct stm32_dsi_priv *dsi, u32 reg) +{ + return readl(dsi->base + reg); +} + +static inline void dsi_set(struct stm32_dsi_priv *dsi, u32 reg, u32 mask) +{ + dsi_write(dsi, reg, dsi_read(dsi, reg) | mask); +} + +static inline void dsi_clear(struct stm32_dsi_priv *dsi, u32 reg, u32 mask) +{ + dsi_write(dsi, reg, dsi_read(dsi, reg) & ~mask); +} + +static inline void dsi_update_bits(struct stm32_dsi_priv *dsi, u32 reg, + u32 mask, u32 val) +{ + dsi_write(dsi, reg, (dsi_read(dsi, reg) & ~mask) | val); +} + +static enum dsi_color dsi_color_from_mipi(u32 fmt) +{ + switch (fmt) { + case MIPI_DSI_FMT_RGB888: + return DSI_RGB888; + case MIPI_DSI_FMT_RGB666: + return DSI_RGB666_CONF2; + case MIPI_DSI_FMT_RGB666_PACKED: + return DSI_RGB666_CONF1; + case MIPI_DSI_FMT_RGB565: + return DSI_RGB565_CONF1; + default: + pr_err("MIPI color invalid, so we use rgb888\n"); + } + return DSI_RGB888; +} + +static int dsi_pll_get_clkout_khz(int clkin_khz, int idf, int ndiv, int odf) +{ + int divisor = idf * odf; + + /* prevent from division by 0 */ + if (!divisor) + return 0; + + return DIV_ROUND_CLOSEST(clkin_khz * ndiv, divisor); +} + +static int dsi_pll_get_params(struct stm32_dsi_priv *dsi, + int clkin_khz, int clkout_khz, + int *idf, int *ndiv, int *odf) +{ + int i, o, n, n_min, n_max; + int fvco_min, fvco_max, delta, best_delta; /* all in khz */ + + /* Early checks preventing division by 0 & odd results */ + if (clkin_khz <= 0 || clkout_khz <= 0) + return -EINVAL; + + fvco_min = dsi->lane_min_kbps * 2 * ODF_MAX; + fvco_max = dsi->lane_max_kbps * 2 * ODF_MIN; + + best_delta = 1000000; /* big started value (1000000khz) */ + + for (i = IDF_MIN; i <= IDF_MAX; i++) { + /* Compute ndiv range according to Fvco */ + n_min = ((fvco_min * i) / (2 * clkin_khz)) + 1; + n_max = (fvco_max * i) / (2 * clkin_khz); + + /* No need to continue idf loop if we reach ndiv max */ + if (n_min >= NDIV_MAX) + break; + + /* Clamp ndiv to valid values */ + if (n_min < NDIV_MIN) + n_min = NDIV_MIN; + if (n_max > NDIV_MAX) + n_max = NDIV_MAX; + + for (o = ODF_MIN; o <= ODF_MAX; o *= 2) { + n = DIV_ROUND_CLOSEST(i * o * clkout_khz, clkin_khz); + /* Check ndiv according to vco range */ + if (n < n_min || n > n_max) + continue; + /* Check if new delta is better & saves parameters */ + delta = dsi_pll_get_clkout_khz(clkin_khz, i, n, o) - + clkout_khz; + if (delta < 0) + delta = -delta; + if (delta < best_delta) { + *idf = i; + *ndiv = n; + *odf = o; + best_delta = delta; + } + /* fast return in case of "perfect result" */ + if (!delta) + return 0; + } + } + + return 0; +} + +static int dsi_phy_init(void *priv_data) +{ + struct mipi_dsi_device *device = priv_data; + struct stm32_dsi_priv *dsi = dev_get_priv(device->dev); + u32 val; + int ret; + + /* Enable the regulator */ + dsi_set(dsi, DSI_WRPCR, WRPCR_REGEN | WRPCR_BGREN); + ret = readl_poll_timeout(dsi->base + DSI_WISR, val, val & WISR_RRS, + TIMEOUT_US); + if (ret) { + pr_err("!TIMEOUT! waiting REGU\n"); + return ret; + } + + /* Enable the DSI PLL & wait for its lock */ + dsi_set(dsi, DSI_WRPCR, WRPCR_PLLEN); + ret = readl_poll_timeout(dsi->base + DSI_WISR, val, val & WISR_PLLLS, + TIMEOUT_US); + if (ret) { + pr_err("!TIMEOUT! waiting PLL\n"); + return ret; + } + + /* Enable the DSI wrapper */ + dsi_set(dsi, DSI_WCR, WCR_DSIEN); + + return 0; +} + +static int dsi_get_lane_mbps(void *priv_data, struct display_timing *timings, + u32 lanes, u32 format, unsigned int *lane_mbps) +{ + struct mipi_dsi_device *device = priv_data; + struct stm32_dsi_priv *dsi = dev_get_priv(device->dev); + int idf, ndiv, odf, pll_in_khz, pll_out_khz; + int ret, bpp; + u32 val; + + /* Update lane capabilities according to hw version */ + dsi->hw_version = dsi_read(dsi, DSI_VERSION) & VERSION; + dsi->lane_min_kbps = LANE_MIN_KBPS; + dsi->lane_max_kbps = LANE_MAX_KBPS; + if (dsi->hw_version == HWVER_131) { + dsi->lane_min_kbps *= 2; + dsi->lane_max_kbps *= 2; + } + + pll_in_khz = dsi->pllref_clk / 1000; + + /* Compute requested pll out */ + bpp = mipi_dsi_pixel_format_to_bpp(format); + pll_out_khz = (timings->pixelclock.typ / 1000) * bpp / lanes; + /* Add 20% to pll out to be higher than pixel bw (burst mode only) */ + pll_out_khz = (pll_out_khz * 12) / 10; + if (pll_out_khz > dsi->lane_max_kbps) { + pll_out_khz = dsi->lane_max_kbps; + pr_warn("Warning max phy mbps is used\n"); + } + if (pll_out_khz < dsi->lane_min_kbps) { + pll_out_khz = dsi->lane_min_kbps; + pr_warn("Warning min phy mbps is used\n"); + } + + /* Compute best pll parameters */ + idf = 0; + ndiv = 0; + odf = 0; + ret = dsi_pll_get_params(dsi, pll_in_khz, pll_out_khz, + &idf, &ndiv, &odf); + if (ret) { + pr_warn("Warning dsi_pll_get_params(): bad params\n"); + return ret; + } + + /* Get the adjusted pll out value */ + pll_out_khz = dsi_pll_get_clkout_khz(pll_in_khz, idf, ndiv, odf); + + /* Set the PLL division factors */ + dsi_update_bits(dsi, DSI_WRPCR, WRPCR_NDIV | WRPCR_IDF | WRPCR_ODF, + (ndiv << 2) | (idf << 11) | ((ffs(odf) - 1) << 16)); + + /* Compute uix4 & set the bit period in high-speed mode */ + val = 4000000 / pll_out_khz; + dsi_update_bits(dsi, DSI_WPCR0, WPCR0_UIX4, val); + + /* Select video mode by resetting DSIM bit */ + dsi_clear(dsi, DSI_WCFGR, WCFGR_DSIM); + + /* Select the color coding */ + dsi_update_bits(dsi, DSI_WCFGR, WCFGR_COLMUX, + dsi_color_from_mipi(format) << 1); + + *lane_mbps = pll_out_khz / 1000; + + pr_info("pll_in %ukHz pll_out %ukHz lane_mbps %uMHz\n", + pll_in_khz, pll_out_khz, *lane_mbps); + + return 0; +} + +static const struct dw_mipi_dsi_phy_ops dw_mipi_dsi_stm_phy_ops = { + .init = dsi_phy_init, + .get_lane_mbps = dsi_get_lane_mbps, +}; + +static int stm32_dsi_attach(struct udevice *dev) +{ + struct stm32_dsi_priv *priv = dev_get_priv(dev); + struct dw_mipi_dsi_plat_data *platdata = dev_get_platdata(dev); + struct mipi_dsi_device *device = &priv->device; + int ret; + + platdata->max_data_lanes = 2; + platdata->phy_ops = &dw_mipi_dsi_stm_phy_ops; + + ret = uclass_first_device(UCLASS_PANEL, &platdata->panel); + if (ret) { + pr_err("%s: panel device error %d\n", __func__, ret); + return ret; + } + + ret = dw_mipi_dsi_init_bridge(device); + if (ret) { + pr_err("Failed to initialize mipi dsi host\n"); + return ret; + } + + return 0; +} + +static int stm32_dsi_set_backlight(struct udevice *dev, int percent) +{ + struct dw_mipi_dsi_plat_data *dplat = dev_get_platdata(dev); + struct stm32_dsi_priv *priv = dev_get_priv(dev); + struct mipi_dsi_device *device = &priv->device; + struct udevice *panel = dplat->panel; + struct mipi_dsi_panel_plat *mplat; + int ret; + + mplat = dev_get_platdata(panel); + mplat->device = device; + + ret = panel_enable_backlight(panel); + if (ret) { + pr_err("%s: panel %s enable backlight error %d\n", + __func__, panel->name, ret); + return ret; + } + + dw_mipi_dsi_bridge_enable(device); + + return 0; +} + +static int stm32_dsi_probe(struct udevice *dev) +{ + struct stm32_dsi_priv *priv = dev_get_priv(dev); + struct mipi_dsi_device *device = &priv->device; + struct reset_ctl rst; + struct clk clk; + int ret; + + device->dev = dev; + + priv->base = (void *)dev_read_addr(dev); + if ((fdt_addr_t)priv->base == FDT_ADDR_T_NONE) { + pr_err("%s: dsi dt register address error\n", __func__); + return -EINVAL; + } + + ret = clk_get_by_name(device->dev, "pclk", &clk); + if (ret) { + pr_err("%s: peripheral clock get error %d\n", __func__, ret); + return -ENODEV; + } + + ret = clk_enable(&clk); + if (ret) { + pr_err("%s: peripheral clock enable error %d\n", __func__, ret); + return -ENODEV; + } + + ret = clk_get_by_name(dev, "ref", &clk); + if (ret) { + pr_err("%s: pll reference clock get error %d\n", __func__, ret); + return ret; + } + + priv->pllref_clk = (unsigned int)clk_get_rate(&clk); + + ret = reset_get_by_index(device->dev, 0, &rst); + if (ret) { + pr_err("%s: missing dsi hardware reset\n", __func__); + return -ENODEV; + } + + /* Reset */ + reset_deassert(&rst); + + return 0; +} + +struct video_bridge_ops stm32_dsi_ops = { + .attach = stm32_dsi_attach, + .set_backlight = stm32_dsi_set_backlight, +}; + +static const struct udevice_id stm32_dsi_ids[] = { + { .compatible = "st,stm32-dsi"}, + { } +}; + +U_BOOT_DRIVER(stm32_dsi) = { + .name = "stm32-display-dsi", + .id = UCLASS_VIDEO_BRIDGE, + .of_match = stm32_dsi_ids, + .bind = dm_scan_fdt_dev, + .probe = stm32_dsi_probe, + .ops = &stm32_dsi_ops, + .priv_auto_alloc_size = sizeof(struct stm32_dsi_priv), + .platdata_auto_alloc_size = sizeof(struct dw_mipi_dsi_plat_data), +}; -- 1.9.1 From mboxrd@z Thu Jan 1 00:00:00 1970 From: yannick fertre Date: Fri, 2 Mar 2018 16:44:07 +0100 Subject: [U-Boot] [PATCH v2 06/10] video: add support of STM32 MIPI DSI controller driver In-Reply-To: <1520005451-23217-1-git-send-email-yannick.fertre@st.com> References: <1520005451-23217-1-git-send-email-yannick.fertre@st.com> Message-ID: <1520005451-23217-7-git-send-email-yannick.fertre@st.com> List-Id: MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit To: u-boot@lists.denx.de Add the STM32 DSI controller driver that uses the Synopsys DesignWare MIPI DSI host controller bridge. Signed-off-by: yannick fertre --- drivers/video/stm32/Kconfig | 10 + drivers/video/stm32/Makefile | 1 + drivers/video/stm32/stm32_dsi.c | 427 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 438 insertions(+) create mode 100644 drivers/video/stm32/stm32_dsi.c diff --git a/drivers/video/stm32/Kconfig b/drivers/video/stm32/Kconfig index 113a2bb..2ea6f18 100644 --- a/drivers/video/stm32/Kconfig +++ b/drivers/video/stm32/Kconfig @@ -15,6 +15,16 @@ menuconfig VIDEO_STM32 DSI. This option enables these supports which can be used on devices which have RGB TFT or DSI display connected. +config VIDEO_STM32_DSI + bool "Enable STM32 DSI video support" + depends on VIDEO_STM32 + select VIDEO_MIPI_DSI + select VIDEO_BRIDGE + select VIDEO_DW_MIPI_DSI + help + This option enables support DSI internal bridge which can be used on + devices which have DSI display connected. + config VIDEO_STM32_MAX_XRES int "Maximum horizontal resolution (for memory allocation purposes)" depends on VIDEO_STM32 diff --git a/drivers/video/stm32/Makefile b/drivers/video/stm32/Makefile index 372a2e1..f8c3ff7 100644 --- a/drivers/video/stm32/Makefile +++ b/drivers/video/stm32/Makefile @@ -8,3 +8,4 @@ # obj-${CONFIG_VIDEO_STM32} = stm32_ltdc.o +obj-${CONFIG_VIDEO_STM32_DSI} += stm32_dsi.o diff --git a/drivers/video/stm32/stm32_dsi.c b/drivers/video/stm32/stm32_dsi.c new file mode 100644 index 0000000..3e26433 --- /dev/null +++ b/drivers/video/stm32/stm32_dsi.c @@ -0,0 +1,427 @@ +/* + * Copyright (C) 2018 STMicroelectronics - All Rights Reserved + * Author(s): Philippe Cornu for STMicroelectronics. + * Yannick Fertre for STMicroelectronics. + * + * This driver is based on the mipi dsi driver from + * drivers/gpu/drm/stm/dw_mipi_dsi-stm.c (kernel linux). + * + * SPDX-License-Identifier: GPL-2.0 + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +DECLARE_GLOBAL_DATA_PTR; + +#define HWVER_130 0x31333000 /* IP version 1.30 */ +#define HWVER_131 0x31333100 /* IP version 1.31 */ + +/* DSI digital registers & bit definitions */ +#define DSI_VERSION 0x00 +#define VERSION GENMASK(31, 8) + +/* + * DSI wrapper registers & bit definitions + * Note: registers are named as in the Reference Manual + */ +#define DSI_WCFGR 0x0400 /* Wrapper ConFiGuration Reg */ +#define WCFGR_DSIM BIT(0) /* DSI Mode */ +#define WCFGR_COLMUX GENMASK(3, 1) /* COLor MUltipleXing */ + +#define DSI_WCR 0x0404 /* Wrapper Control Reg */ +#define WCR_DSIEN BIT(3) /* DSI ENable */ + +#define DSI_WISR 0x040C /* Wrapper Interrupt and Status Reg */ +#define WISR_PLLLS BIT(8) /* PLL Lock Status */ +#define WISR_RRS BIT(12) /* Regulator Ready Status */ + +#define DSI_WPCR0 0x0418 /* Wrapper Phy Conf Reg 0 */ +#define WPCR0_UIX4 GENMASK(5, 0) /* Unit Interval X 4 */ +#define WPCR0_TDDL BIT(16) /* Turn Disable Data Lanes */ + +#define DSI_WRPCR 0x0430 /* Wrapper Regulator & Pll Ctrl Reg */ +#define WRPCR_PLLEN BIT(0) /* PLL ENable */ +#define WRPCR_NDIV GENMASK(8, 2) /* pll loop DIVision Factor */ +#define WRPCR_IDF GENMASK(14, 11) /* pll Input Division Factor */ +#define WRPCR_ODF GENMASK(17, 16) /* pll Output Division Factor */ +#define WRPCR_REGEN BIT(24) /* REGulator ENable */ +#define WRPCR_BGREN BIT(28) /* BandGap Reference ENable */ +#define IDF_MIN 1 +#define IDF_MAX 7 +#define NDIV_MIN 10 +#define NDIV_MAX 125 +#define ODF_MIN 1 +#define ODF_MAX 8 + +/* dsi color format coding according to the datasheet */ +enum dsi_color { + DSI_RGB565_CONF1, + DSI_RGB565_CONF2, + DSI_RGB565_CONF3, + DSI_RGB666_CONF1, + DSI_RGB666_CONF2, + DSI_RGB888, +}; + +#define LANE_MIN_KBPS 31250 +#define LANE_MAX_KBPS 500000 + +/* Timeout for regulator on/off, pll lock/unlock & fifo empty */ +#define TIMEOUT_US 200000 + +struct stm32_dsi_priv { + struct mipi_dsi_device device; + void __iomem *base; + struct udevice *panel; + u32 pllref_clk; + u32 hw_version; + int lane_min_kbps; + int lane_max_kbps; +}; + +static inline void dsi_write(struct stm32_dsi_priv *dsi, u32 reg, u32 val) +{ + writel(val, dsi->base + reg); +} + +static inline u32 dsi_read(struct stm32_dsi_priv *dsi, u32 reg) +{ + return readl(dsi->base + reg); +} + +static inline void dsi_set(struct stm32_dsi_priv *dsi, u32 reg, u32 mask) +{ + dsi_write(dsi, reg, dsi_read(dsi, reg) | mask); +} + +static inline void dsi_clear(struct stm32_dsi_priv *dsi, u32 reg, u32 mask) +{ + dsi_write(dsi, reg, dsi_read(dsi, reg) & ~mask); +} + +static inline void dsi_update_bits(struct stm32_dsi_priv *dsi, u32 reg, + u32 mask, u32 val) +{ + dsi_write(dsi, reg, (dsi_read(dsi, reg) & ~mask) | val); +} + +static enum dsi_color dsi_color_from_mipi(u32 fmt) +{ + switch (fmt) { + case MIPI_DSI_FMT_RGB888: + return DSI_RGB888; + case MIPI_DSI_FMT_RGB666: + return DSI_RGB666_CONF2; + case MIPI_DSI_FMT_RGB666_PACKED: + return DSI_RGB666_CONF1; + case MIPI_DSI_FMT_RGB565: + return DSI_RGB565_CONF1; + default: + pr_err("MIPI color invalid, so we use rgb888\n"); + } + return DSI_RGB888; +} + +static int dsi_pll_get_clkout_khz(int clkin_khz, int idf, int ndiv, int odf) +{ + int divisor = idf * odf; + + /* prevent from division by 0 */ + if (!divisor) + return 0; + + return DIV_ROUND_CLOSEST(clkin_khz * ndiv, divisor); +} + +static int dsi_pll_get_params(struct stm32_dsi_priv *dsi, + int clkin_khz, int clkout_khz, + int *idf, int *ndiv, int *odf) +{ + int i, o, n, n_min, n_max; + int fvco_min, fvco_max, delta, best_delta; /* all in khz */ + + /* Early checks preventing division by 0 & odd results */ + if (clkin_khz <= 0 || clkout_khz <= 0) + return -EINVAL; + + fvco_min = dsi->lane_min_kbps * 2 * ODF_MAX; + fvco_max = dsi->lane_max_kbps * 2 * ODF_MIN; + + best_delta = 1000000; /* big started value (1000000khz) */ + + for (i = IDF_MIN; i <= IDF_MAX; i++) { + /* Compute ndiv range according to Fvco */ + n_min = ((fvco_min * i) / (2 * clkin_khz)) + 1; + n_max = (fvco_max * i) / (2 * clkin_khz); + + /* No need to continue idf loop if we reach ndiv max */ + if (n_min >= NDIV_MAX) + break; + + /* Clamp ndiv to valid values */ + if (n_min < NDIV_MIN) + n_min = NDIV_MIN; + if (n_max > NDIV_MAX) + n_max = NDIV_MAX; + + for (o = ODF_MIN; o <= ODF_MAX; o *= 2) { + n = DIV_ROUND_CLOSEST(i * o * clkout_khz, clkin_khz); + /* Check ndiv according to vco range */ + if (n < n_min || n > n_max) + continue; + /* Check if new delta is better & saves parameters */ + delta = dsi_pll_get_clkout_khz(clkin_khz, i, n, o) - + clkout_khz; + if (delta < 0) + delta = -delta; + if (delta < best_delta) { + *idf = i; + *ndiv = n; + *odf = o; + best_delta = delta; + } + /* fast return in case of "perfect result" */ + if (!delta) + return 0; + } + } + + return 0; +} + +static int dsi_phy_init(void *priv_data) +{ + struct mipi_dsi_device *device = priv_data; + struct stm32_dsi_priv *dsi = dev_get_priv(device->dev); + u32 val; + int ret; + + /* Enable the regulator */ + dsi_set(dsi, DSI_WRPCR, WRPCR_REGEN | WRPCR_BGREN); + ret = readl_poll_timeout(dsi->base + DSI_WISR, val, val & WISR_RRS, + TIMEOUT_US); + if (ret) { + pr_err("!TIMEOUT! waiting REGU\n"); + return ret; + } + + /* Enable the DSI PLL & wait for its lock */ + dsi_set(dsi, DSI_WRPCR, WRPCR_PLLEN); + ret = readl_poll_timeout(dsi->base + DSI_WISR, val, val & WISR_PLLLS, + TIMEOUT_US); + if (ret) { + pr_err("!TIMEOUT! waiting PLL\n"); + return ret; + } + + /* Enable the DSI wrapper */ + dsi_set(dsi, DSI_WCR, WCR_DSIEN); + + return 0; +} + +static int dsi_get_lane_mbps(void *priv_data, struct display_timing *timings, + u32 lanes, u32 format, unsigned int *lane_mbps) +{ + struct mipi_dsi_device *device = priv_data; + struct stm32_dsi_priv *dsi = dev_get_priv(device->dev); + int idf, ndiv, odf, pll_in_khz, pll_out_khz; + int ret, bpp; + u32 val; + + /* Update lane capabilities according to hw version */ + dsi->hw_version = dsi_read(dsi, DSI_VERSION) & VERSION; + dsi->lane_min_kbps = LANE_MIN_KBPS; + dsi->lane_max_kbps = LANE_MAX_KBPS; + if (dsi->hw_version == HWVER_131) { + dsi->lane_min_kbps *= 2; + dsi->lane_max_kbps *= 2; + } + + pll_in_khz = dsi->pllref_clk / 1000; + + /* Compute requested pll out */ + bpp = mipi_dsi_pixel_format_to_bpp(format); + pll_out_khz = (timings->pixelclock.typ / 1000) * bpp / lanes; + /* Add 20% to pll out to be higher than pixel bw (burst mode only) */ + pll_out_khz = (pll_out_khz * 12) / 10; + if (pll_out_khz > dsi->lane_max_kbps) { + pll_out_khz = dsi->lane_max_kbps; + pr_warn("Warning max phy mbps is used\n"); + } + if (pll_out_khz < dsi->lane_min_kbps) { + pll_out_khz = dsi->lane_min_kbps; + pr_warn("Warning min phy mbps is used\n"); + } + + /* Compute best pll parameters */ + idf = 0; + ndiv = 0; + odf = 0; + ret = dsi_pll_get_params(dsi, pll_in_khz, pll_out_khz, + &idf, &ndiv, &odf); + if (ret) { + pr_warn("Warning dsi_pll_get_params(): bad params\n"); + return ret; + } + + /* Get the adjusted pll out value */ + pll_out_khz = dsi_pll_get_clkout_khz(pll_in_khz, idf, ndiv, odf); + + /* Set the PLL division factors */ + dsi_update_bits(dsi, DSI_WRPCR, WRPCR_NDIV | WRPCR_IDF | WRPCR_ODF, + (ndiv << 2) | (idf << 11) | ((ffs(odf) - 1) << 16)); + + /* Compute uix4 & set the bit period in high-speed mode */ + val = 4000000 / pll_out_khz; + dsi_update_bits(dsi, DSI_WPCR0, WPCR0_UIX4, val); + + /* Select video mode by resetting DSIM bit */ + dsi_clear(dsi, DSI_WCFGR, WCFGR_DSIM); + + /* Select the color coding */ + dsi_update_bits(dsi, DSI_WCFGR, WCFGR_COLMUX, + dsi_color_from_mipi(format) << 1); + + *lane_mbps = pll_out_khz / 1000; + + pr_info("pll_in %ukHz pll_out %ukHz lane_mbps %uMHz\n", + pll_in_khz, pll_out_khz, *lane_mbps); + + return 0; +} + +static const struct dw_mipi_dsi_phy_ops dw_mipi_dsi_stm_phy_ops = { + .init = dsi_phy_init, + .get_lane_mbps = dsi_get_lane_mbps, +}; + +static int stm32_dsi_attach(struct udevice *dev) +{ + struct stm32_dsi_priv *priv = dev_get_priv(dev); + struct dw_mipi_dsi_plat_data *platdata = dev_get_platdata(dev); + struct mipi_dsi_device *device = &priv->device; + int ret; + + platdata->max_data_lanes = 2; + platdata->phy_ops = &dw_mipi_dsi_stm_phy_ops; + + ret = uclass_first_device(UCLASS_PANEL, &platdata->panel); + if (ret) { + pr_err("%s: panel device error %d\n", __func__, ret); + return ret; + } + + ret = dw_mipi_dsi_init_bridge(device); + if (ret) { + pr_err("Failed to initialize mipi dsi host\n"); + return ret; + } + + return 0; +} + +static int stm32_dsi_set_backlight(struct udevice *dev, int percent) +{ + struct dw_mipi_dsi_plat_data *dplat = dev_get_platdata(dev); + struct stm32_dsi_priv *priv = dev_get_priv(dev); + struct mipi_dsi_device *device = &priv->device; + struct udevice *panel = dplat->panel; + struct mipi_dsi_panel_plat *mplat; + int ret; + + mplat = dev_get_platdata(panel); + mplat->device = device; + + ret = panel_enable_backlight(panel); + if (ret) { + pr_err("%s: panel %s enable backlight error %d\n", + __func__, panel->name, ret); + return ret; + } + + dw_mipi_dsi_bridge_enable(device); + + return 0; +} + +static int stm32_dsi_probe(struct udevice *dev) +{ + struct stm32_dsi_priv *priv = dev_get_priv(dev); + struct mipi_dsi_device *device = &priv->device; + struct reset_ctl rst; + struct clk clk; + int ret; + + device->dev = dev; + + priv->base = (void *)dev_read_addr(dev); + if ((fdt_addr_t)priv->base == FDT_ADDR_T_NONE) { + pr_err("%s: dsi dt register address error\n", __func__); + return -EINVAL; + } + + ret = clk_get_by_name(device->dev, "pclk", &clk); + if (ret) { + pr_err("%s: peripheral clock get error %d\n", __func__, ret); + return -ENODEV; + } + + ret = clk_enable(&clk); + if (ret) { + pr_err("%s: peripheral clock enable error %d\n", __func__, ret); + return -ENODEV; + } + + ret = clk_get_by_name(dev, "ref", &clk); + if (ret) { + pr_err("%s: pll reference clock get error %d\n", __func__, ret); + return ret; + } + + priv->pllref_clk = (unsigned int)clk_get_rate(&clk); + + ret = reset_get_by_index(device->dev, 0, &rst); + if (ret) { + pr_err("%s: missing dsi hardware reset\n", __func__); + return -ENODEV; + } + + /* Reset */ + reset_deassert(&rst); + + return 0; +} + +struct video_bridge_ops stm32_dsi_ops = { + .attach = stm32_dsi_attach, + .set_backlight = stm32_dsi_set_backlight, +}; + +static const struct udevice_id stm32_dsi_ids[] = { + { .compatible = "st,stm32-dsi"}, + { } +}; + +U_BOOT_DRIVER(stm32_dsi) = { + .name = "stm32-display-dsi", + .id = UCLASS_VIDEO_BRIDGE, + .of_match = stm32_dsi_ids, + .bind = dm_scan_fdt_dev, + .probe = stm32_dsi_probe, + .ops = &stm32_dsi_ops, + .priv_auto_alloc_size = sizeof(struct stm32_dsi_priv), + .platdata_auto_alloc_size = sizeof(struct dw_mipi_dsi_plat_data), +}; -- 1.9.1