From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-8.3 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,USER_AGENT_SANE_1 autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 6B240FA372A for ; Wed, 16 Oct 2019 13:45:34 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 2E04421925 for ; Wed, 16 Oct 2019 13:45:34 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=ideasonboard.com header.i=@ideasonboard.com header.b="TozhwmiH" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1729093AbfJPNpd (ORCPT ); Wed, 16 Oct 2019 09:45:33 -0400 Received: from perceval.ideasonboard.com ([213.167.242.64]:38558 "EHLO perceval.ideasonboard.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1728253AbfJPNpd (ORCPT ); Wed, 16 Oct 2019 09:45:33 -0400 Received: from pendragon.ideasonboard.com (dfj612yhrgyx302h3jwwy-3.rev.dnainternet.fi [IPv6:2001:14ba:21f5:5b00:ce28:277f:58d7:3ca4]) by perceval.ideasonboard.com (Postfix) with ESMTPSA id 150D79F4; Wed, 16 Oct 2019 15:45:30 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=ideasonboard.com; s=mail; t=1571233530; bh=vOEzWNYztWnSnMZNv4WpRzClI9hoeVdo3Dii5k/kozs=; h=Date:From:To:Cc:Subject:References:In-Reply-To:From; b=TozhwmiHugn++nNlxAq6c3mHORBK3yd5CRx5PD0sXqDvVu4KedJQ+WnEcuL+enbjv iENuxQ/5UINpgsRMWJAbKKP+edfmft1J+NKgflftmZogXb202HOpTk5KMlqRuuy4wV 6o3jXbihSy7Pxho2AB05LX0aN7cvO0zh1vtKVHpY= Date: Wed, 16 Oct 2019 16:45:26 +0300 From: Laurent Pinchart To: Jacopo Mondi Cc: kieran.bingham+renesas@ideasonboard.com, geert@linux-m68k.org, horms@verge.net.au, uli+renesas@fpond.eu, airlied@linux.ie, daniel@ffwll.ch, linux-renesas-soc@vger.kernel.org, dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org Subject: Re: [PATCH v6 3/8] drm: rcar-du: Add support for CMM Message-ID: <20191016134526.GD5175@pendragon.ideasonboard.com> References: <20191016085548.105703-1-jacopo+renesas@jmondi.org> <20191016085548.105703-4-jacopo+renesas@jmondi.org> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline In-Reply-To: <20191016085548.105703-4-jacopo+renesas@jmondi.org> User-Agent: Mutt/1.10.1 (2018-07-13) Sender: linux-renesas-soc-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-renesas-soc@vger.kernel.org Hi Jacopo, Thank you for the patch. On Wed, Oct 16, 2019 at 10:55:43AM +0200, Jacopo Mondi wrote: > Add a driver for the R-Car Display Unit Color Correction Module. > > In most of Gen3 SoCs, each DU output channel is provided with a CMM unit > to perform image enhancement and color correction. > > Add support for CMM through a driver that supports configuration of > the 1-dimensional LUT table. More advanced CMM features will be > implemented on top of this initial one. > > Reviewed-by: Laurent Pinchart > Reviewed-by: Kieran Bingham > Signed-off-by: Jacopo Mondi > --- > drivers/gpu/drm/rcar-du/Kconfig | 7 + > drivers/gpu/drm/rcar-du/Makefile | 1 + > drivers/gpu/drm/rcar-du/rcar_cmm.c | 212 +++++++++++++++++++++++++++++ > drivers/gpu/drm/rcar-du/rcar_cmm.h | 58 ++++++++ > 4 files changed, 278 insertions(+) > create mode 100644 drivers/gpu/drm/rcar-du/rcar_cmm.c > create mode 100644 drivers/gpu/drm/rcar-du/rcar_cmm.h > > diff --git a/drivers/gpu/drm/rcar-du/Kconfig b/drivers/gpu/drm/rcar-du/Kconfig > index 1529849e217e..539d232790d1 100644 > --- a/drivers/gpu/drm/rcar-du/Kconfig > +++ b/drivers/gpu/drm/rcar-du/Kconfig > @@ -13,6 +13,13 @@ config DRM_RCAR_DU > Choose this option if you have an R-Car chipset. > If M is selected the module will be called rcar-du-drm. > > +config DRM_RCAR_CMM > + bool "R-Car DU Color Management Module (CMM) Support" > + depends on DRM && OF > + depends on DRM_RCAR_DU > + help > + Enable support for R-Car Color Management Module (CMM). > + > config DRM_RCAR_DW_HDMI > tristate "R-Car DU Gen3 HDMI Encoder Support" > depends on DRM && OF > diff --git a/drivers/gpu/drm/rcar-du/Makefile b/drivers/gpu/drm/rcar-du/Makefile > index 6c2ed9c46467..4d1187ccc3e5 100644 > --- a/drivers/gpu/drm/rcar-du/Makefile > +++ b/drivers/gpu/drm/rcar-du/Makefile > @@ -15,6 +15,7 @@ rcar-du-drm-$(CONFIG_DRM_RCAR_LVDS) += rcar_du_of.o \ > rcar-du-drm-$(CONFIG_DRM_RCAR_VSP) += rcar_du_vsp.o > rcar-du-drm-$(CONFIG_DRM_RCAR_WRITEBACK) += rcar_du_writeback.o > > +obj-$(CONFIG_DRM_RCAR_CMM) += rcar_cmm.o > obj-$(CONFIG_DRM_RCAR_DU) += rcar-du-drm.o > obj-$(CONFIG_DRM_RCAR_DW_HDMI) += rcar_dw_hdmi.o > obj-$(CONFIG_DRM_RCAR_LVDS) += rcar_lvds.o > diff --git a/drivers/gpu/drm/rcar-du/rcar_cmm.c b/drivers/gpu/drm/rcar-du/rcar_cmm.c > new file mode 100644 > index 000000000000..4170626208cf > --- /dev/null > +++ b/drivers/gpu/drm/rcar-du/rcar_cmm.c > @@ -0,0 +1,212 @@ > +// SPDX-License-Identifier: GPL-2.0+ > +/* > + * rcar_cmm.c -- R-Car Display Unit Color Management Module > + * > + * Copyright (C) 2019 Jacopo Mondi > + */ > + > +#include > +#include > +#include > +#include > +#include > + > +#include > + > +#include "rcar_cmm.h" > + > +#define CM2_LUT_CTRL 0x0000 > +#define CM2_LUT_CTRL_LUT_EN BIT(0) > +#define CM2_LUT_TBL_BASE 0x0600 > +#define CM2_LUT_TBL(__i) (CM2_LUT_TBL_BASE + (__i) * 4) > + > +struct rcar_cmm { > + void __iomem *base; > + > + /* > + * @lut: 1D-LUT state > + * @lut.enabled: 1D-LUT enabled flag > + */ > + struct { > + bool enabled; > + } lut; > +}; > + > +static inline int rcar_cmm_read(struct rcar_cmm *rcmm, u32 reg) > +{ > + return ioread32(rcmm->base + reg); > +} > + > +static inline void rcar_cmm_write(struct rcar_cmm *rcmm, u32 reg, u32 data) > +{ > + iowrite32(data, rcmm->base + reg); > +} > + > +/* > + * rcar_cmm_lut_write() - Scale the DRM LUT table entries to hardware precision > + * and write to the CMM registers > + * @rcmm: Pointer to the CMM device > + * @drm_lut: Pointer to the DRM LUT table > + */ > +static void rcar_cmm_lut_write(struct rcar_cmm *rcmm, > + const struct drm_color_lut *drm_lut) > +{ > + unsigned int i; > + > + for (i = 0; i < CM2_LUT_SIZE; ++i) { > + u32 entry = drm_color_lut_extract(drm_lut[i].red, 8) << 16 > + | drm_color_lut_extract(drm_lut[i].green, 8) << 8 > + | drm_color_lut_extract(drm_lut[i].blue, 8); > + > + rcar_cmm_write(rcmm, CM2_LUT_TBL(i), entry); > + } > +} > + > +/* > + * rcar_cmm_setup() - Configure the CMM unit > + * @pdev: The platform device associated with the CMM instance > + * @config: The CMM unit configuration > + * > + * Configure the CMM unit with the given configuration. Currently enabling, > + * disabling and programming of the 1-D LUT unit is supported. Did you miss the comment in the previous version about explaining when rcar_cmm_setup() can be called (basically requiring the CMM to be enabled) ? I can fix this when applying if you tell me what I should write. > + * > + * TODO: Add support for LUT double buffer operations to avoid updating the > + * LUT table entries while a frame is being displayed. > + */ > +int rcar_cmm_setup(struct platform_device *pdev, > + const struct rcar_cmm_config *config) > +{ > + struct rcar_cmm *rcmm = platform_get_drvdata(pdev); > + > + /* Disable LUT if no table is provided. */ > + if (!config->lut.table) { > + if (rcmm->lut.enabled) { > + rcar_cmm_write(rcmm, CM2_LUT_CTRL, 0); > + rcmm->lut.enabled = false; > + } > + > + return 0; > + } > + > + /* Enable LUT and program the new gamma table values. */ > + if (!rcmm->lut.enabled) { > + rcar_cmm_write(rcmm, CM2_LUT_CTRL, CM2_LUT_CTRL_LUT_EN); > + rcmm->lut.enabled = true; > + } > + > + rcar_cmm_lut_write(rcmm, config->lut.table); > + > + return 0; > +} > +EXPORT_SYMBOL_GPL(rcar_cmm_setup); > + > +/* > + * rcar_cmm_enable() - Enable the CMM unit > + * @pdev: The platform device associated with the CMM instance > + * > + * When the output of the corresponding DU channel is routed to the CMM unit, > + * the unit shall be enabled before the DU channel is started, and remain > + * enabled until the channel is stopped. The CMM unit shall be disabled with > + * rcar_cmm_disable(). > + * > + * Calls to rcar_cmm_enable() and rcar_cmm_disable() are not reference-counted. > + * It is an error to attempt to enable an already enabled CMM unit, or to > + * attempt to disable a disabled unit. > + */ > +int rcar_cmm_enable(struct platform_device *pdev) > +{ > + int ret; > + > + ret = pm_runtime_get_sync(&pdev->dev); > + if (ret < 0) > + return ret; > + > + return 0; > +} > +EXPORT_SYMBOL_GPL(rcar_cmm_enable); > + > +/* > + * rcar_cmm_disable() - Disable the CMM unit > + * @pdev: The platform device associated with the CMM instance > + * > + * See rcar_cmm_enable() for usage information. > + * > + * Disabling the CMM unit disable all the internal processing blocks. The CMM > + * state shall thus be restored with rcar_cmm_setup() when re-enabling the CMM > + * unit after the next rcar_cmm_enable() call. > + */ > +void rcar_cmm_disable(struct platform_device *pdev) > +{ > + struct rcar_cmm *rcmm = platform_get_drvdata(pdev); > + > + rcar_cmm_write(rcmm, CM2_LUT_CTRL, 0); > + rcmm->lut.enabled = false; > + > + pm_runtime_put(&pdev->dev); > +} > +EXPORT_SYMBOL_GPL(rcar_cmm_disable); > + > +/* > + * rcar_cmm_init() - Initialize the CMM unit > + * @pdev: The platform device associated with the CMM instance > + * > + * Return: 0 on success, -EPROBE_DEFER if the CMM is not available yet, > + * -ENODEV if the DRM_RCAR_CMM config option is disabled > + */ > +int rcar_cmm_init(struct platform_device *pdev) > +{ > + struct rcar_cmm *rcmm = platform_get_drvdata(pdev); > + > + if (!rcmm) > + return -EPROBE_DEFER; > + > + return 0; > +} > +EXPORT_SYMBOL_GPL(rcar_cmm_init); > + > +static int rcar_cmm_probe(struct platform_device *pdev) > +{ > + struct rcar_cmm *rcmm; > + > + rcmm = devm_kzalloc(&pdev->dev, sizeof(*rcmm), GFP_KERNEL); > + if (!rcmm) > + return -ENOMEM; > + platform_set_drvdata(pdev, rcmm); > + > + rcmm->base = devm_platform_ioremap_resource(pdev, 0); > + if (IS_ERR(rcmm->base)) > + return PTR_ERR(rcmm->base); > + > + pm_runtime_enable(&pdev->dev); > + > + return 0; > +} > + > +static int rcar_cmm_remove(struct platform_device *pdev) > +{ > + pm_runtime_disable(&pdev->dev); > + > + return 0; > +} > + > +static const struct of_device_id rcar_cmm_of_table[] = { > + { .compatible = "renesas,rcar-gen3-cmm", }, > + { .compatible = "renesas,rcar-gen2-cmm", }, > + { }, > +}; > +MODULE_DEVICE_TABLE(of, rcar_cmm_of_table); > + > +static struct platform_driver rcar_cmm_platform_driver = { > + .probe = rcar_cmm_probe, > + .remove = rcar_cmm_remove, > + .driver = { > + .name = "rcar-cmm", > + .of_match_table = rcar_cmm_of_table, > + }, > +}; > + > +module_platform_driver(rcar_cmm_platform_driver); > + > +MODULE_AUTHOR("Jacopo Mondi "); > +MODULE_DESCRIPTION("Renesas R-Car CMM Driver"); > +MODULE_LICENSE("GPL v2"); > diff --git a/drivers/gpu/drm/rcar-du/rcar_cmm.h b/drivers/gpu/drm/rcar-du/rcar_cmm.h > new file mode 100644 > index 000000000000..b5f7ec6db04a > --- /dev/null > +++ b/drivers/gpu/drm/rcar-du/rcar_cmm.h > @@ -0,0 +1,58 @@ > +/* SPDX-License-Identifier: GPL-2.0+ */ > +/* > + * rcar_cmm.h -- R-Car Display Unit Color Management Module > + * > + * Copyright (C) 2019 Jacopo Mondi > + */ > + > +#ifndef __RCAR_CMM_H__ > +#define __RCAR_CMM_H__ > + > +#define CM2_LUT_SIZE 256 > + > +struct drm_color_lut; > +struct platform_device; > + > +/** > + * struct rcar_cmm_config - CMM configuration > + * > + * @lut: 1D-LUT configuration > + * @lut.table: 1D-LUT table entries. Disable LUT operations when NULL > + */ > +struct rcar_cmm_config { > + struct { > + struct drm_color_lut *table; > + } lut; > +}; > + > +#if IS_ENABLED(CONFIG_DRM_RCAR_CMM) > +int rcar_cmm_init(struct platform_device *pdev); > + > +int rcar_cmm_enable(struct platform_device *pdev); > +void rcar_cmm_disable(struct platform_device *pdev); > + > +int rcar_cmm_setup(struct platform_device *pdev, > + const struct rcar_cmm_config *config); > +#else > +static inline int rcar_cmm_init(struct platform_device *pdev) > +{ > + return -ENODEV; > +} > + > +static inline int rcar_cmm_enable(struct platform_device *pdev) > +{ > + return 0; > +} > + > +static inline void rcar_cmm_disable(struct platform_device *pdev) > +{ > +} > + > +static inline int rcar_cmm_setup(struct platform_device *pdev, > + const struct rcar_cmm_config *config) > +{ > + return 0; > +} > +#endif /* IS_ENABLED(CONFIG_DRM_RCAR_CMM) */ > + > +#endif /* __RCAR_CMM_H__ */ -- Regards, Laurent Pinchart From mboxrd@z Thu Jan 1 00:00:00 1970 From: Laurent Pinchart Subject: Re: [PATCH v6 3/8] drm: rcar-du: Add support for CMM Date: Wed, 16 Oct 2019 16:45:26 +0300 Message-ID: <20191016134526.GD5175@pendragon.ideasonboard.com> References: <20191016085548.105703-1-jacopo+renesas@jmondi.org> <20191016085548.105703-4-jacopo+renesas@jmondi.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from perceval.ideasonboard.com (perceval.ideasonboard.com [213.167.242.64]) by gabe.freedesktop.org (Postfix) with ESMTPS id 45DEC8994D for ; Wed, 16 Oct 2019 13:45:32 +0000 (UTC) Content-Disposition: inline In-Reply-To: <20191016085548.105703-4-jacopo+renesas@jmondi.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Jacopo Mondi Cc: horms@verge.net.au, airlied@linux.ie, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, linux-renesas-soc@vger.kernel.org, kieran.bingham+renesas@ideasonboard.com, geert@linux-m68k.org, uli+renesas@fpond.eu List-Id: dri-devel@lists.freedesktop.org SGkgSmFjb3BvLAoKVGhhbmsgeW91IGZvciB0aGUgcGF0Y2guCgpPbiBXZWQsIE9jdCAxNiwgMjAx OSBhdCAxMDo1NTo0M0FNICswMjAwLCBKYWNvcG8gTW9uZGkgd3JvdGU6Cj4gQWRkIGEgZHJpdmVy IGZvciB0aGUgUi1DYXIgRGlzcGxheSBVbml0IENvbG9yIENvcnJlY3Rpb24gTW9kdWxlLgo+IAo+ IEluIG1vc3Qgb2YgR2VuMyBTb0NzLCBlYWNoIERVIG91dHB1dCBjaGFubmVsIGlzIHByb3ZpZGVk IHdpdGggYSBDTU0gdW5pdAo+IHRvIHBlcmZvcm0gaW1hZ2UgZW5oYW5jZW1lbnQgYW5kIGNvbG9y IGNvcnJlY3Rpb24uCj4gCj4gQWRkIHN1cHBvcnQgZm9yIENNTSB0aHJvdWdoIGEgZHJpdmVyIHRo YXQgc3VwcG9ydHMgY29uZmlndXJhdGlvbiBvZgo+IHRoZSAxLWRpbWVuc2lvbmFsIExVVCB0YWJs ZS4gTW9yZSBhZHZhbmNlZCBDTU0gZmVhdHVyZXMgd2lsbCBiZQo+IGltcGxlbWVudGVkIG9uIHRv cCBvZiB0aGlzIGluaXRpYWwgb25lLgo+IAo+IFJldmlld2VkLWJ5OiBMYXVyZW50IFBpbmNoYXJ0 IDxsYXVyZW50LnBpbmNoYXJ0QGlkZWFzb25ib2FyZC5jb20+Cj4gUmV2aWV3ZWQtYnk6IEtpZXJh biBCaW5naGFtIDxraWVyYW4uYmluZ2hhbStyZW5lc2FzQGlkZWFzb25ib2FyZC5jb20+Cj4gU2ln bmVkLW9mZi1ieTogSmFjb3BvIE1vbmRpIDxqYWNvcG8rcmVuZXNhc0BqbW9uZGkub3JnPgo+IC0t LQo+ICBkcml2ZXJzL2dwdS9kcm0vcmNhci1kdS9LY29uZmlnICAgIHwgICA3ICsKPiAgZHJpdmVy cy9ncHUvZHJtL3JjYXItZHUvTWFrZWZpbGUgICB8ICAgMSArCj4gIGRyaXZlcnMvZ3B1L2RybS9y Y2FyLWR1L3JjYXJfY21tLmMgfCAyMTIgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysKPiAg ZHJpdmVycy9ncHUvZHJtL3JjYXItZHUvcmNhcl9jbW0uaCB8ICA1OCArKysrKysrKwo+ICA0IGZp bGVzIGNoYW5nZWQsIDI3OCBpbnNlcnRpb25zKCspCj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2 ZXJzL2dwdS9kcm0vcmNhci1kdS9yY2FyX2NtbS5jCj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2 ZXJzL2dwdS9kcm0vcmNhci1kdS9yY2FyX2NtbS5oCj4gCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMv Z3B1L2RybS9yY2FyLWR1L0tjb25maWcgYi9kcml2ZXJzL2dwdS9kcm0vcmNhci1kdS9LY29uZmln Cj4gaW5kZXggMTUyOTg0OWUyMTdlLi41MzlkMjMyNzkwZDEgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVy cy9ncHUvZHJtL3JjYXItZHUvS2NvbmZpZwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9yY2FyLWR1 L0tjb25maWcKPiBAQCAtMTMsNiArMTMsMTMgQEAgY29uZmlnIERSTV9SQ0FSX0RVCj4gIAkgIENo b29zZSB0aGlzIG9wdGlvbiBpZiB5b3UgaGF2ZSBhbiBSLUNhciBjaGlwc2V0Lgo+ICAJICBJZiBN IGlzIHNlbGVjdGVkIHRoZSBtb2R1bGUgd2lsbCBiZSBjYWxsZWQgcmNhci1kdS1kcm0uCj4gIAo+ ICtjb25maWcgRFJNX1JDQVJfQ01NCj4gKwlib29sICJSLUNhciBEVSBDb2xvciBNYW5hZ2VtZW50 IE1vZHVsZSAoQ01NKSBTdXBwb3J0Igo+ICsJZGVwZW5kcyBvbiBEUk0gJiYgT0YKPiArCWRlcGVu ZHMgb24gRFJNX1JDQVJfRFUKPiArCWhlbHAKPiArCSAgRW5hYmxlIHN1cHBvcnQgZm9yIFItQ2Fy IENvbG9yIE1hbmFnZW1lbnQgTW9kdWxlIChDTU0pLgo+ICsKPiAgY29uZmlnIERSTV9SQ0FSX0RX X0hETUkKPiAgCXRyaXN0YXRlICJSLUNhciBEVSBHZW4zIEhETUkgRW5jb2RlciBTdXBwb3J0Igo+ ICAJZGVwZW5kcyBvbiBEUk0gJiYgT0YKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3Jj YXItZHUvTWFrZWZpbGUgYi9kcml2ZXJzL2dwdS9kcm0vcmNhci1kdS9NYWtlZmlsZQo+IGluZGV4 IDZjMmVkOWM0NjQ2Ny4uNGQxMTg3Y2NjM2U1IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2Ry bS9yY2FyLWR1L01ha2VmaWxlCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL3JjYXItZHUvTWFrZWZp bGUKPiBAQCAtMTUsNiArMTUsNyBAQCByY2FyLWR1LWRybS0kKENPTkZJR19EUk1fUkNBUl9MVkRT KQkrPSByY2FyX2R1X29mLm8gXAo+ICByY2FyLWR1LWRybS0kKENPTkZJR19EUk1fUkNBUl9WU1Ap CSs9IHJjYXJfZHVfdnNwLm8KPiAgcmNhci1kdS1kcm0tJChDT05GSUdfRFJNX1JDQVJfV1JJVEVC QUNLKSArPSByY2FyX2R1X3dyaXRlYmFjay5vCj4gIAo+ICtvYmotJChDT05GSUdfRFJNX1JDQVJf Q01NKQkJKz0gcmNhcl9jbW0ubwo+ICBvYmotJChDT05GSUdfRFJNX1JDQVJfRFUpCQkrPSByY2Fy LWR1LWRybS5vCj4gIG9iai0kKENPTkZJR19EUk1fUkNBUl9EV19IRE1JKQkJKz0gcmNhcl9kd19o ZG1pLm8KPiAgb2JqLSQoQ09ORklHX0RSTV9SQ0FSX0xWRFMpCQkrPSByY2FyX2x2ZHMubwo+IGRp ZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcmNhci1kdS9yY2FyX2NtbS5jIGIvZHJpdmVycy9n cHUvZHJtL3JjYXItZHUvcmNhcl9jbW0uYwo+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4gaW5kZXgg MDAwMDAwMDAwMDAwLi40MTcwNjI2MjA4Y2YKPiAtLS0gL2Rldi9udWxsCj4gKysrIGIvZHJpdmVy cy9ncHUvZHJtL3JjYXItZHUvcmNhcl9jbW0uYwo+IEBAIC0wLDAgKzEsMjEyIEBACj4gKy8vIFNQ RFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wKwo+ICsvKgo+ICsgKiByY2FyX2NtbS5jIC0t IFItQ2FyIERpc3BsYXkgVW5pdCBDb2xvciBNYW5hZ2VtZW50IE1vZHVsZQo+ICsgKgo+ICsgKiBD b3B5cmlnaHQgKEMpIDIwMTkgSmFjb3BvIE1vbmRpIDxqYWNvcG8rcmVuZXNhc0BqbW9uZGkub3Jn Pgo+ICsgKi8KPiArCj4gKyNpbmNsdWRlIDxsaW51eC9pby5oPgo+ICsjaW5jbHVkZSA8bGludXgv bW9kdWxlLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9vZi5oPgo+ICsjaW5jbHVkZSA8bGludXgvcGxh dGZvcm1fZGV2aWNlLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9wbV9ydW50aW1lLmg+Cj4gKwo+ICsj aW5jbHVkZSA8ZHJtL2RybV9jb2xvcl9tZ210Lmg+Cj4gKwo+ICsjaW5jbHVkZSAicmNhcl9jbW0u aCIKPiArCj4gKyNkZWZpbmUgQ00yX0xVVF9DVFJMCQkweDAwMDAKPiArI2RlZmluZSBDTTJfTFVU X0NUUkxfTFVUX0VOCUJJVCgwKQo+ICsjZGVmaW5lIENNMl9MVVRfVEJMX0JBU0UJMHgwNjAwCj4g KyNkZWZpbmUgQ00yX0xVVF9UQkwoX19pKQkoQ00yX0xVVF9UQkxfQkFTRSArIChfX2kpICogNCkK PiArCj4gK3N0cnVjdCByY2FyX2NtbSB7Cj4gKwl2b2lkIF9faW9tZW0gKmJhc2U7Cj4gKwo+ICsJ LyoKPiArCSAqIEBsdXQ6CQkxRC1MVVQgc3RhdGUKPiArCSAqIEBsdXQuZW5hYmxlZDoJMUQtTFVU IGVuYWJsZWQgZmxhZwo+ICsJICovCj4gKwlzdHJ1Y3Qgewo+ICsJCWJvb2wgZW5hYmxlZDsKPiAr CX0gbHV0Owo+ICt9Owo+ICsKPiArc3RhdGljIGlubGluZSBpbnQgcmNhcl9jbW1fcmVhZChzdHJ1 Y3QgcmNhcl9jbW0gKnJjbW0sIHUzMiByZWcpCj4gK3sKPiArCXJldHVybiBpb3JlYWQzMihyY21t LT5iYXNlICsgcmVnKTsKPiArfQo+ICsKPiArc3RhdGljIGlubGluZSB2b2lkIHJjYXJfY21tX3dy aXRlKHN0cnVjdCByY2FyX2NtbSAqcmNtbSwgdTMyIHJlZywgdTMyIGRhdGEpCj4gK3sKPiArCWlv d3JpdGUzMihkYXRhLCByY21tLT5iYXNlICsgcmVnKTsKPiArfQo+ICsKPiArLyoKPiArICogcmNh cl9jbW1fbHV0X3dyaXRlKCkgLSBTY2FsZSB0aGUgRFJNIExVVCB0YWJsZSBlbnRyaWVzIHRvIGhh cmR3YXJlIHByZWNpc2lvbgo+ICsgKgkJCSAgYW5kIHdyaXRlIHRvIHRoZSBDTU0gcmVnaXN0ZXJz Cj4gKyAqIEByY21tOiBQb2ludGVyIHRvIHRoZSBDTU0gZGV2aWNlCj4gKyAqIEBkcm1fbHV0OiBQ b2ludGVyIHRvIHRoZSBEUk0gTFVUIHRhYmxlCj4gKyAqLwo+ICtzdGF0aWMgdm9pZCByY2FyX2Nt bV9sdXRfd3JpdGUoc3RydWN0IHJjYXJfY21tICpyY21tLAo+ICsJCQkgICAgICAgY29uc3Qgc3Ry dWN0IGRybV9jb2xvcl9sdXQgKmRybV9sdXQpCj4gK3sKPiArCXVuc2lnbmVkIGludCBpOwo+ICsK PiArCWZvciAoaSA9IDA7IGkgPCBDTTJfTFVUX1NJWkU7ICsraSkgewo+ICsJCXUzMiBlbnRyeSA9 IGRybV9jb2xvcl9sdXRfZXh0cmFjdChkcm1fbHV0W2ldLnJlZCwgOCkgPDwgMTYKPiArCQkJICB8 IGRybV9jb2xvcl9sdXRfZXh0cmFjdChkcm1fbHV0W2ldLmdyZWVuLCA4KSA8PCA4Cj4gKwkJCSAg fCBkcm1fY29sb3JfbHV0X2V4dHJhY3QoZHJtX2x1dFtpXS5ibHVlLCA4KTsKPiArCj4gKwkJcmNh cl9jbW1fd3JpdGUocmNtbSwgQ00yX0xVVF9UQkwoaSksIGVudHJ5KTsKPiArCX0KPiArfQo+ICsK PiArLyoKPiArICogcmNhcl9jbW1fc2V0dXAoKSAtIENvbmZpZ3VyZSB0aGUgQ01NIHVuaXQKPiAr ICogQHBkZXY6IFRoZSBwbGF0Zm9ybSBkZXZpY2UgYXNzb2NpYXRlZCB3aXRoIHRoZSBDTU0gaW5z dGFuY2UKPiArICogQGNvbmZpZzogVGhlIENNTSB1bml0IGNvbmZpZ3VyYXRpb24KPiArICoKPiAr ICogQ29uZmlndXJlIHRoZSBDTU0gdW5pdCB3aXRoIHRoZSBnaXZlbiBjb25maWd1cmF0aW9uLiBD dXJyZW50bHkgZW5hYmxpbmcsCj4gKyAqIGRpc2FibGluZyBhbmQgcHJvZ3JhbW1pbmcgb2YgdGhl IDEtRCBMVVQgdW5pdCBpcyBzdXBwb3J0ZWQuCgpEaWQgeW91IG1pc3MgdGhlIGNvbW1lbnQgaW4g dGhlIHByZXZpb3VzIHZlcnNpb24gYWJvdXQgZXhwbGFpbmluZyB3aGVuCnJjYXJfY21tX3NldHVw KCkgY2FuIGJlIGNhbGxlZCAoYmFzaWNhbGx5IHJlcXVpcmluZyB0aGUgQ01NIHRvIGJlCmVuYWJs ZWQpID8gSSBjYW4gZml4IHRoaXMgd2hlbiBhcHBseWluZyBpZiB5b3UgdGVsbCBtZSB3aGF0IEkg c2hvdWxkCndyaXRlLgoKPiArICoKPiArICogVE9ETzogQWRkIHN1cHBvcnQgZm9yIExVVCBkb3Vi bGUgYnVmZmVyIG9wZXJhdGlvbnMgdG8gYXZvaWQgdXBkYXRpbmcgdGhlCj4gKyAqIExVVCB0YWJs ZSBlbnRyaWVzIHdoaWxlIGEgZnJhbWUgaXMgYmVpbmcgZGlzcGxheWVkLgo+ICsgKi8KPiAraW50 IHJjYXJfY21tX3NldHVwKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYsCj4gKwkJICAgY29u c3Qgc3RydWN0IHJjYXJfY21tX2NvbmZpZyAqY29uZmlnKQo+ICt7Cj4gKwlzdHJ1Y3QgcmNhcl9j bW0gKnJjbW0gPSBwbGF0Zm9ybV9nZXRfZHJ2ZGF0YShwZGV2KTsKPiArCj4gKwkvKiBEaXNhYmxl IExVVCBpZiBubyB0YWJsZSBpcyBwcm92aWRlZC4gKi8KPiArCWlmICghY29uZmlnLT5sdXQudGFi bGUpIHsKPiArCQlpZiAocmNtbS0+bHV0LmVuYWJsZWQpIHsKPiArCQkJcmNhcl9jbW1fd3JpdGUo cmNtbSwgQ00yX0xVVF9DVFJMLCAwKTsKPiArCQkJcmNtbS0+bHV0LmVuYWJsZWQgPSBmYWxzZTsK PiArCQl9Cj4gKwo+ICsJCXJldHVybiAwOwo+ICsJfQo+ICsKPiArCS8qIEVuYWJsZSBMVVQgYW5k IHByb2dyYW0gdGhlIG5ldyBnYW1tYSB0YWJsZSB2YWx1ZXMuICovCj4gKwlpZiAoIXJjbW0tPmx1 dC5lbmFibGVkKSB7Cj4gKwkJcmNhcl9jbW1fd3JpdGUocmNtbSwgQ00yX0xVVF9DVFJMLCBDTTJf TFVUX0NUUkxfTFVUX0VOKTsKPiArCQlyY21tLT5sdXQuZW5hYmxlZCA9IHRydWU7Cj4gKwl9Cj4g Kwo+ICsJcmNhcl9jbW1fbHV0X3dyaXRlKHJjbW0sIGNvbmZpZy0+bHV0LnRhYmxlKTsKPiArCj4g KwlyZXR1cm4gMDsKPiArfQo+ICtFWFBPUlRfU1lNQk9MX0dQTChyY2FyX2NtbV9zZXR1cCk7Cj4g Kwo+ICsvKgo+ICsgKiByY2FyX2NtbV9lbmFibGUoKSAtIEVuYWJsZSB0aGUgQ01NIHVuaXQKPiAr ICogQHBkZXY6IFRoZSBwbGF0Zm9ybSBkZXZpY2UgYXNzb2NpYXRlZCB3aXRoIHRoZSBDTU0gaW5z dGFuY2UKPiArICoKPiArICogV2hlbiB0aGUgb3V0cHV0IG9mIHRoZSBjb3JyZXNwb25kaW5nIERV IGNoYW5uZWwgaXMgcm91dGVkIHRvIHRoZSBDTU0gdW5pdCwKPiArICogdGhlIHVuaXQgc2hhbGwg YmUgZW5hYmxlZCBiZWZvcmUgdGhlIERVIGNoYW5uZWwgaXMgc3RhcnRlZCwgYW5kIHJlbWFpbgo+ ICsgKiBlbmFibGVkIHVudGlsIHRoZSBjaGFubmVsIGlzIHN0b3BwZWQuIFRoZSBDTU0gdW5pdCBz aGFsbCBiZSBkaXNhYmxlZCB3aXRoCj4gKyAqIHJjYXJfY21tX2Rpc2FibGUoKS4KPiArICoKPiAr ICogQ2FsbHMgdG8gcmNhcl9jbW1fZW5hYmxlKCkgYW5kIHJjYXJfY21tX2Rpc2FibGUoKSBhcmUg bm90IHJlZmVyZW5jZS1jb3VudGVkLgo+ICsgKiBJdCBpcyBhbiBlcnJvciB0byBhdHRlbXB0IHRv IGVuYWJsZSBhbiBhbHJlYWR5IGVuYWJsZWQgQ01NIHVuaXQsIG9yIHRvCj4gKyAqIGF0dGVtcHQg dG8gZGlzYWJsZSBhIGRpc2FibGVkIHVuaXQuCj4gKyAqLwo+ICtpbnQgcmNhcl9jbW1fZW5hYmxl KHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCj4gK3sKPiArCWludCByZXQ7Cj4gKwo+ICsJ cmV0ID0gcG1fcnVudGltZV9nZXRfc3luYygmcGRldi0+ZGV2KTsKPiArCWlmIChyZXQgPCAwKQo+ ICsJCXJldHVybiByZXQ7Cj4gKwo+ICsJcmV0dXJuIDA7Cj4gK30KPiArRVhQT1JUX1NZTUJPTF9H UEwocmNhcl9jbW1fZW5hYmxlKTsKPiArCj4gKy8qCj4gKyAqIHJjYXJfY21tX2Rpc2FibGUoKSAt IERpc2FibGUgdGhlIENNTSB1bml0Cj4gKyAqIEBwZGV2OiBUaGUgcGxhdGZvcm0gZGV2aWNlIGFz c29jaWF0ZWQgd2l0aCB0aGUgQ01NIGluc3RhbmNlCj4gKyAqCj4gKyAqIFNlZSByY2FyX2NtbV9l bmFibGUoKSBmb3IgdXNhZ2UgaW5mb3JtYXRpb24uCj4gKyAqCj4gKyAqIERpc2FibGluZyB0aGUg Q01NIHVuaXQgZGlzYWJsZSBhbGwgdGhlIGludGVybmFsIHByb2Nlc3NpbmcgYmxvY2tzLiBUaGUg Q01NCj4gKyAqIHN0YXRlIHNoYWxsIHRodXMgYmUgcmVzdG9yZWQgd2l0aCByY2FyX2NtbV9zZXR1 cCgpIHdoZW4gcmUtZW5hYmxpbmcgdGhlIENNTQo+ICsgKiB1bml0IGFmdGVyIHRoZSBuZXh0IHJj YXJfY21tX2VuYWJsZSgpIGNhbGwuCj4gKyAqLwo+ICt2b2lkIHJjYXJfY21tX2Rpc2FibGUoc3Ry dWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKPiArewo+ICsJc3RydWN0IHJjYXJfY21tICpyY21t ID0gcGxhdGZvcm1fZ2V0X2RydmRhdGEocGRldik7Cj4gKwo+ICsJcmNhcl9jbW1fd3JpdGUocmNt bSwgQ00yX0xVVF9DVFJMLCAwKTsKPiArCXJjbW0tPmx1dC5lbmFibGVkID0gZmFsc2U7Cj4gKwo+ ICsJcG1fcnVudGltZV9wdXQoJnBkZXYtPmRldik7Cj4gK30KPiArRVhQT1JUX1NZTUJPTF9HUEwo cmNhcl9jbW1fZGlzYWJsZSk7Cj4gKwo+ICsvKgo+ICsgKiByY2FyX2NtbV9pbml0KCkgLSBJbml0 aWFsaXplIHRoZSBDTU0gdW5pdAo+ICsgKiBAcGRldjogVGhlIHBsYXRmb3JtIGRldmljZSBhc3Nv Y2lhdGVkIHdpdGggdGhlIENNTSBpbnN0YW5jZQo+ICsgKgo+ICsgKiBSZXR1cm46IDAgb24gc3Vj Y2VzcywgLUVQUk9CRV9ERUZFUiBpZiB0aGUgQ01NIGlzIG5vdCBhdmFpbGFibGUgeWV0LAo+ICsg KiAgICAgICAgIC1FTk9ERVYgaWYgdGhlIERSTV9SQ0FSX0NNTSBjb25maWcgb3B0aW9uIGlzIGRp c2FibGVkCj4gKyAqLwo+ICtpbnQgcmNhcl9jbW1faW5pdChzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNl ICpwZGV2KQo+ICt7Cj4gKwlzdHJ1Y3QgcmNhcl9jbW0gKnJjbW0gPSBwbGF0Zm9ybV9nZXRfZHJ2 ZGF0YShwZGV2KTsKPiArCj4gKwlpZiAoIXJjbW0pCj4gKwkJcmV0dXJuIC1FUFJPQkVfREVGRVI7 Cj4gKwo+ICsJcmV0dXJuIDA7Cj4gK30KPiArRVhQT1JUX1NZTUJPTF9HUEwocmNhcl9jbW1faW5p dCk7Cj4gKwo+ICtzdGF0aWMgaW50IHJjYXJfY21tX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZp Y2UgKnBkZXYpCj4gK3sKPiArCXN0cnVjdCByY2FyX2NtbSAqcmNtbTsKPiArCj4gKwlyY21tID0g ZGV2bV9remFsbG9jKCZwZGV2LT5kZXYsIHNpemVvZigqcmNtbSksIEdGUF9LRVJORUwpOwo+ICsJ aWYgKCFyY21tKQo+ICsJCXJldHVybiAtRU5PTUVNOwo+ICsJcGxhdGZvcm1fc2V0X2RydmRhdGEo cGRldiwgcmNtbSk7Cj4gKwo+ICsJcmNtbS0+YmFzZSA9IGRldm1fcGxhdGZvcm1faW9yZW1hcF9y ZXNvdXJjZShwZGV2LCAwKTsKPiArCWlmIChJU19FUlIocmNtbS0+YmFzZSkpCj4gKwkJcmV0dXJu IFBUUl9FUlIocmNtbS0+YmFzZSk7Cj4gKwo+ICsJcG1fcnVudGltZV9lbmFibGUoJnBkZXYtPmRl dik7Cj4gKwo+ICsJcmV0dXJuIDA7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgcmNhcl9jbW1fcmVt b3ZlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCj4gK3sKPiArCXBtX3J1bnRpbWVfZGlz YWJsZSgmcGRldi0+ZGV2KTsKPiArCj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiArc3RhdGljIGNv bnN0IHN0cnVjdCBvZl9kZXZpY2VfaWQgcmNhcl9jbW1fb2ZfdGFibGVbXSA9IHsKPiArCXsgLmNv bXBhdGlibGUgPSAicmVuZXNhcyxyY2FyLWdlbjMtY21tIiwgfSwKPiArCXsgLmNvbXBhdGlibGUg PSAicmVuZXNhcyxyY2FyLWdlbjItY21tIiwgfSwKPiArCXsgfSwKPiArfTsKPiArTU9EVUxFX0RF VklDRV9UQUJMRShvZiwgcmNhcl9jbW1fb2ZfdGFibGUpOwo+ICsKPiArc3RhdGljIHN0cnVjdCBw bGF0Zm9ybV9kcml2ZXIgcmNhcl9jbW1fcGxhdGZvcm1fZHJpdmVyID0gewo+ICsJLnByb2JlCQk9 IHJjYXJfY21tX3Byb2JlLAo+ICsJLnJlbW92ZQkJPSByY2FyX2NtbV9yZW1vdmUsCj4gKwkuZHJp dmVyCQk9IHsKPiArCQkubmFtZQk9ICJyY2FyLWNtbSIsCj4gKwkJLm9mX21hdGNoX3RhYmxlID0g cmNhcl9jbW1fb2ZfdGFibGUsCj4gKwl9LAo+ICt9Owo+ICsKPiArbW9kdWxlX3BsYXRmb3JtX2Ry aXZlcihyY2FyX2NtbV9wbGF0Zm9ybV9kcml2ZXIpOwo+ICsKPiArTU9EVUxFX0FVVEhPUigiSmFj b3BvIE1vbmRpIDxqYWNvcG8rcmVuZXNhc0BqbW9uZGkub3JnPiIpOwo+ICtNT0RVTEVfREVTQ1JJ UFRJT04oIlJlbmVzYXMgUi1DYXIgQ01NIERyaXZlciIpOwo+ICtNT0RVTEVfTElDRU5TRSgiR1BM IHYyIik7Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9yY2FyLWR1L3JjYXJfY21tLmgg Yi9kcml2ZXJzL2dwdS9kcm0vcmNhci1kdS9yY2FyX2NtbS5oCj4gbmV3IGZpbGUgbW9kZSAxMDA2 NDQKPiBpbmRleCAwMDAwMDAwMDAwMDAuLmI1ZjdlYzZkYjA0YQo+IC0tLSAvZGV2L251bGwKPiAr KysgYi9kcml2ZXJzL2dwdS9kcm0vcmNhci1kdS9yY2FyX2NtbS5oCj4gQEAgLTAsMCArMSw1OCBA QAo+ICsvKiBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMCsgKi8KPiArLyoKPiArICog cmNhcl9jbW0uaCAtLSBSLUNhciBEaXNwbGF5IFVuaXQgQ29sb3IgTWFuYWdlbWVudCBNb2R1bGUK PiArICoKPiArICogQ29weXJpZ2h0IChDKSAyMDE5IEphY29wbyBNb25kaSA8amFjb3BvK3JlbmVz YXNAam1vbmRpLm9yZz4KPiArICovCj4gKwo+ICsjaWZuZGVmIF9fUkNBUl9DTU1fSF9fCj4gKyNk ZWZpbmUgX19SQ0FSX0NNTV9IX18KPiArCj4gKyNkZWZpbmUgQ00yX0xVVF9TSVpFCQkyNTYKPiAr Cj4gK3N0cnVjdCBkcm1fY29sb3JfbHV0Owo+ICtzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlOwo+ICsK PiArLyoqCj4gKyAqIHN0cnVjdCByY2FyX2NtbV9jb25maWcgLSBDTU0gY29uZmlndXJhdGlvbgo+ ICsgKgo+ICsgKiBAbHV0OgkxRC1MVVQgY29uZmlndXJhdGlvbgo+ICsgKiBAbHV0LnRhYmxlOgkx RC1MVVQgdGFibGUgZW50cmllcy4gRGlzYWJsZSBMVVQgb3BlcmF0aW9ucyB3aGVuIE5VTEwKPiAr ICovCj4gK3N0cnVjdCByY2FyX2NtbV9jb25maWcgewo+ICsJc3RydWN0IHsKPiArCQlzdHJ1Y3Qg ZHJtX2NvbG9yX2x1dCAqdGFibGU7Cj4gKwl9IGx1dDsKPiArfTsKPiArCj4gKyNpZiBJU19FTkFC TEVEKENPTkZJR19EUk1fUkNBUl9DTU0pCj4gK2ludCByY2FyX2NtbV9pbml0KHN0cnVjdCBwbGF0 Zm9ybV9kZXZpY2UgKnBkZXYpOwo+ICsKPiAraW50IHJjYXJfY21tX2VuYWJsZShzdHJ1Y3QgcGxh dGZvcm1fZGV2aWNlICpwZGV2KTsKPiArdm9pZCByY2FyX2NtbV9kaXNhYmxlKHN0cnVjdCBwbGF0 Zm9ybV9kZXZpY2UgKnBkZXYpOwo+ICsKPiAraW50IHJjYXJfY21tX3NldHVwKHN0cnVjdCBwbGF0 Zm9ybV9kZXZpY2UgKnBkZXYsCj4gKwkJICAgY29uc3Qgc3RydWN0IHJjYXJfY21tX2NvbmZpZyAq Y29uZmlnKTsKPiArI2Vsc2UKPiArc3RhdGljIGlubGluZSBpbnQgcmNhcl9jbW1faW5pdChzdHJ1 Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQo+ICt7Cj4gKwlyZXR1cm4gLUVOT0RFVjsKPiArfQo+ ICsKPiArc3RhdGljIGlubGluZSBpbnQgcmNhcl9jbW1fZW5hYmxlKHN0cnVjdCBwbGF0Zm9ybV9k ZXZpY2UgKnBkZXYpCj4gK3sKPiArCXJldHVybiAwOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW5saW5l IHZvaWQgcmNhcl9jbW1fZGlzYWJsZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQo+ICt7 Cj4gK30KPiArCj4gK3N0YXRpYyBpbmxpbmUgaW50IHJjYXJfY21tX3NldHVwKHN0cnVjdCBwbGF0 Zm9ybV9kZXZpY2UgKnBkZXYsCj4gKwkJCQkgY29uc3Qgc3RydWN0IHJjYXJfY21tX2NvbmZpZyAq Y29uZmlnKQo+ICt7Cj4gKwlyZXR1cm4gMDsKPiArfQo+ICsjZW5kaWYgLyogSVNfRU5BQkxFRChD T05GSUdfRFJNX1JDQVJfQ01NKSAqLwo+ICsKPiArI2VuZGlmIC8qIF9fUkNBUl9DTU1fSF9fICov CgotLSAKUmVnYXJkcywKCkxhdXJlbnQgUGluY2hhcnQKX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxA bGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxt YW4vbGlzdGluZm8vZHJpLWRldmVs