From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1755762AbeDZUak (ORCPT ); Thu, 26 Apr 2018 16:30:40 -0400 Received: from perceval.ideasonboard.com ([213.167.242.64]:59514 "EHLO perceval.ideasonboard.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753665AbeDZUaj (ORCPT ); Thu, 26 Apr 2018 16:30:39 -0400 From: Laurent Pinchart To: Kieran Bingham Cc: linux-renesas-soc@vger.kernel.org, David Airlie , "open list:DRM DRIVERS FOR RENESAS" , open list Subject: Re: [PATCH 05/17] drm: rcar-du: Split CRTC handling to support hardware indexing Date: Thu, 26 Apr 2018 23:30:52 +0300 Message-ID: <8207827.UIER1Ri0ED@avalon> Organization: Ideas on Board Oy In-Reply-To: <20180426165346.494-6-kieran.bingham+renesas@ideasonboard.com> References: <20180426165346.494-1-kieran.bingham+renesas@ideasonboard.com> <20180426165346.494-6-kieran.bingham+renesas@ideasonboard.com> MIME-Version: 1.0 Content-Transfer-Encoding: 7Bit Content-Type: text/plain; charset="us-ascii" Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Hi Kieran, Thank you for the patch. On Thursday, 26 April 2018 19:53:34 EEST Kieran Bingham wrote: > The DU CRTC driver does not support distinguishing between a hardware > index, and a software (CRTC) index in the event that a DU channel might > not be populated by the hardware. > > Support this by adapting the rcar_du_device_info structure to store a > bitmask of available channels rather than a count of CRTCs. The count > can then be obtained by determining the hamming weight of the bitmask. > > This allows the rcar_du_crtc_create() function to distinguish between > both index types, and non-populated DU channels will be skipped without > leaving a gap in the software CRTC indexes. > > Signed-off-by: Kieran Bingham > --- > drivers/gpu/drm/rcar-du/rcar_du_crtc.c | 26 ++++++++++++++------------ > drivers/gpu/drm/rcar-du/rcar_du_crtc.h | 3 ++- > drivers/gpu/drm/rcar-du/rcar_du_drv.c | 20 ++++++++++---------- > drivers/gpu/drm/rcar-du/rcar_du_drv.h | 4 ++-- > drivers/gpu/drm/rcar-du/rcar_du_kms.c | 17 ++++++++++++----- > 5 files changed, 40 insertions(+), 30 deletions(-) > > diff --git a/drivers/gpu/drm/rcar-du/rcar_du_crtc.c > b/drivers/gpu/drm/rcar-du/rcar_du_crtc.c index 5a15dfd66343..36ce194c13b5 > 100644 > --- a/drivers/gpu/drm/rcar-du/rcar_du_crtc.c > +++ b/drivers/gpu/drm/rcar-du/rcar_du_crtc.c > @@ -902,7 +902,8 @@ static irqreturn_t rcar_du_crtc_irq(int irq, void *arg) > * Initialization > */ > > -int rcar_du_crtc_create(struct rcar_du_group *rgrp, unsigned int index) > +int rcar_du_crtc_create(struct rcar_du_group *rgrp, unsigned int swindex, > + unsigned int hwindex) > { > static const unsigned int mmio_offsets[] = { > DU0_REG_OFFSET, DU1_REG_OFFSET, DU2_REG_OFFSET, DU3_REG_OFFSET > @@ -910,7 +911,7 @@ int rcar_du_crtc_create(struct rcar_du_group *rgrp, > unsigned int index) > > struct rcar_du_device *rcdu = rgrp->dev; > struct platform_device *pdev = to_platform_device(rcdu->dev); > - struct rcar_du_crtc *rcrtc = &rcdu->crtcs[index]; > + struct rcar_du_crtc *rcrtc = &rcdu->crtcs[swindex]; > struct drm_crtc *crtc = &rcrtc->crtc; > struct drm_plane *primary; > unsigned int irqflags; > @@ -922,7 +923,7 @@ int rcar_du_crtc_create(struct rcar_du_group *rgrp, > unsigned int index) > > /* Get the CRTC clock and the optional external clock. */ > if (rcar_du_has(rcdu, RCAR_DU_FEATURE_CRTC_IRQ_CLOCK)) { > - sprintf(clk_name, "du.%u", index); > + sprintf(clk_name, "du.%u", hwindex); > name = clk_name; > } else { > name = NULL; > @@ -930,16 +931,16 @@ int rcar_du_crtc_create(struct rcar_du_group *rgrp, > unsigned int index) > > rcrtc->clock = devm_clk_get(rcdu->dev, name); > if (IS_ERR(rcrtc->clock)) { > - dev_err(rcdu->dev, "no clock for CRTC %u\n", index); > + dev_err(rcdu->dev, "no clock for CRTC %u\n", swindex); How about dev_err(rcdu->dev, "no clock for DU channel %u\n", hwindex); I think that would be clearer, because at this stage we're dealing with hardware resources, so matching the datasheet numbers seems better to me. > return PTR_ERR(rcrtc->clock); > } > > - sprintf(clk_name, "dclkin.%u", index); > + sprintf(clk_name, "dclkin.%u", hwindex); > clk = devm_clk_get(rcdu->dev, clk_name); > if (!IS_ERR(clk)) { > rcrtc->extclock = clk; > } else if (PTR_ERR(rcrtc->clock) == -EPROBE_DEFER) { > - dev_info(rcdu->dev, "can't get external clock %u\n", index); > + dev_info(rcdu->dev, "can't get external clock %u\n", hwindex); > return -EPROBE_DEFER; > } > > @@ -948,13 +949,13 @@ int rcar_du_crtc_create(struct rcar_du_group *rgrp, > unsigned int index) spin_lock_init(&rcrtc->vblank_lock); > > rcrtc->group = rgrp; > - rcrtc->mmio_offset = mmio_offsets[index]; > - rcrtc->index = index; > + rcrtc->mmio_offset = mmio_offsets[hwindex]; > + rcrtc->index = hwindex; > > if (rcar_du_has(rcdu, RCAR_DU_FEATURE_VSP1_SOURCE)) > primary = &rcrtc->vsp->planes[rcrtc->vsp_pipe].plane; > else > - primary = &rgrp->planes[index % 2].plane; > + primary = &rgrp->planes[hwindex % 2].plane; This shouldn't make a difference because when RCAR_DU_FEATURE_VSP1_SOURCE isn't set we're running on Gen2, and don't need to deal with indices, but from a conceptual point of view, wouldn't the software index be better here ? Missing hardware channels won't be visible from userspace, so taking the first plane of the group as the primary plane would seem better to me. > ret = drm_crtc_init_with_planes(rcdu->ddev, crtc, primary, NULL, > rcdu->info->gen <= 2 ? > @@ -970,7 +971,8 @@ int rcar_du_crtc_create(struct rcar_du_group *rgrp, > unsigned int index) > > /* Register the interrupt handler. */ > if (rcar_du_has(rcdu, RCAR_DU_FEATURE_CRTC_IRQ_CLOCK)) { > - irq = platform_get_irq(pdev, index); > + /* The IRQ's are associated with the CRTC (sw)index */ s/index/index./ > + irq = platform_get_irq(pdev, swindex); > irqflags = 0; > } else { > irq = platform_get_irq(pdev, 0); > @@ -978,7 +980,7 @@ int rcar_du_crtc_create(struct rcar_du_group *rgrp, > unsigned int index) } > > if (irq < 0) { > - dev_err(rcdu->dev, "no IRQ for CRTC %u\n", index); > + dev_err(rcdu->dev, "no IRQ for CRTC %u\n", swindex); > return irq; > } > > @@ -986,7 +988,7 @@ int rcar_du_crtc_create(struct rcar_du_group *rgrp, > unsigned int index) dev_name(rcdu->dev), rcrtc); > if (ret < 0) { > dev_err(rcdu->dev, > - "failed to register IRQ for CRTC %u\n", index); > + "failed to register IRQ for CRTC %u\n", swindex); > return ret; > } > > diff --git a/drivers/gpu/drm/rcar-du/rcar_du_crtc.h > b/drivers/gpu/drm/rcar-du/rcar_du_crtc.h index 518ee2c60eb8..5f003a16abc5 > 100644 > --- a/drivers/gpu/drm/rcar-du/rcar_du_crtc.h > +++ b/drivers/gpu/drm/rcar-du/rcar_du_crtc.h > @@ -99,7 +99,8 @@ enum rcar_du_output { > RCAR_DU_OUTPUT_MAX, > }; > > -int rcar_du_crtc_create(struct rcar_du_group *rgrp, unsigned int index); > +int rcar_du_crtc_create(struct rcar_du_group *rgrp, unsigned int swindex, > + unsigned int hwindex); > void rcar_du_crtc_suspend(struct rcar_du_crtc *rcrtc); > void rcar_du_crtc_resume(struct rcar_du_crtc *rcrtc); > > diff --git a/drivers/gpu/drm/rcar-du/rcar_du_drv.c > b/drivers/gpu/drm/rcar-du/rcar_du_drv.c index 05745e86d73e..d6ebc628fc22 > 100644 > --- a/drivers/gpu/drm/rcar-du/rcar_du_drv.c > +++ b/drivers/gpu/drm/rcar-du/rcar_du_drv.c > @@ -40,7 +40,7 @@ static const struct rcar_du_device_info > rzg1_du_r8a7743_info = { .gen = 2, > .features = RCAR_DU_FEATURE_CRTC_IRQ_CLOCK > | RCAR_DU_FEATURE_EXT_CTRL_REGS, > - .num_crtcs = 2, > + .channel_mask = BIT(0) | BIT(1), I'd write it BIT(1) | BIT(0) to match the usual little-endian order. Same comment for the other info structure instances. > .routes = { > /* > * R8A7743 has one RGB output and one LVDS output > @@ -61,7 +61,7 @@ static const struct rcar_du_device_info > rzg1_du_r8a7745_info = { .gen = 2, > .features = RCAR_DU_FEATURE_CRTC_IRQ_CLOCK > | RCAR_DU_FEATURE_EXT_CTRL_REGS, > - .num_crtcs = 2, > + .channel_mask = BIT(0) | BIT(1), > .routes = { > /* > * R8A7745 has two RGB outputs > @@ -80,7 +80,7 @@ static const struct rcar_du_device_info > rzg1_du_r8a7745_info = { static const struct rcar_du_device_info > rcar_du_r8a7779_info = { > .gen = 2, > .features = 0, > - .num_crtcs = 2, > + .channel_mask = BIT(0) | BIT(1), > .routes = { > /* > * R8A7779 has two RGB outputs and one (currently unsupported) > @@ -102,7 +102,7 @@ static const struct rcar_du_device_info > rcar_du_r8a7790_info = { .features = RCAR_DU_FEATURE_CRTC_IRQ_CLOCK > | RCAR_DU_FEATURE_EXT_CTRL_REGS, > .quirks = RCAR_DU_QUIRK_ALIGN_128B, > - .num_crtcs = 3, > + .channel_mask = BIT(0) | BIT(1) | BIT(2), > .routes = { > /* > * R8A7790 has one RGB output, two LVDS outputs and one > @@ -129,7 +129,7 @@ static const struct rcar_du_device_info > rcar_du_r8a7791_info = { .gen = 2, > .features = RCAR_DU_FEATURE_CRTC_IRQ_CLOCK > | RCAR_DU_FEATURE_EXT_CTRL_REGS, > - .num_crtcs = 2, > + .channel_mask = BIT(0) | BIT(1), > .routes = { > /* > * R8A779[13] has one RGB output, one LVDS output and one > @@ -151,7 +151,7 @@ static const struct rcar_du_device_info > rcar_du_r8a7792_info = { .gen = 2, > .features = RCAR_DU_FEATURE_CRTC_IRQ_CLOCK > | RCAR_DU_FEATURE_EXT_CTRL_REGS, > - .num_crtcs = 2, > + .channel_mask = BIT(0) | BIT(1), > .routes = { > /* R8A7792 has two RGB outputs. */ > [RCAR_DU_OUTPUT_DPAD0] = { > @@ -169,7 +169,7 @@ static const struct rcar_du_device_info > rcar_du_r8a7794_info = { .gen = 2, > .features = RCAR_DU_FEATURE_CRTC_IRQ_CLOCK > | RCAR_DU_FEATURE_EXT_CTRL_REGS, > - .num_crtcs = 2, > + .channel_mask = BIT(0) | BIT(1), > .routes = { > /* > * R8A7794 has two RGB outputs and one (currently unsupported) > @@ -191,7 +191,7 @@ static const struct rcar_du_device_info > rcar_du_r8a7795_info = { .features = RCAR_DU_FEATURE_CRTC_IRQ_CLOCK > | RCAR_DU_FEATURE_EXT_CTRL_REGS > | RCAR_DU_FEATURE_VSP1_SOURCE, > - .num_crtcs = 4, > + .channel_mask = BIT(0) | BIT(1) | BIT(2) | BIT(3), > .routes = { > /* > * R8A7795 has one RGB output, two HDMI outputs and one > @@ -223,7 +223,7 @@ static const struct rcar_du_device_info > rcar_du_r8a7796_info = { .features = RCAR_DU_FEATURE_CRTC_IRQ_CLOCK > | RCAR_DU_FEATURE_EXT_CTRL_REGS > | RCAR_DU_FEATURE_VSP1_SOURCE, > - .num_crtcs = 3, > + .channel_mask = BIT(0) | BIT(1) | BIT(2), > .routes = { > /* > * R8A7796 has one RGB output, one LVDS output and one HDMI > @@ -251,7 +251,7 @@ static const struct rcar_du_device_info > rcar_du_r8a77970_info = { .features = RCAR_DU_FEATURE_CRTC_IRQ_CLOCK > | RCAR_DU_FEATURE_EXT_CTRL_REGS > | RCAR_DU_FEATURE_VSP1_SOURCE, > - .num_crtcs = 1, > + .channel_mask = BIT(0), > .routes = { > /* R8A77970 has one RGB output and one LVDS output. */ > [RCAR_DU_OUTPUT_DPAD0] = { > diff --git a/drivers/gpu/drm/rcar-du/rcar_du_drv.h > b/drivers/gpu/drm/rcar-du/rcar_du_drv.h index 5c7ec15818c7..7a5de66deec2 > 100644 > --- a/drivers/gpu/drm/rcar-du/rcar_du_drv.h > +++ b/drivers/gpu/drm/rcar-du/rcar_du_drv.h > @@ -52,7 +52,7 @@ struct rcar_du_output_routing { > * @gen: device generation (2 or 3) > * @features: device features (RCAR_DU_FEATURE_*) > * @quirks: device quirks (RCAR_DU_QUIRK_*) > - * @num_crtcs: total number of CRTCs > + * @channel_mask: bit mask of supported DU channels Nitpicking, how about channels_mask ? > * @routes: array of CRTC to output routes, indexed by output > (RCAR_DU_OUTPUT_*) * @num_lvds: number of internal LVDS encoders > */ > @@ -60,7 +60,7 @@ struct rcar_du_device_info { > unsigned int gen; > unsigned int features; > unsigned int quirks; > - unsigned int num_crtcs; > + unsigned int channel_mask; > struct rcar_du_output_routing routes[RCAR_DU_OUTPUT_MAX]; > unsigned int num_lvds; > unsigned int dpll_ch; > diff --git a/drivers/gpu/drm/rcar-du/rcar_du_kms.c > b/drivers/gpu/drm/rcar-du/rcar_du_kms.c index cf5b422fc753..19a445fbc879 > 100644 > --- a/drivers/gpu/drm/rcar-du/rcar_du_kms.c > +++ b/drivers/gpu/drm/rcar-du/rcar_du_kms.c > @@ -559,6 +559,7 @@ int rcar_du_modeset_init(struct rcar_du_device *rcdu) > struct drm_fbdev_cma *fbdev; > unsigned int num_encoders; > unsigned int num_groups; > + unsigned int swi, hwi; One variable per line please. I would also call them swindex and hwindex, that would be clearer in my opinion. > unsigned int i; > int ret; > > @@ -571,7 +572,7 @@ int rcar_du_modeset_init(struct rcar_du_device *rcdu) > dev->mode_config.funcs = &rcar_du_mode_config_funcs; > dev->mode_config.helper_private = &rcar_du_mode_config_helper; > > - rcdu->num_crtcs = rcdu->info->num_crtcs; > + rcdu->num_crtcs = hweight8(rcdu->info->channel_mask); > > ret = rcar_du_properties_init(rcdu); > if (ret < 0) > @@ -581,7 +582,7 @@ int rcar_du_modeset_init(struct rcar_du_device *rcdu) > * Initialize vertical blanking interrupts handling. Start with vblank > * disabled for all CRTCs. > */ > - ret = drm_vblank_init(dev, (1 << rcdu->info->num_crtcs) - 1); > + ret = drm_vblank_init(dev, (1 << rcdu->num_crtcs) - 1); > if (ret < 0) > return ret; > > @@ -623,10 +624,16 @@ int rcar_du_modeset_init(struct rcar_du_device *rcdu) > } > > /* Create the CRTCs. */ > - for (i = 0; i < rcdu->num_crtcs; ++i) { > - struct rcar_du_group *rgrp = &rcdu->groups[i / 2]; > + for (swi = 0, hwi = 0; swi < rcdu->num_crtcs; ++hwi) { > + struct rcar_du_group *rgrp; > + > + /* Skip unpopulated DU channels */ s/channels/channels./ > + if (!(rcdu->info->channel_mask & BIT(hwi))) > + continue; > + > + rgrp = &rcdu->groups[hwi / 2]; > > - ret = rcar_du_crtc_create(rgrp, i); > + ret = rcar_du_crtc_create(rgrp, swi++, hwi); > if (ret < 0) > return ret; > } This is going to turn into an infinite loop if we ever get the num_crtcs calculation wrong, but I don't see why that should be the case, so I'm OK with the implementation. With all those small issues fixed, Reviewed-by: Laurent Pinchart -- Regards, Laurent Pinchart From mboxrd@z Thu Jan 1 00:00:00 1970 From: Laurent Pinchart Subject: Re: [PATCH 05/17] drm: rcar-du: Split CRTC handling to support hardware indexing Date: Thu, 26 Apr 2018 23:30:52 +0300 Message-ID: <8207827.UIER1Ri0ED@avalon> References: <20180426165346.494-1-kieran.bingham+renesas@ideasonboard.com> <20180426165346.494-6-kieran.bingham+renesas@ideasonboard.com> 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 [IPv6:2001:4b98:dc2:55:216:3eff:fef7:d647]) by gabe.freedesktop.org (Postfix) with ESMTPS id C312B6E762 for ; Thu, 26 Apr 2018 20:30:38 +0000 (UTC) In-Reply-To: <20180426165346.494-6-kieran.bingham+renesas@ideasonboard.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Kieran Bingham Cc: linux-renesas-soc@vger.kernel.org, David Airlie , open list , "open list:DRM DRIVERS FOR RENESAS" List-Id: dri-devel@lists.freedesktop.org SGkgS2llcmFuLAoKVGhhbmsgeW91IGZvciB0aGUgcGF0Y2guCgpPbiBUaHVyc2RheSwgMjYgQXBy aWwgMjAxOCAxOTo1MzozNCBFRVNUIEtpZXJhbiBCaW5naGFtIHdyb3RlOgo+IFRoZSBEVSBDUlRD IGRyaXZlciBkb2VzIG5vdCBzdXBwb3J0IGRpc3Rpbmd1aXNoaW5nIGJldHdlZW4gYSBoYXJkd2Fy ZQo+IGluZGV4LCBhbmQgYSBzb2Z0d2FyZSAoQ1JUQykgaW5kZXggaW4gdGhlIGV2ZW50IHRoYXQg YSBEVSBjaGFubmVsIG1pZ2h0Cj4gbm90IGJlIHBvcHVsYXRlZCBieSB0aGUgaGFyZHdhcmUuCj4g Cj4gU3VwcG9ydCB0aGlzIGJ5IGFkYXB0aW5nIHRoZSByY2FyX2R1X2RldmljZV9pbmZvIHN0cnVj dHVyZSB0byBzdG9yZSBhCj4gYml0bWFzayBvZiBhdmFpbGFibGUgY2hhbm5lbHMgcmF0aGVyIHRo YW4gYSBjb3VudCBvZiBDUlRDcy4gVGhlIGNvdW50Cj4gY2FuIHRoZW4gYmUgb2J0YWluZWQgYnkg ZGV0ZXJtaW5pbmcgdGhlIGhhbW1pbmcgd2VpZ2h0IG9mIHRoZSBiaXRtYXNrLgo+IAo+IFRoaXMg YWxsb3dzIHRoZSByY2FyX2R1X2NydGNfY3JlYXRlKCkgZnVuY3Rpb24gdG8gZGlzdGluZ3Vpc2gg YmV0d2Vlbgo+IGJvdGggaW5kZXggdHlwZXMsIGFuZCBub24tcG9wdWxhdGVkIERVIGNoYW5uZWxz IHdpbGwgYmUgc2tpcHBlZCB3aXRob3V0Cj4gbGVhdmluZyBhIGdhcCBpbiB0aGUgc29mdHdhcmUg Q1JUQyBpbmRleGVzLgo+IAo+IFNpZ25lZC1vZmYtYnk6IEtpZXJhbiBCaW5naGFtIDxraWVyYW4u YmluZ2hhbStyZW5lc2FzQGlkZWFzb25ib2FyZC5jb20+Cj4gLS0tCj4gIGRyaXZlcnMvZ3B1L2Ry bS9yY2FyLWR1L3JjYXJfZHVfY3J0Yy5jIHwgMjYgKysrKysrKysrKysrKystLS0tLS0tLS0tLS0K PiAgZHJpdmVycy9ncHUvZHJtL3JjYXItZHUvcmNhcl9kdV9jcnRjLmggfCAgMyArKy0KPiAgZHJp dmVycy9ncHUvZHJtL3JjYXItZHUvcmNhcl9kdV9kcnYuYyAgfCAyMCArKysrKysrKysrLS0tLS0t LS0tLQo+ICBkcml2ZXJzL2dwdS9kcm0vcmNhci1kdS9yY2FyX2R1X2Rydi5oICB8ICA0ICsrLS0K PiAgZHJpdmVycy9ncHUvZHJtL3JjYXItZHUvcmNhcl9kdV9rbXMuYyAgfCAxNyArKysrKysrKysr KystLS0tLQo+ICA1IGZpbGVzIGNoYW5nZWQsIDQwIGluc2VydGlvbnMoKyksIDMwIGRlbGV0aW9u cygtKQo+IAo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcmNhci1kdS9yY2FyX2R1X2Ny dGMuYwo+IGIvZHJpdmVycy9ncHUvZHJtL3JjYXItZHUvcmNhcl9kdV9jcnRjLmMgaW5kZXggNWEx NWRmZDY2MzQzLi4zNmNlMTk0YzEzYjUKPiAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0v cmNhci1kdS9yY2FyX2R1X2NydGMuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS9yY2FyLWR1L3Jj YXJfZHVfY3J0Yy5jCj4gQEAgLTkwMiw3ICs5MDIsOCBAQCBzdGF0aWMgaXJxcmV0dXJuX3QgcmNh cl9kdV9jcnRjX2lycShpbnQgaXJxLCB2b2lkICphcmcpCj4gICAqIEluaXRpYWxpemF0aW9uCj4g ICAqLwo+IAo+IC1pbnQgcmNhcl9kdV9jcnRjX2NyZWF0ZShzdHJ1Y3QgcmNhcl9kdV9ncm91cCAq cmdycCwgdW5zaWduZWQgaW50IGluZGV4KQo+ICtpbnQgcmNhcl9kdV9jcnRjX2NyZWF0ZShzdHJ1 Y3QgcmNhcl9kdV9ncm91cCAqcmdycCwgdW5zaWduZWQgaW50IHN3aW5kZXgsCj4gKwkJCXVuc2ln bmVkIGludCBod2luZGV4KQo+ICB7Cj4gIAlzdGF0aWMgY29uc3QgdW5zaWduZWQgaW50IG1taW9f b2Zmc2V0c1tdID0gewo+ICAJCURVMF9SRUdfT0ZGU0VULCBEVTFfUkVHX09GRlNFVCwgRFUyX1JF R19PRkZTRVQsIERVM19SRUdfT0ZGU0VUCj4gQEAgLTkxMCw3ICs5MTEsNyBAQCBpbnQgcmNhcl9k dV9jcnRjX2NyZWF0ZShzdHJ1Y3QgcmNhcl9kdV9ncm91cCAqcmdycCwKPiB1bnNpZ25lZCBpbnQg aW5kZXgpCj4gCj4gIAlzdHJ1Y3QgcmNhcl9kdV9kZXZpY2UgKnJjZHUgPSByZ3JwLT5kZXY7Cj4g IAlzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2ID0gdG9fcGxhdGZvcm1fZGV2aWNlKHJjZHUt PmRldik7Cj4gLQlzdHJ1Y3QgcmNhcl9kdV9jcnRjICpyY3J0YyA9ICZyY2R1LT5jcnRjc1tpbmRl eF07Cj4gKwlzdHJ1Y3QgcmNhcl9kdV9jcnRjICpyY3J0YyA9ICZyY2R1LT5jcnRjc1tzd2luZGV4 XTsKPiAgCXN0cnVjdCBkcm1fY3J0YyAqY3J0YyA9ICZyY3J0Yy0+Y3J0YzsKPiAgCXN0cnVjdCBk cm1fcGxhbmUgKnByaW1hcnk7Cj4gIAl1bnNpZ25lZCBpbnQgaXJxZmxhZ3M7Cj4gQEAgLTkyMiw3 ICs5MjMsNyBAQCBpbnQgcmNhcl9kdV9jcnRjX2NyZWF0ZShzdHJ1Y3QgcmNhcl9kdV9ncm91cCAq cmdycCwKPiB1bnNpZ25lZCBpbnQgaW5kZXgpCj4gCj4gIAkvKiBHZXQgdGhlIENSVEMgY2xvY2sg YW5kIHRoZSBvcHRpb25hbCBleHRlcm5hbCBjbG9jay4gKi8KPiAgCWlmIChyY2FyX2R1X2hhcyhy Y2R1LCBSQ0FSX0RVX0ZFQVRVUkVfQ1JUQ19JUlFfQ0xPQ0spKSB7Cj4gLQkJc3ByaW50ZihjbGtf bmFtZSwgImR1LiV1IiwgaW5kZXgpOwo+ICsJCXNwcmludGYoY2xrX25hbWUsICJkdS4ldSIsIGh3 aW5kZXgpOwo+ICAJCW5hbWUgPSBjbGtfbmFtZTsKPiAgCX0gZWxzZSB7Cj4gIAkJbmFtZSA9IE5V TEw7Cj4gQEAgLTkzMCwxNiArOTMxLDE2IEBAIGludCByY2FyX2R1X2NydGNfY3JlYXRlKHN0cnVj dCByY2FyX2R1X2dyb3VwICpyZ3JwLAo+IHVuc2lnbmVkIGludCBpbmRleCkKPiAKPiAgCXJjcnRj LT5jbG9jayA9IGRldm1fY2xrX2dldChyY2R1LT5kZXYsIG5hbWUpOwo+ICAJaWYgKElTX0VSUihy Y3J0Yy0+Y2xvY2spKSB7Cj4gLQkJZGV2X2VycihyY2R1LT5kZXYsICJubyBjbG9jayBmb3IgQ1JU QyAldVxuIiwgaW5kZXgpOwo+ICsJCWRldl9lcnIocmNkdS0+ZGV2LCAibm8gY2xvY2sgZm9yIENS VEMgJXVcbiIsIHN3aW5kZXgpOwoKSG93IGFib3V0CgoJCWRldl9lcnIocmNkdS0+ZGV2LCAibm8g Y2xvY2sgZm9yIERVIGNoYW5uZWwgJXVcbiIsIGh3aW5kZXgpOwoKSSB0aGluayB0aGF0IHdvdWxk IGJlIGNsZWFyZXIsIGJlY2F1c2UgYXQgdGhpcyBzdGFnZSB3ZSdyZSBkZWFsaW5nIHdpdGggCmhh cmR3YXJlIHJlc291cmNlcywgc28gbWF0Y2hpbmcgdGhlIGRhdGFzaGVldCBudW1iZXJzIHNlZW1z IGJldHRlciB0byBtZS4KCj4gIAkJcmV0dXJuIFBUUl9FUlIocmNydGMtPmNsb2NrKTsKPiAgCX0K PiAKPiAtCXNwcmludGYoY2xrX25hbWUsICJkY2xraW4uJXUiLCBpbmRleCk7Cj4gKwlzcHJpbnRm KGNsa19uYW1lLCAiZGNsa2luLiV1IiwgaHdpbmRleCk7Cj4gIAljbGsgPSBkZXZtX2Nsa19nZXQo cmNkdS0+ZGV2LCBjbGtfbmFtZSk7Cj4gIAlpZiAoIUlTX0VSUihjbGspKSB7Cj4gIAkJcmNydGMt PmV4dGNsb2NrID0gY2xrOwo+ICAJfSBlbHNlIGlmIChQVFJfRVJSKHJjcnRjLT5jbG9jaykgPT0g LUVQUk9CRV9ERUZFUikgewo+IC0JCWRldl9pbmZvKHJjZHUtPmRldiwgImNhbid0IGdldCBleHRl cm5hbCBjbG9jayAldVxuIiwgaW5kZXgpOwo+ICsJCWRldl9pbmZvKHJjZHUtPmRldiwgImNhbid0 IGdldCBleHRlcm5hbCBjbG9jayAldVxuIiwgaHdpbmRleCk7Cj4gIAkJcmV0dXJuIC1FUFJPQkVf REVGRVI7Cj4gIAl9Cj4gCj4gQEAgLTk0OCwxMyArOTQ5LDEzIEBAIGludCByY2FyX2R1X2NydGNf Y3JlYXRlKHN0cnVjdCByY2FyX2R1X2dyb3VwICpyZ3JwLAo+IHVuc2lnbmVkIGludCBpbmRleCkg c3Bpbl9sb2NrX2luaXQoJnJjcnRjLT52YmxhbmtfbG9jayk7Cj4gCj4gIAlyY3J0Yy0+Z3JvdXAg PSByZ3JwOwo+IC0JcmNydGMtPm1taW9fb2Zmc2V0ID0gbW1pb19vZmZzZXRzW2luZGV4XTsKPiAt CXJjcnRjLT5pbmRleCA9IGluZGV4Owo+ICsJcmNydGMtPm1taW9fb2Zmc2V0ID0gbW1pb19vZmZz ZXRzW2h3aW5kZXhdOwo+ICsJcmNydGMtPmluZGV4ID0gaHdpbmRleDsKPiAKPiAgCWlmIChyY2Fy X2R1X2hhcyhyY2R1LCBSQ0FSX0RVX0ZFQVRVUkVfVlNQMV9TT1VSQ0UpKQo+ICAJCXByaW1hcnkg PSAmcmNydGMtPnZzcC0+cGxhbmVzW3JjcnRjLT52c3BfcGlwZV0ucGxhbmU7Cj4gIAllbHNlCj4g LQkJcHJpbWFyeSA9ICZyZ3JwLT5wbGFuZXNbaW5kZXggJSAyXS5wbGFuZTsKPiArCQlwcmltYXJ5 ID0gJnJncnAtPnBsYW5lc1tod2luZGV4ICUgMl0ucGxhbmU7CgpUaGlzIHNob3VsZG4ndCBtYWtl IGEgZGlmZmVyZW5jZSBiZWNhdXNlIHdoZW4gUkNBUl9EVV9GRUFUVVJFX1ZTUDFfU09VUkNFIApp c24ndCBzZXQgd2UncmUgcnVubmluZyBvbiBHZW4yLCBhbmQgZG9uJ3QgbmVlZCB0byBkZWFsIHdp dGggaW5kaWNlcywgYnV0IGZyb20gCmEgY29uY2VwdHVhbCBwb2ludCBvZiB2aWV3LCB3b3VsZG4n dCB0aGUgc29mdHdhcmUgaW5kZXggYmUgYmV0dGVyIGhlcmUgPyAKTWlzc2luZyBoYXJkd2FyZSBj aGFubmVscyB3b24ndCBiZSB2aXNpYmxlIGZyb20gdXNlcnNwYWNlLCBzbyB0YWtpbmcgdGhlIGZp cnN0IApwbGFuZSBvZiB0aGUgZ3JvdXAgYXMgdGhlIHByaW1hcnkgcGxhbmUgd291bGQgc2VlbSBi ZXR0ZXIgdG8gbWUuCgo+ICAJcmV0ID0gZHJtX2NydGNfaW5pdF93aXRoX3BsYW5lcyhyY2R1LT5k ZGV2LCBjcnRjLCBwcmltYXJ5LCBOVUxMLAo+ICAJCQkJCXJjZHUtPmluZm8tPmdlbiA8PSAyID8K PiBAQCAtOTcwLDcgKzk3MSw4IEBAIGludCByY2FyX2R1X2NydGNfY3JlYXRlKHN0cnVjdCByY2Fy X2R1X2dyb3VwICpyZ3JwLAo+IHVuc2lnbmVkIGludCBpbmRleCkKPiAKPiAgCS8qIFJlZ2lzdGVy IHRoZSBpbnRlcnJ1cHQgaGFuZGxlci4gKi8KPiAgCWlmIChyY2FyX2R1X2hhcyhyY2R1LCBSQ0FS X0RVX0ZFQVRVUkVfQ1JUQ19JUlFfQ0xPQ0spKSB7Cj4gLQkJaXJxID0gcGxhdGZvcm1fZ2V0X2ly cShwZGV2LCBpbmRleCk7Cj4gKwkJLyogVGhlIElSUSdzIGFyZSBhc3NvY2lhdGVkIHdpdGggdGhl IENSVEMgKHN3KWluZGV4ICovCgpzL2luZGV4L2luZGV4Li8KCj4gKwkJaXJxID0gcGxhdGZvcm1f Z2V0X2lycShwZGV2LCBzd2luZGV4KTsKPiAgCQlpcnFmbGFncyA9IDA7Cj4gIAl9IGVsc2Ugewo+ ICAJCWlycSA9IHBsYXRmb3JtX2dldF9pcnEocGRldiwgMCk7Cj4gQEAgLTk3OCw3ICs5ODAsNyBA QCBpbnQgcmNhcl9kdV9jcnRjX2NyZWF0ZShzdHJ1Y3QgcmNhcl9kdV9ncm91cCAqcmdycCwKPiB1 bnNpZ25lZCBpbnQgaW5kZXgpIH0KPiAKPiAgCWlmIChpcnEgPCAwKSB7Cj4gLQkJZGV2X2Vycihy Y2R1LT5kZXYsICJubyBJUlEgZm9yIENSVEMgJXVcbiIsIGluZGV4KTsKPiArCQlkZXZfZXJyKHJj ZHUtPmRldiwgIm5vIElSUSBmb3IgQ1JUQyAldVxuIiwgc3dpbmRleCk7Cj4gIAkJcmV0dXJuIGly cTsKPiAgCX0KPiAKPiBAQCAtOTg2LDcgKzk4OCw3IEBAIGludCByY2FyX2R1X2NydGNfY3JlYXRl KHN0cnVjdCByY2FyX2R1X2dyb3VwICpyZ3JwLAo+IHVuc2lnbmVkIGludCBpbmRleCkgZGV2X25h bWUocmNkdS0+ZGV2KSwgcmNydGMpOwo+ICAJaWYgKHJldCA8IDApIHsKPiAgCQlkZXZfZXJyKHJj ZHUtPmRldiwKPiAtCQkJImZhaWxlZCB0byByZWdpc3RlciBJUlEgZm9yIENSVEMgJXVcbiIsIGlu ZGV4KTsKPiArCQkJImZhaWxlZCB0byByZWdpc3RlciBJUlEgZm9yIENSVEMgJXVcbiIsIHN3aW5k ZXgpOwo+ICAJCXJldHVybiByZXQ7Cj4gIAl9Cj4gCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1 L2RybS9yY2FyLWR1L3JjYXJfZHVfY3J0Yy5oCj4gYi9kcml2ZXJzL2dwdS9kcm0vcmNhci1kdS9y Y2FyX2R1X2NydGMuaCBpbmRleCA1MThlZTJjNjBlYjguLjVmMDAzYTE2YWJjNQo+IDEwMDY0NAo+ IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9yY2FyLWR1L3JjYXJfZHVfY3J0Yy5oCj4gKysrIGIvZHJp dmVycy9ncHUvZHJtL3JjYXItZHUvcmNhcl9kdV9jcnRjLmgKPiBAQCAtOTksNyArOTksOCBAQCBl bnVtIHJjYXJfZHVfb3V0cHV0IHsKPiAgCVJDQVJfRFVfT1VUUFVUX01BWCwKPiAgfTsKPiAKPiAt aW50IHJjYXJfZHVfY3J0Y19jcmVhdGUoc3RydWN0IHJjYXJfZHVfZ3JvdXAgKnJncnAsIHVuc2ln bmVkIGludCBpbmRleCk7Cj4gK2ludCByY2FyX2R1X2NydGNfY3JlYXRlKHN0cnVjdCByY2FyX2R1 X2dyb3VwICpyZ3JwLCB1bnNpZ25lZCBpbnQgc3dpbmRleCwKPiArCQkJdW5zaWduZWQgaW50IGh3 aW5kZXgpOwo+ICB2b2lkIHJjYXJfZHVfY3J0Y19zdXNwZW5kKHN0cnVjdCByY2FyX2R1X2NydGMg KnJjcnRjKTsKPiAgdm9pZCByY2FyX2R1X2NydGNfcmVzdW1lKHN0cnVjdCByY2FyX2R1X2NydGMg KnJjcnRjKTsKPiAKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3JjYXItZHUvcmNhcl9k dV9kcnYuYwo+IGIvZHJpdmVycy9ncHUvZHJtL3JjYXItZHUvcmNhcl9kdV9kcnYuYyBpbmRleCAw NTc0NWU4NmQ3M2UuLmQ2ZWJjNjI4ZmMyMgo+IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2Ry bS9yY2FyLWR1L3JjYXJfZHVfZHJ2LmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vcmNhci1kdS9y Y2FyX2R1X2Rydi5jCj4gQEAgLTQwLDcgKzQwLDcgQEAgc3RhdGljIGNvbnN0IHN0cnVjdCByY2Fy X2R1X2RldmljZV9pbmZvCj4gcnpnMV9kdV9yOGE3NzQzX2luZm8gPSB7IC5nZW4gPSAyLAo+ICAJ LmZlYXR1cmVzID0gUkNBUl9EVV9GRUFUVVJFX0NSVENfSVJRX0NMT0NLCj4gIAkJICB8IFJDQVJf RFVfRkVBVFVSRV9FWFRfQ1RSTF9SRUdTLAo+IC0JLm51bV9jcnRjcyA9IDIsCj4gKwkuY2hhbm5l bF9tYXNrID0gQklUKDApIHwgQklUKDEpLAoKSSdkIHdyaXRlIGl0IEJJVCgxKSB8IEJJVCgwKSB0 byBtYXRjaCB0aGUgdXN1YWwgbGl0dGxlLWVuZGlhbiBvcmRlci4gU2FtZSAKY29tbWVudCBmb3Ig dGhlIG90aGVyIGluZm8gc3RydWN0dXJlIGluc3RhbmNlcy4KCj4gIAkucm91dGVzID0gewo+ICAJ CS8qCj4gIAkJICogUjhBNzc0MyBoYXMgb25lIFJHQiBvdXRwdXQgYW5kIG9uZSBMVkRTIG91dHB1 dAo+IEBAIC02MSw3ICs2MSw3IEBAIHN0YXRpYyBjb25zdCBzdHJ1Y3QgcmNhcl9kdV9kZXZpY2Vf aW5mbwo+IHJ6ZzFfZHVfcjhhNzc0NV9pbmZvID0geyAuZ2VuID0gMiwKPiAgCS5mZWF0dXJlcyA9 IFJDQVJfRFVfRkVBVFVSRV9DUlRDX0lSUV9DTE9DSwo+ICAJCSAgfCBSQ0FSX0RVX0ZFQVRVUkVf RVhUX0NUUkxfUkVHUywKPiAtCS5udW1fY3J0Y3MgPSAyLAo+ICsJLmNoYW5uZWxfbWFzayA9IEJJ VCgwKSB8IEJJVCgxKSwKPiAgCS5yb3V0ZXMgPSB7Cj4gIAkJLyoKPiAgCQkgKiBSOEE3NzQ1IGhh cyB0d28gUkdCIG91dHB1dHMKPiBAQCAtODAsNyArODAsNyBAQCBzdGF0aWMgY29uc3Qgc3RydWN0 IHJjYXJfZHVfZGV2aWNlX2luZm8KPiByemcxX2R1X3I4YTc3NDVfaW5mbyA9IHsgc3RhdGljIGNv bnN0IHN0cnVjdCByY2FyX2R1X2RldmljZV9pbmZvCj4gcmNhcl9kdV9yOGE3Nzc5X2luZm8gPSB7 Cj4gIAkuZ2VuID0gMiwKPiAgCS5mZWF0dXJlcyA9IDAsCj4gLQkubnVtX2NydGNzID0gMiwKPiAr CS5jaGFubmVsX21hc2sgPSBCSVQoMCkgfCBCSVQoMSksCj4gIAkucm91dGVzID0gewo+ICAJCS8q Cj4gIAkJICogUjhBNzc3OSBoYXMgdHdvIFJHQiBvdXRwdXRzIGFuZCBvbmUgKGN1cnJlbnRseSB1 bnN1cHBvcnRlZCkKPiBAQCAtMTAyLDcgKzEwMiw3IEBAIHN0YXRpYyBjb25zdCBzdHJ1Y3QgcmNh cl9kdV9kZXZpY2VfaW5mbwo+IHJjYXJfZHVfcjhhNzc5MF9pbmZvID0geyAuZmVhdHVyZXMgPSBS Q0FSX0RVX0ZFQVRVUkVfQ1JUQ19JUlFfQ0xPQ0sKPiAgCQkgIHwgUkNBUl9EVV9GRUFUVVJFX0VY VF9DVFJMX1JFR1MsCj4gIAkucXVpcmtzID0gUkNBUl9EVV9RVUlSS19BTElHTl8xMjhCLAo+IC0J Lm51bV9jcnRjcyA9IDMsCj4gKwkuY2hhbm5lbF9tYXNrID0gQklUKDApIHwgQklUKDEpIHwgQklU KDIpLAo+ICAJLnJvdXRlcyA9IHsKPiAgCQkvKgo+ICAJCSAqIFI4QTc3OTAgaGFzIG9uZSBSR0Ig b3V0cHV0LCB0d28gTFZEUyBvdXRwdXRzIGFuZCBvbmUKPiBAQCAtMTI5LDcgKzEyOSw3IEBAIHN0 YXRpYyBjb25zdCBzdHJ1Y3QgcmNhcl9kdV9kZXZpY2VfaW5mbwo+IHJjYXJfZHVfcjhhNzc5MV9p bmZvID0geyAuZ2VuID0gMiwKPiAgCS5mZWF0dXJlcyA9IFJDQVJfRFVfRkVBVFVSRV9DUlRDX0lS UV9DTE9DSwo+ICAJCSAgfCBSQ0FSX0RVX0ZFQVRVUkVfRVhUX0NUUkxfUkVHUywKPiAtCS5udW1f Y3J0Y3MgPSAyLAo+ICsJLmNoYW5uZWxfbWFzayA9IEJJVCgwKSB8IEJJVCgxKSwKPiAgCS5yb3V0 ZXMgPSB7Cj4gIAkJLyoKPiAgCQkgKiBSOEE3NzlbMTNdIGhhcyBvbmUgUkdCIG91dHB1dCwgb25l IExWRFMgb3V0cHV0IGFuZCBvbmUKPiBAQCAtMTUxLDcgKzE1MSw3IEBAIHN0YXRpYyBjb25zdCBz dHJ1Y3QgcmNhcl9kdV9kZXZpY2VfaW5mbwo+IHJjYXJfZHVfcjhhNzc5Ml9pbmZvID0geyAuZ2Vu ID0gMiwKPiAgCS5mZWF0dXJlcyA9IFJDQVJfRFVfRkVBVFVSRV9DUlRDX0lSUV9DTE9DSwo+ICAJ CSAgfCBSQ0FSX0RVX0ZFQVRVUkVfRVhUX0NUUkxfUkVHUywKPiAtCS5udW1fY3J0Y3MgPSAyLAo+ ICsJLmNoYW5uZWxfbWFzayA9IEJJVCgwKSB8IEJJVCgxKSwKPiAgCS5yb3V0ZXMgPSB7Cj4gIAkJ LyogUjhBNzc5MiBoYXMgdHdvIFJHQiBvdXRwdXRzLiAqLwo+ICAJCVtSQ0FSX0RVX09VVFBVVF9E UEFEMF0gPSB7Cj4gQEAgLTE2OSw3ICsxNjksNyBAQCBzdGF0aWMgY29uc3Qgc3RydWN0IHJjYXJf ZHVfZGV2aWNlX2luZm8KPiByY2FyX2R1X3I4YTc3OTRfaW5mbyA9IHsgLmdlbiA9IDIsCj4gIAku ZmVhdHVyZXMgPSBSQ0FSX0RVX0ZFQVRVUkVfQ1JUQ19JUlFfQ0xPQ0sKPiAgCQkgIHwgUkNBUl9E VV9GRUFUVVJFX0VYVF9DVFJMX1JFR1MsCj4gLQkubnVtX2NydGNzID0gMiwKPiArCS5jaGFubmVs X21hc2sgPSBCSVQoMCkgfCBCSVQoMSksCj4gIAkucm91dGVzID0gewo+ICAJCS8qCj4gIAkJICog UjhBNzc5NCBoYXMgdHdvIFJHQiBvdXRwdXRzIGFuZCBvbmUgKGN1cnJlbnRseSB1bnN1cHBvcnRl ZCkKPiBAQCAtMTkxLDcgKzE5MSw3IEBAIHN0YXRpYyBjb25zdCBzdHJ1Y3QgcmNhcl9kdV9kZXZp Y2VfaW5mbwo+IHJjYXJfZHVfcjhhNzc5NV9pbmZvID0geyAuZmVhdHVyZXMgPSBSQ0FSX0RVX0ZF QVRVUkVfQ1JUQ19JUlFfQ0xPQ0sKPiAgCQkgIHwgUkNBUl9EVV9GRUFUVVJFX0VYVF9DVFJMX1JF R1MKPiAgCQkgIHwgUkNBUl9EVV9GRUFUVVJFX1ZTUDFfU09VUkNFLAo+IC0JLm51bV9jcnRjcyA9 IDQsCj4gKwkuY2hhbm5lbF9tYXNrID0gQklUKDApIHwgQklUKDEpIHwgQklUKDIpIHwgQklUKDMp LAo+ICAJLnJvdXRlcyA9IHsKPiAgCQkvKgo+ICAJCSAqIFI4QTc3OTUgaGFzIG9uZSBSR0Igb3V0 cHV0LCB0d28gSERNSSBvdXRwdXRzIGFuZCBvbmUKPiBAQCAtMjIzLDcgKzIyMyw3IEBAIHN0YXRp YyBjb25zdCBzdHJ1Y3QgcmNhcl9kdV9kZXZpY2VfaW5mbwo+IHJjYXJfZHVfcjhhNzc5Nl9pbmZv ID0geyAuZmVhdHVyZXMgPSBSQ0FSX0RVX0ZFQVRVUkVfQ1JUQ19JUlFfQ0xPQ0sKPiAgCQkgIHwg UkNBUl9EVV9GRUFUVVJFX0VYVF9DVFJMX1JFR1MKPiAgCQkgIHwgUkNBUl9EVV9GRUFUVVJFX1ZT UDFfU09VUkNFLAo+IC0JLm51bV9jcnRjcyA9IDMsCj4gKwkuY2hhbm5lbF9tYXNrID0gQklUKDAp IHwgQklUKDEpIHwgQklUKDIpLAo+ICAJLnJvdXRlcyA9IHsKPiAgCQkvKgo+ICAJCSAqIFI4QTc3 OTYgaGFzIG9uZSBSR0Igb3V0cHV0LCBvbmUgTFZEUyBvdXRwdXQgYW5kIG9uZSBIRE1JCj4gQEAg LTI1MSw3ICsyNTEsNyBAQCBzdGF0aWMgY29uc3Qgc3RydWN0IHJjYXJfZHVfZGV2aWNlX2luZm8K PiByY2FyX2R1X3I4YTc3OTcwX2luZm8gPSB7IC5mZWF0dXJlcyA9IFJDQVJfRFVfRkVBVFVSRV9D UlRDX0lSUV9DTE9DSwo+ICAJCSAgfCBSQ0FSX0RVX0ZFQVRVUkVfRVhUX0NUUkxfUkVHUwo+ICAJ CSAgfCBSQ0FSX0RVX0ZFQVRVUkVfVlNQMV9TT1VSQ0UsCj4gLQkubnVtX2NydGNzID0gMSwKPiAr CS5jaGFubmVsX21hc2sgPSBCSVQoMCksCj4gIAkucm91dGVzID0gewo+ICAJCS8qIFI4QTc3OTcw IGhhcyBvbmUgUkdCIG91dHB1dCBhbmQgb25lIExWRFMgb3V0cHV0LiAqLwo+ICAJCVtSQ0FSX0RV X09VVFBVVF9EUEFEMF0gPSB7Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9yY2FyLWR1 L3JjYXJfZHVfZHJ2LmgKPiBiL2RyaXZlcnMvZ3B1L2RybS9yY2FyLWR1L3JjYXJfZHVfZHJ2Lmgg aW5kZXggNWM3ZWMxNTgxOGM3Li43YTVkZTY2ZGVlYzIKPiAxMDA2NDQKPiAtLS0gYS9kcml2ZXJz L2dwdS9kcm0vcmNhci1kdS9yY2FyX2R1X2Rydi5oCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL3Jj YXItZHUvcmNhcl9kdV9kcnYuaAo+IEBAIC01Miw3ICs1Miw3IEBAIHN0cnVjdCByY2FyX2R1X291 dHB1dF9yb3V0aW5nIHsKPiAgICogQGdlbjogZGV2aWNlIGdlbmVyYXRpb24gKDIgb3IgMykKPiAg ICogQGZlYXR1cmVzOiBkZXZpY2UgZmVhdHVyZXMgKFJDQVJfRFVfRkVBVFVSRV8qKQo+ICAgKiBA cXVpcmtzOiBkZXZpY2UgcXVpcmtzIChSQ0FSX0RVX1FVSVJLXyopCj4gLSAqIEBudW1fY3J0Y3M6 IHRvdGFsIG51bWJlciBvZiBDUlRDcwo+ICsgKiBAY2hhbm5lbF9tYXNrOiBiaXQgbWFzayBvZiBz dXBwb3J0ZWQgRFUgY2hhbm5lbHMKCk5pdHBpY2tpbmcsIGhvdyBhYm91dCBjaGFubmVsc19tYXNr ID8KCj4gICAqIEByb3V0ZXM6IGFycmF5IG9mIENSVEMgdG8gb3V0cHV0IHJvdXRlcywgaW5kZXhl ZCBieSBvdXRwdXQKPiAoUkNBUl9EVV9PVVRQVVRfKikgKiBAbnVtX2x2ZHM6IG51bWJlciBvZiBp bnRlcm5hbCBMVkRTIGVuY29kZXJzCj4gICAqLwo+IEBAIC02MCw3ICs2MCw3IEBAIHN0cnVjdCBy Y2FyX2R1X2RldmljZV9pbmZvIHsKPiAgCXVuc2lnbmVkIGludCBnZW47Cj4gIAl1bnNpZ25lZCBp bnQgZmVhdHVyZXM7Cj4gIAl1bnNpZ25lZCBpbnQgcXVpcmtzOwo+IC0JdW5zaWduZWQgaW50IG51 bV9jcnRjczsKPiArCXVuc2lnbmVkIGludCBjaGFubmVsX21hc2s7Cj4gIAlzdHJ1Y3QgcmNhcl9k dV9vdXRwdXRfcm91dGluZyByb3V0ZXNbUkNBUl9EVV9PVVRQVVRfTUFYXTsKPiAgCXVuc2lnbmVk IGludCBudW1fbHZkczsKPiAgCXVuc2lnbmVkIGludCBkcGxsX2NoOwo+IGRpZmYgLS1naXQgYS9k cml2ZXJzL2dwdS9kcm0vcmNhci1kdS9yY2FyX2R1X2ttcy5jCj4gYi9kcml2ZXJzL2dwdS9kcm0v cmNhci1kdS9yY2FyX2R1X2ttcy5jIGluZGV4IGNmNWI0MjJmYzc1My4uMTlhNDQ1ZmJjODc5Cj4g MTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL3JjYXItZHUvcmNhcl9kdV9rbXMuYwo+ICsr KyBiL2RyaXZlcnMvZ3B1L2RybS9yY2FyLWR1L3JjYXJfZHVfa21zLmMKPiBAQCAtNTU5LDYgKzU1 OSw3IEBAIGludCByY2FyX2R1X21vZGVzZXRfaW5pdChzdHJ1Y3QgcmNhcl9kdV9kZXZpY2UgKnJj ZHUpCj4gIAlzdHJ1Y3QgZHJtX2ZiZGV2X2NtYSAqZmJkZXY7Cj4gIAl1bnNpZ25lZCBpbnQgbnVt X2VuY29kZXJzOwo+ICAJdW5zaWduZWQgaW50IG51bV9ncm91cHM7Cj4gKwl1bnNpZ25lZCBpbnQg c3dpLCBod2k7CgpPbmUgdmFyaWFibGUgcGVyIGxpbmUgcGxlYXNlLiBJIHdvdWxkIGFsc28gY2Fs bCB0aGVtIHN3aW5kZXggYW5kIGh3aW5kZXgsIHRoYXQgCndvdWxkIGJlIGNsZWFyZXIgaW4gbXkg b3Bpbmlvbi4KCj4gIAl1bnNpZ25lZCBpbnQgaTsKPiAgCWludCByZXQ7Cj4gCj4gQEAgLTU3MSw3 ICs1NzIsNyBAQCBpbnQgcmNhcl9kdV9tb2Rlc2V0X2luaXQoc3RydWN0IHJjYXJfZHVfZGV2aWNl ICpyY2R1KQo+ICAJZGV2LT5tb2RlX2NvbmZpZy5mdW5jcyA9ICZyY2FyX2R1X21vZGVfY29uZmln X2Z1bmNzOwo+ICAJZGV2LT5tb2RlX2NvbmZpZy5oZWxwZXJfcHJpdmF0ZSA9ICZyY2FyX2R1X21v ZGVfY29uZmlnX2hlbHBlcjsKPiAKPiAtCXJjZHUtPm51bV9jcnRjcyA9IHJjZHUtPmluZm8tPm51 bV9jcnRjczsKPiArCXJjZHUtPm51bV9jcnRjcyA9IGh3ZWlnaHQ4KHJjZHUtPmluZm8tPmNoYW5u ZWxfbWFzayk7Cj4gCj4gIAlyZXQgPSByY2FyX2R1X3Byb3BlcnRpZXNfaW5pdChyY2R1KTsKPiAg CWlmIChyZXQgPCAwKQo+IEBAIC01ODEsNyArNTgyLDcgQEAgaW50IHJjYXJfZHVfbW9kZXNldF9p bml0KHN0cnVjdCByY2FyX2R1X2RldmljZSAqcmNkdSkKPiAgCSAqIEluaXRpYWxpemUgdmVydGlj YWwgYmxhbmtpbmcgaW50ZXJydXB0cyBoYW5kbGluZy4gU3RhcnQgd2l0aCB2YmxhbmsKPiAgCSAq IGRpc2FibGVkIGZvciBhbGwgQ1JUQ3MuCj4gIAkgKi8KPiAtCXJldCA9IGRybV92YmxhbmtfaW5p dChkZXYsICgxIDw8IHJjZHUtPmluZm8tPm51bV9jcnRjcykgLSAxKTsKPiArCXJldCA9IGRybV92 YmxhbmtfaW5pdChkZXYsICgxIDw8IHJjZHUtPm51bV9jcnRjcykgLSAxKTsKPiAgCWlmIChyZXQg PCAwKQo+ICAJCXJldHVybiByZXQ7Cj4gCj4gQEAgLTYyMywxMCArNjI0LDE2IEBAIGludCByY2Fy X2R1X21vZGVzZXRfaW5pdChzdHJ1Y3QgcmNhcl9kdV9kZXZpY2UgKnJjZHUpCj4gIAl9Cj4gCj4g IAkvKiBDcmVhdGUgdGhlIENSVENzLiAqLwo+IC0JZm9yIChpID0gMDsgaSA8IHJjZHUtPm51bV9j cnRjczsgKytpKSB7Cj4gLQkJc3RydWN0IHJjYXJfZHVfZ3JvdXAgKnJncnAgPSAmcmNkdS0+Z3Jv dXBzW2kgLyAyXTsKPiArCWZvciAoc3dpID0gMCwgaHdpID0gMDsgc3dpIDwgcmNkdS0+bnVtX2Ny dGNzOyArK2h3aSkgewo+ICsJCXN0cnVjdCByY2FyX2R1X2dyb3VwICpyZ3JwOwo+ICsKPiArCQkv KiBTa2lwIHVucG9wdWxhdGVkIERVIGNoYW5uZWxzICovCgpzL2NoYW5uZWxzL2NoYW5uZWxzLi8K Cj4gKwkJaWYgKCEocmNkdS0+aW5mby0+Y2hhbm5lbF9tYXNrICYgQklUKGh3aSkpKQo+ICsJCQlj b250aW51ZTsKPiArCj4gKwkJcmdycCA9ICZyY2R1LT5ncm91cHNbaHdpIC8gMl07Cj4gCj4gLQkJ cmV0ID0gcmNhcl9kdV9jcnRjX2NyZWF0ZShyZ3JwLCBpKTsKPiArCQlyZXQgPSByY2FyX2R1X2Ny dGNfY3JlYXRlKHJncnAsIHN3aSsrLCBod2kpOwo+ICAJCWlmIChyZXQgPCAwKQo+ICAJCQlyZXR1 cm4gcmV0Owo+ICAJfQoKVGhpcyBpcyBnb2luZyB0byB0dXJuIGludG8gYW4gaW5maW5pdGUgbG9v cCBpZiB3ZSBldmVyIGdldCB0aGUgbnVtX2NydGNzIApjYWxjdWxhdGlvbiB3cm9uZywgYnV0IEkg ZG9uJ3Qgc2VlIHdoeSB0aGF0IHNob3VsZCBiZSB0aGUgY2FzZSwgc28gSSdtIE9LIHdpdGggCnRo ZSBpbXBsZW1lbnRhdGlvbi4KCldpdGggYWxsIHRob3NlIHNtYWxsIGlzc3VlcyBmaXhlZCwKClJl dmlld2VkLWJ5OiBMYXVyZW50IFBpbmNoYXJ0IDxsYXVyZW50LnBpbmNoYXJ0QGlkZWFzb25ib2Fy ZC5jb20+CgotLSAKUmVnYXJkcywKCkxhdXJlbnQgUGluY2hhcnQKCgoKX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApk cmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Au b3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVsCg==