From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from galahad.ideasonboard.com ([185.26.127.97]:54335 "EHLO galahad.ideasonboard.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751938AbeDEJSi (ORCPT ); Thu, 5 Apr 2018 05:18:38 -0400 From: Laurent Pinchart To: linux-media@vger.kernel.org Cc: dri-devel@lists.freedesktop.org, linux-renesas-soc@vger.kernel.org, Kieran Bingham Subject: [PATCH v2 03/15] v4l: vsp1: Store pipeline pointer in vsp1_entity Date: Thu, 5 Apr 2018 12:18:28 +0300 Message-Id: <20180405091840.30728-4-laurent.pinchart+renesas@ideasonboard.com> In-Reply-To: <20180405091840.30728-1-laurent.pinchart+renesas@ideasonboard.com> References: <20180405091840.30728-1-laurent.pinchart+renesas@ideasonboard.com> Sender: linux-media-owner@vger.kernel.org List-ID: Various types of objects subclassing vsp1_entity currently store a pointer to the pipeline. Move the pointer to vsp1_entity to simplify the code and avoid storing the pipeline in more entity subclasses later. Signed-off-by: Laurent Pinchart Reviewed-by: Kieran Bingham --- drivers/media/platform/vsp1/vsp1_drm.c | 20 +++++++++++++------ drivers/media/platform/vsp1/vsp1_drv.c | 2 +- drivers/media/platform/vsp1/vsp1_entity.h | 2 ++ drivers/media/platform/vsp1/vsp1_histo.c | 2 +- drivers/media/platform/vsp1/vsp1_histo.h | 3 --- drivers/media/platform/vsp1/vsp1_pipe.c | 33 +++++++++---------------------- drivers/media/platform/vsp1/vsp1_rwpf.h | 2 -- drivers/media/platform/vsp1/vsp1_video.c | 17 +++++++--------- 8 files changed, 34 insertions(+), 47 deletions(-) diff --git a/drivers/media/platform/vsp1/vsp1_drm.c b/drivers/media/platform/vsp1/vsp1_drm.c index a267f12f0cc8..a7ad85ab0b08 100644 --- a/drivers/media/platform/vsp1/vsp1_drm.c +++ b/drivers/media/platform/vsp1/vsp1_drm.c @@ -120,6 +120,7 @@ int vsp1_du_setup_lif(struct device *dev, unsigned int pipe_index, * inputs. */ WARN_ON(list_empty(&rpf->entity.list_pipe)); + rpf->entity.pipe = NULL; list_del_init(&rpf->entity.list_pipe); pipe->inputs[i] = NULL; @@ -536,8 +537,10 @@ void vsp1_du_atomic_flush(struct device *dev, unsigned int pipe_index) continue; } - if (list_empty(&rpf->entity.list_pipe)) + if (list_empty(&rpf->entity.list_pipe)) { + rpf->entity.pipe = pipe; list_add_tail(&rpf->entity.list_pipe, &pipe->entities); + } bru->inputs[i].rpf = rpf; rpf->bru_input = i; @@ -562,6 +565,7 @@ void vsp1_du_atomic_flush(struct device *dev, unsigned int pipe_index) vsp1_dl_list_write(dl, entity->route->reg, VI6_DPR_NODE_UNUSED); + entity->pipe = NULL; list_del_init(&entity->list_pipe); continue; @@ -625,24 +629,28 @@ int vsp1_drm_init(struct vsp1_device *vsp1) vsp1_pipeline_init(pipe); + pipe->frame_end = vsp1_du_pipeline_frame_end; + /* * The DRM pipeline is static, add entities manually. The first * pipeline uses the BRU and the second pipeline the BRS. */ pipe->bru = i == 0 ? &vsp1->bru->entity : &vsp1->brs->entity; - pipe->lif = &vsp1->lif[i]->entity; pipe->output = vsp1->wpf[i]; - pipe->output->pipe = pipe; - pipe->frame_end = vsp1_du_pipeline_frame_end; + pipe->lif = &vsp1->lif[i]->entity; + pipe->bru->pipe = pipe; pipe->bru->sink = &pipe->output->entity; pipe->bru->sink_pad = 0; + list_add_tail(&pipe->bru->list_pipe, &pipe->entities); + + pipe->output->entity.pipe = pipe; pipe->output->entity.sink = pipe->lif; pipe->output->entity.sink_pad = 0; + list_add_tail(&pipe->output->entity.list_pipe, &pipe->entities); - list_add_tail(&pipe->bru->list_pipe, &pipe->entities); + pipe->lif->pipe = pipe; list_add_tail(&pipe->lif->list_pipe, &pipe->entities); - list_add_tail(&pipe->output->entity.list_pipe, &pipe->entities); } /* Disable all RPFs initially. */ diff --git a/drivers/media/platform/vsp1/vsp1_drv.c b/drivers/media/platform/vsp1/vsp1_drv.c index eed9516e25e1..58a7993f2306 100644 --- a/drivers/media/platform/vsp1/vsp1_drv.c +++ b/drivers/media/platform/vsp1/vsp1_drv.c @@ -63,7 +63,7 @@ static irqreturn_t vsp1_irq_handler(int irq, void *data) vsp1_write(vsp1, VI6_WPF_IRQ_STA(i), ~status & mask); if (status & VI6_WFP_IRQ_STA_DFE) { - vsp1_pipeline_frame_end(wpf->pipe); + vsp1_pipeline_frame_end(wpf->entity.pipe); ret = IRQ_HANDLED; } } diff --git a/drivers/media/platform/vsp1/vsp1_entity.h b/drivers/media/platform/vsp1/vsp1_entity.h index 408602ebeb97..c26523c56c05 100644 --- a/drivers/media/platform/vsp1/vsp1_entity.h +++ b/drivers/media/platform/vsp1/vsp1_entity.h @@ -106,6 +106,8 @@ struct vsp1_entity { unsigned int index; const struct vsp1_route *route; + struct vsp1_pipeline *pipe; + struct list_head list_dev; struct list_head list_pipe; diff --git a/drivers/media/platform/vsp1/vsp1_histo.c b/drivers/media/platform/vsp1/vsp1_histo.c index afab77cf4fa5..8638ebc514b4 100644 --- a/drivers/media/platform/vsp1/vsp1_histo.c +++ b/drivers/media/platform/vsp1/vsp1_histo.c @@ -61,7 +61,7 @@ void vsp1_histogram_buffer_complete(struct vsp1_histogram *histo, struct vsp1_histogram_buffer *buf, size_t size) { - struct vsp1_pipeline *pipe = histo->pipe; + struct vsp1_pipeline *pipe = histo->entity.pipe; unsigned long flags; /* diff --git a/drivers/media/platform/vsp1/vsp1_histo.h b/drivers/media/platform/vsp1/vsp1_histo.h index af2874f6031d..e774adbf251f 100644 --- a/drivers/media/platform/vsp1/vsp1_histo.h +++ b/drivers/media/platform/vsp1/vsp1_histo.h @@ -25,7 +25,6 @@ #include "vsp1_entity.h" struct vsp1_device; -struct vsp1_pipeline; #define HISTO_PAD_SINK 0 #define HISTO_PAD_SOURCE 1 @@ -37,8 +36,6 @@ struct vsp1_histogram_buffer { }; struct vsp1_histogram { - struct vsp1_pipeline *pipe; - struct vsp1_entity entity; struct video_device video; struct media_pad pad; diff --git a/drivers/media/platform/vsp1/vsp1_pipe.c b/drivers/media/platform/vsp1/vsp1_pipe.c index 44944ac86d9b..99ccbac3256a 100644 --- a/drivers/media/platform/vsp1/vsp1_pipe.c +++ b/drivers/media/platform/vsp1/vsp1_pipe.c @@ -185,6 +185,7 @@ const struct vsp1_format_info *vsp1_get_format_info(struct vsp1_device *vsp1, void vsp1_pipeline_reset(struct vsp1_pipeline *pipe) { + struct vsp1_entity *entity; unsigned int i; if (pipe->bru) { @@ -194,29 +195,13 @@ void vsp1_pipeline_reset(struct vsp1_pipeline *pipe) bru->inputs[i].rpf = NULL; } - for (i = 0; i < ARRAY_SIZE(pipe->inputs); ++i) { - if (pipe->inputs[i]) { - pipe->inputs[i]->pipe = NULL; - pipe->inputs[i] = NULL; - } - } - - if (pipe->output) { - pipe->output->pipe = NULL; - pipe->output = NULL; - } + for (i = 0; i < ARRAY_SIZE(pipe->inputs); ++i) + pipe->inputs[i] = NULL; - if (pipe->hgo) { - struct vsp1_hgo *hgo = to_hgo(&pipe->hgo->subdev); + pipe->output = NULL; - hgo->histo.pipe = NULL; - } - - if (pipe->hgt) { - struct vsp1_hgt *hgt = to_hgt(&pipe->hgt->subdev); - - hgt->histo.pipe = NULL; - } + list_for_each_entry(entity, &pipe->entities, list_pipe) + entity->pipe = NULL; INIT_LIST_HEAD(&pipe->entities); pipe->state = VSP1_PIPELINE_STOPPED; @@ -423,7 +408,7 @@ void vsp1_pipelines_suspend(struct vsp1_device *vsp1) if (wpf == NULL) continue; - pipe = wpf->pipe; + pipe = wpf->entity.pipe; if (pipe == NULL) continue; @@ -440,7 +425,7 @@ void vsp1_pipelines_suspend(struct vsp1_device *vsp1) if (wpf == NULL) continue; - pipe = wpf->pipe; + pipe = wpf->entity.pipe; if (pipe == NULL) continue; @@ -465,7 +450,7 @@ void vsp1_pipelines_resume(struct vsp1_device *vsp1) if (wpf == NULL) continue; - pipe = wpf->pipe; + pipe = wpf->entity.pipe; if (pipe == NULL) continue; diff --git a/drivers/media/platform/vsp1/vsp1_rwpf.h b/drivers/media/platform/vsp1/vsp1_rwpf.h index 58215a7ab631..c94ac89abfa7 100644 --- a/drivers/media/platform/vsp1/vsp1_rwpf.h +++ b/drivers/media/platform/vsp1/vsp1_rwpf.h @@ -27,7 +27,6 @@ struct v4l2_ctrl; struct vsp1_dl_manager; -struct vsp1_pipeline; struct vsp1_rwpf; struct vsp1_video; @@ -39,7 +38,6 @@ struct vsp1_rwpf { struct vsp1_entity entity; struct v4l2_ctrl_handler ctrls; - struct vsp1_pipeline *pipe; struct vsp1_video *video; unsigned int max_width; diff --git a/drivers/media/platform/vsp1/vsp1_video.c b/drivers/media/platform/vsp1/vsp1_video.c index c2d3b8f0f487..cdd53d6cc408 100644 --- a/drivers/media/platform/vsp1/vsp1_video.c +++ b/drivers/media/platform/vsp1/vsp1_video.c @@ -324,7 +324,7 @@ static int vsp1_video_pipeline_setup_partitions(struct vsp1_pipeline *pipe) static struct vsp1_vb2_buffer * vsp1_video_complete_buffer(struct vsp1_video *video) { - struct vsp1_pipeline *pipe = video->rwpf->pipe; + struct vsp1_pipeline *pipe = video->rwpf->entity.pipe; struct vsp1_vb2_buffer *next = NULL; struct vsp1_vb2_buffer *done; unsigned long flags; @@ -598,20 +598,19 @@ static int vsp1_video_pipeline_build(struct vsp1_pipeline *pipe, subdev = media_entity_to_v4l2_subdev(entity); e = to_vsp1_entity(subdev); list_add_tail(&e->list_pipe, &pipe->entities); + e->pipe = pipe; switch (e->type) { case VSP1_ENTITY_RPF: rwpf = to_rwpf(subdev); pipe->inputs[rwpf->entity.index] = rwpf; rwpf->video->pipe_index = ++pipe->num_inputs; - rwpf->pipe = pipe; break; case VSP1_ENTITY_WPF: rwpf = to_rwpf(subdev); pipe->output = rwpf; rwpf->video->pipe_index = 0; - rwpf->pipe = pipe; break; case VSP1_ENTITY_LIF: @@ -625,12 +624,10 @@ static int vsp1_video_pipeline_build(struct vsp1_pipeline *pipe, case VSP1_ENTITY_HGO: pipe->hgo = e; - to_hgo(subdev)->histo.pipe = pipe; break; case VSP1_ENTITY_HGT: pipe->hgt = e; - to_hgt(subdev)->histo.pipe = pipe; break; default: @@ -682,7 +679,7 @@ static struct vsp1_pipeline *vsp1_video_pipeline_get(struct vsp1_video *video) * Otherwise allocate a new pipeline and initialize it, it will be freed * when the last reference is released. */ - if (!video->rwpf->pipe) { + if (!video->rwpf->entity.pipe) { pipe = kzalloc(sizeof(*pipe), GFP_KERNEL); if (!pipe) return ERR_PTR(-ENOMEM); @@ -694,7 +691,7 @@ static struct vsp1_pipeline *vsp1_video_pipeline_get(struct vsp1_video *video) return ERR_PTR(ret); } } else { - pipe = video->rwpf->pipe; + pipe = video->rwpf->entity.pipe; kref_get(&pipe->kref); } @@ -777,7 +774,7 @@ static void vsp1_video_buffer_queue(struct vb2_buffer *vb) { struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb); struct vsp1_video *video = vb2_get_drv_priv(vb->vb2_queue); - struct vsp1_pipeline *pipe = video->rwpf->pipe; + struct vsp1_pipeline *pipe = video->rwpf->entity.pipe; struct vsp1_vb2_buffer *buf = to_vsp1_vb2_buffer(vbuf); unsigned long flags; bool empty; @@ -872,7 +869,7 @@ static void vsp1_video_cleanup_pipeline(struct vsp1_pipeline *pipe) static int vsp1_video_start_streaming(struct vb2_queue *vq, unsigned int count) { struct vsp1_video *video = vb2_get_drv_priv(vq); - struct vsp1_pipeline *pipe = video->rwpf->pipe; + struct vsp1_pipeline *pipe = video->rwpf->entity.pipe; bool start_pipeline = false; unsigned long flags; int ret; @@ -913,7 +910,7 @@ static int vsp1_video_start_streaming(struct vb2_queue *vq, unsigned int count) static void vsp1_video_stop_streaming(struct vb2_queue *vq) { struct vsp1_video *video = vb2_get_drv_priv(vq); - struct vsp1_pipeline *pipe = video->rwpf->pipe; + struct vsp1_pipeline *pipe = video->rwpf->entity.pipe; unsigned long flags; int ret; -- Regards, Laurent Pinchart From mboxrd@z Thu Jan 1 00:00:00 1970 From: Laurent Pinchart Subject: [PATCH v2 03/15] v4l: vsp1: Store pipeline pointer in vsp1_entity Date: Thu, 5 Apr 2018 12:18:28 +0300 Message-ID: <20180405091840.30728-4-laurent.pinchart+renesas@ideasonboard.com> References: <20180405091840.30728-1-laurent.pinchart+renesas@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 0A8386E6EC for ; Thu, 5 Apr 2018 09:18:36 +0000 (UTC) In-Reply-To: <20180405091840.30728-1-laurent.pinchart+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: linux-media@vger.kernel.org Cc: linux-renesas-soc@vger.kernel.org, Kieran Bingham , dri-devel@lists.freedesktop.org List-Id: dri-devel@lists.freedesktop.org VmFyaW91cyB0eXBlcyBvZiBvYmplY3RzIHN1YmNsYXNzaW5nIHZzcDFfZW50aXR5IGN1cnJlbnRs eSBzdG9yZSBhCnBvaW50ZXIgdG8gdGhlIHBpcGVsaW5lLiBNb3ZlIHRoZSBwb2ludGVyIHRvIHZz cDFfZW50aXR5IHRvIHNpbXBsaWZ5IHRoZQpjb2RlIGFuZCBhdm9pZCBzdG9yaW5nIHRoZSBwaXBl bGluZSBpbiBtb3JlIGVudGl0eSBzdWJjbGFzc2VzIGxhdGVyLgoKU2lnbmVkLW9mZi1ieTogTGF1 cmVudCBQaW5jaGFydCA8bGF1cmVudC5waW5jaGFydCtyZW5lc2FzQGlkZWFzb25ib2FyZC5jb20+ ClJldmlld2VkLWJ5OiBLaWVyYW4gQmluZ2hhbSA8a2llcmFuLmJpbmdoYW0rcmVuZXNhc0BpZGVh c29uYm9hcmQuY29tPgotLS0KIGRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX2RybS5j ICAgIHwgMjAgKysrKysrKysrKysrKy0tLS0tLQogZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3Ax L3ZzcDFfZHJ2LmMgICAgfCAgMiArLQogZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFf ZW50aXR5LmggfCAgMiArKwogZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfaGlzdG8u YyAgfCAgMiArLQogZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfaGlzdG8uaCAgfCAg MyAtLS0KIGRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX3BpcGUuYyAgIHwgMzMgKysr KysrKysrLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3Ax L3ZzcDFfcndwZi5oICAgfCAgMiAtLQogZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFf dmlkZW8uYyAgfCAxNyArKysrKysrLS0tLS0tLS0tCiA4IGZpbGVzIGNoYW5nZWQsIDM0IGluc2Vy dGlvbnMoKyksIDQ3IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvcGxh dGZvcm0vdnNwMS92c3AxX2RybS5jIGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFf ZHJtLmMKaW5kZXggYTI2N2YxMmYwY2M4Li5hN2FkODVhYjBiMDggMTAwNjQ0Ci0tLSBhL2RyaXZl cnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX2RybS5jCisrKyBiL2RyaXZlcnMvbWVkaWEvcGxh dGZvcm0vdnNwMS92c3AxX2RybS5jCkBAIC0xMjAsNiArMTIwLDcgQEAgaW50IHZzcDFfZHVfc2V0 dXBfbGlmKHN0cnVjdCBkZXZpY2UgKmRldiwgdW5zaWduZWQgaW50IHBpcGVfaW5kZXgsCiAJCQkg KiBpbnB1dHMuCiAJCQkgKi8KIAkJCVdBUk5fT04obGlzdF9lbXB0eSgmcnBmLT5lbnRpdHkubGlz dF9waXBlKSk7CisJCQlycGYtPmVudGl0eS5waXBlID0gTlVMTDsKIAkJCWxpc3RfZGVsX2luaXQo JnJwZi0+ZW50aXR5Lmxpc3RfcGlwZSk7CiAJCQlwaXBlLT5pbnB1dHNbaV0gPSBOVUxMOwogCkBA IC01MzYsOCArNTM3LDEwIEBAIHZvaWQgdnNwMV9kdV9hdG9taWNfZmx1c2goc3RydWN0IGRldmlj ZSAqZGV2LCB1bnNpZ25lZCBpbnQgcGlwZV9pbmRleCkKIAkJCWNvbnRpbnVlOwogCQl9CiAKLQkJ aWYgKGxpc3RfZW1wdHkoJnJwZi0+ZW50aXR5Lmxpc3RfcGlwZSkpCisJCWlmIChsaXN0X2VtcHR5 KCZycGYtPmVudGl0eS5saXN0X3BpcGUpKSB7CisJCQlycGYtPmVudGl0eS5waXBlID0gcGlwZTsK IAkJCWxpc3RfYWRkX3RhaWwoJnJwZi0+ZW50aXR5Lmxpc3RfcGlwZSwgJnBpcGUtPmVudGl0aWVz KTsKKwkJfQogCiAJCWJydS0+aW5wdXRzW2ldLnJwZiA9IHJwZjsKIAkJcnBmLT5icnVfaW5wdXQg PSBpOwpAQCAtNTYyLDYgKzU2NSw3IEBAIHZvaWQgdnNwMV9kdV9hdG9taWNfZmx1c2goc3RydWN0 IGRldmljZSAqZGV2LCB1bnNpZ25lZCBpbnQgcGlwZV9pbmRleCkKIAkJCXZzcDFfZGxfbGlzdF93 cml0ZShkbCwgZW50aXR5LT5yb3V0ZS0+cmVnLAogCQkJCQkgICBWSTZfRFBSX05PREVfVU5VU0VE KTsKIAorCQkJZW50aXR5LT5waXBlID0gTlVMTDsKIAkJCWxpc3RfZGVsX2luaXQoJmVudGl0eS0+ bGlzdF9waXBlKTsKIAogCQkJY29udGludWU7CkBAIC02MjUsMjQgKzYyOSwyOCBAQCBpbnQgdnNw MV9kcm1faW5pdChzdHJ1Y3QgdnNwMV9kZXZpY2UgKnZzcDEpCiAKIAkJdnNwMV9waXBlbGluZV9p bml0KHBpcGUpOwogCisJCXBpcGUtPmZyYW1lX2VuZCA9IHZzcDFfZHVfcGlwZWxpbmVfZnJhbWVf ZW5kOworCiAJCS8qCiAJCSAqIFRoZSBEUk0gcGlwZWxpbmUgaXMgc3RhdGljLCBhZGQgZW50aXRp ZXMgbWFudWFsbHkuIFRoZSBmaXJzdAogCQkgKiBwaXBlbGluZSB1c2VzIHRoZSBCUlUgYW5kIHRo ZSBzZWNvbmQgcGlwZWxpbmUgdGhlIEJSUy4KIAkJICovCiAJCXBpcGUtPmJydSA9IGkgPT0gMCA/ ICZ2c3AxLT5icnUtPmVudGl0eSA6ICZ2c3AxLT5icnMtPmVudGl0eTsKLQkJcGlwZS0+bGlmID0g JnZzcDEtPmxpZltpXS0+ZW50aXR5OwogCQlwaXBlLT5vdXRwdXQgPSB2c3AxLT53cGZbaV07Ci0J CXBpcGUtPm91dHB1dC0+cGlwZSA9IHBpcGU7Ci0JCXBpcGUtPmZyYW1lX2VuZCA9IHZzcDFfZHVf cGlwZWxpbmVfZnJhbWVfZW5kOworCQlwaXBlLT5saWYgPSAmdnNwMS0+bGlmW2ldLT5lbnRpdHk7 CiAKKwkJcGlwZS0+YnJ1LT5waXBlID0gcGlwZTsKIAkJcGlwZS0+YnJ1LT5zaW5rID0gJnBpcGUt Pm91dHB1dC0+ZW50aXR5OwogCQlwaXBlLT5icnUtPnNpbmtfcGFkID0gMDsKKwkJbGlzdF9hZGRf dGFpbCgmcGlwZS0+YnJ1LT5saXN0X3BpcGUsICZwaXBlLT5lbnRpdGllcyk7CisKKwkJcGlwZS0+ b3V0cHV0LT5lbnRpdHkucGlwZSA9IHBpcGU7CiAJCXBpcGUtPm91dHB1dC0+ZW50aXR5LnNpbmsg PSBwaXBlLT5saWY7CiAJCXBpcGUtPm91dHB1dC0+ZW50aXR5LnNpbmtfcGFkID0gMDsKKwkJbGlz dF9hZGRfdGFpbCgmcGlwZS0+b3V0cHV0LT5lbnRpdHkubGlzdF9waXBlLCAmcGlwZS0+ZW50aXRp ZXMpOwogCi0JCWxpc3RfYWRkX3RhaWwoJnBpcGUtPmJydS0+bGlzdF9waXBlLCAmcGlwZS0+ZW50 aXRpZXMpOworCQlwaXBlLT5saWYtPnBpcGUgPSBwaXBlOwogCQlsaXN0X2FkZF90YWlsKCZwaXBl LT5saWYtPmxpc3RfcGlwZSwgJnBpcGUtPmVudGl0aWVzKTsKLQkJbGlzdF9hZGRfdGFpbCgmcGlw ZS0+b3V0cHV0LT5lbnRpdHkubGlzdF9waXBlLCAmcGlwZS0+ZW50aXRpZXMpOwogCX0KIAogCS8q IERpc2FibGUgYWxsIFJQRnMgaW5pdGlhbGx5LiAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRp YS9wbGF0Zm9ybS92c3AxL3ZzcDFfZHJ2LmMgYi9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEv dnNwMV9kcnYuYwppbmRleCBlZWQ5NTE2ZTI1ZTEuLjU4YTc5OTNmMjMwNiAxMDA2NDQKLS0tIGEv ZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfZHJ2LmMKKysrIGIvZHJpdmVycy9tZWRp YS9wbGF0Zm9ybS92c3AxL3ZzcDFfZHJ2LmMKQEAgLTYzLDcgKzYzLDcgQEAgc3RhdGljIGlycXJl dHVybl90IHZzcDFfaXJxX2hhbmRsZXIoaW50IGlycSwgdm9pZCAqZGF0YSkKIAkJdnNwMV93cml0 ZSh2c3AxLCBWSTZfV1BGX0lSUV9TVEEoaSksIH5zdGF0dXMgJiBtYXNrKTsKIAogCQlpZiAoc3Rh dHVzICYgVkk2X1dGUF9JUlFfU1RBX0RGRSkgewotCQkJdnNwMV9waXBlbGluZV9mcmFtZV9lbmQo d3BmLT5waXBlKTsKKwkJCXZzcDFfcGlwZWxpbmVfZnJhbWVfZW5kKHdwZi0+ZW50aXR5LnBpcGUp OwogCQkJcmV0ID0gSVJRX0hBTkRMRUQ7CiAJCX0KIAl9CmRpZmYgLS1naXQgYS9kcml2ZXJzL21l ZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9lbnRpdHkuaCBiL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0v dnNwMS92c3AxX2VudGl0eS5oCmluZGV4IDQwODYwMmViZWI5Ny4uYzI2NTIzYzU2YzA1IDEwMDY0 NAotLS0gYS9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9lbnRpdHkuaAorKysgYi9k cml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9lbnRpdHkuaApAQCAtMTA2LDYgKzEwNiw4 IEBAIHN0cnVjdCB2c3AxX2VudGl0eSB7CiAJdW5zaWduZWQgaW50IGluZGV4OwogCWNvbnN0IHN0 cnVjdCB2c3AxX3JvdXRlICpyb3V0ZTsKIAorCXN0cnVjdCB2c3AxX3BpcGVsaW5lICpwaXBlOwor CiAJc3RydWN0IGxpc3RfaGVhZCBsaXN0X2RldjsKIAlzdHJ1Y3QgbGlzdF9oZWFkIGxpc3RfcGlw ZTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfaGlzdG8u YyBiL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX2hpc3RvLmMKaW5kZXggYWZhYjc3 Y2Y0ZmE1Li44NjM4ZWJjNTE0YjQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0v dnNwMS92c3AxX2hpc3RvLmMKKysrIGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFf aGlzdG8uYwpAQCAtNjEsNyArNjEsNyBAQCB2b2lkIHZzcDFfaGlzdG9ncmFtX2J1ZmZlcl9jb21w bGV0ZShzdHJ1Y3QgdnNwMV9oaXN0b2dyYW0gKmhpc3RvLAogCQkJCSAgICBzdHJ1Y3QgdnNwMV9o aXN0b2dyYW1fYnVmZmVyICpidWYsCiAJCQkJICAgIHNpemVfdCBzaXplKQogewotCXN0cnVjdCB2 c3AxX3BpcGVsaW5lICpwaXBlID0gaGlzdG8tPnBpcGU7CisJc3RydWN0IHZzcDFfcGlwZWxpbmUg KnBpcGUgPSBoaXN0by0+ZW50aXR5LnBpcGU7CiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIAogCS8q CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9oaXN0by5oIGIv ZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfaGlzdG8uaAppbmRleCBhZjI4NzRmNjAz MWQuLmU3NzRhZGJmMjUxZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3Ax L3ZzcDFfaGlzdG8uaAorKysgYi9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9oaXN0 by5oCkBAIC0yNSw3ICsyNSw2IEBACiAjaW5jbHVkZSAidnNwMV9lbnRpdHkuaCIKIAogc3RydWN0 IHZzcDFfZGV2aWNlOwotc3RydWN0IHZzcDFfcGlwZWxpbmU7CiAKICNkZWZpbmUgSElTVE9fUEFE X1NJTksJCQkJMAogI2RlZmluZSBISVNUT19QQURfU09VUkNFCQkJMQpAQCAtMzcsOCArMzYsNiBA QCBzdHJ1Y3QgdnNwMV9oaXN0b2dyYW1fYnVmZmVyIHsKIH07CiAKIHN0cnVjdCB2c3AxX2hpc3Rv Z3JhbSB7Ci0Jc3RydWN0IHZzcDFfcGlwZWxpbmUgKnBpcGU7Ci0KIAlzdHJ1Y3QgdnNwMV9lbnRp dHkgZW50aXR5OwogCXN0cnVjdCB2aWRlb19kZXZpY2UgdmlkZW87CiAJc3RydWN0IG1lZGlhX3Bh ZCBwYWQ7CmRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9waXBl LmMgYi9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9waXBlLmMKaW5kZXggNDQ5NDRh Yzg2ZDliLi45OWNjYmFjMzI1NmEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0v dnNwMS92c3AxX3BpcGUuYworKysgYi9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9w aXBlLmMKQEAgLTE4NSw2ICsxODUsNyBAQCBjb25zdCBzdHJ1Y3QgdnNwMV9mb3JtYXRfaW5mbyAq dnNwMV9nZXRfZm9ybWF0X2luZm8oc3RydWN0IHZzcDFfZGV2aWNlICp2c3AxLAogCiB2b2lkIHZz cDFfcGlwZWxpbmVfcmVzZXQoc3RydWN0IHZzcDFfcGlwZWxpbmUgKnBpcGUpCiB7CisJc3RydWN0 IHZzcDFfZW50aXR5ICplbnRpdHk7CiAJdW5zaWduZWQgaW50IGk7CiAKIAlpZiAocGlwZS0+YnJ1 KSB7CkBAIC0xOTQsMjkgKzE5NSwxMyBAQCB2b2lkIHZzcDFfcGlwZWxpbmVfcmVzZXQoc3RydWN0 IHZzcDFfcGlwZWxpbmUgKnBpcGUpCiAJCQlicnUtPmlucHV0c1tpXS5ycGYgPSBOVUxMOwogCX0K IAotCWZvciAoaSA9IDA7IGkgPCBBUlJBWV9TSVpFKHBpcGUtPmlucHV0cyk7ICsraSkgewotCQlp ZiAocGlwZS0+aW5wdXRzW2ldKSB7Ci0JCQlwaXBlLT5pbnB1dHNbaV0tPnBpcGUgPSBOVUxMOwot CQkJcGlwZS0+aW5wdXRzW2ldID0gTlVMTDsKLQkJfQotCX0KLQotCWlmIChwaXBlLT5vdXRwdXQp IHsKLQkJcGlwZS0+b3V0cHV0LT5waXBlID0gTlVMTDsKLQkJcGlwZS0+b3V0cHV0ID0gTlVMTDsK LQl9CisJZm9yIChpID0gMDsgaSA8IEFSUkFZX1NJWkUocGlwZS0+aW5wdXRzKTsgKytpKQorCQlw aXBlLT5pbnB1dHNbaV0gPSBOVUxMOwogCi0JaWYgKHBpcGUtPmhnbykgewotCQlzdHJ1Y3QgdnNw MV9oZ28gKmhnbyA9IHRvX2hnbygmcGlwZS0+aGdvLT5zdWJkZXYpOworCXBpcGUtPm91dHB1dCA9 IE5VTEw7CiAKLQkJaGdvLT5oaXN0by5waXBlID0gTlVMTDsKLQl9Ci0KLQlpZiAocGlwZS0+aGd0 KSB7Ci0JCXN0cnVjdCB2c3AxX2hndCAqaGd0ID0gdG9faGd0KCZwaXBlLT5oZ3QtPnN1YmRldik7 Ci0KLQkJaGd0LT5oaXN0by5waXBlID0gTlVMTDsKLQl9CisJbGlzdF9mb3JfZWFjaF9lbnRyeShl bnRpdHksICZwaXBlLT5lbnRpdGllcywgbGlzdF9waXBlKQorCQllbnRpdHktPnBpcGUgPSBOVUxM OwogCiAJSU5JVF9MSVNUX0hFQUQoJnBpcGUtPmVudGl0aWVzKTsKIAlwaXBlLT5zdGF0ZSA9IFZT UDFfUElQRUxJTkVfU1RPUFBFRDsKQEAgLTQyMyw3ICs0MDgsNyBAQCB2b2lkIHZzcDFfcGlwZWxp bmVzX3N1c3BlbmQoc3RydWN0IHZzcDFfZGV2aWNlICp2c3AxKQogCQlpZiAod3BmID09IE5VTEwp CiAJCQljb250aW51ZTsKIAotCQlwaXBlID0gd3BmLT5waXBlOworCQlwaXBlID0gd3BmLT5lbnRp dHkucGlwZTsKIAkJaWYgKHBpcGUgPT0gTlVMTCkKIAkJCWNvbnRpbnVlOwogCkBAIC00NDAsNyAr NDI1LDcgQEAgdm9pZCB2c3AxX3BpcGVsaW5lc19zdXNwZW5kKHN0cnVjdCB2c3AxX2RldmljZSAq dnNwMSkKIAkJaWYgKHdwZiA9PSBOVUxMKQogCQkJY29udGludWU7CiAKLQkJcGlwZSA9IHdwZi0+ cGlwZTsKKwkJcGlwZSA9IHdwZi0+ZW50aXR5LnBpcGU7CiAJCWlmIChwaXBlID09IE5VTEwpCiAJ CQljb250aW51ZTsKIApAQCAtNDY1LDcgKzQ1MCw3IEBAIHZvaWQgdnNwMV9waXBlbGluZXNfcmVz dW1lKHN0cnVjdCB2c3AxX2RldmljZSAqdnNwMSkKIAkJaWYgKHdwZiA9PSBOVUxMKQogCQkJY29u dGludWU7CiAKLQkJcGlwZSA9IHdwZi0+cGlwZTsKKwkJcGlwZSA9IHdwZi0+ZW50aXR5LnBpcGU7 CiAJCWlmIChwaXBlID09IE5VTEwpCiAJCQljb250aW51ZTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVy cy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfcndwZi5oIGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9y bS92c3AxL3ZzcDFfcndwZi5oCmluZGV4IDU4MjE1YTdhYjYzMS4uYzk0YWM4OWFiZmE3IDEwMDY0 NAotLS0gYS9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9yd3BmLmgKKysrIGIvZHJp dmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfcndwZi5oCkBAIC0yNyw3ICsyNyw2IEBACiAK IHN0cnVjdCB2NGwyX2N0cmw7CiBzdHJ1Y3QgdnNwMV9kbF9tYW5hZ2VyOwotc3RydWN0IHZzcDFf cGlwZWxpbmU7CiBzdHJ1Y3QgdnNwMV9yd3BmOwogc3RydWN0IHZzcDFfdmlkZW87CiAKQEAgLTM5 LDcgKzM4LDYgQEAgc3RydWN0IHZzcDFfcndwZiB7CiAJc3RydWN0IHZzcDFfZW50aXR5IGVudGl0 eTsKIAlzdHJ1Y3QgdjRsMl9jdHJsX2hhbmRsZXIgY3RybHM7CiAKLQlzdHJ1Y3QgdnNwMV9waXBl bGluZSAqcGlwZTsKIAlzdHJ1Y3QgdnNwMV92aWRlbyAqdmlkZW87CiAKIAl1bnNpZ25lZCBpbnQg bWF4X3dpZHRoOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFf dmlkZW8uYyBiL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX3ZpZGVvLmMKaW5kZXgg YzJkM2I4ZjBmNDg3Li5jZGQ1M2Q2Y2M0MDggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvcGxh dGZvcm0vdnNwMS92c3AxX3ZpZGVvLmMKKysrIGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3Ax L3ZzcDFfdmlkZW8uYwpAQCAtMzI0LDcgKzMyNCw3IEBAIHN0YXRpYyBpbnQgdnNwMV92aWRlb19w aXBlbGluZV9zZXR1cF9wYXJ0aXRpb25zKHN0cnVjdCB2c3AxX3BpcGVsaW5lICpwaXBlKQogc3Rh dGljIHN0cnVjdCB2c3AxX3ZiMl9idWZmZXIgKgogdnNwMV92aWRlb19jb21wbGV0ZV9idWZmZXIo c3RydWN0IHZzcDFfdmlkZW8gKnZpZGVvKQogewotCXN0cnVjdCB2c3AxX3BpcGVsaW5lICpwaXBl ID0gdmlkZW8tPnJ3cGYtPnBpcGU7CisJc3RydWN0IHZzcDFfcGlwZWxpbmUgKnBpcGUgPSB2aWRl by0+cndwZi0+ZW50aXR5LnBpcGU7CiAJc3RydWN0IHZzcDFfdmIyX2J1ZmZlciAqbmV4dCA9IE5V TEw7CiAJc3RydWN0IHZzcDFfdmIyX2J1ZmZlciAqZG9uZTsKIAl1bnNpZ25lZCBsb25nIGZsYWdz OwpAQCAtNTk4LDIwICs1OTgsMTkgQEAgc3RhdGljIGludCB2c3AxX3ZpZGVvX3BpcGVsaW5lX2J1 aWxkKHN0cnVjdCB2c3AxX3BpcGVsaW5lICpwaXBlLAogCQlzdWJkZXYgPSBtZWRpYV9lbnRpdHlf dG9fdjRsMl9zdWJkZXYoZW50aXR5KTsKIAkJZSA9IHRvX3ZzcDFfZW50aXR5KHN1YmRldik7CiAJ CWxpc3RfYWRkX3RhaWwoJmUtPmxpc3RfcGlwZSwgJnBpcGUtPmVudGl0aWVzKTsKKwkJZS0+cGlw ZSA9IHBpcGU7CiAKIAkJc3dpdGNoIChlLT50eXBlKSB7CiAJCWNhc2UgVlNQMV9FTlRJVFlfUlBG OgogCQkJcndwZiA9IHRvX3J3cGYoc3ViZGV2KTsKIAkJCXBpcGUtPmlucHV0c1tyd3BmLT5lbnRp dHkuaW5kZXhdID0gcndwZjsKIAkJCXJ3cGYtPnZpZGVvLT5waXBlX2luZGV4ID0gKytwaXBlLT5u dW1faW5wdXRzOwotCQkJcndwZi0+cGlwZSA9IHBpcGU7CiAJCQlicmVhazsKIAogCQljYXNlIFZT UDFfRU5USVRZX1dQRjoKIAkJCXJ3cGYgPSB0b19yd3BmKHN1YmRldik7CiAJCQlwaXBlLT5vdXRw dXQgPSByd3BmOwogCQkJcndwZi0+dmlkZW8tPnBpcGVfaW5kZXggPSAwOwotCQkJcndwZi0+cGlw ZSA9IHBpcGU7CiAJCQlicmVhazsKIAogCQljYXNlIFZTUDFfRU5USVRZX0xJRjoKQEAgLTYyNSwx MiArNjI0LDEwIEBAIHN0YXRpYyBpbnQgdnNwMV92aWRlb19waXBlbGluZV9idWlsZChzdHJ1Y3Qg dnNwMV9waXBlbGluZSAqcGlwZSwKIAogCQljYXNlIFZTUDFfRU5USVRZX0hHTzoKIAkJCXBpcGUt PmhnbyA9IGU7Ci0JCQl0b19oZ28oc3ViZGV2KS0+aGlzdG8ucGlwZSA9IHBpcGU7CiAJCQlicmVh azsKIAogCQljYXNlIFZTUDFfRU5USVRZX0hHVDoKIAkJCXBpcGUtPmhndCA9IGU7Ci0JCQl0b19o Z3Qoc3ViZGV2KS0+aGlzdG8ucGlwZSA9IHBpcGU7CiAJCQlicmVhazsKIAogCQlkZWZhdWx0OgpA QCAtNjgyLDcgKzY3OSw3IEBAIHN0YXRpYyBzdHJ1Y3QgdnNwMV9waXBlbGluZSAqdnNwMV92aWRl b19waXBlbGluZV9nZXQoc3RydWN0IHZzcDFfdmlkZW8gKnZpZGVvKQogCSAqIE90aGVyd2lzZSBh bGxvY2F0ZSBhIG5ldyBwaXBlbGluZSBhbmQgaW5pdGlhbGl6ZSBpdCwgaXQgd2lsbCBiZSBmcmVl ZAogCSAqIHdoZW4gdGhlIGxhc3QgcmVmZXJlbmNlIGlzIHJlbGVhc2VkLgogCSAqLwotCWlmICgh dmlkZW8tPnJ3cGYtPnBpcGUpIHsKKwlpZiAoIXZpZGVvLT5yd3BmLT5lbnRpdHkucGlwZSkgewog CQlwaXBlID0ga3phbGxvYyhzaXplb2YoKnBpcGUpLCBHRlBfS0VSTkVMKTsKIAkJaWYgKCFwaXBl KQogCQkJcmV0dXJuIEVSUl9QVFIoLUVOT01FTSk7CkBAIC02OTQsNyArNjkxLDcgQEAgc3RhdGlj IHN0cnVjdCB2c3AxX3BpcGVsaW5lICp2c3AxX3ZpZGVvX3BpcGVsaW5lX2dldChzdHJ1Y3QgdnNw MV92aWRlbyAqdmlkZW8pCiAJCQlyZXR1cm4gRVJSX1BUUihyZXQpOwogCQl9CiAJfSBlbHNlIHsK LQkJcGlwZSA9IHZpZGVvLT5yd3BmLT5waXBlOworCQlwaXBlID0gdmlkZW8tPnJ3cGYtPmVudGl0 eS5waXBlOwogCQlrcmVmX2dldCgmcGlwZS0+a3JlZik7CiAJfQogCkBAIC03NzcsNyArNzc0LDcg QEAgc3RhdGljIHZvaWQgdnNwMV92aWRlb19idWZmZXJfcXVldWUoc3RydWN0IHZiMl9idWZmZXIg KnZiKQogewogCXN0cnVjdCB2YjJfdjRsMl9idWZmZXIgKnZidWYgPSB0b192YjJfdjRsMl9idWZm ZXIodmIpOwogCXN0cnVjdCB2c3AxX3ZpZGVvICp2aWRlbyA9IHZiMl9nZXRfZHJ2X3ByaXYodmIt PnZiMl9xdWV1ZSk7Ci0Jc3RydWN0IHZzcDFfcGlwZWxpbmUgKnBpcGUgPSB2aWRlby0+cndwZi0+ cGlwZTsKKwlzdHJ1Y3QgdnNwMV9waXBlbGluZSAqcGlwZSA9IHZpZGVvLT5yd3BmLT5lbnRpdHku cGlwZTsKIAlzdHJ1Y3QgdnNwMV92YjJfYnVmZmVyICpidWYgPSB0b192c3AxX3ZiMl9idWZmZXIo dmJ1Zik7CiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIAlib29sIGVtcHR5OwpAQCAtODcyLDcgKzg2 OSw3IEBAIHN0YXRpYyB2b2lkIHZzcDFfdmlkZW9fY2xlYW51cF9waXBlbGluZShzdHJ1Y3QgdnNw MV9waXBlbGluZSAqcGlwZSkKIHN0YXRpYyBpbnQgdnNwMV92aWRlb19zdGFydF9zdHJlYW1pbmco c3RydWN0IHZiMl9xdWV1ZSAqdnEsIHVuc2lnbmVkIGludCBjb3VudCkKIHsKIAlzdHJ1Y3QgdnNw MV92aWRlbyAqdmlkZW8gPSB2YjJfZ2V0X2Rydl9wcml2KHZxKTsKLQlzdHJ1Y3QgdnNwMV9waXBl bGluZSAqcGlwZSA9IHZpZGVvLT5yd3BmLT5waXBlOworCXN0cnVjdCB2c3AxX3BpcGVsaW5lICpw aXBlID0gdmlkZW8tPnJ3cGYtPmVudGl0eS5waXBlOwogCWJvb2wgc3RhcnRfcGlwZWxpbmUgPSBm YWxzZTsKIAl1bnNpZ25lZCBsb25nIGZsYWdzOwogCWludCByZXQ7CkBAIC05MTMsNyArOTEwLDcg QEAgc3RhdGljIGludCB2c3AxX3ZpZGVvX3N0YXJ0X3N0cmVhbWluZyhzdHJ1Y3QgdmIyX3F1ZXVl ICp2cSwgdW5zaWduZWQgaW50IGNvdW50KQogc3RhdGljIHZvaWQgdnNwMV92aWRlb19zdG9wX3N0 cmVhbWluZyhzdHJ1Y3QgdmIyX3F1ZXVlICp2cSkKIHsKIAlzdHJ1Y3QgdnNwMV92aWRlbyAqdmlk ZW8gPSB2YjJfZ2V0X2Rydl9wcml2KHZxKTsKLQlzdHJ1Y3QgdnNwMV9waXBlbGluZSAqcGlwZSA9 IHZpZGVvLT5yd3BmLT5waXBlOworCXN0cnVjdCB2c3AxX3BpcGVsaW5lICpwaXBlID0gdmlkZW8t PnJ3cGYtPmVudGl0eS5waXBlOwogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAJaW50IHJldDsKIAot LSAKUmVnYXJkcywKCkxhdXJlbnQgUGluY2hhcnQKCl9fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fCmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRldmVsQGxp c3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFu L2xpc3RpbmZvL2RyaS1kZXZlbAo=