From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753292AbdCTIfl (ORCPT ); Mon, 20 Mar 2017 04:35:41 -0400 Received: from mail-wm0-f65.google.com ([74.125.82.65]:36480 "EHLO mail-wm0-f65.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753084AbdCTIe1 (ORCPT ); Mon, 20 Mar 2017 04:34:27 -0400 Date: Mon, 20 Mar 2017 09:34:22 +0100 From: Daniel Vetter To: Eric Anholt Cc: dri-devel@lists.freedesktop.org, tom.cooksey@arm.com, Russell King , linux-kernel@vger.kernel.org Subject: Re: [PATCH 2/2] drm/pl111: Initial drm/kms driver for pl111 Message-ID: <20170320083422.sd6uvisgdgajwxtr@phenom.ffwll.local> Mail-Followup-To: Eric Anholt , dri-devel@lists.freedesktop.org, tom.cooksey@arm.com, Russell King , linux-kernel@vger.kernel.org References: <20170317224742.17219-1-eric@anholt.net> <20170317224742.17219-3-eric@anholt.net> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <20170317224742.17219-3-eric@anholt.net> X-Operating-System: Linux phenom 4.8.0-1-amd64 User-Agent: NeoMutt/20170113 (1.7.2) Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Fri, Mar 17, 2017 at 03:47:42PM -0700, Eric Anholt wrote: > From: Tom Cooksey > > This is a modesetting driver for the pl111 CLCD display controller > found on various ARM platforms such as the Versatile Express. The > driver has only been tested on the bcm911360_entphn platform so far, > with PRIME-based buffer sharing between vc4 and clcd. > > It reuses the existing devicetree binding, while not using quite as > many of its properties as the fbdev driver does (those are left for > future work). > > v2: Nearly complete rewrite by anholt, cutting 2/3 of the code thanks > to DRM core's excellent new helpers. > > Signed-off-by: Tom Cooksey > Signed-off-by: Eric Anholt Looks pretty. A few things below, but nothing big. I'd say if the "how generic do we want this to be for now" question is resolved it's ready to go in. If you want this in drm-misc (imo fine, you're already there so doesn't really extend the scope of the experiment), then please also add a MAINTAINERS entry with the drm-misc git repo and yourself as reviewer. Cheers, Daniel > --- > Documentation/gpu/index.rst | 1 + > Documentation/gpu/pl111.rst | 6 + > drivers/gpu/drm/Kconfig | 2 + > drivers/gpu/drm/Makefile | 1 + > drivers/gpu/drm/pl111/Kconfig | 12 ++ > drivers/gpu/drm/pl111/Makefile | 8 + > drivers/gpu/drm/pl111/pl111_connector.c | 127 ++++++++++++++ > drivers/gpu/drm/pl111/pl111_crtc.c | 239 ++++++++++++++++++++++++++ > drivers/gpu/drm/pl111/pl111_drm.h | 64 +++++++ > drivers/gpu/drm/pl111/pl111_drv.c | 292 ++++++++++++++++++++++++++++++++ > drivers/gpu/drm/pl111/pl111_encoder.c | 50 ++++++ > drivers/gpu/drm/pl111/pl111_gem.c | 35 ++++ > drivers/gpu/drm/pl111/pl111_plane.c | 167 ++++++++++++++++++ > 13 files changed, 1004 insertions(+) > create mode 100644 Documentation/gpu/pl111.rst > create mode 100644 drivers/gpu/drm/pl111/Kconfig > create mode 100644 drivers/gpu/drm/pl111/Makefile > create mode 100644 drivers/gpu/drm/pl111/pl111_connector.c > create mode 100644 drivers/gpu/drm/pl111/pl111_crtc.c > create mode 100644 drivers/gpu/drm/pl111/pl111_drm.h > create mode 100644 drivers/gpu/drm/pl111/pl111_drv.c > create mode 100644 drivers/gpu/drm/pl111/pl111_encoder.c > create mode 100644 drivers/gpu/drm/pl111/pl111_gem.c > create mode 100644 drivers/gpu/drm/pl111/pl111_plane.c > > diff --git a/Documentation/gpu/index.rst b/Documentation/gpu/index.rst > index e998ee0d0dd5..71bf510d47e8 100644 > --- a/Documentation/gpu/index.rst > +++ b/Documentation/gpu/index.rst > @@ -11,6 +11,7 @@ Linux GPU Driver Developer's Guide > drm-kms-helpers > drm-uapi > i915 > + pl111 > tinydrm > vc4 > vga-switcheroo > diff --git a/Documentation/gpu/pl111.rst b/Documentation/gpu/pl111.rst > new file mode 100644 > index 000000000000..9b03736d33dd > --- /dev/null > +++ b/Documentation/gpu/pl111.rst > @@ -0,0 +1,6 @@ > +========================================== > + drm/pl111 ARM PrimeCell PL111 CLCD Driver > +========================================== > + > +.. kernel-doc:: drivers/gpu/drm/pl111/pl111_drv.c > + :doc: ARM PrimeCell PL111 CLCD Driver > diff --git a/drivers/gpu/drm/Kconfig b/drivers/gpu/drm/Kconfig > index 78d7fc0ebb57..d1c6c12199b7 100644 > --- a/drivers/gpu/drm/Kconfig > +++ b/drivers/gpu/drm/Kconfig > @@ -274,6 +274,8 @@ source "drivers/gpu/drm/meson/Kconfig" > > source "drivers/gpu/drm/tinydrm/Kconfig" > > +source "drivers/gpu/drm/pl111/Kconfig" > + > # Keep legacy drivers last > > menuconfig DRM_LEGACY > diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile > index 59aae43005ee..99810a529bb0 100644 > --- a/drivers/gpu/drm/Makefile > +++ b/drivers/gpu/drm/Makefile > @@ -95,3 +95,4 @@ obj-y += hisilicon/ > obj-$(CONFIG_DRM_ZTE) += zte/ > obj-$(CONFIG_DRM_MXSFB) += mxsfb/ > obj-$(CONFIG_DRM_TINYDRM) += tinydrm/ > +obj-$(CONFIG_DRM_PL111) += pl111/ > diff --git a/drivers/gpu/drm/pl111/Kconfig b/drivers/gpu/drm/pl111/Kconfig > new file mode 100644 > index 000000000000..ede49efd531f > --- /dev/null > +++ b/drivers/gpu/drm/pl111/Kconfig > @@ -0,0 +1,12 @@ > +config DRM_PL111 > + tristate "DRM Support for PL111 CLCD Controller" > + depends on DRM > + depends on ARM || ARM64 || COMPILE_TEST > + select DRM_KMS_HELPER > + select DRM_KMS_CMA_HELPER > + select DRM_GEM_CMA_HELPER > + select VT_HW_CONSOLE_BINDING if FRAMEBUFFER_CONSOLE > + help > + Choose this option for DRM support for the PL111 CLCD controller. > + If M is selected the module will be called pl111_drm. > + > diff --git a/drivers/gpu/drm/pl111/Makefile b/drivers/gpu/drm/pl111/Makefile > new file mode 100644 > index 000000000000..20a7fd76d513 > --- /dev/null > +++ b/drivers/gpu/drm/pl111/Makefile > @@ -0,0 +1,8 @@ > +pl111_drm-y += pl111_connector.o \ > + pl111_crtc.o \ > + pl111_drv.o \ > + pl111_encoder.o \ > + pl111_gem.o \ > + pl111_plane.o > + > +obj-$(CONFIG_DRM_PL111) += pl111_drm.o > diff --git a/drivers/gpu/drm/pl111/pl111_connector.c b/drivers/gpu/drm/pl111/pl111_connector.c > new file mode 100644 > index 000000000000..9811d1eadb63 > --- /dev/null > +++ b/drivers/gpu/drm/pl111/pl111_connector.c > @@ -0,0 +1,127 @@ > +/* > + * (C) COPYRIGHT 2012-2013 ARM Limited. All rights reserved. > + * > + * Parts of this file were based on sources as follows: > + * > + * Copyright (c) 2006-2008 Intel Corporation > + * Copyright (c) 2007 Dave Airlie > + * Copyright (C) 2011 Texas Instruments > + * > + * This program is free software and is provided to you under the terms of the > + * GNU General Public License version 2 as published by the Free Software > + * Foundation, and any use by you of this program is subject to the terms of > + * such GNU licence. > + * > + */ > + > +/** > + * pl111_drm_connector.c > + * Implementation of the connector functions for PL111 DRM > + */ > +#include > +#include > +#include > +#include > + > +#include > +#include > +#include > +#include > +#include > + > +#include "pl111_drm.h" > + > +static void pl111_connector_destroy(struct drm_connector *connector) > +{ > + struct pl111_drm_connector *pl111_connector = > + to_pl111_connector(connector); > + > + if (pl111_connector->panel) > + drm_panel_detach(pl111_connector->panel); > + > + drm_connector_unregister(connector); > + drm_connector_cleanup(connector); > +} > + > +static enum drm_connector_status pl111_connector_detect(struct drm_connector > + *connector, bool force) > +{ > + struct pl111_drm_connector *pl111_connector = > + to_pl111_connector(connector); > + > + return (pl111_connector->panel ? > + connector_status_connected : > + connector_status_disconnected); > +} > + > +static int pl111_connector_helper_get_modes(struct drm_connector *connector) > +{ > + struct pl111_drm_connector *pl111_connector = > + to_pl111_connector(connector); > + > + if (!pl111_connector->panel) > + return 0; > + > + return drm_panel_get_modes(pl111_connector->panel); > +} Probably the umptenth time I've seen this :( One option I think would work well is if we have a generic "wrap a drm_panel into a drm_bridge" driver and just glue that in with an of helper as the last element in the enc/transcoder. Laurent has that practically written already, but he insist in calling it the lvds bridge, because it's for a 100% dummy lvds transcoder. But since it's 100% dummy it's indistinguishable from pure sw abstraction/impendence mismatch helper. Anyway, just an idea, not going to ask you to do this, but if drm_panel takes of like crazy we'll probably want this. > + > +const struct drm_connector_funcs connector_funcs = { > + .fill_modes = drm_helper_probe_single_connector_modes, > + .destroy = pl111_connector_destroy, > + .detect = pl111_connector_detect, > + .dpms = drm_atomic_helper_connector_dpms, > + .reset = drm_atomic_helper_connector_reset, > + .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state, > + .atomic_destroy_state = drm_atomic_helper_connector_destroy_state, > +}; > + > +const struct drm_connector_helper_funcs connector_helper_funcs = { > + .get_modes = pl111_connector_helper_get_modes, > +}; > + > +/* Walks the OF graph to find the panel node and then asks DRM to look > + * up the panel. > + */ > +static struct drm_panel *pl111_get_panel(struct device *dev) > +{ > + struct device_node *endpoint, *panel_node; > + struct device_node *np = dev->of_node; > + struct drm_panel *panel; > + > + endpoint = of_graph_get_next_endpoint(np, NULL); > + if (!endpoint) { > + dev_err(dev, "no endpoint to fetch panel\n"); > + return NULL; > + } > + > + /* don't proceed if we have an endpoint but no panel_node tied to it */ > + panel_node = of_graph_get_remote_port_parent(endpoint); > + of_node_put(endpoint); > + if (!panel_node) { > + dev_err(dev, "no valid panel node\n"); > + return NULL; > + } > + > + panel = of_drm_find_panel(panel_node); > + of_node_put(panel_node); > + > + return panel; > +} > + > +int pl111_connector_create(struct drm_device *dev) > +{ > + struct pl111_drm_dev_private *priv = dev->dev_private; > + struct pl111_drm_connector *pl111_connector = &priv->connector; > + struct drm_connector *connector = &pl111_connector->connector; > + > + drm_connector_init(dev, connector, &connector_funcs, > + DRM_MODE_CONNECTOR_DPI); > + drm_connector_helper_add(connector, &connector_helper_funcs); > + > + pl111_connector->panel = pl111_get_panel(dev->dev); > + if (pl111_connector->panel) > + drm_panel_attach(pl111_connector->panel, connector); > + > + return 0; > +} > + > diff --git a/drivers/gpu/drm/pl111/pl111_crtc.c b/drivers/gpu/drm/pl111/pl111_crtc.c > new file mode 100644 > index 000000000000..4c73bdd3b7e4 > --- /dev/null > +++ b/drivers/gpu/drm/pl111/pl111_crtc.c > @@ -0,0 +1,239 @@ > +/* > + * (C) COPYRIGHT 2012-2013 ARM Limited. All rights reserved. > + * > + * Parts of this file were based on sources as follows: > + * > + * Copyright (c) 2006-2008 Intel Corporation > + * Copyright (c) 2007 Dave Airlie > + * Copyright (C) 2011 Texas Instruments > + * > + * This program is free software and is provided to you under the terms of the > + * GNU General Public License version 2 as published by the Free Software > + * Foundation, and any use by you of this program is subject to the terms of > + * such GNU licence. > + * > + */ > + > +/** > + * pl111_drm_crtc.c > + * Implementation of the CRTC functions for PL111 DRM > + */ > +#include > +#include > +#include > +#include > +#include > + > +#include > +#include > +#include > +#include > + > +#include "pl111_drm.h" > + > +irqreturn_t pl111_irq(int irq, void *data) > +{ > + struct pl111_drm_dev_private *priv = data; > + u32 irq_stat; > + irqreturn_t status = IRQ_NONE; > + > + irq_stat = readl(priv->regs + CLCD_PL111_MIS); > + > + if (!irq_stat) > + return IRQ_NONE; > + > + if (irq_stat & CLCD_IRQ_NEXTBASE_UPDATE) { > + drm_crtc_handle_vblank(&priv->crtc); > + > + status = IRQ_HANDLED; > + } > + > + /* Clear the interrupt once done */ > + writel(irq_stat, priv->regs + CLCD_PL111_ICR); > + > + return status; > +} > + > +static int pl111_crtc_atomic_check(struct drm_crtc *crtc, > + struct drm_crtc_state *state) > +{ > + const struct drm_display_mode *mode = &state->mode; > + > + if (!state->active) > + return 0; > + > + if (mode->hdisplay % 16) > + return -EINVAL; > + > + return 0; > +} > + > +static void pl111_crtc_helper_mode_set_nofb(struct drm_crtc *crtc) > +{ > + struct drm_device *drm = crtc->dev; > + struct pl111_drm_dev_private *priv = crtc->dev->dev_private; > + const struct drm_display_mode *mode = &crtc->state->mode; > + struct drm_connector *connector = &priv->connector.connector; > + unsigned int ppl, hsw, hfp, hbp; > + unsigned int lpp, vsw, vfp, vbp; > + unsigned int cpl; > + int ret; > + > + ret = clk_set_rate(priv->clk, mode->clock * 1000); > + if (ret) { > + dev_err(drm->dev, > + "Failed to set pixel clock rate to %d: %d\n", > + mode->clock * 1000, ret); > + } > + > + ppl = (mode->hdisplay / 16) - 1; > + hsw = mode->hsync_end - mode->hsync_start - 1; > + hfp = mode->hsync_start - mode->hdisplay - 1; > + hbp = mode->htotal - mode->hsync_end - 1; > + > + lpp = mode->vdisplay - 1; > + vsw = mode->vsync_end - mode->vsync_start - 1; > + vfp = mode->vsync_start - mode->vdisplay; > + vbp = mode->vtotal - mode->vsync_end; > + > + cpl = mode->hdisplay - 1; > + > + writel((ppl << 2) | > + (hsw << 8) | > + (hfp << 16) | > + (hbp << 24), > + priv->regs + CLCD_TIM0); > + writel(lpp | > + (vsw << 10) | > + (vfp << 16) | > + (vbp << 24), > + priv->regs + CLCD_TIM1); > + /* XXX: We currently always use CLCDCLK with no divisor. We > + * could probably reduce power consumption by using HCLK > + * (apb_pclk) with a divisor when it gets us near our target > + * pixel clock. > + */ > + writel(((mode->flags & DRM_MODE_FLAG_NHSYNC) ? TIM2_IHS : 0) | > + ((mode->flags & DRM_MODE_FLAG_NVSYNC) ? TIM2_IVS : 0) | > + ((connector->display_info.bus_flags & > + DRM_BUS_FLAG_DE_LOW) ? TIM2_IOE : 0) | > + ((connector->display_info.bus_flags & > + DRM_BUS_FLAG_PIXDATA_NEGEDGE) ? TIM2_IPC : 0) | > + TIM2_BCD | > + (cpl << 16) | > + TIM2_CLKSEL, > + priv->regs + CLCD_TIM2); > + writel(0, priv->regs + CLCD_TIM3); > +} > + > +static void pl111_crtc_helper_enable(struct drm_crtc *crtc) > +{ > + struct pl111_drm_dev_private *priv = crtc->dev->dev_private; > + u32 cntl; > + > + clk_prepare_enable(priv->clk); > + > + drm_panel_prepare(priv->connector.panel); > + > + /* Enable and Power Up */ > + cntl = CNTL_LCDEN | CNTL_LCDTFT | CNTL_LCDPWR | CNTL_LCDVCOMP(1); > + > + /* Keep the format that the primary plane had set up. */ > + cntl |= readl(priv->regs + CLCD_PL111_CNTL) & (7 << 1); > + > + writel(cntl, priv->regs + CLCD_PL111_CNTL); > + > + drm_panel_enable(priv->connector.panel); > +} > + > +void pl111_crtc_helper_disable(struct drm_crtc *crtc) > +{ > + struct pl111_drm_dev_private *priv = crtc->dev->dev_private; > + > + drm_panel_disable(priv->connector.panel); > + > + /* Disable and Power Down */ > + writel(readl(priv->regs + CLCD_PL111_CNTL) & (7 << 1), > + priv->regs + CLCD_PL111_CNTL); > + > + drm_panel_unprepare(priv->connector.panel); > + > + /* Disable clock */ > + clk_disable_unprepare(priv->clk); > +} > + > +static void pl111_crtc_helper_atomic_flush(struct drm_crtc *crtc, > + struct drm_crtc_state *old_state) > +{ > + struct drm_pending_vblank_event *event = crtc->state->event; > + > + if (event) { > + crtc->state->event = NULL; > + > + spin_lock_irq(&crtc->dev->event_lock); > + if (crtc->state->active && drm_crtc_vblank_get(crtc) == 0) > + drm_crtc_arm_vblank_event(crtc, event); > + else > + drm_crtc_send_vblank_event(crtc, event); > + spin_unlock_irq(&crtc->dev->event_lock); > + } > +} > + > +static int pl111_enable_vblank(struct drm_crtc *crtc) > +{ > + struct drm_device *dev = crtc->dev; > + struct pl111_drm_dev_private *priv = dev->dev_private; > + > + clk_prepare_enable(priv->clk); > + > + writel(CLCD_IRQ_NEXTBASE_UPDATE, priv->regs + CLCD_PL111_IENB); > + > + return 0; > +} > + > +static void pl111_disable_vblank(struct drm_crtc *crtc) > +{ > + struct drm_device *dev = crtc->dev; > + struct pl111_drm_dev_private *priv = dev->dev_private; > + > + writel(0, priv->regs + CLCD_PL111_IENB); > + > + clk_disable_unprepare(priv->clk); > +} > + > +const struct drm_crtc_funcs crtc_funcs = { > + .set_config = drm_atomic_helper_set_config, > + .page_flip = drm_atomic_helper_page_flip, > + .reset = drm_atomic_helper_crtc_reset, > + .destroy = drm_crtc_cleanup, > + .enable_vblank = pl111_enable_vblank, > + .disable_vblank = pl111_disable_vblank, > + .atomic_duplicate_state = drm_atomic_helper_crtc_duplicate_state, > + .atomic_destroy_state = drm_atomic_helper_crtc_destroy_state, > +}; > + > +const struct drm_crtc_helper_funcs crtc_helper_funcs = { > + .mode_set_nofb = pl111_crtc_helper_mode_set_nofb, > + .atomic_check = pl111_crtc_atomic_check, > + .atomic_flush = pl111_crtc_helper_atomic_flush, > + .disable = pl111_crtc_helper_disable, > + .enable = pl111_crtc_helper_enable, > +}; > + > +int pl111_crtc_create(struct drm_device *dev) > +{ > + struct pl111_drm_dev_private *priv = dev->dev_private; > + struct drm_crtc *crtc = &priv->crtc; > + > + drm_crtc_init_with_planes(dev, crtc, > + &priv->primary, NULL, > + &crtc_funcs, "primary"); > + drm_crtc_helper_add(crtc, &crtc_helper_funcs); > + > + /* XXX: The runtime clock disabling still results in > + * occasional system hangs, and needs debugging. > + */ > + clk_prepare_enable(priv->clk); > + > + return 0; > +} > diff --git a/drivers/gpu/drm/pl111/pl111_drm.h b/drivers/gpu/drm/pl111/pl111_drm.h > new file mode 100644 > index 000000000000..36e4ce770a6c > --- /dev/null > +++ b/drivers/gpu/drm/pl111/pl111_drm.h > @@ -0,0 +1,64 @@ > +/* > + * > + * (C) COPYRIGHT 2012-2013 ARM Limited. All rights reserved. > + * > + * > + * Parts of this file were based on sources as follows: > + * > + * Copyright (c) 2006-2008 Intel Corporation > + * Copyright (c) 2007 Dave Airlie > + * Copyright (C) 2011 Texas Instruments > + * > + * This program is free software and is provided to you under the terms of the > + * GNU General Public License version 2 as published by the Free Software > + * Foundation, and any use by you of this program is subject to the terms of > + * such GNU licence. > + * > + */ > + > +#ifndef _PL111_DRM_H_ > +#define _PL111_DRM_H_ > + > +#include > + > +#define CLCD_IRQ_NEXTBASE_UPDATE BIT(2) > + > +struct pl111_drm_connector { > + struct drm_connector connector; > + struct drm_panel *panel; > +}; > + > +struct pl111_drm_dev_private { > + struct drm_device *drm; > + > + struct pl111_drm_connector connector; > + struct drm_crtc crtc; > + struct drm_encoder encoder; > + struct drm_plane primary; > + struct drm_fbdev_cma *fbdev; > + > + void *regs; > + struct clk *clk; > +}; > + > +#define to_pl111_connector(x) \ > + container_of(x, struct pl111_drm_connector, connector) > + > +/* CRTC Functions */ > +int pl111_crtc_create(struct drm_device *dev); > +irqreturn_t pl111_irq(int irq, void *data); > + > +int pl111_primary_plane_init(struct drm_device *dev); > + > +/* Connector Functions */ > +int pl111_connector_create(struct drm_device *dev); > + > +/* Encoder Functions */ > +int pl111_encoder_init(struct drm_device *dev); > + > +/* GEM Functions */ > +int pl111_dumb_create(struct drm_file *file_priv, > + struct drm_device *dev, > + struct drm_mode_create_dumb *args); > + > +#endif /* _PL111_DRM_H_ */ > diff --git a/drivers/gpu/drm/pl111/pl111_drv.c b/drivers/gpu/drm/pl111/pl111_drv.c > new file mode 100644 > index 000000000000..571c296dddf7 > --- /dev/null > +++ b/drivers/gpu/drm/pl111/pl111_drv.c > @@ -0,0 +1,292 @@ > +/* > + * (C) COPYRIGHT 2012-2013 ARM Limited. All rights reserved. > + * > + * Parts of this file were based on sources as follows: > + * > + * Copyright (c) 2006-2008 Intel Corporation > + * Copyright (c) 2007 Dave Airlie > + * Copyright (C) 2011 Texas Instruments > + * > + * This program is free software and is provided to you under the terms of the > + * GNU General Public License version 2 as published by the Free Software > + * Foundation, and any use by you of this program is subject to the terms of > + * such GNU licence. > + * > + */ > + > +/** > + * DOC: ARM PrimeCell PL111 CLCD Driver > + * > + * The PL111 is a simple LCD controller that can support TFT and STN > + * displays. This driver exposes a standard KMS interface for them. > + * > + * This driver uses the same Device Tree binding as the fbdev CLCD > + * driver. While the fbdev driver supports panels that may be > + * connected to the CLCD internally to the CLCD driver, in DRM the > + * panels get split out to drivers/gpu/drm/panels/. This means that, > + * in converting from using fbdev to using DRM, you also need to write > + * a panel driver (which may be as simple as an entry in > + * panel-simple.c). > + * > + * The driver currently doesn't expose the cursor. The DRM API for > + * cursors requires support for 64x64 ARGB8888 cursor images, while > + * the hardware can only support 64x64 monochrome with masking > + * cursors. While one could imagine trying to hack something together > + * to look at the ARGB8888 and program reasonable in monochrome, we > + * just don't expose the cursor at all instead, and leave cursor > + * support to the X11 software cursor layer. > + * > + * TODO: > + * > + * - Fix race between setting plane base address and getting IRQ for > + * vsync firing the pageflip completion. > + * > + * - Expose the correct set of formats we can support based on the > + * "arm,pl11x,tft-r0g0b0-pads" DT property. > + * > + * - Use the "max-memory-bandwidth" DT property to filter the > + * supported formats. > + * > + * - Read back hardware state at boot to skip reprogramming the > + * hardware when doing a no-op modeset. > + * > + * - Use the internal clock divisor to reduce power consumption by > + * using HCLK (apb_pclk) when appropriate. > + */ > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include > + > +#include > +#include > +#include > +#include > +#include > + > +#include "pl111_drm.h" > + > +#define DRIVER_DESC "DRM module for PL111" > + > +struct drm_mode_config_funcs mode_config_funcs = { > + .fb_create = drm_fb_cma_create, > + .atomic_check = drm_atomic_helper_check, > + .atomic_commit = drm_atomic_helper_commit, > +}; > + > +static int pl111_modeset_init(struct drm_device *dev) > +{ > + struct drm_mode_config *mode_config; > + struct pl111_drm_dev_private *priv = dev->dev_private; > + int ret = 0; > + > + if (!priv) > + return -EINVAL; > + > + drm_mode_config_init(dev); > + mode_config = &dev->mode_config; > + mode_config->funcs = &mode_config_funcs; > + mode_config->min_width = 1; > + mode_config->max_width = 1024; > + mode_config->min_height = 1; > + mode_config->max_height = 768; > + > + ret = pl111_primary_plane_init(dev); > + if (ret != 0) { > + dev_err(dev->dev, "Failed to init primary plane\n"); > + goto out_config; > + } I assume this display IP has a pile of planes? Otherwise the simple pipe helpers look like a perfect fit. > + > + ret = pl111_crtc_create(dev); > + if (ret) { > + dev_err(dev->dev, "Failed to create crtc\n"); > + goto out_config; > + } > + > + ret = pl111_connector_create(dev); > + if (ret) { > + dev_err(dev->dev, "Failed to create pl111_drm_connector\n"); > + goto out_config; > + } > + > + ret = pl111_encoder_init(dev); > + if (ret) { > + dev_err(dev->dev, "Failed to create pl111_drm_encoder\n"); > + goto out_config; > + } > + > + ret = drm_mode_connector_attach_encoder(&priv->connector.connector, > + &priv->encoder); > + if (ret != 0) { > + dev_err(dev->dev, "Failed to attach encoder\n"); > + goto out_config; > + } > + > + priv->connector.connector.encoder = &priv->encoder; > + > + ret = drm_vblank_init(dev, 1); > + if (ret != 0) { > + dev_err(dev->dev, "Failed to init vblank\n"); > + goto out_config; > + } > + > + drm_mode_config_reset(dev); > + > + priv->fbdev = drm_fbdev_cma_init(dev, 32, > + dev->mode_config.num_connector); > + > + drm_kms_helper_poll_init(dev); > + > + goto finish; > + > +out_config: > + drm_mode_config_cleanup(dev); > +finish: > + return ret; > +} > + > +static const struct file_operations drm_fops = { > + .owner = THIS_MODULE, > + .open = drm_open, > + .release = drm_release, > + .unlocked_ioctl = drm_ioctl, > + .mmap = drm_gem_cma_mmap, > + .poll = drm_poll, > + .read = drm_read, > +}; Very recent, but DEFINE_DRM_GEM_CMA_FOPS. > + > +static void pl111_lastclose(struct drm_device *dev) > +{ > + struct pl111_drm_dev_private *priv = dev->dev_private; > + > + drm_fbdev_cma_restore_mode(priv->fbdev); > +} > + > +static struct drm_driver pl111_drm_driver = { > + .driver_features = > + DRIVER_MODESET | DRIVER_GEM | DRIVER_PRIME | DRIVER_ATOMIC, > + .lastclose = pl111_lastclose, > + .ioctls = NULL, > + .fops = &drm_fops, > + .name = "pl111_drm", > + .desc = DRIVER_DESC, > + .date = "20170317", > + .major = 1, > + .minor = 0, > + .patchlevel = 0, > + .dumb_create = pl111_dumb_create, > + .dumb_destroy = drm_gem_dumb_destroy, > + .dumb_map_offset = drm_gem_cma_dumb_map_offset, > + .gem_free_object = drm_gem_cma_free_object, > + .gem_vm_ops = &drm_gem_cma_vm_ops, > + > + .prime_handle_to_fd = drm_gem_prime_handle_to_fd, > + .prime_fd_to_handle = drm_gem_prime_fd_to_handle, > + .gem_prime_import = drm_gem_prime_import, > + .gem_prime_import_sg_table = drm_gem_cma_prime_import_sg_table, > + .gem_prime_export = drm_gem_prime_export, > + .gem_prime_get_sg_table = drm_gem_cma_prime_get_sg_table, > +}; > + > +#ifdef CONFIG_ARM_AMBA > +static int pl111_amba_probe(struct amba_device *amba_dev, > + const struct amba_id *id) > +{ > + struct device *dev = &amba_dev->dev; > + struct pl111_drm_dev_private *priv; > + struct drm_device *drm; > + int ret; > + > + priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); > + if (!priv) > + return -ENOMEM; > + > + drm = drm_dev_alloc(&pl111_drm_driver, dev); > + if (IS_ERR(drm)) > + return PTR_ERR(drm); > + amba_set_drvdata(amba_dev, drm); > + priv->drm = drm; > + drm->dev_private = priv; > + > + priv->clk = devm_clk_get(dev, "clcdclk"); > + if (IS_ERR(priv->clk)) { > + dev_err(dev, "CLCD: unable to get clk.\n"); > + ret = PTR_ERR(priv->clk); > + goto dev_unref; > + } > + > + priv->regs = devm_ioremap_resource(dev, &amba_dev->res); > + if (!priv->regs) { > + dev_err(dev, "%s failed mmio\n", __func__); > + return -EINVAL; > + } > + > + /* turn off interrupts before requesting the irq */ > + writel(0, priv->regs + CLCD_PL111_IENB); > + > + ret = devm_request_irq(dev, amba_dev->irq[0], pl111_irq, 0, > + "pl111", priv); > + if (ret != 0) { > + dev_err(dev, "%s failed irq %d\n", __func__, ret); > + return ret; > + } > + > + ret = pl111_modeset_init(drm); > + if (ret != 0) { > + dev_err(dev, "Failed to init modeset\n"); > + goto dev_unref; > + } > + > + ret = drm_dev_register(drm, 0); > + if (ret < 0) > + goto dev_unref; > + > + return 0; > + > +dev_unref: > + drm_dev_unref(drm); > + return ret; > +} > + > +static int pl111_amba_remove(struct amba_device *amba_dev) > +{ > + struct drm_device *drm = amba_get_drvdata(amba_dev); > + struct pl111_drm_dev_private *priv = drm->dev_private; > + > + drm_dev_unregister(drm); > + if (priv->fbdev) > + drm_fbdev_cma_fini(priv->fbdev); > + drm_mode_config_cleanup(drm); > + drm_dev_unref(drm); > + > + return 0; > +} > + > +static struct amba_id pl111_id_table[] = { > + { > + .id = 0x00041110, > + .mask = 0x000ffffe, > + }, > + {0, 0}, > +}; > + > +static struct amba_driver pl111_amba_driver = { > + .drv = { > + .name = "clcd-pl11x", > + }, > + .probe = pl111_amba_probe, > + .remove = pl111_amba_remove, > + .id_table = pl111_id_table, > +}; > +#endif /* CONFIG_ARM_AMBA */ > + > +module_amba_driver(pl111_amba_driver); > + > +MODULE_DESCRIPTION(DRIVER_DESC); > +MODULE_AUTHOR("ARM Ltd."); > +MODULE_LICENSE("GPL"); > +MODULE_ALIAS("platform:pl111_drm"); > diff --git a/drivers/gpu/drm/pl111/pl111_encoder.c b/drivers/gpu/drm/pl111/pl111_encoder.c > new file mode 100644 > index 000000000000..78d67ceb46f3 > --- /dev/null > +++ b/drivers/gpu/drm/pl111/pl111_encoder.c > @@ -0,0 +1,50 @@ > +/* > + * (C) COPYRIGHT 2012-2013 ARM Limited. All rights reserved. > + * > + * Parts of this file were based on sources as follows: > + * > + * Copyright (c) 2006-2008 Intel Corporation > + * Copyright (c) 2007 Dave Airlie > + * Copyright (C) 2011 Texas Instruments > + * > + * This program is free software and is provided to you under the terms of the > + * GNU General Public License version 2 as published by the Free Software > + * Foundation, and any use by you of this program is subject to the terms of > + * such GNU licence. > + * > + */ > + > +/** > + * pl111_drm_encoder.c > + * Implementation of the encoder functions for PL111 DRM > + */ > +#include > +#include > +#include > +#include > + > +#include > +#include > + > +#include "pl111_drm.h" > + > +static const struct drm_encoder_funcs pl111_encoder_funcs = { > + .destroy = drm_encoder_cleanup, > +}; > + > +int pl111_encoder_init(struct drm_device *dev) > +{ > + struct pl111_drm_dev_private *priv = dev->dev_private; > + struct drm_encoder *encoder = &priv->encoder; > + int ret; > + > + ret = drm_encoder_init(dev, encoder, &pl111_encoder_funcs, > + DRM_MODE_ENCODER_DPI, NULL); > + if (ret) > + return ret; > + > + encoder->crtc = &priv->crtc; > + encoder->possible_crtcs = drm_crtc_mask(encoder->crtc); > + > + return 0; > +} > diff --git a/drivers/gpu/drm/pl111/pl111_gem.c b/drivers/gpu/drm/pl111/pl111_gem.c > new file mode 100644 > index 000000000000..b7b0e453dea9 > --- /dev/null > +++ b/drivers/gpu/drm/pl111/pl111_gem.c > @@ -0,0 +1,35 @@ > +/* > + * (C) COPYRIGHT 2012-2013 ARM Limited. All rights reserved. > + * > + * Parts of this file were based on sources as follows: > + * > + * Copyright (c) 2006-2008 Intel Corporation > + * Copyright (c) 2007 Dave Airlie > + * Copyright (C) 2011 Texas Instruments > + * > + * This program is free software and is provided to you under the terms of the > + * GNU General Public License version 2 as published by the Free Software > + * Foundation, and any use by you of this program is subject to the terms of > + * such GNU licence. > + * > + */ > + > +/** > + * pl111_drm_gem.c > + * Implementation of the GEM functions for PL111 DRM > + */ > +#include > +#include > +#include > +#include > +#include > +#include > +#include "pl111_drm.h" > + > +int pl111_dumb_create(struct drm_file *file_priv, > + struct drm_device *dev, struct drm_mode_create_dumb *args) > +{ > + args->pitch = DIV_ROUND_UP(args->width * args->bpp, 8); > + > + return drm_gem_cma_dumb_create_internal(file_priv, dev, args); > +} > diff --git a/drivers/gpu/drm/pl111/pl111_plane.c b/drivers/gpu/drm/pl111/pl111_plane.c > new file mode 100644 > index 000000000000..bcdc2f43de46 > --- /dev/null > +++ b/drivers/gpu/drm/pl111/pl111_plane.c > @@ -0,0 +1,167 @@ > +/* > + * (C) COPYRIGHT 2012-2013 ARM Limited. All rights reserved. > + * > + * Parts of this file were based on sources as follows: > + * > + * Copyright (c) 2006-2008 Intel Corporation > + * Copyright (c) 2007 Dave Airlie > + * Copyright (C) 2011 Texas Instruments > + * > + * This program is free software and is provided to you under the terms of the > + * GNU General Public License version 2 as published by the Free Software > + * Foundation, and any use by you of this program is subject to the terms of > + * such GNU licence. > + * > + */ > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include > + > +#include "pl111_drm.h" > + > +static int pl111_primary_plane_atomic_check(struct drm_plane *plane, > + struct drm_plane_state *state) > +{ > + return 0; > +} > + > +static void pl111_primary_plane_atomic_update(struct drm_plane *plane, > + struct drm_plane_state *old_state) > +{ > + struct drm_device *dev = plane->dev; > + struct pl111_drm_dev_private *priv = dev->dev_private; > + struct drm_framebuffer *fb = plane->state->fb; > + struct drm_gem_cma_object *obj; > + u32 addr, cntl; > + > + if (!fb) > + return; > + > + obj = drm_fb_cma_get_gem_obj(fb, 0); > + addr = obj->paddr + fb->offsets[0]; > + addr += fb->format->cpp[0] * plane->state->src_x; > + addr += fb->pitches[0] * plane->state->src_y; > + > + writel(addr, priv->regs + CLCD_UBAS); > + writel(addr + (fb->height - 1 * fb->pitches[0]), > + priv->regs + CLCD_LBAS); > + > + cntl = readl(priv->regs + CLCD_PL111_CNTL); > + cntl &= ~(7 << 1); > + > + /* Note that the the hardware's format reader takes 'r' from > + * the low bit, while DRM formats list channels from high bit > + * to low bit as you read left to right. > + */ > + switch (fb->format->format) { > + case DRM_FORMAT_ABGR8888: > + case DRM_FORMAT_XBGR8888: > + cntl |= CNTL_LCDBPP24; > + break; > + case DRM_FORMAT_ARGB8888: > + case DRM_FORMAT_XRGB8888: > + cntl |= CNTL_LCDBPP24 | CNTL_BGR; > + break; > + case DRM_FORMAT_BGR565: > + cntl |= CNTL_LCDBPP16_565; > + break; > + case DRM_FORMAT_RGB565: > + cntl |= CNTL_LCDBPP16_565 | CNTL_BGR; > + break; > + case DRM_FORMAT_ABGR1555: > + case DRM_FORMAT_XBGR1555: > + cntl |= CNTL_LCDBPP16; > + break; > + case DRM_FORMAT_ARGB1555: > + case DRM_FORMAT_XRGB1555: > + cntl |= CNTL_LCDBPP16 | CNTL_BGR; > + break; > + case DRM_FORMAT_ABGR4444: > + case DRM_FORMAT_XBGR4444: > + cntl |= CNTL_LCDBPP16_444; > + break; > + case DRM_FORMAT_ARGB4444: > + case DRM_FORMAT_XRGB4444: > + cntl |= CNTL_LCDBPP16_444 | CNTL_BGR; > + break; > + } > + > + writel(cntl, priv->regs + CLCD_PL111_CNTL); > +} > + > +static const struct drm_plane_helper_funcs pl111_primary_plane_helper_funcs = { > + .atomic_check = pl111_primary_plane_atomic_check, > + .atomic_update = pl111_primary_plane_atomic_update, > +}; > + > +static const struct drm_plane_funcs pl111_primary_plane_funcs = { > + .update_plane = drm_atomic_helper_update_plane, > + .disable_plane = drm_atomic_helper_disable_plane, > + .reset = drm_atomic_helper_plane_reset, > + .destroy = drm_plane_cleanup, > + .atomic_duplicate_state = drm_atomic_helper_plane_duplicate_state, > + .atomic_destroy_state = drm_atomic_helper_plane_destroy_state, > +}; > + > +int pl111_primary_plane_init(struct drm_device *drm) > +{ > + struct pl111_drm_dev_private *priv = drm->dev_private; > + struct drm_plane *plane = &priv->primary; > + struct device *dev = drm->dev; > + static const u32 formats[] = { > + DRM_FORMAT_ABGR8888, > + DRM_FORMAT_XBGR8888, > + DRM_FORMAT_ARGB8888, > + DRM_FORMAT_XRGB8888, > + DRM_FORMAT_BGR565, > + DRM_FORMAT_RGB565, > + DRM_FORMAT_ABGR1555, > + DRM_FORMAT_XBGR1555, > + DRM_FORMAT_ARGB1555, > + DRM_FORMAT_XRGB1555, > + DRM_FORMAT_ABGR4444, > + DRM_FORMAT_XBGR4444, > + DRM_FORMAT_ARGB4444, > + DRM_FORMAT_XRGB4444, > + }; > + struct device_node *endpoint; > + u32 tft_r0b0g0[3]; > + int ret; > + > + endpoint = of_graph_get_next_endpoint(dev->of_node, NULL); > + if (!endpoint) > + return -ENODEV; > + > + if (of_property_read_u32_array(endpoint, > + "arm,pl11x,tft-r0g0b0-pads", > + tft_r0b0g0, > + ARRAY_SIZE(tft_r0b0g0)) != 0) { > + dev_err(dev, "arm,pl11x,tft-r0g0b0-pads should be 3 ints\n"); > + of_node_put(endpoint); > + return -ENOENT; > + } > + of_node_put(endpoint); > + > + if (tft_r0b0g0[0] != 0 || > + tft_r0b0g0[1] != 8 || > + tft_r0b0g0[2] != 16) { > + dev_err(dev, "arm,pl11x,tft-r0g0b0-pads != [0,8,16] not yet supported\n"); > + return -EINVAL; > + } > + > + ret = drm_universal_plane_init(drm, plane, 0, > + &pl111_primary_plane_funcs, > + formats, ARRAY_SIZE(formats), > + DRM_PLANE_TYPE_PRIMARY, NULL); > + if (ret) > + return ret; > + > + drm_plane_helper_add(plane, &pl111_primary_plane_helper_funcs); > + > + return 0; > +} > -- > 2.11.0 > > _______________________________________________ > dri-devel mailing list > dri-devel@lists.freedesktop.org > https://lists.freedesktop.org/mailman/listinfo/dri-devel -- Daniel Vetter Software Engineer, Intel Corporation http://blog.ffwll.ch From mboxrd@z Thu Jan 1 00:00:00 1970 From: Daniel Vetter Subject: Re: [PATCH 2/2] drm/pl111: Initial drm/kms driver for pl111 Date: Mon, 20 Mar 2017 09:34:22 +0100 Message-ID: <20170320083422.sd6uvisgdgajwxtr@phenom.ffwll.local> References: <20170317224742.17219-1-eric@anholt.net> <20170317224742.17219-3-eric@anholt.net> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail-wm0-x242.google.com (mail-wm0-x242.google.com [IPv6:2a00:1450:400c:c09::242]) by gabe.freedesktop.org (Postfix) with ESMTPS id E48416E441 for ; Mon, 20 Mar 2017 08:34:26 +0000 (UTC) Received: by mail-wm0-x242.google.com with SMTP id z133so12982577wmb.2 for ; Mon, 20 Mar 2017 01:34:26 -0700 (PDT) Content-Disposition: inline In-Reply-To: <20170317224742.17219-3-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: Eric Anholt Cc: linux-kernel@vger.kernel.org, Russell King , dri-devel@lists.freedesktop.org List-Id: dri-devel@lists.freedesktop.org T24gRnJpLCBNYXIgMTcsIDIwMTcgYXQgMDM6NDc6NDJQTSAtMDcwMCwgRXJpYyBBbmhvbHQgd3Jv dGU6Cj4gRnJvbTogVG9tIENvb2tzZXkgPHRvbS5jb29rc2V5QGFybS5jb20+Cj4gCj4gVGhpcyBp cyBhIG1vZGVzZXR0aW5nIGRyaXZlciBmb3IgdGhlIHBsMTExIENMQ0QgZGlzcGxheSBjb250cm9s bGVyCj4gZm91bmQgb24gdmFyaW91cyBBUk0gcGxhdGZvcm1zIHN1Y2ggYXMgdGhlIFZlcnNhdGls ZSBFeHByZXNzLiBUaGUKPiBkcml2ZXIgaGFzIG9ubHkgYmVlbiB0ZXN0ZWQgb24gdGhlIGJjbTkx MTM2MF9lbnRwaG4gcGxhdGZvcm0gc28gZmFyLAo+IHdpdGggUFJJTUUtYmFzZWQgYnVmZmVyIHNo YXJpbmcgYmV0d2VlbiB2YzQgYW5kIGNsY2QuCj4gCj4gSXQgcmV1c2VzIHRoZSBleGlzdGluZyBk ZXZpY2V0cmVlIGJpbmRpbmcsIHdoaWxlIG5vdCB1c2luZyBxdWl0ZSBhcwo+IG1hbnkgb2YgaXRz IHByb3BlcnRpZXMgYXMgdGhlIGZiZGV2IGRyaXZlciBkb2VzICh0aG9zZSBhcmUgbGVmdCBmb3IK PiBmdXR1cmUgd29yaykuCj4gCj4gdjI6IE5lYXJseSBjb21wbGV0ZSByZXdyaXRlIGJ5IGFuaG9s dCwgY3V0dGluZyAyLzMgb2YgdGhlIGNvZGUgdGhhbmtzCj4gICAgIHRvIERSTSBjb3JlJ3MgZXhj ZWxsZW50IG5ldyBoZWxwZXJzLgo+IAo+IFNpZ25lZC1vZmYtYnk6IFRvbSBDb29rc2V5IDx0b20u Y29va3NleUBhcm0uY29tPgo+IFNpZ25lZC1vZmYtYnk6IEVyaWMgQW5ob2x0IDxlcmljQGFuaG9s dC5uZXQ+CgpMb29rcyBwcmV0dHkuIEEgZmV3IHRoaW5ncyBiZWxvdywgYnV0IG5vdGhpbmcgYmln LiBJJ2Qgc2F5IGlmIHRoZSAiaG93CmdlbmVyaWMgZG8gd2Ugd2FudCB0aGlzIHRvIGJlIGZvciBu b3ciIHF1ZXN0aW9uIGlzIHJlc29sdmVkIGl0J3MgcmVhZHkgdG8KZ28gaW4uCgpJZiB5b3Ugd2Fu dCB0aGlzIGluIGRybS1taXNjIChpbW8gZmluZSwgeW91J3JlIGFscmVhZHkgdGhlcmUgc28gZG9l c24ndApyZWFsbHkgZXh0ZW5kIHRoZSBzY29wZSBvZiB0aGUgZXhwZXJpbWVudCksIHRoZW4gcGxl YXNlIGFsc28gYWRkIGEKTUFJTlRBSU5FUlMgZW50cnkgd2l0aCB0aGUgZHJtLW1pc2MgZ2l0IHJl cG8gYW5kIHlvdXJzZWxmIGFzIHJldmlld2VyLgoKQ2hlZXJzLCBEYW5pZWwKCj4gLS0tCj4gIERv Y3VtZW50YXRpb24vZ3B1L2luZGV4LnJzdCAgICAgICAgICAgICB8ICAgMSArCj4gIERvY3VtZW50 YXRpb24vZ3B1L3BsMTExLnJzdCAgICAgICAgICAgICB8ICAgNiArCj4gIGRyaXZlcnMvZ3B1L2Ry bS9LY29uZmlnICAgICAgICAgICAgICAgICB8ICAgMiArCj4gIGRyaXZlcnMvZ3B1L2RybS9NYWtl ZmlsZSAgICAgICAgICAgICAgICB8ICAgMSArCj4gIGRyaXZlcnMvZ3B1L2RybS9wbDExMS9LY29u ZmlnICAgICAgICAgICB8ICAxMiArKwo+ICBkcml2ZXJzL2dwdS9kcm0vcGwxMTEvTWFrZWZpbGUg ICAgICAgICAgfCAgIDggKwo+ICBkcml2ZXJzL2dwdS9kcm0vcGwxMTEvcGwxMTFfY29ubmVjdG9y LmMgfCAxMjcgKysrKysrKysrKysrKysKPiAgZHJpdmVycy9ncHUvZHJtL3BsMTExL3BsMTExX2Ny dGMuYyAgICAgIHwgMjM5ICsrKysrKysrKysrKysrKysrKysrKysrKysrCj4gIGRyaXZlcnMvZ3B1 L2RybS9wbDExMS9wbDExMV9kcm0uaCAgICAgICB8ICA2NCArKysrKysrCj4gIGRyaXZlcnMvZ3B1 L2RybS9wbDExMS9wbDExMV9kcnYuYyAgICAgICB8IDI5MiArKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKwo+ICBkcml2ZXJzL2dwdS9kcm0vcGwxMTEvcGwxMTFfZW5jb2Rlci5jICAgfCAg NTAgKysrKysrCj4gIGRyaXZlcnMvZ3B1L2RybS9wbDExMS9wbDExMV9nZW0uYyAgICAgICB8ICAz NSArKysrCj4gIGRyaXZlcnMvZ3B1L2RybS9wbDExMS9wbDExMV9wbGFuZS5jICAgICB8IDE2NyAr KysrKysrKysrKysrKysrKysKPiAgMTMgZmlsZXMgY2hhbmdlZCwgMTAwNCBpbnNlcnRpb25zKCsp Cj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBEb2N1bWVudGF0aW9uL2dwdS9wbDExMS5yc3QKPiAgY3Jl YXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvZ3B1L2RybS9wbDExMS9LY29uZmlnCj4gIGNyZWF0ZSBt b2RlIDEwMDY0NCBkcml2ZXJzL2dwdS9kcm0vcGwxMTEvTWFrZWZpbGUKPiAgY3JlYXRlIG1vZGUg MTAwNjQ0IGRyaXZlcnMvZ3B1L2RybS9wbDExMS9wbDExMV9jb25uZWN0b3IuYwo+ICBjcmVhdGUg bW9kZSAxMDA2NDQgZHJpdmVycy9ncHUvZHJtL3BsMTExL3BsMTExX2NydGMuYwo+ICBjcmVhdGUg bW9kZSAxMDA2NDQgZHJpdmVycy9ncHUvZHJtL3BsMTExL3BsMTExX2RybS5oCj4gIGNyZWF0ZSBt b2RlIDEwMDY0NCBkcml2ZXJzL2dwdS9kcm0vcGwxMTEvcGwxMTFfZHJ2LmMKPiAgY3JlYXRlIG1v ZGUgMTAwNjQ0IGRyaXZlcnMvZ3B1L2RybS9wbDExMS9wbDExMV9lbmNvZGVyLmMKPiAgY3JlYXRl IG1vZGUgMTAwNjQ0IGRyaXZlcnMvZ3B1L2RybS9wbDExMS9wbDExMV9nZW0uYwo+ICBjcmVhdGUg bW9kZSAxMDA2NDQgZHJpdmVycy9ncHUvZHJtL3BsMTExL3BsMTExX3BsYW5lLmMKPiAKPiBkaWZm IC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9ncHUvaW5kZXgucnN0IGIvRG9jdW1lbnRhdGlvbi9ncHUv aW5kZXgucnN0Cj4gaW5kZXggZTk5OGVlMGQwZGQ1Li43MWJmNTEwZDQ3ZTggMTAwNjQ0Cj4gLS0t IGEvRG9jdW1lbnRhdGlvbi9ncHUvaW5kZXgucnN0Cj4gKysrIGIvRG9jdW1lbnRhdGlvbi9ncHUv aW5kZXgucnN0Cj4gQEAgLTExLDYgKzExLDcgQEAgTGludXggR1BVIERyaXZlciBEZXZlbG9wZXIn cyBHdWlkZQo+ICAgICBkcm0ta21zLWhlbHBlcnMKPiAgICAgZHJtLXVhcGkKPiAgICAgaTkxNQo+ ICsgICBwbDExMQo+ICAgICB0aW55ZHJtCj4gICAgIHZjNAo+ICAgICB2Z2Etc3dpdGNoZXJvbwo+ IGRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2dwdS9wbDExMS5yc3QgYi9Eb2N1bWVudGF0aW9u L2dwdS9wbDExMS5yc3QKPiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+IGluZGV4IDAwMDAwMDAwMDAw MC4uOWIwMzczNmQzM2RkCj4gLS0tIC9kZXYvbnVsbAo+ICsrKyBiL0RvY3VtZW50YXRpb24vZ3B1 L3BsMTExLnJzdAo+IEBAIC0wLDAgKzEsNiBAQAo+ICs9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT0KPiArIGRybS9wbDExMSBBUk0gUHJpbWVDZWxsIFBMMTExIENMQ0Qg RHJpdmVyCj4gKz09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQo+ICsK PiArLi4ga2VybmVsLWRvYzo6IGRyaXZlcnMvZ3B1L2RybS9wbDExMS9wbDExMV9kcnYuYwo+ICsg ICA6ZG9jOiBBUk0gUHJpbWVDZWxsIFBMMTExIENMQ0QgRHJpdmVyCj4gZGlmZiAtLWdpdCBhL2Ry aXZlcnMvZ3B1L2RybS9LY29uZmlnIGIvZHJpdmVycy9ncHUvZHJtL0tjb25maWcKPiBpbmRleCA3 OGQ3ZmMwZWJiNTcuLmQxYzZjMTIxOTliNyAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0v S2NvbmZpZwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9LY29uZmlnCj4gQEAgLTI3NCw2ICsyNzQs OCBAQCBzb3VyY2UgImRyaXZlcnMvZ3B1L2RybS9tZXNvbi9LY29uZmlnIgo+ICAKPiAgc291cmNl ICJkcml2ZXJzL2dwdS9kcm0vdGlueWRybS9LY29uZmlnIgo+ICAKPiArc291cmNlICJkcml2ZXJz L2dwdS9kcm0vcGwxMTEvS2NvbmZpZyIKPiArCj4gICMgS2VlcCBsZWdhY3kgZHJpdmVycyBsYXN0 Cj4gIAo+ICBtZW51Y29uZmlnIERSTV9MRUdBQ1kKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUv ZHJtL01ha2VmaWxlIGIvZHJpdmVycy9ncHUvZHJtL01ha2VmaWxlCj4gaW5kZXggNTlhYWU0MzAw NWVlLi45OTgxMGE1MjliYjAgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL01ha2VmaWxl Cj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL01ha2VmaWxlCj4gQEAgLTk1LDMgKzk1LDQgQEAgb2Jq LXkJCQkrPSBoaXNpbGljb24vCj4gIG9iai0kKENPTkZJR19EUk1fWlRFKQkrPSB6dGUvCj4gIG9i ai0kKENPTkZJR19EUk1fTVhTRkIpCSs9IG14c2ZiLwo+ICBvYmotJChDT05GSUdfRFJNX1RJTllE Uk0pICs9IHRpbnlkcm0vCj4gK29iai0kKENPTkZJR19EUk1fUEwxMTEpICs9IHBsMTExLwo+IGRp ZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcGwxMTEvS2NvbmZpZyBiL2RyaXZlcnMvZ3B1L2Ry bS9wbDExMS9LY29uZmlnCj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPiBpbmRleCAwMDAwMDAwMDAw MDAuLmVkZTQ5ZWZkNTMxZgo+IC0tLSAvZGV2L251bGwKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0v cGwxMTEvS2NvbmZpZwo+IEBAIC0wLDAgKzEsMTIgQEAKPiArY29uZmlnIERSTV9QTDExMQo+ICsJ dHJpc3RhdGUgIkRSTSBTdXBwb3J0IGZvciBQTDExMSBDTENEIENvbnRyb2xsZXIiCj4gKwlkZXBl bmRzIG9uIERSTQo+ICsJZGVwZW5kcyBvbiBBUk0gfHwgQVJNNjQgfHwgQ09NUElMRV9URVNUCj4g KwlzZWxlY3QgRFJNX0tNU19IRUxQRVIKPiArCXNlbGVjdCBEUk1fS01TX0NNQV9IRUxQRVIKPiAr CXNlbGVjdCBEUk1fR0VNX0NNQV9IRUxQRVIKPiArCXNlbGVjdCBWVF9IV19DT05TT0xFX0JJTkRJ TkcgaWYgRlJBTUVCVUZGRVJfQ09OU09MRQo+ICsJaGVscAo+ICsJICBDaG9vc2UgdGhpcyBvcHRp b24gZm9yIERSTSBzdXBwb3J0IGZvciB0aGUgUEwxMTEgQ0xDRCBjb250cm9sbGVyLgo+ICsJICBJ ZiBNIGlzIHNlbGVjdGVkIHRoZSBtb2R1bGUgd2lsbCBiZSBjYWxsZWQgcGwxMTFfZHJtLgo+ICsK PiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3BsMTExL01ha2VmaWxlIGIvZHJpdmVycy9n cHUvZHJtL3BsMTExL01ha2VmaWxlCj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPiBpbmRleCAwMDAw MDAwMDAwMDAuLjIwYTdmZDc2ZDUxMwo+IC0tLSAvZGV2L251bGwKPiArKysgYi9kcml2ZXJzL2dw dS9kcm0vcGwxMTEvTWFrZWZpbGUKPiBAQCAtMCwwICsxLDggQEAKPiArcGwxMTFfZHJtLXkgKz0J cGwxMTFfY29ubmVjdG9yLm8gXAo+ICsJCXBsMTExX2NydGMubyBcCj4gKwkJcGwxMTFfZHJ2Lm8g XAo+ICsJCXBsMTExX2VuY29kZXIubyBcCj4gKwkJcGwxMTFfZ2VtLm8gXAo+ICsJCXBsMTExX3Bs YW5lLm8KPiArCj4gK29iai0kKENPTkZJR19EUk1fUEwxMTEpICs9IHBsMTExX2RybS5vCj4gZGlm ZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9wbDExMS9wbDExMV9jb25uZWN0b3IuYyBiL2RyaXZl cnMvZ3B1L2RybS9wbDExMS9wbDExMV9jb25uZWN0b3IuYwo+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0 Cj4gaW5kZXggMDAwMDAwMDAwMDAwLi45ODExZDFlYWRiNjMKPiAtLS0gL2Rldi9udWxsCj4gKysr IGIvZHJpdmVycy9ncHUvZHJtL3BsMTExL3BsMTExX2Nvbm5lY3Rvci5jCj4gQEAgLTAsMCArMSwx MjcgQEAKPiArLyoKPiArICogKEMpIENPUFlSSUdIVCAyMDEyLTIwMTMgQVJNIExpbWl0ZWQuIEFs bCByaWdodHMgcmVzZXJ2ZWQuCj4gKyAqCj4gKyAqIFBhcnRzIG9mIHRoaXMgZmlsZSB3ZXJlIGJh c2VkIG9uIHNvdXJjZXMgYXMgZm9sbG93czoKPiArICoKPiArICogQ29weXJpZ2h0IChjKSAyMDA2 LTIwMDggSW50ZWwgQ29ycG9yYXRpb24KPiArICogQ29weXJpZ2h0IChjKSAyMDA3IERhdmUgQWly bGllIDxhaXJsaWVkQGxpbnV4LmllPgo+ICsgKiBDb3B5cmlnaHQgKEMpIDIwMTEgVGV4YXMgSW5z dHJ1bWVudHMKPiArICoKPiArICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmUgYW5kIGlz IHByb3ZpZGVkIHRvIHlvdSB1bmRlciB0aGUgdGVybXMgb2YgdGhlCj4gKyAqIEdOVSBHZW5lcmFs IFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdh cmUKPiArICogRm91bmRhdGlvbiwgYW5kIGFueSB1c2UgYnkgeW91IG9mIHRoaXMgcHJvZ3JhbSBp cyBzdWJqZWN0IHRvIHRoZSB0ZXJtcyBvZgo+ICsgKiBzdWNoIEdOVSBsaWNlbmNlLgo+ICsgKgo+ ICsgKi8KPiArCj4gKy8qKgo+ICsgKiBwbDExMV9kcm1fY29ubmVjdG9yLmMKPiArICogSW1wbGVt ZW50YXRpb24gb2YgdGhlIGNvbm5lY3RvciBmdW5jdGlvbnMgZm9yIFBMMTExIERSTQo+ICsgKi8K PiArI2luY2x1ZGUgPGxpbnV4L2FtYmEvY2xjZC1yZWdzLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC92 ZXJzaW9uLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9zaG1lbV9mcy5oPgo+ICsjaW5jbHVkZSA8bGlu dXgvZG1hLWJ1Zi5oPgo+ICsKPiArI2luY2x1ZGUgPGRybS9kcm1QLmg+Cj4gKyNpbmNsdWRlIDxk cm0vZHJtX2F0b21pY19oZWxwZXIuaD4KPiArI2luY2x1ZGUgPGRybS9kcm1fY3J0Y19oZWxwZXIu aD4KPiArI2luY2x1ZGUgPGRybS9kcm1fb2YuaD4KPiArI2luY2x1ZGUgPGRybS9kcm1fcGFuZWwu aD4KPiArCj4gKyNpbmNsdWRlICJwbDExMV9kcm0uaCIKPiArCj4gK3N0YXRpYyB2b2lkIHBsMTEx X2Nvbm5lY3Rvcl9kZXN0cm95KHN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3IpCj4gK3sK PiArCXN0cnVjdCBwbDExMV9kcm1fY29ubmVjdG9yICpwbDExMV9jb25uZWN0b3IgPQo+ICsJCXRv X3BsMTExX2Nvbm5lY3Rvcihjb25uZWN0b3IpOwo+ICsKPiArCWlmIChwbDExMV9jb25uZWN0b3It PnBhbmVsKQo+ICsJCWRybV9wYW5lbF9kZXRhY2gocGwxMTFfY29ubmVjdG9yLT5wYW5lbCk7Cj4g Kwo+ICsJZHJtX2Nvbm5lY3Rvcl91bnJlZ2lzdGVyKGNvbm5lY3Rvcik7Cj4gKwlkcm1fY29ubmVj dG9yX2NsZWFudXAoY29ubmVjdG9yKTsKPiArfQo+ICsKPiArc3RhdGljIGVudW0gZHJtX2Nvbm5l Y3Rvcl9zdGF0dXMgcGwxMTFfY29ubmVjdG9yX2RldGVjdChzdHJ1Y3QgZHJtX2Nvbm5lY3Rvcgo+ ICsJCQkJCQkJKmNvbm5lY3RvciwgYm9vbCBmb3JjZSkKPiArewo+ICsJc3RydWN0IHBsMTExX2Ry bV9jb25uZWN0b3IgKnBsMTExX2Nvbm5lY3RvciA9Cj4gKwkJdG9fcGwxMTFfY29ubmVjdG9yKGNv bm5lY3Rvcik7Cj4gKwo+ICsJcmV0dXJuIChwbDExMV9jb25uZWN0b3ItPnBhbmVsID8KPiArCQlj b25uZWN0b3Jfc3RhdHVzX2Nvbm5lY3RlZCA6Cj4gKwkJY29ubmVjdG9yX3N0YXR1c19kaXNjb25u ZWN0ZWQpOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IHBsMTExX2Nvbm5lY3Rvcl9oZWxwZXJfZ2V0 X21vZGVzKHN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3IpCj4gK3sKPiArCXN0cnVjdCBw bDExMV9kcm1fY29ubmVjdG9yICpwbDExMV9jb25uZWN0b3IgPQo+ICsJCXRvX3BsMTExX2Nvbm5l Y3Rvcihjb25uZWN0b3IpOwo+ICsKPiArCWlmICghcGwxMTFfY29ubmVjdG9yLT5wYW5lbCkKPiAr CQlyZXR1cm4gMDsKPiArCj4gKwlyZXR1cm4gZHJtX3BhbmVsX2dldF9tb2RlcyhwbDExMV9jb25u ZWN0b3ItPnBhbmVsKTsKPiArfQoKUHJvYmFibHkgdGhlIHVtcHRlbnRoIHRpbWUgSSd2ZSBzZWVu IHRoaXMgOigKCk9uZSBvcHRpb24gSSB0aGluayB3b3VsZCB3b3JrIHdlbGwgaXMgaWYgd2UgaGF2 ZSBhIGdlbmVyaWMgIndyYXAgYQpkcm1fcGFuZWwgaW50byBhIGRybV9icmlkZ2UiIGRyaXZlciBh bmQganVzdCBnbHVlIHRoYXQgaW4gd2l0aCBhbiBvZgpoZWxwZXIgYXMgdGhlIGxhc3QgZWxlbWVu dCBpbiB0aGUgZW5jL3RyYW5zY29kZXIuIExhdXJlbnQgaGFzIHRoYXQKcHJhY3RpY2FsbHkgd3Jp dHRlbiBhbHJlYWR5LCBidXQgaGUgaW5zaXN0IGluIGNhbGxpbmcgaXQgdGhlIGx2ZHMgYnJpZGdl LApiZWNhdXNlIGl0J3MgZm9yIGEgMTAwJSBkdW1teSBsdmRzIHRyYW5zY29kZXIuCgpCdXQgc2lu Y2UgaXQncyAxMDAlIGR1bW15IGl0J3MgaW5kaXN0aW5ndWlzaGFibGUgZnJvbSBwdXJlIHN3CmFi c3RyYWN0aW9uL2ltcGVuZGVuY2UgbWlzbWF0Y2ggaGVscGVyLgoKQW55d2F5LCBqdXN0IGFuIGlk ZWEsIG5vdCBnb2luZyB0byBhc2sgeW91IHRvIGRvIHRoaXMsIGJ1dCBpZiBkcm1fcGFuZWwKdGFr ZXMgb2YgbGlrZSBjcmF6eSB3ZSdsbCBwcm9iYWJseSB3YW50IHRoaXMuCgo+ICsKPiArY29uc3Qg c3RydWN0IGRybV9jb25uZWN0b3JfZnVuY3MgY29ubmVjdG9yX2Z1bmNzID0gewo+ICsJLmZpbGxf bW9kZXMgPSBkcm1faGVscGVyX3Byb2JlX3NpbmdsZV9jb25uZWN0b3JfbW9kZXMsCj4gKwkuZGVz dHJveSA9IHBsMTExX2Nvbm5lY3Rvcl9kZXN0cm95LAo+ICsJLmRldGVjdCA9IHBsMTExX2Nvbm5l Y3Rvcl9kZXRlY3QsCj4gKwkuZHBtcyA9IGRybV9hdG9taWNfaGVscGVyX2Nvbm5lY3Rvcl9kcG1z LAo+ICsJLnJlc2V0ID0gZHJtX2F0b21pY19oZWxwZXJfY29ubmVjdG9yX3Jlc2V0LAo+ICsJLmF0 b21pY19kdXBsaWNhdGVfc3RhdGUgPSBkcm1fYXRvbWljX2hlbHBlcl9jb25uZWN0b3JfZHVwbGlj YXRlX3N0YXRlLAo+ICsJLmF0b21pY19kZXN0cm95X3N0YXRlID0gZHJtX2F0b21pY19oZWxwZXJf Y29ubmVjdG9yX2Rlc3Ryb3lfc3RhdGUsCj4gK307Cj4gKwo+ICtjb25zdCBzdHJ1Y3QgZHJtX2Nv bm5lY3Rvcl9oZWxwZXJfZnVuY3MgY29ubmVjdG9yX2hlbHBlcl9mdW5jcyA9IHsKPiArCS5nZXRf bW9kZXMgPSBwbDExMV9jb25uZWN0b3JfaGVscGVyX2dldF9tb2RlcywKPiArfTsKPiArCj4gKy8q IFdhbGtzIHRoZSBPRiBncmFwaCB0byBmaW5kIHRoZSBwYW5lbCBub2RlIGFuZCB0aGVuIGFza3Mg RFJNIHRvIGxvb2sKPiArICogdXAgdGhlIHBhbmVsLgo+ICsgKi8KPiArc3RhdGljIHN0cnVjdCBk cm1fcGFuZWwgKnBsMTExX2dldF9wYW5lbChzdHJ1Y3QgZGV2aWNlICpkZXYpCj4gK3sKPiArCXN0 cnVjdCBkZXZpY2Vfbm9kZSAqZW5kcG9pbnQsICpwYW5lbF9ub2RlOwo+ICsJc3RydWN0IGRldmlj ZV9ub2RlICpucCA9IGRldi0+b2Zfbm9kZTsKPiArCXN0cnVjdCBkcm1fcGFuZWwgKnBhbmVsOwo+ ICsKPiArCWVuZHBvaW50ID0gb2ZfZ3JhcGhfZ2V0X25leHRfZW5kcG9pbnQobnAsIE5VTEwpOwo+ ICsJaWYgKCFlbmRwb2ludCkgewo+ICsJCWRldl9lcnIoZGV2LCAibm8gZW5kcG9pbnQgdG8gZmV0 Y2ggcGFuZWxcbiIpOwo+ICsJCXJldHVybiBOVUxMOwo+ICsJfQo+ICsKPiArCS8qIGRvbid0IHBy b2NlZWQgaWYgd2UgaGF2ZSBhbiBlbmRwb2ludCBidXQgbm8gcGFuZWxfbm9kZSB0aWVkIHRvIGl0 ICovCj4gKwlwYW5lbF9ub2RlID0gb2ZfZ3JhcGhfZ2V0X3JlbW90ZV9wb3J0X3BhcmVudChlbmRw b2ludCk7Cj4gKwlvZl9ub2RlX3B1dChlbmRwb2ludCk7Cj4gKwlpZiAoIXBhbmVsX25vZGUpIHsK PiArCQlkZXZfZXJyKGRldiwgIm5vIHZhbGlkIHBhbmVsIG5vZGVcbiIpOwo+ICsJCXJldHVybiBO VUxMOwo+ICsJfQo+ICsKPiArCXBhbmVsID0gb2ZfZHJtX2ZpbmRfcGFuZWwocGFuZWxfbm9kZSk7 Cj4gKwlvZl9ub2RlX3B1dChwYW5lbF9ub2RlKTsKPiArCj4gKwlyZXR1cm4gcGFuZWw7Cj4gK30K PiArCj4gK2ludCBwbDExMV9jb25uZWN0b3JfY3JlYXRlKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYp Cj4gK3sKPiArCXN0cnVjdCBwbDExMV9kcm1fZGV2X3ByaXZhdGUgKnByaXYgPSBkZXYtPmRldl9w cml2YXRlOwo+ICsJc3RydWN0IHBsMTExX2RybV9jb25uZWN0b3IgKnBsMTExX2Nvbm5lY3RvciA9 ICZwcml2LT5jb25uZWN0b3I7Cj4gKwlzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9yID0g JnBsMTExX2Nvbm5lY3Rvci0+Y29ubmVjdG9yOwo+ICsKPiArCWRybV9jb25uZWN0b3JfaW5pdChk ZXYsIGNvbm5lY3RvciwgJmNvbm5lY3Rvcl9mdW5jcywKPiArCQkJICAgRFJNX01PREVfQ09OTkVD VE9SX0RQSSk7Cj4gKwlkcm1fY29ubmVjdG9yX2hlbHBlcl9hZGQoY29ubmVjdG9yLCAmY29ubmVj dG9yX2hlbHBlcl9mdW5jcyk7Cj4gKwo+ICsJcGwxMTFfY29ubmVjdG9yLT5wYW5lbCA9IHBsMTEx X2dldF9wYW5lbChkZXYtPmRldik7Cj4gKwlpZiAocGwxMTFfY29ubmVjdG9yLT5wYW5lbCkKPiAr CQlkcm1fcGFuZWxfYXR0YWNoKHBsMTExX2Nvbm5lY3Rvci0+cGFuZWwsIGNvbm5lY3Rvcik7Cj4g Kwo+ICsJcmV0dXJuIDA7Cj4gK30KPiArCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9w bDExMS9wbDExMV9jcnRjLmMgYi9kcml2ZXJzL2dwdS9kcm0vcGwxMTEvcGwxMTFfY3J0Yy5jCj4g bmV3IGZpbGUgbW9kZSAxMDA2NDQKPiBpbmRleCAwMDAwMDAwMDAwMDAuLjRjNzNiZGQzYjdlNAo+ IC0tLSAvZGV2L251bGwKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vcGwxMTEvcGwxMTFfY3J0Yy5j Cj4gQEAgLTAsMCArMSwyMzkgQEAKPiArLyoKPiArICogKEMpIENPUFlSSUdIVCAyMDEyLTIwMTMg QVJNIExpbWl0ZWQuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCj4gKyAqCj4gKyAqIFBhcnRzIG9mIHRo aXMgZmlsZSB3ZXJlIGJhc2VkIG9uIHNvdXJjZXMgYXMgZm9sbG93czoKPiArICoKPiArICogQ29w eXJpZ2h0IChjKSAyMDA2LTIwMDggSW50ZWwgQ29ycG9yYXRpb24KPiArICogQ29weXJpZ2h0IChj KSAyMDA3IERhdmUgQWlybGllIDxhaXJsaWVkQGxpbnV4LmllPgo+ICsgKiBDb3B5cmlnaHQgKEMp IDIwMTEgVGV4YXMgSW5zdHJ1bWVudHMKPiArICoKPiArICogVGhpcyBwcm9ncmFtIGlzIGZyZWUg c29mdHdhcmUgYW5kIGlzIHByb3ZpZGVkIHRvIHlvdSB1bmRlciB0aGUgdGVybXMgb2YgdGhlCj4g KyAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcyBwdWJsaXNoZWQgYnkg dGhlIEZyZWUgU29mdHdhcmUKPiArICogRm91bmRhdGlvbiwgYW5kIGFueSB1c2UgYnkgeW91IG9m IHRoaXMgcHJvZ3JhbSBpcyBzdWJqZWN0IHRvIHRoZSB0ZXJtcyBvZgo+ICsgKiBzdWNoIEdOVSBs aWNlbmNlLgo+ICsgKgo+ICsgKi8KPiArCj4gKy8qKgo+ICsgKiBwbDExMV9kcm1fY3J0Yy5jCj4g KyAqIEltcGxlbWVudGF0aW9uIG9mIHRoZSBDUlRDIGZ1bmN0aW9ucyBmb3IgUEwxMTEgRFJNCj4g KyAqLwo+ICsjaW5jbHVkZSA8bGludXgvYW1iYS9jbGNkLXJlZ3MuaD4KPiArI2luY2x1ZGUgPGxp bnV4L2Nsay5oPgo+ICsjaW5jbHVkZSA8bGludXgvdmVyc2lvbi5oPgo+ICsjaW5jbHVkZSA8bGlu dXgvc2htZW1fZnMuaD4KPiArI2luY2x1ZGUgPGxpbnV4L2RtYS1idWYuaD4KPiArCj4gKyNpbmNs dWRlIDxkcm0vZHJtUC5oPgo+ICsjaW5jbHVkZSA8ZHJtL2RybV9hdG9taWNfaGVscGVyLmg+Cj4g KyNpbmNsdWRlIDxkcm0vZHJtX2NydGNfaGVscGVyLmg+Cj4gKyNpbmNsdWRlIDxkcm0vZHJtX3Bh bmVsLmg+Cj4gKwo+ICsjaW5jbHVkZSAicGwxMTFfZHJtLmgiCj4gKwo+ICtpcnFyZXR1cm5fdCBw bDExMV9pcnEoaW50IGlycSwgdm9pZCAqZGF0YSkKPiArewo+ICsJc3RydWN0IHBsMTExX2RybV9k ZXZfcHJpdmF0ZSAqcHJpdiA9IGRhdGE7Cj4gKwl1MzIgaXJxX3N0YXQ7Cj4gKwlpcnFyZXR1cm5f dCBzdGF0dXMgPSBJUlFfTk9ORTsKPiArCj4gKwlpcnFfc3RhdCA9IHJlYWRsKHByaXYtPnJlZ3Mg KyBDTENEX1BMMTExX01JUyk7Cj4gKwo+ICsJaWYgKCFpcnFfc3RhdCkKPiArCQlyZXR1cm4gSVJR X05PTkU7Cj4gKwo+ICsJaWYgKGlycV9zdGF0ICYgQ0xDRF9JUlFfTkVYVEJBU0VfVVBEQVRFKSB7 Cj4gKwkJZHJtX2NydGNfaGFuZGxlX3ZibGFuaygmcHJpdi0+Y3J0Yyk7Cj4gKwo+ICsJCXN0YXR1 cyA9IElSUV9IQU5ETEVEOwo+ICsJfQo+ICsKPiArCS8qIENsZWFyIHRoZSBpbnRlcnJ1cHQgb25j ZSBkb25lICovCj4gKwl3cml0ZWwoaXJxX3N0YXQsIHByaXYtPnJlZ3MgKyBDTENEX1BMMTExX0lD Uik7Cj4gKwo+ICsJcmV0dXJuIHN0YXR1czsKPiArfQo+ICsKPiArc3RhdGljIGludCBwbDExMV9j cnRjX2F0b21pY19jaGVjayhzdHJ1Y3QgZHJtX2NydGMgKmNydGMsCj4gKwkJCQkgICBzdHJ1Y3Qg ZHJtX2NydGNfc3RhdGUgKnN0YXRlKQo+ICt7Cj4gKwljb25zdCBzdHJ1Y3QgZHJtX2Rpc3BsYXlf bW9kZSAqbW9kZSA9ICZzdGF0ZS0+bW9kZTsKPiArCj4gKwlpZiAoIXN0YXRlLT5hY3RpdmUpCj4g KwkJcmV0dXJuIDA7Cj4gKwo+ICsJaWYgKG1vZGUtPmhkaXNwbGF5ICUgMTYpCj4gKwkJcmV0dXJu IC1FSU5WQUw7Cj4gKwo+ICsJcmV0dXJuIDA7Cj4gK30KPiArCj4gK3N0YXRpYyB2b2lkIHBsMTEx X2NydGNfaGVscGVyX21vZGVfc2V0X25vZmIoc3RydWN0IGRybV9jcnRjICpjcnRjKQo+ICt7Cj4g KwlzdHJ1Y3QgZHJtX2RldmljZSAqZHJtID0gY3J0Yy0+ZGV2Owo+ICsJc3RydWN0IHBsMTExX2Ry bV9kZXZfcHJpdmF0ZSAqcHJpdiA9IGNydGMtPmRldi0+ZGV2X3ByaXZhdGU7Cj4gKwljb25zdCBz dHJ1Y3QgZHJtX2Rpc3BsYXlfbW9kZSAqbW9kZSA9ICZjcnRjLT5zdGF0ZS0+bW9kZTsKPiArCXN0 cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3IgPSAmcHJpdi0+Y29ubmVjdG9yLmNvbm5lY3Rv cjsKPiArCXVuc2lnbmVkIGludCBwcGwsIGhzdywgaGZwLCBoYnA7Cj4gKwl1bnNpZ25lZCBpbnQg bHBwLCB2c3csIHZmcCwgdmJwOwo+ICsJdW5zaWduZWQgaW50IGNwbDsKPiArCWludCByZXQ7Cj4g Kwo+ICsJcmV0ID0gY2xrX3NldF9yYXRlKHByaXYtPmNsaywgbW9kZS0+Y2xvY2sgKiAxMDAwKTsK PiArCWlmIChyZXQpIHsKPiArCQlkZXZfZXJyKGRybS0+ZGV2LAo+ICsJCQkiRmFpbGVkIHRvIHNl dCBwaXhlbCBjbG9jayByYXRlIHRvICVkOiAlZFxuIiwKPiArCQkJbW9kZS0+Y2xvY2sgKiAxMDAw LCByZXQpOwo+ICsJfQo+ICsKPiArCXBwbCA9IChtb2RlLT5oZGlzcGxheSAvIDE2KSAtIDE7Cj4g Kwloc3cgPSBtb2RlLT5oc3luY19lbmQgLSBtb2RlLT5oc3luY19zdGFydCAtIDE7Cj4gKwloZnAg PSBtb2RlLT5oc3luY19zdGFydCAtIG1vZGUtPmhkaXNwbGF5IC0gMTsKPiArCWhicCA9IG1vZGUt Pmh0b3RhbCAtIG1vZGUtPmhzeW5jX2VuZCAtIDE7Cj4gKwo+ICsJbHBwID0gbW9kZS0+dmRpc3Bs YXkgLSAxOwo+ICsJdnN3ID0gbW9kZS0+dnN5bmNfZW5kIC0gbW9kZS0+dnN5bmNfc3RhcnQgLSAx Owo+ICsJdmZwID0gbW9kZS0+dnN5bmNfc3RhcnQgLSBtb2RlLT52ZGlzcGxheTsKPiArCXZicCA9 IG1vZGUtPnZ0b3RhbCAtIG1vZGUtPnZzeW5jX2VuZDsKPiArCj4gKwljcGwgPSBtb2RlLT5oZGlz cGxheSAtIDE7Cj4gKwo+ICsJd3JpdGVsKChwcGwgPDwgMikgfAo+ICsJICAgICAgIChoc3cgPDwg OCkgfAo+ICsJICAgICAgIChoZnAgPDwgMTYpIHwKPiArCSAgICAgICAoaGJwIDw8IDI0KSwKPiAr CSAgICAgICBwcml2LT5yZWdzICsgQ0xDRF9USU0wKTsKPiArCXdyaXRlbChscHAgfAo+ICsJICAg ICAgICh2c3cgPDwgMTApIHwKPiArCSAgICAgICAodmZwIDw8IDE2KSB8Cj4gKwkgICAgICAgKHZi cCA8PCAyNCksCj4gKwkgICAgICAgcHJpdi0+cmVncyArIENMQ0RfVElNMSk7Cj4gKwkvKiBYWFg6 IFdlIGN1cnJlbnRseSBhbHdheXMgdXNlIENMQ0RDTEsgd2l0aCBubyBkaXZpc29yLiAgV2UKPiAr CSAqIGNvdWxkIHByb2JhYmx5IHJlZHVjZSBwb3dlciBjb25zdW1wdGlvbiBieSB1c2luZyBIQ0xL Cj4gKwkgKiAoYXBiX3BjbGspIHdpdGggYSBkaXZpc29yIHdoZW4gaXQgZ2V0cyB1cyBuZWFyIG91 ciB0YXJnZXQKPiArCSAqIHBpeGVsIGNsb2NrLgo+ICsJICovCj4gKwl3cml0ZWwoKChtb2RlLT5m bGFncyAmIERSTV9NT0RFX0ZMQUdfTkhTWU5DKSA/IFRJTTJfSUhTIDogMCkgfAo+ICsJICAgICAg ICgobW9kZS0+ZmxhZ3MgJiBEUk1fTU9ERV9GTEFHX05WU1lOQykgPyBUSU0yX0lWUyA6IDApIHwK PiArCSAgICAgICAoKGNvbm5lY3Rvci0+ZGlzcGxheV9pbmZvLmJ1c19mbGFncyAmCj4gKwkJIERS TV9CVVNfRkxBR19ERV9MT1cpID8gVElNMl9JT0UgOiAwKSB8Cj4gKwkgICAgICAgKChjb25uZWN0 b3ItPmRpc3BsYXlfaW5mby5idXNfZmxhZ3MgJgo+ICsJCSBEUk1fQlVTX0ZMQUdfUElYREFUQV9O RUdFREdFKSA/IFRJTTJfSVBDIDogMCkgfAo+ICsJICAgICAgIFRJTTJfQkNEIHwKPiArCSAgICAg ICAoY3BsIDw8IDE2KSB8Cj4gKwkgICAgICAgVElNMl9DTEtTRUwsCj4gKwkgICAgICAgcHJpdi0+ cmVncyArIENMQ0RfVElNMik7Cj4gKwl3cml0ZWwoMCwgcHJpdi0+cmVncyArIENMQ0RfVElNMyk7 Cj4gK30KPiArCj4gK3N0YXRpYyB2b2lkIHBsMTExX2NydGNfaGVscGVyX2VuYWJsZShzdHJ1Y3Qg ZHJtX2NydGMgKmNydGMpCj4gK3sKPiArCXN0cnVjdCBwbDExMV9kcm1fZGV2X3ByaXZhdGUgKnBy aXYgPSBjcnRjLT5kZXYtPmRldl9wcml2YXRlOwo+ICsJdTMyIGNudGw7Cj4gKwo+ICsJY2xrX3By ZXBhcmVfZW5hYmxlKHByaXYtPmNsayk7Cj4gKwo+ICsJZHJtX3BhbmVsX3ByZXBhcmUocHJpdi0+ Y29ubmVjdG9yLnBhbmVsKTsKPiArCj4gKwkvKiBFbmFibGUgYW5kIFBvd2VyIFVwICovCj4gKwlj bnRsID0gQ05UTF9MQ0RFTiB8IENOVExfTENEVEZUIHwgQ05UTF9MQ0RQV1IgfCBDTlRMX0xDRFZD T01QKDEpOwo+ICsKPiArCS8qIEtlZXAgdGhlIGZvcm1hdCB0aGF0IHRoZSBwcmltYXJ5IHBsYW5l IGhhZCBzZXQgdXAuICovCj4gKwljbnRsIHw9IHJlYWRsKHByaXYtPnJlZ3MgKyBDTENEX1BMMTEx X0NOVEwpICYgKDcgPDwgMSk7Cj4gKwo+ICsJd3JpdGVsKGNudGwsIHByaXYtPnJlZ3MgKyBDTENE X1BMMTExX0NOVEwpOwo+ICsKPiArCWRybV9wYW5lbF9lbmFibGUocHJpdi0+Y29ubmVjdG9yLnBh bmVsKTsKPiArfQo+ICsKPiArdm9pZCBwbDExMV9jcnRjX2hlbHBlcl9kaXNhYmxlKHN0cnVjdCBk cm1fY3J0YyAqY3J0YykKPiArewo+ICsJc3RydWN0IHBsMTExX2RybV9kZXZfcHJpdmF0ZSAqcHJp diA9IGNydGMtPmRldi0+ZGV2X3ByaXZhdGU7Cj4gKwo+ICsJZHJtX3BhbmVsX2Rpc2FibGUocHJp di0+Y29ubmVjdG9yLnBhbmVsKTsKPiArCj4gKwkvKiBEaXNhYmxlIGFuZCBQb3dlciBEb3duICov Cj4gKwl3cml0ZWwocmVhZGwocHJpdi0+cmVncyArIENMQ0RfUEwxMTFfQ05UTCkgJiAoNyA8PCAx KSwKPiArCSAgICAgICBwcml2LT5yZWdzICsgQ0xDRF9QTDExMV9DTlRMKTsKPiArCj4gKwlkcm1f cGFuZWxfdW5wcmVwYXJlKHByaXYtPmNvbm5lY3Rvci5wYW5lbCk7Cj4gKwo+ICsJLyogRGlzYWJs ZSBjbG9jayAqLwo+ICsJY2xrX2Rpc2FibGVfdW5wcmVwYXJlKHByaXYtPmNsayk7Cj4gK30KPiAr Cj4gK3N0YXRpYyB2b2lkIHBsMTExX2NydGNfaGVscGVyX2F0b21pY19mbHVzaChzdHJ1Y3QgZHJt X2NydGMgKmNydGMsCj4gKwkJCQkJICAgc3RydWN0IGRybV9jcnRjX3N0YXRlICpvbGRfc3RhdGUp Cj4gK3sKPiArCXN0cnVjdCBkcm1fcGVuZGluZ192YmxhbmtfZXZlbnQgKmV2ZW50ID0gY3J0Yy0+ c3RhdGUtPmV2ZW50Owo+ICsKPiArCWlmIChldmVudCkgewo+ICsJCWNydGMtPnN0YXRlLT5ldmVu dCA9IE5VTEw7Cj4gKwo+ICsJCXNwaW5fbG9ja19pcnEoJmNydGMtPmRldi0+ZXZlbnRfbG9jayk7 Cj4gKwkJaWYgKGNydGMtPnN0YXRlLT5hY3RpdmUgJiYgZHJtX2NydGNfdmJsYW5rX2dldChjcnRj KSA9PSAwKQo+ICsJCQlkcm1fY3J0Y19hcm1fdmJsYW5rX2V2ZW50KGNydGMsIGV2ZW50KTsKPiAr CQllbHNlCj4gKwkJCWRybV9jcnRjX3NlbmRfdmJsYW5rX2V2ZW50KGNydGMsIGV2ZW50KTsKPiAr CQlzcGluX3VubG9ja19pcnEoJmNydGMtPmRldi0+ZXZlbnRfbG9jayk7Cj4gKwl9Cj4gK30KPiAr Cj4gK3N0YXRpYyBpbnQgcGwxMTFfZW5hYmxlX3ZibGFuayhzdHJ1Y3QgZHJtX2NydGMgKmNydGMp Cj4gK3sKPiArCXN0cnVjdCBkcm1fZGV2aWNlICpkZXYgPSBjcnRjLT5kZXY7Cj4gKwlzdHJ1Y3Qg cGwxMTFfZHJtX2Rldl9wcml2YXRlICpwcml2ID0gZGV2LT5kZXZfcHJpdmF0ZTsKPiArCj4gKwlj bGtfcHJlcGFyZV9lbmFibGUocHJpdi0+Y2xrKTsKPiArCj4gKwl3cml0ZWwoQ0xDRF9JUlFfTkVY VEJBU0VfVVBEQVRFLCBwcml2LT5yZWdzICsgQ0xDRF9QTDExMV9JRU5CKTsKPiArCj4gKwlyZXR1 cm4gMDsKPiArfQo+ICsKPiArc3RhdGljIHZvaWQgcGwxMTFfZGlzYWJsZV92Ymxhbmsoc3RydWN0 IGRybV9jcnRjICpjcnRjKQo+ICt7Cj4gKwlzdHJ1Y3QgZHJtX2RldmljZSAqZGV2ID0gY3J0Yy0+ ZGV2Owo+ICsJc3RydWN0IHBsMTExX2RybV9kZXZfcHJpdmF0ZSAqcHJpdiA9IGRldi0+ZGV2X3By aXZhdGU7Cj4gKwo+ICsJd3JpdGVsKDAsIHByaXYtPnJlZ3MgKyBDTENEX1BMMTExX0lFTkIpOwo+ ICsKPiArCWNsa19kaXNhYmxlX3VucHJlcGFyZShwcml2LT5jbGspOwo+ICt9Cj4gKwo+ICtjb25z dCBzdHJ1Y3QgZHJtX2NydGNfZnVuY3MgY3J0Y19mdW5jcyA9IHsKPiArCS5zZXRfY29uZmlnID0g ZHJtX2F0b21pY19oZWxwZXJfc2V0X2NvbmZpZywKPiArCS5wYWdlX2ZsaXAgPSBkcm1fYXRvbWlj X2hlbHBlcl9wYWdlX2ZsaXAsCj4gKwkucmVzZXQgPSBkcm1fYXRvbWljX2hlbHBlcl9jcnRjX3Jl c2V0LAo+ICsJLmRlc3Ryb3kgPSBkcm1fY3J0Y19jbGVhbnVwLAo+ICsJLmVuYWJsZV92Ymxhbmsg PSBwbDExMV9lbmFibGVfdmJsYW5rLAo+ICsJLmRpc2FibGVfdmJsYW5rID0gcGwxMTFfZGlzYWJs ZV92YmxhbmssCj4gKwkuYXRvbWljX2R1cGxpY2F0ZV9zdGF0ZSA9IGRybV9hdG9taWNfaGVscGVy X2NydGNfZHVwbGljYXRlX3N0YXRlLAo+ICsJLmF0b21pY19kZXN0cm95X3N0YXRlID0gZHJtX2F0 b21pY19oZWxwZXJfY3J0Y19kZXN0cm95X3N0YXRlLAo+ICt9Owo+ICsKPiArY29uc3Qgc3RydWN0 IGRybV9jcnRjX2hlbHBlcl9mdW5jcyBjcnRjX2hlbHBlcl9mdW5jcyA9IHsKPiArCS5tb2RlX3Nl dF9ub2ZiID0gcGwxMTFfY3J0Y19oZWxwZXJfbW9kZV9zZXRfbm9mYiwKPiArCS5hdG9taWNfY2hl Y2sgPSBwbDExMV9jcnRjX2F0b21pY19jaGVjaywKPiArCS5hdG9taWNfZmx1c2ggPSBwbDExMV9j cnRjX2hlbHBlcl9hdG9taWNfZmx1c2gsCj4gKwkuZGlzYWJsZSA9IHBsMTExX2NydGNfaGVscGVy X2Rpc2FibGUsCj4gKwkuZW5hYmxlID0gcGwxMTFfY3J0Y19oZWxwZXJfZW5hYmxlLAo+ICt9Owo+ ICsKPiAraW50IHBsMTExX2NydGNfY3JlYXRlKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYpCj4gK3sK PiArCXN0cnVjdCBwbDExMV9kcm1fZGV2X3ByaXZhdGUgKnByaXYgPSBkZXYtPmRldl9wcml2YXRl Owo+ICsJc3RydWN0IGRybV9jcnRjICpjcnRjID0gJnByaXYtPmNydGM7Cj4gKwo+ICsJZHJtX2Ny dGNfaW5pdF93aXRoX3BsYW5lcyhkZXYsIGNydGMsCj4gKwkJCQkgICZwcml2LT5wcmltYXJ5LCBO VUxMLAo+ICsJCQkJICAmY3J0Y19mdW5jcywgInByaW1hcnkiKTsKPiArCWRybV9jcnRjX2hlbHBl cl9hZGQoY3J0YywgJmNydGNfaGVscGVyX2Z1bmNzKTsKPiArCj4gKwkvKiBYWFg6IFRoZSBydW50 aW1lIGNsb2NrIGRpc2FibGluZyBzdGlsbCByZXN1bHRzIGluCj4gKwkgKiBvY2Nhc2lvbmFsIHN5 c3RlbSBoYW5ncywgYW5kIG5lZWRzIGRlYnVnZ2luZy4KPiArCSAqLwo+ICsJY2xrX3ByZXBhcmVf ZW5hYmxlKHByaXYtPmNsayk7Cj4gKwo+ICsJcmV0dXJuIDA7Cj4gK30KPiBkaWZmIC0tZ2l0IGEv ZHJpdmVycy9ncHUvZHJtL3BsMTExL3BsMTExX2RybS5oIGIvZHJpdmVycy9ncHUvZHJtL3BsMTEx L3BsMTExX2RybS5oCj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPiBpbmRleCAwMDAwMDAwMDAwMDAu LjM2ZTRjZTc3MGE2Ywo+IC0tLSAvZGV2L251bGwKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vcGwx MTEvcGwxMTFfZHJtLmgKPiBAQCAtMCwwICsxLDY0IEBACj4gKy8qCj4gKyAqCj4gKyAqIChDKSBD T1BZUklHSFQgMjAxMi0yMDEzIEFSTSBMaW1pdGVkLiBBbGwgcmlnaHRzIHJlc2VydmVkLgo+ICsg Kgo+ICsgKgo+ICsgKiBQYXJ0cyBvZiB0aGlzIGZpbGUgd2VyZSBiYXNlZCBvbiBzb3VyY2VzIGFz IGZvbGxvd3M6Cj4gKyAqCj4gKyAqIENvcHlyaWdodCAoYykgMjAwNi0yMDA4IEludGVsIENvcnBv cmF0aW9uCj4gKyAqIENvcHlyaWdodCAoYykgMjAwNyBEYXZlIEFpcmxpZSA8YWlybGllZEBsaW51 eC5pZT4KPiArICogQ29weXJpZ2h0IChDKSAyMDExIFRleGFzIEluc3RydW1lbnRzCj4gKyAqCj4g KyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlIGFuZCBpcyBwcm92aWRlZCB0byB5b3Ug dW5kZXIgdGhlIHRlcm1zIG9mIHRoZQo+ICsgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2 ZXJzaW9uIDIgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlCj4gKyAqIEZvdW5kYXRp b24sIGFuZCBhbnkgdXNlIGJ5IHlvdSBvZiB0aGlzIHByb2dyYW0gaXMgc3ViamVjdCB0byB0aGUg dGVybXMgb2YKPiArICogc3VjaCBHTlUgbGljZW5jZS4KPiArICoKPiArICovCj4gKwo+ICsjaWZu ZGVmIF9QTDExMV9EUk1fSF8KPiArI2RlZmluZSBfUEwxMTFfRFJNX0hfCj4gKwo+ICsjaW5jbHVk ZSA8ZHJtL2RybV9nZW0uaD4KPiArCj4gKyNkZWZpbmUgQ0xDRF9JUlFfTkVYVEJBU0VfVVBEQVRF IEJJVCgyKQo+ICsKPiArc3RydWN0IHBsMTExX2RybV9jb25uZWN0b3Igewo+ICsJc3RydWN0IGRy bV9jb25uZWN0b3IgY29ubmVjdG9yOwo+ICsJc3RydWN0IGRybV9wYW5lbCAqcGFuZWw7Cj4gK307 Cj4gKwo+ICtzdHJ1Y3QgcGwxMTFfZHJtX2Rldl9wcml2YXRlIHsKPiArCXN0cnVjdCBkcm1fZGV2 aWNlICpkcm07Cj4gKwo+ICsJc3RydWN0IHBsMTExX2RybV9jb25uZWN0b3IgY29ubmVjdG9yOwo+ ICsJc3RydWN0IGRybV9jcnRjIGNydGM7Cj4gKwlzdHJ1Y3QgZHJtX2VuY29kZXIgZW5jb2RlcjsK PiArCXN0cnVjdCBkcm1fcGxhbmUgcHJpbWFyeTsKPiArCXN0cnVjdCBkcm1fZmJkZXZfY21hICpm YmRldjsKPiArCj4gKwl2b2lkICpyZWdzOwo+ICsJc3RydWN0IGNsayAqY2xrOwo+ICt9Owo+ICsK PiArI2RlZmluZSB0b19wbDExMV9jb25uZWN0b3IoeCkgXAo+ICsJY29udGFpbmVyX29mKHgsIHN0 cnVjdCBwbDExMV9kcm1fY29ubmVjdG9yLCBjb25uZWN0b3IpCj4gKwo+ICsvKiBDUlRDIEZ1bmN0 aW9ucyAqLwo+ICtpbnQgcGwxMTFfY3J0Y19jcmVhdGUoc3RydWN0IGRybV9kZXZpY2UgKmRldik7 Cj4gK2lycXJldHVybl90IHBsMTExX2lycShpbnQgaXJxLCB2b2lkICpkYXRhKTsKPiArCj4gK2lu dCBwbDExMV9wcmltYXJ5X3BsYW5lX2luaXQoc3RydWN0IGRybV9kZXZpY2UgKmRldik7Cj4gKwo+ ICsvKiBDb25uZWN0b3IgRnVuY3Rpb25zICovCj4gK2ludCBwbDExMV9jb25uZWN0b3JfY3JlYXRl KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYpOwo+ICsKPiArLyogRW5jb2RlciBGdW5jdGlvbnMgKi8K PiAraW50IHBsMTExX2VuY29kZXJfaW5pdChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2KTsKPiArCj4g Ky8qIEdFTSBGdW5jdGlvbnMgKi8KPiAraW50IHBsMTExX2R1bWJfY3JlYXRlKHN0cnVjdCBkcm1f ZmlsZSAqZmlsZV9wcml2LAo+ICsJCSAgICAgIHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsCj4gKwkJ ICAgICAgc3RydWN0IGRybV9tb2RlX2NyZWF0ZV9kdW1iICphcmdzKTsKPiArCj4gKyNlbmRpZiAv KiBfUEwxMTFfRFJNX0hfICovCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9wbDExMS9w bDExMV9kcnYuYyBiL2RyaXZlcnMvZ3B1L2RybS9wbDExMS9wbDExMV9kcnYuYwo+IG5ldyBmaWxl IG1vZGUgMTAwNjQ0Cj4gaW5kZXggMDAwMDAwMDAwMDAwLi41NzFjMjk2ZGRkZjcKPiAtLS0gL2Rl di9udWxsCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL3BsMTExL3BsMTExX2Rydi5jCj4gQEAgLTAs MCArMSwyOTIgQEAKPiArLyoKPiArICogKEMpIENPUFlSSUdIVCAyMDEyLTIwMTMgQVJNIExpbWl0 ZWQuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCj4gKyAqCj4gKyAqIFBhcnRzIG9mIHRoaXMgZmlsZSB3 ZXJlIGJhc2VkIG9uIHNvdXJjZXMgYXMgZm9sbG93czoKPiArICoKPiArICogQ29weXJpZ2h0IChj KSAyMDA2LTIwMDggSW50ZWwgQ29ycG9yYXRpb24KPiArICogQ29weXJpZ2h0IChjKSAyMDA3IERh dmUgQWlybGllIDxhaXJsaWVkQGxpbnV4LmllPgo+ICsgKiBDb3B5cmlnaHQgKEMpIDIwMTEgVGV4 YXMgSW5zdHJ1bWVudHMKPiArICoKPiArICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmUg YW5kIGlzIHByb3ZpZGVkIHRvIHlvdSB1bmRlciB0aGUgdGVybXMgb2YgdGhlCj4gKyAqIEdOVSBH ZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUg U29mdHdhcmUKPiArICogRm91bmRhdGlvbiwgYW5kIGFueSB1c2UgYnkgeW91IG9mIHRoaXMgcHJv Z3JhbSBpcyBzdWJqZWN0IHRvIHRoZSB0ZXJtcyBvZgo+ICsgKiBzdWNoIEdOVSBsaWNlbmNlLgo+ ICsgKgo+ICsgKi8KPiArCj4gKy8qKgo+ICsgKiBET0M6IEFSTSBQcmltZUNlbGwgUEwxMTEgQ0xD RCBEcml2ZXIKPiArICoKPiArICogVGhlIFBMMTExIGlzIGEgc2ltcGxlIExDRCBjb250cm9sbGVy IHRoYXQgY2FuIHN1cHBvcnQgVEZUIGFuZCBTVE4KPiArICogZGlzcGxheXMuICBUaGlzIGRyaXZl ciBleHBvc2VzIGEgc3RhbmRhcmQgS01TIGludGVyZmFjZSBmb3IgdGhlbS4KPiArICoKPiArICog VGhpcyBkcml2ZXIgdXNlcyB0aGUgc2FtZSBEZXZpY2UgVHJlZSBiaW5kaW5nIGFzIHRoZSBmYmRl diBDTENECj4gKyAqIGRyaXZlci4gIFdoaWxlIHRoZSBmYmRldiBkcml2ZXIgc3VwcG9ydHMgcGFu ZWxzIHRoYXQgbWF5IGJlCj4gKyAqIGNvbm5lY3RlZCB0byB0aGUgQ0xDRCBpbnRlcm5hbGx5IHRv IHRoZSBDTENEIGRyaXZlciwgaW4gRFJNIHRoZQo+ICsgKiBwYW5lbHMgZ2V0IHNwbGl0IG91dCB0 byBkcml2ZXJzL2dwdS9kcm0vcGFuZWxzLy4gIFRoaXMgbWVhbnMgdGhhdCwKPiArICogaW4gY29u dmVydGluZyBmcm9tIHVzaW5nIGZiZGV2IHRvIHVzaW5nIERSTSwgeW91IGFsc28gbmVlZCB0byB3 cml0ZQo+ICsgKiBhIHBhbmVsIGRyaXZlciAod2hpY2ggbWF5IGJlIGFzIHNpbXBsZSBhcyBhbiBl bnRyeSBpbgo+ICsgKiBwYW5lbC1zaW1wbGUuYykuCj4gKyAqCj4gKyAqIFRoZSBkcml2ZXIgY3Vy cmVudGx5IGRvZXNuJ3QgZXhwb3NlIHRoZSBjdXJzb3IuICBUaGUgRFJNIEFQSSBmb3IKPiArICog Y3Vyc29ycyByZXF1aXJlcyBzdXBwb3J0IGZvciA2NHg2NCBBUkdCODg4OCBjdXJzb3IgaW1hZ2Vz LCB3aGlsZQo+ICsgKiB0aGUgaGFyZHdhcmUgY2FuIG9ubHkgc3VwcG9ydCA2NHg2NCBtb25vY2hy b21lIHdpdGggbWFza2luZwo+ICsgKiBjdXJzb3JzLiAgV2hpbGUgb25lIGNvdWxkIGltYWdpbmUg dHJ5aW5nIHRvIGhhY2sgc29tZXRoaW5nIHRvZ2V0aGVyCj4gKyAqIHRvIGxvb2sgYXQgdGhlIEFS R0I4ODg4IGFuZCBwcm9ncmFtIHJlYXNvbmFibGUgaW4gbW9ub2Nocm9tZSwgd2UKPiArICoganVz dCBkb24ndCBleHBvc2UgdGhlIGN1cnNvciBhdCBhbGwgaW5zdGVhZCwgYW5kIGxlYXZlIGN1cnNv cgo+ICsgKiBzdXBwb3J0IHRvIHRoZSBYMTEgc29mdHdhcmUgY3Vyc29yIGxheWVyLgo+ICsgKgo+ ICsgKiBUT0RPOgo+ICsgKgo+ICsgKiAtIEZpeCByYWNlIGJldHdlZW4gc2V0dGluZyBwbGFuZSBi YXNlIGFkZHJlc3MgYW5kIGdldHRpbmcgSVJRIGZvcgo+ICsgKiAgIHZzeW5jIGZpcmluZyB0aGUg cGFnZWZsaXAgY29tcGxldGlvbi4KPiArICoKPiArICogLSBFeHBvc2UgdGhlIGNvcnJlY3Qgc2V0 IG9mIGZvcm1hdHMgd2UgY2FuIHN1cHBvcnQgYmFzZWQgb24gdGhlCj4gKyAqICAgImFybSxwbDEx eCx0ZnQtcjBnMGIwLXBhZHMiIERUIHByb3BlcnR5Lgo+ICsgKgo+ICsgKiAtIFVzZSB0aGUgIm1h eC1tZW1vcnktYmFuZHdpZHRoIiBEVCBwcm9wZXJ0eSB0byBmaWx0ZXIgdGhlCj4gKyAqICAgc3Vw cG9ydGVkIGZvcm1hdHMuCj4gKyAqCj4gKyAqIC0gUmVhZCBiYWNrIGhhcmR3YXJlIHN0YXRlIGF0 IGJvb3QgdG8gc2tpcCByZXByb2dyYW1taW5nIHRoZQo+ICsgKiAgIGhhcmR3YXJlIHdoZW4gZG9p bmcgYSBuby1vcCBtb2Rlc2V0Lgo+ICsgKgo+ICsgKiAtIFVzZSB0aGUgaW50ZXJuYWwgY2xvY2sg ZGl2aXNvciB0byByZWR1Y2UgcG93ZXIgY29uc3VtcHRpb24gYnkKPiArICogICB1c2luZyBIQ0xL IChhcGJfcGNsaykgd2hlbiBhcHByb3ByaWF0ZS4KPiArICovCj4gKwo+ICsjaW5jbHVkZSA8bGlu dXgvYW1iYS9idXMuaD4KPiArI2luY2x1ZGUgPGxpbnV4L2FtYmEvY2xjZC1yZWdzLmg+Cj4gKyNp bmNsdWRlIDxsaW51eC92ZXJzaW9uLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9zaG1lbV9mcy5oPgo+ ICsjaW5jbHVkZSA8bGludXgvZG1hLWJ1Zi5oPgo+ICsjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+ Cj4gKyNpbmNsdWRlIDxsaW51eC9zbGFiLmg+Cj4gKwo+ICsjaW5jbHVkZSA8ZHJtL2RybVAuaD4K PiArI2luY2x1ZGUgPGRybS9kcm1fYXRvbWljX2hlbHBlci5oPgo+ICsjaW5jbHVkZSA8ZHJtL2Ry bV9jcnRjX2hlbHBlci5oPgo+ICsjaW5jbHVkZSA8ZHJtL2RybV9nZW1fY21hX2hlbHBlci5oPgo+ ICsjaW5jbHVkZSA8ZHJtL2RybV9mYl9jbWFfaGVscGVyLmg+Cj4gKwo+ICsjaW5jbHVkZSAicGwx MTFfZHJtLmgiCj4gKwo+ICsjZGVmaW5lIERSSVZFUl9ERVNDICAgICAgIkRSTSBtb2R1bGUgZm9y IFBMMTExIgo+ICsKPiArc3RydWN0IGRybV9tb2RlX2NvbmZpZ19mdW5jcyBtb2RlX2NvbmZpZ19m dW5jcyA9IHsKPiArCS5mYl9jcmVhdGUgPSBkcm1fZmJfY21hX2NyZWF0ZSwKPiArCS5hdG9taWNf Y2hlY2sgPSBkcm1fYXRvbWljX2hlbHBlcl9jaGVjaywKPiArCS5hdG9taWNfY29tbWl0ID0gZHJt X2F0b21pY19oZWxwZXJfY29tbWl0LAo+ICt9Owo+ICsKPiArc3RhdGljIGludCBwbDExMV9tb2Rl c2V0X2luaXQoc3RydWN0IGRybV9kZXZpY2UgKmRldikKPiArewo+ICsJc3RydWN0IGRybV9tb2Rl X2NvbmZpZyAqbW9kZV9jb25maWc7Cj4gKwlzdHJ1Y3QgcGwxMTFfZHJtX2Rldl9wcml2YXRlICpw cml2ID0gZGV2LT5kZXZfcHJpdmF0ZTsKPiArCWludCByZXQgPSAwOwo+ICsKPiArCWlmICghcHJp dikKPiArCQlyZXR1cm4gLUVJTlZBTDsKPiArCj4gKwlkcm1fbW9kZV9jb25maWdfaW5pdChkZXYp Owo+ICsJbW9kZV9jb25maWcgPSAmZGV2LT5tb2RlX2NvbmZpZzsKPiArCW1vZGVfY29uZmlnLT5m dW5jcyA9ICZtb2RlX2NvbmZpZ19mdW5jczsKPiArCW1vZGVfY29uZmlnLT5taW5fd2lkdGggPSAx Owo+ICsJbW9kZV9jb25maWctPm1heF93aWR0aCA9IDEwMjQ7Cj4gKwltb2RlX2NvbmZpZy0+bWlu X2hlaWdodCA9IDE7Cj4gKwltb2RlX2NvbmZpZy0+bWF4X2hlaWdodCA9IDc2ODsKPiArCj4gKwly ZXQgPSBwbDExMV9wcmltYXJ5X3BsYW5lX2luaXQoZGV2KTsKPiArCWlmIChyZXQgIT0gMCkgewo+ ICsJCWRldl9lcnIoZGV2LT5kZXYsICJGYWlsZWQgdG8gaW5pdCBwcmltYXJ5IHBsYW5lXG4iKTsK PiArCQlnb3RvIG91dF9jb25maWc7Cj4gKwl9CgpJIGFzc3VtZSB0aGlzIGRpc3BsYXkgSVAgaGFz IGEgcGlsZSBvZiBwbGFuZXM/IE90aGVyd2lzZSB0aGUgc2ltcGxlIHBpcGUKaGVscGVycyBsb29r IGxpa2UgYSBwZXJmZWN0IGZpdC4KCj4gKwo+ICsJcmV0ID0gcGwxMTFfY3J0Y19jcmVhdGUoZGV2 KTsKPiArCWlmIChyZXQpIHsKPiArCQlkZXZfZXJyKGRldi0+ZGV2LCAiRmFpbGVkIHRvIGNyZWF0 ZSBjcnRjXG4iKTsKPiArCQlnb3RvIG91dF9jb25maWc7Cj4gKwl9Cj4gKwo+ICsJcmV0ID0gcGwx MTFfY29ubmVjdG9yX2NyZWF0ZShkZXYpOwo+ICsJaWYgKHJldCkgewo+ICsJCWRldl9lcnIoZGV2 LT5kZXYsICJGYWlsZWQgdG8gY3JlYXRlIHBsMTExX2RybV9jb25uZWN0b3JcbiIpOwo+ICsJCWdv dG8gb3V0X2NvbmZpZzsKPiArCX0KPiArCj4gKwlyZXQgPSBwbDExMV9lbmNvZGVyX2luaXQoZGV2 KTsKPiArCWlmIChyZXQpIHsKPiArCQlkZXZfZXJyKGRldi0+ZGV2LCAiRmFpbGVkIHRvIGNyZWF0 ZSBwbDExMV9kcm1fZW5jb2RlclxuIik7Cj4gKwkJZ290byBvdXRfY29uZmlnOwo+ICsJfQo+ICsK PiArCXJldCA9IGRybV9tb2RlX2Nvbm5lY3Rvcl9hdHRhY2hfZW5jb2RlcigmcHJpdi0+Y29ubmVj dG9yLmNvbm5lY3RvciwKPiArCQkJCQkJJnByaXYtPmVuY29kZXIpOwo+ICsJaWYgKHJldCAhPSAw KSB7Cj4gKwkJZGV2X2VycihkZXYtPmRldiwgIkZhaWxlZCB0byBhdHRhY2ggZW5jb2RlclxuIik7 Cj4gKwkJZ290byBvdXRfY29uZmlnOwo+ICsJfQo+ICsKPiArCXByaXYtPmNvbm5lY3Rvci5jb25u ZWN0b3IuZW5jb2RlciA9ICZwcml2LT5lbmNvZGVyOwo+ICsKPiArCXJldCA9IGRybV92Ymxhbmtf aW5pdChkZXYsIDEpOwo+ICsJaWYgKHJldCAhPSAwKSB7Cj4gKwkJZGV2X2VycihkZXYtPmRldiwg IkZhaWxlZCB0byBpbml0IHZibGFua1xuIik7Cj4gKwkJZ290byBvdXRfY29uZmlnOwo+ICsJfQo+ ICsKPiArCWRybV9tb2RlX2NvbmZpZ19yZXNldChkZXYpOwo+ICsKPiArCXByaXYtPmZiZGV2ID0g ZHJtX2ZiZGV2X2NtYV9pbml0KGRldiwgMzIsCj4gKwkJCQkJIGRldi0+bW9kZV9jb25maWcubnVt X2Nvbm5lY3Rvcik7Cj4gKwo+ICsJZHJtX2ttc19oZWxwZXJfcG9sbF9pbml0KGRldik7Cj4gKwo+ ICsJZ290byBmaW5pc2g7Cj4gKwo+ICtvdXRfY29uZmlnOgo+ICsJZHJtX21vZGVfY29uZmlnX2Ns ZWFudXAoZGV2KTsKPiArZmluaXNoOgo+ICsJcmV0dXJuIHJldDsKPiArfQo+ICsKPiArc3RhdGlj IGNvbnN0IHN0cnVjdCBmaWxlX29wZXJhdGlvbnMgZHJtX2ZvcHMgPSB7Cj4gKwkub3duZXIgPSBU SElTX01PRFVMRSwKPiArCS5vcGVuID0gZHJtX29wZW4sCj4gKwkucmVsZWFzZSA9IGRybV9yZWxl YXNlLAo+ICsJLnVubG9ja2VkX2lvY3RsID0gZHJtX2lvY3RsLAo+ICsJLm1tYXAgPSBkcm1fZ2Vt X2NtYV9tbWFwLAo+ICsJLnBvbGwgPSBkcm1fcG9sbCwKPiArCS5yZWFkID0gZHJtX3JlYWQsCj4g K307CgpWZXJ5IHJlY2VudCwgYnV0IERFRklORV9EUk1fR0VNX0NNQV9GT1BTLgoKPiArCj4gK3N0 YXRpYyB2b2lkIHBsMTExX2xhc3RjbG9zZShzdHJ1Y3QgZHJtX2RldmljZSAqZGV2KQo+ICt7Cj4g KwlzdHJ1Y3QgcGwxMTFfZHJtX2Rldl9wcml2YXRlICpwcml2ID0gZGV2LT5kZXZfcHJpdmF0ZTsK PiArCj4gKwlkcm1fZmJkZXZfY21hX3Jlc3RvcmVfbW9kZShwcml2LT5mYmRldik7Cj4gK30KPiAr Cj4gK3N0YXRpYyBzdHJ1Y3QgZHJtX2RyaXZlciBwbDExMV9kcm1fZHJpdmVyID0gewo+ICsJLmRy aXZlcl9mZWF0dXJlcyA9Cj4gKwkJRFJJVkVSX01PREVTRVQgfCBEUklWRVJfR0VNIHwgRFJJVkVS X1BSSU1FIHwgRFJJVkVSX0FUT01JQywKPiArCS5sYXN0Y2xvc2UgPSBwbDExMV9sYXN0Y2xvc2Us Cj4gKwkuaW9jdGxzID0gTlVMTCwKPiArCS5mb3BzID0gJmRybV9mb3BzLAo+ICsJLm5hbWUgPSAi cGwxMTFfZHJtIiwKPiArCS5kZXNjID0gRFJJVkVSX0RFU0MsCj4gKwkuZGF0ZSA9ICIyMDE3MDMx NyIsCj4gKwkubWFqb3IgPSAxLAo+ICsJLm1pbm9yID0gMCwKPiArCS5wYXRjaGxldmVsID0gMCwK PiArCS5kdW1iX2NyZWF0ZSA9IHBsMTExX2R1bWJfY3JlYXRlLAo+ICsJLmR1bWJfZGVzdHJveSA9 IGRybV9nZW1fZHVtYl9kZXN0cm95LAo+ICsJLmR1bWJfbWFwX29mZnNldCA9IGRybV9nZW1fY21h X2R1bWJfbWFwX29mZnNldCwKPiArCS5nZW1fZnJlZV9vYmplY3QgPSBkcm1fZ2VtX2NtYV9mcmVl X29iamVjdCwKPiArCS5nZW1fdm1fb3BzID0gJmRybV9nZW1fY21hX3ZtX29wcywKPiArCj4gKwku cHJpbWVfaGFuZGxlX3RvX2ZkID0gZHJtX2dlbV9wcmltZV9oYW5kbGVfdG9fZmQsCj4gKwkucHJp bWVfZmRfdG9faGFuZGxlID0gZHJtX2dlbV9wcmltZV9mZF90b19oYW5kbGUsCj4gKwkuZ2VtX3By aW1lX2ltcG9ydCA9IGRybV9nZW1fcHJpbWVfaW1wb3J0LAo+ICsJLmdlbV9wcmltZV9pbXBvcnRf c2dfdGFibGUgPSBkcm1fZ2VtX2NtYV9wcmltZV9pbXBvcnRfc2dfdGFibGUsCj4gKwkuZ2VtX3By aW1lX2V4cG9ydCA9IGRybV9nZW1fcHJpbWVfZXhwb3J0LAo+ICsJLmdlbV9wcmltZV9nZXRfc2df dGFibGUJPSBkcm1fZ2VtX2NtYV9wcmltZV9nZXRfc2dfdGFibGUsCj4gK307Cj4gKwo+ICsjaWZk ZWYgQ09ORklHX0FSTV9BTUJBCj4gK3N0YXRpYyBpbnQgcGwxMTFfYW1iYV9wcm9iZShzdHJ1Y3Qg YW1iYV9kZXZpY2UgKmFtYmFfZGV2LAo+ICsJCQkgICAgY29uc3Qgc3RydWN0IGFtYmFfaWQgKmlk KQo+ICt7Cj4gKwlzdHJ1Y3QgZGV2aWNlICpkZXYgPSAmYW1iYV9kZXYtPmRldjsKPiArCXN0cnVj dCBwbDExMV9kcm1fZGV2X3ByaXZhdGUgKnByaXY7Cj4gKwlzdHJ1Y3QgZHJtX2RldmljZSAqZHJt Owo+ICsJaW50IHJldDsKPiArCj4gKwlwcml2ID0gZGV2bV9remFsbG9jKGRldiwgc2l6ZW9mKCpw cml2KSwgR0ZQX0tFUk5FTCk7Cj4gKwlpZiAoIXByaXYpCj4gKwkJcmV0dXJuIC1FTk9NRU07Cj4g Kwo+ICsJZHJtID0gZHJtX2Rldl9hbGxvYygmcGwxMTFfZHJtX2RyaXZlciwgZGV2KTsKPiArCWlm IChJU19FUlIoZHJtKSkKPiArCQlyZXR1cm4gUFRSX0VSUihkcm0pOwo+ICsJYW1iYV9zZXRfZHJ2 ZGF0YShhbWJhX2RldiwgZHJtKTsKPiArCXByaXYtPmRybSA9IGRybTsKPiArCWRybS0+ZGV2X3By aXZhdGUgPSBwcml2Owo+ICsKPiArCXByaXYtPmNsayA9IGRldm1fY2xrX2dldChkZXYsICJjbGNk Y2xrIik7Cj4gKwlpZiAoSVNfRVJSKHByaXYtPmNsaykpIHsKPiArCQlkZXZfZXJyKGRldiwgIkNM Q0Q6IHVuYWJsZSB0byBnZXQgY2xrLlxuIik7Cj4gKwkJcmV0ID0gUFRSX0VSUihwcml2LT5jbGsp Owo+ICsJCWdvdG8gZGV2X3VucmVmOwo+ICsJfQo+ICsKPiArCXByaXYtPnJlZ3MgPSBkZXZtX2lv cmVtYXBfcmVzb3VyY2UoZGV2LCAmYW1iYV9kZXYtPnJlcyk7Cj4gKwlpZiAoIXByaXYtPnJlZ3Mp IHsKPiArCQlkZXZfZXJyKGRldiwgIiVzIGZhaWxlZCBtbWlvXG4iLCBfX2Z1bmNfXyk7Cj4gKwkJ cmV0dXJuIC1FSU5WQUw7Cj4gKwl9Cj4gKwo+ICsJLyogdHVybiBvZmYgaW50ZXJydXB0cyBiZWZv cmUgcmVxdWVzdGluZyB0aGUgaXJxICovCj4gKwl3cml0ZWwoMCwgcHJpdi0+cmVncyArIENMQ0Rf UEwxMTFfSUVOQik7Cj4gKwo+ICsJcmV0ID0gZGV2bV9yZXF1ZXN0X2lycShkZXYsIGFtYmFfZGV2 LT5pcnFbMF0sIHBsMTExX2lycSwgMCwKPiArCQkJICAgICAgICJwbDExMSIsIHByaXYpOwo+ICsJ aWYgKHJldCAhPSAwKSB7Cj4gKwkJZGV2X2VycihkZXYsICIlcyBmYWlsZWQgaXJxICVkXG4iLCBf X2Z1bmNfXywgcmV0KTsKPiArCQlyZXR1cm4gcmV0Owo+ICsJfQo+ICsKPiArCXJldCA9IHBsMTEx X21vZGVzZXRfaW5pdChkcm0pOwo+ICsJaWYgKHJldCAhPSAwKSB7Cj4gKwkJZGV2X2VycihkZXYs ICJGYWlsZWQgdG8gaW5pdCBtb2Rlc2V0XG4iKTsKPiArCQlnb3RvIGRldl91bnJlZjsKPiArCX0K PiArCj4gKwlyZXQgPSBkcm1fZGV2X3JlZ2lzdGVyKGRybSwgMCk7Cj4gKwlpZiAocmV0IDwgMCkK PiArCQlnb3RvIGRldl91bnJlZjsKPiArCj4gKwlyZXR1cm4gMDsKPiArCj4gK2Rldl91bnJlZjoK PiArCWRybV9kZXZfdW5yZWYoZHJtKTsKPiArCXJldHVybiByZXQ7Cj4gK30KPiArCj4gK3N0YXRp YyBpbnQgcGwxMTFfYW1iYV9yZW1vdmUoc3RydWN0IGFtYmFfZGV2aWNlICphbWJhX2RldikKPiAr ewo+ICsJc3RydWN0IGRybV9kZXZpY2UgKmRybSA9IGFtYmFfZ2V0X2RydmRhdGEoYW1iYV9kZXYp Owo+ICsJc3RydWN0IHBsMTExX2RybV9kZXZfcHJpdmF0ZSAqcHJpdiA9IGRybS0+ZGV2X3ByaXZh dGU7Cj4gKwo+ICsJZHJtX2Rldl91bnJlZ2lzdGVyKGRybSk7Cj4gKwlpZiAocHJpdi0+ZmJkZXYp Cj4gKwkJZHJtX2ZiZGV2X2NtYV9maW5pKHByaXYtPmZiZGV2KTsKPiArCWRybV9tb2RlX2NvbmZp Z19jbGVhbnVwKGRybSk7Cj4gKwlkcm1fZGV2X3VucmVmKGRybSk7Cj4gKwo+ICsJcmV0dXJuIDA7 Cj4gK30KPiArCj4gK3N0YXRpYyBzdHJ1Y3QgYW1iYV9pZCBwbDExMV9pZF90YWJsZVtdID0gewo+ ICsJewo+ICsJCS5pZCA9IDB4MDAwNDExMTAsCj4gKwkJLm1hc2sgPSAweDAwMGZmZmZlLAo+ICsJ fSwKPiArCXswLCAwfSwKPiArfTsKPiArCj4gK3N0YXRpYyBzdHJ1Y3QgYW1iYV9kcml2ZXIgcGwx MTFfYW1iYV9kcml2ZXIgPSB7Cj4gKwkuZHJ2ID0gewo+ICsJCS5uYW1lID0gImNsY2QtcGwxMXgi LAo+ICsJfSwKPiArCS5wcm9iZSA9IHBsMTExX2FtYmFfcHJvYmUsCj4gKwkucmVtb3ZlID0gcGwx MTFfYW1iYV9yZW1vdmUsCj4gKwkuaWRfdGFibGUgPSBwbDExMV9pZF90YWJsZSwKPiArfTsKPiAr I2VuZGlmIC8qIENPTkZJR19BUk1fQU1CQSAqLwo+ICsKPiArbW9kdWxlX2FtYmFfZHJpdmVyKHBs MTExX2FtYmFfZHJpdmVyKTsKPiArCj4gK01PRFVMRV9ERVNDUklQVElPTihEUklWRVJfREVTQyk7 Cj4gK01PRFVMRV9BVVRIT1IoIkFSTSBMdGQuIik7Cj4gK01PRFVMRV9MSUNFTlNFKCJHUEwiKTsK PiArTU9EVUxFX0FMSUFTKCJwbGF0Zm9ybTpwbDExMV9kcm0iKTsKPiBkaWZmIC0tZ2l0IGEvZHJp dmVycy9ncHUvZHJtL3BsMTExL3BsMTExX2VuY29kZXIuYyBiL2RyaXZlcnMvZ3B1L2RybS9wbDEx MS9wbDExMV9lbmNvZGVyLmMKPiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+IGluZGV4IDAwMDAwMDAw MDAwMC4uNzhkNjdjZWI0NmYzCj4gLS0tIC9kZXYvbnVsbAo+ICsrKyBiL2RyaXZlcnMvZ3B1L2Ry bS9wbDExMS9wbDExMV9lbmNvZGVyLmMKPiBAQCAtMCwwICsxLDUwIEBACj4gKy8qCj4gKyAqIChD KSBDT1BZUklHSFQgMjAxMi0yMDEzIEFSTSBMaW1pdGVkLiBBbGwgcmlnaHRzIHJlc2VydmVkLgo+ ICsgKgo+ICsgKiBQYXJ0cyBvZiB0aGlzIGZpbGUgd2VyZSBiYXNlZCBvbiBzb3VyY2VzIGFzIGZv bGxvd3M6Cj4gKyAqCj4gKyAqIENvcHlyaWdodCAoYykgMjAwNi0yMDA4IEludGVsIENvcnBvcmF0 aW9uCj4gKyAqIENvcHlyaWdodCAoYykgMjAwNyBEYXZlIEFpcmxpZSA8YWlybGllZEBsaW51eC5p ZT4KPiArICogQ29weXJpZ2h0IChDKSAyMDExIFRleGFzIEluc3RydW1lbnRzCj4gKyAqCj4gKyAq IFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlIGFuZCBpcyBwcm92aWRlZCB0byB5b3UgdW5k ZXIgdGhlIHRlcm1zIG9mIHRoZQo+ICsgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJz aW9uIDIgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlCj4gKyAqIEZvdW5kYXRpb24s IGFuZCBhbnkgdXNlIGJ5IHlvdSBvZiB0aGlzIHByb2dyYW0gaXMgc3ViamVjdCB0byB0aGUgdGVy bXMgb2YKPiArICogc3VjaCBHTlUgbGljZW5jZS4KPiArICoKPiArICovCj4gKwo+ICsvKioKPiAr ICogcGwxMTFfZHJtX2VuY29kZXIuYwo+ICsgKiBJbXBsZW1lbnRhdGlvbiBvZiB0aGUgZW5jb2Rl ciBmdW5jdGlvbnMgZm9yIFBMMTExIERSTQo+ICsgKi8KPiArI2luY2x1ZGUgPGxpbnV4L2FtYmEv Y2xjZC1yZWdzLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC92ZXJzaW9uLmg+Cj4gKyNpbmNsdWRlIDxs aW51eC9zaG1lbV9mcy5oPgo+ICsjaW5jbHVkZSA8bGludXgvZG1hLWJ1Zi5oPgo+ICsKPiArI2lu Y2x1ZGUgPGRybS9kcm1QLmg+Cj4gKyNpbmNsdWRlIDxkcm0vZHJtX2NydGNfaGVscGVyLmg+Cj4g Kwo+ICsjaW5jbHVkZSAicGwxMTFfZHJtLmgiCj4gKwo+ICtzdGF0aWMgY29uc3Qgc3RydWN0IGRy bV9lbmNvZGVyX2Z1bmNzIHBsMTExX2VuY29kZXJfZnVuY3MgPSB7Cj4gKwkuZGVzdHJveSA9IGRy bV9lbmNvZGVyX2NsZWFudXAsCj4gK307Cj4gKwo+ICtpbnQgcGwxMTFfZW5jb2Rlcl9pbml0KHN0 cnVjdCBkcm1fZGV2aWNlICpkZXYpCj4gK3sKPiArCXN0cnVjdCBwbDExMV9kcm1fZGV2X3ByaXZh dGUgKnByaXYgPSBkZXYtPmRldl9wcml2YXRlOwo+ICsJc3RydWN0IGRybV9lbmNvZGVyICplbmNv ZGVyID0gJnByaXYtPmVuY29kZXI7Cj4gKwlpbnQgcmV0Owo+ICsKPiArCXJldCA9IGRybV9lbmNv ZGVyX2luaXQoZGV2LCBlbmNvZGVyLCAmcGwxMTFfZW5jb2Rlcl9mdW5jcywKPiArCQkJICAgICAg IERSTV9NT0RFX0VOQ09ERVJfRFBJLCBOVUxMKTsKPiArCWlmIChyZXQpCj4gKwkJcmV0dXJuIHJl dDsKPiArCj4gKwllbmNvZGVyLT5jcnRjID0gJnByaXYtPmNydGM7Cj4gKwllbmNvZGVyLT5wb3Nz aWJsZV9jcnRjcyA9IGRybV9jcnRjX21hc2soZW5jb2Rlci0+Y3J0Yyk7Cj4gKwo+ICsJcmV0dXJu IDA7Cj4gK30KPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3BsMTExL3BsMTExX2dlbS5j IGIvZHJpdmVycy9ncHUvZHJtL3BsMTExL3BsMTExX2dlbS5jCj4gbmV3IGZpbGUgbW9kZSAxMDA2 NDQKPiBpbmRleCAwMDAwMDAwMDAwMDAuLmI3YjBlNDUzZGVhOQo+IC0tLSAvZGV2L251bGwKPiAr KysgYi9kcml2ZXJzL2dwdS9kcm0vcGwxMTEvcGwxMTFfZ2VtLmMKPiBAQCAtMCwwICsxLDM1IEBA Cj4gKy8qCj4gKyAqIChDKSBDT1BZUklHSFQgMjAxMi0yMDEzIEFSTSBMaW1pdGVkLiBBbGwgcmln aHRzIHJlc2VydmVkLgo+ICsgKgo+ICsgKiBQYXJ0cyBvZiB0aGlzIGZpbGUgd2VyZSBiYXNlZCBv biBzb3VyY2VzIGFzIGZvbGxvd3M6Cj4gKyAqCj4gKyAqIENvcHlyaWdodCAoYykgMjAwNi0yMDA4 IEludGVsIENvcnBvcmF0aW9uCj4gKyAqIENvcHlyaWdodCAoYykgMjAwNyBEYXZlIEFpcmxpZSA8 YWlybGllZEBsaW51eC5pZT4KPiArICogQ29weXJpZ2h0IChDKSAyMDExIFRleGFzIEluc3RydW1l bnRzCj4gKyAqCj4gKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlIGFuZCBpcyBwcm92 aWRlZCB0byB5b3UgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZQo+ICsgKiBHTlUgR2VuZXJhbCBQdWJs aWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlCj4g KyAqIEZvdW5kYXRpb24sIGFuZCBhbnkgdXNlIGJ5IHlvdSBvZiB0aGlzIHByb2dyYW0gaXMgc3Vi amVjdCB0byB0aGUgdGVybXMgb2YKPiArICogc3VjaCBHTlUgbGljZW5jZS4KPiArICoKPiArICov Cj4gKwo+ICsvKioKPiArICogcGwxMTFfZHJtX2dlbS5jCj4gKyAqIEltcGxlbWVudGF0aW9uIG9m IHRoZSBHRU0gZnVuY3Rpb25zIGZvciBQTDExMSBEUk0KPiArICovCj4gKyNpbmNsdWRlIDxsaW51 eC92ZXJzaW9uLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9zaG1lbV9mcy5oPgo+ICsjaW5jbHVkZSA8 bGludXgvZG1hLWJ1Zi5oPgo+ICsjaW5jbHVkZSA8ZHJtL2RybVAuaD4KPiArI2luY2x1ZGUgPGRy bS9kcm1fY3J0Y19oZWxwZXIuaD4KPiArI2luY2x1ZGUgPGRybS9kcm1fZ2VtX2NtYV9oZWxwZXIu aD4KPiArI2luY2x1ZGUgInBsMTExX2RybS5oIgo+ICsKPiAraW50IHBsMTExX2R1bWJfY3JlYXRl KHN0cnVjdCBkcm1fZmlsZSAqZmlsZV9wcml2LAo+ICsJCSAgICAgIHN0cnVjdCBkcm1fZGV2aWNl ICpkZXYsIHN0cnVjdCBkcm1fbW9kZV9jcmVhdGVfZHVtYiAqYXJncykKPiArewo+ICsJYXJncy0+ cGl0Y2ggPSBESVZfUk9VTkRfVVAoYXJncy0+d2lkdGggKiBhcmdzLT5icHAsIDgpOwo+ICsKPiAr CXJldHVybiBkcm1fZ2VtX2NtYV9kdW1iX2NyZWF0ZV9pbnRlcm5hbChmaWxlX3ByaXYsIGRldiwg YXJncyk7Cj4gK30KPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3BsMTExL3BsMTExX3Bs YW5lLmMgYi9kcml2ZXJzL2dwdS9kcm0vcGwxMTEvcGwxMTFfcGxhbmUuYwo+IG5ldyBmaWxlIG1v ZGUgMTAwNjQ0Cj4gaW5kZXggMDAwMDAwMDAwMDAwLi5iY2RjMmY0M2RlNDYKPiAtLS0gL2Rldi9u dWxsCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL3BsMTExL3BsMTExX3BsYW5lLmMKPiBAQCAtMCww ICsxLDE2NyBAQAo+ICsvKgo+ICsgKiAoQykgQ09QWVJJR0hUIDIwMTItMjAxMyBBUk0gTGltaXRl ZC4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KPiArICoKPiArICogUGFydHMgb2YgdGhpcyBmaWxlIHdl cmUgYmFzZWQgb24gc291cmNlcyBhcyBmb2xsb3dzOgo+ICsgKgo+ICsgKiBDb3B5cmlnaHQgKGMp IDIwMDYtMjAwOCBJbnRlbCBDb3Jwb3JhdGlvbgo+ICsgKiBDb3B5cmlnaHQgKGMpIDIwMDcgRGF2 ZSBBaXJsaWUgPGFpcmxpZWRAbGludXguaWU+Cj4gKyAqIENvcHlyaWdodCAoQykgMjAxMSBUZXhh cyBJbnN0cnVtZW50cwo+ICsgKgo+ICsgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZSBh bmQgaXMgcHJvdmlkZWQgdG8geW91IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUKPiArICogR05VIEdl bmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBT b2Z0d2FyZQo+ICsgKiBGb3VuZGF0aW9uLCBhbmQgYW55IHVzZSBieSB5b3Ugb2YgdGhpcyBwcm9n cmFtIGlzIHN1YmplY3QgdG8gdGhlIHRlcm1zIG9mCj4gKyAqIHN1Y2ggR05VIGxpY2VuY2UuCj4g KyAqCj4gKyAqLwo+ICsKPiArI2luY2x1ZGUgPGxpbnV4L2FtYmEvY2xjZC1yZWdzLmg+Cj4gKyNp bmNsdWRlIDxsaW51eC9vZl9ncmFwaC5oPgo+ICsjaW5jbHVkZSA8ZHJtL2RybVAuaD4KPiArI2lu Y2x1ZGUgPGRybS9kcm1fYXRvbWljX2hlbHBlci5oPgo+ICsjaW5jbHVkZSA8ZHJtL2RybV9mYl9j bWFfaGVscGVyLmg+Cj4gKyNpbmNsdWRlIDxkcm0vZHJtX2dlbV9jbWFfaGVscGVyLmg+Cj4gKyNp bmNsdWRlIDxkcm0vZHJtX3BsYW5lX2hlbHBlci5oPgo+ICsKPiArI2luY2x1ZGUgInBsMTExX2Ry bS5oIgo+ICsKPiArc3RhdGljIGludCBwbDExMV9wcmltYXJ5X3BsYW5lX2F0b21pY19jaGVjayhz dHJ1Y3QgZHJtX3BsYW5lICpwbGFuZSwKPiArCQkJCQkgICAgc3RydWN0IGRybV9wbGFuZV9zdGF0 ZSAqc3RhdGUpCj4gK3sKPiArCXJldHVybiAwOwo+ICt9Cj4gKwo+ICtzdGF0aWMgdm9pZCBwbDEx MV9wcmltYXJ5X3BsYW5lX2F0b21pY191cGRhdGUoc3RydWN0IGRybV9wbGFuZSAqcGxhbmUsCj4g KwkJCQkJICAgICAgc3RydWN0IGRybV9wbGFuZV9zdGF0ZSAqb2xkX3N0YXRlKQo+ICt7Cj4gKwlz dHJ1Y3QgZHJtX2RldmljZSAqZGV2ID0gcGxhbmUtPmRldjsKPiArCXN0cnVjdCBwbDExMV9kcm1f ZGV2X3ByaXZhdGUgKnByaXYgPSBkZXYtPmRldl9wcml2YXRlOwo+ICsJc3RydWN0IGRybV9mcmFt ZWJ1ZmZlciAqZmIgPSBwbGFuZS0+c3RhdGUtPmZiOwo+ICsJc3RydWN0IGRybV9nZW1fY21hX29i amVjdCAqb2JqOwo+ICsJdTMyIGFkZHIsIGNudGw7Cj4gKwo+ICsJaWYgKCFmYikKPiArCQlyZXR1 cm47Cj4gKwo+ICsJb2JqID0gZHJtX2ZiX2NtYV9nZXRfZ2VtX29iaihmYiwgMCk7Cj4gKwlhZGRy ID0gb2JqLT5wYWRkciArIGZiLT5vZmZzZXRzWzBdOwo+ICsJYWRkciArPSBmYi0+Zm9ybWF0LT5j cHBbMF0gKiBwbGFuZS0+c3RhdGUtPnNyY194Owo+ICsJYWRkciArPSBmYi0+cGl0Y2hlc1swXSAq IHBsYW5lLT5zdGF0ZS0+c3JjX3k7Cj4gKwo+ICsJd3JpdGVsKGFkZHIsIHByaXYtPnJlZ3MgKyBD TENEX1VCQVMpOwo+ICsJd3JpdGVsKGFkZHIgKyAoZmItPmhlaWdodCAtIDEgKiBmYi0+cGl0Y2hl c1swXSksCj4gKwkgICAgICAgcHJpdi0+cmVncyArIENMQ0RfTEJBUyk7Cj4gKwo+ICsJY250bCA9 IHJlYWRsKHByaXYtPnJlZ3MgKyBDTENEX1BMMTExX0NOVEwpOwo+ICsJY250bCAmPSB+KDcgPDwg MSk7Cj4gKwo+ICsJLyogTm90ZSB0aGF0IHRoZSB0aGUgaGFyZHdhcmUncyBmb3JtYXQgcmVhZGVy IHRha2VzICdyJyBmcm9tCj4gKwkgKiB0aGUgbG93IGJpdCwgd2hpbGUgRFJNIGZvcm1hdHMgbGlz dCBjaGFubmVscyBmcm9tIGhpZ2ggYml0Cj4gKwkgKiB0byBsb3cgYml0IGFzIHlvdSByZWFkIGxl ZnQgdG8gcmlnaHQuCj4gKwkgKi8KPiArCXN3aXRjaCAoZmItPmZvcm1hdC0+Zm9ybWF0KSB7Cj4g KwljYXNlIERSTV9GT1JNQVRfQUJHUjg4ODg6Cj4gKwljYXNlIERSTV9GT1JNQVRfWEJHUjg4ODg6 Cj4gKwkJY250bCB8PSBDTlRMX0xDREJQUDI0Owo+ICsJCWJyZWFrOwo+ICsJY2FzZSBEUk1fRk9S TUFUX0FSR0I4ODg4Ogo+ICsJY2FzZSBEUk1fRk9STUFUX1hSR0I4ODg4Ogo+ICsJCWNudGwgfD0g Q05UTF9MQ0RCUFAyNCB8IENOVExfQkdSOwo+ICsJCWJyZWFrOwo+ICsJY2FzZSBEUk1fRk9STUFU X0JHUjU2NToKPiArCQljbnRsIHw9IENOVExfTENEQlBQMTZfNTY1Owo+ICsJCWJyZWFrOwo+ICsJ Y2FzZSBEUk1fRk9STUFUX1JHQjU2NToKPiArCQljbnRsIHw9IENOVExfTENEQlBQMTZfNTY1IHwg Q05UTF9CR1I7Cj4gKwkJYnJlYWs7Cj4gKwljYXNlIERSTV9GT1JNQVRfQUJHUjE1NTU6Cj4gKwlj YXNlIERSTV9GT1JNQVRfWEJHUjE1NTU6Cj4gKwkJY250bCB8PSBDTlRMX0xDREJQUDE2Owo+ICsJ CWJyZWFrOwo+ICsJY2FzZSBEUk1fRk9STUFUX0FSR0IxNTU1Ogo+ICsJY2FzZSBEUk1fRk9STUFU X1hSR0IxNTU1Ogo+ICsJCWNudGwgfD0gQ05UTF9MQ0RCUFAxNiB8IENOVExfQkdSOwo+ICsJCWJy ZWFrOwo+ICsJY2FzZSBEUk1fRk9STUFUX0FCR1I0NDQ0Ogo+ICsJY2FzZSBEUk1fRk9STUFUX1hC R1I0NDQ0Ogo+ICsJCWNudGwgfD0gQ05UTF9MQ0RCUFAxNl80NDQ7Cj4gKwkJYnJlYWs7Cj4gKwlj YXNlIERSTV9GT1JNQVRfQVJHQjQ0NDQ6Cj4gKwljYXNlIERSTV9GT1JNQVRfWFJHQjQ0NDQ6Cj4g KwkJY250bCB8PSBDTlRMX0xDREJQUDE2XzQ0NCB8IENOVExfQkdSOwo+ICsJCWJyZWFrOwo+ICsJ fQo+ICsKPiArCXdyaXRlbChjbnRsLCBwcml2LT5yZWdzICsgQ0xDRF9QTDExMV9DTlRMKTsKPiAr fQo+ICsKPiArc3RhdGljIGNvbnN0IHN0cnVjdCBkcm1fcGxhbmVfaGVscGVyX2Z1bmNzIHBsMTEx X3ByaW1hcnlfcGxhbmVfaGVscGVyX2Z1bmNzID0gewo+ICsJLmF0b21pY19jaGVjayA9IHBsMTEx X3ByaW1hcnlfcGxhbmVfYXRvbWljX2NoZWNrLAo+ICsJLmF0b21pY191cGRhdGUgPSBwbDExMV9w cmltYXJ5X3BsYW5lX2F0b21pY191cGRhdGUsCj4gK307Cj4gKwo+ICtzdGF0aWMgY29uc3Qgc3Ry dWN0IGRybV9wbGFuZV9mdW5jcyBwbDExMV9wcmltYXJ5X3BsYW5lX2Z1bmNzID0gewo+ICsJLnVw ZGF0ZV9wbGFuZSA9IGRybV9hdG9taWNfaGVscGVyX3VwZGF0ZV9wbGFuZSwKPiArCS5kaXNhYmxl X3BsYW5lID0gZHJtX2F0b21pY19oZWxwZXJfZGlzYWJsZV9wbGFuZSwKPiArCS5yZXNldCA9IGRy bV9hdG9taWNfaGVscGVyX3BsYW5lX3Jlc2V0LAo+ICsJLmRlc3Ryb3kgPSBkcm1fcGxhbmVfY2xl YW51cCwKPiArCS5hdG9taWNfZHVwbGljYXRlX3N0YXRlID0gZHJtX2F0b21pY19oZWxwZXJfcGxh bmVfZHVwbGljYXRlX3N0YXRlLAo+ICsJLmF0b21pY19kZXN0cm95X3N0YXRlID0gZHJtX2F0b21p Y19oZWxwZXJfcGxhbmVfZGVzdHJveV9zdGF0ZSwKPiArfTsKPiArCj4gK2ludCBwbDExMV9wcmlt YXJ5X3BsYW5lX2luaXQoc3RydWN0IGRybV9kZXZpY2UgKmRybSkKPiArewo+ICsJc3RydWN0IHBs MTExX2RybV9kZXZfcHJpdmF0ZSAqcHJpdiA9IGRybS0+ZGV2X3ByaXZhdGU7Cj4gKwlzdHJ1Y3Qg ZHJtX3BsYW5lICpwbGFuZSA9ICZwcml2LT5wcmltYXJ5Owo+ICsJc3RydWN0IGRldmljZSAqZGV2 ID0gZHJtLT5kZXY7Cj4gKwlzdGF0aWMgY29uc3QgdTMyIGZvcm1hdHNbXSA9IHsKPiArCQlEUk1f Rk9STUFUX0FCR1I4ODg4LAo+ICsJCURSTV9GT1JNQVRfWEJHUjg4ODgsCj4gKwkJRFJNX0ZPUk1B VF9BUkdCODg4OCwKPiArCQlEUk1fRk9STUFUX1hSR0I4ODg4LAo+ICsJCURSTV9GT1JNQVRfQkdS NTY1LAo+ICsJCURSTV9GT1JNQVRfUkdCNTY1LAo+ICsJCURSTV9GT1JNQVRfQUJHUjE1NTUsCj4g KwkJRFJNX0ZPUk1BVF9YQkdSMTU1NSwKPiArCQlEUk1fRk9STUFUX0FSR0IxNTU1LAo+ICsJCURS TV9GT1JNQVRfWFJHQjE1NTUsCj4gKwkJRFJNX0ZPUk1BVF9BQkdSNDQ0NCwKPiArCQlEUk1fRk9S TUFUX1hCR1I0NDQ0LAo+ICsJCURSTV9GT1JNQVRfQVJHQjQ0NDQsCj4gKwkJRFJNX0ZPUk1BVF9Y UkdCNDQ0NCwKPiArCX07Cj4gKwlzdHJ1Y3QgZGV2aWNlX25vZGUgKmVuZHBvaW50Owo+ICsJdTMy IHRmdF9yMGIwZzBbM107Cj4gKwlpbnQgcmV0Owo+ICsKPiArCWVuZHBvaW50ID0gb2ZfZ3JhcGhf Z2V0X25leHRfZW5kcG9pbnQoZGV2LT5vZl9ub2RlLCBOVUxMKTsKPiArCWlmICghZW5kcG9pbnQp Cj4gKwkJcmV0dXJuIC1FTk9ERVY7Cj4gKwo+ICsJaWYgKG9mX3Byb3BlcnR5X3JlYWRfdTMyX2Fy cmF5KGVuZHBvaW50LAo+ICsJCQkJICAgICAgICJhcm0scGwxMXgsdGZ0LXIwZzBiMC1wYWRzIiwK PiArCQkJCSAgICAgICB0ZnRfcjBiMGcwLAo+ICsJCQkJICAgICAgIEFSUkFZX1NJWkUodGZ0X3Iw YjBnMCkpICE9IDApIHsKPiArCQlkZXZfZXJyKGRldiwgImFybSxwbDExeCx0ZnQtcjBnMGIwLXBh ZHMgc2hvdWxkIGJlIDMgaW50c1xuIik7Cj4gKwkJb2Zfbm9kZV9wdXQoZW5kcG9pbnQpOwo+ICsJ CXJldHVybiAtRU5PRU5UOwo+ICsJfQo+ICsJb2Zfbm9kZV9wdXQoZW5kcG9pbnQpOwo+ICsKPiAr CWlmICh0ZnRfcjBiMGcwWzBdICE9IDAgfHwKPiArCSAgICB0ZnRfcjBiMGcwWzFdICE9IDggfHwK PiArCSAgICB0ZnRfcjBiMGcwWzJdICE9IDE2KSB7Cj4gKwkJZGV2X2VycihkZXYsICJhcm0scGwx MXgsdGZ0LXIwZzBiMC1wYWRzICE9IFswLDgsMTZdIG5vdCB5ZXQgc3VwcG9ydGVkXG4iKTsKPiAr CQlyZXR1cm4gLUVJTlZBTDsKPiArCX0KPiArCj4gKwlyZXQgPSBkcm1fdW5pdmVyc2FsX3BsYW5l X2luaXQoZHJtLCBwbGFuZSwgMCwKPiArCQkJCSAgICAgICAmcGwxMTFfcHJpbWFyeV9wbGFuZV9m dW5jcywKPiArCQkJCSAgICAgICBmb3JtYXRzLCBBUlJBWV9TSVpFKGZvcm1hdHMpLAo+ICsJCQkJ ICAgICAgIERSTV9QTEFORV9UWVBFX1BSSU1BUlksIE5VTEwpOwo+ICsJaWYgKHJldCkKPiArCQly ZXR1cm4gcmV0Owo+ICsKPiArCWRybV9wbGFuZV9oZWxwZXJfYWRkKHBsYW5lLCAmcGwxMTFfcHJp bWFyeV9wbGFuZV9oZWxwZXJfZnVuY3MpOwo+ICsKPiArCXJldHVybiAwOwo+ICt9Cj4gLS0gCj4g Mi4xMS4wCj4gCj4gX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X18KPiBkcmktZGV2ZWwgbWFpbGluZyBsaXN0Cj4gZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9w Lm9yZwo+IGh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJp LWRldmVsCgotLSAKRGFuaWVsIFZldHRlcgpTb2Z0d2FyZSBFbmdpbmVlciwgSW50ZWwgQ29ycG9y YXRpb24KaHR0cDovL2Jsb2cuZmZ3bGwuY2gKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMu ZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlz dGluZm8vZHJpLWRldmVsCg==