From mboxrd@z Thu Jan 1 00:00:00 1970 From: Eric Anholt Subject: [PATCH v3] drm/bridge: Refactor out the panel wrapper from the lvds-encoder bridge. Date: Fri, 2 Jun 2017 13:25:14 -0700 Message-ID: <20170602202514.11900-1-eric@anholt.net> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from anholt.net (anholt.net [50.246.234.109]) by gabe.freedesktop.org (Postfix) with ESMTP id 004226E3BF for ; Fri, 2 Jun 2017 20:26:14 +0000 (UTC) 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, Archit Taneja , Andrzej Hajda , Laurent Pinchart , Thierry Reding Cc: linux-kernel@vger.kernel.org List-Id: dri-devel@lists.freedesktop.org TWFueSBEUk0gZHJpdmVycyBoYXZlIGNvbW1vbiBjb2RlIHRvIG1ha2UgYSBzdHViIGNvbm5lY3Rv cgppbXBsZW1lbnRhdGlvbiB0aGF0IHdyYXBzIGEgZHJtX3BhbmVsLiAgQnkgd3JhcHBpbmcgdGhl IHBhbmVsIGluIGEgRFJNCmJyaWRnZSwgYWxsIG9mIHRoZSBjb25uZWN0b3IgY29kZSAoaW5jbHVk aW5nIGNhbGxzIGR1cmluZyBlbmNvZGVyCmVuYWJsZS9kaXNhYmxlKSBnb2VzIGF3YXkuCgp2Mjog Rml4IGJ1aWxkIHdpdGggQ09ORklHX0RSTT1tLCBkcm9wICJkZXYiIGFyZ3VtZW50IHRoYXQgc2hv dWxkIGp1c3QKICAgIGJlIHRoZSBwYW5lbCdzIGRldiwgbW92ZSBrZXJuZWxkb2MgdXAgYSBsZXZl bCBhbmQgZG9jdW1lbnQKICAgIF9yZW1vdmUoKS4KdjM6IEZpeCBhbm90aGVyIGJyZWFrYWdlIHdp dGggQ09ORklHX0RSTT1tLCBmaXggYnJlYWthZ2Ugd2l0aAogICAgQ09ORklHX09GPW4sIG1vdmUg cHJvdG9zIHVuZGVyIENPTkZJR19EUk1fUEFORUxfQlJJREdFLCB3cmFwIGEKICAgIGxpbmUuCgpT aWduZWQtb2ZmLWJ5OiBFcmljIEFuaG9sdCA8ZXJpY0BhbmhvbHQubmV0PgpBY2tlZC1ieTogRGFu aWVsIFZldHRlciA8ZGFuaWVsLnZldHRlckBmZndsbC5jaD4gKHYxKQpSZXZpZXdlZC1ieTogQm9y aXMgQnJlemlsbG9uIDxib3Jpcy5icmV6aWxsb25AZnJlZS1lbGVjdHJvbnMuY29tPiAodjIpCkFj a2VkLWJ5OiBBcmNoaXQgVGFuZWphIDxhcmNoaXR0QGNvZGVhdXJvcmEub3JnPiAodjIpCi0tLQoK TmV3IHZlcnNpb24gb2YgdGhlIGZpcnN0IHBhdGNoIHdpdGggYnVpbGQgZml4ZXMuICBJJ3ZlIHJl LXB1c2hlZCB0bwpnZXQgYW5vdGhlciByb3VuZCBvZiBrYnVpbGQgdGVzdCwgYnV0IGlmIGl0IGNv bWVzIGJhY2sgY2xlYW4sIEknZCBsaWtlCnRvIG1lcmdlIHRoaXMgb25lLCB0aGUgdmM0IHBhdGNo ZXMgKHVuY2hhbmdlZCksIGFuZCBhdG1lbC1obGNkYyAoYWNrZWQKYnkgdGhlIG1haW50YWluZXIp LiAgSSdkIGJlIGRyb3BwaW5nIG15IFNUTSBwYXRjaCAocmVwbGFjZWQgYnkgdGhlaXIKRFNJIHNl cmllcyksIGFuZCBtZWRpYXRlayAoSSdkIGxpa2UgYW4gYWNrIGZyb20gdGhlIG1haW50YWluZXIg Zmlyc3QpLgoKIERvY3VtZW50YXRpb24vZ3B1L2RybS1rbXMtaGVscGVycy5yc3QgfCAgIDYgKwog ZHJpdmVycy9ncHUvZHJtL01ha2VmaWxlICAgICAgICAgICAgICB8ICAgMSArCiBkcml2ZXJzL2dw dS9kcm0vYnJpZGdlL0tjb25maWcgICAgICAgIHwgIDExICstCiBkcml2ZXJzL2dwdS9kcm0vYnJp ZGdlL2x2ZHMtZW5jb2Rlci5jIHwgMTU3ICsrKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiBkcml2 ZXJzL2dwdS9kcm0vYnJpZGdlL3BhbmVsLmMgICAgICAgIHwgMjAwICsrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysKIGluY2x1ZGUvZHJtL2RybV9icmlkZ2UuaCAgICAgICAgICAgICAg fCAgIDcgKysKIDYgZmlsZXMgY2hhbmdlZCwgMjQxIGluc2VydGlvbnMoKyksIDE0MSBkZWxldGlv bnMoLSkKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2dwdS9kcm0vYnJpZGdlL3BhbmVsLmMK CmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2dwdS9kcm0ta21zLWhlbHBlcnMucnN0IGIvRG9j dW1lbnRhdGlvbi9ncHUvZHJtLWttcy1oZWxwZXJzLnJzdAppbmRleCBjMDc1YWFkZDcwNzguLjdj NWUyNTQ5YTU4YSAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9ncHUvZHJtLWttcy1oZWxwZXJz LnJzdAorKysgYi9Eb2N1bWVudGF0aW9uL2dwdS9kcm0ta21zLWhlbHBlcnMucnN0CkBAIC0xNDMs NiArMTQzLDEyIEBAIEJyaWRnZSBIZWxwZXIgUmVmZXJlbmNlCiAuLiBrZXJuZWwtZG9jOjogZHJp dmVycy9ncHUvZHJtL2RybV9icmlkZ2UuYwogICAgOmV4cG9ydDoKIAorUGFuZWwtQnJpZGdlIEhl bHBlciBSZWZlcmVuY2UKKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisKKy4uIGtlcm5l bC1kb2M6OiBkcml2ZXJzL2dwdS9kcm0vYnJpZGdlL3BhbmVsLmMKKyAgIDpleHBvcnQ6CisKIC4u IF9kcm1fcGFuZWxfaGVscGVyOgogCiBQYW5lbCBIZWxwZXIgUmVmZXJlbmNlCmRpZmYgLS1naXQg YS9kcml2ZXJzL2dwdS9kcm0vTWFrZWZpbGUgYi9kcml2ZXJzL2dwdS9kcm0vTWFrZWZpbGUKaW5k ZXggYWNjODg5NDJjMmU1Li5kYzY5MTc1MjU1YjEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2Ry bS9NYWtlZmlsZQorKysgYi9kcml2ZXJzL2dwdS9kcm0vTWFrZWZpbGUKQEAgLTI0LDYgKzI0LDcg QEAgZHJtLSQoQ09ORklHX0NPTVBBVCkgKz0gZHJtX2lvYzMyLm8KIGRybS0kKENPTkZJR19EUk1f R0VNX0NNQV9IRUxQRVIpICs9IGRybV9nZW1fY21hX2hlbHBlci5vCiBkcm0tJChDT05GSUdfUENJ KSArPSBhdGlfcGNpZ2FydC5vCiBkcm0tJChDT05GSUdfRFJNX1BBTkVMKSArPSBkcm1fcGFuZWwu bworZHJtLSQoQ09ORklHX0RSTV9QQU5FTF9CUklER0UpICs9IGJyaWRnZS9wYW5lbC5vCiBkcm0t JChDT05GSUdfT0YpICs9IGRybV9vZi5vCiBkcm0tJChDT05GSUdfQUdQKSArPSBkcm1fYWdwc3Vw cG9ydC5vCiBkcm0tJChDT05GSUdfREVCVUdfRlMpICs9IGRybV9kZWJ1Z2ZzLm8gZHJtX2RlYnVn ZnNfY3JjLm8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9icmlkZ2UvS2NvbmZpZyBiL2Ry aXZlcnMvZ3B1L2RybS9icmlkZ2UvS2NvbmZpZwppbmRleCBmNjk2OGQzYjRiNDEuLmFkZjlhZTBl MGI3YyAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2JyaWRnZS9LY29uZmlnCisrKyBiL2Ry aXZlcnMvZ3B1L2RybS9icmlkZ2UvS2NvbmZpZwpAQCAtNCw2ICs0LDE0IEBAIGNvbmZpZyBEUk1f QlJJREdFCiAJaGVscAogCSAgQnJpZGdlIHJlZ2lzdHJhdGlvbiBhbmQgbG9va3VwIGZyYW1ld29y ay4KIAorY29uZmlnIERSTV9QQU5FTF9CUklER0UKKwlkZWZfYm9vbCB5CisJZGVwZW5kcyBvbiBE Uk1fQlJJREdFCisJZGVwZW5kcyBvbiBEUk1fS01TX0hFTFBFUgorCXNlbGVjdCBEUk1fUEFORUwK KwloZWxwCisJICBEUk0gYnJpZGdlIHdyYXBwZXIgb2YgRFJNIHBhbmVscworCiBtZW51ICJEaXNw bGF5IEludGVyZmFjZSBCcmlkZ2VzIgogCWRlcGVuZHMgb24gRFJNICYmIERSTV9CUklER0UKIApA QCAtMjcsOCArMzUsNyBAQCBjb25maWcgRFJNX0RVTUJfVkdBX0RBQwogY29uZmlnIERSTV9MVkRT X0VOQ09ERVIKIAl0cmlzdGF0ZSAiVHJhbnNwYXJlbnQgcGFyYWxsZWwgdG8gTFZEUyBlbmNvZGVy IHN1cHBvcnQiCiAJZGVwZW5kcyBvbiBPRgotCXNlbGVjdCBEUk1fS01TX0hFTFBFUgotCXNlbGVj dCBEUk1fUEFORUwKKwlzZWxlY3QgRFJNX1BBTkVMX0JSSURHRQogCWhlbHAKIAkgIFN1cHBvcnQg Zm9yIHRyYW5zcGFyZW50IHBhcmFsbGVsIHRvIExWRFMgZW5jb2RlcnMgdGhhdCBkb24ndCByZXF1 aXJlCiAJICBhbnkgY29uZmlndXJhdGlvbi4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9i cmlkZ2UvbHZkcy1lbmNvZGVyLmMgYi9kcml2ZXJzL2dwdS9kcm0vYnJpZGdlL2x2ZHMtZW5jb2Rl ci5jCmluZGV4IGYxZjY3YTI3OTQyNi4uMDkwM2JhNTc0ZjYxIDEwMDY0NAotLS0gYS9kcml2ZXJz L2dwdS9kcm0vYnJpZGdlL2x2ZHMtZW5jb2Rlci5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9icmlk Z2UvbHZkcy1lbmNvZGVyLmMKQEAgLTgsMTQ0ICs4LDE4IEBACiAgKi8KIAogI2luY2x1ZGUgPGRy bS9kcm1QLmg+Ci0jaW5jbHVkZSA8ZHJtL2RybV9hdG9taWNfaGVscGVyLmg+Ci0jaW5jbHVkZSA8 ZHJtL2RybV9jb25uZWN0b3IuaD4KLSNpbmNsdWRlIDxkcm0vZHJtX2NydGNfaGVscGVyLmg+Ci0j aW5jbHVkZSA8ZHJtL2RybV9lbmNvZGVyLmg+Ci0jaW5jbHVkZSA8ZHJtL2RybV9tb2Rlc2V0X2hl bHBlcl92dGFibGVzLmg+CisjaW5jbHVkZSA8ZHJtL2RybV9icmlkZ2UuaD4KICNpbmNsdWRlIDxk cm0vZHJtX3BhbmVsLmg+CiAKICNpbmNsdWRlIDxsaW51eC9vZl9ncmFwaC5oPgogCi1zdHJ1Y3Qg bHZkc19lbmNvZGVyIHsKLQlzdHJ1Y3QgZGV2aWNlICpkZXY7Ci0KLQlzdHJ1Y3QgZHJtX2JyaWRn ZSBicmlkZ2U7Ci0Jc3RydWN0IGRybV9jb25uZWN0b3IgY29ubmVjdG9yOwotCXN0cnVjdCBkcm1f cGFuZWwgKnBhbmVsOwotfTsKLQotc3RhdGljIGlubGluZSBzdHJ1Y3QgbHZkc19lbmNvZGVyICoK LWRybV9icmlkZ2VfdG9fbHZkc19lbmNvZGVyKHN0cnVjdCBkcm1fYnJpZGdlICpicmlkZ2UpCi17 Ci0JcmV0dXJuIGNvbnRhaW5lcl9vZihicmlkZ2UsIHN0cnVjdCBsdmRzX2VuY29kZXIsIGJyaWRn ZSk7Ci19Ci0KLXN0YXRpYyBpbmxpbmUgc3RydWN0IGx2ZHNfZW5jb2RlciAqCi1kcm1fY29ubmVj dG9yX3RvX2x2ZHNfZW5jb2RlcihzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9yKQotewot CXJldHVybiBjb250YWluZXJfb2YoY29ubmVjdG9yLCBzdHJ1Y3QgbHZkc19lbmNvZGVyLCBjb25u ZWN0b3IpOwotfQotCi1zdGF0aWMgaW50IGx2ZHNfY29ubmVjdG9yX2dldF9tb2RlcyhzdHJ1Y3Qg ZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9yKQotewotCXN0cnVjdCBsdmRzX2VuY29kZXIgKmx2ZHMg PSBkcm1fY29ubmVjdG9yX3RvX2x2ZHNfZW5jb2Rlcihjb25uZWN0b3IpOwotCi0JcmV0dXJuIGRy bV9wYW5lbF9nZXRfbW9kZXMobHZkcy0+cGFuZWwpOwotfQotCi1zdGF0aWMgY29uc3Qgc3RydWN0 IGRybV9jb25uZWN0b3JfaGVscGVyX2Z1bmNzIGx2ZHNfY29ubmVjdG9yX2hlbHBlcl9mdW5jcyA9 IHsKLQkuZ2V0X21vZGVzID0gbHZkc19jb25uZWN0b3JfZ2V0X21vZGVzLAotfTsKLQotc3RhdGlj IGNvbnN0IHN0cnVjdCBkcm1fY29ubmVjdG9yX2Z1bmNzIGx2ZHNfY29ubmVjdG9yX2Z1bmNzID0g ewotCS5kcG1zID0gZHJtX2F0b21pY19oZWxwZXJfY29ubmVjdG9yX2RwbXMsCi0JLnJlc2V0ID0g ZHJtX2F0b21pY19oZWxwZXJfY29ubmVjdG9yX3Jlc2V0LAotCS5maWxsX21vZGVzID0gZHJtX2hl bHBlcl9wcm9iZV9zaW5nbGVfY29ubmVjdG9yX21vZGVzLAotCS5kZXN0cm95ID0gZHJtX2Nvbm5l Y3Rvcl9jbGVhbnVwLAotCS5hdG9taWNfZHVwbGljYXRlX3N0YXRlID0gZHJtX2F0b21pY19oZWxw ZXJfY29ubmVjdG9yX2R1cGxpY2F0ZV9zdGF0ZSwKLQkuYXRvbWljX2Rlc3Ryb3lfc3RhdGUgPSBk cm1fYXRvbWljX2hlbHBlcl9jb25uZWN0b3JfZGVzdHJveV9zdGF0ZSwKLX07Ci0KLXN0YXRpYyBp bnQgbHZkc19lbmNvZGVyX2F0dGFjaChzdHJ1Y3QgZHJtX2JyaWRnZSAqYnJpZGdlKQotewotCXN0 cnVjdCBsdmRzX2VuY29kZXIgKmx2ZHMgPSBkcm1fYnJpZGdlX3RvX2x2ZHNfZW5jb2Rlcihicmlk Z2UpOwotCXN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3IgPSAmbHZkcy0+Y29ubmVjdG9y OwotCWludCByZXQ7Ci0KLQlpZiAoIWJyaWRnZS0+ZW5jb2RlcikgewotCQlEUk1fRVJST1IoIk1p c3NpbmcgZW5jb2RlclxuIik7Ci0JCXJldHVybiAtRU5PREVWOwotCX0KLQotCWRybV9jb25uZWN0 b3JfaGVscGVyX2FkZChjb25uZWN0b3IsICZsdmRzX2Nvbm5lY3Rvcl9oZWxwZXJfZnVuY3MpOwot Ci0JcmV0ID0gZHJtX2Nvbm5lY3Rvcl9pbml0KGJyaWRnZS0+ZGV2LCBjb25uZWN0b3IsICZsdmRz X2Nvbm5lY3Rvcl9mdW5jcywKLQkJCQkgRFJNX01PREVfQ09OTkVDVE9SX0xWRFMpOwotCWlmIChy ZXQpIHsKLQkJRFJNX0VSUk9SKCJGYWlsZWQgdG8gaW5pdGlhbGl6ZSBjb25uZWN0b3JcbiIpOwot CQlyZXR1cm4gcmV0OwotCX0KLQotCWRybV9tb2RlX2Nvbm5lY3Rvcl9hdHRhY2hfZW5jb2Rlcigm bHZkcy0+Y29ubmVjdG9yLCBicmlkZ2UtPmVuY29kZXIpOwotCi0JcmV0ID0gZHJtX3BhbmVsX2F0 dGFjaChsdmRzLT5wYW5lbCwgJmx2ZHMtPmNvbm5lY3Rvcik7Ci0JaWYgKHJldCA8IDApCi0JCXJl dHVybiByZXQ7Ci0KLQlyZXR1cm4gMDsKLX0KLQotc3RhdGljIHZvaWQgbHZkc19lbmNvZGVyX2Rl dGFjaChzdHJ1Y3QgZHJtX2JyaWRnZSAqYnJpZGdlKQotewotCXN0cnVjdCBsdmRzX2VuY29kZXIg Kmx2ZHMgPSBkcm1fYnJpZGdlX3RvX2x2ZHNfZW5jb2RlcihicmlkZ2UpOwotCi0JZHJtX3BhbmVs X2RldGFjaChsdmRzLT5wYW5lbCk7Ci19Ci0KLXN0YXRpYyB2b2lkIGx2ZHNfZW5jb2Rlcl9wcmVf ZW5hYmxlKHN0cnVjdCBkcm1fYnJpZGdlICpicmlkZ2UpCi17Ci0Jc3RydWN0IGx2ZHNfZW5jb2Rl ciAqbHZkcyA9IGRybV9icmlkZ2VfdG9fbHZkc19lbmNvZGVyKGJyaWRnZSk7Ci0KLQlkcm1fcGFu ZWxfcHJlcGFyZShsdmRzLT5wYW5lbCk7Ci19Ci0KLXN0YXRpYyB2b2lkIGx2ZHNfZW5jb2Rlcl9l bmFibGUoc3RydWN0IGRybV9icmlkZ2UgKmJyaWRnZSkKLXsKLQlzdHJ1Y3QgbHZkc19lbmNvZGVy ICpsdmRzID0gZHJtX2JyaWRnZV90b19sdmRzX2VuY29kZXIoYnJpZGdlKTsKLQotCWRybV9wYW5l bF9lbmFibGUobHZkcy0+cGFuZWwpOwotfQotCi1zdGF0aWMgdm9pZCBsdmRzX2VuY29kZXJfZGlz YWJsZShzdHJ1Y3QgZHJtX2JyaWRnZSAqYnJpZGdlKQotewotCXN0cnVjdCBsdmRzX2VuY29kZXIg Kmx2ZHMgPSBkcm1fYnJpZGdlX3RvX2x2ZHNfZW5jb2RlcihicmlkZ2UpOwotCi0JZHJtX3BhbmVs X2Rpc2FibGUobHZkcy0+cGFuZWwpOwotfQotCi1zdGF0aWMgdm9pZCBsdmRzX2VuY29kZXJfcG9z dF9kaXNhYmxlKHN0cnVjdCBkcm1fYnJpZGdlICpicmlkZ2UpCi17Ci0Jc3RydWN0IGx2ZHNfZW5j b2RlciAqbHZkcyA9IGRybV9icmlkZ2VfdG9fbHZkc19lbmNvZGVyKGJyaWRnZSk7Ci0KLQlkcm1f cGFuZWxfdW5wcmVwYXJlKGx2ZHMtPnBhbmVsKTsKLX0KLQotc3RhdGljIGNvbnN0IHN0cnVjdCBk cm1fYnJpZGdlX2Z1bmNzIGx2ZHNfZW5jb2Rlcl9icmlkZ2VfZnVuY3MgPSB7Ci0JLmF0dGFjaCA9 IGx2ZHNfZW5jb2Rlcl9hdHRhY2gsCi0JLmRldGFjaCA9IGx2ZHNfZW5jb2Rlcl9kZXRhY2gsCi0J LnByZV9lbmFibGUgPSBsdmRzX2VuY29kZXJfcHJlX2VuYWJsZSwKLQkuZW5hYmxlID0gbHZkc19l bmNvZGVyX2VuYWJsZSwKLQkuZGlzYWJsZSA9IGx2ZHNfZW5jb2Rlcl9kaXNhYmxlLAotCS5wb3N0 X2Rpc2FibGUgPSBsdmRzX2VuY29kZXJfcG9zdF9kaXNhYmxlLAotfTsKLQogc3RhdGljIGludCBs dmRzX2VuY29kZXJfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKIHsKLQlzdHJ1 Y3QgbHZkc19lbmNvZGVyICpsdmRzOwogCXN0cnVjdCBkZXZpY2Vfbm9kZSAqcG9ydDsKIAlzdHJ1 Y3QgZGV2aWNlX25vZGUgKmVuZHBvaW50OwotCXN0cnVjdCBkZXZpY2Vfbm9kZSAqcGFuZWw7Ci0K LQlsdmRzID0gZGV2bV9remFsbG9jKCZwZGV2LT5kZXYsIHNpemVvZigqbHZkcyksIEdGUF9LRVJO RUwpOwotCWlmICghbHZkcykKLQkJcmV0dXJuIC1FTk9NRU07Ci0KLQlsdmRzLT5kZXYgPSAmcGRl di0+ZGV2OwotCXBsYXRmb3JtX3NldF9kcnZkYXRhKHBkZXYsIGx2ZHMpOwotCi0JbHZkcy0+YnJp ZGdlLmZ1bmNzID0gJmx2ZHNfZW5jb2Rlcl9icmlkZ2VfZnVuY3M7Ci0JbHZkcy0+YnJpZGdlLm9m X25vZGUgPSBwZGV2LT5kZXYub2Zfbm9kZTsKKwlzdHJ1Y3QgZGV2aWNlX25vZGUgKnBhbmVsX25v ZGU7CisJc3RydWN0IGRybV9wYW5lbCAqcGFuZWw7CisJc3RydWN0IGRybV9icmlkZ2UgKmJyaWRn ZTsKIAogCS8qIExvY2F0ZSB0aGUgcGFuZWwgRFQgbm9kZS4gKi8KIAlwb3J0ID0gb2ZfZ3JhcGhf Z2V0X3BvcnRfYnlfaWQocGRldi0+ZGV2Lm9mX25vZGUsIDEpOwpAQCAtMTYxLDI5ICszNSwzNCBA QCBzdGF0aWMgaW50IGx2ZHNfZW5jb2Rlcl9wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpw ZGV2KQogCQlyZXR1cm4gLUVOWElPOwogCX0KIAotCXBhbmVsID0gb2ZfZ3JhcGhfZ2V0X3JlbW90 ZV9wb3J0X3BhcmVudChlbmRwb2ludCk7CisJcGFuZWxfbm9kZSA9IG9mX2dyYXBoX2dldF9yZW1v dGVfcG9ydF9wYXJlbnQoZW5kcG9pbnQpOwogCW9mX25vZGVfcHV0KGVuZHBvaW50KTsKLQlpZiAo IXBhbmVsKSB7CisJaWYgKCFwYW5lbF9ub2RlKSB7CiAJCWRldl9kYmcoJnBkZXYtPmRldiwgIm5v IHJlbW90ZSBlbmRwb2ludCBmb3IgcG9ydCAxXG4iKTsKIAkJcmV0dXJuIC1FTlhJTzsKIAl9CiAK LQlsdmRzLT5wYW5lbCA9IG9mX2RybV9maW5kX3BhbmVsKHBhbmVsKTsKLQlvZl9ub2RlX3B1dChw YW5lbCk7Ci0JaWYgKCFsdmRzLT5wYW5lbCkgeworCXBhbmVsID0gb2ZfZHJtX2ZpbmRfcGFuZWwo cGFuZWxfbm9kZSk7CisJb2Zfbm9kZV9wdXQocGFuZWxfbm9kZSk7CisJaWYgKCFwYW5lbCkgewog CQlkZXZfZGJnKCZwZGV2LT5kZXYsICJwYW5lbCBub3QgZm91bmQsIGRlZmVycmluZyBwcm9iZVxu Iik7CiAJCXJldHVybiAtRVBST0JFX0RFRkVSOwogCX0KIAotCS8qIFJlZ2lzdGVyIHRoZSBicmlk Z2UuICovCi0JcmV0dXJuIGRybV9icmlkZ2VfYWRkKCZsdmRzLT5icmlkZ2UpOworCWJyaWRnZSA9 IGRybV9wYW5lbF9icmlkZ2VfYWRkKHBhbmVsLCBEUk1fTU9ERV9DT05ORUNUT1JfTFZEUyk7CisJ aWYgKElTX0VSUihicmlkZ2UpKQorCQlyZXR1cm4gUFRSX0VSUihicmlkZ2UpOworCisJcGxhdGZv cm1fc2V0X2RydmRhdGEocGRldiwgYnJpZGdlKTsKKworCXJldHVybiAwOwogfQogCiBzdGF0aWMg aW50IGx2ZHNfZW5jb2Rlcl9yZW1vdmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKIHsK LQlzdHJ1Y3QgbHZkc19lbmNvZGVyICplbmNvZGVyID0gcGxhdGZvcm1fZ2V0X2RydmRhdGEocGRl dik7CisJc3RydWN0IGRybV9icmlkZ2UgKmJyaWRnZSA9IHBsYXRmb3JtX2dldF9kcnZkYXRhKHBk ZXYpOwogCi0JZHJtX2JyaWRnZV9yZW1vdmUoJmVuY29kZXItPmJyaWRnZSk7CisJZHJtX2JyaWRn ZV9yZW1vdmUoYnJpZGdlKTsKIAogCXJldHVybiAwOwogfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9n cHUvZHJtL2JyaWRnZS9wYW5lbC5jIGIvZHJpdmVycy9ncHUvZHJtL2JyaWRnZS9wYW5lbC5jCm5l dyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uOTlmOWE0YmViODU5Ci0tLSAv ZGV2L251bGwKKysrIGIvZHJpdmVycy9ncHUvZHJtL2JyaWRnZS9wYW5lbC5jCkBAIC0wLDAgKzEs MjAwIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDE2IExhdXJlbnQgUGluY2hhcnQgPGxhdXJl bnQucGluY2hhcnRAaWRlYXNvbmJvYXJkLmNvbT4KKyAqIENvcHlyaWdodCAoQykgMjAxNyBCcm9h ZGNvbQorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlz dHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdO VSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29m dHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZgorICogdGhlIExpY2Vuc2UsIG9y IChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisgKi8KKworI2luY2x1ZGUgPGRy bS9kcm1QLmg+CisjaW5jbHVkZSA8ZHJtL2RybV9wYW5lbC5oPgorI2luY2x1ZGUgPGRybS9kcm1f YXRvbWljX2hlbHBlci5oPgorI2luY2x1ZGUgPGRybS9kcm1fY29ubmVjdG9yLmg+CisjaW5jbHVk ZSA8ZHJtL2RybV9jcnRjX2hlbHBlci5oPgorI2luY2x1ZGUgPGRybS9kcm1fZW5jb2Rlci5oPgor I2luY2x1ZGUgPGRybS9kcm1fbW9kZXNldF9oZWxwZXJfdnRhYmxlcy5oPgorI2luY2x1ZGUgPGRy bS9kcm1fcGFuZWwuaD4KKworc3RydWN0IHBhbmVsX2JyaWRnZSB7CisJc3RydWN0IGRybV9icmlk Z2UgYnJpZGdlOworCXN0cnVjdCBkcm1fY29ubmVjdG9yIGNvbm5lY3RvcjsKKwlzdHJ1Y3QgZHJt X3BhbmVsICpwYW5lbDsKKwl1MzIgY29ubmVjdG9yX3R5cGU7Cit9OworCitzdGF0aWMgaW5saW5l IHN0cnVjdCBwYW5lbF9icmlkZ2UgKgorZHJtX2JyaWRnZV90b19wYW5lbF9icmlkZ2Uoc3RydWN0 IGRybV9icmlkZ2UgKmJyaWRnZSkKK3sKKwlyZXR1cm4gY29udGFpbmVyX29mKGJyaWRnZSwgc3Ry dWN0IHBhbmVsX2JyaWRnZSwgYnJpZGdlKTsKK30KKworc3RhdGljIGlubGluZSBzdHJ1Y3QgcGFu ZWxfYnJpZGdlICoKK2RybV9jb25uZWN0b3JfdG9fcGFuZWxfYnJpZGdlKHN0cnVjdCBkcm1fY29u bmVjdG9yICpjb25uZWN0b3IpCit7CisJcmV0dXJuIGNvbnRhaW5lcl9vZihjb25uZWN0b3IsIHN0 cnVjdCBwYW5lbF9icmlkZ2UsIGNvbm5lY3Rvcik7Cit9CisKK3N0YXRpYyBpbnQgcGFuZWxfYnJp ZGdlX2Nvbm5lY3Rvcl9nZXRfbW9kZXMoc3RydWN0IGRybV9jb25uZWN0b3IgKmNvbm5lY3RvcikK K3sKKwlzdHJ1Y3QgcGFuZWxfYnJpZGdlICpwYW5lbF9icmlkZ2UgPQorCQlkcm1fY29ubmVjdG9y X3RvX3BhbmVsX2JyaWRnZShjb25uZWN0b3IpOworCisJcmV0dXJuIGRybV9wYW5lbF9nZXRfbW9k ZXMocGFuZWxfYnJpZGdlLT5wYW5lbCk7Cit9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgZHJtX2Nv bm5lY3Rvcl9oZWxwZXJfZnVuY3MKK3BhbmVsX2JyaWRnZV9jb25uZWN0b3JfaGVscGVyX2Z1bmNz ID0geworCS5nZXRfbW9kZXMgPSBwYW5lbF9icmlkZ2VfY29ubmVjdG9yX2dldF9tb2RlcywKK307 CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgZHJtX2Nvbm5lY3Rvcl9mdW5jcyBwYW5lbF9icmlkZ2Vf Y29ubmVjdG9yX2Z1bmNzID0geworCS5kcG1zID0gZHJtX2F0b21pY19oZWxwZXJfY29ubmVjdG9y X2RwbXMsCisJLnJlc2V0ID0gZHJtX2F0b21pY19oZWxwZXJfY29ubmVjdG9yX3Jlc2V0LAorCS5m aWxsX21vZGVzID0gZHJtX2hlbHBlcl9wcm9iZV9zaW5nbGVfY29ubmVjdG9yX21vZGVzLAorCS5k ZXN0cm95ID0gZHJtX2Nvbm5lY3Rvcl9jbGVhbnVwLAorCS5hdG9taWNfZHVwbGljYXRlX3N0YXRl ID0gZHJtX2F0b21pY19oZWxwZXJfY29ubmVjdG9yX2R1cGxpY2F0ZV9zdGF0ZSwKKwkuYXRvbWlj X2Rlc3Ryb3lfc3RhdGUgPSBkcm1fYXRvbWljX2hlbHBlcl9jb25uZWN0b3JfZGVzdHJveV9zdGF0 ZSwKK307CisKK3N0YXRpYyBpbnQgcGFuZWxfYnJpZGdlX2F0dGFjaChzdHJ1Y3QgZHJtX2JyaWRn ZSAqYnJpZGdlKQoreworCXN0cnVjdCBwYW5lbF9icmlkZ2UgKnBhbmVsX2JyaWRnZSA9IGRybV9i cmlkZ2VfdG9fcGFuZWxfYnJpZGdlKGJyaWRnZSk7CisJc3RydWN0IGRybV9jb25uZWN0b3IgKmNv bm5lY3RvciA9ICZwYW5lbF9icmlkZ2UtPmNvbm5lY3RvcjsKKwlpbnQgcmV0OworCisJaWYgKCFi cmlkZ2UtPmVuY29kZXIpIHsKKwkJRFJNX0VSUk9SKCJNaXNzaW5nIGVuY29kZXJcbiIpOworCQly ZXR1cm4gLUVOT0RFVjsKKwl9CisKKwlkcm1fY29ubmVjdG9yX2hlbHBlcl9hZGQoY29ubmVjdG9y LAorCQkJCSAmcGFuZWxfYnJpZGdlX2Nvbm5lY3Rvcl9oZWxwZXJfZnVuY3MpOworCisJcmV0ID0g ZHJtX2Nvbm5lY3Rvcl9pbml0KGJyaWRnZS0+ZGV2LCBjb25uZWN0b3IsCisJCQkJICZwYW5lbF9i cmlkZ2VfY29ubmVjdG9yX2Z1bmNzLAorCQkJCSBwYW5lbF9icmlkZ2UtPmNvbm5lY3Rvcl90eXBl KTsKKwlpZiAocmV0KSB7CisJCURSTV9FUlJPUigiRmFpbGVkIHRvIGluaXRpYWxpemUgY29ubmVj dG9yXG4iKTsKKwkJcmV0dXJuIHJldDsKKwl9CisKKwlkcm1fbW9kZV9jb25uZWN0b3JfYXR0YWNo X2VuY29kZXIoJnBhbmVsX2JyaWRnZS0+Y29ubmVjdG9yLAorCQkJCQkgIGJyaWRnZS0+ZW5jb2Rl cik7CisKKwlyZXQgPSBkcm1fcGFuZWxfYXR0YWNoKHBhbmVsX2JyaWRnZS0+cGFuZWwsICZwYW5l bF9icmlkZ2UtPmNvbm5lY3Rvcik7CisJaWYgKHJldCA8IDApCisJCXJldHVybiByZXQ7CisKKwly ZXR1cm4gMDsKK30KKworc3RhdGljIHZvaWQgcGFuZWxfYnJpZGdlX2RldGFjaChzdHJ1Y3QgZHJt X2JyaWRnZSAqYnJpZGdlKQoreworCXN0cnVjdCBwYW5lbF9icmlkZ2UgKnBhbmVsX2JyaWRnZSA9 IGRybV9icmlkZ2VfdG9fcGFuZWxfYnJpZGdlKGJyaWRnZSk7CisKKwlkcm1fcGFuZWxfZGV0YWNo KHBhbmVsX2JyaWRnZS0+cGFuZWwpOworfQorCitzdGF0aWMgdm9pZCBwYW5lbF9icmlkZ2VfcHJl X2VuYWJsZShzdHJ1Y3QgZHJtX2JyaWRnZSAqYnJpZGdlKQoreworCXN0cnVjdCBwYW5lbF9icmlk Z2UgKnBhbmVsX2JyaWRnZSA9IGRybV9icmlkZ2VfdG9fcGFuZWxfYnJpZGdlKGJyaWRnZSk7CisK Kwlkcm1fcGFuZWxfcHJlcGFyZShwYW5lbF9icmlkZ2UtPnBhbmVsKTsKK30KKworc3RhdGljIHZv aWQgcGFuZWxfYnJpZGdlX2VuYWJsZShzdHJ1Y3QgZHJtX2JyaWRnZSAqYnJpZGdlKQoreworCXN0 cnVjdCBwYW5lbF9icmlkZ2UgKnBhbmVsX2JyaWRnZSA9IGRybV9icmlkZ2VfdG9fcGFuZWxfYnJp ZGdlKGJyaWRnZSk7CisKKwlkcm1fcGFuZWxfZW5hYmxlKHBhbmVsX2JyaWRnZS0+cGFuZWwpOwor fQorCitzdGF0aWMgdm9pZCBwYW5lbF9icmlkZ2VfZGlzYWJsZShzdHJ1Y3QgZHJtX2JyaWRnZSAq YnJpZGdlKQoreworCXN0cnVjdCBwYW5lbF9icmlkZ2UgKnBhbmVsX2JyaWRnZSA9IGRybV9icmlk Z2VfdG9fcGFuZWxfYnJpZGdlKGJyaWRnZSk7CisKKwlkcm1fcGFuZWxfZGlzYWJsZShwYW5lbF9i cmlkZ2UtPnBhbmVsKTsKK30KKworc3RhdGljIHZvaWQgcGFuZWxfYnJpZGdlX3Bvc3RfZGlzYWJs ZShzdHJ1Y3QgZHJtX2JyaWRnZSAqYnJpZGdlKQoreworCXN0cnVjdCBwYW5lbF9icmlkZ2UgKnBh bmVsX2JyaWRnZSA9IGRybV9icmlkZ2VfdG9fcGFuZWxfYnJpZGdlKGJyaWRnZSk7CisKKwlkcm1f cGFuZWxfdW5wcmVwYXJlKHBhbmVsX2JyaWRnZS0+cGFuZWwpOworfQorCitzdGF0aWMgY29uc3Qg c3RydWN0IGRybV9icmlkZ2VfZnVuY3MgcGFuZWxfYnJpZGdlX2JyaWRnZV9mdW5jcyA9IHsKKwku YXR0YWNoID0gcGFuZWxfYnJpZGdlX2F0dGFjaCwKKwkuZGV0YWNoID0gcGFuZWxfYnJpZGdlX2Rl dGFjaCwKKwkucHJlX2VuYWJsZSA9IHBhbmVsX2JyaWRnZV9wcmVfZW5hYmxlLAorCS5lbmFibGUg PSBwYW5lbF9icmlkZ2VfZW5hYmxlLAorCS5kaXNhYmxlID0gcGFuZWxfYnJpZGdlX2Rpc2FibGUs CisJLnBvc3RfZGlzYWJsZSA9IHBhbmVsX2JyaWRnZV9wb3N0X2Rpc2FibGUsCit9OworCisvKioK KyAqIGRybV9wYW5lbF9icmlkZ2VfYWRkIC0gQ3JlYXRlcyBhIGRybV9icmlkZ2UgYW5kIGRybV9j b25uZWN0b3IgdGhhdAorICoganVzdCBjYWxscyB0aGUgYXBwcm9wcmlhdGUgZnVuY3Rpb25zIGZy b20gZHJtX3BhbmVsLgorICoKKyAqIEBwYW5lbDogVGhlIGRybV9wYW5lbCBiZWluZyB3cmFwcGVk LiAgTXVzdCBiZSBub24tTlVMTC4KKyAqIEBjb25uZWN0b3JfdHlwZTogVGhlIERSTV9NT0RFX0NP Tk5FQ1RPUl8qIGZvciB0aGUgY29ubmVjdG9yIHRvIGJlCisgKiBjcmVhdGVkLgorICoKKyAqIEZv ciBkcml2ZXJzIGNvbnZlcnRpbmcgZnJvbSBkaXJlY3RseSB1c2luZyBkcm1fcGFuZWw6IFRoZSBl eHBlY3RlZAorICogdXNhZ2UgcGF0dGVybiBpcyB0aGF0IGR1cmluZyBlaXRoZXIgZW5jb2RlciBt b2R1bGUgcHJvYmUgb3IgRFNJCisgKiBob3N0IGF0dGFjaCwgYSBkcm1fcGFuZWwgd2lsbCBiZSBs b29rZWQgdXAgdGhyb3VnaAorICogZHJtX29mX2ZpbmRfcGFuZWxfb3JfYnJpZGdlKCkuICBkcm1f cGFuZWxfYnJpZGdlX2FkZCgpIGlzIHVzZWQgdG8KKyAqIHdyYXAgdGhhdCBwYW5lbCBpbiB0aGUg bmV3IGJyaWRnZSwgYW5kIHRoZSByZXN1bHQgY2FuIHRoZW4gYmUKKyAqIHBhc3NlZCB0byBkcm1f YnJpZGdlX2F0dGFjaCgpLiAgVGhlIGRybV9wYW5lbF9wcmVwYXJlKCkgYW5kIHJlbGF0ZWQKKyAq IGZ1bmN0aW9ucyBjYW4gYmUgZHJvcHBlZCBmcm9tIHRoZSBlbmNvZGVyIGRyaXZlciAodGhleSdy ZSBub3cKKyAqIGNhbGxlZCBieSB0aGUgS01TIGhlbHBlcnMgYmVmb3JlIGNhbGxpbmcgaW50byB0 aGUgZW5jb2RlciksIGFsb25nCisgKiB3aXRoIGNvbm5lY3RvciBjcmVhdGlvbi4gIFdoZW4gZG9u ZSB3aXRoIHRoZSBicmlkZ2UsCisgKiBkcm1fYnJpZGdlX2RldGFjaCgpIHNob3VsZCBiZSBjYWxs ZWQgYXMgbm9ybWFsLCB0aGVuCisgKiBkcm1fcGFuZWxfYnJpZGdlX3JlbW92ZSgpIHRvIGZyZWUg aXQuCisgKi8KK3N0cnVjdCBkcm1fYnJpZGdlICpkcm1fcGFuZWxfYnJpZGdlX2FkZChzdHJ1Y3Qg ZHJtX3BhbmVsICpwYW5lbCwKKwkJCQkJdTMyIGNvbm5lY3Rvcl90eXBlKQoreworCXN0cnVjdCBw YW5lbF9icmlkZ2UgKnBhbmVsX2JyaWRnZTsKKwlpbnQgcmV0OworCisJaWYgKCFwYW5lbCkKKwkJ cmV0dXJuIEVSUl9QVFIoRUlOVkFMKTsKKworCXBhbmVsX2JyaWRnZSA9IGRldm1fa3phbGxvYyhw YW5lbC0+ZGV2LCBzaXplb2YoKnBhbmVsX2JyaWRnZSksCisJCQkJICAgIEdGUF9LRVJORUwpOwor CWlmICghcGFuZWxfYnJpZGdlKQorCQlyZXR1cm4gRVJSX1BUUigtRU5PTUVNKTsKKworCXBhbmVs X2JyaWRnZS0+Y29ubmVjdG9yX3R5cGUgPSBjb25uZWN0b3JfdHlwZTsKKwlwYW5lbF9icmlkZ2Ut PnBhbmVsID0gcGFuZWw7CisKKwlwYW5lbF9icmlkZ2UtPmJyaWRnZS5mdW5jcyA9ICZwYW5lbF9i cmlkZ2VfYnJpZGdlX2Z1bmNzOworI2lmZGVmIENPTkZJR19PRgorCXBhbmVsX2JyaWRnZS0+YnJp ZGdlLm9mX25vZGUgPSBwYW5lbC0+ZGV2LT5vZl9ub2RlOworI2VuZGlmCisKKwlyZXQgPSBkcm1f YnJpZGdlX2FkZCgmcGFuZWxfYnJpZGdlLT5icmlkZ2UpOworCWlmIChyZXQpCisJCXJldHVybiBF UlJfUFRSKHJldCk7CisKKwlyZXR1cm4gJnBhbmVsX2JyaWRnZS0+YnJpZGdlOworfQorRVhQT1JU X1NZTUJPTChkcm1fcGFuZWxfYnJpZGdlX2FkZCk7CisKKy8qKgorICogZHJtX3BhbmVsX2JyaWRn ZV9yZW1vdmUgLSBVbnJlZ2lzdGVycyBhbmQgZnJlZXMgYSBkcm1fYnJpZGdlCisgKiBjcmVhdGVk IGJ5IGRybV9wYW5lbF9icmlkZ2VfYWRkKCkuCisgKgorICogQGJyaWRnZTogVGhlIGRybV9icmlk Z2UgYmVpbmcgZnJlZWQuCisgKi8KK3ZvaWQgZHJtX3BhbmVsX2JyaWRnZV9yZW1vdmUoc3RydWN0 IGRybV9icmlkZ2UgKmJyaWRnZSkKK3sKKwlzdHJ1Y3QgcGFuZWxfYnJpZGdlICpwYW5lbF9icmlk Z2UgPSBkcm1fYnJpZGdlX3RvX3BhbmVsX2JyaWRnZShicmlkZ2UpOworCisJZHJtX2JyaWRnZV9y ZW1vdmUoYnJpZGdlKTsKKwlkZXZtX2tmcmVlKHBhbmVsX2JyaWRnZS0+cGFuZWwtPmRldiwgYnJp ZGdlKTsKK30KK0VYUE9SVF9TWU1CT0woZHJtX3BhbmVsX2JyaWRnZV9yZW1vdmUpOwpkaWZmIC0t Z2l0IGEvaW5jbHVkZS9kcm0vZHJtX2JyaWRnZS5oIGIvaW5jbHVkZS9kcm0vZHJtX2JyaWRnZS5o CmluZGV4IDViMTA2ZWNhNmQ1Ny4uMWRjOTRkNTM5MmUyIDEwMDY0NAotLS0gYS9pbmNsdWRlL2Ry bS9kcm1fYnJpZGdlLmgKKysrIGIvaW5jbHVkZS9kcm0vZHJtX2JyaWRnZS5oCkBAIC0yOSw2ICsy OSw3IEBACiAjaW5jbHVkZSA8ZHJtL2RybV9tb2Rlcy5oPgogCiBzdHJ1Y3QgZHJtX2JyaWRnZTsK K3N0cnVjdCBkcm1fcGFuZWw7CiAKIC8qKgogICogc3RydWN0IGRybV9icmlkZ2VfZnVuY3MgLSBk cm1fYnJpZGdlIGNvbnRyb2wgZnVuY3Rpb25zCkBAIC0yNjMsNCArMjY0LDEwIEBAIHZvaWQgZHJt X2JyaWRnZV9tb2RlX3NldChzdHJ1Y3QgZHJtX2JyaWRnZSAqYnJpZGdlLAogdm9pZCBkcm1fYnJp ZGdlX3ByZV9lbmFibGUoc3RydWN0IGRybV9icmlkZ2UgKmJyaWRnZSk7CiB2b2lkIGRybV9icmlk Z2VfZW5hYmxlKHN0cnVjdCBkcm1fYnJpZGdlICpicmlkZ2UpOwogCisjaWZkZWYgQ09ORklHX0RS TV9QQU5FTF9CUklER0UKK3N0cnVjdCBkcm1fYnJpZGdlICpkcm1fcGFuZWxfYnJpZGdlX2FkZChz dHJ1Y3QgZHJtX3BhbmVsICpwYW5lbCwKKwkJCQkJdTMyIGNvbm5lY3Rvcl90eXBlKTsKK3ZvaWQg ZHJtX3BhbmVsX2JyaWRnZV9yZW1vdmUoc3RydWN0IGRybV9icmlkZ2UgKmJyaWRnZSk7CisjZW5k aWYKKwogI2VuZGlmCi0tIAoyLjExLjAKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fCmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZy ZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3Rp bmZvL2RyaS1kZXZlbAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751313AbdFBU0Q (ORCPT ); Fri, 2 Jun 2017 16:26:16 -0400 Received: from anholt.net ([50.246.234.109]:58894 "EHLO anholt.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1750918AbdFBU0P (ORCPT ); Fri, 2 Jun 2017 16:26:15 -0400 From: Eric Anholt To: dri-devel@lists.freedesktop.org, Archit Taneja , Andrzej Hajda , Laurent Pinchart , Thierry Reding Cc: linux-kernel@vger.kernel.org, Eric Anholt Subject: [PATCH v3] drm/bridge: Refactor out the panel wrapper from the lvds-encoder bridge. Date: Fri, 2 Jun 2017 13:25:14 -0700 Message-Id: <20170602202514.11900-1-eric@anholt.net> X-Mailer: git-send-email 2.11.0 Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Many DRM drivers have common code to make a stub connector implementation that wraps a drm_panel. By wrapping the panel in a DRM bridge, all of the connector code (including calls during encoder enable/disable) goes away. v2: Fix build with CONFIG_DRM=m, drop "dev" argument that should just be the panel's dev, move kerneldoc up a level and document _remove(). v3: Fix another breakage with CONFIG_DRM=m, fix breakage with CONFIG_OF=n, move protos under CONFIG_DRM_PANEL_BRIDGE, wrap a line. Signed-off-by: Eric Anholt Acked-by: Daniel Vetter (v1) Reviewed-by: Boris Brezillon (v2) Acked-by: Archit Taneja (v2) --- New version of the first patch with build fixes. I've re-pushed to get another round of kbuild test, but if it comes back clean, I'd like to merge this one, the vc4 patches (unchanged), and atmel-hlcdc (acked by the maintainer). I'd be dropping my STM patch (replaced by their DSI series), and mediatek (I'd like an ack from the maintainer first). Documentation/gpu/drm-kms-helpers.rst | 6 + drivers/gpu/drm/Makefile | 1 + drivers/gpu/drm/bridge/Kconfig | 11 +- drivers/gpu/drm/bridge/lvds-encoder.c | 157 +++----------------------- drivers/gpu/drm/bridge/panel.c | 200 ++++++++++++++++++++++++++++++++++ include/drm/drm_bridge.h | 7 ++ 6 files changed, 241 insertions(+), 141 deletions(-) create mode 100644 drivers/gpu/drm/bridge/panel.c diff --git a/Documentation/gpu/drm-kms-helpers.rst b/Documentation/gpu/drm-kms-helpers.rst index c075aadd7078..7c5e2549a58a 100644 --- a/Documentation/gpu/drm-kms-helpers.rst +++ b/Documentation/gpu/drm-kms-helpers.rst @@ -143,6 +143,12 @@ Bridge Helper Reference .. kernel-doc:: drivers/gpu/drm/drm_bridge.c :export: +Panel-Bridge Helper Reference +----------------------------- + +.. kernel-doc:: drivers/gpu/drm/bridge/panel.c + :export: + .. _drm_panel_helper: Panel Helper Reference diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile index acc88942c2e5..dc69175255b1 100644 --- a/drivers/gpu/drm/Makefile +++ b/drivers/gpu/drm/Makefile @@ -24,6 +24,7 @@ drm-$(CONFIG_COMPAT) += drm_ioc32.o drm-$(CONFIG_DRM_GEM_CMA_HELPER) += drm_gem_cma_helper.o drm-$(CONFIG_PCI) += ati_pcigart.o drm-$(CONFIG_DRM_PANEL) += drm_panel.o +drm-$(CONFIG_DRM_PANEL_BRIDGE) += bridge/panel.o drm-$(CONFIG_OF) += drm_of.o drm-$(CONFIG_AGP) += drm_agpsupport.o drm-$(CONFIG_DEBUG_FS) += drm_debugfs.o drm_debugfs_crc.o diff --git a/drivers/gpu/drm/bridge/Kconfig b/drivers/gpu/drm/bridge/Kconfig index f6968d3b4b41..adf9ae0e0b7c 100644 --- a/drivers/gpu/drm/bridge/Kconfig +++ b/drivers/gpu/drm/bridge/Kconfig @@ -4,6 +4,14 @@ config DRM_BRIDGE help Bridge registration and lookup framework. +config DRM_PANEL_BRIDGE + def_bool y + depends on DRM_BRIDGE + depends on DRM_KMS_HELPER + select DRM_PANEL + help + DRM bridge wrapper of DRM panels + menu "Display Interface Bridges" depends on DRM && DRM_BRIDGE @@ -27,8 +35,7 @@ config DRM_DUMB_VGA_DAC config DRM_LVDS_ENCODER tristate "Transparent parallel to LVDS encoder support" depends on OF - select DRM_KMS_HELPER - select DRM_PANEL + select DRM_PANEL_BRIDGE help Support for transparent parallel to LVDS encoders that don't require any configuration. diff --git a/drivers/gpu/drm/bridge/lvds-encoder.c b/drivers/gpu/drm/bridge/lvds-encoder.c index f1f67a279426..0903ba574f61 100644 --- a/drivers/gpu/drm/bridge/lvds-encoder.c +++ b/drivers/gpu/drm/bridge/lvds-encoder.c @@ -8,144 +8,18 @@ */ #include -#include -#include -#include -#include -#include +#include #include #include -struct lvds_encoder { - struct device *dev; - - struct drm_bridge bridge; - struct drm_connector connector; - struct drm_panel *panel; -}; - -static inline struct lvds_encoder * -drm_bridge_to_lvds_encoder(struct drm_bridge *bridge) -{ - return container_of(bridge, struct lvds_encoder, bridge); -} - -static inline struct lvds_encoder * -drm_connector_to_lvds_encoder(struct drm_connector *connector) -{ - return container_of(connector, struct lvds_encoder, connector); -} - -static int lvds_connector_get_modes(struct drm_connector *connector) -{ - struct lvds_encoder *lvds = drm_connector_to_lvds_encoder(connector); - - return drm_panel_get_modes(lvds->panel); -} - -static const struct drm_connector_helper_funcs lvds_connector_helper_funcs = { - .get_modes = lvds_connector_get_modes, -}; - -static const struct drm_connector_funcs lvds_connector_funcs = { - .dpms = drm_atomic_helper_connector_dpms, - .reset = drm_atomic_helper_connector_reset, - .fill_modes = drm_helper_probe_single_connector_modes, - .destroy = drm_connector_cleanup, - .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state, - .atomic_destroy_state = drm_atomic_helper_connector_destroy_state, -}; - -static int lvds_encoder_attach(struct drm_bridge *bridge) -{ - struct lvds_encoder *lvds = drm_bridge_to_lvds_encoder(bridge); - struct drm_connector *connector = &lvds->connector; - int ret; - - if (!bridge->encoder) { - DRM_ERROR("Missing encoder\n"); - return -ENODEV; - } - - drm_connector_helper_add(connector, &lvds_connector_helper_funcs); - - ret = drm_connector_init(bridge->dev, connector, &lvds_connector_funcs, - DRM_MODE_CONNECTOR_LVDS); - if (ret) { - DRM_ERROR("Failed to initialize connector\n"); - return ret; - } - - drm_mode_connector_attach_encoder(&lvds->connector, bridge->encoder); - - ret = drm_panel_attach(lvds->panel, &lvds->connector); - if (ret < 0) - return ret; - - return 0; -} - -static void lvds_encoder_detach(struct drm_bridge *bridge) -{ - struct lvds_encoder *lvds = drm_bridge_to_lvds_encoder(bridge); - - drm_panel_detach(lvds->panel); -} - -static void lvds_encoder_pre_enable(struct drm_bridge *bridge) -{ - struct lvds_encoder *lvds = drm_bridge_to_lvds_encoder(bridge); - - drm_panel_prepare(lvds->panel); -} - -static void lvds_encoder_enable(struct drm_bridge *bridge) -{ - struct lvds_encoder *lvds = drm_bridge_to_lvds_encoder(bridge); - - drm_panel_enable(lvds->panel); -} - -static void lvds_encoder_disable(struct drm_bridge *bridge) -{ - struct lvds_encoder *lvds = drm_bridge_to_lvds_encoder(bridge); - - drm_panel_disable(lvds->panel); -} - -static void lvds_encoder_post_disable(struct drm_bridge *bridge) -{ - struct lvds_encoder *lvds = drm_bridge_to_lvds_encoder(bridge); - - drm_panel_unprepare(lvds->panel); -} - -static const struct drm_bridge_funcs lvds_encoder_bridge_funcs = { - .attach = lvds_encoder_attach, - .detach = lvds_encoder_detach, - .pre_enable = lvds_encoder_pre_enable, - .enable = lvds_encoder_enable, - .disable = lvds_encoder_disable, - .post_disable = lvds_encoder_post_disable, -}; - static int lvds_encoder_probe(struct platform_device *pdev) { - struct lvds_encoder *lvds; struct device_node *port; struct device_node *endpoint; - struct device_node *panel; - - lvds = devm_kzalloc(&pdev->dev, sizeof(*lvds), GFP_KERNEL); - if (!lvds) - return -ENOMEM; - - lvds->dev = &pdev->dev; - platform_set_drvdata(pdev, lvds); - - lvds->bridge.funcs = &lvds_encoder_bridge_funcs; - lvds->bridge.of_node = pdev->dev.of_node; + struct device_node *panel_node; + struct drm_panel *panel; + struct drm_bridge *bridge; /* Locate the panel DT node. */ port = of_graph_get_port_by_id(pdev->dev.of_node, 1); @@ -161,29 +35,34 @@ static int lvds_encoder_probe(struct platform_device *pdev) return -ENXIO; } - panel = of_graph_get_remote_port_parent(endpoint); + panel_node = of_graph_get_remote_port_parent(endpoint); of_node_put(endpoint); - if (!panel) { + if (!panel_node) { dev_dbg(&pdev->dev, "no remote endpoint for port 1\n"); return -ENXIO; } - lvds->panel = of_drm_find_panel(panel); - of_node_put(panel); - if (!lvds->panel) { + panel = of_drm_find_panel(panel_node); + of_node_put(panel_node); + if (!panel) { dev_dbg(&pdev->dev, "panel not found, deferring probe\n"); return -EPROBE_DEFER; } - /* Register the bridge. */ - return drm_bridge_add(&lvds->bridge); + bridge = drm_panel_bridge_add(panel, DRM_MODE_CONNECTOR_LVDS); + if (IS_ERR(bridge)) + return PTR_ERR(bridge); + + platform_set_drvdata(pdev, bridge); + + return 0; } static int lvds_encoder_remove(struct platform_device *pdev) { - struct lvds_encoder *encoder = platform_get_drvdata(pdev); + struct drm_bridge *bridge = platform_get_drvdata(pdev); - drm_bridge_remove(&encoder->bridge); + drm_bridge_remove(bridge); return 0; } diff --git a/drivers/gpu/drm/bridge/panel.c b/drivers/gpu/drm/bridge/panel.c new file mode 100644 index 000000000000..99f9a4beb859 --- /dev/null +++ b/drivers/gpu/drm/bridge/panel.c @@ -0,0 +1,200 @@ +/* + * Copyright (C) 2016 Laurent Pinchart + * Copyright (C) 2017 Broadcom + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of + * the License, or (at your option) any later version. + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +struct panel_bridge { + struct drm_bridge bridge; + struct drm_connector connector; + struct drm_panel *panel; + u32 connector_type; +}; + +static inline struct panel_bridge * +drm_bridge_to_panel_bridge(struct drm_bridge *bridge) +{ + return container_of(bridge, struct panel_bridge, bridge); +} + +static inline struct panel_bridge * +drm_connector_to_panel_bridge(struct drm_connector *connector) +{ + return container_of(connector, struct panel_bridge, connector); +} + +static int panel_bridge_connector_get_modes(struct drm_connector *connector) +{ + struct panel_bridge *panel_bridge = + drm_connector_to_panel_bridge(connector); + + return drm_panel_get_modes(panel_bridge->panel); +} + +static const struct drm_connector_helper_funcs +panel_bridge_connector_helper_funcs = { + .get_modes = panel_bridge_connector_get_modes, +}; + +static const struct drm_connector_funcs panel_bridge_connector_funcs = { + .dpms = drm_atomic_helper_connector_dpms, + .reset = drm_atomic_helper_connector_reset, + .fill_modes = drm_helper_probe_single_connector_modes, + .destroy = drm_connector_cleanup, + .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state, + .atomic_destroy_state = drm_atomic_helper_connector_destroy_state, +}; + +static int panel_bridge_attach(struct drm_bridge *bridge) +{ + struct panel_bridge *panel_bridge = drm_bridge_to_panel_bridge(bridge); + struct drm_connector *connector = &panel_bridge->connector; + int ret; + + if (!bridge->encoder) { + DRM_ERROR("Missing encoder\n"); + return -ENODEV; + } + + drm_connector_helper_add(connector, + &panel_bridge_connector_helper_funcs); + + ret = drm_connector_init(bridge->dev, connector, + &panel_bridge_connector_funcs, + panel_bridge->connector_type); + if (ret) { + DRM_ERROR("Failed to initialize connector\n"); + return ret; + } + + drm_mode_connector_attach_encoder(&panel_bridge->connector, + bridge->encoder); + + ret = drm_panel_attach(panel_bridge->panel, &panel_bridge->connector); + if (ret < 0) + return ret; + + return 0; +} + +static void panel_bridge_detach(struct drm_bridge *bridge) +{ + struct panel_bridge *panel_bridge = drm_bridge_to_panel_bridge(bridge); + + drm_panel_detach(panel_bridge->panel); +} + +static void panel_bridge_pre_enable(struct drm_bridge *bridge) +{ + struct panel_bridge *panel_bridge = drm_bridge_to_panel_bridge(bridge); + + drm_panel_prepare(panel_bridge->panel); +} + +static void panel_bridge_enable(struct drm_bridge *bridge) +{ + struct panel_bridge *panel_bridge = drm_bridge_to_panel_bridge(bridge); + + drm_panel_enable(panel_bridge->panel); +} + +static void panel_bridge_disable(struct drm_bridge *bridge) +{ + struct panel_bridge *panel_bridge = drm_bridge_to_panel_bridge(bridge); + + drm_panel_disable(panel_bridge->panel); +} + +static void panel_bridge_post_disable(struct drm_bridge *bridge) +{ + struct panel_bridge *panel_bridge = drm_bridge_to_panel_bridge(bridge); + + drm_panel_unprepare(panel_bridge->panel); +} + +static const struct drm_bridge_funcs panel_bridge_bridge_funcs = { + .attach = panel_bridge_attach, + .detach = panel_bridge_detach, + .pre_enable = panel_bridge_pre_enable, + .enable = panel_bridge_enable, + .disable = panel_bridge_disable, + .post_disable = panel_bridge_post_disable, +}; + +/** + * drm_panel_bridge_add - Creates a drm_bridge and drm_connector that + * just calls the appropriate functions from drm_panel. + * + * @panel: The drm_panel being wrapped. Must be non-NULL. + * @connector_type: The DRM_MODE_CONNECTOR_* for the connector to be + * created. + * + * For drivers converting from directly using drm_panel: The expected + * usage pattern is that during either encoder module probe or DSI + * host attach, a drm_panel will be looked up through + * drm_of_find_panel_or_bridge(). drm_panel_bridge_add() is used to + * wrap that panel in the new bridge, and the result can then be + * passed to drm_bridge_attach(). The drm_panel_prepare() and related + * functions can be dropped from the encoder driver (they're now + * called by the KMS helpers before calling into the encoder), along + * with connector creation. When done with the bridge, + * drm_bridge_detach() should be called as normal, then + * drm_panel_bridge_remove() to free it. + */ +struct drm_bridge *drm_panel_bridge_add(struct drm_panel *panel, + u32 connector_type) +{ + struct panel_bridge *panel_bridge; + int ret; + + if (!panel) + return ERR_PTR(EINVAL); + + panel_bridge = devm_kzalloc(panel->dev, sizeof(*panel_bridge), + GFP_KERNEL); + if (!panel_bridge) + return ERR_PTR(-ENOMEM); + + panel_bridge->connector_type = connector_type; + panel_bridge->panel = panel; + + panel_bridge->bridge.funcs = &panel_bridge_bridge_funcs; +#ifdef CONFIG_OF + panel_bridge->bridge.of_node = panel->dev->of_node; +#endif + + ret = drm_bridge_add(&panel_bridge->bridge); + if (ret) + return ERR_PTR(ret); + + return &panel_bridge->bridge; +} +EXPORT_SYMBOL(drm_panel_bridge_add); + +/** + * drm_panel_bridge_remove - Unregisters and frees a drm_bridge + * created by drm_panel_bridge_add(). + * + * @bridge: The drm_bridge being freed. + */ +void drm_panel_bridge_remove(struct drm_bridge *bridge) +{ + struct panel_bridge *panel_bridge = drm_bridge_to_panel_bridge(bridge); + + drm_bridge_remove(bridge); + devm_kfree(panel_bridge->panel->dev, bridge); +} +EXPORT_SYMBOL(drm_panel_bridge_remove); diff --git a/include/drm/drm_bridge.h b/include/drm/drm_bridge.h index 5b106eca6d57..1dc94d5392e2 100644 --- a/include/drm/drm_bridge.h +++ b/include/drm/drm_bridge.h @@ -29,6 +29,7 @@ #include struct drm_bridge; +struct drm_panel; /** * struct drm_bridge_funcs - drm_bridge control functions @@ -263,4 +264,10 @@ void drm_bridge_mode_set(struct drm_bridge *bridge, void drm_bridge_pre_enable(struct drm_bridge *bridge); void drm_bridge_enable(struct drm_bridge *bridge); +#ifdef CONFIG_DRM_PANEL_BRIDGE +struct drm_bridge *drm_panel_bridge_add(struct drm_panel *panel, + u32 connector_type); +void drm_panel_bridge_remove(struct drm_bridge *bridge); +#endif + #endif -- 2.11.0