From mboxrd@z Thu Jan 1 00:00:00 1970 Subject: Re: [PATCH 3/3] drm: rcar-du: Clip planes to screen boundaries To: Laurent Pinchart , dri-devel@lists.freedesktop.org Cc: linux-renesas-soc@vger.kernel.org References: <20170815230338.14913-1-laurent.pinchart+renesas@ideasonboard.com> <20170815230338.14913-4-laurent.pinchart+renesas@ideasonboard.com> Reply-To: kieran.bingham@ideasonboard.com From: Kieran Bingham Message-ID: Date: Wed, 27 Sep 2017 19:58:44 +0100 MIME-Version: 1.0 In-Reply-To: <20170815230338.14913-4-laurent.pinchart+renesas@ideasonboard.com> Content-Type: text/plain; charset=utf-8 Content-Language: en-GB Content-Transfer-Encoding: 7bit List-ID: Hi Laurent, Thanks for the patch, On 16/08/17 00:03, Laurent Pinchart wrote: > Unlike the KMS API, the hardware doesn't support planes exceeding the > screen boundaries. Clip plane coordinates to support the use case. > > Signed-off-by: Laurent Pinchart Reviewed-by: Kieran Bingham > --- > drivers/gpu/drm/rcar-du/rcar_du_plane.c | 66 +++++++++++++++++++++++++-------- > drivers/gpu/drm/rcar-du/rcar_du_plane.h | 4 ++ > drivers/gpu/drm/rcar-du/rcar_du_vsp.c | 21 +++++++---- > 3 files changed, 67 insertions(+), 24 deletions(-) > > diff --git a/drivers/gpu/drm/rcar-du/rcar_du_plane.c b/drivers/gpu/drm/rcar-du/rcar_du_plane.c > index 714e02960635..7944790bac25 100644 > --- a/drivers/gpu/drm/rcar-du/rcar_du_plane.c > +++ b/drivers/gpu/drm/rcar-du/rcar_du_plane.c > @@ -19,6 +19,7 @@ > #include > #include > #include > +#include > > #include "rcar_du_drv.h" > #include "rcar_du_group.h" > @@ -329,11 +330,39 @@ static void rcar_du_plane_write(struct rcar_du_group *rgrp, > data); > } > > +void rcar_du_plane_clip(const struct drm_plane_state *state, > + struct drm_rect *src, struct drm_rect *dst) > +{ > + const struct drm_display_mode *mode; > + > + /* > + * The hardware requires all planes to be fully contained in the output > + * rectangle. Crop the destination rectangle to fit in the CRTC. > + */ > + mode = &state->crtc->state->adjusted_mode; > + > + dst->x1 = max(0, state->crtc_x); > + dst->y1 = max(0, state->crtc_y); > + dst->x2 = min_t(unsigned int, mode->hdisplay, > + state->crtc_x + state->crtc_w); > + dst->y2 = min_t(unsigned int, mode->vdisplay, > + state->crtc_y + state->crtc_h); > + > + /* > + * Offset the left and top source coordinates by the same displacement > + * we have applied to the destination rectangle. Copy the width and > + * height as the hardware can't scale. > + */ > + src->x1 = (state->src_x >> 16) + (dst->x1 - state->crtc_x); > + src->y1 = (state->src_y >> 16) + (dst->y1 - state->crtc_y); I had to look up why we do a >> 16 here. I guess this is for sub-pixel positioning. That might be obvious to DRM developers, but was new to me. Probably not worth a comment though - as I know what it is now :) Do we have any macros to make this 16.16 -> int conversion more explicit? (I think this comes under the same category as using BIT() to which we differ on opinion anyway though) > + src->x2 = src->x1 + (dst->x2 - dst->x1); > + src->y2 = src->y1 + (dst->y2 - dst->y1); > +} > + > static void rcar_du_plane_setup_scanout(struct rcar_du_group *rgrp, > - const struct rcar_du_plane_state *state) > + const struct rcar_du_plane_state *state, > + const struct drm_rect *src) > { > - unsigned int src_x = state->state.src_x >> 16; > - unsigned int src_y = state->state.src_y >> 16; > unsigned int index = state->hwindex; > unsigned int pitch; > bool interlaced; > @@ -357,7 +386,7 @@ static void rcar_du_plane_setup_scanout(struct rcar_du_group *rgrp, > dma[i] = gem->paddr + fb->offsets[i]; > } > } else { > - pitch = state->state.src_w >> 16; > + pitch = drm_rect_width(&state->state.src); > dma[0] = 0; > dma[1] = 0; > } > @@ -383,8 +412,8 @@ static void rcar_du_plane_setup_scanout(struct rcar_du_group *rgrp, > * require a halved Y position value, in both progressive and interlaced > * modes. > */ > - rcar_du_plane_write(rgrp, index, PnSPXR, src_x); > - rcar_du_plane_write(rgrp, index, PnSPYR, src_y * > + rcar_du_plane_write(rgrp, index, PnSPXR, src->x1); > + rcar_du_plane_write(rgrp, index, PnSPYR, src->y1 * > (!interlaced && state->format->bpp == 32 ? 2 : 1)); > > rcar_du_plane_write(rgrp, index, PnDSA0R, dma[0]); > @@ -394,8 +423,8 @@ static void rcar_du_plane_setup_scanout(struct rcar_du_group *rgrp, > > rcar_du_plane_write(rgrp, index, PnMWR, pitch); > > - rcar_du_plane_write(rgrp, index, PnSPXR, src_x); > - rcar_du_plane_write(rgrp, index, PnSPYR, src_y * > + rcar_du_plane_write(rgrp, index, PnSPXR, src->x1); > + rcar_du_plane_write(rgrp, index, PnSPYR, src->y1 * > (state->format->bpp == 16 ? 2 : 1) / 2); > > rcar_du_plane_write(rgrp, index, PnDSA0R, dma[1]); > @@ -518,7 +547,8 @@ static void rcar_du_plane_setup_format_gen3(struct rcar_du_group *rgrp, > > static void rcar_du_plane_setup_format(struct rcar_du_group *rgrp, > unsigned int index, > - const struct rcar_du_plane_state *state) > + const struct rcar_du_plane_state *state, > + const struct drm_rect *dst) > { > struct rcar_du_device *rcdu = rgrp->dev; > > @@ -528,10 +558,10 @@ static void rcar_du_plane_setup_format(struct rcar_du_group *rgrp, > rcar_du_plane_setup_format_gen3(rgrp, index, state); > > /* Destination position and size */ > - rcar_du_plane_write(rgrp, index, PnDSXR, state->state.crtc_w); > - rcar_du_plane_write(rgrp, index, PnDSYR, state->state.crtc_h); > - rcar_du_plane_write(rgrp, index, PnDPXR, state->state.crtc_x); > - rcar_du_plane_write(rgrp, index, PnDPYR, state->state.crtc_y); > + rcar_du_plane_write(rgrp, index, PnDSXR, drm_rect_width(dst)); > + rcar_du_plane_write(rgrp, index, PnDSYR, drm_rect_height(dst)); > + rcar_du_plane_write(rgrp, index, PnDPXR, dst->x1); > + rcar_du_plane_write(rgrp, index, PnDPYR, dst->y1); > > if (rcdu->info->gen < 3) { > /* Wrap-around and blinking, disabled */ > @@ -546,14 +576,18 @@ void __rcar_du_plane_setup(struct rcar_du_group *rgrp, > const struct rcar_du_plane_state *state) > { > struct rcar_du_device *rcdu = rgrp->dev; > + struct drm_rect src; > + struct drm_rect dst; > + > + rcar_du_plane_clip(&state->state, &src, &dst); > > - rcar_du_plane_setup_format(rgrp, state->hwindex, state); > + rcar_du_plane_setup_format(rgrp, state->hwindex, state, &dst); > if (state->format->planes == 2) > rcar_du_plane_setup_format(rgrp, (state->hwindex + 1) % 8, > - state); > + state, &dst); > > if (rcdu->info->gen < 3) > - rcar_du_plane_setup_scanout(rgrp, state); > + rcar_du_plane_setup_scanout(rgrp, state, &src); > > if (state->source == RCAR_DU_PLANE_VSPD1) { > unsigned int vspd1_sink = rgrp->index ? 2 : 0; > diff --git a/drivers/gpu/drm/rcar-du/rcar_du_plane.h b/drivers/gpu/drm/rcar-du/rcar_du_plane.h > index 890321b4665d..ec52a2af7cd4 100644 > --- a/drivers/gpu/drm/rcar-du/rcar_du_plane.h > +++ b/drivers/gpu/drm/rcar-du/rcar_du_plane.h > @@ -17,6 +17,7 @@ > #include > #include > > +struct drm_rect; > struct rcar_du_format_info; > struct rcar_du_group; > > @@ -79,6 +80,9 @@ int __rcar_du_plane_atomic_check(struct drm_plane *plane, > > int rcar_du_planes_init(struct rcar_du_group *rgrp); > > +void rcar_du_plane_clip(const struct drm_plane_state *state, > + struct drm_rect *src, struct drm_rect *dst); > + > void __rcar_du_plane_setup(struct rcar_du_group *rgrp, > const struct rcar_du_plane_state *state); > > diff --git a/drivers/gpu/drm/rcar-du/rcar_du_vsp.c b/drivers/gpu/drm/rcar-du/rcar_du_vsp.c > index dd66dcb8da23..e62a8d7ee0c5 100644 > --- a/drivers/gpu/drm/rcar-du/rcar_du_vsp.c > +++ b/drivers/gpu/drm/rcar-du/rcar_du_vsp.c > @@ -18,6 +18,7 @@ > #include > #include > #include > +#include > > #include > #include > @@ -176,17 +177,21 @@ static void rcar_du_vsp_plane_setup(struct rcar_du_vsp_plane *plane) > .alpha = state->alpha, > .zpos = state->state.zpos, > }; > + struct drm_rect src; > + struct drm_rect dst; > unsigned int i; > > - cfg.src.left = state->state.src_x >> 16; > - cfg.src.top = state->state.src_y >> 16; > - cfg.src.width = state->state.src_w >> 16; > - cfg.src.height = state->state.src_h >> 16; > + rcar_du_plane_clip(&state->state, &src, &dst); > > - cfg.dst.left = state->state.crtc_x; > - cfg.dst.top = state->state.crtc_y; > - cfg.dst.width = state->state.crtc_w; > - cfg.dst.height = state->state.crtc_h; > + cfg.src.left = src.x1; > + cfg.src.top = src.y1; > + cfg.src.width = drm_rect_width(&src); > + cfg.src.height = drm_rect_height(&src); > + > + cfg.dst.left = dst.x1; > + cfg.dst.top = dst.y1; > + cfg.dst.width = drm_rect_width(&dst); > + cfg.dst.height = drm_rect_height(&dst); > > for (i = 0; i < state->format->planes; ++i) > cfg.mem[i] = sg_dma_address(state->sg_tables[i].sgl) > From mboxrd@z Thu Jan 1 00:00:00 1970 From: Kieran Bingham Subject: Re: [PATCH 3/3] drm: rcar-du: Clip planes to screen boundaries Date: Wed, 27 Sep 2017 19:58:44 +0100 Message-ID: References: <20170815230338.14913-1-laurent.pinchart+renesas@ideasonboard.com> <20170815230338.14913-4-laurent.pinchart+renesas@ideasonboard.com> Reply-To: kieran.bingham@ideasonboard.com Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from galahad.ideasonboard.com (galahad.ideasonboard.com [185.26.127.97]) by gabe.freedesktop.org (Postfix) with ESMTPS id 27C5B6E05E for ; Wed, 27 Sep 2017 18:58:49 +0000 (UTC) In-Reply-To: <20170815230338.14913-4-laurent.pinchart+renesas@ideasonboard.com> Content-Language: en-GB List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Laurent Pinchart , dri-devel@lists.freedesktop.org Cc: linux-renesas-soc@vger.kernel.org List-Id: dri-devel@lists.freedesktop.org SGkgTGF1cmVudCwKClRoYW5rcyBmb3IgdGhlIHBhdGNoLAoKT24gMTYvMDgvMTcgMDA6MDMsIExh dXJlbnQgUGluY2hhcnQgd3JvdGU6Cj4gVW5saWtlIHRoZSBLTVMgQVBJLCB0aGUgaGFyZHdhcmUg ZG9lc24ndCBzdXBwb3J0IHBsYW5lcyBleGNlZWRpbmcgdGhlCj4gc2NyZWVuIGJvdW5kYXJpZXMu IENsaXAgcGxhbmUgY29vcmRpbmF0ZXMgdG8gc3VwcG9ydCB0aGUgdXNlIGNhc2UuCj4gCj4gU2ln bmVkLW9mZi1ieTogTGF1cmVudCBQaW5jaGFydCA8bGF1cmVudC5waW5jaGFydCtyZW5lc2FzQGlk ZWFzb25ib2FyZC5jb20+CgpSZXZpZXdlZC1ieTogS2llcmFuIEJpbmdoYW0gPGtpZXJhbi5iaW5n aGFtK3JlbmVzYXNAaWRlYXNvbmJvYXJkLmNvbT4KCj4gLS0tCj4gIGRyaXZlcnMvZ3B1L2RybS9y Y2FyLWR1L3JjYXJfZHVfcGxhbmUuYyB8IDY2ICsrKysrKysrKysrKysrKysrKysrKysrKystLS0t LS0tLQo+ICBkcml2ZXJzL2dwdS9kcm0vcmNhci1kdS9yY2FyX2R1X3BsYW5lLmggfCAgNCArKwo+ ICBkcml2ZXJzL2dwdS9kcm0vcmNhci1kdS9yY2FyX2R1X3ZzcC5jICAgfCAyMSArKysrKysrLS0t LQo+ICAzIGZpbGVzIGNoYW5nZWQsIDY3IGluc2VydGlvbnMoKyksIDI0IGRlbGV0aW9ucygtKQo+ IAo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vcmNhci1kdS9yY2FyX2R1X3BsYW5lLmMg Yi9kcml2ZXJzL2dwdS9kcm0vcmNhci1kdS9yY2FyX2R1X3BsYW5lLmMKPiBpbmRleCA3MTRlMDI5 NjA2MzUuLjc5NDQ3OTBiYWMyNSAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vcmNhci1k dS9yY2FyX2R1X3BsYW5lLmMKPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vcmNhci1kdS9yY2FyX2R1 X3BsYW5lLmMKPiBAQCAtMTksNiArMTksNyBAQAo+ICAjaW5jbHVkZSA8ZHJtL2RybV9mYl9jbWFf aGVscGVyLmg+Cj4gICNpbmNsdWRlIDxkcm0vZHJtX2dlbV9jbWFfaGVscGVyLmg+Cj4gICNpbmNs dWRlIDxkcm0vZHJtX3BsYW5lX2hlbHBlci5oPgo+ICsjaW5jbHVkZSA8ZHJtL2RybV9yZWN0Lmg+ Cj4gIAo+ICAjaW5jbHVkZSAicmNhcl9kdV9kcnYuaCIKPiAgI2luY2x1ZGUgInJjYXJfZHVfZ3Jv dXAuaCIKPiBAQCAtMzI5LDExICszMzAsMzkgQEAgc3RhdGljIHZvaWQgcmNhcl9kdV9wbGFuZV93 cml0ZShzdHJ1Y3QgcmNhcl9kdV9ncm91cCAqcmdycCwKPiAgCQkgICAgICBkYXRhKTsKPiAgfQo+ ICAKPiArdm9pZCByY2FyX2R1X3BsYW5lX2NsaXAoY29uc3Qgc3RydWN0IGRybV9wbGFuZV9zdGF0 ZSAqc3RhdGUsCj4gKwkJCXN0cnVjdCBkcm1fcmVjdCAqc3JjLCBzdHJ1Y3QgZHJtX3JlY3QgKmRz dCkKPiArewo+ICsJY29uc3Qgc3RydWN0IGRybV9kaXNwbGF5X21vZGUgKm1vZGU7Cj4gKwo+ICsJ LyoKPiArCSAqIFRoZSBoYXJkd2FyZSByZXF1aXJlcyBhbGwgcGxhbmVzIHRvIGJlIGZ1bGx5IGNv bnRhaW5lZCBpbiB0aGUgb3V0cHV0Cj4gKwkgKiByZWN0YW5nbGUuIENyb3AgdGhlIGRlc3RpbmF0 aW9uIHJlY3RhbmdsZSB0byBmaXQgaW4gdGhlIENSVEMuCj4gKwkgKi8KPiArCW1vZGUgPSAmc3Rh dGUtPmNydGMtPnN0YXRlLT5hZGp1c3RlZF9tb2RlOwo+ICsKPiArCWRzdC0+eDEgPSBtYXgoMCwg c3RhdGUtPmNydGNfeCk7Cj4gKwlkc3QtPnkxID0gbWF4KDAsIHN0YXRlLT5jcnRjX3kpOwo+ICsJ ZHN0LT54MiA9IG1pbl90KHVuc2lnbmVkIGludCwgbW9kZS0+aGRpc3BsYXksCj4gKwkJCXN0YXRl LT5jcnRjX3ggKyBzdGF0ZS0+Y3J0Y193KTsKPiArCWRzdC0+eTIgPSBtaW5fdCh1bnNpZ25lZCBp bnQsIG1vZGUtPnZkaXNwbGF5LAo+ICsJCQlzdGF0ZS0+Y3J0Y195ICsgc3RhdGUtPmNydGNfaCk7 Cj4gKwo+ICsJLyoKPiArCSAqIE9mZnNldCB0aGUgbGVmdCBhbmQgdG9wIHNvdXJjZSBjb29yZGlu YXRlcyBieSB0aGUgc2FtZSBkaXNwbGFjZW1lbnQKPiArCSAqIHdlIGhhdmUgYXBwbGllZCB0byB0 aGUgZGVzdGluYXRpb24gcmVjdGFuZ2xlLiBDb3B5IHRoZSB3aWR0aCBhbmQKPiArCSAqIGhlaWdo dCBhcyB0aGUgaGFyZHdhcmUgY2FuJ3Qgc2NhbGUuCj4gKwkgKi8KPiArCXNyYy0+eDEgPSAoc3Rh dGUtPnNyY194ID4+IDE2KSArIChkc3QtPngxIC0gc3RhdGUtPmNydGNfeCk7Cj4gKwlzcmMtPnkx ID0gKHN0YXRlLT5zcmNfeSA+PiAxNikgKyAoZHN0LT55MSAtIHN0YXRlLT5jcnRjX3kpOwoKSSBo YWQgdG8gbG9vayB1cCB3aHkgd2UgZG8gYSA+PiAxNiBoZXJlLiBJIGd1ZXNzIHRoaXMgaXMgZm9y IHN1Yi1waXhlbApwb3NpdGlvbmluZy4gVGhhdCBtaWdodCBiZSBvYnZpb3VzIHRvIERSTSBkZXZl bG9wZXJzLCBidXQgd2FzIG5ldyB0byBtZS4KClByb2JhYmx5IG5vdCB3b3J0aCBhIGNvbW1lbnQg dGhvdWdoIC0gYXMgSSBrbm93IHdoYXQgaXQgaXMgbm93IDopCkRvIHdlIGhhdmUgYW55IG1hY3Jv cyB0byBtYWtlIHRoaXMgMTYuMTYgLT4gaW50IGNvbnZlcnNpb24gbW9yZSBleHBsaWNpdD8KKEkg dGhpbmsgdGhpcyBjb21lcyB1bmRlciB0aGUgc2FtZSBjYXRlZ29yeSBhcyB1c2luZyBCSVQoKSB0 byB3aGljaCB3ZSBkaWZmZXIgb24Kb3BpbmlvbiBhbnl3YXkgdGhvdWdoKQoKCj4gKwlzcmMtPngy ID0gc3JjLT54MSArIChkc3QtPngyIC0gZHN0LT54MSk7Cj4gKwlzcmMtPnkyID0gc3JjLT55MSAr IChkc3QtPnkyIC0gZHN0LT55MSk7Cj4gK30KPiArCj4gIHN0YXRpYyB2b2lkIHJjYXJfZHVfcGxh bmVfc2V0dXBfc2Nhbm91dChzdHJ1Y3QgcmNhcl9kdV9ncm91cCAqcmdycCwKPiAtCQkJCQljb25z dCBzdHJ1Y3QgcmNhcl9kdV9wbGFuZV9zdGF0ZSAqc3RhdGUpCj4gKwkJCQkJY29uc3Qgc3RydWN0 IHJjYXJfZHVfcGxhbmVfc3RhdGUgKnN0YXRlLAo+ICsJCQkJCWNvbnN0IHN0cnVjdCBkcm1fcmVj dCAqc3JjKQo+ICB7Cj4gLQl1bnNpZ25lZCBpbnQgc3JjX3ggPSBzdGF0ZS0+c3RhdGUuc3JjX3gg Pj4gMTY7Cj4gLQl1bnNpZ25lZCBpbnQgc3JjX3kgPSBzdGF0ZS0+c3RhdGUuc3JjX3kgPj4gMTY7 Cj4gIAl1bnNpZ25lZCBpbnQgaW5kZXggPSBzdGF0ZS0+aHdpbmRleDsKPiAgCXVuc2lnbmVkIGlu dCBwaXRjaDsKPiAgCWJvb2wgaW50ZXJsYWNlZDsKPiBAQCAtMzU3LDcgKzM4Niw3IEBAIHN0YXRp YyB2b2lkIHJjYXJfZHVfcGxhbmVfc2V0dXBfc2Nhbm91dChzdHJ1Y3QgcmNhcl9kdV9ncm91cCAq cmdycCwKPiAgCQkJZG1hW2ldID0gZ2VtLT5wYWRkciArIGZiLT5vZmZzZXRzW2ldOwo+ICAJCX0K PiAgCX0gZWxzZSB7Cj4gLQkJcGl0Y2ggPSBzdGF0ZS0+c3RhdGUuc3JjX3cgPj4gMTY7Cj4gKwkJ cGl0Y2ggPSBkcm1fcmVjdF93aWR0aCgmc3RhdGUtPnN0YXRlLnNyYyk7Cj4gIAkJZG1hWzBdID0g MDsKPiAgCQlkbWFbMV0gPSAwOwo+ICAJfQo+IEBAIC0zODMsOCArNDEyLDggQEAgc3RhdGljIHZv aWQgcmNhcl9kdV9wbGFuZV9zZXR1cF9zY2Fub3V0KHN0cnVjdCByY2FyX2R1X2dyb3VwICpyZ3Jw LAo+ICAJICogcmVxdWlyZSBhIGhhbHZlZCBZIHBvc2l0aW9uIHZhbHVlLCBpbiBib3RoIHByb2dy ZXNzaXZlIGFuZCBpbnRlcmxhY2VkCj4gIAkgKiBtb2Rlcy4KPiAgCSAqLwo+IC0JcmNhcl9kdV9w bGFuZV93cml0ZShyZ3JwLCBpbmRleCwgUG5TUFhSLCBzcmNfeCk7Cj4gLQlyY2FyX2R1X3BsYW5l X3dyaXRlKHJncnAsIGluZGV4LCBQblNQWVIsIHNyY195ICoKPiArCXJjYXJfZHVfcGxhbmVfd3Jp dGUocmdycCwgaW5kZXgsIFBuU1BYUiwgc3JjLT54MSk7Cj4gKwlyY2FyX2R1X3BsYW5lX3dyaXRl KHJncnAsIGluZGV4LCBQblNQWVIsIHNyYy0+eTEgKgo+ICAJCQkgICAgKCFpbnRlcmxhY2VkICYm IHN0YXRlLT5mb3JtYXQtPmJwcCA9PSAzMiA/IDIgOiAxKSk7Cj4gIAo+ICAJcmNhcl9kdV9wbGFu ZV93cml0ZShyZ3JwLCBpbmRleCwgUG5EU0EwUiwgZG1hWzBdKTsKPiBAQCAtMzk0LDggKzQyMyw4 IEBAIHN0YXRpYyB2b2lkIHJjYXJfZHVfcGxhbmVfc2V0dXBfc2Nhbm91dChzdHJ1Y3QgcmNhcl9k dV9ncm91cCAqcmdycCwKPiAgCj4gIAkJcmNhcl9kdV9wbGFuZV93cml0ZShyZ3JwLCBpbmRleCwg UG5NV1IsIHBpdGNoKTsKPiAgCj4gLQkJcmNhcl9kdV9wbGFuZV93cml0ZShyZ3JwLCBpbmRleCwg UG5TUFhSLCBzcmNfeCk7Cj4gLQkJcmNhcl9kdV9wbGFuZV93cml0ZShyZ3JwLCBpbmRleCwgUG5T UFlSLCBzcmNfeSAqCj4gKwkJcmNhcl9kdV9wbGFuZV93cml0ZShyZ3JwLCBpbmRleCwgUG5TUFhS LCBzcmMtPngxKTsKPiArCQlyY2FyX2R1X3BsYW5lX3dyaXRlKHJncnAsIGluZGV4LCBQblNQWVIs IHNyYy0+eTEgKgo+ICAJCQkJICAgIChzdGF0ZS0+Zm9ybWF0LT5icHAgPT0gMTYgPyAyIDogMSkg LyAyKTsKPiAgCj4gIAkJcmNhcl9kdV9wbGFuZV93cml0ZShyZ3JwLCBpbmRleCwgUG5EU0EwUiwg ZG1hWzFdKTsKPiBAQCAtNTE4LDcgKzU0Nyw4IEBAIHN0YXRpYyB2b2lkIHJjYXJfZHVfcGxhbmVf c2V0dXBfZm9ybWF0X2dlbjMoc3RydWN0IHJjYXJfZHVfZ3JvdXAgKnJncnAsCj4gIAo+ICBzdGF0 aWMgdm9pZCByY2FyX2R1X3BsYW5lX3NldHVwX2Zvcm1hdChzdHJ1Y3QgcmNhcl9kdV9ncm91cCAq cmdycCwKPiAgCQkJCSAgICAgICB1bnNpZ25lZCBpbnQgaW5kZXgsCj4gLQkJCQkgICAgICAgY29u c3Qgc3RydWN0IHJjYXJfZHVfcGxhbmVfc3RhdGUgKnN0YXRlKQo+ICsJCQkJICAgICAgIGNvbnN0 IHN0cnVjdCByY2FyX2R1X3BsYW5lX3N0YXRlICpzdGF0ZSwKPiArCQkJCSAgICAgICBjb25zdCBz dHJ1Y3QgZHJtX3JlY3QgKmRzdCkKPiAgewo+ICAJc3RydWN0IHJjYXJfZHVfZGV2aWNlICpyY2R1 ID0gcmdycC0+ZGV2Owo+ICAKPiBAQCAtNTI4LDEwICs1NTgsMTAgQEAgc3RhdGljIHZvaWQgcmNh cl9kdV9wbGFuZV9zZXR1cF9mb3JtYXQoc3RydWN0IHJjYXJfZHVfZ3JvdXAgKnJncnAsCj4gIAkJ cmNhcl9kdV9wbGFuZV9zZXR1cF9mb3JtYXRfZ2VuMyhyZ3JwLCBpbmRleCwgc3RhdGUpOwo+ICAK PiAgCS8qIERlc3RpbmF0aW9uIHBvc2l0aW9uIGFuZCBzaXplICovCj4gLQlyY2FyX2R1X3BsYW5l X3dyaXRlKHJncnAsIGluZGV4LCBQbkRTWFIsIHN0YXRlLT5zdGF0ZS5jcnRjX3cpOwo+IC0JcmNh cl9kdV9wbGFuZV93cml0ZShyZ3JwLCBpbmRleCwgUG5EU1lSLCBzdGF0ZS0+c3RhdGUuY3J0Y19o KTsKPiAtCXJjYXJfZHVfcGxhbmVfd3JpdGUocmdycCwgaW5kZXgsIFBuRFBYUiwgc3RhdGUtPnN0 YXRlLmNydGNfeCk7Cj4gLQlyY2FyX2R1X3BsYW5lX3dyaXRlKHJncnAsIGluZGV4LCBQbkRQWVIs IHN0YXRlLT5zdGF0ZS5jcnRjX3kpOwo+ICsJcmNhcl9kdV9wbGFuZV93cml0ZShyZ3JwLCBpbmRl eCwgUG5EU1hSLCBkcm1fcmVjdF93aWR0aChkc3QpKTsKPiArCXJjYXJfZHVfcGxhbmVfd3JpdGUo cmdycCwgaW5kZXgsIFBuRFNZUiwgZHJtX3JlY3RfaGVpZ2h0KGRzdCkpOwo+ICsJcmNhcl9kdV9w bGFuZV93cml0ZShyZ3JwLCBpbmRleCwgUG5EUFhSLCBkc3QtPngxKTsKPiArCXJjYXJfZHVfcGxh bmVfd3JpdGUocmdycCwgaW5kZXgsIFBuRFBZUiwgZHN0LT55MSk7Cj4gIAo+ICAJaWYgKHJjZHUt PmluZm8tPmdlbiA8IDMpIHsKPiAgCQkvKiBXcmFwLWFyb3VuZCBhbmQgYmxpbmtpbmcsIGRpc2Fi bGVkICovCj4gQEAgLTU0NiwxNCArNTc2LDE4IEBAIHZvaWQgX19yY2FyX2R1X3BsYW5lX3NldHVw KHN0cnVjdCByY2FyX2R1X2dyb3VwICpyZ3JwLAo+ICAJCQkgICBjb25zdCBzdHJ1Y3QgcmNhcl9k dV9wbGFuZV9zdGF0ZSAqc3RhdGUpCj4gIHsKPiAgCXN0cnVjdCByY2FyX2R1X2RldmljZSAqcmNk dSA9IHJncnAtPmRldjsKPiArCXN0cnVjdCBkcm1fcmVjdCBzcmM7Cj4gKwlzdHJ1Y3QgZHJtX3Jl Y3QgZHN0Owo+ICsKPiArCXJjYXJfZHVfcGxhbmVfY2xpcCgmc3RhdGUtPnN0YXRlLCAmc3JjLCAm ZHN0KTsKPiAgCj4gLQlyY2FyX2R1X3BsYW5lX3NldHVwX2Zvcm1hdChyZ3JwLCBzdGF0ZS0+aHdp bmRleCwgc3RhdGUpOwo+ICsJcmNhcl9kdV9wbGFuZV9zZXR1cF9mb3JtYXQocmdycCwgc3RhdGUt Pmh3aW5kZXgsIHN0YXRlLCAmZHN0KTsKPiAgCWlmIChzdGF0ZS0+Zm9ybWF0LT5wbGFuZXMgPT0g MikKPiAgCQlyY2FyX2R1X3BsYW5lX3NldHVwX2Zvcm1hdChyZ3JwLCAoc3RhdGUtPmh3aW5kZXgg KyAxKSAlIDgsCj4gLQkJCQkJICAgc3RhdGUpOwo+ICsJCQkJCSAgIHN0YXRlLCAmZHN0KTsKPiAg Cj4gIAlpZiAocmNkdS0+aW5mby0+Z2VuIDwgMykKPiAtCQlyY2FyX2R1X3BsYW5lX3NldHVwX3Nj YW5vdXQocmdycCwgc3RhdGUpOwo+ICsJCXJjYXJfZHVfcGxhbmVfc2V0dXBfc2Nhbm91dChyZ3Jw LCBzdGF0ZSwgJnNyYyk7Cj4gIAo+ICAJaWYgKHN0YXRlLT5zb3VyY2UgPT0gUkNBUl9EVV9QTEFO RV9WU1BEMSkgewo+ICAJCXVuc2lnbmVkIGludCB2c3BkMV9zaW5rID0gcmdycC0+aW5kZXggPyAy IDogMDsKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3JjYXItZHUvcmNhcl9kdV9wbGFu ZS5oIGIvZHJpdmVycy9ncHUvZHJtL3JjYXItZHUvcmNhcl9kdV9wbGFuZS5oCj4gaW5kZXggODkw MzIxYjQ2NjVkLi5lYzUyYTJhZjdjZDQgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL3Jj YXItZHUvcmNhcl9kdV9wbGFuZS5oCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL3JjYXItZHUvcmNh cl9kdV9wbGFuZS5oCj4gQEAgLTE3LDYgKzE3LDcgQEAKPiAgI2luY2x1ZGUgPGRybS9kcm1QLmg+ Cj4gICNpbmNsdWRlIDxkcm0vZHJtX2NydGMuaD4KPiAgCj4gK3N0cnVjdCBkcm1fcmVjdDsKPiAg c3RydWN0IHJjYXJfZHVfZm9ybWF0X2luZm87Cj4gIHN0cnVjdCByY2FyX2R1X2dyb3VwOwo+ICAK PiBAQCAtNzksNiArODAsOSBAQCBpbnQgX19yY2FyX2R1X3BsYW5lX2F0b21pY19jaGVjayhzdHJ1 Y3QgZHJtX3BsYW5lICpwbGFuZSwKPiAgCj4gIGludCByY2FyX2R1X3BsYW5lc19pbml0KHN0cnVj dCByY2FyX2R1X2dyb3VwICpyZ3JwKTsKPiAgCj4gK3ZvaWQgcmNhcl9kdV9wbGFuZV9jbGlwKGNv bnN0IHN0cnVjdCBkcm1fcGxhbmVfc3RhdGUgKnN0YXRlLAo+ICsJCQlzdHJ1Y3QgZHJtX3JlY3Qg KnNyYywgc3RydWN0IGRybV9yZWN0ICpkc3QpOwo+ICsKPiAgdm9pZCBfX3JjYXJfZHVfcGxhbmVf c2V0dXAoc3RydWN0IHJjYXJfZHVfZ3JvdXAgKnJncnAsCj4gIAkJCSAgIGNvbnN0IHN0cnVjdCBy Y2FyX2R1X3BsYW5lX3N0YXRlICpzdGF0ZSk7Cj4gIAo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dw dS9kcm0vcmNhci1kdS9yY2FyX2R1X3ZzcC5jIGIvZHJpdmVycy9ncHUvZHJtL3JjYXItZHUvcmNh cl9kdV92c3AuYwo+IGluZGV4IGRkNjZkY2I4ZGEyMy4uZTYyYThkN2VlMGM1IDEwMDY0NAo+IC0t LSBhL2RyaXZlcnMvZ3B1L2RybS9yY2FyLWR1L3JjYXJfZHVfdnNwLmMKPiArKysgYi9kcml2ZXJz L2dwdS9kcm0vcmNhci1kdS9yY2FyX2R1X3ZzcC5jCj4gQEAgLTE4LDYgKzE4LDcgQEAKPiAgI2lu Y2x1ZGUgPGRybS9kcm1fZmJfY21hX2hlbHBlci5oPgo+ICAjaW5jbHVkZSA8ZHJtL2RybV9nZW1f Y21hX2hlbHBlci5oPgo+ICAjaW5jbHVkZSA8ZHJtL2RybV9wbGFuZV9oZWxwZXIuaD4KPiArI2lu Y2x1ZGUgPGRybS9kcm1fcmVjdC5oPgo+ICAKPiAgI2luY2x1ZGUgPGxpbnV4L2JpdG9wcy5oPgo+ ICAjaW5jbHVkZSA8bGludXgvZG1hLW1hcHBpbmcuaD4KPiBAQCAtMTc2LDE3ICsxNzcsMjEgQEAg c3RhdGljIHZvaWQgcmNhcl9kdV92c3BfcGxhbmVfc2V0dXAoc3RydWN0IHJjYXJfZHVfdnNwX3Bs YW5lICpwbGFuZSkKPiAgCQkuYWxwaGEgPSBzdGF0ZS0+YWxwaGEsCj4gIAkJLnpwb3MgPSBzdGF0 ZS0+c3RhdGUuenBvcywKPiAgCX07Cj4gKwlzdHJ1Y3QgZHJtX3JlY3Qgc3JjOwo+ICsJc3RydWN0 IGRybV9yZWN0IGRzdDsKPiAgCXVuc2lnbmVkIGludCBpOwo+ICAKPiAtCWNmZy5zcmMubGVmdCA9 IHN0YXRlLT5zdGF0ZS5zcmNfeCA+PiAxNjsKPiAtCWNmZy5zcmMudG9wID0gc3RhdGUtPnN0YXRl LnNyY195ID4+IDE2Owo+IC0JY2ZnLnNyYy53aWR0aCA9IHN0YXRlLT5zdGF0ZS5zcmNfdyA+PiAx NjsKPiAtCWNmZy5zcmMuaGVpZ2h0ID0gc3RhdGUtPnN0YXRlLnNyY19oID4+IDE2Owo+ICsJcmNh cl9kdV9wbGFuZV9jbGlwKCZzdGF0ZS0+c3RhdGUsICZzcmMsICZkc3QpOwo+ICAKPiAtCWNmZy5k c3QubGVmdCA9IHN0YXRlLT5zdGF0ZS5jcnRjX3g7Cj4gLQljZmcuZHN0LnRvcCA9IHN0YXRlLT5z dGF0ZS5jcnRjX3k7Cj4gLQljZmcuZHN0LndpZHRoID0gc3RhdGUtPnN0YXRlLmNydGNfdzsKPiAt CWNmZy5kc3QuaGVpZ2h0ID0gc3RhdGUtPnN0YXRlLmNydGNfaDsKPiArCWNmZy5zcmMubGVmdCA9 IHNyYy54MTsKPiArCWNmZy5zcmMudG9wID0gc3JjLnkxOwo+ICsJY2ZnLnNyYy53aWR0aCA9IGRy bV9yZWN0X3dpZHRoKCZzcmMpOwo+ICsJY2ZnLnNyYy5oZWlnaHQgPSBkcm1fcmVjdF9oZWlnaHQo JnNyYyk7Cj4gKwo+ICsJY2ZnLmRzdC5sZWZ0ID0gZHN0LngxOwo+ICsJY2ZnLmRzdC50b3AgPSBk c3QueTE7Cj4gKwljZmcuZHN0LndpZHRoID0gZHJtX3JlY3Rfd2lkdGgoJmRzdCk7Cj4gKwljZmcu ZHN0LmhlaWdodCA9IGRybV9yZWN0X2hlaWdodCgmZHN0KTsKPiAgCj4gIAlmb3IgKGkgPSAwOyBp IDwgc3RhdGUtPmZvcm1hdC0+cGxhbmVzOyArK2kpCj4gIAkJY2ZnLm1lbVtpXSA9IHNnX2RtYV9h ZGRyZXNzKHN0YXRlLT5zZ190YWJsZXNbaV0uc2dsKQo+IApfX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1kZXZl bEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFp bG1hbi9saXN0aW5mby9kcmktZGV2ZWwK