From mboxrd@z Thu Jan 1 00:00:00 1970 From: Rob Herring Subject: [PATCH v4 4/5] drm: convert drivers to use drm_of_find_panel_or_bridge Date: Wed, 29 Mar 2017 13:55:46 -0500 Message-ID: <20170329185546.11667-1-robh@kernel.org> References: <20170322132608.17353-5-robh@kernel.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail-oi0-f65.google.com (mail-oi0-f65.google.com [209.85.218.65]) by gabe.freedesktop.org (Postfix) with ESMTPS id DBC476E799 for ; Wed, 29 Mar 2017 18:55:50 +0000 (UTC) Received: by mail-oi0-f65.google.com with SMTP id y7so1030365oiy.2 for ; Wed, 29 Mar 2017 11:55:50 -0700 (PDT) In-Reply-To: <20170322132608.17353-5-robh@kernel.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Sean Paul Cc: Neil Armstrong , Liviu Dudau , dri-devel@lists.freedesktop.org, Tomi Valkeinen , Daniel Vetter , Marek Vasut , Kevin Hilman , Chen-Yu Tsai , Krzysztof Kozlowski , Xinliang Liu , Javier Martinez Canillas , Xinwei Kong , Kukjin Kim , Mali DP Maintainers , Chen Feng , Jyri Sarha , Carlo Caione , Russell King , Matthias Brugger , Alison Wang , Jingoo Han , Seung-Woo Kim , linux-kernel@vger.kernel.org, Kyungmin List-Id: dri-devel@lists.freedesktop.org U2ltaWxhciB0byB0aGUgcHJldmlvdXMgY29tbWl0LCBjb252ZXJ0IGRyaXZlcnMgb3BlbiBjb2Rp bmcgT0YgZ3JhcGgKcGFyc2luZyB0byB1c2UgZHJtX29mX2ZpbmRfcGFuZWxfb3JfYnJpZGdlIGlu c3RlYWQuCgpUaGlzIGNoYW5nZXMgc29tZSBlcnJvciBtZXNzYWdlcyB0byBkZWJ1ZyBtZXNzYWdl cyAoaW4gdGhlIGdyYXBoIGNvcmUpLgpHcmFwaCBjb25uZWN0aW9ucyBhcmUgb2Z0ZW4gIm5vIGNv bm5lY3RzIiBkZXBlbmRpbmcgb24gdGhlIHBhcnRpY3VsYXIKYm9hcmQsIHNvIHdlIHdhbnQgdG8g YXZvaWQgc3B1cmlvdXMgbWVzc2FnZXMuIFBsdXMgdGhlIGtlcm5lbCBpcyBub3QgYQpEVCB2YWxp ZGF0b3IuCgpTaWduZWQtb2ZmLWJ5OiBSb2IgSGVycmluZyA8cm9iaEBrZXJuZWwub3JnPgpSZXZp ZXdlZC1ieTogQXJjaGl0IFRhbmVqYSA8YXJjaGl0dEBjb2RlYXVyb3JhLm9yZz4KVGVzdGVkLWJ5 OiBQaGlsaXBwIFphYmVsIDxwLnphYmVsQHBlbmd1dHJvbml4LmRlPgpBY2tlZC1ieTogTWF4aW1l IFJpcGFyZCA8bWF4aW1lLnJpcGFyZEBmcmVlLWVsZWN0cm9ucy5jb20+Ci0tLQpTZWFuLAoKSSBm aXhlZCB0aGUgY29tcGlsZSBlcnJvciBvbiBGU0wgRENVLiBMZXQgbWUga25vdyBpZiB5b3Ugd2Fu dCBtZSB0byAKc2VuZCB0aGUgd2hvbGUgc2VyaWVzIGFnYWluLgoKUm9iCgogZHJpdmVycy9ncHUv ZHJtL2F0bWVsLWhsY2RjL2F0bWVsX2hsY2RjX291dHB1dC5jIHwgNzMgKysrKysrLS0tLS0tLS0t LS0tLQogZHJpdmVycy9ncHUvZHJtL2JyaWRnZS9ueHAtcHRuMzQ2MC5jICAgICAgICAgICAgIHwg MTYgKystLS0KIGRyaXZlcnMvZ3B1L2RybS9icmlkZ2UvcGFyYWRlLXBzODYyMi5jICAgICAgICAg ICB8IDE2ICsrLS0tCiBkcml2ZXJzL2dwdS9kcm0vYnJpZGdlL3RjMzU4NzY3LmMgICAgICAgICAg ICAgICAgfCAyNyArLS0tLS0tCiBkcml2ZXJzL2dwdS9kcm0vZXh5bm9zL2V4eW5vc19kcC5jICAg ICAgICAgICAgICAgfCAzNSArKysrLS0tLS0KIGRyaXZlcnMvZ3B1L2RybS9mc2wtZGN1L2ZzbF9k Y3VfZHJtX3JnYi5jICAgICAgICB8IDQ0ICsrKystLS0tLS0tLQogZHJpdmVycy9ncHUvZHJtL2hp c2lsaWNvbi9raXJpbi9kd19kcm1fZHNpLmMgICAgIHwgMjcgKystLS0tLQogZHJpdmVycy9ncHUv ZHJtL2lteC9pbXgtbGRiLmMgICAgICAgICAgICAgICAgICAgIHwgMjcgKystLS0tLQogZHJpdmVy cy9ncHUvZHJtL2lteC9wYXJhbGxlbC1kaXNwbGF5LmMgICAgICAgICAgIHwgMzYgKystLS0tLS0t LQogZHJpdmVycy9ncHUvZHJtL21lZGlhdGVrL210a19kc2kuYyAgICAgICAgICAgICAgIHwgMjMg KystLS0tCiBkcml2ZXJzL2dwdS9kcm0vbXhzZmIvbXhzZmJfb3V0LmMgICAgICAgICAgICAgICAg fCA0MCArKy0tLS0tLS0tLQogZHJpdmVycy9ncHUvZHJtL3JvY2tjaGlwL2FuYWxvZ2l4X2RwLXJv Y2tjaGlwLmMgIHwgMjYgKystLS0tLQogZHJpdmVycy9ncHUvZHJtL3N1bjRpL3N1bjRpX3JnYi5j ICAgICAgICAgICAgICAgIHwgMTEgKy0tCiBkcml2ZXJzL2dwdS9kcm0vc3VuNGkvc3VuNGlfdGNv bi5jICAgICAgICAgICAgICAgfCA5MCArKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIDE0IGZpbGVz IGNoYW5nZWQsIDk1IGluc2VydGlvbnMoKyksIDM5NiBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQg YS9kcml2ZXJzL2dwdS9kcm0vYXRtZWwtaGxjZGMvYXRtZWxfaGxjZGNfb3V0cHV0LmMgYi9kcml2 ZXJzL2dwdS9kcm0vYXRtZWwtaGxjZGMvYXRtZWxfaGxjZGNfb3V0cHV0LmMKaW5kZXggZTc3OTli NmVlODI5Li5mOTg3YjQ1NzJkNGEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9hdG1lbC1o bGNkYy9hdG1lbF9obGNkY19vdXRwdXQuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vYXRtZWwtaGxj ZGMvYXRtZWxfaGxjZGNfb3V0cHV0LmMKQEAgLTIyLDcgKzIyLDcgQEAKICNpbmNsdWRlIDxsaW51 eC9vZl9ncmFwaC5oPgogCiAjaW5jbHVkZSA8ZHJtL2RybVAuaD4KLSNpbmNsdWRlIDxkcm0vZHJt X3BhbmVsLmg+CisjaW5jbHVkZSA8ZHJtL2RybV9vZi5oPgogCiAjaW5jbHVkZSAiYXRtZWxfaGxj ZGNfZGMuaCIKIApAQCAtMTUyLDI5ICsxNTIsMTEgQEAgc3RhdGljIGNvbnN0IHN0cnVjdCBkcm1f Y29ubmVjdG9yX2Z1bmNzIGF0bWVsX2hsY2RjX3BhbmVsX2Nvbm5lY3Rvcl9mdW5jcyA9IHsKIAku YXRvbWljX2Rlc3Ryb3lfc3RhdGUgPSBkcm1fYXRvbWljX2hlbHBlcl9jb25uZWN0b3JfZGVzdHJv eV9zdGF0ZSwKIH07CiAKLXN0YXRpYyBpbnQgYXRtZWxfaGxjZGNfY2hlY2tfZW5kcG9pbnQoc3Ry dWN0IGRybV9kZXZpY2UgKmRldiwKLQkJCQkgICAgICBjb25zdCBzdHJ1Y3Qgb2ZfZW5kcG9pbnQg KmVwKQotewotCXN0cnVjdCBkZXZpY2Vfbm9kZSAqbnA7Ci0Jdm9pZCAqb2JqOwotCi0JbnAgPSBv Zl9ncmFwaF9nZXRfcmVtb3RlX3BvcnRfcGFyZW50KGVwLT5sb2NhbF9ub2RlKTsKLQotCW9iaiA9 IG9mX2RybV9maW5kX3BhbmVsKG5wKTsKLQlpZiAoIW9iaikKLQkJb2JqID0gb2ZfZHJtX2ZpbmRf YnJpZGdlKG5wKTsKLQotCW9mX25vZGVfcHV0KG5wKTsKLQotCXJldHVybiBvYmogPyAwIDogLUVQ Uk9CRV9ERUZFUjsKLX0KLQogc3RhdGljIGludCBhdG1lbF9obGNkY19hdHRhY2hfZW5kcG9pbnQo c3RydWN0IGRybV9kZXZpY2UgKmRldiwKLQkJCQkgICAgICAgY29uc3Qgc3RydWN0IG9mX2VuZHBv aW50ICplcCkKKwkJCQkgICAgICAgY29uc3Qgc3RydWN0IGRldmljZV9ub2RlICpucCkKIHsKIAlz dHJ1Y3QgYXRtZWxfaGxjZGNfZGMgKmRjID0gZGV2LT5kZXZfcHJpdmF0ZTsKIAlzdHJ1Y3QgYXRt ZWxfaGxjZGNfcmdiX291dHB1dCAqb3V0cHV0OwotCXN0cnVjdCBkZXZpY2Vfbm9kZSAqbnA7CiAJ c3RydWN0IGRybV9wYW5lbCAqcGFuZWw7CiAJc3RydWN0IGRybV9icmlkZ2UgKmJyaWRnZTsKIAlp bnQgcmV0OwpAQCAtMTk1LDEzICsxNzcsMTEgQEAgc3RhdGljIGludCBhdG1lbF9obGNkY19hdHRh Y2hfZW5kcG9pbnQoc3RydWN0IGRybV9kZXZpY2UgKmRldiwKIAogCW91dHB1dC0+ZW5jb2Rlci5w b3NzaWJsZV9jcnRjcyA9IDB4MTsKIAotCW5wID0gb2ZfZ3JhcGhfZ2V0X3JlbW90ZV9wb3J0X3Bh cmVudChlcC0+bG9jYWxfbm9kZSk7Ci0KLQlyZXQgPSAtRVBST0JFX0RFRkVSOworCXJldCA9IGRy bV9vZl9maW5kX3BhbmVsX29yX2JyaWRnZShucCwgMCwgMCwgJnBhbmVsLCAmYnJpZGdlKTsKKwlp ZiAocmV0KQorCQlyZXR1cm4gcmV0OwogCi0JcGFuZWwgPSBvZl9kcm1fZmluZF9wYW5lbChucCk7 CiAJaWYgKHBhbmVsKSB7Ci0JCW9mX25vZGVfcHV0KG5wKTsKIAkJb3V0cHV0LT5jb25uZWN0b3Iu ZHBtcyA9IERSTV9NT0RFX0RQTVNfT0ZGOwogCQlvdXRwdXQtPmNvbm5lY3Rvci5wb2xsZWQgPSBE Uk1fQ09OTkVDVE9SX1BPTExfQ09OTkVDVDsKIAkJZHJtX2Nvbm5lY3Rvcl9oZWxwZXJfYWRkKCZv dXRwdXQtPmNvbm5lY3RvciwKQEAgLTIyNiw5ICsyMDYsNiBAQCBzdGF0aWMgaW50IGF0bWVsX2hs Y2RjX2F0dGFjaF9lbmRwb2ludChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LAogCQlyZXR1cm4gMDsK IAl9CiAKLQlicmlkZ2UgPSBvZl9kcm1fZmluZF9icmlkZ2UobnApOwotCW9mX25vZGVfcHV0KG5w KTsKLQogCWlmIChicmlkZ2UpIHsKIAkJcmV0ID0gZHJtX2JyaWRnZV9hdHRhY2goJm91dHB1dC0+ ZW5jb2RlciwgYnJpZGdlLCBOVUxMKTsKIAkJaWYgKCFyZXQpCkBAIC0yNDMsMzEgKzIyMCwyMyBA QCBzdGF0aWMgaW50IGF0bWVsX2hsY2RjX2F0dGFjaF9lbmRwb2ludChzdHJ1Y3QgZHJtX2Rldmlj ZSAqZGV2LAogCiBpbnQgYXRtZWxfaGxjZGNfY3JlYXRlX291dHB1dHMoc3RydWN0IGRybV9kZXZp Y2UgKmRldikKIHsKLQlzdHJ1Y3QgZGV2aWNlX25vZGUgKmVwX25wID0gTlVMTDsKLQlzdHJ1Y3Qg b2ZfZW5kcG9pbnQgZXA7Ci0JaW50IHJldDsKLQotCWZvcl9lYWNoX2VuZHBvaW50X29mX25vZGUo ZGV2LT5kZXYtPm9mX25vZGUsIGVwX25wKSB7Ci0JCXJldCA9IG9mX2dyYXBoX3BhcnNlX2VuZHBv aW50KGVwX25wLCAmZXApOwotCQlpZiAoIXJldCkKLQkJCXJldCA9IGF0bWVsX2hsY2RjX2NoZWNr X2VuZHBvaW50KGRldiwgJmVwKTsKLQotCQlpZiAocmV0KSB7Ci0JCQlvZl9ub2RlX3B1dChlcF9u cCk7Ci0JCQlyZXR1cm4gcmV0OwotCQl9Ci0JfQotCi0JZm9yX2VhY2hfZW5kcG9pbnRfb2Zfbm9k ZShkZXYtPmRldi0+b2Zfbm9kZSwgZXBfbnApIHsKLQkJcmV0ID0gb2ZfZ3JhcGhfcGFyc2VfZW5k cG9pbnQoZXBfbnAsICZlcCk7Ci0JCWlmICghcmV0KQotCQkJcmV0ID0gYXRtZWxfaGxjZGNfYXR0 YWNoX2VuZHBvaW50KGRldiwgJmVwKTsKLQotCQlpZiAocmV0KSB7Ci0JCQlvZl9ub2RlX3B1dChl cF9ucCk7CisJc3RydWN0IGRldmljZV9ub2RlICpyZW1vdGU7CisJaW50IHJldCwgZW5kcG9pbnQg PSAwOworCisJd2hpbGUgKHRydWUpIHsKKwkJLyogTG9vcCB0aHJ1IHBvc3NpYmxlIG11bHRpcGxl IGNvbm5lY3Rpb25zIHRvIHRoZSBvdXRwdXQgKi8KKwkJcmVtb3RlID0gb2ZfZ3JhcGhfZ2V0X3Jl bW90ZV9ub2RlKGRldi0+ZGV2LT5vZl9ub2RlLCAwLAorCQkJCQkJICBlbmRwb2ludCsrKTsKKwkJ aWYgKCFyZW1vdGUpCisJCQlicmVhazsKKworCQlyZXQgPSBhdG1lbF9obGNkY19hdHRhY2hfZW5k cG9pbnQoZGV2LCByZW1vdGUpOworCQlvZl9ub2RlX3B1dChyZW1vdGUpOworCQlpZiAocmV0KQog CQkJcmV0dXJuIHJldDsKLQkJfQogCX0KIAotCXJldHVybiAwOworCWlmICghZW5kcG9pbnQpCisJ CXJldHVybiAtRU5PREVWOworCXJldHVybiByZXQ7CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dw dS9kcm0vYnJpZGdlL254cC1wdG4zNDYwLmMgYi9kcml2ZXJzL2dwdS9kcm0vYnJpZGdlL254cC1w dG4zNDYwLmMKaW5kZXggMjdmOThjNTE4ZGRlLi4zNTE3MDQzOTBkMDIgMTAwNjQ0Ci0tLSBhL2Ry aXZlcnMvZ3B1L2RybS9icmlkZ2UvbnhwLXB0bjM0NjAuYworKysgYi9kcml2ZXJzL2dwdS9kcm0v YnJpZGdlL254cC1wdG4zNDYwLmMKQEAgLTIwLDggKzIwLDggQEAKICNpbmNsdWRlIDxsaW51eC9t b2R1bGUuaD4KICNpbmNsdWRlIDxsaW51eC9vZi5oPgogI2luY2x1ZGUgPGxpbnV4L29mX2dwaW8u aD4KLSNpbmNsdWRlIDxsaW51eC9vZl9ncmFwaC5oPgogCisjaW5jbHVkZSA8ZHJtL2RybV9vZi5o PgogI2luY2x1ZGUgPGRybS9kcm1fcGFuZWwuaD4KIAogI2luY2x1ZGUgImRybV9jcnRjLmgiCkBA IC0yOTIsNyArMjkyLDYgQEAgc3RhdGljIGludCBwdG4zNDYwX3Byb2JlKHN0cnVjdCBpMmNfY2xp ZW50ICpjbGllbnQsCiB7CiAJc3RydWN0IGRldmljZSAqZGV2ID0gJmNsaWVudC0+ZGV2OwogCXN0 cnVjdCBwdG4zNDYwX2JyaWRnZSAqcHRuX2JyaWRnZTsKLQlzdHJ1Y3QgZGV2aWNlX25vZGUgKmVu ZHBvaW50LCAqcGFuZWxfbm9kZTsKIAlpbnQgcmV0OwogCiAJcHRuX2JyaWRnZSA9IGRldm1fa3ph bGxvYyhkZXYsIHNpemVvZigqcHRuX2JyaWRnZSksIEdGUF9LRVJORUwpOwpAQCAtMzAwLDE2ICsy OTksOSBAQCBzdGF0aWMgaW50IHB0bjM0NjBfcHJvYmUoc3RydWN0IGkyY19jbGllbnQgKmNsaWVu dCwKIAkJcmV0dXJuIC1FTk9NRU07CiAJfQogCi0JZW5kcG9pbnQgPSBvZl9ncmFwaF9nZXRfbmV4 dF9lbmRwb2ludChkZXYtPm9mX25vZGUsIE5VTEwpOwotCWlmIChlbmRwb2ludCkgewotCQlwYW5l bF9ub2RlID0gb2ZfZ3JhcGhfZ2V0X3JlbW90ZV9wb3J0X3BhcmVudChlbmRwb2ludCk7Ci0JCWlm IChwYW5lbF9ub2RlKSB7Ci0JCQlwdG5fYnJpZGdlLT5wYW5lbCA9IG9mX2RybV9maW5kX3BhbmVs KHBhbmVsX25vZGUpOwotCQkJb2Zfbm9kZV9wdXQocGFuZWxfbm9kZSk7Ci0JCQlpZiAoIXB0bl9i cmlkZ2UtPnBhbmVsKQotCQkJCXJldHVybiAtRVBST0JFX0RFRkVSOwotCQl9Ci0JfQorCXJldCA9 IGRybV9vZl9maW5kX3BhbmVsX29yX2JyaWRnZShkZXYtPm9mX25vZGUsIDAsIDAsICZwdG5fYnJp ZGdlLT5wYW5lbCwgTlVMTCk7CisJaWYgKHJldCkKKwkJcmV0dXJuIHJldDsKIAogCXB0bl9icmlk Z2UtPmNsaWVudCA9IGNsaWVudDsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2JyaWRn ZS9wYXJhZGUtcHM4NjIyLmMgYi9kcml2ZXJzL2dwdS9kcm0vYnJpZGdlL3BhcmFkZS1wczg2MjIu YwppbmRleCBhYzhjYzViNTBkOWYuLjFkY2VjM2I5N2U2NyAxMDA2NDQKLS0tIGEvZHJpdmVycy9n cHUvZHJtL2JyaWRnZS9wYXJhZGUtcHM4NjIyLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2JyaWRn ZS9wYXJhZGUtcHM4NjIyLmMKQEAgLTIyLDEwICsyMiwxMCBAQAogI2luY2x1ZGUgPGxpbnV4L21v ZHVsZS5oPgogI2luY2x1ZGUgPGxpbnV4L29mLmg+CiAjaW5jbHVkZSA8bGludXgvb2ZfZGV2aWNl Lmg+Ci0jaW5jbHVkZSA8bGludXgvb2ZfZ3JhcGguaD4KICNpbmNsdWRlIDxsaW51eC9wbS5oPgog I2luY2x1ZGUgPGxpbnV4L3JlZ3VsYXRvci9jb25zdW1lci5oPgogCisjaW5jbHVkZSA8ZHJtL2Ry bV9vZi5oPgogI2luY2x1ZGUgPGRybS9kcm1fcGFuZWwuaD4KIAogI2luY2x1ZGUgImRybVAuaCIK QEAgLTUzNiw3ICs1MzYsNiBAQCBzdGF0aWMgaW50IHBzODYyMl9wcm9iZShzdHJ1Y3QgaTJjX2Ns aWVudCAqY2xpZW50LAogCQkJCQljb25zdCBzdHJ1Y3QgaTJjX2RldmljZV9pZCAqaWQpCiB7CiAJ c3RydWN0IGRldmljZSAqZGV2ID0gJmNsaWVudC0+ZGV2OwotCXN0cnVjdCBkZXZpY2Vfbm9kZSAq ZW5kcG9pbnQsICpwYW5lbF9ub2RlOwogCXN0cnVjdCBwczg2MjJfYnJpZGdlICpwczg2MjI7CiAJ aW50IHJldDsKIApAQCAtNTQ0LDE2ICs1NDMsOSBAQCBzdGF0aWMgaW50IHBzODYyMl9wcm9iZShz dHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50LAogCWlmICghcHM4NjIyKQogCQlyZXR1cm4gLUVOT01F TTsKIAotCWVuZHBvaW50ID0gb2ZfZ3JhcGhfZ2V0X25leHRfZW5kcG9pbnQoZGV2LT5vZl9ub2Rl LCBOVUxMKTsKLQlpZiAoZW5kcG9pbnQpIHsKLQkJcGFuZWxfbm9kZSA9IG9mX2dyYXBoX2dldF9y ZW1vdGVfcG9ydF9wYXJlbnQoZW5kcG9pbnQpOwotCQlpZiAocGFuZWxfbm9kZSkgewotCQkJcHM4 NjIyLT5wYW5lbCA9IG9mX2RybV9maW5kX3BhbmVsKHBhbmVsX25vZGUpOwotCQkJb2Zfbm9kZV9w dXQocGFuZWxfbm9kZSk7Ci0JCQlpZiAoIXBzODYyMi0+cGFuZWwpCi0JCQkJcmV0dXJuIC1FUFJP QkVfREVGRVI7Ci0JCX0KLQl9CisJcmV0ID0gZHJtX29mX2ZpbmRfcGFuZWxfb3JfYnJpZGdlKGRl di0+b2Zfbm9kZSwgMCwgMCwgJnBzODYyMi0+cGFuZWwsIE5VTEwpOworCWlmIChyZXQpCisJCXJl dHVybiByZXQ7CiAKIAlwczg2MjItPmNsaWVudCA9IGNsaWVudDsKIApkaWZmIC0tZ2l0IGEvZHJp dmVycy9ncHUvZHJtL2JyaWRnZS90YzM1ODc2Ny5jIGIvZHJpdmVycy9ncHUvZHJtL2JyaWRnZS90 YzM1ODc2Ny5jCmluZGV4IGRlOWZmYjQ5ZTlmNi4uNWMyNjQ4OGU3YTJkIDEwMDY0NAotLS0gYS9k cml2ZXJzL2dwdS9kcm0vYnJpZGdlL3RjMzU4NzY3LmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2Jy aWRnZS90YzM1ODc2Ny5jCkBAIC0xMjQ0LDcgKzEyNDQsNiBAQCBzdGF0aWMgY29uc3Qgc3RydWN0 IHJlZ21hcF9jb25maWcgdGNfcmVnbWFwX2NvbmZpZyA9IHsKIHN0YXRpYyBpbnQgdGNfcHJvYmUo c3RydWN0IGkyY19jbGllbnQgKmNsaWVudCwgY29uc3Qgc3RydWN0IGkyY19kZXZpY2VfaWQgKmlk KQogewogCXN0cnVjdCBkZXZpY2UgKmRldiA9ICZjbGllbnQtPmRldjsKLQlzdHJ1Y3QgZGV2aWNl X25vZGUgKmVwOwogCXN0cnVjdCB0Y19kYXRhICp0YzsKIAlpbnQgcmV0OwogCkBAIC0xMjU1LDI5 ICsxMjU0LDkgQEAgc3RhdGljIGludCB0Y19wcm9iZShzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50 LCBjb25zdCBzdHJ1Y3QgaTJjX2RldmljZV9pZCAqaWQpCiAJdGMtPmRldiA9IGRldjsKIAogCS8q IHBvcnRAMiBpcyB0aGUgb3V0cHV0IHBvcnQgKi8KLQllcCA9IG9mX2dyYXBoX2dldF9lbmRwb2lu dF9ieV9yZWdzKGRldi0+b2Zfbm9kZSwgMiwgLTEpOwotCWlmIChlcCkgewotCQlzdHJ1Y3QgZGV2 aWNlX25vZGUgKnJlbW90ZTsKLQotCQlyZW1vdGUgPSBvZl9ncmFwaF9nZXRfcmVtb3RlX3BvcnRf cGFyZW50KGVwKTsKLQkJaWYgKCFyZW1vdGUpIHsKLQkJCWRldl93YXJuKGRldiwgImVuZHBvaW50 ICVzIG5vdCBjb25uZWN0ZWRcbiIsCi0JCQkJIGVwLT5mdWxsX25hbWUpOwotCQkJb2Zfbm9kZV9w dXQoZXApOwotCQkJcmV0dXJuIC1FTk9ERVY7Ci0JCX0KLQkJb2Zfbm9kZV9wdXQoZXApOwotCQl0 Yy0+cGFuZWwgPSBvZl9kcm1fZmluZF9wYW5lbChyZW1vdGUpOwotCQlpZiAodGMtPnBhbmVsKSB7 Ci0JCQlkZXZfZGJnKGRldiwgImZvdW5kIHBhbmVsICVzXG4iLCByZW1vdGUtPmZ1bGxfbmFtZSk7 Ci0JCX0gZWxzZSB7Ci0JCQlkZXZfZGJnKGRldiwgIndhaXRpbmcgZm9yIHBhbmVsICVzXG4iLAot CQkJCXJlbW90ZS0+ZnVsbF9uYW1lKTsKLQkJCW9mX25vZGVfcHV0KHJlbW90ZSk7Ci0JCQlyZXR1 cm4gLUVQUk9CRV9ERUZFUjsKLQkJfQotCQlvZl9ub2RlX3B1dChyZW1vdGUpOwotCX0KKwlyZXQg PSBkcm1fb2ZfZmluZF9wYW5lbF9vcl9icmlkZ2UoZGV2LT5vZl9ub2RlLCAyLCAwLCAmdGMtPnBh bmVsLCBOVUxMKTsKKwlpZiAocmV0KQorCQlyZXR1cm4gcmV0OwogCiAJLyogU2h1dCBkb3duIEdQ SU8gaXMgb3B0aW9uYWwgKi8KIAl0Yy0+c2RfZ3BpbyA9IGRldm1fZ3Bpb2RfZ2V0X29wdGlvbmFs KGRldiwgInNodXRkb3duIiwgR1BJT0RfT1VUX0hJR0gpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9n cHUvZHJtL2V4eW5vcy9leHlub3NfZHAuYyBiL2RyaXZlcnMvZ3B1L2RybS9leHlub3MvZXh5bm9z X2RwLmMKaW5kZXggMWVmMGJlMzM4Yjg1Li5hMjY5ZjQzOWU3NDIgMTAwNjQ0Ci0tLSBhL2RyaXZl cnMvZ3B1L2RybS9leHlub3MvZXh5bm9zX2RwLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2V4eW5v cy9leHlub3NfZHAuYwpAQCAtMjMsNiArMjMsNyBAQAogI2luY2x1ZGUgPGRybS9kcm1QLmg+CiAj aW5jbHVkZSA8ZHJtL2RybV9jcnRjLmg+CiAjaW5jbHVkZSA8ZHJtL2RybV9jcnRjX2hlbHBlci5o PgorI2luY2x1ZGUgPGRybS9kcm1fb2YuaD4KICNpbmNsdWRlIDxkcm0vZHJtX3BhbmVsLmg+CiAK ICNpbmNsdWRlIDxkcm0vYnJpZGdlL2FuYWxvZ2l4X2RwLmg+CkBAIC0yMTIsOCArMjEzLDExIEBA IHN0YXRpYyBjb25zdCBzdHJ1Y3QgY29tcG9uZW50X29wcyBleHlub3NfZHBfb3BzID0gewogc3Rh dGljIGludCBleHlub3NfZHBfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKIHsK IAlzdHJ1Y3QgZGV2aWNlICpkZXYgPSAmcGRldi0+ZGV2OwotCXN0cnVjdCBkZXZpY2Vfbm9kZSAq bnAgPSBOVUxMLCAqZW5kcG9pbnQgPSBOVUxMOworCXN0cnVjdCBkZXZpY2Vfbm9kZSAqbnA7CiAJ c3RydWN0IGV4eW5vc19kcF9kZXZpY2UgKmRwOworCXN0cnVjdCBkcm1fcGFuZWwgKnBhbmVsOwor CXN0cnVjdCBkcm1fYnJpZGdlICpicmlkZ2U7CisJaW50IHJldDsKIAogCWRwID0gZGV2bV9remFs bG9jKCZwZGV2LT5kZXYsIHNpemVvZihzdHJ1Y3QgZXh5bm9zX2RwX2RldmljZSksCiAJCQkgIEdG UF9LRVJORUwpOwpAQCAtMjM3LDI4ICsyNDEsMTMgQEAgc3RhdGljIGludCBleHlub3NfZHBfcHJv YmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKIAkJZ290byBvdXQ7CiAJfQogCi0JZW5k cG9pbnQgPSBvZl9ncmFwaF9nZXRfbmV4dF9lbmRwb2ludChkZXYtPm9mX25vZGUsIE5VTEwpOwot CWlmIChlbmRwb2ludCkgewotCQlucCA9IG9mX2dyYXBoX2dldF9yZW1vdGVfcG9ydF9wYXJlbnQo ZW5kcG9pbnQpOwotCQlpZiAobnApIHsKLQkJCS8qIFRoZSByZW1vdGUgcG9ydCBjYW4gYmUgZWl0 aGVyIGEgcGFuZWwgb3IgYSBicmlkZ2UgKi8KLQkJCWRwLT5wbGF0X2RhdGEucGFuZWwgPSBvZl9k cm1fZmluZF9wYW5lbChucCk7Ci0JCQlpZiAoIWRwLT5wbGF0X2RhdGEucGFuZWwpIHsKLQkJCQlk cC0+cHRuX2JyaWRnZSA9IG9mX2RybV9maW5kX2JyaWRnZShucCk7Ci0JCQkJaWYgKCFkcC0+cHRu X2JyaWRnZSkgewotCQkJCQlvZl9ub2RlX3B1dChucCk7Ci0JCQkJCXJldHVybiAtRVBST0JFX0RF RkVSOwotCQkJCX0KLQkJCX0KLQkJCW9mX25vZGVfcHV0KG5wKTsKLQkJfSBlbHNlIHsKLQkJCURS TV9FUlJPUigibm8gcmVtb3RlIGVuZHBvaW50IGRldmljZSBub2RlIGZvdW5kLlxuIik7Ci0JCQly ZXR1cm4gLUVJTlZBTDsKLQkJfQotCX0gZWxzZSB7Ci0JCURSTV9FUlJPUigibm8gcG9ydCBlbmRw b2ludCBzdWJub2RlIGZvdW5kLlxuIik7Ci0JCXJldHVybiAtRUlOVkFMOwotCX0KKwlyZXQgPSBk cm1fb2ZfZmluZF9wYW5lbF9vcl9icmlkZ2UoZGV2LT5vZl9ub2RlLCAwLCAwLCAmcGFuZWwsICZi cmlkZ2UpOworCWlmIChyZXQpCisJCXJldHVybiByZXQ7CisKKwkvKiBUaGUgcmVtb3RlIHBvcnQg Y2FuIGJlIGVpdGhlciBhIHBhbmVsIG9yIGEgYnJpZGdlICovCisJZHAtPnBsYXRfZGF0YS5wYW5l bCA9IHBhbmVsOworCWRwLT5wdG5fYnJpZGdlID0gYnJpZGdlOwogCiBvdXQ6CiAJcmV0dXJuIGNv bXBvbmVudF9hZGQoJnBkZXYtPmRldiwgJmV4eW5vc19kcF9vcHMpOwpkaWZmIC0tZ2l0IGEvZHJp dmVycy9ncHUvZHJtL2ZzbC1kY3UvZnNsX2RjdV9kcm1fcmdiLmMgYi9kcml2ZXJzL2dwdS9kcm0v ZnNsLWRjdS9mc2xfZGN1X2RybV9yZ2IuYwppbmRleCBjMzY1MTQ1NmM5NjMuLmRjYmYzYzA2ZTFk OCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2ZzbC1kY3UvZnNsX2RjdV9kcm1fcmdiLmMK KysrIGIvZHJpdmVycy9ncHUvZHJtL2ZzbC1kY3UvZnNsX2RjdV9kcm1fcmdiLmMKQEAgLTE1LDYg KzE1LDcgQEAKICNpbmNsdWRlIDxkcm0vZHJtUC5oPgogI2luY2x1ZGUgPGRybS9kcm1fYXRvbWlj X2hlbHBlci5oPgogI2luY2x1ZGUgPGRybS9kcm1fY3J0Y19oZWxwZXIuaD4KKyNpbmNsdWRlIDxk cm0vZHJtX29mLmg+CiAjaW5jbHVkZSA8ZHJtL2RybV9wYW5lbC5oPgogCiAjaW5jbHVkZSAiZnNs X2RjdV9kcm1fZHJ2LmgiCkBAIC0xNDEsMzIgKzE0MiwxMSBAQCBzdGF0aWMgaW50IGZzbF9kY3Vf YXR0YWNoX3BhbmVsKHN0cnVjdCBmc2xfZGN1X2RybV9kZXZpY2UgKmZzbF9kZXYsCiAJcmV0dXJu IHJldDsKIH0KIAotc3RhdGljIGludCBmc2xfZGN1X2F0dGFjaF9lbmRwb2ludChzdHJ1Y3QgZnNs X2RjdV9kcm1fZGV2aWNlICpmc2xfZGV2LAotCQkJCSAgIGNvbnN0IHN0cnVjdCBvZl9lbmRwb2lu dCAqZXApCi17Ci0Jc3RydWN0IGRybV9icmlkZ2UgKmJyaWRnZTsKLQlzdHJ1Y3QgZGV2aWNlX25v ZGUgKm5wOwotCi0JbnAgPSBvZl9ncmFwaF9nZXRfcmVtb3RlX3BvcnRfcGFyZW50KGVwLT5sb2Nh bF9ub2RlKTsKLQotCWZzbF9kZXYtPmNvbm5lY3Rvci5wYW5lbCA9IG9mX2RybV9maW5kX3BhbmVs KG5wKTsKLQlpZiAoZnNsX2Rldi0+Y29ubmVjdG9yLnBhbmVsKSB7Ci0JCW9mX25vZGVfcHV0KG5w KTsKLQkJcmV0dXJuIGZzbF9kY3VfYXR0YWNoX3BhbmVsKGZzbF9kZXYsIGZzbF9kZXYtPmNvbm5l Y3Rvci5wYW5lbCk7Ci0JfQotCi0JYnJpZGdlID0gb2ZfZHJtX2ZpbmRfYnJpZGdlKG5wKTsKLQlv Zl9ub2RlX3B1dChucCk7Ci0JaWYgKCFicmlkZ2UpCi0JCXJldHVybiAtRU5PREVWOwotCi0JcmV0 dXJuIGRybV9icmlkZ2VfYXR0YWNoKCZmc2xfZGV2LT5lbmNvZGVyLCBicmlkZ2UsIE5VTEwpOwot fQotCiBpbnQgZnNsX2RjdV9jcmVhdGVfb3V0cHV0cyhzdHJ1Y3QgZnNsX2RjdV9kcm1fZGV2aWNl ICpmc2xfZGV2KQogewotCXN0cnVjdCBvZl9lbmRwb2ludCBlcDsKLQlzdHJ1Y3QgZGV2aWNlX25v ZGUgKmVwX25vZGUsICpwYW5lbF9ub2RlOworCXN0cnVjdCBkZXZpY2Vfbm9kZSAqcGFuZWxfbm9k ZTsKKwlzdHJ1Y3QgZHJtX3BhbmVsICpwYW5lbDsKKwlzdHJ1Y3QgZHJtX2JyaWRnZSAqYnJpZGdl OwogCWludCByZXQ7CiAKIAkvKiBUaGlzIGlzIGZvciBiYWNrd2FyZCBjb21wYXRpYmlsaXR5ICov CkBAIC0xNzksMTQgKzE1OSwxNCBAQCBpbnQgZnNsX2RjdV9jcmVhdGVfb3V0cHV0cyhzdHJ1Y3Qg ZnNsX2RjdV9kcm1fZGV2aWNlICpmc2xfZGV2KQogCQlyZXR1cm4gZnNsX2RjdV9hdHRhY2hfcGFu ZWwoZnNsX2RldiwgZnNsX2Rldi0+Y29ubmVjdG9yLnBhbmVsKTsKIAl9CiAKLQllcF9ub2RlID0g b2ZfZ3JhcGhfZ2V0X25leHRfZW5kcG9pbnQoZnNsX2Rldi0+bnAsIE5VTEwpOwotCWlmICghZXBf bm9kZSkKLQkJcmV0dXJuIC1FTk9ERVY7Ci0KLQlyZXQgPSBvZl9ncmFwaF9wYXJzZV9lbmRwb2lu dChlcF9ub2RlLCAmZXApOwotCW9mX25vZGVfcHV0KGVwX25vZGUpOworCXJldCA9IGRybV9vZl9m aW5kX3BhbmVsX29yX2JyaWRnZShmc2xfZGV2LT5ucCwgMCwgMCwgJnBhbmVsLCAmYnJpZGdlKTsK IAlpZiAocmV0KQotCQlyZXR1cm4gLUVOT0RFVjsKKwkJcmV0dXJuIHJldDsKKworCWlmIChwYW5l bCkgeworCQlmc2xfZGV2LT5jb25uZWN0b3IucGFuZWwgPSBwYW5lbDsKKwkJcmV0dXJuIGZzbF9k Y3VfYXR0YWNoX3BhbmVsKGZzbF9kZXYsIHBhbmVsKTsKKwl9CiAKLQlyZXR1cm4gZnNsX2RjdV9h dHRhY2hfZW5kcG9pbnQoZnNsX2RldiwgJmVwKTsKKwlyZXR1cm4gZHJtX2JyaWRnZV9hdHRhY2go JmZzbF9kZXYtPmVuY29kZXIsIGJyaWRnZSwgTlVMTCk7CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJz L2dwdS9kcm0vaGlzaWxpY29uL2tpcmluL2R3X2RybV9kc2kuYyBiL2RyaXZlcnMvZ3B1L2RybS9o aXNpbGljb24va2lyaW4vZHdfZHJtX2RzaS5jCmluZGV4IDE3MzdlOThiYzEwYS4uNWFiYzY5Yzk2 MzBmIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaGlzaWxpY29uL2tpcmluL2R3X2RybV9k c2kuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vaGlzaWxpY29uL2tpcmluL2R3X2RybV9kc2kuYwpA QCAtMTcsNyArMTcsNiBAQAogCiAjaW5jbHVkZSA8bGludXgvY2xrLmg+CiAjaW5jbHVkZSA8bGlu dXgvY29tcG9uZW50Lmg+Ci0jaW5jbHVkZSA8bGludXgvb2ZfZ3JhcGguaD4KIAogI2luY2x1ZGUg PGRybS9kcm1fb2YuaD4KICNpbmNsdWRlIDxkcm0vZHJtX2NydGNfaGVscGVyLmg+CkBAIC03NTQs MzQgKzc1MywxNiBAQCBzdGF0aWMgaW50IGRzaV9wYXJzZV9kdChzdHJ1Y3QgcGxhdGZvcm1fZGV2 aWNlICpwZGV2LCBzdHJ1Y3QgZHdfZHNpICpkc2kpCiB7CiAJc3RydWN0IGRzaV9od19jdHggKmN0 eCA9IGRzaS0+Y3R4OwogCXN0cnVjdCBkZXZpY2Vfbm9kZSAqbnAgPSBwZGV2LT5kZXYub2Zfbm9k ZTsKLQlzdHJ1Y3QgZGV2aWNlX25vZGUgKmVuZHBvaW50LCAqYnJpZGdlX25vZGU7Ci0Jc3RydWN0 IGRybV9icmlkZ2UgKmJyaWRnZTsKIAlzdHJ1Y3QgcmVzb3VyY2UgKnJlczsKKwlpbnQgcmV0Owog CiAJLyoKIAkgKiBHZXQgdGhlIGVuZHBvaW50IG5vZGUuIEluIG91ciBjYXNlLCBkc2kgaGFzIG9u ZSBvdXRwdXQgcG9ydDEKIAkgKiB0byB3aGljaCB0aGUgZXh0ZXJuYWwgSERNSSBicmlkZ2UgaXMg Y29ubmVjdGVkLgogCSAqLwotCWVuZHBvaW50ID0gb2ZfZ3JhcGhfZ2V0X2VuZHBvaW50X2J5X3Jl Z3MobnAsIDEsIC0xKTsKLQlpZiAoIWVuZHBvaW50KSB7Ci0JCURSTV9FUlJPUigibm8gdmFsaWQg ZW5kcG9pbnQgbm9kZVxuIik7Ci0JCXJldHVybiAtRU5PREVWOwotCX0KLQlvZl9ub2RlX3B1dChl bmRwb2ludCk7Ci0KLQlicmlkZ2Vfbm9kZSA9IG9mX2dyYXBoX2dldF9yZW1vdGVfcG9ydF9wYXJl bnQoZW5kcG9pbnQpOwotCWlmICghYnJpZGdlX25vZGUpIHsKLQkJRFJNX0VSUk9SKCJubyB2YWxp ZCBicmlkZ2Ugbm9kZVxuIik7Ci0JCXJldHVybiAtRU5PREVWOwotCX0KLQlvZl9ub2RlX3B1dChi cmlkZ2Vfbm9kZSk7Ci0KLQlicmlkZ2UgPSBvZl9kcm1fZmluZF9icmlkZ2UoYnJpZGdlX25vZGUp OwotCWlmICghYnJpZGdlKSB7Ci0JCURSTV9JTkZPKCJ3YWl0IGZvciBleHRlcm5hbCBIRE1JIGJy aWRnZSBkcml2ZXIuXG4iKTsKLQkJcmV0dXJuIC1FUFJPQkVfREVGRVI7Ci0JfQotCWRzaS0+YnJp ZGdlID0gYnJpZGdlOworCXJldCA9IGRybV9vZl9maW5kX3BhbmVsX29yX2JyaWRnZShucCwgMCwg MCwgTlVMTCwgJmRzaS0+YnJpZGdlKTsKKwlpZiAocmV0KQorCQlyZXR1cm4gcmV0OwogCiAJY3R4 LT5wY2xrID0gZGV2bV9jbGtfZ2V0KCZwZGV2LT5kZXYsICJwY2xrIik7CiAJaWYgKElTX0VSUihj dHgtPnBjbGspKSB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaW14L2lteC1sZGIuYyBi L2RyaXZlcnMvZ3B1L2RybS9pbXgvaW14LWxkYi5jCmluZGV4IDg4Y2QxMWQzMDEzNC4uOGZiODAx ZmFiMDM5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaW14L2lteC1sZGIuYworKysgYi9k cml2ZXJzL2dwdS9kcm0vaW14L2lteC1sZGIuYwpAQCAtNjQ3LDcgKzY0Nyw2IEBAIHN0YXRpYyBp bnQgaW14X2xkYl9iaW5kKHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IGRldmljZSAqbWFzdGVy LCB2b2lkICpkYXRhKQogCiAJZm9yX2VhY2hfY2hpbGRfb2Zfbm9kZShucCwgY2hpbGQpIHsKIAkJ c3RydWN0IGlteF9sZGJfY2hhbm5lbCAqY2hhbm5lbDsKLQkJc3RydWN0IGRldmljZV9ub2RlICpl cDsKIAkJaW50IGJ1c19mb3JtYXQ7CiAKIAkJcmV0ID0gb2ZfcHJvcGVydHlfcmVhZF91MzIoY2hp bGQsICJyZWciLCAmaSk7CkBAIC02NzEsMjcgKzY3MCwxMSBAQCBzdGF0aWMgaW50IGlteF9sZGJf YmluZChzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2UgKm1hc3Rlciwgdm9pZCAqZGF0 YSkKIAkJICogVGhlIG91dHB1dCBwb3J0IGlzIHBvcnRANCB3aXRoIGFuIGV4dGVybmFsIDQtcG9y dCBtdXggb3IKIAkJICogcG9ydEAyIHdpdGggdGhlIGludGVybmFsIDItcG9ydCBtdXguCiAJCSAq LwotCQllcCA9IG9mX2dyYXBoX2dldF9lbmRwb2ludF9ieV9yZWdzKGNoaWxkLAotCQkJCQkJICAg aW14X2xkYi0+bHZkc19tdXggPyA0IDogMiwKLQkJCQkJCSAgIC0xKTsKLQkJaWYgKGVwKSB7Ci0J CQlzdHJ1Y3QgZGV2aWNlX25vZGUgKnJlbW90ZTsKLQotCQkJcmVtb3RlID0gb2ZfZ3JhcGhfZ2V0 X3JlbW90ZV9wb3J0X3BhcmVudChlcCk7Ci0JCQlvZl9ub2RlX3B1dChlcCk7Ci0JCQlpZiAocmVt b3RlKSB7Ci0JCQkJY2hhbm5lbC0+cGFuZWwgPSBvZl9kcm1fZmluZF9wYW5lbChyZW1vdGUpOwot CQkJCWNoYW5uZWwtPmJyaWRnZSA9IG9mX2RybV9maW5kX2JyaWRnZShyZW1vdGUpOwotCQkJfSBl bHNlCi0JCQkJcmV0dXJuIC1FUFJPQkVfREVGRVI7Ci0JCQlvZl9ub2RlX3B1dChyZW1vdGUpOwot Ci0JCQlpZiAoIWNoYW5uZWwtPnBhbmVsICYmICFjaGFubmVsLT5icmlkZ2UpIHsKLQkJCQlkZXZf ZXJyKGRldiwgInBhbmVsL2JyaWRnZSBub3QgZm91bmQ6ICVzXG4iLAotCQkJCQlyZW1vdGUtPmZ1 bGxfbmFtZSk7Ci0JCQkJcmV0dXJuIC1FUFJPQkVfREVGRVI7Ci0JCQl9Ci0JCX0KKwkJcmV0ID0g ZHJtX29mX2ZpbmRfcGFuZWxfb3JfYnJpZGdlKGNoaWxkLAorCQkJCQkJICBpbXhfbGRiLT5sdmRz X211eCA/IDQgOiAyLCAwLAorCQkJCQkJICAmY2hhbm5lbC0+cGFuZWwsICZjaGFubmVsLT5icmlk Z2UpOworCQlpZiAocmV0KQorCQkJcmV0dXJuIHJldDsKIAogCQkvKiBwYW5lbCBkZGMgb25seSBp ZiB0aGVyZSBpcyBubyBicmlkZ2UgKi8KIAkJaWYgKCFjaGFubmVsLT5icmlkZ2UpIHsKZGlmZiAt LWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pbXgvcGFyYWxsZWwtZGlzcGxheS5jIGIvZHJpdmVycy9n cHUvZHJtL2lteC9wYXJhbGxlbC1kaXNwbGF5LmMKaW5kZXggZDVjMDZmZDg5ZjkwLi42MzYwMzFh MzBlMTcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pbXgvcGFyYWxsZWwtZGlzcGxheS5j CisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pbXgvcGFyYWxsZWwtZGlzcGxheS5jCkBAIC0xOSwxMCAr MTksMTAgQEAKICNpbmNsdWRlIDxkcm0vZHJtX2F0b21pY19oZWxwZXIuaD4KICNpbmNsdWRlIDxk cm0vZHJtX2ZiX2hlbHBlci5oPgogI2luY2x1ZGUgPGRybS9kcm1fY3J0Y19oZWxwZXIuaD4KKyNp bmNsdWRlIDxkcm0vZHJtX29mLmg+CiAjaW5jbHVkZSA8ZHJtL2RybV9wYW5lbC5oPgogI2luY2x1 ZGUgPGxpbnV4L3ZpZGVvZGV2Mi5oPgogI2luY2x1ZGUgPHZpZGVvL29mX2Rpc3BsYXlfdGltaW5n Lmg+Ci0jaW5jbHVkZSA8bGludXgvb2ZfZ3JhcGguaD4KIAogI2luY2x1ZGUgImlteC1kcm0uaCIK IApAQCAtMjA4LDcgKzIwOCw2IEBAIHN0YXRpYyBpbnQgaW14X3BkX2JpbmQoc3RydWN0IGRldmlj ZSAqZGV2LCBzdHJ1Y3QgZGV2aWNlICptYXN0ZXIsIHZvaWQgKmRhdGEpCiB7CiAJc3RydWN0IGRy bV9kZXZpY2UgKmRybSA9IGRhdGE7CiAJc3RydWN0IGRldmljZV9ub2RlICpucCA9IGRldi0+b2Zf bm9kZTsKLQlzdHJ1Y3QgZGV2aWNlX25vZGUgKmVwOwogCWNvbnN0IHU4ICplZGlkcDsKIAlzdHJ1 Y3QgaW14X3BhcmFsbGVsX2Rpc3BsYXkgKmlteHBkOwogCWludCByZXQ7CkBAIC0yMzcsMzYgKzIz Niw5IEBAIHN0YXRpYyBpbnQgaW14X3BkX2JpbmQoc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3Qg ZGV2aWNlICptYXN0ZXIsIHZvaWQgKmRhdGEpCiAJaW14cGQtPmJ1c19mb3JtYXQgPSBidXNfZm9y bWF0OwogCiAJLyogcG9ydEAxIGlzIHRoZSBvdXRwdXQgcG9ydCAqLwotCWVwID0gb2ZfZ3JhcGhf Z2V0X2VuZHBvaW50X2J5X3JlZ3MobnAsIDEsIC0xKTsKLQlpZiAoZXApIHsKLQkJc3RydWN0IGRl dmljZV9ub2RlICpyZW1vdGU7Ci0KLQkJcmVtb3RlID0gb2ZfZ3JhcGhfZ2V0X3JlbW90ZV9wb3J0 X3BhcmVudChlcCk7Ci0JCWlmICghcmVtb3RlKSB7Ci0JCQlkZXZfd2FybihkZXYsICJlbmRwb2lu dCAlcyBub3QgY29ubmVjdGVkXG4iLAotCQkJCSBlcC0+ZnVsbF9uYW1lKTsKLQkJCW9mX25vZGVf cHV0KGVwKTsKLQkJCXJldHVybiAtRU5PREVWOwotCQl9Ci0JCW9mX25vZGVfcHV0KGVwKTsKLQot CQlpbXhwZC0+cGFuZWwgPSBvZl9kcm1fZmluZF9wYW5lbChyZW1vdGUpOwotCQlpZiAoaW14cGQt PnBhbmVsKSB7Ci0JCQlkZXZfZGJnKGRldiwgImZvdW5kIHBhbmVsICVzXG4iLCByZW1vdGUtPmZ1 bGxfbmFtZSk7Ci0JCX0gZWxzZSB7Ci0JCQlpbXhwZC0+YnJpZGdlID0gb2ZfZHJtX2ZpbmRfYnJp ZGdlKHJlbW90ZSk7Ci0JCQlpZiAoaW14cGQtPmJyaWRnZSkKLQkJCQlkZXZfZGJnKGRldiwgImZv dW5kIGJyaWRnZSAlc1xuIiwKLQkJCQkJcmVtb3RlLT5mdWxsX25hbWUpOwotCQl9Ci0JCWlmICgh aW14cGQtPnBhbmVsICYmICFpbXhwZC0+YnJpZGdlKSB7Ci0JCQlkZXZfZGJnKGRldiwgIndhaXRp bmcgZm9yIHBhbmVsIG9yIGJyaWRnZSAlc1xuIiwKLQkJCQlyZW1vdGUtPmZ1bGxfbmFtZSk7Ci0J CQlvZl9ub2RlX3B1dChyZW1vdGUpOwotCQkJcmV0dXJuIC1FUFJPQkVfREVGRVI7Ci0JCX0KLQkJ b2Zfbm9kZV9wdXQocmVtb3RlKTsKLQl9CisJcmV0ID0gZHJtX29mX2ZpbmRfcGFuZWxfb3JfYnJp ZGdlKG5wLCAxLCAwLCAmaW14cGQtPnBhbmVsLCAmaW14cGQtPmJyaWRnZSk7CisJaWYgKHJldCkK KwkJcmV0dXJuIHJldDsKIAogCWlteHBkLT5kZXYgPSBkZXY7CiAKZGlmZiAtLWdpdCBhL2RyaXZl cnMvZ3B1L2RybS9tZWRpYXRlay9tdGtfZHNpLmMgYi9kcml2ZXJzL2dwdS9kcm0vbWVkaWF0ZWsv bXRrX2RzaS5jCmluZGV4IGRkNzFjYmIxYTYyMi4uNGQ4MzdiMjllZTllIDEwMDY0NAotLS0gYS9k cml2ZXJzL2dwdS9kcm0vbWVkaWF0ZWsvbXRrX2RzaS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9t ZWRpYXRlay9tdGtfZHNpLmMKQEAgLTE2LDExICsxNiwxMSBAQAogI2luY2x1ZGUgPGRybS9kcm1f Y3J0Y19oZWxwZXIuaD4KICNpbmNsdWRlIDxkcm0vZHJtX21pcGlfZHNpLmg+CiAjaW5jbHVkZSA8 ZHJtL2RybV9wYW5lbC5oPgorI2luY2x1ZGUgPGRybS9kcm1fb2YuaD4KICNpbmNsdWRlIDxsaW51 eC9jbGsuaD4KICNpbmNsdWRlIDxsaW51eC9jb21wb25lbnQuaD4KICNpbmNsdWRlIDxsaW51eC9v Zi5oPgogI2luY2x1ZGUgPGxpbnV4L29mX3BsYXRmb3JtLmg+Ci0jaW5jbHVkZSA8bGludXgvb2Zf Z3JhcGguaD4KICNpbmNsdWRlIDxsaW51eC9waHkvcGh5Lmg+CiAjaW5jbHVkZSA8bGludXgvcGxh dGZvcm1fZGV2aWNlLmg+CiAjaW5jbHVkZSA8dmlkZW8vdmlkZW9tb2RlLmg+CkBAIC04MDEsNyAr ODAxLDYgQEAgc3RhdGljIGludCBtdGtfZHNpX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2Ug KnBkZXYpCiB7CiAJc3RydWN0IG10a19kc2kgKmRzaTsKIAlzdHJ1Y3QgZGV2aWNlICpkZXYgPSAm cGRldi0+ZGV2OwotCXN0cnVjdCBkZXZpY2Vfbm9kZSAqcmVtb3RlX25vZGUsICplbmRwb2ludDsK IAlzdHJ1Y3QgcmVzb3VyY2UgKnJlZ3M7CiAJaW50IGNvbXBfaWQ7CiAJaW50IHJldDsKQEAgLTgx MywyMiArODEyLDEwIEBAIHN0YXRpYyBpbnQgbXRrX2RzaV9wcm9iZShzdHJ1Y3QgcGxhdGZvcm1f ZGV2aWNlICpwZGV2KQogCWRzaS0+aG9zdC5vcHMgPSAmbXRrX2RzaV9vcHM7CiAJZHNpLT5ob3N0 LmRldiA9IGRldjsKIAotCWVuZHBvaW50ID0gb2ZfZ3JhcGhfZ2V0X25leHRfZW5kcG9pbnQoZGV2 LT5vZl9ub2RlLCBOVUxMKTsKLQlpZiAoZW5kcG9pbnQpIHsKLQkJcmVtb3RlX25vZGUgPSBvZl9n cmFwaF9nZXRfcmVtb3RlX3BvcnRfcGFyZW50KGVuZHBvaW50KTsKLQkJaWYgKCFyZW1vdGVfbm9k ZSkgewotCQkJZGV2X2VycihkZXYsICJObyBwYW5lbCBjb25uZWN0ZWRcbiIpOwotCQkJcmV0dXJu IC1FTk9ERVY7Ci0JCX0KLQotCQlkc2ktPmJyaWRnZSA9IG9mX2RybV9maW5kX2JyaWRnZShyZW1v dGVfbm9kZSk7Ci0JCWRzaS0+cGFuZWwgPSBvZl9kcm1fZmluZF9wYW5lbChyZW1vdGVfbm9kZSk7 Ci0JCW9mX25vZGVfcHV0KHJlbW90ZV9ub2RlKTsKLQkJaWYgKCFkc2ktPmJyaWRnZSAmJiAhZHNp LT5wYW5lbCkgewotCQkJZGV2X2luZm8oZGV2LCAiV2FpdGluZyBmb3IgYnJpZGdlIG9yIHBhbmVs IGRyaXZlclxuIik7Ci0JCQlyZXR1cm4gLUVQUk9CRV9ERUZFUjsKLQkJfQotCX0KKwlyZXQgPSBk cm1fb2ZfZmluZF9wYW5lbF9vcl9icmlkZ2UoZGV2LT5vZl9ub2RlLCAwLCAwLAorCQkJCQkgICZk c2ktPnBhbmVsLCAmZHNpLT5icmlkZ2UpOworCWlmIChyZXQpCisJCXJldHVybiByZXQ7CiAKIAlk c2ktPmVuZ2luZV9jbGsgPSBkZXZtX2Nsa19nZXQoZGV2LCAiZW5naW5lIik7CiAJaWYgKElTX0VS Uihkc2ktPmVuZ2luZV9jbGspKSB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vbXhzZmIv bXhzZmJfb3V0LmMgYi9kcml2ZXJzL2dwdS9kcm0vbXhzZmIvbXhzZmJfb3V0LmMKaW5kZXggYjhl ODE0MjJkNGUyLi5mN2Q3MjlhYTA5YmQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9teHNm Yi9teHNmYl9vdXQuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vbXhzZmIvbXhzZmJfb3V0LmMKQEAg LTE5LDYgKzE5LDcgQEAKICNpbmNsdWRlIDxkcm0vZHJtX2NydGNfaGVscGVyLmg+CiAjaW5jbHVk ZSA8ZHJtL2RybV9mYl9jbWFfaGVscGVyLmg+CiAjaW5jbHVkZSA8ZHJtL2RybV9nZW1fY21hX2hl bHBlci5oPgorI2luY2x1ZGUgPGRybS9kcm1fb2YuaD4KICNpbmNsdWRlIDxkcm0vZHJtX3BhbmVs Lmg+CiAjaW5jbHVkZSA8ZHJtL2RybV9wbGFuZV9oZWxwZXIuaD4KICNpbmNsdWRlIDxkcm0vZHJt X3NpbXBsZV9rbXNfaGVscGVyLmg+CkBAIC04MiwyMCArODMsMTUgQEAgc3RhdGljIGNvbnN0IHN0 cnVjdCBkcm1fY29ubmVjdG9yX2Z1bmNzIG14c2ZiX3BhbmVsX2Nvbm5lY3Rvcl9mdW5jcyA9IHsK IAkuYXRvbWljX2Rlc3Ryb3lfc3RhdGUJPSBkcm1fYXRvbWljX2hlbHBlcl9jb25uZWN0b3JfZGVz dHJveV9zdGF0ZSwKIH07CiAKLXN0YXRpYyBpbnQgbXhzZmJfYXR0YWNoX2VuZHBvaW50KHN0cnVj dCBkcm1fZGV2aWNlICpkcm0sCi0JCQkJIGNvbnN0IHN0cnVjdCBvZl9lbmRwb2ludCAqZXApCitp bnQgbXhzZmJfY3JlYXRlX291dHB1dChzdHJ1Y3QgZHJtX2RldmljZSAqZHJtKQogewogCXN0cnVj dCBteHNmYl9kcm1fcHJpdmF0ZSAqbXhzZmIgPSBkcm0tPmRldl9wcml2YXRlOwotCXN0cnVjdCBk ZXZpY2Vfbm9kZSAqbnA7CiAJc3RydWN0IGRybV9wYW5lbCAqcGFuZWw7Ci0JaW50IHJldCA9IC1F UFJPQkVfREVGRVI7Ci0KLQlucCA9IG9mX2dyYXBoX2dldF9yZW1vdGVfcG9ydF9wYXJlbnQoZXAt PmxvY2FsX25vZGUpOwotCXBhbmVsID0gb2ZfZHJtX2ZpbmRfcGFuZWwobnApOwotCW9mX25vZGVf cHV0KG5wKTsKKwlpbnQgcmV0OwogCi0JaWYgKCFwYW5lbCkKLQkJcmV0dXJuIC1FUFJPQkVfREVG RVI7CisJcmV0ID0gZHJtX29mX2ZpbmRfcGFuZWxfb3JfYnJpZGdlKGRybS0+ZGV2LT5vZl9ub2Rl LCAwLCAwLCAmcGFuZWwsIE5VTEwpOworCWlmIChyZXQpCisJCXJldHVybiByZXQ7CiAKIAlteHNm Yi0+Y29ubmVjdG9yLmRwbXMgPSBEUk1fTU9ERV9EUE1TX09GRjsKIAlteHNmYi0+Y29ubmVjdG9y LnBvbGxlZCA9IDA7CkBAIC0xMDksMjcgKzEwNSwzIEBAIHN0YXRpYyBpbnQgbXhzZmJfYXR0YWNo X2VuZHBvaW50KHN0cnVjdCBkcm1fZGV2aWNlICpkcm0sCiAKIAlyZXR1cm4gcmV0OwogfQotCi1p bnQgbXhzZmJfY3JlYXRlX291dHB1dChzdHJ1Y3QgZHJtX2RldmljZSAqZHJtKQotewotCXN0cnVj dCBteHNmYl9kcm1fcHJpdmF0ZSAqbXhzZmIgPSBkcm0tPmRldl9wcml2YXRlOwotCXN0cnVjdCBk ZXZpY2Vfbm9kZSAqZXBfbnAgPSBOVUxMOwotCXN0cnVjdCBvZl9lbmRwb2ludCBlcDsKLQlpbnQg cmV0OwotCi0JZm9yX2VhY2hfZW5kcG9pbnRfb2Zfbm9kZShkcm0tPmRldi0+b2Zfbm9kZSwgZXBf bnApIHsKLQkJcmV0ID0gb2ZfZ3JhcGhfcGFyc2VfZW5kcG9pbnQoZXBfbnAsICZlcCk7Ci0JCWlm ICghcmV0KQotCQkJcmV0ID0gbXhzZmJfYXR0YWNoX2VuZHBvaW50KGRybSwgJmVwKTsKLQotCQlp ZiAocmV0KSB7Ci0JCQlvZl9ub2RlX3B1dChlcF9ucCk7Ci0JCQlyZXR1cm4gcmV0OwotCQl9Ci0J fQotCi0JaWYgKCFteHNmYi0+cGFuZWwpCi0JCXJldHVybiAtRVBST0JFX0RFRkVSOwotCi0JcmV0 dXJuIDA7Ci19CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcm9ja2NoaXAvYW5hbG9naXhf ZHAtcm9ja2NoaXAuYyBiL2RyaXZlcnMvZ3B1L2RybS9yb2NrY2hpcC9hbmFsb2dpeF9kcC1yb2Nr Y2hpcC5jCmluZGV4IDg1NDhlODI3MTYzOS4uNjE1YWZhZDI4MGE4IDEwMDY0NAotLS0gYS9kcml2 ZXJzL2dwdS9kcm0vcm9ja2NoaXAvYW5hbG9naXhfZHAtcm9ja2NoaXAuYworKysgYi9kcml2ZXJz L2dwdS9kcm0vcm9ja2NoaXAvYW5hbG9naXhfZHAtcm9ja2NoaXAuYwpAQCAtNDI4LDMxICs0Mjgs MTMgQEAgc3RhdGljIGNvbnN0IHN0cnVjdCBjb21wb25lbnRfb3BzIHJvY2tjaGlwX2RwX2NvbXBv bmVudF9vcHMgPSB7CiBzdGF0aWMgaW50IHJvY2tjaGlwX2RwX3Byb2JlKHN0cnVjdCBwbGF0Zm9y bV9kZXZpY2UgKnBkZXYpCiB7CiAJc3RydWN0IGRldmljZSAqZGV2ID0gJnBkZXYtPmRldjsKLQlz dHJ1Y3QgZGV2aWNlX25vZGUgKnBhbmVsX25vZGUsICpwb3J0LCAqZW5kcG9pbnQ7CiAJc3RydWN0 IGRybV9wYW5lbCAqcGFuZWwgPSBOVUxMOwogCXN0cnVjdCByb2NrY2hpcF9kcF9kZXZpY2UgKmRw OworCWludCByZXQ7CiAKLQlwb3J0ID0gb2ZfZ3JhcGhfZ2V0X3BvcnRfYnlfaWQoZGV2LT5vZl9u b2RlLCAxKTsKLQlpZiAocG9ydCkgewotCQllbmRwb2ludCA9IG9mX2dldF9jaGlsZF9ieV9uYW1l KHBvcnQsICJlbmRwb2ludCIpOwotCQlvZl9ub2RlX3B1dChwb3J0KTsKLQkJaWYgKCFlbmRwb2lu dCkgewotCQkJZGV2X2VycihkZXYsICJubyBvdXRwdXQgZW5kcG9pbnQgZm91bmRcbiIpOwotCQkJ cmV0dXJuIC1FSU5WQUw7Ci0JCX0KLQotCQlwYW5lbF9ub2RlID0gb2ZfZ3JhcGhfZ2V0X3JlbW90 ZV9wb3J0X3BhcmVudChlbmRwb2ludCk7Ci0JCW9mX25vZGVfcHV0KGVuZHBvaW50KTsKLQkJaWYg KCFwYW5lbF9ub2RlKSB7Ci0JCQlkZXZfZXJyKGRldiwgIm5vIG91dHB1dCBub2RlIGZvdW5kXG4i KTsKLQkJCXJldHVybiAtRUlOVkFMOwotCQl9Ci0KLQkJcGFuZWwgPSBvZl9kcm1fZmluZF9wYW5l bChwYW5lbF9ub2RlKTsKLQkJb2Zfbm9kZV9wdXQocGFuZWxfbm9kZSk7Ci0JCWlmICghcGFuZWwp Ci0JCQlyZXR1cm4gLUVQUk9CRV9ERUZFUjsKLQl9CisJcmV0ID0gZHJtX29mX2ZpbmRfcGFuZWxf b3JfYnJpZGdlKGRldi0+b2Zfbm9kZSwgMSwgMCwgJnBhbmVsLCBOVUxMKTsKKwlpZiAocmV0KQor CQlyZXR1cm4gcmV0OwogCiAJZHAgPSBkZXZtX2t6YWxsb2MoZGV2LCBzaXplb2YoKmRwKSwgR0ZQ X0tFUk5FTCk7CiAJaWYgKCFkcCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9zdW40aS9z dW40aV9yZ2IuYyBiL2RyaXZlcnMvZ3B1L2RybS9zdW40aS9zdW40aV9yZ2IuYwppbmRleCA3NTcy MDhmNTE3MzEuLjQ2MjgwZGQ3MGM5ZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3N1bjRp L3N1bjRpX3JnYi5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9zdW40aS9zdW40aV9yZ2IuYwpAQCAt MTUsNiArMTUsNyBAQAogI2luY2x1ZGUgPGRybS9kcm1QLmg+CiAjaW5jbHVkZSA8ZHJtL2RybV9h dG9taWNfaGVscGVyLmg+CiAjaW5jbHVkZSA8ZHJtL2RybV9jcnRjX2hlbHBlci5oPgorI2luY2x1 ZGUgPGRybS9kcm1fb2YuaD4KICNpbmNsdWRlIDxkcm0vZHJtX3BhbmVsLmg+CiAKICNpbmNsdWRl ICJzdW40aV9kcnYuaCIKQEAgLTIxOCw5ICsyMTksOSBAQCBpbnQgc3VuNGlfcmdiX2luaXQoc3Ry dWN0IGRybV9kZXZpY2UgKmRybSkKIAlyZ2ItPmRydiA9IGRydjsKIAllbmNvZGVyID0gJnJnYi0+ ZW5jb2RlcjsKIAotCXRjb24tPnBhbmVsID0gc3VuNGlfdGNvbl9maW5kX3BhbmVsKHRjb24tPmRl di0+b2Zfbm9kZSk7Ci0JYnJpZGdlID0gc3VuNGlfdGNvbl9maW5kX2JyaWRnZSh0Y29uLT5kZXYt Pm9mX25vZGUpOwotCWlmIChJU19FUlIodGNvbi0+cGFuZWwpICYmIElTX0VSUihicmlkZ2UpKSB7 CisJcmV0ID0gZHJtX29mX2ZpbmRfcGFuZWxfb3JfYnJpZGdlKHRjb24tPmRldi0+b2Zfbm9kZSwg MSwgMCwKKwkJCQkJICAmdGNvbi0+cGFuZWwsICZicmlkZ2UpOworCWlmIChyZXQpIHsKIAkJZGV2 X2luZm8oZHJtLT5kZXYsICJObyBwYW5lbCBvciBicmlkZ2UgZm91bmQuLi4gUkdCIG91dHB1dCBk aXNhYmxlZFxuIik7CiAJCXJldHVybiAwOwogCX0KQEAgLTI0MCw3ICsyNDEsNyBAQCBpbnQgc3Vu NGlfcmdiX2luaXQoc3RydWN0IGRybV9kZXZpY2UgKmRybSkKIAkvKiBUaGUgUkdCIGVuY29kZXIg Y2FuIG9ubHkgd29yayB3aXRoIHRoZSBUQ09OIGNoYW5uZWwgMCAqLwogCXJnYi0+ZW5jb2Rlci5w b3NzaWJsZV9jcnRjcyA9IEJJVCgwKTsKIAotCWlmICghSVNfRVJSKHRjb24tPnBhbmVsKSkgewor CWlmICh0Y29uLT5wYW5lbCkgewogCQlkcm1fY29ubmVjdG9yX2hlbHBlcl9hZGQoJnJnYi0+Y29u bmVjdG9yLAogCQkJCQkgJnN1bjRpX3JnYl9jb25faGVscGVyX2Z1bmNzKTsKIAkJcmV0ID0gZHJt X2Nvbm5lY3Rvcl9pbml0KGRybSwgJnJnYi0+Y29ubmVjdG9yLApAQCAtMjYxLDcgKzI2Miw3IEBA IGludCBzdW40aV9yZ2JfaW5pdChzdHJ1Y3QgZHJtX2RldmljZSAqZHJtKQogCQl9CiAJfQogCi0J aWYgKCFJU19FUlIoYnJpZGdlKSkgeworCWlmIChicmlkZ2UpIHsKIAkJcmV0ID0gZHJtX2JyaWRn ZV9hdHRhY2goZW5jb2RlciwgYnJpZGdlLCBOVUxMKTsKIAkJaWYgKHJldCkgewogCQkJZGV2X2Vy cihkcm0tPmRldiwgIkNvdWxkbid0IGF0dGFjaCBvdXIgYnJpZGdlXG4iKTsKZGlmZiAtLWdpdCBh L2RyaXZlcnMvZ3B1L2RybS9zdW40aS9zdW40aV90Y29uLmMgYi9kcml2ZXJzL2dwdS9kcm0vc3Vu NGkvc3VuNGlfdGNvbi5jCmluZGV4IGVhMjkwNmY4N2NiOS4uMmU0ZTM2NWNlY2Y5IDEwMDY0NAot LS0gYS9kcml2ZXJzL2dwdS9kcm0vc3VuNGkvc3VuNGlfdGNvbi5jCisrKyBiL2RyaXZlcnMvZ3B1 L2RybS9zdW40aS9zdW40aV90Y29uLmMKQEAgLTE1LDEzICsxNSwxMiBAQAogI2luY2x1ZGUgPGRy bS9kcm1fY3J0Yy5oPgogI2luY2x1ZGUgPGRybS9kcm1fY3J0Y19oZWxwZXIuaD4KICNpbmNsdWRl IDxkcm0vZHJtX21vZGVzLmg+Ci0jaW5jbHVkZSA8ZHJtL2RybV9wYW5lbC5oPgorI2luY2x1ZGUg PGRybS9kcm1fb2YuaD4KIAogI2luY2x1ZGUgPGxpbnV4L2NvbXBvbmVudC5oPgogI2luY2x1ZGUg PGxpbnV4L2lvcG9ydC5oPgogI2luY2x1ZGUgPGxpbnV4L29mX2FkZHJlc3MuaD4KICNpbmNsdWRl IDxsaW51eC9vZl9kZXZpY2UuaD4KLSNpbmNsdWRlIDxsaW51eC9vZl9ncmFwaC5oPgogI2luY2x1 ZGUgPGxpbnV4L29mX2lycS5oPgogI2luY2x1ZGUgPGxpbnV4L3JlZ21hcC5oPgogI2luY2x1ZGUg PGxpbnV4L3Jlc2V0Lmg+CkBAIC00MDUsNzQgKzQwNCw2IEBAIHN0YXRpYyBpbnQgc3VuNGlfdGNv bl9pbml0X3JlZ21hcChzdHJ1Y3QgZGV2aWNlICpkZXYsCiAJcmV0dXJuIDA7CiB9CiAKLXN0cnVj dCBkcm1fcGFuZWwgKnN1bjRpX3Rjb25fZmluZF9wYW5lbChzdHJ1Y3QgZGV2aWNlX25vZGUgKm5v ZGUpCi17Ci0Jc3RydWN0IGRldmljZV9ub2RlICpwb3J0LCAqcmVtb3RlLCAqY2hpbGQ7Ci0Jc3Ry dWN0IGRldmljZV9ub2RlICplbmRfbm9kZSA9IE5VTEw7Ci0KLQkvKiBJbnB1dHMgYXJlIGxpc3Rl ZCBmaXJzdCwgdGhlbiBvdXRwdXRzICovCi0JcG9ydCA9IG9mX2dyYXBoX2dldF9wb3J0X2J5X2lk KG5vZGUsIDEpOwotCi0JLyoKLQkgKiBPdXIgZmlyc3Qgb3V0cHV0IGlzIHRoZSBSR0IgaW50ZXJm YWNlIHdoZXJlIHRoZSBwYW5lbCB3aWxsCi0JICogYmUgY29ubmVjdGVkLgotCSAqLwotCWZvcl9l YWNoX2NoaWxkX29mX25vZGUocG9ydCwgY2hpbGQpIHsKLQkJdTMyIHJlZzsKLQotCQlvZl9wcm9w ZXJ0eV9yZWFkX3UzMihjaGlsZCwgInJlZyIsICZyZWcpOwotCQlpZiAocmVnID09IDApCi0JCQll bmRfbm9kZSA9IGNoaWxkOwotCX0KLQotCWlmICghZW5kX25vZGUpIHsKLQkJRFJNX0RFQlVHX0RS SVZFUigiTWlzc2luZyBwYW5lbCBlbmRwb2ludFxuIik7Ci0JCXJldHVybiBFUlJfUFRSKC1FTk9E RVYpOwotCX0KLQotCXJlbW90ZSA9IG9mX2dyYXBoX2dldF9yZW1vdGVfcG9ydF9wYXJlbnQoZW5k X25vZGUpOwotCWlmICghcmVtb3RlKSB7Ci0JCURSTV9ERUJVR19EUklWRVIoIlVuYWJsZSB0byBw YXJzZSByZW1vdGUgbm9kZVxuIik7Ci0JCXJldHVybiBFUlJfUFRSKC1FSU5WQUwpOwotCX0KLQot CXJldHVybiBvZl9kcm1fZmluZF9wYW5lbChyZW1vdGUpID86IEVSUl9QVFIoLUVQUk9CRV9ERUZF Uik7Ci19Ci0KLXN0cnVjdCBkcm1fYnJpZGdlICpzdW40aV90Y29uX2ZpbmRfYnJpZGdlKHN0cnVj dCBkZXZpY2Vfbm9kZSAqbm9kZSkKLXsKLQlzdHJ1Y3QgZGV2aWNlX25vZGUgKnBvcnQsICpyZW1v dGUsICpjaGlsZDsKLQlzdHJ1Y3QgZGV2aWNlX25vZGUgKmVuZF9ub2RlID0gTlVMTDsKLQotCS8q IElucHV0cyBhcmUgbGlzdGVkIGZpcnN0LCB0aGVuIG91dHB1dHMgKi8KLQlwb3J0ID0gb2ZfZ3Jh cGhfZ2V0X3BvcnRfYnlfaWQobm9kZSwgMSk7Ci0KLQkvKgotCSAqIE91ciBmaXJzdCBvdXRwdXQg aXMgdGhlIFJHQiBpbnRlcmZhY2Ugd2hlcmUgdGhlIHBhbmVsIHdpbGwKLQkgKiBiZSBjb25uZWN0 ZWQuCi0JICovCi0JZm9yX2VhY2hfY2hpbGRfb2Zfbm9kZShwb3J0LCBjaGlsZCkgewotCQl1MzIg cmVnOwotCi0JCW9mX3Byb3BlcnR5X3JlYWRfdTMyKGNoaWxkLCAicmVnIiwgJnJlZyk7Ci0JCWlm IChyZWcgPT0gMCkKLQkJCWVuZF9ub2RlID0gY2hpbGQ7Ci0JfQotCi0JaWYgKCFlbmRfbm9kZSkg ewotCQlEUk1fREVCVUdfRFJJVkVSKCJNaXNzaW5nIGJyaWRnZSBlbmRwb2ludFxuIik7Ci0JCXJl dHVybiBFUlJfUFRSKC1FTk9ERVYpOwotCX0KLQotCXJlbW90ZSA9IG9mX2dyYXBoX2dldF9yZW1v dGVfcG9ydF9wYXJlbnQoZW5kX25vZGUpOwotCWlmICghcmVtb3RlKSB7Ci0JCURSTV9ERUJVR19E UklWRVIoIkVuYWJsZSB0byBwYXJzZSByZW1vdGUgbm9kZVxuIik7Ci0JCXJldHVybiBFUlJfUFRS KC1FSU5WQUwpOwotCX0KLQotCXJldHVybiBvZl9kcm1fZmluZF9icmlkZ2UocmVtb3RlKSA/OiBF UlJfUFRSKC1FUFJPQkVfREVGRVIpOwotfQotCiBzdGF0aWMgaW50IHN1bjRpX3Rjb25fYmluZChz dHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2UgKm1hc3RlciwKIAkJCSAgIHZvaWQgKmRh dGEpCiB7CkBAIC01NTUsMjIgKzQ4NiwxMSBAQCBzdGF0aWMgaW50IHN1bjRpX3Rjb25fcHJvYmUo c3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKIAlzdHJ1Y3QgZGV2aWNlX25vZGUgKm5vZGUg PSBwZGV2LT5kZXYub2Zfbm9kZTsKIAlzdHJ1Y3QgZHJtX2JyaWRnZSAqYnJpZGdlOwogCXN0cnVj dCBkcm1fcGFuZWwgKnBhbmVsOworCWludCByZXQ7CiAKLQkvKgotCSAqIE5laXRoZXIgdGhlIGJy aWRnZSBvciB0aGUgcGFuZWwgaXMgcmVhZHkuCi0JICogRGVmZXIgdGhlIHByb2JlLgotCSAqLwot CXBhbmVsID0gc3VuNGlfdGNvbl9maW5kX3BhbmVsKG5vZGUpOwotCWJyaWRnZSA9IHN1bjRpX3Rj b25fZmluZF9icmlkZ2Uobm9kZSk7Ci0KLQkvKgotCSAqIElmIHdlIGRvbid0IGhhdmUgYSBwYW5l bCBlbmRwb2ludCwganVzdCBnbyBvbgotCSAqLwotCWlmICgoUFRSX0VSUihwYW5lbCkgPT0gLUVQ Uk9CRV9ERUZFUikgJiYKLQkgICAgKFBUUl9FUlIoYnJpZGdlKSA9PSAtRVBST0JFX0RFRkVSKSkg ewotCQlEUk1fREVCVUdfRFJJVkVSKCJTdGlsbCB3YWl0aW5nIGZvciBvdXIgcGFuZWwvYnJpZGdl LiBEZWZlcnJpbmcuLi5cbiIpOwotCQlyZXR1cm4gLUVQUk9CRV9ERUZFUjsKLQl9CisJcmV0ID0g ZHJtX29mX2ZpbmRfcGFuZWxfb3JfYnJpZGdlKG5vZGUsIDEsIDAsICZwYW5lbCwgJmJyaWRnZSk7 CisJaWYgKHJldCA9PSAtRVBST0JFX0RFRkVSKQorCQlyZXR1cm4gcmV0OwogCiAJcmV0dXJuIGNv bXBvbmVudF9hZGQoJnBkZXYtPmRldiwgJnN1bjRpX3Rjb25fb3BzKTsKIH0KLS0gCjIuMTAuMQoK X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVs IG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlz dHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVsCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1754280AbdC2S4O (ORCPT ); Wed, 29 Mar 2017 14:56:14 -0400 Received: from mail-oi0-f67.google.com ([209.85.218.67]:36046 "EHLO mail-oi0-f67.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752138AbdC2S4K (ORCPT ); Wed, 29 Mar 2017 14:56:10 -0400 From: Rob Herring To: Sean Paul Cc: David Airlie , Daniel Vetter , dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org, Boris Brezillon , Archit Taneja , Jingoo Han , Inki Dae , Joonyoung Shim , Seung-Woo Kim , Kyungmin Park , Kukjin Kim , Krzysztof Kozlowski , Javier Martinez Canillas , Stefan Agner , Alison Wang , Xinliang Liu , Rongrong Zou , Xinwei Kong , Chen Feng , Philipp Zabel , CK Hu , Matthias Brugger , Marek Vasut , Mark Yao , Heiko Stuebner , Maxime Ripard , Chen-Yu Tsai , Liviu Dudau , Mali DP Maintainers , Neil Armstrong , Carlo Caione , Kevin Hilman , Rob Clark , Jyri Sarha , Tomi Valkeinen , Eric Anholt , Russell King Subject: [PATCH v4 4/5] drm: convert drivers to use drm_of_find_panel_or_bridge Date: Wed, 29 Mar 2017 13:55:46 -0500 Message-Id: <20170329185546.11667-1-robh@kernel.org> X-Mailer: git-send-email 2.10.1 In-Reply-To: <20170322132608.17353-5-robh@kernel.org> Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Similar to the previous commit, convert drivers open coding OF graph parsing to use drm_of_find_panel_or_bridge instead. This changes some error messages to debug messages (in the graph core). Graph connections are often "no connects" depending on the particular board, so we want to avoid spurious messages. Plus the kernel is not a DT validator. Signed-off-by: Rob Herring Reviewed-by: Archit Taneja Tested-by: Philipp Zabel Acked-by: Maxime Ripard --- Sean, I fixed the compile error on FSL DCU. Let me know if you want me to send the whole series again. Rob drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_output.c | 73 ++++++------------- drivers/gpu/drm/bridge/nxp-ptn3460.c | 16 ++--- drivers/gpu/drm/bridge/parade-ps8622.c | 16 ++--- drivers/gpu/drm/bridge/tc358767.c | 27 +------ drivers/gpu/drm/exynos/exynos_dp.c | 35 ++++----- drivers/gpu/drm/fsl-dcu/fsl_dcu_drm_rgb.c | 44 ++++-------- drivers/gpu/drm/hisilicon/kirin/dw_drm_dsi.c | 27 ++----- drivers/gpu/drm/imx/imx-ldb.c | 27 ++----- drivers/gpu/drm/imx/parallel-display.c | 36 ++-------- drivers/gpu/drm/mediatek/mtk_dsi.c | 23 ++---- drivers/gpu/drm/mxsfb/mxsfb_out.c | 40 ++--------- drivers/gpu/drm/rockchip/analogix_dp-rockchip.c | 26 ++----- drivers/gpu/drm/sun4i/sun4i_rgb.c | 11 +-- drivers/gpu/drm/sun4i/sun4i_tcon.c | 90 ++---------------------- 14 files changed, 95 insertions(+), 396 deletions(-) diff --git a/drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_output.c b/drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_output.c index e7799b6ee829..f987b4572d4a 100644 --- a/drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_output.c +++ b/drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_output.c @@ -22,7 +22,7 @@ #include #include -#include +#include #include "atmel_hlcdc_dc.h" @@ -152,29 +152,11 @@ static const struct drm_connector_funcs atmel_hlcdc_panel_connector_funcs = { .atomic_destroy_state = drm_atomic_helper_connector_destroy_state, }; -static int atmel_hlcdc_check_endpoint(struct drm_device *dev, - const struct of_endpoint *ep) -{ - struct device_node *np; - void *obj; - - np = of_graph_get_remote_port_parent(ep->local_node); - - obj = of_drm_find_panel(np); - if (!obj) - obj = of_drm_find_bridge(np); - - of_node_put(np); - - return obj ? 0 : -EPROBE_DEFER; -} - static int atmel_hlcdc_attach_endpoint(struct drm_device *dev, - const struct of_endpoint *ep) + const struct device_node *np) { struct atmel_hlcdc_dc *dc = dev->dev_private; struct atmel_hlcdc_rgb_output *output; - struct device_node *np; struct drm_panel *panel; struct drm_bridge *bridge; int ret; @@ -195,13 +177,11 @@ static int atmel_hlcdc_attach_endpoint(struct drm_device *dev, output->encoder.possible_crtcs = 0x1; - np = of_graph_get_remote_port_parent(ep->local_node); - - ret = -EPROBE_DEFER; + ret = drm_of_find_panel_or_bridge(np, 0, 0, &panel, &bridge); + if (ret) + return ret; - panel = of_drm_find_panel(np); if (panel) { - of_node_put(np); output->connector.dpms = DRM_MODE_DPMS_OFF; output->connector.polled = DRM_CONNECTOR_POLL_CONNECT; drm_connector_helper_add(&output->connector, @@ -226,9 +206,6 @@ static int atmel_hlcdc_attach_endpoint(struct drm_device *dev, return 0; } - bridge = of_drm_find_bridge(np); - of_node_put(np); - if (bridge) { ret = drm_bridge_attach(&output->encoder, bridge, NULL); if (!ret) @@ -243,31 +220,23 @@ static int atmel_hlcdc_attach_endpoint(struct drm_device *dev, int atmel_hlcdc_create_outputs(struct drm_device *dev) { - struct device_node *ep_np = NULL; - struct of_endpoint ep; - int ret; - - for_each_endpoint_of_node(dev->dev->of_node, ep_np) { - ret = of_graph_parse_endpoint(ep_np, &ep); - if (!ret) - ret = atmel_hlcdc_check_endpoint(dev, &ep); - - if (ret) { - of_node_put(ep_np); - return ret; - } - } - - for_each_endpoint_of_node(dev->dev->of_node, ep_np) { - ret = of_graph_parse_endpoint(ep_np, &ep); - if (!ret) - ret = atmel_hlcdc_attach_endpoint(dev, &ep); - - if (ret) { - of_node_put(ep_np); + struct device_node *remote; + int ret, endpoint = 0; + + while (true) { + /* Loop thru possible multiple connections to the output */ + remote = of_graph_get_remote_node(dev->dev->of_node, 0, + endpoint++); + if (!remote) + break; + + ret = atmel_hlcdc_attach_endpoint(dev, remote); + of_node_put(remote); + if (ret) return ret; - } } - return 0; + if (!endpoint) + return -ENODEV; + return ret; } diff --git a/drivers/gpu/drm/bridge/nxp-ptn3460.c b/drivers/gpu/drm/bridge/nxp-ptn3460.c index 27f98c518dde..351704390d02 100644 --- a/drivers/gpu/drm/bridge/nxp-ptn3460.c +++ b/drivers/gpu/drm/bridge/nxp-ptn3460.c @@ -20,8 +20,8 @@ #include #include #include -#include +#include #include #include "drm_crtc.h" @@ -292,7 +292,6 @@ static int ptn3460_probe(struct i2c_client *client, { struct device *dev = &client->dev; struct ptn3460_bridge *ptn_bridge; - struct device_node *endpoint, *panel_node; int ret; ptn_bridge = devm_kzalloc(dev, sizeof(*ptn_bridge), GFP_KERNEL); @@ -300,16 +299,9 @@ static int ptn3460_probe(struct i2c_client *client, return -ENOMEM; } - endpoint = of_graph_get_next_endpoint(dev->of_node, NULL); - if (endpoint) { - panel_node = of_graph_get_remote_port_parent(endpoint); - if (panel_node) { - ptn_bridge->panel = of_drm_find_panel(panel_node); - of_node_put(panel_node); - if (!ptn_bridge->panel) - return -EPROBE_DEFER; - } - } + ret = drm_of_find_panel_or_bridge(dev->of_node, 0, 0, &ptn_bridge->panel, NULL); + if (ret) + return ret; ptn_bridge->client = client; diff --git a/drivers/gpu/drm/bridge/parade-ps8622.c b/drivers/gpu/drm/bridge/parade-ps8622.c index ac8cc5b50d9f..1dcec3b97e67 100644 --- a/drivers/gpu/drm/bridge/parade-ps8622.c +++ b/drivers/gpu/drm/bridge/parade-ps8622.c @@ -22,10 +22,10 @@ #include #include #include -#include #include #include +#include #include #include "drmP.h" @@ -536,7 +536,6 @@ static int ps8622_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct device *dev = &client->dev; - struct device_node *endpoint, *panel_node; struct ps8622_bridge *ps8622; int ret; @@ -544,16 +543,9 @@ static int ps8622_probe(struct i2c_client *client, if (!ps8622) return -ENOMEM; - endpoint = of_graph_get_next_endpoint(dev->of_node, NULL); - if (endpoint) { - panel_node = of_graph_get_remote_port_parent(endpoint); - if (panel_node) { - ps8622->panel = of_drm_find_panel(panel_node); - of_node_put(panel_node); - if (!ps8622->panel) - return -EPROBE_DEFER; - } - } + ret = drm_of_find_panel_or_bridge(dev->of_node, 0, 0, &ps8622->panel, NULL); + if (ret) + return ret; ps8622->client = client; diff --git a/drivers/gpu/drm/bridge/tc358767.c b/drivers/gpu/drm/bridge/tc358767.c index de9ffb49e9f6..5c26488e7a2d 100644 --- a/drivers/gpu/drm/bridge/tc358767.c +++ b/drivers/gpu/drm/bridge/tc358767.c @@ -1244,7 +1244,6 @@ static const struct regmap_config tc_regmap_config = { static int tc_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct device *dev = &client->dev; - struct device_node *ep; struct tc_data *tc; int ret; @@ -1255,29 +1254,9 @@ static int tc_probe(struct i2c_client *client, const struct i2c_device_id *id) tc->dev = dev; /* port@2 is the output port */ - ep = of_graph_get_endpoint_by_regs(dev->of_node, 2, -1); - if (ep) { - struct device_node *remote; - - remote = of_graph_get_remote_port_parent(ep); - if (!remote) { - dev_warn(dev, "endpoint %s not connected\n", - ep->full_name); - of_node_put(ep); - return -ENODEV; - } - of_node_put(ep); - tc->panel = of_drm_find_panel(remote); - if (tc->panel) { - dev_dbg(dev, "found panel %s\n", remote->full_name); - } else { - dev_dbg(dev, "waiting for panel %s\n", - remote->full_name); - of_node_put(remote); - return -EPROBE_DEFER; - } - of_node_put(remote); - } + ret = drm_of_find_panel_or_bridge(dev->of_node, 2, 0, &tc->panel, NULL); + if (ret) + return ret; /* Shut down GPIO is optional */ tc->sd_gpio = devm_gpiod_get_optional(dev, "shutdown", GPIOD_OUT_HIGH); diff --git a/drivers/gpu/drm/exynos/exynos_dp.c b/drivers/gpu/drm/exynos/exynos_dp.c index 1ef0be338b85..a269f439e742 100644 --- a/drivers/gpu/drm/exynos/exynos_dp.c +++ b/drivers/gpu/drm/exynos/exynos_dp.c @@ -23,6 +23,7 @@ #include #include #include +#include #include #include @@ -212,8 +213,11 @@ static const struct component_ops exynos_dp_ops = { static int exynos_dp_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; - struct device_node *np = NULL, *endpoint = NULL; + struct device_node *np; struct exynos_dp_device *dp; + struct drm_panel *panel; + struct drm_bridge *bridge; + int ret; dp = devm_kzalloc(&pdev->dev, sizeof(struct exynos_dp_device), GFP_KERNEL); @@ -237,28 +241,13 @@ static int exynos_dp_probe(struct platform_device *pdev) goto out; } - endpoint = of_graph_get_next_endpoint(dev->of_node, NULL); - if (endpoint) { - np = of_graph_get_remote_port_parent(endpoint); - if (np) { - /* The remote port can be either a panel or a bridge */ - dp->plat_data.panel = of_drm_find_panel(np); - if (!dp->plat_data.panel) { - dp->ptn_bridge = of_drm_find_bridge(np); - if (!dp->ptn_bridge) { - of_node_put(np); - return -EPROBE_DEFER; - } - } - of_node_put(np); - } else { - DRM_ERROR("no remote endpoint device node found.\n"); - return -EINVAL; - } - } else { - DRM_ERROR("no port endpoint subnode found.\n"); - return -EINVAL; - } + ret = drm_of_find_panel_or_bridge(dev->of_node, 0, 0, &panel, &bridge); + if (ret) + return ret; + + /* The remote port can be either a panel or a bridge */ + dp->plat_data.panel = panel; + dp->ptn_bridge = bridge; out: return component_add(&pdev->dev, &exynos_dp_ops); diff --git a/drivers/gpu/drm/fsl-dcu/fsl_dcu_drm_rgb.c b/drivers/gpu/drm/fsl-dcu/fsl_dcu_drm_rgb.c index c3651456c963..dcbf3c06e1d8 100644 --- a/drivers/gpu/drm/fsl-dcu/fsl_dcu_drm_rgb.c +++ b/drivers/gpu/drm/fsl-dcu/fsl_dcu_drm_rgb.c @@ -15,6 +15,7 @@ #include #include #include +#include #include #include "fsl_dcu_drm_drv.h" @@ -141,32 +142,11 @@ static int fsl_dcu_attach_panel(struct fsl_dcu_drm_device *fsl_dev, return ret; } -static int fsl_dcu_attach_endpoint(struct fsl_dcu_drm_device *fsl_dev, - const struct of_endpoint *ep) -{ - struct drm_bridge *bridge; - struct device_node *np; - - np = of_graph_get_remote_port_parent(ep->local_node); - - fsl_dev->connector.panel = of_drm_find_panel(np); - if (fsl_dev->connector.panel) { - of_node_put(np); - return fsl_dcu_attach_panel(fsl_dev, fsl_dev->connector.panel); - } - - bridge = of_drm_find_bridge(np); - of_node_put(np); - if (!bridge) - return -ENODEV; - - return drm_bridge_attach(&fsl_dev->encoder, bridge, NULL); -} - int fsl_dcu_create_outputs(struct fsl_dcu_drm_device *fsl_dev) { - struct of_endpoint ep; - struct device_node *ep_node, *panel_node; + struct device_node *panel_node; + struct drm_panel *panel; + struct drm_bridge *bridge; int ret; /* This is for backward compatibility */ @@ -179,14 +159,14 @@ int fsl_dcu_create_outputs(struct fsl_dcu_drm_device *fsl_dev) return fsl_dcu_attach_panel(fsl_dev, fsl_dev->connector.panel); } - ep_node = of_graph_get_next_endpoint(fsl_dev->np, NULL); - if (!ep_node) - return -ENODEV; - - ret = of_graph_parse_endpoint(ep_node, &ep); - of_node_put(ep_node); + ret = drm_of_find_panel_or_bridge(fsl_dev->np, 0, 0, &panel, &bridge); if (ret) - return -ENODEV; + return ret; + + if (panel) { + fsl_dev->connector.panel = panel; + return fsl_dcu_attach_panel(fsl_dev, panel); + } - return fsl_dcu_attach_endpoint(fsl_dev, &ep); + return drm_bridge_attach(&fsl_dev->encoder, bridge, NULL); } diff --git a/drivers/gpu/drm/hisilicon/kirin/dw_drm_dsi.c b/drivers/gpu/drm/hisilicon/kirin/dw_drm_dsi.c index 1737e98bc10a..5abc69c9630f 100644 --- a/drivers/gpu/drm/hisilicon/kirin/dw_drm_dsi.c +++ b/drivers/gpu/drm/hisilicon/kirin/dw_drm_dsi.c @@ -17,7 +17,6 @@ #include #include -#include #include #include @@ -754,34 +753,16 @@ static int dsi_parse_dt(struct platform_device *pdev, struct dw_dsi *dsi) { struct dsi_hw_ctx *ctx = dsi->ctx; struct device_node *np = pdev->dev.of_node; - struct device_node *endpoint, *bridge_node; - struct drm_bridge *bridge; struct resource *res; + int ret; /* * Get the endpoint node. In our case, dsi has one output port1 * to which the external HDMI bridge is connected. */ - endpoint = of_graph_get_endpoint_by_regs(np, 1, -1); - if (!endpoint) { - DRM_ERROR("no valid endpoint node\n"); - return -ENODEV; - } - of_node_put(endpoint); - - bridge_node = of_graph_get_remote_port_parent(endpoint); - if (!bridge_node) { - DRM_ERROR("no valid bridge node\n"); - return -ENODEV; - } - of_node_put(bridge_node); - - bridge = of_drm_find_bridge(bridge_node); - if (!bridge) { - DRM_INFO("wait for external HDMI bridge driver.\n"); - return -EPROBE_DEFER; - } - dsi->bridge = bridge; + ret = drm_of_find_panel_or_bridge(np, 0, 0, NULL, &dsi->bridge); + if (ret) + return ret; ctx->pclk = devm_clk_get(&pdev->dev, "pclk"); if (IS_ERR(ctx->pclk)) { diff --git a/drivers/gpu/drm/imx/imx-ldb.c b/drivers/gpu/drm/imx/imx-ldb.c index 88cd11d30134..8fb801fab039 100644 --- a/drivers/gpu/drm/imx/imx-ldb.c +++ b/drivers/gpu/drm/imx/imx-ldb.c @@ -647,7 +647,6 @@ static int imx_ldb_bind(struct device *dev, struct device *master, void *data) for_each_child_of_node(np, child) { struct imx_ldb_channel *channel; - struct device_node *ep; int bus_format; ret = of_property_read_u32(child, "reg", &i); @@ -671,27 +670,11 @@ static int imx_ldb_bind(struct device *dev, struct device *master, void *data) * The output port is port@4 with an external 4-port mux or * port@2 with the internal 2-port mux. */ - ep = of_graph_get_endpoint_by_regs(child, - imx_ldb->lvds_mux ? 4 : 2, - -1); - if (ep) { - struct device_node *remote; - - remote = of_graph_get_remote_port_parent(ep); - of_node_put(ep); - if (remote) { - channel->panel = of_drm_find_panel(remote); - channel->bridge = of_drm_find_bridge(remote); - } else - return -EPROBE_DEFER; - of_node_put(remote); - - if (!channel->panel && !channel->bridge) { - dev_err(dev, "panel/bridge not found: %s\n", - remote->full_name); - return -EPROBE_DEFER; - } - } + ret = drm_of_find_panel_or_bridge(child, + imx_ldb->lvds_mux ? 4 : 2, 0, + &channel->panel, &channel->bridge); + if (ret) + return ret; /* panel ddc only if there is no bridge */ if (!channel->bridge) { diff --git a/drivers/gpu/drm/imx/parallel-display.c b/drivers/gpu/drm/imx/parallel-display.c index d5c06fd89f90..636031a30e17 100644 --- a/drivers/gpu/drm/imx/parallel-display.c +++ b/drivers/gpu/drm/imx/parallel-display.c @@ -19,10 +19,10 @@ #include #include #include +#include #include #include #include