From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from galahad.ideasonboard.com ([185.26.127.97]:59200 "EHLO galahad.ideasonboard.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752392AbdCEV57 (ORCPT ); Sun, 5 Mar 2017 16:57:59 -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: [PATCH v3 2/3] v4l: vsp1: Extend VSP1 module API to allow DRM callbacks Date: Sun, 05 Mar 2017 23:58:33 +0200 Message-ID: <16730350.NvnRv331tg@avalon> In-Reply-To: <200127cf978c8d8904e43ab2b28a225e8a786f6e.1488729419.git-series.kieran.bingham+renesas@ideasonboard.com> References: <200127cf978c8d8904e43ab2b28a225e8a786f6e.1488729419.git-series.kieran.bingham+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, Thank you for the patch. On Sunday 05 Mar 2017 16:00:03 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. > > 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/media/platform/vsp1/vsp1_drm.c | 17 +++++++++++++++++ > drivers/media/platform/vsp1/vsp1_drm.h | 11 +++++++++++ > include/media/vsp1.h | 13 +++++++++++++ > 3 files changed, 41 insertions(+) > > diff --git a/drivers/media/platform/vsp1/vsp1_drm.c > b/drivers/media/platform/vsp1/vsp1_drm.c index 4ee437c7ff0c..d93bf7d3a39e > 100644 > --- a/drivers/media/platform/vsp1/vsp1_drm.c > +++ b/drivers/media/platform/vsp1/vsp1_drm.c > @@ -37,6 +37,14 @@ void vsp1_drm_display_start(struct vsp1_device *vsp1) > vsp1_dlm_irq_display_start(vsp1->drm->pipe.output->dlm); > } > > +static void vsp1_du_pipeline_frame_end(struct vsp1_pipeline *pipe) > +{ > + struct vsp1_drm *drm = to_vsp1_drm(pipe); > + > + if (drm->du_complete) > + drm->du_complete(drm->du_private); > +} > + > /* ------------------------------------------------------------------------ > * DU Driver API > */ > @@ -96,6 +104,7 @@ int vsp1_du_setup_lif(struct device *dev, const struct > vsp1_du_lif_config *cfg) } > > pipe->num_inputs = 0; > + vsp1->drm->du_complete = NULL; > > vsp1_dlm_reset(pipe->output->dlm); > vsp1_device_put(vsp1); > @@ -200,6 +209,13 @@ int vsp1_du_setup_lif(struct device *dev, const struct > vsp1_du_lif_config *cfg) if (ret < 0) > return ret; > > + /* > + * Register a callback to allow us to notify the DRM framework of frame s/framework/driver/ > + * completion events. > + */ > + vsp1->drm->du_complete = cfg->callback; > + vsp1->drm->du_private = cfg->callback_data; > + > ret = media_pipeline_start(&pipe->output->entity.subdev.entity, > &pipe->pipe); > if (ret < 0) { > @@ -607,6 +623,7 @@ int vsp1_drm_init(struct vsp1_device *vsp1) > pipe->lif = &vsp1->lif->entity; > pipe->output = vsp1->wpf[0]; > pipe->output->pipe = pipe; > + pipe->frame_end = vsp1_du_pipeline_frame_end; > > return 0; > } > diff --git a/drivers/media/platform/vsp1/vsp1_drm.h > b/drivers/media/platform/vsp1/vsp1_drm.h index c8d2f88fc483..3de2095cb0ce > 100644 > --- a/drivers/media/platform/vsp1/vsp1_drm.h > +++ b/drivers/media/platform/vsp1/vsp1_drm.h > @@ -23,6 +23,8 @@ > * @num_inputs: number of active pipeline inputs at the beginning of an > update > * @inputs: source crop rectangle, destination compose rectangle and > z-order > * position for every input > + * @du_complete: frame completion callback for the DU driver (optional) > + * @du_private: data to be passed to the du_complete callback > */ > struct vsp1_drm { > struct vsp1_pipeline pipe; > @@ -33,8 +35,17 @@ struct vsp1_drm { > struct v4l2_rect compose; > unsigned int zpos; > } inputs[VSP1_MAX_RPF]; > + > + /* Frame syncronisation */ s/syncronisation/synchronisation/ > + void (*du_complete)(void *); > + void *du_private; > }; > > +static inline struct vsp1_drm *to_vsp1_drm(struct vsp1_pipeline *pipe) > +{ > + 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 bfc701f04f3f..d59d0adf560d 100644 > --- a/include/media/vsp1.h > +++ b/include/media/vsp1.h > @@ -20,9 +20,22 @@ struct device; > > int vsp1_du_init(struct device *dev); > > +/** > + * struct vsp1_du_lif_config - VSP LIF configuration > + * @width: output frame width > + * @height: output frame height > + * @callback: frame completion callback function (optional) > + * @callback_data: data to be passed to the frame completion callback > + * > + * When the optional callback is provided to the VSP1, the VSP1 must > guarantee > + * that one completion callback is performed after every > vsp1_du_atomic_flush() This paragraph should be part of the @callback documentation. I would phrase it as * @callback: frame completion callback function (optional). When a callback * is provided, the VSP driver guarantees that it will be called * once and only once for each vsp1_du_atomic_flush() call. With this fixed, Reviewed-by: Laurent Pinchart If you're fine with the above changes there's no need to resubmit, I'll fix when applying the patch. > + */ > struct vsp1_du_lif_config { > unsigned int width; > unsigned int height; > + > + void (*callback)(void *); > + void *callback_data; > }; > > int vsp1_du_setup_lif(struct device *dev, const struct vsp1_du_lif_config > *cfg); -- Regards, Laurent Pinchart From mboxrd@z Thu Jan 1 00:00:00 1970 From: Laurent Pinchart Subject: Re: [PATCH v3 2/3] v4l: vsp1: Extend VSP1 module API to allow DRM callbacks Date: Sun, 05 Mar 2017 23:58:33 +0200 Message-ID: <16730350.NvnRv331tg@avalon> References: <200127cf978c8d8904e43ab2b28a225e8a786f6e.1488729419.git-series.kieran.bingham+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 221FA6E2FC for ; Sun, 5 Mar 2017 21:57:59 +0000 (UTC) In-Reply-To: <200127cf978c8d8904e43ab2b28a225e8a786f6e.1488729419.git-series.kieran.bingham+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: 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 SGkgS2llcmFuLAoKVGhhbmsgeW91IGZvciB0aGUgcGF0Y2guCgpPbiBTdW5kYXkgMDUgTWFyIDIw MTcgMTY6MDA6MDMgS2llcmFuIEJpbmdoYW0gd3JvdGU6Cj4gVG8gYmUgYWJsZSB0byBwZXJmb3Jt IHBhZ2UgZmxpcHMgaW4gRFJNIHdpdGhvdXQgZmxpY2tlciB3ZSBuZWVkIHRvIGJlCj4gYWJsZSB0 byBub3RpZnkgdGhlIHJjYXItZHUgbW9kdWxlIHdoZW4gdGhlIFZTUCBoYXMgY29tcGxldGVkIGl0 cwo+IHByb2Nlc3NpbmcuCj4gCj4gV2UgbXVzdCBub3QgaGF2ZSBiaWRpcmVjdGlvbmFsIGRlcGVu ZGVuY2llcyBvbiB0aGUgdHdvIGNvbXBvbmVudHMgdG8KPiBtYWludGFpbiBzdXBwb3J0IGZvciBs b2FkYWJsZSBtb2R1bGVzLCB0aHVzIHdlIGV4dGVuZCB0aGUgQVBJIHRvIGFsbG93Cj4gYSBjYWxs YmFjayB0byBiZSByZWdpc3RlcmVkIHdpdGhpbiB0aGUgVlNQIERSTSBpbnRlcmZhY2UuCj4gCj4g U2lnbmVkLW9mZi1ieTogS2llcmFuIEJpbmdoYW0gPGtpZXJhbi5iaW5naGFtK3JlbmVzYXNAaWRl YXNvbmJvYXJkLmNvbT4KPiAtLS0KPiAgZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFf ZHJtLmMgfCAxNyArKysrKysrKysrKysrKysrKwo+ICBkcml2ZXJzL21lZGlhL3BsYXRmb3JtL3Zz cDEvdnNwMV9kcm0uaCB8IDExICsrKysrKysrKysrCj4gIGluY2x1ZGUvbWVkaWEvdnNwMS5oICAg ICAgICAgICAgICAgICAgIHwgMTMgKysrKysrKysrKysrKwo+ICAzIGZpbGVzIGNoYW5nZWQsIDQx IGluc2VydGlvbnMoKykKPiAKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS9wbGF0Zm9ybS92 c3AxL3ZzcDFfZHJtLmMKPiBiL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX2RybS5j IGluZGV4IDRlZTQzN2M3ZmYwYy4uZDkzYmY3ZDNhMzllCj4gMTAwNjQ0Cj4gLS0tIGEvZHJpdmVy cy9tZWRpYS9wbGF0Zm9ybS92c3AxL3ZzcDFfZHJtLmMKPiArKysgYi9kcml2ZXJzL21lZGlhL3Bs YXRmb3JtL3ZzcDEvdnNwMV9kcm0uYwo+IEBAIC0zNyw2ICszNywxNCBAQCB2b2lkIHZzcDFfZHJt X2Rpc3BsYXlfc3RhcnQoc3RydWN0IHZzcDFfZGV2aWNlICp2c3AxKQo+ICAJdnNwMV9kbG1faXJx X2Rpc3BsYXlfc3RhcnQodnNwMS0+ZHJtLT5waXBlLm91dHB1dC0+ZGxtKTsKPiAgfQo+IAo+ICtz dGF0aWMgdm9pZCB2c3AxX2R1X3BpcGVsaW5lX2ZyYW1lX2VuZChzdHJ1Y3QgdnNwMV9waXBlbGlu ZSAqcGlwZSkKPiArewo+ICsJc3RydWN0IHZzcDFfZHJtICpkcm0gPSB0b192c3AxX2RybShwaXBl KTsKPiArCj4gKwlpZiAoZHJtLT5kdV9jb21wbGV0ZSkKPiArCQlkcm0tPmR1X2NvbXBsZXRlKGRy bS0+ZHVfcHJpdmF0ZSk7Cj4gK30KPiArCj4gIC8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQo+ICAgKiBEVSBE cml2ZXIgQVBJCj4gICAqLwo+IEBAIC05Niw2ICsxMDQsNyBAQCBpbnQgdnNwMV9kdV9zZXR1cF9s aWYoc3RydWN0IGRldmljZSAqZGV2LCBjb25zdCBzdHJ1Y3QKPiB2c3AxX2R1X2xpZl9jb25maWcg KmNmZykgfQo+IAo+ICAJCXBpcGUtPm51bV9pbnB1dHMgPSAwOwo+ICsJCXZzcDEtPmRybS0+ZHVf Y29tcGxldGUgPSBOVUxMOwo+IAo+ICAJCXZzcDFfZGxtX3Jlc2V0KHBpcGUtPm91dHB1dC0+ZGxt KTsKPiAgCQl2c3AxX2RldmljZV9wdXQodnNwMSk7Cj4gQEAgLTIwMCw2ICsyMDksMTMgQEAgaW50 IHZzcDFfZHVfc2V0dXBfbGlmKHN0cnVjdCBkZXZpY2UgKmRldiwgY29uc3Qgc3RydWN0Cj4gdnNw MV9kdV9saWZfY29uZmlnICpjZmcpIGlmIChyZXQgPCAwKQo+ICAJCXJldHVybiByZXQ7Cj4gCj4g KwkvKgo+ICsJICogUmVnaXN0ZXIgYSBjYWxsYmFjayB0byBhbGxvdyB1cyB0byBub3RpZnkgdGhl IERSTSBmcmFtZXdvcmsgb2YgCmZyYW1lCgpzL2ZyYW1ld29yay9kcml2ZXIvCgo+ICsJICogY29t cGxldGlvbiBldmVudHMuCj4gKwkgKi8KPiArCXZzcDEtPmRybS0+ZHVfY29tcGxldGUgPSBjZmct PmNhbGxiYWNrOwo+ICsJdnNwMS0+ZHJtLT5kdV9wcml2YXRlID0gY2ZnLT5jYWxsYmFja19kYXRh Owo+ICsKPiAgCXJldCA9IG1lZGlhX3BpcGVsaW5lX3N0YXJ0KCZwaXBlLT5vdXRwdXQtPmVudGl0 eS5zdWJkZXYuZW50aXR5LAo+ICAJCQkJCSAgJnBpcGUtPnBpcGUpOwo+ICAJaWYgKHJldCA8IDAp IHsKPiBAQCAtNjA3LDYgKzYyMyw3IEBAIGludCB2c3AxX2RybV9pbml0KHN0cnVjdCB2c3AxX2Rl dmljZSAqdnNwMSkKPiAgCXBpcGUtPmxpZiA9ICZ2c3AxLT5saWYtPmVudGl0eTsKPiAgCXBpcGUt Pm91dHB1dCA9IHZzcDEtPndwZlswXTsKPiAgCXBpcGUtPm91dHB1dC0+cGlwZSA9IHBpcGU7Cj4g KwlwaXBlLT5mcmFtZV9lbmQgPSB2c3AxX2R1X3BpcGVsaW5lX2ZyYW1lX2VuZDsKPiAKPiAgCXJl dHVybiAwOwo+ICB9Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92 c3AxX2RybS5oCj4gYi9kcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9kcm0uaCBpbmRl eCBjOGQyZjg4ZmM0ODMuLjNkZTIwOTVjYjBjZQo+IDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvbWVk aWEvcGxhdGZvcm0vdnNwMS92c3AxX2RybS5oCj4gKysrIGIvZHJpdmVycy9tZWRpYS9wbGF0Zm9y bS92c3AxL3ZzcDFfZHJtLmgKPiBAQCAtMjMsNiArMjMsOCBAQAo+ICAgKiBAbnVtX2lucHV0czog bnVtYmVyIG9mIGFjdGl2ZSBwaXBlbGluZSBpbnB1dHMgYXQgdGhlIGJlZ2lubmluZyBvZiBhbgo+ IHVwZGF0ZQo+ICAgKiBAaW5wdXRzOiBzb3VyY2UgY3JvcCByZWN0YW5nbGUsIGRlc3RpbmF0aW9u IGNvbXBvc2UgcmVjdGFuZ2xlIGFuZAo+IHotb3JkZXIKPiAgICoJcG9zaXRpb24gZm9yIGV2ZXJ5 IGlucHV0Cj4gKyAqIEBkdV9jb21wbGV0ZTogZnJhbWUgY29tcGxldGlvbiBjYWxsYmFjayBmb3Ig dGhlIERVIGRyaXZlciAob3B0aW9uYWwpCj4gKyAqIEBkdV9wcml2YXRlOiBkYXRhIHRvIGJlIHBh c3NlZCB0byB0aGUgZHVfY29tcGxldGUgY2FsbGJhY2sKPiAgICovCj4gIHN0cnVjdCB2c3AxX2Ry bSB7Cj4gIAlzdHJ1Y3QgdnNwMV9waXBlbGluZSBwaXBlOwo+IEBAIC0zMyw4ICszNSwxNyBAQCBz dHJ1Y3QgdnNwMV9kcm0gewo+ICAJCXN0cnVjdCB2NGwyX3JlY3QgY29tcG9zZTsKPiAgCQl1bnNp Z25lZCBpbnQgenBvczsKPiAgCX0gaW5wdXRzW1ZTUDFfTUFYX1JQRl07Cj4gKwo+ICsJLyogRnJh bWUgc3luY3JvbmlzYXRpb24gKi8KCnMvc3luY3JvbmlzYXRpb24vc3luY2hyb25pc2F0aW9uLwoK PiArCXZvaWQgKCpkdV9jb21wbGV0ZSkodm9pZCAqKTsKPiArCXZvaWQgKmR1X3ByaXZhdGU7Cj4g IH07Cj4gCj4gK3N0YXRpYyBpbmxpbmUgc3RydWN0IHZzcDFfZHJtICp0b192c3AxX2RybShzdHJ1 Y3QgdnNwMV9waXBlbGluZSAqcGlwZSkKPiArewo+ICsJcmV0dXJuIGNvbnRhaW5lcl9vZihwaXBl LCBzdHJ1Y3QgdnNwMV9kcm0sIHBpcGUpOwo+ICt9Cj4gKwo+ICBpbnQgdnNwMV9kcm1faW5pdChz dHJ1Y3QgdnNwMV9kZXZpY2UgKnZzcDEpOwo+ICB2b2lkIHZzcDFfZHJtX2NsZWFudXAoc3RydWN0 IHZzcDFfZGV2aWNlICp2c3AxKTsKPiAgaW50IHZzcDFfZHJtX2NyZWF0ZV9saW5rcyhzdHJ1Y3Qg dnNwMV9kZXZpY2UgKnZzcDEpOwo+IGRpZmYgLS1naXQgYS9pbmNsdWRlL21lZGlhL3ZzcDEuaCBi L2luY2x1ZGUvbWVkaWEvdnNwMS5oCj4gaW5kZXggYmZjNzAxZjA0ZjNmLi5kNTlkMGFkZjU2MGQg MTAwNjQ0Cj4gLS0tIGEvaW5jbHVkZS9tZWRpYS92c3AxLmgKPiArKysgYi9pbmNsdWRlL21lZGlh L3ZzcDEuaAo+IEBAIC0yMCw5ICsyMCwyMiBAQCBzdHJ1Y3QgZGV2aWNlOwo+IAo+ICBpbnQgdnNw MV9kdV9pbml0KHN0cnVjdCBkZXZpY2UgKmRldik7Cj4gCj4gKy8qKgo+ICsgKiBzdHJ1Y3QgdnNw MV9kdV9saWZfY29uZmlnIC0gVlNQIExJRiBjb25maWd1cmF0aW9uCj4gKyAqIEB3aWR0aDogb3V0 cHV0IGZyYW1lIHdpZHRoCj4gKyAqIEBoZWlnaHQ6IG91dHB1dCBmcmFtZSBoZWlnaHQKPiArICog QGNhbGxiYWNrOiBmcmFtZSBjb21wbGV0aW9uIGNhbGxiYWNrIGZ1bmN0aW9uIChvcHRpb25hbCkK PiArICogQGNhbGxiYWNrX2RhdGE6IGRhdGEgdG8gYmUgcGFzc2VkIHRvIHRoZSBmcmFtZSBjb21w bGV0aW9uIGNhbGxiYWNrCj4gKyAqCj4gKyAqIFdoZW4gdGhlIG9wdGlvbmFsIGNhbGxiYWNrIGlz IHByb3ZpZGVkIHRvIHRoZSBWU1AxLCB0aGUgVlNQMSBtdXN0Cj4gZ3VhcmFudGVlCj4gKyAqIHRo YXQgb25lIGNvbXBsZXRpb24gY2FsbGJhY2sgaXMgcGVyZm9ybWVkIGFmdGVyIGV2ZXJ5Cj4gdnNw MV9kdV9hdG9taWNfZmx1c2goKQoKVGhpcyBwYXJhZ3JhcGggc2hvdWxkIGJlIHBhcnQgb2YgdGhl IEBjYWxsYmFjayBkb2N1bWVudGF0aW9uLiBJIHdvdWxkIHBocmFzZSAKaXQgYXMKCiAqIEBjYWxs YmFjazogZnJhbWUgY29tcGxldGlvbiBjYWxsYmFjayBmdW5jdGlvbiAob3B0aW9uYWwpLiBXaGVu IGEgY2FsbGJhY2sKICoJICAgICAgaXMgcHJvdmlkZWQsIHRoZSBWU1AgZHJpdmVyIGd1YXJhbnRl ZXMgdGhhdCBpdCB3aWxsIGJlIGNhbGxlZAogKgkgICAgICBvbmNlIGFuZCBvbmx5IG9uY2UgZm9y IGVhY2ggdnNwMV9kdV9hdG9taWNfZmx1c2goKSBjYWxsLgoKV2l0aCB0aGlzIGZpeGVkLAoKUmV2 aWV3ZWQtYnk6IExhdXJlbnQgUGluY2hhcnQgPGxhdXJlbnQucGluY2hhcnRAaWRlYXNvbmJvYXJk LmNvbT4KCklmIHlvdSdyZSBmaW5lIHdpdGggdGhlIGFib3ZlIGNoYW5nZXMgdGhlcmUncyBubyBu ZWVkIHRvIHJlc3VibWl0LCBJJ2xsIGZpeCAKd2hlbiBhcHBseWluZyB0aGUgcGF0Y2guCgo+ICsg Ki8KPiAgc3RydWN0IHZzcDFfZHVfbGlmX2NvbmZpZyB7Cj4gIAl1bnNpZ25lZCBpbnQgd2lkdGg7 Cj4gIAl1bnNpZ25lZCBpbnQgaGVpZ2h0Owo+ICsKPiArCXZvaWQgKCpjYWxsYmFjaykodm9pZCAq KTsKPiArCXZvaWQgKmNhbGxiYWNrX2RhdGE7Cj4gIH07Cj4gCj4gIGludCB2c3AxX2R1X3NldHVw X2xpZihzdHJ1Y3QgZGV2aWNlICpkZXYsIGNvbnN0IHN0cnVjdCB2c3AxX2R1X2xpZl9jb25maWcK PiAqY2ZnKTsKCi0tIApSZWdhcmRzLAoKTGF1cmVudCBQaW5jaGFydAoKX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApk cmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Au b3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVsCg==