From mboxrd@z Thu Jan 1 00:00:00 1970 From: Jayant Shekhar Subject: [v5 1/3] drm/msm/dpu: clean up references of DPU custom bus scaling Date: Wed, 9 Jan 2019 23:22:03 +0530 Message-ID: <1547056325-1919-2-git-send-email-jshekhar@codeaurora.org> References: <1547056325-1919-1-git-send-email-jshekhar@codeaurora.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1547056325-1919-1-git-send-email-jshekhar@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, linux-arm-msm@vger.kernel.org, freedreno@lists.freedesktop.org, devicetree@vger.kernel.org Cc: linux-kernel@vger.kernel.org, abhinavk@codeaurora.org, Jayant Shekhar , seanpaul@chromium.org, chandanu@codeaurora.org, hoegsberg@chromium.org, Sravanthi Kollukuduru List-Id: linux-arm-msm@vger.kernel.org RnJvbTogU3JhdmFudGhpIEtvbGx1a3VkdXJ1IDxza29sbHVrdUBjb2RlYXVyb3JhLm9yZz4KClNp bmNlIHRoZSB1cHN0cmVhbSBpbnRlcmNvbm5lY3QgYnVzIGZyYW1ld29yayBoYXMgbGFuZGVkCnVw c3RyZWFtLCB0aGUgZXhpc3RpbmcgcmVmZXJlbmNlcyBvZiBjdXN0b20gYnVzIHNjYWxpbmcKbmVl ZHMgdG8gYmUgY2xlYW5lZCB1cC4KCkNoYW5nZXMgaW4gdjI6CgktIEZpeGVkIGJ1aWxkIGVycm9y IGR1ZSB0byBwYXJ0aWFsIGNsZWFuIHVwCgpDaGFuZ2VzIGluIHYzOgoJLSBDb25kZW5zZSBtdWx0 aXBsZSBsaW5lcyBpbnRvIGEgc2luZ2xlIGxpbmUgKFNlYW4gUGF1bCkKCkNoYW5nZXMgaW4gdjQ6 CgktIE5vbmUKCkNoYW5nZXMgaW4gdjU6CgktIE5vbmUKClNpZ25lZC1vZmYtYnk6IFNyYXZhbnRo aSBLb2xsdWt1ZHVydSA8c2tvbGx1a3VAY29kZWF1cm9yYS5vcmc+ClNpZ25lZC1vZmYtYnk6IEph eWFudCBTaGVraGFyIDxqc2hla2hhckBjb2RlYXVyb3JhLm9yZz4KLS0tCiBkcml2ZXJzL2dwdS9k cm0vbXNtL2Rpc3AvZHB1MS9kcHVfY29yZV9wZXJmLmMgICAgfCAxNzQgKysrKysrKysrLS0tLS0t LS0tLS0tLS0KIGRyaXZlcnMvZ3B1L2RybS9tc20vZGlzcC9kcHUxL2RwdV9jb3JlX3BlcmYuaCAg ICB8ICAgNCArLQogZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL2RwdTEvZHB1X2NydGMuYyAgICAg ICAgIHwgIDEzICstCiBkcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3AvZHB1MS9kcHVfcG93ZXJfaGFu ZGxlLmMgfCAgNDcgKystLS0tCiBkcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3AvZHB1MS9kcHVfcG93 ZXJfaGFuZGxlLmggfCAgNjggLS0tLS0tLS0tCiBkcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3AvZHB1 MS9kcHVfdHJhY2UuaCAgICAgICAgfCAgMjIgKy0tCiA2IGZpbGVzIGNoYW5nZWQsIDg5IGluc2Vy dGlvbnMoKyksIDIzOSBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0v bXNtL2Rpc3AvZHB1MS9kcHVfY29yZV9wZXJmLmMgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3Av ZHB1MS9kcHVfY29yZV9wZXJmLmMKaW5kZXggMjJlODRiMy4uYzc1NTM2ZSAxMDA2NDQKLS0tIGEv ZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL2RwdTEvZHB1X2NvcmVfcGVyZi5jCisrKyBiL2RyaXZl cnMvZ3B1L2RybS9tc20vZGlzcC9kcHUxL2RwdV9jb3JlX3BlcmYuYwpAQCAtODQsNyArODQsNiBA QCBzdGF0aWMgdm9pZCBfZHB1X2NvcmVfcGVyZl9jYWxjX2NydGMoc3RydWN0IGRwdV9rbXMgKmtt cywKIAkJc3RydWN0IGRwdV9jb3JlX3BlcmZfcGFyYW1zICpwZXJmKQogewogCXN0cnVjdCBkcHVf Y3J0Y19zdGF0ZSAqZHB1X2NzdGF0ZTsKLQlpbnQgaTsKIAogCWlmICgha21zIHx8ICFrbXMtPmNh dGFsb2cgfHwgIWNydGMgfHwgIXN0YXRlIHx8ICFwZXJmKSB7CiAJCURQVV9FUlJPUigiaW52YWxp ZCBwYXJhbWV0ZXJzXG4iKTsKQEAgLTk1LDM1ICs5NCwyNCBAQCBzdGF0aWMgdm9pZCBfZHB1X2Nv cmVfcGVyZl9jYWxjX2NydGMoc3RydWN0IGRwdV9rbXMgKmttcywKIAltZW1zZXQocGVyZiwgMCwg c2l6ZW9mKHN0cnVjdCBkcHVfY29yZV9wZXJmX3BhcmFtcykpOwogCiAJaWYgKCFkcHVfY3N0YXRl LT5id19jb250cm9sKSB7Ci0JCWZvciAoaSA9IDA7IGkgPCBEUFVfUE9XRVJfSEFORExFX0RCVVNf SURfTUFYOyBpKyspIHsKLQkJCXBlcmYtPmJ3X2N0bFtpXSA9IGttcy0+Y2F0YWxvZy0+cGVyZi5t YXhfYndfaGlnaCAqCisJCXBlcmYtPmJ3X2N0bCA9IGttcy0+Y2F0YWxvZy0+cGVyZi5tYXhfYndf aGlnaCAqCiAJCQkJCTEwMDBVTEw7Ci0JCQlwZXJmLT5tYXhfcGVyX3BpcGVfaWJbaV0gPSBwZXJm LT5id19jdGxbaV07Ci0JCX0KKwkJcGVyZi0+bWF4X3Blcl9waXBlX2liID0gcGVyZi0+YndfY3Rs OwogCQlwZXJmLT5jb3JlX2Nsa19yYXRlID0ga21zLT5wZXJmLm1heF9jb3JlX2Nsa19yYXRlOwog CX0gZWxzZSBpZiAoa21zLT5wZXJmLnBlcmZfdHVuZS5tb2RlID09IERQVV9QRVJGX01PREVfTUlO SU1VTSkgewotCQlmb3IgKGkgPSAwOyBpIDwgRFBVX1BPV0VSX0hBTkRMRV9EQlVTX0lEX01BWDsg aSsrKSB7Ci0JCQlwZXJmLT5id19jdGxbaV0gPSAwOwotCQkJcGVyZi0+bWF4X3Blcl9waXBlX2li W2ldID0gMDsKLQkJfQorCQlwZXJmLT5id19jdGwgPSAwOworCQlwZXJmLT5tYXhfcGVyX3BpcGVf aWIgPSAwOwogCQlwZXJmLT5jb3JlX2Nsa19yYXRlID0gMDsKIAl9IGVsc2UgaWYgKGttcy0+cGVy Zi5wZXJmX3R1bmUubW9kZSA9PSBEUFVfUEVSRl9NT0RFX0ZJWEVEKSB7Ci0JCWZvciAoaSA9IDA7 IGkgPCBEUFVfUE9XRVJfSEFORExFX0RCVVNfSURfTUFYOyBpKyspIHsKLQkJCXBlcmYtPmJ3X2N0 bFtpXSA9IGttcy0+cGVyZi5maXhfY29yZV9hYl92b3RlOwotCQkJcGVyZi0+bWF4X3Blcl9waXBl X2liW2ldID0ga21zLT5wZXJmLmZpeF9jb3JlX2liX3ZvdGU7Ci0JCX0KKwkJcGVyZi0+YndfY3Rs ID0ga21zLT5wZXJmLmZpeF9jb3JlX2FiX3ZvdGU7CisJCXBlcmYtPm1heF9wZXJfcGlwZV9pYiA9 IGttcy0+cGVyZi5maXhfY29yZV9pYl92b3RlOwogCQlwZXJmLT5jb3JlX2Nsa19yYXRlID0ga21z LT5wZXJmLmZpeF9jb3JlX2Nsa19yYXRlOwogCX0KIAogCURQVV9ERUJVRygKLQkJImNydGM9JWQg Y2xrX3JhdGU9JWxsdSBjb3JlX2liPSVsbHUgY29yZV9hYj0lbGx1IGxsY2NfaWI9JWxsdSBsbGNj X2FiPSVsbHUgbWVtX2liPSVsbHUgbWVtX2FiPSVsbHVcbiIsCisJCSJjcnRjPSVkIGNsa19yYXRl PSVsbHUgY29yZV9pYj0lbGx1IGNvcmVfYWI9JWxsdVxuIiwKIAkJCWNydGMtPmJhc2UuaWQsIHBl cmYtPmNvcmVfY2xrX3JhdGUsCi0JCQlwZXJmLT5tYXhfcGVyX3BpcGVfaWJbRFBVX1BPV0VSX0hB TkRMRV9EQlVTX0lEX01OT0NdLAotCQkJcGVyZi0+YndfY3RsW0RQVV9QT1dFUl9IQU5ETEVfREJV U19JRF9NTk9DXSwKLQkJCXBlcmYtPm1heF9wZXJfcGlwZV9pYltEUFVfUE9XRVJfSEFORExFX0RC VVNfSURfTExDQ10sCi0JCQlwZXJmLT5id19jdGxbRFBVX1BPV0VSX0hBTkRMRV9EQlVTX0lEX0xM Q0NdLAotCQkJcGVyZi0+bWF4X3Blcl9waXBlX2liW0RQVV9QT1dFUl9IQU5ETEVfREJVU19JRF9F QkldLAotCQkJcGVyZi0+YndfY3RsW0RQVV9QT1dFUl9IQU5ETEVfREJVU19JRF9FQkldKTsKKwkJ CXBlcmYtPm1heF9wZXJfcGlwZV9pYiwgcGVyZi0+YndfY3RsKTsKIH0KIAogaW50IGRwdV9jb3Jl X3BlcmZfY3J0Y19jaGVjayhzdHJ1Y3QgZHJtX2NydGMgKmNydGMsCkBAIC0xMzYsNyArMTI0LDYg QEAgaW50IGRwdV9jb3JlX3BlcmZfY3J0Y19jaGVjayhzdHJ1Y3QgZHJtX2NydGMgKmNydGMsCiAJ c3RydWN0IGRwdV9jcnRjX3N0YXRlICpkcHVfY3N0YXRlOwogCXN0cnVjdCBkcm1fY3J0YyAqdG1w X2NydGM7CiAJc3RydWN0IGRwdV9rbXMgKmttczsKLQlpbnQgaTsKIAogCWlmICghY3J0YyB8fCAh c3RhdGUpIHsKIAkJRFBVX0VSUk9SKCJpbnZhbGlkIGNydGNcbiIpOwpAQCAtMTU4LDMxICsxNDUs MjUgQEAgaW50IGRwdV9jb3JlX3BlcmZfY3J0Y19jaGVjayhzdHJ1Y3QgZHJtX2NydGMgKmNydGMs CiAJLyogb2J0YWluIG5ldyB2YWx1ZXMgKi8KIAlfZHB1X2NvcmVfcGVyZl9jYWxjX2NydGMoa21z LCBjcnRjLCBzdGF0ZSwgJmRwdV9jc3RhdGUtPm5ld19wZXJmKTsKIAotCWZvciAoaSA9IERQVV9Q T1dFUl9IQU5ETEVfREJVU19JRF9NTk9DOwotCQkJaSA8IERQVV9QT1dFUl9IQU5ETEVfREJVU19J RF9NQVg7IGkrKykgewotCQlid19zdW1fb2ZfaW50ZnMgPSBkcHVfY3N0YXRlLT5uZXdfcGVyZi5i d19jdGxbaV07Ci0JCWN1cnJfY2xpZW50X3R5cGUgPSBkcHVfY3J0Y19nZXRfY2xpZW50X3R5cGUo Y3J0Yyk7CisJYndfc3VtX29mX2ludGZzID0gZHB1X2NzdGF0ZS0+bmV3X3BlcmYuYndfY3RsOwor CWN1cnJfY2xpZW50X3R5cGUgPSBkcHVfY3J0Y19nZXRfY2xpZW50X3R5cGUoY3J0Yyk7CiAKLQkJ ZHJtX2Zvcl9lYWNoX2NydGModG1wX2NydGMsIGNydGMtPmRldikgewotCQkJaWYgKF9kcHVfY29y ZV9wZXJmX2NydGNfaXNfcG93ZXJfb24odG1wX2NydGMpICYmCi0JCQkgICAgKGRwdV9jcnRjX2dl dF9jbGllbnRfdHlwZSh0bXBfY3J0YykgPT0KLQkJCQkJICAgIGN1cnJfY2xpZW50X3R5cGUpICYm Ci0JCQkgICAgKHRtcF9jcnRjICE9IGNydGMpKSB7Ci0JCQkJc3RydWN0IGRwdV9jcnRjX3N0YXRl ICp0bXBfY3N0YXRlID0KLQkJCQkJdG9fZHB1X2NydGNfc3RhdGUodG1wX2NydGMtPnN0YXRlKTsK LQotCQkJCURQVV9ERUJVRygiY3J0YzolZCBidzolbGx1IGN0cmw6JWRcbiIsCi0JCQkJCXRtcF9j cnRjLT5iYXNlLmlkLAotCQkJCQl0bXBfY3N0YXRlLT5uZXdfcGVyZi5id19jdGxbaV0sCi0JCQkJ CXRtcF9jc3RhdGUtPmJ3X2NvbnRyb2wpOwotCQkJCS8qCi0JCQkJICogRm9yIGJ3IGNoZWNrIG9u bHkgdXNlIHRoZSBidyBpZiB0aGUKLQkJCQkgKiBhdG9taWMgcHJvcGVydHkgaGFzIGJlZW4gYWxy ZWFkeSBzZXQKLQkJCQkgKi8KLQkJCQlpZiAodG1wX2NzdGF0ZS0+YndfY29udHJvbCkKLQkJCQkJ Yndfc3VtX29mX2ludGZzICs9Ci0JCQkJCQl0bXBfY3N0YXRlLT5uZXdfcGVyZi5id19jdGxbaV07 Ci0JCQl9CisJZHJtX2Zvcl9lYWNoX2NydGModG1wX2NydGMsIGNydGMtPmRldikgeworCQlpZiAo X2RwdV9jb3JlX3BlcmZfY3J0Y19pc19wb3dlcl9vbih0bXBfY3J0YykgJiYKKwkJICAgIChkcHVf Y3J0Y19nZXRfY2xpZW50X3R5cGUodG1wX2NydGMpID09CisJCQkJY3Vycl9jbGllbnRfdHlwZSkg JiYgKHRtcF9jcnRjICE9IGNydGMpKSB7CisJCQlzdHJ1Y3QgZHB1X2NydGNfc3RhdGUgKnRtcF9j c3RhdGUgPQorCQkJCXRvX2RwdV9jcnRjX3N0YXRlKHRtcF9jcnRjLT5zdGF0ZSk7CisKKwkJCURQ VV9ERUJVRygiY3J0YzolZCBidzolbGx1IGN0cmw6JWRcbiIsCisJCQkJdG1wX2NydGMtPmJhc2Uu aWQsIHRtcF9jc3RhdGUtPm5ld19wZXJmLmJ3X2N0bCwKKwkJCQl0bXBfY3N0YXRlLT5id19jb250 cm9sKTsKKwkJCS8qCisJCQkgKiBGb3IgYncgY2hlY2sgb25seSB1c2UgdGhlIGJ3IGlmIHRoZQor CQkJICogYXRvbWljIHByb3BlcnR5IGhhcyBiZWVuIGFscmVhZHkgc2V0CisJCQkgKi8KKwkJCWlm ICh0bXBfY3N0YXRlLT5id19jb250cm9sKQorCQkJCWJ3X3N1bV9vZl9pbnRmcyArPSB0bXBfY3N0 YXRlLT5uZXdfcGVyZi5id19jdGw7CiAJCX0KIAogCQkvKiBjb252ZXJ0IGJhbmR3aWR0aCB0byBr YiAqLwpAQCAtMjEzLDkgKzE5NCw5IEBAIGludCBkcHVfY29yZV9wZXJmX2NydGNfY2hlY2soc3Ry dWN0IGRybV9jcnRjICpjcnRjLAogfQogCiBzdGF0aWMgaW50IF9kcHVfY29yZV9wZXJmX2NydGNf dXBkYXRlX2J1cyhzdHJ1Y3QgZHB1X2ttcyAqa21zLAotCQlzdHJ1Y3QgZHJtX2NydGMgKmNydGMs IHUzMiBidXNfaWQpCisJCXN0cnVjdCBkcm1fY3J0YyAqY3J0YykKIHsKLQlzdHJ1Y3QgZHB1X2Nv cmVfcGVyZl9wYXJhbXMgcGVyZiA9IHsgeyAwIH0gfTsKKwlzdHJ1Y3QgZHB1X2NvcmVfcGVyZl9w YXJhbXMgcGVyZiA9IHsgMCB9OwogCWVudW0gZHB1X2NydGNfY2xpZW50X3R5cGUgY3Vycl9jbGll bnRfdHlwZQogCQkJCQk9IGRwdV9jcnRjX2dldF9jbGllbnRfdHlwZShjcnRjKTsKIAlzdHJ1Y3Qg ZHJtX2NydGMgKnRtcF9jcnRjOwpAQCAtMjI4LDEzICsyMDksMTEgQEAgc3RhdGljIGludCBfZHB1 X2NvcmVfcGVyZl9jcnRjX3VwZGF0ZV9idXMoc3RydWN0IGRwdV9rbXMgKmttcywKIAkJCQlkcHVf Y3J0Y19nZXRfY2xpZW50X3R5cGUodG1wX2NydGMpKSB7CiAJCQlkcHVfY3N0YXRlID0gdG9fZHB1 X2NydGNfc3RhdGUodG1wX2NydGMtPnN0YXRlKTsKIAotCQkJcGVyZi5tYXhfcGVyX3BpcGVfaWJb YnVzX2lkXSA9Ci0JCQkJbWF4KHBlcmYubWF4X3Blcl9waXBlX2liW2J1c19pZF0sCi0JCQkJZHB1 X2NzdGF0ZS0+bmV3X3BlcmYubWF4X3Blcl9waXBlX2liW2J1c19pZF0pOworCQkJcGVyZi5tYXhf cGVyX3BpcGVfaWIgPSBtYXgocGVyZi5tYXhfcGVyX3BpcGVfaWIsCisJCQkJCWRwdV9jc3RhdGUt Pm5ld19wZXJmLm1heF9wZXJfcGlwZV9pYik7CiAKLQkJCURQVV9ERUJVRygiY3J0Yz0lZCBidXNf aWQ9JWQgYnc9JWxsdVxuIiwKLQkJCQl0bXBfY3J0Yy0+YmFzZS5pZCwgYnVzX2lkLAotCQkJCWRw dV9jc3RhdGUtPm5ld19wZXJmLmJ3X2N0bFtidXNfaWRdKTsKKwkJCURQVV9ERUJVRygiY3J0Yz0l ZCBidz0lbGx1XG4iLCB0bXBfY3J0Yy0+YmFzZS5pZCwKKwkJCQkJZHB1X2NzdGF0ZS0+bmV3X3Bl cmYuYndfY3RsKTsKIAkJfQogCX0KIAlyZXR1cm4gcmV0OwpAQCAtMjU0LDcgKzIzMyw2IEBAIHZv aWQgZHB1X2NvcmVfcGVyZl9jcnRjX3JlbGVhc2VfYncoc3RydWN0IGRybV9jcnRjICpjcnRjKQog CXN0cnVjdCBkcHVfY3J0YyAqZHB1X2NydGM7CiAJc3RydWN0IGRwdV9jcnRjX3N0YXRlICpkcHVf Y3N0YXRlOwogCXN0cnVjdCBkcHVfa21zICprbXM7Ci0JaW50IGk7CiAKIAlpZiAoIWNydGMpIHsK IAkJRFBVX0VSUk9SKCJpbnZhbGlkIGNydGNcbiIpOwpAQCAtMjkwLDEwICsyNjgsOCBAQCB2b2lk IGRwdV9jb3JlX3BlcmZfY3J0Y19yZWxlYXNlX2J3KHN0cnVjdCBkcm1fY3J0YyAqY3J0YykKIAlp ZiAoa21zLT5wZXJmLmVuYWJsZV9id19yZWxlYXNlKSB7CiAJCXRyYWNlX2RwdV9jbWRfcmVsZWFz ZV9idyhjcnRjLT5iYXNlLmlkKTsKIAkJRFBVX0RFQlVHKCJSZWxlYXNlIEJXIGNydGM9JWRcbiIs IGNydGMtPmJhc2UuaWQpOwotCQlmb3IgKGkgPSAwOyBpIDwgRFBVX1BPV0VSX0hBTkRMRV9EQlVT X0lEX01BWDsgaSsrKSB7Ci0JCQlkcHVfY3J0Yy0+Y3VyX3BlcmYuYndfY3RsW2ldID0gMDsKLQkJ CV9kcHVfY29yZV9wZXJmX2NydGNfdXBkYXRlX2J1cyhrbXMsIGNydGMsIGkpOwotCQl9CisJCWRw dV9jcnRjLT5jdXJfcGVyZi5id19jdGwgPSAwOworCQlfZHB1X2NvcmVfcGVyZl9jcnRjX3VwZGF0 ZV9idXMoa21zLCBjcnRjKTsKIAl9CiB9CiAKQEAgLTMzNiwxMSArMzEyLDEwIEBAIGludCBkcHVf Y29yZV9wZXJmX2NydGNfdXBkYXRlKHN0cnVjdCBkcm1fY3J0YyAqY3J0YywKIAkJaW50IHBhcmFt c19jaGFuZ2VkLCBib29sIHN0b3BfcmVxKQogewogCXN0cnVjdCBkcHVfY29yZV9wZXJmX3BhcmFt cyAqbmV3LCAqb2xkOwotCWludCB1cGRhdGVfYnVzID0gMCwgdXBkYXRlX2NsayA9IDA7CisJYm9v bCB1cGRhdGVfYnVzID0gZmFsc2UsIHVwZGF0ZV9jbGsgPSBmYWxzZTsKIAl1NjQgY2xrX3JhdGUg PSAwOwogCXN0cnVjdCBkcHVfY3J0YyAqZHB1X2NydGM7CiAJc3RydWN0IGRwdV9jcnRjX3N0YXRl ICpkcHVfY3N0YXRlOwotCWludCBpOwogCXN0cnVjdCBtc21fZHJtX3ByaXZhdGUgKnByaXY7CiAJ c3RydWN0IGRwdV9rbXMgKmttczsKIAlpbnQgcmV0OwpAQCAtMzY3LDYyICszNDIsNDkgQEAgaW50 IGRwdV9jb3JlX3BlcmZfY3J0Y191cGRhdGUoc3RydWN0IGRybV9jcnRjICpjcnRjLAogCW5ldyA9 ICZkcHVfY3N0YXRlLT5uZXdfcGVyZjsKIAogCWlmIChfZHB1X2NvcmVfcGVyZl9jcnRjX2lzX3Bv d2VyX29uKGNydGMpICYmICFzdG9wX3JlcSkgewotCQlmb3IgKGkgPSAwOyBpIDwgRFBVX1BPV0VS X0hBTkRMRV9EQlVTX0lEX01BWDsgaSsrKSB7Ci0JCQkvKgotCQkJICogY2FzZXMgZm9yIGJ1cyBi YW5kd2lkdGggdXBkYXRlLgotCQkJICogMS4gbmV3IGJhbmR3aWR0aCB2b3RlIC0gImFiIG9yIGli IHZvdGUiIGlzIGhpZ2hlcgotCQkJICogICAgdGhhbiBjdXJyZW50IHZvdGUgZm9yIHVwZGF0ZSBy ZXF1ZXN0LgotCQkJICogMi4gbmV3IGJhbmR3aWR0aCB2b3RlIC0gImFiIG9yIGliIHZvdGUiIGlz IGxvd2VyCi0JCQkgKiAgICB0aGFuIGN1cnJlbnQgdm90ZSBhdCBlbmQgb2YgY29tbWl0IG9yIHN0 b3AuCi0JCQkgKi8KLQkJCWlmICgocGFyYW1zX2NoYW5nZWQgJiYgKChuZXctPmJ3X2N0bFtpXSA+ Ci0JCQkJCQlvbGQtPmJ3X2N0bFtpXSkgfHwKLQkJCQkgIChuZXctPm1heF9wZXJfcGlwZV9pYltp XSA+Ci0JCQkJCQlvbGQtPm1heF9wZXJfcGlwZV9pYltpXSkpKSB8fAotCQkJICAgICghcGFyYW1z X2NoYW5nZWQgJiYgKChuZXctPmJ3X2N0bFtpXSA8Ci0JCQkJCQlvbGQtPmJ3X2N0bFtpXSkgfHwK LQkJCQkgIChuZXctPm1heF9wZXJfcGlwZV9pYltpXSA8Ci0JCQkJCQlvbGQtPm1heF9wZXJfcGlw ZV9pYltpXSkpKSkgewotCQkJCURQVV9ERUJVRygKLQkJCQkJImNydGM9JWQgcD0lZCBuZXdfYnc9 JWxsdSxvbGRfYnc9JWxsdVxuIiwKLQkJCQkJY3J0Yy0+YmFzZS5pZCwgcGFyYW1zX2NoYW5nZWQs Ci0JCQkJCW5ldy0+YndfY3RsW2ldLCBvbGQtPmJ3X2N0bFtpXSk7Ci0JCQkJb2xkLT5id19jdGxb aV0gPSBuZXctPmJ3X2N0bFtpXTsKLQkJCQlvbGQtPm1heF9wZXJfcGlwZV9pYltpXSA9Ci0JCQkJ CQluZXctPm1heF9wZXJfcGlwZV9pYltpXTsKLQkJCQl1cGRhdGVfYnVzIHw9IEJJVChpKTsKLQkJ CX0KKwkJLyoKKwkJICogY2FzZXMgZm9yIGJ1cyBiYW5kd2lkdGggdXBkYXRlLgorCQkgKiAxLiBu ZXcgYmFuZHdpZHRoIHZvdGUgLSAiYWIgb3IgaWIgdm90ZSIgaXMgaGlnaGVyCisJCSAqICAgIHRo YW4gY3VycmVudCB2b3RlIGZvciB1cGRhdGUgcmVxdWVzdC4KKwkJICogMi4gbmV3IGJhbmR3aWR0 aCB2b3RlIC0gImFiIG9yIGliIHZvdGUiIGlzIGxvd2VyCisJCSAqICAgIHRoYW4gY3VycmVudCB2 b3RlIGF0IGVuZCBvZiBjb21taXQgb3Igc3RvcC4KKwkJICovCisJCWlmICgocGFyYW1zX2NoYW5n ZWQgJiYgKChuZXctPmJ3X2N0bCA+IG9sZC0+YndfY3RsKSB8fAorCQkJKG5ldy0+bWF4X3Blcl9w aXBlX2liID4gb2xkLT5tYXhfcGVyX3BpcGVfaWIpKSkJfHwKKwkJCSghcGFyYW1zX2NoYW5nZWQg JiYgKChuZXctPmJ3X2N0bCA8IG9sZC0+YndfY3RsKSB8fAorCQkJKG5ldy0+bWF4X3Blcl9waXBl X2liIDwgb2xkLT5tYXhfcGVyX3BpcGVfaWIpKSkpIHsKKwkJCURQVV9ERUJVRygiY3J0Yz0lZCBw PSVkIG5ld19idz0lbGx1LG9sZF9idz0lbGx1XG4iLAorCQkJCWNydGMtPmJhc2UuaWQsIHBhcmFt c19jaGFuZ2VkLAorCQkJCW5ldy0+YndfY3RsLCBvbGQtPmJ3X2N0bCk7CisJCQlvbGQtPmJ3X2N0 bCA9IG5ldy0+YndfY3RsOworCQkJb2xkLT5tYXhfcGVyX3BpcGVfaWIgPSBuZXctPm1heF9wZXJf cGlwZV9pYjsKKwkJCXVwZGF0ZV9idXMgPSB0cnVlOwogCQl9CiAKIAkJaWYgKChwYXJhbXNfY2hh bmdlZCAmJgotCQkJCShuZXctPmNvcmVfY2xrX3JhdGUgPiBvbGQtPmNvcmVfY2xrX3JhdGUpKSB8 fAotCQkJCSghcGFyYW1zX2NoYW5nZWQgJiYKLQkJCQkobmV3LT5jb3JlX2Nsa19yYXRlIDwgb2xk LT5jb3JlX2Nsa19yYXRlKSkpIHsKKwkJCShuZXctPmNvcmVfY2xrX3JhdGUgPiBvbGQtPmNvcmVf Y2xrX3JhdGUpKSB8fAorCQkJKCFwYXJhbXNfY2hhbmdlZCAmJgorCQkJKG5ldy0+Y29yZV9jbGtf cmF0ZSA8IG9sZC0+Y29yZV9jbGtfcmF0ZSkpKSB7CiAJCQlvbGQtPmNvcmVfY2xrX3JhdGUgPSBu ZXctPmNvcmVfY2xrX3JhdGU7Ci0JCQl1cGRhdGVfY2xrID0gMTsKKwkJCXVwZGF0ZV9jbGsgPSB0 cnVlOwogCQl9CiAJfSBlbHNlIHsKIAkJRFBVX0RFQlVHKCJjcnRjPSVkIGRpc2FibGVcbiIsIGNy dGMtPmJhc2UuaWQpOwogCQltZW1zZXQob2xkLCAwLCBzaXplb2YoKm9sZCkpOwogCQltZW1zZXQo bmV3LCAwLCBzaXplb2YoKm5ldykpOwotCQl1cGRhdGVfYnVzID0gfjA7Ci0JCXVwZGF0ZV9jbGsg PSAxOworCQl1cGRhdGVfYnVzID0gdHJ1ZTsKKwkJdXBkYXRlX2NsayA9IHRydWU7CiAJfQotCXRy YWNlX2RwdV9wZXJmX2NydGNfdXBkYXRlKGNydGMtPmJhc2UuaWQsCi0JCQkJbmV3LT5id19jdGxb RFBVX1BPV0VSX0hBTkRMRV9EQlVTX0lEX01OT0NdLAotCQkJCW5ldy0+YndfY3RsW0RQVV9QT1dF Ul9IQU5ETEVfREJVU19JRF9MTENDXSwKLQkJCQluZXctPmJ3X2N0bFtEUFVfUE9XRVJfSEFORExF X0RCVVNfSURfRUJJXSwKLQkJCQluZXctPmNvcmVfY2xrX3JhdGUsIHN0b3BfcmVxLAotCQkJCXVw ZGF0ZV9idXMsIHVwZGF0ZV9jbGspOwotCi0JZm9yIChpID0gMDsgaSA8IERQVV9QT1dFUl9IQU5E TEVfREJVU19JRF9NQVg7IGkrKykgewotCQlpZiAodXBkYXRlX2J1cyAmIEJJVChpKSkgewotCQkJ cmV0ID0gX2RwdV9jb3JlX3BlcmZfY3J0Y191cGRhdGVfYnVzKGttcywgY3J0YywgaSk7Ci0JCQlp ZiAocmV0KSB7Ci0JCQkJRFBVX0VSUk9SKCJjcnRjLSVkOiBmYWlsZWQgdG8gdXBkYXRlIGJ3IHZv dGUgZm9yIGJ1cy0lZFxuIiwKLQkJCQkJICBjcnRjLT5iYXNlLmlkLCBpKTsKLQkJCQlyZXR1cm4g cmV0OwotCQkJfQorCisJdHJhY2VfZHB1X3BlcmZfY3J0Y191cGRhdGUoY3J0Yy0+YmFzZS5pZCwg bmV3LT5id19jdGwsCisJCW5ldy0+Y29yZV9jbGtfcmF0ZSwgc3RvcF9yZXEsIHVwZGF0ZV9idXMs IHVwZGF0ZV9jbGspOworCisJaWYgKHVwZGF0ZV9idXMpIHsKKwkJcmV0ID0gX2RwdV9jb3JlX3Bl cmZfY3J0Y191cGRhdGVfYnVzKGttcywgY3J0Yyk7CisJCWlmIChyZXQpIHsKKwkJCURQVV9FUlJP UigiY3J0Yy0lZDogZmFpbGVkIHRvIHVwZGF0ZSBidXMgYncgdm90ZVxuIiwKKwkJCQkgIGNydGMt PmJhc2UuaWQpOworCQkJcmV0dXJuIHJldDsKIAkJfQogCX0KIApkaWZmIC0tZ2l0IGEvZHJpdmVy cy9ncHUvZHJtL21zbS9kaXNwL2RwdTEvZHB1X2NvcmVfcGVyZi5oIGIvZHJpdmVycy9ncHUvZHJt L21zbS9kaXNwL2RwdTEvZHB1X2NvcmVfcGVyZi5oCmluZGV4IGZiY2JlMGMuLjBmYjI3NjkgMTAw NjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9tc20vZGlzcC9kcHUxL2RwdV9jb3JlX3BlcmYuaAor KysgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3AvZHB1MS9kcHVfY29yZV9wZXJmLmgKQEAgLTMw LDggKzMwLDggQEAKICAqIEBjb3JlX2Nsa19yYXRlOiBjb3JlIGNsb2NrIHJhdGUgcmVxdWVzdAog ICovCiBzdHJ1Y3QgZHB1X2NvcmVfcGVyZl9wYXJhbXMgewotCXU2NCBtYXhfcGVyX3BpcGVfaWJb RFBVX1BPV0VSX0hBTkRMRV9EQlVTX0lEX01BWF07Ci0JdTY0IGJ3X2N0bFtEUFVfUE9XRVJfSEFO RExFX0RCVVNfSURfTUFYXTsKKwl1NjQgbWF4X3Blcl9waXBlX2liOworCXU2NCBid19jdGw7CiAJ dTY0IGNvcmVfY2xrX3JhdGU7CiB9OwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbXNt L2Rpc3AvZHB1MS9kcHVfY3J0Yy5jIGIvZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL2RwdTEvZHB1 X2NydGMuYwppbmRleCBkMjdlYTJhLi5kMzRlYzlmIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9k cm0vbXNtL2Rpc3AvZHB1MS9kcHVfY3J0Yy5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9tc20vZGlz cC9kcHUxL2RwdV9jcnRjLmMKQEAgLTEzODksMjEgKzEzODksMTQgQEAgc3RhdGljIGludCBkcHVf Y3J0Y19kZWJ1Z2ZzX3N0YXRlX3Nob3coc3RydWN0IHNlcV9maWxlICpzLCB2b2lkICp2KQogewog CXN0cnVjdCBkcm1fY3J0YyAqY3J0YyA9IChzdHJ1Y3QgZHJtX2NydGMgKikgcy0+cHJpdmF0ZTsK IAlzdHJ1Y3QgZHB1X2NydGMgKmRwdV9jcnRjID0gdG9fZHB1X2NydGMoY3J0Yyk7Ci0JaW50IGk7 CiAKIAlzZXFfcHJpbnRmKHMsICJjbGllbnQgdHlwZTogJWRcbiIsIGRwdV9jcnRjX2dldF9jbGll bnRfdHlwZShjcnRjKSk7CiAJc2VxX3ByaW50ZihzLCAiaW50Zl9tb2RlOiAlZFxuIiwgZHB1X2Ny dGNfZ2V0X2ludGZfbW9kZShjcnRjKSk7CiAJc2VxX3ByaW50ZihzLCAiY29yZV9jbGtfcmF0ZTog JWxsdVxuIiwKIAkJCWRwdV9jcnRjLT5jdXJfcGVyZi5jb3JlX2Nsa19yYXRlKTsKLQlmb3IgKGkg PSBEUFVfUE9XRVJfSEFORExFX0RCVVNfSURfTU5PQzsKLQkJCWkgPCBEUFVfUE9XRVJfSEFORExF X0RCVVNfSURfTUFYOyBpKyspIHsKLQkJc2VxX3ByaW50ZihzLCAiYndfY3RsWyVzXTogJWxsdVxu IiwKLQkJCQlkcHVfcG93ZXJfaGFuZGxlX2dldF9kYnVzX25hbWUoaSksCi0JCQkJZHB1X2NydGMt PmN1cl9wZXJmLmJ3X2N0bFtpXSk7Ci0JCXNlcV9wcmludGYocywgIm1heF9wZXJfcGlwZV9pYlsl c106ICVsbHVcbiIsCi0JCQkJZHB1X3Bvd2VyX2hhbmRsZV9nZXRfZGJ1c19uYW1lKGkpLAotCQkJ CWRwdV9jcnRjLT5jdXJfcGVyZi5tYXhfcGVyX3BpcGVfaWJbaV0pOwotCX0KKwlzZXFfcHJpbnRm KHMsICJid19jdGw6ICVsbHVcbiIsIGRwdV9jcnRjLT5jdXJfcGVyZi5id19jdGwpOworCXNlcV9w cmludGYocywgIm1heF9wZXJfcGlwZV9pYjogJWxsdVxuIiwKKwkJCQlkcHVfY3J0Yy0+Y3VyX3Bl cmYubWF4X3Blcl9waXBlX2liKTsKIAogCXJldHVybiAwOwogfQpkaWZmIC0tZ2l0IGEvZHJpdmVy cy9ncHUvZHJtL21zbS9kaXNwL2RwdTEvZHB1X3Bvd2VyX2hhbmRsZS5jIGIvZHJpdmVycy9ncHUv ZHJtL21zbS9kaXNwL2RwdTEvZHB1X3Bvd2VyX2hhbmRsZS5jCmluZGV4IGZjMTQxMTYuLmQ1OGQw MTUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9tc20vZGlzcC9kcHUxL2RwdV9wb3dlcl9o YW5kbGUuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3AvZHB1MS9kcHVfcG93ZXJfaGFu ZGxlLmMKQEAgLTI0LDIwICsyNCw2IEBACiAjaW5jbHVkZSAiZHB1X3Bvd2VyX2hhbmRsZS5oIgog I2luY2x1ZGUgImRwdV90cmFjZS5oIgogCi1zdGF0aWMgY29uc3QgY2hhciAqZGF0YV9idXNfbmFt ZVtEUFVfUE9XRVJfSEFORExFX0RCVVNfSURfTUFYXSA9IHsKLQlbRFBVX1BPV0VSX0hBTkRMRV9E QlVTX0lEX01OT0NdID0gInFjb20sZHB1LWRhdGEtYnVzIiwKLQlbRFBVX1BPV0VSX0hBTkRMRV9E QlVTX0lEX0xMQ0NdID0gInFjb20sZHB1LWxsY2MtYnVzIiwKLQlbRFBVX1BPV0VSX0hBTkRMRV9E QlVTX0lEX0VCSV0gPSAicWNvbSxkcHUtZWJpLWJ1cyIsCi19OwotCi1jb25zdCBjaGFyICpkcHVf cG93ZXJfaGFuZGxlX2dldF9kYnVzX25hbWUodTMyIGJ1c19pZCkKLXsKLQlpZiAoYnVzX2lkIDwg RFBVX1BPV0VSX0hBTkRMRV9EQlVTX0lEX01BWCkKLQkJcmV0dXJuIGRhdGFfYnVzX25hbWVbYnVz X2lkXTsKLQotCXJldHVybiBOVUxMOwotfQotCiBzdGF0aWMgdm9pZCBkcHVfcG93ZXJfZXZlbnRf dHJpZ2dlcl9sb2NrZWQoc3RydWN0IGRwdV9wb3dlcl9oYW5kbGUgKnBoYW5kbGUsCiAJCXUzMiBl dmVudF90eXBlKQogewpAQCAtNjYsNyArNTIsNiBAQCBzdHJ1Y3QgZHB1X3Bvd2VyX2NsaWVudCAq ZHB1X3Bvd2VyX2NsaWVudF9jcmVhdGUoCiAKIAltdXRleF9sb2NrKCZwaGFuZGxlLT5waGFuZGxl X2xvY2spOwogCXN0cmxjcHkoY2xpZW50LT5uYW1lLCBjbGllbnRfbmFtZSwgTUFYX0NMSUVOVF9O QU1FX0xFTik7Ci0JY2xpZW50LT51c2VjYXNlX25keCA9IFZPVEVfSU5ERVhfRElTQUJMRTsKIAlj bGllbnQtPmlkID0gaWQ7CiAJY2xpZW50LT5hY3RpdmUgPSB0cnVlOwogCXByX2RlYnVnKCJjbGll bnQgJXMgY3JlYXRlZDolcEsgaWQgOiVkXG4iLCBjbGllbnRfbmFtZSwKQEAgLTE0Myw4ICsxMjgs NiBAQCBpbnQgZHB1X3Bvd2VyX3Jlc291cmNlX2VuYWJsZShzdHJ1Y3QgZHB1X3Bvd2VyX2hhbmRs ZSAqcGhhbmRsZSwKIAlzdHJ1Y3QgZHB1X3Bvd2VyX2NsaWVudCAqcGNsaWVudCwgYm9vbCBlbmFi bGUpCiB7CiAJYm9vbCBjaGFuZ2VkID0gZmFsc2U7Ci0JdTMyIG1heF91c2VjYXNlX25keCA9IFZP VEVfSU5ERVhfRElTQUJMRSwgcHJldl91c2VjYXNlX25keDsKLQlzdHJ1Y3QgZHB1X3Bvd2VyX2Ns aWVudCAqY2xpZW50OwogCXUzMiBldmVudF90eXBlOwogCiAJaWYgKCFwaGFuZGxlIHx8ICFwY2xp ZW50KSB7CkBAIC0xNTMsMzEgKzEzNiwxOSBAQCBpbnQgZHB1X3Bvd2VyX3Jlc291cmNlX2VuYWJs ZShzdHJ1Y3QgZHB1X3Bvd2VyX2hhbmRsZSAqcGhhbmRsZSwKIAl9CiAKIAltdXRleF9sb2NrKCZw aGFuZGxlLT5waGFuZGxlX2xvY2spOwotCWlmIChlbmFibGUpCisJaWYgKGVuYWJsZSkgewogCQlw Y2xpZW50LT5yZWZjb3VudCsrOwotCWVsc2UgaWYgKHBjbGllbnQtPnJlZmNvdW50KQorCQlpZiAo cGNsaWVudC0+cmVmY291bnQgPT0gMSkKKwkJCWNoYW5nZWQgPSB0cnVlOworCX0gZWxzZSBpZiAo cGNsaWVudC0+cmVmY291bnQpIHsKIAkJcGNsaWVudC0+cmVmY291bnQtLTsKLQotCWlmIChwY2xp ZW50LT5yZWZjb3VudCkKLQkJcGNsaWVudC0+dXNlY2FzZV9uZHggPSBWT1RFX0lOREVYX0xPVzsK LQllbHNlCi0JCXBjbGllbnQtPnVzZWNhc2VfbmR4ID0gVk9URV9JTkRFWF9ESVNBQkxFOwotCi0J bGlzdF9mb3JfZWFjaF9lbnRyeShjbGllbnQsICZwaGFuZGxlLT5wb3dlcl9jbGllbnRfY2xpc3Qs IGxpc3QpIHsKLQkJaWYgKGNsaWVudC0+dXNlY2FzZV9uZHggPCBWT1RFX0lOREVYX01BWCAmJgot CQkgICAgY2xpZW50LT51c2VjYXNlX25keCA+IG1heF91c2VjYXNlX25keCkKLQkJCW1heF91c2Vj YXNlX25keCA9IGNsaWVudC0+dXNlY2FzZV9uZHg7Ci0JfQotCi0JaWYgKHBoYW5kbGUtPmN1cnJl bnRfdXNlY2FzZV9uZHggIT0gbWF4X3VzZWNhc2VfbmR4KSB7Ci0JCWNoYW5nZWQgPSB0cnVlOwot CQlwcmV2X3VzZWNhc2VfbmR4ID0gcGhhbmRsZS0+Y3VycmVudF91c2VjYXNlX25keDsKLQkJcGhh bmRsZS0+Y3VycmVudF91c2VjYXNlX25keCA9IG1heF91c2VjYXNlX25keDsKKwkJaWYgKCFwY2xp ZW50LT5yZWZjb3VudCkKKwkJCWNoYW5nZWQgPSB0cnVlOwogCX0KIAotCXByX2RlYnVnKCIlcFM6 IGNoYW5nZWQ9JWQgY3VycmVudCBpZHg9JWQgcmVxdWVzdCBjbGllbnQgJXMgaWQ6JXUgZW5hYmxl OiVkIHJlZmNvdW50OiVkXG4iLAotCQlfX2J1aWx0aW5fcmV0dXJuX2FkZHJlc3MoMCksIGNoYW5n ZWQsIG1heF91c2VjYXNlX25keCwKLQkJcGNsaWVudC0+bmFtZSwgcGNsaWVudC0+aWQsIGVuYWJs ZSwgcGNsaWVudC0+cmVmY291bnQpOworCXByX2RlYnVnKCIlcFM6Y2hhbmdlZD0lZCBjbGllbnQg JXMgaWQ6JXUgZW5hYmxlOiVkIHJlZmNvdW50OiVkXG4iLAorCQlfX2J1aWx0aW5fcmV0dXJuX2Fk ZHJlc3MoMCksIGNoYW5nZWQsIHBjbGllbnQtPm5hbWUsCisJCXBjbGllbnQtPmlkLCBlbmFibGUs IHBjbGllbnQtPnJlZmNvdW50KTsKIAogCWlmICghY2hhbmdlZCkKIAkJZ290byBlbmQ7CmRpZmYg LS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3AvZHB1MS9kcHVfcG93ZXJfaGFuZGxlLmgg Yi9kcml2ZXJzL2dwdS9kcm0vbXNtL2Rpc3AvZHB1MS9kcHVfcG93ZXJfaGFuZGxlLmgKaW5kZXgg YTY1YjdhMi4uYjFhNWFlNCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL2Rw dTEvZHB1X3Bvd2VyX2hhbmRsZS5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9tc20vZGlzcC9kcHUx L2RwdV9wb3dlcl9oYW5kbGUuaApAQCAtMTYsMTEgKzE2LDYgQEAKIAogI2RlZmluZSBNQVhfQ0xJ RU5UX05BTUVfTEVOIDEyOAogCi0jZGVmaW5lIERQVV9QT1dFUl9IQU5ETEVfRU5BQkxFX0JVU19B Ql9RVU9UQQkwCi0jZGVmaW5lIERQVV9QT1dFUl9IQU5ETEVfRElTQUJMRV9CVVNfQUJfUVVPVEEJ MAotI2RlZmluZSBEUFVfUE9XRVJfSEFORExFX0VOQUJMRV9CVVNfSUJfUVVPVEEJMTYwMDAwMDAw MAotI2RlZmluZSBEUFVfUE9XRVJfSEFORExFX0RJU0FCTEVfQlVTX0lCX1FVT1RBCTAKLQogI2lu Y2x1ZGUgImRwdV9pb191dGlsLmgiCiAKIC8qIGV2ZW50cyB3aWxsIGJlIHRyaWdnZXJlZCBvbiBw b3dlciBoYW5kbGVyIGVuYWJsZS9kaXNhYmxlICovCkBAIC0yOCw2NCArMjMsMjEgQEAKICNkZWZp bmUgRFBVX1BPV0VSX0VWRU5UX0VOQUJMRQlCSVQoMSkKIAogLyoqCi0gKiBtZHNzX2J1c192b3Rl X3R5cGU6IHJlZ2lzdGVyIGJ1cyB2b3RlIHR5cGUKLSAqIFZPVEVfSU5ERVhfRElTQUJMRTogcmVt b3ZlcyB0aGUgY2xpZW50IHZvdGUKLSAqIFZPVEVfSU5ERVhfTE9XOiBrZWVwcyB0aGUgbG93ZXN0 IHZvdGUgZm9yIHJlZ2lzdGVyIGJ1cwotICogVk9URV9JTkRFWF9NQVg6IGludmFsaWQKLSAqLwot ZW51bSBtZHNzX2J1c192b3RlX3R5cGUgewotCVZPVEVfSU5ERVhfRElTQUJMRSwKLQlWT1RFX0lO REVYX0xPVywKLQlWT1RFX0lOREVYX01BWCwKLX07Ci0KLS8qKgotICogZW51bSBkcHVfcG93ZXJf aGFuZGxlX2RhdGFfYnVzX2NsaWVudCAtIHR5cGUgb2YgYXhpIGJ1cyBjbGllbnRzCi0gKiBARFBV X1BPV0VSX0hBTkRMRV9EQVRBX0JVU19DTElFTlRfUlQ6IGNvcmUgcmVhbC10aW1lIGJ1cyBjbGll bnQKLSAqIEBEUFVfUE9XRVJfSEFORExFX0RBVEFfQlVTX0NMSUVOVF9OUlQ6IGNvcmUgbm9uLXJl YWwtdGltZSBidXMgY2xpZW50Ci0gKiBARFBVX1BPV0VSX0hBTkRMRV9EQVRBX0JVU19DTElFTlRf TUFYOiBtYXhpbXVtIG51bWJlciBvZiBidXMgY2xpZW50IHR5cGUKLSAqLwotZW51bSBkcHVfcG93 ZXJfaGFuZGxlX2RhdGFfYnVzX2NsaWVudCB7Ci0JRFBVX1BPV0VSX0hBTkRMRV9EQVRBX0JVU19D TElFTlRfUlQsCi0JRFBVX1BPV0VSX0hBTkRMRV9EQVRBX0JVU19DTElFTlRfTlJULAotCURQVV9Q T1dFUl9IQU5ETEVfREFUQV9CVVNfQ0xJRU5UX01BWAotfTsKLQotLyoqCi0gKiBlbnVtIERQVV9Q T1dFUl9IQU5ETEVfREJVU19JRCAtIGRhdGEgYnVzIGlkZW50aWZpZXIKLSAqIEBEUFVfUE9XRVJf SEFORExFX0RCVVNfSURfTU5PQzogRFBVL01OT0MgZGF0YSBidXMKLSAqIEBEUFVfUE9XRVJfSEFO RExFX0RCVVNfSURfTExDQzogTU5PQy9MTENDIGRhdGEgYnVzCi0gKiBARFBVX1BPV0VSX0hBTkRM RV9EQlVTX0lEX0VCSTogTExDQy9FQkkgZGF0YSBidXMKLSAqLwotZW51bSBEUFVfUE9XRVJfSEFO RExFX0RCVVNfSUQgewotCURQVV9QT1dFUl9IQU5ETEVfREJVU19JRF9NTk9DLAotCURQVV9QT1dF Ul9IQU5ETEVfREJVU19JRF9MTENDLAotCURQVV9QT1dFUl9IQU5ETEVfREJVU19JRF9FQkksCi0J RFBVX1BPV0VSX0hBTkRMRV9EQlVTX0lEX01BWCwKLX07Ci0KLS8qKgogICogc3RydWN0IGRwdV9w b3dlcl9jbGllbnQ6IHN0b3JlcyB0aGUgcG93ZXIgY2xpZW50IGZvciBkcHUgZHJpdmVyCiAgKiBA bmFtZToJbmFtZSBvZiB0aGUgY2xpZW50Ci0gKiBAdXNlY2FzZV9uZHg6IGN1cnJlbnQgcmVncyBi dXMgdm90ZSB0eXBlCiAgKiBAcmVmY291bnQ6CWN1cnJlbnQgcmVmY291bnQgaWYgbXVsdGlwbGUg bW9kdWxlcyBhcmUgdXNpbmcgc2FtZQogICogICAgICAgICAgICAgIHNhbWUgY2xpZW50IGZvciBl bmFibGUvZGlzYWJsZS4gUG93ZXIgbW9kdWxlIHdpbGwKICAqICAgICAgICAgICAgICBhZ2dyZWdh dGUgdGhlIHJlZmNvdW50IGFuZCB2b3RlIGFjY29yZGluZ2x5IGZvciB0aGlzCiAgKiAgICAgICAg ICAgICAgY2xpZW50LgogICogQGlkOgkJYXNzaWduZWQgZHVyaW5nIGNyZWF0ZS4gaGVscHMgZm9y IGRlYnVnZ2luZy4KICAqIEBsaXN0OglsaXN0IHRvIGF0dGFjaCBwb3dlciBoYW5kbGUgbWFzdGVy IGxpc3QKLSAqIEBhYjogICAgICAgICBhcmJpdHJhdGVkIGJhbmR3aWR0aCBmb3IgZWFjaCBidXMg Y2xpZW50Ci0gKiBAaWI6ICAgICAgICAgaW5zdGFudGFuZW91cyBiYW5kd2lkdGggZm9yIGVhY2gg YnVzIGNsaWVudAogICogQGFjdGl2ZToJaW5pZGNhdGVzIHRoZSBzdGF0ZSBvZiBkcHUgcG93ZXIg aGFuZGxlCiAgKi8KIHN0cnVjdCBkcHVfcG93ZXJfY2xpZW50IHsKIAljaGFyIG5hbWVbTUFYX0NM SUVOVF9OQU1FX0xFTl07Ci0Jc2hvcnQgdXNlY2FzZV9uZHg7CiAJc2hvcnQgcmVmY291bnQ7CiAJ dTMyIGlkOwogCXN0cnVjdCBsaXN0X2hlYWQgbGlzdDsKLQl1NjQgYWJbRFBVX1BPV0VSX0hBTkRM RV9EQVRBX0JVU19DTElFTlRfTUFYXTsKLQl1NjQgaWJbRFBVX1BPV0VSX0hBTkRMRV9EQVRBX0JV U19DTElFTlRfTUFYXTsKIAlib29sIGFjdGl2ZTsKIH07CiAKQEAgLTExMiwxNCArNjQsMTIgQEAg c3RydWN0IGRwdV9wb3dlcl9ldmVudCB7CiAgKiBAY2xpZW50X2NsaXN0OiBtYXN0ZXIgbGlzdCB0 byBzdG9yZSBhbGwgY2xpZW50cwogICogQHBoYW5kbGVfbG9jazogbG9jayB0byBzeW5jaHJvbml6 ZSB0aGUgZW5hYmxlL2Rpc2FibGUKICAqIEBkZXY6IHBvaW50ZXIgdG8gZGV2aWNlIHN0cnVjdHVy ZQotICogQHVzZWNhc2VfbmR4OiBjdXJyZW50IHVzZWNhc2UgaW5kZXgKICAqIEBldmVudF9saXN0 OiBjdXJyZW50IHBvd2VyIGhhbmRsZSBldmVudCBsaXN0CiAgKi8KIHN0cnVjdCBkcHVfcG93ZXJf aGFuZGxlIHsKIAlzdHJ1Y3QgbGlzdF9oZWFkIHBvd2VyX2NsaWVudF9jbGlzdDsKIAlzdHJ1Y3Qg bXV0ZXggcGhhbmRsZV9sb2NrOwogCXN0cnVjdCBkZXZpY2UgKmRldjsKLQl1MzIgY3VycmVudF91 c2VjYXNlX25keDsKIAlzdHJ1Y3QgbGlzdF9oZWFkIGV2ZW50X2xpc3Q7CiB9OwogCkBAIC0xNzMs MTcgKzEyMyw2IEBAIGludCBkcHVfcG93ZXJfcmVzb3VyY2VfZW5hYmxlKHN0cnVjdCBkcHVfcG93 ZXJfaGFuZGxlICpwZGF0YSwKIAlzdHJ1Y3QgZHB1X3Bvd2VyX2NsaWVudCAqcGNsaWVudCwgYm9v bCBlbmFibGUpOwogCiAvKioKLSAqIGRwdV9wb3dlcl9kYXRhX2J1c19iYW5kd2lkdGhfY3RybCgp IC0gY29udHJvbCBkYXRhIGJ1cyBiYW5kd2lkdGggZW5hYmxlCi0gKiBAcGhhbmRsZTogIHBvd2Vy IGhhbmRsZSBjb250YWluaW5nIHRoZSByZXNvdXJjZXMKLSAqIEBjbGllbnQ6IGNsaWVudCBpbmZv cm1hdGlvbiB0byBiYW5kd2lkdGggY29udHJvbAotICogQGVuYWJsZTogdHJ1ZSB0byBlbmFibGUg YmFuZHdpZHRoIGZvciBkYXRhIGJhc2UKLSAqCi0gKiBSZXR1cm46IG5vbmUKLSAqLwotdm9pZCBk cHVfcG93ZXJfZGF0YV9idXNfYmFuZHdpZHRoX2N0cmwoc3RydWN0IGRwdV9wb3dlcl9oYW5kbGUg KnBoYW5kbGUsCi0JCXN0cnVjdCBkcHVfcG93ZXJfY2xpZW50ICpwY2xpZW50LCBpbnQgZW5hYmxl KTsKLQotLyoqCiAgKiBkcHVfcG93ZXJfaGFuZGxlX3JlZ2lzdGVyX2V2ZW50IC0gcmVnaXN0ZXIg YSBjYWxsYmFjayBmdW5jdGlvbiBmb3IgYW4gZXZlbnQuCiAgKglDbGllbnRzIGNhbiByZWdpc3Rl ciBmb3IgbXVsdGlwbGUgZXZlbnRzIHdpdGggYSBzaW5nbGUgcmVnaXN0ZXIuCiAgKglBbnkgYmxv Y2sgd2l0aCBhY2Nlc3MgdG8gcGhhbmRsZSBjYW4gcmVnaXN0ZXIgZm9yIHRoZSBldmVudApAQCAt MjA3LDExICsxNDYsNCBAQCBzdHJ1Y3QgZHB1X3Bvd2VyX2V2ZW50ICpkcHVfcG93ZXJfaGFuZGxl X3JlZ2lzdGVyX2V2ZW50KAogdm9pZCBkcHVfcG93ZXJfaGFuZGxlX3VucmVnaXN0ZXJfZXZlbnQo c3RydWN0IGRwdV9wb3dlcl9oYW5kbGUgKnBoYW5kbGUsCiAJCXN0cnVjdCBkcHVfcG93ZXJfZXZl bnQgKmV2ZW50KTsKIAotLyoqCi0gKiBkcHVfcG93ZXJfaGFuZGxlX2dldF9kYnVzX25hbWUgLSBn ZXQgbmFtZSBvZiBnaXZlbiBkYXRhIGJ1cyBpZGVudGlmaWVyCi0gKiBAYnVzX2lkOglkYXRhIGJ1 cyBpZGVudGlmaWVyCi0gKiBSZXR1cm46CVBvaW50ZXIgdG8gbmFtZSBzdHJpbmcgaWYgc3VjY2Vz czsgTlVMTCBvdGhlcndpc2UKLSAqLwotY29uc3QgY2hhciAqZHB1X3Bvd2VyX2hhbmRsZV9nZXRf ZGJ1c19uYW1lKHUzMiBidXNfaWQpOwotCiAjZW5kaWYgLyogX0RQVV9QT1dFUl9IQU5ETEVfSF8g Ki8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9tc20vZGlzcC9kcHUxL2RwdV90cmFjZS5o IGIvZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL2RwdTEvZHB1X3RyYWNlLmgKaW5kZXggMGMxMjJl MS4uN2M4YTkyZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL2RwdTEvZHB1 X3RyYWNlLmgKKysrIGIvZHJpdmVycy9ncHUvZHJtL21zbS9kaXNwL2RwdTEvZHB1X3RyYWNlLmgK QEAgLTE2NywxNiArMTY3LDEyIEBACiApCiAKIFRSQUNFX0VWRU5UKGRwdV9wZXJmX2NydGNfdXBk YXRlLAotCVRQX1BST1RPKHUzMiBjcnRjLCB1NjQgYndfY3RsX21ub2MsIHU2NCBid19jdGxfbGxj YywKLQkJCXU2NCBid19jdGxfZWJpLCB1MzIgY29yZV9jbGtfcmF0ZSwKLQkJCWJvb2wgc3RvcF9y ZXEsIHUzMiB1cGRhdGVfYnVzLCB1MzIgdXBkYXRlX2NsayksCi0JVFBfQVJHUyhjcnRjLCBid19j dGxfbW5vYywgYndfY3RsX2xsY2MsIGJ3X2N0bF9lYmksIGNvcmVfY2xrX3JhdGUsCi0JCXN0b3Bf cmVxLCB1cGRhdGVfYnVzLCB1cGRhdGVfY2xrKSwKKwlUUF9QUk9UTyh1MzIgY3J0YywgdTY0IGJ3 X2N0bCwgdTMyIGNvcmVfY2xrX3JhdGUsCisJCQlib29sIHN0b3BfcmVxLCBib29sIHVwZGF0ZV9i dXMsIGJvb2wgdXBkYXRlX2NsayksCisJVFBfQVJHUyhjcnRjLCBid19jdGwsIGNvcmVfY2xrX3Jh dGUsIHN0b3BfcmVxLCB1cGRhdGVfYnVzLCB1cGRhdGVfY2xrKSwKIAlUUF9TVFJVQ1RfX2VudHJ5 KAogCQkJX19maWVsZCh1MzIsIGNydGMpCi0JCQlfX2ZpZWxkKHU2NCwgYndfY3RsX21ub2MpCi0J CQlfX2ZpZWxkKHU2NCwgYndfY3RsX2xsY2MpCi0JCQlfX2ZpZWxkKHU2NCwgYndfY3RsX2ViaSkK KwkJCV9fZmllbGQodTY0LCBid19jdGwpCiAJCQlfX2ZpZWxkKHUzMiwgY29yZV9jbGtfcmF0ZSkK IAkJCV9fZmllbGQoYm9vbCwgc3RvcF9yZXEpCiAJCQlfX2ZpZWxkKHUzMiwgdXBkYXRlX2J1cykK QEAgLTE4NCwyMCArMTgwLDE2IEBACiAJKSwKIAlUUF9mYXN0X2Fzc2lnbigKIAkJCV9fZW50cnkt PmNydGMgPSBjcnRjOwotCQkJX19lbnRyeS0+YndfY3RsX21ub2MgPSBid19jdGxfbW5vYzsKLQkJ CV9fZW50cnktPmJ3X2N0bF9sbGNjID0gYndfY3RsX2xsY2M7Ci0JCQlfX2VudHJ5LT5id19jdGxf ZWJpID0gYndfY3RsX2ViaTsKKwkJCV9fZW50cnktPmJ3X2N0bCA9IGJ3X2N0bDsKIAkJCV9fZW50 cnktPmNvcmVfY2xrX3JhdGUgPSBjb3JlX2Nsa19yYXRlOwogCQkJX19lbnRyeS0+c3RvcF9yZXEg PSBzdG9wX3JlcTsKIAkJCV9fZW50cnktPnVwZGF0ZV9idXMgPSB1cGRhdGVfYnVzOwogCQkJX19l bnRyeS0+dXBkYXRlX2NsayA9IHVwZGF0ZV9jbGs7CiAJKSwKIAkgVFBfcHJpbnRrKAotCQkiY3J0 Yz0lZCBid19tbm9jPSVsbHUgYndfbGxjYz0lbGx1IGJ3X2ViaT0lbGx1IGNsa19yYXRlPSV1IHN0 b3BfcmVxPSVkIHVfYnVzPSVkIHVfY2xrPSVkIiwKKwkJImNydGM9JWQgYndfY3RsPSVsbHUgY2xr X3JhdGU9JXUgc3RvcF9yZXE9JWQgdV9idXM9JWQgdV9jbGs9JWQiLAogCQkJX19lbnRyeS0+Y3J0 YywKLQkJCV9fZW50cnktPmJ3X2N0bF9tbm9jLAotCQkJX19lbnRyeS0+YndfY3RsX2xsY2MsCi0J CQlfX2VudHJ5LT5id19jdGxfZWJpLAorCQkJX19lbnRyeS0+YndfY3RsLAogCQkJX19lbnRyeS0+ Y29yZV9jbGtfcmF0ZSwKIAkJCV9fZW50cnktPnN0b3BfcmVxLAogCQkJX19lbnRyeS0+dXBkYXRl X2J1cywKLS0gClRoZSBRdWFsY29tbSBJbm5vdmF0aW9uIENlbnRlciwgSW5jLiBpcyBhIG1lbWJl ciBvZiB0aGUgQ29kZSBBdXJvcmEgRm9ydW0sCmEgTGludXggRm91bmRhdGlvbiBDb2xsYWJvcmF0 aXZlIFByb2plY3QKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fCmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9y ZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZl bAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-8.8 required=3.0 tests=DKIM_INVALID,DKIM_SIGNED, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id EE7C7C43387 for ; Wed, 9 Jan 2019 17:52:36 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id A1AE120685 for ; Wed, 9 Jan 2019 17:52:36 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="key not found in DNS" (0-bit key) header.d=codeaurora.org header.i=@codeaurora.org header.b="EV/BgJIo"; dkim=fail reason="key not found in DNS" (0-bit key) header.d=codeaurora.org header.i=@codeaurora.org header.b="htRBMUq2" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727183AbfAIRwf (ORCPT ); Wed, 9 Jan 2019 12:52:35 -0500 Received: from smtp.codeaurora.org ([198.145.29.96]:38532 "EHLO smtp.codeaurora.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727113AbfAIRwf (ORCPT ); Wed, 9 Jan 2019 12:52:35 -0500 Received: by smtp.codeaurora.org (Postfix, from userid 1000) id 587F1608CB; Wed, 9 Jan 2019 17:52:32 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=codeaurora.org; s=default; t=1547056353; bh=xGER5/jlfIuK2aNMQ1vd40Wog39lkPtSBgVErZ6duKo=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=EV/BgJIo9aWt+D5TLsDyAOw2dKabyqlQ8UuOKE8N8hqfCOxSmH89wkEfPepkjqbgX Bt/zpL8Ca3dTL1HqrcjGl8CHfHsYGnxrZVAGzbROf6AG30qxkYT2rrwyfJnkfXXVNd an6SUPwtqNj4OrCX6w26dR1TzzKbbF7xP3NWweKw= Received: from jshekhar-linux.qualcomm.com (blr-c-bdr-fw-01_globalnat_allzones-outside.qualcomm.com [103.229.19.19]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-SHA256 (128/128 bits)) (No client certificate requested) (Authenticated sender: jshekhar@smtp.codeaurora.org) by smtp.codeaurora.org (Postfix) with ESMTPSA id C6F95608CB; Wed, 9 Jan 2019 17:52:23 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=codeaurora.org; s=default; t=1547056348; bh=xGER5/jlfIuK2aNMQ1vd40Wog39lkPtSBgVErZ6duKo=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=htRBMUq2SP3nHOpRG2OJpH47HHRJSu66OTvAb5IVTm8VYJhD5r/hSwf095g9XZk7C X0DDEWvzdOw+sM+MCQGVZKu2RYnHCY4nhALdnYDSepKw7R9+aqGzAr54CiPXNKBaTY qOz+ASkdh7ag0Snlu1Pkq+M5qU07eKzTU6Xed81I= DMARC-Filter: OpenDMARC Filter v1.3.2 smtp.codeaurora.org C6F95608CB Authentication-Results: pdx-caf-mail.web.codeaurora.org; dmarc=none (p=none dis=none) header.from=codeaurora.org Authentication-Results: pdx-caf-mail.web.codeaurora.org; spf=none smtp.mailfrom=jshekhar@codeaurora.org From: Jayant Shekhar To: dri-devel@lists.freedesktop.org, linux-arm-msm@vger.kernel.org, freedreno@lists.freedesktop.org, devicetree@vger.kernel.org Cc: Sravanthi Kollukuduru , linux-kernel@vger.kernel.org, robdclark@gmail.com, seanpaul@chromium.org, hoegsberg@chromium.org, abhinavk@codeaurora.org, jsanka@codeaurora.org, chandanu@codeaurora.org, nganji@codeaurora.org, Jayant Shekhar Subject: [v5 1/3] drm/msm/dpu: clean up references of DPU custom bus scaling Date: Wed, 9 Jan 2019 23:22:03 +0530 Message-Id: <1547056325-1919-2-git-send-email-jshekhar@codeaurora.org> X-Mailer: git-send-email 1.9.1 In-Reply-To: <1547056325-1919-1-git-send-email-jshekhar@codeaurora.org> References: <1547056325-1919-1-git-send-email-jshekhar@codeaurora.org> Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org From: Sravanthi Kollukuduru Since the upstream interconnect bus framework has landed upstream, the existing references of custom bus scaling needs to be cleaned up. Changes in v2: - Fixed build error due to partial clean up Changes in v3: - Condense multiple lines into a single line (Sean Paul) Changes in v4: - None Changes in v5: - None Signed-off-by: Sravanthi Kollukuduru Signed-off-by: Jayant Shekhar --- drivers/gpu/drm/msm/disp/dpu1/dpu_core_perf.c | 174 +++++++++-------------- drivers/gpu/drm/msm/disp/dpu1/dpu_core_perf.h | 4 +- drivers/gpu/drm/msm/disp/dpu1/dpu_crtc.c | 13 +- drivers/gpu/drm/msm/disp/dpu1/dpu_power_handle.c | 47 ++---- drivers/gpu/drm/msm/disp/dpu1/dpu_power_handle.h | 68 --------- drivers/gpu/drm/msm/disp/dpu1/dpu_trace.h | 22 +-- 6 files changed, 89 insertions(+), 239 deletions(-) diff --git a/drivers/gpu/drm/msm/disp/dpu1/dpu_core_perf.c b/drivers/gpu/drm/msm/disp/dpu1/dpu_core_perf.c index 22e84b3..c75536e 100644 --- a/drivers/gpu/drm/msm/disp/dpu1/dpu_core_perf.c +++ b/drivers/gpu/drm/msm/disp/dpu1/dpu_core_perf.c @@ -84,7 +84,6 @@ static void _dpu_core_perf_calc_crtc(struct dpu_kms *kms, struct dpu_core_perf_params *perf) { struct dpu_crtc_state *dpu_cstate; - int i; if (!kms || !kms->catalog || !crtc || !state || !perf) { DPU_ERROR("invalid parameters\n"); @@ -95,35 +94,24 @@ static void _dpu_core_perf_calc_crtc(struct dpu_kms *kms, memset(perf, 0, sizeof(struct dpu_core_perf_params)); if (!dpu_cstate->bw_control) { - for (i = 0; i < DPU_POWER_HANDLE_DBUS_ID_MAX; i++) { - perf->bw_ctl[i] = kms->catalog->perf.max_bw_high * + perf->bw_ctl = kms->catalog->perf.max_bw_high * 1000ULL; - perf->max_per_pipe_ib[i] = perf->bw_ctl[i]; - } + perf->max_per_pipe_ib = perf->bw_ctl; perf->core_clk_rate = kms->perf.max_core_clk_rate; } else if (kms->perf.perf_tune.mode == DPU_PERF_MODE_MINIMUM) { - for (i = 0; i < DPU_POWER_HANDLE_DBUS_ID_MAX; i++) { - perf->bw_ctl[i] = 0; - perf->max_per_pipe_ib[i] = 0; - } + perf->bw_ctl = 0; + perf->max_per_pipe_ib = 0; perf->core_clk_rate = 0; } else if (kms->perf.perf_tune.mode == DPU_PERF_MODE_FIXED) { - for (i = 0; i < DPU_POWER_HANDLE_DBUS_ID_MAX; i++) { - perf->bw_ctl[i] = kms->perf.fix_core_ab_vote; - perf->max_per_pipe_ib[i] = kms->perf.fix_core_ib_vote; - } + perf->bw_ctl = kms->perf.fix_core_ab_vote; + perf->max_per_pipe_ib = kms->perf.fix_core_ib_vote; perf->core_clk_rate = kms->perf.fix_core_clk_rate; } DPU_DEBUG( - "crtc=%d clk_rate=%llu core_ib=%llu core_ab=%llu llcc_ib=%llu llcc_ab=%llu mem_ib=%llu mem_ab=%llu\n", + "crtc=%d clk_rate=%llu core_ib=%llu core_ab=%llu\n", crtc->base.id, perf->core_clk_rate, - perf->max_per_pipe_ib[DPU_POWER_HANDLE_DBUS_ID_MNOC], - perf->bw_ctl[DPU_POWER_HANDLE_DBUS_ID_MNOC], - perf->max_per_pipe_ib[DPU_POWER_HANDLE_DBUS_ID_LLCC], - perf->bw_ctl[DPU_POWER_HANDLE_DBUS_ID_LLCC], - perf->max_per_pipe_ib[DPU_POWER_HANDLE_DBUS_ID_EBI], - perf->bw_ctl[DPU_POWER_HANDLE_DBUS_ID_EBI]); + perf->max_per_pipe_ib, perf->bw_ctl); } int dpu_core_perf_crtc_check(struct drm_crtc *crtc, @@ -136,7 +124,6 @@ int dpu_core_perf_crtc_check(struct drm_crtc *crtc, struct dpu_crtc_state *dpu_cstate; struct drm_crtc *tmp_crtc; struct dpu_kms *kms; - int i; if (!crtc || !state) { DPU_ERROR("invalid crtc\n"); @@ -158,31 +145,25 @@ int dpu_core_perf_crtc_check(struct drm_crtc *crtc, /* obtain new values */ _dpu_core_perf_calc_crtc(kms, crtc, state, &dpu_cstate->new_perf); - for (i = DPU_POWER_HANDLE_DBUS_ID_MNOC; - i < DPU_POWER_HANDLE_DBUS_ID_MAX; i++) { - bw_sum_of_intfs = dpu_cstate->new_perf.bw_ctl[i]; - curr_client_type = dpu_crtc_get_client_type(crtc); + bw_sum_of_intfs = dpu_cstate->new_perf.bw_ctl; + curr_client_type = dpu_crtc_get_client_type(crtc); - drm_for_each_crtc(tmp_crtc, crtc->dev) { - if (_dpu_core_perf_crtc_is_power_on(tmp_crtc) && - (dpu_crtc_get_client_type(tmp_crtc) == - curr_client_type) && - (tmp_crtc != crtc)) { - struct dpu_crtc_state *tmp_cstate = - to_dpu_crtc_state(tmp_crtc->state); - - DPU_DEBUG("crtc:%d bw:%llu ctrl:%d\n", - tmp_crtc->base.id, - tmp_cstate->new_perf.bw_ctl[i], - tmp_cstate->bw_control); - /* - * For bw check only use the bw if the - * atomic property has been already set - */ - if (tmp_cstate->bw_control) - bw_sum_of_intfs += - tmp_cstate->new_perf.bw_ctl[i]; - } + drm_for_each_crtc(tmp_crtc, crtc->dev) { + if (_dpu_core_perf_crtc_is_power_on(tmp_crtc) && + (dpu_crtc_get_client_type(tmp_crtc) == + curr_client_type) && (tmp_crtc != crtc)) { + struct dpu_crtc_state *tmp_cstate = + to_dpu_crtc_state(tmp_crtc->state); + + DPU_DEBUG("crtc:%d bw:%llu ctrl:%d\n", + tmp_crtc->base.id, tmp_cstate->new_perf.bw_ctl, + tmp_cstate->bw_control); + /* + * For bw check only use the bw if the + * atomic property has been already set + */ + if (tmp_cstate->bw_control) + bw_sum_of_intfs += tmp_cstate->new_perf.bw_ctl; } /* convert bandwidth to kb */ @@ -213,9 +194,9 @@ int dpu_core_perf_crtc_check(struct drm_crtc *crtc, } static int _dpu_core_perf_crtc_update_bus(struct dpu_kms *kms, - struct drm_crtc *crtc, u32 bus_id) + struct drm_crtc *crtc) { - struct dpu_core_perf_params perf = { { 0 } }; + struct dpu_core_perf_params perf = { 0 }; enum dpu_crtc_client_type curr_client_type = dpu_crtc_get_client_type(crtc); struct drm_crtc *tmp_crtc; @@ -228,13 +209,11 @@ static int _dpu_core_perf_crtc_update_bus(struct dpu_kms *kms, dpu_crtc_get_client_type(tmp_crtc)) { dpu_cstate = to_dpu_crtc_state(tmp_crtc->state); - perf.max_per_pipe_ib[bus_id] = - max(perf.max_per_pipe_ib[bus_id], - dpu_cstate->new_perf.max_per_pipe_ib[bus_id]); + perf.max_per_pipe_ib = max(perf.max_per_pipe_ib, + dpu_cstate->new_perf.max_per_pipe_ib); - DPU_DEBUG("crtc=%d bus_id=%d bw=%llu\n", - tmp_crtc->base.id, bus_id, - dpu_cstate->new_perf.bw_ctl[bus_id]); + DPU_DEBUG("crtc=%d bw=%llu\n", tmp_crtc->base.id, + dpu_cstate->new_perf.bw_ctl); } } return ret; @@ -254,7 +233,6 @@ void dpu_core_perf_crtc_release_bw(struct drm_crtc *crtc) struct dpu_crtc *dpu_crtc; struct dpu_crtc_state *dpu_cstate; struct dpu_kms *kms; - int i; if (!crtc) { DPU_ERROR("invalid crtc\n"); @@ -290,10 +268,8 @@ void dpu_core_perf_crtc_release_bw(struct drm_crtc *crtc) if (kms->perf.enable_bw_release) { trace_dpu_cmd_release_bw(crtc->base.id); DPU_DEBUG("Release BW crtc=%d\n", crtc->base.id); - for (i = 0; i < DPU_POWER_HANDLE_DBUS_ID_MAX; i++) { - dpu_crtc->cur_perf.bw_ctl[i] = 0; - _dpu_core_perf_crtc_update_bus(kms, crtc, i); - } + dpu_crtc->cur_perf.bw_ctl = 0; + _dpu_core_perf_crtc_update_bus(kms, crtc); } } @@ -336,11 +312,10 @@ int dpu_core_perf_crtc_update(struct drm_crtc *crtc, int params_changed, bool stop_req) { struct dpu_core_perf_params *new, *old; - int update_bus = 0, update_clk = 0; + bool update_bus = false, update_clk = false; u64 clk_rate = 0; struct dpu_crtc *dpu_crtc; struct dpu_crtc_state *dpu_cstate; - int i; struct msm_drm_private *priv; struct dpu_kms *kms; int ret; @@ -367,62 +342,49 @@ int dpu_core_perf_crtc_update(struct drm_crtc *crtc, new = &dpu_cstate->new_perf; if (_dpu_core_perf_crtc_is_power_on(crtc) && !stop_req) { - for (i = 0; i < DPU_POWER_HANDLE_DBUS_ID_MAX; i++) { - /* - * cases for bus bandwidth update. - * 1. new bandwidth vote - "ab or ib vote" is higher - * than current vote for update request. - * 2. new bandwidth vote - "ab or ib vote" is lower - * than current vote at end of commit or stop. - */ - if ((params_changed && ((new->bw_ctl[i] > - old->bw_ctl[i]) || - (new->max_per_pipe_ib[i] > - old->max_per_pipe_ib[i]))) || - (!params_changed && ((new->bw_ctl[i] < - old->bw_ctl[i]) || - (new->max_per_pipe_ib[i] < - old->max_per_pipe_ib[i])))) { - DPU_DEBUG( - "crtc=%d p=%d new_bw=%llu,old_bw=%llu\n", - crtc->base.id, params_changed, - new->bw_ctl[i], old->bw_ctl[i]); - old->bw_ctl[i] = new->bw_ctl[i]; - old->max_per_pipe_ib[i] = - new->max_per_pipe_ib[i]; - update_bus |= BIT(i); - } + /* + * cases for bus bandwidth update. + * 1. new bandwidth vote - "ab or ib vote" is higher + * than current vote for update request. + * 2. new bandwidth vote - "ab or ib vote" is lower + * than current vote at end of commit or stop. + */ + if ((params_changed && ((new->bw_ctl > old->bw_ctl) || + (new->max_per_pipe_ib > old->max_per_pipe_ib))) || + (!params_changed && ((new->bw_ctl < old->bw_ctl) || + (new->max_per_pipe_ib < old->max_per_pipe_ib)))) { + DPU_DEBUG("crtc=%d p=%d new_bw=%llu,old_bw=%llu\n", + crtc->base.id, params_changed, + new->bw_ctl, old->bw_ctl); + old->bw_ctl = new->bw_ctl; + old->max_per_pipe_ib = new->max_per_pipe_ib; + update_bus = true; } if ((params_changed && - (new->core_clk_rate > old->core_clk_rate)) || - (!params_changed && - (new->core_clk_rate < old->core_clk_rate))) { + (new->core_clk_rate > old->core_clk_rate)) || + (!params_changed && + (new->core_clk_rate < old->core_clk_rate))) { old->core_clk_rate = new->core_clk_rate; - update_clk = 1; + update_clk = true; } } else { DPU_DEBUG("crtc=%d disable\n", crtc->base.id); memset(old, 0, sizeof(*old)); memset(new, 0, sizeof(*new)); - update_bus = ~0; - update_clk = 1; + update_bus = true; + update_clk = true; } - trace_dpu_perf_crtc_update(crtc->base.id, - new->bw_ctl[DPU_POWER_HANDLE_DBUS_ID_MNOC], - new->bw_ctl[DPU_POWER_HANDLE_DBUS_ID_LLCC], - new->bw_ctl[DPU_POWER_HANDLE_DBUS_ID_EBI], - new->core_clk_rate, stop_req, - update_bus, update_clk); - - for (i = 0; i < DPU_POWER_HANDLE_DBUS_ID_MAX; i++) { - if (update_bus & BIT(i)) { - ret = _dpu_core_perf_crtc_update_bus(kms, crtc, i); - if (ret) { - DPU_ERROR("crtc-%d: failed to update bw vote for bus-%d\n", - crtc->base.id, i); - return ret; - } + + trace_dpu_perf_crtc_update(crtc->base.id, new->bw_ctl, + new->core_clk_rate, stop_req, update_bus, update_clk); + + if (update_bus) { + ret = _dpu_core_perf_crtc_update_bus(kms, crtc); + if (ret) { + DPU_ERROR("crtc-%d: failed to update bus bw vote\n", + crtc->base.id); + return ret; } } diff --git a/drivers/gpu/drm/msm/disp/dpu1/dpu_core_perf.h b/drivers/gpu/drm/msm/disp/dpu1/dpu_core_perf.h index fbcbe0c..0fb2769 100644 --- a/drivers/gpu/drm/msm/disp/dpu1/dpu_core_perf.h +++ b/drivers/gpu/drm/msm/disp/dpu1/dpu_core_perf.h @@ -30,8 +30,8 @@ * @core_clk_rate: core clock rate request */ struct dpu_core_perf_params { - u64 max_per_pipe_ib[DPU_POWER_HANDLE_DBUS_ID_MAX]; - u64 bw_ctl[DPU_POWER_HANDLE_DBUS_ID_MAX]; + u64 max_per_pipe_ib; + u64 bw_ctl; u64 core_clk_rate; }; diff --git a/drivers/gpu/drm/msm/disp/dpu1/dpu_crtc.c b/drivers/gpu/drm/msm/disp/dpu1/dpu_crtc.c index d27ea2a..d34ec9f 100644 --- a/drivers/gpu/drm/msm/disp/dpu1/dpu_crtc.c +++ b/drivers/gpu/drm/msm/disp/dpu1/dpu_crtc.c @@ -1389,21 +1389,14 @@ static int dpu_crtc_debugfs_state_show(struct seq_file *s, void *v) { struct drm_crtc *crtc = (struct drm_crtc *) s->private; struct dpu_crtc *dpu_crtc = to_dpu_crtc(crtc); - int i; seq_printf(s, "client type: %d\n", dpu_crtc_get_client_type(crtc)); seq_printf(s, "intf_mode: %d\n", dpu_crtc_get_intf_mode(crtc)); seq_printf(s, "core_clk_rate: %llu\n", dpu_crtc->cur_perf.core_clk_rate); - for (i = DPU_POWER_HANDLE_DBUS_ID_MNOC; - i < DPU_POWER_HANDLE_DBUS_ID_MAX; i++) { - seq_printf(s, "bw_ctl[%s]: %llu\n", - dpu_power_handle_get_dbus_name(i), - dpu_crtc->cur_perf.bw_ctl[i]); - seq_printf(s, "max_per_pipe_ib[%s]: %llu\n", - dpu_power_handle_get_dbus_name(i), - dpu_crtc->cur_perf.max_per_pipe_ib[i]); - } + seq_printf(s, "bw_ctl: %llu\n", dpu_crtc->cur_perf.bw_ctl); + seq_printf(s, "max_per_pipe_ib: %llu\n", + dpu_crtc->cur_perf.max_per_pipe_ib); return 0; } diff --git a/drivers/gpu/drm/msm/disp/dpu1/dpu_power_handle.c b/drivers/gpu/drm/msm/disp/dpu1/dpu_power_handle.c index fc14116..d58d015 100644 --- a/drivers/gpu/drm/msm/disp/dpu1/dpu_power_handle.c +++ b/drivers/gpu/drm/msm/disp/dpu1/dpu_power_handle.c @@ -24,20 +24,6 @@ #include "dpu_power_handle.h" #include "dpu_trace.h" -static const char *data_bus_name[DPU_POWER_HANDLE_DBUS_ID_MAX] = { - [DPU_POWER_HANDLE_DBUS_ID_MNOC] = "qcom,dpu-data-bus", - [DPU_POWER_HANDLE_DBUS_ID_LLCC] = "qcom,dpu-llcc-bus", - [DPU_POWER_HANDLE_DBUS_ID_EBI] = "qcom,dpu-ebi-bus", -}; - -const char *dpu_power_handle_get_dbus_name(u32 bus_id) -{ - if (bus_id < DPU_POWER_HANDLE_DBUS_ID_MAX) - return data_bus_name[bus_id]; - - return NULL; -} - static void dpu_power_event_trigger_locked(struct dpu_power_handle *phandle, u32 event_type) { @@ -66,7 +52,6 @@ struct dpu_power_client *dpu_power_client_create( mutex_lock(&phandle->phandle_lock); strlcpy(client->name, client_name, MAX_CLIENT_NAME_LEN); - client->usecase_ndx = VOTE_INDEX_DISABLE; client->id = id; client->active = true; pr_debug("client %s created:%pK id :%d\n", client_name, @@ -143,8 +128,6 @@ int dpu_power_resource_enable(struct dpu_power_handle *phandle, struct dpu_power_client *pclient, bool enable) { bool changed = false; - u32 max_usecase_ndx = VOTE_INDEX_DISABLE, prev_usecase_ndx; - struct dpu_power_client *client; u32 event_type; if (!phandle || !pclient) { @@ -153,31 +136,19 @@ int dpu_power_resource_enable(struct dpu_power_handle *phandle, } mutex_lock(&phandle->phandle_lock); - if (enable) + if (enable) { pclient->refcount++; - else if (pclient->refcount) + if (pclient->refcount == 1) + changed = true; + } else if (pclient->refcount) { pclient->refcount--; - - if (pclient->refcount) - pclient->usecase_ndx = VOTE_INDEX_LOW; - else - pclient->usecase_ndx = VOTE_INDEX_DISABLE; - - list_for_each_entry(client, &phandle->power_client_clist, list) { - if (client->usecase_ndx < VOTE_INDEX_MAX && - client->usecase_ndx > max_usecase_ndx) - max_usecase_ndx = client->usecase_ndx; - } - - if (phandle->current_usecase_ndx != max_usecase_ndx) { - changed = true; - prev_usecase_ndx = phandle->current_usecase_ndx; - phandle->current_usecase_ndx = max_usecase_ndx; + if (!pclient->refcount) + changed = true; } - pr_debug("%pS: changed=%d current idx=%d request client %s id:%u enable:%d refcount:%d\n", - __builtin_return_address(0), changed, max_usecase_ndx, - pclient->name, pclient->id, enable, pclient->refcount); + pr_debug("%pS:changed=%d client %s id:%u enable:%d refcount:%d\n", + __builtin_return_address(0), changed, pclient->name, + pclient->id, enable, pclient->refcount); if (!changed) goto end; diff --git a/drivers/gpu/drm/msm/disp/dpu1/dpu_power_handle.h b/drivers/gpu/drm/msm/disp/dpu1/dpu_power_handle.h index a65b7a2..b1a5ae4 100644 --- a/drivers/gpu/drm/msm/disp/dpu1/dpu_power_handle.h +++ b/drivers/gpu/drm/msm/disp/dpu1/dpu_power_handle.h @@ -16,11 +16,6 @@ #define MAX_CLIENT_NAME_LEN 128 -#define DPU_POWER_HANDLE_ENABLE_BUS_AB_QUOTA 0 -#define DPU_POWER_HANDLE_DISABLE_BUS_AB_QUOTA 0 -#define DPU_POWER_HANDLE_ENABLE_BUS_IB_QUOTA 1600000000 -#define DPU_POWER_HANDLE_DISABLE_BUS_IB_QUOTA 0 - #include "dpu_io_util.h" /* events will be triggered on power handler enable/disable */ @@ -28,64 +23,21 @@ #define DPU_POWER_EVENT_ENABLE BIT(1) /** - * mdss_bus_vote_type: register bus vote type - * VOTE_INDEX_DISABLE: removes the client vote - * VOTE_INDEX_LOW: keeps the lowest vote for register bus - * VOTE_INDEX_MAX: invalid - */ -enum mdss_bus_vote_type { - VOTE_INDEX_DISABLE, - VOTE_INDEX_LOW, - VOTE_INDEX_MAX, -}; - -/** - * enum dpu_power_handle_data_bus_client - type of axi bus clients - * @DPU_POWER_HANDLE_DATA_BUS_CLIENT_RT: core real-time bus client - * @DPU_POWER_HANDLE_DATA_BUS_CLIENT_NRT: core non-real-time bus client - * @DPU_POWER_HANDLE_DATA_BUS_CLIENT_MAX: maximum number of bus client type - */ -enum dpu_power_handle_data_bus_client { - DPU_POWER_HANDLE_DATA_BUS_CLIENT_RT, - DPU_POWER_HANDLE_DATA_BUS_CLIENT_NRT, - DPU_POWER_HANDLE_DATA_BUS_CLIENT_MAX -}; - -/** - * enum DPU_POWER_HANDLE_DBUS_ID - data bus identifier - * @DPU_POWER_HANDLE_DBUS_ID_MNOC: DPU/MNOC data bus - * @DPU_POWER_HANDLE_DBUS_ID_LLCC: MNOC/LLCC data bus - * @DPU_POWER_HANDLE_DBUS_ID_EBI: LLCC/EBI data bus - */ -enum DPU_POWER_HANDLE_DBUS_ID { - DPU_POWER_HANDLE_DBUS_ID_MNOC, - DPU_POWER_HANDLE_DBUS_ID_LLCC, - DPU_POWER_HANDLE_DBUS_ID_EBI, - DPU_POWER_HANDLE_DBUS_ID_MAX, -}; - -/** * struct dpu_power_client: stores the power client for dpu driver * @name: name of the client - * @usecase_ndx: current regs bus vote type * @refcount: current refcount if multiple modules are using same * same client for enable/disable. Power module will * aggregate the refcount and vote accordingly for this * client. * @id: assigned during create. helps for debugging. * @list: list to attach power handle master list - * @ab: arbitrated bandwidth for each bus client - * @ib: instantaneous bandwidth for each bus client * @active: inidcates the state of dpu power handle */ struct dpu_power_client { char name[MAX_CLIENT_NAME_LEN]; - short usecase_ndx; short refcount; u32 id; struct list_head list; - u64 ab[DPU_POWER_HANDLE_DATA_BUS_CLIENT_MAX]; - u64 ib[DPU_POWER_HANDLE_DATA_BUS_CLIENT_MAX]; bool active; }; @@ -112,14 +64,12 @@ struct dpu_power_event { * @client_clist: master list to store all clients * @phandle_lock: lock to synchronize the enable/disable * @dev: pointer to device structure - * @usecase_ndx: current usecase index * @event_list: current power handle event list */ struct dpu_power_handle { struct list_head power_client_clist; struct mutex phandle_lock; struct device *dev; - u32 current_usecase_ndx; struct list_head event_list; }; @@ -173,17 +123,6 @@ int dpu_power_resource_enable(struct dpu_power_handle *pdata, struct dpu_power_client *pclient, bool enable); /** - * dpu_power_data_bus_bandwidth_ctrl() - control data bus bandwidth enable - * @phandle: power handle containing the resources - * @client: client information to bandwidth control - * @enable: true to enable bandwidth for data base - * - * Return: none - */ -void dpu_power_data_bus_bandwidth_ctrl(struct dpu_power_handle *phandle, - struct dpu_power_client *pclient, int enable); - -/** * dpu_power_handle_register_event - register a callback function for an event. * Clients can register for multiple events with a single register. * Any block with access to phandle can register for the event @@ -207,11 +146,4 @@ struct dpu_power_event *dpu_power_handle_register_event( void dpu_power_handle_unregister_event(struct dpu_power_handle *phandle, struct dpu_power_event *event); -/** - * dpu_power_handle_get_dbus_name - get name of given data bus identifier - * @bus_id: data bus identifier - * Return: Pointer to name string if success; NULL otherwise - */ -const char *dpu_power_handle_get_dbus_name(u32 bus_id); - #endif /* _DPU_POWER_HANDLE_H_ */ diff --git a/drivers/gpu/drm/msm/disp/dpu1/dpu_trace.h b/drivers/gpu/drm/msm/disp/dpu1/dpu_trace.h index 0c122e1..7c8a92d 100644 --- a/drivers/gpu/drm/msm/disp/dpu1/dpu_trace.h +++ b/drivers/gpu/drm/msm/disp/dpu1/dpu_trace.h @@ -167,16 +167,12 @@ ) TRACE_EVENT(dpu_perf_crtc_update, - TP_PROTO(u32 crtc, u64 bw_ctl_mnoc, u64 bw_ctl_llcc, - u64 bw_ctl_ebi, u32 core_clk_rate, - bool stop_req, u32 update_bus, u32 update_clk), - TP_ARGS(crtc, bw_ctl_mnoc, bw_ctl_llcc, bw_ctl_ebi, core_clk_rate, - stop_req, update_bus, update_clk), + TP_PROTO(u32 crtc, u64 bw_ctl, u32 core_clk_rate, + bool stop_req, bool update_bus, bool update_clk), + TP_ARGS(crtc, bw_ctl, core_clk_rate, stop_req, update_bus, update_clk), TP_STRUCT__entry( __field(u32, crtc) - __field(u64, bw_ctl_mnoc) - __field(u64, bw_ctl_llcc) - __field(u64, bw_ctl_ebi) + __field(u64, bw_ctl) __field(u32, core_clk_rate) __field(bool, stop_req) __field(u32, update_bus) @@ -184,20 +180,16 @@ ), TP_fast_assign( __entry->crtc = crtc; - __entry->bw_ctl_mnoc = bw_ctl_mnoc; - __entry->bw_ctl_llcc = bw_ctl_llcc; - __entry->bw_ctl_ebi = bw_ctl_ebi; + __entry->bw_ctl = bw_ctl; __entry->core_clk_rate = core_clk_rate; __entry->stop_req = stop_req; __entry->update_bus = update_bus; __entry->update_clk = update_clk; ), TP_printk( - "crtc=%d bw_mnoc=%llu bw_llcc=%llu bw_ebi=%llu clk_rate=%u stop_req=%d u_bus=%d u_clk=%d", + "crtc=%d bw_ctl=%llu clk_rate=%u stop_req=%d u_bus=%d u_clk=%d", __entry->crtc, - __entry->bw_ctl_mnoc, - __entry->bw_ctl_llcc, - __entry->bw_ctl_ebi, + __entry->bw_ctl, __entry->core_clk_rate, __entry->stop_req, __entry->update_bus, -- The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project