From mboxrd@z Thu Jan 1 00:00:00 1970 From: Yakir Yang Subject: Re: [RFC PATCH v2 1/3] drm: bridge/analogix_dp: add the PSR function support Date: Thu, 2 Jun 2016 21:41:51 +0800 Message-ID: <5750379F.2050007@rock-chips.com> References: <1464872228-18292-1-git-send-email-ykk@rock-chips.com> <1464872245-18362-1-git-send-email-ykk@rock-chips.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8"; Format="flowed" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1464872245-18362-1-git-send-email-ykk@rock-chips.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Mark Yao , Inki Dae , Heiko Stuebner , Tomasz Figa , Jingoo Han Cc: Krzysztof Kozlowski , linux-samsung-soc@vger.kernel.org, daniel.vetter@ffwll.ch, emil.l.velikov@gmail.com, dianders@chromium.org, dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org, "open list:ARM/Rockchip SoC..." , Thierry Reding List-Id: linux-rockchip.vger.kernel.org SGkgYWxsLAoKU29ycnkgYWJvdXQgdGhlIENDIGxpc3QsIEkgbG9zZSBzb21lIGd1eXMgaGVyZSwg anVzdCBhZGQgdGhlbSBiYWNrLgoKT24gMDYvMDIvMjAxNiAwODo1NyBQTSwgWWFraXIgWWFuZyB3 cm90ZToKPiBUaGUgZnVsbCBuYW1lIG9mIFBTUiBpcyBQYW5lbCBTZWxmIFJlZnJlc2gsIHBhbmVs IGRldmljZSBjb3VsZCByZWZyZXNoCj4gaXRzZWxmIHdpdGggdGhlIGhhcmR3YXJlIGZyYW1lYnVm ZmVyIGluIHBhbmVsLCB0aGlzIHdvdWxkIG1ha2UgbG90cyBvZgo+IHNlbnNlIHRvIHNhdmUgdGhl IHBvd2VyIGNvbnN1bXB0aW9uLgo+Cj4gVGhpcyBwYXRjaCBoYXZlIGV4cG9ydCB0d28gc3ltYm9s cyBmb3IgcGxhdGZvcm0gZHJpdmVyOgo+ICAgICAgYW5hbG9naXhfZHBfYWN0aXZlX3BzcigpCj4g ICAgICBhbmFsb2dpeF9kcF9pbmFjdGl2ZV9wc3IoKQo+Cj4gU2lnbmVkLW9mZi1ieTogWWFraXIg WWFuZyA8eWtrQHJvY2stY2hpcHMuY29tPgo+IC0tLQo+IENoYW5nZXMgaW4gdjI6Cj4gLSBJbnRy b2R1Y2UgaW4gdjIsIHNwbGl0ZSB0aGUgY29tbW9uIEFuYWxvZ2l4IERQIGNoYW5nZXMgb3V0Cj4K PiAgIGRyaXZlcnMvZ3B1L2RybS9icmlkZ2UvYW5hbG9naXgvYW5hbG9naXhfZHBfY29yZS5jIHwg NjkgKysrKysrKysrKysrKysrKysrKysrKwo+ICAgZHJpdmVycy9ncHUvZHJtL2JyaWRnZS9hbmFs b2dpeC9hbmFsb2dpeF9kcF9jb3JlLmggfCAgNCArKwo+ICAgZHJpdmVycy9ncHUvZHJtL2JyaWRn ZS9hbmFsb2dpeC9hbmFsb2dpeF9kcF9yZWcuYyAgfCA1NCArKysrKysrKysrKysrKysrKwo+ICAg ZHJpdmVycy9ncHUvZHJtL2JyaWRnZS9hbmFsb2dpeC9hbmFsb2dpeF9kcF9yZWcuaCAgfCAyOCAr KysrKysrKysKPiAgIGluY2x1ZGUvZHJtL2JyaWRnZS9hbmFsb2dpeF9kcC5oICAgICAgICAgICAg ICAgICAgIHwgIDMgKwo+ICAgNSBmaWxlcyBjaGFuZ2VkLCAxNTggaW5zZXJ0aW9ucygrKQo+Cj4g ZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9icmlkZ2UvYW5hbG9naXgvYW5hbG9naXhfZHBf Y29yZS5jIGIvZHJpdmVycy9ncHUvZHJtL2JyaWRnZS9hbmFsb2dpeC9hbmFsb2dpeF9kcF9jb3Jl LmMKPiBpbmRleCA1YWY5Y2U0Li5hNjZjY2I2IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2Ry bS9icmlkZ2UvYW5hbG9naXgvYW5hbG9naXhfZHBfY29yZS5jCj4gKysrIGIvZHJpdmVycy9ncHUv ZHJtL2JyaWRnZS9hbmFsb2dpeC9hbmFsb2dpeF9kcF9jb3JlLmMKPiBAQCAtMzksNiArMzksNzIg QEAgc3RydWN0IGJyaWRnZV9pbml0IHsKPiAgIAlzdHJ1Y3QgZGV2aWNlX25vZGUgKm5vZGU7Cj4g ICB9Owo+ICAgCj4gK2ludCBhbmFsb2dpeF9kcF9hY3RpY2VfcHNyKHN0cnVjdCBkZXZpY2UgKmRl dikKPiArewo+ICsJc3RydWN0IGFuYWxvZ2l4X2RwX2RldmljZSAqZHAgPSBkZXZfZ2V0X2RydmRh dGEoZGV2KTsKPiArCj4gKwlpZiAoIWRwLT5wc3Jfc3VwcG9ydCkKPiArCQlyZXR1cm4gLUVJTlZB TDsKPiArCj4gKwlhbmFsb2dpeF9kcF9zZW5kX3ZzYyhkcCwgRURQX1ZTQ19QU1JfU1RBVEVfQUNU SVZFIHwKPiArCQkJICAgICBFRFBfVlNDX1BTUl9DUkNfVkFMVUVTX1ZBTElEKTsKPiArCj4gKwly ZXR1cm4gMDsKPiArfQo+ICtFWFBPUlRfU1lNQk9MX0dQTChhbmFsb2dpeF9kcF9hY3RpY2VfcHNy KTsKPiArCj4gK2ludCBhbmFsb2dpeF9kcF9pbmFjdGljZV9wc3Ioc3RydWN0IGRldmljZSAqZGV2 KQo+ICt7Cj4gKwlzdHJ1Y3QgYW5hbG9naXhfZHBfZGV2aWNlICpkcCA9IGRldl9nZXRfZHJ2ZGF0 YShkZXYpOwo+ICsKPiArCWlmICghZHAtPnBzcl9zdXBwb3J0KQo+ICsJCXJldHVybiAtRUlOVkFM Owo+ICsKPiArCWFuYWxvZ2l4X2RwX3NlbmRfdnNjKGRwLCAwKTsKPiArCj4gKwlyZXR1cm4gMDsK PiArfQo+ICtFWFBPUlRfU1lNQk9MX0dQTChhbmFsb2dpeF9kcF9pbmFjdGljZV9wc3IpOwo+ICsK PiAraW50IGFuYWxvZ2l4X2RwX2VuYWJsZV9wc3Ioc3RydWN0IGFuYWxvZ2l4X2RwX2RldmljZSAq ZHApCj4gK3sKPiArCXVuc2lnbmVkIGNoYXIgcHNyX3ZlcnNpb24sIHBzcl9jYXBzOwo+ICsJdW5z aWduZWQgY2hhciBwc3JfZW47Cj4gKwo+ICsJLyogZGlzYWJsZSBwc3IgZnVuY3Rpb24gKi8KPiAr CWFuYWxvZ2l4X2RwX3JlYWRfYnl0ZV9mcm9tX2RwY2QoZHAsIERQX1BTUl9FTl9DRkcsICZwc3Jf ZW4pOwo+ICsJcHNyX2VuICY9IH5EUF9QU1JfRU5BQkxFOwo+ICsJYW5hbG9naXhfZHBfd3JpdGVf Ynl0ZV90b19kcGNkKGRwLCBEUF9QU1JfRU5fQ0ZHLCBwc3JfZW4pOwo+ICsKPiArCS8qIGNoZWNr IHBhbmVsIHBzciB2ZXJzaW9uICovCj4gKwlhbmFsb2dpeF9kcF9yZWFkX2J5dGVfZnJvbV9kcGNk KGRwLCBEUF9QU1JfU1VQUE9SVCwgJnBzcl92ZXJzaW9uKTsKPiArCWFuYWxvZ2l4X2RwX3JlYWRf Ynl0ZV9mcm9tX2RwY2QoZHAsIERQX1BTUl9DQVBTLCAmcHNyX2NhcHMpOwo+ICsJZGV2X2luZm8o ZHAtPmRldiwgIlBhbmVsIFBTUiB2ZXJzaW9uIDogJXguJXhcbiIsIHBzcl92ZXJzaW9uLCBwc3Jf Y2Fwcyk7Cj4gKwo+ICsJaWYgKCEocHNyX3ZlcnNpb24gJiBEUF9QU1JfSVNfU1VQUE9SVEVEKSkK PiArCQlyZXR1cm4gLTE7Cj4gKwo+ICsJLyogTWFpbi1MaW5rIHRyYW5zbWl0dGVyIHJlbWFpbnMg YWN0aXZlIGR1cmluZyBQU1IgYWN0aXZlIHN0YXRlcyAqLwo+ICsJYW5hbG9naXhfZHBfcmVhZF9i eXRlX2Zyb21fZHBjZChkcCwgRFBfUFNSX0VOX0NGRywgJnBzcl9lbik7Cj4gKwlwc3JfZW4gPSBE UF9QU1JfTUFJTl9MSU5LX0FDVElWRSB8IERQX1BTUl9DUkNfVkVSSUZJQ0FUSU9OOwo+ICsJYW5h bG9naXhfZHBfd3JpdGVfYnl0ZV90b19kcGNkKGRwLCBEUF9QU1JfRU5fQ0ZHLCBwc3JfZW4pOwo+ ICsKPiArCS8qIGVuYWJsZSBQU1IgZnVuY3Rpb24gKi8KPiArCWFuYWxvZ2l4X2RwX3JlYWRfYnl0 ZV9mcm9tX2RwY2QoZHAsIERQX1BTUl9FTl9DRkcsICZwc3JfZW4pOwo+ICsJcHNyX2VuID0gRFBf UFNSX0VOQUJMRSB8IERQX1BTUl9NQUlOX0xJTktfQUNUSVZFIHwKPiArCQkgRFBfUFNSX0NSQ19W RVJJRklDQVRJT047Cj4gKwlhbmFsb2dpeF9kcF93cml0ZV9ieXRlX3RvX2RwY2QoZHAsIERQX1BT Ul9FTl9DRkcsIHBzcl9lbik7Cj4gKwo+ICsJLyogcmVhZCBzaW5rIHBzciBzdGF0ZSAqLwo+ICsJ YW5hbG9naXhfZHBfcmVhZF9ieXRlX2Zyb21fZHBjZChkcCwgRFBfUFNSX0VOX0NGRywgJnBzcl9l bik7Cj4gKwlkZXZfaW5mbyhkcC0+ZGV2LCAiRFBfUFNSX0VOX0NGRzogJXhcbiIsIHBzcl9lbik7 Cj4gKwo+ICsJYW5hbG9naXhfZHBfZW5hYmxlX3Bzcl9jcmMoZHApOwo+ICsJZHAtPnBzcl9zdXBw b3J0ID0gdHJ1ZTsKPiArCj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiAgIHN0YXRpYyB2b2lkIGFu YWxvZ2l4X2RwX2luaXRfZHAoc3RydWN0IGFuYWxvZ2l4X2RwX2RldmljZSAqZHApCj4gICB7Cj4g ICAJYW5hbG9naXhfZHBfcmVzZXQoZHApOwo+IEBAIC05MjEsNiArOTg3LDkgQEAgc3RhdGljIHZv aWQgYW5hbG9naXhfZHBfY29tbWl0KHN0cnVjdCBhbmFsb2dpeF9kcF9kZXZpY2UgKmRwKQo+ICAg Cj4gICAJLyogRW5hYmxlIHZpZGVvICovCj4gICAJYW5hbG9naXhfZHBfc3RhcnRfdmlkZW8oZHAp Owo+ICsKPiArCS8qIEVuYWJsZSBQU1Igc3VwcG9ydCAqLwo+ICsJYW5hbG9naXhfZHBfZW5hYmxl X3BzcihkcCk7Cj4gICB9Cj4gICAKPiAgIGludCBhbmFsb2dpeF9kcF9nZXRfbW9kZXMoc3RydWN0 IGRybV9jb25uZWN0b3IgKmNvbm5lY3RvcikKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJt L2JyaWRnZS9hbmFsb2dpeC9hbmFsb2dpeF9kcF9jb3JlLmggYi9kcml2ZXJzL2dwdS9kcm0vYnJp ZGdlL2FuYWxvZ2l4L2FuYWxvZ2l4X2RwX2NvcmUuaAo+IGluZGV4IGI0NTYzODAuLjJkMWRhZTIg MTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2JyaWRnZS9hbmFsb2dpeC9hbmFsb2dpeF9k cF9jb3JlLmgKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vYnJpZGdlL2FuYWxvZ2l4L2FuYWxvZ2l4 X2RwX2NvcmUuaAo+IEBAIC0xNzcsNiArMTc3LDcgQEAgc3RydWN0IGFuYWxvZ2l4X2RwX2Rldmlj ZSB7Cj4gICAJaW50CQkJaHBkX2dwaW87Cj4gICAJYm9vbCAgICAgICAgICAgICAgICAgICAgZm9y Y2VfaHBkOwo+ICAgCXVuc2lnbmVkIGNoYXIgICAgICAgICAgIGVkaWRbRURJRF9CTE9DS19MRU5H VEggKiAyXTsKPiArCWJvb2wJCQlwc3Jfc3VwcG9ydDsKPiAgIAo+ICAgCXN0cnVjdCBhbmFsb2dp eF9kcF9wbGF0X2RhdGEgKnBsYXRfZGF0YTsKPiAgIH07Cj4gQEAgLTI3OCw0ICsyNzksNyBAQCBp bnQgYW5hbG9naXhfZHBfaXNfdmlkZW9fc3RyZWFtX29uKHN0cnVjdCBhbmFsb2dpeF9kcF9kZXZp Y2UgKmRwKTsKPiAgIHZvaWQgYW5hbG9naXhfZHBfY29uZmlnX3ZpZGVvX3NsYXZlX21vZGUoc3Ry dWN0IGFuYWxvZ2l4X2RwX2RldmljZSAqZHApOwo+ICAgdm9pZCBhbmFsb2dpeF9kcF9lbmFibGVf c2NyYW1ibGluZyhzdHJ1Y3QgYW5hbG9naXhfZHBfZGV2aWNlICpkcCk7Cj4gICB2b2lkIGFuYWxv Z2l4X2RwX2Rpc2FibGVfc2NyYW1ibGluZyhzdHJ1Y3QgYW5hbG9naXhfZHBfZGV2aWNlICpkcCk7 Cj4gK3ZvaWQgYW5hbG9naXhfZHBfZW5hYmxlX3Bzcl9jcmMoc3RydWN0IGFuYWxvZ2l4X2RwX2Rl dmljZSAqZHApOwo+ICt2b2lkIGFuYWxvZ2l4X2RwX3NlbmRfdnNjKHN0cnVjdCBhbmFsb2dpeF9k cF9kZXZpY2UgKmRwLCBpbnQgZGIxKTsKPiArCj4gICAjZW5kaWYgLyogX0FOQUxPR0lYX0RQX0NP UkVfSCAqLwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vYnJpZGdlL2FuYWxvZ2l4L2Fu YWxvZ2l4X2RwX3JlZy5jIGIvZHJpdmVycy9ncHUvZHJtL2JyaWRnZS9hbmFsb2dpeC9hbmFsb2dp eF9kcF9yZWcuYwo+IGluZGV4IDMxMzY2YmYuLjhkOGMzN2EgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVy cy9ncHUvZHJtL2JyaWRnZS9hbmFsb2dpeC9hbmFsb2dpeF9kcF9yZWcuYwo+ICsrKyBiL2RyaXZl cnMvZ3B1L2RybS9icmlkZ2UvYW5hbG9naXgvYW5hbG9naXhfZHBfcmVnLmMKPiBAQCAtMTMyMiwz ICsxMzIyLDU3IEBAIHZvaWQgYW5hbG9naXhfZHBfZGlzYWJsZV9zY3JhbWJsaW5nKHN0cnVjdCBh bmFsb2dpeF9kcF9kZXZpY2UgKmRwKQo+ICAgCXJlZyB8PSBTQ1JBTUJMSU5HX0RJU0FCTEU7Cj4g ICAJd3JpdGVsKHJlZywgZHAtPnJlZ19iYXNlICsgQU5BTE9HSVhfRFBfVFJBSU5JTkdfUFROX1NF VCk7Cj4gICB9Cj4gKwo+ICt2b2lkIGFuYWxvZ2l4X2RwX2VuYWJsZV9wc3JfY3JjKHN0cnVjdCBh bmFsb2dpeF9kcF9kZXZpY2UgKmRwKQo+ICt7Cj4gKwl3cml0ZWwoUFNSX1ZJRF9DUkNfRkxVU0gg fCBQU1JfVklEX0NSQ19FTkFCTEUsCj4gKwkgICAgICAgZHAtPnJlZ19iYXNlICsgQU5BTE9HSVhf RFBfQ1JDX0NPTik7Cj4gKwo+ICsJdXNsZWVwX3JhbmdlKDEwLCAyMCk7Cj4gKwo+ICsJd3JpdGVs KFBTUl9WSURfQ1JDX0VOQUJMRSwgZHAtPnJlZ19iYXNlICsgQU5BTE9HSVhfRFBfQ1JDX0NPTik7 Cj4gK30KPiArCj4gK3ZvaWQgYW5hbG9naXhfZHBfc2VuZF92c2Moc3RydWN0IGFuYWxvZ2l4X2Rw X2RldmljZSAqZHAsIGludCBkYjEpCj4gK3sKPiArCXVuc2lnbmVkIGludCB2YWw7Cj4gKwo+ICsJ LyogZG9uJ3Qgc2VuZCBpbmZvIGZyYW1lICovCj4gKwl2YWwgPSByZWFkbChkcC0+cmVnX2Jhc2Ug KyBBTkFMT0dJWF9EUF9QS1RfU0VORF9DVEwpOwo+ICsJdmFsICY9IH5JRl9FTjsKPiArCXdyaXRl bCh2YWwsIGRwLT5yZWdfYmFzZSArIEFOQUxPR0lYX0RQX1BLVF9TRU5EX0NUTCk7Cj4gKwo+ICsJ LyogY29uZmlndXJlIHNpbmdsZSBmcmFtZSB1cGRhdGUgbW9kZSAqLwo+ICsJd3JpdGVsKDB4Mywg ZHAtPnJlZ19iYXNlICsgQU5BTE9HSVhfRFBfUFNSX0ZSQU1FX1VQREFURV9DVFJMKTsKPiArCj4g KwkvKiBjb25maWd1cmUgVlNDIEhCMCB+IEhCMyAqLwo+ICsJd3JpdGVsKDB4MDAsIGRwLT5yZWdf YmFzZSArIEFOQUxPR0lYX0RQX1NQRF9IQjApOwo+ICsJd3JpdGVsKDB4MDcsIGRwLT5yZWdfYmFz ZSArIEFOQUxPR0lYX0RQX1NQRF9IQjEpOwo+ICsJd3JpdGVsKDB4MDIsIGRwLT5yZWdfYmFzZSAr IEFOQUxPR0lYX0RQX1NQRF9IQjIpOwo+ICsJd3JpdGVsKDB4MDgsIGRwLT5yZWdfYmFzZSArIEFO QUxPR0lYX0RQX1NQRF9IQjMpOwo+ICsKPiArCS8qIGNvbmZpZ3VyZSBWU0MgSEIwIH4gSEIzICov Cj4gKwl3cml0ZWwoMHgwMCwgZHAtPnJlZ19iYXNlICsgQU5BTE9HSVhfRFBfU1BEX1BCMCk7Cj4g Kwl3cml0ZWwoMHgxNiwgZHAtPnJlZ19iYXNlICsgQU5BTE9HSVhfRFBfU1BEX1BCMSk7Cj4gKwl3 cml0ZWwoMHhDRSwgZHAtPnJlZ19iYXNlICsgQU5BTE9HSVhfRFBfU1BEX1BCMik7Cj4gKwl3cml0 ZWwoMHg1RCwgZHAtPnJlZ19iYXNlICsgQU5BTE9HSVhfRFBfU1BEX1BCMyk7Cj4gKwo+ICsJLyog Y29uZmlndXJlIERCMCAvIERCMSB2YWx1ZXMgKi8KPiArCXdyaXRlbCgweDAwLCBkcC0+cmVnX2Jh c2UgKyBBTkFMT0dJWF9EUF9WU0NfU0hBRE9XX0RCMCk7Cj4gKwl3cml0ZWwoZGIxLCBkcC0+cmVn X2Jhc2UgKyBBTkFMT0dJWF9EUF9WU0NfU0hBRE9XX0RCMSk7Cj4gKwo+ICsJLyogc2V0IHJldXNl IHNwZCBpbmZvcmZyYW1lICovCj4gKwl2YWwgPSByZWFkbChkcC0+cmVnX2Jhc2UgKyBBTkFMT0dJ WF9EUF9WSURFT19DVExfMyk7Cj4gKwl2YWwgfD0gUkVVU0VfU1BEX0VOOwo+ICsJd3JpdGVsKHZh bCwgZHAtPnJlZ19iYXNlICsgQU5BTE9HSVhfRFBfVklERU9fQ1RMXzMpOwo+ICsKPiArCS8qIG1h cmsgaW5mbyBmcmFtZSB1cGRhdGUgKi8KPiArCXZhbCA9IHJlYWRsKGRwLT5yZWdfYmFzZSArIEFO QUxPR0lYX0RQX1BLVF9TRU5EX0NUTCk7Cj4gKwl2YWwgPSAodmFsIHwgSUZfVVApICYgfklGX0VO Owo+ICsJd3JpdGVsKHZhbCwgZHAtPnJlZ19iYXNlICsgQU5BTE9HSVhfRFBfUEtUX1NFTkRfQ1RM KTsKPiArCj4gKwkvKiBzZW5kIGluZm8gZnJhbWUgKi8KPiArCXZhbCA9IHJlYWRsKGRwLT5yZWdf YmFzZSArIEFOQUxPR0lYX0RQX1BLVF9TRU5EX0NUTCk7Cj4gKwl2YWwgfD0gSUZfRU47Cj4gKwl3 cml0ZWwodmFsLCBkcC0+cmVnX2Jhc2UgKyBBTkFMT0dJWF9EUF9QS1RfU0VORF9DVEwpOwo+ICt9 Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9icmlkZ2UvYW5hbG9naXgvYW5hbG9naXhf ZHBfcmVnLmggYi9kcml2ZXJzL2dwdS9kcm0vYnJpZGdlL2FuYWxvZ2l4L2FuYWxvZ2l4X2RwX3Jl Zy5oCj4gaW5kZXggY2RjYzZjNS4uYTI2OThlNCAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9k cm0vYnJpZGdlL2FuYWxvZ2l4L2FuYWxvZ2l4X2RwX3JlZy5oCj4gKysrIGIvZHJpdmVycy9ncHUv ZHJtL2JyaWRnZS9hbmFsb2dpeC9hbmFsb2dpeF9kcF9yZWcuaAo+IEBAIC0yMiw2ICsyMiw4IEBA Cj4gICAjZGVmaW5lIEFOQUxPR0lYX0RQX1ZJREVPX0NUTF84CQkJMHgzQwo+ICAgI2RlZmluZSBB TkFMT0dJWF9EUF9WSURFT19DVExfMTAJCTB4NDQKPiAgIAo+ICsjZGVmaW5lIEFOQUxPR0lYX0RQ X1NQRElGX0FVRElPX0NUTF8wCQkweEQ4Cj4gKwo+ICAgI2RlZmluZSBBTkFMT0dJWF9EUF9QTExf UkVHXzEJCQkweGZjCj4gICAjZGVmaW5lIEFOQUxPR0lYX0RQX1BMTF9SRUdfMgkJCTB4OWU0Cj4g ICAjZGVmaW5lIEFOQUxPR0lYX0RQX1BMTF9SRUdfMwkJCTB4OWU4Cj4gQEAgLTMwLDYgKzMyLDIx IEBACj4gICAKPiAgICNkZWZpbmUgQU5BTE9HSVhfRFBfUEQJCQkJMHgxMmMKPiAgIAo+ICsjZGVm aW5lIEFOQUxPR0lYX0RQX0lGX1RZUEUJCQkweDI0NAo+ICsjZGVmaW5lIEFOQUxPR0lYX0RQX0lG X1BLVF9EQjEJCQkweDI1NAo+ICsjZGVmaW5lIEFOQUxPR0lYX0RQX0lGX1BLVF9EQjIJCQkweDI1 OAo+ICsjZGVmaW5lIEFOQUxPR0lYX0RQX1NQRF9IQjAJCQkweDJGOAo+ICsjZGVmaW5lIEFOQUxP R0lYX0RQX1NQRF9IQjEJCQkweDJGQwo+ICsjZGVmaW5lIEFOQUxPR0lYX0RQX1NQRF9IQjIJCQkw eDMwMAo+ICsjZGVmaW5lIEFOQUxPR0lYX0RQX1NQRF9IQjMJCQkweDMwNAo+ICsjZGVmaW5lIEFO QUxPR0lYX0RQX1NQRF9QQjAJCQkweDMwOAo+ICsjZGVmaW5lIEFOQUxPR0lYX0RQX1NQRF9QQjEJ CQkweDMwQwo+ICsjZGVmaW5lIEFOQUxPR0lYX0RQX1NQRF9QQjIJCQkweDMxMAo+ICsjZGVmaW5l IEFOQUxPR0lYX0RQX1NQRF9QQjMJCQkweDMxNAo+ICsjZGVmaW5lIEFOQUxPR0lYX0RQX1BTUl9G UkFNRV9VUERBVEVfQ1RSTAkweDMxOAo+ICsjZGVmaW5lIEFOQUxPR0lYX0RQX1ZTQ19TSEFET1df REIwCQkweDMxQwo+ICsjZGVmaW5lIEFOQUxPR0lYX0RQX1ZTQ19TSEFET1dfREIxCQkweDMyMAo+ ICsKPiAgICNkZWZpbmUgQU5BTE9HSVhfRFBfTEFORV9NQVAJCQkweDM1Qwo+ICAgCj4gICAjZGVm aW5lIEFOQUxPR0lYX0RQX0FOQUxPR19DVExfMQkJMHgzNzAKPiBAQCAtMTAzLDYgKzEyMCw4IEBA Cj4gICAKPiAgICNkZWZpbmUgQU5BTE9HSVhfRFBfU09DX0dFTkVSQUxfQ1RMCQkweDgwMAo+ICAg Cj4gKyNkZWZpbmUgQU5BTE9HSVhfRFBfQ1JDX0NPTgkJCTB4ODkwCj4gKwo+ICAgLyogQU5BTE9H SVhfRFBfVFhfU1dfUkVTRVQgKi8KPiAgICNkZWZpbmUgUkVTRVRfRFBfVFgJCQkJKDB4MSA8PCAw KQo+ICAgCj4gQEAgLTE1MSw2ICsxNzAsNyBAQAo+ICAgI2RlZmluZSBWSURfQ0hLX1VQREFURV9U WVBFX1NISUZUCQkoNCkKPiAgICNkZWZpbmUgVklEX0NIS19VUERBVEVfVFlQRV8xCQkJKDB4MSA8 PCA0KQo+ICAgI2RlZmluZSBWSURfQ0hLX1VQREFURV9UWVBFXzAJCQkoMHgwIDw8IDQpCj4gKyNk ZWZpbmUgUkVVU0VfU1BEX0VOCQkJCSgweDEgPDwgMykKPiAgIAo+ICAgLyogQU5BTE9HSVhfRFBf VklERU9fQ1RMXzggKi8KPiAgICNkZWZpbmUgVklEX0hSRVNfVEgoeCkJCQkJKCgoeCkgJiAweGYp IDw8IDQpCj4gQEAgLTM3Niw0ICszOTYsMTIgQEAKPiAgICNkZWZpbmUgVklERU9fTU9ERV9TTEFW RV9NT0RFCQkJKDB4MSA8PCAwKQo+ICAgI2RlZmluZSBWSURFT19NT0RFX01BU1RFUl9NT0RFCQkJ KDB4MCA8PCAwKQo+ICAgCj4gKy8qIEFOQUxPR0lYX0RQX1BLVF9TRU5EX0NUTCAqLwo+ICsjZGVm aW5lIElGX1VQCQkJCQkoMHgxIDw8IDQpCj4gKyNkZWZpbmUgSUZfRU4JCQkJCSgweDEgPDwgMCkK PiArCj4gKy8qIEFOQUxPR0lYX0RQX0NSQ19DT04gKi8KPiArI2RlZmluZSBQU1JfVklEX0NSQ19G TFVTSAkJCSgweDEgPDwgMikKPiArI2RlZmluZSBQU1JfVklEX0NSQ19FTkFCTEUJCQkoMHgxIDw8 IDApCj4gKwo+ICAgI2VuZGlmIC8qIF9BTkFMT0dJWF9EUF9SRUdfSCAqLwo+IGRpZmYgLS1naXQg YS9pbmNsdWRlL2RybS9icmlkZ2UvYW5hbG9naXhfZHAuaCBiL2luY2x1ZGUvZHJtL2JyaWRnZS9h bmFsb2dpeF9kcC5oCj4gaW5kZXggOWVmODlkZS4uZGQzODUyNyAxMDA2NDQKPiAtLS0gYS9pbmNs dWRlL2RybS9icmlkZ2UvYW5hbG9naXhfZHAuaAo+ICsrKyBiL2luY2x1ZGUvZHJtL2JyaWRnZS9h bmFsb2dpeF9kcC5oCj4gQEAgLTQxLDYgKzQxLDkgQEAgc3RydWN0IGFuYWxvZ2l4X2RwX3BsYXRf ZGF0YSB7Cj4gICAJCQkJCSAgIHN0cnVjdCBkcm1fZGlzcGxheV9tb2RlICopOwo+ICAgfTsKPiAg IAo+ICtpbnQgYW5hbG9naXhfZHBfYWN0aWNlX3BzcihzdHJ1Y3QgZGV2aWNlICpkZXYpOwo+ICtp bnQgYW5hbG9naXhfZHBfaW5hY3RpY2VfcHNyKHN0cnVjdCBkZXZpY2UgKmRldik7Cj4gKwo+ICAg aW50IGFuYWxvZ2l4X2RwX3Jlc3VtZShzdHJ1Y3QgZGV2aWNlICpkZXYpOwo+ICAgaW50IGFuYWxv Z2l4X2RwX3N1c3BlbmQoc3RydWN0IGRldmljZSAqZGV2KTsKPiAgIAoKCl9fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QK ZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9w Lm9yZy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZlbAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S932729AbcFBNmG (ORCPT ); Thu, 2 Jun 2016 09:42:06 -0400 Received: from lucky1.263xmail.com ([211.157.147.134]:58179 "EHLO lucky1.263xmail.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S932310AbcFBNmE (ORCPT ); Thu, 2 Jun 2016 09:42:04 -0400 X-263anti-spam: KSV:0; X-MAIL-GRAY: 1 X-MAIL-DELIVERY: 0 X-KSVirus-check: 0 X-ABS-CHECKED: 4 X-ADDR-CHECKED: 0 X-RL-SENDER: ykk@rock-chips.com X-FST-TO: linux-rockchip@lists.infradead.org X-SENDER-IP: 103.29.142.67 X-LOGIN-NAME: ykk@rock-chips.com X-UNIQUE-TAG: <98df1c35c1e1274f06fad889775ba73c> X-ATTACHMENT-NUM: 0 X-DNS-TYPE: 0 Subject: Re: [RFC PATCH v2 1/3] drm: bridge/analogix_dp: add the PSR function support To: Mark Yao , Inki Dae , Heiko Stuebner , Tomasz Figa , Jingoo Han References: <1464872228-18292-1-git-send-email-ykk@rock-chips.com> <1464872245-18362-1-git-send-email-ykk@rock-chips.com> Cc: David Airlie , daniel.vetter@ffwll.ch, Thierry Reding , dianders@chromium.org, Krzysztof Kozlowski , emil.l.velikov@gmail.com, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, linux-samsung-soc@vger.kernel.org, "open list:ARM/Rockchip SoC..." From: Yakir Yang Message-ID: <5750379F.2050007@rock-chips.com> Date: Thu, 2 Jun 2016 21:41:51 +0800 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:38.0) Gecko/20100101 Thunderbird/38.5.1 MIME-Version: 1.0 In-Reply-To: <1464872245-18362-1-git-send-email-ykk@rock-chips.com> Content-Type: text/plain; charset=windows-1252; format=flowed Content-Transfer-Encoding: 7bit Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Hi all, Sorry about the CC list, I lose some guys here, just add them back. On 06/02/2016 08:57 PM, Yakir Yang wrote: > The full name of PSR is Panel Self Refresh, panel device could refresh > itself with the hardware framebuffer in panel, this would make lots of > sense to save the power consumption. > > This patch have export two symbols for platform driver: > analogix_dp_active_psr() > analogix_dp_inactive_psr() > > Signed-off-by: Yakir Yang > --- > Changes in v2: > - Introduce in v2, splite the common Analogix DP changes out > > drivers/gpu/drm/bridge/analogix/analogix_dp_core.c | 69 ++++++++++++++++++++++ > drivers/gpu/drm/bridge/analogix/analogix_dp_core.h | 4 ++ > drivers/gpu/drm/bridge/analogix/analogix_dp_reg.c | 54 +++++++++++++++++ > drivers/gpu/drm/bridge/analogix/analogix_dp_reg.h | 28 +++++++++ > include/drm/bridge/analogix_dp.h | 3 + > 5 files changed, 158 insertions(+) > > diff --git a/drivers/gpu/drm/bridge/analogix/analogix_dp_core.c b/drivers/gpu/drm/bridge/analogix/analogix_dp_core.c > index 5af9ce4..a66ccb6 100644 > --- a/drivers/gpu/drm/bridge/analogix/analogix_dp_core.c > +++ b/drivers/gpu/drm/bridge/analogix/analogix_dp_core.c > @@ -39,6 +39,72 @@ struct bridge_init { > struct device_node *node; > }; > > +int analogix_dp_actice_psr(struct device *dev) > +{ > + struct analogix_dp_device *dp = dev_get_drvdata(dev); > + > + if (!dp->psr_support) > + return -EINVAL; > + > + analogix_dp_send_vsc(dp, EDP_VSC_PSR_STATE_ACTIVE | > + EDP_VSC_PSR_CRC_VALUES_VALID); > + > + return 0; > +} > +EXPORT_SYMBOL_GPL(analogix_dp_actice_psr); > + > +int analogix_dp_inactice_psr(struct device *dev) > +{ > + struct analogix_dp_device *dp = dev_get_drvdata(dev); > + > + if (!dp->psr_support) > + return -EINVAL; > + > + analogix_dp_send_vsc(dp, 0); > + > + return 0; > +} > +EXPORT_SYMBOL_GPL(analogix_dp_inactice_psr); > + > +int analogix_dp_enable_psr(struct analogix_dp_device *dp) > +{ > + unsigned char psr_version, psr_caps; > + unsigned char psr_en; > + > + /* disable psr function */ > + analogix_dp_read_byte_from_dpcd(dp, DP_PSR_EN_CFG, &psr_en); > + psr_en &= ~DP_PSR_ENABLE; > + analogix_dp_write_byte_to_dpcd(dp, DP_PSR_EN_CFG, psr_en); > + > + /* check panel psr version */ > + analogix_dp_read_byte_from_dpcd(dp, DP_PSR_SUPPORT, &psr_version); > + analogix_dp_read_byte_from_dpcd(dp, DP_PSR_CAPS, &psr_caps); > + dev_info(dp->dev, "Panel PSR version : %x.%x\n", psr_version, psr_caps); > + > + if (!(psr_version & DP_PSR_IS_SUPPORTED)) > + return -1; > + > + /* Main-Link transmitter remains active during PSR active states */ > + analogix_dp_read_byte_from_dpcd(dp, DP_PSR_EN_CFG, &psr_en); > + psr_en = DP_PSR_MAIN_LINK_ACTIVE | DP_PSR_CRC_VERIFICATION; > + analogix_dp_write_byte_to_dpcd(dp, DP_PSR_EN_CFG, psr_en); > + > + /* enable PSR function */ > + analogix_dp_read_byte_from_dpcd(dp, DP_PSR_EN_CFG, &psr_en); > + psr_en = DP_PSR_ENABLE | DP_PSR_MAIN_LINK_ACTIVE | > + DP_PSR_CRC_VERIFICATION; > + analogix_dp_write_byte_to_dpcd(dp, DP_PSR_EN_CFG, psr_en); > + > + /* read sink psr state */ > + analogix_dp_read_byte_from_dpcd(dp, DP_PSR_EN_CFG, &psr_en); > + dev_info(dp->dev, "DP_PSR_EN_CFG: %x\n", psr_en); > + > + analogix_dp_enable_psr_crc(dp); > + dp->psr_support = true; > + > + return 0; > +} > + > static void analogix_dp_init_dp(struct analogix_dp_device *dp) > { > analogix_dp_reset(dp); > @@ -921,6 +987,9 @@ static void analogix_dp_commit(struct analogix_dp_device *dp) > > /* Enable video */ > analogix_dp_start_video(dp); > + > + /* Enable PSR support */ > + analogix_dp_enable_psr(dp); > } > > int analogix_dp_get_modes(struct drm_connector *connector) > diff --git a/drivers/gpu/drm/bridge/analogix/analogix_dp_core.h b/drivers/gpu/drm/bridge/analogix/analogix_dp_core.h > index b456380..2d1dae2 100644 > --- a/drivers/gpu/drm/bridge/analogix/analogix_dp_core.h > +++ b/drivers/gpu/drm/bridge/analogix/analogix_dp_core.h > @@ -177,6 +177,7 @@ struct analogix_dp_device { > int hpd_gpio; > bool force_hpd; > unsigned char edid[EDID_BLOCK_LENGTH * 2]; > + bool psr_support; > > struct analogix_dp_plat_data *plat_data; > }; > @@ -278,4 +279,7 @@ int analogix_dp_is_video_stream_on(struct analogix_dp_device *dp); > void analogix_dp_config_video_slave_mode(struct analogix_dp_device *dp); > void analogix_dp_enable_scrambling(struct analogix_dp_device *dp); > void analogix_dp_disable_scrambling(struct analogix_dp_device *dp); > +void analogix_dp_enable_psr_crc(struct analogix_dp_device *dp); > +void analogix_dp_send_vsc(struct analogix_dp_device *dp, int db1); > + > #endif /* _ANALOGIX_DP_CORE_H */ > diff --git a/drivers/gpu/drm/bridge/analogix/analogix_dp_reg.c b/drivers/gpu/drm/bridge/analogix/analogix_dp_reg.c > index 31366bf..8d8c37a 100644 > --- a/drivers/gpu/drm/bridge/analogix/analogix_dp_reg.c > +++ b/drivers/gpu/drm/bridge/analogix/analogix_dp_reg.c > @@ -1322,3 +1322,57 @@ void analogix_dp_disable_scrambling(struct analogix_dp_device *dp) > reg |= SCRAMBLING_DISABLE; > writel(reg, dp->reg_base + ANALOGIX_DP_TRAINING_PTN_SET); > } > + > +void analogix_dp_enable_psr_crc(struct analogix_dp_device *dp) > +{ > + writel(PSR_VID_CRC_FLUSH | PSR_VID_CRC_ENABLE, > + dp->reg_base + ANALOGIX_DP_CRC_CON); > + > + usleep_range(10, 20); > + > + writel(PSR_VID_CRC_ENABLE, dp->reg_base + ANALOGIX_DP_CRC_CON); > +} > + > +void analogix_dp_send_vsc(struct analogix_dp_device *dp, int db1) > +{ > + unsigned int val; > + > + /* don't send info frame */ > + val = readl(dp->reg_base + ANALOGIX_DP_PKT_SEND_CTL); > + val &= ~IF_EN; > + writel(val, dp->reg_base + ANALOGIX_DP_PKT_SEND_CTL); > + > + /* configure single frame update mode */ > + writel(0x3, dp->reg_base + ANALOGIX_DP_PSR_FRAME_UPDATE_CTRL); > + > + /* configure VSC HB0 ~ HB3 */ > + writel(0x00, dp->reg_base + ANALOGIX_DP_SPD_HB0); > + writel(0x07, dp->reg_base + ANALOGIX_DP_SPD_HB1); > + writel(0x02, dp->reg_base + ANALOGIX_DP_SPD_HB2); > + writel(0x08, dp->reg_base + ANALOGIX_DP_SPD_HB3); > + > + /* configure VSC HB0 ~ HB3 */ > + writel(0x00, dp->reg_base + ANALOGIX_DP_SPD_PB0); > + writel(0x16, dp->reg_base + ANALOGIX_DP_SPD_PB1); > + writel(0xCE, dp->reg_base + ANALOGIX_DP_SPD_PB2); > + writel(0x5D, dp->reg_base + ANALOGIX_DP_SPD_PB3); > + > + /* configure DB0 / DB1 values */ > + writel(0x00, dp->reg_base + ANALOGIX_DP_VSC_SHADOW_DB0); > + writel(db1, dp->reg_base + ANALOGIX_DP_VSC_SHADOW_DB1); > + > + /* set reuse spd inforframe */ > + val = readl(dp->reg_base + ANALOGIX_DP_VIDEO_CTL_3); > + val |= REUSE_SPD_EN; > + writel(val, dp->reg_base + ANALOGIX_DP_VIDEO_CTL_3); > + > + /* mark info frame update */ > + val = readl(dp->reg_base + ANALOGIX_DP_PKT_SEND_CTL); > + val = (val | IF_UP) & ~IF_EN; > + writel(val, dp->reg_base + ANALOGIX_DP_PKT_SEND_CTL); > + > + /* send info frame */ > + val = readl(dp->reg_base + ANALOGIX_DP_PKT_SEND_CTL); > + val |= IF_EN; > + writel(val, dp->reg_base + ANALOGIX_DP_PKT_SEND_CTL); > +} > diff --git a/drivers/gpu/drm/bridge/analogix/analogix_dp_reg.h b/drivers/gpu/drm/bridge/analogix/analogix_dp_reg.h > index cdcc6c5..a2698e4 100644 > --- a/drivers/gpu/drm/bridge/analogix/analogix_dp_reg.h > +++ b/drivers/gpu/drm/bridge/analogix/analogix_dp_reg.h > @@ -22,6 +22,8 @@ > #define ANALOGIX_DP_VIDEO_CTL_8 0x3C > #define ANALOGIX_DP_VIDEO_CTL_10 0x44 > > +#define ANALOGIX_DP_SPDIF_AUDIO_CTL_0 0xD8 > + > #define ANALOGIX_DP_PLL_REG_1 0xfc > #define ANALOGIX_DP_PLL_REG_2 0x9e4 > #define ANALOGIX_DP_PLL_REG_3 0x9e8 > @@ -30,6 +32,21 @@ > > #define ANALOGIX_DP_PD 0x12c > > +#define ANALOGIX_DP_IF_TYPE 0x244 > +#define ANALOGIX_DP_IF_PKT_DB1 0x254 > +#define ANALOGIX_DP_IF_PKT_DB2 0x258 > +#define ANALOGIX_DP_SPD_HB0 0x2F8 > +#define ANALOGIX_DP_SPD_HB1 0x2FC > +#define ANALOGIX_DP_SPD_HB2 0x300 > +#define ANALOGIX_DP_SPD_HB3 0x304 > +#define ANALOGIX_DP_SPD_PB0 0x308 > +#define ANALOGIX_DP_SPD_PB1 0x30C > +#define ANALOGIX_DP_SPD_PB2 0x310 > +#define ANALOGIX_DP_SPD_PB3 0x314 > +#define ANALOGIX_DP_PSR_FRAME_UPDATE_CTRL 0x318 > +#define ANALOGIX_DP_VSC_SHADOW_DB0 0x31C > +#define ANALOGIX_DP_VSC_SHADOW_DB1 0x320 > + > #define ANALOGIX_DP_LANE_MAP 0x35C > > #define ANALOGIX_DP_ANALOG_CTL_1 0x370 > @@ -103,6 +120,8 @@ > > #define ANALOGIX_DP_SOC_GENERAL_CTL 0x800 > > +#define ANALOGIX_DP_CRC_CON 0x890 > + > /* ANALOGIX_DP_TX_SW_RESET */ > #define RESET_DP_TX (0x1 << 0) > > @@ -151,6 +170,7 @@ > #define VID_CHK_UPDATE_TYPE_SHIFT (4) > #define VID_CHK_UPDATE_TYPE_1 (0x1 << 4) > #define VID_CHK_UPDATE_TYPE_0 (0x0 << 4) > +#define REUSE_SPD_EN (0x1 << 3) > > /* ANALOGIX_DP_VIDEO_CTL_8 */ > #define VID_HRES_TH(x) (((x) & 0xf) << 4) > @@ -376,4 +396,12 @@ > #define VIDEO_MODE_SLAVE_MODE (0x1 << 0) > #define VIDEO_MODE_MASTER_MODE (0x0 << 0) > > +/* ANALOGIX_DP_PKT_SEND_CTL */ > +#define IF_UP (0x1 << 4) > +#define IF_EN (0x1 << 0) > + > +/* ANALOGIX_DP_CRC_CON */ > +#define PSR_VID_CRC_FLUSH (0x1 << 2) > +#define PSR_VID_CRC_ENABLE (0x1 << 0) > + > #endif /* _ANALOGIX_DP_REG_H */ > diff --git a/include/drm/bridge/analogix_dp.h b/include/drm/bridge/analogix_dp.h > index 9ef89de..dd38527 100644 > --- a/include/drm/bridge/analogix_dp.h > +++ b/include/drm/bridge/analogix_dp.h > @@ -41,6 +41,9 @@ struct analogix_dp_plat_data { > struct drm_display_mode *); > }; > > +int analogix_dp_actice_psr(struct device *dev); > +int analogix_dp_inactice_psr(struct device *dev); > + > int analogix_dp_resume(struct device *dev); > int analogix_dp_suspend(struct device *dev); >