From mboxrd@z Thu Jan 1 00:00:00 1970 From: Ville =?iso-8859-1?Q?Syrj=E4l=E4?= Subject: Re: [Intel-gfx] [v2 7/7] drm/i915: Backlight control using CRC PMIC based PWM driver Date: Thu, 25 Jun 2015 11:48:41 +0300 Message-ID: <20150625084841.GZ5176@intel.com> References: <1434970465-12687-1-git-send-email-shobhit.kumar@intel.com> <1434970465-12687-8-git-send-email-shobhit.kumar@intel.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Content-Disposition: inline In-Reply-To: <1434970465-12687-8-git-send-email-shobhit.kumar@intel.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Shobhit Kumar Cc: Alexandre Courbot , Paul Bolle , Samuel Ortiz , linux-pwm , Jani Nikula , Povilas Staniulis , intel-gfx , Paul Gortmaker , linux-kernel , dri-devel , linux-gpio , bloften80@gmail.com, Daniel Vetter , Lee Jones List-Id: linux-gpio@vger.kernel.org T24gTW9uLCBKdW4gMjIsIDIwMTUgYXQgMDQ6MjQ6MjVQTSArMDUzMCwgU2hvYmhpdCBLdW1hciB3 cm90ZToKPiBVc2UgdGhlIENSQyBQV00gZGV2aWNlIGluIGludGVsX3BhbmVsLmMgYW5kIGFkZCBu ZXcgTUlQSSBiYWNrbGlnaHQKPiBzcGVjaWZpZmMgY2FsbGJhY2tzCj4gCj4gdjI6IE1vZGlmeSB0 byB1c2UgcHdtX2NvbmZpZyBjYWxsYmFjawo+IHYzOiBBZGRyZXNzZWQgSmFuaSdzIGNvbW1lbnRz Cj4gICAgIC0gUmVuYW1lZCBhbGwgZnVuY3Rpb24gYXMgcHdtXyogaW5zdGVhZCBvZiB2bHZfKgo+ ICAgICAtIENhbGwgaW50ZWxfcGFuZWxfYWN0dWFsbHlfc2V0X2JhY2tsaWdodCBpbiBlbmFibGUg ZnVuY3Rpb24KPiAgICAgLSBSZXR1cm4gLUVOT0RFViBpbiBjYXNlIHB3bV9nZXQgZmFpbHMKPiAg ICAgLSBpbiBjYXNlIHB3bV9jb25maWcgZXJyb3IgcmV0dXJuIGVycm9yIGNkb2UgZnJvbSBwd21f Y29uZmlnCj4gICAgIC0gQ2xlYW51cCBwd20gaW4gaW50ZWxfcGFuZWxfZGVzdHJveV9iYWNrbGln aHQKPiAKPiBDQzogU2FtdWVsIE9ydGl6IDxzYW1lb0BsaW51eC5pbnRlbC5jb20+Cj4gQ2M6IExp bnVzIFdhbGxlaWogPGxpbnVzLndhbGxlaWpAbGluYXJvLm9yZz4KPiBDYzogQWxleGFuZHJlIENv dXJib3QgPGdudXJvdUBnbWFpbC5jb20+Cj4gQ2M6IFRoaWVycnkgUmVkaW5nIDx0aGllcnJ5LnJl ZGluZ0BnbWFpbC5jb20+Cj4gU2lnbmVkLW9mZi1ieTogU2hvYmhpdCBLdW1hciA8c2hvYmhpdC5r dW1hckBpbnRlbC5jb20+Cj4gLS0tCj4gIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rydi5o ICAgfCAgNCArKwo+ICBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kc2kuYyAgIHwgIDYgKysr Cj4gIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3BhbmVsLmMgfCA5NSArKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKystLQo+ICAzIGZpbGVzIGNoYW5nZWQsIDEwMCBpbnNlcnRp b25zKCspLCA1IGRlbGV0aW9ucygtKQo+IAo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0v aTkxNS9pbnRlbF9kcnYuaCBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rydi5oCj4gaW5k ZXggMmFmYjMxYS4uNTYxYzE3ZiAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9p bnRlbF9kcnYuaAo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rydi5oCj4gQEAg LTE4Miw2ICsxODIsMTAgQEAgc3RydWN0IGludGVsX3BhbmVsIHsKPiAgCQlib29sIGVuYWJsZWQ7 Cj4gIAkJYm9vbCBjb21iaW5hdGlvbl9tb2RlOwkvKiBnZW4gMi80IG9ubHkgKi8KPiAgCQlib29s IGFjdGl2ZV9sb3dfcHdtOwo+ICsKPiArCQkvKiBQV00gY2hpcCAqLwo+ICsJCXN0cnVjdCBwd21f ZGV2aWNlICpwd207Cj4gKwo+ICAJCXN0cnVjdCBiYWNrbGlnaHRfZGV2aWNlICpkZXZpY2U7Cj4g IAl9IGJhY2tsaWdodDsKPiAgCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2lu dGVsX2RzaS5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHNpLmMKPiBpbmRleCBjNGRi NzRhLi5iZTg3MjJjIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rz aS5jCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHNpLmMKPiBAQCAtNDAyLDYg KzQwMiw4IEBAIHN0YXRpYyB2b2lkIGludGVsX2RzaV9lbmFibGUoc3RydWN0IGludGVsX2VuY29k ZXIgKmVuY29kZXIpCj4gIAo+ICAJCWludGVsX2RzaV9wb3J0X2VuYWJsZShlbmNvZGVyKTsKPiAg CX0KPiArCj4gKwlpbnRlbF9wYW5lbF9lbmFibGVfYmFja2xpZ2h0KGludGVsX2RzaS0+YXR0YWNo ZWRfY29ubmVjdG9yKTsKPiAgfQo+ICAKPiAgc3RhdGljIHZvaWQgaW50ZWxfZHNpX3ByZV9lbmFi bGUoc3RydWN0IGludGVsX2VuY29kZXIgKmVuY29kZXIpCj4gQEAgLTQ2Niw2ICs0NjgsOCBAQCBz dGF0aWMgdm9pZCBpbnRlbF9kc2lfcHJlX2Rpc2FibGUoc3RydWN0IGludGVsX2VuY29kZXIgKmVu Y29kZXIpCj4gIAo+ICAJRFJNX0RFQlVHX0tNUygiXG4iKTsKPiAgCj4gKwlpbnRlbF9wYW5lbF9k aXNhYmxlX2JhY2tsaWdodChpbnRlbF9kc2ktPmF0dGFjaGVkX2Nvbm5lY3Rvcik7Cj4gKwo+ICAJ aWYgKGlzX3ZpZF9tb2RlKGludGVsX2RzaSkpIHsKPiAgCQkvKiBTZW5kIFNodXRkb3duIGNvbW1h bmQgdG8gdGhlIHBhbmVsIGluIExQIG1vZGUgKi8KPiAgCQlmb3JfZWFjaF9kc2lfcG9ydChwb3J0 LCBpbnRlbF9kc2ktPnBvcnRzKQo+IEBAIC0xMTMyLDYgKzExMzYsOCBAQCB2b2lkIGludGVsX2Rz aV9pbml0KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYpCj4gIAl9Cj4gIAo+ICAJaW50ZWxfcGFuZWxf aW5pdCgmaW50ZWxfY29ubmVjdG9yLT5wYW5lbCwgZml4ZWRfbW9kZSwgTlVMTCk7Cj4gKwlpbnRl bF9wYW5lbF9zZXR1cF9iYWNrbGlnaHQoY29ubmVjdG9yLAo+ICsJCShpbnRlbF9lbmNvZGVyLT5j cnRjX21hc2sgPSAoMSA8PCBQSVBFX0EpKSA/IFBJUEVfQSA6IFBJUEVfQik7CiAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIF4KCldob29wcy4gQnV0IHNpbmNlIHRoZSBQ V00gYmFja2xpZ2h0IGRvZXNuJ3QgbmVlZCB0aGUgaW5pdGlhbCBwaXBlIGZvcgphbnl0aGluZyB5 b3UgY2FuIGFjdHVhbGx5IGp1c3QgcGFzcyBJTlZBTElEX1BJUEUgaGVyZS4KICAgICAgICAgICAg ICAgIAo+ICAKPiAgCXJldHVybjsKPiAgCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9p OTE1L2ludGVsX3BhbmVsLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9wYW5lbC5jCj4g aW5kZXggN2Q4MzUyNy4uMmFhMzBkYiAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkx NS9pbnRlbF9wYW5lbC5jCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfcGFuZWwu Ywo+IEBAIC0zMiw4ICszMiwxMiBAQAo+ICAKPiAgI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgo+ ICAjaW5jbHVkZSA8bGludXgvbW9kdWxlcGFyYW0uaD4KPiArI2luY2x1ZGUgPGxpbnV4L3B3bS5o Pgo+ICAjaW5jbHVkZSAiaW50ZWxfZHJ2LmgiCj4gIAo+ICsjZGVmaW5lIENSQ19QTUlDX1BXTV9Q RVJJT0RfTlMJMjEzMzMKPiArI2RlZmluZSBDUkNfUE1JQ19QV01fU1RFUFMJMjU1CgpUaGlzIGRl ZmluZSBhcHBlYXJzIHRvIGJlIHVudXNlZC4KCj4gKwo+ICB2b2lkCj4gIGludGVsX2ZpeGVkX3Bh bmVsX21vZGUoY29uc3Qgc3RydWN0IGRybV9kaXNwbGF5X21vZGUgKmZpeGVkX21vZGUsCj4gIAkJ ICAgICAgIHN0cnVjdCBkcm1fZGlzcGxheV9tb2RlICphZGp1c3RlZF9tb2RlKQo+IEBAIC01NDQs NiArNTQ4LDE1IEBAIHN0YXRpYyB1MzIgYnh0X2dldF9iYWNrbGlnaHQoc3RydWN0IGludGVsX2Nv bm5lY3RvciAqY29ubmVjdG9yKQo+ICAJcmV0dXJuIEk5MTVfUkVBRChCWFRfQkxDX1BXTV9EVVRZ MSk7Cj4gIH0KPiAgCj4gK3N0YXRpYyB1MzIgcHdtX2dldF9iYWNrbGlnaHQoc3RydWN0IGludGVs X2Nvbm5lY3RvciAqY29ubmVjdG9yKQo+ICt7Cj4gKwlzdHJ1Y3QgaW50ZWxfcGFuZWwgKnBhbmVs ID0gJmNvbm5lY3Rvci0+cGFuZWw7Cj4gKwlpbnQgZHV0eV9uczsKPiArCj4gKwlkdXR5X25zID0g cHdtX2dldF9kdXR5X2N5Y2xlKHBhbmVsLT5iYWNrbGlnaHQucHdtKTsKPiArCXJldHVybiBESVZf Uk9VTkRfVVAoZHV0eV9ucyAqIDEwMCwgQ1JDX1BNSUNfUFdNX1BFUklPRF9OUyk7Cj4gK30KPiAr Cj4gIHN0YXRpYyB1MzIgaW50ZWxfcGFuZWxfZ2V0X2JhY2tsaWdodChzdHJ1Y3QgaW50ZWxfY29u bmVjdG9yICpjb25uZWN0b3IpCj4gIHsKPiAgCXN0cnVjdCBkcm1fZGV2aWNlICpkZXYgPSBjb25u ZWN0b3ItPmJhc2UuZGV2Owo+IEBAIC02MzIsNiArNjQ1LDE0IEBAIHN0YXRpYyB2b2lkIGJ4dF9z ZXRfYmFja2xpZ2h0KHN0cnVjdCBpbnRlbF9jb25uZWN0b3IgKmNvbm5lY3RvciwgdTMyIGxldmVs KQo+ICAJSTkxNV9XUklURShCWFRfQkxDX1BXTV9EVVRZMSwgbGV2ZWwpOwo+ICB9Cj4gIAo+ICtz dGF0aWMgdm9pZCBwd21fc2V0X2JhY2tsaWdodChzdHJ1Y3QgaW50ZWxfY29ubmVjdG9yICpjb25u ZWN0b3IsIHUzMiBsZXZlbCkKPiArewo+ICsJc3RydWN0IGludGVsX3BhbmVsICpwYW5lbCA9ICZj b25uZWN0b3ItPnBhbmVsOwo+ICsJaW50IGR1dHlfbnMgPSBESVZfUk9VTkRfVVAobGV2ZWwgKiBD UkNfUE1JQ19QV01fUEVSSU9EX05TLCAxMDApOwo+ICsKPiArCXB3bV9jb25maWcocGFuZWwtPmJh Y2tsaWdodC5wd20sIGR1dHlfbnMsIENSQ19QTUlDX1BXTV9QRVJJT0RfTlMpOwo+ICt9Cj4gKwo+ ICBzdGF0aWMgdm9pZAo+ICBpbnRlbF9wYW5lbF9hY3R1YWxseV9zZXRfYmFja2xpZ2h0KHN0cnVj dCBpbnRlbF9jb25uZWN0b3IgKmNvbm5lY3RvciwgdTMyIGxldmVsKQo+ICB7Cj4gQEAgLTc2OSw2 ICs3OTAsMTYgQEAgc3RhdGljIHZvaWQgYnh0X2Rpc2FibGVfYmFja2xpZ2h0KHN0cnVjdCBpbnRl bF9jb25uZWN0b3IgKmNvbm5lY3RvcikKPiAgCUk5MTVfV1JJVEUoQlhUX0JMQ19QV01fQ1RMMSwg dG1wICYgfkJYVF9CTENfUFdNX0VOQUJMRSk7Cj4gIH0KPiAgCj4gK3N0YXRpYyB2b2lkIHB3bV9k aXNhYmxlX2JhY2tsaWdodChzdHJ1Y3QgaW50ZWxfY29ubmVjdG9yICpjb25uZWN0b3IpCj4gK3sK PiArCXN0cnVjdCBpbnRlbF9wYW5lbCAqcGFuZWwgPSAmY29ubmVjdG9yLT5wYW5lbDsKPiArCj4g KwkvKiBEaXNhYmxlIHRoZSBiYWNrbGlnaHQgKi8KPiArCXB3bV9jb25maWcocGFuZWwtPmJhY2ts aWdodC5wd20sIDAsIENSQ19QTUlDX1BXTV9QRVJJT0RfTlMpOwo+ICsJdXNsZWVwX3JhbmdlKDIw MDAsIDMwMDApOwo+ICsJcHdtX2Rpc2FibGUocGFuZWwtPmJhY2tsaWdodC5wd20pOwo+ICt9Cj4g Kwo+ICB2b2lkIGludGVsX3BhbmVsX2Rpc2FibGVfYmFja2xpZ2h0KHN0cnVjdCBpbnRlbF9jb25u ZWN0b3IgKmNvbm5lY3RvcikKPiAgewo+ICAJc3RydWN0IGRybV9kZXZpY2UgKmRldiA9IGNvbm5l Y3Rvci0+YmFzZS5kZXY7Cj4gQEAgLTEwMDIsNiArMTAzMywxNCBAQCBzdGF0aWMgdm9pZCBieHRf ZW5hYmxlX2JhY2tsaWdodChzdHJ1Y3QgaW50ZWxfY29ubmVjdG9yICpjb25uZWN0b3IpCj4gIAlJ OTE1X1dSSVRFKEJYVF9CTENfUFdNX0NUTDEsIHB3bV9jdGwgfCBCWFRfQkxDX1BXTV9FTkFCTEUp Owo+ICB9Cj4gIAo+ICtzdGF0aWMgdm9pZCBwd21fZW5hYmxlX2JhY2tsaWdodChzdHJ1Y3QgaW50 ZWxfY29ubmVjdG9yICpjb25uZWN0b3IpCj4gK3sKPiArCXN0cnVjdCBpbnRlbF9wYW5lbCAqcGFu ZWwgPSAmY29ubmVjdG9yLT5wYW5lbDsKPiArCj4gKwlwd21fZW5hYmxlKHBhbmVsLT5iYWNrbGln aHQucHdtKTsKPiArCWludGVsX3BhbmVsX2FjdHVhbGx5X3NldF9iYWNrbGlnaHQoY29ubmVjdG9y LCBwYW5lbC0+YmFja2xpZ2h0LmxldmVsKTsKPiArfQo+ICsKPiAgdm9pZCBpbnRlbF9wYW5lbF9l bmFibGVfYmFja2xpZ2h0KHN0cnVjdCBpbnRlbF9jb25uZWN0b3IgKmNvbm5lY3RvcikKPiAgewo+ ICAJc3RydWN0IGRybV9kZXZpY2UgKmRldiA9IGNvbm5lY3Rvci0+YmFzZS5kZXY7Cj4gQEAgLTEz NzgsNiArMTQxNyw0MCBAQCBieHRfc2V0dXBfYmFja2xpZ2h0KHN0cnVjdCBpbnRlbF9jb25uZWN0 b3IgKmNvbm5lY3RvciwgZW51bSBwaXBlIHVudXNlZCkKPiAgCXJldHVybiAwOwo+ICB9Cj4gIAo+ ICtzdGF0aWMgaW50IHB3bV9zZXR1cF9iYWNrbGlnaHQoc3RydWN0IGludGVsX2Nvbm5lY3RvciAq Y29ubmVjdG9yLAo+ICsJCQkgICAgICAgZW51bSBwaXBlIHBpcGUpCj4gK3sKPiArCXN0cnVjdCBk cm1fZGV2aWNlICpkZXYgPSBjb25uZWN0b3ItPmJhc2UuZGV2Owo+ICsJc3RydWN0IGludGVsX3Bh bmVsICpwYW5lbCA9ICZjb25uZWN0b3ItPnBhbmVsOwo+ICsJaW50IHJldHZhbCA9IC0xOwoKTm8g bmVlZCB0byBpbml0aWFsaXplIGl0LgoKPiArCj4gKwkvKiBHZXQgdGhlIFBXTSBjaGlwIGZvciBi YWNrbGlnaHQgY29udHJvbCAqLwo+ICsJcGFuZWwtPmJhY2tsaWdodC5wd20gPSBwd21fZ2V0KGRl di0+ZGV2LCAicHdtX2JhY2tsaWdodCIpOwo+ICsJaWYgKElTX0VSUihwYW5lbC0+YmFja2xpZ2h0 LnB3bSkpIHsKPiArCQlEUk1fRVJST1IoIkZhaWxlZCB0byBvd24gdGhlIHB3bSBjaGlwXG4iKTsK PiArCQlwYW5lbC0+YmFja2xpZ2h0LnB3bSA9IE5VTEw7Cj4gKwkJcmV0dXJuIC1FTk9ERVY7Cj4g Kwl9Cj4gKwo+ICsJcmV0dmFsID0gcHdtX2NvbmZpZyhwYW5lbC0+YmFja2xpZ2h0LnB3bSwgQ1JD X1BNSUNfUFdNX1BFUklPRF9OUywKPiArCQkJICAgIENSQ19QTUlDX1BXTV9QRVJJT0RfTlMpOwo+ ICsJaWYgKHJldHZhbCA8IDApIHsKPiArCQlEUk1fRVJST1IoIkZhaWxlZCB0byBjb25maWd1cmUg dGhlIHB3bSBjaGlwXG4iKTsKPiArCQlwd21fcHV0KHBhbmVsLT5iYWNrbGlnaHQucHdtKTsKPiAr CQlwYW5lbC0+YmFja2xpZ2h0LnB3bSA9IE5VTEw7Cj4gKwkJcmV0dXJuIHJldHZhbDsKPiArCX0K PiArCj4gKwlwYW5lbC0+YmFja2xpZ2h0Lm1pbiA9IDA7IC8qIDAlICovCj4gKwlwYW5lbC0+YmFj a2xpZ2h0Lm1heCA9IDEwMDsgLyogMTAwJSAqLwo+ICsJcGFuZWwtPmJhY2tsaWdodC5sZXZlbCA9 IERJVl9ST1VORF9VUCgKPiArCQkJCSBwd21fZ2V0X2R1dHlfY3ljbGUocGFuZWwtPmJhY2tsaWdo dC5wd20pICogMTAwLAo+ICsJCQkJIENSQ19QTUlDX1BXTV9QRVJJT0RfTlMpOwo+ICsJcGFuZWwt PmJhY2tsaWdodC5lbmFibGVkID0gcGFuZWwtPmJhY2tsaWdodC5sZXZlbCAhPSAwOwo+ICsKPiAr CXJldHVybiAwOwo+ICt9Cj4gKwo+ICBpbnQgaW50ZWxfcGFuZWxfc2V0dXBfYmFja2xpZ2h0KHN0 cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3IsIGVudW0gcGlwZSBwaXBlKQo+ICB7Cj4gIAlz dHJ1Y3QgZHJtX2RldmljZSAqZGV2ID0gY29ubmVjdG9yLT5kZXY7Cj4gQEAgLTE0MjEsNiArMTQ5 NCwxMCBAQCB2b2lkIGludGVsX3BhbmVsX2Rlc3Ryb3lfYmFja2xpZ2h0KHN0cnVjdCBkcm1fY29u bmVjdG9yICpjb25uZWN0b3IpCj4gIAlzdHJ1Y3QgaW50ZWxfY29ubmVjdG9yICppbnRlbF9jb25u ZWN0b3IgPSB0b19pbnRlbF9jb25uZWN0b3IoY29ubmVjdG9yKTsKPiAgCXN0cnVjdCBpbnRlbF9w YW5lbCAqcGFuZWwgPSAmaW50ZWxfY29ubmVjdG9yLT5wYW5lbDsKPiAgCj4gKwkvKiBkaXNwb3Nl IG9mIHRoZSBwd20gKi8KPiArCWlmIChwYW5lbC0+YmFja2xpZ2h0LnB3bSkKPiArCQlwd21fcHV0 KHBhbmVsLT5iYWNrbGlnaHQucHdtKTsKPiArCj4gIAlwYW5lbC0+YmFja2xpZ2h0LnByZXNlbnQg PSBmYWxzZTsKPiAgfQo+ICAKPiBAQCAtMTQ0OCwxMSArMTUyNSwxOSBAQCB2b2lkIGludGVsX3Bh bmVsX2luaXRfYmFja2xpZ2h0X2Z1bmNzKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYpCj4gIAkJZGV2 X3ByaXYtPmRpc3BsYXkuc2V0X2JhY2tsaWdodCA9IHBjaF9zZXRfYmFja2xpZ2h0Owo+ICAJCWRl dl9wcml2LT5kaXNwbGF5LmdldF9iYWNrbGlnaHQgPSBwY2hfZ2V0X2JhY2tsaWdodDsKPiAgCX0g ZWxzZSBpZiAoSVNfVkFMTEVZVklFVyhkZXYpKSB7Cj4gLQkJZGV2X3ByaXYtPmRpc3BsYXkuc2V0 dXBfYmFja2xpZ2h0ID0gdmx2X3NldHVwX2JhY2tsaWdodDsKPiAtCQlkZXZfcHJpdi0+ZGlzcGxh eS5lbmFibGVfYmFja2xpZ2h0ID0gdmx2X2VuYWJsZV9iYWNrbGlnaHQ7Cj4gLQkJZGV2X3ByaXYt PmRpc3BsYXkuZGlzYWJsZV9iYWNrbGlnaHQgPSB2bHZfZGlzYWJsZV9iYWNrbGlnaHQ7Cj4gLQkJ ZGV2X3ByaXYtPmRpc3BsYXkuc2V0X2JhY2tsaWdodCA9IHZsdl9zZXRfYmFja2xpZ2h0Owo+IC0J CWRldl9wcml2LT5kaXNwbGF5LmdldF9iYWNrbGlnaHQgPSB2bHZfZ2V0X2JhY2tsaWdodDsKPiAr CQlpZiAoZGV2X3ByaXYtPnZidC5oYXNfbWlwaSkgewoKRG8gYWxsIFZMViBEU0kgZGVzaW5zIHVz ZSB0aGUgUE1JQyBmb3IgYmFja2xpZ2h0LCBvciBpcyB0aGVyZQpzb21ldGhpbmcgbW9yZSBzcGVj aWZpYyBpbiBWQlQgd2UgY291bGQgbG9vayBhdD8KCkFuZCB3aGF0IGFib3V0IENIVD8KCk90aHdl cndpc2UgdGhpbmdzIHNlZW0gcmVhc29uYWJsZSwgc28gd2l0aCB0aGUgdGhlCmludGVsX3BhbmVs X3NldHVwX2JhY2tsaWdodCgpIHBpcGUgdGhpbmcgZml4ZWQgdGhpcyBwYXRjaCBpcwpSZXZpZXdl ZC1ieTogVmlsbGUgU3lyasOkbMOkIDx2aWxsZS5zeXJqYWxhQGxpbnV4LmludGVsLmNvbT4KCkkg YWxzbyBnYXZlIHRoZSBlbnRpcmUgc2VyaWVzIGEgZ28gb24gbXkgRkZSRDggYW5kIGl0IGFwcGVh cnMgdG8gd29yawpqdXN0IGZpbmUsIHNvIHlvdSBjYW4gYWxzbyBhZGQKVGVzdGVkLWJ5OiBWaWxs ZSBTeXJqw6Rsw6QgPHZpbGxlLnN5cmphbGFAbGludXguaW50ZWwuY29tPgp0byBhbGwgdGhlIHBh dGNoZXMgaWYgeW91IHdhbnQuCgo+ICsJCQlkZXZfcHJpdi0+ZGlzcGxheS5zZXR1cF9iYWNrbGln aHQgPSBwd21fc2V0dXBfYmFja2xpZ2h0Owo+ICsJCQlkZXZfcHJpdi0+ZGlzcGxheS5lbmFibGVf YmFja2xpZ2h0ID0gcHdtX2VuYWJsZV9iYWNrbGlnaHQ7Cj4gKwkJCWRldl9wcml2LT5kaXNwbGF5 LmRpc2FibGVfYmFja2xpZ2h0ID0gcHdtX2Rpc2FibGVfYmFja2xpZ2h0Owo+ICsJCQlkZXZfcHJp di0+ZGlzcGxheS5zZXRfYmFja2xpZ2h0ID0gcHdtX3NldF9iYWNrbGlnaHQ7Cj4gKwkJCWRldl9w cml2LT5kaXNwbGF5LmdldF9iYWNrbGlnaHQgPSBwd21fZ2V0X2JhY2tsaWdodDsKPiArCQl9IGVs c2Ugewo+ICsJCQlkZXZfcHJpdi0+ZGlzcGxheS5zZXR1cF9iYWNrbGlnaHQgPSB2bHZfc2V0dXBf YmFja2xpZ2h0Owo+ICsJCQlkZXZfcHJpdi0+ZGlzcGxheS5lbmFibGVfYmFja2xpZ2h0ID0gdmx2 X2VuYWJsZV9iYWNrbGlnaHQ7Cj4gKwkJCWRldl9wcml2LT5kaXNwbGF5LmRpc2FibGVfYmFja2xp Z2h0ID0gdmx2X2Rpc2FibGVfYmFja2xpZ2h0Owo+ICsJCQlkZXZfcHJpdi0+ZGlzcGxheS5zZXRf YmFja2xpZ2h0ID0gdmx2X3NldF9iYWNrbGlnaHQ7Cj4gKwkJCWRldl9wcml2LT5kaXNwbGF5Lmdl dF9iYWNrbGlnaHQgPSB2bHZfZ2V0X2JhY2tsaWdodDsKPiArCQl9Cj4gIAl9IGVsc2UgaWYgKElT X0dFTjQoZGV2KSkgewo+ICAJCWRldl9wcml2LT5kaXNwbGF5LnNldHVwX2JhY2tsaWdodCA9IGk5 NjVfc2V0dXBfYmFja2xpZ2h0Owo+ICAJCWRldl9wcml2LT5kaXNwbGF5LmVuYWJsZV9iYWNrbGln aHQgPSBpOTY1X2VuYWJsZV9iYWNrbGlnaHQ7Cj4gLS0gCj4gMS45LjEKPiAKPiBfX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwo+IEludGVsLWdmeCBtYWlsaW5n IGxpc3QKPiBJbnRlbC1nZnhAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCj4gaHR0cDovL2xpc3RzLmZy ZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2ludGVsLWdmeAoKLS0gClZpbGxlIFN5cmrD pGzDpApJbnRlbCBPVEMKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Au b3JnCmh0dHA6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9kcmktZGV2 ZWwK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751247AbbFYItc (ORCPT ); Thu, 25 Jun 2015 04:49:32 -0400 Received: from mga14.intel.com ([192.55.52.115]:34423 "EHLO mga14.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751652AbbFYItW (ORCPT ); Thu, 25 Jun 2015 04:49:22 -0400 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.13,675,1427785200"; d="scan'208";a="514002035" Date: Thu, 25 Jun 2015 11:48:41 +0300 From: Ville =?iso-8859-1?Q?Syrj=E4l=E4?= To: Shobhit Kumar Cc: linux-pwm , intel-gfx , linux-kernel , dri-devel , linux-gpio , Alexandre Courbot , Paul Bolle , Samuel Ortiz , Povilas Staniulis , Jani Nikula , Linus Walleij , Paul Gortmaker , bloften80@gmail.com, David Airlie , Chih-Wei Huang , Thierry Reding , Daniel Vetter , Lee Jones Subject: Re: [Intel-gfx] [v2 7/7] drm/i915: Backlight control using CRC PMIC based PWM driver Message-ID: <20150625084841.GZ5176@intel.com> References: <1434970465-12687-1-git-send-email-shobhit.kumar@intel.com> <1434970465-12687-8-git-send-email-shobhit.kumar@intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset=iso-8859-1 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <1434970465-12687-8-git-send-email-shobhit.kumar@intel.com> User-Agent: Mutt/1.5.23 (2014-03-12) Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Mon, Jun 22, 2015 at 04:24:25PM +0530, Shobhit Kumar wrote: > Use the CRC PWM device in intel_panel.c and add new MIPI backlight > specififc callbacks > > v2: Modify to use pwm_config callback > v3: Addressed Jani's comments > - Renamed all function as pwm_* instead of vlv_* > - Call intel_panel_actually_set_backlight in enable function > - Return -ENODEV in case pwm_get fails > - in case pwm_config error return error cdoe from pwm_config > - Cleanup pwm in intel_panel_destroy_backlight > > CC: Samuel Ortiz > Cc: Linus Walleij > Cc: Alexandre Courbot > Cc: Thierry Reding > Signed-off-by: Shobhit Kumar > --- > drivers/gpu/drm/i915/intel_drv.h | 4 ++ > drivers/gpu/drm/i915/intel_dsi.c | 6 +++ > drivers/gpu/drm/i915/intel_panel.c | 95 ++++++++++++++++++++++++++++++++++++-- > 3 files changed, 100 insertions(+), 5 deletions(-) > > diff --git a/drivers/gpu/drm/i915/intel_drv.h b/drivers/gpu/drm/i915/intel_drv.h > index 2afb31a..561c17f 100644 > --- a/drivers/gpu/drm/i915/intel_drv.h > +++ b/drivers/gpu/drm/i915/intel_drv.h > @@ -182,6 +182,10 @@ struct intel_panel { > bool enabled; > bool combination_mode; /* gen 2/4 only */ > bool active_low_pwm; > + > + /* PWM chip */ > + struct pwm_device *pwm; > + > struct backlight_device *device; > } backlight; > > diff --git a/drivers/gpu/drm/i915/intel_dsi.c b/drivers/gpu/drm/i915/intel_dsi.c > index c4db74a..be8722c 100644 > --- a/drivers/gpu/drm/i915/intel_dsi.c > +++ b/drivers/gpu/drm/i915/intel_dsi.c > @@ -402,6 +402,8 @@ static void intel_dsi_enable(struct intel_encoder *encoder) > > intel_dsi_port_enable(encoder); > } > + > + intel_panel_enable_backlight(intel_dsi->attached_connector); > } > > static void intel_dsi_pre_enable(struct intel_encoder *encoder) > @@ -466,6 +468,8 @@ static void intel_dsi_pre_disable(struct intel_encoder *encoder) > > DRM_DEBUG_KMS("\n"); > > + intel_panel_disable_backlight(intel_dsi->attached_connector); > + > if (is_vid_mode(intel_dsi)) { > /* Send Shutdown command to the panel in LP mode */ > for_each_dsi_port(port, intel_dsi->ports) > @@ -1132,6 +1136,8 @@ void intel_dsi_init(struct drm_device *dev) > } > > intel_panel_init(&intel_connector->panel, fixed_mode, NULL); > + intel_panel_setup_backlight(connector, > + (intel_encoder->crtc_mask = (1 << PIPE_A)) ? PIPE_A : PIPE_B); ^ Whoops. But since the PWM backlight doesn't need the initial pipe for anything you can actually just pass INVALID_PIPE here. > > return; > > diff --git a/drivers/gpu/drm/i915/intel_panel.c b/drivers/gpu/drm/i915/intel_panel.c > index 7d83527..2aa30db 100644 > --- a/drivers/gpu/drm/i915/intel_panel.c > +++ b/drivers/gpu/drm/i915/intel_panel.c > @@ -32,8 +32,12 @@ > > #include > #include > +#include > #include "intel_drv.h" > > +#define CRC_PMIC_PWM_PERIOD_NS 21333 > +#define CRC_PMIC_PWM_STEPS 255 This define appears to be unused. > + > void > intel_fixed_panel_mode(const struct drm_display_mode *fixed_mode, > struct drm_display_mode *adjusted_mode) > @@ -544,6 +548,15 @@ static u32 bxt_get_backlight(struct intel_connector *connector) > return I915_READ(BXT_BLC_PWM_DUTY1); > } > > +static u32 pwm_get_backlight(struct intel_connector *connector) > +{ > + struct intel_panel *panel = &connector->panel; > + int duty_ns; > + > + duty_ns = pwm_get_duty_cycle(panel->backlight.pwm); > + return DIV_ROUND_UP(duty_ns * 100, CRC_PMIC_PWM_PERIOD_NS); > +} > + > static u32 intel_panel_get_backlight(struct intel_connector *connector) > { > struct drm_device *dev = connector->base.dev; > @@ -632,6 +645,14 @@ static void bxt_set_backlight(struct intel_connector *connector, u32 level) > I915_WRITE(BXT_BLC_PWM_DUTY1, level); > } > > +static void pwm_set_backlight(struct intel_connector *connector, u32 level) > +{ > + struct intel_panel *panel = &connector->panel; > + int duty_ns = DIV_ROUND_UP(level * CRC_PMIC_PWM_PERIOD_NS, 100); > + > + pwm_config(panel->backlight.pwm, duty_ns, CRC_PMIC_PWM_PERIOD_NS); > +} > + > static void > intel_panel_actually_set_backlight(struct intel_connector *connector, u32 level) > { > @@ -769,6 +790,16 @@ static void bxt_disable_backlight(struct intel_connector *connector) > I915_WRITE(BXT_BLC_PWM_CTL1, tmp & ~BXT_BLC_PWM_ENABLE); > } > > +static void pwm_disable_backlight(struct intel_connector *connector) > +{ > + struct intel_panel *panel = &connector->panel; > + > + /* Disable the backlight */ > + pwm_config(panel->backlight.pwm, 0, CRC_PMIC_PWM_PERIOD_NS); > + usleep_range(2000, 3000); > + pwm_disable(panel->backlight.pwm); > +} > + > void intel_panel_disable_backlight(struct intel_connector *connector) > { > struct drm_device *dev = connector->base.dev; > @@ -1002,6 +1033,14 @@ static void bxt_enable_backlight(struct intel_connector *connector) > I915_WRITE(BXT_BLC_PWM_CTL1, pwm_ctl | BXT_BLC_PWM_ENABLE); > } > > +static void pwm_enable_backlight(struct intel_connector *connector) > +{ > + struct intel_panel *panel = &connector->panel; > + > + pwm_enable(panel->backlight.pwm); > + intel_panel_actually_set_backlight(connector, panel->backlight.level); > +} > + > void intel_panel_enable_backlight(struct intel_connector *connector) > { > struct drm_device *dev = connector->base.dev; > @@ -1378,6 +1417,40 @@ bxt_setup_backlight(struct intel_connector *connector, enum pipe unused) > return 0; > } > > +static int pwm_setup_backlight(struct intel_connector *connector, > + enum pipe pipe) > +{ > + struct drm_device *dev = connector->base.dev; > + struct intel_panel *panel = &connector->panel; > + int retval = -1; No need to initialize it. > + > + /* Get the PWM chip for backlight control */ > + panel->backlight.pwm = pwm_get(dev->dev, "pwm_backlight"); > + if (IS_ERR(panel->backlight.pwm)) { > + DRM_ERROR("Failed to own the pwm chip\n"); > + panel->backlight.pwm = NULL; > + return -ENODEV; > + } > + > + retval = pwm_config(panel->backlight.pwm, CRC_PMIC_PWM_PERIOD_NS, > + CRC_PMIC_PWM_PERIOD_NS); > + if (retval < 0) { > + DRM_ERROR("Failed to configure the pwm chip\n"); > + pwm_put(panel->backlight.pwm); > + panel->backlight.pwm = NULL; > + return retval; > + } > + > + panel->backlight.min = 0; /* 0% */ > + panel->backlight.max = 100; /* 100% */ > + panel->backlight.level = DIV_ROUND_UP( > + pwm_get_duty_cycle(panel->backlight.pwm) * 100, > + CRC_PMIC_PWM_PERIOD_NS); > + panel->backlight.enabled = panel->backlight.level != 0; > + > + return 0; > +} > + > int intel_panel_setup_backlight(struct drm_connector *connector, enum pipe pipe) > { > struct drm_device *dev = connector->dev; > @@ -1421,6 +1494,10 @@ void intel_panel_destroy_backlight(struct drm_connector *connector) > struct intel_connector *intel_connector = to_intel_connector(connector); > struct intel_panel *panel = &intel_connector->panel; > > + /* dispose of the pwm */ > + if (panel->backlight.pwm) > + pwm_put(panel->backlight.pwm); > + > panel->backlight.present = false; > } > > @@ -1448,11 +1525,19 @@ void intel_panel_init_backlight_funcs(struct drm_device *dev) > dev_priv->display.set_backlight = pch_set_backlight; > dev_priv->display.get_backlight = pch_get_backlight; > } else if (IS_VALLEYVIEW(dev)) { > - dev_priv->display.setup_backlight = vlv_setup_backlight; > - dev_priv->display.enable_backlight = vlv_enable_backlight; > - dev_priv->display.disable_backlight = vlv_disable_backlight; > - dev_priv->display.set_backlight = vlv_set_backlight; > - dev_priv->display.get_backlight = vlv_get_backlight; > + if (dev_priv->vbt.has_mipi) { Do all VLV DSI desins use the PMIC for backlight, or is there something more specific in VBT we could look at? And what about CHT? Othwerwise things seem reasonable, so with the the intel_panel_setup_backlight() pipe thing fixed this patch is Reviewed-by: Ville Syrjälä I also gave the entire series a go on my FFRD8 and it appears to work just fine, so you can also add Tested-by: Ville Syrjälä to all the patches if you want. > + dev_priv->display.setup_backlight = pwm_setup_backlight; > + dev_priv->display.enable_backlight = pwm_enable_backlight; > + dev_priv->display.disable_backlight = pwm_disable_backlight; > + dev_priv->display.set_backlight = pwm_set_backlight; > + dev_priv->display.get_backlight = pwm_get_backlight; > + } else { > + dev_priv->display.setup_backlight = vlv_setup_backlight; > + dev_priv->display.enable_backlight = vlv_enable_backlight; > + dev_priv->display.disable_backlight = vlv_disable_backlight; > + dev_priv->display.set_backlight = vlv_set_backlight; > + dev_priv->display.get_backlight = vlv_get_backlight; > + } > } else if (IS_GEN4(dev)) { > dev_priv->display.setup_backlight = i965_setup_backlight; > dev_priv->display.enable_backlight = i965_enable_backlight; > -- > 1.9.1 > > _______________________________________________ > Intel-gfx mailing list > Intel-gfx@lists.freedesktop.org > http://lists.freedesktop.org/mailman/listinfo/intel-gfx -- Ville Syrjälä Intel OTC