From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from galahad.ideasonboard.com ([185.26.127.97]:38809 "EHLO galahad.ideasonboard.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1759302AbdENRBS (ORCPT ); Sun, 14 May 2017 13:01:18 -0400 From: Laurent Pinchart To: Magnus Damm Cc: Laurent Pinchart , Linux Media Mailing List , dri-devel@lists.freedesktop.org, Linux-Renesas Subject: Re: [PATCH 0/6] R-Car DU: Fix IOMMU operation when connected to VSP Date: Sun, 14 May 2017 20:01:18 +0300 Message-ID: <1655138.Hl7EZz7Q96@avalon> In-Reply-To: References: <1471595974-28960-1-git-send-email-laurent.pinchart+renesas@ideasonboard.com> MIME-Version: 1.0 Content-Transfer-Encoding: 7Bit Content-Type: text/plain; charset="us-ascii" Sender: linux-media-owner@vger.kernel.org List-ID: Hi Magnus, On Wednesday 07 Sep 2016 17:01:06 Magnus Damm wrote: > Hi Laurent, > > Thanks for your help with this. Good to see that the DU driver is > getting closer to work with the IPMMU hardware! Please see below for > some feedback from me. > > On Fri, Aug 19, 2016 at 5:39 PM, Laurent Pinchart wrote: > > 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. > > Slight clarification, the R-Car Gen3 family as a whole does not have > broken IPMMU hardware. Early R-Car H3 revisions do require some errata > handling though, but M3-W and later ES versions and MP of H3 will be > fine. Given the early R-Car H3 errata I agree it makes sense to > develop and test this series on R-Car Gen2 though. > > > 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. > > The code in general looks fine to me. The APIs introduced by patches > 4/6 and 5/6 seem quite straightforward. Is there something I can do to > help with those? > > > [1] > > https://www.mail-archive.com/linux-renesas-soc@vger.kernel.org/msg06589.h > > tml > > 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(-) > > So I've spent some time to test this series on R-Car H3. In particular > I've tested the code in renesas-drivers-2016-08-23-v4.8-rc3. > > Since I did some early prototyping to enable the DU with IPMMU myself > I noticed that some further changes may be needed. For instance, the > Display List code and VB2 queue both need a struct device from > somewhere. I propose something like the below, using the API from > patch 4/6 in this series: > > --- 0001/drivers/media/platform/vsp1/vsp1_dl.c > +++ work/drivers/media/platform/vsp1/vsp1_dl.c 2016-09-01 > 06:18:17.140607110 +0900 > @@ -17,6 +17,8 @@ > #include > #include > > +#include > + > #include "vsp1.h" > #include "vsp1_dl.h" > > @@ -130,12 +132,12 @@ static int vsp1_dl_body_init(struct vsp1 > size_t extra_size) > { > size_t size = num_entries * sizeof(*dlb->entries) + extra_size; > + struct device *fcp = rcar_fcp_get_device(vsp1->fcp); > > dlb->vsp1 = vsp1; > dlb->size = size; > - > - dlb->entries = dma_alloc_wc(vsp1->dev, dlb->size, &dlb->dma, > - GFP_KERNEL); > + dlb->entries = dma_alloc_wc(fcp ? fcp : vsp1->dev, > + dlb->size, &dlb->dma, GFP_KERNEL); > if (!dlb->entries) > return -ENOMEM; > > @@ -147,7 +149,10 @@ static int vsp1_dl_body_init(struct vsp1 > */ > static void vsp1_dl_body_cleanup(struct vsp1_dl_body *dlb) > { > - dma_free_wc(dlb->vsp1->dev, dlb->size, dlb->entries, dlb->dma); > + struct device *fcp = rcar_fcp_get_device(dlb->vsp1->fcp); > + > + dma_free_wc(fcp ? fcp : dlb->vsp1->dev, > + dlb->size, dlb->entries, dlb->dma); > } > > /** > --- 0001/drivers/media/platform/vsp1/vsp1_video.c > +++ work/drivers/media/platform/vsp1/vsp1_video.c 2016-09-01 > 06:20:02.940607110 +0900 > @@ -27,6 +27,8 @@ > #include > #include > > +#include > + > #include "vsp1.h" > #include "vsp1_bru.h" > #include "vsp1_dl.h" > @@ -939,6 +941,7 @@ struct vsp1_video *vsp1_video_create(str > { > struct vsp1_video *video; > const char *direction; > + struct device *fcp; > int ret; > > video = devm_kzalloc(vsp1->dev, sizeof(*video), GFP_KERNEL); > @@ -996,7 +999,8 @@ struct vsp1_video *vsp1_video_create(str > video->queue.ops = &vsp1_video_queue_qops; > video->queue.mem_ops = &vb2_dma_contig_memops; > video->queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_COPY; > - video->queue.dev = video->vsp1->dev; > + fcp = rcar_fcp_get_device(vsp1->fcp); > + video->queue.dev = fcp ? fcp : video->vsp1->dev; > ret = vb2_queue_init(&video->queue); > if (ret < 0) { > dev_err(video->vsp1->dev, "failed to initialize vb2 queue\n"); > > Can you please consider to include or rework the above code in your > next version of this series? > > Not sure if R-Car Gen2 is affected or not, but without the above code > I get the following trap during boot on r8a7795 Salvator-X: > > ipmmu-vmsa febd0000.mmu: Unhandled faut: status 0x00000101 iova 0x7f09a000 I'm finally getting back to this. I'll include a modified version of the above code in the next version of the series and will make sure to test it on both Gen2 and Gen3 systems with and without the IOMMU enabled. Unless you'd prefer otherwise, I'll mark you as the author of the code. Can I get your SoB ? -- Regards, Laurent Pinchart From mboxrd@z Thu Jan 1 00:00:00 1970 From: Laurent Pinchart Subject: Re: [PATCH 0/6] R-Car DU: Fix IOMMU operation when connected to VSP Date: Sun, 14 May 2017 20:01:18 +0300 Message-ID: <1655138.Hl7EZz7Q96@avalon> References: <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 67B0689DA2 for ; Sun, 14 May 2017 17:01:17 +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: Magnus Damm Cc: Linux-Renesas , Laurent Pinchart , dri-devel@lists.freedesktop.org, Linux Media Mailing List List-Id: dri-devel@lists.freedesktop.org SGkgTWFnbnVzLAoKT24gV2VkbmVzZGF5IDA3IFNlcCAyMDE2IDE3OjAxOjA2IE1hZ251cyBEYW1t IHdyb3RlOgo+IEhpIExhdXJlbnQsCj4gCj4gVGhhbmtzIGZvciB5b3VyIGhlbHAgd2l0aCB0aGlz LiBHb29kIHRvIHNlZSB0aGF0IHRoZSBEVSBkcml2ZXIgaXMKPiBnZXR0aW5nIGNsb3NlciB0byB3 b3JrIHdpdGggdGhlIElQTU1VIGhhcmR3YXJlISBQbGVhc2Ugc2VlIGJlbG93IGZvcgo+IHNvbWUg ZmVlZGJhY2sgZnJvbSBtZS4KPiAKPiBPbiBGcmksIEF1ZyAxOSwgMjAxNiBhdCA1OjM5IFBNLCBM YXVyZW50IFBpbmNoYXJ0IHdyb3RlOgo+ID4gSGVsbG8sCj4gPiAKPiA+IFRoaXMgcGF0Y2ggc2Vy aWVzIGZpeGVzIHRoZSByY2FyLWR1LWRybSBkcml2ZXIgdG8gc3VwcG9ydCBWU1AgcGxhbmUKPiA+ IHNvdXJjZXMgd2l0aCBhbiBJT01NVS4gSXQgaXMgYXZhaWxhYmxlIGZvciBjb252ZW5pZW5jZSBh dAo+ID4gCj4gPiAgICAgICAgIGdpdDovL2xpbnV4dHYub3JnL3BpbmNoYXJ0bC9tZWRpYS5naXQg aW9tbXUvZGV2ZWwvZHUKPiA+IAo+ID4gT24gUi1DYXIgR2VuMyB0aGUgRFUgaGFzIG5vIGRpcmVj dCBtZW1vcnkgYWNjZXNzIGJ1dCBzb3VyY2VzIHBsYW5lcwo+ID4gdGhyb3VnaCBWU1AgaW5zdGFu Y2VzLiBXaGVuIGFuIElPTU1VIGlzIGluc2VydGVkIGJldHdlZW4gdGhlIFZTUCBhbmQKPiA+IG1l bW9yeSwgdGhlIERVIGZyYW1lYnVmZmVycyBuZWVkIHRvIGJlIERNQSBtYXBwZWQgdXNpbmcgdGhl IFZTUCBkZXZpY2UsCj4gPiBub3QgdGhlIERVIGRldmljZSBhcyBjdXJyZW50bHkgZG9uZS4gVGhl IHNhbWUgc2l0dWF0aW9uIGNhbiBhbHNvIGJlCj4gPiByZXByb2R1Y2VkIG9uIEdlbjIgaGFyZHdh cmUgYnkgbGlua2luZyB0aGUgVlNQIHRvIHRoZSBEVSBpbiBEVCBbMV0sCj4gPiBlZmZlY3RpdmVs eSBkaXNhYmxpbmcgZGlyZWN0IG1lbW9yeSBhY2Nlc3MgYnkgdGhlIERVLgo+ID4gCj4gPiBUaGUg c2l0dWF0aW9uIGlzIG1hZGUgcXVpdGUgY29tcGxleCBieSB0aGUgZmFjdCB0aGF0IGRpZmZlcmVu dCBwbGFuZXMgY2FuCj4gPiBiZSBjb25uZWN0ZWQgdG8gZGlmZmVyZW50IERVIGluc3RhbmNlcywg YW5kIHRodXMgc2VydmVkIGJ5IGRpZmZlcmVudAo+ID4gSU9NTVVzIChvciwgaW4gcHJhY3RpY2Ug b24gZXhpc3RpbmcgaGFyZHdhcmUsIGJ5IHRoZSBzYW1lIElPTU1VIGJ1dAo+ID4gdGhyb3VnaCBk aWZmZXJlbnQgbWljcm8tVExCcykuIFdlIHRodXMgY2FuJ3QgYWxsb2NhdGUgYW5kIG1hcCBidWZm ZXJzIHRvCj4gPiB0aGUgcmlnaHQgZGV2aWNlIGluIGEgc2luZ2xlIGRtYV9hbGxvY193YygpIG9w ZXJhdGlvbiBhcyBkb25lIGluIHRoZSBEUk0KPiA+IENNQSBHRU0gaGVscGVycy4KPiA+IAo+ID4g SG93ZXZlciwgb24gc3VjaCBzZXR1cHMsIHRoZSBEVSBEVCBub2RlIGRvZXNuJ3QgcmVmZXJlbmNl IElPTU1VcyBhcyB0aGUgRFUKPiA+IGRvZXMgbm90IHBlcmZvcm0gYW55IGRpcmVjdCBtZW1vcnkg YWNjZXNzLiBXZSBjYW4gdGh1cyBrZWVwIHRoZSBHRU0gb2JqZWN0Cj4gPiBhbGxvY2F0aW9uIHVu Y2hhbmdlZCwgYW5kIHRoZSBETUEgYWRkcmVzc2VzIHRoYXQgd2UgcmVjZWl2ZSBpbiB0aGUgRFUK PiA+IGRyaXZlciB3aWxsIGJlIHBoeXNpY2FsIGFkZHJlc3Nlcy4gVGhvc2UgYnVmZmVycyB0aGVu IG5lZWQgdG8gYmUgbWFwcGVkCj4gPiB0byB0aGUgVlNQIGRldmljZSB3aGVuIHRoZXkgYXJlIGFz c29jaWF0ZWQgd2l0aCBwbGFuZXMuIEZvcnR1bmF0ZWx5IHRoZQo+ID4gYXRvbWljIGZyYW1ld29y ayBwcm92aWRlcyB0d28gcGxhbmUgaGVscGVyIG9wZXJhdGlvbnMsIC5wcmVwYXJlX2ZiKCkgYW5k Cj4gPiAuY2xlYW51cF9mYigpIHRoYXQgd2UgY2FuIHVzZSBmb3IgdGhpcyBwdXJwb3NlLgo+ID4g Cj4gPiBUaGUgcmVhbGl0eSBpcyBzbGlnaHRseSBtb3JlIGNvbXBsZXggdGhhbiB0aGlzIG9uIEdl bjMsIGFzIGFuIEZDUCBkZXZpY2UKPiA+IGluc3RhbmNlIHNpdHMgYmV0d2VlbiBWU1AgaW5zdGFu Y2VzIGFuZCBtZW1vcnkuIEl0IGlzIHRoZSBGQ1AgZGV2aWNlcyB0aGF0Cj4gPiBhcmUgY29ubmVj dGVkIHRvIHRoZSBJT01NVXMsIGFuZCBidWZmZXIgbWFwcGluZyB0aHVzIG5lZWQgdG8gYmUgcGVy Zm9ybWVkCj4gPiB1c2luZyB0aGUgRkNQIGRldmljZXMuIFRoaXMgaXNuJ3QgcmVxdWlyZWQgb24g R2VuMiBhcyB0aGUgcGxhdGZvcm1zIGRvbid0Cj4gPiBoYXZlIGFueSBGQ1BzLgo+ID4gCj4gPiBQ YXRjaGVzIDEvNiBhbmQgMi82IHVuY29uc3RpZnkgdGhlIHN0YXRlIGFyZ3VtZW50IHRvIHRoZSAu cHJlcGFyZV9mYigpIGFuZAo+ID4gLmNsZWFudXBfZmIoKSBvcGVyYXRpb25zLCB0byBhbGxvdyBz dG9yaW5nIHRoZSBtYXBwZWQgYnVmZmVyIGFkZHJlc3NlcyBpbgo+ID4gdGhlIHN0YXRlLiBQYXRj aGVzIDMvNiBhbmQgNC82IHRoZW4gZXh0ZW5kIHRoZSByY2FyLWZjcCBkcml2ZXIgQVBJIHRvCj4g PiBleHBvc2UgdGhlIEZDUCBzdHJ1Y3QgZGV2aWNlLiBQYXRjaCA1LzYgZXh0ZW5kcyB0aGUgdnNw MSBkcml2ZXIgQVBJIHRvCj4gPiBhbGxvdyBtYXBwaW5nIGEgc2NhdHRlci1nYXRoZXIgbGlzdCB0 byB0aGUgVlNQLCB3aXRoIHRoZSBpbXBsZW1lbnRhdGlvbgo+ID4gdXNpbmcgdGhlIEZDUCBkZXZp Y2VzIGluc3RlYWQgd2hlbiBhdmFpbGFibGUuIFBhdGNoIDYvNiB0aGVuIHVzZSB0aGUgdnNwMQo+ ID4gbWFwcGluZyBBUEkgaW4gdGhlIHJjYXItZHUtZHJtIGRyaXZlciB0byBtYXAgYW5kIHVubWFw IGJ1ZmZlcnMgd2hlbgo+ID4gbmVlZGVkLgo+ID4gCj4gPiBUaGUgc2VyaWVzIGhhcyBiZWVuIHRl c3RlZCBvbiBHZW4yIChMYWdlcikgb25seSBhcyB0aGUgR2VuMyBJT01NVSBpcyBrbm93bgo+ID4g dG8gYmUgYnJva2VuLgo+IAo+IFNsaWdodCBjbGFyaWZpY2F0aW9uLCB0aGUgUi1DYXIgR2VuMyBm YW1pbHkgYXMgYSB3aG9sZSBkb2VzIG5vdCBoYXZlCj4gYnJva2VuIElQTU1VIGhhcmR3YXJlLiBF YXJseSBSLUNhciBIMyByZXZpc2lvbnMgZG8gcmVxdWlyZSBzb21lIGVycmF0YQo+IGhhbmRsaW5n IHRob3VnaCwgYnV0IE0zLVcgYW5kIGxhdGVyIEVTIHZlcnNpb25zIGFuZCBNUCBvZiBIMyB3aWxs IGJlCj4gZmluZS4gR2l2ZW4gdGhlIGVhcmx5IFItQ2FyIEgzIGVycmF0YSBJIGFncmVlIGl0IG1h a2VzIHNlbnNlIHRvCj4gZGV2ZWxvcCBhbmQgdGVzdCB0aGlzIHNlcmllcyBvbiBSLUNhciBHZW4y IHRob3VnaC4KPiAKPiA+IEEgcG9zc2libGUgaW1wcm92ZW1lbnQgaXMgdG8gbW9kaWZ5IHRoZSBH RU0gb2JqZWN0IGFsbG9jYXRpb24gbWVjaGFuaXNtIHRvCj4gPiB1c2Ugbm9uLWNvbnRpZ3VvdXMg bWVtb3J5IHdoZW4gdGhlIERVIGRyaXZlciBkZXRlY3RzIHRoYXQgYWxsIHRoZSBWU1AKPiA+IGlu c3RhbmNlcyBpdCBpcyBjb25uZWN0ZWQgdG8gdXNlIGFuIElPTU1VIChwb3NzaWJseSB0aHJvdWdo IEZDUCBkZXZpY2VzKS4KPiA+IAo+ID4gQW4gaXNzdWUgaGFzIGJlZW4gbm90aWNlZCB3aXRoIHN5 bmNocm9uaXphdGlvbiBiZXR3ZWVuIHBhZ2UgZmxpcCBhbmQgVlNQCj4gPiBvcGVyYXRpb24uIEJ1 ZmZlcnMgZ2V0IHVubWFwcGVkIChhbmQgcG9zc2libHkgZnJlZWQpIGJlZm9yZSB0aGUgVlNQIGlz Cj4gPiBkb25lIHJlYWRpbmcgdGhlbS4gVGhlIHByb2JsZW0gaXNuJ3QgbmV3LCBidXQgaXMgbXVj aCBtb3JlIG5vdGljZWFibGUgd2l0aAo+ID4gSU9NTVUgc3VwcG9ydCBlbmFibGVkIGFzIGFueSBo YXJkd2FyZSBhY2Nlc3MgdG8gdW5tYXBwZWQgbWVtb3J5IGdlbmVyYXRlcwo+ID4gYW4gSU9NTVUg cGFnZSBmYXVsdCBpbW1lZGlhdGVseS4KPiA+IAo+ID4gVGhlIHNlcmllcyB1bmZvcnR1bmF0ZWx5 IGNvbnRhaW4gYSBkZXBlbmRlbmN5IGJldHdlZW4gRFJNIGFuZCBWNEwyCj4gPiBwYXRjaGVzLCBj b21wbGljYXRpbmcgdXBzdHJlYW0gbWVyZ2UuIEFzIHRoZXJlJ3Mgbm8gdXJnZW5jeSB0byBtZXJn ZSBwYXRjaAo+ID4gNi82IGR1ZSB0byB0aGUgSU9NTVUgYmVpbmcgYnJva2VuIG9uIEdlbjMgYXQg dGhlIG1vbWVudCwgSSBwcm9wb3NlIG1lcmdpbmcKPiA+IHBhdGNoZXMgMS82LTIvNiBhbmQgMy82 LTUvNiBpbmRlcGVuZGVudGx5IGZvciB0aGUgbmV4dCBrZXJuZWwgcmVsZWFzZS4KPiA+IAo+ID4g SSB3b3VsZCBwYXJ0aWN1bGFybHkgYXBwcmVjaWF0ZSBmZWVkYmFjayBvbiB0aGUgQVBJcyBpbnRy b2R1Y2VkIGJ5IHBhdGNoZXMKPiA+IDQvNiBhbmQgNS82Lgo+IAo+IFRoZSBjb2RlIGluIGdlbmVy YWwgbG9va3MgZmluZSB0byBtZS4gVGhlIEFQSXMgaW50cm9kdWNlZCBieSBwYXRjaGVzCj4gNC82 IGFuZCA1LzYgc2VlbSBxdWl0ZSBzdHJhaWdodGZvcndhcmQuIElzIHRoZXJlIHNvbWV0aGluZyBJ IGNhbiBkbyB0bwo+IGhlbHAgd2l0aCB0aG9zZT8KPiAKPiA+IFsxXQo+ID4gaHR0cHM6Ly93d3cu bWFpbC1hcmNoaXZlLmNvbS9saW51eC1yZW5lc2FzLXNvY0B2Z2VyLmtlcm5lbC5vcmcvbXNnMDY1 ODkuaAo+ID4gdG1sCj4gPiBMYXVyZW50IFBpbmNoYXJ0ICg2KToKPiA+ICAgZHJtOiBEb24ndCBp bXBsZW1lbnQgZW1wdHkgcHJlcGFyZV9mYigpL2NsZWFudXBfZmIoKQo+ID4gICBkcm06IFVuY29u c3RpZnkgc3RhdGUgYXJndW1lbnQgdG8gcHJlcGFyZV9mYigpL2NsZWFudXBfZmIoKQo+ID4gICB2 NGw6IHJjYXItZmNwOiBEb24ndCBnZXQvcHV0IG1vZHVsZSByZWZlcmVuY2UKPiA+ICAgdjRsOiBy Y2FyLWZjcDogQWRkIGFuIEFQSSB0byByZXRyaWV2ZSB0aGUgRkNQIGRldmljZQo+ID4gICB2NGw6 IHZzcDE6IEFkZCBBUEkgdG8gbWFwIGFuZCB1bm1hcCBEUk0gYnVmZmVycyB0aHJvdWdoIHRoZSBW U1AKPiA+ICAgZHJtOiByY2FyLWR1OiBNYXAgbWVtb3J5IHRocm91Z2ggdGhlIFZTUCBkZXZpY2UK PiA+ICAKPiA+ICBkcml2ZXJzL2dwdS9kcm0vYXJjL2FyY3BndV9jcnRjLmMgICAgICAgICAgICAg ICB8ICAyIC0KPiA+ICBkcml2ZXJzL2dwdS9kcm0vYXRtZWwtaGxjZGMvYXRtZWxfaGxjZGNfcGxh bmUuYyB8ICA0ICstCj4gPiAgZHJpdmVycy9ncHUvZHJtL2ZzbC1kY3UvZnNsX2RjdV9kcm1fcGxh bmUuYyAgICAgfCAxNSAtLS0tLQo+ID4gIGRyaXZlcnMvZ3B1L2RybS9oaXNpbGljb24va2lyaW4v a2lyaW5fZHJtX2FkZS5jIHwgMTUgLS0tLS0KPiA+ICBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRl bF9kaXNwbGF5LmMgICAgICAgICAgICB8ICA0ICstCj4gPiAgZHJpdmVycy9ncHUvZHJtL2k5MTUv aW50ZWxfZHJ2LmggICAgICAgICAgICAgICAgfCAgNCArLQo+ID4gIGRyaXZlcnMvZ3B1L2RybS9t c20vbWRwL21kcDQvbWRwNF9wbGFuZS5jICAgICAgIHwgIDQgKy0KPiA+ICBkcml2ZXJzL2dwdS9k cm0vbXNtL21kcC9tZHA1L21kcDVfcGxhbmUuYyAgICAgICB8ICA0ICstCj4gPiAgZHJpdmVycy9n cHUvZHJtL29tYXBkcm0vb21hcF9wbGFuZS5jICAgICAgICAgICAgfCAgNCArLQo+ID4gIGRyaXZl cnMvZ3B1L2RybS9yY2FyLWR1L3JjYXJfZHVfdnNwLmMgICAgICAgICAgIHwgNzQgKysrKysrKysr KysrKysrKysrLS0KPiA+ICBkcml2ZXJzL2dwdS9kcm0vcmNhci1kdS9yY2FyX2R1X3ZzcC5oICAg ICAgICAgICB8ICAyICsKPiA+ICBkcml2ZXJzL2dwdS9kcm0vcm9ja2NoaXAvcm9ja2NoaXBfZHJt X3ZvcC5jICAgICB8ICA0ICstCj4gPiAgZHJpdmVycy9ncHUvZHJtL3RlZ3JhL2RjLmMgICAgICAg ICAgICAgICAgICAgICAgfCAxNyAtLS0tLS0KPiA+ICBkcml2ZXJzL2dwdS9kcm0vdmM0L3ZjNF9w bGFuZS5jICAgICAgICAgICAgICAgICB8ICAyIC0KPiA+ICBkcml2ZXJzL21lZGlhL3BsYXRmb3Jt L3JjYXItZmNwLmMgICAgICAgICAgICAgICB8IDE3ICsrKy0tLQo+ID4gIGRyaXZlcnMvbWVkaWEv cGxhdGZvcm0vdnNwMS92c3AxX2RybS5jICAgICAgICAgIHwgMjQgKysrKysrKysKPiA+ICBpbmNs dWRlL2RybS9kcm1fbW9kZXNldF9oZWxwZXJfdnRhYmxlcy5oICAgICAgICB8ICA0ICstCj4gPiAg aW5jbHVkZS9tZWRpYS9yY2FyLWZjcC5oICAgICAgICAgICAgICAgICAgICAgICAgfCAgNSArKwo+ ID4gIGluY2x1ZGUvbWVkaWEvdnNwMS5oICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgIDMg Kwo+ID4gIDE5IGZpbGVzIGNoYW5nZWQsIDEyNiBpbnNlcnRpb25zKCspLCA4MiBkZWxldGlvbnMo LSkKPiAKPiBTbyBJJ3ZlIHNwZW50IHNvbWUgdGltZSB0byB0ZXN0IHRoaXMgc2VyaWVzIG9uIFIt Q2FyIEgzLiBJbiBwYXJ0aWN1bGFyCj4gSSd2ZSB0ZXN0ZWQgdGhlIGNvZGUgaW4gcmVuZXNhcy1k cml2ZXJzLTIwMTYtMDgtMjMtdjQuOC1yYzMuCj4gCj4gU2luY2UgSSBkaWQgc29tZSBlYXJseSBw cm90b3R5cGluZyB0byBlbmFibGUgdGhlIERVIHdpdGggSVBNTVUgbXlzZWxmCj4gSSBub3RpY2Vk IHRoYXQgc29tZSBmdXJ0aGVyIGNoYW5nZXMgbWF5IGJlIG5lZWRlZC4gRm9yIGluc3RhbmNlLCB0 aGUKPiBEaXNwbGF5IExpc3QgY29kZSBhbmQgVkIyIHF1ZXVlIGJvdGggbmVlZCBhIHN0cnVjdCBk ZXZpY2UgZnJvbQo+IHNvbWV3aGVyZS4gSSBwcm9wb3NlIHNvbWV0aGluZyBsaWtlIHRoZSBiZWxv dywgdXNpbmcgdGhlIEFQSSBmcm9tCj4gcGF0Y2ggNC82IGluIHRoaXMgc2VyaWVzOgo+IAo+IC0t LSAwMDAxL2RyaXZlcnMvbWVkaWEvcGxhdGZvcm0vdnNwMS92c3AxX2RsLmMKPiArKysgd29yay9k cml2ZXJzL21lZGlhL3BsYXRmb3JtL3ZzcDEvdnNwMV9kbC5jIDIwMTYtMDktMDEKPiAwNjoxODox Ny4xNDA2MDcxMTAgKzA5MDAKPiBAQCAtMTcsNiArMTcsOCBAQAo+ICAjaW5jbHVkZSA8bGludXgv c2xhYi5oPgo+ICAjaW5jbHVkZSA8bGludXgvd29ya3F1ZXVlLmg+Cj4gCj4gKyNpbmNsdWRlIDxt ZWRpYS9yY2FyLWZjcC5oPgo+ICsKPiAgI2luY2x1ZGUgInZzcDEuaCIKPiAgI2luY2x1ZGUgInZz cDFfZGwuaCIKPiAKPiBAQCAtMTMwLDEyICsxMzIsMTIgQEAgc3RhdGljIGludCB2c3AxX2RsX2Jv ZHlfaW5pdChzdHJ1Y3QgdnNwMQo+ICAgICAgIHNpemVfdCBleHRyYV9zaXplKQo+ICB7Cj4gICBz aXplX3Qgc2l6ZSA9IG51bV9lbnRyaWVzICogc2l6ZW9mKCpkbGItPmVudHJpZXMpICsgZXh0cmFf c2l6ZTsKPiArIHN0cnVjdCBkZXZpY2UgKmZjcCA9IHJjYXJfZmNwX2dldF9kZXZpY2UodnNwMS0+ ZmNwKTsKPiAKPiAgIGRsYi0+dnNwMSA9IHZzcDE7Cj4gICBkbGItPnNpemUgPSBzaXplOwo+IC0K PiAtIGRsYi0+ZW50cmllcyA9IGRtYV9hbGxvY193Yyh2c3AxLT5kZXYsIGRsYi0+c2l6ZSwgJmRs Yi0+ZG1hLAo+IC0gICAgR0ZQX0tFUk5FTCk7Cj4gKyBkbGItPmVudHJpZXMgPSBkbWFfYWxsb2Nf d2MoZmNwID8gZmNwIDogdnNwMS0+ZGV2LAo+ICsgICAgZGxiLT5zaXplLCAmZGxiLT5kbWEsIEdG UF9LRVJORUwpOwo+ICAgaWYgKCFkbGItPmVudHJpZXMpCj4gICByZXR1cm4gLUVOT01FTTsKPiAK PiBAQCAtMTQ3LDcgKzE0OSwxMCBAQCBzdGF0aWMgaW50IHZzcDFfZGxfYm9keV9pbml0KHN0cnVj dCB2c3AxCj4gICAqLwo+ICBzdGF0aWMgdm9pZCB2c3AxX2RsX2JvZHlfY2xlYW51cChzdHJ1Y3Qg dnNwMV9kbF9ib2R5ICpkbGIpCj4gIHsKPiAtIGRtYV9mcmVlX3djKGRsYi0+dnNwMS0+ZGV2LCBk bGItPnNpemUsIGRsYi0+ZW50cmllcywgZGxiLT5kbWEpOwo+ICsgc3RydWN0IGRldmljZSAqZmNw ID0gcmNhcl9mY3BfZ2V0X2RldmljZShkbGItPnZzcDEtPmZjcCk7Cj4gKwo+ICsgZG1hX2ZyZWVf d2MoZmNwID8gZmNwIDogZGxiLT52c3AxLT5kZXYsCj4gKyAgICBkbGItPnNpemUsIGRsYi0+ZW50 cmllcywgZGxiLT5kbWEpOwo+ICB9Cj4gCj4gIC8qKgo+IC0tLSAwMDAxL2RyaXZlcnMvbWVkaWEv cGxhdGZvcm0vdnNwMS92c3AxX3ZpZGVvLmMKPiArKysgd29yay9kcml2ZXJzL21lZGlhL3BsYXRm b3JtL3ZzcDEvdnNwMV92aWRlby5jIDIwMTYtMDktMDEKPiAwNjoyMDowMi45NDA2MDcxMTAgKzA5 MDAKPiBAQCAtMjcsNiArMjcsOCBAQAo+ICAjaW5jbHVkZSA8bWVkaWEvdmlkZW9idWYyLXY0bDIu aD4KPiAgI2luY2x1ZGUgPG1lZGlhL3ZpZGVvYnVmMi1kbWEtY29udGlnLmg+Cj4gCj4gKyNpbmNs dWRlIDxtZWRpYS9yY2FyLWZjcC5oPgo+ICsKPiAgI2luY2x1ZGUgInZzcDEuaCIKPiAgI2luY2x1 ZGUgInZzcDFfYnJ1LmgiCj4gICNpbmNsdWRlICJ2c3AxX2RsLmgiCj4gQEAgLTkzOSw2ICs5NDEs NyBAQCBzdHJ1Y3QgdnNwMV92aWRlbyAqdnNwMV92aWRlb19jcmVhdGUoc3RyCj4gIHsKPiAgIHN0 cnVjdCB2c3AxX3ZpZGVvICp2aWRlbzsKPiAgIGNvbnN0IGNoYXIgKmRpcmVjdGlvbjsKPiArIHN0 cnVjdCBkZXZpY2UgKmZjcDsKPiAgIGludCByZXQ7Cj4gCj4gICB2aWRlbyA9IGRldm1fa3phbGxv Yyh2c3AxLT5kZXYsIHNpemVvZigqdmlkZW8pLCBHRlBfS0VSTkVMKTsKPiBAQCAtOTk2LDcgKzk5 OSw4IEBAIHN0cnVjdCB2c3AxX3ZpZGVvICp2c3AxX3ZpZGVvX2NyZWF0ZShzdHIKPiAgIHZpZGVv LT5xdWV1ZS5vcHMgPSAmdnNwMV92aWRlb19xdWV1ZV9xb3BzOwo+ICAgdmlkZW8tPnF1ZXVlLm1l bV9vcHMgPSAmdmIyX2RtYV9jb250aWdfbWVtb3BzOwo+ICAgdmlkZW8tPnF1ZXVlLnRpbWVzdGFt cF9mbGFncyA9IFY0TDJfQlVGX0ZMQUdfVElNRVNUQU1QX0NPUFk7Cj4gLSB2aWRlby0+cXVldWUu ZGV2ID0gdmlkZW8tPnZzcDEtPmRldjsKPiArIGZjcCA9IHJjYXJfZmNwX2dldF9kZXZpY2UodnNw MS0+ZmNwKTsKPiArIHZpZGVvLT5xdWV1ZS5kZXYgPSBmY3AgPyBmY3AgOiB2aWRlby0+dnNwMS0+ ZGV2Owo+ICAgcmV0ID0gdmIyX3F1ZXVlX2luaXQoJnZpZGVvLT5xdWV1ZSk7Cj4gICBpZiAocmV0 IDwgMCkgewo+ICAgZGV2X2Vycih2aWRlby0+dnNwMS0+ZGV2LCAiZmFpbGVkIHRvIGluaXRpYWxp emUgdmIyIHF1ZXVlXG4iKTsKPiAKPiBDYW4geW91IHBsZWFzZSBjb25zaWRlciB0byBpbmNsdWRl IG9yIHJld29yayB0aGUgYWJvdmUgY29kZSBpbiB5b3VyCj4gbmV4dCB2ZXJzaW9uIG9mIHRoaXMg c2VyaWVzPwo+IAo+IE5vdCBzdXJlIGlmIFItQ2FyIEdlbjIgaXMgYWZmZWN0ZWQgb3Igbm90LCBi dXQgd2l0aG91dCB0aGUgYWJvdmUgY29kZQo+IEkgZ2V0IHRoZSBmb2xsb3dpbmcgdHJhcCBkdXJp bmcgYm9vdCBvbiByOGE3Nzk1IFNhbHZhdG9yLVg6Cj4gCj4gaXBtbXUtdm1zYSBmZWJkMDAwMC5t bXU6IFVuaGFuZGxlZCBmYXV0OiBzdGF0dXMgMHgwMDAwMDEwMSBpb3ZhIDB4N2YwOWEwMDAKCkkn bSBmaW5hbGx5IGdldHRpbmcgYmFjayB0byB0aGlzLiBJJ2xsIGluY2x1ZGUgYSBtb2RpZmllZCB2 ZXJzaW9uIG9mIHRoZSBhYm92ZSAKY29kZSBpbiB0aGUgbmV4dCB2ZXJzaW9uIG9mIHRoZSBzZXJp ZXMgYW5kIHdpbGwgbWFrZSBzdXJlIHRvIHRlc3QgaXQgb24gYm90aCAKR2VuMiBhbmQgR2VuMyBz eXN0ZW1zIHdpdGggYW5kIHdpdGhvdXQgdGhlIElPTU1VIGVuYWJsZWQuCgpVbmxlc3MgeW91J2Qg cHJlZmVyIG90aGVyd2lzZSwgSSdsbCBtYXJrIHlvdSBhcyB0aGUgYXV0aG9yIG9mIHRoZSBjb2Rl LiBDYW4gSSAKZ2V0IHlvdXIgU29CID8KCi0tIApSZWdhcmRzLAoKTGF1cmVudCBQaW5jaGFydAoK X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVs IG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlz dHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVsCg==