From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.8 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id C7EF2C3A59E for ; Wed, 21 Aug 2019 10:16:24 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 9BA2A22D6D for ; Wed, 21 Aug 2019 10:16:24 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727894AbfHUKQX (ORCPT ); Wed, 21 Aug 2019 06:16:23 -0400 Received: from inva021.nxp.com ([92.121.34.21]:45522 "EHLO inva021.nxp.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726513AbfHUKQT (ORCPT ); Wed, 21 Aug 2019 06:16:19 -0400 Received: from inva021.nxp.com (localhost [127.0.0.1]) by inva021.eu-rdc02.nxp.com (Postfix) with ESMTP id D07FD2004FE; Wed, 21 Aug 2019 12:16:16 +0200 (CEST) Received: from inva024.eu-rdc02.nxp.com (inva024.eu-rdc02.nxp.com [134.27.226.22]) by inva021.eu-rdc02.nxp.com (Postfix) with ESMTP id C1DB9200241; Wed, 21 Aug 2019 12:16:16 +0200 (CEST) Received: from fsr-ub1664-120.ea.freescale.net (fsr-ub1664-120.ea.freescale.net [10.171.82.81]) by inva024.eu-rdc02.nxp.com (Postfix) with ESMTP id 11898205D3; Wed, 21 Aug 2019 12:16:16 +0200 (CEST) From: Robert Chiras To: =?UTF-8?q?Guido=20G=C3=BCnther?= , Marek Vasut , Stefan Agner , David Airlie , Daniel Vetter , Rob Herring , Mark Rutland , Shawn Guo , Sascha Hauer , Fabio Estevam Cc: Pengutronix Kernel Team , NXP Linux Team , dri-devel@lists.freedesktop.org, devicetree@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org Subject: [PATCH v3 01/15] drm/mxsfb: Update mxsfb to support a bridge Date: Wed, 21 Aug 2019 13:15:41 +0300 Message-Id: <1566382555-12102-2-git-send-email-robert.chiras@nxp.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1566382555-12102-1-git-send-email-robert.chiras@nxp.com> References: <1566382555-12102-1-git-send-email-robert.chiras@nxp.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-Virus-Scanned: ClamAV using ClamSMTP Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Currently, the MXSFB DRM driver only supports a panel. But, its output display signal can also be redirected to another encoder, like a DSI controller. In this case, that DSI controller may act like a drm_bridge. In order support this use-case too, this patch adds support for drm_bridge in mxsfb. Signed-off-by: Robert Chiras Tested-by: Guido Günther --- drivers/gpu/drm/mxsfb/mxsfb_crtc.c | 17 +++++++++++--- drivers/gpu/drm/mxsfb/mxsfb_drv.c | 46 +++++++++++++++++++++++++++++++++----- drivers/gpu/drm/mxsfb/mxsfb_drv.h | 4 +++- drivers/gpu/drm/mxsfb/mxsfb_out.c | 26 +++++++++++---------- 4 files changed, 72 insertions(+), 21 deletions(-) diff --git a/drivers/gpu/drm/mxsfb/mxsfb_crtc.c b/drivers/gpu/drm/mxsfb/mxsfb_crtc.c index 1242156..de09b93 100644 --- a/drivers/gpu/drm/mxsfb/mxsfb_crtc.c +++ b/drivers/gpu/drm/mxsfb/mxsfb_crtc.c @@ -95,8 +95,11 @@ static void mxsfb_set_bus_fmt(struct mxsfb_drm_private *mxsfb) reg = readl(mxsfb->base + LCDC_CTRL); - if (mxsfb->connector.display_info.num_bus_formats) - bus_format = mxsfb->connector.display_info.bus_formats[0]; + if (mxsfb->connector->display_info.num_bus_formats) + bus_format = mxsfb->connector->display_info.bus_formats[0]; + + DRM_DEV_DEBUG_DRIVER(drm->dev, "Using bus_format: 0x%08X\n", + bus_format); reg &= ~CTRL_BUS_WIDTH_MASK; switch (bus_format) { @@ -204,8 +207,9 @@ static dma_addr_t mxsfb_get_fb_paddr(struct mxsfb_drm_private *mxsfb) static void mxsfb_crtc_mode_set_nofb(struct mxsfb_drm_private *mxsfb) { + struct drm_device *drm = mxsfb->pipe.crtc.dev; struct drm_display_mode *m = &mxsfb->pipe.crtc.state->adjusted_mode; - const u32 bus_flags = mxsfb->connector.display_info.bus_flags; + const u32 bus_flags = mxsfb->connector->display_info.bus_flags; u32 vdctrl0, vsync_pulse_len, hsync_pulse_len; int err; @@ -229,6 +233,13 @@ static void mxsfb_crtc_mode_set_nofb(struct mxsfb_drm_private *mxsfb) clk_set_rate(mxsfb->clk, m->crtc_clock * 1000); + DRM_DEV_DEBUG_DRIVER(drm->dev, "Pixel clock: %dkHz (actual: %dkHz)\n", + m->crtc_clock, + (int)(clk_get_rate(mxsfb->clk) / 1000)); + DRM_DEV_DEBUG_DRIVER(drm->dev, "Connector bus_flags: 0x%08X\n", + bus_flags); + DRM_DEV_DEBUG_DRIVER(drm->dev, "Mode flags: 0x%08X\n", m->flags); + writel(TRANSFER_COUNT_SET_VCOUNT(m->crtc_vdisplay) | TRANSFER_COUNT_SET_HCOUNT(m->crtc_hdisplay), mxsfb->base + mxsfb->devdata->transfer_count); diff --git a/drivers/gpu/drm/mxsfb/mxsfb_drv.c b/drivers/gpu/drm/mxsfb/mxsfb_drv.c index 878ef68..9dc69b7 100644 --- a/drivers/gpu/drm/mxsfb/mxsfb_drv.c +++ b/drivers/gpu/drm/mxsfb/mxsfb_drv.c @@ -101,9 +101,25 @@ static void mxsfb_pipe_enable(struct drm_simple_display_pipe *pipe, struct drm_crtc_state *crtc_state, struct drm_plane_state *plane_state) { + struct drm_connector *connector; struct mxsfb_drm_private *mxsfb = drm_pipe_to_mxsfb_drm_private(pipe); struct drm_device *drm = pipe->plane.dev; + if (!mxsfb->connector) { + list_for_each_entry(connector, + &drm->mode_config.connector_list, + head) + if (connector->encoder == &mxsfb->pipe.encoder) { + mxsfb->connector = connector; + break; + } + } + + if (!mxsfb->connector) { + dev_warn(drm->dev, "No connector attached, using default\n"); + mxsfb->connector = &mxsfb->panel_connector; + } + pm_runtime_get_sync(drm->dev); drm_panel_prepare(mxsfb->panel); mxsfb_crtc_enable(mxsfb); @@ -129,6 +145,9 @@ static void mxsfb_pipe_disable(struct drm_simple_display_pipe *pipe) drm_crtc_send_vblank_event(crtc, event); } spin_unlock_irq(&drm->event_lock); + + if (mxsfb->connector != &mxsfb->panel_connector) + mxsfb->connector = NULL; } static void mxsfb_pipe_update(struct drm_simple_display_pipe *pipe, @@ -226,16 +245,33 @@ static int mxsfb_load(struct drm_device *drm, unsigned long flags) ret = drm_simple_display_pipe_init(drm, &mxsfb->pipe, &mxsfb_funcs, mxsfb_formats, ARRAY_SIZE(mxsfb_formats), NULL, - &mxsfb->connector); + mxsfb->connector); if (ret < 0) { dev_err(drm->dev, "Cannot setup simple display pipe\n"); goto err_vblank; } - ret = drm_panel_attach(mxsfb->panel, &mxsfb->connector); - if (ret) { - dev_err(drm->dev, "Cannot connect panel\n"); - goto err_vblank; + /* + * Attach panel only if there is one. + * If there is no panel attach, it must be a bridge. In this case, we + * need a reference to its connector for a proper initialization. + * We will do this check in pipe->enable(), since the connector won't + * be attached to an encoder until then. + */ + + if (mxsfb->panel) { + ret = drm_panel_attach(mxsfb->panel, mxsfb->connector); + if (ret) { + dev_err(drm->dev, "Cannot connect panel: %d\n", ret); + goto err_vblank; + } + } else if (mxsfb->bridge) { + ret = drm_simple_display_pipe_attach_bridge(&mxsfb->pipe, + mxsfb->bridge); + if (ret) { + dev_err(drm->dev, "Cannot connect bridge: %d\n", ret); + goto err_vblank; + } } drm->mode_config.min_width = MXSFB_MIN_XRES; diff --git a/drivers/gpu/drm/mxsfb/mxsfb_drv.h b/drivers/gpu/drm/mxsfb/mxsfb_drv.h index d975300..0b65b51 100644 --- a/drivers/gpu/drm/mxsfb/mxsfb_drv.h +++ b/drivers/gpu/drm/mxsfb/mxsfb_drv.h @@ -27,8 +27,10 @@ struct mxsfb_drm_private { struct clk *clk_disp_axi; struct drm_simple_display_pipe pipe; - struct drm_connector connector; + struct drm_connector panel_connector; + struct drm_connector *connector; struct drm_panel *panel; + struct drm_bridge *bridge; }; int mxsfb_setup_crtc(struct drm_device *dev); diff --git a/drivers/gpu/drm/mxsfb/mxsfb_out.c b/drivers/gpu/drm/mxsfb/mxsfb_out.c index 231d016..9506eec 100644 --- a/drivers/gpu/drm/mxsfb/mxsfb_out.c +++ b/drivers/gpu/drm/mxsfb/mxsfb_out.c @@ -21,7 +21,8 @@ static struct mxsfb_drm_private * drm_connector_to_mxsfb_drm_private(struct drm_connector *connector) { - return container_of(connector, struct mxsfb_drm_private, connector); + return container_of(connector, struct mxsfb_drm_private, + panel_connector); } static int mxsfb_panel_get_modes(struct drm_connector *connector) @@ -76,22 +77,23 @@ static const struct drm_connector_funcs mxsfb_panel_connector_funcs = { int mxsfb_create_output(struct drm_device *drm) { struct mxsfb_drm_private *mxsfb = drm->dev_private; - struct drm_panel *panel; int ret; - ret = drm_of_find_panel_or_bridge(drm->dev->of_node, 0, 0, &panel, NULL); + ret = drm_of_find_panel_or_bridge(drm->dev->of_node, 0, 0, + &mxsfb->panel, &mxsfb->bridge); if (ret) return ret; - mxsfb->connector.dpms = DRM_MODE_DPMS_OFF; - mxsfb->connector.polled = 0; - drm_connector_helper_add(&mxsfb->connector, - &mxsfb_panel_connector_helper_funcs); - ret = drm_connector_init(drm, &mxsfb->connector, - &mxsfb_panel_connector_funcs, - DRM_MODE_CONNECTOR_Unknown); - if (!ret) - mxsfb->panel = panel; + if (mxsfb->panel) { + mxsfb->connector = &mxsfb->panel_connector; + mxsfb->connector->dpms = DRM_MODE_DPMS_OFF; + mxsfb->connector->polled = 0; + drm_connector_helper_add(mxsfb->connector, + &mxsfb_panel_connector_helper_funcs); + ret = drm_connector_init(drm, mxsfb->connector, + &mxsfb_panel_connector_funcs, + DRM_MODE_CONNECTOR_Unknown); + } return ret; } -- 2.7.4 From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.8 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 9A43EC3A59B for ; Wed, 21 Aug 2019 10:17:14 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 65C3722D6D for ; Wed, 21 Aug 2019 10:17:14 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="bRaBktj8" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 65C3722D6D Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=nxp.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+infradead-linux-arm-kernel=archiver.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:Cc:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Message-Id:Date:Subject:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=IjrWSyAdkRMX174U5B0o9NQHYEUOco3viIqTvIFciYo=; b=bRaBktj8JGkBFT PgETMuQPKlpuF79NTWmhWk7AuCJmjhw28/Eh9JFS1Moho1z13RVKOJFbtCk0huqtHMkMO6RSFh92F OUyHDRNdoFPG4ROpfFcoZj+t8NBSJjzoDc7Zm9/d//r+YUK8qvyv3emHx3Iinzi8SFHXLR3IpVCq/ x390mUxNQPS6aNKA9AsdgOrYnMQn+R/jsrtdgq5lP0DvMnslVrWbw83Fv0wa7q/UMWv66vhlUhsu8 tIMZIq6ag3lUZTxhR/iCUgvR9TYARDcKd81Zn53tsTuRGqVmrQNrKhEDwJuimvI1LtXZ6jIsWHflX YTtRMspkGZYHQNsE2MNQ==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92 #3 (Red Hat Linux)) id 1i0Nfs-0002Nn-Eq; Wed, 21 Aug 2019 10:17:04 +0000 Received: from inva021.nxp.com ([92.121.34.21]) by bombadil.infradead.org with esmtps (Exim 4.92 #3 (Red Hat Linux)) id 1i0NfA-00024l-3W for linux-arm-kernel@lists.infradead.org; Wed, 21 Aug 2019 10:16:22 +0000 Received: from inva021.nxp.com (localhost [127.0.0.1]) by inva021.eu-rdc02.nxp.com (Postfix) with ESMTP id D07FD2004FE; Wed, 21 Aug 2019 12:16:16 +0200 (CEST) Received: from inva024.eu-rdc02.nxp.com (inva024.eu-rdc02.nxp.com [134.27.226.22]) by inva021.eu-rdc02.nxp.com (Postfix) with ESMTP id C1DB9200241; Wed, 21 Aug 2019 12:16:16 +0200 (CEST) Received: from fsr-ub1664-120.ea.freescale.net (fsr-ub1664-120.ea.freescale.net [10.171.82.81]) by inva024.eu-rdc02.nxp.com (Postfix) with ESMTP id 11898205D3; Wed, 21 Aug 2019 12:16:16 +0200 (CEST) From: Robert Chiras To: =?UTF-8?q?Guido=20G=C3=BCnther?= , Marek Vasut , Stefan Agner , David Airlie , Daniel Vetter , Rob Herring , Mark Rutland , Shawn Guo , Sascha Hauer , Fabio Estevam Subject: [PATCH v3 01/15] drm/mxsfb: Update mxsfb to support a bridge Date: Wed, 21 Aug 2019 13:15:41 +0300 Message-Id: <1566382555-12102-2-git-send-email-robert.chiras@nxp.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1566382555-12102-1-git-send-email-robert.chiras@nxp.com> References: <1566382555-12102-1-git-send-email-robert.chiras@nxp.com> MIME-Version: 1.0 X-Virus-Scanned: ClamAV using ClamSMTP X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20190821_031620_431662_D08A11F8 X-CRM114-Status: GOOD ( 19.73 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, NXP Linux Team , Pengutronix Kernel Team , linux-arm-kernel@lists.infradead.org Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+infradead-linux-arm-kernel=archiver.kernel.org@lists.infradead.org Q3VycmVudGx5LCB0aGUgTVhTRkIgRFJNIGRyaXZlciBvbmx5IHN1cHBvcnRzIGEgcGFuZWwuIEJ1 dCwgaXRzIG91dHB1dApkaXNwbGF5IHNpZ25hbCBjYW4gYWxzbyBiZSByZWRpcmVjdGVkIHRvIGFu b3RoZXIgZW5jb2RlciwgbGlrZSBhIERTSQpjb250cm9sbGVyLiBJbiB0aGlzIGNhc2UsIHRoYXQg RFNJIGNvbnRyb2xsZXIgbWF5IGFjdCBsaWtlIGEgZHJtX2JyaWRnZS4KSW4gb3JkZXIgc3VwcG9y dCB0aGlzIHVzZS1jYXNlIHRvbywgdGhpcyBwYXRjaCBhZGRzIHN1cHBvcnQgZm9yIGRybV9icmlk Z2UKaW4gbXhzZmIuCgpTaWduZWQtb2ZmLWJ5OiBSb2JlcnQgQ2hpcmFzIDxyb2JlcnQuY2hpcmFz QG54cC5jb20+ClRlc3RlZC1ieTogR3VpZG8gR8O8bnRoZXIgPGFneEBzaWd4Y3B1Lm9yZz4KLS0t CiBkcml2ZXJzL2dwdS9kcm0vbXhzZmIvbXhzZmJfY3J0Yy5jIHwgMTcgKysrKysrKysrKystLS0K IGRyaXZlcnMvZ3B1L2RybS9teHNmYi9teHNmYl9kcnYuYyAgfCA0NiArKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKystLS0tLQogZHJpdmVycy9ncHUvZHJtL214c2ZiL214c2ZiX2Rydi5o ICB8ICA0ICsrKy0KIGRyaXZlcnMvZ3B1L2RybS9teHNmYi9teHNmYl9vdXQuYyAgfCAyNiArKysr KysrKysrKy0tLS0tLS0tLS0KIDQgZmlsZXMgY2hhbmdlZCwgNzIgaW5zZXJ0aW9ucygrKSwgMjEg ZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL214c2ZiL214c2ZiX2Ny dGMuYyBiL2RyaXZlcnMvZ3B1L2RybS9teHNmYi9teHNmYl9jcnRjLmMKaW5kZXggMTI0MjE1Ni4u ZGUwOWI5MyAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL214c2ZiL214c2ZiX2NydGMuYwor KysgYi9kcml2ZXJzL2dwdS9kcm0vbXhzZmIvbXhzZmJfY3J0Yy5jCkBAIC05NSw4ICs5NSwxMSBA QCBzdGF0aWMgdm9pZCBteHNmYl9zZXRfYnVzX2ZtdChzdHJ1Y3QgbXhzZmJfZHJtX3ByaXZhdGUg Km14c2ZiKQogCiAJcmVnID0gcmVhZGwobXhzZmItPmJhc2UgKyBMQ0RDX0NUUkwpOwogCi0JaWYg KG14c2ZiLT5jb25uZWN0b3IuZGlzcGxheV9pbmZvLm51bV9idXNfZm9ybWF0cykKLQkJYnVzX2Zv cm1hdCA9IG14c2ZiLT5jb25uZWN0b3IuZGlzcGxheV9pbmZvLmJ1c19mb3JtYXRzWzBdOworCWlm IChteHNmYi0+Y29ubmVjdG9yLT5kaXNwbGF5X2luZm8ubnVtX2J1c19mb3JtYXRzKQorCQlidXNf Zm9ybWF0ID0gbXhzZmItPmNvbm5lY3Rvci0+ZGlzcGxheV9pbmZvLmJ1c19mb3JtYXRzWzBdOwor CisJRFJNX0RFVl9ERUJVR19EUklWRVIoZHJtLT5kZXYsICJVc2luZyBidXNfZm9ybWF0OiAweCUw OFhcbiIsCisJCQkgICAgIGJ1c19mb3JtYXQpOwogCiAJcmVnICY9IH5DVFJMX0JVU19XSURUSF9N QVNLOwogCXN3aXRjaCAoYnVzX2Zvcm1hdCkgewpAQCAtMjA0LDggKzIwNyw5IEBAIHN0YXRpYyBk bWFfYWRkcl90IG14c2ZiX2dldF9mYl9wYWRkcihzdHJ1Y3QgbXhzZmJfZHJtX3ByaXZhdGUgKm14 c2ZiKQogCiBzdGF0aWMgdm9pZCBteHNmYl9jcnRjX21vZGVfc2V0X25vZmIoc3RydWN0IG14c2Zi X2RybV9wcml2YXRlICpteHNmYikKIHsKKwlzdHJ1Y3QgZHJtX2RldmljZSAqZHJtID0gbXhzZmIt PnBpcGUuY3J0Yy5kZXY7CiAJc3RydWN0IGRybV9kaXNwbGF5X21vZGUgKm0gPSAmbXhzZmItPnBp cGUuY3J0Yy5zdGF0ZS0+YWRqdXN0ZWRfbW9kZTsKLQljb25zdCB1MzIgYnVzX2ZsYWdzID0gbXhz ZmItPmNvbm5lY3Rvci5kaXNwbGF5X2luZm8uYnVzX2ZsYWdzOworCWNvbnN0IHUzMiBidXNfZmxh Z3MgPSBteHNmYi0+Y29ubmVjdG9yLT5kaXNwbGF5X2luZm8uYnVzX2ZsYWdzOwogCXUzMiB2ZGN0 cmwwLCB2c3luY19wdWxzZV9sZW4sIGhzeW5jX3B1bHNlX2xlbjsKIAlpbnQgZXJyOwogCkBAIC0y MjksNiArMjMzLDEzIEBAIHN0YXRpYyB2b2lkIG14c2ZiX2NydGNfbW9kZV9zZXRfbm9mYihzdHJ1 Y3QgbXhzZmJfZHJtX3ByaXZhdGUgKm14c2ZiKQogCiAJY2xrX3NldF9yYXRlKG14c2ZiLT5jbGss IG0tPmNydGNfY2xvY2sgKiAxMDAwKTsKIAorCURSTV9ERVZfREVCVUdfRFJJVkVSKGRybS0+ZGV2 LCAiUGl4ZWwgY2xvY2s6ICVka0h6IChhY3R1YWw6ICVka0h6KVxuIiwKKwkJCSAgICAgbS0+Y3J0 Y19jbG9jaywKKwkJCSAgICAgKGludCkoY2xrX2dldF9yYXRlKG14c2ZiLT5jbGspIC8gMTAwMCkp OworCURSTV9ERVZfREVCVUdfRFJJVkVSKGRybS0+ZGV2LCAiQ29ubmVjdG9yIGJ1c19mbGFnczog MHglMDhYXG4iLAorCQkJICAgICBidXNfZmxhZ3MpOworCURSTV9ERVZfREVCVUdfRFJJVkVSKGRy bS0+ZGV2LCAiTW9kZSBmbGFnczogMHglMDhYXG4iLCBtLT5mbGFncyk7CisKIAl3cml0ZWwoVFJB TlNGRVJfQ09VTlRfU0VUX1ZDT1VOVChtLT5jcnRjX3ZkaXNwbGF5KSB8CiAJICAgICAgIFRSQU5T RkVSX0NPVU5UX1NFVF9IQ09VTlQobS0+Y3J0Y19oZGlzcGxheSksCiAJICAgICAgIG14c2ZiLT5i YXNlICsgbXhzZmItPmRldmRhdGEtPnRyYW5zZmVyX2NvdW50KTsKZGlmZiAtLWdpdCBhL2RyaXZl cnMvZ3B1L2RybS9teHNmYi9teHNmYl9kcnYuYyBiL2RyaXZlcnMvZ3B1L2RybS9teHNmYi9teHNm Yl9kcnYuYwppbmRleCA4NzhlZjY4Li45ZGM2OWI3IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9k cm0vbXhzZmIvbXhzZmJfZHJ2LmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL214c2ZiL214c2ZiX2Ry di5jCkBAIC0xMDEsOSArMTAxLDI1IEBAIHN0YXRpYyB2b2lkIG14c2ZiX3BpcGVfZW5hYmxlKHN0 cnVjdCBkcm1fc2ltcGxlX2Rpc3BsYXlfcGlwZSAqcGlwZSwKIAkJCSAgICAgIHN0cnVjdCBkcm1f Y3J0Y19zdGF0ZSAqY3J0Y19zdGF0ZSwKIAkJCSAgICAgIHN0cnVjdCBkcm1fcGxhbmVfc3RhdGUg KnBsYW5lX3N0YXRlKQogeworCXN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3I7CiAJc3Ry dWN0IG14c2ZiX2RybV9wcml2YXRlICpteHNmYiA9IGRybV9waXBlX3RvX214c2ZiX2RybV9wcml2 YXRlKHBpcGUpOwogCXN0cnVjdCBkcm1fZGV2aWNlICpkcm0gPSBwaXBlLT5wbGFuZS5kZXY7CiAK KwlpZiAoIW14c2ZiLT5jb25uZWN0b3IpIHsKKwkJbGlzdF9mb3JfZWFjaF9lbnRyeShjb25uZWN0 b3IsCisJCQkJICAgICZkcm0tPm1vZGVfY29uZmlnLmNvbm5lY3Rvcl9saXN0LAorCQkJCSAgICBo ZWFkKQorCQkJaWYgKGNvbm5lY3Rvci0+ZW5jb2RlciA9PSAmbXhzZmItPnBpcGUuZW5jb2Rlcikg eworCQkJCW14c2ZiLT5jb25uZWN0b3IgPSBjb25uZWN0b3I7CisJCQkJYnJlYWs7CisJCQl9CisJ fQorCisJaWYgKCFteHNmYi0+Y29ubmVjdG9yKSB7CisJCWRldl93YXJuKGRybS0+ZGV2LCAiTm8g Y29ubmVjdG9yIGF0dGFjaGVkLCB1c2luZyBkZWZhdWx0XG4iKTsKKwkJbXhzZmItPmNvbm5lY3Rv ciA9ICZteHNmYi0+cGFuZWxfY29ubmVjdG9yOworCX0KKwogCXBtX3J1bnRpbWVfZ2V0X3N5bmMo ZHJtLT5kZXYpOwogCWRybV9wYW5lbF9wcmVwYXJlKG14c2ZiLT5wYW5lbCk7CiAJbXhzZmJfY3J0 Y19lbmFibGUobXhzZmIpOwpAQCAtMTI5LDYgKzE0NSw5IEBAIHN0YXRpYyB2b2lkIG14c2ZiX3Bp cGVfZGlzYWJsZShzdHJ1Y3QgZHJtX3NpbXBsZV9kaXNwbGF5X3BpcGUgKnBpcGUpCiAJCWRybV9j cnRjX3NlbmRfdmJsYW5rX2V2ZW50KGNydGMsIGV2ZW50KTsKIAl9CiAJc3Bpbl91bmxvY2tfaXJx KCZkcm0tPmV2ZW50X2xvY2spOworCisJaWYgKG14c2ZiLT5jb25uZWN0b3IgIT0gJm14c2ZiLT5w YW5lbF9jb25uZWN0b3IpCisJCW14c2ZiLT5jb25uZWN0b3IgPSBOVUxMOwogfQogCiBzdGF0aWMg dm9pZCBteHNmYl9waXBlX3VwZGF0ZShzdHJ1Y3QgZHJtX3NpbXBsZV9kaXNwbGF5X3BpcGUgKnBp cGUsCkBAIC0yMjYsMTYgKzI0NSwzMyBAQCBzdGF0aWMgaW50IG14c2ZiX2xvYWQoc3RydWN0IGRy bV9kZXZpY2UgKmRybSwgdW5zaWduZWQgbG9uZyBmbGFncykKIAogCXJldCA9IGRybV9zaW1wbGVf ZGlzcGxheV9waXBlX2luaXQoZHJtLCAmbXhzZmItPnBpcGUsICZteHNmYl9mdW5jcywKIAkJCW14 c2ZiX2Zvcm1hdHMsIEFSUkFZX1NJWkUobXhzZmJfZm9ybWF0cyksIE5VTEwsCi0JCQkmbXhzZmIt PmNvbm5lY3Rvcik7CisJCQlteHNmYi0+Y29ubmVjdG9yKTsKIAlpZiAocmV0IDwgMCkgewogCQlk ZXZfZXJyKGRybS0+ZGV2LCAiQ2Fubm90IHNldHVwIHNpbXBsZSBkaXNwbGF5IHBpcGVcbiIpOwog CQlnb3RvIGVycl92Ymxhbms7CiAJfQogCi0JcmV0ID0gZHJtX3BhbmVsX2F0dGFjaChteHNmYi0+ cGFuZWwsICZteHNmYi0+Y29ubmVjdG9yKTsKLQlpZiAocmV0KSB7Ci0JCWRldl9lcnIoZHJtLT5k ZXYsICJDYW5ub3QgY29ubmVjdCBwYW5lbFxuIik7Ci0JCWdvdG8gZXJyX3ZibGFuazsKKwkvKgor CSAqIEF0dGFjaCBwYW5lbCBvbmx5IGlmIHRoZXJlIGlzIG9uZS4KKwkgKiBJZiB0aGVyZSBpcyBu byBwYW5lbCBhdHRhY2gsIGl0IG11c3QgYmUgYSBicmlkZ2UuIEluIHRoaXMgY2FzZSwgd2UKKwkg KiBuZWVkIGEgcmVmZXJlbmNlIHRvIGl0cyBjb25uZWN0b3IgZm9yIGEgcHJvcGVyIGluaXRpYWxp emF0aW9uLgorCSAqIFdlIHdpbGwgZG8gdGhpcyBjaGVjayBpbiBwaXBlLT5lbmFibGUoKSwgc2lu Y2UgdGhlIGNvbm5lY3RvciB3b24ndAorCSAqIGJlIGF0dGFjaGVkIHRvIGFuIGVuY29kZXIgdW50 aWwgdGhlbi4KKwkgKi8KKworCWlmIChteHNmYi0+cGFuZWwpIHsKKwkJcmV0ID0gZHJtX3BhbmVs X2F0dGFjaChteHNmYi0+cGFuZWwsIG14c2ZiLT5jb25uZWN0b3IpOworCQlpZiAocmV0KSB7CisJ CQlkZXZfZXJyKGRybS0+ZGV2LCAiQ2Fubm90IGNvbm5lY3QgcGFuZWw6ICVkXG4iLCByZXQpOwor CQkJZ290byBlcnJfdmJsYW5rOworCQl9CisJfSBlbHNlIGlmIChteHNmYi0+YnJpZGdlKSB7CisJ CXJldCA9IGRybV9zaW1wbGVfZGlzcGxheV9waXBlX2F0dGFjaF9icmlkZ2UoJm14c2ZiLT5waXBl LAorCQkJCQkJCSAgICBteHNmYi0+YnJpZGdlKTsKKwkJaWYgKHJldCkgeworCQkJZGV2X2Vycihk cm0tPmRldiwgIkNhbm5vdCBjb25uZWN0IGJyaWRnZTogJWRcbiIsIHJldCk7CisJCQlnb3RvIGVy cl92Ymxhbms7CisJCX0KIAl9CiAKIAlkcm0tPm1vZGVfY29uZmlnLm1pbl93aWR0aAk9IE1YU0ZC X01JTl9YUkVTOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL214c2ZiL214c2ZiX2Rydi5o IGIvZHJpdmVycy9ncHUvZHJtL214c2ZiL214c2ZiX2Rydi5oCmluZGV4IGQ5NzUzMDAuLjBiNjVi NTEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9teHNmYi9teHNmYl9kcnYuaAorKysgYi9k cml2ZXJzL2dwdS9kcm0vbXhzZmIvbXhzZmJfZHJ2LmgKQEAgLTI3LDggKzI3LDEwIEBAIHN0cnVj dCBteHNmYl9kcm1fcHJpdmF0ZSB7CiAJc3RydWN0IGNsawkJCSpjbGtfZGlzcF9heGk7CiAKIAlz dHJ1Y3QgZHJtX3NpbXBsZV9kaXNwbGF5X3BpcGUJcGlwZTsKLQlzdHJ1Y3QgZHJtX2Nvbm5lY3Rv cgkJY29ubmVjdG9yOworCXN0cnVjdCBkcm1fY29ubmVjdG9yCQlwYW5lbF9jb25uZWN0b3I7CisJ c3RydWN0IGRybV9jb25uZWN0b3IJCSpjb25uZWN0b3I7CiAJc3RydWN0IGRybV9wYW5lbAkJKnBh bmVsOworCXN0cnVjdCBkcm1fYnJpZGdlCQkqYnJpZGdlOwogfTsKIAogaW50IG14c2ZiX3NldHVw X2NydGMoc3RydWN0IGRybV9kZXZpY2UgKmRldik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9k cm0vbXhzZmIvbXhzZmJfb3V0LmMgYi9kcml2ZXJzL2dwdS9kcm0vbXhzZmIvbXhzZmJfb3V0LmMK aW5kZXggMjMxZDAxNi4uOTUwNmVlYyAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL214c2Zi L214c2ZiX291dC5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9teHNmYi9teHNmYl9vdXQuYwpAQCAt MjEsNyArMjEsOCBAQAogc3RhdGljIHN0cnVjdCBteHNmYl9kcm1fcHJpdmF0ZSAqCiBkcm1fY29u bmVjdG9yX3RvX214c2ZiX2RybV9wcml2YXRlKHN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0 b3IpCiB7Ci0JcmV0dXJuIGNvbnRhaW5lcl9vZihjb25uZWN0b3IsIHN0cnVjdCBteHNmYl9kcm1f cHJpdmF0ZSwgY29ubmVjdG9yKTsKKwlyZXR1cm4gY29udGFpbmVyX29mKGNvbm5lY3Rvciwgc3Ry dWN0IG14c2ZiX2RybV9wcml2YXRlLAorCQkJICAgIHBhbmVsX2Nvbm5lY3Rvcik7CiB9CiAKIHN0 YXRpYyBpbnQgbXhzZmJfcGFuZWxfZ2V0X21vZGVzKHN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25u ZWN0b3IpCkBAIC03NiwyMiArNzcsMjMgQEAgc3RhdGljIGNvbnN0IHN0cnVjdCBkcm1fY29ubmVj dG9yX2Z1bmNzIG14c2ZiX3BhbmVsX2Nvbm5lY3Rvcl9mdW5jcyA9IHsKIGludCBteHNmYl9jcmVh dGVfb3V0cHV0KHN0cnVjdCBkcm1fZGV2aWNlICpkcm0pCiB7CiAJc3RydWN0IG14c2ZiX2RybV9w cml2YXRlICpteHNmYiA9IGRybS0+ZGV2X3ByaXZhdGU7Ci0Jc3RydWN0IGRybV9wYW5lbCAqcGFu ZWw7CiAJaW50IHJldDsKIAotCXJldCA9IGRybV9vZl9maW5kX3BhbmVsX29yX2JyaWRnZShkcm0t PmRldi0+b2Zfbm9kZSwgMCwgMCwgJnBhbmVsLCBOVUxMKTsKKwlyZXQgPSBkcm1fb2ZfZmluZF9w YW5lbF9vcl9icmlkZ2UoZHJtLT5kZXYtPm9mX25vZGUsIDAsIDAsCisJCQkJCSAgJm14c2ZiLT5w YW5lbCwgJm14c2ZiLT5icmlkZ2UpOwogCWlmIChyZXQpCiAJCXJldHVybiByZXQ7CiAKLQlteHNm Yi0+Y29ubmVjdG9yLmRwbXMgPSBEUk1fTU9ERV9EUE1TX09GRjsKLQlteHNmYi0+Y29ubmVjdG9y LnBvbGxlZCA9IDA7Ci0JZHJtX2Nvbm5lY3Rvcl9oZWxwZXJfYWRkKCZteHNmYi0+Y29ubmVjdG9y LAotCQkJJm14c2ZiX3BhbmVsX2Nvbm5lY3Rvcl9oZWxwZXJfZnVuY3MpOwotCXJldCA9IGRybV9j b25uZWN0b3JfaW5pdChkcm0sICZteHNmYi0+Y29ubmVjdG9yLAotCQkJCSAmbXhzZmJfcGFuZWxf Y29ubmVjdG9yX2Z1bmNzLAotCQkJCSBEUk1fTU9ERV9DT05ORUNUT1JfVW5rbm93bik7Ci0JaWYg KCFyZXQpCi0JCW14c2ZiLT5wYW5lbCA9IHBhbmVsOworCWlmIChteHNmYi0+cGFuZWwpIHsKKwkJ bXhzZmItPmNvbm5lY3RvciA9ICZteHNmYi0+cGFuZWxfY29ubmVjdG9yOworCQlteHNmYi0+Y29u bmVjdG9yLT5kcG1zID0gRFJNX01PREVfRFBNU19PRkY7CisJCW14c2ZiLT5jb25uZWN0b3ItPnBv bGxlZCA9IDA7CisJCWRybV9jb25uZWN0b3JfaGVscGVyX2FkZChteHNmYi0+Y29ubmVjdG9yLAor CQkJCQkgJm14c2ZiX3BhbmVsX2Nvbm5lY3Rvcl9oZWxwZXJfZnVuY3MpOworCQlyZXQgPSBkcm1f Y29ubmVjdG9yX2luaXQoZHJtLCBteHNmYi0+Y29ubmVjdG9yLAorCQkJCQkgJm14c2ZiX3BhbmVs X2Nvbm5lY3Rvcl9mdW5jcywKKwkJCQkJIERSTV9NT0RFX0NPTk5FQ1RPUl9Vbmtub3duKTsKKwl9 CiAKIAlyZXR1cm4gcmV0OwogfQotLSAKMi43LjQKCgpfX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fXwpsaW51eC1hcm0ta2VybmVsIG1haWxpbmcgbGlzdApsaW51 eC1hcm0ta2VybmVsQGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5v cmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1hcm0ta2VybmVsCg==