From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from galahad.ideasonboard.com ([185.26.127.97]:51084 "EHLO galahad.ideasonboard.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1755125AbcHSIje (ORCPT ); Fri, 19 Aug 2016 04:39:34 -0400 From: Laurent Pinchart To: linux-media@vger.kernel.org, dri-devel@lists.freedesktop.org Cc: linux-renesas-soc@vger.kernel.org Subject: [PATCH 0/6] R-Car DU: Fix IOMMU operation when connected to VSP Date: Fri, 19 Aug 2016 11:39:28 +0300 Message-Id: <1471595974-28960-1-git-send-email-laurent.pinchart+renesas@ideasonboard.com> Sender: linux-media-owner@vger.kernel.org List-ID: Hello, This patch series fixes the rcar-du-drm driver to support VSP plane sources with an IOMMU. It is available for convenience at git://linuxtv.org/pinchartl/media.git iommu/devel/du On R-Car Gen3 the DU has no direct memory access but sources planes through VSP instances. When an IOMMU is inserted between the VSP and memory, the DU framebuffers need to be DMA mapped using the VSP device, not the DU device as currently done. The same situation can also be reproduced on Gen2 hardware by linking the VSP to the DU in DT [1], effectively disabling direct memory access by the DU. The situation is made quite complex by the fact that different planes can be connected to different DU instances, and thus served by different IOMMUs (or, in practice on existing hardware, by the same IOMMU but through different micro-TLBs). We thus can't allocate and map buffers to the right device in a single dma_alloc_wc() operation as done in the DRM CMA GEM helpers. However, on such setups, the DU DT node doesn't reference IOMMUs as the DU does not perform any direct memory access. We can thus keep the GEM object allocation unchanged, and the DMA addresses that we receive in the DU driver will be physical addresses. Those buffers then need to be mapped to the VSP device when they are associated with planes. Fortunately the atomic framework provides two plane helper operations, .prepare_fb() and .cleanup_fb() that we can use for this purpose. The reality is slightly more complex than this on Gen3, as an FCP device instance sits between VSP instances and memory. It is the FCP devices that are connected to the IOMMUs, and buffer mapping thus need to be performed using the FCP devices. This isn't required on Gen2 as the platforms don't have any FCPs. Patches 1/6 and 2/6 unconstify the state argument to the .prepare_fb() and .cleanup_fb() operations, to allow storing the mapped buffer addresses in the state. Patches 3/6 and 4/6 then extend the rcar-fcp driver API to expose the FCP struct device. Patch 5/6 extends the vsp1 driver API to allow mapping a scatter-gather list to the VSP, with the implementation using the FCP devices instead when available. Patch 6/6 then use the vsp1 mapping API in the rcar-du-drm driver to map and unmap buffers when needed. The series has been tested on Gen2 (Lager) only as the Gen3 IOMMU is known to be broken. A possible improvement is to modify the GEM object allocation mechanism to use non-contiguous memory when the DU driver detects that all the VSP instances it is connected to use an IOMMU (possibly through FCP devices). An issue has been noticed with synchronization between page flip and VSP operation. Buffers get unmapped (and possibly freed) before the VSP is done reading them. The problem isn't new, but is much more noticeable with IOMMU support enabled as any hardware access to unmapped memory generates an IOMMU page fault immediately. The series unfortunately contain a dependency between DRM and V4L2 patches, complicating upstream merge. As there's no urgency to merge patch 6/6 due to the IOMMU being broken on Gen3 at the moment, I propose merging patches 1/6-2/6 and 3/6-5/6 independently for the next kernel release. I would particularly appreciate feedback on the APIs introduced by patches 4/6 and 5/6. [1] https://www.mail-archive.com/linux-renesas-soc@vger.kernel.org/msg06589.html Laurent Pinchart (6): drm: Don't implement empty prepare_fb()/cleanup_fb() drm: Unconstify state argument to prepare_fb()/cleanup_fb() v4l: rcar-fcp: Don't get/put module reference v4l: rcar-fcp: Add an API to retrieve the FCP device v4l: vsp1: Add API to map and unmap DRM buffers through the VSP drm: rcar-du: Map memory through the VSP device drivers/gpu/drm/arc/arcpgu_crtc.c | 2 - drivers/gpu/drm/atmel-hlcdc/atmel_hlcdc_plane.c | 4 +- drivers/gpu/drm/fsl-dcu/fsl_dcu_drm_plane.c | 15 ----- drivers/gpu/drm/hisilicon/kirin/kirin_drm_ade.c | 15 ----- drivers/gpu/drm/i915/intel_display.c | 4 +- drivers/gpu/drm/i915/intel_drv.h | 4 +- drivers/gpu/drm/msm/mdp/mdp4/mdp4_plane.c | 4 +- drivers/gpu/drm/msm/mdp/mdp5/mdp5_plane.c | 4 +- drivers/gpu/drm/omapdrm/omap_plane.c | 4 +- drivers/gpu/drm/rcar-du/rcar_du_vsp.c | 74 +++++++++++++++++++++++-- drivers/gpu/drm/rcar-du/rcar_du_vsp.h | 2 + drivers/gpu/drm/rockchip/rockchip_drm_vop.c | 4 +- drivers/gpu/drm/tegra/dc.c | 17 ------ drivers/gpu/drm/vc4/vc4_plane.c | 2 - drivers/media/platform/rcar-fcp.c | 17 +++--- drivers/media/platform/vsp1/vsp1_drm.c | 24 ++++++++ include/drm/drm_modeset_helper_vtables.h | 4 +- include/media/rcar-fcp.h | 5 ++ include/media/vsp1.h | 3 + 19 files changed, 126 insertions(+), 82 deletions(-) -- Regards, Laurent Pinchart From mboxrd@z Thu Jan 1 00:00:00 1970 From: Laurent Pinchart Subject: [PATCH 0/6] R-Car DU: Fix IOMMU operation when connected to VSP Date: Fri, 19 Aug 2016 11:39:28 +0300 Message-ID: <1471595974-28960-1-git-send-email-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 1AB0C6EBBA for ; Fri, 19 Aug 2016 08:39:23 +0000 (UTC) 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, dri-devel@lists.freedesktop.org Cc: linux-renesas-soc@vger.kernel.org List-Id: dri-devel@lists.freedesktop.org SGVsbG8sCgpUaGlzIHBhdGNoIHNlcmllcyBmaXhlcyB0aGUgcmNhci1kdS1kcm0gZHJpdmVyIHRv IHN1cHBvcnQgVlNQIHBsYW5lIHNvdXJjZXMKd2l0aCBhbiBJT01NVS4gSXQgaXMgYXZhaWxhYmxl IGZvciBjb252ZW5pZW5jZSBhdAoKCWdpdDovL2xpbnV4dHYub3JnL3BpbmNoYXJ0bC9tZWRpYS5n aXQgaW9tbXUvZGV2ZWwvZHUKCk9uIFItQ2FyIEdlbjMgdGhlIERVIGhhcyBubyBkaXJlY3QgbWVt b3J5IGFjY2VzcyBidXQgc291cmNlcyBwbGFuZXMgdGhyb3VnaApWU1AgaW5zdGFuY2VzLiBXaGVu IGFuIElPTU1VIGlzIGluc2VydGVkIGJldHdlZW4gdGhlIFZTUCBhbmQgbWVtb3J5LCB0aGUgRFUK ZnJhbWVidWZmZXJzIG5lZWQgdG8gYmUgRE1BIG1hcHBlZCB1c2luZyB0aGUgVlNQIGRldmljZSwg bm90IHRoZSBEVSBkZXZpY2UgYXMKY3VycmVudGx5IGRvbmUuIFRoZSBzYW1lIHNpdHVhdGlvbiBj YW4gYWxzbyBiZSByZXByb2R1Y2VkIG9uIEdlbjIgaGFyZHdhcmUgYnkKbGlua2luZyB0aGUgVlNQ IHRvIHRoZSBEVSBpbiBEVCBbMV0sIGVmZmVjdGl2ZWx5IGRpc2FibGluZyBkaXJlY3QgbWVtb3J5 CmFjY2VzcyBieSB0aGUgRFUuCgpUaGUgc2l0dWF0aW9uIGlzIG1hZGUgcXVpdGUgY29tcGxleCBi eSB0aGUgZmFjdCB0aGF0IGRpZmZlcmVudCBwbGFuZXMgY2FuIGJlCmNvbm5lY3RlZCB0byBkaWZm ZXJlbnQgRFUgaW5zdGFuY2VzLCBhbmQgdGh1cyBzZXJ2ZWQgYnkgZGlmZmVyZW50IElPTU1VcyAo b3IsCmluIHByYWN0aWNlIG9uIGV4aXN0aW5nIGhhcmR3YXJlLCBieSB0aGUgc2FtZSBJT01NVSBi dXQgdGhyb3VnaCBkaWZmZXJlbnQKbWljcm8tVExCcykuIFdlIHRodXMgY2FuJ3QgYWxsb2NhdGUg YW5kIG1hcCBidWZmZXJzIHRvIHRoZSByaWdodCBkZXZpY2UgaW4gYQpzaW5nbGUgZG1hX2FsbG9j X3djKCkgb3BlcmF0aW9uIGFzIGRvbmUgaW4gdGhlIERSTSBDTUEgR0VNIGhlbHBlcnMuCgpIb3dl dmVyLCBvbiBzdWNoIHNldHVwcywgdGhlIERVIERUIG5vZGUgZG9lc24ndCByZWZlcmVuY2UgSU9N TVVzIGFzIHRoZSBEVQpkb2VzIG5vdCBwZXJmb3JtIGFueSBkaXJlY3QgbWVtb3J5IGFjY2Vzcy4g V2UgY2FuIHRodXMga2VlcCB0aGUgR0VNIG9iamVjdAphbGxvY2F0aW9uIHVuY2hhbmdlZCwgYW5k IHRoZSBETUEgYWRkcmVzc2VzIHRoYXQgd2UgcmVjZWl2ZSBpbiB0aGUgRFUgZHJpdmVyCndpbGwg YmUgcGh5c2ljYWwgYWRkcmVzc2VzLiBUaG9zZSBidWZmZXJzIHRoZW4gbmVlZCB0byBiZSBtYXBw ZWQgdG8gdGhlIFZTUApkZXZpY2Ugd2hlbiB0aGV5IGFyZSBhc3NvY2lhdGVkIHdpdGggcGxhbmVz LiBGb3J0dW5hdGVseSB0aGUgYXRvbWljIGZyYW1ld29yawpwcm92aWRlcyB0d28gcGxhbmUgaGVs cGVyIG9wZXJhdGlvbnMsIC5wcmVwYXJlX2ZiKCkgYW5kIC5jbGVhbnVwX2ZiKCkgdGhhdCB3ZQpj YW4gdXNlIGZvciB0aGlzIHB1cnBvc2UuCgpUaGUgcmVhbGl0eSBpcyBzbGlnaHRseSBtb3JlIGNv bXBsZXggdGhhbiB0aGlzIG9uIEdlbjMsIGFzIGFuIEZDUCBkZXZpY2UKaW5zdGFuY2Ugc2l0cyBi ZXR3ZWVuIFZTUCBpbnN0YW5jZXMgYW5kIG1lbW9yeS4gSXQgaXMgdGhlIEZDUCBkZXZpY2VzIHRo YXQgYXJlCmNvbm5lY3RlZCB0byB0aGUgSU9NTVVzLCBhbmQgYnVmZmVyIG1hcHBpbmcgdGh1cyBu ZWVkIHRvIGJlIHBlcmZvcm1lZCB1c2luZwp0aGUgRkNQIGRldmljZXMuIFRoaXMgaXNuJ3QgcmVx dWlyZWQgb24gR2VuMiBhcyB0aGUgcGxhdGZvcm1zIGRvbid0IGhhdmUgYW55CkZDUHMuCgpQYXRj aGVzIDEvNiBhbmQgMi82IHVuY29uc3RpZnkgdGhlIHN0YXRlIGFyZ3VtZW50IHRvIHRoZSAucHJl cGFyZV9mYigpIGFuZAouY2xlYW51cF9mYigpIG9wZXJhdGlvbnMsIHRvIGFsbG93IHN0b3Jpbmcg dGhlIG1hcHBlZCBidWZmZXIgYWRkcmVzc2VzIGluIHRoZQpzdGF0ZS4gUGF0Y2hlcyAzLzYgYW5k IDQvNiB0aGVuIGV4dGVuZCB0aGUgcmNhci1mY3AgZHJpdmVyIEFQSSB0byBleHBvc2UgdGhlCkZD UCBzdHJ1Y3QgZGV2aWNlLiBQYXRjaCA1LzYgZXh0ZW5kcyB0aGUgdnNwMSBkcml2ZXIgQVBJIHRv IGFsbG93IG1hcHBpbmcgYQpzY2F0dGVyLWdhdGhlciBsaXN0IHRvIHRoZSBWU1AsIHdpdGggdGhl IGltcGxlbWVudGF0aW9uIHVzaW5nIHRoZSBGQ1AgZGV2aWNlcwppbnN0ZWFkIHdoZW4gYXZhaWxh YmxlLiBQYXRjaCA2LzYgdGhlbiB1c2UgdGhlIHZzcDEgbWFwcGluZyBBUEkgaW4gdGhlCnJjYXIt ZHUtZHJtIGRyaXZlciB0byBtYXAgYW5kIHVubWFwIGJ1ZmZlcnMgd2hlbiBuZWVkZWQuCgpUaGUg c2VyaWVzIGhhcyBiZWVuIHRlc3RlZCBvbiBHZW4yIChMYWdlcikgb25seSBhcyB0aGUgR2VuMyBJ T01NVSBpcyBrbm93biB0bwpiZSBicm9rZW4uCgpBIHBvc3NpYmxlIGltcHJvdmVtZW50IGlzIHRv IG1vZGlmeSB0aGUgR0VNIG9iamVjdCBhbGxvY2F0aW9uIG1lY2hhbmlzbSB0byB1c2UKbm9uLWNv bnRpZ3VvdXMgbWVtb3J5IHdoZW4gdGhlIERVIGRyaXZlciBkZXRlY3RzIHRoYXQgYWxsIHRoZSBW U1AgaW5zdGFuY2VzIGl0CmlzIGNvbm5lY3RlZCB0byB1c2UgYW4gSU9NTVUgKHBvc3NpYmx5IHRo cm91Z2ggRkNQIGRldmljZXMpLgoKQW4gaXNzdWUgaGFzIGJlZW4gbm90aWNlZCB3aXRoIHN5bmNo cm9uaXphdGlvbiBiZXR3ZWVuIHBhZ2UgZmxpcCBhbmQgVlNQCm9wZXJhdGlvbi4gQnVmZmVycyBn ZXQgdW5tYXBwZWQgKGFuZCBwb3NzaWJseSBmcmVlZCkgYmVmb3JlIHRoZSBWU1AgaXMgZG9uZQpy ZWFkaW5nIHRoZW0uIFRoZSBwcm9ibGVtIGlzbid0IG5ldywgYnV0IGlzIG11Y2ggbW9yZSBub3Rp Y2VhYmxlIHdpdGggSU9NTVUKc3VwcG9ydCBlbmFibGVkIGFzIGFueSBoYXJkd2FyZSBhY2Nlc3Mg dG8gdW5tYXBwZWQgbWVtb3J5IGdlbmVyYXRlcyBhbiBJT01NVQpwYWdlIGZhdWx0IGltbWVkaWF0 ZWx5LgoKVGhlIHNlcmllcyB1bmZvcnR1bmF0ZWx5IGNvbnRhaW4gYSBkZXBlbmRlbmN5IGJldHdl ZW4gRFJNIGFuZCBWNEwyIHBhdGNoZXMsCmNvbXBsaWNhdGluZyB1cHN0cmVhbSBtZXJnZS4gQXMg dGhlcmUncyBubyB1cmdlbmN5IHRvIG1lcmdlIHBhdGNoIDYvNiBkdWUgdG8KdGhlIElPTU1VIGJl aW5nIGJyb2tlbiBvbiBHZW4zIGF0IHRoZSBtb21lbnQsIEkgcHJvcG9zZSBtZXJnaW5nIHBhdGNo ZXMKMS82LTIvNiBhbmQgMy82LTUvNiBpbmRlcGVuZGVudGx5IGZvciB0aGUgbmV4dCBrZXJuZWwg cmVsZWFzZS4KCkkgd291bGQgcGFydGljdWxhcmx5IGFwcHJlY2lhdGUgZmVlZGJhY2sgb24gdGhl IEFQSXMgaW50cm9kdWNlZCBieSBwYXRjaGVzIDQvNgphbmQgNS82LgoKWzFdIGh0dHBzOi8vd3d3 Lm1haWwtYXJjaGl2ZS5jb20vbGludXgtcmVuZXNhcy1zb2NAdmdlci5rZXJuZWwub3JnL21zZzA2 NTg5Lmh0bWwKCkxhdXJlbnQgUGluY2hhcnQgKDYpOgogIGRybTogRG9uJ3QgaW1wbGVtZW50IGVt cHR5IHByZXBhcmVfZmIoKS9jbGVhbnVwX2ZiKCkKICBkcm06IFVuY29uc3RpZnkgc3RhdGUgYXJn dW1lbnQgdG8gcHJlcGFyZV9mYigpL2NsZWFudXBfZmIoKQogIHY0bDogcmNhci1mY3A6IERvbid0 IGdldC9wdXQgbW9kdWxlIHJlZmVyZW5jZQogIHY0bDogcmNhci1mY3A6IEFkZCBhbiBBUEkgdG8g cmV0cmlldmUgdGhlIEZDUCBkZXZpY2UKICB2NGw6IHZzcDE6IEFkZCBBUEkgdG8gbWFwIGFuZCB1 bm1hcCBEUk0gYnVmZmVycyB0aHJvdWdoIHRoZSBWU1AKICBkcm06IHJjYXItZHU6IE1hcCBtZW1v cnkgdGhyb3VnaCB0aGUgVlNQIGRldmljZQoKIGRyaXZlcnMvZ3B1L2RybS9hcmMvYXJjcGd1X2Ny dGMuYyAgICAgICAgICAgICAgIHwgIDIgLQogZHJpdmVycy9ncHUvZHJtL2F0bWVsLWhsY2RjL2F0 bWVsX2hsY2RjX3BsYW5lLmMgfCAgNCArLQogZHJpdmVycy9ncHUvZHJtL2ZzbC1kY3UvZnNsX2Rj dV9kcm1fcGxhbmUuYyAgICAgfCAxNSAtLS0tLQogZHJpdmVycy9ncHUvZHJtL2hpc2lsaWNvbi9r aXJpbi9raXJpbl9kcm1fYWRlLmMgfCAxNSAtLS0tLQogZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50 ZWxfZGlzcGxheS5jICAgICAgICAgICAgfCAgNCArLQogZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50 ZWxfZHJ2LmggICAgICAgICAgICAgICAgfCAgNCArLQogZHJpdmVycy9ncHUvZHJtL21zbS9tZHAv bWRwNC9tZHA0X3BsYW5lLmMgICAgICAgfCAgNCArLQogZHJpdmVycy9ncHUvZHJtL21zbS9tZHAv bWRwNS9tZHA1X3BsYW5lLmMgICAgICAgfCAgNCArLQogZHJpdmVycy9ncHUvZHJtL29tYXBkcm0v b21hcF9wbGFuZS5jICAgICAgICAgICAgfCAgNCArLQogZHJpdmVycy9ncHUvZHJtL3JjYXItZHUv cmNhcl9kdV92c3AuYyAgICAgICAgICAgfCA3NCArKysrKysrKysrKysrKysrKysrKysrKy0tCiBk cml2ZXJzL2dwdS9kcm0vcmNhci1kdS9yY2FyX2R1X3ZzcC5oICAgICAgICAgICB8ICAyICsKIGRy aXZlcnMvZ3B1L2RybS9yb2NrY2hpcC9yb2NrY2hpcF9kcm1fdm9wLmMgICAgIHwgIDQgKy0KIGRy aXZlcnMvZ3B1L2RybS90ZWdyYS9kYy5jICAgICAgICAgICAgICAgICAgICAgIHwgMTcgLS0tLS0t CiBkcml2ZXJzL2dwdS9kcm0vdmM0L3ZjNF9wbGFuZS5jICAgICAgICAgICAgICAgICB8ICAyIC0K IGRyaXZlcnMvbWVkaWEvcGxhdGZvcm0vcmNhci1mY3AuYyAgICAgICAgICAgICAgIHwgMTcgKysr LS0tCiBkcml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9kcm0uYyAgICAgICAgICB8IDI0 ICsrKysrKysrCiBpbmNsdWRlL2RybS9kcm1fbW9kZXNldF9oZWxwZXJfdnRhYmxlcy5oICAgICAg ICB8ICA0ICstCiBpbmNsdWRlL21lZGlhL3JjYXItZmNwLmggICAgICAgICAgICAgICAgICAgICAg ICB8ICA1ICsrCiBpbmNsdWRlL21lZGlhL3ZzcDEuaCAgICAgICAgICAgICAgICAgICAgICAgICAg ICB8ICAzICsKIDE5IGZpbGVzIGNoYW5nZWQsIDEyNiBpbnNlcnRpb25zKCspLCA4MiBkZWxldGlv bnMoLSkKCi0tIApSZWdhcmRzLAoKTGF1cmVudCBQaW5jaGFydAoKX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmkt ZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3Jn L21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVsCg==