From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-8.5 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_PASS,URIBL_BLOCKED, USER_AGENT_MUTT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id B2ECEC10F00 for ; Fri, 15 Mar 2019 17:55:01 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 7C2FE218A1 for ; Fri, 15 Mar 2019 17:55:01 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726671AbfCORzA (ORCPT ); Fri, 15 Mar 2019 13:55:00 -0400 Received: from usa-sjc-mx-foss1.foss.arm.com ([217.140.101.70]:34422 "EHLO foss.arm.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726466AbfCORzA (ORCPT ); Fri, 15 Mar 2019 13:55:00 -0400 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.72.51.249]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 5B09AA78; Fri, 15 Mar 2019 10:54:59 -0700 (PDT) Received: from e110455-lin.cambridge.arm.com (usa-sjc-imap-foss1.foss.arm.com [10.72.51.249]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 082E73F71D; Fri, 15 Mar 2019 10:54:59 -0700 (PDT) Received: by e110455-lin.cambridge.arm.com (Postfix, from userid 1000) id 60EB2680208; Fri, 15 Mar 2019 17:54:57 +0000 (GMT) Date: Fri, 15 Mar 2019 17:54:57 +0000 From: Liviu Dudau To: Laurent Pinchart Cc: dri-devel@lists.freedesktop.org, linux-media@vger.kernel.org, linux-renesas-soc@vger.kernel.org, Brian Starkey , Kieran Bingham Subject: Re: [PATCH v6 14/18] drm: writeback: Add job prepare and cleanup operations Message-ID: <20190315175457.GG26454@e110455-lin.cambridge.arm.com> References: <20190313000532.7087-1-laurent.pinchart+renesas@ideasonboard.com> <20190313000532.7087-15-laurent.pinchart+renesas@ideasonboard.com> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <20190313000532.7087-15-laurent.pinchart+renesas@ideasonboard.com> User-Agent: Mutt/1.11.4 (2019-03-13) Sender: linux-media-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-media@vger.kernel.org On Wed, Mar 13, 2019 at 02:05:28AM +0200, Laurent Pinchart wrote: > As writeback jobs contain a framebuffer, drivers may need to prepare and > cleanup them the same way they can prepare and cleanup framebuffers for > planes. Add two new optional connector helper operations, > .prepare_writeback_job() and .cleanup_writeback_job() to support this. > > The job prepare operation is called from > drm_atomic_helper_prepare_planes() to avoid a new atomic commit helper > that would need to be called by all drivers not using > drm_atomic_helper_commit(). The job cleanup operation is called from the > existing drm_writeback_cleanup_job() function, invoked both when > destroying the job as part of a aborted commit, or when the job > completes. > > The drm_writeback_job structure is extended with a priv field to let > drivers store per-job data, such as mappings related to the writeback > framebuffer. > > For internal plumbing reasons the drm_writeback_job structure needs to > store a back-pointer to the drm_writeback_connector. To avoid pushing > too much writeback-specific knowledge to drm_atomic_uapi.c, create a > drm_writeback_set_fb() function, move the writeback job setup code > there, and set the connector backpointer. The prepare_signaling() > function doesn't need to allocate writeback jobs and can ignore > connectors without a job, as it is called after the writeback jobs are > allocated to store framebuffers, and a writeback fence with a > framebuffer is an invalid configuration that gets rejected by the commit > check. > > Signed-off-by: Laurent Pinchart Reviewed-by: Liviu Dudau Best regards, Liviu > --- > Changes since v5: > > - Export drm_writeback_prepare_job() > - Check for .prepare_writeback_job() in drm_writeback_prepare_job() > --- > drivers/gpu/drm/drm_atomic_helper.c | 11 ++++++ > drivers/gpu/drm/drm_atomic_uapi.c | 31 +++++------------ > drivers/gpu/drm/drm_writeback.c | 44 ++++++++++++++++++++++++ > include/drm/drm_modeset_helper_vtables.h | 7 ++++ > include/drm/drm_writeback.h | 28 ++++++++++++++- > 5 files changed, 97 insertions(+), 24 deletions(-) > > diff --git a/drivers/gpu/drm/drm_atomic_helper.c b/drivers/gpu/drm/drm_atomic_helper.c > index 6fe2303fccd9..70a4886c6e65 100644 > --- a/drivers/gpu/drm/drm_atomic_helper.c > +++ b/drivers/gpu/drm/drm_atomic_helper.c > @@ -2245,10 +2245,21 @@ EXPORT_SYMBOL(drm_atomic_helper_commit_cleanup_done); > int drm_atomic_helper_prepare_planes(struct drm_device *dev, > struct drm_atomic_state *state) > { > + struct drm_connector *connector; > + struct drm_connector_state *new_conn_state; > struct drm_plane *plane; > struct drm_plane_state *new_plane_state; > int ret, i, j; > > + for_each_new_connector_in_state(state, connector, new_conn_state, i) { > + if (!new_conn_state->writeback_job) > + continue; > + > + ret = drm_writeback_prepare_job(new_conn_state->writeback_job); > + if (ret < 0) > + return ret; > + } > + > for_each_new_plane_in_state(state, plane, new_plane_state, i) { > const struct drm_plane_helper_funcs *funcs; > > diff --git a/drivers/gpu/drm/drm_atomic_uapi.c b/drivers/gpu/drm/drm_atomic_uapi.c > index c40889888a16..e802152a01ad 100644 > --- a/drivers/gpu/drm/drm_atomic_uapi.c > +++ b/drivers/gpu/drm/drm_atomic_uapi.c > @@ -647,28 +647,15 @@ drm_atomic_plane_get_property(struct drm_plane *plane, > return 0; > } > > -static struct drm_writeback_job * > -drm_atomic_get_writeback_job(struct drm_connector_state *conn_state) > -{ > - WARN_ON(conn_state->connector->connector_type != DRM_MODE_CONNECTOR_WRITEBACK); > - > - if (!conn_state->writeback_job) > - conn_state->writeback_job = > - kzalloc(sizeof(*conn_state->writeback_job), GFP_KERNEL); > - > - return conn_state->writeback_job; > -} > - > static int drm_atomic_set_writeback_fb_for_connector( > struct drm_connector_state *conn_state, > struct drm_framebuffer *fb) > { > - struct drm_writeback_job *job = > - drm_atomic_get_writeback_job(conn_state); > - if (!job) > - return -ENOMEM; > + int ret; > > - drm_framebuffer_assign(&job->fb, fb); > + ret = drm_writeback_set_fb(conn_state, fb); > + if (ret < 0) > + return ret; > > if (fb) > DRM_DEBUG_ATOMIC("Set [FB:%d] for connector state %p\n", > @@ -1158,19 +1145,17 @@ static int prepare_signaling(struct drm_device *dev, > > for_each_new_connector_in_state(state, conn, conn_state, i) { > struct drm_writeback_connector *wb_conn; > - struct drm_writeback_job *job; > struct drm_out_fence_state *f; > struct dma_fence *fence; > s32 __user *fence_ptr; > > + if (!conn_state->writeback_job) > + continue; > + > fence_ptr = get_out_fence_for_connector(state, conn); > if (!fence_ptr) > continue; > > - job = drm_atomic_get_writeback_job(conn_state); > - if (!job) > - return -ENOMEM; > - > f = krealloc(*fence_state, sizeof(**fence_state) * > (*num_fences + 1), GFP_KERNEL); > if (!f) > @@ -1192,7 +1177,7 @@ static int prepare_signaling(struct drm_device *dev, > return ret; > } > > - job->out_fence = fence; > + conn_state->writeback_job->out_fence = fence; > } > > /* > diff --git a/drivers/gpu/drm/drm_writeback.c b/drivers/gpu/drm/drm_writeback.c > index 1b497d3530b5..79ac014701c8 100644 > --- a/drivers/gpu/drm/drm_writeback.c > +++ b/drivers/gpu/drm/drm_writeback.c > @@ -239,6 +239,43 @@ int drm_writeback_connector_init(struct drm_device *dev, > } > EXPORT_SYMBOL(drm_writeback_connector_init); > > +int drm_writeback_set_fb(struct drm_connector_state *conn_state, > + struct drm_framebuffer *fb) > +{ > + WARN_ON(conn_state->connector->connector_type != DRM_MODE_CONNECTOR_WRITEBACK); > + > + if (!conn_state->writeback_job) { > + conn_state->writeback_job = > + kzalloc(sizeof(*conn_state->writeback_job), GFP_KERNEL); > + if (!conn_state->writeback_job) > + return -ENOMEM; > + > + conn_state->writeback_job->connector = > + drm_connector_to_writeback(conn_state->connector); > + } > + > + drm_framebuffer_assign(&conn_state->writeback_job->fb, fb); > + return 0; > +} > + > +int drm_writeback_prepare_job(struct drm_writeback_job *job) > +{ > + struct drm_writeback_connector *connector = job->connector; > + const struct drm_connector_helper_funcs *funcs = > + connector->base.helper_private; > + int ret; > + > + if (funcs->prepare_writeback_job) { > + ret = funcs->prepare_writeback_job(connector, job); > + if (ret < 0) > + return ret; > + } > + > + job->prepared = true; > + return 0; > +} > +EXPORT_SYMBOL(drm_writeback_prepare_job); > + > /** > * drm_writeback_queue_job - Queue a writeback job for later signalling > * @wb_connector: The writeback connector to queue a job on > @@ -275,6 +312,13 @@ EXPORT_SYMBOL(drm_writeback_queue_job); > > void drm_writeback_cleanup_job(struct drm_writeback_job *job) > { > + struct drm_writeback_connector *connector = job->connector; > + const struct drm_connector_helper_funcs *funcs = > + connector->base.helper_private; > + > + if (job->prepared && funcs->cleanup_writeback_job) > + funcs->cleanup_writeback_job(connector, job); > + > if (job->fb) > drm_framebuffer_put(job->fb); > > diff --git a/include/drm/drm_modeset_helper_vtables.h b/include/drm/drm_modeset_helper_vtables.h > index 61142aa0ab23..73d03fe66799 100644 > --- a/include/drm/drm_modeset_helper_vtables.h > +++ b/include/drm/drm_modeset_helper_vtables.h > @@ -49,6 +49,8 @@ > */ > > enum mode_set_atomic; > +struct drm_writeback_connector; > +struct drm_writeback_job; > > /** > * struct drm_crtc_helper_funcs - helper operations for CRTCs > @@ -989,6 +991,11 @@ struct drm_connector_helper_funcs { > */ > void (*atomic_commit)(struct drm_connector *connector, > struct drm_connector_state *state); > + > + int (*prepare_writeback_job)(struct drm_writeback_connector *connector, > + struct drm_writeback_job *job); > + void (*cleanup_writeback_job)(struct drm_writeback_connector *connector, > + struct drm_writeback_job *job); > }; > > /** > diff --git a/include/drm/drm_writeback.h b/include/drm/drm_writeback.h > index 47662c362743..777c14c847f0 100644 > --- a/include/drm/drm_writeback.h > +++ b/include/drm/drm_writeback.h > @@ -79,6 +79,20 @@ struct drm_writeback_connector { > }; > > struct drm_writeback_job { > + /** > + * @connector: > + * > + * Back-pointer to the writeback connector associated with the job > + */ > + struct drm_writeback_connector *connector; > + > + /** > + * @prepared: > + * > + * Set when the job has been prepared with drm_writeback_prepare_job() > + */ > + bool prepared; > + > /** > * @cleanup_work: > * > @@ -98,7 +112,7 @@ struct drm_writeback_job { > * @fb: > * > * Framebuffer to be written to by the writeback connector. Do not set > - * directly, use drm_atomic_set_writeback_fb_for_connector() > + * directly, use drm_writeback_set_fb() > */ > struct drm_framebuffer *fb; > > @@ -108,6 +122,13 @@ struct drm_writeback_job { > * Fence which will signal once the writeback has completed > */ > struct dma_fence *out_fence; > + > + /** > + * @priv: > + * > + * Driver-private data > + */ > + void *priv; > }; > > static inline struct drm_writeback_connector * > @@ -122,6 +143,11 @@ int drm_writeback_connector_init(struct drm_device *dev, > const struct drm_encoder_helper_funcs *enc_helper_funcs, > const u32 *formats, int n_formats); > > +int drm_writeback_set_fb(struct drm_connector_state *conn_state, > + struct drm_framebuffer *fb); > + > +int drm_writeback_prepare_job(struct drm_writeback_job *job); > + > void drm_writeback_queue_job(struct drm_writeback_connector *wb_connector, > struct drm_connector_state *conn_state); > > -- > Regards, > > Laurent Pinchart > -- ==================== | I would like to | | fix the world, | | but they're not | | giving me the | \ source code! / --------------- ¯\_(ツ)_/¯ From mboxrd@z Thu Jan 1 00:00:00 1970 From: Liviu Dudau Subject: Re: [PATCH v6 14/18] drm: writeback: Add job prepare and cleanup operations Date: Fri, 15 Mar 2019 17:54:57 +0000 Message-ID: <20190315175457.GG26454@e110455-lin.cambridge.arm.com> References: <20190313000532.7087-1-laurent.pinchart+renesas@ideasonboard.com> <20190313000532.7087-15-laurent.pinchart+renesas@ideasonboard.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from foss.arm.com (foss.arm.com [217.140.101.70]) by gabe.freedesktop.org (Postfix) with ESMTP id 905196E4DD for ; Fri, 15 Mar 2019 17:54:59 +0000 (UTC) Content-Disposition: inline In-Reply-To: <20190313000532.7087-15-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: Laurent Pinchart Cc: linux-renesas-soc@vger.kernel.org, Kieran Bingham , dri-devel@lists.freedesktop.org, linux-media@vger.kernel.org List-Id: dri-devel@lists.freedesktop.org T24gV2VkLCBNYXIgMTMsIDIwMTkgYXQgMDI6MDU6MjhBTSArMDIwMCwgTGF1cmVudCBQaW5jaGFy dCB3cm90ZToKPiBBcyB3cml0ZWJhY2sgam9icyBjb250YWluIGEgZnJhbWVidWZmZXIsIGRyaXZl cnMgbWF5IG5lZWQgdG8gcHJlcGFyZSBhbmQKPiBjbGVhbnVwIHRoZW0gdGhlIHNhbWUgd2F5IHRo ZXkgY2FuIHByZXBhcmUgYW5kIGNsZWFudXAgZnJhbWVidWZmZXJzIGZvcgo+IHBsYW5lcy4gQWRk IHR3byBuZXcgb3B0aW9uYWwgY29ubmVjdG9yIGhlbHBlciBvcGVyYXRpb25zLAo+IC5wcmVwYXJl X3dyaXRlYmFja19qb2IoKSBhbmQgLmNsZWFudXBfd3JpdGViYWNrX2pvYigpIHRvIHN1cHBvcnQg dGhpcy4KPiAKPiBUaGUgam9iIHByZXBhcmUgb3BlcmF0aW9uIGlzIGNhbGxlZCBmcm9tCj4gZHJt X2F0b21pY19oZWxwZXJfcHJlcGFyZV9wbGFuZXMoKSB0byBhdm9pZCBhIG5ldyBhdG9taWMgY29t bWl0IGhlbHBlcgo+IHRoYXQgd291bGQgbmVlZCB0byBiZSBjYWxsZWQgYnkgYWxsIGRyaXZlcnMg bm90IHVzaW5nCj4gZHJtX2F0b21pY19oZWxwZXJfY29tbWl0KCkuIFRoZSBqb2IgY2xlYW51cCBv cGVyYXRpb24gaXMgY2FsbGVkIGZyb20gdGhlCj4gZXhpc3RpbmcgZHJtX3dyaXRlYmFja19jbGVh bnVwX2pvYigpIGZ1bmN0aW9uLCBpbnZva2VkIGJvdGggd2hlbgo+IGRlc3Ryb3lpbmcgdGhlIGpv YiBhcyBwYXJ0IG9mIGEgYWJvcnRlZCBjb21taXQsIG9yIHdoZW4gdGhlIGpvYgo+IGNvbXBsZXRl cy4KPiAKPiBUaGUgZHJtX3dyaXRlYmFja19qb2Igc3RydWN0dXJlIGlzIGV4dGVuZGVkIHdpdGgg YSBwcml2IGZpZWxkIHRvIGxldAo+IGRyaXZlcnMgc3RvcmUgcGVyLWpvYiBkYXRhLCBzdWNoIGFz IG1hcHBpbmdzIHJlbGF0ZWQgdG8gdGhlIHdyaXRlYmFjawo+IGZyYW1lYnVmZmVyLgo+IAo+IEZv ciBpbnRlcm5hbCBwbHVtYmluZyByZWFzb25zIHRoZSBkcm1fd3JpdGViYWNrX2pvYiBzdHJ1Y3R1 cmUgbmVlZHMgdG8KPiBzdG9yZSBhIGJhY2stcG9pbnRlciB0byB0aGUgZHJtX3dyaXRlYmFja19j b25uZWN0b3IuIFRvIGF2b2lkIHB1c2hpbmcKPiB0b28gbXVjaCB3cml0ZWJhY2stc3BlY2lmaWMg a25vd2xlZGdlIHRvIGRybV9hdG9taWNfdWFwaS5jLCBjcmVhdGUgYQo+IGRybV93cml0ZWJhY2tf c2V0X2ZiKCkgZnVuY3Rpb24sIG1vdmUgdGhlIHdyaXRlYmFjayBqb2Igc2V0dXAgY29kZQo+IHRo ZXJlLCBhbmQgc2V0IHRoZSBjb25uZWN0b3IgYmFja3BvaW50ZXIuIFRoZSBwcmVwYXJlX3NpZ25h bGluZygpCj4gZnVuY3Rpb24gZG9lc24ndCBuZWVkIHRvIGFsbG9jYXRlIHdyaXRlYmFjayBqb2Jz IGFuZCBjYW4gaWdub3JlCj4gY29ubmVjdG9ycyB3aXRob3V0IGEgam9iLCBhcyBpdCBpcyBjYWxs ZWQgYWZ0ZXIgdGhlIHdyaXRlYmFjayBqb2JzIGFyZQo+IGFsbG9jYXRlZCB0byBzdG9yZSBmcmFt ZWJ1ZmZlcnMsIGFuZCBhIHdyaXRlYmFjayBmZW5jZSB3aXRoIGEKPiBmcmFtZWJ1ZmZlciBpcyBh biBpbnZhbGlkIGNvbmZpZ3VyYXRpb24gdGhhdCBnZXRzIHJlamVjdGVkIGJ5IHRoZSBjb21taXQK PiBjaGVjay4KPiAKPiBTaWduZWQtb2ZmLWJ5OiBMYXVyZW50IFBpbmNoYXJ0IDxsYXVyZW50LnBp bmNoYXJ0K3JlbmVzYXNAaWRlYXNvbmJvYXJkLmNvbT4KClJldmlld2VkLWJ5OiBMaXZpdSBEdWRh dSA8bGl2aXUuZHVkYXVAYXJtLmNvbT4KCkJlc3QgcmVnYXJkcywKTGl2aXUKCj4gLS0tCj4gQ2hh bmdlcyBzaW5jZSB2NToKPiAKPiAtIEV4cG9ydCBkcm1fd3JpdGViYWNrX3ByZXBhcmVfam9iKCkK PiAtIENoZWNrIGZvciAucHJlcGFyZV93cml0ZWJhY2tfam9iKCkgaW4gZHJtX3dyaXRlYmFja19w cmVwYXJlX2pvYigpCj4gLS0tCj4gIGRyaXZlcnMvZ3B1L2RybS9kcm1fYXRvbWljX2hlbHBlci5j ICAgICAgfCAxMSArKysrKysKPiAgZHJpdmVycy9ncHUvZHJtL2RybV9hdG9taWNfdWFwaS5jICAg ICAgICB8IDMxICsrKysrLS0tLS0tLS0tLS0tCj4gIGRyaXZlcnMvZ3B1L2RybS9kcm1fd3JpdGVi YWNrLmMgICAgICAgICAgfCA0NCArKysrKysrKysrKysrKysrKysrKysrKysKPiAgaW5jbHVkZS9k cm0vZHJtX21vZGVzZXRfaGVscGVyX3Z0YWJsZXMuaCB8ICA3ICsrKysKPiAgaW5jbHVkZS9kcm0v ZHJtX3dyaXRlYmFjay5oICAgICAgICAgICAgICB8IDI4ICsrKysrKysrKysrKysrLQo+ICA1IGZp bGVzIGNoYW5nZWQsIDk3IGluc2VydGlvbnMoKyksIDI0IGRlbGV0aW9ucygtKQo+IAo+IGRpZmYg LS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vZHJtX2F0b21pY19oZWxwZXIuYyBiL2RyaXZlcnMvZ3B1 L2RybS9kcm1fYXRvbWljX2hlbHBlci5jCj4gaW5kZXggNmZlMjMwM2ZjY2Q5Li43MGE0ODg2YzZl NjUgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL2RybV9hdG9taWNfaGVscGVyLmMKPiAr KysgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX2F0b21pY19oZWxwZXIuYwo+IEBAIC0yMjQ1LDEwICsy MjQ1LDIxIEBAIEVYUE9SVF9TWU1CT0woZHJtX2F0b21pY19oZWxwZXJfY29tbWl0X2NsZWFudXBf ZG9uZSk7Cj4gIGludCBkcm1fYXRvbWljX2hlbHBlcl9wcmVwYXJlX3BsYW5lcyhzdHJ1Y3QgZHJt X2RldmljZSAqZGV2LAo+ICAJCQkJICAgICBzdHJ1Y3QgZHJtX2F0b21pY19zdGF0ZSAqc3RhdGUp Cj4gIHsKPiArCXN0cnVjdCBkcm1fY29ubmVjdG9yICpjb25uZWN0b3I7Cj4gKwlzdHJ1Y3QgZHJt X2Nvbm5lY3Rvcl9zdGF0ZSAqbmV3X2Nvbm5fc3RhdGU7Cj4gIAlzdHJ1Y3QgZHJtX3BsYW5lICpw bGFuZTsKPiAgCXN0cnVjdCBkcm1fcGxhbmVfc3RhdGUgKm5ld19wbGFuZV9zdGF0ZTsKPiAgCWlu dCByZXQsIGksIGo7Cj4gIAo+ICsJZm9yX2VhY2hfbmV3X2Nvbm5lY3Rvcl9pbl9zdGF0ZShzdGF0 ZSwgY29ubmVjdG9yLCBuZXdfY29ubl9zdGF0ZSwgaSkgewo+ICsJCWlmICghbmV3X2Nvbm5fc3Rh dGUtPndyaXRlYmFja19qb2IpCj4gKwkJCWNvbnRpbnVlOwo+ICsKPiArCQlyZXQgPSBkcm1fd3Jp dGViYWNrX3ByZXBhcmVfam9iKG5ld19jb25uX3N0YXRlLT53cml0ZWJhY2tfam9iKTsKPiArCQlp ZiAocmV0IDwgMCkKPiArCQkJcmV0dXJuIHJldDsKPiArCX0KPiArCj4gIAlmb3JfZWFjaF9uZXdf cGxhbmVfaW5fc3RhdGUoc3RhdGUsIHBsYW5lLCBuZXdfcGxhbmVfc3RhdGUsIGkpIHsKPiAgCQlj b25zdCBzdHJ1Y3QgZHJtX3BsYW5lX2hlbHBlcl9mdW5jcyAqZnVuY3M7Cj4gIAo+IGRpZmYgLS1n aXQgYS9kcml2ZXJzL2dwdS9kcm0vZHJtX2F0b21pY191YXBpLmMgYi9kcml2ZXJzL2dwdS9kcm0v ZHJtX2F0b21pY191YXBpLmMKPiBpbmRleCBjNDA4ODk4ODhhMTYuLmU4MDIxNTJhMDFhZCAxMDA2 NDQKPiAtLS0gYS9kcml2ZXJzL2dwdS9kcm0vZHJtX2F0b21pY191YXBpLmMKPiArKysgYi9kcml2 ZXJzL2dwdS9kcm0vZHJtX2F0b21pY191YXBpLmMKPiBAQCAtNjQ3LDI4ICs2NDcsMTUgQEAgZHJt X2F0b21pY19wbGFuZV9nZXRfcHJvcGVydHkoc3RydWN0IGRybV9wbGFuZSAqcGxhbmUsCj4gIAly ZXR1cm4gMDsKPiAgfQo+ICAKPiAtc3RhdGljIHN0cnVjdCBkcm1fd3JpdGViYWNrX2pvYiAqCj4g LWRybV9hdG9taWNfZ2V0X3dyaXRlYmFja19qb2Ioc3RydWN0IGRybV9jb25uZWN0b3Jfc3RhdGUg KmNvbm5fc3RhdGUpCj4gLXsKPiAtCVdBUk5fT04oY29ubl9zdGF0ZS0+Y29ubmVjdG9yLT5jb25u ZWN0b3JfdHlwZSAhPSBEUk1fTU9ERV9DT05ORUNUT1JfV1JJVEVCQUNLKTsKPiAtCj4gLQlpZiAo IWNvbm5fc3RhdGUtPndyaXRlYmFja19qb2IpCj4gLQkJY29ubl9zdGF0ZS0+d3JpdGViYWNrX2pv YiA9Cj4gLQkJCWt6YWxsb2Moc2l6ZW9mKCpjb25uX3N0YXRlLT53cml0ZWJhY2tfam9iKSwgR0ZQ X0tFUk5FTCk7Cj4gLQo+IC0JcmV0dXJuIGNvbm5fc3RhdGUtPndyaXRlYmFja19qb2I7Cj4gLX0K PiAtCj4gIHN0YXRpYyBpbnQgZHJtX2F0b21pY19zZXRfd3JpdGViYWNrX2ZiX2Zvcl9jb25uZWN0 b3IoCj4gIAkJc3RydWN0IGRybV9jb25uZWN0b3Jfc3RhdGUgKmNvbm5fc3RhdGUsCj4gIAkJc3Ry dWN0IGRybV9mcmFtZWJ1ZmZlciAqZmIpCj4gIHsKPiAtCXN0cnVjdCBkcm1fd3JpdGViYWNrX2pv YiAqam9iID0KPiAtCQlkcm1fYXRvbWljX2dldF93cml0ZWJhY2tfam9iKGNvbm5fc3RhdGUpOwo+ IC0JaWYgKCFqb2IpCj4gLQkJcmV0dXJuIC1FTk9NRU07Cj4gKwlpbnQgcmV0Owo+ICAKPiAtCWRy bV9mcmFtZWJ1ZmZlcl9hc3NpZ24oJmpvYi0+ZmIsIGZiKTsKPiArCXJldCA9IGRybV93cml0ZWJh Y2tfc2V0X2ZiKGNvbm5fc3RhdGUsIGZiKTsKPiArCWlmIChyZXQgPCAwKQo+ICsJCXJldHVybiBy ZXQ7Cj4gIAo+ICAJaWYgKGZiKQo+ICAJCURSTV9ERUJVR19BVE9NSUMoIlNldCBbRkI6JWRdIGZv ciBjb25uZWN0b3Igc3RhdGUgJXBcbiIsCj4gQEAgLTExNTgsMTkgKzExNDUsMTcgQEAgc3RhdGlj IGludCBwcmVwYXJlX3NpZ25hbGluZyhzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LAo+ICAKPiAgCWZv cl9lYWNoX25ld19jb25uZWN0b3JfaW5fc3RhdGUoc3RhdGUsIGNvbm4sIGNvbm5fc3RhdGUsIGkp IHsKPiAgCQlzdHJ1Y3QgZHJtX3dyaXRlYmFja19jb25uZWN0b3IgKndiX2Nvbm47Cj4gLQkJc3Ry dWN0IGRybV93cml0ZWJhY2tfam9iICpqb2I7Cj4gIAkJc3RydWN0IGRybV9vdXRfZmVuY2Vfc3Rh dGUgKmY7Cj4gIAkJc3RydWN0IGRtYV9mZW5jZSAqZmVuY2U7Cj4gIAkJczMyIF9fdXNlciAqZmVu Y2VfcHRyOwo+ICAKPiArCQlpZiAoIWNvbm5fc3RhdGUtPndyaXRlYmFja19qb2IpCj4gKwkJCWNv bnRpbnVlOwo+ICsKPiAgCQlmZW5jZV9wdHIgPSBnZXRfb3V0X2ZlbmNlX2Zvcl9jb25uZWN0b3Io c3RhdGUsIGNvbm4pOwo+ICAJCWlmICghZmVuY2VfcHRyKQo+ICAJCQljb250aW51ZTsKPiAgCj4g LQkJam9iID0gZHJtX2F0b21pY19nZXRfd3JpdGViYWNrX2pvYihjb25uX3N0YXRlKTsKPiAtCQlp ZiAoIWpvYikKPiAtCQkJcmV0dXJuIC1FTk9NRU07Cj4gLQo+ICAJCWYgPSBrcmVhbGxvYygqZmVu Y2Vfc3RhdGUsIHNpemVvZigqKmZlbmNlX3N0YXRlKSAqCj4gIAkJCSAgICAgKCpudW1fZmVuY2Vz ICsgMSksIEdGUF9LRVJORUwpOwo+ICAJCWlmICghZikKPiBAQCAtMTE5Miw3ICsxMTc3LDcgQEAg c3RhdGljIGludCBwcmVwYXJlX3NpZ25hbGluZyhzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LAo+ICAJ CQlyZXR1cm4gcmV0Owo+ICAJCX0KPiAgCj4gLQkJam9iLT5vdXRfZmVuY2UgPSBmZW5jZTsKPiAr CQljb25uX3N0YXRlLT53cml0ZWJhY2tfam9iLT5vdXRfZmVuY2UgPSBmZW5jZTsKPiAgCX0KPiAg Cj4gIAkvKgo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vZHJtX3dyaXRlYmFjay5jIGIv ZHJpdmVycy9ncHUvZHJtL2RybV93cml0ZWJhY2suYwo+IGluZGV4IDFiNDk3ZDM1MzBiNS4uNzlh YzAxNDcwMWM4IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS9kcm1fd3JpdGViYWNrLmMK PiArKysgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX3dyaXRlYmFjay5jCj4gQEAgLTIzOSw2ICsyMzks NDMgQEAgaW50IGRybV93cml0ZWJhY2tfY29ubmVjdG9yX2luaXQoc3RydWN0IGRybV9kZXZpY2Ug KmRldiwKPiAgfQo+ICBFWFBPUlRfU1lNQk9MKGRybV93cml0ZWJhY2tfY29ubmVjdG9yX2luaXQp Owo+ICAKPiAraW50IGRybV93cml0ZWJhY2tfc2V0X2ZiKHN0cnVjdCBkcm1fY29ubmVjdG9yX3N0 YXRlICpjb25uX3N0YXRlLAo+ICsJCQkgc3RydWN0IGRybV9mcmFtZWJ1ZmZlciAqZmIpCj4gK3sK PiArCVdBUk5fT04oY29ubl9zdGF0ZS0+Y29ubmVjdG9yLT5jb25uZWN0b3JfdHlwZSAhPSBEUk1f TU9ERV9DT05ORUNUT1JfV1JJVEVCQUNLKTsKPiArCj4gKwlpZiAoIWNvbm5fc3RhdGUtPndyaXRl YmFja19qb2IpIHsKPiArCQljb25uX3N0YXRlLT53cml0ZWJhY2tfam9iID0KPiArCQkJa3phbGxv YyhzaXplb2YoKmNvbm5fc3RhdGUtPndyaXRlYmFja19qb2IpLCBHRlBfS0VSTkVMKTsKPiArCQlp ZiAoIWNvbm5fc3RhdGUtPndyaXRlYmFja19qb2IpCj4gKwkJCXJldHVybiAtRU5PTUVNOwo+ICsK PiArCQljb25uX3N0YXRlLT53cml0ZWJhY2tfam9iLT5jb25uZWN0b3IgPQo+ICsJCQlkcm1fY29u bmVjdG9yX3RvX3dyaXRlYmFjayhjb25uX3N0YXRlLT5jb25uZWN0b3IpOwo+ICsJfQo+ICsKPiAr CWRybV9mcmFtZWJ1ZmZlcl9hc3NpZ24oJmNvbm5fc3RhdGUtPndyaXRlYmFja19qb2ItPmZiLCBm Yik7Cj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiAraW50IGRybV93cml0ZWJhY2tfcHJlcGFyZV9q b2Ioc3RydWN0IGRybV93cml0ZWJhY2tfam9iICpqb2IpCj4gK3sKPiArCXN0cnVjdCBkcm1fd3Jp dGViYWNrX2Nvbm5lY3RvciAqY29ubmVjdG9yID0gam9iLT5jb25uZWN0b3I7Cj4gKwljb25zdCBz dHJ1Y3QgZHJtX2Nvbm5lY3Rvcl9oZWxwZXJfZnVuY3MgKmZ1bmNzID0KPiArCQljb25uZWN0b3It PmJhc2UuaGVscGVyX3ByaXZhdGU7Cj4gKwlpbnQgcmV0Owo+ICsKPiArCWlmIChmdW5jcy0+cHJl cGFyZV93cml0ZWJhY2tfam9iKSB7Cj4gKwkJcmV0ID0gZnVuY3MtPnByZXBhcmVfd3JpdGViYWNr X2pvYihjb25uZWN0b3IsIGpvYik7Cj4gKwkJaWYgKHJldCA8IDApCj4gKwkJCXJldHVybiByZXQ7 Cj4gKwl9Cj4gKwo+ICsJam9iLT5wcmVwYXJlZCA9IHRydWU7Cj4gKwlyZXR1cm4gMDsKPiArfQo+ ICtFWFBPUlRfU1lNQk9MKGRybV93cml0ZWJhY2tfcHJlcGFyZV9qb2IpOwo+ICsKPiAgLyoqCj4g ICAqIGRybV93cml0ZWJhY2tfcXVldWVfam9iIC0gUXVldWUgYSB3cml0ZWJhY2sgam9iIGZvciBs YXRlciBzaWduYWxsaW5nCj4gICAqIEB3Yl9jb25uZWN0b3I6IFRoZSB3cml0ZWJhY2sgY29ubmVj dG9yIHRvIHF1ZXVlIGEgam9iIG9uCj4gQEAgLTI3NSw2ICszMTIsMTMgQEAgRVhQT1JUX1NZTUJP TChkcm1fd3JpdGViYWNrX3F1ZXVlX2pvYik7Cj4gIAo+ICB2b2lkIGRybV93cml0ZWJhY2tfY2xl YW51cF9qb2Ioc3RydWN0IGRybV93cml0ZWJhY2tfam9iICpqb2IpCj4gIHsKPiArCXN0cnVjdCBk cm1fd3JpdGViYWNrX2Nvbm5lY3RvciAqY29ubmVjdG9yID0gam9iLT5jb25uZWN0b3I7Cj4gKwlj b25zdCBzdHJ1Y3QgZHJtX2Nvbm5lY3Rvcl9oZWxwZXJfZnVuY3MgKmZ1bmNzID0KPiArCQljb25u ZWN0b3ItPmJhc2UuaGVscGVyX3ByaXZhdGU7Cj4gKwo+ICsJaWYgKGpvYi0+cHJlcGFyZWQgJiYg ZnVuY3MtPmNsZWFudXBfd3JpdGViYWNrX2pvYikKPiArCQlmdW5jcy0+Y2xlYW51cF93cml0ZWJh Y2tfam9iKGNvbm5lY3Rvciwgam9iKTsKPiArCj4gIAlpZiAoam9iLT5mYikKPiAgCQlkcm1fZnJh bWVidWZmZXJfcHV0KGpvYi0+ZmIpOwo+ICAKPiBkaWZmIC0tZ2l0IGEvaW5jbHVkZS9kcm0vZHJt X21vZGVzZXRfaGVscGVyX3Z0YWJsZXMuaCBiL2luY2x1ZGUvZHJtL2RybV9tb2Rlc2V0X2hlbHBl cl92dGFibGVzLmgKPiBpbmRleCA2MTE0MmFhMGFiMjMuLjczZDAzZmU2Njc5OSAxMDA2NDQKPiAt LS0gYS9pbmNsdWRlL2RybS9kcm1fbW9kZXNldF9oZWxwZXJfdnRhYmxlcy5oCj4gKysrIGIvaW5j bHVkZS9kcm0vZHJtX21vZGVzZXRfaGVscGVyX3Z0YWJsZXMuaAo+IEBAIC00OSw2ICs0OSw4IEBA Cj4gICAqLwo+ICAKPiAgZW51bSBtb2RlX3NldF9hdG9taWM7Cj4gK3N0cnVjdCBkcm1fd3JpdGVi YWNrX2Nvbm5lY3RvcjsKPiArc3RydWN0IGRybV93cml0ZWJhY2tfam9iOwo+ICAKPiAgLyoqCj4g ICAqIHN0cnVjdCBkcm1fY3J0Y19oZWxwZXJfZnVuY3MgLSBoZWxwZXIgb3BlcmF0aW9ucyBmb3Ig Q1JUQ3MKPiBAQCAtOTg5LDYgKzk5MSwxMSBAQCBzdHJ1Y3QgZHJtX2Nvbm5lY3Rvcl9oZWxwZXJf ZnVuY3Mgewo+ICAJICovCj4gIAl2b2lkICgqYXRvbWljX2NvbW1pdCkoc3RydWN0IGRybV9jb25u ZWN0b3IgKmNvbm5lY3RvciwKPiAgCQkJICAgICAgc3RydWN0IGRybV9jb25uZWN0b3Jfc3RhdGUg KnN0YXRlKTsKPiArCj4gKwlpbnQgKCpwcmVwYXJlX3dyaXRlYmFja19qb2IpKHN0cnVjdCBkcm1f d3JpdGViYWNrX2Nvbm5lY3RvciAqY29ubmVjdG9yLAo+ICsJCQkJICAgICBzdHJ1Y3QgZHJtX3dy aXRlYmFja19qb2IgKmpvYik7Cj4gKwl2b2lkICgqY2xlYW51cF93cml0ZWJhY2tfam9iKShzdHJ1 Y3QgZHJtX3dyaXRlYmFja19jb25uZWN0b3IgKmNvbm5lY3RvciwKPiArCQkJCSAgICAgIHN0cnVj dCBkcm1fd3JpdGViYWNrX2pvYiAqam9iKTsKPiAgfTsKPiAgCj4gIC8qKgo+IGRpZmYgLS1naXQg YS9pbmNsdWRlL2RybS9kcm1fd3JpdGViYWNrLmggYi9pbmNsdWRlL2RybS9kcm1fd3JpdGViYWNr LmgKPiBpbmRleCA0NzY2MmMzNjI3NDMuLjc3N2MxNGM4NDdmMCAxMDA2NDQKPiAtLS0gYS9pbmNs dWRlL2RybS9kcm1fd3JpdGViYWNrLmgKPiArKysgYi9pbmNsdWRlL2RybS9kcm1fd3JpdGViYWNr LmgKPiBAQCAtNzksNiArNzksMjAgQEAgc3RydWN0IGRybV93cml0ZWJhY2tfY29ubmVjdG9yIHsK PiAgfTsKPiAgCj4gIHN0cnVjdCBkcm1fd3JpdGViYWNrX2pvYiB7Cj4gKwkvKioKPiArCSAqIEBj b25uZWN0b3I6Cj4gKwkgKgo+ICsJICogQmFjay1wb2ludGVyIHRvIHRoZSB3cml0ZWJhY2sgY29u bmVjdG9yIGFzc29jaWF0ZWQgd2l0aCB0aGUgam9iCj4gKwkgKi8KPiArCXN0cnVjdCBkcm1fd3Jp dGViYWNrX2Nvbm5lY3RvciAqY29ubmVjdG9yOwo+ICsKPiArCS8qKgo+ICsJICogQHByZXBhcmVk Ogo+ICsJICoKPiArCSAqIFNldCB3aGVuIHRoZSBqb2IgaGFzIGJlZW4gcHJlcGFyZWQgd2l0aCBk cm1fd3JpdGViYWNrX3ByZXBhcmVfam9iKCkKPiArCSAqLwo+ICsJYm9vbCBwcmVwYXJlZDsKPiAr Cj4gIAkvKioKPiAgCSAqIEBjbGVhbnVwX3dvcms6Cj4gIAkgKgo+IEBAIC05OCw3ICsxMTIsNyBA QCBzdHJ1Y3QgZHJtX3dyaXRlYmFja19qb2Igewo+ICAJICogQGZiOgo+ICAJICoKPiAgCSAqIEZy YW1lYnVmZmVyIHRvIGJlIHdyaXR0ZW4gdG8gYnkgdGhlIHdyaXRlYmFjayBjb25uZWN0b3IuIERv IG5vdCBzZXQKPiAtCSAqIGRpcmVjdGx5LCB1c2UgZHJtX2F0b21pY19zZXRfd3JpdGViYWNrX2Zi X2Zvcl9jb25uZWN0b3IoKQo+ICsJICogZGlyZWN0bHksIHVzZSBkcm1fd3JpdGViYWNrX3NldF9m YigpCj4gIAkgKi8KPiAgCXN0cnVjdCBkcm1fZnJhbWVidWZmZXIgKmZiOwo+ICAKPiBAQCAtMTA4 LDYgKzEyMiwxMyBAQCBzdHJ1Y3QgZHJtX3dyaXRlYmFja19qb2Igewo+ICAJICogRmVuY2Ugd2hp Y2ggd2lsbCBzaWduYWwgb25jZSB0aGUgd3JpdGViYWNrIGhhcyBjb21wbGV0ZWQKPiAgCSAqLwo+ ICAJc3RydWN0IGRtYV9mZW5jZSAqb3V0X2ZlbmNlOwo+ICsKPiArCS8qKgo+ICsJICogQHByaXY6 Cj4gKwkgKgo+ICsJICogRHJpdmVyLXByaXZhdGUgZGF0YQo+ICsJICovCj4gKwl2b2lkICpwcml2 Owo+ICB9Owo+ICAKPiAgc3RhdGljIGlubGluZSBzdHJ1Y3QgZHJtX3dyaXRlYmFja19jb25uZWN0 b3IgKgo+IEBAIC0xMjIsNiArMTQzLDExIEBAIGludCBkcm1fd3JpdGViYWNrX2Nvbm5lY3Rvcl9p bml0KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsCj4gIAkJCQkgY29uc3Qgc3RydWN0IGRybV9lbmNv ZGVyX2hlbHBlcl9mdW5jcyAqZW5jX2hlbHBlcl9mdW5jcywKPiAgCQkJCSBjb25zdCB1MzIgKmZv cm1hdHMsIGludCBuX2Zvcm1hdHMpOwo+ICAKPiAraW50IGRybV93cml0ZWJhY2tfc2V0X2ZiKHN0 cnVjdCBkcm1fY29ubmVjdG9yX3N0YXRlICpjb25uX3N0YXRlLAo+ICsJCQkgc3RydWN0IGRybV9m cmFtZWJ1ZmZlciAqZmIpOwo+ICsKPiAraW50IGRybV93cml0ZWJhY2tfcHJlcGFyZV9qb2Ioc3Ry dWN0IGRybV93cml0ZWJhY2tfam9iICpqb2IpOwo+ICsKPiAgdm9pZCBkcm1fd3JpdGViYWNrX3F1 ZXVlX2pvYihzdHJ1Y3QgZHJtX3dyaXRlYmFja19jb25uZWN0b3IgKndiX2Nvbm5lY3RvciwKPiAg CQkJICAgICBzdHJ1Y3QgZHJtX2Nvbm5lY3Rvcl9zdGF0ZSAqY29ubl9zdGF0ZSk7Cj4gIAo+IC0t IAo+IFJlZ2FyZHMsCj4gCj4gTGF1cmVudCBQaW5jaGFydAo+IAoKLS0gCj09PT09PT09PT09PT09 PT09PT09CnwgSSB3b3VsZCBsaWtlIHRvIHwKfCBmaXggdGhlIHdvcmxkLCAgfAp8IGJ1dCB0aGV5 J3JlIG5vdCB8CnwgZ2l2aW5nIG1lIHRoZSAgIHwKIFwgc291cmNlIGNvZGUhICAvCiAgLS0tLS0t LS0tLS0tLS0tCiAgICDCr1xfKOODhClfL8KvCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fCmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3Rz LmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xp c3RpbmZvL2RyaS1kZXZlbA==