From mboxrd@z Thu Jan 1 00:00:00 1970 From: Hai Li Subject: [PATCH 4/4] drm/msm/mdp5: Enable DSI connector in msm drm driver Date: Fri, 13 Mar 2015 19:24:18 -0400 Message-ID: <1426289058-6663-5-git-send-email-hali@codeaurora.org> References: <1426289058-6663-1-git-send-email-hali@codeaurora.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1426289058-6663-1-git-send-email-hali@codeaurora.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: dri-devel@lists.freedesktop.org Cc: linux-arm-msm@vger.kernel.org, linux-kernel@vger.kernel.org List-Id: linux-arm-msm@vger.kernel.org VGhpcyBjaGFuZ2UgYWRkcyB0aGUgc3VwcG9ydCBpbiBtZHA1IGttcyBkcml2ZXIgZm9yIHNpbmds ZQphbmQgZHVhbCBEU0kuIER1YWwgRFNJIGNhc2UgZGVwZW5kcyBvbiB0aGUgZnJhbWV3b3JrIEFQ SQphbmQgc2VxdWVuY2UgY2hhbmdlIHRvIHN1cHBvcnQgZHVhbCBkYXRhIHBhdGguCgpTaWduZWQt b2ZmLWJ5OiBIYWkgTGkgPGhhbGlAY29kZWF1cm9yYS5vcmc+Ci0tLQogZHJpdmVycy9ncHUvZHJt L21zbS9tZHAvbWRwNS9tZHA1X2NmZy5jICAgICB8ICAgNCArCiBkcml2ZXJzL2dwdS9kcm0vbXNt L21kcC9tZHA1L21kcDVfY3J0Yy5jICAgIHwgIDExICstCiBkcml2ZXJzL2dwdS9kcm0vbXNtL21k cC9tZHA1L21kcDVfZW5jb2Rlci5jIHwgMjY4ICsrKysrKysrKysrKysrKysrKysrKysrKysrKy0K IGRyaXZlcnMvZ3B1L2RybS9tc20vbWRwL21kcDUvbWRwNV9rbXMuYyAgICAgfCAgNjkgKysrKysr LQogZHJpdmVycy9ncHUvZHJtL21zbS9tZHAvbWRwNS9tZHA1X2ttcy5oICAgICB8ICAxMiArLQog ZHJpdmVycy9ncHUvZHJtL21zbS9tc21fZHJ2LmMgICAgICAgICAgICAgICB8ICAgMiArCiA2IGZp bGVzIGNoYW5nZWQsIDM1MyBpbnNlcnRpb25zKCspLCAxMyBkZWxldGlvbnMoLSkKCmRpZmYgLS1n aXQgYS9kcml2ZXJzL2dwdS9kcm0vbXNtL21kcC9tZHA1L21kcDVfY2ZnLmMgYi9kcml2ZXJzL2dw dS9kcm0vbXNtL21kcC9tZHA1L21kcDVfY2ZnLmMKaW5kZXggNmM0NjdmYi4uMmM5YTlkYyAxMDA2 NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL21zbS9tZHAvbWRwNS9tZHA1X2NmZy5jCisrKyBiL2Ry aXZlcnMvZ3B1L2RybS9tc20vbWRwL21kcDUvbWRwNV9jZmcuYwpAQCAtNjgsNiArNjgsOCBAQCBj b25zdCBzdHJ1Y3QgbWRwNV9jZmdfaHcgbXNtOHg3NF9jb25maWcgPSB7CiAJfSwKIAkuaW50ZnMg PSB7CiAJCVswXSA9IElOVEZfZURQLAorCQlbMV0gPSBJTlRGX0RTSSwKKwkJWzJdID0gSU5URl9E U0ksCiAJCVszXSA9IElOVEZfSERNSSwKIAl9LAogCS5tYXhfY2xrID0gMjAwMDAwMDAwLApAQCAt MTI1LDYgKzEyNyw4IEBAIGNvbnN0IHN0cnVjdCBtZHA1X2NmZ19odyBhcHE4MDg0X2NvbmZpZyA9 IHsKIAl9LAogCS5pbnRmcyA9IHsKIAkJWzBdID0gSU5URl9lRFAsCisJCVsxXSA9IElOVEZfRFNJ LAorCQlbMl0gPSBJTlRGX0RTSSwKIAkJWzNdID0gSU5URl9IRE1JLAogCX0sCiAJLm1heF9jbGsg PSAzMjAwMDAwMDAsCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbXNtL21kcC9tZHA1L21k cDVfY3J0Yy5jIGIvZHJpdmVycy9ncHUvZHJtL21zbS9tZHAvbWRwNS9tZHA1X2NydGMuYwppbmRl eCA5YjM4Y2RlLi5mODc3ZTFkIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vbXNtL21kcC9t ZHA1L21kcDVfY3J0Yy5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9tc20vbWRwL21kcDUvbWRwNV9j cnRjLmMKQEAgLTYyNiw3ICs2MjYsMTYgQEAgdm9pZCBtZHA1X2NydGNfc2V0X2ludGYoc3RydWN0 IGRybV9jcnRjICpjcnRjLCBzdHJ1Y3QgbWRwNV9pbnRlcmZhY2UgKmludGYpCiAKIAkvKiBub3cg dGhhdCB3ZSBrbm93IHdoYXQgaXJxJ3Mgd2Ugd2FudDogKi8KIAltZHA1X2NydGMtPmVyci5pcnFt YXNrID0gaW50ZjJlcnIoaW50Zi0+bnVtKTsKLQltZHA1X2NydGMtPnZibGFuay5pcnFtYXNrID0g aW50ZjJ2YmxhbmsobG0sIGludGYpOworCisJLyogUmVnaXN0ZXIgY29tbWFuZCBtb2RlIFBpbmdw b25nIGRvbmUgYXMgdmJsYW5rIGZvciBub3csCisJICogc28gdGhhdCBhdG9taWMgY29tbWl0IHNo b3VsZCB3YWl0IGZvciBpdCB0byBmaW5pc2guCisJICogSWRlYWxseSwgaW4gdGhlIGZ1dHVyZSwg d2Ugc2hvdWxkIHRha2UgcmRfcHRyIGRvbmUgYXMgdmJsYW5rLAorCSAqIGFuZCBsZXQgYXRvbWlj IGNvbW1pdCB3YWl0IGZvciBwaW5ncG9uZyBkb25lIGZvciBjb21tb25kIG1vZGUuCisJICovCisJ aWYgKGludGYtPm1vZGUgPT0gTURQNV9JTlRGX0RTSV9NT0RFX0NPTU1BTkQpCisJCW1kcDVfY3J0 Yy0+dmJsYW5rLmlycW1hc2sgPSBsbTJwcGRvbmUobG0pOworCWVsc2UKKwkJbWRwNV9jcnRjLT52 YmxhbmsuaXJxbWFzayA9IGludGYydmJsYW5rKGxtLCBpbnRmKTsKIAltZHBfaXJxX3VwZGF0ZSgm bWRwNV9rbXMtPmJhc2UpOwogCiAJbWRwNV9jdGxfc2V0X2ludGYobWRwNV9jcnRjLT5jdGwsIGlu dGYpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL21zbS9tZHAvbWRwNS9tZHA1X2VuY29k ZXIuYyBiL2RyaXZlcnMvZ3B1L2RybS9tc20vbWRwL21kcDUvbWRwNV9lbmNvZGVyLmMKaW5kZXgg YTE3ZWI5Yy4uZWZlN2FhZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL21zbS9tZHAvbWRw NS9tZHA1X2VuY29kZXIuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL21kcC9tZHA1L21kcDVf ZW5jb2Rlci5jCkBAIC05OCw2ICs5OCwyMjEgQEAgc3RhdGljIHZvaWQgYnNfZmluaShzdHJ1Y3Qg bWRwNV9lbmNvZGVyICptZHA1X2VuY29kZXIpIHt9CiBzdGF0aWMgdm9pZCBic19zZXQoc3RydWN0 IG1kcDVfZW5jb2RlciAqbWRwNV9lbmNvZGVyLCBpbnQgaWR4KSB7fQogI2VuZGlmCiAKKy8qCisg KiBDb21tYW5kIG1vZGUgZW5jb2RlciwgdXNlZCBieSBEU0kgY29tbWFuZCBtb2RlIHBhdGguCisg KiBTaG91bGQgbW92ZSB0byBhIHNlcGFyYXRlIGZpbGUsIG9uY2UgZ2xvYmFsIGJhbmR3aWR0aAor ICogZnVuY3Rpb25zIGFyZSBhdmFpbGFibGUuCisgKi8KKyNkZWZpbmUgVlNZTkNfQ0xLX1JBVEUg MTkyMDAwMDAKK3N0YXRpYyBpbnQgcGluZ3BvbmdfdGVhcmNoZWNrX3NldHVwKHN0cnVjdCBkcm1f ZW5jb2RlciAqZW5jb2RlciwKKwkJCQkJc3RydWN0IGRybV9kaXNwbGF5X21vZGUgKm1vZGUpCit7 CisJc3RydWN0IG1kcDVfa21zICptZHA1X2ttcyA9IGdldF9rbXMoZW5jb2Rlcik7CisJc3RydWN0 IGRldmljZSAqZGV2ID0gZW5jb2Rlci0+ZGV2LT5kZXY7CisJdTMyIHRvdGFsX2xpbmVzX3gxMDAs IHZjbGtzX2xpbmUsIGNmZzsKKwlsb25nIHZzeW5jX2Nsa19zcGVlZDsKKwlpbnQgcHBfaWQgPSBH RVRfUElOR19QT05HX0lEKG1kcDVfY3J0Y19nZXRfbG0oZW5jb2Rlci0+Y3J0YykpOworCisJaWYg KElTX0VSUl9PUl9OVUxMKG1kcDVfa21zLT52c3luY19jbGspKSB7CisJCWRldl9lcnIoZGV2LCAi dnN5bmNfY2xrIGlzIG5vdCBpbml0aWFsaXplZFxuIik7CisJCXJldHVybiAtRUlOVkFMOworCX0K KworCXRvdGFsX2xpbmVzX3gxMDAgPSBtb2RlLT52dG90YWwgKiBtb2RlLT52cmVmcmVzaDsKKwlp ZiAoIXRvdGFsX2xpbmVzX3gxMDApIHsKKwkJZGV2X2VycihkZXYsICIlczogdnRvdGFsKCVkKSBv ciB2cmVmcmVzaCglZCkgaXMgMFxuIiwKKwkJCQlfX2Z1bmNfXywgbW9kZS0+dnRvdGFsLCBtb2Rl LT52cmVmcmVzaCk7CisJCXJldHVybiAtRUlOVkFMOworCX0KKworCXZzeW5jX2Nsa19zcGVlZCA9 IGNsa19yb3VuZF9yYXRlKG1kcDVfa21zLT52c3luY19jbGssIFZTWU5DX0NMS19SQVRFKTsKKwlp ZiAodnN5bmNfY2xrX3NwZWVkIDw9IDApIHsKKwkJZGV2X2VycihkZXYsICJ2c3luY19jbGsgcm91 bmQgcmF0ZSBmYWlsZWQgJWxkXG4iLAorCQkJCQkJCXZzeW5jX2Nsa19zcGVlZCk7CisJCXJldHVy biAtRUlOVkFMOworCX0KKwl2Y2xrc19saW5lID0gdnN5bmNfY2xrX3NwZWVkICogMTAwIC8gdG90 YWxfbGluZXNfeDEwMDsKKworCWNmZyA9IE1EUDVfUFBfU1lOQ19DT05GSUdfVlNZTkNfQ09VTlRF Ul9FTgorCQl8IE1EUDVfUFBfU1lOQ19DT05GSUdfVlNZTkNfSU5fRU47CisJY2ZnIHw9IE1EUDVf UFBfU1lOQ19DT05GSUdfVlNZTkNfQ09VTlQodmNsa3NfbGluZSk7CisKKwltZHA1X3dyaXRlKG1k cDVfa21zLCBSRUdfTURQNV9QUF9TWU5DX0NPTkZJR19WU1lOQyhwcF9pZCksIGNmZyk7CisJbWRw NV93cml0ZShtZHA1X2ttcywKKwkJUkVHX01EUDVfUFBfU1lOQ19DT05GSUdfSEVJR0hUKHBwX2lk KSwgMHhmZmYwKTsKKwltZHA1X3dyaXRlKG1kcDVfa21zLAorCQlSRUdfTURQNV9QUF9WU1lOQ19J TklUX1ZBTChwcF9pZCksIG1vZGUtPnZkaXNwbGF5KTsKKwltZHA1X3dyaXRlKG1kcDVfa21zLCBS RUdfTURQNV9QUF9SRF9QVFJfSVJRKHBwX2lkKSwgbW9kZS0+dmRpc3BsYXkgKyAxKTsKKwltZHA1 X3dyaXRlKG1kcDVfa21zLCBSRUdfTURQNV9QUF9TVEFSVF9QT1MocHBfaWQpLCBtb2RlLT52ZGlz cGxheSk7CisJbWRwNV93cml0ZShtZHA1X2ttcywgUkVHX01EUDVfUFBfU1lOQ19USFJFU0gocHBf aWQpLAorCQkJTURQNV9QUF9TWU5DX1RIUkVTSF9TVEFSVCg0KSB8CisJCQlNRFA1X1BQX1NZTkNf VEhSRVNIX0NPTlRJTlVFKDQpKTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IHBpbmdw b25nX3RlYXJjaGVja19lbmFibGUoc3RydWN0IGRybV9lbmNvZGVyICplbmNvZGVyKQoreworCXN0 cnVjdCBtZHA1X2ttcyAqbWRwNV9rbXMgPSBnZXRfa21zKGVuY29kZXIpOworCWludCBwcF9pZCA9 IEdFVF9QSU5HX1BPTkdfSUQobWRwNV9jcnRjX2dldF9sbShlbmNvZGVyLT5jcnRjKSk7CisJaW50 IHJldDsKKworCXJldCA9IGNsa19zZXRfcmF0ZShtZHA1X2ttcy0+dnN5bmNfY2xrLAorCQljbGtf cm91bmRfcmF0ZShtZHA1X2ttcy0+dnN5bmNfY2xrLCBWU1lOQ19DTEtfUkFURSkpOworCWlmIChy ZXQpIHsKKwkJZGV2X2VycihlbmNvZGVyLT5kZXYtPmRldiwKKwkJCSJ2c3luY19jbGsgY2xrX3Nl dF9yYXRlIGZhaWxlZCwgJWRcbiIsIHJldCk7CisJCXJldHVybiByZXQ7CisJfQorCXJldCA9IGNs a19wcmVwYXJlX2VuYWJsZShtZHA1X2ttcy0+dnN5bmNfY2xrKTsKKwlpZiAocmV0KSB7CisJCWRl dl9lcnIoZW5jb2Rlci0+ZGV2LT5kZXYsCisJCQkidnN5bmNfY2xrIGNsa19wcmVwYXJlX2VuYWJs ZSBmYWlsZWQsICVkXG4iLCByZXQpOworCQlyZXR1cm4gcmV0OworCX0KKworCW1kcDVfd3JpdGUo bWRwNV9rbXMsIFJFR19NRFA1X1BQX1RFQVJfQ0hFQ0tfRU4ocHBfaWQpLCAxKTsKKworCXJldHVy biAwOworfQorCitzdGF0aWMgdm9pZCBwaW5ncG9uZ190ZWFyY2hlY2tfZGlzYWJsZShzdHJ1Y3Qg ZHJtX2VuY29kZXIgKmVuY29kZXIpCit7CisJc3RydWN0IG1kcDVfa21zICptZHA1X2ttcyA9IGdl dF9rbXMoZW5jb2Rlcik7CisJaW50IHBwX2lkID0gR0VUX1BJTkdfUE9OR19JRChtZHA1X2NydGNf Z2V0X2xtKGVuY29kZXItPmNydGMpKTsKKworCW1kcDVfd3JpdGUobWRwNV9rbXMsIFJFR19NRFA1 X1BQX1RFQVJfQ0hFQ0tfRU4ocHBfaWQpLCAwKTsKKwljbGtfZGlzYWJsZV91bnByZXBhcmUobWRw NV9rbXMtPnZzeW5jX2Nsayk7Cit9CisKK3N0YXRpYyB2b2lkIG1kcDVfY21kX2VuY29kZXJfZGVz dHJveShzdHJ1Y3QgZHJtX2VuY29kZXIgKmVuY29kZXIpCit7CisJc3RydWN0IG1kcDVfZW5jb2Rl ciAqbWRwNV9lbmNvZGVyID0gdG9fbWRwNV9lbmNvZGVyKGVuY29kZXIpOworCWJzX2ZpbmkobWRw NV9lbmNvZGVyKTsKKwlkcm1fZW5jb2Rlcl9jbGVhbnVwKGVuY29kZXIpOworCWtmcmVlKG1kcDVf ZW5jb2Rlcik7Cit9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgZHJtX2VuY29kZXJfZnVuY3MgbWRw NV9jbWRfZW5jb2Rlcl9mdW5jcyA9IHsKKwkuZGVzdHJveSA9IG1kcDVfY21kX2VuY29kZXJfZGVz dHJveSwKK307CisKK3N0YXRpYyBib29sIG1kcDVfY21kX2VuY29kZXJfbW9kZV9maXh1cChzdHJ1 Y3QgZHJtX2VuY29kZXIgKmVuY29kZXIsCisJCWNvbnN0IHN0cnVjdCBkcm1fZGlzcGxheV9tb2Rl ICptb2RlLAorCQlzdHJ1Y3QgZHJtX2Rpc3BsYXlfbW9kZSAqYWRqdXN0ZWRfbW9kZSkKK3sKKwly ZXR1cm4gdHJ1ZTsKK30KKworc3RhdGljIHZvaWQgbWRwNV9jbWRfZW5jb2Rlcl9tb2RlX3NldChz dHJ1Y3QgZHJtX2VuY29kZXIgKmVuY29kZXIsCisJCXN0cnVjdCBkcm1fZGlzcGxheV9tb2RlICpt b2RlLAorCQlzdHJ1Y3QgZHJtX2Rpc3BsYXlfbW9kZSAqYWRqdXN0ZWRfbW9kZSkKK3sKKwlzdHJ1 Y3QgbWRwNV9lbmNvZGVyICptZHA1X2VuY29kZXIgPSB0b19tZHA1X2VuY29kZXIoZW5jb2Rlcik7 CisKKwltb2RlID0gYWRqdXN0ZWRfbW9kZTsKKworCURCRygic2V0IG1vZGU6ICVkOlwiJXNcIiAl ZCAlZCAlZCAlZCAlZCAlZCAlZCAlZCAlZCAlZCAweCV4IDB4JXgiLAorCQkJbW9kZS0+YmFzZS5p ZCwgbW9kZS0+bmFtZSwKKwkJCW1vZGUtPnZyZWZyZXNoLCBtb2RlLT5jbG9jaywKKwkJCW1vZGUt PmhkaXNwbGF5LCBtb2RlLT5oc3luY19zdGFydCwKKwkJCW1vZGUtPmhzeW5jX2VuZCwgbW9kZS0+ aHRvdGFsLAorCQkJbW9kZS0+dmRpc3BsYXksIG1vZGUtPnZzeW5jX3N0YXJ0LAorCQkJbW9kZS0+ dnN5bmNfZW5kLCBtb2RlLT52dG90YWwsCisJCQltb2RlLT50eXBlLCBtb2RlLT5mbGFncyk7CisJ cGluZ3BvbmdfdGVhcmNoZWNrX3NldHVwKGVuY29kZXIsIG1vZGUpOworCW1kcDVfY3J0Y19zZXRf aW50ZihlbmNvZGVyLT5jcnRjLCAmbWRwNV9lbmNvZGVyLT5pbnRmKTsKK30KKworc3RhdGljIHZv aWQgbWRwNV9jbWRfZW5jb2Rlcl9kaXNhYmxlKHN0cnVjdCBkcm1fZW5jb2RlciAqZW5jb2RlcikK K3sKKwlzdHJ1Y3QgbWRwNV9lbmNvZGVyICptZHA1X2VuY29kZXIgPSB0b19tZHA1X2VuY29kZXIo ZW5jb2Rlcik7CisJc3RydWN0IG1kcDVfa21zICptZHA1X2ttcyA9IGdldF9rbXMoZW5jb2Rlcik7 CisJc3RydWN0IG1kcDVfY3RsICpjdGwgPSBtZHA1X2NydGNfZ2V0X2N0bChlbmNvZGVyLT5jcnRj KTsKKwlzdHJ1Y3QgbWRwNV9pbnRlcmZhY2UgKmludGYgPSAmbWRwNV9lbmNvZGVyLT5pbnRmOwor CWludCBsbSA9IG1kcDVfY3J0Y19nZXRfbG0oZW5jb2Rlci0+Y3J0Yyk7CisKKwlpZiAoV0FSTl9P TighbWRwNV9lbmNvZGVyLT5lbmFibGVkKSkKKwkJcmV0dXJuOworCisJLyogV2FpdCBmb3IgdGhl IGxhc3QgZnJhbWUgZG9uZSAqLworCW1kcF9pcnFfd2FpdCgmbWRwNV9rbXMtPmJhc2UsIGxtMnBw ZG9uZShsbSkpOworCXBpbmdwb25nX3RlYXJjaGVja19kaXNhYmxlKGVuY29kZXIpOworCisJbWRw NV9jdGxfc2V0X2VuY29kZXJfc3RhdGUoY3RsLCBmYWxzZSk7CisJbWRwNV9jdGxfY29tbWl0KGN0 bCwgbWRwX2N0bF9mbHVzaF9tYXNrX2VuY29kZXIoaW50ZikpOworCisJYnNfc2V0KG1kcDVfZW5j b2RlciwgMCk7CisKKwltZHA1X2VuY29kZXItPmVuYWJsZWQgPSBmYWxzZTsKK30KKworc3RhdGlj IHZvaWQgbWRwNV9jbWRfZW5jb2Rlcl9lbmFibGUoc3RydWN0IGRybV9lbmNvZGVyICplbmNvZGVy KQoreworCXN0cnVjdCBtZHA1X2VuY29kZXIgKm1kcDVfZW5jb2RlciA9IHRvX21kcDVfZW5jb2Rl cihlbmNvZGVyKTsKKwlzdHJ1Y3QgbWRwNV9jdGwgKmN0bCA9IG1kcDVfY3J0Y19nZXRfY3RsKGVu Y29kZXItPmNydGMpOworCXN0cnVjdCBtZHA1X2ludGVyZmFjZSAqaW50ZiA9ICZtZHA1X2VuY29k ZXItPmludGY7CisKKwlpZiAoV0FSTl9PTihtZHA1X2VuY29kZXItPmVuYWJsZWQpKQorCQlyZXR1 cm47CisKKwlic19zZXQobWRwNV9lbmNvZGVyLCAxKTsKKwlpZiAocGluZ3BvbmdfdGVhcmNoZWNr X2VuYWJsZShlbmNvZGVyKSkKKwkJcmV0dXJuOworCisJbWRwNV9jdGxfY29tbWl0KGN0bCwgbWRw X2N0bF9mbHVzaF9tYXNrX2VuY29kZXIoaW50ZikpOworCisJbWRwNV9jdGxfc2V0X2VuY29kZXJf c3RhdGUoY3RsLCB0cnVlKTsKKworCW1kcDVfZW5jb2Rlci0+ZW5hYmxlZCA9IHRydWU7Cit9CisK K3N0YXRpYyBjb25zdCBzdHJ1Y3QgZHJtX2VuY29kZXJfaGVscGVyX2Z1bmNzIG1kcDVfY21kX2Vu Y29kZXJfaGVscGVyX2Z1bmNzID0geworCS5tb2RlX2ZpeHVwID0gbWRwNV9jbWRfZW5jb2Rlcl9t b2RlX2ZpeHVwLAorCS5tb2RlX3NldCA9IG1kcDVfY21kX2VuY29kZXJfbW9kZV9zZXQsCisJLmRp c2FibGUgPSBtZHA1X2NtZF9lbmNvZGVyX2Rpc2FibGUsCisJLmVuYWJsZSA9IG1kcDVfY21kX2Vu Y29kZXJfZW5hYmxlLAorfTsKKworaW50IG1kcDVfY21kX2VuY29kZXJfc2V0X3NwbGl0X2Rpc3Bs YXkoc3RydWN0IGRybV9lbmNvZGVyICplbmNvZGVyLAorCQkJCQlzdHJ1Y3QgZHJtX2VuY29kZXIg KnNsYXZlX2VuY29kZXIpCit7CisJc3RydWN0IG1kcDVfZW5jb2RlciAqbWRwNV9lbmNvZGVyID0g dG9fbWRwNV9lbmNvZGVyKGVuY29kZXIpOworCXN0cnVjdCBtZHA1X2ttcyAqbWRwNV9rbXM7CisJ aW50IGludGZfbnVtOworCXUzMiBkYXRhID0gMDsKKworCWlmICghZW5jb2RlciB8fCAhc2xhdmVf ZW5jb2RlcikKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwltZHA1X2ttcyA9IGdldF9rbXMoZW5jb2Rl cik7CisJaW50Zl9udW0gPSBtZHA1X2VuY29kZXItPmludGYubnVtOworCisJLyogU3dpdGNoIHNs YXZlIGVuY29kZXIncyB0cmlnZ2VyIE1VWCwgdG8gdXNlIHRoZSBtYXN0ZXIncworCSAqIHN0YXJ0 IHNpZ25hbCBmb3IgdGhlIHNsYXZlIGVuY29kZXIKKwkgKi8KKwlpZiAoaW50Zl9udW0gPT0gMSkK KwkJZGF0YSB8PSBNRFA1X1NQTElUX0RQTF9VUFBFUl9JTlRGMl9TV19UUkdfTVVYOworCWVsc2Ug aWYgKGludGZfbnVtID09IDIpCisJCWRhdGEgfD0gTURQNV9TUExJVF9EUExfVVBQRVJfSU5URjFf U1dfVFJHX01VWDsKKwllbHNlCisJCXJldHVybiAtRUlOVkFMOworCisJLyogU21hcnQgUGFuZWws IFN5bmMgbW9kZSAqLworCWRhdGEgfD0gTURQNV9TUExJVF9EUExfVVBQRVJfU01BUlRfUEFORUw7 CisKKwkvKiBNYWtlIHN1cmUgY2xvY2tzIGFyZSBvbiB3aGVuIGNvbm5lY3RvcnMgY2FsbGluZyB0 aGlzIGZ1bmN0aW9uLiAqLworCW1kcDVfZW5hYmxlKG1kcDVfa21zKTsKKwltZHA1X3dyaXRlKG1k cDVfa21zLCBSRUdfTURQNV9TUExJVF9EUExfVVBQRVIsIGRhdGEpOworCisJbWRwNV93cml0ZSht ZHA1X2ttcywgUkVHX01EUDVfU1BMSVRfRFBMX0xPV0VSLAorCQkJTURQNV9TUExJVF9EUExfTE9X RVJfU01BUlRfUEFORUwpOworCW1kcDVfd3JpdGUobWRwNV9rbXMsIFJFR19NRFA1X1NQTElUX0RQ TF9FTiwgMSk7CisJbWRwNV9kaXNhYmxlKG1kcDVfa21zKTsKKworCXJldHVybiAwOworfQorCiBz dGF0aWMgdm9pZCBtZHA1X2VuY29kZXJfZGVzdHJveShzdHJ1Y3QgZHJtX2VuY29kZXIgKmVuY29k ZXIpCiB7CiAJc3RydWN0IG1kcDVfZW5jb2RlciAqbWRwNV9lbmNvZGVyID0gdG9fbWRwNV9lbmNv ZGVyKGVuY29kZXIpOwpAQCAtMjg2LDEyICs1MDEsNTkgQEAgc3RhdGljIGNvbnN0IHN0cnVjdCBk cm1fZW5jb2Rlcl9oZWxwZXJfZnVuY3MgbWRwNV9lbmNvZGVyX2hlbHBlcl9mdW5jcyA9IHsKIAku ZW5hYmxlID0gbWRwNV9lbmNvZGVyX2VuYWJsZSwKIH07CiAKK2ludCBtZHA1X2VuY29kZXJfc2V0 X3NwbGl0X2Rpc3BsYXkoc3RydWN0IGRybV9lbmNvZGVyICplbmNvZGVyLAorCQkJCQlzdHJ1Y3Qg ZHJtX2VuY29kZXIgKnNsYXZlX2VuY29kZXIpCit7CisJc3RydWN0IG1kcDVfZW5jb2RlciAqbWRw NV9lbmNvZGVyID0gdG9fbWRwNV9lbmNvZGVyKGVuY29kZXIpOworCXN0cnVjdCBtZHA1X2ttcyAq bWRwNV9rbXM7CisJaW50IGludGZfbnVtOworCXUzMiBkYXRhID0gMDsKKworCWlmICghZW5jb2Rl ciB8fCAhc2xhdmVfZW5jb2RlcikKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwltZHA1X2ttcyA9IGdl dF9rbXMoZW5jb2Rlcik7CisJaW50Zl9udW0gPSBtZHA1X2VuY29kZXItPmludGYubnVtOworCisJ bWRwNV93cml0ZShtZHA1X2ttcywgUkVHX01EUDVfU1BBUkVfMCwKKwkJTURQNV9TUEFSRV8wX1NQ TElUX0RQTF9TSU5HTEVfRkxVU0hfRU4pOworCisJLyogU3dpdGNoIHNsYXZlIGVuY29kZXIncyBU aW1pbmdHZW4gU3luYyBtb2RlLAorCSAqIHRvIHVzZSB0aGUgbWFzdGVyJ3MgZW5hYmxlIHNpZ25h bCBmb3IgdGhlIHNsYXZlIGVuY29kZXIuCisJICovCisJaWYgKGludGZfbnVtID09IDEpCisJCWRh dGEgfD0gTURQNV9TUExJVF9EUExfTE9XRVJfSU5URjJfVEdfU1lOQzsKKwllbHNlIGlmIChpbnRm X251bSA9PSAyKQorCQlkYXRhIHw9IE1EUDVfU1BMSVRfRFBMX0xPV0VSX0lOVEYxX1RHX1NZTkM7 CisJZWxzZQorCQlyZXR1cm4gLUVJTlZBTDsKKworCS8qIE1ha2Ugc3VyZSBjbG9ja3MgYXJlIG9u IHdoZW4gY29ubmVjdG9ycyBjYWxsaW5nIHRoaXMgZnVuY3Rpb24uICovCisJbWRwNV9lbmFibGUo bWRwNV9rbXMpOworCS8qIER1bWIgUGFuZWwsIFN5bmMgbW9kZSAqLworCW1kcDVfd3JpdGUobWRw NV9rbXMsIFJFR19NRFA1X1NQTElUX0RQTF9VUFBFUiwgMCk7CisJbWRwNV93cml0ZShtZHA1X2tt cywgUkVHX01EUDVfU1BMSVRfRFBMX0xPV0VSLCBkYXRhKTsKKwltZHA1X3dyaXRlKG1kcDVfa21z LCBSRUdfTURQNV9TUExJVF9EUExfRU4sIDEpOworCW1kcDVfZGlzYWJsZShtZHA1X2ttcyk7CisK KwlyZXR1cm4gMDsKK30KKwogLyogaW5pdGlhbGl6ZSBlbmNvZGVyICovCiBzdHJ1Y3QgZHJtX2Vu Y29kZXIgKm1kcDVfZW5jb2Rlcl9pbml0KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsCiAJCQkJc3Ry dWN0IG1kcDVfaW50ZXJmYWNlICppbnRmKQogewogCXN0cnVjdCBkcm1fZW5jb2RlciAqZW5jb2Rl ciA9IE5VTEw7CiAJc3RydWN0IG1kcDVfZW5jb2RlciAqbWRwNV9lbmNvZGVyOworCWNvbnN0IHN0 cnVjdCBkcm1fZW5jb2Rlcl9mdW5jcyAqZnVuY3MgPQorCQkoaW50Zi0+bW9kZSA9PSBNRFA1X0lO VEZfRFNJX01PREVfQ09NTUFORCkgPworCQkoJm1kcDVfY21kX2VuY29kZXJfZnVuY3MpIDogKCZt ZHA1X2VuY29kZXJfZnVuY3MpOworCWNvbnN0IHN0cnVjdCBkcm1fZW5jb2Rlcl9oZWxwZXJfZnVu Y3MgKmhlbHBlcl9mdW5jcyA9CisJCShpbnRmLT5tb2RlID09IE1EUDVfSU5URl9EU0lfTU9ERV9D T01NQU5EKSA/CisJCSgmbWRwNV9jbWRfZW5jb2Rlcl9oZWxwZXJfZnVuY3MpIDogKCZtZHA1X2Vu Y29kZXJfaGVscGVyX2Z1bmNzKTsKKwlpbnQgZW5jX3R5cGUgPSAoaW50Zi0+dHlwZSA9PSBJTlRG X0RTSSkgPworCQlEUk1fTU9ERV9FTkNPREVSX0RTSSA6IERSTV9NT0RFX0VOQ09ERVJfVE1EUzsK KwogCWludCByZXQ7CiAKIAltZHA1X2VuY29kZXIgPSBremFsbG9jKHNpemVvZigqbWRwNV9lbmNv ZGVyKSwgR0ZQX0tFUk5FTCk7CkBAIC0zMDUsOSArNTY3LDkgQEAgc3RydWN0IGRybV9lbmNvZGVy ICptZHA1X2VuY29kZXJfaW5pdChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LAogCiAJc3Bpbl9sb2Nr X2luaXQoJm1kcDVfZW5jb2Rlci0+aW50Zl9sb2NrKTsKIAotCWRybV9lbmNvZGVyX2luaXQoZGV2 LCBlbmNvZGVyLCAmbWRwNV9lbmNvZGVyX2Z1bmNzLAotCQkJIERSTV9NT0RFX0VOQ09ERVJfVE1E Uyk7Ci0JZHJtX2VuY29kZXJfaGVscGVyX2FkZChlbmNvZGVyLCAmbWRwNV9lbmNvZGVyX2hlbHBl cl9mdW5jcyk7CisJZHJtX2VuY29kZXJfaW5pdChkZXYsIGVuY29kZXIsIGZ1bmNzLCBlbmNfdHlw ZSk7CisKKwlkcm1fZW5jb2Rlcl9oZWxwZXJfYWRkKGVuY29kZXIsIGhlbHBlcl9mdW5jcyk7CiAK IAlic19pbml0KG1kcDVfZW5jb2Rlcik7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9t c20vbWRwL21kcDUvbWRwNV9rbXMuYyBiL2RyaXZlcnMvZ3B1L2RybS9tc20vbWRwL21kcDUvbWRw NV9rbXMuYwppbmRleCBlNWZkMzMyLi5kZmMzZDM4IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9k cm0vbXNtL21kcC9tZHA1L21kcDVfa21zLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL21zbS9tZHAv bWRwNS9tZHA1X2ttcy5jCkBAIC04OCw2ICs4OCwxOCBAQCBzdGF0aWMgbG9uZyBtZHA1X3JvdW5k X3BpeGNsayhzdHJ1Y3QgbXNtX2ttcyAqa21zLCB1bnNpZ25lZCBsb25nIHJhdGUsCiAJcmV0dXJu IHJhdGU7CiB9CiAKK3N0YXRpYyBpbnQgbWRwNV9zZXRfc3BsaXRfZGlzcGxheShzdHJ1Y3QgbXNt X2ttcyAqa21zLAorCQlzdHJ1Y3QgZHJtX2VuY29kZXIgKmVuY29kZXIsCisJCXN0cnVjdCBkcm1f ZW5jb2RlciAqc2xhdmVfZW5jb2RlciwKKwkJYm9vbCBpc19jbWRfbW9kZSkKK3sKKwlpZiAoaXNf Y21kX21vZGUpCisJCXJldHVybiBtZHA1X2NtZF9lbmNvZGVyX3NldF9zcGxpdF9kaXNwbGF5KGVu Y29kZXIsCisJCQkJCQkJc2xhdmVfZW5jb2Rlcik7CisJZWxzZQorCQlyZXR1cm4gbWRwNV9lbmNv ZGVyX3NldF9zcGxpdF9kaXNwbGF5KGVuY29kZXIsIHNsYXZlX2VuY29kZXIpOworfQorCiBzdGF0 aWMgdm9pZCBtZHA1X3ByZWNsb3NlKHN0cnVjdCBtc21fa21zICprbXMsIHN0cnVjdCBkcm1fZmls ZSAqZmlsZSkKIHsKIAlzdHJ1Y3QgbWRwNV9rbXMgKm1kcDVfa21zID0gdG9fbWRwNV9rbXModG9f bWRwX2ttcyhrbXMpKTsKQEAgLTEzMyw2ICsxNDUsNyBAQCBzdGF0aWMgY29uc3Qgc3RydWN0IG1k cF9rbXNfZnVuY3Mga21zX2Z1bmNzID0gewogCQkuY29tcGxldGVfY29tbWl0ID0gbWRwNV9jb21w bGV0ZV9jb21taXQsCiAJCS5nZXRfZm9ybWF0ICAgICAgPSBtZHBfZ2V0X2Zvcm1hdCwKIAkJLnJv dW5kX3BpeGNsayAgICA9IG1kcDVfcm91bmRfcGl4Y2xrLAorCQkuc2V0X3NwbGl0X2Rpc3BsYXkg PSBtZHA1X3NldF9zcGxpdF9kaXNwbGF5LAogCQkucHJlY2xvc2UgICAgICAgID0gbWRwNV9wcmVj bG9zZSwKIAkJLmRlc3Ryb3kgICAgICAgICA9IG1kcDVfZGVzdHJveSwKIAl9LApAQCAtMTYzLDYg KzE3NiwyNCBAQCBpbnQgbWRwNV9lbmFibGUoc3RydWN0IG1kcDVfa21zICptZHA1X2ttcykKIAly ZXR1cm4gMDsKIH0KIAorc3RhdGljIGludCBnZXRfZHNpX2lkX2Zyb21faW50Zihjb25zdCBzdHJ1 Y3QgbWRwNV9jZmdfaHcgKmh3X2NmZywgaW50IGludGZfbnVtKQoreworCWNvbnN0IGludCBpbnRm X2NudCA9IGh3X2NmZy0+aW50Zi5jb3VudDsKKwljb25zdCB1MzIgKmludGZzID0gaHdfY2ZnLT5p bnRmczsKKwlpbnQgaWQgPSAwLCBpOworCisJZm9yIChpID0gMDsgaSA8IGludGZfY250OyBpKysp IHsKKwkJaWYgKGludGZzW2ldID09IElOVEZfRFNJKSB7CisJCQlpZiAoaW50Zl9udW0gPT0gaSkK KwkJCQlyZXR1cm4gaWQ7CisKKwkJCWlkKys7CisJCX0KKwl9CisKKwlyZXR1cm4gLUVJTlZBTDsK K30KKwogc3RhdGljIHN0cnVjdCBkcm1fZW5jb2RlciAqY29uc3RydWN0X2VuY29kZXIoc3RydWN0 IG1kcDVfa21zICptZHA1X2ttcywKIAkJZW51bSBtZHA1X2ludGZfdHlwZSBpbnRmX3R5cGUsIGlu dCBpbnRmX251bSwKIAkJZW51bSBtZHA1X2ludGZfbW9kZSBpbnRmX21vZGUpCkBAIC0yNTQsNiAr Mjg1LDcgQEAgc3RhdGljIGludCBtb2Rlc2V0X2luaXQoc3RydWN0IG1kcDVfa21zICptZHA1X2tt cykKIAkJZW51bSBtZHA1X2ludGZfbW9kZSBpbnRmX21vZGUgPSBNRFA1X0lOVEZfTU9ERV9OT05F OwogCQlzdHJ1Y3QgbXNtX2RybV9zdWJfZGV2ICpzdWJfZGV2OwogCQlzdHJ1Y3QgZHJtX2VuY29k ZXIgKmVuY29kZXI7CisJCWludCBlbmNvZGVyX251bSA9IDEsIGo7CiAKIAkJc3dpdGNoIChpbnRm X3R5cGUpIHsKIAkJY2FzZSBJTlRGX0RJU0FCTEVEOgpAQCAtMjY1LDYgKzI5NywyMyBAQCBzdGF0 aWMgaW50IG1vZGVzZXRfaW5pdChzdHJ1Y3QgbWRwNV9rbXMgKm1kcDVfa21zKQogCQljYXNlIElO VEZfSERNSToKIAkJCXN1Yl9kZXYgPSBwcml2LT5oZG1pOwogCQkJYnJlYWs7CisJCWNhc2UgSU5U Rl9EU0k6CisJCXsKKwkJCWludCBkc2lfaWQgPSBnZXRfZHNpX2lkX2Zyb21faW50Zihod19jZmcs IGkpOworCisJCQlpZiAoKGRzaV9pZCA+PSBBUlJBWV9TSVpFKHByaXYtPmRzaSkpIHx8CisJCQkJ KGRzaV9pZCA8IDApKSB7CisJCQkJZGV2X2VycihkZXYtPmRldiwKKwkJCQkJImZhaWxlZCB0byBm aW5kIGRzaSBpZCBmcm9tIGludGYgJWRcbiIsCisJCQkJCWkpOworCQkJCXJldCA9IC1FSU5WQUw7 CisJCQkJZ290byBmYWlsOworCQkJfQorCQkJc3ViX2RldiA9IHByaXYtPmRzaVtkc2lfaWRdOwor CQkJZW5jb2Rlcl9udW0gPSBNU01fRFNJX0VOQ09ERVJfTlVNOworCisJCQlicmVhazsKKwkJfQog CQlkZWZhdWx0OgogCQkJZGV2X2VycihkZXYtPmRldiwgInVua25vd24gaW50ZjogJWRcbiIsIGlu dGZfdHlwZSk7CiAJCQlyZXQgPSAtRUlOVkFMOwpAQCAtMjcyLDE0ICszMjEsMjAgQEAgc3RhdGlj IGludCBtb2Rlc2V0X2luaXQoc3RydWN0IG1kcDVfa21zICptZHA1X2ttcykKIAkJfQogCiAJCWlm IChzdWJfZGV2KSB7Ci0JCQllbmNvZGVyID0gY29uc3RydWN0X2VuY29kZXIobWRwNV9rbXMsIGlu dGZfdHlwZSwKLQkJCQkJCQlpLCBpbnRmX21vZGUpOwotCQkJaWYgKElTX0VSUihlbmNvZGVyKSkg ewotCQkJCXJldCA9IFBUUl9FUlIoZW5jb2Rlcik7Ci0JCQkJZ290byBmYWlsOworCQkJZm9yIChq ID0gMDsgaiA8IGVuY29kZXJfbnVtOyBqKyspIHsKKwkJCQlpZiAoTVNNX0RTSV9DTURfRU5DT0RF Ul9JRCA9PSBqKQorCQkJCQlpbnRmX21vZGUgPSBNRFA1X0lOVEZfRFNJX01PREVfQ09NTUFORDsK KworCQkJCWVuY29kZXIgPSBjb25zdHJ1Y3RfZW5jb2RlcihtZHA1X2ttcywgaW50Zl90eXBlLAor CQkJCQkJCQlpLCBpbnRmX21vZGUpOworCQkJCWlmIChJU19FUlIoZW5jb2RlcikpIHsKKwkJCQkJ cmV0ID0gUFRSX0VSUihlbmNvZGVyKTsKKwkJCQkJZ290byBmYWlsOworCQkJCX0KKworCQkJCXN1 Yl9kZXYtPmVuY29kZXJzW3N1Yl9kZXYtPm51bV9lbmNvZGVycysrXSA9CisJCQkJCQkJCQllbmNv ZGVyOwogCQkJfQotCi0JCQlzdWJfZGV2LT5lbmNvZGVyc1tzdWJfZGV2LT5udW1fZW5jb2RlcnMr K10gPSBlbmNvZGVyOwogCQkJcmV0ID0gc3ViX2Rldi0+bW9kZXNldF9pbml0KHN1Yl9kZXYsIGRl dik7CiAJCQlpZiAocmV0KQogCQkJCWdvdG8gZmFpbDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1 L2RybS9tc20vbWRwL21kcDUvbWRwNV9rbXMuaCBiL2RyaXZlcnMvZ3B1L2RybS9tc20vbWRwL21k cDUvbWRwNV9rbXMuaAppbmRleCA2OTBlZGZkLi4zZWYyZmY2IDEwMDY0NAotLS0gYS9kcml2ZXJz L2dwdS9kcm0vbXNtL21kcC9tZHA1L21kcDVfa21zLmgKKysrIGIvZHJpdmVycy9ncHUvZHJtL21z bS9tZHAvbWRwNS9tZHA1X2ttcy5oCkBAIC0xNTksMTAgKzE1OSw5IEBAIHN0YXRpYyBpbmxpbmUg dWludDMyX3QgaW50ZjJlcnIoaW50IGludGZfbnVtKQogCX0KIH0KIAorI2RlZmluZSBHRVRfUElO R19QT05HX0lEKGxheWVyX21peGVyKQkoKGxheWVyX21peGVyID09IDUpID8gMyA6IGxheWVyX21p eGVyKQogc3RhdGljIGlubGluZSB1aW50MzJfdCBpbnRmMnZibGFuayhpbnQgbG0sIHN0cnVjdCBt ZHA1X2ludGVyZmFjZSAqaW50ZikKIHsKLSNkZWZpbmUgR0VUX1BJTkdfUE9OR19JRChsYXllcl9t aXhlcikJKChsYXllcl9taXhlciA9PSA1KSA/IDMgOiBsYXllcl9taXhlcikKLQogCS8qCiAJICog SW4gY2FzZSBvZiBEU0kgQ29tbWFuZCBNb2RlLCB0aGUgUGluZyBQb25nJ3MgcmVhZCBwb2ludGVy IElSUQogCSAqIGFjdHMgYXMgYSBWYmxhbmsgc2lnbmFsLiBUaGUgUGluZyBQb25nIGJ1ZmZlciB1 c2VkIGlzIGJvdW5kIHRvCkBAIC0xODUsNiArMTg0LDExIEBAIHN0YXRpYyBpbmxpbmUgdWludDMy X3QgaW50ZjJ2YmxhbmsoaW50IGxtLCBzdHJ1Y3QgbWRwNV9pbnRlcmZhY2UgKmludGYpCiAJfQog fQogCitzdGF0aWMgaW5saW5lIHVpbnQzMl90IGxtMnBwZG9uZShpbnQgbG0pCit7CisJcmV0dXJu IE1EUDVfSVJRX1BJTkdfUE9OR18wX0RPTkUgPDwgR0VUX1BJTkdfUE9OR19JRChsbSk7Cit9CisK IGludCBtZHA1X2Rpc2FibGUoc3RydWN0IG1kcDVfa21zICptZHA1X2ttcyk7CiBpbnQgbWRwNV9l bmFibGUoc3RydWN0IG1kcDVfa21zICptZHA1X2ttcyk7CiAKQEAgLTIzNiw2ICsyNDAsMTAgQEAg dm9pZCBtZHA1X2NydGNfc2V0X2ludGYoc3RydWN0IGRybV9jcnRjICpjcnRjLCBzdHJ1Y3QgbWRw NV9pbnRlcmZhY2UgKmludGYpOwogc3RydWN0IGRybV9jcnRjICptZHA1X2NydGNfaW5pdChzdHJ1 Y3QgZHJtX2RldmljZSAqZGV2LAogCQlzdHJ1Y3QgZHJtX3BsYW5lICpwbGFuZSwgaW50IGlkKTsK IAoraW50IG1kcDVfY21kX2VuY29kZXJfc2V0X3NwbGl0X2Rpc3BsYXkoc3RydWN0IGRybV9lbmNv ZGVyICplbmNvZGVyLAorCQkJCQlzdHJ1Y3QgZHJtX2VuY29kZXIgKnNsYXZlX2VuY29kZXIpOwor aW50IG1kcDVfZW5jb2Rlcl9zZXRfc3BsaXRfZGlzcGxheShzdHJ1Y3QgZHJtX2VuY29kZXIgKmVu Y29kZXIsCisJCQkJCXN0cnVjdCBkcm1fZW5jb2RlciAqc2xhdmVfZW5jb2Rlcik7CiBzdHJ1Y3Qg ZHJtX2VuY29kZXIgKm1kcDVfZW5jb2Rlcl9pbml0KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsCiAJ CXN0cnVjdCBtZHA1X2ludGVyZmFjZSAqaW50Zik7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1 L2RybS9tc20vbXNtX2Rydi5jIGIvZHJpdmVycy9ncHUvZHJtL21zbS9tc21fZHJ2LmMKaW5kZXgg ZGZkNTgzZi4uYmM2MWMzNCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL21zbS9tc21fZHJ2 LmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL21zbS9tc21fZHJ2LmMKQEAgLTEwMzAsNiArMTAzMCw3 IEBAIHN0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZHJpdmVyIG1zbV9wbGF0Zm9ybV9kcml2ZXIgPSB7 CiBzdGF0aWMgaW50IF9faW5pdCBtc21fZHJtX3JlZ2lzdGVyKHZvaWQpCiB7CiAJREJHKCJpbml0 Iik7CisJbXNtX2RzaV9yZWdpc3RlcigpOwogCW1zbV9lZHBfcmVnaXN0ZXIoKTsKIAloZG1pX3Jl Z2lzdGVyKCk7CiAJYWRyZW5vX3JlZ2lzdGVyKCk7CkBAIC0xMDQzLDYgKzEwNDQsNyBAQCBzdGF0 aWMgdm9pZCBfX2V4aXQgbXNtX2RybV91bnJlZ2lzdGVyKHZvaWQpCiAJaGRtaV91bnJlZ2lzdGVy KCk7CiAJYWRyZW5vX3VucmVnaXN0ZXIoKTsKIAltc21fZWRwX3VucmVnaXN0ZXIoKTsKKwltc21f ZHNpX3VucmVnaXN0ZXIoKTsKIH0KIAogbW9kdWxlX2luaXQobXNtX2RybV9yZWdpc3Rlcik7Ci0t IApUaGUgUXVhbGNvbW0gSW5ub3ZhdGlvbiBDZW50ZXIsIEluYy4gaXMgYSBtZW1iZXIgb2YgdGhl IENvZGUgQXVyb3JhIEZvcnVtLApob3N0ZWQgYnkgVGhlIExpbnV4IEZvdW5kYXRpb24KCl9fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmRyaS1kZXZlbCBtYWls aW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwOi8vbGlzdHMuZnJl ZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVsCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1757104AbbCMXZS (ORCPT ); Fri, 13 Mar 2015 19:25:18 -0400 Received: from smtp.codeaurora.org ([198.145.29.96]:45711 "EHLO smtp.codeaurora.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753902AbbCMXZG (ORCPT ); Fri, 13 Mar 2015 19:25:06 -0400 From: Hai Li To: dri-devel@lists.freedesktop.org Cc: linux-arm-msm@vger.kernel.org, linux-kernel@vger.kernel.org, robdclark@gmail.com, Hai Li Subject: [PATCH 4/4] drm/msm/mdp5: Enable DSI connector in msm drm driver Date: Fri, 13 Mar 2015 19:24:18 -0400 Message-Id: <1426289058-6663-5-git-send-email-hali@codeaurora.org> X-Mailer: git-send-email 1.8.2.1 In-Reply-To: <1426289058-6663-1-git-send-email-hali@codeaurora.org> References: <1426289058-6663-1-git-send-email-hali@codeaurora.org> Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org This change adds the support in mdp5 kms driver for single and dual DSI. Dual DSI case depends on the framework API and sequence change to support dual data path. Signed-off-by: Hai Li --- drivers/gpu/drm/msm/mdp/mdp5/mdp5_cfg.c | 4 + drivers/gpu/drm/msm/mdp/mdp5/mdp5_crtc.c | 11 +- drivers/gpu/drm/msm/mdp/mdp5/mdp5_encoder.c | 268 +++++++++++++++++++++++++++- drivers/gpu/drm/msm/mdp/mdp5/mdp5_kms.c | 69 ++++++- drivers/gpu/drm/msm/mdp/mdp5/mdp5_kms.h | 12 +- drivers/gpu/drm/msm/msm_drv.c | 2 + 6 files changed, 353 insertions(+), 13 deletions(-) diff --git a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_cfg.c b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_cfg.c index 6c467fb..2c9a9dc 100644 --- a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_cfg.c +++ b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_cfg.c @@ -68,6 +68,8 @@ const struct mdp5_cfg_hw msm8x74_config = { }, .intfs = { [0] = INTF_eDP, + [1] = INTF_DSI, + [2] = INTF_DSI, [3] = INTF_HDMI, }, .max_clk = 200000000, @@ -125,6 +127,8 @@ const struct mdp5_cfg_hw apq8084_config = { }, .intfs = { [0] = INTF_eDP, + [1] = INTF_DSI, + [2] = INTF_DSI, [3] = INTF_HDMI, }, .max_clk = 320000000, diff --git a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_crtc.c b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_crtc.c index 9b38cde..f877e1d 100644 --- a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_crtc.c +++ b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_crtc.c @@ -626,7 +626,16 @@ void mdp5_crtc_set_intf(struct drm_crtc *crtc, struct mdp5_interface *intf) /* now that we know what irq's we want: */ mdp5_crtc->err.irqmask = intf2err(intf->num); - mdp5_crtc->vblank.irqmask = intf2vblank(lm, intf); + + /* Register command mode Pingpong done as vblank for now, + * so that atomic commit should wait for it to finish. + * Ideally, in the future, we should take rd_ptr done as vblank, + * and let atomic commit wait for pingpong done for commond mode. + */ + if (intf->mode == MDP5_INTF_DSI_MODE_COMMAND) + mdp5_crtc->vblank.irqmask = lm2ppdone(lm); + else + mdp5_crtc->vblank.irqmask = intf2vblank(lm, intf); mdp_irq_update(&mdp5_kms->base); mdp5_ctl_set_intf(mdp5_crtc->ctl, intf); diff --git a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_encoder.c b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_encoder.c index a17eb9c..efe7aaf 100644 --- a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_encoder.c +++ b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_encoder.c @@ -98,6 +98,221 @@ static void bs_fini(struct mdp5_encoder *mdp5_encoder) {} static void bs_set(struct mdp5_encoder *mdp5_encoder, int idx) {} #endif +/* + * Command mode encoder, used by DSI command mode path. + * Should move to a separate file, once global bandwidth + * functions are available. + */ +#define VSYNC_CLK_RATE 19200000 +static int pingpong_tearcheck_setup(struct drm_encoder *encoder, + struct drm_display_mode *mode) +{ + struct mdp5_kms *mdp5_kms = get_kms(encoder); + struct device *dev = encoder->dev->dev; + u32 total_lines_x100, vclks_line, cfg; + long vsync_clk_speed; + int pp_id = GET_PING_PONG_ID(mdp5_crtc_get_lm(encoder->crtc)); + + if (IS_ERR_OR_NULL(mdp5_kms->vsync_clk)) { + dev_err(dev, "vsync_clk is not initialized\n"); + return -EINVAL; + } + + total_lines_x100 = mode->vtotal * mode->vrefresh; + if (!total_lines_x100) { + dev_err(dev, "%s: vtotal(%d) or vrefresh(%d) is 0\n", + __func__, mode->vtotal, mode->vrefresh); + return -EINVAL; + } + + vsync_clk_speed = clk_round_rate(mdp5_kms->vsync_clk, VSYNC_CLK_RATE); + if (vsync_clk_speed <= 0) { + dev_err(dev, "vsync_clk round rate failed %ld\n", + vsync_clk_speed); + return -EINVAL; + } + vclks_line = vsync_clk_speed * 100 / total_lines_x100; + + cfg = MDP5_PP_SYNC_CONFIG_VSYNC_COUNTER_EN + | MDP5_PP_SYNC_CONFIG_VSYNC_IN_EN; + cfg |= MDP5_PP_SYNC_CONFIG_VSYNC_COUNT(vclks_line); + + mdp5_write(mdp5_kms, REG_MDP5_PP_SYNC_CONFIG_VSYNC(pp_id), cfg); + mdp5_write(mdp5_kms, + REG_MDP5_PP_SYNC_CONFIG_HEIGHT(pp_id), 0xfff0); + mdp5_write(mdp5_kms, + REG_MDP5_PP_VSYNC_INIT_VAL(pp_id), mode->vdisplay); + mdp5_write(mdp5_kms, REG_MDP5_PP_RD_PTR_IRQ(pp_id), mode->vdisplay + 1); + mdp5_write(mdp5_kms, REG_MDP5_PP_START_POS(pp_id), mode->vdisplay); + mdp5_write(mdp5_kms, REG_MDP5_PP_SYNC_THRESH(pp_id), + MDP5_PP_SYNC_THRESH_START(4) | + MDP5_PP_SYNC_THRESH_CONTINUE(4)); + + return 0; +} + +static int pingpong_tearcheck_enable(struct drm_encoder *encoder) +{ + struct mdp5_kms *mdp5_kms = get_kms(encoder); + int pp_id = GET_PING_PONG_ID(mdp5_crtc_get_lm(encoder->crtc)); + int ret; + + ret = clk_set_rate(mdp5_kms->vsync_clk, + clk_round_rate(mdp5_kms->vsync_clk, VSYNC_CLK_RATE)); + if (ret) { + dev_err(encoder->dev->dev, + "vsync_clk clk_set_rate failed, %d\n", ret); + return ret; + } + ret = clk_prepare_enable(mdp5_kms->vsync_clk); + if (ret) { + dev_err(encoder->dev->dev, + "vsync_clk clk_prepare_enable failed, %d\n", ret); + return ret; + } + + mdp5_write(mdp5_kms, REG_MDP5_PP_TEAR_CHECK_EN(pp_id), 1); + + return 0; +} + +static void pingpong_tearcheck_disable(struct drm_encoder *encoder) +{ + struct mdp5_kms *mdp5_kms = get_kms(encoder); + int pp_id = GET_PING_PONG_ID(mdp5_crtc_get_lm(encoder->crtc)); + + mdp5_write(mdp5_kms, REG_MDP5_PP_TEAR_CHECK_EN(pp_id), 0); + clk_disable_unprepare(mdp5_kms->vsync_clk); +} + +static void mdp5_cmd_encoder_destroy(struct drm_encoder *encoder) +{ + struct mdp5_encoder *mdp5_encoder = to_mdp5_encoder(encoder); + bs_fini(mdp5_encoder); + drm_encoder_cleanup(encoder); + kfree(mdp5_encoder); +} + +static const struct drm_encoder_funcs mdp5_cmd_encoder_funcs = { + .destroy = mdp5_cmd_encoder_destroy, +}; + +static bool mdp5_cmd_encoder_mode_fixup(struct drm_encoder *encoder, + const struct drm_display_mode *mode, + struct drm_display_mode *adjusted_mode) +{ + return true; +} + +static void mdp5_cmd_encoder_mode_set(struct drm_encoder *encoder, + struct drm_display_mode *mode, + struct drm_display_mode *adjusted_mode) +{ + struct mdp5_encoder *mdp5_encoder = to_mdp5_encoder(encoder); + + mode = adjusted_mode; + + DBG("set mode: %d:\"%s\" %d %d %d %d %d %d %d %d %d %d 0x%x 0x%x", + mode->base.id, mode->name, + mode->vrefresh, mode->clock, + mode->hdisplay, mode->hsync_start, + mode->hsync_end, mode->htotal, + mode->vdisplay, mode->vsync_start, + mode->vsync_end, mode->vtotal, + mode->type, mode->flags); + pingpong_tearcheck_setup(encoder, mode); + mdp5_crtc_set_intf(encoder->crtc, &mdp5_encoder->intf); +} + +static void mdp5_cmd_encoder_disable(struct drm_encoder *encoder) +{ + struct mdp5_encoder *mdp5_encoder = to_mdp5_encoder(encoder); + struct mdp5_kms *mdp5_kms = get_kms(encoder); + struct mdp5_ctl *ctl = mdp5_crtc_get_ctl(encoder->crtc); + struct mdp5_interface *intf = &mdp5_encoder->intf; + int lm = mdp5_crtc_get_lm(encoder->crtc); + + if (WARN_ON(!mdp5_encoder->enabled)) + return; + + /* Wait for the last frame done */ + mdp_irq_wait(&mdp5_kms->base, lm2ppdone(lm)); + pingpong_tearcheck_disable(encoder); + + mdp5_ctl_set_encoder_state(ctl, false); + mdp5_ctl_commit(ctl, mdp_ctl_flush_mask_encoder(intf)); + + bs_set(mdp5_encoder, 0); + + mdp5_encoder->enabled = false; +} + +static void mdp5_cmd_encoder_enable(struct drm_encoder *encoder) +{ + struct mdp5_encoder *mdp5_encoder = to_mdp5_encoder(encoder); + struct mdp5_ctl *ctl = mdp5_crtc_get_ctl(encoder->crtc); + struct mdp5_interface *intf = &mdp5_encoder->intf; + + if (WARN_ON(mdp5_encoder->enabled)) + return; + + bs_set(mdp5_encoder, 1); + if (pingpong_tearcheck_enable(encoder)) + return; + + mdp5_ctl_commit(ctl, mdp_ctl_flush_mask_encoder(intf)); + + mdp5_ctl_set_encoder_state(ctl, true); + + mdp5_encoder->enabled = true; +} + +static const struct drm_encoder_helper_funcs mdp5_cmd_encoder_helper_funcs = { + .mode_fixup = mdp5_cmd_encoder_mode_fixup, + .mode_set = mdp5_cmd_encoder_mode_set, + .disable = mdp5_cmd_encoder_disable, + .enable = mdp5_cmd_encoder_enable, +}; + +int mdp5_cmd_encoder_set_split_display(struct drm_encoder *encoder, + struct drm_encoder *slave_encoder) +{ + struct mdp5_encoder *mdp5_encoder = to_mdp5_encoder(encoder); + struct mdp5_kms *mdp5_kms; + int intf_num; + u32 data = 0; + + if (!encoder || !slave_encoder) + return -EINVAL; + + mdp5_kms = get_kms(encoder); + intf_num = mdp5_encoder->intf.num; + + /* Switch slave encoder's trigger MUX, to use the master's + * start signal for the slave encoder + */ + if (intf_num == 1) + data |= MDP5_SPLIT_DPL_UPPER_INTF2_SW_TRG_MUX; + else if (intf_num == 2) + data |= MDP5_SPLIT_DPL_UPPER_INTF1_SW_TRG_MUX; + else + return -EINVAL; + + /* Smart Panel, Sync mode */ + data |= MDP5_SPLIT_DPL_UPPER_SMART_PANEL; + + /* Make sure clocks are on when connectors calling this function. */ + mdp5_enable(mdp5_kms); + mdp5_write(mdp5_kms, REG_MDP5_SPLIT_DPL_UPPER, data); + + mdp5_write(mdp5_kms, REG_MDP5_SPLIT_DPL_LOWER, + MDP5_SPLIT_DPL_LOWER_SMART_PANEL); + mdp5_write(mdp5_kms, REG_MDP5_SPLIT_DPL_EN, 1); + mdp5_disable(mdp5_kms); + + return 0; +} + static void mdp5_encoder_destroy(struct drm_encoder *encoder) { struct mdp5_encoder *mdp5_encoder = to_mdp5_encoder(encoder); @@ -286,12 +501,59 @@ static const struct drm_encoder_helper_funcs mdp5_encoder_helper_funcs = { .enable = mdp5_encoder_enable, }; +int mdp5_encoder_set_split_display(struct drm_encoder *encoder, + struct drm_encoder *slave_encoder) +{ + struct mdp5_encoder *mdp5_encoder = to_mdp5_encoder(encoder); + struct mdp5_kms *mdp5_kms; + int intf_num; + u32 data = 0; + + if (!encoder || !slave_encoder) + return -EINVAL; + + mdp5_kms = get_kms(encoder); + intf_num = mdp5_encoder->intf.num; + + mdp5_write(mdp5_kms, REG_MDP5_SPARE_0, + MDP5_SPARE_0_SPLIT_DPL_SINGLE_FLUSH_EN); + + /* Switch slave encoder's TimingGen Sync mode, + * to use the master's enable signal for the slave encoder. + */ + if (intf_num == 1) + data |= MDP5_SPLIT_DPL_LOWER_INTF2_TG_SYNC; + else if (intf_num == 2) + data |= MDP5_SPLIT_DPL_LOWER_INTF1_TG_SYNC; + else + return -EINVAL; + + /* Make sure clocks are on when connectors calling this function. */ + mdp5_enable(mdp5_kms); + /* Dumb Panel, Sync mode */ + mdp5_write(mdp5_kms, REG_MDP5_SPLIT_DPL_UPPER, 0); + mdp5_write(mdp5_kms, REG_MDP5_SPLIT_DPL_LOWER, data); + mdp5_write(mdp5_kms, REG_MDP5_SPLIT_DPL_EN, 1); + mdp5_disable(mdp5_kms); + + return 0; +} + /* initialize encoder */ struct drm_encoder *mdp5_encoder_init(struct drm_device *dev, struct mdp5_interface *intf) { struct drm_encoder *encoder = NULL; struct mdp5_encoder *mdp5_encoder; + const struct drm_encoder_funcs *funcs = + (intf->mode == MDP5_INTF_DSI_MODE_COMMAND) ? + (&mdp5_cmd_encoder_funcs) : (&mdp5_encoder_funcs); + const struct drm_encoder_helper_funcs *helper_funcs = + (intf->mode == MDP5_INTF_DSI_MODE_COMMAND) ? + (&mdp5_cmd_encoder_helper_funcs) : (&mdp5_encoder_helper_funcs); + int enc_type = (intf->type == INTF_DSI) ? + DRM_MODE_ENCODER_DSI : DRM_MODE_ENCODER_TMDS; + int ret; mdp5_encoder = kzalloc(sizeof(*mdp5_encoder), GFP_KERNEL); @@ -305,9 +567,9 @@ struct drm_encoder *mdp5_encoder_init(struct drm_device *dev, spin_lock_init(&mdp5_encoder->intf_lock); - drm_encoder_init(dev, encoder, &mdp5_encoder_funcs, - DRM_MODE_ENCODER_TMDS); - drm_encoder_helper_add(encoder, &mdp5_encoder_helper_funcs); + drm_encoder_init(dev, encoder, funcs, enc_type); + + drm_encoder_helper_add(encoder, helper_funcs); bs_init(mdp5_encoder); diff --git a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_kms.c b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_kms.c index e5fd332..dfc3d38 100644 --- a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_kms.c +++ b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_kms.c @@ -88,6 +88,18 @@ static long mdp5_round_pixclk(struct msm_kms *kms, unsigned long rate, return rate; } +static int mdp5_set_split_display(struct msm_kms *kms, + struct drm_encoder *encoder, + struct drm_encoder *slave_encoder, + bool is_cmd_mode) +{ + if (is_cmd_mode) + return mdp5_cmd_encoder_set_split_display(encoder, + slave_encoder); + else + return mdp5_encoder_set_split_display(encoder, slave_encoder); +} + static void mdp5_preclose(struct msm_kms *kms, struct drm_file *file) { struct mdp5_kms *mdp5_kms = to_mdp5_kms(to_mdp_kms(kms)); @@ -133,6 +145,7 @@ static const struct mdp_kms_funcs kms_funcs = { .complete_commit = mdp5_complete_commit, .get_format = mdp_get_format, .round_pixclk = mdp5_round_pixclk, + .set_split_display = mdp5_set_split_display, .preclose = mdp5_preclose, .destroy = mdp5_destroy, }, @@ -163,6 +176,24 @@ int mdp5_enable(struct mdp5_kms *mdp5_kms) return 0; } +static int get_dsi_id_from_intf(const struct mdp5_cfg_hw *hw_cfg, int intf_num) +{ + const int intf_cnt = hw_cfg->intf.count; + const u32 *intfs = hw_cfg->intfs; + int id = 0, i; + + for (i = 0; i < intf_cnt; i++) { + if (intfs[i] == INTF_DSI) { + if (intf_num == i) + return id; + + id++; + } + } + + return -EINVAL; +} + static struct drm_encoder *construct_encoder(struct mdp5_kms *mdp5_kms, enum mdp5_intf_type intf_type, int intf_num, enum mdp5_intf_mode intf_mode) @@ -254,6 +285,7 @@ static int modeset_init(struct mdp5_kms *mdp5_kms) enum mdp5_intf_mode intf_mode = MDP5_INTF_MODE_NONE; struct msm_drm_sub_dev *sub_dev; struct drm_encoder *encoder; + int encoder_num = 1, j; switch (intf_type) { case INTF_DISABLED: @@ -265,6 +297,23 @@ static int modeset_init(struct mdp5_kms *mdp5_kms) case INTF_HDMI: sub_dev = priv->hdmi; break; + case INTF_DSI: + { + int dsi_id = get_dsi_id_from_intf(hw_cfg, i); + + if ((dsi_id >= ARRAY_SIZE(priv->dsi)) || + (dsi_id < 0)) { + dev_err(dev->dev, + "failed to find dsi id from intf %d\n", + i); + ret = -EINVAL; + goto fail; + } + sub_dev = priv->dsi[dsi_id]; + encoder_num = MSM_DSI_ENCODER_NUM; + + break; + } default: dev_err(dev->dev, "unknown intf: %d\n", intf_type); ret = -EINVAL; @@ -272,14 +321,20 @@ static int modeset_init(struct mdp5_kms *mdp5_kms) } if (sub_dev) { - encoder = construct_encoder(mdp5_kms, intf_type, - i, intf_mode); - if (IS_ERR(encoder)) { - ret = PTR_ERR(encoder); - goto fail; + for (j = 0; j < encoder_num; j++) { + if (MSM_DSI_CMD_ENCODER_ID == j) + intf_mode = MDP5_INTF_DSI_MODE_COMMAND; + + encoder = construct_encoder(mdp5_kms, intf_type, + i, intf_mode); + if (IS_ERR(encoder)) { + ret = PTR_ERR(encoder); + goto fail; + } + + sub_dev->encoders[sub_dev->num_encoders++] = + encoder; } - - sub_dev->encoders[sub_dev->num_encoders++] = encoder; ret = sub_dev->modeset_init(sub_dev, dev); if (ret) goto fail; diff --git a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_kms.h b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_kms.h index 690edfd..3ef2ff6 100644 --- a/drivers/gpu/drm/msm/mdp/mdp5/mdp5_kms.h +++ b/drivers/gpu/drm/msm/mdp/mdp5/mdp5_kms.h @@ -159,10 +159,9 @@ static inline uint32_t intf2err(int intf_num) } } +#define GET_PING_PONG_ID(layer_mixer) ((layer_mixer == 5) ? 3 : layer_mixer) static inline uint32_t intf2vblank(int lm, struct mdp5_interface *intf) { -#define GET_PING_PONG_ID(layer_mixer) ((layer_mixer == 5) ? 3 : layer_mixer) - /* * In case of DSI Command Mode, the Ping Pong's read pointer IRQ * acts as a Vblank signal. The Ping Pong buffer used is bound to @@ -185,6 +184,11 @@ static inline uint32_t intf2vblank(int lm, struct mdp5_interface *intf) } } +static inline uint32_t lm2ppdone(int lm) +{ + return MDP5_IRQ_PING_PONG_0_DONE << GET_PING_PONG_ID(lm); +} + int mdp5_disable(struct mdp5_kms *mdp5_kms); int mdp5_enable(struct mdp5_kms *mdp5_kms); @@ -236,6 +240,10 @@ void mdp5_crtc_set_intf(struct drm_crtc *crtc, struct mdp5_interface *intf); struct drm_crtc *mdp5_crtc_init(struct drm_device *dev, struct drm_plane *plane, int id); +int mdp5_cmd_encoder_set_split_display(struct drm_encoder *encoder, + struct drm_encoder *slave_encoder); +int mdp5_encoder_set_split_display(struct drm_encoder *encoder, + struct drm_encoder *slave_encoder); struct drm_encoder *mdp5_encoder_init(struct drm_device *dev, struct mdp5_interface *intf); diff --git a/drivers/gpu/drm/msm/msm_drv.c b/drivers/gpu/drm/msm/msm_drv.c index dfd583f..bc61c34 100644 --- a/drivers/gpu/drm/msm/msm_drv.c +++ b/drivers/gpu/drm/msm/msm_drv.c @@ -1030,6 +1030,7 @@ static struct platform_driver msm_platform_driver = { static int __init msm_drm_register(void) { DBG("init"); + msm_dsi_register(); msm_edp_register(); hdmi_register(); adreno_register(); @@ -1043,6 +1044,7 @@ static void __exit msm_drm_unregister(void) hdmi_unregister(); adreno_unregister(); msm_edp_unregister(); + msm_dsi_unregister(); } module_init(msm_drm_register); -- The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, hosted by The Linux Foundation