From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from galahad.ideasonboard.com ([185.26.127.97]:48540 "EHLO galahad.ideasonboard.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752141AbeDDVn2 (ORCPT ); Wed, 4 Apr 2018 17:43:28 -0400 From: Laurent Pinchart To: Kieran Bingham Cc: Laurent Pinchart , linux-media@vger.kernel.org, dri-devel@lists.freedesktop.org, linux-renesas-soc@vger.kernel.org Subject: Re: [PATCH 11/15] v4l: vsp1: Add per-display list completion notification support Date: Thu, 05 Apr 2018 00:43:37 +0300 Message-ID: <12800662.MfxixVfYp4@avalon> In-Reply-To: References: <20180226214516.11559-1-laurent.pinchart+renesas@ideasonboard.com> <20180226214516.11559-12-laurent.pinchart+renesas@ideasonboard.com> MIME-Version: 1.0 Content-Transfer-Encoding: 7Bit Content-Type: text/plain; charset="us-ascii" Sender: linux-renesas-soc-owner@vger.kernel.org List-ID: Hi Kieran, On Wednesday, 4 April 2018 19:16:46 EEST Kieran Bingham wrote: > On 26/02/18 21:45, Laurent Pinchart wrote: > > Display list completion is already reported to the frame end handler, > > but that mechanism is global to all display lists. In order to implement > > BRU and BRS reassignment in DRM pipelines we will need to wait for > > completion of a particular display list. Extend the display list and > > frame end handler APIs to support such a notification. > > > > Signed-off-by: Laurent Pinchart > > > > --- > > > > drivers/media/platform/vsp1/vsp1_dl.c | 27 +++++++++++++++++++++++++-- > > drivers/media/platform/vsp1/vsp1_dl.h | 4 ++-- > > drivers/media/platform/vsp1/vsp1_drm.c | 4 ++-- > > drivers/media/platform/vsp1/vsp1_pipe.c | 5 +++-- > > drivers/media/platform/vsp1/vsp1_pipe.h | 3 ++- > > drivers/media/platform/vsp1/vsp1_video.c | 4 ++-- > > 6 files changed, 36 insertions(+), 11 deletions(-) > > > > diff --git a/drivers/media/platform/vsp1/vsp1_dl.c > > b/drivers/media/platform/vsp1/vsp1_dl.c index 0b86ed01e85d..eb2971218e28 > > 100644 > > --- a/drivers/media/platform/vsp1/vsp1_dl.c > > +++ b/drivers/media/platform/vsp1/vsp1_dl.c > > @@ -72,6 +72,7 @@ struct vsp1_dl_body { > > * @fragments: list of extra display list bodies > > * @has_chain: if true, indicates that there's a partition chain > > * @chain: entry in the display list partition chain > > + * @notify: whether the display list completion should be notified > > */ > > struct vsp1_dl_list { > > struct list_head list; > > @@ -85,6 +86,8 @@ struct vsp1_dl_list { > > bool has_chain; > > struct list_head chain; > > + > > + bool notify; > > }; > > > > enum vsp1_dl_mode { > > @@ -550,8 +553,16 @@ static void vsp1_dl_list_commit_continuous(struct > > vsp1_dl_list *dl)> > > * case we can't replace the queued list by the new one, as we could > > * race with the hardware. We thus mark the update as pending, it will > > * be queued up to the hardware by the frame end interrupt handler. > > + * > > + * If a display list is already pending we simply drop it as the new > > + * display list is assumed to contain a more recent configuration. It > > is > > + * an error if the already pending list has the notify flag set, as > > + * there is then a process waiting for that list to complete. This > > + * shouldn't happen as the waiting process should perform proper > > + * locking, but warn just in case. > > */ > > if (vsp1_dl_list_hw_update_pending(dlm)) { > > + WARN_ON(dlm->pending && dlm->pending->notify); > > __vsp1_dl_list_put(dlm->pending); > > dlm->pending = dl; > > > > @@ -581,7 +592,7 @@ static void vsp1_dl_list_commit_singleshot(struct > > vsp1_dl_list *dl) > > dlm->active = dl; > > } > > > > -void vsp1_dl_list_commit(struct vsp1_dl_list *dl) > > +void vsp1_dl_list_commit(struct vsp1_dl_list *dl, bool notify) > > Rather than changing the vsp1_dl_list_commit() function - would it be nicer > to have an API to request or set the notify property? : > > @@..@@ static void vsp1_du_pipeline_configure(struct vsp1_pipeline *pipe) > ... > + /* The BRx will be released, without sending an update to DRM */ > + if (drm_pipe->force_bru_release) > + vsp1_dl_list_request_internal_notify(dl); > > vsp1_dl_list_commit(dl); > ... That's not a bad idea, but I wonder if it's worth it as we'll have to call an extra function for what is essentially an internal API. On the other hand this isn't a common case, so it's not a hot code path. We could also argue equally that it is the commit that is internal or that it is the display list that is for internal purpose. Do you think an extra function call is better ? If you do I'll change it. > > { > > struct vsp1_dl_manager *dlm = dl->dlm; > > struct vsp1_dl_list *dl_child; > > @@ -598,6 +609,8 @@ void vsp1_dl_list_commit(struct vsp1_dl_list *dl) > > } > > } > > > > + dl->notify = notify; > > + > > spin_lock_irqsave(&dlm->lock, flags); > > > > if (dlm->singleshot) > > @@ -615,16 +628,23 @@ void vsp1_dl_list_commit(struct vsp1_dl_list *dl) > > /** > > * vsp1_dlm_irq_frame_end - Display list handler for the frame end > > interrupt > > * @dlm: the display list manager > > + * @notify: whether the display list that completed has notification > > enabled > > * > > * Return true if the previous display list has completed at frame end, > > or false > > * if it has been delayed by one frame because the display list commit > > raced > > * with the frame end interrupt. The function always returns true in > > header mode > > * as display list processing is then not continuous and races never > > occur. > > + * > > + * Upon return, the @notify parameter is set to true if the previous > > display > > + * list has completed and had been queued with the notify flag, or to > > false > > + * otherwise. Notification is only supported for continuous mode. > > */ > > -bool vsp1_dlm_irq_frame_end(struct vsp1_dl_manager *dlm) > > +bool vsp1_dlm_irq_frame_end(struct vsp1_dl_manager *dlm, bool *notify) > > { > > bool completed = false; > > > > + *notify = false; > > + > > spin_lock(&dlm->lock); > > > > /* > > @@ -652,6 +672,9 @@ bool vsp1_dlm_irq_frame_end(struct vsp1_dl_manager > > *dlm) > > * frame end interrupt. The display list thus becomes active. > > */ > > if (dlm->queued) { > > + *notify = dlm->queued->notify; > > + dlm->queued->notify = false; > > + > > __vsp1_dl_list_put(dlm->active); > > dlm->active = dlm->queued; > > dlm->queued = NULL; > > diff --git a/drivers/media/platform/vsp1/vsp1_dl.h > > b/drivers/media/platform/vsp1/vsp1_dl.h index ee3508172f0a..480c6b0dd2e4 > > 100644 > > --- a/drivers/media/platform/vsp1/vsp1_dl.h > > +++ b/drivers/media/platform/vsp1/vsp1_dl.h > > @@ -27,12 +27,12 @@ struct vsp1_dl_manager *vsp1_dlm_create(struct > > vsp1_device *vsp1, > > unsigned int prealloc); > > void vsp1_dlm_destroy(struct vsp1_dl_manager *dlm); > > void vsp1_dlm_reset(struct vsp1_dl_manager *dlm); > > -bool vsp1_dlm_irq_frame_end(struct vsp1_dl_manager *dlm); > > +bool vsp1_dlm_irq_frame_end(struct vsp1_dl_manager *dlm, bool *notify); > > > > struct vsp1_dl_list *vsp1_dl_list_get(struct vsp1_dl_manager *dlm); > > void vsp1_dl_list_put(struct vsp1_dl_list *dl); > > void vsp1_dl_list_write(struct vsp1_dl_list *dl, u32 reg, u32 data); > > -void vsp1_dl_list_commit(struct vsp1_dl_list *dl); > > +void vsp1_dl_list_commit(struct vsp1_dl_list *dl, bool notify); > > > > struct vsp1_dl_body *vsp1_dl_fragment_alloc(struct vsp1_device *vsp1, > > unsigned int num_entries); > > diff --git a/drivers/media/platform/vsp1/vsp1_drm.c > > b/drivers/media/platform/vsp1/vsp1_drm.c index 1c8adda47440..d705a6e9fa1d > > 100644 > > --- a/drivers/media/platform/vsp1/vsp1_drm.c > > +++ b/drivers/media/platform/vsp1/vsp1_drm.c > > @@ -34,7 +34,7 @@ > > */ > > > > static void vsp1_du_pipeline_frame_end(struct vsp1_pipeline *pipe, > > - bool completed) > > + bool completed, bool notify) > > { > > struct vsp1_drm_pipeline *drm_pipe = to_vsp1_drm_pipeline(pipe); > > > > @@ -370,7 +370,7 @@ static void vsp1_du_pipeline_configure(struct > > vsp1_pipeline *pipe) > > } > > } > > > > - vsp1_dl_list_commit(dl); > > + vsp1_dl_list_commit(dl, false); > > } > > > > /* ---------------------------------------------------------------------- > > diff --git a/drivers/media/platform/vsp1/vsp1_pipe.c > > b/drivers/media/platform/vsp1/vsp1_pipe.c index > > 99ccbac3256a..4d819c9019f4 100644 > > --- a/drivers/media/platform/vsp1/vsp1_pipe.c > > +++ b/drivers/media/platform/vsp1/vsp1_pipe.c > > @@ -316,6 +316,7 @@ bool vsp1_pipeline_ready(struct vsp1_pipeline *pipe) > > void vsp1_pipeline_frame_end(struct vsp1_pipeline *pipe) > > { > > bool completed; > > + bool notify; > > > > if (pipe == NULL) > > return; > > @@ -325,7 +326,7 @@ void vsp1_pipeline_frame_end(struct vsp1_pipeline > > *pipe) > > * up being postponed by one frame. @completed represents whether the > > * active frame was finished or postponed. > > */ > > - completed = vsp1_dlm_irq_frame_end(pipe->output->dlm); > > + completed = vsp1_dlm_irq_frame_end(pipe->output->dlm, ¬ify); > > Eugh ... two return values, one passed back through the return, and the > other passed as a pointer. I don't like it much either :-/ > What about converting this to some flags which get passed into the > pipe->frame_end() instead? That's a very good idea, I'll do that. > > if (pipe->hgo) > > vsp1_hgo_frame_end(pipe->hgo); > > > > @@ -338,7 +339,7 @@ void vsp1_pipeline_frame_end(struct vsp1_pipeline > > *pipe)> > > * frame_end to account for vblank events. > > */ > > if (pipe->frame_end) > > - pipe->frame_end(pipe, completed); > > + pipe->frame_end(pipe, completed, notify); > > > > pipe->sequence++; > > } > > > > diff --git a/drivers/media/platform/vsp1/vsp1_pipe.h > > b/drivers/media/platform/vsp1/vsp1_pipe.h index > > dfff9b5685fe..482711024fa2 100644 > > --- a/drivers/media/platform/vsp1/vsp1_pipe.h > > +++ b/drivers/media/platform/vsp1/vsp1_pipe.h > > @@ -118,7 +118,8 @@ struct vsp1_pipeline { > > enum vsp1_pipeline_state state; > > wait_queue_head_t wq; > > > > - void (*frame_end)(struct vsp1_pipeline *pipe, bool completed); > > + void (*frame_end)(struct vsp1_pipeline *pipe, bool completed, > > + bool notify); > > > > struct mutex lock; > > struct kref kref; > > diff --git a/drivers/media/platform/vsp1/vsp1_video.c > > b/drivers/media/platform/vsp1/vsp1_video.c index > > cdd53d6cc408..483b4259e1b4 100644 > > --- a/drivers/media/platform/vsp1/vsp1_video.c > > +++ b/drivers/media/platform/vsp1/vsp1_video.c > > @@ -437,14 +437,14 @@ static void vsp1_video_pipeline_run(struct > > vsp1_pipeline *pipe)> > > } > > > > /* Complete, and commit the head display list. */ > > - vsp1_dl_list_commit(pipe->dl); > > + vsp1_dl_list_commit(pipe->dl, false); > > > > pipe->dl = NULL; > > > > vsp1_pipeline_run(pipe); > > } > > > > static void vsp1_video_pipeline_frame_end(struct vsp1_pipeline *pipe, > > - bool completed) > > + bool completed, bool notify) > > { > > struct vsp1_device *vsp1 = pipe->output->entity.vsp1; > > enum vsp1_pipeline_state state; -- Regards, Laurent Pinchart From mboxrd@z Thu Jan 1 00:00:00 1970 From: Laurent Pinchart Subject: Re: [PATCH 11/15] v4l: vsp1: Add per-display list completion notification support Date: Thu, 05 Apr 2018 00:43:37 +0300 Message-ID: <12800662.MfxixVfYp4@avalon> References: <20180226214516.11559-1-laurent.pinchart+renesas@ideasonboard.com> <20180226214516.11559-12-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 [IPv6:2001:4b98:dc2:45:216:3eff:febb:480d]) by gabe.freedesktop.org (Postfix) with ESMTPS id CC1426E62F for ; Wed, 4 Apr 2018 21:43:28 +0000 (UTC) In-Reply-To: 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, Laurent Pinchart , dri-devel@lists.freedesktop.org, linux-media@vger.kernel.org List-Id: dri-devel@lists.freedesktop.org SGkgS2llcmFuLAoKT24gV2VkbmVzZGF5LCA0IEFwcmlsIDIwMTggMTk6MTY6NDYgRUVTVCBLaWVy YW4gQmluZ2hhbSB3cm90ZToKPiBPbiAyNi8wMi8xOCAyMTo0NSwgTGF1cmVudCBQaW5jaGFydCB3 cm90ZToKPiA+IERpc3BsYXkgbGlzdCBjb21wbGV0aW9uIGlzIGFscmVhZHkgcmVwb3J0ZWQgdG8g dGhlIGZyYW1lIGVuZCBoYW5kbGVyLAo+ID4gYnV0IHRoYXQgbWVjaGFuaXNtIGlzIGdsb2JhbCB0 byBhbGwgZGlzcGxheSBsaXN0cy4gSW4gb3JkZXIgdG8gaW1wbGVtZW50Cj4gPiBCUlUgYW5kIEJS UyByZWFzc2lnbm1lbnQgaW4gRFJNIHBpcGVsaW5lcyB3ZSB3aWxsIG5lZWQgdG8gd2FpdCBmb3IK PiA+IGNvbXBsZXRpb24gb2YgYSBwYXJ0aWN1bGFyIGRpc3BsYXkgbGlzdC4gRXh0ZW5kIHRoZSBk aXNwbGF5IGxpc3QgYW5kCj4gPiBmcmFtZSBlbmQgaGFuZGxlciBBUElzIHRvIHN1cHBvcnQgc3Vj aCBhIG5vdGlmaWNhdGlvbi4KPiA+IAo+ID4gU2lnbmVkLW9mZi1ieTogTGF1cmVudCBQaW5jaGFy dAo+ID4gPGxhdXJlbnQucGluY2hhcnQrcmVuZXNhc0BpZGVhc29uYm9hcmQuY29tPgo+ID4gLS0t Cj4gPiAKPiA+ICBkcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9kbC5jICAgIHwgMjcg KysrKysrKysrKysrKysrKysrKysrKysrKy0tCj4gPiAgZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92 c3AxL3ZzcDFfZGwuaCAgICB8ICA0ICsrLS0KPiA+ICBkcml2ZXJzL21lZGlhL3BsYXRmb3JtL3Zz cDEvdnNwMV9kcm0uYyAgIHwgIDQgKystLQo+ID4gIGRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNw MS92c3AxX3BpcGUuYyAgfCAgNSArKystLQo+ID4gIGRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNw MS92c3AxX3BpcGUuaCAgfCAgMyArKy0KPiA+ICBkcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEv dnNwMV92aWRlby5jIHwgIDQgKystLQo+ID4gIDYgZmlsZXMgY2hhbmdlZCwgMzYgaW5zZXJ0aW9u cygrKSwgMTEgZGVsZXRpb25zKC0pCj4gPiAKPiA+IGRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlh L3BsYXRmb3JtL3ZzcDEvdnNwMV9kbC5jCj4gPiBiL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNw MS92c3AxX2RsLmMgaW5kZXggMGI4NmVkMDFlODVkLi5lYjI5NzEyMThlMjgKPiA+IDEwMDY0NAo+ ID4gLS0tIGEvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfZGwuYwo+ID4gKysrIGIv ZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfZGwuYwo+ID4gQEAgLTcyLDYgKzcyLDcg QEAgc3RydWN0IHZzcDFfZGxfYm9keSB7Cj4gPiAgICogQGZyYWdtZW50czogbGlzdCBvZiBleHRy YSBkaXNwbGF5IGxpc3QgYm9kaWVzCj4gPiAgICogQGhhc19jaGFpbjogaWYgdHJ1ZSwgaW5kaWNh dGVzIHRoYXQgdGhlcmUncyBhIHBhcnRpdGlvbiBjaGFpbgo+ID4gICAqIEBjaGFpbjogZW50cnkg aW4gdGhlIGRpc3BsYXkgbGlzdCBwYXJ0aXRpb24gY2hhaW4KPiA+ICsgKiBAbm90aWZ5OiB3aGV0 aGVyIHRoZSBkaXNwbGF5IGxpc3QgY29tcGxldGlvbiBzaG91bGQgYmUgbm90aWZpZWQKPiA+ICAg Ki8KPiA+ICBzdHJ1Y3QgdnNwMV9kbF9saXN0IHsKPiA+ICAJc3RydWN0IGxpc3RfaGVhZCBsaXN0 Owo+ID4gQEAgLTg1LDYgKzg2LDggQEAgc3RydWN0IHZzcDFfZGxfbGlzdCB7Cj4gPiAgCWJvb2wg aGFzX2NoYWluOwo+ID4gIAlzdHJ1Y3QgbGlzdF9oZWFkIGNoYWluOwo+ID4gKwo+ID4gKwlib29s IG5vdGlmeTsKPiA+ICB9Owo+ID4gIAo+ID4gIGVudW0gdnNwMV9kbF9tb2RlIHsKPiA+IEBAIC01 NTAsOCArNTUzLDE2IEBAIHN0YXRpYyB2b2lkIHZzcDFfZGxfbGlzdF9jb21taXRfY29udGludW91 cyhzdHJ1Y3QKPiA+IHZzcDFfZGxfbGlzdCAqZGwpPiAKPiA+ICAJICogY2FzZSB3ZSBjYW4ndCBy ZXBsYWNlIHRoZSBxdWV1ZWQgbGlzdCBieSB0aGUgbmV3IG9uZSwgYXMgd2UgY291bGQKPiA+ICAJ ICogcmFjZSB3aXRoIHRoZSBoYXJkd2FyZS4gV2UgdGh1cyBtYXJrIHRoZSB1cGRhdGUgYXMgcGVu ZGluZywgaXQgd2lsbAo+ID4gIAkgKiBiZSBxdWV1ZWQgdXAgdG8gdGhlIGhhcmR3YXJlIGJ5IHRo ZSBmcmFtZSBlbmQgaW50ZXJydXB0IGhhbmRsZXIuCj4gPiArCSAqCj4gPiArCSAqIElmIGEgZGlz cGxheSBsaXN0IGlzIGFscmVhZHkgcGVuZGluZyB3ZSBzaW1wbHkgZHJvcCBpdCBhcyB0aGUgbmV3 Cj4gPiArCSAqIGRpc3BsYXkgbGlzdCBpcyBhc3N1bWVkIHRvIGNvbnRhaW4gYSBtb3JlIHJlY2Vu dCBjb25maWd1cmF0aW9uLiBJdAo+ID4gaXMKPiA+ICsJICogYW4gZXJyb3IgaWYgdGhlIGFscmVh ZHkgcGVuZGluZyBsaXN0IGhhcyB0aGUgbm90aWZ5IGZsYWcgc2V0LCBhcwo+ID4gKwkgKiB0aGVy ZSBpcyB0aGVuIGEgcHJvY2VzcyB3YWl0aW5nIGZvciB0aGF0IGxpc3QgdG8gY29tcGxldGUuIFRo aXMKPiA+ICsJICogc2hvdWxkbid0IGhhcHBlbiBhcyB0aGUgd2FpdGluZyBwcm9jZXNzIHNob3Vs ZCBwZXJmb3JtIHByb3Blcgo+ID4gKwkgKiBsb2NraW5nLCBidXQgd2FybiBqdXN0IGluIGNhc2Uu Cj4gPiAgCSAqLwo+ID4gIAlpZiAodnNwMV9kbF9saXN0X2h3X3VwZGF0ZV9wZW5kaW5nKGRsbSkp IHsKPiA+ICsJCVdBUk5fT04oZGxtLT5wZW5kaW5nICYmIGRsbS0+cGVuZGluZy0+bm90aWZ5KTsK PiA+ICAJCV9fdnNwMV9kbF9saXN0X3B1dChkbG0tPnBlbmRpbmcpOwo+ID4gIAkJZGxtLT5wZW5k aW5nID0gZGw7Cj4gPiAKPiA+IEBAIC01ODEsNyArNTkyLDcgQEAgc3RhdGljIHZvaWQgdnNwMV9k bF9saXN0X2NvbW1pdF9zaW5nbGVzaG90KHN0cnVjdAo+ID4gdnNwMV9kbF9saXN0ICpkbCkKPiA+ ICAJZGxtLT5hY3RpdmUgPSBkbDsKPiA+ICB9Cj4gPiAKPiA+IC12b2lkIHZzcDFfZGxfbGlzdF9j b21taXQoc3RydWN0IHZzcDFfZGxfbGlzdCAqZGwpCj4gPiArdm9pZCB2c3AxX2RsX2xpc3RfY29t bWl0KHN0cnVjdCB2c3AxX2RsX2xpc3QgKmRsLCBib29sIG5vdGlmeSkKPiAKPiBSYXRoZXIgdGhh biBjaGFuZ2luZyB0aGUgdnNwMV9kbF9saXN0X2NvbW1pdCgpIGZ1bmN0aW9uIC0gd291bGQgaXQg YmUgbmljZXIKPiB0byBoYXZlIGFuIEFQSSB0byByZXF1ZXN0IG9yIHNldCB0aGUgbm90aWZ5IHBy b3BlcnR5PyA6Cj4gCj4gQEAuLkBAIHN0YXRpYyB2b2lkIHZzcDFfZHVfcGlwZWxpbmVfY29uZmln dXJlKHN0cnVjdCB2c3AxX3BpcGVsaW5lICpwaXBlKQo+IC4uLgo+ICsJLyogVGhlIEJSeCB3aWxs IGJlIHJlbGVhc2VkLCB3aXRob3V0IHNlbmRpbmcgYW4gdXBkYXRlIHRvIERSTSAqLwo+ICsJaWYg KGRybV9waXBlLT5mb3JjZV9icnVfcmVsZWFzZSkKPiArCQl2c3AxX2RsX2xpc3RfcmVxdWVzdF9p bnRlcm5hbF9ub3RpZnkoZGwpOwo+IAo+IAl2c3AxX2RsX2xpc3RfY29tbWl0KGRsKTsKPiAuLi4K ClRoYXQncyBub3QgYSBiYWQgaWRlYSwgYnV0IEkgd29uZGVyIGlmIGl0J3Mgd29ydGggaXQgYXMg d2UnbGwgaGF2ZSB0byBjYWxsIGFuIApleHRyYSBmdW5jdGlvbiBmb3Igd2hhdCBpcyBlc3NlbnRp YWxseSBhbiBpbnRlcm5hbCBBUEkuIE9uIHRoZSBvdGhlciBoYW5kIHRoaXMgCmlzbid0IGEgY29t bW9uIGNhc2UsIHNvIGl0J3Mgbm90IGEgaG90IGNvZGUgcGF0aC4gV2UgY291bGQgYWxzbyBhcmd1 ZSBlcXVhbGx5IAp0aGF0IGl0IGlzIHRoZSBjb21taXQgdGhhdCBpcyBpbnRlcm5hbCBvciB0aGF0 IGl0IGlzIHRoZSBkaXNwbGF5IGxpc3QgdGhhdCBpcyAKZm9yIGludGVybmFsIHB1cnBvc2UuIERv IHlvdSB0aGluayBhbiBleHRyYSBmdW5jdGlvbiBjYWxsIGlzIGJldHRlciA/IElmIHlvdSAKZG8g SSdsbCBjaGFuZ2UgaXQuCgo+ID4gIHsKPiA+ICAJc3RydWN0IHZzcDFfZGxfbWFuYWdlciAqZGxt ID0gZGwtPmRsbTsKPiA+ICAJc3RydWN0IHZzcDFfZGxfbGlzdCAqZGxfY2hpbGQ7Cj4gPiBAQCAt NTk4LDYgKzYwOSw4IEBAIHZvaWQgdnNwMV9kbF9saXN0X2NvbW1pdChzdHJ1Y3QgdnNwMV9kbF9s aXN0ICpkbCkKPiA+ICAJCX0KPiA+ICAJfQo+ID4gCj4gPiArCWRsLT5ub3RpZnkgPSBub3RpZnk7 Cj4gPiArCj4gPiAgCXNwaW5fbG9ja19pcnFzYXZlKCZkbG0tPmxvY2ssIGZsYWdzKTsKPiA+ICAJ Cj4gPiAgCWlmIChkbG0tPnNpbmdsZXNob3QpCj4gPiBAQCAtNjE1LDE2ICs2MjgsMjMgQEAgdm9p ZCB2c3AxX2RsX2xpc3RfY29tbWl0KHN0cnVjdCB2c3AxX2RsX2xpc3QgKmRsKQo+ID4gIC8qKgo+ ID4gICAqIHZzcDFfZGxtX2lycV9mcmFtZV9lbmQgLSBEaXNwbGF5IGxpc3QgaGFuZGxlciBmb3Ig dGhlIGZyYW1lIGVuZAo+ID4gICBpbnRlcnJ1cHQKPiA+ICAgKiBAZGxtOiB0aGUgZGlzcGxheSBs aXN0IG1hbmFnZXIKPiA+ICsgKiBAbm90aWZ5OiB3aGV0aGVyIHRoZSBkaXNwbGF5IGxpc3QgdGhh dCBjb21wbGV0ZWQgaGFzIG5vdGlmaWNhdGlvbgo+ID4gZW5hYmxlZAo+ID4gICAqCj4gPiAgICog UmV0dXJuIHRydWUgaWYgdGhlIHByZXZpb3VzIGRpc3BsYXkgbGlzdCBoYXMgY29tcGxldGVkIGF0 IGZyYW1lIGVuZCwKPiA+ICAgb3IgZmFsc2UKPiA+ICAgKiBpZiBpdCBoYXMgYmVlbiBkZWxheWVk IGJ5IG9uZSBmcmFtZSBiZWNhdXNlIHRoZSBkaXNwbGF5IGxpc3QgY29tbWl0Cj4gPiAgIHJhY2Vk Cj4gPiAgICogd2l0aCB0aGUgZnJhbWUgZW5kIGludGVycnVwdC4gVGhlIGZ1bmN0aW9uIGFsd2F5 cyByZXR1cm5zIHRydWUgaW4KPiA+ICAgaGVhZGVyIG1vZGUKPiA+ICAgKiBhcyBkaXNwbGF5IGxp c3QgcHJvY2Vzc2luZyBpcyB0aGVuIG5vdCBjb250aW51b3VzIGFuZCByYWNlcyBuZXZlcgo+ID4g ICBvY2N1ci4KPiA+ICsgKgo+ID4gKyAqIFVwb24gcmV0dXJuLCB0aGUgQG5vdGlmeSBwYXJhbWV0 ZXIgaXMgc2V0IHRvIHRydWUgaWYgdGhlIHByZXZpb3VzCj4gPiBkaXNwbGF5Cj4gPiArICogbGlz dCBoYXMgY29tcGxldGVkIGFuZCBoYWQgYmVlbiBxdWV1ZWQgd2l0aCB0aGUgbm90aWZ5IGZsYWcs IG9yIHRvCj4gPiBmYWxzZQo+ID4gKyAqIG90aGVyd2lzZS4gTm90aWZpY2F0aW9uIGlzIG9ubHkg c3VwcG9ydGVkIGZvciBjb250aW51b3VzIG1vZGUuCj4gPiAgICovCj4gPiAtYm9vbCB2c3AxX2Rs bV9pcnFfZnJhbWVfZW5kKHN0cnVjdCB2c3AxX2RsX21hbmFnZXIgKmRsbSkKPiA+ICtib29sIHZz cDFfZGxtX2lycV9mcmFtZV9lbmQoc3RydWN0IHZzcDFfZGxfbWFuYWdlciAqZGxtLCBib29sICpu b3RpZnkpCj4gPiAgewo+ID4gIAlib29sIGNvbXBsZXRlZCA9IGZhbHNlOwo+ID4gCj4gPiArCSpu b3RpZnkgPSBmYWxzZTsKPiA+ICsKPiA+ICAJc3Bpbl9sb2NrKCZkbG0tPmxvY2spOwo+ID4gIAkK PiA+ICAJLyoKPiA+IEBAIC02NTIsNiArNjcyLDkgQEAgYm9vbCB2c3AxX2RsbV9pcnFfZnJhbWVf ZW5kKHN0cnVjdCB2c3AxX2RsX21hbmFnZXIKPiA+ICpkbG0pCj4gPiAgCSAqIGZyYW1lIGVuZCBp bnRlcnJ1cHQuIFRoZSBkaXNwbGF5IGxpc3QgdGh1cyBiZWNvbWVzIGFjdGl2ZS4KPiA+ICAJICov Cj4gPiAgCWlmIChkbG0tPnF1ZXVlZCkgewo+ID4gKwkJKm5vdGlmeSA9IGRsbS0+cXVldWVkLT5u b3RpZnk7Cj4gPiArCQlkbG0tPnF1ZXVlZC0+bm90aWZ5ID0gZmFsc2U7Cj4gPiArCj4gPiAgCQlf X3ZzcDFfZGxfbGlzdF9wdXQoZGxtLT5hY3RpdmUpOwo+ID4gIAkJZGxtLT5hY3RpdmUgPSBkbG0t PnF1ZXVlZDsKPiA+ICAJCWRsbS0+cXVldWVkID0gTlVMTDsKPiA+IGRpZmYgLS1naXQgYS9kcml2 ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9kbC5oCj4gPiBiL2RyaXZlcnMvbWVkaWEvcGxh dGZvcm0vdnNwMS92c3AxX2RsLmggaW5kZXggZWUzNTA4MTcyZjBhLi40ODBjNmIwZGQyZTQKPiA+ IDEwMDY0NAo+ID4gLS0tIGEvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfZGwuaAo+ ID4gKysrIGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfZGwuaAo+ID4gQEAgLTI3 LDEyICsyNywxMiBAQCBzdHJ1Y3QgdnNwMV9kbF9tYW5hZ2VyICp2c3AxX2RsbV9jcmVhdGUoc3Ry dWN0Cj4gPiB2c3AxX2RldmljZSAqdnNwMSwKPiA+ICAJCQkJCXVuc2lnbmVkIGludCBwcmVhbGxv Yyk7Cj4gPiAgdm9pZCB2c3AxX2RsbV9kZXN0cm95KHN0cnVjdCB2c3AxX2RsX21hbmFnZXIgKmRs bSk7Cj4gPiAgdm9pZCB2c3AxX2RsbV9yZXNldChzdHJ1Y3QgdnNwMV9kbF9tYW5hZ2VyICpkbG0p Owo+ID4gLWJvb2wgdnNwMV9kbG1faXJxX2ZyYW1lX2VuZChzdHJ1Y3QgdnNwMV9kbF9tYW5hZ2Vy ICpkbG0pOwo+ID4gK2Jvb2wgdnNwMV9kbG1faXJxX2ZyYW1lX2VuZChzdHJ1Y3QgdnNwMV9kbF9t YW5hZ2VyICpkbG0sIGJvb2wgKm5vdGlmeSk7Cj4gPiAKPiA+ICBzdHJ1Y3QgdnNwMV9kbF9saXN0 ICp2c3AxX2RsX2xpc3RfZ2V0KHN0cnVjdCB2c3AxX2RsX21hbmFnZXIgKmRsbSk7Cj4gPiAgdm9p ZCB2c3AxX2RsX2xpc3RfcHV0KHN0cnVjdCB2c3AxX2RsX2xpc3QgKmRsKTsKPiA+ICB2b2lkIHZz cDFfZGxfbGlzdF93cml0ZShzdHJ1Y3QgdnNwMV9kbF9saXN0ICpkbCwgdTMyIHJlZywgdTMyIGRh dGEpOwo+ID4gLXZvaWQgdnNwMV9kbF9saXN0X2NvbW1pdChzdHJ1Y3QgdnNwMV9kbF9saXN0ICpk bCk7Cj4gPiArdm9pZCB2c3AxX2RsX2xpc3RfY29tbWl0KHN0cnVjdCB2c3AxX2RsX2xpc3QgKmRs LCBib29sIG5vdGlmeSk7Cj4gPiAKPiA+ICBzdHJ1Y3QgdnNwMV9kbF9ib2R5ICp2c3AxX2RsX2Zy YWdtZW50X2FsbG9jKHN0cnVjdCB2c3AxX2RldmljZSAqdnNwMSwKPiA+ICAJCQkJCSAgICB1bnNp Z25lZCBpbnQgbnVtX2VudHJpZXMpOwo+ID4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvcGxh dGZvcm0vdnNwMS92c3AxX2RybS5jCj4gPiBiL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92 c3AxX2RybS5jIGluZGV4IDFjOGFkZGE0NzQ0MC4uZDcwNWE2ZTlmYTFkCj4gPiAxMDA2NDQKPiA+ IC0tLSBhL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX2RybS5jCj4gPiArKysgYi9k cml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9kcm0uYwo+ID4gQEAgLTM0LDcgKzM0LDcg QEAKPiA+ICAgKi8KPiA+ICAKPiA+ICBzdGF0aWMgdm9pZCB2c3AxX2R1X3BpcGVsaW5lX2ZyYW1l X2VuZChzdHJ1Y3QgdnNwMV9waXBlbGluZSAqcGlwZSwKPiA+IC0JCQkJICAgICAgIGJvb2wgY29t cGxldGVkKQo+ID4gKwkJCQkgICAgICAgYm9vbCBjb21wbGV0ZWQsIGJvb2wgbm90aWZ5KQo+ID4g IHsKPiA+ICAJc3RydWN0IHZzcDFfZHJtX3BpcGVsaW5lICpkcm1fcGlwZSA9IHRvX3ZzcDFfZHJt X3BpcGVsaW5lKHBpcGUpOwo+ID4gCj4gPiBAQCAtMzcwLDcgKzM3MCw3IEBAIHN0YXRpYyB2b2lk IHZzcDFfZHVfcGlwZWxpbmVfY29uZmlndXJlKHN0cnVjdAo+ID4gdnNwMV9waXBlbGluZSAqcGlw ZSkKPiA+ICAJCX0KPiA+ICAJfQo+ID4gCj4gPiAtCXZzcDFfZGxfbGlzdF9jb21taXQoZGwpOwo+ ID4gKwl2c3AxX2RsX2xpc3RfY29tbWl0KGRsLCBmYWxzZSk7Cj4gPiAgfQo+ID4gIAo+ID4gIC8q IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0KPiA+IGRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3Zz cDEvdnNwMV9waXBlLmMKPiA+IGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfcGlw ZS5jIGluZGV4Cj4gPiA5OWNjYmFjMzI1NmEuLjRkODE5YzkwMTlmNCAxMDA2NDQKPiA+IC0tLSBh L2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX3BpcGUuYwo+ID4gKysrIGIvZHJpdmVy cy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfcGlwZS5jCj4gPiBAQCAtMzE2LDYgKzMxNiw3IEBA IGJvb2wgdnNwMV9waXBlbGluZV9yZWFkeShzdHJ1Y3QgdnNwMV9waXBlbGluZSAqcGlwZSkKPiA+ ICB2b2lkIHZzcDFfcGlwZWxpbmVfZnJhbWVfZW5kKHN0cnVjdCB2c3AxX3BpcGVsaW5lICpwaXBl KQo+ID4gIHsKPiA+ICAJYm9vbCBjb21wbGV0ZWQ7Cj4gPiArCWJvb2wgbm90aWZ5Owo+ID4gCj4g PiAgCWlmIChwaXBlID09IE5VTEwpCj4gPiAgCQlyZXR1cm47Cj4gPiBAQCAtMzI1LDcgKzMyNiw3 IEBAIHZvaWQgdnNwMV9waXBlbGluZV9mcmFtZV9lbmQoc3RydWN0IHZzcDFfcGlwZWxpbmUKPiA+ ICpwaXBlKQo+ID4gIAkgKiB1cCBiZWluZyBwb3N0cG9uZWQgYnkgb25lIGZyYW1lLiBAY29tcGxl dGVkIHJlcHJlc2VudHMgd2hldGhlciB0aGUKPiA+ICAJICogYWN0aXZlIGZyYW1lIHdhcyBmaW5p c2hlZCBvciBwb3N0cG9uZWQuCj4gPiAgCSAqLwo+ID4gLQljb21wbGV0ZWQgPSB2c3AxX2RsbV9p cnFfZnJhbWVfZW5kKHBpcGUtPm91dHB1dC0+ZGxtKTsKPiA+ICsJY29tcGxldGVkID0gdnNwMV9k bG1faXJxX2ZyYW1lX2VuZChwaXBlLT5vdXRwdXQtPmRsbSwgJm5vdGlmeSk7Cj4gCj4gRXVnaCAu Li4gdHdvIHJldHVybiB2YWx1ZXMsIG9uZSBwYXNzZWQgYmFjayB0aHJvdWdoIHRoZSByZXR1cm4s IGFuZCB0aGUKPiBvdGhlciBwYXNzZWQgYXMgYSBwb2ludGVyLgoKSSBkb24ndCBsaWtlIGl0IG11 Y2ggZWl0aGVyIDotLwoKPiBXaGF0IGFib3V0IGNvbnZlcnRpbmcgdGhpcyB0byBzb21lIGZsYWdz IHdoaWNoIGdldCBwYXNzZWQgaW50byB0aGUKPiBwaXBlLT5mcmFtZV9lbmQoKSBpbnN0ZWFkPwoK VGhhdCdzIGEgdmVyeSBnb29kIGlkZWEsIEknbGwgZG8gdGhhdC4KCj4gPiAgCWlmIChwaXBlLT5o Z28pCj4gPiAgCQl2c3AxX2hnb19mcmFtZV9lbmQocGlwZS0+aGdvKTsKPiA+IAo+ID4gQEAgLTMz OCw3ICszMzksNyBAQCB2b2lkIHZzcDFfcGlwZWxpbmVfZnJhbWVfZW5kKHN0cnVjdCB2c3AxX3Bp cGVsaW5lCj4gPiAqcGlwZSk+IAo+ID4gIAkgKiBmcmFtZV9lbmQgdG8gYWNjb3VudCBmb3IgdmJs YW5rIGV2ZW50cy4KPiA+ICAJICovCj4gPiAgCWlmIChwaXBlLT5mcmFtZV9lbmQpCj4gPiAtCQlw aXBlLT5mcmFtZV9lbmQocGlwZSwgY29tcGxldGVkKTsKPiA+ICsJCXBpcGUtPmZyYW1lX2VuZChw aXBlLCBjb21wbGV0ZWQsIG5vdGlmeSk7Cj4gPiAKPiA+ICAJcGlwZS0+c2VxdWVuY2UrKzsKPiA+ ICB9Cj4gPiAKPiA+IGRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNw MV9waXBlLmgKPiA+IGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfcGlwZS5oIGlu ZGV4Cj4gPiBkZmZmOWI1Njg1ZmUuLjQ4MjcxMTAyNGZhMiAxMDA2NDQKPiA+IC0tLSBhL2RyaXZl cnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX3BpcGUuaAo+ID4gKysrIGIvZHJpdmVycy9tZWRp YS9wbGF0Zm9ybS92c3AxL3ZzcDFfcGlwZS5oCj4gPiBAQCAtMTE4LDcgKzExOCw4IEBAIHN0cnVj dCB2c3AxX3BpcGVsaW5lIHsKPiA+ICAJZW51bSB2c3AxX3BpcGVsaW5lX3N0YXRlIHN0YXRlOwo+ ID4gIAl3YWl0X3F1ZXVlX2hlYWRfdCB3cTsKPiA+IAo+ID4gLQl2b2lkICgqZnJhbWVfZW5kKShz dHJ1Y3QgdnNwMV9waXBlbGluZSAqcGlwZSwgYm9vbCBjb21wbGV0ZWQpOwo+ID4gKwl2b2lkICgq ZnJhbWVfZW5kKShzdHJ1Y3QgdnNwMV9waXBlbGluZSAqcGlwZSwgYm9vbCBjb21wbGV0ZWQsCj4g PiArCQkJICBib29sIG5vdGlmeSk7Cj4gPiAKPiA+ICAJc3RydWN0IG11dGV4IGxvY2s7Cj4gPiAg CXN0cnVjdCBrcmVmIGtyZWY7Cj4gPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS9wbGF0Zm9y bS92c3AxL3ZzcDFfdmlkZW8uYwo+ID4gYi9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNw MV92aWRlby5jIGluZGV4Cj4gPiBjZGQ1M2Q2Y2M0MDguLjQ4M2I0MjU5ZTFiNCAxMDA2NDQKPiA+ IC0tLSBhL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX3ZpZGVvLmMKPiA+ICsrKyBi L2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX3ZpZGVvLmMKPiA+IEBAIC00MzcsMTQg KzQzNywxNCBAQCBzdGF0aWMgdm9pZCB2c3AxX3ZpZGVvX3BpcGVsaW5lX3J1bihzdHJ1Y3QKPiA+ IHZzcDFfcGlwZWxpbmUgKnBpcGUpPiAKPiA+ICAJfQo+ID4gIAkKPiA+ICAJLyogQ29tcGxldGUs IGFuZCBjb21taXQgdGhlIGhlYWQgZGlzcGxheSBsaXN0LiAqLwo+ID4gLQl2c3AxX2RsX2xpc3Rf Y29tbWl0KHBpcGUtPmRsKTsKPiA+ICsJdnNwMV9kbF9saXN0X2NvbW1pdChwaXBlLT5kbCwgZmFs c2UpOwo+ID4gCj4gPiAgCXBpcGUtPmRsID0gTlVMTDsKPiA+ICAJCj4gPiAgCXZzcDFfcGlwZWxp bmVfcnVuKHBpcGUpOwo+ID4gIH0KPiA+ICAKPiA+ICBzdGF0aWMgdm9pZCB2c3AxX3ZpZGVvX3Bp cGVsaW5lX2ZyYW1lX2VuZChzdHJ1Y3QgdnNwMV9waXBlbGluZSAqcGlwZSwKPiA+IC0JCQkJCSAg Ym9vbCBjb21wbGV0ZWQpCj4gPiArCQkJCQkgIGJvb2wgY29tcGxldGVkLCBib29sIG5vdGlmeSkK PiA+ICB7Cj4gPiAgCXN0cnVjdCB2c3AxX2RldmljZSAqdnNwMSA9IHBpcGUtPm91dHB1dC0+ZW50 aXR5LnZzcDE7Cj4gPiAgCWVudW0gdnNwMV9waXBlbGluZV9zdGF0ZSBzdGF0ZTsKCi0tIApSZWdh cmRzLAoKTGF1cmVudCBQaW5jaGFydAoKCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1kZXZlbEBsaXN0cy5m cmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0 aW5mby9kcmktZGV2ZWwK