From mboxrd@z Thu Jan 1 00:00:00 1970 From: daniel@ffwll.ch (Daniel Vetter) Date: Mon, 14 Aug 2017 16:20:15 +0200 Subject: [PATCH 2/4] drm/tve200: Add new driver for TVE200 In-Reply-To: <20170813151132.24736-3-linus.walleij@linaro.org> References: <20170813151132.24736-1-linus.walleij@linaro.org> <20170813151132.24736-3-linus.walleij@linaro.org> Message-ID: <20170814142015.dy73yguwmuglloiz@phenom.ffwll.local> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org On Sun, Aug 13, 2017 at 05:11:30PM +0200, Linus Walleij wrote: > This adds a new DRM driver for the Faraday Technology TVE200 > block. This "TV Encoder" encodes a ITU-T BT.656 stream and can > be found in the StorLink SL3516 (later Cortina Systems CS3516) > as well as the Grain Media GM8180. > > I do not have definitive word from anyone at Faraday that this > IP block is theirs, but it bears the hallmark of their 3-digit > version code (200) and is used in two SoCs from completely > different companies. (Grain Media was fully owned by Faraday > until it was transferred to NovoTek this january, and > Faraday did lots of work on the StorLink SoCs.) > > The D-Link DIR-685 uses this in connection with the Ilitek > ILI9322 panel driver that supports BT.656 input, while the > GM8180 apparently has been used with the Cirrus Logic CS4954 > digital video encoder. The oldest user seems to be > something called Techwall 2835. > > This driver is heavily inspired by Eric Anholt's PL111 > driver and therefore I have mentioned all the ancestor authors > in the header file. > > Signed-off-by: Linus Walleij > --- > Documentation/gpu/index.rst | 1 + > Documentation/gpu/tve200.rst | 6 + > MAINTAINERS | 6 + > drivers/gpu/drm/Kconfig | 2 + > drivers/gpu/drm/Makefile | 1 + > drivers/gpu/drm/tve200/Kconfig | 15 ++ > drivers/gpu/drm/tve200/Makefile | 5 + > drivers/gpu/drm/tve200/tve200_connector.c | 126 +++++++++++ > drivers/gpu/drm/tve200/tve200_display.c | 346 ++++++++++++++++++++++++++++++ > drivers/gpu/drm/tve200/tve200_drm.h | 129 +++++++++++ > drivers/gpu/drm/tve200/tve200_drv.c | 277 ++++++++++++++++++++++++ > 11 files changed, 914 insertions(+) > create mode 100644 Documentation/gpu/tve200.rst > create mode 100644 drivers/gpu/drm/tve200/Kconfig > create mode 100644 drivers/gpu/drm/tve200/Makefile > create mode 100644 drivers/gpu/drm/tve200/tve200_connector.c > create mode 100644 drivers/gpu/drm/tve200/tve200_display.c > create mode 100644 drivers/gpu/drm/tve200/tve200_drm.h > create mode 100644 drivers/gpu/drm/tve200/tve200_drv.c > > diff --git a/Documentation/gpu/index.rst b/Documentation/gpu/index.rst > index 35d673bf9b56..c36586dad29d 100644 > --- a/Documentation/gpu/index.rst > +++ b/Documentation/gpu/index.rst > @@ -15,6 +15,7 @@ Linux GPU Driver Developer's Guide > pl111 > tegra > tinydrm > + tve200 > vc4 > vga-switcheroo > vgaarbiter > diff --git a/Documentation/gpu/tve200.rst b/Documentation/gpu/tve200.rst > new file mode 100644 > index 000000000000..69b17b324e12 > --- /dev/null > +++ b/Documentation/gpu/tve200.rst > @@ -0,0 +1,6 @@ > +================================== > + drm/tve200 Faraday TV Encoder 200 > +================================== > + > +.. kernel-doc:: drivers/gpu/drm/tve200/tve200_drv.c > + :doc: Faraday TV Encoder 200 > diff --git a/MAINTAINERS b/MAINTAINERS > index e87cba115ea4..c3d42d68253a 100644 > --- a/MAINTAINERS > +++ b/MAINTAINERS > @@ -4305,6 +4305,12 @@ T: git git://anongit.freedesktop.org/drm/drm-misc > S: Maintained > F: drivers/gpu/drm/bochs/ > > +DRM DRIVER FOR FARADAY TVE200 TV ENCODER > +M: Linus Walleij > +T: git git://anongit.freedesktop.org/drm/drm-misc > +S: Maintained > +F: drivers/gpu/drm/tve200/ > + > DRM DRIVER FOR INTEL I810 VIDEO CARDS > S: Orphan / Obsolete > F: drivers/gpu/drm/i810/ > diff --git a/drivers/gpu/drm/Kconfig b/drivers/gpu/drm/Kconfig > index 83cb2a88c204..c5e1a8409285 100644 > --- a/drivers/gpu/drm/Kconfig > +++ b/drivers/gpu/drm/Kconfig > @@ -278,6 +278,8 @@ source "drivers/gpu/drm/tinydrm/Kconfig" > > source "drivers/gpu/drm/pl111/Kconfig" > > +source "drivers/gpu/drm/tve200/Kconfig" > + > # Keep legacy drivers last > > menuconfig DRM_LEGACY > diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile > index 24a066e1841c..cc81813e2238 100644 > --- a/drivers/gpu/drm/Makefile > +++ b/drivers/gpu/drm/Makefile > @@ -100,3 +100,4 @@ obj-$(CONFIG_DRM_ZTE) += zte/ > obj-$(CONFIG_DRM_MXSFB) += mxsfb/ > obj-$(CONFIG_DRM_TINYDRM) += tinydrm/ > obj-$(CONFIG_DRM_PL111) += pl111/ > +obj-$(CONFIG_DRM_TVE200) += tve200/ > diff --git a/drivers/gpu/drm/tve200/Kconfig b/drivers/gpu/drm/tve200/Kconfig > new file mode 100644 > index 000000000000..21d9841ddb88 > --- /dev/null > +++ b/drivers/gpu/drm/tve200/Kconfig > @@ -0,0 +1,15 @@ > +config DRM_TVE200 > + tristate "DRM Support for Faraday TV Encoder TVE200" > + depends on DRM > + depends on CMA > + depends on ARM || COMPILE_TEST > + depends on OF > + select DRM_PANEL > + 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 Faraday TV Encoder > + TVE200 Controller. > + If M is selected the module will be called tve200_drm. > diff --git a/drivers/gpu/drm/tve200/Makefile b/drivers/gpu/drm/tve200/Makefile > new file mode 100644 > index 000000000000..a9dba54f7ee5 > --- /dev/null > +++ b/drivers/gpu/drm/tve200/Makefile > @@ -0,0 +1,5 @@ > +tve200_drm-y += tve200_connector.o \ > + tve200_display.o \ > + tve200_drv.o > + > +obj-$(CONFIG_DRM_TVE200) += tve200_drm.o > diff --git a/drivers/gpu/drm/tve200/tve200_connector.c b/drivers/gpu/drm/tve200/tve200_connector.c > new file mode 100644 > index 000000000000..93e99156d375 > --- /dev/null > +++ b/drivers/gpu/drm/tve200/tve200_connector.c > @@ -0,0 +1,126 @@ > +/* > + * Copyright (C) 2017 Linus Walleij > + * Parts of this file were based on sources as follows: > + * > + * Copyright (C) 2006-2008 Intel Corporation > + * Copyright (C) 2007 Amos Lee > + * Copyright (C) 2007 Dave Airlie > + * Copyright (C) 2011 Texas Instruments > + * Copyright (C) 2017 Eric Anholt > + * > + * 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. > + */ > + > +/** > + * tve200_drm_connector.c > + * Implementation of the connector functions for the Faraday TV Encoder > + */ > +#include > +#include > +#include > + > +#include > +#include > +#include > +#include > +#include > + > +#include "tve200_drm.h" > + > +static void tve200_connector_destroy(struct drm_connector *connector) > +{ > + struct tve200_drm_connector *tve200con = > + to_tve200_connector(connector); > + > + if (tve200con->panel) > + drm_panel_detach(tve200con->panel); > + > + drm_connector_unregister(connector); > + drm_connector_cleanup(connector); > +} > + > +static enum drm_connector_status tve200_connector_detect(struct drm_connector > + *connector, bool force) > +{ > + struct tve200_drm_connector *tve200con = > + to_tve200_connector(connector); > + > + return (tve200con->panel ? > + connector_status_connected : > + connector_status_disconnected); > +} > + > +static int tve200_connector_helper_get_modes(struct drm_connector *connector) > +{ > + struct tve200_drm_connector *tve200con = > + to_tve200_connector(connector); > + > + if (!tve200con->panel) > + return 0; > + > + return drm_panel_get_modes(tve200con->panel); > +} > + > +static const struct drm_connector_funcs connector_funcs = { > + .fill_modes = drm_helper_probe_single_connector_modes, > + .destroy = tve200_connector_destroy, > + .detect = tve200_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, > +}; > + > +static const struct drm_connector_helper_funcs connector_helper_funcs = { > + .get_modes = tve200_connector_helper_get_modes, > +}; The new "wrap panel as a bridge endpoint" helper we have in drm/bridge/panel.c is meant to remove all the need for the above boilerplate. Even comes with devm_ built-in :-) Please check it out. You're using the simple helpers, but I think they should fully mesh with the bridge stuff. Otherwise looks all neat and tidy. Acked-by: Daniel Vetter Wrt merging/maintaining: Want to include it in the drm-misc pile? We'll happily throw commit rights at every driver submission (and honestly expect that, since it helps tremendously with balance maintainer loads for the oddball trivial patch). Thanks, Daniel > + > +/* > + * Walks the OF graph to find the panel node and then asks DRM to look > + * up the panel. > + */ > +static struct drm_panel *tve200_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 tve200_connector_init(struct drm_device *dev) > +{ > + struct tve200_drm_dev_private *priv = dev->dev_private; > + struct tve200_drm_connector *tve200con = &priv->connector; > + struct drm_connector *connector = &tve200con->connector; > + > + drm_connector_init(dev, connector, &connector_funcs, > + DRM_MODE_CONNECTOR_DPI); > + drm_connector_helper_add(connector, &connector_helper_funcs); > + > + tve200con->panel = tve200_get_panel(dev->dev); > + if (tve200con->panel) > + drm_panel_attach(tve200con->panel, connector); > + > + return 0; > +} > diff --git a/drivers/gpu/drm/tve200/tve200_display.c b/drivers/gpu/drm/tve200/tve200_display.c > new file mode 100644 > index 000000000000..027553aacb33 > --- /dev/null > +++ b/drivers/gpu/drm/tve200/tve200_display.c > @@ -0,0 +1,346 @@ > +/* > + * Copyright (C) 2017 Linus Walleij > + * Parts of this file were based on sources as follows: > + * > + * Copyright (C) 2006-2008 Intel Corporation > + * Copyright (C) 2007 Amos Lee > + * Copyright (C) 2007 Dave Airlie > + * Copyright (C) 2011 Texas Instruments > + * Copyright (C) 2017 Eric Anholt > + * > + * 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 > + > +#include "tve200_drm.h" > + > +irqreturn_t tve200_irq(int irq, void *data) > +{ > + struct tve200_drm_dev_private *priv = data; > + u32 stat; > + u32 val; > + > + stat = readl(priv->regs + TVE200_INT_STAT); > + > + if (!stat) > + return IRQ_NONE; > + > + /* > + * Vblank IRQ > + * > + * The hardware is a bit tilted: the line stays high after clearing > + * the vblank IRQ, fireing many more interrupts. We counter this > + * by toggling the IRQ back and forth from fireing at vblank and > + * fireing at start of active image, which works around the problem > + * since those occur strictly in sequence, and we get two IRQs for each > + * frame, one at start of Vblank (that we make call into the CRTC) and > + * another one at the start of the image (that we discard). > + */ > + if (stat & TVE200_INT_V_STATUS) { > + val = readl(priv->regs + TVE200_CTRL); > + /* We have an actual start of vsync */ > + if (!(val & TVE200_VSTSTYPE_BITS)) { > + drm_crtc_handle_vblank(&priv->pipe.crtc); > + /* Toggle trigger to start of active image */ > + val |= TVE200_VSTSTYPE_VAI; > + } else { > + /* Toggle trigger back to start of vsync */ > + val &= ~TVE200_VSTSTYPE_BITS; > + } > + writel(val, priv->regs + TVE200_CTRL); > + } else > + dev_err(priv->drm->dev, "stray IRQ %08x\n", stat); > + > + /* Clear the interrupt once done */ > + writel(stat, priv->regs + TVE200_INT_CLR); > + > + return IRQ_HANDLED; > +} > + > +static int tve200_display_check(struct drm_simple_display_pipe *pipe, > + struct drm_plane_state *pstate, > + struct drm_crtc_state *cstate) > +{ > + const struct drm_display_mode *mode = &cstate->mode; > + struct drm_framebuffer *old_fb = pipe->plane.state->fb; > + struct drm_framebuffer *fb = pstate->fb; > + struct drm_connector *connector = pipe->connector; > + struct drm_device *drm = connector->dev; > + > + /* > + * We support these specific resolutions and nothing else. > + */ > + if (!(mode->hdisplay == 352 && mode->vdisplay == 240) && /* SIF(525) */ > + !(mode->hdisplay == 352 && mode->vdisplay == 288) && /* CIF(625) */ > + !(mode->hdisplay == 640 && mode->vdisplay == 480) && /* VGA */ > + !(mode->hdisplay == 720 && mode->vdisplay == 480) && /* D1 */ > + !(mode->hdisplay == 720 && mode->vdisplay == 576)) { /* D1 */ > + dev_err(drm->dev, "unsupported display mode (%u x %u)\n", > + mode->hdisplay, mode->vdisplay); > + return -EINVAL; > + } > + > + if (fb) { > + u32 offset = drm_fb_cma_get_gem_addr(fb, pstate, 0); > + > + /* FB base address must be dword aligned. */ > + if (offset & 3) { > + dev_err(drm->dev, "FB not 32-bit aligned\n"); > + return -EINVAL; > + } > + > + /* > + * There's no pitch register, the mode's hdisplay > + * controls this. > + */ > + if (fb->pitches[0] != mode->hdisplay * fb->format->cpp[0]) { > + dev_err(drm->dev, "can't handle pitches\n"); > + return -EINVAL; > + } > + > + /* > + * We can't change the FB format in a flicker-free > + * manner (and only update it during CRTC enable). > + */ > + if (old_fb && old_fb->format != fb->format) > + cstate->mode_changed = true; > + } > + > + return 0; > +} > + > +static void tve200_display_enable(struct drm_simple_display_pipe *pipe, > + struct drm_crtc_state *cstate) > +{ > + struct drm_crtc *crtc = &pipe->crtc; > + struct drm_plane *plane = &pipe->plane; > + struct drm_device *drm = crtc->dev; > + struct tve200_drm_dev_private *priv = drm->dev_private; > + const struct drm_display_mode *mode = &cstate->mode; > + struct drm_framebuffer *fb = plane->state->fb; > + struct drm_connector *connector = &priv->connector.connector; > + u32 format = fb->format->format; > + u32 ctrl1 = 0; > + > + clk_prepare_enable(priv->clk); > + > + /* Function 1 */ > + ctrl1 |= TVE200_CTRL_CSMODE; > + /* Interlace mode for CCIR656: parameterize? */ > + ctrl1 |= TVE200_CTRL_NONINTERLACE; > + /* 32 words per burst */ > + ctrl1 |= TVE200_CTRL_BURST_32_WORDS; > + /* 16 retries */ > + ctrl1 |= TVE200_CTRL_RETRYCNT_16; > + /* NTSC mode: parametrize? */ > + ctrl1 |= TVE200_CTRL_NTSC; > + > + /* Vsync IRQ at start of Vsync at first */ > + ctrl1 |= TVE200_VSTSTYPE_VSYNC; > + > + if (connector->display_info.bus_flags & DRM_BUS_FLAG_PIXDATA_NEGEDGE) > + ctrl1 |= TVE200_CTRL_TVCLKP; > + > + if ((mode->hdisplay == 352 && mode->vdisplay == 240) || /* SIF(525) */ > + (mode->hdisplay == 352 && mode->vdisplay == 288)) { /* CIF(625) */ > + ctrl1 |= TVE200_CTRL_IPRESOL_CIF; > + dev_info(drm->dev, "CIF mode\n"); > + } else if (mode->hdisplay == 640 && mode->vdisplay == 480) { > + ctrl1 |= TVE200_CTRL_IPRESOL_VGA; > + dev_info(drm->dev, "VGA mode\n"); > + } else if ((mode->hdisplay == 720 && mode->vdisplay == 480) || > + (mode->hdisplay == 720 && mode->vdisplay == 576)) { > + ctrl1 |= TVE200_CTRL_IPRESOL_D1; > + dev_info(drm->dev, "D1 mode\n"); > + } > + > + if (format & DRM_FORMAT_BIG_ENDIAN) { > + ctrl1 |= TVE200_CTRL_BBBP; > + format &= ~DRM_FORMAT_BIG_ENDIAN; > + } > + > + switch (format) { > + case DRM_FORMAT_XRGB8888: > + ctrl1 |= TVE200_IPDMOD_RGB888; > + break; > + case DRM_FORMAT_RGB565: > + ctrl1 |= TVE200_IPDMOD_RGB565; > + break; > + case DRM_FORMAT_XRGB1555: > + ctrl1 |= TVE200_IPDMOD_RGB555; > + break; > + case DRM_FORMAT_XBGR8888: > + ctrl1 |= TVE200_IPDMOD_RGB888 | TVE200_BGR; > + break; > + case DRM_FORMAT_BGR565: > + ctrl1 |= TVE200_IPDMOD_RGB565 | TVE200_BGR; > + break; > + case DRM_FORMAT_XBGR1555: > + ctrl1 |= TVE200_IPDMOD_RGB555 | TVE200_BGR; > + break; > + case DRM_FORMAT_YUYV: > + ctrl1 |= TVE200_IPDMOD_YUV422; > + ctrl1 |= TVE200_CTRL_YCBCRODR_CR0Y1CB0Y0; > + break; > + case DRM_FORMAT_YVYU: > + ctrl1 |= TVE200_IPDMOD_YUV422; > + ctrl1 |= TVE200_CTRL_YCBCRODR_CB0Y1CR0Y0; > + break; > + case DRM_FORMAT_UYVY: > + ctrl1 |= TVE200_IPDMOD_YUV422; > + ctrl1 |= TVE200_CTRL_YCBCRODR_Y1CR0Y0CB0; > + break; > + case DRM_FORMAT_VYUY: > + ctrl1 |= TVE200_IPDMOD_YUV422; > + ctrl1 |= TVE200_CTRL_YCBCRODR_Y1CB0Y0CR0; > + break; > + case DRM_FORMAT_YUV420: > + ctrl1 |= TVE200_CTRL_YUV420; > + ctrl1 |= TVE200_IPDMOD_YUV420; > + break; > + default: > + dev_err(drm->dev, "Unknown FB format 0x%08x\n", > + fb->format->format); > + break; > + } > + > + ctrl1 |= TVE200_TVEEN; > + > + drm_panel_prepare(priv->connector.panel); > + > + /* Turn it on */ > + writel(ctrl1, priv->regs + TVE200_CTRL); > + > + drm_panel_enable(priv->connector.panel); > + > + drm_crtc_vblank_on(crtc); > +} > + > +void tve200_display_disable(struct drm_simple_display_pipe *pipe) > +{ > + struct drm_crtc *crtc = &pipe->crtc; > + struct drm_device *drm = crtc->dev; > + struct tve200_drm_dev_private *priv = drm->dev_private; > + > + drm_crtc_vblank_off(crtc); > + > + drm_panel_disable(priv->connector.panel); > + > + /* Disable and Power Down */ > + writel(0, priv->regs + TVE200_CTRL); > + > + drm_panel_unprepare(priv->connector.panel); > + > + clk_disable_unprepare(priv->clk); > +} > + > +static void tve200_display_update(struct drm_simple_display_pipe *pipe, > + struct drm_plane_state *old_pstate) > +{ > + struct drm_crtc *crtc = &pipe->crtc; > + struct drm_device *drm = crtc->dev; > + struct tve200_drm_dev_private *priv = drm->dev_private; > + struct drm_pending_vblank_event *event = crtc->state->event; > + struct drm_plane *plane = &pipe->plane; > + struct drm_plane_state *pstate = plane->state; > + struct drm_framebuffer *fb = pstate->fb; > + > + if (fb) { > + /* For RGB, the Y component is used as base address */ > + writel(drm_fb_cma_get_gem_addr(fb, pstate, 0), > + priv->regs + TVE200_Y_FRAME_BASE_ADDR); > + > + /* For three plane YUV we need two more addresses */ > + if (fb->format->format == DRM_FORMAT_YUV420) { > + writel(drm_fb_cma_get_gem_addr(fb, pstate, 1), > + priv->regs + TVE200_U_FRAME_BASE_ADDR); > + writel(drm_fb_cma_get_gem_addr(fb, pstate, 2), > + priv->regs + TVE200_V_FRAME_BASE_ADDR); > + } > + } > + > + 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); > + } > +} > + > +int tve200_enable_vblank(struct drm_device *drm, unsigned int crtc) > +{ > + struct tve200_drm_dev_private *priv = drm->dev_private; > + > + writel(TVE200_INT_V_STATUS, priv->regs + TVE200_INT_EN); > + return 0; > +} > + > +void tve200_disable_vblank(struct drm_device *drm, unsigned int crtc) > +{ > + struct tve200_drm_dev_private *priv = drm->dev_private; > + > + writel(0, priv->regs + TVE200_INT_EN); > +} > + > +static int tve200_display_prepare_fb(struct drm_simple_display_pipe *pipe, > + struct drm_plane_state *plane_state) > +{ > + return drm_fb_cma_prepare_fb(&pipe->plane, plane_state); > +} > + > +const struct drm_simple_display_pipe_funcs tve200_display_funcs = { > + .check = tve200_display_check, > + .enable = tve200_display_enable, > + .disable = tve200_display_disable, > + .update = tve200_display_update, > + .prepare_fb = tve200_display_prepare_fb, > +}; > + > +int tve200_display_init(struct drm_device *drm) > +{ > + struct tve200_drm_dev_private *priv = drm->dev_private; > + int ret; > + static const u32 formats[] = { > + DRM_FORMAT_XRGB8888, > + DRM_FORMAT_XBGR8888, > + DRM_FORMAT_RGB565, > + DRM_FORMAT_BGR565, > + DRM_FORMAT_XRGB1555, > + DRM_FORMAT_XBGR1555, > + /* > + * The controller actually supports any YCbCr ordering, > + * for packed YCbCr. This just lists the orderings that > + * DRM supports. > + */ > + DRM_FORMAT_YUYV, > + DRM_FORMAT_YVYU, > + DRM_FORMAT_UYVY, > + DRM_FORMAT_VYUY, > + /* This uses three planes */ > + DRM_FORMAT_YUV420, > + }; > + > + ret = drm_simple_display_pipe_init(drm, &priv->pipe, > + &tve200_display_funcs, > + formats, ARRAY_SIZE(formats), > + &priv->connector.connector); > + if (ret) > + return ret; > + > + return 0; > +} > diff --git a/drivers/gpu/drm/tve200/tve200_drm.h b/drivers/gpu/drm/tve200/tve200_drm.h > new file mode 100644 > index 000000000000..f00fc47a6bd1 > --- /dev/null > +++ b/drivers/gpu/drm/tve200/tve200_drm.h > @@ -0,0 +1,129 @@ > +/* > + * Copyright (C) 2017 Linus Walleij > + * Parts of this file were based on sources as follows: > + * > + * Copyright (C) 2006-2008 Intel Corporation > + * Copyright (C) 2007 Amos Lee > + * Copyright (C) 2007 Dave Airlie > + * Copyright (C) 2011 Texas Instruments > + * Copyright (C) 2017 Eric Anholt > + * > + * 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 _TVE200_DRM_H_ > +#define _TVE200_DRM_H_ > + > +/* Bits 2-31 are valid physical base addresses */ > +#define TVE200_Y_FRAME_BASE_ADDR 0x00 > +#define TVE200_U_FRAME_BASE_ADDR 0x04 > +#define TVE200_V_FRAME_BASE_ADDR 0x08 > + > +#define TVE200_INT_EN 0x0C > +#define TVE200_INT_CLR 0x10 > +#define TVE200_INT_STAT 0x14 > +#define TVE200_INT_BUS_ERR BIT(7) > +#define TVE200_INT_V_STATUS BIT(6) /* vertical blank */ > +#define TVE200_INT_V_NEXT_FRAME BIT(5) > +#define TVE200_INT_U_NEXT_FRAME BIT(4) > +#define TVE200_INT_Y_NEXT_FRAME BIT(3) > +#define TVE200_INT_V_FIFO_UNDERRUN BIT(2) > +#define TVE200_INT_U_FIFO_UNDERRUN BIT(1) > +#define TVE200_INT_Y_FIFO_UNDERRUN BIT(0) > +#define TVE200_FIFO_UNDERRUNS (TVE200_INT_V_FIFO_UNDERRUN | \ > + TVE200_INT_U_FIFO_UNDERRUN | \ > + TVE200_INT_Y_FIFO_UNDERRUN) > + > +#define TVE200_CTRL 0x18 > +#define TVE200_CTRL_YUV420 BIT(31) > +#define TVE200_CTRL_CSMODE BIT(30) > +#define TVE200_CTRL_NONINTERLACE BIT(28) /* 0 = non-interlace CCIR656 */ > +#define TVE200_CTRL_TVCLKP BIT(27) /* Inverted clock phase */ > +/* Bits 24..26 define the burst size after arbitration on the bus */ > +#define TVE200_CTRL_BURST_4_WORDS (0 << 24) > +#define TVE200_CTRL_BURST_8_WORDS (1 << 24) > +#define TVE200_CTRL_BURST_16_WORDS (2 << 24) > +#define TVE200_CTRL_BURST_32_WORDS (3 << 24) > +#define TVE200_CTRL_BURST_64_WORDS (4 << 24) > +#define TVE200_CTRL_BURST_128_WORDS (5 << 24) > +#define TVE200_CTRL_BURST_256_WORDS (6 << 24) > +#define TVE200_CTRL_BURST_0_WORDS (7 << 24) /* ? */ > +/* > + * Bits 16..23 is the retry count*16 before issueing a new AHB transfer > + * on the AHB bus. > + */ > +#define TVE200_CTRL_RETRYCNT_MASK GENMASK(23, 16) > +#define TVE200_CTRL_RETRYCNT_16 (1 << 16) > +#define TVE200_CTRL_BBBP BIT(15) /* 0 = little-endian */ > +/* Bits 12..14 define the YCbCr ordering */ > +#define TVE200_CTRL_YCBCRODR_CB0Y0CR0Y1 (0 << 12) > +#define TVE200_CTRL_YCBCRODR_Y0CB0Y1CR0 (1 << 12) > +#define TVE200_CTRL_YCBCRODR_CR0Y0CB0Y1 (2 << 12) > +#define TVE200_CTRL_YCBCRODR_Y1CB0Y0CR0 (3 << 12) > +#define TVE200_CTRL_YCBCRODR_CR0Y1CB0Y0 (4 << 12) > +#define TVE200_CTRL_YCBCRODR_Y1CR0Y0CB0 (5 << 12) > +#define TVE200_CTRL_YCBCRODR_CB0Y1CR0Y0 (6 << 12) > +#define TVE200_CTRL_YCBCRODR_Y0CR0Y1CB0 (7 << 12) > +/* Bits 10..11 define the input resolution (framebuffer size) */ > +#define TVE200_CTRL_IPRESOL_CIF (0 << 10) > +#define TVE200_CTRL_IPRESOL_VGA (1 << 10) > +#define TVE200_CTRL_IPRESOL_D1 (2 << 10) > +#define TVE200_CTRL_NTSC BIT(9) /* 0 = PAL, 1 = NTSC */ > +#define TVE200_CTRL_INTERLACE BIT(8) /* 1 = interlace, only for D1 */ > +#define TVE200_IPDMOD_RGB555 (0 << 6) /* TVE200_CTRL_YUV420 = 0 */ > +#define TVE200_IPDMOD_RGB565 (1 << 6) > +#define TVE200_IPDMOD_RGB888 (2 << 6) > +#define TVE200_IPDMOD_YUV420 (2 << 6) /* TVE200_CTRL_YUV420 = 1 */ > +#define TVE200_IPDMOD_YUV422 (3 << 6) > +/* Bits 4 & 5 define when to fire the vblank IRQ */ > +#define TVE200_VSTSTYPE_VSYNC (0 << 4) /* start of vsync */ > +#define TVE200_VSTSTYPE_VBP (1 << 4) /* start of v back porch */ > +#define TVE200_VSTSTYPE_VAI (2 << 4) /* start of v active image */ > +#define TVE200_VSTSTYPE_VFP (3 << 4) /* start of v front porch */ > +#define TVE200_VSTSTYPE_BITS (BIT(4) | BIT(5)) > +#define TVE200_BGR BIT(1) /* 0 = RGB, 1 = BGR */ > +#define TVE200_TVEEN BIT(0) /* Enable TVE block */ > + > +#define TVE200_CTRL_2 0x1c > +#define TVE200_CTRL_3 0x20 > + > +#define TVE200_CTRL_4 0x24 > +#define TVE200_CTRL_4_RESET BIT(0) /* triggers reset of TVE200 */ > + > +#include > +#include > + > +struct tve200_drm_connector { > + struct drm_connector connector; > + struct drm_panel *panel; > +}; > + > +struct tve200_drm_dev_private { > + struct drm_device *drm; > + > + struct tve200_drm_connector connector; > + struct drm_simple_display_pipe pipe; > + struct drm_fbdev_cma *fbdev; > + > + void *regs; > + struct clk *pclk; > + struct clk *clk; > +}; > + > +#define to_tve200_connector(x) \ > + container_of(x, struct tve200_drm_connector, connector) > + > +int tve200_display_init(struct drm_device *dev); > +int tve200_enable_vblank(struct drm_device *drm, unsigned int crtc); > +void tve200_disable_vblank(struct drm_device *drm, unsigned int crtc); > +irqreturn_t tve200_irq(int irq, void *data); > +int tve200_connector_init(struct drm_device *dev); > +int tve200_encoder_init(struct drm_device *dev); > +int tve200_dumb_create(struct drm_file *file_priv, > + struct drm_device *dev, > + struct drm_mode_create_dumb *args); > + > +#endif /* _TVE200_DRM_H_ */ > diff --git a/drivers/gpu/drm/tve200/tve200_drv.c b/drivers/gpu/drm/tve200/tve200_drv.c > new file mode 100644 > index 000000000000..9e34147e2617 > --- /dev/null > +++ b/drivers/gpu/drm/tve200/tve200_drv.c > @@ -0,0 +1,277 @@ > +/* > + * Copyright (C) 2017 Linus Walleij > + * Parts of this file were based on sources as follows: > + * > + * Copyright (C) 2006-2008 Intel Corporation > + * Copyright (C) 2007 Amos Lee > + * Copyright (C) 2007 Dave Airlie > + * Copyright (C) 2011 Texas Instruments > + * Copyright (C) 2017 Eric Anholt > + * > + * 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: Faraday TV Encoder TVE200 DRM Driver > + * > + * The Faraday TV Encoder TVE200 is also known as the Gemini TV Interface > + * Controller (TVC) and is found in the Gemini Chipset from Storlink > + * Semiconductor (later Storm Semiconductor, later Cortina Systems) > + * but also in the Grain Media GM8180 chipset. On the Gemini the module > + * is connected to 8 data lines and a single clock line, comprising an > + * 8-bit BT.656 interface. > + * > + * This is a very basic YUV display driver. The datasheet specifies that > + * it supports the ITU BT.656 standard. It requires a 27 MHz clock which is > + * the hallmark of any TV encoder supporting both PAL and NTSC. > + * > + * This driver exposes a standard KMS interface for this TV encoder. > + */ > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > + > +#include > +#include > +#include > +#include > +#include > +#include > + > +#include "tve200_drm.h" > + > +#define DRIVER_DESC "DRM module for Faraday TVE200" > + > +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 tve200_modeset_init(struct drm_device *dev) > +{ > + struct drm_mode_config *mode_config; > + struct tve200_drm_dev_private *priv = dev->dev_private; > + int ret = 0; > + > + drm_mode_config_init(dev); > + mode_config = &dev->mode_config; > + mode_config->funcs = &mode_config_funcs; > + mode_config->min_width = 352; > + mode_config->max_width = 720; > + mode_config->min_height = 240; > + mode_config->max_height = 576; > + > + ret = tve200_connector_init(dev); > + if (ret) { > + dev_err(dev->dev, "Failed to create tve200_drm_connector\n"); > + goto out_config; > + } > + > + /* > + * Don't actually attach if we didn't find a drm_panel > + * attached to us. > + */ > + if (!priv->connector.panel) { > + dev_info(dev->dev, > + "deferring due to lack of DRM panel device\n"); > + ret = -EPROBE_DEFER; > + goto out_config; > + } > + dev_info(dev->dev, "attached to panel %s\n", > + dev_name(priv->connector.panel->dev)); > + > + ret = tve200_display_init(dev); > + if (ret) { > + dev_err(dev->dev, "failed to init display\n"); > + goto out_config; > + } > + > + ret = drm_vblank_init(dev, 1); > + if (ret) { > + dev_err(dev->dev, "failed to init vblank\n"); > + goto out_config; > + } > + > + drm_mode_config_reset(dev); > + > + /* > + * Passing in 16 here will make the RGB656 mode the default > + * Passing in 32 will use XRGB8888 mode > + */ > + priv->fbdev = drm_fbdev_cma_init(dev, 16, > + dev->mode_config.num_connector); > + drm_kms_helper_poll_init(dev); > + > + goto finish; > + > +out_config: > + drm_mode_config_cleanup(dev); > +finish: > + return ret; > +} > + > +DEFINE_DRM_GEM_CMA_FOPS(drm_fops); > + > +static void tve200_lastclose(struct drm_device *dev) > +{ > + struct tve200_drm_dev_private *priv = dev->dev_private; > + > + drm_fbdev_cma_restore_mode(priv->fbdev); > +} > + > +static struct drm_driver tve200_drm_driver = { > + .driver_features = > + DRIVER_MODESET | DRIVER_GEM | DRIVER_PRIME | DRIVER_ATOMIC, > + .lastclose = tve200_lastclose, > + .ioctls = NULL, > + .fops = &drm_fops, > + .name = "tve200", > + .desc = DRIVER_DESC, > + .date = "20170703", > + .major = 1, > + .minor = 0, > + .patchlevel = 0, > + .dumb_create = drm_gem_cma_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, > + > + .enable_vblank = tve200_enable_vblank, > + .disable_vblank = tve200_disable_vblank, > + > + .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, > +}; > + > +static int tve200_probe(struct platform_device *pdev) > +{ > + struct device *dev = &pdev->dev; > + struct tve200_drm_dev_private *priv; > + struct drm_device *drm; > + struct resource *res; > + int irq; > + int ret; > + > + priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); > + if (!priv) > + return -ENOMEM; > + > + drm = drm_dev_alloc(&tve200_drm_driver, dev); > + if (IS_ERR(drm)) > + return PTR_ERR(drm); > + platform_set_drvdata(pdev, drm); > + priv->drm = drm; > + drm->dev_private = priv; > + > + /* Clock the silicon so we can access the registers */ > + priv->pclk = devm_clk_get(dev, "PCLK"); > + if (IS_ERR(priv->pclk)) { > + dev_err(dev, "unable to get PCLK\n"); > + ret = PTR_ERR(priv->pclk); > + goto dev_unref; > + } > + ret = clk_prepare_enable(priv->pclk); > + if (ret) { > + dev_err(dev, "failed to enable PCLK\n"); > + goto dev_unref; > + } > + > + /* This clock is for the pixels (27MHz) */ > + priv->clk = devm_clk_get(dev, "TVE"); > + if (IS_ERR(priv->clk)) { > + dev_err(dev, "unable to get TVE clock\n"); > + ret = PTR_ERR(priv->clk); > + goto clk_disable; > + } > + > + res = platform_get_resource(pdev, IORESOURCE_MEM, 0); > + priv->regs = devm_ioremap_resource(dev, res); > + if (!priv->regs) { > + dev_err(dev, "%s failed mmio\n", __func__); > + ret = -EINVAL; > + goto dev_unref; > + } > + > + irq = platform_get_irq(pdev, 0); > + if (!irq) { > + ret = -EINVAL; > + goto dev_unref; > + } > + > + /* turn off interrupts before requesting the irq */ > + writel(0, priv->regs + TVE200_INT_EN); > + > + ret = devm_request_irq(dev, irq, tve200_irq, 0, "tve200", priv); > + if (ret) { > + dev_err(dev, "failed to request irq %d\n", ret); > + return ret; > + } > + > + ret = tve200_modeset_init(drm); > + if (ret) > + goto dev_unref; > + > + ret = drm_dev_register(drm, 0); > + if (ret < 0) > + goto dev_unref; > + > + return 0; > + > +clk_disable: > + clk_disable_unprepare(priv->pclk); > +dev_unref: > + drm_dev_unref(drm); > + return ret; > +} > + > +static int tve200_remove(struct platform_device *pdev) > +{ > + struct drm_device *drm = platform_get_drvdata(pdev); > + struct tve200_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); > + clk_disable_unprepare(priv->pclk); > + drm_dev_unref(drm); > + > + return 0; > +} > + > +static const struct of_device_id tve200_of_match[] = { > + { > + .compatible = "faraday,tve200", > + }, > + {}, > +}; > + > +static struct platform_driver tve200_driver = { > + .driver = { > + .name = "tve200", > + .of_match_table = of_match_ptr(tve200_of_match), > + }, > + .probe = tve200_probe, > + .remove = tve200_remove, > +}; > +module_platform_driver(tve200_driver); > + > +MODULE_DESCRIPTION(DRIVER_DESC); > +MODULE_AUTHOR("Linus Walleij "); > +MODULE_LICENSE("GPL"); > -- > 2.13.4 > > _______________________________________________ > dri-devel mailing list > dri-devel at 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/4] drm/tve200: Add new driver for TVE200 Date: Mon, 14 Aug 2017 16:20:15 +0200 Message-ID: <20170814142015.dy73yguwmuglloiz@phenom.ffwll.local> References: <20170813151132.24736-1-linus.walleij@linaro.org> <20170813151132.24736-3-linus.walleij@linaro.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail-wm0-x243.google.com (mail-wm0-x243.google.com [IPv6:2a00:1450:400c:c09::243]) by gabe.freedesktop.org (Postfix) with ESMTPS id EA0DE6E188 for ; Mon, 14 Aug 2017 14:20:20 +0000 (UTC) Received: by mail-wm0-x243.google.com with SMTP id r77so14649400wmd.2 for ; Mon, 14 Aug 2017 07:20:20 -0700 (PDT) Content-Disposition: inline In-Reply-To: <20170813151132.24736-3-linus.walleij@linaro.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Linus Walleij Cc: dri-devel@lists.freedesktop.org, Daniel Vetter , linux-arm-kernel@lists.infradead.org List-Id: dri-devel@lists.freedesktop.org T24gU3VuLCBBdWcgMTMsIDIwMTcgYXQgMDU6MTE6MzBQTSArMDIwMCwgTGludXMgV2FsbGVpaiB3 cm90ZToKPiBUaGlzIGFkZHMgYSBuZXcgRFJNIGRyaXZlciBmb3IgdGhlIEZhcmFkYXkgVGVjaG5v bG9neSBUVkUyMDAKPiBibG9jay4gVGhpcyAiVFYgRW5jb2RlciIgZW5jb2RlcyBhIElUVS1UIEJU LjY1NiBzdHJlYW0gYW5kIGNhbgo+IGJlIGZvdW5kIGluIHRoZSBTdG9yTGluayBTTDM1MTYgKGxh dGVyIENvcnRpbmEgU3lzdGVtcyBDUzM1MTYpCj4gYXMgd2VsbCBhcyB0aGUgR3JhaW4gTWVkaWEg R004MTgwLgo+IAo+IEkgZG8gbm90IGhhdmUgZGVmaW5pdGl2ZSB3b3JkIGZyb20gYW55b25lIGF0 IEZhcmFkYXkgdGhhdCB0aGlzCj4gSVAgYmxvY2sgaXMgdGhlaXJzLCBidXQgaXQgYmVhcnMgdGhl IGhhbGxtYXJrIG9mIHRoZWlyIDMtZGlnaXQKPiB2ZXJzaW9uIGNvZGUgKDIwMCkgYW5kIGlzIHVz ZWQgaW4gdHdvIFNvQ3MgZnJvbSBjb21wbGV0ZWx5Cj4gZGlmZmVyZW50IGNvbXBhbmllcy4gKEdy YWluIE1lZGlhIHdhcyBmdWxseSBvd25lZCBieSBGYXJhZGF5Cj4gdW50aWwgaXQgd2FzIHRyYW5z ZmVycmVkIHRvIE5vdm9UZWsgdGhpcyBqYW51YXJ5LCBhbmQKPiBGYXJhZGF5IGRpZCBsb3RzIG9m IHdvcmsgb24gdGhlIFN0b3JMaW5rIFNvQ3MuKQo+IAo+IFRoZSBELUxpbmsgRElSLTY4NSB1c2Vz IHRoaXMgaW4gY29ubmVjdGlvbiB3aXRoIHRoZSBJbGl0ZWsKPiBJTEk5MzIyIHBhbmVsIGRyaXZl ciB0aGF0IHN1cHBvcnRzIEJULjY1NiBpbnB1dCwgd2hpbGUgdGhlCj4gR004MTgwIGFwcGFyZW50 bHkgaGFzIGJlZW4gdXNlZCB3aXRoIHRoZSBDaXJydXMgTG9naWMgQ1M0OTU0Cj4gZGlnaXRhbCB2 aWRlbyBlbmNvZGVyLiBUaGUgb2xkZXN0IHVzZXIgc2VlbXMgdG8gYmUKPiBzb21ldGhpbmcgY2Fs bGVkIFRlY2h3YWxsIDI4MzUuCj4gCj4gVGhpcyBkcml2ZXIgaXMgaGVhdmlseSBpbnNwaXJlZCBi eSBFcmljIEFuaG9sdCdzIFBMMTExCj4gZHJpdmVyIGFuZCB0aGVyZWZvcmUgSSBoYXZlIG1lbnRp b25lZCBhbGwgdGhlIGFuY2VzdG9yIGF1dGhvcnMKPiBpbiB0aGUgaGVhZGVyIGZpbGUuCj4gCj4g U2lnbmVkLW9mZi1ieTogTGludXMgV2FsbGVpaiA8bGludXMud2FsbGVpakBsaW5hcm8ub3JnPgo+ IC0tLQo+ICBEb2N1bWVudGF0aW9uL2dwdS9pbmRleC5yc3QgICAgICAgICAgICAgICB8ICAgMSAr Cj4gIERvY3VtZW50YXRpb24vZ3B1L3R2ZTIwMC5yc3QgICAgICAgICAgICAgIHwgICA2ICsKPiAg TUFJTlRBSU5FUlMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDYgKwo+ICBkcml2 ZXJzL2dwdS9kcm0vS2NvbmZpZyAgICAgICAgICAgICAgICAgICB8ICAgMiArCj4gIGRyaXZlcnMv Z3B1L2RybS9NYWtlZmlsZSAgICAgICAgICAgICAgICAgIHwgICAxICsKPiAgZHJpdmVycy9ncHUv ZHJtL3R2ZTIwMC9LY29uZmlnICAgICAgICAgICAgfCAgMTUgKysKPiAgZHJpdmVycy9ncHUvZHJt L3R2ZTIwMC9NYWtlZmlsZSAgICAgICAgICAgfCAgIDUgKwo+ICBkcml2ZXJzL2dwdS9kcm0vdHZl MjAwL3R2ZTIwMF9jb25uZWN0b3IuYyB8IDEyNiArKysrKysrKysrKwo+ICBkcml2ZXJzL2dwdS9k cm0vdHZlMjAwL3R2ZTIwMF9kaXNwbGF5LmMgICB8IDM0NiArKysrKysrKysrKysrKysrKysrKysr KysrKysrKysKPiAgZHJpdmVycy9ncHUvZHJtL3R2ZTIwMC90dmUyMDBfZHJtLmggICAgICAgfCAx MjkgKysrKysrKysrKysKPiAgZHJpdmVycy9ncHUvZHJtL3R2ZTIwMC90dmUyMDBfZHJ2LmMgICAg ICAgfCAyNzcgKysrKysrKysrKysrKysrKysrKysrKysrCj4gIDExIGZpbGVzIGNoYW5nZWQsIDkx NCBpbnNlcnRpb25zKCspCj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBEb2N1bWVudGF0aW9uL2dwdS90 dmUyMDAucnN0Cj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2dwdS9kcm0vdHZlMjAwL0tj b25maWcKPiAgY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvZ3B1L2RybS90dmUyMDAvTWFrZWZp bGUKPiAgY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvZ3B1L2RybS90dmUyMDAvdHZlMjAwX2Nv bm5lY3Rvci5jCj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2dwdS9kcm0vdHZlMjAwL3R2 ZTIwMF9kaXNwbGF5LmMKPiAgY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvZ3B1L2RybS90dmUy MDAvdHZlMjAwX2RybS5oCj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2dwdS9kcm0vdHZl MjAwL3R2ZTIwMF9kcnYuYwo+IAo+IGRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2dwdS9pbmRl eC5yc3QgYi9Eb2N1bWVudGF0aW9uL2dwdS9pbmRleC5yc3QKPiBpbmRleCAzNWQ2NzNiZjliNTYu LmMzNjU4NmRhZDI5ZCAxMDA2NDQKPiAtLS0gYS9Eb2N1bWVudGF0aW9uL2dwdS9pbmRleC5yc3QK PiArKysgYi9Eb2N1bWVudGF0aW9uL2dwdS9pbmRleC5yc3QKPiBAQCAtMTUsNiArMTUsNyBAQCBM aW51eCBHUFUgRHJpdmVyIERldmVsb3BlcidzIEd1aWRlCj4gICAgIHBsMTExCj4gICAgIHRlZ3Jh Cj4gICAgIHRpbnlkcm0KPiArICAgdHZlMjAwCj4gICAgIHZjNAo+ICAgICB2Z2Etc3dpdGNoZXJv bwo+ICAgICB2Z2FhcmJpdGVyCj4gZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZ3B1L3R2ZTIw MC5yc3QgYi9Eb2N1bWVudGF0aW9uL2dwdS90dmUyMDAucnN0Cj4gbmV3IGZpbGUgbW9kZSAxMDA2 NDQKPiBpbmRleCAwMDAwMDAwMDAwMDAuLjY5YjE3YjMyNGUxMgo+IC0tLSAvZGV2L251bGwKPiAr KysgYi9Eb2N1bWVudGF0aW9uL2dwdS90dmUyMDAucnN0Cj4gQEAgLTAsMCArMSw2IEBACj4gKz09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KPiArIGRybS90dmUyMDAgRmFyYWRheSBU ViBFbmNvZGVyIDIwMAo+ICs9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Cj4gKwo+ ICsuLiBrZXJuZWwtZG9jOjogZHJpdmVycy9ncHUvZHJtL3R2ZTIwMC90dmUyMDBfZHJ2LmMKPiAr ICAgOmRvYzogRmFyYWRheSBUViBFbmNvZGVyIDIwMAo+IGRpZmYgLS1naXQgYS9NQUlOVEFJTkVS UyBiL01BSU5UQUlORVJTCj4gaW5kZXggZTg3Y2JhMTE1ZWE0Li5jM2Q0MmQ2ODI1M2EgMTAwNjQ0 Cj4gLS0tIGEvTUFJTlRBSU5FUlMKPiArKysgYi9NQUlOVEFJTkVSUwo+IEBAIC00MzA1LDYgKzQz MDUsMTIgQEAgVDoJZ2l0IGdpdDovL2Fub25naXQuZnJlZWRlc2t0b3Aub3JnL2RybS9kcm0tbWlz Ywo+ICBTOglNYWludGFpbmVkCj4gIEY6CWRyaXZlcnMvZ3B1L2RybS9ib2Nocy8KPiAgCj4gK0RS TSBEUklWRVIgRk9SIEZBUkFEQVkgVFZFMjAwIFRWIEVOQ09ERVIKPiArTToJTGludXMgV2FsbGVp aiA8bGludXMud2FsbGVpakBsaW5hcm8ub3JnPgo+ICtUOglnaXQgZ2l0Oi8vYW5vbmdpdC5mcmVl ZGVza3RvcC5vcmcvZHJtL2RybS1taXNjCj4gK1M6CU1haW50YWluZWQKPiArRjoJZHJpdmVycy9n cHUvZHJtL3R2ZTIwMC8KPiArCj4gIERSTSBEUklWRVIgRk9SIElOVEVMIEk4MTAgVklERU8gQ0FS RFMKPiAgUzoJT3JwaGFuIC8gT2Jzb2xldGUKPiAgRjoJZHJpdmVycy9ncHUvZHJtL2k4MTAvCj4g ZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9LY29uZmlnIGIvZHJpdmVycy9ncHUvZHJtL0tj b25maWcKPiBpbmRleCA4M2NiMmE4OGMyMDQuLmM1ZTFhODQwOTI4NSAxMDA2NDQKPiAtLS0gYS9k cml2ZXJzL2dwdS9kcm0vS2NvbmZpZwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9LY29uZmlnCj4g QEAgLTI3OCw2ICsyNzgsOCBAQCBzb3VyY2UgImRyaXZlcnMvZ3B1L2RybS90aW55ZHJtL0tjb25m aWciCj4gIAo+ICBzb3VyY2UgImRyaXZlcnMvZ3B1L2RybS9wbDExMS9LY29uZmlnIgo+ICAKPiAr c291cmNlICJkcml2ZXJzL2dwdS9kcm0vdHZlMjAwL0tjb25maWciCj4gKwo+ICAjIEtlZXAgbGVn YWN5IGRyaXZlcnMgbGFzdAo+ICAKPiAgbWVudWNvbmZpZyBEUk1fTEVHQUNZCj4gZGlmZiAtLWdp dCBhL2RyaXZlcnMvZ3B1L2RybS9NYWtlZmlsZSBiL2RyaXZlcnMvZ3B1L2RybS9NYWtlZmlsZQo+ IGluZGV4IDI0YTA2NmUxODQxYy4uY2M4MTgxM2UyMjM4IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMv Z3B1L2RybS9NYWtlZmlsZQo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9NYWtlZmlsZQo+IEBAIC0x MDAsMyArMTAwLDQgQEAgb2JqLSQoQ09ORklHX0RSTV9aVEUpCSs9IHp0ZS8KPiAgb2JqLSQoQ09O RklHX0RSTV9NWFNGQikJKz0gbXhzZmIvCj4gIG9iai0kKENPTkZJR19EUk1fVElOWURSTSkgKz0g dGlueWRybS8KPiAgb2JqLSQoQ09ORklHX0RSTV9QTDExMSkgKz0gcGwxMTEvCj4gK29iai0kKENP TkZJR19EUk1fVFZFMjAwKSArPSB0dmUyMDAvCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2Ry bS90dmUyMDAvS2NvbmZpZyBiL2RyaXZlcnMvZ3B1L2RybS90dmUyMDAvS2NvbmZpZwo+IG5ldyBm aWxlIG1vZGUgMTAwNjQ0Cj4gaW5kZXggMDAwMDAwMDAwMDAwLi4yMWQ5ODQxZGRiODgKPiAtLS0g L2Rldi9udWxsCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL3R2ZTIwMC9LY29uZmlnCj4gQEAgLTAs MCArMSwxNSBAQAo+ICtjb25maWcgRFJNX1RWRTIwMAo+ICsJdHJpc3RhdGUgIkRSTSBTdXBwb3J0 IGZvciBGYXJhZGF5IFRWIEVuY29kZXIgVFZFMjAwIgo+ICsJZGVwZW5kcyBvbiBEUk0KPiArCWRl cGVuZHMgb24gQ01BCj4gKwlkZXBlbmRzIG9uIEFSTSB8fCBDT01QSUxFX1RFU1QKPiArCWRlcGVu ZHMgb24gT0YKPiArCXNlbGVjdCBEUk1fUEFORUwKPiArCXNlbGVjdCBEUk1fS01TX0hFTFBFUgo+ ICsJc2VsZWN0IERSTV9LTVNfQ01BX0hFTFBFUgo+ICsJc2VsZWN0IERSTV9HRU1fQ01BX0hFTFBF Ugo+ICsJc2VsZWN0IFZUX0hXX0NPTlNPTEVfQklORElORyBpZiBGUkFNRUJVRkZFUl9DT05TT0xF Cj4gKwloZWxwCj4gKwkgIENob29zZSB0aGlzIG9wdGlvbiBmb3IgRFJNIHN1cHBvcnQgZm9yIHRo ZSBGYXJhZGF5IFRWIEVuY29kZXIKPiArCSAgVFZFMjAwIENvbnRyb2xsZXIuCj4gKwkgIElmIE0g aXMgc2VsZWN0ZWQgdGhlIG1vZHVsZSB3aWxsIGJlIGNhbGxlZCB0dmUyMDBfZHJtLgo+IGRpZmYg LS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vdHZlMjAwL01ha2VmaWxlIGIvZHJpdmVycy9ncHUvZHJt L3R2ZTIwMC9NYWtlZmlsZQo+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4gaW5kZXggMDAwMDAwMDAw MDAwLi5hOWRiYTU0ZjdlZTUKPiAtLS0gL2Rldi9udWxsCj4gKysrIGIvZHJpdmVycy9ncHUvZHJt L3R2ZTIwMC9NYWtlZmlsZQo+IEBAIC0wLDAgKzEsNSBAQAo+ICt0dmUyMDBfZHJtLXkgKz0JdHZl MjAwX2Nvbm5lY3Rvci5vIFwKPiArCQl0dmUyMDBfZGlzcGxheS5vIFwKPiArCQl0dmUyMDBfZHJ2 Lm8KPiArCj4gK29iai0kKENPTkZJR19EUk1fVFZFMjAwKSArPSB0dmUyMDBfZHJtLm8KPiBkaWZm IC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3R2ZTIwMC90dmUyMDBfY29ubmVjdG9yLmMgYi9kcml2 ZXJzL2dwdS9kcm0vdHZlMjAwL3R2ZTIwMF9jb25uZWN0b3IuYwo+IG5ldyBmaWxlIG1vZGUgMTAw NjQ0Cj4gaW5kZXggMDAwMDAwMDAwMDAwLi45M2U5OTE1NmQzNzUKPiAtLS0gL2Rldi9udWxsCj4g KysrIGIvZHJpdmVycy9ncHUvZHJtL3R2ZTIwMC90dmUyMDBfY29ubmVjdG9yLmMKPiBAQCAtMCww ICsxLDEyNiBAQAo+ICsvKgo+ICsgKiBDb3B5cmlnaHQgKEMpIDIwMTcgTGludXMgV2FsbGVpaiA8 bGludXMud2FsbGVpakBsaW5hcm8ub3JnPgo+ICsgKiBQYXJ0cyBvZiB0aGlzIGZpbGUgd2VyZSBi YXNlZCBvbiBzb3VyY2VzIGFzIGZvbGxvd3M6Cj4gKyAqCj4gKyAqIENvcHlyaWdodCAoQykgMjAw Ni0yMDA4IEludGVsIENvcnBvcmF0aW9uCj4gKyAqIENvcHlyaWdodCAoQykgMjAwNyBBbW9zIExl ZSA8YW1vc19sZWVAc3RvcmxpbmtzZW1pLmNvbT4KPiArICogQ29weXJpZ2h0IChDKSAyMDA3IERh dmUgQWlybGllIDxhaXJsaWVkQGxpbnV4LmllPgo+ICsgKiBDb3B5cmlnaHQgKEMpIDIwMTEgVGV4 YXMgSW5zdHJ1bWVudHMKPiArICogQ29weXJpZ2h0IChDKSAyMDE3IEVyaWMgQW5ob2x0Cj4gKyAq Cj4gKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlIGFuZCBpcyBwcm92aWRlZCB0byB5 b3UgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZQo+ICsgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5z ZSB2ZXJzaW9uIDIgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlCj4gKyAqIEZvdW5k YXRpb24sIGFuZCBhbnkgdXNlIGJ5IHlvdSBvZiB0aGlzIHByb2dyYW0gaXMgc3ViamVjdCB0byB0 aGUgdGVybXMgb2YKPiArICogc3VjaCBHTlUgbGljZW5jZS4KPiArICovCj4gKwo+ICsvKioKPiAr ICogdHZlMjAwX2RybV9jb25uZWN0b3IuYwo+ICsgKiBJbXBsZW1lbnRhdGlvbiBvZiB0aGUgY29u bmVjdG9yIGZ1bmN0aW9ucyBmb3IgdGhlIEZhcmFkYXkgVFYgRW5jb2Rlcgo+ICsgKi8KPiArI2lu Y2x1ZGUgPGxpbnV4L3ZlcnNpb24uaD4KPiArI2luY2x1ZGUgPGxpbnV4L3NobWVtX2ZzLmg+Cj4g KyNpbmNsdWRlIDxsaW51eC9kbWEtYnVmLmg+Cj4gKwo+ICsjaW5jbHVkZSA8ZHJtL2RybVAuaD4K PiArI2luY2x1ZGUgPGRybS9kcm1fYXRvbWljX2hlbHBlci5oPgo+ICsjaW5jbHVkZSA8ZHJtL2Ry bV9jcnRjX2hlbHBlci5oPgo+ICsjaW5jbHVkZSA8ZHJtL2RybV9vZi5oPgo+ICsjaW5jbHVkZSA8 ZHJtL2RybV9wYW5lbC5oPgo+ICsKPiArI2luY2x1ZGUgInR2ZTIwMF9kcm0uaCIKPiArCj4gK3N0 YXRpYyB2b2lkIHR2ZTIwMF9jb25uZWN0b3JfZGVzdHJveShzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAq Y29ubmVjdG9yKQo+ICt7Cj4gKwlzdHJ1Y3QgdHZlMjAwX2RybV9jb25uZWN0b3IgKnR2ZTIwMGNv biA9Cj4gKwkJdG9fdHZlMjAwX2Nvbm5lY3Rvcihjb25uZWN0b3IpOwo+ICsKPiArCWlmICh0dmUy MDBjb24tPnBhbmVsKQo+ICsJCWRybV9wYW5lbF9kZXRhY2godHZlMjAwY29uLT5wYW5lbCk7Cj4g Kwo+ICsJZHJtX2Nvbm5lY3Rvcl91bnJlZ2lzdGVyKGNvbm5lY3Rvcik7Cj4gKwlkcm1fY29ubmVj dG9yX2NsZWFudXAoY29ubmVjdG9yKTsKPiArfQo+ICsKPiArc3RhdGljIGVudW0gZHJtX2Nvbm5l Y3Rvcl9zdGF0dXMgdHZlMjAwX2Nvbm5lY3Rvcl9kZXRlY3Qoc3RydWN0IGRybV9jb25uZWN0b3IK PiArCQkJCQkJCSpjb25uZWN0b3IsIGJvb2wgZm9yY2UpCj4gK3sKPiArCXN0cnVjdCB0dmUyMDBf ZHJtX2Nvbm5lY3RvciAqdHZlMjAwY29uID0KPiArCQl0b190dmUyMDBfY29ubmVjdG9yKGNvbm5l Y3Rvcik7Cj4gKwo+ICsJcmV0dXJuICh0dmUyMDBjb24tPnBhbmVsID8KPiArCQljb25uZWN0b3Jf c3RhdHVzX2Nvbm5lY3RlZCA6Cj4gKwkJY29ubmVjdG9yX3N0YXR1c19kaXNjb25uZWN0ZWQpOwo+ ICt9Cj4gKwo+ICtzdGF0aWMgaW50IHR2ZTIwMF9jb25uZWN0b3JfaGVscGVyX2dldF9tb2Rlcyhz dHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9yKQo+ICt7Cj4gKwlzdHJ1Y3QgdHZlMjAwX2Ry bV9jb25uZWN0b3IgKnR2ZTIwMGNvbiA9Cj4gKwkJdG9fdHZlMjAwX2Nvbm5lY3Rvcihjb25uZWN0 b3IpOwo+ICsKPiArCWlmICghdHZlMjAwY29uLT5wYW5lbCkKPiArCQlyZXR1cm4gMDsKPiArCj4g KwlyZXR1cm4gZHJtX3BhbmVsX2dldF9tb2Rlcyh0dmUyMDBjb24tPnBhbmVsKTsKPiArfQo+ICsK PiArc3RhdGljIGNvbnN0IHN0cnVjdCBkcm1fY29ubmVjdG9yX2Z1bmNzIGNvbm5lY3Rvcl9mdW5j cyA9IHsKPiArCS5maWxsX21vZGVzID0gZHJtX2hlbHBlcl9wcm9iZV9zaW5nbGVfY29ubmVjdG9y X21vZGVzLAo+ICsJLmRlc3Ryb3kgPSB0dmUyMDBfY29ubmVjdG9yX2Rlc3Ryb3ksCj4gKwkuZGV0 ZWN0ID0gdHZlMjAwX2Nvbm5lY3Rvcl9kZXRlY3QsCj4gKwkuZHBtcyA9IGRybV9hdG9taWNfaGVs cGVyX2Nvbm5lY3Rvcl9kcG1zLAo+ICsJLnJlc2V0ID0gZHJtX2F0b21pY19oZWxwZXJfY29ubmVj dG9yX3Jlc2V0LAo+ICsJLmF0b21pY19kdXBsaWNhdGVfc3RhdGUgPSBkcm1fYXRvbWljX2hlbHBl cl9jb25uZWN0b3JfZHVwbGljYXRlX3N0YXRlLAo+ICsJLmF0b21pY19kZXN0cm95X3N0YXRlID0g ZHJtX2F0b21pY19oZWxwZXJfY29ubmVjdG9yX2Rlc3Ryb3lfc3RhdGUsCj4gK307Cj4gKwo+ICtz dGF0aWMgY29uc3Qgc3RydWN0IGRybV9jb25uZWN0b3JfaGVscGVyX2Z1bmNzIGNvbm5lY3Rvcl9o ZWxwZXJfZnVuY3MgPSB7Cj4gKwkuZ2V0X21vZGVzID0gdHZlMjAwX2Nvbm5lY3Rvcl9oZWxwZXJf Z2V0X21vZGVzLAo+ICt9OwoKVGhlIG5ldyAid3JhcCBwYW5lbCBhcyBhIGJyaWRnZSBlbmRwb2lu dCIgaGVscGVyIHdlIGhhdmUgaW4KZHJtL2JyaWRnZS9wYW5lbC5jIGlzIG1lYW50IHRvIHJlbW92 ZSBhbGwgdGhlIG5lZWQgZm9yIHRoZSBhYm92ZQpib2lsZXJwbGF0ZS4gRXZlbiBjb21lcyB3aXRo IGRldm1fIGJ1aWx0LWluIDotKQoKUGxlYXNlIGNoZWNrIGl0IG91dC4KCllvdSdyZSB1c2luZyB0 aGUgc2ltcGxlIGhlbHBlcnMsIGJ1dCBJIHRoaW5rIHRoZXkgc2hvdWxkIGZ1bGx5IG1lc2ggd2l0 aAp0aGUgYnJpZGdlIHN0dWZmLgoKT3RoZXJ3aXNlIGxvb2tzIGFsbCBuZWF0IGFuZCB0aWR5LgoK QWNrZWQtYnk6IERhbmllbCBWZXR0ZXIgPGRhbmllbC52ZXR0ZXJAZmZ3bGwuY2g+CgpXcnQgbWVy Z2luZy9tYWludGFpbmluZzogV2FudCB0byBpbmNsdWRlIGl0IGluIHRoZSBkcm0tbWlzYyBwaWxl PyBXZSdsbApoYXBwaWx5IHRocm93IGNvbW1pdCByaWdodHMgYXQgZXZlcnkgZHJpdmVyIHN1Ym1p c3Npb24gKGFuZCBob25lc3RseQpleHBlY3QgdGhhdCwgc2luY2UgaXQgaGVscHMgdHJlbWVuZG91 c2x5IHdpdGggYmFsYW5jZSBtYWludGFpbmVyIGxvYWRzIGZvcgp0aGUgb2RkYmFsbCB0cml2aWFs IHBhdGNoKS4KClRoYW5rcywgRGFuaWVsCgo+ICsKPiArLyoKPiArICogV2Fsa3MgdGhlIE9GIGdy YXBoIHRvIGZpbmQgdGhlIHBhbmVsIG5vZGUgYW5kIHRoZW4gYXNrcyBEUk0gdG8gbG9vawo+ICsg KiB1cCB0aGUgcGFuZWwuCj4gKyAqLwo+ICtzdGF0aWMgc3RydWN0IGRybV9wYW5lbCAqdHZlMjAw X2dldF9wYW5lbChzdHJ1Y3QgZGV2aWNlICpkZXYpCj4gK3sKPiArCXN0cnVjdCBkZXZpY2Vfbm9k ZSAqZW5kcG9pbnQsICpwYW5lbF9ub2RlOwo+ICsJc3RydWN0IGRldmljZV9ub2RlICpucCA9IGRl di0+b2Zfbm9kZTsKPiArCXN0cnVjdCBkcm1fcGFuZWwgKnBhbmVsOwo+ICsKPiArCWVuZHBvaW50 ID0gb2ZfZ3JhcGhfZ2V0X25leHRfZW5kcG9pbnQobnAsIE5VTEwpOwo+ICsJaWYgKCFlbmRwb2lu dCkgewo+ICsJCWRldl9lcnIoZGV2LCAibm8gZW5kcG9pbnQgdG8gZmV0Y2ggcGFuZWxcbiIpOwo+ ICsJCXJldHVybiBOVUxMOwo+ICsJfQo+ICsKPiArCS8qIERvbid0IHByb2NlZWQgaWYgd2UgaGF2 ZSBhbiBlbmRwb2ludCBidXQgbm8gcGFuZWxfbm9kZSB0aWVkIHRvIGl0ICovCj4gKwlwYW5lbF9u b2RlID0gb2ZfZ3JhcGhfZ2V0X3JlbW90ZV9wb3J0X3BhcmVudChlbmRwb2ludCk7Cj4gKwlvZl9u b2RlX3B1dChlbmRwb2ludCk7Cj4gKwlpZiAoIXBhbmVsX25vZGUpIHsKPiArCQlkZXZfZXJyKGRl diwgIm5vIHZhbGlkIHBhbmVsIG5vZGVcbiIpOwo+ICsJCXJldHVybiBOVUxMOwo+ICsJfQo+ICsK PiArCXBhbmVsID0gb2ZfZHJtX2ZpbmRfcGFuZWwocGFuZWxfbm9kZSk7Cj4gKwlvZl9ub2RlX3B1 dChwYW5lbF9ub2RlKTsKPiArCj4gKwlyZXR1cm4gcGFuZWw7Cj4gK30KPiArCj4gK2ludCB0dmUy MDBfY29ubmVjdG9yX2luaXQoc3RydWN0IGRybV9kZXZpY2UgKmRldikKPiArewo+ICsJc3RydWN0 IHR2ZTIwMF9kcm1fZGV2X3ByaXZhdGUgKnByaXYgPSBkZXYtPmRldl9wcml2YXRlOwo+ICsJc3Ry dWN0IHR2ZTIwMF9kcm1fY29ubmVjdG9yICp0dmUyMDBjb24gPSAmcHJpdi0+Y29ubmVjdG9yOwo+ ICsJc3RydWN0IGRybV9jb25uZWN0b3IgKmNvbm5lY3RvciA9ICZ0dmUyMDBjb24tPmNvbm5lY3Rv cjsKPiArCj4gKwlkcm1fY29ubmVjdG9yX2luaXQoZGV2LCBjb25uZWN0b3IsICZjb25uZWN0b3Jf ZnVuY3MsCj4gKwkJCSAgIERSTV9NT0RFX0NPTk5FQ1RPUl9EUEkpOwo+ICsJZHJtX2Nvbm5lY3Rv cl9oZWxwZXJfYWRkKGNvbm5lY3RvciwgJmNvbm5lY3Rvcl9oZWxwZXJfZnVuY3MpOwo+ICsKPiAr CXR2ZTIwMGNvbi0+cGFuZWwgPSB0dmUyMDBfZ2V0X3BhbmVsKGRldi0+ZGV2KTsKPiArCWlmICh0 dmUyMDBjb24tPnBhbmVsKQo+ICsJCWRybV9wYW5lbF9hdHRhY2godHZlMjAwY29uLT5wYW5lbCwg Y29ubmVjdG9yKTsKPiArCj4gKwlyZXR1cm4gMDsKPiArfQo+IGRpZmYgLS1naXQgYS9kcml2ZXJz L2dwdS9kcm0vdHZlMjAwL3R2ZTIwMF9kaXNwbGF5LmMgYi9kcml2ZXJzL2dwdS9kcm0vdHZlMjAw L3R2ZTIwMF9kaXNwbGF5LmMKPiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+IGluZGV4IDAwMDAwMDAw MDAwMC4uMDI3NTUzYWFjYjMzCj4gLS0tIC9kZXYvbnVsbAo+ICsrKyBiL2RyaXZlcnMvZ3B1L2Ry bS90dmUyMDAvdHZlMjAwX2Rpc3BsYXkuYwo+IEBAIC0wLDAgKzEsMzQ2IEBACj4gKy8qCj4gKyAq IENvcHlyaWdodCAoQykgMjAxNyBMaW51cyBXYWxsZWlqIDxsaW51cy53YWxsZWlqQGxpbmFyby5v cmc+Cj4gKyAqIFBhcnRzIG9mIHRoaXMgZmlsZSB3ZXJlIGJhc2VkIG9uIHNvdXJjZXMgYXMgZm9s bG93czoKPiArICoKPiArICogQ29weXJpZ2h0IChDKSAyMDA2LTIwMDggSW50ZWwgQ29ycG9yYXRp b24KPiArICogQ29weXJpZ2h0IChDKSAyMDA3IEFtb3MgTGVlIDxhbW9zX2xlZUBzdG9ybGlua3Nl bWkuY29tPgo+ICsgKiBDb3B5cmlnaHQgKEMpIDIwMDcgRGF2ZSBBaXJsaWUgPGFpcmxpZWRAbGlu dXguaWU+Cj4gKyAqIENvcHlyaWdodCAoQykgMjAxMSBUZXhhcyBJbnN0cnVtZW50cwo+ICsgKiBD b3B5cmlnaHQgKEMpIDIwMTcgRXJpYyBBbmhvbHQKPiArICoKPiArICogVGhpcyBwcm9ncmFtIGlz IGZyZWUgc29mdHdhcmUgYW5kIGlzIHByb3ZpZGVkIHRvIHlvdSB1bmRlciB0aGUgdGVybXMgb2Yg dGhlCj4gKyAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcyBwdWJsaXNo ZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUKPiArICogRm91bmRhdGlvbiwgYW5kIGFueSB1c2UgYnkg eW91IG9mIHRoaXMgcHJvZ3JhbSBpcyBzdWJqZWN0IHRvIHRoZSB0ZXJtcyBvZgo+ICsgKiBzdWNo IEdOVSBsaWNlbmNlLgo+ICsgKi8KPiArI2luY2x1ZGUgPGxpbnV4L2Nsay5oPgo+ICsjaW5jbHVk ZSA8bGludXgvdmVyc2lvbi5oPgo+ICsjaW5jbHVkZSA8bGludXgvZG1hLWJ1Zi5oPgo+ICsjaW5j bHVkZSA8bGludXgvb2ZfZ3JhcGguaD4KPiArCj4gKyNpbmNsdWRlIDxkcm0vZHJtUC5oPgo+ICsj aW5jbHVkZSA8ZHJtL2RybV9wYW5lbC5oPgo+ICsjaW5jbHVkZSA8ZHJtL2RybV9nZW1fY21hX2hl bHBlci5oPgo+ICsjaW5jbHVkZSA8ZHJtL2RybV9mYl9jbWFfaGVscGVyLmg+Cj4gKwo+ICsjaW5j bHVkZSAidHZlMjAwX2RybS5oIgo+ICsKPiAraXJxcmV0dXJuX3QgdHZlMjAwX2lycShpbnQgaXJx LCB2b2lkICpkYXRhKQo+ICt7Cj4gKwlzdHJ1Y3QgdHZlMjAwX2RybV9kZXZfcHJpdmF0ZSAqcHJp diA9IGRhdGE7Cj4gKwl1MzIgc3RhdDsKPiArCXUzMiB2YWw7Cj4gKwo+ICsJc3RhdCA9IHJlYWRs KHByaXYtPnJlZ3MgKyBUVkUyMDBfSU5UX1NUQVQpOwo+ICsKPiArCWlmICghc3RhdCkKPiArCQly ZXR1cm4gSVJRX05PTkU7Cj4gKwo+ICsJLyoKPiArCSAqIFZibGFuayBJUlEKPiArCSAqCj4gKwkg KiBUaGUgaGFyZHdhcmUgaXMgYSBiaXQgdGlsdGVkOiB0aGUgbGluZSBzdGF5cyBoaWdoIGFmdGVy IGNsZWFyaW5nCj4gKwkgKiB0aGUgdmJsYW5rIElSUSwgZmlyZWluZyBtYW55IG1vcmUgaW50ZXJy dXB0cy4gV2UgY291bnRlciB0aGlzCj4gKwkgKiBieSB0b2dnbGluZyB0aGUgSVJRIGJhY2sgYW5k IGZvcnRoIGZyb20gZmlyZWluZyBhdCB2YmxhbmsgYW5kCj4gKwkgKiBmaXJlaW5nIGF0IHN0YXJ0 IG9mIGFjdGl2ZSBpbWFnZSwgd2hpY2ggd29ya3MgYXJvdW5kIHRoZSBwcm9ibGVtCj4gKwkgKiBz aW5jZSB0aG9zZSBvY2N1ciBzdHJpY3RseSBpbiBzZXF1ZW5jZSwgYW5kIHdlIGdldCB0d28gSVJR cyBmb3IgZWFjaAo+ICsJICogZnJhbWUsIG9uZSBhdCBzdGFydCBvZiBWYmxhbmsgKHRoYXQgd2Ug bWFrZSBjYWxsIGludG8gdGhlIENSVEMpIGFuZAo+ICsJICogYW5vdGhlciBvbmUgYXQgdGhlIHN0 YXJ0IG9mIHRoZSBpbWFnZSAodGhhdCB3ZSBkaXNjYXJkKS4KPiArCSAqLwo+ICsJaWYgKHN0YXQg JiBUVkUyMDBfSU5UX1ZfU1RBVFVTKSB7Cj4gKwkJdmFsID0gcmVhZGwocHJpdi0+cmVncyArIFRW RTIwMF9DVFJMKTsKPiArCQkvKiBXZSBoYXZlIGFuIGFjdHVhbCBzdGFydCBvZiB2c3luYyAqLwo+ ICsJCWlmICghKHZhbCAmIFRWRTIwMF9WU1RTVFlQRV9CSVRTKSkgewo+ICsJCQlkcm1fY3J0Y19o YW5kbGVfdmJsYW5rKCZwcml2LT5waXBlLmNydGMpOwo+ICsJCQkvKiBUb2dnbGUgdHJpZ2dlciB0 byBzdGFydCBvZiBhY3RpdmUgaW1hZ2UgKi8KPiArCQkJdmFsIHw9IFRWRTIwMF9WU1RTVFlQRV9W QUk7Cj4gKwkJfSBlbHNlIHsKPiArCQkJLyogVG9nZ2xlIHRyaWdnZXIgYmFjayB0byBzdGFydCBv ZiB2c3luYyAqLwo+ICsJCQl2YWwgJj0gflRWRTIwMF9WU1RTVFlQRV9CSVRTOwo+ICsJCX0KPiAr CQl3cml0ZWwodmFsLCBwcml2LT5yZWdzICsgVFZFMjAwX0NUUkwpOwo+ICsJfSBlbHNlCj4gKwkJ ZGV2X2Vycihwcml2LT5kcm0tPmRldiwgInN0cmF5IElSUSAlMDh4XG4iLCBzdGF0KTsKPiArCj4g KwkvKiBDbGVhciB0aGUgaW50ZXJydXB0IG9uY2UgZG9uZSAqLwo+ICsJd3JpdGVsKHN0YXQsIHBy aXYtPnJlZ3MgKyBUVkUyMDBfSU5UX0NMUik7Cj4gKwo+ICsJcmV0dXJuIElSUV9IQU5ETEVEOwo+ ICt9Cj4gKwo+ICtzdGF0aWMgaW50IHR2ZTIwMF9kaXNwbGF5X2NoZWNrKHN0cnVjdCBkcm1fc2lt cGxlX2Rpc3BsYXlfcGlwZSAqcGlwZSwKPiArCQkJICAgICAgIHN0cnVjdCBkcm1fcGxhbmVfc3Rh dGUgKnBzdGF0ZSwKPiArCQkJICAgICAgIHN0cnVjdCBkcm1fY3J0Y19zdGF0ZSAqY3N0YXRlKQo+ ICt7Cj4gKwljb25zdCBzdHJ1Y3QgZHJtX2Rpc3BsYXlfbW9kZSAqbW9kZSA9ICZjc3RhdGUtPm1v ZGU7Cj4gKwlzdHJ1Y3QgZHJtX2ZyYW1lYnVmZmVyICpvbGRfZmIgPSBwaXBlLT5wbGFuZS5zdGF0 ZS0+ZmI7Cj4gKwlzdHJ1Y3QgZHJtX2ZyYW1lYnVmZmVyICpmYiA9IHBzdGF0ZS0+ZmI7Cj4gKwlz dHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9yID0gcGlwZS0+Y29ubmVjdG9yOwo+ICsJc3Ry dWN0IGRybV9kZXZpY2UgKmRybSA9IGNvbm5lY3Rvci0+ZGV2Owo+ICsKPiArCS8qCj4gKwkgKiBX ZSBzdXBwb3J0IHRoZXNlIHNwZWNpZmljIHJlc29sdXRpb25zIGFuZCBub3RoaW5nIGVsc2UuCj4g KwkgKi8KPiArCWlmICghKG1vZGUtPmhkaXNwbGF5ID09IDM1MiAmJiBtb2RlLT52ZGlzcGxheSA9 PSAyNDApICYmIC8qIFNJRig1MjUpICovCj4gKwkgICAgIShtb2RlLT5oZGlzcGxheSA9PSAzNTIg JiYgbW9kZS0+dmRpc3BsYXkgPT0gMjg4KSAmJiAvKiBDSUYoNjI1KSAqLwo+ICsJICAgICEobW9k ZS0+aGRpc3BsYXkgPT0gNjQwICYmIG1vZGUtPnZkaXNwbGF5ID09IDQ4MCkgJiYgLyogVkdBICov Cj4gKwkgICAgIShtb2RlLT5oZGlzcGxheSA9PSA3MjAgJiYgbW9kZS0+dmRpc3BsYXkgPT0gNDgw KSAmJiAvKiBEMSAqLwo+ICsJICAgICEobW9kZS0+aGRpc3BsYXkgPT0gNzIwICYmIG1vZGUtPnZk aXNwbGF5ID09IDU3NikpIHsgLyogRDEgKi8KPiArCQlkZXZfZXJyKGRybS0+ZGV2LCAidW5zdXBw b3J0ZWQgZGlzcGxheSBtb2RlICgldSB4ICV1KVxuIiwKPiArCQkJbW9kZS0+aGRpc3BsYXksIG1v ZGUtPnZkaXNwbGF5KTsKPiArCQlyZXR1cm4gLUVJTlZBTDsKPiArCX0KPiArCj4gKwlpZiAoZmIp IHsKPiArCQl1MzIgb2Zmc2V0ID0gZHJtX2ZiX2NtYV9nZXRfZ2VtX2FkZHIoZmIsIHBzdGF0ZSwg MCk7Cj4gKwo+ICsJCS8qIEZCIGJhc2UgYWRkcmVzcyBtdXN0IGJlIGR3b3JkIGFsaWduZWQuICov Cj4gKwkJaWYgKG9mZnNldCAmIDMpIHsKPiArCQkJZGV2X2Vycihkcm0tPmRldiwgIkZCIG5vdCAz Mi1iaXQgYWxpZ25lZFxuIik7Cj4gKwkJCXJldHVybiAtRUlOVkFMOwo+ICsJCX0KPiArCj4gKwkJ LyoKPiArCQkgKiBUaGVyZSdzIG5vIHBpdGNoIHJlZ2lzdGVyLCB0aGUgbW9kZSdzIGhkaXNwbGF5 Cj4gKwkJICogY29udHJvbHMgdGhpcy4KPiArCQkgKi8KPiArCQlpZiAoZmItPnBpdGNoZXNbMF0g IT0gbW9kZS0+aGRpc3BsYXkgKiBmYi0+Zm9ybWF0LT5jcHBbMF0pIHsKPiArCQkJZGV2X2Vycihk cm0tPmRldiwgImNhbid0IGhhbmRsZSBwaXRjaGVzXG4iKTsKPiArCQkJcmV0dXJuIC1FSU5WQUw7 Cj4gKwkJfQo+ICsKPiArCQkvKgo+ICsJCSAqIFdlIGNhbid0IGNoYW5nZSB0aGUgRkIgZm9ybWF0 IGluIGEgZmxpY2tlci1mcmVlCj4gKwkJICogbWFubmVyIChhbmQgb25seSB1cGRhdGUgaXQgZHVy aW5nIENSVEMgZW5hYmxlKS4KPiArCQkgKi8KPiArCQlpZiAob2xkX2ZiICYmIG9sZF9mYi0+Zm9y bWF0ICE9IGZiLT5mb3JtYXQpCj4gKwkJCWNzdGF0ZS0+bW9kZV9jaGFuZ2VkID0gdHJ1ZTsKPiAr CX0KPiArCj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiArc3RhdGljIHZvaWQgdHZlMjAwX2Rpc3Bs YXlfZW5hYmxlKHN0cnVjdCBkcm1fc2ltcGxlX2Rpc3BsYXlfcGlwZSAqcGlwZSwKPiArCQkJCSBz dHJ1Y3QgZHJtX2NydGNfc3RhdGUgKmNzdGF0ZSkKPiArewo+ICsJc3RydWN0IGRybV9jcnRjICpj cnRjID0gJnBpcGUtPmNydGM7Cj4gKwlzdHJ1Y3QgZHJtX3BsYW5lICpwbGFuZSA9ICZwaXBlLT5w bGFuZTsKPiArCXN0cnVjdCBkcm1fZGV2aWNlICpkcm0gPSBjcnRjLT5kZXY7Cj4gKwlzdHJ1Y3Qg dHZlMjAwX2RybV9kZXZfcHJpdmF0ZSAqcHJpdiA9IGRybS0+ZGV2X3ByaXZhdGU7Cj4gKwljb25z dCBzdHJ1Y3QgZHJtX2Rpc3BsYXlfbW9kZSAqbW9kZSA9ICZjc3RhdGUtPm1vZGU7Cj4gKwlzdHJ1 Y3QgZHJtX2ZyYW1lYnVmZmVyICpmYiA9IHBsYW5lLT5zdGF0ZS0+ZmI7Cj4gKwlzdHJ1Y3QgZHJt X2Nvbm5lY3RvciAqY29ubmVjdG9yID0gJnByaXYtPmNvbm5lY3Rvci5jb25uZWN0b3I7Cj4gKwl1 MzIgZm9ybWF0ID0gZmItPmZvcm1hdC0+Zm9ybWF0Owo+ICsJdTMyIGN0cmwxID0gMDsKPiArCj4g KwljbGtfcHJlcGFyZV9lbmFibGUocHJpdi0+Y2xrKTsKPiArCj4gKwkvKiBGdW5jdGlvbiAxICov Cj4gKwljdHJsMSB8PSBUVkUyMDBfQ1RSTF9DU01PREU7Cj4gKwkvKiBJbnRlcmxhY2UgbW9kZSBm b3IgQ0NJUjY1NjogcGFyYW1ldGVyaXplPyAqLwo+ICsJY3RybDEgfD0gVFZFMjAwX0NUUkxfTk9O SU5URVJMQUNFOwo+ICsJLyogMzIgd29yZHMgcGVyIGJ1cnN0ICovCj4gKwljdHJsMSB8PSBUVkUy MDBfQ1RSTF9CVVJTVF8zMl9XT1JEUzsKPiArCS8qIDE2IHJldHJpZXMgKi8KPiArCWN0cmwxIHw9 IFRWRTIwMF9DVFJMX1JFVFJZQ05UXzE2Owo+ICsJLyogTlRTQyBtb2RlOiBwYXJhbWV0cml6ZT8g Ki8KPiArCWN0cmwxIHw9IFRWRTIwMF9DVFJMX05UU0M7Cj4gKwo+ICsJLyogVnN5bmMgSVJRIGF0 IHN0YXJ0IG9mIFZzeW5jIGF0IGZpcnN0ICovCj4gKwljdHJsMSB8PSBUVkUyMDBfVlNUU1RZUEVf VlNZTkM7Cj4gKwo+ICsJaWYgKGNvbm5lY3Rvci0+ZGlzcGxheV9pbmZvLmJ1c19mbGFncyAmIERS TV9CVVNfRkxBR19QSVhEQVRBX05FR0VER0UpCj4gKwkJY3RybDEgfD0gVFZFMjAwX0NUUkxfVFZD TEtQOwo+ICsKPiArCWlmICgobW9kZS0+aGRpc3BsYXkgPT0gMzUyICYmIG1vZGUtPnZkaXNwbGF5 ID09IDI0MCkgfHwgLyogU0lGKDUyNSkgKi8KPiArCSAgICAobW9kZS0+aGRpc3BsYXkgPT0gMzUy ICYmIG1vZGUtPnZkaXNwbGF5ID09IDI4OCkpIHsgLyogQ0lGKDYyNSkgKi8KPiArCQljdHJsMSB8 PSBUVkUyMDBfQ1RSTF9JUFJFU09MX0NJRjsKPiArCQlkZXZfaW5mbyhkcm0tPmRldiwgIkNJRiBt b2RlXG4iKTsKPiArCX0gZWxzZSBpZiAobW9kZS0+aGRpc3BsYXkgPT0gNjQwICYmIG1vZGUtPnZk aXNwbGF5ID09IDQ4MCkgewo+ICsJCWN0cmwxIHw9IFRWRTIwMF9DVFJMX0lQUkVTT0xfVkdBOwo+ ICsJCWRldl9pbmZvKGRybS0+ZGV2LCAiVkdBIG1vZGVcbiIpOwo+ICsJfSBlbHNlIGlmICgobW9k ZS0+aGRpc3BsYXkgPT0gNzIwICYmIG1vZGUtPnZkaXNwbGF5ID09IDQ4MCkgfHwKPiArCQkgICAo bW9kZS0+aGRpc3BsYXkgPT0gNzIwICYmIG1vZGUtPnZkaXNwbGF5ID09IDU3NikpIHsKPiArCQlj dHJsMSB8PSBUVkUyMDBfQ1RSTF9JUFJFU09MX0QxOwo+ICsJCWRldl9pbmZvKGRybS0+ZGV2LCAi RDEgbW9kZVxuIik7Cj4gKwl9Cj4gKwo+ICsJaWYgKGZvcm1hdCAmIERSTV9GT1JNQVRfQklHX0VO RElBTikgewo+ICsJCWN0cmwxIHw9IFRWRTIwMF9DVFJMX0JCQlA7Cj4gKwkJZm9ybWF0ICY9IH5E Uk1fRk9STUFUX0JJR19FTkRJQU47Cj4gKwl9Cj4gKwo+ICsJc3dpdGNoIChmb3JtYXQpIHsKPiAr CWNhc2UgRFJNX0ZPUk1BVF9YUkdCODg4ODoKPiArCQljdHJsMSB8PSBUVkUyMDBfSVBETU9EX1JH Qjg4ODsKPiArCQlicmVhazsKPiArCWNhc2UgRFJNX0ZPUk1BVF9SR0I1NjU6Cj4gKwkJY3RybDEg fD0gVFZFMjAwX0lQRE1PRF9SR0I1NjU7Cj4gKwkJYnJlYWs7Cj4gKwljYXNlIERSTV9GT1JNQVRf WFJHQjE1NTU6Cj4gKwkJY3RybDEgfD0gVFZFMjAwX0lQRE1PRF9SR0I1NTU7Cj4gKwkJYnJlYWs7 Cj4gKwljYXNlIERSTV9GT1JNQVRfWEJHUjg4ODg6Cj4gKwkJY3RybDEgfD0gVFZFMjAwX0lQRE1P RF9SR0I4ODggfCBUVkUyMDBfQkdSOwo+ICsJCWJyZWFrOwo+ICsJY2FzZSBEUk1fRk9STUFUX0JH UjU2NToKPiArCQljdHJsMSB8PSBUVkUyMDBfSVBETU9EX1JHQjU2NSB8IFRWRTIwMF9CR1I7Cj4g KwkJYnJlYWs7Cj4gKwljYXNlIERSTV9GT1JNQVRfWEJHUjE1NTU6Cj4gKwkJY3RybDEgfD0gVFZF MjAwX0lQRE1PRF9SR0I1NTUgfCBUVkUyMDBfQkdSOwo+ICsJCWJyZWFrOwo+ICsJY2FzZSBEUk1f Rk9STUFUX1lVWVY6Cj4gKwkJY3RybDEgfD0gVFZFMjAwX0lQRE1PRF9ZVVY0MjI7Cj4gKwkJY3Ry bDEgfD0gVFZFMjAwX0NUUkxfWUNCQ1JPRFJfQ1IwWTFDQjBZMDsKPiArCQlicmVhazsKPiArCWNh c2UgRFJNX0ZPUk1BVF9ZVllVOgo+ICsJCWN0cmwxIHw9IFRWRTIwMF9JUERNT0RfWVVWNDIyOwo+ ICsJCWN0cmwxIHw9IFRWRTIwMF9DVFJMX1lDQkNST0RSX0NCMFkxQ1IwWTA7Cj4gKwkJYnJlYWs7 Cj4gKwljYXNlIERSTV9GT1JNQVRfVVlWWToKPiArCQljdHJsMSB8PSBUVkUyMDBfSVBETU9EX1lV VjQyMjsKPiArCQljdHJsMSB8PSBUVkUyMDBfQ1RSTF9ZQ0JDUk9EUl9ZMUNSMFkwQ0IwOwo+ICsJ CWJyZWFrOwo+ICsJY2FzZSBEUk1fRk9STUFUX1ZZVVk6Cj4gKwkJY3RybDEgfD0gVFZFMjAwX0lQ RE1PRF9ZVVY0MjI7Cj4gKwkJY3RybDEgfD0gVFZFMjAwX0NUUkxfWUNCQ1JPRFJfWTFDQjBZMENS MDsKPiArCQlicmVhazsKPiArCWNhc2UgRFJNX0ZPUk1BVF9ZVVY0MjA6Cj4gKwkJY3RybDEgfD0g VFZFMjAwX0NUUkxfWVVWNDIwOwo+ICsJCWN0cmwxIHw9IFRWRTIwMF9JUERNT0RfWVVWNDIwOwo+ ICsJCWJyZWFrOwo+ICsJZGVmYXVsdDoKPiArCQlkZXZfZXJyKGRybS0+ZGV2LCAiVW5rbm93biBG QiBmb3JtYXQgMHglMDh4XG4iLAo+ICsJCQlmYi0+Zm9ybWF0LT5mb3JtYXQpOwo+ICsJCWJyZWFr Owo+ICsJfQo+ICsKPiArCWN0cmwxIHw9IFRWRTIwMF9UVkVFTjsKPiArCj4gKwlkcm1fcGFuZWxf cHJlcGFyZShwcml2LT5jb25uZWN0b3IucGFuZWwpOwo+ICsKPiArCS8qIFR1cm4gaXQgb24gKi8K PiArCXdyaXRlbChjdHJsMSwgcHJpdi0+cmVncyArIFRWRTIwMF9DVFJMKTsKPiArCj4gKwlkcm1f cGFuZWxfZW5hYmxlKHByaXYtPmNvbm5lY3Rvci5wYW5lbCk7Cj4gKwo+ICsJZHJtX2NydGNfdmJs YW5rX29uKGNydGMpOwo+ICt9Cj4gKwo+ICt2b2lkIHR2ZTIwMF9kaXNwbGF5X2Rpc2FibGUoc3Ry dWN0IGRybV9zaW1wbGVfZGlzcGxheV9waXBlICpwaXBlKQo+ICt7Cj4gKwlzdHJ1Y3QgZHJtX2Ny dGMgKmNydGMgPSAmcGlwZS0+Y3J0YzsKPiArCXN0cnVjdCBkcm1fZGV2aWNlICpkcm0gPSBjcnRj LT5kZXY7Cj4gKwlzdHJ1Y3QgdHZlMjAwX2RybV9kZXZfcHJpdmF0ZSAqcHJpdiA9IGRybS0+ZGV2 X3ByaXZhdGU7Cj4gKwo+ICsJZHJtX2NydGNfdmJsYW5rX29mZihjcnRjKTsKPiArCj4gKwlkcm1f cGFuZWxfZGlzYWJsZShwcml2LT5jb25uZWN0b3IucGFuZWwpOwo+ICsKPiArCS8qIERpc2FibGUg YW5kIFBvd2VyIERvd24gKi8KPiArCXdyaXRlbCgwLCBwcml2LT5yZWdzICsgVFZFMjAwX0NUUkwp Owo+ICsKPiArCWRybV9wYW5lbF91bnByZXBhcmUocHJpdi0+Y29ubmVjdG9yLnBhbmVsKTsKPiAr Cj4gKwljbGtfZGlzYWJsZV91bnByZXBhcmUocHJpdi0+Y2xrKTsKPiArfQo+ICsKPiArc3RhdGlj IHZvaWQgdHZlMjAwX2Rpc3BsYXlfdXBkYXRlKHN0cnVjdCBkcm1fc2ltcGxlX2Rpc3BsYXlfcGlw ZSAqcGlwZSwKPiArCQkJCSBzdHJ1Y3QgZHJtX3BsYW5lX3N0YXRlICpvbGRfcHN0YXRlKQo+ICt7 Cj4gKwlzdHJ1Y3QgZHJtX2NydGMgKmNydGMgPSAmcGlwZS0+Y3J0YzsKPiArCXN0cnVjdCBkcm1f ZGV2aWNlICpkcm0gPSBjcnRjLT5kZXY7Cj4gKwlzdHJ1Y3QgdHZlMjAwX2RybV9kZXZfcHJpdmF0 ZSAqcHJpdiA9IGRybS0+ZGV2X3ByaXZhdGU7Cj4gKwlzdHJ1Y3QgZHJtX3BlbmRpbmdfdmJsYW5r X2V2ZW50ICpldmVudCA9IGNydGMtPnN0YXRlLT5ldmVudDsKPiArCXN0cnVjdCBkcm1fcGxhbmUg KnBsYW5lID0gJnBpcGUtPnBsYW5lOwo+ICsJc3RydWN0IGRybV9wbGFuZV9zdGF0ZSAqcHN0YXRl ID0gcGxhbmUtPnN0YXRlOwo+ICsJc3RydWN0IGRybV9mcmFtZWJ1ZmZlciAqZmIgPSBwc3RhdGUt PmZiOwo+ICsKPiArCWlmIChmYikgewo+ICsJCS8qIEZvciBSR0IsIHRoZSBZIGNvbXBvbmVudCBp cyB1c2VkIGFzIGJhc2UgYWRkcmVzcyAqLwo+ICsJCXdyaXRlbChkcm1fZmJfY21hX2dldF9nZW1f YWRkcihmYiwgcHN0YXRlLCAwKSwKPiArCQkgICAgICAgcHJpdi0+cmVncyArIFRWRTIwMF9ZX0ZS QU1FX0JBU0VfQUREUik7Cj4gKwo+ICsJCS8qIEZvciB0aHJlZSBwbGFuZSBZVVYgd2UgbmVlZCB0 d28gbW9yZSBhZGRyZXNzZXMgKi8KPiArCQlpZiAoZmItPmZvcm1hdC0+Zm9ybWF0ID09IERSTV9G T1JNQVRfWVVWNDIwKSB7Cj4gKwkJCXdyaXRlbChkcm1fZmJfY21hX2dldF9nZW1fYWRkcihmYiwg cHN0YXRlLCAxKSwKPiArCQkJICAgICAgIHByaXYtPnJlZ3MgKyBUVkUyMDBfVV9GUkFNRV9CQVNF X0FERFIpOwo+ICsJCQl3cml0ZWwoZHJtX2ZiX2NtYV9nZXRfZ2VtX2FkZHIoZmIsIHBzdGF0ZSwg MiksCj4gKwkJCSAgICAgICBwcml2LT5yZWdzICsgVFZFMjAwX1ZfRlJBTUVfQkFTRV9BRERSKTsK PiArCQl9Cj4gKwl9Cj4gKwo+ICsJaWYgKGV2ZW50KSB7Cj4gKwkJY3J0Yy0+c3RhdGUtPmV2ZW50 ID0gTlVMTDsKPiArCj4gKwkJc3Bpbl9sb2NrX2lycSgmY3J0Yy0+ZGV2LT5ldmVudF9sb2NrKTsK PiArCQlpZiAoY3J0Yy0+c3RhdGUtPmFjdGl2ZSAmJiBkcm1fY3J0Y192YmxhbmtfZ2V0KGNydGMp ID09IDApCj4gKwkJCWRybV9jcnRjX2FybV92YmxhbmtfZXZlbnQoY3J0YywgZXZlbnQpOwo+ICsJ CWVsc2UKPiArCQkJZHJtX2NydGNfc2VuZF92YmxhbmtfZXZlbnQoY3J0YywgZXZlbnQpOwo+ICsJ CXNwaW5fdW5sb2NrX2lycSgmY3J0Yy0+ZGV2LT5ldmVudF9sb2NrKTsKPiArCX0KPiArfQo+ICsK PiAraW50IHR2ZTIwMF9lbmFibGVfdmJsYW5rKHN0cnVjdCBkcm1fZGV2aWNlICpkcm0sIHVuc2ln bmVkIGludCBjcnRjKQo+ICt7Cj4gKwlzdHJ1Y3QgdHZlMjAwX2RybV9kZXZfcHJpdmF0ZSAqcHJp diA9IGRybS0+ZGV2X3ByaXZhdGU7Cj4gKwo+ICsJd3JpdGVsKFRWRTIwMF9JTlRfVl9TVEFUVVMs IHByaXYtPnJlZ3MgKyBUVkUyMDBfSU5UX0VOKTsKPiArCXJldHVybiAwOwo+ICt9Cj4gKwo+ICt2 b2lkIHR2ZTIwMF9kaXNhYmxlX3ZibGFuayhzdHJ1Y3QgZHJtX2RldmljZSAqZHJtLCB1bnNpZ25l ZCBpbnQgY3J0YykKPiArewo+ICsJc3RydWN0IHR2ZTIwMF9kcm1fZGV2X3ByaXZhdGUgKnByaXYg PSBkcm0tPmRldl9wcml2YXRlOwo+ICsKPiArCXdyaXRlbCgwLCBwcml2LT5yZWdzICsgVFZFMjAw X0lOVF9FTik7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgdHZlMjAwX2Rpc3BsYXlfcHJlcGFyZV9m YihzdHJ1Y3QgZHJtX3NpbXBsZV9kaXNwbGF5X3BpcGUgKnBpcGUsCj4gKwkJCQkgICAgc3RydWN0 IGRybV9wbGFuZV9zdGF0ZSAqcGxhbmVfc3RhdGUpCj4gK3sKPiArCXJldHVybiBkcm1fZmJfY21h X3ByZXBhcmVfZmIoJnBpcGUtPnBsYW5lLCBwbGFuZV9zdGF0ZSk7Cj4gK30KPiArCj4gK2NvbnN0 IHN0cnVjdCBkcm1fc2ltcGxlX2Rpc3BsYXlfcGlwZV9mdW5jcyB0dmUyMDBfZGlzcGxheV9mdW5j cyA9IHsKPiArCS5jaGVjayA9IHR2ZTIwMF9kaXNwbGF5X2NoZWNrLAo+ICsJLmVuYWJsZSA9IHR2 ZTIwMF9kaXNwbGF5X2VuYWJsZSwKPiArCS5kaXNhYmxlID0gdHZlMjAwX2Rpc3BsYXlfZGlzYWJs ZSwKPiArCS51cGRhdGUgPSB0dmUyMDBfZGlzcGxheV91cGRhdGUsCj4gKwkucHJlcGFyZV9mYiA9 IHR2ZTIwMF9kaXNwbGF5X3ByZXBhcmVfZmIsCj4gK307Cj4gKwo+ICtpbnQgdHZlMjAwX2Rpc3Bs YXlfaW5pdChzdHJ1Y3QgZHJtX2RldmljZSAqZHJtKQo+ICt7Cj4gKwlzdHJ1Y3QgdHZlMjAwX2Ry bV9kZXZfcHJpdmF0ZSAqcHJpdiA9IGRybS0+ZGV2X3ByaXZhdGU7Cj4gKwlpbnQgcmV0Owo+ICsJ c3RhdGljIGNvbnN0IHUzMiBmb3JtYXRzW10gPSB7Cj4gKwkJRFJNX0ZPUk1BVF9YUkdCODg4OCwK PiArCQlEUk1fRk9STUFUX1hCR1I4ODg4LAo+ICsJCURSTV9GT1JNQVRfUkdCNTY1LAo+ICsJCURS TV9GT1JNQVRfQkdSNTY1LAo+ICsJCURSTV9GT1JNQVRfWFJHQjE1NTUsCj4gKwkJRFJNX0ZPUk1B VF9YQkdSMTU1NSwKPiArCQkvKgo+ICsJCSAqIFRoZSBjb250cm9sbGVyIGFjdHVhbGx5IHN1cHBv cnRzIGFueSBZQ2JDciBvcmRlcmluZywKPiArCQkgKiBmb3IgcGFja2VkIFlDYkNyLiBUaGlzIGp1 c3QgbGlzdHMgdGhlIG9yZGVyaW5ncyB0aGF0Cj4gKwkJICogRFJNIHN1cHBvcnRzLgo+ICsJCSAq Lwo+ICsJCURSTV9GT1JNQVRfWVVZViwKPiArCQlEUk1fRk9STUFUX1lWWVUsCj4gKwkJRFJNX0ZP Uk1BVF9VWVZZLAo+ICsJCURSTV9GT1JNQVRfVllVWSwKPiArCQkvKiBUaGlzIHVzZXMgdGhyZWUg cGxhbmVzICovCj4gKwkJRFJNX0ZPUk1BVF9ZVVY0MjAsCj4gKwl9Owo+ICsKPiArCXJldCA9IGRy bV9zaW1wbGVfZGlzcGxheV9waXBlX2luaXQoZHJtLCAmcHJpdi0+cGlwZSwKPiArCQkJCQkgICAm dHZlMjAwX2Rpc3BsYXlfZnVuY3MsCj4gKwkJCQkJICAgZm9ybWF0cywgQVJSQVlfU0laRShmb3Jt YXRzKSwKPiArCQkJCQkgICAmcHJpdi0+Y29ubmVjdG9yLmNvbm5lY3Rvcik7Cj4gKwlpZiAocmV0 KQo+ICsJCXJldHVybiByZXQ7Cj4gKwo+ICsJcmV0dXJuIDA7Cj4gK30KPiBkaWZmIC0tZ2l0IGEv ZHJpdmVycy9ncHUvZHJtL3R2ZTIwMC90dmUyMDBfZHJtLmggYi9kcml2ZXJzL2dwdS9kcm0vdHZl MjAwL3R2ZTIwMF9kcm0uaAo+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4gaW5kZXggMDAwMDAwMDAw MDAwLi5mMDBmYzQ3YTZiZDEKPiAtLS0gL2Rldi9udWxsCj4gKysrIGIvZHJpdmVycy9ncHUvZHJt L3R2ZTIwMC90dmUyMDBfZHJtLmgKPiBAQCAtMCwwICsxLDEyOSBAQAo+ICsvKgo+ICsgKiBDb3B5 cmlnaHQgKEMpIDIwMTcgTGludXMgV2FsbGVpaiA8bGludXMud2FsbGVpakBsaW5hcm8ub3JnPgo+ ICsgKiBQYXJ0cyBvZiB0aGlzIGZpbGUgd2VyZSBiYXNlZCBvbiBzb3VyY2VzIGFzIGZvbGxvd3M6 Cj4gKyAqCj4gKyAqIENvcHlyaWdodCAoQykgMjAwNi0yMDA4IEludGVsIENvcnBvcmF0aW9uCj4g KyAqIENvcHlyaWdodCAoQykgMjAwNyBBbW9zIExlZSA8YW1vc19sZWVAc3RvcmxpbmtzZW1pLmNv bT4KPiArICogQ29weXJpZ2h0IChDKSAyMDA3IERhdmUgQWlybGllIDxhaXJsaWVkQGxpbnV4Lmll Pgo+ICsgKiBDb3B5cmlnaHQgKEMpIDIwMTEgVGV4YXMgSW5zdHJ1bWVudHMKPiArICogQ29weXJp Z2h0IChDKSAyMDE3IEVyaWMgQW5ob2x0Cj4gKyAqCj4gKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVl IHNvZnR3YXJlIGFuZCBpcyBwcm92aWRlZCB0byB5b3UgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZQo+ ICsgKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMgcHVibGlzaGVkIGJ5 IHRoZSBGcmVlIFNvZnR3YXJlCj4gKyAqIEZvdW5kYXRpb24sIGFuZCBhbnkgdXNlIGJ5IHlvdSBv ZiB0aGlzIHByb2dyYW0gaXMgc3ViamVjdCB0byB0aGUgdGVybXMgb2YKPiArICogc3VjaCBHTlUg bGljZW5jZS4KPiArICovCj4gKwo+ICsjaWZuZGVmIF9UVkUyMDBfRFJNX0hfCj4gKyNkZWZpbmUg X1RWRTIwMF9EUk1fSF8KPiArCj4gKy8qIEJpdHMgMi0zMSBhcmUgdmFsaWQgcGh5c2ljYWwgYmFz ZSBhZGRyZXNzZXMgKi8KPiArI2RlZmluZSBUVkUyMDBfWV9GUkFNRV9CQVNFX0FERFIJMHgwMAo+ ICsjZGVmaW5lIFRWRTIwMF9VX0ZSQU1FX0JBU0VfQUREUgkweDA0Cj4gKyNkZWZpbmUgVFZFMjAw X1ZfRlJBTUVfQkFTRV9BRERSCTB4MDgKPiArCj4gKyNkZWZpbmUgVFZFMjAwX0lOVF9FTgkJCTB4 MEMKPiArI2RlZmluZSBUVkUyMDBfSU5UX0NMUgkJCTB4MTAKPiArI2RlZmluZSBUVkUyMDBfSU5U X1NUQVQJCQkweDE0Cj4gKyNkZWZpbmUgVFZFMjAwX0lOVF9CVVNfRVJSCQlCSVQoNykKPiArI2Rl ZmluZSBUVkUyMDBfSU5UX1ZfU1RBVFVTCQlCSVQoNikgLyogdmVydGljYWwgYmxhbmsgKi8KPiAr I2RlZmluZSBUVkUyMDBfSU5UX1ZfTkVYVF9GUkFNRQkJQklUKDUpCj4gKyNkZWZpbmUgVFZFMjAw X0lOVF9VX05FWFRfRlJBTUUJCUJJVCg0KQo+ICsjZGVmaW5lIFRWRTIwMF9JTlRfWV9ORVhUX0ZS QU1FCQlCSVQoMykKPiArI2RlZmluZSBUVkUyMDBfSU5UX1ZfRklGT19VTkRFUlJVTglCSVQoMikK PiArI2RlZmluZSBUVkUyMDBfSU5UX1VfRklGT19VTkRFUlJVTglCSVQoMSkKPiArI2RlZmluZSBU VkUyMDBfSU5UX1lfRklGT19VTkRFUlJVTglCSVQoMCkKPiArI2RlZmluZSBUVkUyMDBfRklGT19V TkRFUlJVTlMJCShUVkUyMDBfSU5UX1ZfRklGT19VTkRFUlJVTiB8IFwKPiArCQkJCQkgVFZFMjAw X0lOVF9VX0ZJRk9fVU5ERVJSVU4gfCBcCj4gKwkJCQkJIFRWRTIwMF9JTlRfWV9GSUZPX1VOREVS UlVOKQo+ICsKPiArI2RlZmluZSBUVkUyMDBfQ1RSTAkJCTB4MTgKPiArI2RlZmluZSBUVkUyMDBf Q1RSTF9ZVVY0MjAJCUJJVCgzMSkKPiArI2RlZmluZSBUVkUyMDBfQ1RSTF9DU01PREUJCUJJVCgz MCkKPiArI2RlZmluZSBUVkUyMDBfQ1RSTF9OT05JTlRFUkxBQ0UJQklUKDI4KSAvKiAwID0gbm9u LWludGVybGFjZSBDQ0lSNjU2ICovCj4gKyNkZWZpbmUgVFZFMjAwX0NUUkxfVFZDTEtQCQlCSVQo MjcpIC8qIEludmVydGVkIGNsb2NrIHBoYXNlICovCj4gKy8qIEJpdHMgMjQuLjI2IGRlZmluZSB0 aGUgYnVyc3Qgc2l6ZSBhZnRlciBhcmJpdHJhdGlvbiBvbiB0aGUgYnVzICovCj4gKyNkZWZpbmUg VFZFMjAwX0NUUkxfQlVSU1RfNF9XT1JEUwkoMCA8PCAyNCkKPiArI2RlZmluZSBUVkUyMDBfQ1RS TF9CVVJTVF84X1dPUkRTCSgxIDw8IDI0KQo+ICsjZGVmaW5lIFRWRTIwMF9DVFJMX0JVUlNUXzE2 X1dPUkRTCSgyIDw8IDI0KQo+ICsjZGVmaW5lIFRWRTIwMF9DVFJMX0JVUlNUXzMyX1dPUkRTCSgz IDw8IDI0KQo+ICsjZGVmaW5lIFRWRTIwMF9DVFJMX0JVUlNUXzY0X1dPUkRTCSg0IDw8IDI0KQo+ ICsjZGVmaW5lIFRWRTIwMF9DVFJMX0JVUlNUXzEyOF9XT1JEUwkoNSA8PCAyNCkKPiArI2RlZmlu ZSBUVkUyMDBfQ1RSTF9CVVJTVF8yNTZfV09SRFMJKDYgPDwgMjQpCj4gKyNkZWZpbmUgVFZFMjAw X0NUUkxfQlVSU1RfMF9XT1JEUwkoNyA8PCAyNCkgLyogPyAqLwo+ICsvKgo+ICsgKiBCaXRzIDE2 Li4yMyBpcyB0aGUgcmV0cnkgY291bnQqMTYgYmVmb3JlIGlzc3VlaW5nIGEgbmV3IEFIQiB0cmFu c2Zlcgo+ICsgKiBvbiB0aGUgQUhCIGJ1cy4KPiArICovCj4gKyNkZWZpbmUgVFZFMjAwX0NUUkxf UkVUUllDTlRfTUFTSwlHRU5NQVNLKDIzLCAxNikKPiArI2RlZmluZSBUVkUyMDBfQ1RSTF9SRVRS WUNOVF8xNgkJKDEgPDwgMTYpCj4gKyNkZWZpbmUgVFZFMjAwX0NUUkxfQkJCUAkJQklUKDE1KSAv KiAwID0gbGl0dGxlLWVuZGlhbiAqLwo+ICsvKiBCaXRzIDEyLi4xNCBkZWZpbmUgdGhlIFlDYkNy IG9yZGVyaW5nICovCj4gKyNkZWZpbmUgVFZFMjAwX0NUUkxfWUNCQ1JPRFJfQ0IwWTBDUjBZMQko MCA8PCAxMikKPiArI2RlZmluZSBUVkUyMDBfQ1RSTF9ZQ0JDUk9EUl9ZMENCMFkxQ1IwCSgxIDw8 IDEyKQo+ICsjZGVmaW5lIFRWRTIwMF9DVFJMX1lDQkNST0RSX0NSMFkwQ0IwWTEJKDIgPDwgMTIp Cj4gKyNkZWZpbmUgVFZFMjAwX0NUUkxfWUNCQ1JPRFJfWTFDQjBZMENSMAkoMyA8PCAxMikKPiAr I2RlZmluZSBUVkUyMDBfQ1RSTF9ZQ0JDUk9EUl9DUjBZMUNCMFkwCSg0IDw8IDEyKQo+ICsjZGVm aW5lIFRWRTIwMF9DVFJMX1lDQkNST0RSX1kxQ1IwWTBDQjAJKDUgPDwgMTIpCj4gKyNkZWZpbmUg VFZFMjAwX0NUUkxfWUNCQ1JPRFJfQ0IwWTFDUjBZMAkoNiA8PCAxMikKPiArI2RlZmluZSBUVkUy MDBfQ1RSTF9ZQ0JDUk9EUl9ZMENSMFkxQ0IwCSg3IDw8IDEyKQo+ICsvKiBCaXRzIDEwLi4xMSBk ZWZpbmUgdGhlIGlucHV0IHJlc29sdXRpb24gKGZyYW1lYnVmZmVyIHNpemUpICovCj4gKyNkZWZp bmUgVFZFMjAwX0NUUkxfSVBSRVNPTF9DSUYJCSgwIDw8IDEwKQo+ICsjZGVmaW5lIFRWRTIwMF9D VFJMX0lQUkVTT0xfVkdBCQkoMSA8PCAxMCkKPiArI2RlZmluZSBUVkUyMDBfQ1RSTF9JUFJFU09M X0QxCQkoMiA8PCAxMCkKPiArI2RlZmluZSBUVkUyMDBfQ1RSTF9OVFNDCQlCSVQoOSkgLyogMCA9 IFBBTCwgMSA9IE5UU0MgKi8KPiArI2RlZmluZSBUVkUyMDBfQ1RSTF9JTlRFUkxBQ0UJCUJJVCg4 KSAvKiAxID0gaW50ZXJsYWNlLCBvbmx5IGZvciBEMSAqLwo+ICsjZGVmaW5lIFRWRTIwMF9JUERN T0RfUkdCNTU1CQkoMCA8PCA2KSAvKiBUVkUyMDBfQ1RSTF9ZVVY0MjAgPSAwICovCj4gKyNkZWZp bmUgVFZFMjAwX0lQRE1PRF9SR0I1NjUJCSgxIDw8IDYpCj4gKyNkZWZpbmUgVFZFMjAwX0lQRE1P RF9SR0I4ODgJCSgyIDw8IDYpCj4gKyNkZWZpbmUgVFZFMjAwX0lQRE1PRF9ZVVY0MjAJCSgyIDw8 IDYpIC8qIFRWRTIwMF9DVFJMX1lVVjQyMCA9IDEgKi8KPiArI2RlZmluZSBUVkUyMDBfSVBETU9E X1lVVjQyMgkJKDMgPDwgNikKPiArLyogQml0cyA0ICYgNSBkZWZpbmUgd2hlbiB0byBmaXJlIHRo ZSB2YmxhbmsgSVJRICovCj4gKyNkZWZpbmUgVFZFMjAwX1ZTVFNUWVBFX1ZTWU5DCQkoMCA8PCA0 KSAvKiBzdGFydCBvZiB2c3luYyAqLwo+ICsjZGVmaW5lIFRWRTIwMF9WU1RTVFlQRV9WQlAJCSgx IDw8IDQpIC8qIHN0YXJ0IG9mIHYgYmFjayBwb3JjaCAqLwo+ICsjZGVmaW5lIFRWRTIwMF9WU1RT VFlQRV9WQUkJCSgyIDw8IDQpIC8qIHN0YXJ0IG9mIHYgYWN0aXZlIGltYWdlICovCj4gKyNkZWZp bmUgVFZFMjAwX1ZTVFNUWVBFX1ZGUAkJKDMgPDwgNCkgLyogc3RhcnQgb2YgdiBmcm9udCBwb3Jj aCAqLwo+ICsjZGVmaW5lIFRWRTIwMF9WU1RTVFlQRV9CSVRTCQkoQklUKDQpIHwgQklUKDUpKQo+ ICsjZGVmaW5lIFRWRTIwMF9CR1IJCQlCSVQoMSkgLyogMCA9IFJHQiwgMSA9IEJHUiAqLwo+ICsj ZGVmaW5lIFRWRTIwMF9UVkVFTgkJCUJJVCgwKSAvKiBFbmFibGUgVFZFIGJsb2NrICovCj4gKwo+ ICsjZGVmaW5lIFRWRTIwMF9DVFJMXzIJCQkweDFjCj4gKyNkZWZpbmUgVFZFMjAwX0NUUkxfMwkJ CTB4MjAKPiArCj4gKyNkZWZpbmUgVFZFMjAwX0NUUkxfNAkJCTB4MjQKPiArI2RlZmluZSBUVkUy MDBfQ1RSTF80X1JFU0VUCQlCSVQoMCkgLyogdHJpZ2dlcnMgcmVzZXQgb2YgVFZFMjAwICovCj4g Kwo+ICsjaW5jbHVkZSA8ZHJtL2RybV9nZW0uaD4KPiArI2luY2x1ZGUgPGRybS9kcm1fc2ltcGxl X2ttc19oZWxwZXIuaD4KPiArCj4gK3N0cnVjdCB0dmUyMDBfZHJtX2Nvbm5lY3RvciB7Cj4gKwlz dHJ1Y3QgZHJtX2Nvbm5lY3RvciBjb25uZWN0b3I7Cj4gKwlzdHJ1Y3QgZHJtX3BhbmVsICpwYW5l bDsKPiArfTsKPiArCj4gK3N0cnVjdCB0dmUyMDBfZHJtX2Rldl9wcml2YXRlIHsKPiArCXN0cnVj dCBkcm1fZGV2aWNlICpkcm07Cj4gKwo+ICsJc3RydWN0IHR2ZTIwMF9kcm1fY29ubmVjdG9yIGNv bm5lY3RvcjsKPiArCXN0cnVjdCBkcm1fc2ltcGxlX2Rpc3BsYXlfcGlwZSBwaXBlOwo+ICsJc3Ry dWN0IGRybV9mYmRldl9jbWEgKmZiZGV2Owo+ICsKPiArCXZvaWQgKnJlZ3M7Cj4gKwlzdHJ1Y3Qg Y2xrICpwY2xrOwo+ICsJc3RydWN0IGNsayAqY2xrOwo+ICt9Owo+ICsKPiArI2RlZmluZSB0b190 dmUyMDBfY29ubmVjdG9yKHgpIFwKPiArCWNvbnRhaW5lcl9vZih4LCBzdHJ1Y3QgdHZlMjAwX2Ry bV9jb25uZWN0b3IsIGNvbm5lY3RvcikKPiArCj4gK2ludCB0dmUyMDBfZGlzcGxheV9pbml0KHN0 cnVjdCBkcm1fZGV2aWNlICpkZXYpOwo+ICtpbnQgdHZlMjAwX2VuYWJsZV92Ymxhbmsoc3RydWN0 IGRybV9kZXZpY2UgKmRybSwgdW5zaWduZWQgaW50IGNydGMpOwo+ICt2b2lkIHR2ZTIwMF9kaXNh YmxlX3ZibGFuayhzdHJ1Y3QgZHJtX2RldmljZSAqZHJtLCB1bnNpZ25lZCBpbnQgY3J0Yyk7Cj4g K2lycXJldHVybl90IHR2ZTIwMF9pcnEoaW50IGlycSwgdm9pZCAqZGF0YSk7Cj4gK2ludCB0dmUy MDBfY29ubmVjdG9yX2luaXQoc3RydWN0IGRybV9kZXZpY2UgKmRldik7Cj4gK2ludCB0dmUyMDBf ZW5jb2Rlcl9pbml0KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYpOwo+ICtpbnQgdHZlMjAwX2R1bWJf Y3JlYXRlKHN0cnVjdCBkcm1fZmlsZSAqZmlsZV9wcml2LAo+ICsJCSAgICAgIHN0cnVjdCBkcm1f ZGV2aWNlICpkZXYsCj4gKwkJICAgICAgc3RydWN0IGRybV9tb2RlX2NyZWF0ZV9kdW1iICphcmdz KTsKPiArCj4gKyNlbmRpZiAvKiBfVFZFMjAwX0RSTV9IXyAqLwo+IGRpZmYgLS1naXQgYS9kcml2 ZXJzL2dwdS9kcm0vdHZlMjAwL3R2ZTIwMF9kcnYuYyBiL2RyaXZlcnMvZ3B1L2RybS90dmUyMDAv dHZlMjAwX2Rydi5jCj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPiBpbmRleCAwMDAwMDAwMDAwMDAu LjllMzQxNDdlMjYxNwo+IC0tLSAvZGV2L251bGwKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vdHZl MjAwL3R2ZTIwMF9kcnYuYwo+IEBAIC0wLDAgKzEsMjc3IEBACj4gKy8qCj4gKyAqIENvcHlyaWdo dCAoQykgMjAxNyBMaW51cyBXYWxsZWlqIDxsaW51cy53YWxsZWlqQGxpbmFyby5vcmc+Cj4gKyAq IFBhcnRzIG9mIHRoaXMgZmlsZSB3ZXJlIGJhc2VkIG9uIHNvdXJjZXMgYXMgZm9sbG93czoKPiAr ICoKPiArICogQ29weXJpZ2h0IChDKSAyMDA2LTIwMDggSW50ZWwgQ29ycG9yYXRpb24KPiArICog Q29weXJpZ2h0IChDKSAyMDA3IEFtb3MgTGVlIDxhbW9zX2xlZUBzdG9ybGlua3NlbWkuY29tPgo+ ICsgKiBDb3B5cmlnaHQgKEMpIDIwMDcgRGF2ZSBBaXJsaWUgPGFpcmxpZWRAbGludXguaWU+Cj4g KyAqIENvcHlyaWdodCAoQykgMjAxMSBUZXhhcyBJbnN0cnVtZW50cwo+ICsgKiBDb3B5cmlnaHQg KEMpIDIwMTcgRXJpYyBBbmhvbHQKPiArICoKPiArICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29m dHdhcmUgYW5kIGlzIHByb3ZpZGVkIHRvIHlvdSB1bmRlciB0aGUgdGVybXMgb2YgdGhlCj4gKyAq IEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcyBwdWJsaXNoZWQgYnkgdGhl IEZyZWUgU29mdHdhcmUKPiArICogRm91bmRhdGlvbiwgYW5kIGFueSB1c2UgYnkgeW91IG9mIHRo aXMgcHJvZ3JhbSBpcyBzdWJqZWN0IHRvIHRoZSB0ZXJtcyBvZgo+ICsgKiBzdWNoIEdOVSBsaWNl bmNlLgo+ICsgKi8KPiArCj4gKy8qKgo+ICsgKiBET0M6IEZhcmFkYXkgVFYgRW5jb2RlciBUVkUy MDAgRFJNIERyaXZlcgo+ICsgKgo+ICsgKiBUaGUgRmFyYWRheSBUViBFbmNvZGVyIFRWRTIwMCBp cyBhbHNvIGtub3duIGFzIHRoZSBHZW1pbmkgVFYgSW50ZXJmYWNlCj4gKyAqIENvbnRyb2xsZXIg KFRWQykgYW5kIGlzIGZvdW5kIGluIHRoZSBHZW1pbmkgQ2hpcHNldCBmcm9tIFN0b3JsaW5rCj4g KyAqIFNlbWljb25kdWN0b3IgKGxhdGVyIFN0b3JtIFNlbWljb25kdWN0b3IsIGxhdGVyIENvcnRp bmEgU3lzdGVtcykKPiArICogYnV0IGFsc28gaW4gdGhlIEdyYWluIE1lZGlhIEdNODE4MCBjaGlw c2V0LiBPbiB0aGUgR2VtaW5pIHRoZSBtb2R1bGUKPiArICogaXMgY29ubmVjdGVkIHRvIDggZGF0 YSBsaW5lcyBhbmQgYSBzaW5nbGUgY2xvY2sgbGluZSwgY29tcHJpc2luZyBhbgo+ICsgKiA4LWJp dCBCVC42NTYgaW50ZXJmYWNlLgo+ICsgKgo+ICsgKiBUaGlzIGlzIGEgdmVyeSBiYXNpYyBZVVYg ZGlzcGxheSBkcml2ZXIuIFRoZSBkYXRhc2hlZXQgc3BlY2lmaWVzIHRoYXQKPiArICogaXQgc3Vw cG9ydHMgdGhlIElUVSBCVC42NTYgc3RhbmRhcmQuIEl0IHJlcXVpcmVzIGEgMjcgTUh6IGNsb2Nr IHdoaWNoIGlzCj4gKyAqIHRoZSBoYWxsbWFyayBvZiBhbnkgVFYgZW5jb2RlciBzdXBwb3J0aW5n IGJvdGggUEFMIGFuZCBOVFNDLgo+ICsgKgo+ICsgKiBUaGlzIGRyaXZlciBleHBvc2VzIGEgc3Rh bmRhcmQgS01TIGludGVyZmFjZSBmb3IgdGhpcyBUViBlbmNvZGVyLgo+ICsgKi8KPiArCj4gKyNp bmNsdWRlIDxsaW51eC9jbGsuaD4KPiArI2luY2x1ZGUgPGxpbnV4L2RtYS1idWYuaD4KPiArI2lu Y2x1ZGUgPGxpbnV4L2lycS5oPgo+ICsjaW5jbHVkZSA8bGludXgvaW8uaD4KPiArI2luY2x1ZGUg PGxpbnV4L21vZHVsZS5oPgo+ICsjaW5jbHVkZSA8bGludXgvcGxhdGZvcm1fZGV2aWNlLmg+Cj4g KyNpbmNsdWRlIDxsaW51eC9zaG1lbV9mcy5oPgo+ICsjaW5jbHVkZSA8bGludXgvc2xhYi5oPgo+ ICsjaW5jbHVkZSA8bGludXgvdmVyc2lvbi5oPgo+ICsKPiArI2luY2x1ZGUgPGRybS9kcm1QLmg+ Cj4gKyNpbmNsdWRlIDxkcm0vZHJtX2F0b21pY19oZWxwZXIuaD4KPiArI2luY2x1ZGUgPGRybS9k cm1fY3J0Y19oZWxwZXIuaD4KPiArI2luY2x1ZGUgPGRybS9kcm1fZ2VtX2NtYV9oZWxwZXIuaD4K PiArI2luY2x1ZGUgPGRybS9kcm1fZmJfY21hX2hlbHBlci5oPgo+ICsjaW5jbHVkZSA8ZHJtL2Ry bV9wYW5lbC5oPgo+ICsKPiArI2luY2x1ZGUgInR2ZTIwMF9kcm0uaCIKPiArCj4gKyNkZWZpbmUg RFJJVkVSX0RFU0MgICAgICAiRFJNIG1vZHVsZSBmb3IgRmFyYWRheSBUVkUyMDAiCj4gKwo+ICtz dHJ1Y3QgZHJtX21vZGVfY29uZmlnX2Z1bmNzIG1vZGVfY29uZmlnX2Z1bmNzID0gewo+ICsJLmZi X2NyZWF0ZSA9IGRybV9mYl9jbWFfY3JlYXRlLAo+ICsJLmF0b21pY19jaGVjayA9IGRybV9hdG9t aWNfaGVscGVyX2NoZWNrLAo+ICsJLmF0b21pY19jb21taXQgPSBkcm1fYXRvbWljX2hlbHBlcl9j b21taXQsCj4gK307Cj4gKwo+ICtzdGF0aWMgaW50IHR2ZTIwMF9tb2Rlc2V0X2luaXQoc3RydWN0 IGRybV9kZXZpY2UgKmRldikKPiArewo+ICsJc3RydWN0IGRybV9tb2RlX2NvbmZpZyAqbW9kZV9j b25maWc7Cj4gKwlzdHJ1Y3QgdHZlMjAwX2RybV9kZXZfcHJpdmF0ZSAqcHJpdiA9IGRldi0+ZGV2 X3ByaXZhdGU7Cj4gKwlpbnQgcmV0ID0gMDsKPiArCj4gKwlkcm1fbW9kZV9jb25maWdfaW5pdChk ZXYpOwo+ICsJbW9kZV9jb25maWcgPSAmZGV2LT5tb2RlX2NvbmZpZzsKPiArCW1vZGVfY29uZmln LT5mdW5jcyA9ICZtb2RlX2NvbmZpZ19mdW5jczsKPiArCW1vZGVfY29uZmlnLT5taW5fd2lkdGgg PSAzNTI7Cj4gKwltb2RlX2NvbmZpZy0+bWF4X3dpZHRoID0gNzIwOwo+ICsJbW9kZV9jb25maWct Pm1pbl9oZWlnaHQgPSAyNDA7Cj4gKwltb2RlX2NvbmZpZy0+bWF4X2hlaWdodCA9IDU3NjsKPiAr Cj4gKwlyZXQgPSB0dmUyMDBfY29ubmVjdG9yX2luaXQoZGV2KTsKPiArCWlmIChyZXQpIHsKPiAr CQlkZXZfZXJyKGRldi0+ZGV2LCAiRmFpbGVkIHRvIGNyZWF0ZSB0dmUyMDBfZHJtX2Nvbm5lY3Rv clxuIik7Cj4gKwkJZ290byBvdXRfY29uZmlnOwo+ICsJfQo+ICsKPiArCS8qCj4gKwkgKiBEb24n dCBhY3R1YWxseSBhdHRhY2ggaWYgd2UgZGlkbid0IGZpbmQgYSBkcm1fcGFuZWwKPiArCSAqIGF0 dGFjaGVkIHRvIHVzLgo+ICsJICovCj4gKwlpZiAoIXByaXYtPmNvbm5lY3Rvci5wYW5lbCkgewo+ ICsJCWRldl9pbmZvKGRldi0+ZGV2LAo+ICsJCQkgImRlZmVycmluZyBkdWUgdG8gbGFjayBvZiBE Uk0gcGFuZWwgZGV2aWNlXG4iKTsKPiArCQlyZXQgPSAtRVBST0JFX0RFRkVSOwo+ICsJCWdvdG8g b3V0X2NvbmZpZzsKPiArCX0KPiArCWRldl9pbmZvKGRldi0+ZGV2LCAiYXR0YWNoZWQgdG8gcGFu ZWwgJXNcbiIsCj4gKwkJIGRldl9uYW1lKHByaXYtPmNvbm5lY3Rvci5wYW5lbC0+ZGV2KSk7Cj4g Kwo+ICsJcmV0ID0gdHZlMjAwX2Rpc3BsYXlfaW5pdChkZXYpOwo+ICsJaWYgKHJldCkgewo+ICsJ CWRldl9lcnIoZGV2LT5kZXYsICJmYWlsZWQgdG8gaW5pdCBkaXNwbGF5XG4iKTsKPiArCQlnb3Rv IG91dF9jb25maWc7Cj4gKwl9Cj4gKwo+ICsJcmV0ID0gZHJtX3ZibGFua19pbml0KGRldiwgMSk7 Cj4gKwlpZiAocmV0KSB7Cj4gKwkJZGV2X2VycihkZXYtPmRldiwgImZhaWxlZCB0byBpbml0IHZi bGFua1xuIik7Cj4gKwkJZ290byBvdXRfY29uZmlnOwo+ICsJfQo+ICsKPiArCWRybV9tb2RlX2Nv bmZpZ19yZXNldChkZXYpOwo+ICsKPiArCS8qCj4gKwkgKiBQYXNzaW5nIGluIDE2IGhlcmUgd2ls bCBtYWtlIHRoZSBSR0I2NTYgbW9kZSB0aGUgZGVmYXVsdAo+ICsJICogUGFzc2luZyBpbiAzMiB3 aWxsIHVzZSBYUkdCODg4OCBtb2RlCj4gKwkgKi8KPiArCXByaXYtPmZiZGV2ID0gZHJtX2ZiZGV2 X2NtYV9pbml0KGRldiwgMTYsCj4gKwkJCQkJIGRldi0+bW9kZV9jb25maWcubnVtX2Nvbm5lY3Rv cik7Cj4gKwlkcm1fa21zX2hlbHBlcl9wb2xsX2luaXQoZGV2KTsKPiArCj4gKwlnb3RvIGZpbmlz aDsKPiArCj4gK291dF9jb25maWc6Cj4gKwlkcm1fbW9kZV9jb25maWdfY2xlYW51cChkZXYpOwo+ ICtmaW5pc2g6Cj4gKwlyZXR1cm4gcmV0Owo+ICt9Cj4gKwo+ICtERUZJTkVfRFJNX0dFTV9DTUFf Rk9QUyhkcm1fZm9wcyk7Cj4gKwo+ICtzdGF0aWMgdm9pZCB0dmUyMDBfbGFzdGNsb3NlKHN0cnVj dCBkcm1fZGV2aWNlICpkZXYpCj4gK3sKPiArCXN0cnVjdCB0dmUyMDBfZHJtX2Rldl9wcml2YXRl ICpwcml2ID0gZGV2LT5kZXZfcHJpdmF0ZTsKPiArCj4gKwlkcm1fZmJkZXZfY21hX3Jlc3RvcmVf bW9kZShwcml2LT5mYmRldik7Cj4gK30KPiArCj4gK3N0YXRpYyBzdHJ1Y3QgZHJtX2RyaXZlciB0 dmUyMDBfZHJtX2RyaXZlciA9IHsKPiArCS5kcml2ZXJfZmVhdHVyZXMgPQo+ICsJCURSSVZFUl9N T0RFU0VUIHwgRFJJVkVSX0dFTSB8IERSSVZFUl9QUklNRSB8IERSSVZFUl9BVE9NSUMsCj4gKwku bGFzdGNsb3NlID0gdHZlMjAwX2xhc3RjbG9zZSwKPiArCS5pb2N0bHMgPSBOVUxMLAo+ICsJLmZv cHMgPSAmZHJtX2ZvcHMsCj4gKwkubmFtZSA9ICJ0dmUyMDAiLAo+ICsJLmRlc2MgPSBEUklWRVJf REVTQywKPiArCS5kYXRlID0gIjIwMTcwNzAzIiwKPiArCS5tYWpvciA9IDEsCj4gKwkubWlub3Ig PSAwLAo+ICsJLnBhdGNobGV2ZWwgPSAwLAo+ICsJLmR1bWJfY3JlYXRlID0gZHJtX2dlbV9jbWFf ZHVtYl9jcmVhdGUsCj4gKwkuZHVtYl9kZXN0cm95ID0gZHJtX2dlbV9kdW1iX2Rlc3Ryb3ksCj4g KwkuZHVtYl9tYXBfb2Zmc2V0ID0gZHJtX2dlbV9jbWFfZHVtYl9tYXBfb2Zmc2V0LAo+ICsJLmdl bV9mcmVlX29iamVjdCA9IGRybV9nZW1fY21hX2ZyZWVfb2JqZWN0LAo+ICsJLmdlbV92bV9vcHMg PSAmZHJtX2dlbV9jbWFfdm1fb3BzLAo+ICsKPiArCS5lbmFibGVfdmJsYW5rID0gdHZlMjAwX2Vu YWJsZV92YmxhbmssCj4gKwkuZGlzYWJsZV92YmxhbmsgPSB0dmUyMDBfZGlzYWJsZV92Ymxhbmss Cj4gKwo+ICsJLnByaW1lX2hhbmRsZV90b19mZCA9IGRybV9nZW1fcHJpbWVfaGFuZGxlX3RvX2Zk LAo+ICsJLnByaW1lX2ZkX3RvX2hhbmRsZSA9IGRybV9nZW1fcHJpbWVfZmRfdG9faGFuZGxlLAo+ ICsJLmdlbV9wcmltZV9pbXBvcnQgPSBkcm1fZ2VtX3ByaW1lX2ltcG9ydCwKPiArCS5nZW1fcHJp bWVfaW1wb3J0X3NnX3RhYmxlID0gZHJtX2dlbV9jbWFfcHJpbWVfaW1wb3J0X3NnX3RhYmxlLAo+ ICsJLmdlbV9wcmltZV9leHBvcnQgPSBkcm1fZ2VtX3ByaW1lX2V4cG9ydCwKPiArCS5nZW1fcHJp bWVfZ2V0X3NnX3RhYmxlCT0gZHJtX2dlbV9jbWFfcHJpbWVfZ2V0X3NnX3RhYmxlLAo+ICt9Owo+ ICsKPiArc3RhdGljIGludCB0dmUyMDBfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRl dikKPiArewo+ICsJc3RydWN0IGRldmljZSAqZGV2ID0gJnBkZXYtPmRldjsKPiArCXN0cnVjdCB0 dmUyMDBfZHJtX2Rldl9wcml2YXRlICpwcml2Owo+ICsJc3RydWN0IGRybV9kZXZpY2UgKmRybTsK PiArCXN0cnVjdCByZXNvdXJjZSAqcmVzOwo+ICsJaW50IGlycTsKPiArCWludCByZXQ7Cj4gKwo+ ICsJcHJpdiA9IGRldm1fa3phbGxvYyhkZXYsIHNpemVvZigqcHJpdiksIEdGUF9LRVJORUwpOwo+ ICsJaWYgKCFwcml2KQo+ICsJCXJldHVybiAtRU5PTUVNOwo+ICsKPiArCWRybSA9IGRybV9kZXZf YWxsb2MoJnR2ZTIwMF9kcm1fZHJpdmVyLCBkZXYpOwo+ICsJaWYgKElTX0VSUihkcm0pKQo+ICsJ CXJldHVybiBQVFJfRVJSKGRybSk7Cj4gKwlwbGF0Zm9ybV9zZXRfZHJ2ZGF0YShwZGV2LCBkcm0p Owo+ICsJcHJpdi0+ZHJtID0gZHJtOwo+ICsJZHJtLT5kZXZfcHJpdmF0ZSA9IHByaXY7Cj4gKwo+ ICsJLyogQ2xvY2sgdGhlIHNpbGljb24gc28gd2UgY2FuIGFjY2VzcyB0aGUgcmVnaXN0ZXJzICov Cj4gKwlwcml2LT5wY2xrID0gZGV2bV9jbGtfZ2V0KGRldiwgIlBDTEsiKTsKPiArCWlmIChJU19F UlIocHJpdi0+cGNsaykpIHsKPiArCQlkZXZfZXJyKGRldiwgInVuYWJsZSB0byBnZXQgUENMS1xu Iik7Cj4gKwkJcmV0ID0gUFRSX0VSUihwcml2LT5wY2xrKTsKPiArCQlnb3RvIGRldl91bnJlZjsK PiArCX0KPiArCXJldCA9IGNsa19wcmVwYXJlX2VuYWJsZShwcml2LT5wY2xrKTsKPiArCWlmIChy ZXQpIHsKPiArCQlkZXZfZXJyKGRldiwgImZhaWxlZCB0byBlbmFibGUgUENMS1xuIik7Cj4gKwkJ Z290byBkZXZfdW5yZWY7Cj4gKwl9Cj4gKwo+ICsJLyogVGhpcyBjbG9jayBpcyBmb3IgdGhlIHBp eGVscyAoMjdNSHopICovCj4gKwlwcml2LT5jbGsgPSBkZXZtX2Nsa19nZXQoZGV2LCAiVFZFIik7 Cj4gKwlpZiAoSVNfRVJSKHByaXYtPmNsaykpIHsKPiArCQlkZXZfZXJyKGRldiwgInVuYWJsZSB0 byBnZXQgVFZFIGNsb2NrXG4iKTsKPiArCQlyZXQgPSBQVFJfRVJSKHByaXYtPmNsayk7Cj4gKwkJ Z290byBjbGtfZGlzYWJsZTsKPiArCX0KPiArCj4gKwlyZXMgPSBwbGF0Zm9ybV9nZXRfcmVzb3Vy Y2UocGRldiwgSU9SRVNPVVJDRV9NRU0sIDApOwo+ICsJcHJpdi0+cmVncyA9IGRldm1faW9yZW1h cF9yZXNvdXJjZShkZXYsIHJlcyk7Cj4gKwlpZiAoIXByaXYtPnJlZ3MpIHsKPiArCQlkZXZfZXJy KGRldiwgIiVzIGZhaWxlZCBtbWlvXG4iLCBfX2Z1bmNfXyk7Cj4gKwkJcmV0ID0gLUVJTlZBTDsK PiArCQlnb3RvIGRldl91bnJlZjsKPiArCX0KPiArCj4gKwlpcnEgPSBwbGF0Zm9ybV9nZXRfaXJx KHBkZXYsIDApOwo+ICsJaWYgKCFpcnEpIHsKPiArCQlyZXQgPSAtRUlOVkFMOwo+ICsJCWdvdG8g ZGV2X3VucmVmOwo+ICsJfQo+ICsKPiArCS8qIHR1cm4gb2ZmIGludGVycnVwdHMgYmVmb3JlIHJl cXVlc3RpbmcgdGhlIGlycSAqLwo+ICsJd3JpdGVsKDAsIHByaXYtPnJlZ3MgKyBUVkUyMDBfSU5U X0VOKTsKPiArCj4gKwlyZXQgPSBkZXZtX3JlcXVlc3RfaXJxKGRldiwgaXJxLCB0dmUyMDBfaXJx LCAwLCAidHZlMjAwIiwgcHJpdik7Cj4gKwlpZiAocmV0KSB7Cj4gKwkJZGV2X2VycihkZXYsICJm YWlsZWQgdG8gcmVxdWVzdCBpcnEgJWRcbiIsIHJldCk7Cj4gKwkJcmV0dXJuIHJldDsKPiArCX0K PiArCj4gKwlyZXQgPSB0dmUyMDBfbW9kZXNldF9pbml0KGRybSk7Cj4gKwlpZiAocmV0KQo+ICsJ CWdvdG8gZGV2X3VucmVmOwo+ICsKPiArCXJldCA9IGRybV9kZXZfcmVnaXN0ZXIoZHJtLCAwKTsK PiArCWlmIChyZXQgPCAwKQo+ICsJCWdvdG8gZGV2X3VucmVmOwo+ICsKPiArCXJldHVybiAwOwo+ ICsKPiArY2xrX2Rpc2FibGU6Cj4gKwljbGtfZGlzYWJsZV91bnByZXBhcmUocHJpdi0+cGNsayk7 Cj4gK2Rldl91bnJlZjoKPiArCWRybV9kZXZfdW5yZWYoZHJtKTsKPiArCXJldHVybiByZXQ7Cj4g K30KPiArCj4gK3N0YXRpYyBpbnQgdHZlMjAwX3JlbW92ZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNl ICpwZGV2KQo+ICt7Cj4gKwlzdHJ1Y3QgZHJtX2RldmljZSAqZHJtID0gcGxhdGZvcm1fZ2V0X2Ry dmRhdGEocGRldik7Cj4gKwlzdHJ1Y3QgdHZlMjAwX2RybV9kZXZfcHJpdmF0ZSAqcHJpdiA9IGRy bS0+ZGV2X3ByaXZhdGU7Cj4gKwo+ICsJZHJtX2Rldl91bnJlZ2lzdGVyKGRybSk7Cj4gKwlpZiAo cHJpdi0+ZmJkZXYpCj4gKwkJZHJtX2ZiZGV2X2NtYV9maW5pKHByaXYtPmZiZGV2KTsKPiArCWRy bV9tb2RlX2NvbmZpZ19jbGVhbnVwKGRybSk7Cj4gKwljbGtfZGlzYWJsZV91bnByZXBhcmUocHJp di0+cGNsayk7Cj4gKwlkcm1fZGV2X3VucmVmKGRybSk7Cj4gKwo+ICsJcmV0dXJuIDA7Cj4gK30K PiArCj4gK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgb2ZfZGV2aWNlX2lkIHR2ZTIwMF9vZl9tYXRjaFtd ID0gewo+ICsJewo+ICsJCS5jb21wYXRpYmxlID0gImZhcmFkYXksdHZlMjAwIiwKPiArCX0sCj4g Kwl7fSwKPiArfTsKPiArCj4gK3N0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZHJpdmVyIHR2ZTIwMF9k cml2ZXIgPSB7Cj4gKwkuZHJpdmVyID0gewo+ICsJCS5uYW1lICAgICAgICAgICA9ICJ0dmUyMDAi LAo+ICsJCS5vZl9tYXRjaF90YWJsZSA9IG9mX21hdGNoX3B0cih0dmUyMDBfb2ZfbWF0Y2gpLAo+ ICsJfSwKPiArCS5wcm9iZSA9IHR2ZTIwMF9wcm9iZSwKPiArCS5yZW1vdmUgPSB0dmUyMDBfcmVt b3ZlLAo+ICt9Owo+ICttb2R1bGVfcGxhdGZvcm1fZHJpdmVyKHR2ZTIwMF9kcml2ZXIpOwo+ICsK PiArTU9EVUxFX0RFU0NSSVBUSU9OKERSSVZFUl9ERVNDKTsKPiArTU9EVUxFX0FVVEhPUigiTGlu dXMgV2FsbGVpaiA8bGludXMud2FsbGVpakBsaW5hcm8ub3JnPiIpOwo+ICtNT0RVTEVfTElDRU5T RSgiR1BMIik7Cj4gLS0gCj4gMi4xMy40Cj4gCj4gX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX18KPiBkcmktZGV2ZWwgbWFpbGluZyBsaXN0Cj4gZHJpLWRldmVs QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwo+IGh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21h aWxtYW4vbGlzdGluZm8vZHJpLWRldmVsCgotLSAKRGFuaWVsIFZldHRlcgpTb2Z0d2FyZSBFbmdp bmVlciwgSW50ZWwgQ29ycG9yYXRpb24KaHR0cDovL2Jsb2cuZmZ3bGwuY2gKX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlz dApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0 b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVsCg==