From mboxrd@z Thu Jan 1 00:00:00 1970 From: Jani Nikula Subject: Re: [PATCH] i915: intel_dp_aux_backlight: Fix max backlight calculations Date: Tue, 25 Jun 2019 18:09:20 +0300 Message-ID: <87v9wtog67.fsf@intel.com> References: <20190618062628.133783-1-furquan@google.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20190618062628.133783-1-furquan@google.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Joonas Lahtinen , Rodrigo Vivi , David Airlie , Daniel Vetter Cc: Furquan Shaikh , intel-gfx@lists.freedesktop.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, marcheu@chromium.org, rajatja@google.com, "Lee, Shawn C" List-Id: dri-devel@lists.freedesktop.org T24gTW9uLCAxNyBKdW4gMjAxOSwgRnVycXVhbiBTaGFpa2ggPGZ1cnF1YW5AZ29vZ2xlLmNvbT4g d3JvdGU6Cj4gTWF4IGJhY2tsaWdodCB2YWx1ZSBmb3IgdGhlIHBhbmVsIHdhcyBiZWluZyBjYWxj dWxhdGVkIHVzaW5nIGJ5dGUKPiBjb3VudCBpLmUuIDB4ZmZmZiBpZiAyIGJ5dGVzIGFyZSBzdXBw b3J0ZWQgZm9yIGJhY2tsaWdodCBicmlnaHRuZXNzCj4gYW5kIDB4ZmYgaWYgMSBieXRlIGlzIHN1 cHBvcnRlZC4gSG93ZXZlciwgRURQX1BXTUdFTl9CSVRfQ09VTlQKPiBkZXRlcm1pbmVzIHRoZSBu dW1iZXIgb2YgYWN0aXZlIGNvbnRyb2wgYml0cyB1c2VkIGZvciB0aGUgYnJpZ2h0bmVzcwo+IHNl dHRpbmcuIFRodXMsIGV2ZW4gaWYgdGhlIHBhbmVsIHVzZXMgMiBieXRlIHNldHRpbmcsIGl0IG1p Z2h0IG5vdCB1c2UKPiBhbGwgdGhlIGNvbnRyb2wgYml0cy4gVGh1cywgbWF4IGJhY2tsaWdodCBz aG91bGQgYmUgc2V0IGJhc2VkIG9uIHRoZQo+IHZhbHVlIG9mIEVEUF9QV01HRU5fQklUX0NPVU5U IGluc3RlYWQgb2YgYXNzdW1pbmcgNjU1MzUgb3IgMjU1Lgo+Cj4gQWRkaXRpb25hbGx5LCBFRFBf UFdNR0VOX0JJVF9DT1VOVCB3YXMgYmVpbmcgdXBkYXRlZCBiYXNlZCBvbiB0aGUgVkJUCj4gZnJl cXVlbmN5IHdoaWNoIHJlc3VsdHMgaW4gYSBkaWZmZXJlbnQgbWF4IGJhY2tsaWdodCB2YWx1ZS4g VGh1cywKPiBzZXR0aW5nIG9mIEVEUF9QV01HRU5fQklUX0NPVU5UIGlzIG1vdmVkIHRvIHNldHVw IHBoYXNlIGluc3RlYWQgb2YKPiBlbmFibGUgc28gdGhhdCBtYXggYmFja2xpZ2h0IGNhbiBiZSBj YWxjdWxhdGVkIGNvcnJlY3RseS4gT25seSB0aGUKPiBmcmVxdWVuY3kgZGl2aWRlciBpcyBzZXQg ZHVyaW5nIHRoZSBlbmFibGUgcGhhc2UgdXNpbmcgdGhlIHZhbHVlIG9mCj4gRURQX1BXTUdFTl9C SVRfQ09VTlQuCgpUaGUgZURQIGF1eCBiYWNrbGlnaHQgaXMgYW5vdGhlciBmaW5lIGV4YW1wbGUg b2Ygc2ltcGxlIG1hZGUKZGlmZmljdWx0LiBVZ2guCgpTaGF3biAoQ2MnZCkgaGFzIHJlY2VudGx5 IHN1Ym1pdHRlZCBwYXRjaGVzIHRvIHRoaXMgY29kZS4gU2hhd24sIHBsZWFzZQphbHNvIGxvb2sg dGhyb3VnaCB0aGlzIGFuZCBwcm92aWRlIHlvdXIgY29tbWVudHMsIGlmIGFueS4KCk9uZSBjb21t ZW50IGlubGluZS4KCj4gU2lnbmVkLW9mZi1ieTogRnVycXVhbiBTaGFpa2ggPGZ1cnF1YW5AZ29v Z2xlLmNvbT4KPiBSZXZpZXdlZC1ieTogU3TDqXBoYW5lIE1hcmNoZXNpbiA8bWFyY2hldUBjaHJv bWl1bS5vcmc+Cj4gLS0tCj4gIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2RwX2F1eF9iYWNr bGlnaHQuYyB8IDEzMiArKysrKysrKysrKystLS0tLS0KPiAgMSBmaWxlIGNoYW5nZWQsIDg4IGlu c2VydGlvbnMoKyksIDQ0IGRlbGV0aW9ucygtKQo+Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1 L2RybS9pOTE1L2ludGVsX2RwX2F1eF9iYWNrbGlnaHQuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1 L2ludGVsX2RwX2F1eF9iYWNrbGlnaHQuYwo+IGluZGV4IDM1NzEzNmYxN2Y4NS4uNDYzNmM4ZThh ZThhIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2RwX2F1eF9iYWNr bGlnaHQuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2RwX2F1eF9iYWNrbGln aHQuYwo+IEBAIC0xMTAsNjEgKzExMCwzNCBAQCBzdGF0aWMgYm9vbCBpbnRlbF9kcF9hdXhfc2V0 X3B3bV9mcmVxKHN0cnVjdCBpbnRlbF9jb25uZWN0b3IgKmNvbm5lY3RvcikKPiAgewo+ICAJc3Ry dWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2ID0gdG9faTkxNShjb25uZWN0b3ItPmJhc2Uu ZGV2KTsKPiAgCXN0cnVjdCBpbnRlbF9kcCAqaW50ZWxfZHAgPSBlbmNfdG9faW50ZWxfZHAoJmNv bm5lY3Rvci0+ZW5jb2Rlci0+YmFzZSk7Cj4gLQlpbnQgZnJlcSwgZnhwLCBmeHBfbWluLCBmeHBf bWF4LCBmeHBfYWN0dWFsLCBmID0gMTsKPiAtCXU4IHBuLCBwbl9taW4sIHBuX21heDsKPiArCWlu dCBmcmVxLCBmeHAsIGYsIGZ4cF9hY3R1YWwsIGZ4cF9taW4sIGZ4cF9tYXg7Cj4gKwl1OCBwbjsK PiAgCj4gLQkvKiBGaW5kIGRlc2lyZWQgdmFsdWUgb2YgKEYgeCBQKQo+IC0JICogTm90ZSB0aGF0 LCBpZiBGIHggUCBpcyBvdXQgb2Ygc3VwcG9ydGVkIHJhbmdlLCB0aGUgbWF4aW11bSB2YWx1ZSBv cgo+IC0JICogbWluaW11bSB2YWx1ZSB3aWxsIGFwcGxpZWQgYXV0b21hdGljYWxseS4gU28gbm8g bmVlZCB0byBjaGVjayB0aGF0Lgo+IC0JICovCj4gIAlmcmVxID0gZGV2X3ByaXYtPnZidC5iYWNr bGlnaHQucHdtX2ZyZXFfaHo7Cj4gLQlEUk1fREVCVUdfS01TKCJWQlQgZGVmaW5lZCBiYWNrbGln aHQgZnJlcXVlbmN5ICV1IEh6XG4iLCBmcmVxKTsKPiAgCWlmICghZnJlcSkgewo+ICAJCURSTV9E RUJVR19LTVMoIlVzZSBwYW5lbCBkZWZhdWx0IGJhY2tsaWdodCBmcmVxdWVuY3lcbiIpOwo+ICAJ CXJldHVybiBmYWxzZTsKPiAgCX0KPiAgCj4gLQlmeHAgPSBESVZfUk9VTkRfQ0xPU0VTVChLSHoo RFBfRURQX0JBQ0tMSUdIVF9GUkVRX0JBU0VfS0haKSwgZnJlcSk7Cj4gLQo+IC0JLyogVXNlIGhp Z2hlc3QgcG9zc2libGUgdmFsdWUgb2YgUG4gZm9yIG1vcmUgZ3JhbnVsYXJpdHkgb2YgYnJpZ2h0 bmVzcwo+IC0JICogYWRqdXN0bWVudCB3aGlsZSBzYXRpZnlpbmcgdGhlIGNvbmRpdGlvbnMgYmVs b3cuCj4gLQkgKiAtIFBuIGlzIGluIHRoZSByYW5nZSBvZiBQbl9taW4gYW5kIFBuX21heAo+IC0J ICogLSBGIGlzIGluIHRoZSByYW5nZSBvZiAxIGFuZCAyNTUKPiAtCSAqIC0gRnhQIGlzIHdpdGhp biAyNSUgb2YgZGVzaXJlZCB2YWx1ZS4KPiAtCSAqICAgTm90ZTogMjUlIGlzIGFyYml0cmFyeSB2 YWx1ZSBhbmQgbWF5IG5lZWQgc29tZSB0d2Vhay4KPiAtCSAqLwo+IC0JaWYgKGRybV9kcF9kcGNk X3JlYWRiKCZpbnRlbF9kcC0+YXV4LAo+IC0JCQkgICAgICAgRFBfRURQX1BXTUdFTl9CSVRfQ09V TlRfQ0FQX01JTiwgJnBuX21pbikgIT0gMSkgewo+IC0JCURSTV9ERUJVR19LTVMoIkZhaWxlZCB0 byByZWFkIHB3bWdlbiBiaXQgY291bnQgY2FwIG1pblxuIik7Cj4gKwlpZiAoZHJtX2RwX2RwY2Rf cmVhZGIoJmludGVsX2RwLT5hdXgsIERQX0VEUF9QV01HRU5fQklUX0NPVU5ULAo+ICsJCQkgICAg ICAmcG4pIDwgMCkgewo+ICsJCURSTV9ERUJVR19LTVMoIkZhaWxlZCB0byByZWFkIGF1eCBwd21n ZW4gYml0IGNvdW50XG4iKTsKPiAgCQlyZXR1cm4gZmFsc2U7Cj4gIAl9Cj4gLQlpZiAoZHJtX2Rw X2RwY2RfcmVhZGIoJmludGVsX2RwLT5hdXgsCj4gLQkJCSAgICAgICBEUF9FRFBfUFdNR0VOX0JJ VF9DT1VOVF9DQVBfTUFYLCAmcG5fbWF4KSAhPSAxKSB7Cj4gLQkJRFJNX0RFQlVHX0tNUygiRmFp bGVkIHRvIHJlYWQgcHdtZ2VuIGJpdCBjb3VudCBjYXAgbWF4XG4iKTsKPiAtCQlyZXR1cm4gZmFs c2U7Cj4gLQl9Cj4gLQlwbl9taW4gJj0gRFBfRURQX1BXTUdFTl9CSVRfQ09VTlRfTUFTSzsKPiAt CXBuX21heCAmPSBEUF9FRFBfUFdNR0VOX0JJVF9DT1VOVF9NQVNLOwo+ICAKPiArCWZ4cCA9IERJ Vl9ST1VORF9DTE9TRVNUKEtIeihEUF9FRFBfQkFDS0xJR0hUX0ZSRVFfQkFTRV9LSFopLCBmcmVx KTsKPiArCWYgPSBjbGFtcChESVZfUk9VTkRfQ0xPU0VTVChmeHAsIDEgPDwgcG4pLCAxLCAyNTUp Owo+ICsJZnhwX2FjdHVhbCA9IGYgPDwgcG47Cj4gKwo+ICsJLyogRW5zdXJlIGZyZXF1ZW5jeSBp cyB3aXRoaW4gMjUlIG9mIGRlc2lyZWQgdmFsdWUgKi8KPiAgCWZ4cF9taW4gPSBESVZfUk9VTkRf Q0xPU0VTVChmeHAgKiAzLCA0KTsKPiAgCWZ4cF9tYXggPSBESVZfUk9VTkRfQ0xPU0VTVChmeHAg KiA1LCA0KTsKPiAtCWlmIChmeHBfbWluIDwgKDEgPDwgcG5fbWluKSB8fCAoMjU1IDw8IHBuX21h eCkgPCBmeHBfbWF4KSB7Cj4gLQkJRFJNX0RFQlVHX0tNUygiVkJUIGRlZmluZWQgYmFja2xpZ2h0 IGZyZXF1ZW5jeSBvdXQgb2YgcmFuZ2VcbiIpOwo+IC0JCXJldHVybiBmYWxzZTsKPiAtCX0KPiAg Cj4gLQlmb3IgKHBuID0gcG5fbWF4OyBwbiA+PSBwbl9taW47IHBuLS0pIHsKPiAtCQlmID0gY2xh bXAoRElWX1JPVU5EX0NMT1NFU1QoZnhwLCAxIDw8IHBuKSwgMSwgMjU1KTsKPiAtCQlmeHBfYWN0 dWFsID0gZiA8PCBwbjsKPiAtCQlpZiAoZnhwX21pbiA8PSBmeHBfYWN0dWFsICYmIGZ4cF9hY3R1 YWwgPD0gZnhwX21heCkKPiAtCQkJYnJlYWs7Cj4gLQl9Cj4gLQo+IC0JaWYgKGRybV9kcF9kcGNk X3dyaXRlYigmaW50ZWxfZHAtPmF1eCwKPiAtCQkJICAgICAgIERQX0VEUF9QV01HRU5fQklUX0NP VU5ULCBwbikgPCAwKSB7Cj4gLQkJRFJNX0RFQlVHX0tNUygiRmFpbGVkIHRvIHdyaXRlIGF1eCBw d21nZW4gYml0IGNvdW50XG4iKTsKPiArCWlmIChmeHBfbWluID4gZnhwX2FjdHVhbCB8fCBmeHBf YWN0dWFsID4gZnhwX21heCkgewo+ICsJCURSTV9ERUJVR19LTVMoIkFjdHVhbCBmcmVxdWVuY3kg b3V0IG9mIHJhbmdlXG4iKTsKPiAgCQlyZXR1cm4gZmFsc2U7Cj4gIAl9Cj4gKwo+ICAJaWYgKGRy bV9kcF9kcGNkX3dyaXRlYigmaW50ZWxfZHAtPmF1eCwKPiAgCQkJICAgICAgIERQX0VEUF9CQUNL TElHSFRfRlJFUV9TRVQsICh1OCkgZikgPCAwKSB7Cj4gIAkJRFJNX0RFQlVHX0tNUygiRmFpbGVk IHRvIHdyaXRlIGF1eCBiYWNrbGlnaHQgZnJlcVxuIik7Cj4gQEAgLTIyNCwxNiArMTk3LDg3IEBA IHN0YXRpYyB2b2lkIGludGVsX2RwX2F1eF9kaXNhYmxlX2JhY2tsaWdodChjb25zdCBzdHJ1Y3Qg ZHJtX2Nvbm5lY3Rvcl9zdGF0ZSAqb2xkCj4gIAlzZXRfYXV4X2JhY2tsaWdodF9lbmFibGUoZW5j X3RvX2ludGVsX2RwKG9sZF9jb25uX3N0YXRlLT5iZXN0X2VuY29kZXIpLCBmYWxzZSk7Cj4gIH0K PiAgCj4gK3N0YXRpYyB1MzIgaW50ZWxfZHBfYXV4X2NhbGNfbWF4X2JhY2tsaWdodChzdHJ1Y3Qg aW50ZWxfY29ubmVjdG9yICpjb25uZWN0b3IpCj4gK3sKPiArCXN0cnVjdCBkcm1faTkxNV9wcml2 YXRlICpkZXZfcHJpdiA9IHRvX2k5MTUoY29ubmVjdG9yLT5iYXNlLmRldik7Cj4gKwlzdHJ1Y3Qg aW50ZWxfZHAgKmludGVsX2RwID0gZW5jX3RvX2ludGVsX2RwKCZjb25uZWN0b3ItPmVuY29kZXIt PmJhc2UpOwo+ICsJdTMyIG1heF9iYWNrbGlnaHQgPSAwOwo+ICsJaW50IGZyZXEsIGZ4cCwgZnhw X21pbiwgZnhwX21heCwgZnhwX2FjdHVhbCwgZiA9IDE7Cj4gKwl1OCBwbiwgcG5fbWluLCBwbl9t YXg7Cj4gKwo+ICsJaWYgKGRybV9kcF9kcGNkX3JlYWRiKCZpbnRlbF9kcC0+YXV4LCBEUF9FRFBf UFdNR0VOX0JJVF9DT1VOVCwgJnBuKSkgewo+ICsJCXBuICY9IERQX0VEUF9QV01HRU5fQklUX0NP VU5UX01BU0s7Cj4gKwkJbWF4X2JhY2tsaWdodCA9ICgxIDw8IHBuKSAtIDE7Cj4gKwl9CgpJZiB0 aGUgZHBjZCByZWFkIGZhaWxzLCBwbiBtYXkgYmUgdW5pbml0aWFsaXplZDsgbmVlZCB0byBjaGVj ayB0aGUKcmV0dXJuIHZhbHVlIHByb3Blcmx5IGhlcmUuCgpPdGhlcndpc2UsIHNlZW1zIGZpbmUs IHRob3VnaCB1bm5lY2Vzc2FyaWx5IGNvbXBsaWNhdGVkIGJ1dCB0aGF0J3MKaGFyZGx5IHlvdXIg ZmF1bHQuLi4KCgpCUiwKSmFuaS4KCj4gKwo+ICsJLyogRmluZCBkZXNpcmVkIHZhbHVlIG9mIChG IHggUCkKPiArCSAqIE5vdGUgdGhhdCwgaWYgRiB4IFAgaXMgb3V0IG9mIHN1cHBvcnRlZCByYW5n ZSwgdGhlIG1heGltdW0gdmFsdWUgb3IKPiArCSAqIG1pbmltdW0gdmFsdWUgd2lsbCBhcHBsaWVk IGF1dG9tYXRpY2FsbHkuIFNvIG5vIG5lZWQgdG8gY2hlY2sgdGhhdC4KPiArCSAqLwo+ICsJZnJl cSA9IGRldl9wcml2LT52YnQuYmFja2xpZ2h0LnB3bV9mcmVxX2h6Owo+ICsJRFJNX0RFQlVHX0tN UygiVkJUIGRlZmluZWQgYmFja2xpZ2h0IGZyZXF1ZW5jeSAldSBIelxuIiwgZnJlcSk7Cj4gKwlp ZiAoIWZyZXEpIHsKPiArCQlEUk1fREVCVUdfS01TKCJVc2UgcGFuZWwgZGVmYXVsdCBiYWNrbGln aHQgZnJlcXVlbmN5XG4iKTsKPiArCQlyZXR1cm4gbWF4X2JhY2tsaWdodDsKPiArCX0KPiArCj4g KwlmeHAgPSBESVZfUk9VTkRfQ0xPU0VTVChLSHooRFBfRURQX0JBQ0tMSUdIVF9GUkVRX0JBU0Vf S0haKSwgZnJlcSk7Cj4gKwo+ICsJLyogVXNlIGhpZ2hlc3QgcG9zc2libGUgdmFsdWUgb2YgUG4g Zm9yIG1vcmUgZ3JhbnVsYXJpdHkgb2YgYnJpZ2h0bmVzcwo+ICsJICogYWRqdXN0bWVudCB3aGls ZSBzYXRpZnlpbmcgdGhlIGNvbmRpdGlvbnMgYmVsb3cuCj4gKwkgKiAtIFBuIGlzIGluIHRoZSBy YW5nZSBvZiBQbl9taW4gYW5kIFBuX21heAo+ICsJICogLSBGIGlzIGluIHRoZSByYW5nZSBvZiAx IGFuZCAyNTUKPiArCSAqIC0gRnhQIGlzIHdpdGhpbiAyNSUgb2YgZGVzaXJlZCB2YWx1ZS4KPiAr CSAqICAgTm90ZTogMjUlIGlzIGFyYml0cmFyeSB2YWx1ZSBhbmQgbWF5IG5lZWQgc29tZSB0d2Vh ay4KPiArCSAqLwo+ICsJaWYgKGRybV9kcF9kcGNkX3JlYWRiKCZpbnRlbF9kcC0+YXV4LAo+ICsJ CQkgICAgICAgRFBfRURQX1BXTUdFTl9CSVRfQ09VTlRfQ0FQX01JTiwgJnBuX21pbikgIT0gMSkg ewo+ICsJCURSTV9ERUJVR19LTVMoIkZhaWxlZCB0byByZWFkIHB3bWdlbiBiaXQgY291bnQgY2Fw IG1pblxuIik7Cj4gKwkJcmV0dXJuIG1heF9iYWNrbGlnaHQ7Cj4gKwl9Cj4gKwlpZiAoZHJtX2Rw X2RwY2RfcmVhZGIoJmludGVsX2RwLT5hdXgsCj4gKwkJCSAgICAgICBEUF9FRFBfUFdNR0VOX0JJ VF9DT1VOVF9DQVBfTUFYLCAmcG5fbWF4KSAhPSAxKSB7Cj4gKwkJRFJNX0RFQlVHX0tNUygiRmFp bGVkIHRvIHJlYWQgcHdtZ2VuIGJpdCBjb3VudCBjYXAgbWF4XG4iKTsKPiArCQlyZXR1cm4gbWF4 X2JhY2tsaWdodDsKPiArCX0KPiArCXBuX21pbiAmPSBEUF9FRFBfUFdNR0VOX0JJVF9DT1VOVF9N QVNLOwo+ICsJcG5fbWF4ICY9IERQX0VEUF9QV01HRU5fQklUX0NPVU5UX01BU0s7Cj4gKwo+ICsJ ZnhwX21pbiA9IERJVl9ST1VORF9DTE9TRVNUKGZ4cCAqIDMsIDQpOwo+ICsJZnhwX21heCA9IERJ Vl9ST1VORF9DTE9TRVNUKGZ4cCAqIDUsIDQpOwo+ICsJaWYgKGZ4cF9taW4gPCAoMSA8PCBwbl9t aW4pIHx8ICgyNTUgPDwgcG5fbWF4KSA8IGZ4cF9tYXgpIHsKPiArCQlEUk1fREVCVUdfS01TKCJW QlQgZGVmaW5lZCBiYWNrbGlnaHQgZnJlcXVlbmN5IG91dCBvZiByYW5nZVxuIik7Cj4gKwkJcmV0 dXJuIG1heF9iYWNrbGlnaHQ7Cj4gKwl9Cj4gKwo+ICsJZm9yIChwbiA9IHBuX21heDsgcG4gPj0g cG5fbWluOyBwbi0tKSB7Cj4gKwkJZiA9IGNsYW1wKERJVl9ST1VORF9DTE9TRVNUKGZ4cCwgMSA8 PCBwbiksIDEsIDI1NSk7Cj4gKwkJZnhwX2FjdHVhbCA9IGYgPDwgcG47Cj4gKwkJaWYgKGZ4cF9t aW4gPD0gZnhwX2FjdHVhbCAmJiBmeHBfYWN0dWFsIDw9IGZ4cF9tYXgpCj4gKwkJCWJyZWFrOwo+ ICsJfQo+ICsKPiArCWlmIChkcm1fZHBfZHBjZF93cml0ZWIoJmludGVsX2RwLT5hdXgsCj4gKwkJ CSAgICAgICBEUF9FRFBfUFdNR0VOX0JJVF9DT1VOVCwgcG4pIDwgMCkgewo+ICsJCURSTV9ERUJV R19LTVMoIkZhaWxlZCB0byB3cml0ZSBhdXggcHdtZ2VuIGJpdCBjb3VudFxuIik7Cj4gKwkJcmV0 dXJuIG1heF9iYWNrbGlnaHQ7Cj4gKwl9Cj4gKwo+ICsJbWF4X2JhY2tsaWdodCA9ICgxIDw8IHBu KSAtIDE7Cj4gKwo+ICsJcmV0dXJuIG1heF9iYWNrbGlnaHQ7Cj4gK30KPiArCj4gIHN0YXRpYyBp bnQgaW50ZWxfZHBfYXV4X3NldHVwX2JhY2tsaWdodChzdHJ1Y3QgaW50ZWxfY29ubmVjdG9yICpj b25uZWN0b3IsCj4gIAkJCQkJZW51bSBwaXBlIHBpcGUpCj4gIHsKPiAgCXN0cnVjdCBpbnRlbF9k cCAqaW50ZWxfZHAgPSBlbmNfdG9faW50ZWxfZHAoJmNvbm5lY3Rvci0+ZW5jb2Rlci0+YmFzZSk7 Cj4gIAlzdHJ1Y3QgaW50ZWxfcGFuZWwgKnBhbmVsID0gJmNvbm5lY3Rvci0+cGFuZWw7Cj4gIAo+ IC0JaWYgKGludGVsX2RwLT5lZHBfZHBjZFsyXSAmIERQX0VEUF9CQUNLTElHSFRfQlJJR0hUTkVT U19CWVRFX0NPVU5UKQo+IC0JCXBhbmVsLT5iYWNrbGlnaHQubWF4ID0gMHhGRkZGOwo+IC0JZWxz ZQo+IC0JCXBhbmVsLT5iYWNrbGlnaHQubWF4ID0gMHhGRjsKPiArCXBhbmVsLT5iYWNrbGlnaHQu bWF4ID0gaW50ZWxfZHBfYXV4X2NhbGNfbWF4X2JhY2tsaWdodChjb25uZWN0b3IpOwo+ICsKPiAr CWlmICghcGFuZWwtPmJhY2tsaWdodC5tYXgpCj4gKwkJcmV0dXJuIC1FTk9ERVY7Cj4gIAo+ICAJ cGFuZWwtPmJhY2tsaWdodC5taW4gPSAwOwo+ICAJcGFuZWwtPmJhY2tsaWdodC5sZXZlbCA9IGlu dGVsX2RwX2F1eF9nZXRfYmFja2xpZ2h0KGNvbm5lY3Rvcik7CgotLSAKSmFuaSBOaWt1bGEsIElu dGVsIE9wZW4gU291cmNlIEdyYXBoaWNzIENlbnRlcgpfX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1kZXZlbEBs aXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1h bi9saXN0aW5mby9kcmktZGV2ZWw= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-6.8 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 9E1B8C48BD5 for ; Tue, 25 Jun 2019 15:07:35 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 67DEB216FD for ; Tue, 25 Jun 2019 15:07:35 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1732127AbfFYPHe convert rfc822-to-8bit (ORCPT ); Tue, 25 Jun 2019 11:07:34 -0400 Received: from mga09.intel.com ([134.134.136.24]:14395 "EHLO mga09.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1730777AbfFYPHd (ORCPT ); Tue, 25 Jun 2019 11:07:33 -0400 X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from fmsmga001.fm.intel.com ([10.253.24.23]) by orsmga102.jf.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 25 Jun 2019 08:07:32 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.63,416,1557212400"; d="scan'208";a="182907469" Received: from triedme-mobl.ger.corp.intel.com (HELO localhost) ([10.252.35.180]) by fmsmga001.fm.intel.com with ESMTP; 25 Jun 2019 08:07:28 -0700 From: Jani Nikula To: Furquan Shaikh , Joonas Lahtinen , Rodrigo Vivi , David Airlie , Daniel Vetter Cc: intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org, rajatja@google.com, marcheu@chromium.org, Furquan Shaikh , "Lee\, Shawn C" Subject: Re: [PATCH] i915: intel_dp_aux_backlight: Fix max backlight calculations In-Reply-To: <20190618062628.133783-1-furquan@google.com> Organization: Intel Finland Oy - BIC 0357606-4 - Westendinkatu 7, 02160 Espoo References: <20190618062628.133783-1-furquan@google.com> Date: Tue, 25 Jun 2019 18:09:20 +0300 Message-ID: <87v9wtog67.fsf@intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 8BIT Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Mon, 17 Jun 2019, Furquan Shaikh wrote: > Max backlight value for the panel was being calculated using byte > count i.e. 0xffff if 2 bytes are supported for backlight brightness > and 0xff if 1 byte is supported. However, EDP_PWMGEN_BIT_COUNT > determines the number of active control bits used for the brightness > setting. Thus, even if the panel uses 2 byte setting, it might not use > all the control bits. Thus, max backlight should be set based on the > value of EDP_PWMGEN_BIT_COUNT instead of assuming 65535 or 255. > > Additionally, EDP_PWMGEN_BIT_COUNT was being updated based on the VBT > frequency which results in a different max backlight value. Thus, > setting of EDP_PWMGEN_BIT_COUNT is moved to setup phase instead of > enable so that max backlight can be calculated correctly. Only the > frequency divider is set during the enable phase using the value of > EDP_PWMGEN_BIT_COUNT. The eDP aux backlight is another fine example of simple made difficult. Ugh. Shawn (Cc'd) has recently submitted patches to this code. Shawn, please also look through this and provide your comments, if any. One comment inline. > Signed-off-by: Furquan Shaikh > Reviewed-by: Stéphane Marchesin > --- > drivers/gpu/drm/i915/intel_dp_aux_backlight.c | 132 ++++++++++++------ > 1 file changed, 88 insertions(+), 44 deletions(-) > > diff --git a/drivers/gpu/drm/i915/intel_dp_aux_backlight.c b/drivers/gpu/drm/i915/intel_dp_aux_backlight.c > index 357136f17f85..4636c8e8ae8a 100644 > --- a/drivers/gpu/drm/i915/intel_dp_aux_backlight.c > +++ b/drivers/gpu/drm/i915/intel_dp_aux_backlight.c > @@ -110,61 +110,34 @@ static bool intel_dp_aux_set_pwm_freq(struct intel_connector *connector) > { > struct drm_i915_private *dev_priv = to_i915(connector->base.dev); > struct intel_dp *intel_dp = enc_to_intel_dp(&connector->encoder->base); > - int freq, fxp, fxp_min, fxp_max, fxp_actual, f = 1; > - u8 pn, pn_min, pn_max; > + int freq, fxp, f, fxp_actual, fxp_min, fxp_max; > + u8 pn; > > - /* Find desired value of (F x P) > - * Note that, if F x P is out of supported range, the maximum value or > - * minimum value will applied automatically. So no need to check that. > - */ > freq = dev_priv->vbt.backlight.pwm_freq_hz; > - DRM_DEBUG_KMS("VBT defined backlight frequency %u Hz\n", freq); > if (!freq) { > DRM_DEBUG_KMS("Use panel default backlight frequency\n"); > return false; > } > > - fxp = DIV_ROUND_CLOSEST(KHz(DP_EDP_BACKLIGHT_FREQ_BASE_KHZ), freq); > - > - /* Use highest possible value of Pn for more granularity of brightness > - * adjustment while satifying the conditions below. > - * - Pn is in the range of Pn_min and Pn_max > - * - F is in the range of 1 and 255 > - * - FxP is within 25% of desired value. > - * Note: 25% is arbitrary value and may need some tweak. > - */ > - if (drm_dp_dpcd_readb(&intel_dp->aux, > - DP_EDP_PWMGEN_BIT_COUNT_CAP_MIN, &pn_min) != 1) { > - DRM_DEBUG_KMS("Failed to read pwmgen bit count cap min\n"); > + if (drm_dp_dpcd_readb(&intel_dp->aux, DP_EDP_PWMGEN_BIT_COUNT, > + &pn) < 0) { > + DRM_DEBUG_KMS("Failed to read aux pwmgen bit count\n"); > return false; > } > - if (drm_dp_dpcd_readb(&intel_dp->aux, > - DP_EDP_PWMGEN_BIT_COUNT_CAP_MAX, &pn_max) != 1) { > - DRM_DEBUG_KMS("Failed to read pwmgen bit count cap max\n"); > - return false; > - } > - pn_min &= DP_EDP_PWMGEN_BIT_COUNT_MASK; > - pn_max &= DP_EDP_PWMGEN_BIT_COUNT_MASK; > > + fxp = DIV_ROUND_CLOSEST(KHz(DP_EDP_BACKLIGHT_FREQ_BASE_KHZ), freq); > + f = clamp(DIV_ROUND_CLOSEST(fxp, 1 << pn), 1, 255); > + fxp_actual = f << pn; > + > + /* Ensure frequency is within 25% of desired value */ > fxp_min = DIV_ROUND_CLOSEST(fxp * 3, 4); > fxp_max = DIV_ROUND_CLOSEST(fxp * 5, 4); > - if (fxp_min < (1 << pn_min) || (255 << pn_max) < fxp_max) { > - DRM_DEBUG_KMS("VBT defined backlight frequency out of range\n"); > - return false; > - } > > - for (pn = pn_max; pn >= pn_min; pn--) { > - f = clamp(DIV_ROUND_CLOSEST(fxp, 1 << pn), 1, 255); > - fxp_actual = f << pn; > - if (fxp_min <= fxp_actual && fxp_actual <= fxp_max) > - break; > - } > - > - if (drm_dp_dpcd_writeb(&intel_dp->aux, > - DP_EDP_PWMGEN_BIT_COUNT, pn) < 0) { > - DRM_DEBUG_KMS("Failed to write aux pwmgen bit count\n"); > + if (fxp_min > fxp_actual || fxp_actual > fxp_max) { > + DRM_DEBUG_KMS("Actual frequency out of range\n"); > return false; > } > + > if (drm_dp_dpcd_writeb(&intel_dp->aux, > DP_EDP_BACKLIGHT_FREQ_SET, (u8) f) < 0) { > DRM_DEBUG_KMS("Failed to write aux backlight freq\n"); > @@ -224,16 +197,87 @@ static void intel_dp_aux_disable_backlight(const struct drm_connector_state *old > set_aux_backlight_enable(enc_to_intel_dp(old_conn_state->best_encoder), false); > } > > +static u32 intel_dp_aux_calc_max_backlight(struct intel_connector *connector) > +{ > + struct drm_i915_private *dev_priv = to_i915(connector->base.dev); > + struct intel_dp *intel_dp = enc_to_intel_dp(&connector->encoder->base); > + u32 max_backlight = 0; > + int freq, fxp, fxp_min, fxp_max, fxp_actual, f = 1; > + u8 pn, pn_min, pn_max; > + > + if (drm_dp_dpcd_readb(&intel_dp->aux, DP_EDP_PWMGEN_BIT_COUNT, &pn)) { > + pn &= DP_EDP_PWMGEN_BIT_COUNT_MASK; > + max_backlight = (1 << pn) - 1; > + } If the dpcd read fails, pn may be uninitialized; need to check the return value properly here. Otherwise, seems fine, though unnecessarily complicated but that's hardly your fault... BR, Jani. > + > + /* Find desired value of (F x P) > + * Note that, if F x P is out of supported range, the maximum value or > + * minimum value will applied automatically. So no need to check that. > + */ > + freq = dev_priv->vbt.backlight.pwm_freq_hz; > + DRM_DEBUG_KMS("VBT defined backlight frequency %u Hz\n", freq); > + if (!freq) { > + DRM_DEBUG_KMS("Use panel default backlight frequency\n"); > + return max_backlight; > + } > + > + fxp = DIV_ROUND_CLOSEST(KHz(DP_EDP_BACKLIGHT_FREQ_BASE_KHZ), freq); > + > + /* Use highest possible value of Pn for more granularity of brightness > + * adjustment while satifying the conditions below. > + * - Pn is in the range of Pn_min and Pn_max > + * - F is in the range of 1 and 255 > + * - FxP is within 25% of desired value. > + * Note: 25% is arbitrary value and may need some tweak. > + */ > + if (drm_dp_dpcd_readb(&intel_dp->aux, > + DP_EDP_PWMGEN_BIT_COUNT_CAP_MIN, &pn_min) != 1) { > + DRM_DEBUG_KMS("Failed to read pwmgen bit count cap min\n"); > + return max_backlight; > + } > + if (drm_dp_dpcd_readb(&intel_dp->aux, > + DP_EDP_PWMGEN_BIT_COUNT_CAP_MAX, &pn_max) != 1) { > + DRM_DEBUG_KMS("Failed to read pwmgen bit count cap max\n"); > + return max_backlight; > + } > + pn_min &= DP_EDP_PWMGEN_BIT_COUNT_MASK; > + pn_max &= DP_EDP_PWMGEN_BIT_COUNT_MASK; > + > + fxp_min = DIV_ROUND_CLOSEST(fxp * 3, 4); > + fxp_max = DIV_ROUND_CLOSEST(fxp * 5, 4); > + if (fxp_min < (1 << pn_min) || (255 << pn_max) < fxp_max) { > + DRM_DEBUG_KMS("VBT defined backlight frequency out of range\n"); > + return max_backlight; > + } > + > + for (pn = pn_max; pn >= pn_min; pn--) { > + f = clamp(DIV_ROUND_CLOSEST(fxp, 1 << pn), 1, 255); > + fxp_actual = f << pn; > + if (fxp_min <= fxp_actual && fxp_actual <= fxp_max) > + break; > + } > + > + if (drm_dp_dpcd_writeb(&intel_dp->aux, > + DP_EDP_PWMGEN_BIT_COUNT, pn) < 0) { > + DRM_DEBUG_KMS("Failed to write aux pwmgen bit count\n"); > + return max_backlight; > + } > + > + max_backlight = (1 << pn) - 1; > + > + return max_backlight; > +} > + > static int intel_dp_aux_setup_backlight(struct intel_connector *connector, > enum pipe pipe) > { > struct intel_dp *intel_dp = enc_to_intel_dp(&connector->encoder->base); > struct intel_panel *panel = &connector->panel; > > - if (intel_dp->edp_dpcd[2] & DP_EDP_BACKLIGHT_BRIGHTNESS_BYTE_COUNT) > - panel->backlight.max = 0xFFFF; > - else > - panel->backlight.max = 0xFF; > + panel->backlight.max = intel_dp_aux_calc_max_backlight(connector); > + > + if (!panel->backlight.max) > + return -ENODEV; > > panel->backlight.min = 0; > panel->backlight.level = intel_dp_aux_get_backlight(connector); -- Jani Nikula, Intel Open Source Graphics Center