From mboxrd@z Thu Jan 1 00:00:00 1970 From: Shobhit Kumar Subject: [v3 7/7] drm/i915: Backlight control using CRC PMIC based PWM driver Date: Fri, 26 Jun 2015 14:32:10 +0530 Message-ID: <1435309330-50725-8-git-send-email-shobhit.kumar@intel.com> References: <1435309330-50725-1-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: <1435309330-50725-1-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: linux-pwm , intel-gfx , linux-kernel , dri-devel , linux-gpio Cc: Alexandre Courbot , Paul Bolle , Samuel Ortiz , Povilas Staniulis , Jani Nikula , Shobhit Kumar , Linus Walleij , varkabhadram@gmail.com, Paul Gortmaker , bloften80@gmail.com, David Airlie , Chih-Wei Huang , Thierry Reding , Daniel Vetter , Lee Jones List-Id: linux-gpio@vger.kernel.org VXNlIHRoZSBDUkMgUFdNIGRldmljZSBpbiBpbnRlbF9wYW5lbC5jIGFuZCBhZGQgbmV3IE1JUEkg YmFja2xpZ2h0CnNwZWNpZmlmYyBjYWxsYmFja3MKCnYyOiBNb2RpZnkgdG8gdXNlIHB3bV9jb25m aWcgY2FsbGJhY2sKdjM6IEFkZHJlc3NlZCBKYW5pJ3MgY29tbWVudHMKICAgIC0gUmVuYW1lZCBh bGwgZnVuY3Rpb24gYXMgcHdtXyogaW5zdGVhZCBvZiB2bHZfKgogICAgLSBDYWxsIGludGVsX3Bh bmVsX2FjdHVhbGx5X3NldF9iYWNrbGlnaHQgaW4gZW5hYmxlIGZ1bmN0aW9uCiAgICAtIFJldHVy biAtRU5PREVWIGluIGNhc2UgcHdtX2dldCBmYWlscwogICAgLSBpbiBjYXNlIHB3bV9jb25maWcg ZXJyb3IgcmV0dXJuIGVycm9yIGNkb2UgZnJvbSBwd21fY29uZmlnCiAgICAtIENsZWFudXAgcHdt IGluIGludGVsX3BhbmVsX2Rlc3Ryb3lfYmFja2xpZ2h0CnY0OiBSZW1vdmVkIHVudXNlZCAjZGVm aW5lcyBhbmQgaW5pdGlhbGl6ZWQgYmFja2xpZ2h0IHdpdGggSU5WQUxJRF9QSVBFIChWaWxsZSkK CkNDOiBTYW11ZWwgT3J0aXogPHNhbWVvQGxpbnV4LmludGVsLmNvbT4KQ2M6IExpbnVzIFdhbGxl aWogPGxpbnVzLndhbGxlaWpAbGluYXJvLm9yZz4KQ2M6IEFsZXhhbmRyZSBDb3VyYm90IDxnbnVy b3VAZ21haWwuY29tPgpDYzogVGhpZXJyeSBSZWRpbmcgPHRoaWVycnkucmVkaW5nQGdtYWlsLmNv bT4KUmV2aWV3ZWQtYnk6IFZpbGxlIFN5cmrDpGzDpCA8dmlsbGUuc3lyamFsYUBsaW51eC5pbnRl bC5jb20+ClRlc3RlZC1ieTogVmlsbGUgU3lyasOkbMOkIDx2aWxsZS5zeXJqYWxhQGxpbnV4Lmlu dGVsLmNvbT4KU2lnbmVkLW9mZi1ieTogU2hvYmhpdCBLdW1hciA8c2hvYmhpdC5rdW1hckBpbnRl bC5jb20+Ci0tLQogZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHJ2LmggICB8ICA0ICsrCiBk cml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kc2kuYyAgIHwgIDUgKysKIGRyaXZlcnMvZ3B1L2Ry bS9pOTE1L2ludGVsX3BhbmVsLmMgfCA5NCArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKystLQogMyBmaWxlcyBjaGFuZ2VkLCA5OCBpbnNlcnRpb25zKCspLCA1IGRlbGV0aW9ucygt KQoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rydi5oIGIvZHJpdmVy cy9ncHUvZHJtL2k5MTUvaW50ZWxfZHJ2LmgKaW5kZXggMmFmYjMxYS4uNTYxYzE3ZiAxMDA2NDQK LS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHJ2LmgKKysrIGIvZHJpdmVycy9ncHUv ZHJtL2k5MTUvaW50ZWxfZHJ2LmgKQEAgLTE4Miw2ICsxODIsMTAgQEAgc3RydWN0IGludGVsX3Bh bmVsIHsKIAkJYm9vbCBlbmFibGVkOwogCQlib29sIGNvbWJpbmF0aW9uX21vZGU7CS8qIGdlbiAy LzQgb25seSAqLwogCQlib29sIGFjdGl2ZV9sb3dfcHdtOworCisJCS8qIFBXTSBjaGlwICovCisJ CXN0cnVjdCBwd21fZGV2aWNlICpwd207CisKIAkJc3RydWN0IGJhY2tsaWdodF9kZXZpY2UgKmRl dmljZTsKIAl9IGJhY2tsaWdodDsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUv aW50ZWxfZHNpLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kc2kuYwppbmRleCBjNGRi NzRhLi44OTJiOTM2IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kc2ku YworKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kc2kuYwpAQCAtNDAyLDYgKzQwMiw4 IEBAIHN0YXRpYyB2b2lkIGludGVsX2RzaV9lbmFibGUoc3RydWN0IGludGVsX2VuY29kZXIgKmVu Y29kZXIpCiAKIAkJaW50ZWxfZHNpX3BvcnRfZW5hYmxlKGVuY29kZXIpOwogCX0KKworCWludGVs X3BhbmVsX2VuYWJsZV9iYWNrbGlnaHQoaW50ZWxfZHNpLT5hdHRhY2hlZF9jb25uZWN0b3IpOwog fQogCiBzdGF0aWMgdm9pZCBpbnRlbF9kc2lfcHJlX2VuYWJsZShzdHJ1Y3QgaW50ZWxfZW5jb2Rl ciAqZW5jb2RlcikKQEAgLTQ2Niw2ICs0NjgsOCBAQCBzdGF0aWMgdm9pZCBpbnRlbF9kc2lfcHJl X2Rpc2FibGUoc3RydWN0IGludGVsX2VuY29kZXIgKmVuY29kZXIpCiAKIAlEUk1fREVCVUdfS01T KCJcbiIpOwogCisJaW50ZWxfcGFuZWxfZGlzYWJsZV9iYWNrbGlnaHQoaW50ZWxfZHNpLT5hdHRh Y2hlZF9jb25uZWN0b3IpOworCiAJaWYgKGlzX3ZpZF9tb2RlKGludGVsX2RzaSkpIHsKIAkJLyog U2VuZCBTaHV0ZG93biBjb21tYW5kIHRvIHRoZSBwYW5lbCBpbiBMUCBtb2RlICovCiAJCWZvcl9l YWNoX2RzaV9wb3J0KHBvcnQsIGludGVsX2RzaS0+cG9ydHMpCkBAIC0xMTMyLDYgKzExMzYsNyBA QCB2b2lkIGludGVsX2RzaV9pbml0KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYpCiAJfQogCiAJaW50 ZWxfcGFuZWxfaW5pdCgmaW50ZWxfY29ubmVjdG9yLT5wYW5lbCwgZml4ZWRfbW9kZSwgTlVMTCk7 CisJaW50ZWxfcGFuZWxfc2V0dXBfYmFja2xpZ2h0KGNvbm5lY3RvciwgSU5WQUxJRF9QSVBFKTsK IAogCXJldHVybjsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfcGFu ZWwuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3BhbmVsLmMKaW5kZXggN2Q4MzUyNy4u OTUyZmFkYyAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfcGFuZWwuYwor KysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9wYW5lbC5jCkBAIC0zMiw4ICszMiwxMSBA QAogCiAjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CiAjaW5jbHVkZSA8bGludXgvbW9kdWxlcGFy YW0uaD4KKyNpbmNsdWRlIDxsaW51eC9wd20uaD4KICNpbmNsdWRlICJpbnRlbF9kcnYuaCIKIAor I2RlZmluZSBDUkNfUE1JQ19QV01fUEVSSU9EX05TCTIxMzMzCisKIHZvaWQKIGludGVsX2ZpeGVk X3BhbmVsX21vZGUoY29uc3Qgc3RydWN0IGRybV9kaXNwbGF5X21vZGUgKmZpeGVkX21vZGUsCiAJ CSAgICAgICBzdHJ1Y3QgZHJtX2Rpc3BsYXlfbW9kZSAqYWRqdXN0ZWRfbW9kZSkKQEAgLTU0NCw2 ICs1NDcsMTUgQEAgc3RhdGljIHUzMiBieHRfZ2V0X2JhY2tsaWdodChzdHJ1Y3QgaW50ZWxfY29u bmVjdG9yICpjb25uZWN0b3IpCiAJcmV0dXJuIEk5MTVfUkVBRChCWFRfQkxDX1BXTV9EVVRZMSk7 CiB9CiAKK3N0YXRpYyB1MzIgcHdtX2dldF9iYWNrbGlnaHQoc3RydWN0IGludGVsX2Nvbm5lY3Rv ciAqY29ubmVjdG9yKQoreworCXN0cnVjdCBpbnRlbF9wYW5lbCAqcGFuZWwgPSAmY29ubmVjdG9y LT5wYW5lbDsKKwlpbnQgZHV0eV9uczsKKworCWR1dHlfbnMgPSBwd21fZ2V0X2R1dHlfY3ljbGUo cGFuZWwtPmJhY2tsaWdodC5wd20pOworCXJldHVybiBESVZfUk9VTkRfVVAoZHV0eV9ucyAqIDEw MCwgQ1JDX1BNSUNfUFdNX1BFUklPRF9OUyk7Cit9CisKIHN0YXRpYyB1MzIgaW50ZWxfcGFuZWxf Z2V0X2JhY2tsaWdodChzdHJ1Y3QgaW50ZWxfY29ubmVjdG9yICpjb25uZWN0b3IpCiB7CiAJc3Ry dWN0IGRybV9kZXZpY2UgKmRldiA9IGNvbm5lY3Rvci0+YmFzZS5kZXY7CkBAIC02MzIsNiArNjQ0 LDE0IEBAIHN0YXRpYyB2b2lkIGJ4dF9zZXRfYmFja2xpZ2h0KHN0cnVjdCBpbnRlbF9jb25uZWN0 b3IgKmNvbm5lY3RvciwgdTMyIGxldmVsKQogCUk5MTVfV1JJVEUoQlhUX0JMQ19QV01fRFVUWTEs IGxldmVsKTsKIH0KIAorc3RhdGljIHZvaWQgcHdtX3NldF9iYWNrbGlnaHQoc3RydWN0IGludGVs X2Nvbm5lY3RvciAqY29ubmVjdG9yLCB1MzIgbGV2ZWwpCit7CisJc3RydWN0IGludGVsX3BhbmVs ICpwYW5lbCA9ICZjb25uZWN0b3ItPnBhbmVsOworCWludCBkdXR5X25zID0gRElWX1JPVU5EX1VQ KGxldmVsICogQ1JDX1BNSUNfUFdNX1BFUklPRF9OUywgMTAwKTsKKworCXB3bV9jb25maWcocGFu ZWwtPmJhY2tsaWdodC5wd20sIGR1dHlfbnMsIENSQ19QTUlDX1BXTV9QRVJJT0RfTlMpOworfQor CiBzdGF0aWMgdm9pZAogaW50ZWxfcGFuZWxfYWN0dWFsbHlfc2V0X2JhY2tsaWdodChzdHJ1Y3Qg aW50ZWxfY29ubmVjdG9yICpjb25uZWN0b3IsIHUzMiBsZXZlbCkKIHsKQEAgLTc2OSw2ICs3ODks MTYgQEAgc3RhdGljIHZvaWQgYnh0X2Rpc2FibGVfYmFja2xpZ2h0KHN0cnVjdCBpbnRlbF9jb25u ZWN0b3IgKmNvbm5lY3RvcikKIAlJOTE1X1dSSVRFKEJYVF9CTENfUFdNX0NUTDEsIHRtcCAmIH5C WFRfQkxDX1BXTV9FTkFCTEUpOwogfQogCitzdGF0aWMgdm9pZCBwd21fZGlzYWJsZV9iYWNrbGln aHQoc3RydWN0IGludGVsX2Nvbm5lY3RvciAqY29ubmVjdG9yKQoreworCXN0cnVjdCBpbnRlbF9w YW5lbCAqcGFuZWwgPSAmY29ubmVjdG9yLT5wYW5lbDsKKworCS8qIERpc2FibGUgdGhlIGJhY2ts aWdodCAqLworCXB3bV9jb25maWcocGFuZWwtPmJhY2tsaWdodC5wd20sIDAsIENSQ19QTUlDX1BX TV9QRVJJT0RfTlMpOworCXVzbGVlcF9yYW5nZSgyMDAwLCAzMDAwKTsKKwlwd21fZGlzYWJsZShw YW5lbC0+YmFja2xpZ2h0LnB3bSk7Cit9CisKIHZvaWQgaW50ZWxfcGFuZWxfZGlzYWJsZV9iYWNr bGlnaHQoc3RydWN0IGludGVsX2Nvbm5lY3RvciAqY29ubmVjdG9yKQogewogCXN0cnVjdCBkcm1f ZGV2aWNlICpkZXYgPSBjb25uZWN0b3ItPmJhc2UuZGV2OwpAQCAtMTAwMiw2ICsxMDMyLDE0IEBA IHN0YXRpYyB2b2lkIGJ4dF9lbmFibGVfYmFja2xpZ2h0KHN0cnVjdCBpbnRlbF9jb25uZWN0b3Ig KmNvbm5lY3RvcikKIAlJOTE1X1dSSVRFKEJYVF9CTENfUFdNX0NUTDEsIHB3bV9jdGwgfCBCWFRf QkxDX1BXTV9FTkFCTEUpOwogfQogCitzdGF0aWMgdm9pZCBwd21fZW5hYmxlX2JhY2tsaWdodChz dHJ1Y3QgaW50ZWxfY29ubmVjdG9yICpjb25uZWN0b3IpCit7CisJc3RydWN0IGludGVsX3BhbmVs ICpwYW5lbCA9ICZjb25uZWN0b3ItPnBhbmVsOworCisJcHdtX2VuYWJsZShwYW5lbC0+YmFja2xp Z2h0LnB3bSk7CisJaW50ZWxfcGFuZWxfYWN0dWFsbHlfc2V0X2JhY2tsaWdodChjb25uZWN0b3Is IHBhbmVsLT5iYWNrbGlnaHQubGV2ZWwpOworfQorCiB2b2lkIGludGVsX3BhbmVsX2VuYWJsZV9i YWNrbGlnaHQoc3RydWN0IGludGVsX2Nvbm5lY3RvciAqY29ubmVjdG9yKQogewogCXN0cnVjdCBk cm1fZGV2aWNlICpkZXYgPSBjb25uZWN0b3ItPmJhc2UuZGV2OwpAQCAtMTM3OCw2ICsxNDE2LDQw IEBAIGJ4dF9zZXR1cF9iYWNrbGlnaHQoc3RydWN0IGludGVsX2Nvbm5lY3RvciAqY29ubmVjdG9y LCBlbnVtIHBpcGUgdW51c2VkKQogCXJldHVybiAwOwogfQogCitzdGF0aWMgaW50IHB3bV9zZXR1 cF9iYWNrbGlnaHQoc3RydWN0IGludGVsX2Nvbm5lY3RvciAqY29ubmVjdG9yLAorCQkJICAgICAg IGVudW0gcGlwZSBwaXBlKQoreworCXN0cnVjdCBkcm1fZGV2aWNlICpkZXYgPSBjb25uZWN0b3It PmJhc2UuZGV2OworCXN0cnVjdCBpbnRlbF9wYW5lbCAqcGFuZWwgPSAmY29ubmVjdG9yLT5wYW5l bDsKKwlpbnQgcmV0dmFsOworCisJLyogR2V0IHRoZSBQV00gY2hpcCBmb3IgYmFja2xpZ2h0IGNv bnRyb2wgKi8KKwlwYW5lbC0+YmFja2xpZ2h0LnB3bSA9IHB3bV9nZXQoZGV2LT5kZXYsICJwd21f YmFja2xpZ2h0Iik7CisJaWYgKElTX0VSUihwYW5lbC0+YmFja2xpZ2h0LnB3bSkpIHsKKwkJRFJN X0VSUk9SKCJGYWlsZWQgdG8gb3duIHRoZSBwd20gY2hpcFxuIik7CisJCXBhbmVsLT5iYWNrbGln aHQucHdtID0gTlVMTDsKKwkJcmV0dXJuIC1FTk9ERVY7CisJfQorCisJcmV0dmFsID0gcHdtX2Nv bmZpZyhwYW5lbC0+YmFja2xpZ2h0LnB3bSwgQ1JDX1BNSUNfUFdNX1BFUklPRF9OUywKKwkJCSAg ICBDUkNfUE1JQ19QV01fUEVSSU9EX05TKTsKKwlpZiAocmV0dmFsIDwgMCkgeworCQlEUk1fRVJS T1IoIkZhaWxlZCB0byBjb25maWd1cmUgdGhlIHB3bSBjaGlwXG4iKTsKKwkJcHdtX3B1dChwYW5l bC0+YmFja2xpZ2h0LnB3bSk7CisJCXBhbmVsLT5iYWNrbGlnaHQucHdtID0gTlVMTDsKKwkJcmV0 dXJuIHJldHZhbDsKKwl9CisKKwlwYW5lbC0+YmFja2xpZ2h0Lm1pbiA9IDA7IC8qIDAlICovCisJ cGFuZWwtPmJhY2tsaWdodC5tYXggPSAxMDA7IC8qIDEwMCUgKi8KKwlwYW5lbC0+YmFja2xpZ2h0 LmxldmVsID0gRElWX1JPVU5EX1VQKAorCQkJCSBwd21fZ2V0X2R1dHlfY3ljbGUocGFuZWwtPmJh Y2tsaWdodC5wd20pICogMTAwLAorCQkJCSBDUkNfUE1JQ19QV01fUEVSSU9EX05TKTsKKwlwYW5l bC0+YmFja2xpZ2h0LmVuYWJsZWQgPSBwYW5lbC0+YmFja2xpZ2h0LmxldmVsICE9IDA7CisKKwly ZXR1cm4gMDsKK30KKwogaW50IGludGVsX3BhbmVsX3NldHVwX2JhY2tsaWdodChzdHJ1Y3QgZHJt X2Nvbm5lY3RvciAqY29ubmVjdG9yLCBlbnVtIHBpcGUgcGlwZSkKIHsKIAlzdHJ1Y3QgZHJtX2Rl dmljZSAqZGV2ID0gY29ubmVjdG9yLT5kZXY7CkBAIC0xNDIxLDYgKzE0OTMsMTAgQEAgdm9pZCBp bnRlbF9wYW5lbF9kZXN0cm95X2JhY2tsaWdodChzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubmVj dG9yKQogCXN0cnVjdCBpbnRlbF9jb25uZWN0b3IgKmludGVsX2Nvbm5lY3RvciA9IHRvX2ludGVs X2Nvbm5lY3Rvcihjb25uZWN0b3IpOwogCXN0cnVjdCBpbnRlbF9wYW5lbCAqcGFuZWwgPSAmaW50 ZWxfY29ubmVjdG9yLT5wYW5lbDsKIAorCS8qIGRpc3Bvc2Ugb2YgdGhlIHB3bSAqLworCWlmIChw YW5lbC0+YmFja2xpZ2h0LnB3bSkKKwkJcHdtX3B1dChwYW5lbC0+YmFja2xpZ2h0LnB3bSk7CisK IAlwYW5lbC0+YmFja2xpZ2h0LnByZXNlbnQgPSBmYWxzZTsKIH0KIApAQCAtMTQ0OCwxMSArMTUy NCwxOSBAQCB2b2lkIGludGVsX3BhbmVsX2luaXRfYmFja2xpZ2h0X2Z1bmNzKHN0cnVjdCBkcm1f ZGV2aWNlICpkZXYpCiAJCWRldl9wcml2LT5kaXNwbGF5LnNldF9iYWNrbGlnaHQgPSBwY2hfc2V0 X2JhY2tsaWdodDsKIAkJZGV2X3ByaXYtPmRpc3BsYXkuZ2V0X2JhY2tsaWdodCA9IHBjaF9nZXRf YmFja2xpZ2h0OwogCX0gZWxzZSBpZiAoSVNfVkFMTEVZVklFVyhkZXYpKSB7Ci0JCWRldl9wcml2 LT5kaXNwbGF5LnNldHVwX2JhY2tsaWdodCA9IHZsdl9zZXR1cF9iYWNrbGlnaHQ7Ci0JCWRldl9w cml2LT5kaXNwbGF5LmVuYWJsZV9iYWNrbGlnaHQgPSB2bHZfZW5hYmxlX2JhY2tsaWdodDsKLQkJ ZGV2X3ByaXYtPmRpc3BsYXkuZGlzYWJsZV9iYWNrbGlnaHQgPSB2bHZfZGlzYWJsZV9iYWNrbGln aHQ7Ci0JCWRldl9wcml2LT5kaXNwbGF5LnNldF9iYWNrbGlnaHQgPSB2bHZfc2V0X2JhY2tsaWdo dDsKLQkJZGV2X3ByaXYtPmRpc3BsYXkuZ2V0X2JhY2tsaWdodCA9IHZsdl9nZXRfYmFja2xpZ2h0 OworCQlpZiAoZGV2X3ByaXYtPnZidC5oYXNfbWlwaSkgeworCQkJZGV2X3ByaXYtPmRpc3BsYXku c2V0dXBfYmFja2xpZ2h0ID0gcHdtX3NldHVwX2JhY2tsaWdodDsKKwkJCWRldl9wcml2LT5kaXNw bGF5LmVuYWJsZV9iYWNrbGlnaHQgPSBwd21fZW5hYmxlX2JhY2tsaWdodDsKKwkJCWRldl9wcml2 LT5kaXNwbGF5LmRpc2FibGVfYmFja2xpZ2h0ID0gcHdtX2Rpc2FibGVfYmFja2xpZ2h0OworCQkJ ZGV2X3ByaXYtPmRpc3BsYXkuc2V0X2JhY2tsaWdodCA9IHB3bV9zZXRfYmFja2xpZ2h0OworCQkJ ZGV2X3ByaXYtPmRpc3BsYXkuZ2V0X2JhY2tsaWdodCA9IHB3bV9nZXRfYmFja2xpZ2h0OworCQl9 IGVsc2UgeworCQkJZGV2X3ByaXYtPmRpc3BsYXkuc2V0dXBfYmFja2xpZ2h0ID0gdmx2X3NldHVw X2JhY2tsaWdodDsKKwkJCWRldl9wcml2LT5kaXNwbGF5LmVuYWJsZV9iYWNrbGlnaHQgPSB2bHZf ZW5hYmxlX2JhY2tsaWdodDsKKwkJCWRldl9wcml2LT5kaXNwbGF5LmRpc2FibGVfYmFja2xpZ2h0 ID0gdmx2X2Rpc2FibGVfYmFja2xpZ2h0OworCQkJZGV2X3ByaXYtPmRpc3BsYXkuc2V0X2JhY2ts aWdodCA9IHZsdl9zZXRfYmFja2xpZ2h0OworCQkJZGV2X3ByaXYtPmRpc3BsYXkuZ2V0X2JhY2ts aWdodCA9IHZsdl9nZXRfYmFja2xpZ2h0OworCQl9CiAJfSBlbHNlIGlmIChJU19HRU40KGRldikp IHsKIAkJZGV2X3ByaXYtPmRpc3BsYXkuc2V0dXBfYmFja2xpZ2h0ID0gaTk2NV9zZXR1cF9iYWNr bGlnaHQ7CiAJCWRldl9wcml2LT5kaXNwbGF5LmVuYWJsZV9iYWNrbGlnaHQgPSBpOTY1X2VuYWJs ZV9iYWNrbGlnaHQ7Ci0tIAoxLjkuMQoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX18KSW50ZWwtZ2Z4IG1haWxpbmcgbGlzdApJbnRlbC1nZnhAbGlzdHMuZnJl ZWRlc2t0b3Aub3JnCmh0dHA6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5m by9pbnRlbC1nZngK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751751AbbFZJEV (ORCPT ); Fri, 26 Jun 2015 05:04:21 -0400 Received: from mga14.intel.com ([192.55.52.115]:28954 "EHLO mga14.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752712AbbFZJDK (ORCPT ); Fri, 26 Jun 2015 05:03:10 -0400 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.13,683,1427785200"; d="scan'208";a="718042927" From: Shobhit Kumar To: linux-pwm , intel-gfx , linux-kernel , dri-devel , linux-gpio Cc: Paul Bolle , Jani Nikula , Samuel Ortiz , Alexandre Courbot , David Airlie , Povilas Staniulis , Chih-Wei Huang , Thierry Reding , Daniel Vetter , Lee Jones , Linus Walleij , Paul Gortmaker , bloften80@gmail.com, varkabhadram@gmail.com, Shobhit Kumar Subject: [v3 7/7] drm/i915: Backlight control using CRC PMIC based PWM driver Date: Fri, 26 Jun 2015 14:32:10 +0530 Message-Id: <1435309330-50725-8-git-send-email-shobhit.kumar@intel.com> X-Mailer: git-send-email 1.9.1 In-Reply-To: <1435309330-50725-1-git-send-email-shobhit.kumar@intel.com> References: <1435309330-50725-1-git-send-email-shobhit.kumar@intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org 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 v4: Removed unused #defines and initialized backlight with INVALID_PIPE (Ville) CC: Samuel Ortiz Cc: Linus Walleij Cc: Alexandre Courbot Cc: Thierry Reding Reviewed-by: Ville Syrjälä Tested-by: Ville Syrjälä Signed-off-by: Shobhit Kumar --- drivers/gpu/drm/i915/intel_drv.h | 4 ++ drivers/gpu/drm/i915/intel_dsi.c | 5 ++ drivers/gpu/drm/i915/intel_panel.c | 94 ++++++++++++++++++++++++++++++++++++-- 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 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..892b936 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,7 @@ void intel_dsi_init(struct drm_device *dev) } intel_panel_init(&intel_connector->panel, fixed_mode, NULL); + intel_panel_setup_backlight(connector, INVALID_PIPE); return; diff --git a/drivers/gpu/drm/i915/intel_panel.c b/drivers/gpu/drm/i915/intel_panel.c index 7d83527..952fadc 100644 --- a/drivers/gpu/drm/i915/intel_panel.c +++ b/drivers/gpu/drm/i915/intel_panel.c @@ -32,8 +32,11 @@ #include #include +#include #include "intel_drv.h" +#define CRC_PMIC_PWM_PERIOD_NS 21333 + void intel_fixed_panel_mode(const struct drm_display_mode *fixed_mode, struct drm_display_mode *adjusted_mode) @@ -544,6 +547,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 +644,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 +789,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 +1032,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 +1416,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; + + /* 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 +1493,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 +1524,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 = 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