From mboxrd@z Thu Jan 1 00:00:00 1970 From: Jani Nikula Subject: Re: [PATCH 8/8] drm/i915: Backlight control using CRC PMIC based PWM driver Date: Wed, 06 May 2015 16:39:40 +0300 Message-ID: <87y4l1ddur.fsf@intel.com> References: <1430316005-16480-1-git-send-email-shobhit.kumar@intel.com> <1430316005-16480-9-git-send-email-shobhit.kumar@intel.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1430316005-16480-9-git-send-email-shobhit.kumar@intel.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" To: intel-gfx , linux-kernel , linux-gpio , linux-pwm , dri-devel Cc: Alexandre Courbot , Samuel Ortiz , David Airlie , Shobhit Kumar , Linus Walleij , Povilas Staniulis , Chih-Wei Huang , Thierry Reding , Daniel Vetter , Lee Jones List-Id: linux-gpio@vger.kernel.org T24gV2VkLCAyOSBBcHIgMjAxNSwgU2hvYmhpdCBLdW1hciA8c2hvYmhpdC5rdW1hckBpbnRlbC5j b20+IHdyb3RlOgo+IFVzZSB0aGUgQ1JDIFBXTSBkZXZpY2UgaW4gaW50ZWxfcGFuZWwuYyBhbmQg YWRkIG5ldyBNSVBJIGJhY2tsaWdodAo+IHNwZWNpZmlmYyBjYWxsYmFja3MKPgo+IHYyOiBNb2Rp ZnkgdG8gdXNlIHB3bV9jb25maWcgY2FsbGJhY2sKPgo+IENDOiBTYW11ZWwgT3J0aXogPHNhbWVv QGxpbnV4LmludGVsLmNvbT4KPiBDYzogTGludXMgV2FsbGVpaiA8bGludXMud2FsbGVpakBsaW5h cm8ub3JnPgo+IENjOiBBbGV4YW5kcmUgQ291cmJvdCA8Z251cm91QGdtYWlsLmNvbT4KPiBDYzog VGhpZXJyeSBSZWRpbmcgPHRoaWVycnkucmVkaW5nQGdtYWlsLmNvbT4KPiBTaWduZWQtb2ZmLWJ5 OiBTaG9iaGl0IEt1bWFyIDxzaG9iaGl0Lmt1bWFyQGludGVsLmNvbT4KPiAtLS0KPiAgZHJpdmVy cy9ncHUvZHJtL2k5MTUvaW50ZWxfZHJ2LmggICB8ICA1ICsrKwo+ICBkcml2ZXJzL2dwdS9kcm0v aTkxNS9pbnRlbF9kc2kuYyAgIHwgIDYgKysrCj4gIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVs X3BhbmVsLmMgfCA5MiArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKy0tLQo+ICAz IGZpbGVzIGNoYW5nZWQsIDk4IGluc2VydGlvbnMoKyksIDUgZGVsZXRpb25zKC0pCj4KPiBkaWZm IC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHJ2LmggYi9kcml2ZXJzL2dwdS9k cm0vaTkxNS9pbnRlbF9kcnYuaAo+IGluZGV4IDg5N2YxN2QuLmI0ZWJlM2IgMTAwNjQ0Cj4gLS0t IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHJ2LmgKPiArKysgYi9kcml2ZXJzL2dwdS9k cm0vaTkxNS9pbnRlbF9kcnYuaAo+IEBAIC0xODIsNyArMTgyLDEyIEBAIHN0cnVjdCBpbnRlbF9w YW5lbCB7Cj4gIAkJYm9vbCBlbmFibGVkOwo+ICAJCWJvb2wgY29tYmluYXRpb25fbW9kZTsJLyog Z2VuIDIvNCBvbmx5ICovCj4gIAkJYm9vbCBhY3RpdmVfbG93X3B3bTsKPiArCj4gKwkJLyogUFdN IGNoaXAgKi8KPiArCQlzdHJ1Y3QgcHdtX2RldmljZSAqcHdtOwo+ICsKPiAgCQlzdHJ1Y3QgYmFj a2xpZ2h0X2RldmljZSAqZGV2aWNlOwo+ICsKClN1cGVyZmx1b3VzIHdoaXRlc3BhY2UuCgo+ICAJ fSBiYWNrbGlnaHQ7Cj4gIAo+ICAJdm9pZCAoKmJhY2tsaWdodF9wb3dlcikoc3RydWN0IGludGVs X2Nvbm5lY3RvciAqLCBib29sIGVuYWJsZSk7Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2Ry bS9pOTE1L2ludGVsX2RzaS5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHNpLmMKPiBp bmRleCBiZTU1ZmZhLi44M2M0NTQwIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1 L2ludGVsX2RzaS5jCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHNpLmMKPiBA QCAtNDAyLDYgKzQwMiw4IEBAIHN0YXRpYyB2b2lkIGludGVsX2RzaV9lbmFibGUoc3RydWN0IGlu dGVsX2VuY29kZXIgKmVuY29kZXIpCj4gIAo+ICAJCWludGVsX2RzaV9wb3J0X2VuYWJsZShlbmNv ZGVyKTsKPiAgCX0KPiArCj4gKwlpbnRlbF9wYW5lbF9lbmFibGVfYmFja2xpZ2h0KGludGVsX2Rz aS0+YXR0YWNoZWRfY29ubmVjdG9yKTsKPiAgfQo+ICAKPiAgc3RhdGljIHZvaWQgaW50ZWxfZHNp X3ByZV9lbmFibGUoc3RydWN0IGludGVsX2VuY29kZXIgKmVuY29kZXIpCj4gQEAgLTQ2Niw2ICs0 NjgsOCBAQCBzdGF0aWMgdm9pZCBpbnRlbF9kc2lfcHJlX2Rpc2FibGUoc3RydWN0IGludGVsX2Vu Y29kZXIgKmVuY29kZXIpCj4gIAo+ICAJRFJNX0RFQlVHX0tNUygiXG4iKTsKPiAgCj4gKwlpbnRl bF9wYW5lbF9kaXNhYmxlX2JhY2tsaWdodChpbnRlbF9kc2ktPmF0dGFjaGVkX2Nvbm5lY3Rvcik7 Cj4gKwo+ICAJaWYgKGlzX3ZpZF9tb2RlKGludGVsX2RzaSkpIHsKPiAgCQkvKiBTZW5kIFNodXRk b3duIGNvbW1hbmQgdG8gdGhlIHBhbmVsIGluIExQIG1vZGUgKi8KPiAgCQlmb3JfZWFjaF9kc2lf cG9ydChwb3J0LCBpbnRlbF9kc2ktPnBvcnRzKQo+IEBAIC0xMTMyLDYgKzExMzYsOCBAQCB2b2lk IGludGVsX2RzaV9pbml0KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYpCj4gIAl9Cj4gIAo+ICAJaW50 ZWxfcGFuZWxfaW5pdCgmaW50ZWxfY29ubmVjdG9yLT5wYW5lbCwgZml4ZWRfbW9kZSwgTlVMTCk7 Cj4gKwlpbnRlbF9wYW5lbF9zZXR1cF9iYWNrbGlnaHQoY29ubmVjdG9yLAo+ICsJCShpbnRlbF9l bmNvZGVyLT5jcnRjX21hc2sgPSAoMSA8PCBQSVBFX0EpKSA/IFBJUEVfQTogUElQRV9CKTsKPiAg Cj4gIAlyZXR1cm47Cj4gIAo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRl bF9wYW5lbC5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfcGFuZWwuYwo+IGluZGV4IDA4 NTMyZDQuLjU3MDBmNmYgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxf cGFuZWwuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3BhbmVsLmMKPiBAQCAt MzIsOCArMzIsMTIgQEAKPiAgCj4gICNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KPiAgI2luY2x1 ZGUgPGxpbnV4L21vZHVsZXBhcmFtLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9wd20uaD4KPiAgI2lu Y2x1ZGUgImludGVsX2Rydi5oIgo+ICAKPiArI2RlZmluZSBDUkNfUE1JQ19QV01fUEVSSU9EX05T CTIxMzMzCj4gKyNkZWZpbmUgQ1JDX1BNSUNfUFdNX1NURVBTCTI1NQo+ICsKPiAgdm9pZAo+ICBp bnRlbF9maXhlZF9wYW5lbF9tb2RlKGNvbnN0IHN0cnVjdCBkcm1fZGlzcGxheV9tb2RlICpmaXhl ZF9tb2RlLAo+ICAJCSAgICAgICBzdHJ1Y3QgZHJtX2Rpc3BsYXlfbW9kZSAqYWRqdXN0ZWRfbW9k ZSkKPiBAQCAtNTM2LDYgKzU0MCwxNSBAQCBzdGF0aWMgdTMyIHZsdl9nZXRfYmFja2xpZ2h0KHN0 cnVjdCBpbnRlbF9jb25uZWN0b3IgKmNvbm5lY3RvcikKPiAgCXJldHVybiBfdmx2X2dldF9iYWNr bGlnaHQoZGV2LCBwaXBlKTsKPiAgfQo+ICAKPiArc3RhdGljIHUzMiB2bHZfZ2V0X21pcGlfYmFj a2xpZ2h0KHN0cnVjdCBpbnRlbF9jb25uZWN0b3IgKmNvbm5lY3RvcikKCkknZCByYXRoZXIgY2Fs bCB0aGlzIGVpdGhlciBwbWljX2dldF9iYWNrbGlnaHQgb3IgZXZlbiBwd21fZ2V0X2JhY2tsaWdo dApiZWNhdXNlIHRoZXJlJ3Mgbm90aGluZyByZWFsbHkgdmx2IHNwZWNpZmljIGFib3V0IHRoZSBm dW5jdGlvbnMKdGhlbXNlbHZlcy4gU2FtZSBmb3IgYWxsIG9mIHRoZW0uCgo+ICt7Cj4gKwlzdHJ1 Y3QgaW50ZWxfcGFuZWwgKnBhbmVsID0gJmNvbm5lY3Rvci0+cGFuZWw7Cj4gKwlpbnQgZHV0eV9u czsKPiArCj4gKwlkdXR5X25zID0gcHdtX2dldF9kdXR5X2N5Y2xlKHBhbmVsLT5iYWNrbGlnaHQu cHdtKTsKPiArCXJldHVybiBESVZfUk9VTkRfVVAoZHV0eV9ucyAqIDEwMCwgQ1JDX1BNSUNfUFdN X1BFUklPRF9OUyk7CgpCYXNpY2FsbHkgd2UgaGF2ZSBhbGwgdGhlIGNvZGUgaW4gcGxhY2UgdG8g ZG8gdGhlIHNjYWxpbmcgZnJvbSBodyB0bwp1c2VyLiBTZWUgdGhlIG5vdGUgaW4gaW50ZWxfYmFj a2xpZ2h0X2RldmljZV9yZWdpc3Rlci4gV2Ugc2hvdWxkbid0IG5lZWQKdG8gYWRkIGFkZGl0aW9u YWwgc2NhbGluZyBhbGwgYXJvdW5kLgoKSG93ZXZlciB0aGlzIGNhbiBiZSBhIGZ1dHVyZSBjbGVh bnVwIElNTy4KCj4gK30KPiArCj4gIHN0YXRpYyB1MzIgaW50ZWxfcGFuZWxfZ2V0X2JhY2tsaWdo dChzdHJ1Y3QgaW50ZWxfY29ubmVjdG9yICpjb25uZWN0b3IpCj4gIHsKPiAgCXN0cnVjdCBkcm1f ZGV2aWNlICpkZXYgPSBjb25uZWN0b3ItPmJhc2UuZGV2Owo+IEBAIC02MTYsNiArNjI5LDE0IEBA IHN0YXRpYyB2b2lkIHZsdl9zZXRfYmFja2xpZ2h0KHN0cnVjdCBpbnRlbF9jb25uZWN0b3IgKmNv bm5lY3RvciwgdTMyIGxldmVsKQo+ICAJSTkxNV9XUklURShWTFZfQkxDX1BXTV9DVEwocGlwZSks IHRtcCB8IGxldmVsKTsKPiAgfQo+ICAKPiArc3RhdGljIHZvaWQgdmx2X3NldF9taXBpX2JhY2ts aWdodChzdHJ1Y3QgaW50ZWxfY29ubmVjdG9yICpjb25uZWN0b3IsIHUzMiBsZXZlbCkKPiArewo+ ICsJc3RydWN0IGludGVsX3BhbmVsICpwYW5lbCA9ICZjb25uZWN0b3ItPnBhbmVsOwo+ICsJaW50 IGR1dHlfbnMgPSBESVZfUk9VTkRfVVAobGV2ZWwgKiBDUkNfUE1JQ19QV01fUEVSSU9EX05TLCAx MDApOwo+ICsKPiArCXB3bV9jb25maWcocGFuZWwtPmJhY2tsaWdodC5wd20sIGR1dHlfbnMsIENS Q19QTUlDX1BXTV9QRVJJT0RfTlMpOwo+ICt9Cj4gKwo+ICBzdGF0aWMgdm9pZAo+ICBpbnRlbF9w YW5lbF9hY3R1YWxseV9zZXRfYmFja2xpZ2h0KHN0cnVjdCBpbnRlbF9jb25uZWN0b3IgKmNvbm5l Y3RvciwgdTMyIGxldmVsKQo+ICB7Cj4gQEAgLTc0MSw2ICs3NjIsMTYgQEAgc3RhdGljIHZvaWQg dmx2X2Rpc2FibGVfYmFja2xpZ2h0KHN0cnVjdCBpbnRlbF9jb25uZWN0b3IgKmNvbm5lY3RvcikK PiAgCUk5MTVfV1JJVEUoVkxWX0JMQ19QV01fQ1RMMihwaXBlKSwgdG1wICYgfkJMTV9QV01fRU5B QkxFKTsKPiAgfQo+ICAKPiArc3RhdGljIHZvaWQgdmx2X2Rpc2FibGVfbWlwaV9iYWNrbGlnaHQo c3RydWN0IGludGVsX2Nvbm5lY3RvciAqY29ubmVjdG9yKQo+ICt7Cj4gKwlzdHJ1Y3QgaW50ZWxf cGFuZWwgKnBhbmVsID0gJmNvbm5lY3Rvci0+cGFuZWw7Cj4gKwo+ICsJLyogRGlzYWJsZSB0aGUg YmFja2xpZ2h0ICovCj4gKwlwd21fY29uZmlnKHBhbmVsLT5iYWNrbGlnaHQucHdtLCAwLCBDUkNf UE1JQ19QV01fUEVSSU9EX05TKTsKPiArCXVzbGVlcF9yYW5nZSgyMDAwLCAzMDAwKTsKPiArCXB3 bV9kaXNhYmxlKHBhbmVsLT5iYWNrbGlnaHQucHdtKTsKPiArfQo+ICsKPiAgdm9pZCBpbnRlbF9w YW5lbF9kaXNhYmxlX2JhY2tsaWdodChzdHJ1Y3QgaW50ZWxfY29ubmVjdG9yICpjb25uZWN0b3Ip Cj4gIHsKPiAgCXN0cnVjdCBkcm1fZGV2aWNlICpkZXYgPSBjb25uZWN0b3ItPmJhc2UuZGV2Owo+ IEBAIC05NDcsNiArOTc4LDE2IEBAIHN0YXRpYyB2b2lkIHZsdl9lbmFibGVfYmFja2xpZ2h0KHN0 cnVjdCBpbnRlbF9jb25uZWN0b3IgKmNvbm5lY3RvcikKPiAgCUk5MTVfV1JJVEUoVkxWX0JMQ19Q V01fQ1RMMihwaXBlKSwgY3RsMiB8IEJMTV9QV01fRU5BQkxFKTsKPiAgfQo+ICAKPiArc3RhdGlj IHZvaWQgdmx2X2VuYWJsZV9taXBpX2JhY2tsaWdodChzdHJ1Y3QgaW50ZWxfY29ubmVjdG9yICpj b25uZWN0b3IpCj4gK3sKPiArCXN0cnVjdCBpbnRlbF9wYW5lbCAqcGFuZWwgPSAmY29ubmVjdG9y LT5wYW5lbDsKPiArCWludCBkdXR5X25zID0gRElWX1JPVU5EX1VQKAo+ICsJCQlwYW5lbC0+YmFj a2xpZ2h0LmxldmVsICogQ1JDX1BNSUNfUFdNX1BFUklPRF9OUywgMTAwKTsKPiArCj4gKwlwd21f ZW5hYmxlKHBhbmVsLT5iYWNrbGlnaHQucHdtKTsKPiArCXB3bV9jb25maWcocGFuZWwtPmJhY2ts aWdodC5wd20sIGR1dHlfbnMsIENSQ19QTUlDX1BXTV9QRVJJT0RfTlMpOwoKQWxsIG90aGVyIGVu YWJsZSBmdW5jdGlvbnMgY2FsbAoKCWludGVsX3BhbmVsX2FjdHVhbGx5X3NldF9iYWNrbGlnaHQo Y29ubmVjdG9yLCBwYW5lbC0+YmFja2xpZ2h0LmxldmVsKTsKCnRvIGRvIHRoaXMuIEl0J2xsIGdp dmUgeW91IGxvZ2dpbmcgdG9vLgoKPiArfQo+ICsKPiAgdm9pZCBpbnRlbF9wYW5lbF9lbmFibGVf YmFja2xpZ2h0KHN0cnVjdCBpbnRlbF9jb25uZWN0b3IgKmNvbm5lY3RvcikKPiAgewo+ICAJc3Ry dWN0IGRybV9kZXZpY2UgKmRldiA9IGNvbm5lY3Rvci0+YmFzZS5kZXY7Cj4gQEAgLTEyOTksNiAr MTM0MCwzNCBAQCBzdGF0aWMgaW50IHZsdl9zZXR1cF9iYWNrbGlnaHQoc3RydWN0IGludGVsX2Nv bm5lY3RvciAqY29ubmVjdG9yLCBlbnVtIHBpcGUgcGlwZQo+ICAJcmV0dXJuIDA7Cj4gIH0KPiAg Cj4gK3N0YXRpYyBpbnQgdmx2X3NldHVwX21pcGlfYmFja2xpZ2h0KHN0cnVjdCBpbnRlbF9jb25u ZWN0b3IgKmNvbm5lY3RvciwgZW51bSBwaXBlIHBpcGUpCj4gK3sKPiArCXN0cnVjdCBkcm1fZGV2 aWNlICpkZXYgPSBjb25uZWN0b3ItPmJhc2UuZGV2Owo+ICsJc3RydWN0IGludGVsX3BhbmVsICpw YW5lbCA9ICZjb25uZWN0b3ItPnBhbmVsOwo+ICsKPiArCS8qIEdldCB0aGUgUFdNIGNoaXAgZm9y IGJhY2tsaWdodCBjb250cm9sICovCj4gKwlwYW5lbC0+YmFja2xpZ2h0LnB3bSA9IHB3bV9nZXQo ZGV2LT5kZXYsICJwd21fYmFja2xpZ2h0Iik7Cj4gKwlpZiAoSVNfRVJSKHBhbmVsLT5iYWNrbGln aHQucHdtKSkgewo+ICsJCURSTV9FUlJPUigiRmFpbGQgdG8gb3duIHRoZSBwd20gY2hpcFxuIik7 Cj4gKwkJcGFuZWwtPmJhY2tsaWdodC5wd20gPSBOVUxMOwoKSSB0aGluayB5b3Ugd2FudCB0byBy ZXR1cm4gLUVOT0RFViBoZXJlLiBBbmQgdGhlbiB5b3UgY2FuIGRyb3AgdGhlCiJlbHNlIiBiZWxv dyBhbmQgbWFrZSB0aGF0IGEgbm9ybWFsIGlmLgoKPiArCX0gZWxzZSBpZiAocHdtX2NvbmZpZyhw YW5lbC0+YmFja2xpZ2h0LnB3bSwgQ1JDX1BNSUNfUFdNX1BFUklPRF9OUywKPiArCQkJCQkJQ1JD X1BNSUNfUFdNX1BFUklPRF9OUykgPCAwKSB7Cj4gKwkJRFJNX0VSUk9SKCJGYWlsZWQgdG8gY29u ZmlndXJlIHRoZSBwd20gY2hpcFxuIik7Cj4gKwkJcHdtX3B1dChwYW5lbC0+YmFja2xpZ2h0LnB3 bSk7Cj4gKwkJcGFuZWwtPmJhY2tsaWdodC5wd20gPSBOVUxMOwo+ICsJCXJldHVybiAtMTsKClNh dmUgd2hhdGV2ZXIgcHdtX2NvbmZpZyByZXR1cm5zIGFuZCByZXR1cm4gdGhhdCBpbnN0ZWFkIG9m IC0xLgoKPiArCX0KPiArCj4gKwlwYW5lbC0+YmFja2xpZ2h0Lm1pbiA9IDA7IC8qIDAlICovCj4g KwlwYW5lbC0+YmFja2xpZ2h0Lm1heCA9IDEwMDsgLyogMTAwJSAqLwo+ICsJcGFuZWwtPmJhY2ts aWdodC5sZXZlbCA9IERJVl9ST1VORF9VUCgKPiArCQkJCSBwd21fZ2V0X2R1dHlfY3ljbGUocGFu ZWwtPmJhY2tsaWdodC5wd20pICogMTAwLAo+ICsJCQkJIENSQ19QTUlDX1BXTV9QRVJJT0RfTlMp Owo+ICsJcGFuZWwtPmJhY2tsaWdodC5lbmFibGVkID0gcGFuZWwtPmJhY2tsaWdodC5sZXZlbCA/ IHRydWUgOiBmYWxzZTsKCnBhbmVsLT5iYWNrbGlnaHQubGV2ZWwgIT0gMAoKPiArCj4gKwlyZXR1 cm4gMDsKPiArfQo+ICsKPiAgaW50IGludGVsX3BhbmVsX3NldHVwX2JhY2tsaWdodChzdHJ1Y3Qg ZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9yLCBlbnVtIHBpcGUgcGlwZSkKPiAgewo+ICAJc3RydWN0 IGRybV9kZXZpY2UgKmRldiA9IGNvbm5lY3Rvci0+ZGV2Owo+IEBAIC0xMzYzLDExICsxNDMyLDE5 IEBAIHZvaWQgaW50ZWxfcGFuZWxfaW5pdF9iYWNrbGlnaHRfZnVuY3Moc3RydWN0IGRybV9kZXZp Y2UgKmRldikKPiAgCQlkZXZfcHJpdi0+ZGlzcGxheS5zZXRfYmFja2xpZ2h0ID0gcGNoX3NldF9i YWNrbGlnaHQ7Cj4gIAkJZGV2X3ByaXYtPmRpc3BsYXkuZ2V0X2JhY2tsaWdodCA9IHBjaF9nZXRf YmFja2xpZ2h0Owo+ICAJfSBlbHNlIGlmIChJU19WQUxMRVlWSUVXKGRldikpIHsKPiAtCQlkZXZf cHJpdi0+ZGlzcGxheS5zZXR1cF9iYWNrbGlnaHQgPSB2bHZfc2V0dXBfYmFja2xpZ2h0Owo+IC0J CWRldl9wcml2LT5kaXNwbGF5LmVuYWJsZV9iYWNrbGlnaHQgPSB2bHZfZW5hYmxlX2JhY2tsaWdo dDsKPiAtCQlkZXZfcHJpdi0+ZGlzcGxheS5kaXNhYmxlX2JhY2tsaWdodCA9IHZsdl9kaXNhYmxl X2JhY2tsaWdodDsKPiAtCQlkZXZfcHJpdi0+ZGlzcGxheS5zZXRfYmFja2xpZ2h0ID0gdmx2X3Nl dF9iYWNrbGlnaHQ7Cj4gLQkJZGV2X3ByaXYtPmRpc3BsYXkuZ2V0X2JhY2tsaWdodCA9IHZsdl9n ZXRfYmFja2xpZ2h0Owo+ICsJCWlmIChkZXZfcHJpdi0+dmJ0Lmhhc19taXBpKSB7Cj4gKwkJCWRl dl9wcml2LT5kaXNwbGF5LnNldHVwX2JhY2tsaWdodCA9IHZsdl9zZXR1cF9taXBpX2JhY2tsaWdo dDsKPiArCQkJZGV2X3ByaXYtPmRpc3BsYXkuZW5hYmxlX2JhY2tsaWdodCA9IHZsdl9lbmFibGVf bWlwaV9iYWNrbGlnaHQ7Cj4gKwkJCWRldl9wcml2LT5kaXNwbGF5LmRpc2FibGVfYmFja2xpZ2h0 ID0gdmx2X2Rpc2FibGVfbWlwaV9iYWNrbGlnaHQ7Cj4gKwkJCWRldl9wcml2LT5kaXNwbGF5LnNl dF9iYWNrbGlnaHQgPSB2bHZfc2V0X21pcGlfYmFja2xpZ2h0Owo+ICsJCQlkZXZfcHJpdi0+ZGlz cGxheS5nZXRfYmFja2xpZ2h0ID0gdmx2X2dldF9taXBpX2JhY2tsaWdodDsKPiArCQl9IGVsc2Ug ewo+ICsJCQlkZXZfcHJpdi0+ZGlzcGxheS5zZXR1cF9iYWNrbGlnaHQgPSB2bHZfc2V0dXBfYmFj a2xpZ2h0Owo+ICsJCQlkZXZfcHJpdi0+ZGlzcGxheS5lbmFibGVfYmFja2xpZ2h0ID0gdmx2X2Vu YWJsZV9iYWNrbGlnaHQ7Cj4gKwkJCWRldl9wcml2LT5kaXNwbGF5LmRpc2FibGVfYmFja2xpZ2h0 ID0gdmx2X2Rpc2FibGVfYmFja2xpZ2h0Owo+ICsJCQlkZXZfcHJpdi0+ZGlzcGxheS5zZXRfYmFj a2xpZ2h0ID0gdmx2X3NldF9iYWNrbGlnaHQ7Cj4gKwkJCWRldl9wcml2LT5kaXNwbGF5LmdldF9i YWNrbGlnaHQgPSB2bHZfZ2V0X2JhY2tsaWdodDsKPiArCQl9Cj4gIAl9IGVsc2UgaWYgKElTX0dF TjQoZGV2KSkgewo+ICAJCWRldl9wcml2LT5kaXNwbGF5LnNldHVwX2JhY2tsaWdodCA9IGk5NjVf c2V0dXBfYmFja2xpZ2h0Owo+ICAJCWRldl9wcml2LT5kaXNwbGF5LmVuYWJsZV9iYWNrbGlnaHQg PSBpOTY1X2VuYWJsZV9iYWNrbGlnaHQ7Cj4gQEAgLTE0MDQsNiArMTQ4MSwxMSBAQCB2b2lkIGlu dGVsX3BhbmVsX2Zpbmkoc3RydWN0IGludGVsX3BhbmVsICpwYW5lbCkKPiAgCWlmIChwYW5lbC0+ ZG93bmNsb2NrX21vZGUpCj4gIAkJZHJtX21vZGVfZGVzdHJveShpbnRlbF9jb25uZWN0b3ItPmJh c2UuZGV2LAo+ICAJCQkJcGFuZWwtPmRvd25jbG9ja19tb2RlKTsKPiArCj4gKwkvKiBkaXNwb3Nl IG9mIHRoZSBwd20gKi8KPiArCWlmIChwYW5lbC0+YmFja2xpZ2h0LnB3bSkKPiArCQlwd21fcHV0 KHBhbmVsLT5iYWNrbGlnaHQucHdtKTsKPiArCgpUaGUgY2xlYW51cCBzaG91bGQgYmUgaW4gaW50 ZWxfcGFuZWxfZGVzdHJveV9iYWNrbGlnaHQgdG8gbWF0Y2ggd2hlcmUKLnB3bSBpcyBpbml0aWFs aXplZC4KCkJSLApKYW5pLgoKPiAgfQo+ICAKPiAgdm9pZCBpbnRlbF9iYWNrbGlnaHRfcmVnaXN0 ZXIoc3RydWN0IGRybV9kZXZpY2UgKmRldikKPiAtLSAKPiAyLjEuMAo+CgotLSAKSmFuaSBOaWt1 bGEsIEludGVsIE9wZW4gU291cmNlIFRlY2hub2xvZ3kgQ2VudGVyCl9fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCkludGVsLWdmeCBtYWlsaW5nIGxpc3QKSW50 ZWwtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3Jn L21haWxtYW4vbGlzdGluZm8vaW50ZWwtZ2Z4Cg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752625AbbEFNlZ (ORCPT ); Wed, 6 May 2015 09:41:25 -0400 Received: from mga14.intel.com ([192.55.52.115]:2327 "EHLO mga14.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751365AbbEFNlV (ORCPT ); Wed, 6 May 2015 09:41:21 -0400 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.13,379,1427785200"; d="scan'208";a="721599505" From: Jani Nikula To: Shobhit Kumar , intel-gfx , linux-kernel , linux-gpio , linux-pwm , dri-devel Cc: Linus Walleij , Alexandre Courbot , Daniel Vetter , David Airlie , Samuel Ortiz , Thierry Reding , Lee Jones , Povilas Staniulis , Chih-Wei Huang , Shobhit Kumar Subject: Re: [PATCH 8/8] drm/i915: Backlight control using CRC PMIC based PWM driver In-Reply-To: <1430316005-16480-9-git-send-email-shobhit.kumar@intel.com> Organization: Intel Finland Oy - BIC 0357606-4 - Westendinkatu 7, 02160 Espoo References: <1430316005-16480-1-git-send-email-shobhit.kumar@intel.com> <1430316005-16480-9-git-send-email-shobhit.kumar@intel.com> User-Agent: Notmuch/0.19+87~gcf99a78 (http://notmuchmail.org) Emacs/24.4.1 (x86_64-pc-linux-gnu) Date: Wed, 06 May 2015 16:39:40 +0300 Message-ID: <87y4l1ddur.fsf@intel.com> MIME-Version: 1.0 Content-Type: text/plain Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Wed, 29 Apr 2015, 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 > > CC: Samuel Ortiz > Cc: Linus Walleij > Cc: Alexandre Courbot > Cc: Thierry Reding > Signed-off-by: Shobhit Kumar > --- > drivers/gpu/drm/i915/intel_drv.h | 5 +++ > drivers/gpu/drm/i915/intel_dsi.c | 6 +++ > drivers/gpu/drm/i915/intel_panel.c | 92 +++++++++++++++++++++++++++++++++++--- > 3 files changed, 98 insertions(+), 5 deletions(-) > > diff --git a/drivers/gpu/drm/i915/intel_drv.h b/drivers/gpu/drm/i915/intel_drv.h > index 897f17d..b4ebe3b 100644 > --- a/drivers/gpu/drm/i915/intel_drv.h > +++ b/drivers/gpu/drm/i915/intel_drv.h > @@ -182,7 +182,12 @@ 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; > + Superfluous whitespace. > } backlight; > > void (*backlight_power)(struct intel_connector *, bool enable); > diff --git a/drivers/gpu/drm/i915/intel_dsi.c b/drivers/gpu/drm/i915/intel_dsi.c > index be55ffa..83c4540 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); > > return; > > diff --git a/drivers/gpu/drm/i915/intel_panel.c b/drivers/gpu/drm/i915/intel_panel.c > index 08532d4..5700f6f 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 > + > void > intel_fixed_panel_mode(const struct drm_display_mode *fixed_mode, > struct drm_display_mode *adjusted_mode) > @@ -536,6 +540,15 @@ static u32 vlv_get_backlight(struct intel_connector *connector) > return _vlv_get_backlight(dev, pipe); > } > > +static u32 vlv_get_mipi_backlight(struct intel_connector *connector) I'd rather call this either pmic_get_backlight or even pwm_get_backlight because there's nothing really vlv specific about the functions themselves. Same for all of them. > +{ > + 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); Basically we have all the code in place to do the scaling from hw to user. See the note in intel_backlight_device_register. We shouldn't need to add additional scaling all around. However this can be a future cleanup IMO. > +} > + > static u32 intel_panel_get_backlight(struct intel_connector *connector) > { > struct drm_device *dev = connector->base.dev; > @@ -616,6 +629,14 @@ static void vlv_set_backlight(struct intel_connector *connector, u32 level) > I915_WRITE(VLV_BLC_PWM_CTL(pipe), tmp | level); > } > > +static void vlv_set_mipi_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) > { > @@ -741,6 +762,16 @@ static void vlv_disable_backlight(struct intel_connector *connector) > I915_WRITE(VLV_BLC_PWM_CTL2(pipe), tmp & ~BLM_PWM_ENABLE); > } > > +static void vlv_disable_mipi_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; > @@ -947,6 +978,16 @@ static void vlv_enable_backlight(struct intel_connector *connector) > I915_WRITE(VLV_BLC_PWM_CTL2(pipe), ctl2 | BLM_PWM_ENABLE); > } > > +static void vlv_enable_mipi_backlight(struct intel_connector *connector) > +{ > + struct intel_panel *panel = &connector->panel; > + int duty_ns = DIV_ROUND_UP( > + panel->backlight.level * CRC_PMIC_PWM_PERIOD_NS, 100); > + > + pwm_enable(panel->backlight.pwm); > + pwm_config(panel->backlight.pwm, duty_ns, CRC_PMIC_PWM_PERIOD_NS); All other enable functions call intel_panel_actually_set_backlight(connector, panel->backlight.level); to do this. It'll give you logging too. > +} > + > void intel_panel_enable_backlight(struct intel_connector *connector) > { > struct drm_device *dev = connector->base.dev; > @@ -1299,6 +1340,34 @@ static int vlv_setup_backlight(struct intel_connector *connector, enum pipe pipe > return 0; > } > > +static int vlv_setup_mipi_backlight(struct intel_connector *connector, enum pipe pipe) > +{ > + struct drm_device *dev = connector->base.dev; > + struct intel_panel *panel = &connector->panel; > + > + /* Get the PWM chip for backlight control */ > + panel->backlight.pwm = pwm_get(dev->dev, "pwm_backlight"); > + if (IS_ERR(panel->backlight.pwm)) { > + DRM_ERROR("Faild to own the pwm chip\n"); > + panel->backlight.pwm = NULL; I think you want to return -ENODEV here. And then you can drop the "else" below and make that a normal if. > + } else if (pwm_config(panel->backlight.pwm, CRC_PMIC_PWM_PERIOD_NS, > + CRC_PMIC_PWM_PERIOD_NS) < 0) { > + DRM_ERROR("Failed to configure the pwm chip\n"); > + pwm_put(panel->backlight.pwm); > + panel->backlight.pwm = NULL; > + return -1; Save whatever pwm_config returns and return that instead of -1. > + } > + > + 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 ? true : false; panel->backlight.level != 0 > + > + return 0; > +} > + > int intel_panel_setup_backlight(struct drm_connector *connector, enum pipe pipe) > { > struct drm_device *dev = connector->dev; > @@ -1363,11 +1432,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) { > + dev_priv->display.setup_backlight = vlv_setup_mipi_backlight; > + dev_priv->display.enable_backlight = vlv_enable_mipi_backlight; > + dev_priv->display.disable_backlight = vlv_disable_mipi_backlight; > + dev_priv->display.set_backlight = vlv_set_mipi_backlight; > + dev_priv->display.get_backlight = vlv_get_mipi_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; > @@ -1404,6 +1481,11 @@ void intel_panel_fini(struct intel_panel *panel) > if (panel->downclock_mode) > drm_mode_destroy(intel_connector->base.dev, > panel->downclock_mode); > + > + /* dispose of the pwm */ > + if (panel->backlight.pwm) > + pwm_put(panel->backlight.pwm); > + The cleanup should be in intel_panel_destroy_backlight to match where .pwm is initialized. BR, Jani. > } > > void intel_backlight_register(struct drm_device *dev) > -- > 2.1.0 > -- Jani Nikula, Intel Open Source Technology Center