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 Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 7EAE3C433EF for ; Tue, 24 May 2022 16:12:02 +0000 (UTC) Received: from list by lists.xenproject.org with outflank-mailman.336647.561010 (Exim 4.92) (envelope-from ) id 1ntX8M-00077S-AJ; Tue, 24 May 2022 16:11:46 +0000 X-Outflank-Mailman: Message body and most headers restored to incoming version Received: by outflank-mailman (output) from mailman id 336647.561010; Tue, 24 May 2022 16:11:46 +0000 Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1ntX8M-00077L-6o; Tue, 24 May 2022 16:11:46 +0000 Received: by outflank-mailman (input) for mailman id 336647; Tue, 24 May 2022 16:11:45 +0000 Received: from se1-gles-flk1-in.inumbo.com ([94.247.172.50] helo=se1-gles-flk1.inumbo.com) by lists.xenproject.org with esmtp (Exim 4.92) (envelope-from ) id 1ntX8K-000779-S2 for xen-devel@lists.xenproject.org; Tue, 24 May 2022 16:11:45 +0000 Received: from mail-lf1-x12f.google.com (mail-lf1-x12f.google.com [2a00:1450:4864:20::12f]) by se1-gles-flk1.inumbo.com (Halon) with ESMTPS id 33c37b81-db7c-11ec-837f-e5687231ffcc; Tue, 24 May 2022 18:11:43 +0200 (CEST) Received: by mail-lf1-x12f.google.com with SMTP id u23so31646335lfc.1 for ; Tue, 24 May 2022 09:11:43 -0700 (PDT) Received: from [192.168.1.7] ([212.22.223.21]) by smtp.gmail.com with ESMTPSA id r5-20020a19ac45000000b0047255d21167sm2602292lfc.150.2022.05.24.09.11.41 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Tue, 24 May 2022 09:11:42 -0700 (PDT) X-BeenThere: xen-devel@lists.xenproject.org List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Precedence: list Sender: "Xen-devel" X-Inumbo-ID: 33c37b81-db7c-11ec-837f-e5687231ffcc DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=subject:to:cc:references:from:message-id:date:user-agent :mime-version:in-reply-to:content-transfer-encoding:content-language; bh=qm9weLaNL4nn8FQertxYN6C+mkrhTu3vRp9alXEDss4=; b=C3hl1VyjK6sleZh5X3NsN4HkcpazdnD3DvB91rml+7SI+bM/M9WlbinHobisvAdCDx TIFsLkor6QMpQ+FOcvltP6Y7vjOIApbqfERArF1rBmpDxNUuwx3fmpXDfcy1X6WJZ1og H6LBMwkKrwG7NZRW7NvQL17o1gKB/CEveeaG+/NsUinUz1IQJ2lOgsAm2oLcM9shofvf To0dJAOR5lz51Pr9hSJZi6WTUIs5PHuUhUWSAW33LrcpoG/AfTRe7fR2ArBOLDc+GaWJ WEvDxgUBgJqU4u56STpTuQ0nSE3Y18JCw5qNaFyUpBmtM610Ul9uM7WhuYgYqw7rD9G3 ABzg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:subject:to:cc:references:from:message-id:date :user-agent:mime-version:in-reply-to:content-transfer-encoding :content-language; bh=qm9weLaNL4nn8FQertxYN6C+mkrhTu3vRp9alXEDss4=; b=M3TMPesK4jdSTDexTSj3vZPA4d/cbTe8pvAi4yx4v4OspnGE3oQlMZWMGqOZha0+fj pirrteXOHBA7CVEZNvJKQaJUYuoHmm0S+lzV/702z1nGRxV/8iwemyq16lIT6h4WE+z8 RXuk1P7++p+flpL6b+D8vNI6s4GqfDcz+k8+WmuBu6z8jyZ0fM56mNft6KsBhWAP9bjR MOCOBI2H69LBe3wU0FzMkgM6PoEPc0kWXtz0CuVW6Oh7vsGSJBu6y3VxOwE3ayJT9qap hOXPlcFNr4n1QguXrEcxSSLbvrK7+krb19Tn8IHRfnR4lIgVadDEZ9Y56e+xlSLAWLVw SMdg== X-Gm-Message-State: AOAM532RcDZS3oSDyCd0c1rajn8PvKpMBtpf6oOHEJcQkq+BZv9Wdidz jdy1k5pf5ap/iluhprfitF4= X-Google-Smtp-Source: ABdhPJymEImVNMQVJEQurd3WYXxyCnU02Ld7OWJwHzzYYlnnKByiq/YpRyTQbxag9jFDkQ9qyPIpBA== X-Received: by 2002:a05:6512:1316:b0:473:fda3:8dc8 with SMTP id x22-20020a056512131600b00473fda38dc8mr20057105lfu.529.1653408702637; Tue, 24 May 2022 09:11:42 -0700 (PDT) Subject: Re: [PATCH V2 5/7] dt-bindings: Add xen,dev-domid property description for xen-grant DMA ops To: Stefano Stabellini Cc: xen-devel , "open list:DRM DRIVER FOR QEMU'S CIRRUS DEVICE" , DTML , Linux Kernel Mailing List , Linux ARM , Arnd Bergmann , Oleksandr Tyshchenko , Jason Wang , Rob Herring , Krzysztof Kozlowski , Julien Grall , Juergen Gross , "Michael S. Tsirkin" , Christoph Hellwig , Jean-Philippe Brucker References: <1651947548-4055-1-git-send-email-olekstysh@gmail.com> <1651947548-4055-6-git-send-email-olekstysh@gmail.com> <56e8c32d-6771-7179-005f-26ca58555659@gmail.com> <460a746c-6b61-214b-4653-44a1430e314d@gmail.com> <6f469e9c-c26e-f4be-9a85-710afb0d77eb@gmail.com> <390ba7bb-ee9e-b7b7-5f08-71a7245fa4ec@gmail.com> From: Oleksandr Message-ID: <606dfdcc-ec10-0c4a-04e9-72cd73ee6676@gmail.com> Date: Tue, 24 May 2022 19:11:40 +0300 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Thunderbird/68.10.0 MIME-Version: 1.0 In-Reply-To: Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 8bit Content-Language: en-US On 24.05.22 04:58, Stefano Stabellini wrote: Hello Stefano, all > On Mon, 23 May 2022, Oleksandr wrote: >>>> On Thu, 19 May 2022, Oleksandr wrote: >>>>>> On Wed, May 18, 2022 at 5:06 PM Oleksandr wrote: >>>>>>> On 18.05.22 17:32, Arnd Bergmann wrote: >>>>>>>> On Sat, May 7, 2022 at 7:19 PM Oleksandr Tyshchenko >>>>>>>> wrote: >>>>>>>>     This would mean having a device >>>>>>>> node for the grant-table mechanism that can be referred to using >>>>>>>> the >>>>>>>> 'iommus' >>>>>>>> phandle property, with the domid as an additional argument. >>>>>>> I assume, you are speaking about something like the following? >>>>>>> >>>>>>> >>>>>>> xen_dummy_iommu { >>>>>>>       compatible = "xen,dummy-iommu"; >>>>>>>       #iommu-cells = <1>; >>>>>>> }; >>>>>>> >>>>>>> virtio@3000 { >>>>>>>       compatible = "virtio,mmio"; >>>>>>>       reg = <0x3000 0x100>; >>>>>>>       interrupts = <41>; >>>>>>> >>>>>>>       /* The device is located in Xen domain with ID 1 */ >>>>>>>       iommus = <&xen_dummy_iommu 1>; >>>>>>> }; >>>>>> Right, that's that's the idea, >>>>> thank you for the confirmation >>>>> >>>>> >>>>> >>>>>>    except I would not call it a 'dummy'. >>>>>>   From the perspective of the DT, this behaves just like an IOMMU, >>>>>> even if the exact mechanism is different from most hardware IOMMU >>>>>> implementations. >>>>> well, agree >>>>> >>>>> >>>>>>>> It does not quite fit the model that Linux currently uses for >>>>>>>> iommus, >>>>>>>> as that has an allocator for dma_addr_t space >>>>>>> yes (# 3/7 adds grant-table based allocator) >>>>>>> >>>>>>> >>>>>>>> , but it would think it's >>>>>>>> conceptually close enough that it makes sense for the binding. >>>>>>> Interesting idea. I am wondering, do we need an extra actions for >>>>>>> this >>>>>>> to work in Linux guest (dummy IOMMU driver, etc)? >>>>>> It depends on how closely the guest implementation can be made to >>>>>> resemble a normal iommu. If you do allocate dma_addr_t addresses, >>>>>> it may actually be close enough that you can just turn the grant-table >>>>>> code into a normal iommu driver and change nothing else. >>>>> Unfortunately, I failed to find a way how use grant references at the >>>>> iommu_ops level (I mean to fully pretend that we are an IOMMU driver). I >>>>> am >>>>> not too familiar with that, so what is written below might be wrong or >>>>> at >>>>> least not precise. >>>>> >>>>> The normal IOMMU driver in Linux doesn’t allocate DMA addresses by >>>>> itself, it >>>>> just maps (IOVA-PA) what was requested to be mapped by the upper layer. >>>>> The >>>>> DMA address allocation is done by the upper layer (DMA-IOMMU which is >>>>> the glue >>>>> layer between DMA API and IOMMU API allocates IOVA for PA?). But, all >>>>> what we >>>>> need here is just to allocate our specific grant-table based DMA >>>>> addresses >>>>> (DMA address = grant reference + offset in the page), so let’s say we >>>>> need an >>>>> entity to take a physical address as parameter and return a DMA address >>>>> (what >>>>> actually commit #3/7 is doing), and that’s all. So working at the >>>>> dma_ops >>>>> layer we get exactly what we need, with the minimal changes to guest >>>>> infrastructure. In our case the Xen itself acts as an IOMMU. >>>>> >>>>> Assuming that we want to reuse the IOMMU infrastructure somehow for our >>>>> needs. >>>>> I think, in that case we will likely need to introduce a new specific >>>>> IOVA >>>>> allocator (alongside with a generic one) to be hooked up by the >>>>> DMA-IOMMU >>>>> layer if we run on top of Xen. But, even having the specific IOVA >>>>> allocator to >>>>> return what we indeed need (DMA address = grant reference + offset in >>>>> the >>>>> page) we will still need the specific minimal required IOMMU driver to >>>>> be >>>>> present in the system anyway in order to track the mappings(?) and do >>>>> nothing >>>>> with them, returning a success (this specific IOMMU driver should have >>>>> all >>>>> mandatory callbacks implemented). >>>>> >>>>> I completely agree, it would be really nice to reuse generic IOMMU >>>>> bindings >>>>> rather than introducing Xen specific property if what we are trying to >>>>> implement in current patch series fits in the usage of "iommus" in Linux >>>>> more-less. But, if we will have to add more complexity/more components >>>>> to the >>>>> code for the sake of reusing device tree binding, this raises a question >>>>> whether that’s worthwhile. >>>>> >>>>> Or I really missed something? >>>> I think Arnd was primarily suggesting to reuse the IOMMU Device Tree >>>> bindings, not necessarily the IOMMU drivers framework in Linux (although >>>> that would be an added bonus.) >>>> >>>> I know from previous discussions with you that making the grant table >>>> fit in the existing IOMMU drivers model is difficult, but just reusing >>>> the Device Tree bindings seems feasible? >>> I started experimenting with that. As wrote in a separate email, I got a >>> deferred probe timeout, >>> >>> after inserting required nodes into guest device tree, which seems to be a >>> consequence of the unavailability of IOMMU, I will continue to investigate >>> this question. >> >> I have experimented with that. Yes, just reusing the Device Tree bindings is >> technically feasible (and we are able to do this by only touching >> grant-dma-ops.c), although deferred probe timeout still stands (as there is no >> IOMMU driver being present actually). >> >> [    0.583771] virtio-mmio 2000000.virtio: deferred probe timeout, ignoring >> dependency >> [    0.615556] virtio_blk virtio0: [vda] 4096000 512-byte logical blocks (2.10 >> GB/1.95 GiB) >> >> >> Below the working diff (on top of current series): >> >> diff --git a/drivers/xen/grant-dma-ops.c b/drivers/xen/grant-dma-ops.c >> index da9c7ff..6586152 100644 >> --- a/drivers/xen/grant-dma-ops.c >> +++ b/drivers/xen/grant-dma-ops.c >> @@ -272,17 +272,24 @@ static const struct dma_map_ops xen_grant_dma_ops = { >> >>  bool xen_is_grant_dma_device(struct device *dev) >>  { >> +       struct device_node *iommu_np; >> +       bool has_iommu; >> + >>         /* XXX Handle only DT devices for now */ >>         if (!dev->of_node) >>                 return false; >> >> -       return of_property_read_bool(dev->of_node, "xen,backend-domid"); >> +       iommu_np = of_parse_phandle(dev->of_node, "iommus", 0); >> +       has_iommu = iommu_np && of_device_is_compatible(iommu_np, >> "xen,grant-dma"); >> +       of_node_put(iommu_np); >> + >> +       return has_iommu; >>  } >> >>  void xen_grant_setup_dma_ops(struct device *dev) >>  { >>         struct xen_grant_dma_data *data; >> -       uint32_t domid; >> +       struct of_phandle_args iommu_spec; >> >>         data = find_xen_grant_dma_data(dev); >>         if (data) { >> @@ -294,16 +301,30 @@ void xen_grant_setup_dma_ops(struct device *dev) >>         if (!dev->of_node) >>                 goto err; >> >> -       if (of_property_read_u32(dev->of_node, "xen,backend-domid", &domid)) { >> -               dev_err(dev, "xen,backend-domid property is not present\n"); >> +       if (of_parse_phandle_with_args(dev->of_node, "iommus", "#iommu-cells", >> +                       0, &iommu_spec)) { >> +               dev_err(dev, "Cannot parse iommus property\n"); >> +               goto err; >> +       } >> + >> +       if (!of_device_is_compatible(iommu_spec.np, "xen,grant-dma") || >> +                       iommu_spec.args_count != 1) { >> +               dev_err(dev, "Incompatible IOMMU node\n"); >> +               of_node_put(iommu_spec.np); >>                 goto err; >>         } >> >> +       of_node_put(iommu_spec.np); >> + >>         data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); >>         if (!data) >>                 goto err; >> >> -       data->backend_domid = domid; >> +       /* >> +        * The endpoint ID here means the ID of the domain where the >> corresponding >> +        * backend is running >> +        */ >> +       data->backend_domid = iommu_spec.args[0]; >> >>         if (xa_err(xa_store(&xen_grant_dma_devices, (unsigned long)dev, data, >>                         GFP_KERNEL))) { >> (END) >> >> >> >> Below, the nodes generated by Xen toolstack: >> >>         xen_grant_dma { >>                 compatible = "xen,grant-dma"; >>                 #iommu-cells = <0x01>; >>                 phandle = <0xfde9>; >>         }; >> >>         virtio@2000000 { >>                 compatible = "virtio,mmio"; >>                 reg = <0x00 0x2000000 0x00 0x200>; >>                 interrupts = <0x00 0x01 0xf01>; >>                 interrupt-parent = <0xfde8>; >>                 dma-coherent; >>                 iommus = <0xfde9 0x01>; >>         }; > > Not bad! I like it. Good. > > >> I am wondering, would be the proper solution to eliminate deferred probe >> timeout issue in our particular case (without introducing an extra IOMMU >> driver)? > In reality I don't think there is a way to do that. I would create an > empty skelethon IOMMU driver for xen,grant-dma. Ok, I found yet another option how we can avoid deferred probe timeout issue. I am not sure whether it will be welcome. But it doesn't really require introducing stub IOMMU driver or other changes in the guest. The idea is to make IOMMU device unavailable (status = "disabled"), this way of_iommu_configure() will treat that as success condition also. https://elixir.bootlin.com/linux/v5.18/source/drivers/iommu/of_iommu.c#L31 https://elixir.bootlin.com/linux/v5.18/source/drivers/iommu/of_iommu.c#L149         xen_grant_dma {                 compatible = "xen,grant-dma";                 #iommu-cells = <0x01>;                 phandle = <0xfde9>;                 status = "disabled";         };         virtio@2000000 {                 compatible = "virtio,mmio";                 reg = <0x00 0x2000000 0x00 0x200>;                 interrupts = <0x00 0x01 0xf01>;                 interrupt-parent = <0xfde8>;                 dma-coherent;                 iommus = <0xfde9 0x01>;         }; I have checked, this "fixes" deferred probe timeout issue. Or we indeed need to introduce stub IOMMU driver (I placed it to driver/xen instead of driver/iommu, also we can even squash it with grant-dma-ops.c?). This stub driver also results in NO_IOMMU condition (as "of_xlate" callback is not implemented). diff --git a/drivers/xen/Kconfig b/drivers/xen/Kconfig index a7bd8ce..35b91b9 100644 --- a/drivers/xen/Kconfig +++ b/drivers/xen/Kconfig @@ -335,6 +335,10 @@ config XEN_UNPOPULATED_ALLOC           having to balloon out RAM regions in order to obtain physical memory           space to create such mappings. +config XEN_GRANT_DMA_IOMMU +       bool +       select IOMMU_API +  config XEN_GRANT_DMA_OPS         bool         select DMA_OPS @@ -343,6 +347,7 @@ config XEN_VIRTIO         bool "Xen virtio support"         depends on VIRTIO         select XEN_GRANT_DMA_OPS +       select XEN_GRANT_DMA_IOMMU         help           Enable virtio support for running as Xen guest. Depending on the           guest type this will require special support on the backend side diff --git a/drivers/xen/Makefile b/drivers/xen/Makefile index 1a23cb0..c0503f1 100644 --- a/drivers/xen/Makefile +++ b/drivers/xen/Makefile @@ -40,3 +40,4 @@ xen-privcmd-y                         := privcmd.o privcmd-buf.o  obj-$(CONFIG_XEN_FRONT_PGDIR_SHBUF)    += xen-front-pgdir-shbuf.o  obj-$(CONFIG_XEN_UNPOPULATED_ALLOC)    += unpopulated-alloc.o  obj-$(CONFIG_XEN_GRANT_DMA_OPS)                += grant-dma-ops.o +obj-$(CONFIG_XEN_GRANT_DMA_IOMMU)      += grant-dma-iommu.o diff --git a/drivers/xen/grant-dma-iommu.c b/drivers/xen/grant-dma-iommu.c new file mode 100644 index 00000000..b8aad8a --- /dev/null +++ b/drivers/xen/grant-dma-iommu.c @@ -0,0 +1,76 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Stub IOMMU driver which does nothing. + * The main purpose of it being present is to reuse generic device-tree IOMMU + * bindings by Xen grant DMA-mapping layer. + */ + +#include +#include +#include + +struct grant_dma_iommu_device { +       struct device *dev; +       struct iommu_device iommu; +}; + +/* Nothing is really needed here */ +static const struct iommu_ops grant_dma_iommu_ops; + +static const struct of_device_id grant_dma_iommu_of_match[] = { +       { .compatible = "xen,grant-dma" }, +       { }, +}; + +static int grant_dma_iommu_probe(struct platform_device *pdev) +{ +       struct grant_dma_iommu_device *mmu; +       int ret; + +       mmu = devm_kzalloc(&pdev->dev, sizeof(*mmu), GFP_KERNEL); +       if (!mmu) +               return -ENOMEM; + +       mmu->dev = &pdev->dev; + +       ret = iommu_device_register(&mmu->iommu, &grant_dma_iommu_ops, &pdev->dev); +       if (ret) +               return ret; + +       platform_set_drvdata(pdev, mmu); + +       return 0; +} + +static int grant_dma_iommu_remove(struct platform_device *pdev) +{ +       struct grant_dma_iommu_device *mmu = platform_get_drvdata(pdev); + +       platform_set_drvdata(pdev, NULL); +       iommu_device_unregister(&mmu->iommu); + +       return 0; +} + +static struct platform_driver grant_dma_iommu_driver = { +       .driver = { +               .name = "grant-dma-iommu", +               .of_match_table = grant_dma_iommu_of_match, +       }, +       .probe = grant_dma_iommu_probe, +       .remove = grant_dma_iommu_remove, +}; + +static int __init grant_dma_iommu_init(void) +{ +       struct device_node *iommu_np; + +       iommu_np = of_find_matching_node(NULL, grant_dma_iommu_of_match); +       if (!iommu_np) +               return 0; + +       of_node_put(iommu_np); + +       return platform_driver_register(&grant_dma_iommu_driver); +} +subsys_initcall(grant_dma_iommu_init); I have checked, this also "fixes" deferred probe timeout issue. Personally I would prefer the first option, but I would be also happy to use second option in order to unblock the series. What do the maintainers think? -- Regards, Oleksandr Tyshchenko 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 Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id EDCFCC433EF for ; Tue, 24 May 2022 16:13:02 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender:Content-Type: Content-Transfer-Encoding:List-Subscribe:List-Help:List-Post:List-Archive: List-Unsubscribe:List-Id:In-Reply-To:MIME-Version:Date:Message-ID:From: References:Cc:To:Subject:Reply-To:Content-ID:Content-Description:Resent-Date: Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Owner; bh=EK5mBaP4AwN+syZocgxZ72dNmjuYAj+MHGOe4u7wO/Y=; b=3EQGjZ6Y8JG46VNQK0RwcYyPlP bPMDOMvrB4Wgd0S1IAex6wu2aMRwz5r3BPHxhIDCTqN9JK2G7Rs3Hp095ZhPbCfWzuxze9lTNIdEh Ep77cR5gVInR59geAWCKHR43JeT3wVUEOoGPunZhtLcAv0bdn6EJmYy3yWHJgjA3hMR9IahCZKvSJ qacLHi4qKClmSr6y/cxIU5Z7yHq/9PRFa3OUbP9jB2TJ1hxHZZRtzqRRxrI3U0K5YFP8zWhOGCFYq O0/duXk+rbF6t0oXYM9w/WLPhl84h6DgS1OPD4E9licaDKqAq0Ie4WCEl9nQIIzpavx8RTKBsqRo9 qtECDlsQ==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1ntX8P-008cuI-K1; Tue, 24 May 2022 16:11:49 +0000 Received: from mail-lf1-x12c.google.com ([2a00:1450:4864:20::12c]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1ntX8L-008csw-Bu for linux-arm-kernel@lists.infradead.org; Tue, 24 May 2022 16:11:48 +0000 Received: by mail-lf1-x12c.google.com with SMTP id j10so8154491lfe.12 for ; Tue, 24 May 2022 09:11:44 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=subject:to:cc:references:from:message-id:date:user-agent :mime-version:in-reply-to:content-transfer-encoding:content-language; bh=qm9weLaNL4nn8FQertxYN6C+mkrhTu3vRp9alXEDss4=; b=C3hl1VyjK6sleZh5X3NsN4HkcpazdnD3DvB91rml+7SI+bM/M9WlbinHobisvAdCDx TIFsLkor6QMpQ+FOcvltP6Y7vjOIApbqfERArF1rBmpDxNUuwx3fmpXDfcy1X6WJZ1og H6LBMwkKrwG7NZRW7NvQL17o1gKB/CEveeaG+/NsUinUz1IQJ2lOgsAm2oLcM9shofvf To0dJAOR5lz51Pr9hSJZi6WTUIs5PHuUhUWSAW33LrcpoG/AfTRe7fR2ArBOLDc+GaWJ WEvDxgUBgJqU4u56STpTuQ0nSE3Y18JCw5qNaFyUpBmtM610Ul9uM7WhuYgYqw7rD9G3 ABzg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:subject:to:cc:references:from:message-id:date :user-agent:mime-version:in-reply-to:content-transfer-encoding :content-language; bh=qm9weLaNL4nn8FQertxYN6C+mkrhTu3vRp9alXEDss4=; b=sN10EP+AsuyUW3Fq6r1cGWExVeKz4ymdf98tkBdP5bE+80V/11EJT7mTMV7nXiwEwR lyTFoc3ai/7xTFtzaemk9Xj2qZOqsXYVWkLf1ze7iSVtixE+qHnbmUuwL4VnpfiRwlaJ jvkZO5ymdLDL74+Z8QtP10tyxY1sHtRwQPFrlJneCyJdXfFnBKAedEMrLpei0koSG97O KBXzpDiasoJXTHMt8AFQx/n/VfWINFkOAqvEpc4h44+WbIdd6rXnoRDiVw86Pu7QvrlR 0ZcTHwZ4RloY230QbGPkBoSnB1JhTveInEULO9zmWdU6JgyDGfH1xw1NouLa2VViL5oy EzOg== X-Gm-Message-State: AOAM533p4WcApu+tR9+RrY1TChYTO/Qkt0jJR0yOa006X4i7znTh/etE snnSdhtJZo0bVPFiC5KpuwY= X-Google-Smtp-Source: ABdhPJymEImVNMQVJEQurd3WYXxyCnU02Ld7OWJwHzzYYlnnKByiq/YpRyTQbxag9jFDkQ9qyPIpBA== X-Received: by 2002:a05:6512:1316:b0:473:fda3:8dc8 with SMTP id x22-20020a056512131600b00473fda38dc8mr20057105lfu.529.1653408702637; Tue, 24 May 2022 09:11:42 -0700 (PDT) Received: from [192.168.1.7] ([212.22.223.21]) by smtp.gmail.com with ESMTPSA id r5-20020a19ac45000000b0047255d21167sm2602292lfc.150.2022.05.24.09.11.41 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Tue, 24 May 2022 09:11:42 -0700 (PDT) Subject: Re: [PATCH V2 5/7] dt-bindings: Add xen,dev-domid property description for xen-grant DMA ops To: Stefano Stabellini Cc: xen-devel , "open list:DRM DRIVER FOR QEMU'S CIRRUS DEVICE" , DTML , Linux Kernel Mailing List , Linux ARM , Arnd Bergmann , Oleksandr Tyshchenko , Jason Wang , Rob Herring , Krzysztof Kozlowski , Julien Grall , Juergen Gross , "Michael S. Tsirkin" , Christoph Hellwig , Jean-Philippe Brucker References: <1651947548-4055-1-git-send-email-olekstysh@gmail.com> <1651947548-4055-6-git-send-email-olekstysh@gmail.com> <56e8c32d-6771-7179-005f-26ca58555659@gmail.com> <460a746c-6b61-214b-4653-44a1430e314d@gmail.com> <6f469e9c-c26e-f4be-9a85-710afb0d77eb@gmail.com> <390ba7bb-ee9e-b7b7-5f08-71a7245fa4ec@gmail.com> From: Oleksandr Message-ID: <606dfdcc-ec10-0c4a-04e9-72cd73ee6676@gmail.com> Date: Tue, 24 May 2022 19:11:40 +0300 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Thunderbird/68.10.0 MIME-Version: 1.0 In-Reply-To: Content-Language: en-US X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20220524_091145_504587_02599F0B X-CRM114-Status: GOOD ( 46.69 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Transfer-Encoding: base64 Content-Type: text/plain; charset="utf-8"; Format="flowed" Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org Ck9uIDI0LjA1LjIyIDA0OjU4LCBTdGVmYW5vIFN0YWJlbGxpbmkgd3JvdGU6CgpIZWxsbyBTdGVm YW5vLCBhbGwKCj4gT24gTW9uLCAyMyBNYXkgMjAyMiwgT2xla3NhbmRyIHdyb3RlOgo+Pj4+IE9u IFRodSwgMTkgTWF5IDIwMjIsIE9sZWtzYW5kciB3cm90ZToKPj4+Pj4+IE9uIFdlZCwgTWF5IDE4 LCAyMDIyIGF0IDU6MDYgUE0gT2xla3NhbmRyIDxvbGVrc3R5c2hAZ21haWwuY29tPiB3cm90ZToK Pj4+Pj4+PiBPbiAxOC4wNS4yMiAxNzozMiwgQXJuZCBCZXJnbWFubiB3cm90ZToKPj4+Pj4+Pj4g T24gU2F0LCBNYXkgNywgMjAyMiBhdCA3OjE5IFBNIE9sZWtzYW5kciBUeXNoY2hlbmtvCj4+Pj4+ Pj4+IDxvbGVrc3R5c2hAZ21haWwuY29tPiB3cm90ZToKPj4+Pj4+Pj4gIMKgwqDCoCBUaGlzIHdv dWxkIG1lYW4gaGF2aW5nIGEgZGV2aWNlCj4+Pj4+Pj4+IG5vZGUgZm9yIHRoZSBncmFudC10YWJs ZSBtZWNoYW5pc20gdGhhdCBjYW4gYmUgcmVmZXJyZWQgdG8gdXNpbmcKPj4+Pj4+Pj4gdGhlCj4+ Pj4+Pj4+ICdpb21tdXMnCj4+Pj4+Pj4+IHBoYW5kbGUgcHJvcGVydHksIHdpdGggdGhlIGRvbWlk IGFzIGFuIGFkZGl0aW9uYWwgYXJndW1lbnQuCj4+Pj4+Pj4gSSBhc3N1bWUsIHlvdSBhcmUgc3Bl YWtpbmcgYWJvdXQgc29tZXRoaW5nIGxpa2UgdGhlIGZvbGxvd2luZz8KPj4+Pj4+Pgo+Pj4+Pj4+ Cj4+Pj4+Pj4geGVuX2R1bW15X2lvbW11IHsKPj4+Pj4+PiAgwqDCoMKgwqDCoCBjb21wYXRpYmxl ID0gInhlbixkdW1teS1pb21tdSI7Cj4+Pj4+Pj4gIMKgwqDCoMKgwqAgI2lvbW11LWNlbGxzID0g PDE+Owo+Pj4+Pj4+IH07Cj4+Pj4+Pj4KPj4+Pj4+PiB2aXJ0aW9AMzAwMCB7Cj4+Pj4+Pj4gIMKg wqDCoMKgwqAgY29tcGF0aWJsZSA9ICJ2aXJ0aW8sbW1pbyI7Cj4+Pj4+Pj4gIMKgwqDCoMKgwqAg cmVnID0gPDB4MzAwMCAweDEwMD47Cj4+Pj4+Pj4gIMKgwqDCoMKgwqAgaW50ZXJydXB0cyA9IDw0 MT47Cj4+Pj4+Pj4KPj4+Pj4+PiAgwqDCoMKgwqDCoCAvKiBUaGUgZGV2aWNlIGlzIGxvY2F0ZWQg aW4gWGVuIGRvbWFpbiB3aXRoIElEIDEgKi8KPj4+Pj4+PiAgwqDCoMKgwqDCoCBpb21tdXMgPSA8 Jnhlbl9kdW1teV9pb21tdSAxPjsKPj4+Pj4+PiB9Owo+Pj4+Pj4gUmlnaHQsIHRoYXQncyB0aGF0 J3MgdGhlIGlkZWEsCj4+Pj4+IHRoYW5rIHlvdSBmb3IgdGhlIGNvbmZpcm1hdGlvbgo+Pj4+Pgo+ Pj4+Pgo+Pj4+Pgo+Pj4+Pj4gIMKgwqAgZXhjZXB0IEkgd291bGQgbm90IGNhbGwgaXQgYSAnZHVt bXknLgo+Pj4+Pj4gIMKgIEZyb20gdGhlIHBlcnNwZWN0aXZlIG9mIHRoZSBEVCwgdGhpcyBiZWhh dmVzIGp1c3QgbGlrZSBhbiBJT01NVSwKPj4+Pj4+IGV2ZW4gaWYgdGhlIGV4YWN0IG1lY2hhbmlz bSBpcyBkaWZmZXJlbnQgZnJvbSBtb3N0IGhhcmR3YXJlIElPTU1VCj4+Pj4+PiBpbXBsZW1lbnRh dGlvbnMuCj4+Pj4+IHdlbGwsIGFncmVlCj4+Pj4+Cj4+Pj4+Cj4+Pj4+Pj4+IEl0IGRvZXMgbm90 IHF1aXRlIGZpdCB0aGUgbW9kZWwgdGhhdCBMaW51eCBjdXJyZW50bHkgdXNlcyBmb3IKPj4+Pj4+ Pj4gaW9tbXVzLAo+Pj4+Pj4+PiBhcyB0aGF0IGhhcyBhbiBhbGxvY2F0b3IgZm9yIGRtYV9hZGRy X3Qgc3BhY2UKPj4+Pj4+PiB5ZXMgKCMgMy83IGFkZHMgZ3JhbnQtdGFibGUgYmFzZWQgYWxsb2Nh dG9yKQo+Pj4+Pj4+Cj4+Pj4+Pj4KPj4+Pj4+Pj4gLCBidXQgaXQgd291bGQgdGhpbmsgaXQncwo+ Pj4+Pj4+PiBjb25jZXB0dWFsbHkgY2xvc2UgZW5vdWdoIHRoYXQgaXQgbWFrZXMgc2Vuc2UgZm9y IHRoZSBiaW5kaW5nLgo+Pj4+Pj4+IEludGVyZXN0aW5nIGlkZWEuIEkgYW0gd29uZGVyaW5nLCBk byB3ZSBuZWVkIGFuIGV4dHJhIGFjdGlvbnMgZm9yCj4+Pj4+Pj4gdGhpcwo+Pj4+Pj4+IHRvIHdv cmsgaW4gTGludXggZ3Vlc3QgKGR1bW15IElPTU1VIGRyaXZlciwgZXRjKT8KPj4+Pj4+IEl0IGRl cGVuZHMgb24gaG93IGNsb3NlbHkgdGhlIGd1ZXN0IGltcGxlbWVudGF0aW9uIGNhbiBiZSBtYWRl IHRvCj4+Pj4+PiByZXNlbWJsZSBhIG5vcm1hbCBpb21tdS4gSWYgeW91IGRvIGFsbG9jYXRlIGRt YV9hZGRyX3QgYWRkcmVzc2VzLAo+Pj4+Pj4gaXQgbWF5IGFjdHVhbGx5IGJlIGNsb3NlIGVub3Vn aCB0aGF0IHlvdSBjYW4ganVzdCB0dXJuIHRoZSBncmFudC10YWJsZQo+Pj4+Pj4gY29kZSBpbnRv IGEgbm9ybWFsIGlvbW11IGRyaXZlciBhbmQgY2hhbmdlIG5vdGhpbmcgZWxzZS4KPj4+Pj4gVW5m b3J0dW5hdGVseSwgSSBmYWlsZWQgdG8gZmluZCBhIHdheSBob3cgdXNlIGdyYW50IHJlZmVyZW5j ZXMgYXQgdGhlCj4+Pj4+IGlvbW11X29wcyBsZXZlbCAoSSBtZWFuIHRvIGZ1bGx5IHByZXRlbmQg dGhhdCB3ZSBhcmUgYW4gSU9NTVUgZHJpdmVyKS4gSQo+Pj4+PiBhbQo+Pj4+PiBub3QgdG9vIGZh bWlsaWFyIHdpdGggdGhhdCwgc28gd2hhdCBpcyB3cml0dGVuIGJlbG93IG1pZ2h0IGJlIHdyb25n IG9yCj4+Pj4+IGF0Cj4+Pj4+IGxlYXN0IG5vdCBwcmVjaXNlLgo+Pj4+Pgo+Pj4+PiBUaGUgbm9y bWFsIElPTU1VIGRyaXZlciBpbiBMaW51eCBkb2VzbuKAmXQgYWxsb2NhdGUgRE1BIGFkZHJlc3Nl cyBieQo+Pj4+PiBpdHNlbGYsIGl0Cj4+Pj4+IGp1c3QgbWFwcyAoSU9WQS1QQSkgd2hhdCB3YXMg cmVxdWVzdGVkIHRvIGJlIG1hcHBlZCBieSB0aGUgdXBwZXIgbGF5ZXIuCj4+Pj4+IFRoZQo+Pj4+ PiBETUEgYWRkcmVzcyBhbGxvY2F0aW9uIGlzIGRvbmUgYnkgdGhlIHVwcGVyIGxheWVyIChETUEt SU9NTVUgd2hpY2ggaXMKPj4+Pj4gdGhlIGdsdWUKPj4+Pj4gbGF5ZXIgYmV0d2VlbiBETUEgQVBJ IGFuZCBJT01NVSBBUEkgYWxsb2NhdGVzIElPVkEgZm9yIFBBPykuIEJ1dCwgYWxsCj4+Pj4+IHdo YXQgd2UKPj4+Pj4gbmVlZCBoZXJlIGlzIGp1c3QgdG8gYWxsb2NhdGUgb3VyIHNwZWNpZmljIGdy YW50LXRhYmxlIGJhc2VkIERNQQo+Pj4+PiBhZGRyZXNzZXMKPj4+Pj4gKERNQSBhZGRyZXNzID0g Z3JhbnQgcmVmZXJlbmNlICsgb2Zmc2V0IGluIHRoZSBwYWdlKSwgc28gbGV04oCZcyBzYXkgd2UK Pj4+Pj4gbmVlZCBhbgo+Pj4+PiBlbnRpdHkgdG8gdGFrZSBhIHBoeXNpY2FsIGFkZHJlc3MgYXMg cGFyYW1ldGVyIGFuZCByZXR1cm4gYSBETUEgYWRkcmVzcwo+Pj4+PiAod2hhdAo+Pj4+PiBhY3R1 YWxseSBjb21taXQgIzMvNyBpcyBkb2luZyksIGFuZCB0aGF04oCZcyBhbGwuIFNvIHdvcmtpbmcg YXQgdGhlCj4+Pj4+IGRtYV9vcHMKPj4+Pj4gbGF5ZXIgd2UgZ2V0IGV4YWN0bHkgd2hhdCB3ZSBu ZWVkLCB3aXRoIHRoZSBtaW5pbWFsIGNoYW5nZXMgdG8gZ3Vlc3QKPj4+Pj4gaW5mcmFzdHJ1Y3R1 cmUuIEluIG91ciBjYXNlIHRoZSBYZW4gaXRzZWxmIGFjdHMgYXMgYW4gSU9NTVUuCj4+Pj4+Cj4+ Pj4+IEFzc3VtaW5nIHRoYXQgd2Ugd2FudCB0byByZXVzZSB0aGUgSU9NTVUgaW5mcmFzdHJ1Y3R1 cmUgc29tZWhvdyBmb3Igb3VyCj4+Pj4+IG5lZWRzLgo+Pj4+PiBJIHRoaW5rLCBpbiB0aGF0IGNh c2Ugd2Ugd2lsbCBsaWtlbHkgbmVlZCB0byBpbnRyb2R1Y2UgYSBuZXcgc3BlY2lmaWMKPj4+Pj4g SU9WQQo+Pj4+PiBhbGxvY2F0b3IgKGFsb25nc2lkZSB3aXRoIGEgZ2VuZXJpYyBvbmUpIHRvIGJl IGhvb2tlZCB1cCBieSB0aGUKPj4+Pj4gRE1BLUlPTU1VCj4+Pj4+IGxheWVyIGlmIHdlIHJ1biBv biB0b3Agb2YgWGVuLiBCdXQsIGV2ZW4gaGF2aW5nIHRoZSBzcGVjaWZpYyBJT1ZBCj4+Pj4+IGFs bG9jYXRvciB0bwo+Pj4+PiByZXR1cm4gd2hhdCB3ZSBpbmRlZWQgbmVlZCAoRE1BIGFkZHJlc3Mg PSBncmFudCByZWZlcmVuY2UgKyBvZmZzZXQgaW4KPj4+Pj4gdGhlCj4+Pj4+IHBhZ2UpIHdlIHdp bGwgc3RpbGwgbmVlZCB0aGUgc3BlY2lmaWMgbWluaW1hbCByZXF1aXJlZCBJT01NVSBkcml2ZXIg dG8KPj4+Pj4gYmUKPj4+Pj4gcHJlc2VudCBpbiB0aGUgc3lzdGVtIGFueXdheSBpbiBvcmRlciB0 byB0cmFjayB0aGUgbWFwcGluZ3MoPykgYW5kIGRvCj4+Pj4+IG5vdGhpbmcKPj4+Pj4gd2l0aCB0 aGVtLCByZXR1cm5pbmcgYSBzdWNjZXNzICh0aGlzIHNwZWNpZmljIElPTU1VIGRyaXZlciBzaG91 bGQgaGF2ZQo+Pj4+PiBhbGwKPj4+Pj4gbWFuZGF0b3J5IGNhbGxiYWNrcyBpbXBsZW1lbnRlZCku Cj4+Pj4+Cj4+Pj4+IEkgY29tcGxldGVseSBhZ3JlZSwgaXQgd291bGQgYmUgcmVhbGx5IG5pY2Ug dG8gcmV1c2UgZ2VuZXJpYyBJT01NVQo+Pj4+PiBiaW5kaW5ncwo+Pj4+PiByYXRoZXIgdGhhbiBp bnRyb2R1Y2luZyBYZW4gc3BlY2lmaWMgcHJvcGVydHkgaWYgd2hhdCB3ZSBhcmUgdHJ5aW5nIHRv Cj4+Pj4+IGltcGxlbWVudCBpbiBjdXJyZW50IHBhdGNoIHNlcmllcyBmaXRzIGluIHRoZSB1c2Fn ZSBvZiAiaW9tbXVzIiBpbiBMaW51eAo+Pj4+PiBtb3JlLWxlc3MuIEJ1dCwgaWYgd2Ugd2lsbCBo YXZlIHRvIGFkZCBtb3JlIGNvbXBsZXhpdHkvbW9yZSBjb21wb25lbnRzCj4+Pj4+IHRvIHRoZQo+ Pj4+PiBjb2RlIGZvciB0aGUgc2FrZSBvZiByZXVzaW5nIGRldmljZSB0cmVlIGJpbmRpbmcsIHRo aXMgcmFpc2VzIGEgcXVlc3Rpb24KPj4+Pj4gd2hldGhlciB0aGF04oCZcyB3b3J0aHdoaWxlLgo+ Pj4+Pgo+Pj4+PiBPciBJIHJlYWxseSBtaXNzZWQgc29tZXRoaW5nPwo+Pj4+IEkgdGhpbmsgQXJu ZCB3YXMgcHJpbWFyaWx5IHN1Z2dlc3RpbmcgdG8gcmV1c2UgdGhlIElPTU1VIERldmljZSBUcmVl Cj4+Pj4gYmluZGluZ3MsIG5vdCBuZWNlc3NhcmlseSB0aGUgSU9NTVUgZHJpdmVycyBmcmFtZXdv cmsgaW4gTGludXggKGFsdGhvdWdoCj4+Pj4gdGhhdCB3b3VsZCBiZSBhbiBhZGRlZCBib251cy4p Cj4+Pj4KPj4+PiBJIGtub3cgZnJvbSBwcmV2aW91cyBkaXNjdXNzaW9ucyB3aXRoIHlvdSB0aGF0 IG1ha2luZyB0aGUgZ3JhbnQgdGFibGUKPj4+PiBmaXQgaW4gdGhlIGV4aXN0aW5nIElPTU1VIGRy aXZlcnMgbW9kZWwgaXMgZGlmZmljdWx0LCBidXQganVzdCByZXVzaW5nCj4+Pj4gdGhlIERldmlj ZSBUcmVlIGJpbmRpbmdzIHNlZW1zIGZlYXNpYmxlPwo+Pj4gSSBzdGFydGVkIGV4cGVyaW1lbnRp bmcgd2l0aCB0aGF0LiBBcyB3cm90ZSBpbiBhIHNlcGFyYXRlIGVtYWlsLCBJIGdvdCBhCj4+PiBk ZWZlcnJlZCBwcm9iZSB0aW1lb3V0LAo+Pj4KPj4+IGFmdGVyIGluc2VydGluZyByZXF1aXJlZCBu b2RlcyBpbnRvIGd1ZXN0IGRldmljZSB0cmVlLCB3aGljaCBzZWVtcyB0byBiZSBhCj4+PiBjb25z ZXF1ZW5jZSBvZiB0aGUgdW5hdmFpbGFiaWxpdHkgb2YgSU9NTVUsIEkgd2lsbCBjb250aW51ZSB0 byBpbnZlc3RpZ2F0ZQo+Pj4gdGhpcyBxdWVzdGlvbi4KPj4KPj4gSSBoYXZlIGV4cGVyaW1lbnRl ZCB3aXRoIHRoYXQuIFllcywganVzdCByZXVzaW5nIHRoZSBEZXZpY2UgVHJlZSBiaW5kaW5ncyBp cwo+PiB0ZWNobmljYWxseSBmZWFzaWJsZSAoYW5kIHdlIGFyZSBhYmxlIHRvIGRvIHRoaXMgYnkg b25seSB0b3VjaGluZwo+PiBncmFudC1kbWEtb3BzLmMpLCBhbHRob3VnaCBkZWZlcnJlZCBwcm9i ZSB0aW1lb3V0IHN0aWxsIHN0YW5kcyAoYXMgdGhlcmUgaXMgbm8KPj4gSU9NTVUgZHJpdmVyIGJl aW5nIHByZXNlbnQgYWN0dWFsbHkpLgo+Pgo+PiBbwqDCoMKgIDAuNTgzNzcxXSB2aXJ0aW8tbW1p byAyMDAwMDAwLnZpcnRpbzogZGVmZXJyZWQgcHJvYmUgdGltZW91dCwgaWdub3JpbmcKPj4gZGVw ZW5kZW5jeQo+PiBbwqDCoMKgIDAuNjE1NTU2XSB2aXJ0aW9fYmxrIHZpcnRpbzA6IFt2ZGFdIDQw OTYwMDAgNTEyLWJ5dGUgbG9naWNhbCBibG9ja3MgKDIuMTAKPj4gR0IvMS45NSBHaUIpCj4+Cj4+ Cj4+IEJlbG93IHRoZSB3b3JraW5nIGRpZmYgKG9uIHRvcCBvZiBjdXJyZW50IHNlcmllcyk6Cj4+ Cj4+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3hlbi9ncmFudC1kbWEtb3BzLmMgYi9kcml2ZXJzL3hl bi9ncmFudC1kbWEtb3BzLmMKPj4gaW5kZXggZGE5YzdmZi4uNjU4NjE1MiAxMDA2NDQKPj4gLS0t IGEvZHJpdmVycy94ZW4vZ3JhbnQtZG1hLW9wcy5jCj4+ICsrKyBiL2RyaXZlcnMveGVuL2dyYW50 LWRtYS1vcHMuYwo+PiBAQCAtMjcyLDE3ICsyNzIsMjQgQEAgc3RhdGljIGNvbnN0IHN0cnVjdCBk bWFfbWFwX29wcyB4ZW5fZ3JhbnRfZG1hX29wcyA9IHsKPj4KPj4gIMKgYm9vbCB4ZW5faXNfZ3Jh bnRfZG1hX2RldmljZShzdHJ1Y3QgZGV2aWNlICpkZXYpCj4+ICDCoHsKPj4gK8KgwqDCoMKgwqDC oCBzdHJ1Y3QgZGV2aWNlX25vZGUgKmlvbW11X25wOwo+PiArwqDCoMKgwqDCoMKgIGJvb2wgaGFz X2lvbW11Owo+PiArCj4+ICDCoMKgwqDCoMKgwqDCoCAvKiBYWFggSGFuZGxlIG9ubHkgRFQgZGV2 aWNlcyBmb3Igbm93ICovCj4+ICDCoMKgwqDCoMKgwqDCoCBpZiAoIWRldi0+b2Zfbm9kZSkKPj4g IMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCByZXR1cm4gZmFsc2U7Cj4+Cj4+IC3CoMKg wqDCoMKgwqAgcmV0dXJuIG9mX3Byb3BlcnR5X3JlYWRfYm9vbChkZXYtPm9mX25vZGUsICJ4ZW4s YmFja2VuZC1kb21pZCIpOwo+PiArwqDCoMKgwqDCoMKgIGlvbW11X25wID0gb2ZfcGFyc2VfcGhh bmRsZShkZXYtPm9mX25vZGUsICJpb21tdXMiLCAwKTsKPj4gK8KgwqDCoMKgwqDCoCBoYXNfaW9t bXUgPSBpb21tdV9ucCAmJiBvZl9kZXZpY2VfaXNfY29tcGF0aWJsZShpb21tdV9ucCwKPj4gInhl bixncmFudC1kbWEiKTsKPj4gK8KgwqDCoMKgwqDCoCBvZl9ub2RlX3B1dChpb21tdV9ucCk7Cj4+ ICsKPj4gK8KgwqDCoMKgwqDCoCByZXR1cm4gaGFzX2lvbW11Owo+PiAgwqB9Cj4+Cj4+ICDCoHZv aWQgeGVuX2dyYW50X3NldHVwX2RtYV9vcHMoc3RydWN0IGRldmljZSAqZGV2KQo+PiAgwqB7Cj4+ ICDCoMKgwqDCoMKgwqDCoCBzdHJ1Y3QgeGVuX2dyYW50X2RtYV9kYXRhICpkYXRhOwo+PiAtwqDC oMKgwqDCoMKgIHVpbnQzMl90IGRvbWlkOwo+PiArwqDCoMKgwqDCoMKgIHN0cnVjdCBvZl9waGFu ZGxlX2FyZ3MgaW9tbXVfc3BlYzsKPj4KPj4gIMKgwqDCoMKgwqDCoMKgIGRhdGEgPSBmaW5kX3hl bl9ncmFudF9kbWFfZGF0YShkZXYpOwo+PiAgwqDCoMKgwqDCoMKgwqAgaWYgKGRhdGEpIHsKPj4g QEAgLTI5NCwxNiArMzAxLDMwIEBAIHZvaWQgeGVuX2dyYW50X3NldHVwX2RtYV9vcHMoc3RydWN0 IGRldmljZSAqZGV2KQo+PiAgwqDCoMKgwqDCoMKgwqAgaWYgKCFkZXYtPm9mX25vZGUpCj4+ICDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgZ290byBlcnI7Cj4+Cj4+IC3CoMKgwqDCoMKg wqAgaWYgKG9mX3Byb3BlcnR5X3JlYWRfdTMyKGRldi0+b2Zfbm9kZSwgInhlbixiYWNrZW5kLWRv bWlkIiwgJmRvbWlkKSkgewo+PiAtwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBkZXZfZXJy KGRldiwgInhlbixiYWNrZW5kLWRvbWlkIHByb3BlcnR5IGlzIG5vdCBwcmVzZW50XG4iKTsKPj4g K8KgwqDCoMKgwqDCoCBpZiAob2ZfcGFyc2VfcGhhbmRsZV93aXRoX2FyZ3MoZGV2LT5vZl9ub2Rl LCAiaW9tbXVzIiwgIiNpb21tdS1jZWxscyIsCj4+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoCAwLCAmaW9tbXVfc3BlYykpIHsKPj4gK8KgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqAgZGV2X2VycihkZXYsICJDYW5ub3QgcGFyc2UgaW9tbXVzIHByb3BlcnR5 XG4iKTsKPj4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgZ290byBlcnI7Cj4+ICvCoMKg wqDCoMKgwqAgfQo+PiArCj4+ICvCoMKgwqDCoMKgwqAgaWYgKCFvZl9kZXZpY2VfaXNfY29tcGF0 aWJsZShpb21tdV9zcGVjLm5wLCAieGVuLGdyYW50LWRtYSIpIHx8Cj4+ICvCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBpb21tdV9zcGVjLmFyZ3NfY291bnQgIT0g MSkgewo+PiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBkZXZfZXJyKGRldiwgIkluY29t cGF0aWJsZSBJT01NVSBub2RlXG4iKTsKPj4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAg b2Zfbm9kZV9wdXQoaW9tbXVfc3BlYy5ucCk7Cj4+ICDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqAgZ290byBlcnI7Cj4+ICDCoMKgwqDCoMKgwqDCoCB9Cj4+Cj4+ICvCoMKgwqDCoMKgwqAg b2Zfbm9kZV9wdXQoaW9tbXVfc3BlYy5ucCk7Cj4+ICsKPj4gIMKgwqDCoMKgwqDCoMKgIGRhdGEg PSBkZXZtX2t6YWxsb2MoZGV2LCBzaXplb2YoKmRhdGEpLCBHRlBfS0VSTkVMKTsKPj4gIMKgwqDC oMKgwqDCoMKgIGlmICghZGF0YSkKPj4gIMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBn b3RvIGVycjsKPj4KPj4gLcKgwqDCoMKgwqDCoCBkYXRhLT5iYWNrZW5kX2RvbWlkID0gZG9taWQ7 Cj4+ICvCoMKgwqDCoMKgwqAgLyoKPj4gK8KgwqDCoMKgwqDCoMKgICogVGhlIGVuZHBvaW50IElE IGhlcmUgbWVhbnMgdGhlIElEIG9mIHRoZSBkb21haW4gd2hlcmUgdGhlCj4+IGNvcnJlc3BvbmRp bmcKPj4gK8KgwqDCoMKgwqDCoMKgICogYmFja2VuZCBpcyBydW5uaW5nCj4+ICvCoMKgwqDCoMKg wqDCoCAqLwo+PiArwqDCoMKgwqDCoMKgIGRhdGEtPmJhY2tlbmRfZG9taWQgPSBpb21tdV9zcGVj LmFyZ3NbMF07Cj4+Cj4+ICDCoMKgwqDCoMKgwqDCoCBpZiAoeGFfZXJyKHhhX3N0b3JlKCZ4ZW5f Z3JhbnRfZG1hX2RldmljZXMsICh1bnNpZ25lZCBsb25nKWRldiwgZGF0YSwKPj4gIMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgR0ZQX0tFUk5FTCkpKSB7Cj4+ IChFTkQpCj4+Cj4+Cj4+Cj4+IEJlbG93LCB0aGUgbm9kZXMgZ2VuZXJhdGVkIGJ5IFhlbiB0b29s c3RhY2s6Cj4+Cj4+ICDCoMKgwqDCoMKgwqDCoCB4ZW5fZ3JhbnRfZG1hIHsKPj4gIMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBjb21wYXRpYmxlID0gInhlbixncmFudC1kbWEiOwo+PiAg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgICNpb21tdS1jZWxscyA9IDwweDAxPjsKPj4g IMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBwaGFuZGxlID0gPDB4ZmRlOT47Cj4+ICDC oMKgwqDCoMKgwqDCoCB9Owo+Pgo+PiAgwqDCoMKgwqDCoMKgwqAgdmlydGlvQDIwMDAwMDAgewo+ PiAgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGNvbXBhdGlibGUgPSAidmlydGlvLG1t aW8iOwo+PiAgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHJlZyA9IDwweDAwIDB4MjAw MDAwMCAweDAwIDB4MjAwPjsKPj4gIMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBpbnRl cnJ1cHRzID0gPDB4MDAgMHgwMSAweGYwMT47Cj4+ICDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqAgaW50ZXJydXB0LXBhcmVudCA9IDwweGZkZTg+Owo+PiAgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgIGRtYS1jb2hlcmVudDsKPj4gIMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoCBpb21tdXMgPSA8MHhmZGU5IDB4MDE+Owo+PiAgwqDCoMKgwqDCoMKgwqAgfTsKPiAgIAo+ IE5vdCBiYWQhIEkgbGlrZSBpdC4KCgpHb29kLgoKCgo+ICAgCj4gICAKPj4gSSBhbSB3b25kZXJp bmcsIHdvdWxkIGJlIHRoZSBwcm9wZXIgc29sdXRpb24gdG8gZWxpbWluYXRlIGRlZmVycmVkIHBy b2JlCj4+IHRpbWVvdXQgaXNzdWUgaW4gb3VyIHBhcnRpY3VsYXIgY2FzZSAod2l0aG91dCBpbnRy b2R1Y2luZyBhbiBleHRyYSBJT01NVQo+PiBkcml2ZXIpPwo+IEluIHJlYWxpdHkgSSBkb24ndCB0 aGluayB0aGVyZSBpcyBhIHdheSB0byBkbyB0aGF0LiBJIHdvdWxkIGNyZWF0ZSBhbgo+IGVtcHR5 IHNrZWxldGhvbiBJT01NVSBkcml2ZXIgZm9yIHhlbixncmFudC1kbWEuCgpPaywgSSBmb3VuZCB5 ZXQgYW5vdGhlciBvcHRpb24gaG93IHdlIGNhbiBhdm9pZCBkZWZlcnJlZCBwcm9iZSB0aW1lb3V0 IAppc3N1ZS4gSSBhbSBub3Qgc3VyZSB3aGV0aGVyIGl0IHdpbGwgYmUgd2VsY29tZS4gQnV0IGl0 IGRvZXNuJ3QgcmVhbGx5IApyZXF1aXJlIGludHJvZHVjaW5nIHN0dWIgSU9NTVUgZHJpdmVyIG9y IG90aGVyIGNoYW5nZXMgaW4gdGhlIGd1ZXN0LiBUaGUgCmlkZWEgaXMgdG8gbWFrZSBJT01NVSBk ZXZpY2UgdW5hdmFpbGFibGUgKHN0YXR1cyA9ICJkaXNhYmxlZCIpLCB0aGlzIHdheSAKb2ZfaW9t bXVfY29uZmlndXJlKCkgd2lsbCB0cmVhdCB0aGF0IGFzIHN1Y2Nlc3MgY29uZGl0aW9uIGFsc28u CgpodHRwczovL2VsaXhpci5ib290bGluLmNvbS9saW51eC92NS4xOC9zb3VyY2UvZHJpdmVycy9p b21tdS9vZl9pb21tdS5jI0wzMQpodHRwczovL2VsaXhpci5ib290bGluLmNvbS9saW51eC92NS4x OC9zb3VyY2UvZHJpdmVycy9pb21tdS9vZl9pb21tdS5jI0wxNDkKCiDCoMKgwqDCoMKgwqDCoCB4 ZW5fZ3JhbnRfZG1hIHsKIMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBjb21wYXRpYmxl ID0gInhlbixncmFudC1kbWEiOwogwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgICNpb21t dS1jZWxscyA9IDwweDAxPjsKIMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBwaGFuZGxl ID0gPDB4ZmRlOT47CiDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgc3RhdHVzID0gImRp c2FibGVkIjsKIMKgwqDCoMKgwqDCoMKgIH07CiDCoMKgwqDCoMKgwqDCoCB2aXJ0aW9AMjAwMDAw MCB7CiDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgY29tcGF0aWJsZSA9ICJ2aXJ0aW8s bW1pbyI7CiDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgcmVnID0gPDB4MDAgMHgyMDAw MDAwIDB4MDAgMHgyMDA+OwogwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGludGVycnVw dHMgPSA8MHgwMCAweDAxIDB4ZjAxPjsKIMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBp bnRlcnJ1cHQtcGFyZW50ID0gPDB4ZmRlOD47CiDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqAgZG1hLWNvaGVyZW50OwogwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGlvbW11cyA9 IDwweGZkZTkgMHgwMT47CiDCoMKgwqDCoMKgwqDCoCB9OwoKSSBoYXZlIGNoZWNrZWQsIHRoaXMg ImZpeGVzIiBkZWZlcnJlZCBwcm9iZSB0aW1lb3V0IGlzc3VlLgoKCk9yIHdlIGluZGVlZCBuZWVk IHRvIGludHJvZHVjZSBzdHViIElPTU1VIGRyaXZlciAoSSBwbGFjZWQgaXQgdG8gCmRyaXZlci94 ZW4gaW5zdGVhZCBvZiBkcml2ZXIvaW9tbXUsIGFsc28gd2UgY2FuIGV2ZW4gc3F1YXNoIGl0IHdp dGggCmdyYW50LWRtYS1vcHMuYz8pLgpUaGlzIHN0dWIgZHJpdmVyIGFsc28gcmVzdWx0cyBpbiBO T19JT01NVSBjb25kaXRpb24gKGFzICJvZl94bGF0ZSIgCmNhbGxiYWNrIGlzIG5vdCBpbXBsZW1l bnRlZCkuCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy94ZW4vS2NvbmZpZyBiL2RyaXZlcnMveGVuL0tj b25maWcKaW5kZXggYTdiZDhjZS4uMzViOTFiOSAxMDA2NDQKLS0tIGEvZHJpdmVycy94ZW4vS2Nv bmZpZworKysgYi9kcml2ZXJzL3hlbi9LY29uZmlnCkBAIC0zMzUsNiArMzM1LDEwIEBAIGNvbmZp ZyBYRU5fVU5QT1BVTEFURURfQUxMT0MKIMKgwqDCoMKgwqDCoMKgwqDCoCBoYXZpbmcgdG8gYmFs bG9vbiBvdXQgUkFNIHJlZ2lvbnMgaW4gb3JkZXIgdG8gb2J0YWluIHBoeXNpY2FsIAptZW1vcnkK IMKgwqDCoMKgwqDCoMKgwqDCoCBzcGFjZSB0byBjcmVhdGUgc3VjaCBtYXBwaW5ncy4KCitjb25m aWcgWEVOX0dSQU5UX0RNQV9JT01NVQorwqDCoMKgwqDCoMKgIGJvb2wKK8KgwqDCoMKgwqDCoCBz ZWxlY3QgSU9NTVVfQVBJCisKIMKgY29uZmlnIFhFTl9HUkFOVF9ETUFfT1BTCiDCoMKgwqDCoMKg wqDCoCBib29sCiDCoMKgwqDCoMKgwqDCoCBzZWxlY3QgRE1BX09QUwpAQCAtMzQzLDYgKzM0Nyw3 IEBAIGNvbmZpZyBYRU5fVklSVElPCiDCoMKgwqDCoMKgwqDCoCBib29sICJYZW4gdmlydGlvIHN1 cHBvcnQiCiDCoMKgwqDCoMKgwqDCoCBkZXBlbmRzIG9uIFZJUlRJTwogwqDCoMKgwqDCoMKgwqAg c2VsZWN0IFhFTl9HUkFOVF9ETUFfT1BTCivCoMKgwqDCoMKgwqAgc2VsZWN0IFhFTl9HUkFOVF9E TUFfSU9NTVUKIMKgwqDCoMKgwqDCoMKgIGhlbHAKIMKgwqDCoMKgwqDCoMKgwqDCoCBFbmFibGUg dmlydGlvIHN1cHBvcnQgZm9yIHJ1bm5pbmcgYXMgWGVuIGd1ZXN0LiBEZXBlbmRpbmcgb24gdGhl CiDCoMKgwqDCoMKgwqDCoMKgwqAgZ3Vlc3QgdHlwZSB0aGlzIHdpbGwgcmVxdWlyZSBzcGVjaWFs IHN1cHBvcnQgb24gdGhlIGJhY2tlbmQgc2lkZQpkaWZmIC0tZ2l0IGEvZHJpdmVycy94ZW4vTWFr ZWZpbGUgYi9kcml2ZXJzL3hlbi9NYWtlZmlsZQppbmRleCAxYTIzY2IwLi5jMDUwM2YxIDEwMDY0 NAotLS0gYS9kcml2ZXJzL3hlbi9NYWtlZmlsZQorKysgYi9kcml2ZXJzL3hlbi9NYWtlZmlsZQpA QCAtNDAsMyArNDAsNCBAQCB4ZW4tcHJpdmNtZC15wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgIDo9IHByaXZjbWQubyAKcHJpdmNtZC1idWYubwogwqBvYmot JChDT05GSUdfWEVOX0ZST05UX1BHRElSX1NIQlVGKcKgwqDCoCArPSB4ZW4tZnJvbnQtcGdkaXIt c2hidWYubwogwqBvYmotJChDT05GSUdfWEVOX1VOUE9QVUxBVEVEX0FMTE9DKcKgwqDCoCArPSB1 bnBvcHVsYXRlZC1hbGxvYy5vCiDCoG9iai0kKENPTkZJR19YRU5fR1JBTlRfRE1BX09QUynCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgKz0gZ3JhbnQtZG1hLW9wcy5vCitvYmotJChDT05G SUdfWEVOX0dSQU5UX0RNQV9JT01NVSnCoMKgwqDCoMKgICs9IGdyYW50LWRtYS1pb21tdS5vCmRp ZmYgLS1naXQgYS9kcml2ZXJzL3hlbi9ncmFudC1kbWEtaW9tbXUuYyBiL2RyaXZlcnMveGVuL2dy YW50LWRtYS1pb21tdS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwLi5iOGFh ZDhhCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy94ZW4vZ3JhbnQtZG1hLWlvbW11LmMKQEAg LTAsMCArMSw3NiBAQAorLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAKKy8qCisg KiBTdHViIElPTU1VIGRyaXZlciB3aGljaCBkb2VzIG5vdGhpbmcuCisgKiBUaGUgbWFpbiBwdXJw b3NlIG9mIGl0IGJlaW5nIHByZXNlbnQgaXMgdG8gcmV1c2UgZ2VuZXJpYyBkZXZpY2UtdHJlZSAK SU9NTVUKKyAqIGJpbmRpbmdzIGJ5IFhlbiBncmFudCBETUEtbWFwcGluZyBsYXllci4KKyAqLwor CisjaW5jbHVkZSA8bGludXgvaW9tbXUuaD4KKyNpbmNsdWRlIDxsaW51eC9vZi5oPgorI2luY2x1 ZGUgPGxpbnV4L3BsYXRmb3JtX2RldmljZS5oPgorCitzdHJ1Y3QgZ3JhbnRfZG1hX2lvbW11X2Rl dmljZSB7CivCoMKgwqDCoMKgwqAgc3RydWN0IGRldmljZSAqZGV2OworwqDCoMKgwqDCoMKgIHN0 cnVjdCBpb21tdV9kZXZpY2UgaW9tbXU7Cit9OworCisvKiBOb3RoaW5nIGlzIHJlYWxseSBuZWVk ZWQgaGVyZSAqLworc3RhdGljIGNvbnN0IHN0cnVjdCBpb21tdV9vcHMgZ3JhbnRfZG1hX2lvbW11 X29wczsKKworc3RhdGljIGNvbnN0IHN0cnVjdCBvZl9kZXZpY2VfaWQgZ3JhbnRfZG1hX2lvbW11 X29mX21hdGNoW10gPSB7CivCoMKgwqDCoMKgwqAgeyAuY29tcGF0aWJsZSA9ICJ4ZW4sZ3JhbnQt ZG1hIiB9LAorwqDCoMKgwqDCoMKgIHsgfSwKK307CisKK3N0YXRpYyBpbnQgZ3JhbnRfZG1hX2lv bW11X3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCit7CivCoMKgwqDCoMKgwqAg c3RydWN0IGdyYW50X2RtYV9pb21tdV9kZXZpY2UgKm1tdTsKK8KgwqDCoMKgwqDCoCBpbnQgcmV0 OworCivCoMKgwqDCoMKgwqAgbW11ID0gZGV2bV9remFsbG9jKCZwZGV2LT5kZXYsIHNpemVvZigq bW11KSwgR0ZQX0tFUk5FTCk7CivCoMKgwqDCoMKgwqAgaWYgKCFtbXUpCivCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgIHJldHVybiAtRU5PTUVNOworCivCoMKgwqDCoMKgwqAgbW11LT5kZXYg PSAmcGRldi0+ZGV2OworCivCoMKgwqDCoMKgwqAgcmV0ID0gaW9tbXVfZGV2aWNlX3JlZ2lzdGVy KCZtbXUtPmlvbW11LCAmZ3JhbnRfZG1hX2lvbW11X29wcywgCiZwZGV2LT5kZXYpOworwqDCoMKg wqDCoMKgIGlmIChyZXQpCivCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHJldHVybiByZXQ7 CisKK8KgwqDCoMKgwqDCoCBwbGF0Zm9ybV9zZXRfZHJ2ZGF0YShwZGV2LCBtbXUpOworCivCoMKg wqDCoMKgwqAgcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgZ3JhbnRfZG1hX2lvbW11X3JlbW92 ZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQoreworwqDCoMKgwqDCoMKgIHN0cnVjdCBn cmFudF9kbWFfaW9tbXVfZGV2aWNlICptbXUgPSBwbGF0Zm9ybV9nZXRfZHJ2ZGF0YShwZGV2KTsK KworwqDCoMKgwqDCoMKgIHBsYXRmb3JtX3NldF9kcnZkYXRhKHBkZXYsIE5VTEwpOworwqDCoMKg wqDCoMKgIGlvbW11X2RldmljZV91bnJlZ2lzdGVyKCZtbXUtPmlvbW11KTsKKworwqDCoMKgwqDC oMKgIHJldHVybiAwOworfQorCitzdGF0aWMgc3RydWN0IHBsYXRmb3JtX2RyaXZlciBncmFudF9k bWFfaW9tbXVfZHJpdmVyID0geworwqDCoMKgwqDCoMKgIC5kcml2ZXIgPSB7CivCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgIC5uYW1lID0gImdyYW50LWRtYS1pb21tdSIsCivCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgIC5vZl9tYXRjaF90YWJsZSA9IGdyYW50X2RtYV9pb21tdV9vZl9t YXRjaCwKK8KgwqDCoMKgwqDCoCB9LAorwqDCoMKgwqDCoMKgIC5wcm9iZSA9IGdyYW50X2RtYV9p b21tdV9wcm9iZSwKK8KgwqDCoMKgwqDCoCAucmVtb3ZlID0gZ3JhbnRfZG1hX2lvbW11X3JlbW92 ZSwKK307CisKK3N0YXRpYyBpbnQgX19pbml0IGdyYW50X2RtYV9pb21tdV9pbml0KHZvaWQpCit7 CivCoMKgwqDCoMKgwqAgc3RydWN0IGRldmljZV9ub2RlICppb21tdV9ucDsKKworwqDCoMKgwqDC oMKgIGlvbW11X25wID0gb2ZfZmluZF9tYXRjaGluZ19ub2RlKE5VTEwsIGdyYW50X2RtYV9pb21t dV9vZl9tYXRjaCk7CivCoMKgwqDCoMKgwqAgaWYgKCFpb21tdV9ucCkKK8KgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqAgcmV0dXJuIDA7CisKK8KgwqDCoMKgwqDCoCBvZl9ub2RlX3B1dChpb21t dV9ucCk7CisKK8KgwqDCoMKgwqDCoCByZXR1cm4gcGxhdGZvcm1fZHJpdmVyX3JlZ2lzdGVyKCZn cmFudF9kbWFfaW9tbXVfZHJpdmVyKTsKK30KK3N1YnN5c19pbml0Y2FsbChncmFudF9kbWFfaW9t bXVfaW5pdCk7CgpJIGhhdmUgY2hlY2tlZCwgdGhpcyBhbHNvICJmaXhlcyIgZGVmZXJyZWQgcHJv YmUgdGltZW91dCBpc3N1ZS4KClBlcnNvbmFsbHkgSSB3b3VsZCBwcmVmZXIgdGhlIGZpcnN0IG9w dGlvbiwgYnV0IEkgd291bGQgYmUgYWxzbyBoYXBweSB0byAKdXNlIHNlY29uZCBvcHRpb24gaW4g b3JkZXIgdG8gdW5ibG9jayB0aGUgc2VyaWVzLgoKV2hhdCBkbyB0aGUgbWFpbnRhaW5lcnMgdGhp bms/CgoKLS0gClJlZ2FyZHMsCgpPbGVrc2FuZHIgVHlzaGNoZW5rbwoKCl9fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmxpbnV4LWFybS1rZXJuZWwgbWFpbGlu ZyBsaXN0CmxpbnV4LWFybS1rZXJuZWxAbGlzdHMuaW5mcmFkZWFkLm9yZwpodHRwOi8vbGlzdHMu aW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LWFybS1rZXJuZWwK