From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from galahad.ideasonboard.com ([185.26.127.97]:35553 "EHLO galahad.ideasonboard.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751203AbdCCCNN (ORCPT ); Thu, 2 Mar 2017 21:13:13 -0500 From: Laurent Pinchart To: Kieran Bingham Cc: linux-renesas-soc@vger.kernel.org, linux-media@vger.kernel.org, dri-devel@lists.freedesktop.org Subject: Re: [RFC PATCH 2/3] v4l: vsp1: extend VSP1 module API to allow DRM callback registration Date: Fri, 03 Mar 2017 04:11:09 +0200 Message-ID: <2628026.T8y166ePVA@avalon> In-Reply-To: References: 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, Thank you for the patch. On Wednesday 01 Mar 2017 13:12:55 Kieran Bingham wrote: > To be able to perform page flips in DRM without flicker we need to be > able to notify the rcar-du module when the VSP has completed its > processing. > > To synchronise the page flip events for userspace, we move the required > event through the VSP to track the data flow. When the frame is > completed, the event can be returned back to the originator through the > registered callback. > > We must not have bidirectional dependencies on the two components to > maintain support for loadable modules, thus we extend the API to allow > a callback to be registered within the VSP DRM interface. > > Signed-off-by: Kieran Bingham > --- > drivers/gpu/drm/rcar-du/rcar_du_vsp.c | 2 +- > drivers/media/platform/vsp1/vsp1_drm.c | 42 +++++++++++++++++++++++++-- > drivers/media/platform/vsp1/vsp1_drm.h | 12 ++++++++- > include/media/vsp1.h | 6 +++- > 4 files changed, 58 insertions(+), 4 deletions(-) > > diff --git a/drivers/gpu/drm/rcar-du/rcar_du_vsp.c > b/drivers/gpu/drm/rcar-du/rcar_du_vsp.c index b5bfbe50bd87..71e70e1e0881 > 100644 > --- a/drivers/gpu/drm/rcar-du/rcar_du_vsp.c > +++ b/drivers/gpu/drm/rcar-du/rcar_du_vsp.c > @@ -81,7 +81,7 @@ void rcar_du_vsp_atomic_begin(struct rcar_du_crtc *crtc) > > void rcar_du_vsp_atomic_flush(struct rcar_du_crtc *crtc) > { > - vsp1_du_atomic_flush(crtc->vsp->vsp); > + vsp1_du_atomic_flush(crtc->vsp->vsp, NULL); > } > > /* Keep the two tables in sync. */ > diff --git a/drivers/media/platform/vsp1/vsp1_drm.c > b/drivers/media/platform/vsp1/vsp1_drm.c index 8e2aa3f8e52f..743cbce48d0c > 100644 > --- a/drivers/media/platform/vsp1/vsp1_drm.c > +++ b/drivers/media/platform/vsp1/vsp1_drm.c > @@ -52,6 +52,40 @@ int vsp1_du_init(struct device *dev) > EXPORT_SYMBOL_GPL(vsp1_du_init); > > /** > + * vsp1_du_register_callback - Register VSP completion notifier callback > + * > + * Allow the DRM framework to register a callback with us to notify the end > of + * processing each frame. This allows synchronisation for page > flipping. + * > + * @dev: the VSP device > + * @callback: the callback function to notify the DU module > + * @private: private structure data to pass with the callback > + * > + */ > +void vsp1_du_register_callback(struct device *dev, > + void (*callback)(void *, void *), > + void *private) > +{ > + struct vsp1_device *vsp1 = dev_get_drvdata(dev); > + > + vsp1->drm->du_complete = callback; > + vsp1->drm->du_private = private; > +} > +EXPORT_SYMBOL_GPL(vsp1_du_register_callback); As they're not supposed to change at runtime while the display is running, how about passing the callback and private data pointer to the vsp1_du_setup_lif() function ? Feel free to create a structure for all the parameters passed to the function if you think we'll have too much (which would, as a side effect, made updates to the API easier in the future as changes to the two subsystems will be easier to decouple). > +static void vsp1_du_pipeline_frame_end(struct vsp1_pipeline *pipe) > +{ > + struct vsp1_drm *drm = to_vsp1_drm(pipe); > + > + if (drm->du_complete && drm->active_data) > + drm->du_complete(drm->du_private, drm->active_data); > + > + /* The pending frame is now active */ > + drm->active_data = drm->pending_data; > + drm->pending_data = NULL; > +} I would move this function to the "Interrupt Handling" section. > +/** > * vsp1_du_setup_lif - Setup the output part of the VSP pipeline > * @dev: the VSP device > * @width: output frame width in pixels > @@ -99,7 +133,8 @@ int vsp1_du_setup_lif(struct device *dev, unsigned int > width, } > > pipe->num_inputs = 0; > - > + pipe->frame_end = NULL; You can drop this if ... > + vsp1->drm->du_complete = NULL; > vsp1_dlm_reset(pipe->output->dlm); > vsp1_device_put(vsp1); > > @@ -196,6 +231,8 @@ int vsp1_du_setup_lif(struct device *dev, unsigned int > width, if (ret < 0) > return ret; > > + pipe->frame_end = vsp1_du_pipeline_frame_end; > + ... you move this to vsp1_drm_init(). > ret = media_entity_pipeline_start(&pipe->output->entity.subdev.entity, > &pipe->pipe); > if (ret < 0) { > @@ -420,7 +457,7 @@ static unsigned int rpf_zpos(struct vsp1_device *vsp1, > struct vsp1_rwpf *rpf) * vsp1_du_atomic_flush - Commit an atomic update > * @dev: the VSP device > */ > -void vsp1_du_atomic_flush(struct device *dev) > +void vsp1_du_atomic_flush(struct device *dev, void *data) > { > struct vsp1_device *vsp1 = dev_get_drvdata(dev); > struct vsp1_pipeline *pipe = &vsp1->drm->pipe; > @@ -504,6 +541,7 @@ void vsp1_du_atomic_flush(struct device *dev) > > vsp1_dl_list_commit(pipe->dl); > pipe->dl = NULL; > + vsp1->drm->pending_data = data; > > /* Start or stop the pipeline if needed. */ > if (!vsp1->drm->num_inputs && pipe->num_inputs) { > diff --git a/drivers/media/platform/vsp1/vsp1_drm.h > b/drivers/media/platform/vsp1/vsp1_drm.h index 9e28ab9254ba..fde19e5948a0 > 100644 > --- a/drivers/media/platform/vsp1/vsp1_drm.h > +++ b/drivers/media/platform/vsp1/vsp1_drm.h > @@ -33,8 +33,20 @@ struct vsp1_drm { > struct v4l2_rect compose; > unsigned int zpos; > } inputs[VSP1_MAX_RPF]; > + > + /* Frame syncronisation */ > + void (*du_complete)(void *, void *); > + void *du_private; > + void *pending_data; > + void *active_data; > }; > > +static inline struct vsp1_drm * > +to_vsp1_drm(struct vsp1_pipeline *pipe) No need for a line split. > +{ > + return container_of(pipe, struct vsp1_drm, pipe); > +} > + > int vsp1_drm_init(struct vsp1_device *vsp1); > void vsp1_drm_cleanup(struct vsp1_device *vsp1); > int vsp1_drm_create_links(struct vsp1_device *vsp1); > diff --git a/include/media/vsp1.h b/include/media/vsp1.h > index 458b400373d4..f82fbab01f21 100644 > --- a/include/media/vsp1.h > +++ b/include/media/vsp1.h > @@ -20,6 +20,10 @@ struct device; > > int vsp1_du_init(struct device *dev); > > +void vsp1_du_register_callback(struct device *dev, > + void (*callback)(void *, void *), > + void *private); > + > int vsp1_du_setup_lif(struct device *dev, unsigned int width, > unsigned int height); > > @@ -36,6 +40,6 @@ struct vsp1_du_atomic_config { > void vsp1_du_atomic_begin(struct device *dev); > int vsp1_du_atomic_update(struct device *dev, unsigned int rpf, > const struct vsp1_du_atomic_config *cfg); > -void vsp1_du_atomic_flush(struct device *dev); > +void vsp1_du_atomic_flush(struct device *dev, void *data); > > #endif /* __MEDIA_VSP1_H__ */ -- Regards, Laurent Pinchart From mboxrd@z Thu Jan 1 00:00:00 1970 From: Laurent Pinchart Subject: Re: [RFC PATCH 2/3] v4l: vsp1: extend VSP1 module API to allow DRM callback registration Date: Fri, 03 Mar 2017 04:11:09 +0200 Message-ID: <2628026.T8y166ePVA@avalon> References: 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 EFE106E1B9 for ; Fri, 3 Mar 2017 02:10:34 +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, dri-devel@lists.freedesktop.org, linux-media@vger.kernel.org List-Id: dri-devel@lists.freedesktop.org SGkgS2llcmFuLAoKVGhhbmsgeW91IGZvciB0aGUgcGF0Y2guCgpPbiBXZWRuZXNkYXkgMDEgTWFy IDIwMTcgMTM6MTI6NTUgS2llcmFuIEJpbmdoYW0gd3JvdGU6Cj4gVG8gYmUgYWJsZSB0byBwZXJm b3JtIHBhZ2UgZmxpcHMgaW4gRFJNIHdpdGhvdXQgZmxpY2tlciB3ZSBuZWVkIHRvIGJlCj4gYWJs ZSB0byBub3RpZnkgdGhlIHJjYXItZHUgbW9kdWxlIHdoZW4gdGhlIFZTUCBoYXMgY29tcGxldGVk IGl0cwo+IHByb2Nlc3NpbmcuCj4gCj4gVG8gc3luY2hyb25pc2UgdGhlIHBhZ2UgZmxpcCBldmVu dHMgZm9yIHVzZXJzcGFjZSwgd2UgbW92ZSB0aGUgcmVxdWlyZWQKPiBldmVudCB0aHJvdWdoIHRo ZSBWU1AgdG8gdHJhY2sgdGhlIGRhdGEgZmxvdy4gV2hlbiB0aGUgZnJhbWUgaXMKPiBjb21wbGV0 ZWQsIHRoZSBldmVudCBjYW4gYmUgcmV0dXJuZWQgYmFjayB0byB0aGUgb3JpZ2luYXRvciB0aHJv dWdoIHRoZQo+IHJlZ2lzdGVyZWQgY2FsbGJhY2suCj4gCj4gV2UgbXVzdCBub3QgaGF2ZSBiaWRp cmVjdGlvbmFsIGRlcGVuZGVuY2llcyBvbiB0aGUgdHdvIGNvbXBvbmVudHMgdG8KPiBtYWludGFp biBzdXBwb3J0IGZvciBsb2FkYWJsZSBtb2R1bGVzLCB0aHVzIHdlIGV4dGVuZCB0aGUgQVBJIHRv IGFsbG93Cj4gYSBjYWxsYmFjayB0byBiZSByZWdpc3RlcmVkIHdpdGhpbiB0aGUgVlNQIERSTSBp bnRlcmZhY2UuCj4gCj4gU2lnbmVkLW9mZi1ieTogS2llcmFuIEJpbmdoYW0gPGtpZXJhbi5iaW5n aGFtK3JlbmVzYXNAaWRlYXNvbmJvYXJkLmNvbT4KPiAtLS0KPiAgZHJpdmVycy9ncHUvZHJtL3Jj YXItZHUvcmNhcl9kdV92c3AuYyAgfCAgMiArLQo+ICBkcml2ZXJzL21lZGlhL3BsYXRmb3JtL3Zz cDEvdnNwMV9kcm0uYyB8IDQyICsrKysrKysrKysrKysrKysrKysrKysrKystLQo+ICBkcml2ZXJz L21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9kcm0uaCB8IDEyICsrKysrKysrLQo+ICBpbmNsdWRl L21lZGlhL3ZzcDEuaCAgICAgICAgICAgICAgICAgICB8ICA2ICsrKy0KPiAgNCBmaWxlcyBjaGFu Z2VkLCA1OCBpbnNlcnRpb25zKCspLCA0IGRlbGV0aW9ucygtKQo+IAo+IGRpZmYgLS1naXQgYS9k cml2ZXJzL2dwdS9kcm0vcmNhci1kdS9yY2FyX2R1X3ZzcC5jCj4gYi9kcml2ZXJzL2dwdS9kcm0v cmNhci1kdS9yY2FyX2R1X3ZzcC5jIGluZGV4IGI1YmZiZTUwYmQ4Ny4uNzFlNzBlMWUwODgxCj4g MTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL3JjYXItZHUvcmNhcl9kdV92c3AuYwo+ICsr KyBiL2RyaXZlcnMvZ3B1L2RybS9yY2FyLWR1L3JjYXJfZHVfdnNwLmMKPiBAQCAtODEsNyArODEs NyBAQCB2b2lkIHJjYXJfZHVfdnNwX2F0b21pY19iZWdpbihzdHJ1Y3QgcmNhcl9kdV9jcnRjICpj cnRjKQo+IAo+ICB2b2lkIHJjYXJfZHVfdnNwX2F0b21pY19mbHVzaChzdHJ1Y3QgcmNhcl9kdV9j cnRjICpjcnRjKQo+ICB7Cj4gLQl2c3AxX2R1X2F0b21pY19mbHVzaChjcnRjLT52c3AtPnZzcCk7 Cj4gKwl2c3AxX2R1X2F0b21pY19mbHVzaChjcnRjLT52c3AtPnZzcCwgTlVMTCk7Cj4gIH0KPiAK PiAgLyogS2VlcCB0aGUgdHdvIHRhYmxlcyBpbiBzeW5jLiAqLwo+IGRpZmYgLS1naXQgYS9kcml2 ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9kcm0uYwo+IGIvZHJpdmVycy9tZWRpYS9wbGF0 Zm9ybS92c3AxL3ZzcDFfZHJtLmMgaW5kZXggOGUyYWEzZjhlNTJmLi43NDNjYmNlNDhkMGMKPiAx MDA2NDQKPiAtLS0gYS9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9kcm0uYwo+ICsr KyBiL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX2RybS5jCj4gQEAgLTUyLDYgKzUy LDQwIEBAIGludCB2c3AxX2R1X2luaXQoc3RydWN0IGRldmljZSAqZGV2KQo+ICBFWFBPUlRfU1lN Qk9MX0dQTCh2c3AxX2R1X2luaXQpOwo+IAo+ICAvKioKPiArICogdnNwMV9kdV9yZWdpc3Rlcl9j YWxsYmFjayAtIFJlZ2lzdGVyIFZTUCBjb21wbGV0aW9uIG5vdGlmaWVyIGNhbGxiYWNrCj4gKyAq Cj4gKyAqIEFsbG93IHRoZSBEUk0gZnJhbWV3b3JrIHRvIHJlZ2lzdGVyIGEgY2FsbGJhY2sgd2l0 aCB1cyB0byBub3RpZnkgdGhlIGVuZAo+IG9mICsgKiBwcm9jZXNzaW5nIGVhY2ggZnJhbWUuIFRo aXMgYWxsb3dzIHN5bmNocm9uaXNhdGlvbiBmb3IgcGFnZQo+IGZsaXBwaW5nLiArICoKPiArICog QGRldjogdGhlIFZTUCBkZXZpY2UKPiArICogQGNhbGxiYWNrOiB0aGUgY2FsbGJhY2sgZnVuY3Rp b24gdG8gbm90aWZ5IHRoZSBEVSBtb2R1bGUKPiArICogQHByaXZhdGU6IHByaXZhdGUgc3RydWN0 dXJlIGRhdGEgdG8gcGFzcyB3aXRoIHRoZSBjYWxsYmFjawo+ICsgKgo+ICsgKi8KPiArdm9pZCB2 c3AxX2R1X3JlZ2lzdGVyX2NhbGxiYWNrKHN0cnVjdCBkZXZpY2UgKmRldiwKPiArCQkJICAgICAg IHZvaWQgKCpjYWxsYmFjaykodm9pZCAqLCB2b2lkICopLAo+ICsJCQkgICAgICAgdm9pZCAqcHJp dmF0ZSkKPiArewo+ICsJc3RydWN0IHZzcDFfZGV2aWNlICp2c3AxID0gZGV2X2dldF9kcnZkYXRh KGRldik7Cj4gKwo+ICsJdnNwMS0+ZHJtLT5kdV9jb21wbGV0ZSA9IGNhbGxiYWNrOwo+ICsJdnNw MS0+ZHJtLT5kdV9wcml2YXRlID0gcHJpdmF0ZTsKPiArfQo+ICtFWFBPUlRfU1lNQk9MX0dQTCh2 c3AxX2R1X3JlZ2lzdGVyX2NhbGxiYWNrKTsKCkFzIHRoZXkncmUgbm90IHN1cHBvc2VkIHRvIGNo YW5nZSBhdCBydW50aW1lIHdoaWxlIHRoZSBkaXNwbGF5IGlzIHJ1bm5pbmcsIGhvdyAKYWJvdXQg cGFzc2luZyB0aGUgY2FsbGJhY2sgYW5kIHByaXZhdGUgZGF0YSBwb2ludGVyIHRvIHRoZSB2c3Ax X2R1X3NldHVwX2xpZigpIApmdW5jdGlvbiA/IEZlZWwgZnJlZSB0byBjcmVhdGUgYSBzdHJ1Y3R1 cmUgZm9yIGFsbCB0aGUgcGFyYW1ldGVycyBwYXNzZWQgdG8gCnRoZSBmdW5jdGlvbiBpZiB5b3Ug dGhpbmsgd2UnbGwgaGF2ZSB0b28gbXVjaCAod2hpY2ggd291bGQsIGFzIGEgc2lkZSBlZmZlY3Qs IAptYWRlIHVwZGF0ZXMgdG8gdGhlIEFQSSBlYXNpZXIgaW4gdGhlIGZ1dHVyZSBhcyBjaGFuZ2Vz IHRvIHRoZSB0d28gc3Vic3lzdGVtcyAKd2lsbCBiZSBlYXNpZXIgdG8gZGVjb3VwbGUpLgoKPiAr c3RhdGljIHZvaWQgdnNwMV9kdV9waXBlbGluZV9mcmFtZV9lbmQoc3RydWN0IHZzcDFfcGlwZWxp bmUgKnBpcGUpCj4gK3sKPiArCXN0cnVjdCB2c3AxX2RybSAqZHJtID0gdG9fdnNwMV9kcm0ocGlw ZSk7Cj4gKwo+ICsJaWYgKGRybS0+ZHVfY29tcGxldGUgJiYgZHJtLT5hY3RpdmVfZGF0YSkKPiAr CQlkcm0tPmR1X2NvbXBsZXRlKGRybS0+ZHVfcHJpdmF0ZSwgZHJtLT5hY3RpdmVfZGF0YSk7Cj4g Kwo+ICsJLyogVGhlIHBlbmRpbmcgZnJhbWUgaXMgbm93IGFjdGl2ZSAqLwo+ICsJZHJtLT5hY3Rp dmVfZGF0YSA9IGRybS0+cGVuZGluZ19kYXRhOwo+ICsJZHJtLT5wZW5kaW5nX2RhdGEgPSBOVUxM Owo+ICt9CgpJIHdvdWxkIG1vdmUgdGhpcyBmdW5jdGlvbiB0byB0aGUgIkludGVycnVwdCBIYW5k bGluZyIgc2VjdGlvbi4KCj4gKy8qKgo+ICAgKiB2c3AxX2R1X3NldHVwX2xpZiAtIFNldHVwIHRo ZSBvdXRwdXQgcGFydCBvZiB0aGUgVlNQIHBpcGVsaW5lCj4gICAqIEBkZXY6IHRoZSBWU1AgZGV2 aWNlCj4gICAqIEB3aWR0aDogb3V0cHV0IGZyYW1lIHdpZHRoIGluIHBpeGVscwo+IEBAIC05OSw3 ICsxMzMsOCBAQCBpbnQgdnNwMV9kdV9zZXR1cF9saWYoc3RydWN0IGRldmljZSAqZGV2LCB1bnNp Z25lZCBpbnQKPiB3aWR0aCwgfQo+IAo+ICAJCXBpcGUtPm51bV9pbnB1dHMgPSAwOwo+IC0KPiAr CQlwaXBlLT5mcmFtZV9lbmQgPSBOVUxMOwoKWW91IGNhbiBkcm9wIHRoaXMgaWYgLi4uCgo+ICsJ CXZzcDEtPmRybS0+ZHVfY29tcGxldGUgPSBOVUxMOwo+ICAJCXZzcDFfZGxtX3Jlc2V0KHBpcGUt Pm91dHB1dC0+ZGxtKTsKPiAgCQl2c3AxX2RldmljZV9wdXQodnNwMSk7Cj4gCj4gQEAgLTE5Niw2 ICsyMzEsOCBAQCBpbnQgdnNwMV9kdV9zZXR1cF9saWYoc3RydWN0IGRldmljZSAqZGV2LCB1bnNp Z25lZCBpbnQKPiB3aWR0aCwgaWYgKHJldCA8IDApCj4gIAkJcmV0dXJuIHJldDsKPiAKPiArCXBp cGUtPmZyYW1lX2VuZCA9IHZzcDFfZHVfcGlwZWxpbmVfZnJhbWVfZW5kOwo+ICsKCi4uLiB5b3Ug bW92ZSB0aGlzIHRvIHZzcDFfZHJtX2luaXQoKS4KCj4gIAlyZXQgPSBtZWRpYV9lbnRpdHlfcGlw ZWxpbmVfc3RhcnQoJnBpcGUtPm91dHB1dC0+ZW50aXR5LnN1YmRldi5lbnRpdHksCj4gIAkJCQkJ ICAmcGlwZS0+cGlwZSk7Cj4gIAlpZiAocmV0IDwgMCkgewo+IEBAIC00MjAsNyArNDU3LDcgQEAg c3RhdGljIHVuc2lnbmVkIGludCBycGZfenBvcyhzdHJ1Y3QgdnNwMV9kZXZpY2UgKnZzcDEsCj4g c3RydWN0IHZzcDFfcndwZiAqcnBmKSAqIHZzcDFfZHVfYXRvbWljX2ZsdXNoIC0gQ29tbWl0IGFu IGF0b21pYyB1cGRhdGUKPiAgICogQGRldjogdGhlIFZTUCBkZXZpY2UKPiAgICovCj4gLXZvaWQg dnNwMV9kdV9hdG9taWNfZmx1c2goc3RydWN0IGRldmljZSAqZGV2KQo+ICt2b2lkIHZzcDFfZHVf YXRvbWljX2ZsdXNoKHN0cnVjdCBkZXZpY2UgKmRldiwgdm9pZCAqZGF0YSkKPiAgewo+ICAJc3Ry dWN0IHZzcDFfZGV2aWNlICp2c3AxID0gZGV2X2dldF9kcnZkYXRhKGRldik7Cj4gIAlzdHJ1Y3Qg dnNwMV9waXBlbGluZSAqcGlwZSA9ICZ2c3AxLT5kcm0tPnBpcGU7Cj4gQEAgLTUwNCw2ICs1NDEs NyBAQCB2b2lkIHZzcDFfZHVfYXRvbWljX2ZsdXNoKHN0cnVjdCBkZXZpY2UgKmRldikKPiAKPiAg CXZzcDFfZGxfbGlzdF9jb21taXQocGlwZS0+ZGwpOwo+ICAJcGlwZS0+ZGwgPSBOVUxMOwo+ICsJ dnNwMS0+ZHJtLT5wZW5kaW5nX2RhdGEgPSBkYXRhOwo+IAo+ICAJLyogU3RhcnQgb3Igc3RvcCB0 aGUgcGlwZWxpbmUgaWYgbmVlZGVkLiAqLwo+ICAJaWYgKCF2c3AxLT5kcm0tPm51bV9pbnB1dHMg JiYgcGlwZS0+bnVtX2lucHV0cykgewo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL21lZGlhL3BsYXRm b3JtL3ZzcDEvdnNwMV9kcm0uaAo+IGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFf ZHJtLmggaW5kZXggOWUyOGFiOTI1NGJhLi5mZGUxOWU1OTQ4YTAKPiAxMDA2NDQKPiAtLS0gYS9k cml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9kcm0uaAo+ICsrKyBiL2RyaXZlcnMvbWVk aWEvcGxhdGZvcm0vdnNwMS92c3AxX2RybS5oCj4gQEAgLTMzLDggKzMzLDIwIEBAIHN0cnVjdCB2 c3AxX2RybSB7Cj4gIAkJc3RydWN0IHY0bDJfcmVjdCBjb21wb3NlOwo+ICAJCXVuc2lnbmVkIGlu dCB6cG9zOwo+ICAJfSBpbnB1dHNbVlNQMV9NQVhfUlBGXTsKPiArCj4gKwkvKiBGcmFtZSBzeW5j cm9uaXNhdGlvbiAqLwo+ICsJdm9pZCAoKmR1X2NvbXBsZXRlKSh2b2lkICosIHZvaWQgKik7Cj4g Kwl2b2lkICpkdV9wcml2YXRlOwo+ICsJdm9pZCAqcGVuZGluZ19kYXRhOwo+ICsJdm9pZCAqYWN0 aXZlX2RhdGE7Cj4gIH07Cj4gCj4gK3N0YXRpYyBpbmxpbmUgc3RydWN0IHZzcDFfZHJtICoKPiAr dG9fdnNwMV9kcm0oc3RydWN0IHZzcDFfcGlwZWxpbmUgKnBpcGUpCgpObyBuZWVkIGZvciBhIGxp bmUgc3BsaXQuCgo+ICt7Cj4gKwlyZXR1cm4gY29udGFpbmVyX29mKHBpcGUsIHN0cnVjdCB2c3Ax X2RybSwgcGlwZSk7Cj4gK30KPiArCj4gIGludCB2c3AxX2RybV9pbml0KHN0cnVjdCB2c3AxX2Rl dmljZSAqdnNwMSk7Cj4gIHZvaWQgdnNwMV9kcm1fY2xlYW51cChzdHJ1Y3QgdnNwMV9kZXZpY2Ug KnZzcDEpOwo+ICBpbnQgdnNwMV9kcm1fY3JlYXRlX2xpbmtzKHN0cnVjdCB2c3AxX2RldmljZSAq dnNwMSk7Cj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvbWVkaWEvdnNwMS5oIGIvaW5jbHVkZS9tZWRp YS92c3AxLmgKPiBpbmRleCA0NThiNDAwMzczZDQuLmY4MmZiYWIwMWYyMSAxMDA2NDQKPiAtLS0g YS9pbmNsdWRlL21lZGlhL3ZzcDEuaAo+ICsrKyBiL2luY2x1ZGUvbWVkaWEvdnNwMS5oCj4gQEAg LTIwLDYgKzIwLDEwIEBAIHN0cnVjdCBkZXZpY2U7Cj4gCj4gIGludCB2c3AxX2R1X2luaXQoc3Ry dWN0IGRldmljZSAqZGV2KTsKPiAKPiArdm9pZCB2c3AxX2R1X3JlZ2lzdGVyX2NhbGxiYWNrKHN0 cnVjdCBkZXZpY2UgKmRldiwKPiArCQkJICAgICAgIHZvaWQgKCpjYWxsYmFjaykodm9pZCAqLCB2 b2lkICopLAo+ICsJCQkgICAgICAgdm9pZCAqcHJpdmF0ZSk7Cj4gKwo+ICBpbnQgdnNwMV9kdV9z ZXR1cF9saWYoc3RydWN0IGRldmljZSAqZGV2LCB1bnNpZ25lZCBpbnQgd2lkdGgsCj4gIAkJICAg ICAgdW5zaWduZWQgaW50IGhlaWdodCk7Cj4gCj4gQEAgLTM2LDYgKzQwLDYgQEAgc3RydWN0IHZz cDFfZHVfYXRvbWljX2NvbmZpZyB7Cj4gIHZvaWQgdnNwMV9kdV9hdG9taWNfYmVnaW4oc3RydWN0 IGRldmljZSAqZGV2KTsKPiAgaW50IHZzcDFfZHVfYXRvbWljX3VwZGF0ZShzdHJ1Y3QgZGV2aWNl ICpkZXYsIHVuc2lnbmVkIGludCBycGYsCj4gIAkJCSAgY29uc3Qgc3RydWN0IHZzcDFfZHVfYXRv bWljX2NvbmZpZyAqY2ZnKTsKPiAtdm9pZCB2c3AxX2R1X2F0b21pY19mbHVzaChzdHJ1Y3QgZGV2 aWNlICpkZXYpOwo+ICt2b2lkIHZzcDFfZHVfYXRvbWljX2ZsdXNoKHN0cnVjdCBkZXZpY2UgKmRl diwgdm9pZCAqZGF0YSk7Cj4gCj4gICNlbmRpZiAvKiBfX01FRElBX1ZTUDFfSF9fICovCgotLSAK UmVnYXJkcywKCkxhdXJlbnQgUGluY2hhcnQKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fCmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3Rz LmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xp c3RpbmZvL2RyaS1kZXZlbAo=