From mboxrd@z Thu Jan 1 00:00:00 1970 From: Yakir Yang Subject: Re: [RFC PATCH v2 3/3] drm/rockchip: analogix_dp: add PSR support Date: Thu, 2 Jun 2016 21:37:55 +0800 Message-ID: <575036B3.9070505@rock-chips.com> References: <1464872228-18292-1-git-send-email-ykk@rock-chips.com> <1464872258-18468-1-git-send-email-ykk@rock-chips.com> <20160602131847.GG7231@phenom.ffwll.local> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8"; Format="flowed" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20160602131847.GG7231@phenom.ffwll.local> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Daniel Vetter Cc: Thierry Reding , Mark Yao , linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, dianders@chromium.org, linux-rockchip@lists.infradead.org, tfiga@chromium.org List-Id: linux-rockchip.vger.kernel.org SGkgRGFuaWVsLAoKVGhhbmtzIGZvciB5b3VyIGZhc3QgcmVzcG9uZC4KCk9uIDA2LzAyLzIwMTYg MDk6MTggUE0sIERhbmllbCBWZXR0ZXIgd3JvdGU6Cj4gT24gVGh1LCBKdW4gMDIsIDIwMTYgYXQg MDg6NTc6MzhQTSArMDgwMCwgWWFraXIgWWFuZyB3cm90ZToKPj4gTGV0IFZPUCB2Ymxhbmsgc3Rh dHVzIGRlY2lkZSB3aGV0aGVyIHBhbmxlIHNob3VsZCBlbnRlciBpbnRvIG9yCj4+IGV4aXQgZnJv bSBQU1Igc3RhdHVzLiBCZWZvcmUgZURQIHN0YXJ0IHRvIGNoYW5nZSBQU1Igc3RhdHVzLCBpdAo+ PiBuZWVkIHRvIHdhaXQgZm9yIFZPUCB2YWN0X2VuZCBldmVudC4gSW4gb3JkZXIgdG8gbGlzdGVu IHZhY3RfZW5kCj4+IGV2ZW50LCBJIGNyZWF0ZSBhIG5ldyBmaWxlIGFib3V0IFBTUiBub3RpZnkg YmV0d2VlbiBlRFAgYW5kIFZPUC4KPj4KPj4gU2lnbmVkLW9mZi1ieTogWWFraXIgWWFuZyA8eWtr QHJvY2stY2hpcHMuY29tPgo+PiAtLS0KPj4gQ2hhbmdlcyBpbiB2MjoKPj4gLSBSZW1vdmUgdmJs YW5rIG5vdGlmeSBvdXQgKERhbmllbCkKPj4gLSBDcmVhdGUgYSBwc3JfYWN0aXZlKCkgY2FsbGJh Y2sgaW4gdm9wIGRhdGEgc3RydWN0Lgo+IFN0aWxsIGNvbnRhaW5zIGEgbm90aWZpZXIuIFN0aWxs IGRvZXNuJ3QgY29udGFpbiBhIHByb3BlciBmYi0+ZGlydHkKPiBjYWxsYmFjay4gUGxlYXNlIGRv bid0IGp1c3QgYWN0IG9uIHJldmlldyB3aXRob3V0IHVuZGVyc3RhbmRpbmcgdGhlIGRlZXBlcgo+ IGltcGxpY2F0aW9ucywgc2luY2UgSSBkaWRuJ3QgYXNrIHlvdSB0byByZW1vdmUgdGhlIHZibGFu ayBsb2dpYyAoeW91Cj4gcHJvYmFibHkgc3RpbGwgbmVlZCB0aGF0KSwgSSBzdWdnZXN0ZWQgdG8g aW1wbGVtZW50IGl0IGRpZmZlcmVudGx5Cj4gKHdpdGhvdHUgbm90aWZpZXJzKS4KPiAtRGFuaWVs CgpZZXMsIEkgbWlzdW5kZXJzdGFuZCB3aGF0IHlvdSBjb21tZW50IGJlZm9yZSwgSSB0aG91Z2h0 IG9ubHkKdGhlIHZibGFuayBub3RpZnkgaXMgYmFkLCBzbyBpIGNyZWF0ZSBhIGNhbGxiYWNrIGVu dHJ5IGluIHZvcC4gQnV0CnRoZSB2YWN0X2VuZCBldmVudCBpcyBzdGlsbCBhbiBldmlsIHRvbywg c3BlY2lmaWMgdG8gYSBnaXZlbiBjcnRjLgoKSG1tbSwgYWZ0ZXIgaSBhYmFuZG9uIHRoZSBub3Rp ZnksIGkgbmVlZCB0byBmb3VuZCBhIGdvb2Qgd2F5CmZvciBlRFAgdG8gZ2V0IHRoZSB2YWN0X2Vu ZCBvciB2YmxhbmsgZXZlbnQuIFRoYXQgd291bGQgYmUgYQpxdWVzdGlvbiwgaGF2ZSBubyBpZGVh IG5vdy4uLi4uCgoKQXMgZm9yIHdoeSBpIGlnbm9yZSB0aGUgdGhlIGZiLT5kaXJ0eSBjYWxsYmFj ayBpbiB0aGlzIGNhc2UsIHBsZWFzZQpzZWUgbXkgcHJldmlvdXMgcmVwbHkgdG8geW91LgoKVGhh bmtzLAotIFlha2lyCgo+PiAgIGRyaXZlcnMvZ3B1L2RybS9yb2NrY2hpcC9NYWtlZmlsZSAgICAg ICAgICAgICAgIHwgIDIgKy0KPj4gICBkcml2ZXJzL2dwdS9kcm0vcm9ja2NoaXAvYW5hbG9naXhf ZHAtcm9ja2NoaXAuYyB8IDY0ICsrKysrKysrKysrKysrKysrKysrKysrKy0KPj4gICBkcml2ZXJz L2dwdS9kcm0vcm9ja2NoaXAvcm9ja2NoaXBfZHJtX2Rydi5oICAgICB8ICA3ICsrKwo+PiAgIGRy aXZlcnMvZ3B1L2RybS9yb2NrY2hpcC9yb2NrY2hpcF9kcm1fbm90aWZ5LmMgIHwgNTQgKysrKysr KysrKysrKysrKysrKysrCj4+ICAgZHJpdmVycy9ncHUvZHJtL3JvY2tjaGlwL3JvY2tjaGlwX2Ry bV9ub3RpZnkuaCAgfCAyMyArKysrKysrKysKPj4gICBkcml2ZXJzL2dwdS9kcm0vcm9ja2NoaXAv cm9ja2NoaXBfZHJtX3ZvcC5jICAgICB8IDQxICsrKysrKysrKysrKysrKysKPj4gICA2IGZpbGVz IGNoYW5nZWQsIDE4OSBpbnNlcnRpb25zKCspLCAyIGRlbGV0aW9ucygtKQo+PiAgIGNyZWF0ZSBt b2RlIDEwMDY0NCBkcml2ZXJzL2dwdS9kcm0vcm9ja2NoaXAvcm9ja2NoaXBfZHJtX25vdGlmeS5j Cj4+ICAgY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvZ3B1L2RybS9yb2NrY2hpcC9yb2NrY2hp cF9kcm1fbm90aWZ5LmgKPj4KPj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9yb2NrY2hp cC9NYWtlZmlsZSBiL2RyaXZlcnMvZ3B1L2RybS9yb2NrY2hpcC9NYWtlZmlsZQo+PiBpbmRleCAw NWQwNzEzLi40OWZlZThjIDEwMDY0NAo+PiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vcm9ja2NoaXAv TWFrZWZpbGUKPj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL3JvY2tjaGlwL01ha2VmaWxlCj4+IEBA IC0zLDcgKzMsNyBAQAo+PiAgICMgRGlyZWN0IFJlbmRlcmluZyBJbmZyYXN0cnVjdHVyZSAoRFJJ KSBpbiBYRnJlZTg2IDQuMS4wIGFuZCBoaWdoZXIuCj4+ICAgCj4+ICAgcm9ja2NoaXBkcm0teSA6 PSByb2NrY2hpcF9kcm1fZHJ2Lm8gcm9ja2NoaXBfZHJtX2ZiLm8gXAo+PiAtCQlyb2NrY2hpcF9k cm1fZ2VtLm8gcm9ja2NoaXBfZHJtX3ZvcC5vCj4+ICsJCXJvY2tjaGlwX2RybV9nZW0ubyByb2Nr Y2hpcF9kcm1fdm9wLm8gcm9ja2NoaXBfZHJtX25vdGlmeS5vCj4+ICAgcm9ja2NoaXBkcm0tJChD T05GSUdfRFJNX0ZCREVWX0VNVUxBVElPTikgKz0gcm9ja2NoaXBfZHJtX2ZiZGV2Lm8KPj4gICAK Pj4gICBvYmotJChDT05GSUdfUk9DS0NISVBfQU5BTE9HSVhfRFApICs9IGFuYWxvZ2l4X2RwLXJv Y2tjaGlwLm8KPj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9yb2NrY2hpcC9hbmFsb2dp eF9kcC1yb2NrY2hpcC5jIGIvZHJpdmVycy9ncHUvZHJtL3JvY2tjaGlwL2FuYWxvZ2l4X2RwLXJv Y2tjaGlwLmMKPj4gaW5kZXggNGI2NDk2NC4uMjVmYjY4NyAxMDA2NDQKPj4gLS0tIGEvZHJpdmVy cy9ncHUvZHJtL3JvY2tjaGlwL2FuYWxvZ2l4X2RwLXJvY2tjaGlwLmMKPj4gKysrIGIvZHJpdmVy cy9ncHUvZHJtL3JvY2tjaGlwL2FuYWxvZ2l4X2RwLXJvY2tjaGlwLmMKPj4gQEAgLTMzLDYgKzMz LDcgQEAKPj4gICAKPj4gICAjaW5jbHVkZSAicm9ja2NoaXBfZHJtX2Rydi5oIgo+PiAgICNpbmNs dWRlICJyb2NrY2hpcF9kcm1fdm9wLmgiCj4+ICsjaW5jbHVkZSAicm9ja2NoaXBfZHJtX25vdGlm eS5oIgo+PiAgIAo+PiAgICNkZWZpbmUgdG9fZHAobm0pCWNvbnRhaW5lcl9vZihubSwgc3RydWN0 IHJvY2tjaGlwX2RwX2RldmljZSwgbm0pCj4+ICAgCj4+IEBAIC01NCw2ICs1NSwxMCBAQCBzdHJ1 Y3Qgcm9ja2NoaXBfZHBfZGV2aWNlIHsKPj4gICAJc3RydWN0IHJlZ21hcCAgICAgICAgICAgICpn cmY7Cj4+ICAgCXN0cnVjdCByZXNldF9jb250cm9sICAgICAqcnN0Owo+PiAgIAo+PiArCXN0cnVj dCB3b3JrcXVldWVfc3RydWN0CSAqZHBfd29ya3E7Cj4+ICsJc3RydWN0IHdvcmtfc3RydWN0CSBw c3Jfd29yazsKPj4gKwl1bnNpZ25lZCBpbnQJCSBwc3Jfc3RhdGU7Cj4+ICsKPj4gICAJY29uc3Qg c3RydWN0IHJvY2tjaGlwX2RwX2NoaXBfZGF0YSAqZGF0YTsKPj4gICAKPj4gICAJc3RydWN0IGFu YWxvZ2l4X2RwX3BsYXRfZGF0YSBwbGF0X2RhdGE7Cj4+IEBAIC05Nyw2ICsxMDIsNDIgQEAgc3Rh dGljIGludCByb2NrY2hpcF9kcF9wb3dlcmRvd24oc3RydWN0IGFuYWxvZ2l4X2RwX3BsYXRfZGF0 YSAqcGxhdF9kYXRhKQo+PiAgIAlyZXR1cm4gMDsKPj4gICB9Cj4+ICAgCj4+ICtzdGF0aWMgaW50 IHJvY2tjaGlwX2RwX3Bzcl9hY3RpdmUoZW51bSBwc3JfYWN0aW9uIGFjdGlvbiwgdm9pZCAqcHJp dikKPj4gK3sKPj4gKwlzdHJ1Y3Qgcm9ja2NoaXBfZHBfZGV2aWNlICpkcCA9IChzdHJ1Y3Qgcm9j a2NoaXBfZHBfZGV2aWNlICopcHJpdjsKPj4gKwo+PiArCXN3aXRjaCAoYWN0aW9uKSB7Cj4+ICsJ Y2FzZSBQU1JfSU5BQ1RJVkU6Cj4+ICsJCWRwLT5wc3Jfc3RhdGUgPSAwOwo+PiArCQlicmVhazsK Pj4gKwljYXNlIFBTUl9BQ1RJVkU6Cj4+ICsJCWRwLT5wc3Jfc3RhdGUgPSBFRFBfVlNDX1BTUl9T VEFURV9BQ1RJVkU7Cj4+ICsJCWJyZWFrOwo+PiArCWRlZmF1bHQ6Cj4+ICsJCXJldHVybiAwOwo+ PiArCX0KPj4gKwo+PiArCXF1ZXVlX3dvcmsoZHAtPmRwX3dvcmtxLCAmZHAtPnBzcl93b3JrKTsK Pj4gKwlyZXR1cm4gMDsKPj4gK30KPj4gKwo+PiArc3RhdGljIHZvaWQgZHBfcHNyX3dvcmsoc3Ry dWN0IHdvcmtfc3RydWN0ICpwc3Jfd29yaykKPj4gK3sKPj4gKwlzdHJ1Y3Qgcm9ja2NoaXBfZHBf ZGV2aWNlICpkcCA9IHRvX2RwKHBzcl93b3JrKTsKPj4gKwlpbnQgcHNyX3N0YXRlID0gZHAtPnBz cl9zdGF0ZTsKPj4gKwlpbnQgcmV0Owo+PiArCj4+ICsJaWYgKHBzcl9zdGF0ZSA9PSBFRFBfVlND X1BTUl9TVEFURV9BQ1RJVkUpIHsKPj4gKwkJcmV0ID0gcm9ja2NoaXBfcHNyX3JlYWR5X3dhaXQo KTsKPj4gKwkJaWYgKHJldCA9PSAwKQo+PiArCQkJYW5hbG9naXhfZHBfYWN0aWNlX3BzcihkcC0+ ZGV2KTsKPj4gKwl9IGVsc2Ugewo+PiArCQlyZXQgPSByb2NrY2hpcF9wc3JfcmVhZHlfd2FpdCgp Owo+PiArCQlpZiAocmV0ID09IDApCj4+ICsJCQlhbmFsb2dpeF9kcF9pbmFjdGljZV9wc3IoZHAt PmRldik7Cj4+ICsJfQo+PiArfQo+PiArCj4+ICAgc3RhdGljIGVudW0gZHJtX21vZGVfc3RhdHVz Cj4+ICAgcm9ja2NoaXBfZHBfbW9kZV92YWxpZChzdHJ1Y3QgYW5hbG9naXhfZHBfcGxhdF9kYXRh ICpwbGF0X2RhdGEsCj4+ICAgCQkgICAgICAgc3RydWN0IGRybV9jb25uZWN0b3IgKmNvbm5lY3Rv ciwKPj4gQEAgLTEyOCw5ICsxNjksMTggQEAgc3RhdGljIHZvaWQgcm9ja2NoaXBfZHBfZHJtX2Vu Y29kZXJfbW9kZV9zZXQoc3RydWN0IGRybV9lbmNvZGVyICplbmNvZGVyLAo+PiAgIAkJCQkJICAg ICBzdHJ1Y3QgZHJtX2Rpc3BsYXlfbW9kZSAqbW9kZSwKPj4gICAJCQkJCSAgICAgc3RydWN0IGRy bV9kaXNwbGF5X21vZGUgKmFkanVzdGVkKQo+PiAgIHsKPj4gLQkvKiBkbyBub3RoaW5nICovCj4+ ICsJc3RydWN0IHJvY2tjaGlwX2RwX2RldmljZSAqZHAgPSB0b19kcChlbmNvZGVyKTsKPj4gKwlz dHJ1Y3QgZHJtX2NydGMgKmNydGMgPSBlbmNvZGVyLT5jcnRjOwo+PiArCXN0cnVjdCByb2NrY2hp cF9jcnRjX3N0YXRlICpzOwo+PiArCj4+ICsJaWYgKGNydGMpIHsKPj4gKwkJcyA9IHRvX3JvY2tj aGlwX2NydGNfc3RhdGUoY3J0Yy0+c3RhdGUpOwo+PiArCQlzLT5wc3JfYWN0aXZlID0gcm9ja2No aXBfZHBfcHNyX2FjdGl2ZTsKPj4gKwkJcy0+cHNyX3ByaXYgPSBkcDsKPj4gKwl9Cj4+ICAgfQo+ PiAgIAo+PiArCj4+ICAgc3RhdGljIHZvaWQgcm9ja2NoaXBfZHBfZHJtX2VuY29kZXJfZW5hYmxl KHN0cnVjdCBkcm1fZW5jb2RlciAqZW5jb2RlcikKPj4gICB7Cj4+ICAgCXN0cnVjdCByb2NrY2hp cF9kcF9kZXZpY2UgKmRwID0gdG9fZHAoZW5jb2Rlcik7Cj4+IEBAIC0xOTgsNiArMjQ4LDkgQEAg cm9ja2NoaXBfZHBfZHJtX2VuY29kZXJfYXRvbWljX2NoZWNrKHN0cnVjdCBkcm1fZW5jb2RlciAq ZW5jb2RlciwKPj4gICAJCWJyZWFrOwo+PiAgIAl9Cj4+ICAgCj4+ICsJcy0+cHNyX2FjdGl2ZSA9 IHJvY2tjaGlwX2RwX3Bzcl9hY3RpdmU7Cj4+ICsJcy0+cHNyX3ByaXYgPSBkcDsKPj4gKwo+PiAg IAlyZXR1cm4gMDsKPj4gICB9Cj4+ICAgCj4+IEBAIC0zMjAsNiArMzczLDE1IEBAIHN0YXRpYyBp bnQgcm9ja2NoaXBfZHBfYmluZChzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2UgKm1h c3RlciwKPj4gICAJZHAtPnBsYXRfZGF0YS5wb3dlcl9vZmYgPSByb2NrY2hpcF9kcF9wb3dlcmRv d247Cj4+ICAgCWRwLT5wbGF0X2RhdGEubW9kZV92YWxpZCA9IHJvY2tjaGlwX2RwX21vZGVfdmFs aWQ7Cj4+ICAgCj4+ICsJZHAtPmRwX3dvcmtxID0gY3JlYXRlX3NpbmdsZXRocmVhZF93b3JrcXVl dWUoImRwIik7Cj4+ICsJaWYgKCFkcC0+ZHBfd29ya3EpIHsKPj4gKwkJZGV2X2VycihkcC0+ZGV2 LCAiZmFpbGVkIHRvIGNyZWF0ZSB3b3JrcXVldWVcbiIpOwo+PiArCQlyZXR1cm4gUFRSX0VSUihk cC0+ZHBfd29ya3EpOwo+PiArCX0KPj4gKwo+PiArCWRwLT5wc3Jfc3RhdGUgPSAwOwo+PiArCUlO SVRfV09SSygmZHAtPnBzcl93b3JrLCBkcF9wc3Jfd29yayk7Cj4+ICsKPj4gICAJcmV0dXJuIGFu YWxvZ2l4X2RwX2JpbmQoZGV2LCBkcC0+ZHJtX2RldiwgJmRwLT5wbGF0X2RhdGEpOwo+PiAgIH0K Pj4gICAKPj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9yb2NrY2hpcC9yb2NrY2hpcF9k cm1fZHJ2LmggYi9kcml2ZXJzL2dwdS9kcm0vcm9ja2NoaXAvcm9ja2NoaXBfZHJtX2Rydi5oCj4+ IGluZGV4IDU2ZjQzYTMuLmYxY2NjMTAgMTAwNjQ0Cj4+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9y b2NrY2hpcC9yb2NrY2hpcF9kcm1fZHJ2LmgKPj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL3JvY2tj aGlwL3JvY2tjaGlwX2RybV9kcnYuaAo+PiBAQCAtMzEsNiArMzEsMTEgQEAKPj4gICBzdHJ1Y3Qg ZHJtX2RldmljZTsKPj4gICBzdHJ1Y3QgZHJtX2Nvbm5lY3RvcjsKPj4gICAKPj4gK2VudW0gcHNy X2FjdGlvbiB7Cj4+ICsJUFNSX0FDVElWRSA9IDAsCj4+ICsJUFNSX0lOQUNUSVZFLAo+PiArfTsK Pj4gKwo+PiAgIC8qCj4+ICAgICogUm9ja2NoaXAgZHJtIHByaXZhdGUgY3J0YyBmdW5jcy4KPj4g ICAgKiBAZW5hYmxlX3ZibGFuazogZW5hYmxlIGNydGMgdmJsYW5rIGlycS4KPj4gQEAgLTU0LDYg KzU5LDggQEAgc3RydWN0IHJvY2tjaGlwX2NydGNfc3RhdGUgewo+PiAgIAlzdHJ1Y3QgZHJtX2Ny dGNfc3RhdGUgYmFzZTsKPj4gICAJaW50IG91dHB1dF90eXBlOwo+PiAgIAlpbnQgb3V0cHV0X21v ZGU7Cj4+ICsJaW50ICgqcHNyX2FjdGl2ZSkoZW51bSBwc3JfYWN0aW9uIGFjdGlvbiwgdm9pZCAq cHJpdik7Cj4+ICsJdm9pZCAqcHNyX3ByaXY7Cj4+ICAgfTsKPj4gICAjZGVmaW5lIHRvX3JvY2tj aGlwX2NydGNfc3RhdGUocykgXAo+PiAgIAkJY29udGFpbmVyX29mKHMsIHN0cnVjdCByb2NrY2hp cF9jcnRjX3N0YXRlLCBiYXNlKQo+PiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3JvY2tj aGlwL3JvY2tjaGlwX2RybV9ub3RpZnkuYyBiL2RyaXZlcnMvZ3B1L2RybS9yb2NrY2hpcC9yb2Nr Y2hpcF9kcm1fbm90aWZ5LmMKPj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPj4gaW5kZXggMDAwMDAw MC4uOTA4ZTk5MQo+PiAtLS0gL2Rldi9udWxsCj4+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9yb2Nr Y2hpcC9yb2NrY2hpcF9kcm1fbm90aWZ5LmMKPj4gQEAgLTAsMCArMSw1NCBAQAo+PiArLyoKPj4g KyAqIENvcHlyaWdodCAoQykgRnV6aG91IFJvY2tjaGlwIEVsZWN0cm9uaWNzIENvLkx0ZAo+PiAr ICogQXV0aG9yOiBZYWtpciBZYW5nIDx5a2tAcm9jay1jaGlwcy5jb20+Cj4+ICsgKgo+PiArICog VGhpcyBzb2Z0d2FyZSBpcyBsaWNlbnNlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5l cmFsIFB1YmxpYwo+PiArICogTGljZW5zZSB2ZXJzaW9uIDIsIGFzIHB1Ymxpc2hlZCBieSB0aGUg RnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBhbmQKPj4gKyAqIG1heSBiZSBjb3BpZWQsIGRpc3Ry aWJ1dGVkLCBhbmQgbW9kaWZpZWQgdW5kZXIgdGhvc2UgdGVybXMuCj4+ICsgKgo+PiArICogVGhp cyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2Vm dWwsCj4+ICsgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1w bGllZCB3YXJyYW50eSBvZgo+PiArICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEg UEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQo+PiArICogR05VIEdlbmVyYWwgUHVibGljIExp Y2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KPj4gKyAqLwo+PiArCj4+ICsjaW5jbHVkZSAicm9ja2No aXBfZHJtX25vdGlmeS5oIgo+PiArCj4+ICtzdGF0aWMgUkFXX05PVElGSUVSX0hFQUQocHNyX3Jl YWR5X2NoYWluKTsKPj4gK3N0YXRpYyBERUZJTkVfTVVURVgocHNyX3JlYWR5X2xvY2spOwo+PiAr Cj4+ICtpbnQgcm9ja2NoaXBfZHJtX3Bzcl9yZWFkeV9yZWdpc3Rlcl9ub3RpZmllcihzdHJ1Y3Qg bm90aWZpZXJfYmxvY2sgKm5iKQo+PiArewo+PiArCWludCByZXQgPSAwOwo+PiArCj4+ICsJaWYg KCFuYikKPj4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4+ICsKPj4gKwlyZXQgPSByYXdfbm90aWZpZXJf Y2hhaW5fcmVnaXN0ZXIoJnBzcl9yZWFkeV9jaGFpbiwgbmIpOwo+PiArCXJldHVybiByZXQ7Cj4+ ICt9Cj4+ICtFWFBPUlRfU1lNQk9MX0dQTChyb2NrY2hpcF9kcm1fcHNyX3JlYWR5X3JlZ2lzdGVy X25vdGlmaWVyKTsKPj4gKwo+PiAraW50IHJvY2tjaGlwX2RybV9wc3JfcmVhZHlfdW5yZWdpc3Rl cl9ub3RpZmllcihzdHJ1Y3Qgbm90aWZpZXJfYmxvY2sgKm5iKQo+PiArewo+PiArCWludCByZXQg PSAwOwo+PiArCj4+ICsJaWYgKCFuYikKPj4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4+ICsKPj4gKwly ZXQgPSByYXdfbm90aWZpZXJfY2hhaW5fdW5yZWdpc3RlcigmcHNyX3JlYWR5X2NoYWluLCBuYik7 Cj4+ICsJcmV0dXJuIHJldDsKPj4gK30KPj4gK0VYUE9SVF9TWU1CT0xfR1BMKHJvY2tjaGlwX2Ry bV9wc3JfcmVhZHlfdW5yZWdpc3Rlcl9ub3RpZmllcik7Cj4+ICsKPj4gK2ludCByb2NrY2hpcF9w c3JfcmVhZHlfd2FpdCh2b2lkKQo+PiArewo+PiArCWludCByZXQ7Cj4+ICsKPj4gKwlyZXQgPSBy YXdfbm90aWZpZXJfY2FsbF9jaGFpbigmcHNyX3JlYWR5X2NoYWluLCAwLCAwKTsKPj4gKwlpZiAo cmV0ID09IE5PVElGWV9CQUQpCj4+ICsJCXJldHVybiAtRVRJTUVET1VUOwo+PiArCj4+ICsJcmV0 dXJuIDA7Cj4+ICt9Cj4+ICtFWFBPUlRfU1lNQk9MX0dQTChyb2NrY2hpcF9wc3JfcmVhZHlfd2Fp dCk7Cj4+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcm9ja2NoaXAvcm9ja2NoaXBfZHJt X25vdGlmeS5oIGIvZHJpdmVycy9ncHUvZHJtL3JvY2tjaGlwL3JvY2tjaGlwX2RybV9ub3RpZnku aAo+PiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+PiBpbmRleCAwMDAwMDAwLi4xYjE5MGU1Cj4+IC0t LSAvZGV2L251bGwKPj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL3JvY2tjaGlwL3JvY2tjaGlwX2Ry bV9ub3RpZnkuaAo+PiBAQCAtMCwwICsxLDIzIEBACj4+ICsvKgo+PiArICogQ29weXJpZ2h0IChD KSAyMDE0IEdvb2dsZSwgSW5jLgo+PiArICoKPj4gKyAqIFRoaXMgc29mdHdhcmUgaXMgbGljZW5z ZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMKPj4gKyAqIExpY2Vu c2UgdmVyc2lvbiAyLCBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlv biwgYW5kCj4+ICsgKiBtYXkgYmUgY29waWVkLCBkaXN0cmlidXRlZCwgYW5kIG1vZGlmaWVkIHVu ZGVyIHRob3NlIHRlcm1zLgo+PiArICoKPj4gKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRl ZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAo+PiArICogYnV0IFdJVEhPVVQg QU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKPj4gKyAq IE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gU2Vl IHRoZQo+PiArICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4K Pj4gKyAqLwo+PiArCj4+ICsjaWZuZGVmIF9fUk9DS0NISVBfRFJNX05PVElGWV9ICj4+ICsjZGVm aW5lIF9fUk9DS0NISVBfRFJNX05PVElGWV9ICj4+ICsKPj4gKyNpbmNsdWRlIDxsaW51eC9ub3Rp Zmllci5oPgo+PiArCj4+ICtpbnQgcm9ja2NoaXBfcHNyX3JlYWR5X3dhaXQodm9pZCk7Cj4+ICtp bnQgcm9ja2NoaXBfZHJtX3Bzcl9yZWFkeV9yZWdpc3Rlcl9ub3RpZmllcihzdHJ1Y3Qgbm90aWZp ZXJfYmxvY2sgKm5iKTsKPj4gK2ludCByb2NrY2hpcF9kcm1fcHNyX3JlYWR5X3VucmVnaXN0ZXJf bm90aWZpZXIoc3RydWN0IG5vdGlmaWVyX2Jsb2NrICpuYik7Cj4+ICsKPj4gKyNlbmRpZiAvKiBf X1JPQ0tDSElQX0RSTV9OT1RJRllfSCAqLwo+PiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJt L3JvY2tjaGlwL3JvY2tjaGlwX2RybV92b3AuYyBiL2RyaXZlcnMvZ3B1L2RybS9yb2NrY2hpcC9y b2NrY2hpcF9kcm1fdm9wLmMKPj4gaW5kZXggYjJhMzZkYi4uYjVhMDE1YiAxMDA2NDQKPj4gLS0t IGEvZHJpdmVycy9ncHUvZHJtL3JvY2tjaGlwL3JvY2tjaGlwX2RybV92b3AuYwo+PiArKysgYi9k cml2ZXJzL2dwdS9kcm0vcm9ja2NoaXAvcm9ja2NoaXBfZHJtX3ZvcC5jCj4+IEBAIC0zNSw2ICsz NSw3IEBACj4+ICAgI2luY2x1ZGUgInJvY2tjaGlwX2RybV9nZW0uaCIKPj4gICAjaW5jbHVkZSAi cm9ja2NoaXBfZHJtX2ZiLmgiCj4+ICAgI2luY2x1ZGUgInJvY2tjaGlwX2RybV92b3AuaCIKPj4g KyNpbmNsdWRlICJyb2NrY2hpcF9kcm1fbm90aWZ5LmgiCj4+ICAgCj4+ICAgI2RlZmluZSBfX1JF R19TRVRfUkVMQVhFRCh4LCBvZmYsIG1hc2ssIHNoaWZ0LCB2LCB3cml0ZV9tYXNrKSBcCj4+ICAg CQl2b3BfbWFza193cml0ZSh4LCBvZmYsIG1hc2ssIHNoaWZ0LCB2LCB3cml0ZV9tYXNrLCB0cnVl KQo+PiBAQCAtMTE3LDYgKzExOCwxMCBAQCBzdHJ1Y3Qgdm9wIHsKPj4gICAJc3RydWN0IGNvbXBs ZXRpb24gd2FpdF91cGRhdGVfY29tcGxldGU7Cj4+ICAgCXN0cnVjdCBkcm1fcGVuZGluZ192Ymxh bmtfZXZlbnQgKmV2ZW50Owo+PiAgIAo+PiArCS8qIGVEUCBQU1IgY2FsbGJhY2sgKi8KPj4gKwlp bnQgKCpwc3JfYWN0aXZlKShlbnVtIHBzcl9hY3Rpb24gYWN0aW9uLCB2b2lkICpwcml2KTsKPj4g Kwl2b2lkICpwc3JfcHJpdjsKPj4gKwlzdHJ1Y3Qgbm90aWZpZXJfYmxvY2sgcHNyX3ByZXBhcmVf bmI7Cj4+ICAgCXN0cnVjdCBjb21wbGV0aW9uIGxpbmVfZmxhZ19jb21wbGV0aW9uOwo+PiAgIAo+ PiAgIAljb25zdCBzdHJ1Y3Qgdm9wX2RhdGEgKmRhdGE7Cj4+IEBAIC05MDYsNiArOTExLDkgQEAg c3RhdGljIGludCB2b3BfY3J0Y19lbmFibGVfdmJsYW5rKHN0cnVjdCBkcm1fY3J0YyAqY3J0YykK Pj4gICAKPj4gICAJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmdm9wLT5pcnFfbG9jaywgZmxhZ3Mp Owo+PiAgIAo+PiArCWlmICh2b3AtPnBzcl9hY3RpdmUpCj4+ICsJCXZvcC0+cHNyX2FjdGl2ZShQ U1JfSU5BQ1RJVkUsIHZvcC0+cHNyX3ByaXYpOwo+PiArCj4+ICAgCXJldHVybiAwOwo+PiAgIH0K Pj4gICAKPj4gQEAgLTkyMiw2ICs5MzAsOSBAQCBzdGF0aWMgdm9pZCB2b3BfY3J0Y19kaXNhYmxl X3ZibGFuayhzdHJ1Y3QgZHJtX2NydGMgKmNydGMpCj4+ICAgCVZPUF9JTlRSX1NFVF9UWVBFKHZv cCwgZW5hYmxlLCBGU19JTlRSLCAwKTsKPj4gICAKPj4gICAJc3Bpbl91bmxvY2tfaXJxcmVzdG9y ZSgmdm9wLT5pcnFfbG9jaywgZmxhZ3MpOwo+PiArCj4+ICsJaWYgKHZvcC0+cHNyX2FjdGl2ZSkK Pj4gKwkJdm9wLT5wc3JfYWN0aXZlKFBTUl9BQ1RJVkUsIHZvcC0+cHNyX3ByaXYpOwo+PiAgIH0K Pj4gICAKPj4gICBzdGF0aWMgdm9pZCB2b3BfY3J0Y193YWl0X2Zvcl91cGRhdGUoc3RydWN0IGRy bV9jcnRjICpjcnRjKQo+PiBAQCAtMTA2Niw2ICsxMDc3LDkgQEAgc3RhdGljIHZvaWQgdm9wX2Ny dGNfZW5hYmxlKHN0cnVjdCBkcm1fY3J0YyAqY3J0YykKPj4gICAJY2xrX3NldF9yYXRlKHZvcC0+ ZGNsaywgYWRqdXN0ZWRfbW9kZS0+Y2xvY2sgKiAxMDAwKTsKPj4gICAKPj4gICAJVk9QX0NUUkxf U0VUKHZvcCwgc3RhbmRieSwgMCk7Cj4+ICsKPj4gKwl2b3AtPnBzcl9hY3RpdmUgPSBzLT5wc3Jf YWN0aXZlOwo+PiArCXZvcC0+cHNyX3ByaXYgPSBzLT5wc3JfcHJpdjsKPj4gICB9Cj4+ICAgCj4+ ICAgc3RhdGljIHZvaWQgdm9wX2NydGNfYXRvbWljX2ZsdXNoKHN0cnVjdCBkcm1fY3J0YyAqY3J0 YywKPj4gQEAgLTExNzgsNiArMTE5MiwzMCBAQCBzdGF0aWMgdm9pZCB2b3BfaGFuZGxlX3ZibGFu ayhzdHJ1Y3Qgdm9wICp2b3ApCj4+ICAgCQljb21wbGV0ZSgmdm9wLT53YWl0X3VwZGF0ZV9jb21w bGV0ZSk7Cj4+ICAgfQo+PiAgIAo+PiArc3RhdGljIGludCBwc3JfcHJlcGFyZV9ub3RpZnkoc3Ry dWN0IG5vdGlmaWVyX2Jsb2NrICpwc3JfcHJlcGFyZV9uYiwKPj4gKwkJCSAgICAgIHVuc2lnbmVk IGxvbmcgYWN0aW9uLCB2b2lkICpkYXRhKQo+PiArewo+PiArCXN0cnVjdCB2b3AgKnZvcCA9IGNv bnRhaW5lcl9vZihwc3JfcHJlcGFyZV9uYiwgc3RydWN0IHZvcCwKPj4gKwkJCQkgICAgICAgcHNy X3ByZXBhcmVfbmIpOwo+PiArCXN0cnVjdCBkcm1fZGlzcGxheV9tb2RlICptb2RlID0gJnZvcC0+ Y3J0Yy5tb2RlOwo+PiArCWludCB2YWN0X2VuZCA9IG1vZGUtPnZ0b3RhbCAtIG1vZGUtPnZzeW5j X3N0YXJ0ICsgbW9kZS0+dmRpc3BsYXk7Cj4+ICsJdW5zaWduZWQgbG9uZyBqaWZmaWVzX2xlZnQ7 Cj4+ICsKPj4gKwlyZWluaXRfY29tcGxldGlvbigmdm9wLT5saW5lX2ZsYWdfY29tcGxldGlvbik7 Cj4+ICsJdm9wX2xpbmVfZmxhZ19pcnFfZW5hYmxlKHZvcCwgdmFjdF9lbmQpOwo+PiArCj4+ICsJ amlmZmllc19sZWZ0ID0gd2FpdF9mb3JfY29tcGxldGlvbl90aW1lb3V0KCZ2b3AtPmxpbmVfZmxh Z19jb21wbGV0aW9uLAo+PiArCQkJCQkJICAgbXNlY3NfdG9famlmZmllcygyMDApKTsKPj4gKwl2 b3BfbGluZV9mbGFnX2lycV9kaXNhYmxlKHZvcCk7Cj4+ICsKPj4gKwlpZiAoamlmZmllc19sZWZ0 ID09IDApIHsKPj4gKwkJZGV2X2Vycih2b3AtPmRldiwgIlRpbWVvdXQgd2FpdGluZyBmb3IgSVJR XG4iKTsKPj4gKwkJcmV0dXJuIE5PVElGWV9CQUQ7Cj4+ICsJfQo+PiArCj4+ICsJcmV0dXJuIE5P VElGWV9TVE9QOwo+PiArfQo+PiArCj4+ICAgc3RhdGljIGlycXJldHVybl90IHZvcF9pc3IoaW50 IGlycSwgdm9pZCAqZGF0YSkKPj4gICB7Cj4+ICAgCXN0cnVjdCB2b3AgKnZvcCA9IGRhdGE7Cj4+ IEBAIC0xMzEyLDYgKzEzNTAsOSBAQCBzdGF0aWMgaW50IHZvcF9jcmVhdGVfY3J0YyhzdHJ1Y3Qg dm9wICp2b3ApCj4+ICAgCQlnb3RvIGVycl9jbGVhbnVwX2NydGM7Cj4+ICAgCX0KPj4gICAKPj4g Kwl2b3AtPnBzcl9wcmVwYXJlX25iLm5vdGlmaWVyX2NhbGwgPSBwc3JfcHJlcGFyZV9ub3RpZnk7 Cj4+ICsJcm9ja2NoaXBfZHJtX3Bzcl9yZWFkeV9yZWdpc3Rlcl9ub3RpZmllcigmdm9wLT5wc3Jf cHJlcGFyZV9uYik7Cj4+ICsKPj4gICAJaW5pdF9jb21wbGV0aW9uKCZ2b3AtPmRzcF9ob2xkX2Nv bXBsZXRpb24pOwo+PiAgIAlpbml0X2NvbXBsZXRpb24oJnZvcC0+d2FpdF91cGRhdGVfY29tcGxl dGUpOwo+PiAgIAlpbml0X2NvbXBsZXRpb24oJnZvcC0+bGluZV9mbGFnX2NvbXBsZXRpb24pOwo+ PiAtLSAKPj4gMS45LjEKPj4KPj4KPj4gX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX18KPj4gZHJpLWRldmVsIG1haWxpbmcgbGlzdAo+PiBkcmktZGV2ZWxAbGlz dHMuZnJlZWRlc2t0b3Aub3JnCj4+IGh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxt YW4vbGlzdGluZm8vZHJpLWRldmVsCgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJl ZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGlu Zm8vZHJpLWRldmVsCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1161030AbcFBNiP (ORCPT ); Thu, 2 Jun 2016 09:38:15 -0400 Received: from lucky1.263xmail.com ([211.157.147.134]:49512 "EHLO lucky1.263xmail.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753230AbcFBNiL (ORCPT ); Thu, 2 Jun 2016 09:38:11 -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: treding@nvidia.com X-SENDER-IP: 103.29.142.67 X-LOGIN-NAME: ykk@rock-chips.com X-UNIQUE-TAG: X-ATTACHMENT-NUM: 0 X-DNS-TYPE: 0 Subject: Re: [RFC PATCH v2 3/3] drm/rockchip: analogix_dp: add PSR support References: <1464872228-18292-1-git-send-email-ykk@rock-chips.com> <1464872258-18468-1-git-send-email-ykk@rock-chips.com> <20160602131847.GG7231@phenom.ffwll.local> From: Yakir Yang Cc: Mark Yao , Heiko Stuebner , tfiga@chromium.org, dianders@chromium.org, dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org, linux-rockchip@lists.infradead.org, Thierry Reding To: Daniel Vetter Message-ID: <575036B3.9070505@rock-chips.com> Date: Thu, 2 Jun 2016 21:37:55 +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: <20160602131847.GG7231@phenom.ffwll.local> 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 Daniel, Thanks for your fast respond. On 06/02/2016 09:18 PM, Daniel Vetter wrote: > On Thu, Jun 02, 2016 at 08:57:38PM +0800, Yakir Yang wrote: >> Let VOP vblank status decide whether panle should enter into or >> exit from PSR status. Before eDP start to change PSR status, it >> need to wait for VOP vact_end event. In order to listen vact_end >> event, I create a new file about PSR notify between eDP and VOP. >> >> Signed-off-by: Yakir Yang >> --- >> Changes in v2: >> - Remove vblank notify out (Daniel) >> - Create a psr_active() callback in vop data struct. > Still contains a notifier. Still doesn't contain a proper fb->dirty > callback. Please don't just act on review without understanding the deeper > implications, since I didn't ask you to remove the vblank logic (you > probably still need that), I suggested to implement it differently > (withotu notifiers). > -Daniel Yes, I misunderstand what you comment before, I thought only the vblank notify is bad, so i create a callback entry in vop. But the vact_end event is still an evil too, specific to a given crtc. Hmmm, after i abandon the notify, i need to found a good way for eDP to get the vact_end or vblank event. That would be a question, have no idea now..... As for why i ignore the the fb->dirty callback in this case, please see my previous reply to you. Thanks, - Yakir >> drivers/gpu/drm/rockchip/Makefile | 2 +- >> drivers/gpu/drm/rockchip/analogix_dp-rockchip.c | 64 ++++++++++++++++++++++++- >> drivers/gpu/drm/rockchip/rockchip_drm_drv.h | 7 +++ >> drivers/gpu/drm/rockchip/rockchip_drm_notify.c | 54 +++++++++++++++++++++ >> drivers/gpu/drm/rockchip/rockchip_drm_notify.h | 23 +++++++++ >> drivers/gpu/drm/rockchip/rockchip_drm_vop.c | 41 ++++++++++++++++ >> 6 files changed, 189 insertions(+), 2 deletions(-) >> create mode 100644 drivers/gpu/drm/rockchip/rockchip_drm_notify.c >> create mode 100644 drivers/gpu/drm/rockchip/rockchip_drm_notify.h >> >> diff --git a/drivers/gpu/drm/rockchip/Makefile b/drivers/gpu/drm/rockchip/Makefile >> index 05d0713..49fee8c 100644 >> --- a/drivers/gpu/drm/rockchip/Makefile >> +++ b/drivers/gpu/drm/rockchip/Makefile >> @@ -3,7 +3,7 @@ >> # Direct Rendering Infrastructure (DRI) in XFree86 4.1.0 and higher. >> >> rockchipdrm-y := rockchip_drm_drv.o rockchip_drm_fb.o \ >> - rockchip_drm_gem.o rockchip_drm_vop.o >> + rockchip_drm_gem.o rockchip_drm_vop.o rockchip_drm_notify.o >> rockchipdrm-$(CONFIG_DRM_FBDEV_EMULATION) += rockchip_drm_fbdev.o >> >> obj-$(CONFIG_ROCKCHIP_ANALOGIX_DP) += analogix_dp-rockchip.o >> diff --git a/drivers/gpu/drm/rockchip/analogix_dp-rockchip.c b/drivers/gpu/drm/rockchip/analogix_dp-rockchip.c >> index 4b64964..25fb687 100644 >> --- a/drivers/gpu/drm/rockchip/analogix_dp-rockchip.c >> +++ b/drivers/gpu/drm/rockchip/analogix_dp-rockchip.c >> @@ -33,6 +33,7 @@ >> >> #include "rockchip_drm_drv.h" >> #include "rockchip_drm_vop.h" >> +#include "rockchip_drm_notify.h" >> >> #define to_dp(nm) container_of(nm, struct rockchip_dp_device, nm) >> >> @@ -54,6 +55,10 @@ struct rockchip_dp_device { >> struct regmap *grf; >> struct reset_control *rst; >> >> + struct workqueue_struct *dp_workq; >> + struct work_struct psr_work; >> + unsigned int psr_state; >> + >> const struct rockchip_dp_chip_data *data; >> >> struct analogix_dp_plat_data plat_data; >> @@ -97,6 +102,42 @@ static int rockchip_dp_powerdown(struct analogix_dp_plat_data *plat_data) >> return 0; >> } >> >> +static int rockchip_dp_psr_active(enum psr_action action, void *priv) >> +{ >> + struct rockchip_dp_device *dp = (struct rockchip_dp_device *)priv; >> + >> + switch (action) { >> + case PSR_INACTIVE: >> + dp->psr_state = 0; >> + break; >> + case PSR_ACTIVE: >> + dp->psr_state = EDP_VSC_PSR_STATE_ACTIVE; >> + break; >> + default: >> + return 0; >> + } >> + >> + queue_work(dp->dp_workq, &dp->psr_work); >> + return 0; >> +} >> + >> +static void dp_psr_work(struct work_struct *psr_work) >> +{ >> + struct rockchip_dp_device *dp = to_dp(psr_work); >> + int psr_state = dp->psr_state; >> + int ret; >> + >> + if (psr_state == EDP_VSC_PSR_STATE_ACTIVE) { >> + ret = rockchip_psr_ready_wait(); >> + if (ret == 0) >> + analogix_dp_actice_psr(dp->dev); >> + } else { >> + ret = rockchip_psr_ready_wait(); >> + if (ret == 0) >> + analogix_dp_inactice_psr(dp->dev); >> + } >> +} >> + >> static enum drm_mode_status >> rockchip_dp_mode_valid(struct analogix_dp_plat_data *plat_data, >> struct drm_connector *connector, >> @@ -128,9 +169,18 @@ static void rockchip_dp_drm_encoder_mode_set(struct drm_encoder *encoder, >> struct drm_display_mode *mode, >> struct drm_display_mode *adjusted) >> { >> - /* do nothing */ >> + struct rockchip_dp_device *dp = to_dp(encoder); >> + struct drm_crtc *crtc = encoder->crtc; >> + struct rockchip_crtc_state *s; >> + >> + if (crtc) { >> + s = to_rockchip_crtc_state(crtc->state); >> + s->psr_active = rockchip_dp_psr_active; >> + s->psr_priv = dp; >> + } >> } >> >> + >> static void rockchip_dp_drm_encoder_enable(struct drm_encoder *encoder) >> { >> struct rockchip_dp_device *dp = to_dp(encoder); >> @@ -198,6 +248,9 @@ rockchip_dp_drm_encoder_atomic_check(struct drm_encoder *encoder, >> break; >> } >> >> + s->psr_active = rockchip_dp_psr_active; >> + s->psr_priv = dp; >> + >> return 0; >> } >> >> @@ -320,6 +373,15 @@ static int rockchip_dp_bind(struct device *dev, struct device *master, >> dp->plat_data.power_off = rockchip_dp_powerdown; >> dp->plat_data.mode_valid = rockchip_dp_mode_valid; >> >> + dp->dp_workq = create_singlethread_workqueue("dp"); >> + if (!dp->dp_workq) { >> + dev_err(dp->dev, "failed to create workqueue\n"); >> + return PTR_ERR(dp->dp_workq); >> + } >> + >> + dp->psr_state = 0; >> + INIT_WORK(&dp->psr_work, dp_psr_work); >> + >> return analogix_dp_bind(dev, dp->drm_dev, &dp->plat_data); >> } >> >> diff --git a/drivers/gpu/drm/rockchip/rockchip_drm_drv.h b/drivers/gpu/drm/rockchip/rockchip_drm_drv.h >> index 56f43a3..f1ccc10 100644 >> --- a/drivers/gpu/drm/rockchip/rockchip_drm_drv.h >> +++ b/drivers/gpu/drm/rockchip/rockchip_drm_drv.h >> @@ -31,6 +31,11 @@ >> struct drm_device; >> struct drm_connector; >> >> +enum psr_action { >> + PSR_ACTIVE = 0, >> + PSR_INACTIVE, >> +}; >> + >> /* >> * Rockchip drm private crtc funcs. >> * @enable_vblank: enable crtc vblank irq. >> @@ -54,6 +59,8 @@ struct rockchip_crtc_state { >> struct drm_crtc_state base; >> int output_type; >> int output_mode; >> + int (*psr_active)(enum psr_action action, void *priv); >> + void *psr_priv; >> }; >> #define to_rockchip_crtc_state(s) \ >> container_of(s, struct rockchip_crtc_state, base) >> diff --git a/drivers/gpu/drm/rockchip/rockchip_drm_notify.c b/drivers/gpu/drm/rockchip/rockchip_drm_notify.c >> new file mode 100644 >> index 0000000..908e991 >> --- /dev/null >> +++ b/drivers/gpu/drm/rockchip/rockchip_drm_notify.c >> @@ -0,0 +1,54 @@ >> +/* >> + * Copyright (C) Fuzhou Rockchip Electronics Co.Ltd >> + * Author: Yakir Yang >> + * >> + * 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 "rockchip_drm_notify.h" >> + >> +static RAW_NOTIFIER_HEAD(psr_ready_chain); >> +static DEFINE_MUTEX(psr_ready_lock); >> + >> +int rockchip_drm_psr_ready_register_notifier(struct notifier_block *nb) >> +{ >> + int ret = 0; >> + >> + if (!nb) >> + return -EINVAL; >> + >> + ret = raw_notifier_chain_register(&psr_ready_chain, nb); >> + return ret; >> +} >> +EXPORT_SYMBOL_GPL(rockchip_drm_psr_ready_register_notifier); >> + >> +int rockchip_drm_psr_ready_unregister_notifier(struct notifier_block *nb) >> +{ >> + int ret = 0; >> + >> + if (!nb) >> + return -EINVAL; >> + >> + ret = raw_notifier_chain_unregister(&psr_ready_chain, nb); >> + return ret; >> +} >> +EXPORT_SYMBOL_GPL(rockchip_drm_psr_ready_unregister_notifier); >> + >> +int rockchip_psr_ready_wait(void) >> +{ >> + int ret; >> + >> + ret = raw_notifier_call_chain(&psr_ready_chain, 0, 0); >> + if (ret == NOTIFY_BAD) >> + return -ETIMEDOUT; >> + >> + return 0; >> +} >> +EXPORT_SYMBOL_GPL(rockchip_psr_ready_wait); >> diff --git a/drivers/gpu/drm/rockchip/rockchip_drm_notify.h b/drivers/gpu/drm/rockchip/rockchip_drm_notify.h >> new file mode 100644 >> index 0000000..1b190e5 >> --- /dev/null >> +++ b/drivers/gpu/drm/rockchip/rockchip_drm_notify.h >> @@ -0,0 +1,23 @@ >> +/* >> + * Copyright (C) 2014 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. >> + */ >> + >> +#ifndef __ROCKCHIP_DRM_NOTIFY_H >> +#define __ROCKCHIP_DRM_NOTIFY_H >> + >> +#include >> + >> +int rockchip_psr_ready_wait(void); >> +int rockchip_drm_psr_ready_register_notifier(struct notifier_block *nb); >> +int rockchip_drm_psr_ready_unregister_notifier(struct notifier_block *nb); >> + >> +#endif /* __ROCKCHIP_DRM_NOTIFY_H */ >> diff --git a/drivers/gpu/drm/rockchip/rockchip_drm_vop.c b/drivers/gpu/drm/rockchip/rockchip_drm_vop.c >> index b2a36db..b5a015b 100644 >> --- a/drivers/gpu/drm/rockchip/rockchip_drm_vop.c >> +++ b/drivers/gpu/drm/rockchip/rockchip_drm_vop.c >> @@ -35,6 +35,7 @@ >> #include "rockchip_drm_gem.h" >> #include "rockchip_drm_fb.h" >> #include "rockchip_drm_vop.h" >> +#include "rockchip_drm_notify.h" >> >> #define __REG_SET_RELAXED(x, off, mask, shift, v, write_mask) \ >> vop_mask_write(x, off, mask, shift, v, write_mask, true) >> @@ -117,6 +118,10 @@ struct vop { >> struct completion wait_update_complete; >> struct drm_pending_vblank_event *event; >> >> + /* eDP PSR callback */ >> + int (*psr_active)(enum psr_action action, void *priv); >> + void *psr_priv; >> + struct notifier_block psr_prepare_nb; >> struct completion line_flag_completion; >> >> const struct vop_data *data; >> @@ -906,6 +911,9 @@ static int vop_crtc_enable_vblank(struct drm_crtc *crtc) >> >> spin_unlock_irqrestore(&vop->irq_lock, flags); >> >> + if (vop->psr_active) >> + vop->psr_active(PSR_INACTIVE, vop->psr_priv); >> + >> return 0; >> } >> >> @@ -922,6 +930,9 @@ static void vop_crtc_disable_vblank(struct drm_crtc *crtc) >> VOP_INTR_SET_TYPE(vop, enable, FS_INTR, 0); >> >> spin_unlock_irqrestore(&vop->irq_lock, flags); >> + >> + if (vop->psr_active) >> + vop->psr_active(PSR_ACTIVE, vop->psr_priv); >> } >> >> static void vop_crtc_wait_for_update(struct drm_crtc *crtc) >> @@ -1066,6 +1077,9 @@ static void vop_crtc_enable(struct drm_crtc *crtc) >> clk_set_rate(vop->dclk, adjusted_mode->clock * 1000); >> >> VOP_CTRL_SET(vop, standby, 0); >> + >> + vop->psr_active = s->psr_active; >> + vop->psr_priv = s->psr_priv; >> } >> >> static void vop_crtc_atomic_flush(struct drm_crtc *crtc, >> @@ -1178,6 +1192,30 @@ static void vop_handle_vblank(struct vop *vop) >> complete(&vop->wait_update_complete); >> } >> >> +static int psr_prepare_notify(struct notifier_block *psr_prepare_nb, >> + unsigned long action, void *data) >> +{ >> + struct vop *vop = container_of(psr_prepare_nb, struct vop, >> + psr_prepare_nb); >> + struct drm_display_mode *mode = &vop->crtc.mode; >> + int vact_end = mode->vtotal - mode->vsync_start + mode->vdisplay; >> + unsigned long jiffies_left; >> + >> + reinit_completion(&vop->line_flag_completion); >> + vop_line_flag_irq_enable(vop, vact_end); >> + >> + jiffies_left = wait_for_completion_timeout(&vop->line_flag_completion, >> + msecs_to_jiffies(200)); >> + vop_line_flag_irq_disable(vop); >> + >> + if (jiffies_left == 0) { >> + dev_err(vop->dev, "Timeout waiting for IRQ\n"); >> + return NOTIFY_BAD; >> + } >> + >> + return NOTIFY_STOP; >> +} >> + >> static irqreturn_t vop_isr(int irq, void *data) >> { >> struct vop *vop = data; >> @@ -1312,6 +1350,9 @@ static int vop_create_crtc(struct vop *vop) >> goto err_cleanup_crtc; >> } >> >> + vop->psr_prepare_nb.notifier_call = psr_prepare_notify; >> + rockchip_drm_psr_ready_register_notifier(&vop->psr_prepare_nb); >> + >> init_completion(&vop->dsp_hold_completion); >> init_completion(&vop->wait_update_complete); >> init_completion(&vop->line_flag_completion); >> -- >> 1.9.1 >> >> >> _______________________________________________ >> dri-devel mailing list >> dri-devel@lists.freedesktop.org >> https://lists.freedesktop.org/mailman/listinfo/dri-devel