From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S934037AbdEKSbf (ORCPT ); Thu, 11 May 2017 14:31:35 -0400 Received: from anholt.net ([50.246.234.109]:56186 "EHLO anholt.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S933972AbdEKSbe (ORCPT ); Thu, 11 May 2017 14:31:34 -0400 From: Eric Anholt To: dri-devel@lists.freedesktop.org, Boris Brezillon , Archit Taneja , Andrzej Hajda , Laurent Pinchart , CK Hu , Philipp Zabel , Yannick Fertre , Philippe Cornu Cc: linux-kernel@vger.kernel.org, Eric Anholt Subject: [PATCH v2 4/7] drm/mediatek: Use the panel-bridge helper. Date: Thu, 11 May 2017 11:31:25 -0700 Message-Id: <20170511183128.25085-4-eric@anholt.net> X-Mailer: git-send-email 2.11.0 In-Reply-To: <20170511183128.25085-1-eric@anholt.net> References: <20170511183128.25085-1-eric@anholt.net> Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Avoids a bunch of connector boilerplate. Note that this causes panel prepare() to be moved before mtk_dsi_poweron() and unprepare() to be after poweroff(). I think this is the expected usage of the panel API (enable should be when you do things that require the link to be brought up), but there may be issues here. Signed-off-by: Eric Anholt --- Note that I haven't tested this change, and am not committed to this patch. It's just an optional cleanup, if it works for you. drivers/gpu/drm/mediatek/mtk_dsi.c | 125 ++++--------------------------------- 1 file changed, 13 insertions(+), 112 deletions(-) diff --git a/drivers/gpu/drm/mediatek/mtk_dsi.c b/drivers/gpu/drm/mediatek/mtk_dsi.c index 808b995a990f..764bd8b9c256 100644 --- a/drivers/gpu/drm/mediatek/mtk_dsi.c +++ b/drivers/gpu/drm/mediatek/mtk_dsi.c @@ -160,7 +160,6 @@ struct mtk_dsi { struct device *dev; struct mipi_dsi_host host; struct drm_encoder encoder; - struct drm_connector conn; struct drm_panel *panel; struct drm_bridge *bridge; struct phy *phy; @@ -188,11 +187,6 @@ static inline struct mtk_dsi *encoder_to_dsi(struct drm_encoder *e) return container_of(e, struct mtk_dsi, encoder); } -static inline struct mtk_dsi *connector_to_dsi(struct drm_connector *c) -{ - return container_of(c, struct mtk_dsi, conn); -} - static inline struct mtk_dsi *host_to_dsi(struct mipi_dsi_host *h) { return container_of(h, struct mtk_dsi, host); @@ -603,16 +597,7 @@ static int mtk_dsi_poweron(struct mtk_dsi *dsi) mtk_dsi_lane0_ulp_mode_leave(dsi); mtk_dsi_clk_hs_mode(dsi, 0); - if (dsi->panel) { - if (drm_panel_prepare(dsi->panel)) { - DRM_ERROR("failed to prepare the panel\n"); - goto err_disable_digital_clk; - } - } - return 0; -err_disable_digital_clk: - clk_disable_unprepare(dsi->digital_clk); err_disable_engine_clk: clk_disable_unprepare(dsi->engine_clk); err_phy_power_off: @@ -630,15 +615,7 @@ static void mtk_dsi_poweroff(struct mtk_dsi *dsi) if (--dsi->refcount != 0) return; - if (!mtk_dsi_switch_to_cmd_mode(dsi, VM_DONE_INT_FLAG, 500)) { - if (dsi->panel) { - if (drm_panel_unprepare(dsi->panel)) { - DRM_ERROR("failed to unprepare the panel\n"); - return; - } - } - } - + mtk_dsi_switch_to_cmd_mode(dsi, VM_DONE_INT_FLAG, 500); mtk_dsi_reset_engine(dsi); mtk_dsi_lane0_ulp_mode_enter(dsi); mtk_dsi_clk_ulp_mode_enter(dsi); @@ -669,19 +646,9 @@ static void mtk_output_dsi_enable(struct mtk_dsi *dsi) mtk_dsi_start(dsi); - if (dsi->panel) { - if (drm_panel_enable(dsi->panel)) { - DRM_ERROR("failed to enable the panel\n"); - goto err_dsi_power_off; - } - } - dsi->enabled = true; return; -err_dsi_power_off: - mtk_dsi_stop(dsi); - mtk_dsi_poweroff(dsi); } static void mtk_output_dsi_disable(struct mtk_dsi *dsi) @@ -689,13 +656,6 @@ static void mtk_output_dsi_disable(struct mtk_dsi *dsi) if (!dsi->enabled) return; - if (dsi->panel) { - if (drm_panel_disable(dsi->panel)) { - DRM_ERROR("failed to disable the panel\n"); - return; - } - } - mtk_dsi_stop(dsi); mtk_dsi_poweroff(dsi); @@ -750,13 +710,6 @@ static void mtk_dsi_encoder_enable(struct drm_encoder *encoder) mtk_output_dsi_enable(dsi); } -static int mtk_dsi_connector_get_modes(struct drm_connector *connector) -{ - struct mtk_dsi *dsi = connector_to_dsi(connector); - - return drm_panel_get_modes(dsi->panel); -} - static const struct drm_encoder_helper_funcs mtk_dsi_encoder_helper_funcs = { .mode_fixup = mtk_dsi_encoder_mode_fixup, .mode_set = mtk_dsi_encoder_mode_set, @@ -764,52 +717,7 @@ static const struct drm_encoder_helper_funcs mtk_dsi_encoder_helper_funcs = { .enable = mtk_dsi_encoder_enable, }; -static const struct drm_connector_funcs mtk_dsi_connector_funcs = { - .dpms = drm_atomic_helper_connector_dpms, - .fill_modes = drm_helper_probe_single_connector_modes, - .destroy = drm_connector_cleanup, - .reset = drm_atomic_helper_connector_reset, - .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state, - .atomic_destroy_state = drm_atomic_helper_connector_destroy_state, -}; - -static const struct drm_connector_helper_funcs - mtk_dsi_connector_helper_funcs = { - .get_modes = mtk_dsi_connector_get_modes, -}; - -static int mtk_dsi_create_connector(struct drm_device *drm, struct mtk_dsi *dsi) -{ - int ret; - - ret = drm_connector_init(drm, &dsi->conn, &mtk_dsi_connector_funcs, - DRM_MODE_CONNECTOR_DSI); - if (ret) { - DRM_ERROR("Failed to connector init to drm\n"); - return ret; - } - - drm_connector_helper_add(&dsi->conn, &mtk_dsi_connector_helper_funcs); - - dsi->conn.dpms = DRM_MODE_DPMS_OFF; - drm_mode_connector_attach_encoder(&dsi->conn, &dsi->encoder); - - if (dsi->panel) { - ret = drm_panel_attach(dsi->panel, &dsi->conn); - if (ret) { - DRM_ERROR("Failed to attach panel to drm\n"); - goto err_connector_cleanup; - } - } - - return 0; - -err_connector_cleanup: - drm_connector_cleanup(&dsi->conn); - return ret; -} - -static int mtk_dsi_create_conn_enc(struct drm_device *drm, struct mtk_dsi *dsi) +static int mtk_dsi_create_enc(struct drm_device *drm, struct mtk_dsi *dsi) { int ret; @@ -827,15 +735,10 @@ static int mtk_dsi_create_conn_enc(struct drm_device *drm, struct mtk_dsi *dsi) */ dsi->encoder.possible_crtcs = 1; - /* If there's a bridge, attach to it and let it create the connector */ ret = drm_bridge_attach(&dsi->encoder, dsi->bridge, NULL); if (ret) { DRM_ERROR("Failed to attach bridge to drm\n"); - - /* Otherwise create our own connector and attach to a panel */ - ret = mtk_dsi_create_connector(drm, dsi); - if (ret) - goto err_encoder_cleanup; + goto err_encoder_cleanup; } return 0; @@ -848,9 +751,8 @@ static int mtk_dsi_create_conn_enc(struct drm_device *drm, struct mtk_dsi *dsi) static void mtk_dsi_destroy_conn_enc(struct mtk_dsi *dsi) { drm_encoder_cleanup(&dsi->encoder); - /* Skip connector cleanup if creation was delegated to the bridge */ - if (dsi->conn.dev) - drm_connector_cleanup(&dsi->conn); + if (dsi->panel) + drm_panel_bridge_remove(dsi->bridge); } static void mtk_dsi_ddp_start(struct mtk_ddp_comp *comp) @@ -881,20 +783,12 @@ static int mtk_dsi_host_attach(struct mipi_dsi_host *host, dsi->format = device->format; dsi->mode_flags = device->mode_flags; - if (dsi->conn.dev) - drm_helper_hpd_irq_event(dsi->conn.dev); - return 0; } static int mtk_dsi_host_detach(struct mipi_dsi_host *host, struct mipi_dsi_device *device) { - struct mtk_dsi *dsi = host_to_dsi(host); - - if (dsi->conn.dev) - drm_helper_hpd_irq_event(dsi->conn.dev); - return 0; } @@ -1062,7 +956,7 @@ static int mtk_dsi_bind(struct device *dev, struct device *master, void *data) goto err_ddp_comp_unregister; } - ret = mtk_dsi_create_conn_enc(drm, dsi); + ret = mtk_dsi_create_enc(drm, dsi); if (ret) { DRM_ERROR("Encoder create failed with %d\n", ret); goto err_unregister; @@ -1114,6 +1008,13 @@ static int mtk_dsi_probe(struct platform_device *pdev) if (ret) return ret; + if (dsi->panel) { + dsi->bridge = drm_panel_bridge_add(dsi->panel, + DRM_MODE_CONNECTOR_DSI); + if (IS_ERR(dsi->bridge)) + return PTR_ERR(dsi->bridge); + } + dsi->engine_clk = devm_clk_get(dev, "engine"); if (IS_ERR(dsi->engine_clk)) { ret = PTR_ERR(dsi->engine_clk); -- 2.11.0 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Eric Anholt Subject: [PATCH v2 4/7] drm/mediatek: Use the panel-bridge helper. Date: Thu, 11 May 2017 11:31:25 -0700 Message-ID: <20170511183128.25085-4-eric@anholt.net> References: <20170511183128.25085-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 DABCE6E58F for ; Thu, 11 May 2017 18:31:33 +0000 (UTC) In-Reply-To: <20170511183128.25085-1-eric@anholt.net> 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, Boris Brezillon , Archit Taneja , Andrzej Hajda , Laurent Pinchart , CK Hu , Philipp Zabel , Yannick Fertre , Philippe Cornu Cc: linux-kernel@vger.kernel.org List-Id: dri-devel@lists.freedesktop.org QXZvaWRzIGEgYnVuY2ggb2YgY29ubmVjdG9yIGJvaWxlcnBsYXRlLiAgTm90ZSB0aGF0IHRoaXMg Y2F1c2VzIHBhbmVsCnByZXBhcmUoKSB0byBiZSBtb3ZlZCBiZWZvcmUgbXRrX2RzaV9wb3dlcm9u KCkgYW5kIHVucHJlcGFyZSgpIHRvIGJlCmFmdGVyIHBvd2Vyb2ZmKCkuICBJIHRoaW5rIHRoaXMg aXMgdGhlIGV4cGVjdGVkIHVzYWdlIG9mIHRoZSBwYW5lbCBBUEkKKGVuYWJsZSBzaG91bGQgYmUg d2hlbiB5b3UgZG8gdGhpbmdzIHRoYXQgcmVxdWlyZSB0aGUgbGluayB0byBiZQpicm91Z2h0IHVw KSwgYnV0IHRoZXJlIG1heSBiZSBpc3N1ZXMgaGVyZS4KClNpZ25lZC1vZmYtYnk6IEVyaWMgQW5o b2x0IDxlcmljQGFuaG9sdC5uZXQ+Ci0tLQoKTm90ZSB0aGF0IEkgaGF2ZW4ndCB0ZXN0ZWQgdGhp cyBjaGFuZ2UsIGFuZCBhbSBub3QgY29tbWl0dGVkIHRvIHRoaXMKcGF0Y2guICBJdCdzIGp1c3Qg YW4gb3B0aW9uYWwgY2xlYW51cCwgaWYgaXQgd29ya3MgZm9yIHlvdS4KCiBkcml2ZXJzL2dwdS9k cm0vbWVkaWF0ZWsvbXRrX2RzaS5jIHwgMTI1ICsrKystLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0KIDEgZmlsZSBjaGFuZ2VkLCAxMyBpbnNlcnRpb25zKCspLCAxMTIgZGVsZXRpb25z KC0pCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL21lZGlhdGVrL210a19kc2kuYyBiL2Ry aXZlcnMvZ3B1L2RybS9tZWRpYXRlay9tdGtfZHNpLmMKaW5kZXggODA4Yjk5NWE5OTBmLi43NjRi ZDhiOWMyNTYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9tZWRpYXRlay9tdGtfZHNpLmMK KysrIGIvZHJpdmVycy9ncHUvZHJtL21lZGlhdGVrL210a19kc2kuYwpAQCAtMTYwLDcgKzE2MCw2 IEBAIHN0cnVjdCBtdGtfZHNpIHsKIAlzdHJ1Y3QgZGV2aWNlICpkZXY7CiAJc3RydWN0IG1pcGlf ZHNpX2hvc3QgaG9zdDsKIAlzdHJ1Y3QgZHJtX2VuY29kZXIgZW5jb2RlcjsKLQlzdHJ1Y3QgZHJt X2Nvbm5lY3RvciBjb25uOwogCXN0cnVjdCBkcm1fcGFuZWwgKnBhbmVsOwogCXN0cnVjdCBkcm1f YnJpZGdlICpicmlkZ2U7CiAJc3RydWN0IHBoeSAqcGh5OwpAQCAtMTg4LDExICsxODcsNiBAQCBz dGF0aWMgaW5saW5lIHN0cnVjdCBtdGtfZHNpICplbmNvZGVyX3RvX2RzaShzdHJ1Y3QgZHJtX2Vu Y29kZXIgKmUpCiAJcmV0dXJuIGNvbnRhaW5lcl9vZihlLCBzdHJ1Y3QgbXRrX2RzaSwgZW5jb2Rl cik7CiB9CiAKLXN0YXRpYyBpbmxpbmUgc3RydWN0IG10a19kc2kgKmNvbm5lY3Rvcl90b19kc2ko c3RydWN0IGRybV9jb25uZWN0b3IgKmMpCi17Ci0JcmV0dXJuIGNvbnRhaW5lcl9vZihjLCBzdHJ1 Y3QgbXRrX2RzaSwgY29ubik7Ci19Ci0KIHN0YXRpYyBpbmxpbmUgc3RydWN0IG10a19kc2kgKmhv c3RfdG9fZHNpKHN0cnVjdCBtaXBpX2RzaV9ob3N0ICpoKQogewogCXJldHVybiBjb250YWluZXJf b2YoaCwgc3RydWN0IG10a19kc2ksIGhvc3QpOwpAQCAtNjAzLDE2ICs1OTcsNyBAQCBzdGF0aWMg aW50IG10a19kc2lfcG93ZXJvbihzdHJ1Y3QgbXRrX2RzaSAqZHNpKQogCW10a19kc2lfbGFuZTBf dWxwX21vZGVfbGVhdmUoZHNpKTsKIAltdGtfZHNpX2Nsa19oc19tb2RlKGRzaSwgMCk7CiAKLQlp ZiAoZHNpLT5wYW5lbCkgewotCQlpZiAoZHJtX3BhbmVsX3ByZXBhcmUoZHNpLT5wYW5lbCkpIHsK LQkJCURSTV9FUlJPUigiZmFpbGVkIHRvIHByZXBhcmUgdGhlIHBhbmVsXG4iKTsKLQkJCWdvdG8g ZXJyX2Rpc2FibGVfZGlnaXRhbF9jbGs7Ci0JCX0KLQl9Ci0KIAlyZXR1cm4gMDsKLWVycl9kaXNh YmxlX2RpZ2l0YWxfY2xrOgotCWNsa19kaXNhYmxlX3VucHJlcGFyZShkc2ktPmRpZ2l0YWxfY2xr KTsKIGVycl9kaXNhYmxlX2VuZ2luZV9jbGs6CiAJY2xrX2Rpc2FibGVfdW5wcmVwYXJlKGRzaS0+ ZW5naW5lX2Nsayk7CiBlcnJfcGh5X3Bvd2VyX29mZjoKQEAgLTYzMCwxNSArNjE1LDcgQEAgc3Rh dGljIHZvaWQgbXRrX2RzaV9wb3dlcm9mZihzdHJ1Y3QgbXRrX2RzaSAqZHNpKQogCWlmICgtLWRz aS0+cmVmY291bnQgIT0gMCkKIAkJcmV0dXJuOwogCi0JaWYgKCFtdGtfZHNpX3N3aXRjaF90b19j bWRfbW9kZShkc2ksIFZNX0RPTkVfSU5UX0ZMQUcsIDUwMCkpIHsKLQkJaWYgKGRzaS0+cGFuZWwp IHsKLQkJCWlmIChkcm1fcGFuZWxfdW5wcmVwYXJlKGRzaS0+cGFuZWwpKSB7Ci0JCQkJRFJNX0VS Uk9SKCJmYWlsZWQgdG8gdW5wcmVwYXJlIHRoZSBwYW5lbFxuIik7Ci0JCQkJcmV0dXJuOwotCQkJ fQotCQl9Ci0JfQotCisJbXRrX2RzaV9zd2l0Y2hfdG9fY21kX21vZGUoZHNpLCBWTV9ET05FX0lO VF9GTEFHLCA1MDApOwogCW10a19kc2lfcmVzZXRfZW5naW5lKGRzaSk7CiAJbXRrX2RzaV9sYW5l MF91bHBfbW9kZV9lbnRlcihkc2kpOwogCW10a19kc2lfY2xrX3VscF9tb2RlX2VudGVyKGRzaSk7 CkBAIC02NjksMTkgKzY0Niw5IEBAIHN0YXRpYyB2b2lkIG10a19vdXRwdXRfZHNpX2VuYWJsZShz dHJ1Y3QgbXRrX2RzaSAqZHNpKQogCiAJbXRrX2RzaV9zdGFydChkc2kpOwogCi0JaWYgKGRzaS0+ cGFuZWwpIHsKLQkJaWYgKGRybV9wYW5lbF9lbmFibGUoZHNpLT5wYW5lbCkpIHsKLQkJCURSTV9F UlJPUigiZmFpbGVkIHRvIGVuYWJsZSB0aGUgcGFuZWxcbiIpOwotCQkJZ290byBlcnJfZHNpX3Bv d2VyX29mZjsKLQkJfQotCX0KLQogCWRzaS0+ZW5hYmxlZCA9IHRydWU7CiAKIAlyZXR1cm47Ci1l cnJfZHNpX3Bvd2VyX29mZjoKLQltdGtfZHNpX3N0b3AoZHNpKTsKLQltdGtfZHNpX3Bvd2Vyb2Zm KGRzaSk7CiB9CiAKIHN0YXRpYyB2b2lkIG10a19vdXRwdXRfZHNpX2Rpc2FibGUoc3RydWN0IG10 a19kc2kgKmRzaSkKQEAgLTY4OSwxMyArNjU2LDYgQEAgc3RhdGljIHZvaWQgbXRrX291dHB1dF9k c2lfZGlzYWJsZShzdHJ1Y3QgbXRrX2RzaSAqZHNpKQogCWlmICghZHNpLT5lbmFibGVkKQogCQly ZXR1cm47CiAKLQlpZiAoZHNpLT5wYW5lbCkgewotCQlpZiAoZHJtX3BhbmVsX2Rpc2FibGUoZHNp LT5wYW5lbCkpIHsKLQkJCURSTV9FUlJPUigiZmFpbGVkIHRvIGRpc2FibGUgdGhlIHBhbmVsXG4i KTsKLQkJCXJldHVybjsKLQkJfQotCX0KLQogCW10a19kc2lfc3RvcChkc2kpOwogCW10a19kc2lf cG93ZXJvZmYoZHNpKTsKIApAQCAtNzUwLDEzICs3MTAsNiBAQCBzdGF0aWMgdm9pZCBtdGtfZHNp X2VuY29kZXJfZW5hYmxlKHN0cnVjdCBkcm1fZW5jb2RlciAqZW5jb2RlcikKIAltdGtfb3V0cHV0 X2RzaV9lbmFibGUoZHNpKTsKIH0KIAotc3RhdGljIGludCBtdGtfZHNpX2Nvbm5lY3Rvcl9nZXRf bW9kZXMoc3RydWN0IGRybV9jb25uZWN0b3IgKmNvbm5lY3RvcikKLXsKLQlzdHJ1Y3QgbXRrX2Rz aSAqZHNpID0gY29ubmVjdG9yX3RvX2RzaShjb25uZWN0b3IpOwotCi0JcmV0dXJuIGRybV9wYW5l bF9nZXRfbW9kZXMoZHNpLT5wYW5lbCk7Ci19Ci0KIHN0YXRpYyBjb25zdCBzdHJ1Y3QgZHJtX2Vu Y29kZXJfaGVscGVyX2Z1bmNzIG10a19kc2lfZW5jb2Rlcl9oZWxwZXJfZnVuY3MgPSB7CiAJLm1v ZGVfZml4dXAgPSBtdGtfZHNpX2VuY29kZXJfbW9kZV9maXh1cCwKIAkubW9kZV9zZXQgPSBtdGtf ZHNpX2VuY29kZXJfbW9kZV9zZXQsCkBAIC03NjQsNTIgKzcxNyw3IEBAIHN0YXRpYyBjb25zdCBz dHJ1Y3QgZHJtX2VuY29kZXJfaGVscGVyX2Z1bmNzIG10a19kc2lfZW5jb2Rlcl9oZWxwZXJfZnVu Y3MgPSB7CiAJLmVuYWJsZSA9IG10a19kc2lfZW5jb2Rlcl9lbmFibGUsCiB9OwogCi1zdGF0aWMg Y29uc3Qgc3RydWN0IGRybV9jb25uZWN0b3JfZnVuY3MgbXRrX2RzaV9jb25uZWN0b3JfZnVuY3Mg PSB7Ci0JLmRwbXMgPSBkcm1fYXRvbWljX2hlbHBlcl9jb25uZWN0b3JfZHBtcywKLQkuZmlsbF9t b2RlcyA9IGRybV9oZWxwZXJfcHJvYmVfc2luZ2xlX2Nvbm5lY3Rvcl9tb2RlcywKLQkuZGVzdHJv eSA9IGRybV9jb25uZWN0b3JfY2xlYW51cCwKLQkucmVzZXQgPSBkcm1fYXRvbWljX2hlbHBlcl9j b25uZWN0b3JfcmVzZXQsCi0JLmF0b21pY19kdXBsaWNhdGVfc3RhdGUgPSBkcm1fYXRvbWljX2hl bHBlcl9jb25uZWN0b3JfZHVwbGljYXRlX3N0YXRlLAotCS5hdG9taWNfZGVzdHJveV9zdGF0ZSA9 IGRybV9hdG9taWNfaGVscGVyX2Nvbm5lY3Rvcl9kZXN0cm95X3N0YXRlLAotfTsKLQotc3RhdGlj IGNvbnN0IHN0cnVjdCBkcm1fY29ubmVjdG9yX2hlbHBlcl9mdW5jcwotCW10a19kc2lfY29ubmVj dG9yX2hlbHBlcl9mdW5jcyA9IHsKLQkuZ2V0X21vZGVzID0gbXRrX2RzaV9jb25uZWN0b3JfZ2V0 X21vZGVzLAotfTsKLQotc3RhdGljIGludCBtdGtfZHNpX2NyZWF0ZV9jb25uZWN0b3Ioc3RydWN0 IGRybV9kZXZpY2UgKmRybSwgc3RydWN0IG10a19kc2kgKmRzaSkKLXsKLQlpbnQgcmV0OwotCi0J cmV0ID0gZHJtX2Nvbm5lY3Rvcl9pbml0KGRybSwgJmRzaS0+Y29ubiwgJm10a19kc2lfY29ubmVj dG9yX2Z1bmNzLAotCQkJCSBEUk1fTU9ERV9DT05ORUNUT1JfRFNJKTsKLQlpZiAocmV0KSB7Ci0J CURSTV9FUlJPUigiRmFpbGVkIHRvIGNvbm5lY3RvciBpbml0IHRvIGRybVxuIik7Ci0JCXJldHVy biByZXQ7Ci0JfQotCi0JZHJtX2Nvbm5lY3Rvcl9oZWxwZXJfYWRkKCZkc2ktPmNvbm4sICZtdGtf ZHNpX2Nvbm5lY3Rvcl9oZWxwZXJfZnVuY3MpOwotCi0JZHNpLT5jb25uLmRwbXMgPSBEUk1fTU9E RV9EUE1TX09GRjsKLQlkcm1fbW9kZV9jb25uZWN0b3JfYXR0YWNoX2VuY29kZXIoJmRzaS0+Y29u biwgJmRzaS0+ZW5jb2Rlcik7Ci0KLQlpZiAoZHNpLT5wYW5lbCkgewotCQlyZXQgPSBkcm1fcGFu ZWxfYXR0YWNoKGRzaS0+cGFuZWwsICZkc2ktPmNvbm4pOwotCQlpZiAocmV0KSB7Ci0JCQlEUk1f RVJST1IoIkZhaWxlZCB0byBhdHRhY2ggcGFuZWwgdG8gZHJtXG4iKTsKLQkJCWdvdG8gZXJyX2Nv bm5lY3Rvcl9jbGVhbnVwOwotCQl9Ci0JfQotCi0JcmV0dXJuIDA7Ci0KLWVycl9jb25uZWN0b3Jf Y2xlYW51cDoKLQlkcm1fY29ubmVjdG9yX2NsZWFudXAoJmRzaS0+Y29ubik7Ci0JcmV0dXJuIHJl dDsKLX0KLQotc3RhdGljIGludCBtdGtfZHNpX2NyZWF0ZV9jb25uX2VuYyhzdHJ1Y3QgZHJtX2Rl dmljZSAqZHJtLCBzdHJ1Y3QgbXRrX2RzaSAqZHNpKQorc3RhdGljIGludCBtdGtfZHNpX2NyZWF0 ZV9lbmMoc3RydWN0IGRybV9kZXZpY2UgKmRybSwgc3RydWN0IG10a19kc2kgKmRzaSkKIHsKIAlp bnQgcmV0OwogCkBAIC04MjcsMTUgKzczNSwxMCBAQCBzdGF0aWMgaW50IG10a19kc2lfY3JlYXRl X2Nvbm5fZW5jKHN0cnVjdCBkcm1fZGV2aWNlICpkcm0sIHN0cnVjdCBtdGtfZHNpICpkc2kpCiAJ ICovCiAJZHNpLT5lbmNvZGVyLnBvc3NpYmxlX2NydGNzID0gMTsKIAotCS8qIElmIHRoZXJlJ3Mg YSBicmlkZ2UsIGF0dGFjaCB0byBpdCBhbmQgbGV0IGl0IGNyZWF0ZSB0aGUgY29ubmVjdG9yICov CiAJcmV0ID0gZHJtX2JyaWRnZV9hdHRhY2goJmRzaS0+ZW5jb2RlciwgZHNpLT5icmlkZ2UsIE5V TEwpOwogCWlmIChyZXQpIHsKIAkJRFJNX0VSUk9SKCJGYWlsZWQgdG8gYXR0YWNoIGJyaWRnZSB0 byBkcm1cbiIpOwotCi0JCS8qIE90aGVyd2lzZSBjcmVhdGUgb3VyIG93biBjb25uZWN0b3IgYW5k IGF0dGFjaCB0byBhIHBhbmVsICovCi0JCXJldCA9IG10a19kc2lfY3JlYXRlX2Nvbm5lY3Rvcihk cm0sIGRzaSk7Ci0JCWlmIChyZXQpCi0JCQlnb3RvIGVycl9lbmNvZGVyX2NsZWFudXA7CisJCWdv dG8gZXJyX2VuY29kZXJfY2xlYW51cDsKIAl9CiAKIAlyZXR1cm4gMDsKQEAgLTg0OCw5ICs3NTEs OCBAQCBzdGF0aWMgaW50IG10a19kc2lfY3JlYXRlX2Nvbm5fZW5jKHN0cnVjdCBkcm1fZGV2aWNl ICpkcm0sIHN0cnVjdCBtdGtfZHNpICpkc2kpCiBzdGF0aWMgdm9pZCBtdGtfZHNpX2Rlc3Ryb3lf Y29ubl9lbmMoc3RydWN0IG10a19kc2kgKmRzaSkKIHsKIAlkcm1fZW5jb2Rlcl9jbGVhbnVwKCZk c2ktPmVuY29kZXIpOwotCS8qIFNraXAgY29ubmVjdG9yIGNsZWFudXAgaWYgY3JlYXRpb24gd2Fz IGRlbGVnYXRlZCB0byB0aGUgYnJpZGdlICovCi0JaWYgKGRzaS0+Y29ubi5kZXYpCi0JCWRybV9j b25uZWN0b3JfY2xlYW51cCgmZHNpLT5jb25uKTsKKwlpZiAoZHNpLT5wYW5lbCkKKwkJZHJtX3Bh bmVsX2JyaWRnZV9yZW1vdmUoZHNpLT5icmlkZ2UpOwogfQogCiBzdGF0aWMgdm9pZCBtdGtfZHNp X2RkcF9zdGFydChzdHJ1Y3QgbXRrX2RkcF9jb21wICpjb21wKQpAQCAtODgxLDIwICs3ODMsMTIg QEAgc3RhdGljIGludCBtdGtfZHNpX2hvc3RfYXR0YWNoKHN0cnVjdCBtaXBpX2RzaV9ob3N0ICpo b3N0LAogCWRzaS0+Zm9ybWF0ID0gZGV2aWNlLT5mb3JtYXQ7CiAJZHNpLT5tb2RlX2ZsYWdzID0g ZGV2aWNlLT5tb2RlX2ZsYWdzOwogCi0JaWYgKGRzaS0+Y29ubi5kZXYpCi0JCWRybV9oZWxwZXJf aHBkX2lycV9ldmVudChkc2ktPmNvbm4uZGV2KTsKLQogCXJldHVybiAwOwogfQogCiBzdGF0aWMg aW50IG10a19kc2lfaG9zdF9kZXRhY2goc3RydWN0IG1pcGlfZHNpX2hvc3QgKmhvc3QsCiAJCQkg ICAgICAgc3RydWN0IG1pcGlfZHNpX2RldmljZSAqZGV2aWNlKQogewotCXN0cnVjdCBtdGtfZHNp ICpkc2kgPSBob3N0X3RvX2RzaShob3N0KTsKLQotCWlmIChkc2ktPmNvbm4uZGV2KQotCQlkcm1f aGVscGVyX2hwZF9pcnFfZXZlbnQoZHNpLT5jb25uLmRldik7Ci0KIAlyZXR1cm4gMDsKIH0KIApA QCAtMTA2Miw3ICs5NTYsNyBAQCBzdGF0aWMgaW50IG10a19kc2lfYmluZChzdHJ1Y3QgZGV2aWNl ICpkZXYsIHN0cnVjdCBkZXZpY2UgKm1hc3Rlciwgdm9pZCAqZGF0YSkKIAkJZ290byBlcnJfZGRw X2NvbXBfdW5yZWdpc3RlcjsKIAl9CiAKLQlyZXQgPSBtdGtfZHNpX2NyZWF0ZV9jb25uX2VuYyhk cm0sIGRzaSk7CisJcmV0ID0gbXRrX2RzaV9jcmVhdGVfZW5jKGRybSwgZHNpKTsKIAlpZiAocmV0 KSB7CiAJCURSTV9FUlJPUigiRW5jb2RlciBjcmVhdGUgZmFpbGVkIHdpdGggJWRcbiIsIHJldCk7 CiAJCWdvdG8gZXJyX3VucmVnaXN0ZXI7CkBAIC0xMTE0LDYgKzEwMDgsMTMgQEAgc3RhdGljIGlu dCBtdGtfZHNpX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCiAJaWYgKHJldCkK IAkJcmV0dXJuIHJldDsKIAorCWlmIChkc2ktPnBhbmVsKSB7CisJCWRzaS0+YnJpZGdlID0gZHJt X3BhbmVsX2JyaWRnZV9hZGQoZHNpLT5wYW5lbCwKKwkJCQkJCSAgIERSTV9NT0RFX0NPTk5FQ1RP Ul9EU0kpOworCQlpZiAoSVNfRVJSKGRzaS0+YnJpZGdlKSkKKwkJCXJldHVybiBQVFJfRVJSKGRz aS0+YnJpZGdlKTsKKwl9CisKIAlkc2ktPmVuZ2luZV9jbGsgPSBkZXZtX2Nsa19nZXQoZGV2LCAi ZW5naW5lIik7CiAJaWYgKElTX0VSUihkc2ktPmVuZ2luZV9jbGspKSB7CiAJCXJldCA9IFBUUl9F UlIoZHNpLT5lbmdpbmVfY2xrKTsKLS0gCjIuMTEuMAoKX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxA bGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxt YW4vbGlzdGluZm8vZHJpLWRldmVsCg==