From mboxrd@z Thu Jan 1 00:00:00 1970 From: Daniel Vetter Subject: Re: [RFC PATCH v2 3/3] drm/rockchip: analogix_dp: add PSR support Date: Thu, 2 Jun 2016 15:18:47 +0200 Message-ID: <20160602131847.GG7231@phenom.ffwll.local> References: <1464872228-18292-1-git-send-email-ykk@rock-chips.com> <1464872258-18468-1-git-send-email-ykk@rock-chips.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Content-Disposition: inline In-Reply-To: <1464872258-18468-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: Yakir Yang Cc: Mark Yao , daniel.vetter@ffwll.ch, dianders@chromium.org, dri-devel@lists.freedesktop.org, tfiga@chromium.org, linux-rockchip@lists.infradead.org, Thierry Reding , linux-kernel@vger.kernel.org List-Id: linux-rockchip.vger.kernel.org T24gVGh1LCBKdW4gMDIsIDIwMTYgYXQgMDg6NTc6MzhQTSArMDgwMCwgWWFraXIgWWFuZyB3cm90 ZToKPiBMZXQgVk9QIHZibGFuayBzdGF0dXMgZGVjaWRlIHdoZXRoZXIgcGFubGUgc2hvdWxkIGVu dGVyIGludG8gb3IKPiBleGl0IGZyb20gUFNSIHN0YXR1cy4gQmVmb3JlIGVEUCBzdGFydCB0byBj aGFuZ2UgUFNSIHN0YXR1cywgaXQKPiBuZWVkIHRvIHdhaXQgZm9yIFZPUCB2YWN0X2VuZCBldmVu dC4gSW4gb3JkZXIgdG8gbGlzdGVuIHZhY3RfZW5kCj4gZXZlbnQsIEkgY3JlYXRlIGEgbmV3IGZp bGUgYWJvdXQgUFNSIG5vdGlmeSBiZXR3ZWVuIGVEUCBhbmQgVk9QLgo+IAo+IFNpZ25lZC1vZmYt Ynk6IFlha2lyIFlhbmcgPHlra0Byb2NrLWNoaXBzLmNvbT4KPiAtLS0KPiBDaGFuZ2VzIGluIHYy Ogo+IC0gUmVtb3ZlIHZibGFuayBub3RpZnkgb3V0IChEYW5pZWwpCj4gLSBDcmVhdGUgYSBwc3Jf YWN0aXZlKCkgY2FsbGJhY2sgaW4gdm9wIGRhdGEgc3RydWN0LgoKU3RpbGwgY29udGFpbnMgYSBu b3RpZmllci4gU3RpbGwgZG9lc24ndCBjb250YWluIGEgcHJvcGVyIGZiLT5kaXJ0eQpjYWxsYmFj ay4gUGxlYXNlIGRvbid0IGp1c3QgYWN0IG9uIHJldmlldyB3aXRob3V0IHVuZGVyc3RhbmRpbmcg dGhlIGRlZXBlcgppbXBsaWNhdGlvbnMsIHNpbmNlIEkgZGlkbid0IGFzayB5b3UgdG8gcmVtb3Zl IHRoZSB2YmxhbmsgbG9naWMgKHlvdQpwcm9iYWJseSBzdGlsbCBuZWVkIHRoYXQpLCBJIHN1Z2dl c3RlZCB0byBpbXBsZW1lbnQgaXQgZGlmZmVyZW50bHkKKHdpdGhvdHUgbm90aWZpZXJzKS4KLURh bmllbAoKPiAKPiAgZHJpdmVycy9ncHUvZHJtL3JvY2tjaGlwL01ha2VmaWxlICAgICAgICAgICAg ICAgfCAgMiArLQo+ICBkcml2ZXJzL2dwdS9kcm0vcm9ja2NoaXAvYW5hbG9naXhfZHAtcm9ja2No aXAuYyB8IDY0ICsrKysrKysrKysrKysrKysrKysrKysrKy0KPiAgZHJpdmVycy9ncHUvZHJtL3Jv Y2tjaGlwL3JvY2tjaGlwX2RybV9kcnYuaCAgICAgfCAgNyArKysKPiAgZHJpdmVycy9ncHUvZHJt L3JvY2tjaGlwL3JvY2tjaGlwX2RybV9ub3RpZnkuYyAgfCA1NCArKysrKysrKysrKysrKysrKysr KysKPiAgZHJpdmVycy9ncHUvZHJtL3JvY2tjaGlwL3JvY2tjaGlwX2RybV9ub3RpZnkuaCAgfCAy MyArKysrKysrKysKPiAgZHJpdmVycy9ncHUvZHJtL3JvY2tjaGlwL3JvY2tjaGlwX2RybV92b3Au YyAgICAgfCA0MSArKysrKysrKysrKysrKysrCj4gIDYgZmlsZXMgY2hhbmdlZCwgMTg5IGluc2Vy dGlvbnMoKyksIDIgZGVsZXRpb25zKC0pCj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2dw dS9kcm0vcm9ja2NoaXAvcm9ja2NoaXBfZHJtX25vdGlmeS5jCj4gIGNyZWF0ZSBtb2RlIDEwMDY0 NCBkcml2ZXJzL2dwdS9kcm0vcm9ja2NoaXAvcm9ja2NoaXBfZHJtX25vdGlmeS5oCj4gCj4gZGlm ZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9yb2NrY2hpcC9NYWtlZmlsZSBiL2RyaXZlcnMvZ3B1 L2RybS9yb2NrY2hpcC9NYWtlZmlsZQo+IGluZGV4IDA1ZDA3MTMuLjQ5ZmVlOGMgMTAwNjQ0Cj4g LS0tIGEvZHJpdmVycy9ncHUvZHJtL3JvY2tjaGlwL01ha2VmaWxlCj4gKysrIGIvZHJpdmVycy9n cHUvZHJtL3JvY2tjaGlwL01ha2VmaWxlCj4gQEAgLTMsNyArMyw3IEBACj4gICMgRGlyZWN0IFJl bmRlcmluZyBJbmZyYXN0cnVjdHVyZSAoRFJJKSBpbiBYRnJlZTg2IDQuMS4wIGFuZCBoaWdoZXIu Cj4gIAo+ICByb2NrY2hpcGRybS15IDo9IHJvY2tjaGlwX2RybV9kcnYubyByb2NrY2hpcF9kcm1f ZmIubyBcCj4gLQkJcm9ja2NoaXBfZHJtX2dlbS5vIHJvY2tjaGlwX2RybV92b3Aubwo+ICsJCXJv Y2tjaGlwX2RybV9nZW0ubyByb2NrY2hpcF9kcm1fdm9wLm8gcm9ja2NoaXBfZHJtX25vdGlmeS5v Cj4gIHJvY2tjaGlwZHJtLSQoQ09ORklHX0RSTV9GQkRFVl9FTVVMQVRJT04pICs9IHJvY2tjaGlw X2RybV9mYmRldi5vCj4gIAo+ICBvYmotJChDT05GSUdfUk9DS0NISVBfQU5BTE9HSVhfRFApICs9 IGFuYWxvZ2l4X2RwLXJvY2tjaGlwLm8KPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3Jv Y2tjaGlwL2FuYWxvZ2l4X2RwLXJvY2tjaGlwLmMgYi9kcml2ZXJzL2dwdS9kcm0vcm9ja2NoaXAv YW5hbG9naXhfZHAtcm9ja2NoaXAuYwo+IGluZGV4IDRiNjQ5NjQuLjI1ZmI2ODcgMTAwNjQ0Cj4g LS0tIGEvZHJpdmVycy9ncHUvZHJtL3JvY2tjaGlwL2FuYWxvZ2l4X2RwLXJvY2tjaGlwLmMKPiAr KysgYi9kcml2ZXJzL2dwdS9kcm0vcm9ja2NoaXAvYW5hbG9naXhfZHAtcm9ja2NoaXAuYwo+IEBA IC0zMyw2ICszMyw3IEBACj4gIAo+ICAjaW5jbHVkZSAicm9ja2NoaXBfZHJtX2Rydi5oIgo+ICAj aW5jbHVkZSAicm9ja2NoaXBfZHJtX3ZvcC5oIgo+ICsjaW5jbHVkZSAicm9ja2NoaXBfZHJtX25v dGlmeS5oIgo+ICAKPiAgI2RlZmluZSB0b19kcChubSkJY29udGFpbmVyX29mKG5tLCBzdHJ1Y3Qg cm9ja2NoaXBfZHBfZGV2aWNlLCBubSkKPiAgCj4gQEAgLTU0LDYgKzU1LDEwIEBAIHN0cnVjdCBy b2NrY2hpcF9kcF9kZXZpY2Ugewo+ICAJc3RydWN0IHJlZ21hcCAgICAgICAgICAgICpncmY7Cj4g IAlzdHJ1Y3QgcmVzZXRfY29udHJvbCAgICAgKnJzdDsKPiAgCj4gKwlzdHJ1Y3Qgd29ya3F1ZXVl X3N0cnVjdAkgKmRwX3dvcmtxOwo+ICsJc3RydWN0IHdvcmtfc3RydWN0CSBwc3Jfd29yazsKPiAr CXVuc2lnbmVkIGludAkJIHBzcl9zdGF0ZTsKPiArCj4gIAljb25zdCBzdHJ1Y3Qgcm9ja2NoaXBf ZHBfY2hpcF9kYXRhICpkYXRhOwo+ICAKPiAgCXN0cnVjdCBhbmFsb2dpeF9kcF9wbGF0X2RhdGEg cGxhdF9kYXRhOwo+IEBAIC05Nyw2ICsxMDIsNDIgQEAgc3RhdGljIGludCByb2NrY2hpcF9kcF9w b3dlcmRvd24oc3RydWN0IGFuYWxvZ2l4X2RwX3BsYXRfZGF0YSAqcGxhdF9kYXRhKQo+ICAJcmV0 dXJuIDA7Cj4gIH0KPiAgCj4gK3N0YXRpYyBpbnQgcm9ja2NoaXBfZHBfcHNyX2FjdGl2ZShlbnVt IHBzcl9hY3Rpb24gYWN0aW9uLCB2b2lkICpwcml2KQo+ICt7Cj4gKwlzdHJ1Y3Qgcm9ja2NoaXBf ZHBfZGV2aWNlICpkcCA9IChzdHJ1Y3Qgcm9ja2NoaXBfZHBfZGV2aWNlICopcHJpdjsKPiArCj4g Kwlzd2l0Y2ggKGFjdGlvbikgewo+ICsJY2FzZSBQU1JfSU5BQ1RJVkU6Cj4gKwkJZHAtPnBzcl9z dGF0ZSA9IDA7Cj4gKwkJYnJlYWs7Cj4gKwljYXNlIFBTUl9BQ1RJVkU6Cj4gKwkJZHAtPnBzcl9z dGF0ZSA9IEVEUF9WU0NfUFNSX1NUQVRFX0FDVElWRTsKPiArCQlicmVhazsKPiArCWRlZmF1bHQ6 Cj4gKwkJcmV0dXJuIDA7Cj4gKwl9Cj4gKwo+ICsJcXVldWVfd29yayhkcC0+ZHBfd29ya3EsICZk cC0+cHNyX3dvcmspOwo+ICsJcmV0dXJuIDA7Cj4gK30KPiArCj4gK3N0YXRpYyB2b2lkIGRwX3Bz cl93b3JrKHN0cnVjdCB3b3JrX3N0cnVjdCAqcHNyX3dvcmspCj4gK3sKPiArCXN0cnVjdCByb2Nr Y2hpcF9kcF9kZXZpY2UgKmRwID0gdG9fZHAocHNyX3dvcmspOwo+ICsJaW50IHBzcl9zdGF0ZSA9 IGRwLT5wc3Jfc3RhdGU7Cj4gKwlpbnQgcmV0Owo+ICsKPiArCWlmIChwc3Jfc3RhdGUgPT0gRURQ X1ZTQ19QU1JfU1RBVEVfQUNUSVZFKSB7Cj4gKwkJcmV0ID0gcm9ja2NoaXBfcHNyX3JlYWR5X3dh aXQoKTsKPiArCQlpZiAocmV0ID09IDApCj4gKwkJCWFuYWxvZ2l4X2RwX2FjdGljZV9wc3IoZHAt PmRldik7Cj4gKwl9IGVsc2Ugewo+ICsJCXJldCA9IHJvY2tjaGlwX3Bzcl9yZWFkeV93YWl0KCk7 Cj4gKwkJaWYgKHJldCA9PSAwKQo+ICsJCQlhbmFsb2dpeF9kcF9pbmFjdGljZV9wc3IoZHAtPmRl dik7Cj4gKwl9Cj4gK30KPiArCj4gIHN0YXRpYyBlbnVtIGRybV9tb2RlX3N0YXR1cwo+ICByb2Nr Y2hpcF9kcF9tb2RlX3ZhbGlkKHN0cnVjdCBhbmFsb2dpeF9kcF9wbGF0X2RhdGEgKnBsYXRfZGF0 YSwKPiAgCQkgICAgICAgc3RydWN0IGRybV9jb25uZWN0b3IgKmNvbm5lY3RvciwKPiBAQCAtMTI4 LDkgKzE2OSwxOCBAQCBzdGF0aWMgdm9pZCByb2NrY2hpcF9kcF9kcm1fZW5jb2Rlcl9tb2RlX3Nl dChzdHJ1Y3QgZHJtX2VuY29kZXIgKmVuY29kZXIsCj4gIAkJCQkJICAgICBzdHJ1Y3QgZHJtX2Rp c3BsYXlfbW9kZSAqbW9kZSwKPiAgCQkJCQkgICAgIHN0cnVjdCBkcm1fZGlzcGxheV9tb2RlICph ZGp1c3RlZCkKPiAgewo+IC0JLyogZG8gbm90aGluZyAqLwo+ICsJc3RydWN0IHJvY2tjaGlwX2Rw X2RldmljZSAqZHAgPSB0b19kcChlbmNvZGVyKTsKPiArCXN0cnVjdCBkcm1fY3J0YyAqY3J0YyA9 IGVuY29kZXItPmNydGM7Cj4gKwlzdHJ1Y3Qgcm9ja2NoaXBfY3J0Y19zdGF0ZSAqczsKPiArCj4g KwlpZiAoY3J0Yykgewo+ICsJCXMgPSB0b19yb2NrY2hpcF9jcnRjX3N0YXRlKGNydGMtPnN0YXRl KTsKPiArCQlzLT5wc3JfYWN0aXZlID0gcm9ja2NoaXBfZHBfcHNyX2FjdGl2ZTsKPiArCQlzLT5w c3JfcHJpdiA9IGRwOwo+ICsJfQo+ICB9Cj4gIAo+ICsKPiAgc3RhdGljIHZvaWQgcm9ja2NoaXBf ZHBfZHJtX2VuY29kZXJfZW5hYmxlKHN0cnVjdCBkcm1fZW5jb2RlciAqZW5jb2RlcikKPiAgewo+ ICAJc3RydWN0IHJvY2tjaGlwX2RwX2RldmljZSAqZHAgPSB0b19kcChlbmNvZGVyKTsKPiBAQCAt MTk4LDYgKzI0OCw5IEBAIHJvY2tjaGlwX2RwX2RybV9lbmNvZGVyX2F0b21pY19jaGVjayhzdHJ1 Y3QgZHJtX2VuY29kZXIgKmVuY29kZXIsCj4gIAkJYnJlYWs7Cj4gIAl9Cj4gIAo+ICsJcy0+cHNy X2FjdGl2ZSA9IHJvY2tjaGlwX2RwX3Bzcl9hY3RpdmU7Cj4gKwlzLT5wc3JfcHJpdiA9IGRwOwo+ ICsKPiAgCXJldHVybiAwOwo+ICB9Cj4gIAo+IEBAIC0zMjAsNiArMzczLDE1IEBAIHN0YXRpYyBp bnQgcm9ja2NoaXBfZHBfYmluZChzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2UgKm1h c3RlciwKPiAgCWRwLT5wbGF0X2RhdGEucG93ZXJfb2ZmID0gcm9ja2NoaXBfZHBfcG93ZXJkb3du Owo+ICAJZHAtPnBsYXRfZGF0YS5tb2RlX3ZhbGlkID0gcm9ja2NoaXBfZHBfbW9kZV92YWxpZDsK PiAgCj4gKwlkcC0+ZHBfd29ya3EgPSBjcmVhdGVfc2luZ2xldGhyZWFkX3dvcmtxdWV1ZSgiZHAi KTsKPiArCWlmICghZHAtPmRwX3dvcmtxKSB7Cj4gKwkJZGV2X2VycihkcC0+ZGV2LCAiZmFpbGVk IHRvIGNyZWF0ZSB3b3JrcXVldWVcbiIpOwo+ICsJCXJldHVybiBQVFJfRVJSKGRwLT5kcF93b3Jr cSk7Cj4gKwl9Cj4gKwo+ICsJZHAtPnBzcl9zdGF0ZSA9IDA7Cj4gKwlJTklUX1dPUksoJmRwLT5w c3Jfd29yaywgZHBfcHNyX3dvcmspOwo+ICsKPiAgCXJldHVybiBhbmFsb2dpeF9kcF9iaW5kKGRl diwgZHAtPmRybV9kZXYsICZkcC0+cGxhdF9kYXRhKTsKPiAgfQo+ICAKPiBkaWZmIC0tZ2l0IGEv ZHJpdmVycy9ncHUvZHJtL3JvY2tjaGlwL3JvY2tjaGlwX2RybV9kcnYuaCBiL2RyaXZlcnMvZ3B1 L2RybS9yb2NrY2hpcC9yb2NrY2hpcF9kcm1fZHJ2LmgKPiBpbmRleCA1NmY0M2EzLi5mMWNjYzEw IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9yb2NrY2hpcC9yb2NrY2hpcF9kcm1fZHJ2 LmgKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vcm9ja2NoaXAvcm9ja2NoaXBfZHJtX2Rydi5oCj4g QEAgLTMxLDYgKzMxLDExIEBACj4gIHN0cnVjdCBkcm1fZGV2aWNlOwo+ICBzdHJ1Y3QgZHJtX2Nv bm5lY3RvcjsKPiAgCj4gK2VudW0gcHNyX2FjdGlvbiB7Cj4gKwlQU1JfQUNUSVZFID0gMCwKPiAr CVBTUl9JTkFDVElWRSwKPiArfTsKPiArCj4gIC8qCj4gICAqIFJvY2tjaGlwIGRybSBwcml2YXRl IGNydGMgZnVuY3MuCj4gICAqIEBlbmFibGVfdmJsYW5rOiBlbmFibGUgY3J0YyB2YmxhbmsgaXJx Lgo+IEBAIC01NCw2ICs1OSw4IEBAIHN0cnVjdCByb2NrY2hpcF9jcnRjX3N0YXRlIHsKPiAgCXN0 cnVjdCBkcm1fY3J0Y19zdGF0ZSBiYXNlOwo+ICAJaW50IG91dHB1dF90eXBlOwo+ICAJaW50IG91 dHB1dF9tb2RlOwo+ICsJaW50ICgqcHNyX2FjdGl2ZSkoZW51bSBwc3JfYWN0aW9uIGFjdGlvbiwg dm9pZCAqcHJpdik7Cj4gKwl2b2lkICpwc3JfcHJpdjsKPiAgfTsKPiAgI2RlZmluZSB0b19yb2Nr Y2hpcF9jcnRjX3N0YXRlKHMpIFwKPiAgCQljb250YWluZXJfb2Yocywgc3RydWN0IHJvY2tjaGlw X2NydGNfc3RhdGUsIGJhc2UpCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9yb2NrY2hp cC9yb2NrY2hpcF9kcm1fbm90aWZ5LmMgYi9kcml2ZXJzL2dwdS9kcm0vcm9ja2NoaXAvcm9ja2No aXBfZHJtX25vdGlmeS5jCj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPiBpbmRleCAwMDAwMDAwLi45 MDhlOTkxCj4gLS0tIC9kZXYvbnVsbAo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9yb2NrY2hpcC9y b2NrY2hpcF9kcm1fbm90aWZ5LmMKPiBAQCAtMCwwICsxLDU0IEBACj4gKy8qCj4gKyAqIENvcHly aWdodCAoQykgRnV6aG91IFJvY2tjaGlwIEVsZWN0cm9uaWNzIENvLkx0ZAo+ICsgKiBBdXRob3I6 IFlha2lyIFlhbmcgPHlra0Byb2NrLWNoaXBzLmNvbT4KPiArICoKPiArICogVGhpcyBzb2Z0d2Fy ZSBpcyBsaWNlbnNlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYwo+ ICsgKiBMaWNlbnNlIHZlcnNpb24gMiwgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJl IEZvdW5kYXRpb24sIGFuZAo+ICsgKiBtYXkgYmUgY29waWVkLCBkaXN0cmlidXRlZCwgYW5kIG1v ZGlmaWVkIHVuZGVyIHRob3NlIHRlcm1zLgo+ICsgKgo+ICsgKiBUaGlzIHByb2dyYW0gaXMgZGlz dHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKPiArICogYnV0IFdJ VEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YK PiArICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NF LiAgU2VlIHRoZQo+ICsgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRh aWxzLgo+ICsgKi8KPiArCj4gKyNpbmNsdWRlICJyb2NrY2hpcF9kcm1fbm90aWZ5LmgiCj4gKwo+ ICtzdGF0aWMgUkFXX05PVElGSUVSX0hFQUQocHNyX3JlYWR5X2NoYWluKTsKPiArc3RhdGljIERF RklORV9NVVRFWChwc3JfcmVhZHlfbG9jayk7Cj4gKwo+ICtpbnQgcm9ja2NoaXBfZHJtX3Bzcl9y ZWFkeV9yZWdpc3Rlcl9ub3RpZmllcihzdHJ1Y3Qgbm90aWZpZXJfYmxvY2sgKm5iKQo+ICt7Cj4g KwlpbnQgcmV0ID0gMDsKPiArCj4gKwlpZiAoIW5iKQo+ICsJCXJldHVybiAtRUlOVkFMOwo+ICsK PiArCXJldCA9IHJhd19ub3RpZmllcl9jaGFpbl9yZWdpc3RlcigmcHNyX3JlYWR5X2NoYWluLCBu Yik7Cj4gKwlyZXR1cm4gcmV0Owo+ICt9Cj4gK0VYUE9SVF9TWU1CT0xfR1BMKHJvY2tjaGlwX2Ry bV9wc3JfcmVhZHlfcmVnaXN0ZXJfbm90aWZpZXIpOwo+ICsKPiAraW50IHJvY2tjaGlwX2RybV9w c3JfcmVhZHlfdW5yZWdpc3Rlcl9ub3RpZmllcihzdHJ1Y3Qgbm90aWZpZXJfYmxvY2sgKm5iKQo+ ICt7Cj4gKwlpbnQgcmV0ID0gMDsKPiArCj4gKwlpZiAoIW5iKQo+ICsJCXJldHVybiAtRUlOVkFM Owo+ICsKPiArCXJldCA9IHJhd19ub3RpZmllcl9jaGFpbl91bnJlZ2lzdGVyKCZwc3JfcmVhZHlf Y2hhaW4sIG5iKTsKPiArCXJldHVybiByZXQ7Cj4gK30KPiArRVhQT1JUX1NZTUJPTF9HUEwocm9j a2NoaXBfZHJtX3Bzcl9yZWFkeV91bnJlZ2lzdGVyX25vdGlmaWVyKTsKPiArCj4gK2ludCByb2Nr Y2hpcF9wc3JfcmVhZHlfd2FpdCh2b2lkKQo+ICt7Cj4gKwlpbnQgcmV0Owo+ICsKPiArCXJldCA9 IHJhd19ub3RpZmllcl9jYWxsX2NoYWluKCZwc3JfcmVhZHlfY2hhaW4sIDAsIDApOwo+ICsJaWYg KHJldCA9PSBOT1RJRllfQkFEKQo+ICsJCXJldHVybiAtRVRJTUVET1VUOwo+ICsKPiArCXJldHVy biAwOwo+ICt9Cj4gK0VYUE9SVF9TWU1CT0xfR1BMKHJvY2tjaGlwX3Bzcl9yZWFkeV93YWl0KTsK PiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3JvY2tjaGlwL3JvY2tjaGlwX2RybV9ub3Rp ZnkuaCBiL2RyaXZlcnMvZ3B1L2RybS9yb2NrY2hpcC9yb2NrY2hpcF9kcm1fbm90aWZ5LmgKPiBu ZXcgZmlsZSBtb2RlIDEwMDY0NAo+IGluZGV4IDAwMDAwMDAuLjFiMTkwZTUKPiAtLS0gL2Rldi9u dWxsCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL3JvY2tjaGlwL3JvY2tjaGlwX2RybV9ub3RpZnku aAo+IEBAIC0wLDAgKzEsMjMgQEAKPiArLyoKPiArICogQ29weXJpZ2h0IChDKSAyMDE0IEdvb2ds ZSwgSW5jLgo+ICsgKgo+ICsgKiBUaGlzIHNvZnR3YXJlIGlzIGxpY2Vuc2VkIHVuZGVyIHRoZSB0 ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljCj4gKyAqIExpY2Vuc2UgdmVyc2lvbiAyLCBh cyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgYW5kCj4gKyAqIG1h eSBiZSBjb3BpZWQsIGRpc3RyaWJ1dGVkLCBhbmQgbW9kaWZpZWQgdW5kZXIgdGhvc2UgdGVybXMu Cj4gKyAqCj4gKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0 IGl0IHdpbGwgYmUgdXNlZnVsLAo+ICsgKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhv dXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgo+ICsgKiBNRVJDSEFOVEFCSUxJVFkgb3Ig RklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0aGUKPiArICogR05VIEdlbmVy YWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KPiArICovCj4gKwo+ICsjaWZuZGVm IF9fUk9DS0NISVBfRFJNX05PVElGWV9ICj4gKyNkZWZpbmUgX19ST0NLQ0hJUF9EUk1fTk9USUZZ X0gKPiArCj4gKyNpbmNsdWRlIDxsaW51eC9ub3RpZmllci5oPgo+ICsKPiAraW50IHJvY2tjaGlw X3Bzcl9yZWFkeV93YWl0KHZvaWQpOwo+ICtpbnQgcm9ja2NoaXBfZHJtX3Bzcl9yZWFkeV9yZWdp c3Rlcl9ub3RpZmllcihzdHJ1Y3Qgbm90aWZpZXJfYmxvY2sgKm5iKTsKPiAraW50IHJvY2tjaGlw X2RybV9wc3JfcmVhZHlfdW5yZWdpc3Rlcl9ub3RpZmllcihzdHJ1Y3Qgbm90aWZpZXJfYmxvY2sg Km5iKTsKPiArCj4gKyNlbmRpZiAvKiBfX1JPQ0tDSElQX0RSTV9OT1RJRllfSCAqLwo+IGRpZmYg LS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcm9ja2NoaXAvcm9ja2NoaXBfZHJtX3ZvcC5jIGIvZHJp dmVycy9ncHUvZHJtL3JvY2tjaGlwL3JvY2tjaGlwX2RybV92b3AuYwo+IGluZGV4IGIyYTM2ZGIu LmI1YTAxNWIgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL3JvY2tjaGlwL3JvY2tjaGlw X2RybV92b3AuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9yb2NrY2hpcC9yb2NrY2hpcF9kcm1f dm9wLmMKPiBAQCAtMzUsNiArMzUsNyBAQAo+ICAjaW5jbHVkZSAicm9ja2NoaXBfZHJtX2dlbS5o Igo+ICAjaW5jbHVkZSAicm9ja2NoaXBfZHJtX2ZiLmgiCj4gICNpbmNsdWRlICJyb2NrY2hpcF9k cm1fdm9wLmgiCj4gKyNpbmNsdWRlICJyb2NrY2hpcF9kcm1fbm90aWZ5LmgiCj4gIAo+ICAjZGVm aW5lIF9fUkVHX1NFVF9SRUxBWEVEKHgsIG9mZiwgbWFzaywgc2hpZnQsIHYsIHdyaXRlX21hc2sp IFwKPiAgCQl2b3BfbWFza193cml0ZSh4LCBvZmYsIG1hc2ssIHNoaWZ0LCB2LCB3cml0ZV9tYXNr LCB0cnVlKQo+IEBAIC0xMTcsNiArMTE4LDEwIEBAIHN0cnVjdCB2b3Agewo+ICAJc3RydWN0IGNv bXBsZXRpb24gd2FpdF91cGRhdGVfY29tcGxldGU7Cj4gIAlzdHJ1Y3QgZHJtX3BlbmRpbmdfdmJs YW5rX2V2ZW50ICpldmVudDsKPiAgCj4gKwkvKiBlRFAgUFNSIGNhbGxiYWNrICovCj4gKwlpbnQg KCpwc3JfYWN0aXZlKShlbnVtIHBzcl9hY3Rpb24gYWN0aW9uLCB2b2lkICpwcml2KTsKPiArCXZv aWQgKnBzcl9wcml2Owo+ICsJc3RydWN0IG5vdGlmaWVyX2Jsb2NrIHBzcl9wcmVwYXJlX25iOwo+ ICAJc3RydWN0IGNvbXBsZXRpb24gbGluZV9mbGFnX2NvbXBsZXRpb247Cj4gIAo+ICAJY29uc3Qg c3RydWN0IHZvcF9kYXRhICpkYXRhOwo+IEBAIC05MDYsNiArOTExLDkgQEAgc3RhdGljIGludCB2 b3BfY3J0Y19lbmFibGVfdmJsYW5rKHN0cnVjdCBkcm1fY3J0YyAqY3J0YykKPiAgCj4gIAlzcGlu X3VubG9ja19pcnFyZXN0b3JlKCZ2b3AtPmlycV9sb2NrLCBmbGFncyk7Cj4gIAo+ICsJaWYgKHZv cC0+cHNyX2FjdGl2ZSkKPiArCQl2b3AtPnBzcl9hY3RpdmUoUFNSX0lOQUNUSVZFLCB2b3AtPnBz cl9wcml2KTsKPiArCj4gIAlyZXR1cm4gMDsKPiAgfQo+ICAKPiBAQCAtOTIyLDYgKzkzMCw5IEBA IHN0YXRpYyB2b2lkIHZvcF9jcnRjX2Rpc2FibGVfdmJsYW5rKHN0cnVjdCBkcm1fY3J0YyAqY3J0 YykKPiAgCVZPUF9JTlRSX1NFVF9UWVBFKHZvcCwgZW5hYmxlLCBGU19JTlRSLCAwKTsKPiAgCj4g IAlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZ2b3AtPmlycV9sb2NrLCBmbGFncyk7Cj4gKwo+ICsJ aWYgKHZvcC0+cHNyX2FjdGl2ZSkKPiArCQl2b3AtPnBzcl9hY3RpdmUoUFNSX0FDVElWRSwgdm9w LT5wc3JfcHJpdik7Cj4gIH0KPiAgCj4gIHN0YXRpYyB2b2lkIHZvcF9jcnRjX3dhaXRfZm9yX3Vw ZGF0ZShzdHJ1Y3QgZHJtX2NydGMgKmNydGMpCj4gQEAgLTEwNjYsNiArMTA3Nyw5IEBAIHN0YXRp YyB2b2lkIHZvcF9jcnRjX2VuYWJsZShzdHJ1Y3QgZHJtX2NydGMgKmNydGMpCj4gIAljbGtfc2V0 X3JhdGUodm9wLT5kY2xrLCBhZGp1c3RlZF9tb2RlLT5jbG9jayAqIDEwMDApOwo+ICAKPiAgCVZP UF9DVFJMX1NFVCh2b3AsIHN0YW5kYnksIDApOwo+ICsKPiArCXZvcC0+cHNyX2FjdGl2ZSA9IHMt PnBzcl9hY3RpdmU7Cj4gKwl2b3AtPnBzcl9wcml2ID0gcy0+cHNyX3ByaXY7Cj4gIH0KPiAgCj4g IHN0YXRpYyB2b2lkIHZvcF9jcnRjX2F0b21pY19mbHVzaChzdHJ1Y3QgZHJtX2NydGMgKmNydGMs Cj4gQEAgLTExNzgsNiArMTE5MiwzMCBAQCBzdGF0aWMgdm9pZCB2b3BfaGFuZGxlX3ZibGFuayhz dHJ1Y3Qgdm9wICp2b3ApCj4gIAkJY29tcGxldGUoJnZvcC0+d2FpdF91cGRhdGVfY29tcGxldGUp Owo+ICB9Cj4gIAo+ICtzdGF0aWMgaW50IHBzcl9wcmVwYXJlX25vdGlmeShzdHJ1Y3Qgbm90aWZp ZXJfYmxvY2sgKnBzcl9wcmVwYXJlX25iLAo+ICsJCQkgICAgICB1bnNpZ25lZCBsb25nIGFjdGlv biwgdm9pZCAqZGF0YSkKPiArewo+ICsJc3RydWN0IHZvcCAqdm9wID0gY29udGFpbmVyX29mKHBz cl9wcmVwYXJlX25iLCBzdHJ1Y3Qgdm9wLAo+ICsJCQkJICAgICAgIHBzcl9wcmVwYXJlX25iKTsK PiArCXN0cnVjdCBkcm1fZGlzcGxheV9tb2RlICptb2RlID0gJnZvcC0+Y3J0Yy5tb2RlOwo+ICsJ aW50IHZhY3RfZW5kID0gbW9kZS0+dnRvdGFsIC0gbW9kZS0+dnN5bmNfc3RhcnQgKyBtb2RlLT52 ZGlzcGxheTsKPiArCXVuc2lnbmVkIGxvbmcgamlmZmllc19sZWZ0Owo+ICsKPiArCXJlaW5pdF9j b21wbGV0aW9uKCZ2b3AtPmxpbmVfZmxhZ19jb21wbGV0aW9uKTsKPiArCXZvcF9saW5lX2ZsYWdf aXJxX2VuYWJsZSh2b3AsIHZhY3RfZW5kKTsKPiArCj4gKwlqaWZmaWVzX2xlZnQgPSB3YWl0X2Zv cl9jb21wbGV0aW9uX3RpbWVvdXQoJnZvcC0+bGluZV9mbGFnX2NvbXBsZXRpb24sCj4gKwkJCQkJ CSAgIG1zZWNzX3RvX2ppZmZpZXMoMjAwKSk7Cj4gKwl2b3BfbGluZV9mbGFnX2lycV9kaXNhYmxl KHZvcCk7Cj4gKwo+ICsJaWYgKGppZmZpZXNfbGVmdCA9PSAwKSB7Cj4gKwkJZGV2X2Vycih2b3At PmRldiwgIlRpbWVvdXQgd2FpdGluZyBmb3IgSVJRXG4iKTsKPiArCQlyZXR1cm4gTk9USUZZX0JB RDsKPiArCX0KPiArCj4gKwlyZXR1cm4gTk9USUZZX1NUT1A7Cj4gK30KPiArCj4gIHN0YXRpYyBp cnFyZXR1cm5fdCB2b3BfaXNyKGludCBpcnEsIHZvaWQgKmRhdGEpCj4gIHsKPiAgCXN0cnVjdCB2 b3AgKnZvcCA9IGRhdGE7Cj4gQEAgLTEzMTIsNiArMTM1MCw5IEBAIHN0YXRpYyBpbnQgdm9wX2Ny ZWF0ZV9jcnRjKHN0cnVjdCB2b3AgKnZvcCkKPiAgCQlnb3RvIGVycl9jbGVhbnVwX2NydGM7Cj4g IAl9Cj4gIAo+ICsJdm9wLT5wc3JfcHJlcGFyZV9uYi5ub3RpZmllcl9jYWxsID0gcHNyX3ByZXBh cmVfbm90aWZ5Owo+ICsJcm9ja2NoaXBfZHJtX3Bzcl9yZWFkeV9yZWdpc3Rlcl9ub3RpZmllcigm dm9wLT5wc3JfcHJlcGFyZV9uYik7Cj4gKwo+ICAJaW5pdF9jb21wbGV0aW9uKCZ2b3AtPmRzcF9o b2xkX2NvbXBsZXRpb24pOwo+ICAJaW5pdF9jb21wbGV0aW9uKCZ2b3AtPndhaXRfdXBkYXRlX2Nv bXBsZXRlKTsKPiAgCWluaXRfY29tcGxldGlvbigmdm9wLT5saW5lX2ZsYWdfY29tcGxldGlvbik7 Cj4gLS0gCj4gMS45LjEKPiAKPiAKPiBfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fXwo+IGRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKPiBkcmktZGV2ZWxAbGlzdHMu ZnJlZWRlc2t0b3Aub3JnCj4gaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9s aXN0aW5mby9kcmktZGV2ZWwKCi0tIApEYW5pZWwgVmV0dGVyClNvZnR3YXJlIEVuZ2luZWVyLCBJ bnRlbCBDb3Jwb3JhdGlvbgpodHRwOi8vYmxvZy5mZndsbC5jaApfX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1k ZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcv bWFpbG1hbi9saXN0aW5mby9kcmktZGV2ZWwK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S932799AbcFBNS4 (ORCPT ); Thu, 2 Jun 2016 09:18:56 -0400 Received: from mail-wm0-f68.google.com ([74.125.82.68]:33719 "EHLO mail-wm0-f68.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S932619AbcFBNSw (ORCPT ); Thu, 2 Jun 2016 09:18:52 -0400 Date: Thu, 2 Jun 2016 15:18:47 +0200 From: Daniel Vetter To: Yakir Yang Cc: Mark Yao , Heiko Stuebner , tfiga@chromium.org, daniel.vetter@ffwll.ch, dianders@chromium.org, dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org, linux-rockchip@lists.infradead.org, Thierry Reding Subject: Re: [RFC PATCH v2 3/3] drm/rockchip: analogix_dp: add PSR support Message-ID: <20160602131847.GG7231@phenom.ffwll.local> Mail-Followup-To: Yakir Yang , 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 References: <1464872228-18292-1-git-send-email-ykk@rock-chips.com> <1464872258-18468-1-git-send-email-ykk@rock-chips.com> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <1464872258-18468-1-git-send-email-ykk@rock-chips.com> X-Operating-System: Linux phenom 4.6.0-rc5+ User-Agent: Mutt/1.6.0 (2016-04-01) Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org 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 > > 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 -- Daniel Vetter Software Engineer, Intel Corporation http://blog.ffwll.ch