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 X-Spam-Level: X-Spam-Status: No, score=-12.7 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id AAD47C433E9 for ; Wed, 17 Feb 2021 16:09:20 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 7667964E2F for ; Wed, 17 Feb 2021 16:09:20 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S233959AbhBQQJO (ORCPT ); Wed, 17 Feb 2021 11:09:14 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:41486 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233989AbhBQQJM (ORCPT ); Wed, 17 Feb 2021 11:09:12 -0500 Received: from mail-pf1-x431.google.com (mail-pf1-x431.google.com [IPv6:2607:f8b0:4864:20::431]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id B7E0EC061574 for ; Wed, 17 Feb 2021 08:08:27 -0800 (PST) Received: by mail-pf1-x431.google.com with SMTP id w18so8691620pfu.9 for ; Wed, 17 Feb 2021 08:08:27 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=message-id:subject:from:to:cc:date:in-reply-to:references :user-agent:mime-version:content-transfer-encoding; bh=41wbPOqN7tIGaC5JgYnmGRS7WrEcWCo1vN/O+KRLugQ=; b=IHJFaG22RBeadjx6CsB3GCJN6bM4jCTjTlJ+Gxj4EoaxeluGfgjC8s57oajN5hVJA0 EuFYzEH+pJWgfleBusBPb50s90ygDkamq40v+A0tNuSK3snFW2Qso7lPSeyxnwKaSwMb 6t0Fw4VPZF/Ptfdu9N54UcHjwpvNkB9S+e6L4mE8Q8HJkFipghA/2vXI03VNwyaqORjr wivYfmi4FTWhq6CkJhIOx+xkqWmGrNNyXw/mXZro6G2odP6SMe1dSepZgzSsEN4qUmLV +xvO6tsAStmyeNARAnIdmPmpSaTjNkfg1cWW6HfDQA67KBlKSkLEIO7S5YVF+ocn2+F/ I43A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:message-id:subject:from:to:cc:date:in-reply-to :references:user-agent:mime-version:content-transfer-encoding; bh=41wbPOqN7tIGaC5JgYnmGRS7WrEcWCo1vN/O+KRLugQ=; b=nrcsDzKT3AuKo6Tyaz/7lswoaXfHWczcziNhuSzV3j3vUc0NgIvpV006GpkXz5XPzh AT3hBR1HiDh5z90+eRuqeCUD/q1HAq3bTifIZHrSJmSmfxc1GGu+XIP+GaOTAI+6kHcl cedUrlZ0R6foVcnMDsFB2afEvOlK/2PNp0Z8I2U7FPEcVoJsSQtjGXfzltiiFBvlhMv0 6lIqV5eMhKMQ2BjZdyhzyBzaWiPx8PUe5IXnjSwFON+wq6ziZxcfZBbgxj0OQWGuWrMz b8o0Kj2qkV1NQY2YYtOhKpMpnrLzXWTSjD3DDvNgPeS08uzFiwz2icB2lo8o6t6eTwnG fk2w== X-Gm-Message-State: AOAM532jErm1tlSjM2PVVG00h2Td52+vhj/MioSjwpRa+aVxFyv0Pkvd oYDBzEPBXyNdIFIPqSh7Gcs= X-Google-Smtp-Source: ABdhPJxMROtn2rBy4Rdvx+uRLGEa7YTkiKrPJS/9TbwKxAMSKSeCnATWn4YXzvEqZHaiQEmtAsGZxQ== X-Received: by 2002:a65:5a09:: with SMTP id y9mr59826pgs.243.1613578105444; Wed, 17 Feb 2021 08:08:25 -0800 (PST) Received: from [192.168.1.8] ([50.47.106.83]) by smtp.gmail.com with ESMTPSA id y22sm2990868pgh.19.2021.02.17.08.08.24 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 17 Feb 2021 08:08:24 -0800 (PST) Message-ID: <20aead71c4aa3f640e19660875f807deae92f8d8.camel@gmail.com> Subject: Re: [PATCH v3 1/2] drm/hyperv: Add DRM driver for hyperv synthetic video device From: Deepak Rawat To: Vitaly Kuznetsov , linux-hyperv@vger.kernel.org, dri-devel@lists.freedesktop.org Cc: Daniel Vetter , Thomas Zimmermann , Gerd Hoffmann , Sam Ravnborg , Dexuan Cui , Haiyang Zhang , Wei Hu , Michael Kelley Date: Wed, 17 Feb 2021 08:08:23 -0800 In-Reply-To: <87k0r6kicg.fsf@vitty.brq.redhat.com> References: <20210216003959.802492-1-drawat.floss@gmail.com> <87k0r6kicg.fsf@vitty.brq.redhat.com> Content-Type: text/plain; charset="UTF-8" User-Agent: Evolution 3.38.4 MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-hyperv@vger.kernel.org On Wed, 2021-02-17 at 13:07 +0100, Vitaly Kuznetsov wrote: > Deepak Rawat writes: > > > DRM driver for hyperv synthetic video device, based on hyperv_fb > > framebuffer driver. Also added config option "DRM_HYPERV" to > > enabled > > this driver. > > > > v2: > > - Add support for gen2 VM > > - Fixed review comments > > > > v3: > > - Split into multiple files as suggested by Thomas Zimmermann > > - Fixed hibernation issue as suggested by Dexuan Cui > > - Use ioremap_cache as suggested by Dexuan Cui > > - Incorporated other review comments > > > > Signed-off-by: Deepak Rawat > > --- > >  drivers/gpu/drm/Kconfig                     |  12 + > >  drivers/gpu/drm/Makefile                    |   1 + > >  drivers/gpu/drm/hyperv/Makefile             |   8 + > >  drivers/gpu/drm/hyperv/hyperv_drm.h         |  51 ++ > >  drivers/gpu/drm/hyperv/hyperv_drm_drv.c     | 313 +++++++++++++ > >  drivers/gpu/drm/hyperv/hyperv_drm_modeset.c | 240 ++++++++++ > >  drivers/gpu/drm/hyperv/hyperv_drm_proto.c   | 486 > > ++++++++++++++++++++ > >  7 files changed, 1111 insertions(+) > >  create mode 100644 drivers/gpu/drm/hyperv/Makefile > >  create mode 100644 drivers/gpu/drm/hyperv/hyperv_drm.h > >  create mode 100644 drivers/gpu/drm/hyperv/hyperv_drm_drv.c > >  create mode 100644 drivers/gpu/drm/hyperv/hyperv_drm_modeset.c > >  create mode 100644 drivers/gpu/drm/hyperv/hyperv_drm_proto.c > > > > diff --git a/drivers/gpu/drm/Kconfig b/drivers/gpu/drm/Kconfig > > index 8bf103de1594..c17f4e9dcd82 100644 > > --- a/drivers/gpu/drm/Kconfig > > +++ b/drivers/gpu/drm/Kconfig > > @@ -382,6 +382,18 @@ source "drivers/gpu/drm/tidss/Kconfig" > >   > >  source "drivers/gpu/drm/xlnx/Kconfig" > >   > > +config DRM_HYPERV > > +       tristate "DRM Support for hyperv synthetic video device" > > +       depends on DRM && PCI && MMU && HYPERV > > +       select DRM_KMS_HELPER > > +       select DRM_GEM_SHMEM_HELPER > > +       help > > +        This is a KMS driver for hyperv synthetic video device. > > Choose this > > +        option if you would like to enable drm driver for Hyper-V > > virtual > > +        machine. > > + > > +        If M is selected the module will be called hyperv_drm. > > + > >  # Keep legacy drivers last > >   > >  menuconfig DRM_LEGACY > > diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile > > index 926adef289db..294e321cd23f 100644 > > --- a/drivers/gpu/drm/Makefile > > +++ b/drivers/gpu/drm/Makefile > > @@ -125,3 +125,4 @@ obj-$(CONFIG_DRM_ASPEED_GFX) += aspeed/ > >  obj-$(CONFIG_DRM_MCDE) += mcde/ > >  obj-$(CONFIG_DRM_TIDSS) += tidss/ > >  obj-y                  += xlnx/ > > +obj-$(CONFIG_DRM_HYPERV) += hyperv/ > > diff --git a/drivers/gpu/drm/hyperv/Makefile > > b/drivers/gpu/drm/hyperv/Makefile > > new file mode 100644 > > index 000000000000..0039b03db0be > > --- /dev/null > > +++ b/drivers/gpu/drm/hyperv/Makefile > > @@ -0,0 +1,8 @@ > > +# SPDX-License-Identifier: GPL-2.0-only > > + > > +hyperv_drm-y := \ > > +       hyperv_drm_proto.o \ > > +       hyperv_drm_modeset.o \ > > +       hyperv_drm_drv.o > > + > > +obj-$(CONFIG_DRM_HYPERV) += hyperv_drm.o > > diff --git a/drivers/gpu/drm/hyperv/hyperv_drm.h > > b/drivers/gpu/drm/hyperv/hyperv_drm.h > > new file mode 100644 > > index 000000000000..4f8c627b303a > > --- /dev/null > > +++ b/drivers/gpu/drm/hyperv/hyperv_drm.h > > @@ -0,0 +1,51 @@ > > +/* SPDX-License-Identifier: GPL-2.0 */ > > +/* > > + * Copyright 2012-2021 Microsoft > > Out of pure curiosity, where does '2012' come from or what does it > mean? > Thanks Vitaly for the review. Actually some of the code is derived from hyperv_fb, which has copyright 2012. Not sure if I should remove here or not? > > + */ > > + > > +#ifndef _HYPERV_DRM_H_ > > +#define _HYPERV_DRM_H_ > > + > > +#define VMBUS_MAX_PACKET_SIZE 0x4000 > > + > > +struct hyperv_drm_device { > > +       /* drm */ > > +       struct drm_device dev; > > +       struct drm_simple_display_pipe pipe; > > +       struct drm_connector connector; > > + > > +       /* mode */ > > +       u32 screen_width_max; > > +       u32 screen_height_max; > > +       u32 preferred_width; > > +       u32 preferred_height; > > +       u32 screen_depth; > > + > > +       /* hw */ > > +       struct resource *mem; > > +       void __iomem *vram; > > +       unsigned long fb_base; > > +       unsigned long fb_size; > > +       struct completion wait; > > +       u32 synthvid_version; > > +       u32 mmio_megabytes; > > + > > +       u8 init_buf[VMBUS_MAX_PACKET_SIZE]; > > +       u8 recv_buf[VMBUS_MAX_PACKET_SIZE]; > > + > > +       struct hv_device *hdev; > > +}; > > + > > +#define to_hv(_dev) container_of(_dev, struct hyperv_drm_device, > > dev) > > + > > +/* hyperv_drm_modeset */ > > +int hyperv_mode_config_init(struct hyperv_drm_device *hv); > > + > > +/* hyperv_drm_proto */ > > +int hyperv_update_vram_location(struct hv_device *hdev, > > phys_addr_t vram_pp); > > +int hyperv_update_situation(struct hv_device *hdev, u8 active, u32 > > bpp, > > +                           u32 w, u32 h, u32 pitch); > > +int hyperv_update_dirt(struct hv_device *hdev, struct drm_rect > > *rect); > > +int hyperv_connect_vsp(struct hv_device *hdev); > > As we already have > balloon_connect_vsp()/netvsc_connect_vsp()/synthvid_connect_vsp(), > could > we maybe rename 'hyperv_connect_vsp()' to something more DRM- > specific? > Since all the functions here in drm driver are prefixed with hyperv, same is done with connect_vsp(). Sure I think better to rename this to something drm specific. > > + > > +#endif > > diff --git a/drivers/gpu/drm/hyperv/hyperv_drm_drv.c > > b/drivers/gpu/drm/hyperv/hyperv_drm_drv.c > > new file mode 100644 > > index 000000000000..b72c1a169125 > > --- /dev/null > > +++ b/drivers/gpu/drm/hyperv/hyperv_drm_drv.c > > @@ -0,0 +1,313 @@ > > +// SPDX-License-Identifier: GPL-2.0 > > +/* > > + * Copyright 2012-2021 Microsoft > > + */ > > + > > +#include > > +#include > > +#include > > +#include > > + > > +#include > > +#include > > +#include > > +#include > > +#include > > + > > +#include "hyperv_drm.h" > > + > > +#define DRIVER_NAME "hyperv_drm" > > +#define DRIVER_DESC "DRM driver for hyperv synthetic video device" > > +#define DRIVER_DATE "2020" > > +#define DRIVER_MAJOR 1 > > +#define DRIVER_MINOR 0 > > + > > +#define PCI_VENDOR_ID_MICROSOFT 0x1414 > > +#define PCI_DEVICE_ID_HYPERV_VIDEO 0x5353 > > + > > +DEFINE_DRM_GEM_FOPS(hv_fops); > > + > > +static struct drm_driver hyperv_driver = { > > +       .driver_features = DRIVER_MODESET | DRIVER_GEM | > > DRIVER_ATOMIC, > > + > > +       .name            = DRIVER_NAME, > > +       .desc            = DRIVER_DESC, > > +       .date            = DRIVER_DATE, > > +       .major           = DRIVER_MAJOR, > > +       .minor           = DRIVER_MINOR, > > + > > +       .fops            = &hv_fops, > > +       DRM_GEM_SHMEM_DRIVER_OPS, > > +}; > > + > > +static int hyperv_pci_probe(struct pci_dev *pdev, > > +                           const struct pci_device_id *ent) > > +{ > > +       return 0; > > +} > > + > > +static void hyperv_pci_remove(struct pci_dev *pdev) > > +{ > > +} > > + > > +static const struct pci_device_id hyperv_pci_tbl[] = { > > +       { > > +               .vendor = PCI_VENDOR_ID_MICROSOFT, > > +               .device = PCI_DEVICE_ID_HYPERV_VIDEO, > > +       }, > > +       { /* end of list */ } > > +}; > > + > > +static struct pci_driver hyperv_pci_driver = { > > +       .name =         KBUILD_MODNAME, > > +       .id_table =     hyperv_pci_tbl, > > +       .probe =        hyperv_pci_probe, > > +       .remove =       hyperv_pci_remove, > > +}; > > + > > +static int hyperv_get_vram_gen1(struct hyperv_drm_device *hv) > > +{ > > +       struct drm_device *dev = &hv->dev; > > +       struct pci_dev *pdev; > > +       int ret; > > + > > +       pdev = pci_get_device(PCI_VENDOR_ID_MICROSOFT, > > +                             PCI_DEVICE_ID_HYPERV_VIDEO, NULL); > > +       if (!pdev) { > > +               drm_err(dev, "Unable to find PCI Hyper-V video\n"); > > +               return -ENODEV; > > +       } > > + > > +       ret = > > drm_fb_helper_remove_conflicting_pci_framebuffers(pdev, > > "hypervdrmfb"); > > +       if (ret) { > > +               drm_err(dev, "Not able to remove boot fb\n"); > > +               return ret; > > +       } > > + > > +       if (pci_request_region(pdev, 0, DRIVER_NAME) != 0) > > +               drm_warn(dev, "Cannot request framebuffer, boot fb > > still active?\n"); > > + > > +       if ((pdev->resource[0].flags & IORESOURCE_MEM) == 0) { > > +               drm_err(dev, "Resource at bar 0 is not > > IORESOURCE_MEM\n"); > > +               ret = -ENODEV; > > +               goto error; > > +       } > > + > > +       hv->fb_base = pci_resource_start(pdev, 0); > > +       hv->fb_size = pci_resource_len(pdev, 0); > > +       if (hv->fb_base == 0) { > > +               drm_err(dev, "Resource not available\n"); > > +               ret = -ENODEV; > > +               goto error; > > +       } > > + > > +       hv->fb_size = min(hv->fb_size, > > +                         (unsigned long)(hv->mmio_megabytes * 1024 > > * 1024)); > > +       hv->vram = devm_ioremap(&pdev->dev, hv->fb_base, hv- > > >fb_size); > > +       if (!hv->vram) { > > +               drm_err(dev, "Failed to map vram\n"); > > +               ret = -ENOMEM; > > +       } > > + > > +error: > > +       pci_dev_put(pdev); > > +       return ret; > > +} > > + > > +static int hyperv_get_vram_gen2(struct hyperv_drm_device *hv, > > +                               struct hv_device *hdev) > > +{ > > +       struct drm_device *dev = &hv->dev; > > +       struct apertures_struct *ap; > > +       int ret; > > + > > +       hv->fb_size = (unsigned long)(hv->mmio_megabytes * 1024 * > > 1024); > > In case 'unsigned long' casting was needed because you're afraid > 'u32' > can overflow, it should be applied before we actually do the > multiplication: > >  (unsigned long)hv->mmio_megabytes * 1024 * 1024 > > otherwise the cast seems useless fb_size is 'unsigned long'. > > > + > > +       ret = vmbus_allocate_mmio(&hv->mem, hdev, 0, -1, hv- > > >fb_size, 0x100000, > > +                                 true); > > +       if (ret) { > > +               drm_err(dev, "Failed to allocate mmio\n"); > > +               return -ENOMEM; > > +       } > > + > > +       /* > > +        * Map the VRAM cacheable for performance. This is also > > required for VM > > +        * connect to display properly for ARM64 Linux VM, as the > > host also maps > > +        * the VRAM cacheable. > > +        */ > > +       hv->vram = ioremap_cache(hv->mem->start, hv->fb_size); > > +       if (!hv->vram) { > > +               drm_err(dev, "Failed to map vram\n"); > > +               ret = -ENOMEM; > > +               goto error; > > +       } > > + > > +       hv->fb_base = hv->mem->start; > > + > > +       ap = alloc_apertures(1); > > +       if (!ap) { > > +               drm_err(dev, "Failed to get apertures\n"); > > +               ret = -ENOMEM; > > +               goto error; > > +       } > > + > > +       ap->ranges[0].base = screen_info.lfb_base; > > +       ap->ranges[0].size = screen_info.lfb_size; > > +       remove_conflicting_framebuffers(ap, KBUILD_MODNAME, false); > > +       kfree(ap); > > + > > +       return 0; > > + > > +error: > > +       vmbus_free_mmio(hv->mem->start, hv->fb_size); > > +       return ret; > > +} > > + > > +static int hyperv_vmbus_probe(struct hv_device *hdev, > > +                             const struct hv_vmbus_device_id > > *dev_id) > > +{ > > +       struct hyperv_drm_device *hv; > > +       struct drm_device *dev; > > +       int ret; > > + > > +       hv = devm_drm_dev_alloc(&hdev->device, &hyperv_driver, > > +                               struct hyperv_drm_device, dev); > > +       if (IS_ERR(hv)) > > +               return PTR_ERR(hv); > > + > > +       dev = &hv->dev; > > +       init_completion(&hv->wait); > > +       hv_set_drvdata(hdev, hv); > > +       hv->hdev = hdev; > > + > > +       /* Get the actual VRAM size from the device */ > > +       ret = hyperv_connect_vsp(hdev); > > +       if (ret) { > > +               drm_err(dev, "Failed to connect to vmbus.\n"); > > +               goto err_hv_set_drv_data; > > +       } > > + > > +       if (efi_enabled(EFI_BOOT)) > > +               ret = hyperv_get_vram_gen2(hv, hdev); > > +       else > > +               ret = hyperv_get_vram_gen1(hv); > > + > > +       if (ret) > > +               goto err_vmbus_close; > > + > > +       /* > > +        * Should be done only once during init and resume. Failing > > to update > > +        * vram location is not fatal. Device will update dirty > > area till > > +        * preferred resolution only. > > +        */ > > +       ret = hyperv_update_vram_location(hdev, hv->fb_base); > > +       if (ret) > > +               drm_warn(dev, "Failed to update vram location.\n"); > > + > > +       ret = hyperv_mode_config_init(hv); > > +       if (ret) > > +               goto err_vmbus_close; > > + > > +       ret = drm_dev_register(dev, 0); > > +       if (ret) { > > +               drm_err(dev, "Failed to register drm driver.\n"); > > +               goto err_vmbus_close; > > +       } > > + > > +       drm_fbdev_generic_setup(dev, 0); > > + > > +       return 0; > > + > > +err_vmbus_close: > > +       vmbus_close(hdev->channel); > > +err_hv_set_drv_data: > > +       hv_set_drvdata(hdev, NULL); > > +       return ret; > > +} > > + > > +static int hyperv_vmbus_remove(struct hv_device *hdev) > > +{ > > +       struct drm_device *dev = hv_get_drvdata(hdev); > > +       struct hyperv_drm_device *hv = to_hv(dev); > > + > > +       drm_dev_unplug(dev); > > +       drm_atomic_helper_shutdown(dev); > > +       vmbus_close(hdev->channel); > > +       hv_set_drvdata(hdev, NULL); > > +       vmbus_free_mmio(hv->mem->start, hv->fb_size); > > + > > +       return 0; > > +} > > + > > +static int hyperv_vmbus_suspend(struct hv_device *hdev) > > +{ > > +       struct drm_device *dev = hv_get_drvdata(hdev); > > +       int ret; > > + > > +       ret = drm_mode_config_helper_suspend(dev); > > + > > +       vmbus_close(hdev->channel); > > + > > +       return ret; > > +} > > + > > +static int hyperv_vmbus_resume(struct hv_device *hdev) > > +{ > > +       struct drm_device *dev = hv_get_drvdata(hdev); > > +       struct hyperv_drm_device *hv = to_hv(dev); > > +       int ret; > > + > > +       ret = hyperv_connect_vsp(hdev); > > +       if (ret) > > +               return ret; > > + > > +       ret = hyperv_update_vram_location(hdev, hv->fb_base); > > +       if (ret) > > +               return ret; > > + > > +       return drm_mode_config_helper_resume(dev); > > +} > > + > > +static const struct hv_vmbus_device_id hyperv_vmbus_tbl[] = { > > +       /* Synthetic Video Device GUID */ > > +       {HV_SYNTHVID_GUID}, > > +       {} > > +}; > > + > > +static struct hv_driver hyperv_hv_driver = { > > +       .name = KBUILD_MODNAME, > > +       .id_table = hyperv_vmbus_tbl, > > +       .probe = hyperv_vmbus_probe, > > +       .remove = hyperv_vmbus_remove, > > +       .suspend = hyperv_vmbus_suspend, > > +       .resume = hyperv_vmbus_resume, > > +       .driver = { > > +               .probe_type = PROBE_PREFER_ASYNCHRONOUS, > > +       }, > > +}; > > + > > +static int __init hyperv_init(void) > > +{ > > +       int ret; > > + > > +       ret = pci_register_driver(&hyperv_pci_driver); > > +       if (ret != 0) > > +               return ret; > > + > > +       return vmbus_driver_register(&hyperv_hv_driver); > > +} > > + > > +static void __exit hyperv_exit(void) > > +{ > > +       vmbus_driver_unregister(&hyperv_hv_driver); > > +       pci_unregister_driver(&hyperv_pci_driver); > > +} > > + > > +module_init(hyperv_init); > > +module_exit(hyperv_exit); > > + > > +MODULE_DEVICE_TABLE(pci, hyperv_pci_tbl); > > +MODULE_DEVICE_TABLE(vmbus, hyperv_vmbus_tbl); > > +MODULE_LICENSE("GPL"); > > +MODULE_AUTHOR("Deepak Rawat "); > > +MODULE_DESCRIPTION("DRM driver for hyperv synthetic video > > device"); > > diff --git a/drivers/gpu/drm/hyperv/hyperv_drm_modeset.c > > b/drivers/gpu/drm/hyperv/hyperv_drm_modeset.c > > new file mode 100644 > > index 000000000000..40ec0cff0e59 > > --- /dev/null > > +++ b/drivers/gpu/drm/hyperv/hyperv_drm_modeset.c > > @@ -0,0 +1,240 @@ > > +// SPDX-License-Identifier: GPL-2.0 > > +/* > > + * Copyright 2012-2021 Microsoft > > + */ > > + > > +#include > > + > > +#include > > +#include > > +#include > > +#include > > +#include > > +#include > > +#include > > +#include > > +#include > > + > > +#include "hyperv_drm.h" > > + > > +static int hyperv_blit_to_vram_rect(struct drm_framebuffer *fb, > > +                                   struct drm_rect *rect) > > +{ > > +       struct hyperv_drm_device *hv = to_hv(fb->dev); > > +       struct dma_buf_map map; > > +       void *vmap; > > +       int idx, ret; > > + > > +       if (!drm_dev_enter(&hv->dev, &idx)) > > +               return -ENODEV; > > + > > +       ret = drm_gem_shmem_vmap(fb->obj[0], &map); > > +       if (ret) { > > +               drm_dev_exit(idx); > > +               return ret; > > +       } > > + > > +       vmap = map.vaddr; > > +       drm_fb_memcpy_dstclip(hv->vram, vmap, fb, rect); > > +       drm_gem_shmem_vunmap(fb->obj[0], vmap); > > +       drm_dev_exit(idx); > > + > > +       return 0; > > +} > > + > > +static int hyperv_blit_to_vram_fullscreen(struct drm_framebuffer > > *fb) > > +{ > > +       struct drm_rect fullscreen = { > > +               .x1 = 0, > > +               .x2 = fb->width, > > +               .y1 = 0, > > +               .y2 = fb->height, > > +       }; > > +       return hyperv_blit_to_vram_rect(fb, &fullscreen); > > +} > > + > > +static int hyperv_connector_get_modes(struct drm_connector > > *connector) > > +{ > > +       struct hyperv_drm_device *hv = to_hv(connector->dev); > > +       int count; > > + > > +       count = drm_add_modes_noedid(connector, > > +                                    connector->dev- > > >mode_config.max_width, > > +                                    connector->dev- > > >mode_config.max_height); > > +       drm_set_preferred_mode(connector, hv->preferred_width, > > +                              hv->preferred_height); > > + > > +       return count; > > +} > > + > > +static const struct drm_connector_helper_funcs > > hyperv_connector_helper_funcs = { > > +       .get_modes = hyperv_connector_get_modes, > > +}; > > + > > +static const struct drm_connector_funcs hyperv_connector_funcs = { > > +       .fill_modes = drm_helper_probe_single_connector_modes, > > +       .destroy = drm_connector_cleanup, > > +       .reset = drm_atomic_helper_connector_reset, > > +       .atomic_duplicate_state = > > drm_atomic_helper_connector_duplicate_state, > > +       .atomic_destroy_state = > > drm_atomic_helper_connector_destroy_state, > > +}; > > + > > +static int hyperv_conn_init(struct hyperv_drm_device *hv) > > +{ > > +       drm_connector_helper_add(&hv->connector, > > &hyperv_connector_helper_funcs); > > +       return drm_connector_init(&hv->dev, &hv->connector, > > +                                 &hyperv_connector_funcs, > > +                                 DRM_MODE_CONNECTOR_VGA); > > +} > > + > > +static int hyperv_check_size(struct hyperv_drm_device *hv, int w, > > int h, > > +                            struct drm_framebuffer *fb) > > +{ > > +       u32 pitch = w * (hv->screen_depth / 8); > > + > > +       if (fb) > > +               pitch = fb->pitches[0]; > > + > > +       if (pitch * h > hv->fb_size) > > +               return -EINVAL; > > + > > +       return 0; > > +} > > + > > +static void hyperv_pipe_enable(struct drm_simple_display_pipe > > *pipe, > > +                              struct drm_crtc_state *crtc_state, > > +                              struct drm_plane_state *plane_state) > > +{ > > +       struct hyperv_drm_device *hv = to_hv(pipe->crtc.dev); > > + > > +       hyperv_update_situation(hv->hdev, 1,  hv->screen_depth, > > +                               crtc_state->mode.hdisplay, > > +                               crtc_state->mode.vdisplay, > > +                               plane_state->fb->pitches[0]); > > +       hyperv_blit_to_vram_fullscreen(plane_state->fb); > > +} > > + > > +static int hyperv_pipe_check(struct drm_simple_display_pipe *pipe, > > +                            struct drm_plane_state *plane_state, > > +                            struct drm_crtc_state *crtc_state) > > +{ > > +       struct hyperv_drm_device *hv = to_hv(pipe->crtc.dev); > > +       struct drm_framebuffer *fb = plane_state->fb; > > + > > +       if (fb->format->format != DRM_FORMAT_XRGB8888) > > +               return -EINVAL; > > + > > +       if (fb->pitches[0] * fb->height > hv->fb_size) > > +               return -EINVAL; > > + > > +       return 0; > > +} > > + > > +static void hyperv_pipe_update(struct drm_simple_display_pipe > > *pipe, > > +                              struct drm_plane_state *old_state) > > +{ > > +       struct hyperv_drm_device *hv = to_hv(pipe->crtc.dev); > > +       struct drm_plane_state *state = pipe->plane.state; > > +       struct drm_rect rect; > > + > > +       if (drm_atomic_helper_damage_merged(old_state, state, > > &rect)) { > > +               hyperv_blit_to_vram_rect(state->fb, &rect); > > +               hyperv_update_dirt(hv->hdev, &rect); > > +       } > > +} > > + > > +static const struct drm_simple_display_pipe_funcs > > hyperv_pipe_funcs = { > > +       .enable = hyperv_pipe_enable, > > +       .check = hyperv_pipe_check, > > +       .update = hyperv_pipe_update, > > +}; > > + > > +static const uint32_t hyperv_formats[] = { > > +       DRM_FORMAT_XRGB8888, > > +}; > > + > > +static const uint64_t hyperv_modifiers[] = { > > +       DRM_FORMAT_MOD_LINEAR, > > +       DRM_FORMAT_MOD_INVALID > > +}; > > + > > +static int hyperv_pipe_init(struct hyperv_drm_device *hv) > > +{ > > +       int ret; > > + > > +       ret = drm_simple_display_pipe_init(&hv->dev, > > +                                          &hv->pipe, > > +                                          &hyperv_pipe_funcs, > > +                                          hyperv_formats, > > +                                          > > ARRAY_SIZE(hyperv_formats), > > +                                          NULL, > > +                                          &hv->connector); > > + > > +       drm_plane_enable_fb_damage_clips(&hv->pipe.plane); > > + > > +       return ret; > > +} > > + > > +static struct drm_framebuffer* > > +hyperv_fb_create(struct drm_device *dev, struct drm_file > > *file_priv, > > +                const struct drm_mode_fb_cmd2 *mode_cmd) > > +{ > > +       return drm_gem_fb_create_with_dirty(dev, file_priv, > > mode_cmd); > > +} > > + > > +static enum drm_mode_status > > +hyperv_mode_valid(struct drm_device *dev, > > +                 const struct drm_display_mode *mode) > > +{ > > +       struct hyperv_drm_device *hv = to_hv(dev); > > + > > +       if (hyperv_check_size(hv, mode->hdisplay, mode->vdisplay, > > NULL)) > > +               return MODE_BAD; > > + > > +       return MODE_OK; > > +} > > + > > +static const struct drm_mode_config_funcs hyperv_mode_config_funcs > > = { > > +       .fb_create = hyperv_fb_create, > > +       .mode_valid = hyperv_mode_valid, > > +       .atomic_check = drm_atomic_helper_check, > > +       .atomic_commit = drm_atomic_helper_commit, > > +}; > > + > > +int hyperv_mode_config_init(struct hyperv_drm_device *hv) > > +{ > > +       struct drm_device *dev = &hv->dev; > > +       int ret; > > + > > +       ret = drmm_mode_config_init(dev); > > +       if (ret) { > > +               drm_err(dev, "Failed to initialized mode > > setting.\n"); > > +               return ret; > > +       } > > + > > +       dev->mode_config.min_width = 0; > > +       dev->mode_config.min_height = 0; > > +       dev->mode_config.max_width = hv->screen_width_max; > > +       dev->mode_config.max_height = hv->screen_height_max; > > + > > +       dev->mode_config.preferred_depth = hv->screen_depth; > > +       dev->mode_config.prefer_shadow = 0; > > + > > +       dev->mode_config.funcs = &hyperv_mode_config_funcs; > > + > > +       ret = hyperv_conn_init(hv); > > +       if (ret) { > > +               drm_err(dev, "Failed to initialized connector.\n"); > > +               return ret; > > +       } > > + > > +       ret = hyperv_pipe_init(hv); > > +       if (ret) { > > +               drm_err(dev, "Failed to initialized pipe.\n"); > > +               return ret; > > +       } > > + > > +       drm_mode_config_reset(dev); > > + > > +       return 0; > > +} > > diff --git a/drivers/gpu/drm/hyperv/hyperv_drm_proto.c > > b/drivers/gpu/drm/hyperv/hyperv_drm_proto.c > > new file mode 100644 > > index 000000000000..4e61992be121 > > --- /dev/null > > +++ b/drivers/gpu/drm/hyperv/hyperv_drm_proto.c > > @@ -0,0 +1,486 @@ > > +// SPDX-License-Identifier: GPL-2.0 > > +/* > > + * Copyright 2012-2021 Microsoft > > + */ > > + > > +#include > > + > > +#include > > +#include > > + > > +#include "hyperv_drm.h" > > + > > +#define VMBUS_RING_BUFSIZE (256 * 1024) > > +#define VMBUS_VSP_TIMEOUT (10 * HZ) > > + > > +#define SYNTHVID_VERSION(major, minor) ((minor) << 16 | (major)) > > +#define SYNTHVID_VER_GET_MAJOR(ver) (ver & 0x0000ffff) > > +#define SYNTHVID_VER_GET_MINOR(ver) ((ver & 0xffff0000) >> 16) > > +#define SYNTHVID_VERSION_WIN7 SYNTHVID_VERSION(3, 0) > > +#define SYNTHVID_VERSION_WIN8 SYNTHVID_VERSION(3, 2) > > +#define SYNTHVID_VERSION_WIN10 SYNTHVID_VERSION(3, 5) > > + > > +#define SYNTHVID_DEPTH_WIN7 16 > > +#define SYNTHVID_DEPTH_WIN8 32 > > +#define SYNTHVID_FB_SIZE_WIN7 (4 * 1024 * 1024) > > +#define SYNTHVID_FB_SIZE_WIN8 (8 * 1024 * 1024) > > +#define SYNTHVID_WIDTH_MAX_WIN7 1600 > > +#define SYNTHVID_HEIGHT_MAX_WIN7 1200 > > + > > +enum pipe_msg_type { > > +       PIPE_MSG_INVALID, > > +       PIPE_MSG_DATA, > > +       PIPE_MSG_MAX > > +}; > > + > > +enum synthvid_msg_type { > > +       SYNTHVID_ERROR                  = 0, > > +       SYNTHVID_VERSION_REQUEST        = 1, > > +       SYNTHVID_VERSION_RESPONSE       = 2, > > +       SYNTHVID_VRAM_LOCATION          = 3, > > +       SYNTHVID_VRAM_LOCATION_ACK      = 4, > > +       SYNTHVID_SITUATION_UPDATE       = 5, > > +       SYNTHVID_SITUATION_UPDATE_ACK   = 6, > > +       SYNTHVID_POINTER_POSITION       = 7, > > +       SYNTHVID_POINTER_SHAPE          = 8, > > +       SYNTHVID_FEATURE_CHANGE         = 9, > > +       SYNTHVID_DIRT                   = 10, > > +       SYNTHVID_RESOLUTION_REQUEST     = 13, > > +       SYNTHVID_RESOLUTION_RESPONSE    = 14, > > + > > +       SYNTHVID_MAX                    = 15 > > +}; > > + > > +struct pipe_msg_hdr { > > +       u32 type; > > +       u32 size; /* size of message after this field */ > > +} __packed; > > + > > +struct hvd_screen_info { > > +       u16 width; > > +       u16 height; > > +} __packed; > > + > > +struct synthvid_msg_hdr { > > +       u32 type; > > +       u32 size;  /* size of this header + payload after this > > field */ > > +} __packed; > > + > > +struct synthvid_version_req { > > +       u32 version; > > +} __packed; > > + > > +struct synthvid_version_resp { > > +       u32 version; > > +       u8 is_accepted; > > +       u8 max_video_outputs; > > +} __packed; > > + > > +struct synthvid_vram_location { > > +       u64 user_ctx; > > +       u8 is_vram_gpa_specified; > > +       u64 vram_gpa; > > +} __packed; > > + > > +struct synthvid_vram_location_ack { > > +       u64 user_ctx; > > +} __packed; > > + > > +struct video_output_situation { > > +       u8 active; > > +       u32 vram_offset; > > +       u8 depth_bits; > > +       u32 width_pixels; > > +       u32 height_pixels; > > +       u32 pitch_bytes; > > +} __packed; > > + > > +struct synthvid_situation_update { > > +       u64 user_ctx; > > +       u8 video_output_count; > > +       struct video_output_situation video_output[1]; > > +} __packed; > > + > > +struct synthvid_situation_update_ack { > > +       u64 user_ctx; > > +} __packed; > > + > > +struct synthvid_pointer_position { > > +       u8 is_visible; > > +       u8 video_output; > > +       s32 image_x; > > +       s32 image_y; > > +} __packed; > > + > > +#define SYNTHVID_CURSOR_MAX_X 96 > > +#define SYNTHVID_CURSOR_MAX_Y 96 > > +#define SYNTHVID_CURSOR_ARGB_PIXEL_SIZE 4 > > +#define SYNTHVID_CURSOR_MAX_SIZE (SYNTHVID_CURSOR_MAX_X * \ > > +       SYNTHVID_CURSOR_MAX_Y * SYNTHVID_CURSOR_ARGB_PIXEL_SIZE) > > +#define SYNTHVID_CURSOR_COMPLETE (-1) > > + > > +struct synthvid_pointer_shape { > > +       u8 part_idx; > > +       u8 is_argb; > > +       u32 width; /* SYNTHVID_CURSOR_MAX_X at most */ > > +       u32 height; /* SYNTHVID_CURSOR_MAX_Y at most */ > > +       u32 hot_x; /* hotspot relative to upper-left of pointer > > image */ > > +       u32 hot_y; > > +       u8 data[4]; > > +} __packed; > > + > > +struct synthvid_feature_change { > > +       u8 is_dirt_needed; > > +       u8 is_ptr_pos_needed; > > +       u8 is_ptr_shape_needed; > > +       u8 is_situ_needed; > > +} __packed; > > + > > +struct rect { > > +       s32 x1, y1; /* top left corner */ > > +       s32 x2, y2; /* bottom right corner, exclusive */ > > +} __packed; > > + > > +struct synthvid_dirt { > > +       u8 video_output; > > +       u8 dirt_count; > > +       struct rect rect[1]; > > +} __packed; > > + > > +#define SYNTHVID_EDID_BLOCK_SIZE       128 > > +#define        SYNTHVID_MAX_RESOLUTION_COUNT   64 > > + > > +struct synthvid_supported_resolution_req { > > +       u8 maximum_resolution_count; > > +} __packed; > > + > > +struct synthvid_supported_resolution_resp { > > +       u8 edid_block[SYNTHVID_EDID_BLOCK_SIZE]; > > +       u8 resolution_count; > > +       u8 default_resolution_index; > > +       u8 is_standard; > > +       struct hvd_screen_info > > supported_resolution[SYNTHVID_MAX_RESOLUTION_COUNT]; > > +} __packed; > > + > > +struct synthvid_msg { > > +       struct pipe_msg_hdr pipe_hdr; > > +       struct synthvid_msg_hdr vid_hdr; > > +       union { > > +               struct synthvid_version_req ver_req; > > +               struct synthvid_version_resp ver_resp; > > +               struct synthvid_vram_location vram; > > +               struct synthvid_vram_location_ack vram_ack; > > +               struct synthvid_situation_update situ; > > +               struct synthvid_situation_update_ack situ_ack; > > +               struct synthvid_pointer_position ptr_pos; > > +               struct synthvid_pointer_shape ptr_shape; > > +               struct synthvid_feature_change feature_chg; > > +               struct synthvid_dirt dirt; > > +               struct synthvid_supported_resolution_req > > resolution_req; > > +               struct synthvid_supported_resolution_resp > > resolution_resp; > > +       }; > > +} __packed; > > + > > +static inline bool hyperv_version_ge(u32 ver1, u32 ver2) > > +{ > > +       if (SYNTHVID_VER_GET_MAJOR(ver1) > > > SYNTHVID_VER_GET_MAJOR(ver2) || > > +           (SYNTHVID_VER_GET_MAJOR(ver1) == > > SYNTHVID_VER_GET_MAJOR(ver2) && > > +            SYNTHVID_VER_GET_MINOR(ver1) >= > > SYNTHVID_VER_GET_MINOR(ver2))) > > +               return true; > > + > > +       return false; > > +} > > + > > +static inline int hyperv_sendpacket(struct hv_device *hdev, struct > > synthvid_msg *msg) > > +{ > > +       static atomic64_t request_id = ATOMIC64_INIT(0); > > +       struct hyperv_drm_device *hv = hv_get_drvdata(hdev); > > +       int ret; > > + > > +       msg->pipe_hdr.type = PIPE_MSG_DATA; > > +       msg->pipe_hdr.size = msg->vid_hdr.size; > > + > > +       ret = vmbus_sendpacket(hdev->channel, msg, > > +                              msg->vid_hdr.size + sizeof(struct > > pipe_msg_hdr), > > +                              atomic64_inc_return(&request_id), > > +                              VM_PKT_DATA_INBAND, 0); > > + > > +       if (ret) > > +               drm_err(&hv->dev, "Unable to send packet via > > vmbus\n"); > > + > > +       return ret; > > +} > > + > > +static int hyperv_negotiate_version(struct hv_device *hdev, u32 > > ver) > > +{ > > +       struct hyperv_drm_device *hv = hv_get_drvdata(hdev); > > +       struct synthvid_msg *msg = (struct synthvid_msg *)hv- > > >init_buf; > > +       struct drm_device *dev = &hv->dev; > > +       unsigned long t; > > +       int ret = 0; > > + > > +       memset(msg, 0, sizeof(struct synthvid_msg)); > > +       msg->vid_hdr.type = SYNTHVID_VERSION_REQUEST; > > +       msg->vid_hdr.size = sizeof(struct synthvid_msg_hdr) + > > +               sizeof(struct synthvid_version_req); > > +       msg->ver_req.version = ver; > > +       hyperv_sendpacket(hdev, msg); > > + > > +       t = wait_for_completion_timeout(&hv->wait, > > VMBUS_VSP_TIMEOUT); > > +       if (!t) { > > +               drm_err(dev, "Time out on waiting version > > response\n"); > > +               ret = -ETIMEDOUT; > > +               goto out; > > +       } > > +       if (!msg->ver_resp.is_accepted) { > > +               ret = -ENODEV; > > +               goto out; > > Both 'out' label and 'ret' variable could be dropped here, just do > 'return -ETIMEDOUT/-ENODEV' directly and 'return 0' at the end. > > > +       } > > + > > +       hv->synthvid_version = ver; > > +       drm_info(dev, "Synthvid Version major %d, minor %d\n", > > +                SYNTHVID_VER_GET_MAJOR(ver), > > SYNTHVID_VER_GET_MINOR(ver)); > > + > > +out: > > +       return ret; > > +} > > + > > +int hyperv_update_vram_location(struct hv_device *hdev, > > phys_addr_t vram_pp) > > +{ > > +       struct hyperv_drm_device *hv = hv_get_drvdata(hdev); > > +       struct synthvid_msg *msg = (struct synthvid_msg *)hv- > > >init_buf; > > +       struct drm_device *dev = &hv->dev; > > +       unsigned long t; > > +       int ret = 0; > > + > > +       memset(msg, 0, sizeof(struct synthvid_msg)); > > +       msg->vid_hdr.type = SYNTHVID_VRAM_LOCATION; > > +       msg->vid_hdr.size = sizeof(struct synthvid_msg_hdr) + > > +               sizeof(struct synthvid_vram_location); > > +       msg->vram.user_ctx = vram_pp; > > +       msg->vram.vram_gpa = vram_pp; > > +       msg->vram.is_vram_gpa_specified = 1; > > +       hyperv_sendpacket(hdev, msg); > > + > > +       t = wait_for_completion_timeout(&hv->wait, > > VMBUS_VSP_TIMEOUT); > > +       if (!t) { > > +               drm_err(dev, "Time out on waiting vram location > > ack\n"); > > +               ret = -ETIMEDOUT; > > +               goto out; > > +       } > > +       if (msg->vram_ack.user_ctx != vram_pp) { > > +               drm_err(dev, "Unable to set VRAM location\n"); > > +               ret = -ENODEV; > > +       } > > + > > +out: > > +       return ret; > > same here: 'out' and 'ret' could be dropped. > > > +} > > + > > +int hyperv_update_situation(struct hv_device *hdev, u8 active, u32 > > bpp, > > +                           u32 w, u32 h, u32 pitch) > > +{ > > +       struct synthvid_msg msg; > > + > > +       memset(&msg, 0, sizeof(struct synthvid_msg)); > > + > > +       msg.vid_hdr.type = SYNTHVID_SITUATION_UPDATE; > > +       msg.vid_hdr.size = sizeof(struct synthvid_msg_hdr) + > > +               sizeof(struct synthvid_situation_update); > > +       msg.situ.user_ctx = 0; > > +       msg.situ.video_output_count = 1; > > +       msg.situ.video_output[0].active = active; > > +       /* vram_offset should always be 0 */ > > +       msg.situ.video_output[0].vram_offset = 0; > > +       msg.situ.video_output[0].depth_bits = bpp; > > +       msg.situ.video_output[0].width_pixels = w; > > +       msg.situ.video_output[0].height_pixels = h; > > +       msg.situ.video_output[0].pitch_bytes = pitch; > > + > > +       hyperv_sendpacket(hdev, &msg); > > + > > +       return 0; > > +} > > + > > +int hyperv_update_dirt(struct hv_device *hdev, struct drm_rect > > *rect) > > +{ > > +       struct synthvid_msg msg; > > + > > +       memset(&msg, 0, sizeof(struct synthvid_msg)); > > + > > +       msg.vid_hdr.type = SYNTHVID_DIRT; > > +       msg.vid_hdr.size = sizeof(struct synthvid_msg_hdr) + > > +               sizeof(struct synthvid_dirt); > > +       msg.dirt.video_output = 0; > > +       msg.dirt.dirt_count = 1; > > +       msg.dirt.rect[0].x1 = rect->x1; > > +       msg.dirt.rect[0].y1 = rect->y1; > > +       msg.dirt.rect[0].x2 = rect->x2; > > +       msg.dirt.rect[0].y2 = rect->y2; > > + > > +       hyperv_sendpacket(hdev, &msg); > > + > > +       return 0; > > +} > > + > > +static int hyperv_get_supported_resolution(struct hv_device *hdev) > > +{ > > +       struct hyperv_drm_device *hv = hv_get_drvdata(hdev); > > +       struct synthvid_msg *msg = (struct synthvid_msg *)hv- > > >init_buf; > > +       struct drm_device *dev = &hv->dev; > > +       unsigned long t; > > +       int ret = 0; > > +       u8 index; > > +       int i; > > + > > +       memset(msg, 0, sizeof(struct synthvid_msg)); > > +       msg->vid_hdr.type = SYNTHVID_RESOLUTION_REQUEST; > > +       msg->vid_hdr.size = sizeof(struct synthvid_msg_hdr) + > > +               sizeof(struct synthvid_supported_resolution_req); > > +       msg->resolution_req.maximum_resolution_count = > > +               SYNTHVID_MAX_RESOLUTION_COUNT; > > +       hyperv_sendpacket(hdev, msg); > > + > > +       t = wait_for_completion_timeout(&hv->wait, > > VMBUS_VSP_TIMEOUT); > > +       if (!t) { > > +               drm_err(dev, "Time out on waiting resolution > > response\n"); > > +               ret = -ETIMEDOUT; > > +               goto out; > > +       } > > + > > +       if (msg->resolution_resp.resolution_count == 0) { > > +               drm_err(dev, "No supported resolutions\n"); > > +               ret = -ENODEV; > > +               goto out; > > +       } > > + > > +       index = msg->resolution_resp.default_resolution_index; > > +       if (index >= msg->resolution_resp.resolution_count) { > > +               drm_err(dev, "Invalid resolution index: %d\n", > > index); > > +               ret = -ENODEV; > > +               goto out; > > +       } > > + > > +       for (i = 0; i < msg->resolution_resp.resolution_count; i++) > > { > > +               hv->screen_width_max = max_t(u32, hv- > > >screen_width_max, > > +                       msg- > > >resolution_resp.supported_resolution[i].width); > > +               hv->screen_height_max = max_t(u32, hv- > > >screen_height_max, > > +                       msg- > > >resolution_resp.supported_resolution[i].height); > > +       } > > + > > +       hv->preferred_width = > > +               msg- > > >resolution_resp.supported_resolution[index].width; > > +       hv->preferred_height = > > +               msg- > > >resolution_resp.supported_resolution[index].height; > > + > > +out: > > +       return ret; > > And here. > > > +} > > + > > +static void hyperv_receive_sub(struct hv_device *hdev) > > +{ > > +       struct hyperv_drm_device *hv = hv_get_drvdata(hdev); > > +       struct synthvid_msg *msg; > > + > > +       if (!hv) > > +               return; > > + > > +       msg = (struct synthvid_msg *)hv->recv_buf; > > + > > +       /* Complete the wait event */ > > +       if (msg->vid_hdr.type == SYNTHVID_VERSION_RESPONSE || > > +           msg->vid_hdr.type == SYNTHVID_RESOLUTION_RESPONSE || > > +           msg->vid_hdr.type == SYNTHVID_VRAM_LOCATION_ACK) { > > +               memcpy(hv->init_buf, msg, VMBUS_MAX_PACKET_SIZE); > > +               complete(&hv->wait); > > +               return; > > +       } > > +} > > + > > +static void hyperv_receive(void *ctx) > > +{ > > +       struct hv_device *hdev = ctx; > > +       struct hyperv_drm_device *hv = hv_get_drvdata(hdev); > > +       struct synthvid_msg *recv_buf; > > +       u32 bytes_recvd; > > +       u64 req_id; > > +       int ret; > > + > > +       if (!hv) > > +               return; > > + > > +       recv_buf = (struct synthvid_msg *)hv->recv_buf; > > + > > +       do { > > +               ret = vmbus_recvpacket(hdev->channel, recv_buf, > > +                                      VMBUS_MAX_PACKET_SIZE, > > +                                      &bytes_recvd, &req_id); > > +               if (bytes_recvd > 0 && > > +                   recv_buf->pipe_hdr.type == PIPE_MSG_DATA) > > +                       hyperv_receive_sub(hdev); > > +       } while (bytes_recvd > 0 && ret == 0); > > +} > > + > > +int hyperv_connect_vsp(struct hv_device *hdev) > > +{ > > +       struct hyperv_drm_device *hv = hv_get_drvdata(hdev); > > +       struct drm_device *dev = &hv->dev; > > +       int ret; > > + > > +       ret = vmbus_open(hdev->channel, VMBUS_RING_BUFSIZE, > > VMBUS_RING_BUFSIZE, > > +                        NULL, 0, hyperv_receive, hdev); > > +       if (ret) { > > +               drm_err(dev, "Unable to open vmbus channel\n"); > > +               return ret; > > +       } > > + > > +       /* Negotiate the protocol version with host */ > > +       switch (vmbus_proto_version) { > > +       case VERSION_WIN10: > > +       case VERSION_WIN10_V5: > > +               ret = hyperv_negotiate_version(hdev, > > SYNTHVID_VERSION_WIN10); > > +               if (!ret) > > +                       break; > > +               fallthrough; > > +       case VERSION_WIN8: > > +       case VERSION_WIN8_1: > > +               ret = hyperv_negotiate_version(hdev, > > SYNTHVID_VERSION_WIN8); > > +               if (!ret) > > +                       break; > > +               fallthrough; > > +       case VERSION_WS2008: > > +       case VERSION_WIN7: > > +               ret = hyperv_negotiate_version(hdev, > > SYNTHVID_VERSION_WIN7); > > +               break; > > +       default: > > +               ret = hyperv_negotiate_version(hdev, > > SYNTHVID_VERSION_WIN10); > > +               break; > > +       } > > + > > +       if (ret) { > > +               drm_err(dev, "Synthetic video device version not > > accepted %d\n", ret); > > +               goto error; > > +       } > > + > > +       if (hv->synthvid_version == SYNTHVID_VERSION_WIN7) > > +               hv->screen_depth = SYNTHVID_DEPTH_WIN7; > > +       else > > +               hv->screen_depth = SYNTHVID_DEPTH_WIN8; > > + > > +       if (hyperv_version_ge(hv->synthvid_version, > > SYNTHVID_VERSION_WIN10)) { > > +               ret = hyperv_get_supported_resolution(hdev); > > +               if (ret) > > +                       drm_err(dev, "Failed to get supported > > resolution from host, use default\n"); > > +       } else { > > +               hv->screen_width_max = SYNTHVID_WIDTH_MAX_WIN7; > > +               hv->screen_height_max = SYNTHVID_HEIGHT_MAX_WIN7; > > +       } > > + > > +       hv->mmio_megabytes = hdev->channel- > > >offermsg.offer.mmio_megabytes; > > + > > +       return 0; > > + > > +error: > > +       vmbus_close(hdev->channel); > > +       return ret; > > +} > 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 X-Spam-Level: X-Spam-Status: No, score=-10.5 required=3.0 tests=BAYES_00, DKIM_ADSP_CUSTOM_MED,DKIM_INVALID,DKIM_SIGNED,FREEMAIL_FORGED_FROMDOMAIN, FREEMAIL_FROM,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER, INCLUDES_PATCH,MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 5A1D1C433E0 for ; Wed, 17 Feb 2021 16:08:28 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 10E1C64E2F for ; Wed, 17 Feb 2021 16:08:28 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 10E1C64E2F Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=gmail.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=dri-devel-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 73C4689C85; Wed, 17 Feb 2021 16:08:27 +0000 (UTC) Received: from mail-pg1-x533.google.com (mail-pg1-x533.google.com [IPv6:2607:f8b0:4864:20::533]) by gabe.freedesktop.org (Postfix) with ESMTPS id 1F13089C85 for ; Wed, 17 Feb 2021 16:08:26 +0000 (UTC) Received: by mail-pg1-x533.google.com with SMTP id p21so3108182pgl.12 for ; Wed, 17 Feb 2021 08:08:26 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=message-id:subject:from:to:cc:date:in-reply-to:references :user-agent:mime-version:content-transfer-encoding; bh=41wbPOqN7tIGaC5JgYnmGRS7WrEcWCo1vN/O+KRLugQ=; b=IHJFaG22RBeadjx6CsB3GCJN6bM4jCTjTlJ+Gxj4EoaxeluGfgjC8s57oajN5hVJA0 EuFYzEH+pJWgfleBusBPb50s90ygDkamq40v+A0tNuSK3snFW2Qso7lPSeyxnwKaSwMb 6t0Fw4VPZF/Ptfdu9N54UcHjwpvNkB9S+e6L4mE8Q8HJkFipghA/2vXI03VNwyaqORjr wivYfmi4FTWhq6CkJhIOx+xkqWmGrNNyXw/mXZro6G2odP6SMe1dSepZgzSsEN4qUmLV +xvO6tsAStmyeNARAnIdmPmpSaTjNkfg1cWW6HfDQA67KBlKSkLEIO7S5YVF+ocn2+F/ I43A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:message-id:subject:from:to:cc:date:in-reply-to :references:user-agent:mime-version:content-transfer-encoding; bh=41wbPOqN7tIGaC5JgYnmGRS7WrEcWCo1vN/O+KRLugQ=; b=LUUte0CQ42EOSSJwRulZn4uxlRNDY4FlvKGzBR312KdXJI/CoNfzbFmv90fn7oQRxC ENGN1wLXMgZqAv1+LXNp9bVeXx1+XG+khoGaSToZoukxUR7KO/ZAWFaHVRxDQka5kgAc w1f/CnUZ4rMizLwBBf9inwCH7sgajXJKdQwV+2FJsAVkEidioDZjmYWdVGDdm0/V/7Le 7v1h/LV0QJb5Zod5rQlv85sq0NA36nSZorNsoOJE+acN9Q+yO9DAnlcKeEclUyLeF0La M43JYQosMTdFCED5VkdFs1jVZjDJHmsx11NYBdKBZsqNJPmyeHFdTg4O7rm1Yw7q+kIJ DMZw== X-Gm-Message-State: AOAM531mlVR3z659PhQo2DzbTjz0y5hQyV9/M0A45ROwoifMDKWkLotf l1sWFiyEw9dLPASTD6khTBM= X-Google-Smtp-Source: ABdhPJxMROtn2rBy4Rdvx+uRLGEa7YTkiKrPJS/9TbwKxAMSKSeCnATWn4YXzvEqZHaiQEmtAsGZxQ== X-Received: by 2002:a65:5a09:: with SMTP id y9mr59826pgs.243.1613578105444; Wed, 17 Feb 2021 08:08:25 -0800 (PST) Received: from [192.168.1.8] ([50.47.106.83]) by smtp.gmail.com with ESMTPSA id y22sm2990868pgh.19.2021.02.17.08.08.24 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 17 Feb 2021 08:08:24 -0800 (PST) Message-ID: <20aead71c4aa3f640e19660875f807deae92f8d8.camel@gmail.com> Subject: Re: [PATCH v3 1/2] drm/hyperv: Add DRM driver for hyperv synthetic video device From: Deepak Rawat To: Vitaly Kuznetsov , linux-hyperv@vger.kernel.org, dri-devel@lists.freedesktop.org Date: Wed, 17 Feb 2021 08:08:23 -0800 In-Reply-To: <87k0r6kicg.fsf@vitty.brq.redhat.com> References: <20210216003959.802492-1-drawat.floss@gmail.com> <87k0r6kicg.fsf@vitty.brq.redhat.com> User-Agent: Evolution 3.38.4 MIME-Version: 1.0 X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Wei Hu , Haiyang Zhang , Dexuan Cui , Michael Kelley , Gerd Hoffmann , Thomas Zimmermann , Sam Ravnborg Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" T24gV2VkLCAyMDIxLTAyLTE3IGF0IDEzOjA3ICswMTAwLCBWaXRhbHkgS3V6bmV0c292IHdyb3Rl Ogo+IERlZXBhayBSYXdhdCA8ZHJhd2F0LmZsb3NzQGdtYWlsLmNvbT4gd3JpdGVzOgo+IAo+ID4g RFJNIGRyaXZlciBmb3IgaHlwZXJ2IHN5bnRoZXRpYyB2aWRlbyBkZXZpY2UsIGJhc2VkIG9uIGh5 cGVydl9mYgo+ID4gZnJhbWVidWZmZXIgZHJpdmVyLiBBbHNvIGFkZGVkIGNvbmZpZyBvcHRpb24g IkRSTV9IWVBFUlYiIHRvCj4gPiBlbmFibGVkCj4gPiB0aGlzIGRyaXZlci4KPiA+IAo+ID4gdjI6 Cj4gPiAtIEFkZCBzdXBwb3J0IGZvciBnZW4yIFZNCj4gPiAtIEZpeGVkIHJldmlldyBjb21tZW50 cwo+ID4gCj4gPiB2MzoKPiA+IC0gU3BsaXQgaW50byBtdWx0aXBsZSBmaWxlcyBhcyBzdWdnZXN0 ZWQgYnkgVGhvbWFzIFppbW1lcm1hbm4KPiA+IC0gRml4ZWQgaGliZXJuYXRpb24gaXNzdWUgYXMg c3VnZ2VzdGVkIGJ5IERleHVhbiBDdWkKPiA+IC0gVXNlIGlvcmVtYXBfY2FjaGUgYXMgc3VnZ2Vz dGVkIGJ5IERleHVhbiBDdWkKPiA+IC0gSW5jb3Jwb3JhdGVkIG90aGVyIHJldmlldyBjb21tZW50 cwo+ID4gCj4gPiBTaWduZWQtb2ZmLWJ5OiBEZWVwYWsgUmF3YXQgPGRyYXdhdC5mbG9zc0BnbWFp bC5jb20+Cj4gPiAtLS0KPiA+IMKgZHJpdmVycy9ncHUvZHJtL0tjb25maWfCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHzCoCAxMiArCj4gPiDCoGRyaXZlcnMvZ3B1L2Ry bS9NYWtlZmlsZcKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHzCoMKgIDEg Kwo+ID4gwqBkcml2ZXJzL2dwdS9kcm0vaHlwZXJ2L01ha2VmaWxlwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgIHzCoMKgIDggKwo+ID4gwqBkcml2ZXJzL2dwdS9kcm0vaHlwZXJ2L2h5cGVydl9kcm0u aMKgwqDCoMKgwqDCoMKgwqAgfMKgIDUxICsrCj4gPiDCoGRyaXZlcnMvZ3B1L2RybS9oeXBlcnYv aHlwZXJ2X2RybV9kcnYuY8KgwqDCoMKgIHwgMzEzICsrKysrKysrKysrKysKPiA+IMKgZHJpdmVy cy9ncHUvZHJtL2h5cGVydi9oeXBlcnZfZHJtX21vZGVzZXQuYyB8IDI0MCArKysrKysrKysrCj4g PiDCoGRyaXZlcnMvZ3B1L2RybS9oeXBlcnYvaHlwZXJ2X2RybV9wcm90by5jwqDCoCB8IDQ4Ngo+ ID4gKysrKysrKysrKysrKysrKysrKysKPiA+IMKgNyBmaWxlcyBjaGFuZ2VkLCAxMTExIGluc2Vy dGlvbnMoKykKPiA+IMKgY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvZ3B1L2RybS9oeXBlcnYv TWFrZWZpbGUKPiA+IMKgY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvZ3B1L2RybS9oeXBlcnYv aHlwZXJ2X2RybS5oCj4gPiDCoGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2dwdS9kcm0vaHlw ZXJ2L2h5cGVydl9kcm1fZHJ2LmMKPiA+IMKgY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvZ3B1 L2RybS9oeXBlcnYvaHlwZXJ2X2RybV9tb2Rlc2V0LmMKPiA+IMKgY3JlYXRlIG1vZGUgMTAwNjQ0 IGRyaXZlcnMvZ3B1L2RybS9oeXBlcnYvaHlwZXJ2X2RybV9wcm90by5jCj4gPiAKPiA+IGRpZmYg LS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vS2NvbmZpZyBiL2RyaXZlcnMvZ3B1L2RybS9LY29uZmln Cj4gPiBpbmRleCA4YmYxMDNkZTE1OTQuLmMxN2Y0ZTlkY2Q4MiAxMDA2NDQKPiA+IC0tLSBhL2Ry aXZlcnMvZ3B1L2RybS9LY29uZmlnCj4gPiArKysgYi9kcml2ZXJzL2dwdS9kcm0vS2NvbmZpZwo+ ID4gQEAgLTM4Miw2ICszODIsMTggQEAgc291cmNlICJkcml2ZXJzL2dwdS9kcm0vdGlkc3MvS2Nv bmZpZyIKPiA+IMKgCj4gPiDCoHNvdXJjZSAiZHJpdmVycy9ncHUvZHJtL3hsbngvS2NvbmZpZyIK PiA+IMKgCj4gPiArY29uZmlnIERSTV9IWVBFUlYKPiA+ICvCoMKgwqDCoMKgwqDCoHRyaXN0YXRl ICJEUk0gU3VwcG9ydCBmb3IgaHlwZXJ2IHN5bnRoZXRpYyB2aWRlbyBkZXZpY2UiCj4gPiArwqDC oMKgwqDCoMKgwqBkZXBlbmRzIG9uIERSTSAmJiBQQ0kgJiYgTU1VICYmIEhZUEVSVgo+ID4gK8Kg wqDCoMKgwqDCoMKgc2VsZWN0IERSTV9LTVNfSEVMUEVSCj4gPiArwqDCoMKgwqDCoMKgwqBzZWxl Y3QgRFJNX0dFTV9TSE1FTV9IRUxQRVIKPiA+ICvCoMKgwqDCoMKgwqDCoGhlbHAKPiA+ICvCoMKg wqDCoMKgwqDCoCBUaGlzIGlzIGEgS01TIGRyaXZlciBmb3IgaHlwZXJ2IHN5bnRoZXRpYyB2aWRl byBkZXZpY2UuCj4gPiBDaG9vc2UgdGhpcwo+ID4gK8KgwqDCoMKgwqDCoMKgIG9wdGlvbiBpZiB5 b3Ugd291bGQgbGlrZSB0byBlbmFibGUgZHJtIGRyaXZlciBmb3IgSHlwZXItVgo+ID4gdmlydHVh bAo+ID4gK8KgwqDCoMKgwqDCoMKgIG1hY2hpbmUuCj4gPiArCj4gPiArwqDCoMKgwqDCoMKgwqAg SWYgTSBpcyBzZWxlY3RlZCB0aGUgbW9kdWxlIHdpbGwgYmUgY2FsbGVkIGh5cGVydl9kcm0uCj4g PiArCj4gPiDCoCMgS2VlcCBsZWdhY3kgZHJpdmVycyBsYXN0Cj4gPiDCoAo+ID4gwqBtZW51Y29u ZmlnIERSTV9MRUdBQ1kKPiA+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vTWFrZWZpbGUg Yi9kcml2ZXJzL2dwdS9kcm0vTWFrZWZpbGUKPiA+IGluZGV4IDkyNmFkZWYyODlkYi4uMjk0ZTMy MWNkMjNmIDEwMDY0NAo+ID4gLS0tIGEvZHJpdmVycy9ncHUvZHJtL01ha2VmaWxlCj4gPiArKysg Yi9kcml2ZXJzL2dwdS9kcm0vTWFrZWZpbGUKPiA+IEBAIC0xMjUsMyArMTI1LDQgQEAgb2JqLSQo Q09ORklHX0RSTV9BU1BFRURfR0ZYKSArPSBhc3BlZWQvCj4gPiDCoG9iai0kKENPTkZJR19EUk1f TUNERSkgKz0gbWNkZS8KPiA+IMKgb2JqLSQoQ09ORklHX0RSTV9USURTUykgKz0gdGlkc3MvCj4g PiDCoG9iai15wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgKz0geGxueC8KPiA+ ICtvYmotJChDT05GSUdfRFJNX0hZUEVSVikgKz0gaHlwZXJ2Lwo+ID4gZGlmZiAtLWdpdCBhL2Ry aXZlcnMvZ3B1L2RybS9oeXBlcnYvTWFrZWZpbGUKPiA+IGIvZHJpdmVycy9ncHUvZHJtL2h5cGVy di9NYWtlZmlsZQo+ID4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPiA+IGluZGV4IDAwMDAwMDAwMDAw MC4uMDAzOWIwM2RiMGJlCj4gPiAtLS0gL2Rldi9udWxsCj4gPiArKysgYi9kcml2ZXJzL2dwdS9k cm0vaHlwZXJ2L01ha2VmaWxlCj4gPiBAQCAtMCwwICsxLDggQEAKPiA+ICsjIFNQRFgtTGljZW5z ZS1JZGVudGlmaWVyOiBHUEwtMi4wLW9ubHkKPiA+ICsKPiA+ICtoeXBlcnZfZHJtLXkgOj0gXAo+ ID4gK8KgwqDCoMKgwqDCoMKgaHlwZXJ2X2RybV9wcm90by5vIFwKPiA+ICvCoMKgwqDCoMKgwqDC oGh5cGVydl9kcm1fbW9kZXNldC5vIFwKPiA+ICvCoMKgwqDCoMKgwqDCoGh5cGVydl9kcm1fZHJ2 Lm8KPiA+ICsKPiA+ICtvYmotJChDT05GSUdfRFJNX0hZUEVSVikgKz0gaHlwZXJ2X2RybS5vCj4g PiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2h5cGVydi9oeXBlcnZfZHJtLmgKPiA+IGIv ZHJpdmVycy9ncHUvZHJtL2h5cGVydi9oeXBlcnZfZHJtLmgKPiA+IG5ldyBmaWxlIG1vZGUgMTAw NjQ0Cj4gPiBpbmRleCAwMDAwMDAwMDAwMDAuLjRmOGM2MjdiMzAzYQo+ID4gLS0tIC9kZXYvbnVs bAo+ID4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2h5cGVydi9oeXBlcnZfZHJtLmgKPiA+IEBAIC0w LDAgKzEsNTEgQEAKPiA+ICsvKiBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMCAqLwo+ ID4gKy8qCj4gPiArICogQ29weXJpZ2h0IDIwMTItMjAyMSBNaWNyb3NvZnQKPiAKPiBPdXQgb2Yg cHVyZSBjdXJpb3NpdHksIHdoZXJlIGRvZXMgJzIwMTInIGNvbWUgZnJvbSBvciB3aGF0IGRvZXMg aXQKPiBtZWFuPwo+IAoKVGhhbmtzIFZpdGFseSBmb3IgdGhlIHJldmlldy4gQWN0dWFsbHkgc29t ZSBvZiB0aGUgY29kZSBpcyBkZXJpdmVkIGZyb20KaHlwZXJ2X2ZiLCB3aGljaCBoYXMgY29weXJp Z2h0IDIwMTIuIE5vdCBzdXJlIGlmIEkgc2hvdWxkIHJlbW92ZSBoZXJlCm9yIG5vdD8KCj4gPiAr ICovCj4gPiArCj4gPiArI2lmbmRlZiBfSFlQRVJWX0RSTV9IXwo+ID4gKyNkZWZpbmUgX0hZUEVS Vl9EUk1fSF8KPiA+ICsKPiA+ICsjZGVmaW5lIFZNQlVTX01BWF9QQUNLRVRfU0laRSAweDQwMDAK PiA+ICsKPiA+ICtzdHJ1Y3QgaHlwZXJ2X2RybV9kZXZpY2Ugewo+ID4gK8KgwqDCoMKgwqDCoMKg LyogZHJtICovCj4gPiArwqDCoMKgwqDCoMKgwqBzdHJ1Y3QgZHJtX2RldmljZSBkZXY7Cj4gPiAr wqDCoMKgwqDCoMKgwqBzdHJ1Y3QgZHJtX3NpbXBsZV9kaXNwbGF5X3BpcGUgcGlwZTsKPiA+ICvC oMKgwqDCoMKgwqDCoHN0cnVjdCBkcm1fY29ubmVjdG9yIGNvbm5lY3RvcjsKPiA+ICsKPiA+ICvC oMKgwqDCoMKgwqDCoC8qIG1vZGUgKi8KPiA+ICvCoMKgwqDCoMKgwqDCoHUzMiBzY3JlZW5fd2lk dGhfbWF4Owo+ID4gK8KgwqDCoMKgwqDCoMKgdTMyIHNjcmVlbl9oZWlnaHRfbWF4Owo+ID4gK8Kg wqDCoMKgwqDCoMKgdTMyIHByZWZlcnJlZF93aWR0aDsKPiA+ICvCoMKgwqDCoMKgwqDCoHUzMiBw cmVmZXJyZWRfaGVpZ2h0Owo+ID4gK8KgwqDCoMKgwqDCoMKgdTMyIHNjcmVlbl9kZXB0aDsKPiA+ ICsKPiA+ICvCoMKgwqDCoMKgwqDCoC8qIGh3ICovCj4gPiArwqDCoMKgwqDCoMKgwqBzdHJ1Y3Qg cmVzb3VyY2UgKm1lbTsKPiA+ICvCoMKgwqDCoMKgwqDCoHZvaWQgX19pb21lbSAqdnJhbTsKPiA+ ICvCoMKgwqDCoMKgwqDCoHVuc2lnbmVkIGxvbmcgZmJfYmFzZTsKPiA+ICvCoMKgwqDCoMKgwqDC oHVuc2lnbmVkIGxvbmcgZmJfc2l6ZTsKPiA+ICvCoMKgwqDCoMKgwqDCoHN0cnVjdCBjb21wbGV0 aW9uIHdhaXQ7Cj4gPiArwqDCoMKgwqDCoMKgwqB1MzIgc3ludGh2aWRfdmVyc2lvbjsKPiA+ICvC oMKgwqDCoMKgwqDCoHUzMiBtbWlvX21lZ2FieXRlczsKPiA+ICsKPiA+ICvCoMKgwqDCoMKgwqDC oHU4IGluaXRfYnVmW1ZNQlVTX01BWF9QQUNLRVRfU0laRV07Cj4gPiArwqDCoMKgwqDCoMKgwqB1 OCByZWN2X2J1ZltWTUJVU19NQVhfUEFDS0VUX1NJWkVdOwo+ID4gKwo+ID4gK8KgwqDCoMKgwqDC oMKgc3RydWN0IGh2X2RldmljZSAqaGRldjsKPiA+ICt9Owo+ID4gKwo+ID4gKyNkZWZpbmUgdG9f aHYoX2RldikgY29udGFpbmVyX29mKF9kZXYsIHN0cnVjdCBoeXBlcnZfZHJtX2RldmljZSwKPiA+ IGRldikKPiA+ICsKPiA+ICsvKiBoeXBlcnZfZHJtX21vZGVzZXQgKi8KPiA+ICtpbnQgaHlwZXJ2 X21vZGVfY29uZmlnX2luaXQoc3RydWN0IGh5cGVydl9kcm1fZGV2aWNlICpodik7Cj4gPiArCj4g PiArLyogaHlwZXJ2X2RybV9wcm90byAqLwo+ID4gK2ludCBoeXBlcnZfdXBkYXRlX3ZyYW1fbG9j YXRpb24oc3RydWN0IGh2X2RldmljZSAqaGRldiwKPiA+IHBoeXNfYWRkcl90IHZyYW1fcHApOwo+ ID4gK2ludCBoeXBlcnZfdXBkYXRlX3NpdHVhdGlvbihzdHJ1Y3QgaHZfZGV2aWNlICpoZGV2LCB1 OCBhY3RpdmUsIHUzMgo+ID4gYnBwLAo+ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgdTMyIHcsIHUzMiBoLCB1MzIgcGl0Y2gpOwo+ID4gK2lu dCBoeXBlcnZfdXBkYXRlX2RpcnQoc3RydWN0IGh2X2RldmljZSAqaGRldiwgc3RydWN0IGRybV9y ZWN0Cj4gPiAqcmVjdCk7Cj4gPiAraW50IGh5cGVydl9jb25uZWN0X3ZzcChzdHJ1Y3QgaHZfZGV2 aWNlICpoZGV2KTsKPiAKPiBBcyB3ZSBhbHJlYWR5IGhhdmUKPiBiYWxsb29uX2Nvbm5lY3RfdnNw KCkvbmV0dnNjX2Nvbm5lY3RfdnNwKCkvc3ludGh2aWRfY29ubmVjdF92c3AoKSwKPiBjb3VsZAo+ IHdlIG1heWJlIHJlbmFtZSAnaHlwZXJ2X2Nvbm5lY3RfdnNwKCknIHRvIHNvbWV0aGluZyBtb3Jl IERSTS0KPiBzcGVjaWZpYz8gCj4gCgpTaW5jZSBhbGwgdGhlIGZ1bmN0aW9ucyBoZXJlIGluIGRy bSBkcml2ZXIgYXJlIHByZWZpeGVkIHdpdGggaHlwZXJ2LApzYW1lIGlzIGRvbmUgd2l0aCBjb25u ZWN0X3ZzcCgpLiBTdXJlIEkgdGhpbmsgYmV0dGVyIHRvIHJlbmFtZSB0aGlzIHRvCnNvbWV0aGlu ZyBkcm0gc3BlY2lmaWMuCgo+ID4gKwo+ID4gKyNlbmRpZgo+ID4gZGlmZiAtLWdpdCBhL2RyaXZl cnMvZ3B1L2RybS9oeXBlcnYvaHlwZXJ2X2RybV9kcnYuYwo+ID4gYi9kcml2ZXJzL2dwdS9kcm0v aHlwZXJ2L2h5cGVydl9kcm1fZHJ2LmMKPiA+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4gPiBpbmRl eCAwMDAwMDAwMDAwMDAuLmI3MmMxYTE2OTEyNQo+ID4gLS0tIC9kZXYvbnVsbAo+ID4gKysrIGIv ZHJpdmVycy9ncHUvZHJtL2h5cGVydi9oeXBlcnZfZHJtX2Rydi5jCj4gPiBAQCAtMCwwICsxLDMx MyBAQAo+ID4gKy8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wCj4gPiArLyoKPiA+ ICsgKiBDb3B5cmlnaHQgMjAxMi0yMDIxIE1pY3Jvc29mdAo+ID4gKyAqLwo+ID4gKwo+ID4gKyNp bmNsdWRlIDxsaW51eC9lZmkuaD4KPiA+ICsjaW5jbHVkZSA8bGludXgvaHlwZXJ2Lmg+Cj4gPiAr I2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgo+ID4gKyNpbmNsdWRlIDxsaW51eC9wY2kuaD4KPiA+ ICsKPiA+ICsjaW5jbHVkZSA8ZHJtL2RybV9hdG9taWNfaGVscGVyLmg+Cj4gPiArI2luY2x1ZGUg PGRybS9kcm1fZHJ2Lmg+Cj4gPiArI2luY2x1ZGUgPGRybS9kcm1fZmJfaGVscGVyLmg+Cj4gPiAr I2luY2x1ZGUgPGRybS9kcm1fZ2VtX3NobWVtX2hlbHBlci5oPgo+ID4gKyNpbmNsdWRlIDxkcm0v ZHJtX3NpbXBsZV9rbXNfaGVscGVyLmg+Cj4gPiArCj4gPiArI2luY2x1ZGUgImh5cGVydl9kcm0u aCIKPiA+ICsKPiA+ICsjZGVmaW5lIERSSVZFUl9OQU1FICJoeXBlcnZfZHJtIgo+ID4gKyNkZWZp bmUgRFJJVkVSX0RFU0MgIkRSTSBkcml2ZXIgZm9yIGh5cGVydiBzeW50aGV0aWMgdmlkZW8gZGV2 aWNlIgo+ID4gKyNkZWZpbmUgRFJJVkVSX0RBVEUgIjIwMjAiCj4gPiArI2RlZmluZSBEUklWRVJf TUFKT1IgMQo+ID4gKyNkZWZpbmUgRFJJVkVSX01JTk9SIDAKPiA+ICsKPiA+ICsjZGVmaW5lIFBD SV9WRU5ET1JfSURfTUlDUk9TT0ZUIDB4MTQxNAo+ID4gKyNkZWZpbmUgUENJX0RFVklDRV9JRF9I WVBFUlZfVklERU8gMHg1MzUzCj4gPiArCj4gPiArREVGSU5FX0RSTV9HRU1fRk9QUyhodl9mb3Bz KTsKPiA+ICsKPiA+ICtzdGF0aWMgc3RydWN0IGRybV9kcml2ZXIgaHlwZXJ2X2RyaXZlciA9IHsK PiA+ICvCoMKgwqDCoMKgwqDCoC5kcml2ZXJfZmVhdHVyZXMgPSBEUklWRVJfTU9ERVNFVCB8IERS SVZFUl9HRU0gfAo+ID4gRFJJVkVSX0FUT01JQywKPiA+ICsKPiA+ICvCoMKgwqDCoMKgwqDCoC5u YW1lwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCA9IERSSVZFUl9OQU1FLAo+ID4gK8KgwqDCoMKgwqDC oMKgLmRlc2PCoMKgwqDCoMKgwqDCoMKgwqDCoMKgID0gRFJJVkVSX0RFU0MsCj4gPiArwqDCoMKg wqDCoMKgwqAuZGF0ZcKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgPSBEUklWRVJfREFURSwKPiA+ICvC oMKgwqDCoMKgwqDCoC5tYWpvcsKgwqDCoMKgwqDCoMKgwqDCoMKgID0gRFJJVkVSX01BSk9SLAo+ ID4gK8KgwqDCoMKgwqDCoMKgLm1pbm9ywqDCoMKgwqDCoMKgwqDCoMKgwqAgPSBEUklWRVJfTUlO T1IsCj4gPiArCj4gPiArwqDCoMKgwqDCoMKgwqAuZm9wc8KgwqDCoMKgwqDCoMKgwqDCoMKgwqAg PSAmaHZfZm9wcywKPiA+ICvCoMKgwqDCoMKgwqDCoERSTV9HRU1fU0hNRU1fRFJJVkVSX09QUywK PiA+ICt9Owo+ID4gKwo+ID4gK3N0YXRpYyBpbnQgaHlwZXJ2X3BjaV9wcm9iZShzdHJ1Y3QgcGNp X2RldiAqcGRldiwKPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgIGNvbnN0IHN0cnVjdCBwY2lfZGV2aWNlX2lkICplbnQpCj4gPiArewo+ID4g K8KgwqDCoMKgwqDCoMKgcmV0dXJuIDA7Cj4gPiArfQo+ID4gKwo+ID4gK3N0YXRpYyB2b2lkIGh5 cGVydl9wY2lfcmVtb3ZlKHN0cnVjdCBwY2lfZGV2ICpwZGV2KQo+ID4gK3sKPiA+ICt9Cj4gPiAr Cj4gPiArc3RhdGljIGNvbnN0IHN0cnVjdCBwY2lfZGV2aWNlX2lkIGh5cGVydl9wY2lfdGJsW10g PSB7Cj4gPiArwqDCoMKgwqDCoMKgwqB7Cj4gPiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgLnZlbmRvciA9IFBDSV9WRU5ET1JfSURfTUlDUk9TT0ZULAo+ID4gK8KgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoC5kZXZpY2UgPSBQQ0lfREVWSUNFX0lEX0hZUEVSVl9WSURFTywKPiA+ ICvCoMKgwqDCoMKgwqDCoH0sCj4gPiArwqDCoMKgwqDCoMKgwqB7IC8qIGVuZCBvZiBsaXN0ICov IH0KPiA+ICt9Owo+ID4gKwo+ID4gK3N0YXRpYyBzdHJ1Y3QgcGNpX2RyaXZlciBoeXBlcnZfcGNp X2RyaXZlciA9IHsKPiA+ICvCoMKgwqDCoMKgwqDCoC5uYW1lID3CoMKgwqDCoMKgwqDCoMKgwqBL QlVJTERfTU9ETkFNRSwKPiA+ICvCoMKgwqDCoMKgwqDCoC5pZF90YWJsZSA9wqDCoMKgwqDCoGh5 cGVydl9wY2lfdGJsLAo+ID4gK8KgwqDCoMKgwqDCoMKgLnByb2JlID3CoMKgwqDCoMKgwqDCoMKg aHlwZXJ2X3BjaV9wcm9iZSwKPiA+ICvCoMKgwqDCoMKgwqDCoC5yZW1vdmUgPcKgwqDCoMKgwqDC oMKgaHlwZXJ2X3BjaV9yZW1vdmUsCj4gPiArfTsKPiA+ICsKPiA+ICtzdGF0aWMgaW50IGh5cGVy dl9nZXRfdnJhbV9nZW4xKHN0cnVjdCBoeXBlcnZfZHJtX2RldmljZSAqaHYpCj4gPiArewo+ID4g K8KgwqDCoMKgwqDCoMKgc3RydWN0IGRybV9kZXZpY2UgKmRldiA9ICZodi0+ZGV2Owo+ID4gK8Kg wqDCoMKgwqDCoMKgc3RydWN0IHBjaV9kZXYgKnBkZXY7Cj4gPiArwqDCoMKgwqDCoMKgwqBpbnQg cmV0Owo+ID4gKwo+ID4gK8KgwqDCoMKgwqDCoMKgcGRldiA9IHBjaV9nZXRfZGV2aWNlKFBDSV9W RU5ET1JfSURfTUlDUk9TT0ZULAo+ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIFBDSV9ERVZJQ0VfSURfSFlQRVJWX1ZJREVPLCBOVUxM KTsKPiA+ICvCoMKgwqDCoMKgwqDCoGlmICghcGRldikgewo+ID4gK8KgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoGRybV9lcnIoZGV2LCAiVW5hYmxlIHRvIGZpbmQgUENJIEh5cGVyLVYgdmlk ZW9cbiIpOwo+ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoHJldHVybiAtRU5PREVW Owo+ID4gK8KgwqDCoMKgwqDCoMKgfQo+ID4gKwo+ID4gK8KgwqDCoMKgwqDCoMKgcmV0ID0KPiA+ IGRybV9mYl9oZWxwZXJfcmVtb3ZlX2NvbmZsaWN0aW5nX3BjaV9mcmFtZWJ1ZmZlcnMocGRldiwK PiA+ICJoeXBlcnZkcm1mYiIpOwo+ID4gK8KgwqDCoMKgwqDCoMKgaWYgKHJldCkgewo+ID4gK8Kg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoGRybV9lcnIoZGV2LCAiTm90IGFibGUgdG8gcmVt b3ZlIGJvb3QgZmJcbiIpOwo+ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoHJldHVy biByZXQ7Cj4gPiArwqDCoMKgwqDCoMKgwqB9Cj4gPiArCj4gPiArwqDCoMKgwqDCoMKgwqBpZiAo cGNpX3JlcXVlc3RfcmVnaW9uKHBkZXYsIDAsIERSSVZFUl9OQU1FKSAhPSAwKQo+ID4gK8KgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoGRybV93YXJuKGRldiwgIkNhbm5vdCByZXF1ZXN0IGZy YW1lYnVmZmVyLCBib290IGZiCj4gPiBzdGlsbCBhY3RpdmU/XG4iKTsKPiA+ICsKPiA+ICvCoMKg wqDCoMKgwqDCoGlmICgocGRldi0+cmVzb3VyY2VbMF0uZmxhZ3MgJiBJT1JFU09VUkNFX01FTSkg PT0gMCkgewo+ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoGRybV9lcnIoZGV2LCAi UmVzb3VyY2UgYXQgYmFyIDAgaXMgbm90Cj4gPiBJT1JFU09VUkNFX01FTVxuIik7Cj4gPiArwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgcmV0ID0gLUVOT0RFVjsKPiA+ICvCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqBnb3RvIGVycm9yOwo+ID4gK8KgwqDCoMKgwqDCoMKgfQo+ID4g Kwo+ID4gK8KgwqDCoMKgwqDCoMKgaHYtPmZiX2Jhc2UgPSBwY2lfcmVzb3VyY2Vfc3RhcnQocGRl diwgMCk7Cj4gPiArwqDCoMKgwqDCoMKgwqBodi0+ZmJfc2l6ZSA9IHBjaV9yZXNvdXJjZV9sZW4o cGRldiwgMCk7Cj4gPiArwqDCoMKgwqDCoMKgwqBpZiAoaHYtPmZiX2Jhc2UgPT0gMCkgewo+ID4g K8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoGRybV9lcnIoZGV2LCAiUmVzb3VyY2Ugbm90 IGF2YWlsYWJsZVxuIik7Cj4gPiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgcmV0ID0g LUVOT0RFVjsKPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqBnb3RvIGVycm9yOwo+ ID4gK8KgwqDCoMKgwqDCoMKgfQo+ID4gKwo+ID4gK8KgwqDCoMKgwqDCoMKgaHYtPmZiX3NpemUg PSBtaW4oaHYtPmZiX3NpemUsCj4gPiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgICh1bnNpZ25lZCBsb25nKShodi0+bW1pb19tZWdhYnl0ZXMgKiAxMDI0 Cj4gPiAqIDEwMjQpKTsKPiA+ICvCoMKgwqDCoMKgwqDCoGh2LT52cmFtID0gZGV2bV9pb3JlbWFw KCZwZGV2LT5kZXYsIGh2LT5mYl9iYXNlLCBodi0KPiA+ID5mYl9zaXplKTsKPiA+ICvCoMKgwqDC oMKgwqDCoGlmICghaHYtPnZyYW0pIHsKPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqBkcm1fZXJyKGRldiwgIkZhaWxlZCB0byBtYXAgdnJhbVxuIik7Cj4gPiArwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgcmV0ID0gLUVOT01FTTsKPiA+ICvCoMKgwqDCoMKgwqDCoH0KPiA+ ICsKPiA+ICtlcnJvcjoKPiA+ICvCoMKgwqDCoMKgwqDCoHBjaV9kZXZfcHV0KHBkZXYpOwo+ID4g K8KgwqDCoMKgwqDCoMKgcmV0dXJuIHJldDsKPiA+ICt9Cj4gPiArCj4gPiArc3RhdGljIGludCBo eXBlcnZfZ2V0X3ZyYW1fZ2VuMihzdHJ1Y3QgaHlwZXJ2X2RybV9kZXZpY2UgKmh2LAo+ID4gK8Kg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgc3RydWN0IGh2X2RldmljZSAqaGRldikKPiA+ICt7Cj4gPiArwqDCoMKgwqDCoMKgwqBzdHJ1 Y3QgZHJtX2RldmljZSAqZGV2ID0gJmh2LT5kZXY7Cj4gPiArwqDCoMKgwqDCoMKgwqBzdHJ1Y3Qg YXBlcnR1cmVzX3N0cnVjdCAqYXA7Cj4gPiArwqDCoMKgwqDCoMKgwqBpbnQgcmV0Owo+ID4gKwo+ ID4gK8KgwqDCoMKgwqDCoMKgaHYtPmZiX3NpemUgPSAodW5zaWduZWQgbG9uZykoaHYtPm1taW9f bWVnYWJ5dGVzICogMTAyNCAqCj4gPiAxMDI0KTsKPiAKPiBJbiBjYXNlICd1bnNpZ25lZCBsb25n JyBjYXN0aW5nIHdhcyBuZWVkZWQgYmVjYXVzZSB5b3UncmUgYWZyYWlkCj4gJ3UzMicKPiBjYW4g b3ZlcmZsb3csIGl0IHNob3VsZCBiZSBhcHBsaWVkIGJlZm9yZSB3ZSBhY3R1YWxseSBkbyB0aGUK PiBtdWx0aXBsaWNhdGlvbjoKPiAKPiDCoCh1bnNpZ25lZCBsb25nKWh2LT5tbWlvX21lZ2FieXRl cyAqIDEwMjQgKiAxMDI0Cj4gCj4gb3RoZXJ3aXNlIHRoZSBjYXN0IHNlZW1zIHVzZWxlc3MgZmJf c2l6ZSBpcyAndW5zaWduZWQgbG9uZycuCj4gCj4gPiArCj4gPiArwqDCoMKgwqDCoMKgwqByZXQg PSB2bWJ1c19hbGxvY2F0ZV9tbWlvKCZodi0+bWVtLCBoZGV2LCAwLCAtMSwgaHYtCj4gPiA+ZmJf c2l6ZSwgMHgxMDAwMDAsCj4gPiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB0cnVlKTsKPiA+ICvCoMKgwqDCoMKgwqDCoGlm IChyZXQpIHsKPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqBkcm1fZXJyKGRldiwg IkZhaWxlZCB0byBhbGxvY2F0ZSBtbWlvXG4iKTsKPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqByZXR1cm4gLUVOT01FTTsKPiA+ICvCoMKgwqDCoMKgwqDCoH0KPiA+ICsKPiA+ICvC oMKgwqDCoMKgwqDCoC8qCj4gPiArwqDCoMKgwqDCoMKgwqAgKiBNYXAgdGhlIFZSQU0gY2FjaGVh YmxlIGZvciBwZXJmb3JtYW5jZS4gVGhpcyBpcyBhbHNvCj4gPiByZXF1aXJlZCBmb3IgVk0KPiA+ ICvCoMKgwqDCoMKgwqDCoCAqIGNvbm5lY3QgdG8gZGlzcGxheSBwcm9wZXJseSBmb3IgQVJNNjQg TGludXggVk0sIGFzIHRoZQo+ID4gaG9zdCBhbHNvIG1hcHMKPiA+ICvCoMKgwqDCoMKgwqDCoCAq IHRoZSBWUkFNIGNhY2hlYWJsZS4KPiA+ICvCoMKgwqDCoMKgwqDCoCAqLwo+ID4gK8KgwqDCoMKg wqDCoMKgaHYtPnZyYW0gPSBpb3JlbWFwX2NhY2hlKGh2LT5tZW0tPnN0YXJ0LCBodi0+ZmJfc2l6 ZSk7Cj4gPiArwqDCoMKgwqDCoMKgwqBpZiAoIWh2LT52cmFtKSB7Cj4gPiArwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgZHJtX2VycihkZXYsICJGYWlsZWQgdG8gbWFwIHZyYW1cbiIpOwo+ ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoHJldCA9IC1FTk9NRU07Cj4gPiArwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgZ290byBlcnJvcjsKPiA+ICvCoMKgwqDCoMKgwqDC oH0KPiA+ICsKPiA+ICvCoMKgwqDCoMKgwqDCoGh2LT5mYl9iYXNlID0gaHYtPm1lbS0+c3RhcnQ7 Cj4gPiArCj4gPiArwqDCoMKgwqDCoMKgwqBhcCA9IGFsbG9jX2FwZXJ0dXJlcygxKTsKPiA+ICvC oMKgwqDCoMKgwqDCoGlmICghYXApIHsKPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqBkcm1fZXJyKGRldiwgIkZhaWxlZCB0byBnZXQgYXBlcnR1cmVzXG4iKTsKPiA+ICvCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqByZXQgPSAtRU5PTUVNOwo+ID4gK8KgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoGdvdG8gZXJyb3I7Cj4gPiArwqDCoMKgwqDCoMKgwqB9Cj4gPiArCj4g PiArwqDCoMKgwqDCoMKgwqBhcC0+cmFuZ2VzWzBdLmJhc2UgPSBzY3JlZW5faW5mby5sZmJfYmFz ZTsKPiA+ICvCoMKgwqDCoMKgwqDCoGFwLT5yYW5nZXNbMF0uc2l6ZSA9IHNjcmVlbl9pbmZvLmxm Yl9zaXplOwo+ID4gK8KgwqDCoMKgwqDCoMKgcmVtb3ZlX2NvbmZsaWN0aW5nX2ZyYW1lYnVmZmVy cyhhcCwgS0JVSUxEX01PRE5BTUUsIGZhbHNlKTsKPiA+ICvCoMKgwqDCoMKgwqDCoGtmcmVlKGFw KTsKPiA+ICsKPiA+ICvCoMKgwqDCoMKgwqDCoHJldHVybiAwOwo+ID4gKwo+ID4gK2Vycm9yOgo+ ID4gK8KgwqDCoMKgwqDCoMKgdm1idXNfZnJlZV9tbWlvKGh2LT5tZW0tPnN0YXJ0LCBodi0+ZmJf c2l6ZSk7Cj4gPiArwqDCoMKgwqDCoMKgwqByZXR1cm4gcmV0Owo+ID4gK30KPiA+ICsKPiA+ICtz dGF0aWMgaW50IGh5cGVydl92bWJ1c19wcm9iZShzdHJ1Y3QgaHZfZGV2aWNlICpoZGV2LAo+ID4g K8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg IGNvbnN0IHN0cnVjdCBodl92bWJ1c19kZXZpY2VfaWQKPiA+ICpkZXZfaWQpCj4gPiArewo+ID4g K8KgwqDCoMKgwqDCoMKgc3RydWN0IGh5cGVydl9kcm1fZGV2aWNlICpodjsKPiA+ICvCoMKgwqDC oMKgwqDCoHN0cnVjdCBkcm1fZGV2aWNlICpkZXY7Cj4gPiArwqDCoMKgwqDCoMKgwqBpbnQgcmV0 Owo+ID4gKwo+ID4gK8KgwqDCoMKgwqDCoMKgaHYgPSBkZXZtX2RybV9kZXZfYWxsb2MoJmhkZXYt PmRldmljZSwgJmh5cGVydl9kcml2ZXIsCj4gPiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqBzdHJ1Y3QgaHlwZXJ2X2RybV9kZXZp Y2UsIGRldik7Cj4gPiArwqDCoMKgwqDCoMKgwqBpZiAoSVNfRVJSKGh2KSkKPiA+ICvCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqByZXR1cm4gUFRSX0VSUihodik7Cj4gPiArCj4gPiArwqDC oMKgwqDCoMKgwqBkZXYgPSAmaHYtPmRldjsKPiA+ICvCoMKgwqDCoMKgwqDCoGluaXRfY29tcGxl dGlvbigmaHYtPndhaXQpOwo+ID4gK8KgwqDCoMKgwqDCoMKgaHZfc2V0X2RydmRhdGEoaGRldiwg aHYpOwo+ID4gK8KgwqDCoMKgwqDCoMKgaHYtPmhkZXYgPSBoZGV2Owo+ID4gKwo+ID4gK8KgwqDC oMKgwqDCoMKgLyogR2V0IHRoZSBhY3R1YWwgVlJBTSBzaXplIGZyb20gdGhlIGRldmljZSAqLwo+ ID4gK8KgwqDCoMKgwqDCoMKgcmV0ID0gaHlwZXJ2X2Nvbm5lY3RfdnNwKGhkZXYpOwo+ID4gK8Kg wqDCoMKgwqDCoMKgaWYgKHJldCkgewo+ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oGRybV9lcnIoZGV2LCAiRmFpbGVkIHRvIGNvbm5lY3QgdG8gdm1idXMuXG4iKTsKPiA+ICvCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqBnb3RvIGVycl9odl9zZXRfZHJ2X2RhdGE7Cj4gPiAr wqDCoMKgwqDCoMKgwqB9Cj4gPiArCj4gPiArwqDCoMKgwqDCoMKgwqBpZiAoZWZpX2VuYWJsZWQo RUZJX0JPT1QpKQo+ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoHJldCA9IGh5cGVy dl9nZXRfdnJhbV9nZW4yKGh2LCBoZGV2KTsKPiA+ICvCoMKgwqDCoMKgwqDCoGVsc2UKPiA+ICvC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqByZXQgPSBoeXBlcnZfZ2V0X3ZyYW1fZ2VuMSho dik7Cj4gPiArCj4gPiArwqDCoMKgwqDCoMKgwqBpZiAocmV0KQo+ID4gK8KgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoGdvdG8gZXJyX3ZtYnVzX2Nsb3NlOwo+ID4gKwo+ID4gK8KgwqDCoMKg wqDCoMKgLyoKPiA+ICvCoMKgwqDCoMKgwqDCoCAqIFNob3VsZCBiZSBkb25lIG9ubHkgb25jZSBk dXJpbmcgaW5pdCBhbmQgcmVzdW1lLiBGYWlsaW5nCj4gPiB0byB1cGRhdGUKPiA+ICvCoMKgwqDC oMKgwqDCoCAqIHZyYW0gbG9jYXRpb24gaXMgbm90IGZhdGFsLiBEZXZpY2Ugd2lsbCB1cGRhdGUg ZGlydHkKPiA+IGFyZWEgdGlsbAo+ID4gK8KgwqDCoMKgwqDCoMKgICogcHJlZmVycmVkIHJlc29s dXRpb24gb25seS4KPiA+ICvCoMKgwqDCoMKgwqDCoCAqLwo+ID4gK8KgwqDCoMKgwqDCoMKgcmV0 ID0gaHlwZXJ2X3VwZGF0ZV92cmFtX2xvY2F0aW9uKGhkZXYsIGh2LT5mYl9iYXNlKTsKPiA+ICvC oMKgwqDCoMKgwqDCoGlmIChyZXQpCj4gPiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg ZHJtX3dhcm4oZGV2LCAiRmFpbGVkIHRvIHVwZGF0ZSB2cmFtIGxvY2F0aW9uLlxuIik7Cj4gPiAr Cj4gPiArwqDCoMKgwqDCoMKgwqByZXQgPSBoeXBlcnZfbW9kZV9jb25maWdfaW5pdChodik7Cj4g PiArwqDCoMKgwqDCoMKgwqBpZiAocmV0KQo+ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoGdvdG8gZXJyX3ZtYnVzX2Nsb3NlOwo+ID4gKwo+ID4gK8KgwqDCoMKgwqDCoMKgcmV0ID0g ZHJtX2Rldl9yZWdpc3RlcihkZXYsIDApOwo+ID4gK8KgwqDCoMKgwqDCoMKgaWYgKHJldCkgewo+ ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoGRybV9lcnIoZGV2LCAiRmFpbGVkIHRv IHJlZ2lzdGVyIGRybSBkcml2ZXIuXG4iKTsKPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqBnb3RvIGVycl92bWJ1c19jbG9zZTsKPiA+ICvCoMKgwqDCoMKgwqDCoH0KPiA+ICsKPiA+ ICvCoMKgwqDCoMKgwqDCoGRybV9mYmRldl9nZW5lcmljX3NldHVwKGRldiwgMCk7Cj4gPiArCj4g PiArwqDCoMKgwqDCoMKgwqByZXR1cm4gMDsKPiA+ICsKPiA+ICtlcnJfdm1idXNfY2xvc2U6Cj4g PiArwqDCoMKgwqDCoMKgwqB2bWJ1c19jbG9zZShoZGV2LT5jaGFubmVsKTsKPiA+ICtlcnJfaHZf c2V0X2Rydl9kYXRhOgo+ID4gK8KgwqDCoMKgwqDCoMKgaHZfc2V0X2RydmRhdGEoaGRldiwgTlVM TCk7Cj4gPiArwqDCoMKgwqDCoMKgwqByZXR1cm4gcmV0Owo+ID4gK30KPiA+ICsKPiA+ICtzdGF0 aWMgaW50IGh5cGVydl92bWJ1c19yZW1vdmUoc3RydWN0IGh2X2RldmljZSAqaGRldikKPiA+ICt7 Cj4gPiArwqDCoMKgwqDCoMKgwqBzdHJ1Y3QgZHJtX2RldmljZSAqZGV2ID0gaHZfZ2V0X2RydmRh dGEoaGRldik7Cj4gPiArwqDCoMKgwqDCoMKgwqBzdHJ1Y3QgaHlwZXJ2X2RybV9kZXZpY2UgKmh2 ID0gdG9faHYoZGV2KTsKPiA+ICsKPiA+ICvCoMKgwqDCoMKgwqDCoGRybV9kZXZfdW5wbHVnKGRl dik7Cj4gPiArwqDCoMKgwqDCoMKgwqBkcm1fYXRvbWljX2hlbHBlcl9zaHV0ZG93bihkZXYpOwo+ ID4gK8KgwqDCoMKgwqDCoMKgdm1idXNfY2xvc2UoaGRldi0+Y2hhbm5lbCk7Cj4gPiArwqDCoMKg wqDCoMKgwqBodl9zZXRfZHJ2ZGF0YShoZGV2LCBOVUxMKTsKPiA+ICvCoMKgwqDCoMKgwqDCoHZt YnVzX2ZyZWVfbW1pbyhodi0+bWVtLT5zdGFydCwgaHYtPmZiX3NpemUpOwo+ID4gKwo+ID4gK8Kg wqDCoMKgwqDCoMKgcmV0dXJuIDA7Cj4gPiArfQo+ID4gKwo+ID4gK3N0YXRpYyBpbnQgaHlwZXJ2 X3ZtYnVzX3N1c3BlbmQoc3RydWN0IGh2X2RldmljZSAqaGRldikKPiA+ICt7Cj4gPiArwqDCoMKg wqDCoMKgwqBzdHJ1Y3QgZHJtX2RldmljZSAqZGV2ID0gaHZfZ2V0X2RydmRhdGEoaGRldik7Cj4g PiArwqDCoMKgwqDCoMKgwqBpbnQgcmV0Owo+ID4gKwo+ID4gK8KgwqDCoMKgwqDCoMKgcmV0ID0g ZHJtX21vZGVfY29uZmlnX2hlbHBlcl9zdXNwZW5kKGRldik7Cj4gPiArCj4gPiArwqDCoMKgwqDC oMKgwqB2bWJ1c19jbG9zZShoZGV2LT5jaGFubmVsKTsKPiA+ICsKPiA+ICvCoMKgwqDCoMKgwqDC oHJldHVybiByZXQ7Cj4gPiArfQo+ID4gKwo+ID4gK3N0YXRpYyBpbnQgaHlwZXJ2X3ZtYnVzX3Jl c3VtZShzdHJ1Y3QgaHZfZGV2aWNlICpoZGV2KQo+ID4gK3sKPiA+ICvCoMKgwqDCoMKgwqDCoHN0 cnVjdCBkcm1fZGV2aWNlICpkZXYgPSBodl9nZXRfZHJ2ZGF0YShoZGV2KTsKPiA+ICvCoMKgwqDC oMKgwqDCoHN0cnVjdCBoeXBlcnZfZHJtX2RldmljZSAqaHYgPSB0b19odihkZXYpOwo+ID4gK8Kg wqDCoMKgwqDCoMKgaW50IHJldDsKPiA+ICsKPiA+ICvCoMKgwqDCoMKgwqDCoHJldCA9IGh5cGVy dl9jb25uZWN0X3ZzcChoZGV2KTsKPiA+ICvCoMKgwqDCoMKgwqDCoGlmIChyZXQpCj4gPiArwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgcmV0dXJuIHJldDsKPiA+ICsKPiA+ICvCoMKgwqDC oMKgwqDCoHJldCA9IGh5cGVydl91cGRhdGVfdnJhbV9sb2NhdGlvbihoZGV2LCBodi0+ZmJfYmFz ZSk7Cj4gPiArwqDCoMKgwqDCoMKgwqBpZiAocmV0KQo+ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoHJldHVybiByZXQ7Cj4gPiArCj4gPiArwqDCoMKgwqDCoMKgwqByZXR1cm4gZHJt X21vZGVfY29uZmlnX2hlbHBlcl9yZXN1bWUoZGV2KTsKPiA+ICt9Cj4gPiArCj4gPiArc3RhdGlj IGNvbnN0IHN0cnVjdCBodl92bWJ1c19kZXZpY2VfaWQgaHlwZXJ2X3ZtYnVzX3RibFtdID0gewo+ ID4gK8KgwqDCoMKgwqDCoMKgLyogU3ludGhldGljIFZpZGVvIERldmljZSBHVUlEICovCj4gPiAr wqDCoMKgwqDCoMKgwqB7SFZfU1lOVEhWSURfR1VJRH0sCj4gPiArwqDCoMKgwqDCoMKgwqB7fQo+ ID4gK307Cj4gPiArCj4gPiArc3RhdGljIHN0cnVjdCBodl9kcml2ZXIgaHlwZXJ2X2h2X2RyaXZl ciA9IHsKPiA+ICvCoMKgwqDCoMKgwqDCoC5uYW1lID0gS0JVSUxEX01PRE5BTUUsCj4gPiArwqDC oMKgwqDCoMKgwqAuaWRfdGFibGUgPSBoeXBlcnZfdm1idXNfdGJsLAo+ID4gK8KgwqDCoMKgwqDC oMKgLnByb2JlID0gaHlwZXJ2X3ZtYnVzX3Byb2JlLAo+ID4gK8KgwqDCoMKgwqDCoMKgLnJlbW92 ZSA9IGh5cGVydl92bWJ1c19yZW1vdmUsCj4gPiArwqDCoMKgwqDCoMKgwqAuc3VzcGVuZCA9IGh5 cGVydl92bWJ1c19zdXNwZW5kLAo+ID4gK8KgwqDCoMKgwqDCoMKgLnJlc3VtZSA9IGh5cGVydl92 bWJ1c19yZXN1bWUsCj4gPiArwqDCoMKgwqDCoMKgwqAuZHJpdmVyID0gewo+ID4gK8KgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoC5wcm9iZV90eXBlID0gUFJPQkVfUFJFRkVSX0FTWU5DSFJP Tk9VUywKPiA+ICvCoMKgwqDCoMKgwqDCoH0sCj4gPiArfTsKPiA+ICsKPiA+ICtzdGF0aWMgaW50 IF9faW5pdCBoeXBlcnZfaW5pdCh2b2lkKQo+ID4gK3sKPiA+ICvCoMKgwqDCoMKgwqDCoGludCBy ZXQ7Cj4gPiArCj4gPiArwqDCoMKgwqDCoMKgwqByZXQgPSBwY2lfcmVnaXN0ZXJfZHJpdmVyKCZo eXBlcnZfcGNpX2RyaXZlcik7Cj4gPiArwqDCoMKgwqDCoMKgwqBpZiAocmV0ICE9IDApCj4gPiAr wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgcmV0dXJuIHJldDsKPiA+ICsKPiA+ICvCoMKg wqDCoMKgwqDCoHJldHVybiB2bWJ1c19kcml2ZXJfcmVnaXN0ZXIoJmh5cGVydl9odl9kcml2ZXIp Owo+ID4gK30KPiA+ICsKPiA+ICtzdGF0aWMgdm9pZCBfX2V4aXQgaHlwZXJ2X2V4aXQodm9pZCkK PiA+ICt7Cj4gPiArwqDCoMKgwqDCoMKgwqB2bWJ1c19kcml2ZXJfdW5yZWdpc3RlcigmaHlwZXJ2 X2h2X2RyaXZlcik7Cj4gPiArwqDCoMKgwqDCoMKgwqBwY2lfdW5yZWdpc3Rlcl9kcml2ZXIoJmh5 cGVydl9wY2lfZHJpdmVyKTsKPiA+ICt9Cj4gPiArCj4gPiArbW9kdWxlX2luaXQoaHlwZXJ2X2lu aXQpOwo+ID4gK21vZHVsZV9leGl0KGh5cGVydl9leGl0KTsKPiA+ICsKPiA+ICtNT0RVTEVfREVW SUNFX1RBQkxFKHBjaSwgaHlwZXJ2X3BjaV90YmwpOwo+ID4gK01PRFVMRV9ERVZJQ0VfVEFCTEUo dm1idXMsIGh5cGVydl92bWJ1c190YmwpOwo+ID4gK01PRFVMRV9MSUNFTlNFKCJHUEwiKTsKPiA+ ICtNT0RVTEVfQVVUSE9SKCJEZWVwYWsgUmF3YXQgPGRyYXdhdC5mbG9zc0BnbWFpbC5jb20+Iik7 Cj4gPiArTU9EVUxFX0RFU0NSSVBUSU9OKCJEUk0gZHJpdmVyIGZvciBoeXBlcnYgc3ludGhldGlj IHZpZGVvCj4gPiBkZXZpY2UiKTsKPiA+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaHlw ZXJ2L2h5cGVydl9kcm1fbW9kZXNldC5jCj4gPiBiL2RyaXZlcnMvZ3B1L2RybS9oeXBlcnYvaHlw ZXJ2X2RybV9tb2Rlc2V0LmMKPiA+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4gPiBpbmRleCAwMDAw MDAwMDAwMDAuLjQwZWMwY2ZmMGU1OQo+ID4gLS0tIC9kZXYvbnVsbAo+ID4gKysrIGIvZHJpdmVy cy9ncHUvZHJtL2h5cGVydi9oeXBlcnZfZHJtX21vZGVzZXQuYwo+ID4gQEAgLTAsMCArMSwyNDAg QEAKPiA+ICsvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMAo+ID4gKy8qCj4gPiAr ICogQ29weXJpZ2h0IDIwMTItMjAyMSBNaWNyb3NvZnQKPiA+ICsgKi8KPiA+ICsKPiA+ICsjaW5j bHVkZSA8bGludXgvaHlwZXJ2Lmg+Cj4gPiArCj4gPiArI2luY2x1ZGUgPGRybS9kcm1fZGFtYWdl X2hlbHBlci5oPgo+ID4gKyNpbmNsdWRlIDxkcm0vZHJtX2Rydi5oPgo+ID4gKyNpbmNsdWRlIDxk cm0vZHJtX2ZiX2hlbHBlci5oPgo+ID4gKyNpbmNsdWRlIDxkcm0vZHJtX2Zvcm1hdF9oZWxwZXIu aD4KPiA+ICsjaW5jbHVkZSA8ZHJtL2RybV9mb3VyY2MuaD4KPiA+ICsjaW5jbHVkZSA8ZHJtL2Ry bV9nZW1fc2htZW1faGVscGVyLmg+Cj4gPiArI2luY2x1ZGUgPGRybS9kcm1fZ2VtX2ZyYW1lYnVm ZmVyX2hlbHBlci5oPgo+ID4gKyNpbmNsdWRlIDxkcm0vZHJtX3Byb2JlX2hlbHBlci5oPgo+ID4g KyNpbmNsdWRlIDxkcm0vZHJtX3NpbXBsZV9rbXNfaGVscGVyLmg+Cj4gPiArCj4gPiArI2luY2x1 ZGUgImh5cGVydl9kcm0uaCIKPiA+ICsKPiA+ICtzdGF0aWMgaW50IGh5cGVydl9ibGl0X3RvX3Zy YW1fcmVjdChzdHJ1Y3QgZHJtX2ZyYW1lYnVmZmVyICpmYiwKPiA+ICvCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBzdHJ1 Y3QgZHJtX3JlY3QgKnJlY3QpCj4gPiArewo+ID4gK8KgwqDCoMKgwqDCoMKgc3RydWN0IGh5cGVy dl9kcm1fZGV2aWNlICpodiA9IHRvX2h2KGZiLT5kZXYpOwo+ID4gK8KgwqDCoMKgwqDCoMKgc3Ry dWN0IGRtYV9idWZfbWFwIG1hcDsKPiA+ICvCoMKgwqDCoMKgwqDCoHZvaWQgKnZtYXA7Cj4gPiAr wqDCoMKgwqDCoMKgwqBpbnQgaWR4LCByZXQ7Cj4gPiArCj4gPiArwqDCoMKgwqDCoMKgwqBpZiAo IWRybV9kZXZfZW50ZXIoJmh2LT5kZXYsICZpZHgpKQo+ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoHJldHVybiAtRU5PREVWOwo+ID4gKwo+ID4gK8KgwqDCoMKgwqDCoMKgcmV0ID0g ZHJtX2dlbV9zaG1lbV92bWFwKGZiLT5vYmpbMF0sICZtYXApOwo+ID4gK8KgwqDCoMKgwqDCoMKg aWYgKHJldCkgewo+ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoGRybV9kZXZfZXhp dChpZHgpOwo+ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoHJldHVybiByZXQ7Cj4g PiArwqDCoMKgwqDCoMKgwqB9Cj4gPiArCj4gPiArwqDCoMKgwqDCoMKgwqB2bWFwID0gbWFwLnZh ZGRyOwo+ID4gK8KgwqDCoMKgwqDCoMKgZHJtX2ZiX21lbWNweV9kc3RjbGlwKGh2LT52cmFtLCB2 bWFwLCBmYiwgcmVjdCk7Cj4gPiArwqDCoMKgwqDCoMKgwqBkcm1fZ2VtX3NobWVtX3Z1bm1hcChm Yi0+b2JqWzBdLCB2bWFwKTsKPiA+ICvCoMKgwqDCoMKgwqDCoGRybV9kZXZfZXhpdChpZHgpOwo+ ID4gKwo+ID4gK8KgwqDCoMKgwqDCoMKgcmV0dXJuIDA7Cj4gPiArfQo+ID4gKwo+ID4gK3N0YXRp YyBpbnQgaHlwZXJ2X2JsaXRfdG9fdnJhbV9mdWxsc2NyZWVuKHN0cnVjdCBkcm1fZnJhbWVidWZm ZXIKPiA+ICpmYikKPiA+ICt7Cj4gPiArwqDCoMKgwqDCoMKgwqBzdHJ1Y3QgZHJtX3JlY3QgZnVs bHNjcmVlbiA9IHsKPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAueDEgPSAwLAo+ ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoC54MiA9IGZiLT53aWR0aCwKPiA+ICvC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAueTEgPSAwLAo+ID4gK8KgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoC55MiA9IGZiLT5oZWlnaHQsCj4gPiArwqDCoMKgwqDCoMKgwqB9Owo+ ID4gK8KgwqDCoMKgwqDCoMKgcmV0dXJuIGh5cGVydl9ibGl0X3RvX3ZyYW1fcmVjdChmYiwgJmZ1 bGxzY3JlZW4pOwo+ID4gK30KPiA+ICsKPiA+ICtzdGF0aWMgaW50IGh5cGVydl9jb25uZWN0b3Jf Z2V0X21vZGVzKHN0cnVjdCBkcm1fY29ubmVjdG9yCj4gPiAqY29ubmVjdG9yKQo+ID4gK3sKPiA+ ICvCoMKgwqDCoMKgwqDCoHN0cnVjdCBoeXBlcnZfZHJtX2RldmljZSAqaHYgPSB0b19odihjb25u ZWN0b3ItPmRldik7Cj4gPiArwqDCoMKgwqDCoMKgwqBpbnQgY291bnQ7Cj4gPiArCj4gPiArwqDC oMKgwqDCoMKgwqBjb3VudCA9IGRybV9hZGRfbW9kZXNfbm9lZGlkKGNvbm5lY3RvciwKPiA+ICvC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgIGNvbm5lY3Rvci0+ZGV2LQo+ID4gPm1vZGVfY29uZmlnLm1heF93aWR0aCwK PiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgIGNvbm5lY3Rvci0+ZGV2LQo+ID4gPm1vZGVfY29uZmlnLm1heF9o ZWlnaHQpOwo+ID4gK8KgwqDCoMKgwqDCoMKgZHJtX3NldF9wcmVmZXJyZWRfbW9kZShjb25uZWN0 b3IsIGh2LT5wcmVmZXJyZWRfd2lkdGgsCj4gPiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBodi0+cHJlZmVycmVkX2hlaWdodCk7Cj4g PiArCj4gPiArwqDCoMKgwqDCoMKgwqByZXR1cm4gY291bnQ7Cj4gPiArfQo+ID4gKwo+ID4gK3N0 YXRpYyBjb25zdCBzdHJ1Y3QgZHJtX2Nvbm5lY3Rvcl9oZWxwZXJfZnVuY3MKPiA+IGh5cGVydl9j b25uZWN0b3JfaGVscGVyX2Z1bmNzID0gewo+ID4gK8KgwqDCoMKgwqDCoMKgLmdldF9tb2RlcyA9 IGh5cGVydl9jb25uZWN0b3JfZ2V0X21vZGVzLAo+ID4gK307Cj4gPiArCj4gPiArc3RhdGljIGNv bnN0IHN0cnVjdCBkcm1fY29ubmVjdG9yX2Z1bmNzIGh5cGVydl9jb25uZWN0b3JfZnVuY3MgPSB7 Cj4gPiArwqDCoMKgwqDCoMKgwqAuZmlsbF9tb2RlcyA9IGRybV9oZWxwZXJfcHJvYmVfc2luZ2xl X2Nvbm5lY3Rvcl9tb2RlcywKPiA+ICvCoMKgwqDCoMKgwqDCoC5kZXN0cm95ID0gZHJtX2Nvbm5l Y3Rvcl9jbGVhbnVwLAo+ID4gK8KgwqDCoMKgwqDCoMKgLnJlc2V0ID0gZHJtX2F0b21pY19oZWxw ZXJfY29ubmVjdG9yX3Jlc2V0LAo+ID4gK8KgwqDCoMKgwqDCoMKgLmF0b21pY19kdXBsaWNhdGVf c3RhdGUgPQo+ID4gZHJtX2F0b21pY19oZWxwZXJfY29ubmVjdG9yX2R1cGxpY2F0ZV9zdGF0ZSwK PiA+ICvCoMKgwqDCoMKgwqDCoC5hdG9taWNfZGVzdHJveV9zdGF0ZSA9Cj4gPiBkcm1fYXRvbWlj X2hlbHBlcl9jb25uZWN0b3JfZGVzdHJveV9zdGF0ZSwKPiA+ICt9Owo+ID4gKwo+ID4gK3N0YXRp YyBpbnQgaHlwZXJ2X2Nvbm5faW5pdChzdHJ1Y3QgaHlwZXJ2X2RybV9kZXZpY2UgKmh2KQo+ID4g K3sKPiA+ICvCoMKgwqDCoMKgwqDCoGRybV9jb25uZWN0b3JfaGVscGVyX2FkZCgmaHYtPmNvbm5l Y3RvciwKPiA+ICZoeXBlcnZfY29ubmVjdG9yX2hlbHBlcl9mdW5jcyk7Cj4gPiArwqDCoMKgwqDC oMKgwqByZXR1cm4gZHJtX2Nvbm5lY3Rvcl9pbml0KCZodi0+ZGV2LCAmaHYtPmNvbm5lY3RvciwK PiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgICZoeXBlcnZfY29ubmVjdG9yX2Z1bmNzLAo+ID4gK8KgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgRFJNX01P REVfQ09OTkVDVE9SX1ZHQSk7Cj4gPiArfQo+ID4gKwo+ID4gK3N0YXRpYyBpbnQgaHlwZXJ2X2No ZWNrX3NpemUoc3RydWN0IGh5cGVydl9kcm1fZGV2aWNlICpodiwgaW50IHcsCj4gPiBpbnQgaCwK PiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqAgc3RydWN0IGRybV9mcmFtZWJ1ZmZlciAqZmIpCj4gPiArewo+ID4gK8KgwqDCoMKgwqDCoMKg dTMyIHBpdGNoID0gdyAqIChodi0+c2NyZWVuX2RlcHRoIC8gOCk7Cj4gPiArCj4gPiArwqDCoMKg wqDCoMKgwqBpZiAoZmIpCj4gPiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgcGl0Y2gg PSBmYi0+cGl0Y2hlc1swXTsKPiA+ICsKPiA+ICvCoMKgwqDCoMKgwqDCoGlmIChwaXRjaCAqIGgg PiBodi0+ZmJfc2l6ZSkKPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqByZXR1cm4g LUVJTlZBTDsKPiA+ICsKPiA+ICvCoMKgwqDCoMKgwqDCoHJldHVybiAwOwo+ID4gK30KPiA+ICsK PiA+ICtzdGF0aWMgdm9pZCBoeXBlcnZfcGlwZV9lbmFibGUoc3RydWN0IGRybV9zaW1wbGVfZGlz cGxheV9waXBlCj4gPiAqcGlwZSwKPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHN0cnVjdCBkcm1fY3J0Y19zdGF0ZSAqY3J0Y19z dGF0ZSwKPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgIHN0cnVjdCBkcm1fcGxhbmVfc3RhdGUgKnBsYW5lX3N0YXRlKQo+ID4gK3sK PiA+ICvCoMKgwqDCoMKgwqDCoHN0cnVjdCBoeXBlcnZfZHJtX2RldmljZSAqaHYgPSB0b19odihw aXBlLT5jcnRjLmRldik7Cj4gPiArCj4gPiArwqDCoMKgwqDCoMKgwqBoeXBlcnZfdXBkYXRlX3Np dHVhdGlvbihodi0+aGRldiwgMSzCoCBodi0+c2NyZWVuX2RlcHRoLAo+ID4gK8KgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgY3J0Y19z dGF0ZS0+bW9kZS5oZGlzcGxheSwKPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoGNydGNfc3RhdGUtPm1vZGUudmRpc3BsYXks Cj4gPiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqBwbGFuZV9zdGF0ZS0+ZmItPnBpdGNoZXNbMF0pOwo+ID4gK8KgwqDCoMKgwqDC oMKgaHlwZXJ2X2JsaXRfdG9fdnJhbV9mdWxsc2NyZWVuKHBsYW5lX3N0YXRlLT5mYik7Cj4gPiAr fQo+ID4gKwo+ID4gK3N0YXRpYyBpbnQgaHlwZXJ2X3BpcGVfY2hlY2soc3RydWN0IGRybV9zaW1w bGVfZGlzcGxheV9waXBlICpwaXBlLAo+ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBzdHJ1Y3QgZHJtX3BsYW5lX3N0YXRlICpwbGFuZV9z dGF0ZSwKPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqAgc3RydWN0IGRybV9jcnRjX3N0YXRlICpjcnRjX3N0YXRlKQo+ID4gK3sKPiA+ICvC oMKgwqDCoMKgwqDCoHN0cnVjdCBoeXBlcnZfZHJtX2RldmljZSAqaHYgPSB0b19odihwaXBlLT5j cnRjLmRldik7Cj4gPiArwqDCoMKgwqDCoMKgwqBzdHJ1Y3QgZHJtX2ZyYW1lYnVmZmVyICpmYiA9 IHBsYW5lX3N0YXRlLT5mYjsKPiA+ICsKPiA+ICvCoMKgwqDCoMKgwqDCoGlmIChmYi0+Zm9ybWF0 LT5mb3JtYXQgIT0gRFJNX0ZPUk1BVF9YUkdCODg4OCkKPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqByZXR1cm4gLUVJTlZBTDsKPiA+ICsKPiA+ICvCoMKgwqDCoMKgwqDCoGlmIChm Yi0+cGl0Y2hlc1swXSAqIGZiLT5oZWlnaHQgPiBodi0+ZmJfc2l6ZSkKPiA+ICvCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqByZXR1cm4gLUVJTlZBTDsKPiA+ICsKPiA+ICvCoMKgwqDCoMKg wqDCoHJldHVybiAwOwo+ID4gK30KPiA+ICsKPiA+ICtzdGF0aWMgdm9pZCBoeXBlcnZfcGlwZV91 cGRhdGUoc3RydWN0IGRybV9zaW1wbGVfZGlzcGxheV9waXBlCj4gPiAqcGlwZSwKPiA+ICvCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHN0 cnVjdCBkcm1fcGxhbmVfc3RhdGUgKm9sZF9zdGF0ZSkKPiA+ICt7Cj4gPiArwqDCoMKgwqDCoMKg wqBzdHJ1Y3QgaHlwZXJ2X2RybV9kZXZpY2UgKmh2ID0gdG9faHYocGlwZS0+Y3J0Yy5kZXYpOwo+ ID4gK8KgwqDCoMKgwqDCoMKgc3RydWN0IGRybV9wbGFuZV9zdGF0ZSAqc3RhdGUgPSBwaXBlLT5w bGFuZS5zdGF0ZTsKPiA+ICvCoMKgwqDCoMKgwqDCoHN0cnVjdCBkcm1fcmVjdCByZWN0Owo+ID4g Kwo+ID4gK8KgwqDCoMKgwqDCoMKgaWYgKGRybV9hdG9taWNfaGVscGVyX2RhbWFnZV9tZXJnZWQo b2xkX3N0YXRlLCBzdGF0ZSwKPiA+ICZyZWN0KSkgewo+ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoGh5cGVydl9ibGl0X3RvX3ZyYW1fcmVjdChzdGF0ZS0+ZmIsICZyZWN0KTsKPiA+ ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqBoeXBlcnZfdXBkYXRlX2RpcnQoaHYtPmhk ZXYsICZyZWN0KTsKPiA+ICvCoMKgwqDCoMKgwqDCoH0KPiA+ICt9Cj4gPiArCj4gPiArc3RhdGlj IGNvbnN0IHN0cnVjdCBkcm1fc2ltcGxlX2Rpc3BsYXlfcGlwZV9mdW5jcwo+ID4gaHlwZXJ2X3Bp cGVfZnVuY3MgPSB7Cj4gPiArwqDCoMKgwqDCoMKgwqAuZW5hYmxlwqA9IGh5cGVydl9waXBlX2Vu YWJsZSwKPiA+ICvCoMKgwqDCoMKgwqDCoC5jaGVjayA9IGh5cGVydl9waXBlX2NoZWNrLAo+ID4g K8KgwqDCoMKgwqDCoMKgLnVwZGF0ZcKgPSBoeXBlcnZfcGlwZV91cGRhdGUsCj4gPiArfTsKPiA+ ICsKPiA+ICtzdGF0aWMgY29uc3QgdWludDMyX3QgaHlwZXJ2X2Zvcm1hdHNbXSA9IHsKPiA+ICvC oMKgwqDCoMKgwqDCoERSTV9GT1JNQVRfWFJHQjg4ODgsCj4gPiArfTsKPiA+ICsKPiA+ICtzdGF0 aWMgY29uc3QgdWludDY0X3QgaHlwZXJ2X21vZGlmaWVyc1tdID0gewo+ID4gK8KgwqDCoMKgwqDC oMKgRFJNX0ZPUk1BVF9NT0RfTElORUFSLAo+ID4gK8KgwqDCoMKgwqDCoMKgRFJNX0ZPUk1BVF9N T0RfSU5WQUxJRAo+ID4gK307Cj4gPiArCj4gPiArc3RhdGljIGludCBoeXBlcnZfcGlwZV9pbml0 KHN0cnVjdCBoeXBlcnZfZHJtX2RldmljZSAqaHYpCj4gPiArewo+ID4gK8KgwqDCoMKgwqDCoMKg aW50IHJldDsKPiA+ICsKPiA+ICvCoMKgwqDCoMKgwqDCoHJldCA9IGRybV9zaW1wbGVfZGlzcGxh eV9waXBlX2luaXQoJmh2LT5kZXYsCj4gPiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCAmaHYt PnBpcGUsCj4gPiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCAmaHlwZXJ2X3BpcGVfZnVuY3Ms Cj4gPiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBoeXBlcnZfZm9ybWF0cywKPiA+ICvCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgCj4gPiBBUlJBWV9TSVpFKGh5cGVydl9mb3JtYXRzKSwKPiA+ ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIE5VTEwsCj4gPiArwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoCAmaHYtPmNvbm5lY3Rvcik7Cj4gPiArCj4gPiArwqDCoMKgwqDCoMKgwqBkcm1fcGxh bmVfZW5hYmxlX2ZiX2RhbWFnZV9jbGlwcygmaHYtPnBpcGUucGxhbmUpOwo+ID4gKwo+ID4gK8Kg wqDCoMKgwqDCoMKgcmV0dXJuIHJldDsKPiA+ICt9Cj4gPiArCj4gPiArc3RhdGljIHN0cnVjdCBk cm1fZnJhbWVidWZmZXIqCj4gPiAraHlwZXJ2X2ZiX2NyZWF0ZShzdHJ1Y3QgZHJtX2RldmljZSAq ZGV2LCBzdHJ1Y3QgZHJtX2ZpbGUKPiA+ICpmaWxlX3ByaXYsCj4gPiArwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgIGNvbnN0IHN0cnVjdCBkcm1fbW9kZV9mYl9jbWQyICptb2RlX2NtZCkK PiA+ICt7Cj4gPiArwqDCoMKgwqDCoMKgwqByZXR1cm4gZHJtX2dlbV9mYl9jcmVhdGVfd2l0aF9k aXJ0eShkZXYsIGZpbGVfcHJpdiwKPiA+IG1vZGVfY21kKTsKPiA+ICt9Cj4gPiArCj4gPiArc3Rh dGljIGVudW0gZHJtX21vZGVfc3RhdHVzCj4gPiAraHlwZXJ2X21vZGVfdmFsaWQoc3RydWN0IGRy bV9kZXZpY2UgKmRldiwKPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBjb25z dCBzdHJ1Y3QgZHJtX2Rpc3BsYXlfbW9kZSAqbW9kZSkKPiA+ICt7Cj4gPiArwqDCoMKgwqDCoMKg wqBzdHJ1Y3QgaHlwZXJ2X2RybV9kZXZpY2UgKmh2ID0gdG9faHYoZGV2KTsKPiA+ICsKPiA+ICvC oMKgwqDCoMKgwqDCoGlmIChoeXBlcnZfY2hlY2tfc2l6ZShodiwgbW9kZS0+aGRpc3BsYXksIG1v ZGUtPnZkaXNwbGF5LAo+ID4gTlVMTCkpCj4gPiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgcmV0dXJuIE1PREVfQkFEOwo+ID4gKwo+ID4gK8KgwqDCoMKgwqDCoMKgcmV0dXJuIE1PREVf T0s7Cj4gPiArfQo+ID4gKwo+ID4gK3N0YXRpYyBjb25zdCBzdHJ1Y3QgZHJtX21vZGVfY29uZmln X2Z1bmNzIGh5cGVydl9tb2RlX2NvbmZpZ19mdW5jcwo+ID4gPSB7Cj4gPiArwqDCoMKgwqDCoMKg wqAuZmJfY3JlYXRlID0gaHlwZXJ2X2ZiX2NyZWF0ZSwKPiA+ICvCoMKgwqDCoMKgwqDCoC5tb2Rl X3ZhbGlkID0gaHlwZXJ2X21vZGVfdmFsaWQsCj4gPiArwqDCoMKgwqDCoMKgwqAuYXRvbWljX2No ZWNrID0gZHJtX2F0b21pY19oZWxwZXJfY2hlY2ssCj4gPiArwqDCoMKgwqDCoMKgwqAuYXRvbWlj X2NvbW1pdCA9IGRybV9hdG9taWNfaGVscGVyX2NvbW1pdCwKPiA+ICt9Owo+ID4gKwo+ID4gK2lu dCBoeXBlcnZfbW9kZV9jb25maWdfaW5pdChzdHJ1Y3QgaHlwZXJ2X2RybV9kZXZpY2UgKmh2KQo+ ID4gK3sKPiA+ICvCoMKgwqDCoMKgwqDCoHN0cnVjdCBkcm1fZGV2aWNlICpkZXYgPSAmaHYtPmRl djsKPiA+ICvCoMKgwqDCoMKgwqDCoGludCByZXQ7Cj4gPiArCj4gPiArwqDCoMKgwqDCoMKgwqBy ZXQgPSBkcm1tX21vZGVfY29uZmlnX2luaXQoZGV2KTsKPiA+ICvCoMKgwqDCoMKgwqDCoGlmIChy ZXQpIHsKPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqBkcm1fZXJyKGRldiwgIkZh aWxlZCB0byBpbml0aWFsaXplZCBtb2RlCj4gPiBzZXR0aW5nLlxuIik7Cj4gPiArwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgcmV0dXJuIHJldDsKPiA+ICvCoMKgwqDCoMKgwqDCoH0KPiA+ ICsKPiA+ICvCoMKgwqDCoMKgwqDCoGRldi0+bW9kZV9jb25maWcubWluX3dpZHRoID0gMDsKPiA+ ICvCoMKgwqDCoMKgwqDCoGRldi0+bW9kZV9jb25maWcubWluX2hlaWdodCA9IDA7Cj4gPiArwqDC oMKgwqDCoMKgwqBkZXYtPm1vZGVfY29uZmlnLm1heF93aWR0aCA9IGh2LT5zY3JlZW5fd2lkdGhf bWF4Owo+ID4gK8KgwqDCoMKgwqDCoMKgZGV2LT5tb2RlX2NvbmZpZy5tYXhfaGVpZ2h0ID0gaHYt PnNjcmVlbl9oZWlnaHRfbWF4Owo+ID4gKwo+ID4gK8KgwqDCoMKgwqDCoMKgZGV2LT5tb2RlX2Nv bmZpZy5wcmVmZXJyZWRfZGVwdGggPSBodi0+c2NyZWVuX2RlcHRoOwo+ID4gK8KgwqDCoMKgwqDC oMKgZGV2LT5tb2RlX2NvbmZpZy5wcmVmZXJfc2hhZG93ID0gMDsKPiA+ICsKPiA+ICvCoMKgwqDC oMKgwqDCoGRldi0+bW9kZV9jb25maWcuZnVuY3MgPSAmaHlwZXJ2X21vZGVfY29uZmlnX2Z1bmNz Owo+ID4gKwo+ID4gK8KgwqDCoMKgwqDCoMKgcmV0ID0gaHlwZXJ2X2Nvbm5faW5pdChodik7Cj4g PiArwqDCoMKgwqDCoMKgwqBpZiAocmV0KSB7Cj4gPiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgZHJtX2VycihkZXYsICJGYWlsZWQgdG8gaW5pdGlhbGl6ZWQgY29ubmVjdG9yLlxuIik7 Cj4gPiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgcmV0dXJuIHJldDsKPiA+ICvCoMKg wqDCoMKgwqDCoH0KPiA+ICsKPiA+ICvCoMKgwqDCoMKgwqDCoHJldCA9IGh5cGVydl9waXBlX2lu aXQoaHYpOwo+ID4gK8KgwqDCoMKgwqDCoMKgaWYgKHJldCkgewo+ID4gK8KgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoGRybV9lcnIoZGV2LCAiRmFpbGVkIHRvIGluaXRpYWxpemVkIHBpcGUu XG4iKTsKPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqByZXR1cm4gcmV0Owo+ID4g K8KgwqDCoMKgwqDCoMKgfQo+ID4gKwo+ID4gK8KgwqDCoMKgwqDCoMKgZHJtX21vZGVfY29uZmln X3Jlc2V0KGRldik7Cj4gPiArCj4gPiArwqDCoMKgwqDCoMKgwqByZXR1cm4gMDsKPiA+ICt9Cj4g PiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2h5cGVydi9oeXBlcnZfZHJtX3Byb3RvLmMK PiA+IGIvZHJpdmVycy9ncHUvZHJtL2h5cGVydi9oeXBlcnZfZHJtX3Byb3RvLmMKPiA+IG5ldyBm aWxlIG1vZGUgMTAwNjQ0Cj4gPiBpbmRleCAwMDAwMDAwMDAwMDAuLjRlNjE5OTJiZTEyMQo+ID4g LS0tIC9kZXYvbnVsbAo+ID4gKysrIGIvZHJpdmVycy9ncHUvZHJtL2h5cGVydi9oeXBlcnZfZHJt X3Byb3RvLmMKPiA+IEBAIC0wLDAgKzEsNDg2IEBACj4gPiArLy8gU1BEWC1MaWNlbnNlLUlkZW50 aWZpZXI6IEdQTC0yLjAKPiA+ICsvKgo+ID4gKyAqIENvcHlyaWdodCAyMDEyLTIwMjEgTWljcm9z b2Z0Cj4gPiArICovCj4gPiArCj4gPiArI2luY2x1ZGUgPGxpbnV4L2h5cGVydi5oPgo+ID4gKwo+ ID4gKyNpbmNsdWRlIDxkcm0vZHJtX3ByaW50Lmg+Cj4gPiArI2luY2x1ZGUgPGRybS9kcm1fc2lt cGxlX2ttc19oZWxwZXIuaD4KPiA+ICsKPiA+ICsjaW5jbHVkZSAiaHlwZXJ2X2RybS5oIgo+ID4g Kwo+ID4gKyNkZWZpbmUgVk1CVVNfUklOR19CVUZTSVpFICgyNTYgKiAxMDI0KQo+ID4gKyNkZWZp bmUgVk1CVVNfVlNQX1RJTUVPVVQgKDEwICogSFopCj4gPiArCj4gPiArI2RlZmluZSBTWU5USFZJ RF9WRVJTSU9OKG1ham9yLCBtaW5vcikgKChtaW5vcikgPDwgMTYgfCAobWFqb3IpKQo+ID4gKyNk ZWZpbmUgU1lOVEhWSURfVkVSX0dFVF9NQUpPUih2ZXIpICh2ZXIgJiAweDAwMDBmZmZmKQo+ID4g KyNkZWZpbmUgU1lOVEhWSURfVkVSX0dFVF9NSU5PUih2ZXIpICgodmVyICYgMHhmZmZmMDAwMCkg Pj4gMTYpCj4gPiArI2RlZmluZSBTWU5USFZJRF9WRVJTSU9OX1dJTjcgU1lOVEhWSURfVkVSU0lP TigzLCAwKQo+ID4gKyNkZWZpbmUgU1lOVEhWSURfVkVSU0lPTl9XSU44IFNZTlRIVklEX1ZFUlNJ T04oMywgMikKPiA+ICsjZGVmaW5lIFNZTlRIVklEX1ZFUlNJT05fV0lOMTAgU1lOVEhWSURfVkVS U0lPTigzLCA1KQo+ID4gKwo+ID4gKyNkZWZpbmUgU1lOVEhWSURfREVQVEhfV0lONyAxNgo+ID4g KyNkZWZpbmUgU1lOVEhWSURfREVQVEhfV0lOOCAzMgo+ID4gKyNkZWZpbmUgU1lOVEhWSURfRkJf U0laRV9XSU43ICg0ICogMTAyNCAqIDEwMjQpCj4gPiArI2RlZmluZSBTWU5USFZJRF9GQl9TSVpF X1dJTjggKDggKiAxMDI0ICogMTAyNCkKPiA+ICsjZGVmaW5lIFNZTlRIVklEX1dJRFRIX01BWF9X SU43IDE2MDAKPiA+ICsjZGVmaW5lIFNZTlRIVklEX0hFSUdIVF9NQVhfV0lONyAxMjAwCj4gPiAr Cj4gPiArZW51bSBwaXBlX21zZ190eXBlIHsKPiA+ICvCoMKgwqDCoMKgwqDCoFBJUEVfTVNHX0lO VkFMSUQsCj4gPiArwqDCoMKgwqDCoMKgwqBQSVBFX01TR19EQVRBLAo+ID4gK8KgwqDCoMKgwqDC oMKgUElQRV9NU0dfTUFYCj4gPiArfTsKPiA+ICsKPiA+ICtlbnVtIHN5bnRodmlkX21zZ190eXBl IHsKPiA+ICvCoMKgwqDCoMKgwqDCoFNZTlRIVklEX0VSUk9SwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgPSAwLAo+ID4gK8KgwqDCoMKgwqDCoMKgU1lOVEhWSURfVkVSU0lPTl9S RVFVRVNUwqDCoMKgwqDCoMKgwqDCoD0gMSwKPiA+ICvCoMKgwqDCoMKgwqDCoFNZTlRIVklEX1ZF UlNJT05fUkVTUE9OU0XCoMKgwqDCoMKgwqDCoD0gMiwKPiA+ICvCoMKgwqDCoMKgwqDCoFNZTlRI VklEX1ZSQU1fTE9DQVRJT07CoMKgwqDCoMKgwqDCoMKgwqDCoD0gMywKPiA+ICvCoMKgwqDCoMKg wqDCoFNZTlRIVklEX1ZSQU1fTE9DQVRJT05fQUNLwqDCoMKgwqDCoMKgPSA0LAo+ID4gK8KgwqDC oMKgwqDCoMKgU1lOVEhWSURfU0lUVUFUSU9OX1VQREFURcKgwqDCoMKgwqDCoMKgPSA1LAo+ID4g K8KgwqDCoMKgwqDCoMKgU1lOVEhWSURfU0lUVUFUSU9OX1VQREFURV9BQ0vCoMKgwqA9IDYsCj4g PiArwqDCoMKgwqDCoMKgwqBTWU5USFZJRF9QT0lOVEVSX1BPU0lUSU9OwqDCoMKgwqDCoMKgwqA9 IDcsCj4gPiArwqDCoMKgwqDCoMKgwqBTWU5USFZJRF9QT0lOVEVSX1NIQVBFwqDCoMKgwqDCoMKg wqDCoMKgwqA9IDgsCj4gPiArwqDCoMKgwqDCoMKgwqBTWU5USFZJRF9GRUFUVVJFX0NIQU5HRcKg wqDCoMKgwqDCoMKgwqDCoD0gOSwKPiA+ICvCoMKgwqDCoMKgwqDCoFNZTlRIVklEX0RJUlTCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoD0gMTAsCj4gPiArwqDCoMKgwqDCoMKg wqBTWU5USFZJRF9SRVNPTFVUSU9OX1JFUVVFU1TCoMKgwqDCoMKgPSAxMywKPiA+ICvCoMKgwqDC oMKgwqDCoFNZTlRIVklEX1JFU09MVVRJT05fUkVTUE9OU0XCoMKgwqDCoD0gMTQsCj4gPiArCj4g PiArwqDCoMKgwqDCoMKgwqBTWU5USFZJRF9NQVjCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgPSAxNQo+ID4gK307Cj4gPiArCj4gPiArc3RydWN0IHBpcGVfbXNnX2hkciB7 Cj4gPiArwqDCoMKgwqDCoMKgwqB1MzIgdHlwZTsKPiA+ICvCoMKgwqDCoMKgwqDCoHUzMiBzaXpl OyAvKiBzaXplIG9mIG1lc3NhZ2UgYWZ0ZXIgdGhpcyBmaWVsZCAqLwo+ID4gK30gX19wYWNrZWQ7 Cj4gPiArCj4gPiArc3RydWN0IGh2ZF9zY3JlZW5faW5mbyB7Cj4gPiArwqDCoMKgwqDCoMKgwqB1 MTYgd2lkdGg7Cj4gPiArwqDCoMKgwqDCoMKgwqB1MTYgaGVpZ2h0Owo+ID4gK30gX19wYWNrZWQ7 Cj4gPiArCj4gPiArc3RydWN0IHN5bnRodmlkX21zZ19oZHIgewo+ID4gK8KgwqDCoMKgwqDCoMKg dTMyIHR5cGU7Cj4gPiArwqDCoMKgwqDCoMKgwqB1MzIgc2l6ZTvCoCAvKiBzaXplIG9mIHRoaXMg aGVhZGVyICsgcGF5bG9hZCBhZnRlciB0aGlzCj4gPiBmaWVsZCAqLwo+ID4gK30gX19wYWNrZWQ7 Cj4gPiArCj4gPiArc3RydWN0IHN5bnRodmlkX3ZlcnNpb25fcmVxIHsKPiA+ICvCoMKgwqDCoMKg wqDCoHUzMiB2ZXJzaW9uOwo+ID4gK30gX19wYWNrZWQ7Cj4gPiArCj4gPiArc3RydWN0IHN5bnRo dmlkX3ZlcnNpb25fcmVzcCB7Cj4gPiArwqDCoMKgwqDCoMKgwqB1MzIgdmVyc2lvbjsKPiA+ICvC oMKgwqDCoMKgwqDCoHU4IGlzX2FjY2VwdGVkOwo+ID4gK8KgwqDCoMKgwqDCoMKgdTggbWF4X3Zp ZGVvX291dHB1dHM7Cj4gPiArfSBfX3BhY2tlZDsKPiA+ICsKPiA+ICtzdHJ1Y3Qgc3ludGh2aWRf dnJhbV9sb2NhdGlvbiB7Cj4gPiArwqDCoMKgwqDCoMKgwqB1NjQgdXNlcl9jdHg7Cj4gPiArwqDC oMKgwqDCoMKgwqB1OCBpc192cmFtX2dwYV9zcGVjaWZpZWQ7Cj4gPiArwqDCoMKgwqDCoMKgwqB1 NjQgdnJhbV9ncGE7Cj4gPiArfSBfX3BhY2tlZDsKPiA+ICsKPiA+ICtzdHJ1Y3Qgc3ludGh2aWRf dnJhbV9sb2NhdGlvbl9hY2sgewo+ID4gK8KgwqDCoMKgwqDCoMKgdTY0IHVzZXJfY3R4Owo+ID4g K30gX19wYWNrZWQ7Cj4gPiArCj4gPiArc3RydWN0IHZpZGVvX291dHB1dF9zaXR1YXRpb24gewo+ ID4gK8KgwqDCoMKgwqDCoMKgdTggYWN0aXZlOwo+ID4gK8KgwqDCoMKgwqDCoMKgdTMyIHZyYW1f b2Zmc2V0Owo+ID4gK8KgwqDCoMKgwqDCoMKgdTggZGVwdGhfYml0czsKPiA+ICvCoMKgwqDCoMKg wqDCoHUzMiB3aWR0aF9waXhlbHM7Cj4gPiArwqDCoMKgwqDCoMKgwqB1MzIgaGVpZ2h0X3BpeGVs czsKPiA+ICvCoMKgwqDCoMKgwqDCoHUzMiBwaXRjaF9ieXRlczsKPiA+ICt9IF9fcGFja2VkOwo+ ID4gKwo+ID4gK3N0cnVjdCBzeW50aHZpZF9zaXR1YXRpb25fdXBkYXRlIHsKPiA+ICvCoMKgwqDC oMKgwqDCoHU2NCB1c2VyX2N0eDsKPiA+ICvCoMKgwqDCoMKgwqDCoHU4IHZpZGVvX291dHB1dF9j b3VudDsKPiA+ICvCoMKgwqDCoMKgwqDCoHN0cnVjdCB2aWRlb19vdXRwdXRfc2l0dWF0aW9uIHZp ZGVvX291dHB1dFsxXTsKPiA+ICt9IF9fcGFja2VkOwo+ID4gKwo+ID4gK3N0cnVjdCBzeW50aHZp ZF9zaXR1YXRpb25fdXBkYXRlX2FjayB7Cj4gPiArwqDCoMKgwqDCoMKgwqB1NjQgdXNlcl9jdHg7 Cj4gPiArfSBfX3BhY2tlZDsKPiA+ICsKPiA+ICtzdHJ1Y3Qgc3ludGh2aWRfcG9pbnRlcl9wb3Np dGlvbiB7Cj4gPiArwqDCoMKgwqDCoMKgwqB1OCBpc192aXNpYmxlOwo+ID4gK8KgwqDCoMKgwqDC oMKgdTggdmlkZW9fb3V0cHV0Owo+ID4gK8KgwqDCoMKgwqDCoMKgczMyIGltYWdlX3g7Cj4gPiAr wqDCoMKgwqDCoMKgwqBzMzIgaW1hZ2VfeTsKPiA+ICt9IF9fcGFja2VkOwo+ID4gKwo+ID4gKyNk ZWZpbmUgU1lOVEhWSURfQ1VSU09SX01BWF9YIDk2Cj4gPiArI2RlZmluZSBTWU5USFZJRF9DVVJT T1JfTUFYX1kgOTYKPiA+ICsjZGVmaW5lIFNZTlRIVklEX0NVUlNPUl9BUkdCX1BJWEVMX1NJWkUg NAo+ID4gKyNkZWZpbmUgU1lOVEhWSURfQ1VSU09SX01BWF9TSVpFIChTWU5USFZJRF9DVVJTT1Jf TUFYX1ggKiBcCj4gPiArwqDCoMKgwqDCoMKgwqBTWU5USFZJRF9DVVJTT1JfTUFYX1kgKiBTWU5U SFZJRF9DVVJTT1JfQVJHQl9QSVhFTF9TSVpFKQo+ID4gKyNkZWZpbmUgU1lOVEhWSURfQ1VSU09S X0NPTVBMRVRFICgtMSkKPiA+ICsKPiA+ICtzdHJ1Y3Qgc3ludGh2aWRfcG9pbnRlcl9zaGFwZSB7 Cj4gPiArwqDCoMKgwqDCoMKgwqB1OCBwYXJ0X2lkeDsKPiA+ICvCoMKgwqDCoMKgwqDCoHU4IGlz X2FyZ2I7Cj4gPiArwqDCoMKgwqDCoMKgwqB1MzIgd2lkdGg7IC8qIFNZTlRIVklEX0NVUlNPUl9N QVhfWCBhdCBtb3N0ICovCj4gPiArwqDCoMKgwqDCoMKgwqB1MzIgaGVpZ2h0OyAvKiBTWU5USFZJ RF9DVVJTT1JfTUFYX1kgYXQgbW9zdCAqLwo+ID4gK8KgwqDCoMKgwqDCoMKgdTMyIGhvdF94OyAv KiBob3RzcG90IHJlbGF0aXZlIHRvIHVwcGVyLWxlZnQgb2YgcG9pbnRlcgo+ID4gaW1hZ2UgKi8K PiA+ICvCoMKgwqDCoMKgwqDCoHUzMiBob3RfeTsKPiA+ICvCoMKgwqDCoMKgwqDCoHU4IGRhdGFb NF07Cj4gPiArfSBfX3BhY2tlZDsKPiA+ICsKPiA+ICtzdHJ1Y3Qgc3ludGh2aWRfZmVhdHVyZV9j aGFuZ2Ugewo+ID4gK8KgwqDCoMKgwqDCoMKgdTggaXNfZGlydF9uZWVkZWQ7Cj4gPiArwqDCoMKg wqDCoMKgwqB1OCBpc19wdHJfcG9zX25lZWRlZDsKPiA+ICvCoMKgwqDCoMKgwqDCoHU4IGlzX3B0 cl9zaGFwZV9uZWVkZWQ7Cj4gPiArwqDCoMKgwqDCoMKgwqB1OCBpc19zaXR1X25lZWRlZDsKPiA+ ICt9IF9fcGFja2VkOwo+ID4gKwo+ID4gK3N0cnVjdCByZWN0IHsKPiA+ICvCoMKgwqDCoMKgwqDC oHMzMiB4MSwgeTE7IC8qIHRvcCBsZWZ0IGNvcm5lciAqLwo+ID4gK8KgwqDCoMKgwqDCoMKgczMy IHgyLCB5MjsgLyogYm90dG9tIHJpZ2h0IGNvcm5lciwgZXhjbHVzaXZlICovCj4gPiArfSBfX3Bh Y2tlZDsKPiA+ICsKPiA+ICtzdHJ1Y3Qgc3ludGh2aWRfZGlydCB7Cj4gPiArwqDCoMKgwqDCoMKg wqB1OCB2aWRlb19vdXRwdXQ7Cj4gPiArwqDCoMKgwqDCoMKgwqB1OCBkaXJ0X2NvdW50Owo+ID4g K8KgwqDCoMKgwqDCoMKgc3RydWN0IHJlY3QgcmVjdFsxXTsKPiA+ICt9IF9fcGFja2VkOwo+ID4g Kwo+ID4gKyNkZWZpbmUgU1lOVEhWSURfRURJRF9CTE9DS19TSVpFwqDCoMKgwqDCoMKgwqAxMjgK PiA+ICsjZGVmaW5lwqDCoMKgwqDCoMKgwqDCoFNZTlRIVklEX01BWF9SRVNPTFVUSU9OX0NPVU5U wqDCoMKgNjQKPiA+ICsKPiA+ICtzdHJ1Y3Qgc3ludGh2aWRfc3VwcG9ydGVkX3Jlc29sdXRpb25f cmVxIHsKPiA+ICvCoMKgwqDCoMKgwqDCoHU4IG1heGltdW1fcmVzb2x1dGlvbl9jb3VudDsKPiA+ ICt9IF9fcGFja2VkOwo+ID4gKwo+ID4gK3N0cnVjdCBzeW50aHZpZF9zdXBwb3J0ZWRfcmVzb2x1 dGlvbl9yZXNwIHsKPiA+ICvCoMKgwqDCoMKgwqDCoHU4IGVkaWRfYmxvY2tbU1lOVEhWSURfRURJ RF9CTE9DS19TSVpFXTsKPiA+ICvCoMKgwqDCoMKgwqDCoHU4IHJlc29sdXRpb25fY291bnQ7Cj4g PiArwqDCoMKgwqDCoMKgwqB1OCBkZWZhdWx0X3Jlc29sdXRpb25faW5kZXg7Cj4gPiArwqDCoMKg wqDCoMKgwqB1OCBpc19zdGFuZGFyZDsKPiA+ICvCoMKgwqDCoMKgwqDCoHN0cnVjdCBodmRfc2Ny ZWVuX2luZm8KPiA+IHN1cHBvcnRlZF9yZXNvbHV0aW9uW1NZTlRIVklEX01BWF9SRVNPTFVUSU9O X0NPVU5UXTsKPiA+ICt9IF9fcGFja2VkOwo+ID4gKwo+ID4gK3N0cnVjdCBzeW50aHZpZF9tc2cg ewo+ID4gK8KgwqDCoMKgwqDCoMKgc3RydWN0IHBpcGVfbXNnX2hkciBwaXBlX2hkcjsKPiA+ICvC oMKgwqDCoMKgwqDCoHN0cnVjdCBzeW50aHZpZF9tc2dfaGRyIHZpZF9oZHI7Cj4gPiArwqDCoMKg wqDCoMKgwqB1bmlvbiB7Cj4gPiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgc3RydWN0 IHN5bnRodmlkX3ZlcnNpb25fcmVxIHZlcl9yZXE7Cj4gPiArwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgc3RydWN0IHN5bnRodmlkX3ZlcnNpb25fcmVzcCB2ZXJfcmVzcDsKPiA+ICvCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqBzdHJ1Y3Qgc3ludGh2aWRfdnJhbV9sb2NhdGlvbiB2 cmFtOwo+ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoHN0cnVjdCBzeW50aHZpZF92 cmFtX2xvY2F0aW9uX2FjayB2cmFtX2FjazsKPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqBzdHJ1Y3Qgc3ludGh2aWRfc2l0dWF0aW9uX3VwZGF0ZSBzaXR1Owo+ID4gK8KgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoHN0cnVjdCBzeW50aHZpZF9zaXR1YXRpb25fdXBkYXRlX2Fj ayBzaXR1X2FjazsKPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqBzdHJ1Y3Qgc3lu dGh2aWRfcG9pbnRlcl9wb3NpdGlvbiBwdHJfcG9zOwo+ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoHN0cnVjdCBzeW50aHZpZF9wb2ludGVyX3NoYXBlIHB0cl9zaGFwZTsKPiA+ICvC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqBzdHJ1Y3Qgc3ludGh2aWRfZmVhdHVyZV9jaGFu Z2UgZmVhdHVyZV9jaGc7Cj4gPiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgc3RydWN0 IHN5bnRodmlkX2RpcnQgZGlydDsKPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqBz dHJ1Y3Qgc3ludGh2aWRfc3VwcG9ydGVkX3Jlc29sdXRpb25fcmVxCj4gPiByZXNvbHV0aW9uX3Jl cTsKPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqBzdHJ1Y3Qgc3ludGh2aWRfc3Vw cG9ydGVkX3Jlc29sdXRpb25fcmVzcAo+ID4gcmVzb2x1dGlvbl9yZXNwOwo+ID4gK8KgwqDCoMKg wqDCoMKgfTsKPiA+ICt9IF9fcGFja2VkOwo+ID4gKwo+ID4gK3N0YXRpYyBpbmxpbmUgYm9vbCBo eXBlcnZfdmVyc2lvbl9nZSh1MzIgdmVyMSwgdTMyIHZlcjIpCj4gPiArewo+ID4gK8KgwqDCoMKg wqDCoMKgaWYgKFNZTlRIVklEX1ZFUl9HRVRfTUFKT1IodmVyMSkgPgo+ID4gU1lOVEhWSURfVkVS X0dFVF9NQUpPUih2ZXIyKSB8fAo+ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgIChTWU5USFZJRF9W RVJfR0VUX01BSk9SKHZlcjEpID09Cj4gPiBTWU5USFZJRF9WRVJfR0VUX01BSk9SKHZlcjIpICYm Cj4gPiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBTWU5USFZJRF9WRVJfR0VUX01JTk9SKHZlcjEp ID49Cj4gPiBTWU5USFZJRF9WRVJfR0VUX01JTk9SKHZlcjIpKSkKPiA+ICvCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqByZXR1cm4gdHJ1ZTsKPiA+ICsKPiA+ICvCoMKgwqDCoMKgwqDCoHJl dHVybiBmYWxzZTsKPiA+ICt9Cj4gPiArCj4gPiArc3RhdGljIGlubGluZSBpbnQgaHlwZXJ2X3Nl bmRwYWNrZXQoc3RydWN0IGh2X2RldmljZSAqaGRldiwgc3RydWN0Cj4gPiBzeW50aHZpZF9tc2cg Km1zZykKPiA+ICt7Cj4gPiArwqDCoMKgwqDCoMKgwqBzdGF0aWMgYXRvbWljNjRfdCByZXF1ZXN0 X2lkID0gQVRPTUlDNjRfSU5JVCgwKTsKPiA+ICvCoMKgwqDCoMKgwqDCoHN0cnVjdCBoeXBlcnZf ZHJtX2RldmljZSAqaHYgPSBodl9nZXRfZHJ2ZGF0YShoZGV2KTsKPiA+ICvCoMKgwqDCoMKgwqDC oGludCByZXQ7Cj4gPiArCj4gPiArwqDCoMKgwqDCoMKgwqBtc2ctPnBpcGVfaGRyLnR5cGUgPSBQ SVBFX01TR19EQVRBOwo+ID4gK8KgwqDCoMKgwqDCoMKgbXNnLT5waXBlX2hkci5zaXplID0gbXNn LT52aWRfaGRyLnNpemU7Cj4gPiArCj4gPiArwqDCoMKgwqDCoMKgwqByZXQgPSB2bWJ1c19zZW5k cGFja2V0KGhkZXYtPmNoYW5uZWwsIG1zZywKPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIG1zZy0+dmlkX2hkci5zaXplICsgc2l6 ZW9mKHN0cnVjdAo+ID4gcGlwZV9tc2dfaGRyKSwKPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGF0b21pYzY0X2luY19yZXR1cm4o JnJlcXVlc3RfaWQpLAo+ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqAgVk1fUEtUX0RBVEFfSU5CQU5ELCAwKTsKPiA+ICsKPiA+ICvC oMKgwqDCoMKgwqDCoGlmIChyZXQpCj4gPiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg ZHJtX2VycigmaHYtPmRldiwgIlVuYWJsZSB0byBzZW5kIHBhY2tldCB2aWEKPiA+IHZtYnVzXG4i KTsKPiA+ICsKPiA+ICvCoMKgwqDCoMKgwqDCoHJldHVybiByZXQ7Cj4gPiArfQo+ID4gKwo+ID4g K3N0YXRpYyBpbnQgaHlwZXJ2X25lZ290aWF0ZV92ZXJzaW9uKHN0cnVjdCBodl9kZXZpY2UgKmhk ZXYsIHUzMgo+ID4gdmVyKQo+ID4gK3sKPiA+ICvCoMKgwqDCoMKgwqDCoHN0cnVjdCBoeXBlcnZf ZHJtX2RldmljZSAqaHYgPSBodl9nZXRfZHJ2ZGF0YShoZGV2KTsKPiA+ICvCoMKgwqDCoMKgwqDC oHN0cnVjdCBzeW50aHZpZF9tc2cgKm1zZyA9IChzdHJ1Y3Qgc3ludGh2aWRfbXNnICopaHYtCj4g PiA+aW5pdF9idWY7Cj4gPiArwqDCoMKgwqDCoMKgwqBzdHJ1Y3QgZHJtX2RldmljZSAqZGV2ID0g Jmh2LT5kZXY7Cj4gPiArwqDCoMKgwqDCoMKgwqB1bnNpZ25lZCBsb25nIHQ7Cj4gPiArwqDCoMKg wqDCoMKgwqBpbnQgcmV0ID0gMDsKPiA+ICsKPiA+ICvCoMKgwqDCoMKgwqDCoG1lbXNldChtc2cs IDAsIHNpemVvZihzdHJ1Y3Qgc3ludGh2aWRfbXNnKSk7Cj4gPiArwqDCoMKgwqDCoMKgwqBtc2ct PnZpZF9oZHIudHlwZSA9IFNZTlRIVklEX1ZFUlNJT05fUkVRVUVTVDsKPiA+ICvCoMKgwqDCoMKg wqDCoG1zZy0+dmlkX2hkci5zaXplID0gc2l6ZW9mKHN0cnVjdCBzeW50aHZpZF9tc2dfaGRyKSAr Cj4gPiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgc2l6ZW9mKHN0cnVjdCBzeW50aHZp ZF92ZXJzaW9uX3JlcSk7Cj4gPiArwqDCoMKgwqDCoMKgwqBtc2ctPnZlcl9yZXEudmVyc2lvbiA9 IHZlcjsKPiA+ICvCoMKgwqDCoMKgwqDCoGh5cGVydl9zZW5kcGFja2V0KGhkZXYsIG1zZyk7Cj4g PiArCj4gPiArwqDCoMKgwqDCoMKgwqB0ID0gd2FpdF9mb3JfY29tcGxldGlvbl90aW1lb3V0KCZo di0+d2FpdCwKPiA+IFZNQlVTX1ZTUF9USU1FT1VUKTsKPiA+ICvCoMKgwqDCoMKgwqDCoGlmICgh dCkgewo+ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoGRybV9lcnIoZGV2LCAiVGlt ZSBvdXQgb24gd2FpdGluZyB2ZXJzaW9uCj4gPiByZXNwb25zZVxuIik7Cj4gPiArwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgcmV0ID0gLUVUSU1FRE9VVDsKPiA+ICvCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqBnb3RvIG91dDsKPiA+ICvCoMKgwqDCoMKgwqDCoH0KPiA+ICvCoMKg wqDCoMKgwqDCoGlmICghbXNnLT52ZXJfcmVzcC5pc19hY2NlcHRlZCkgewo+ID4gK8KgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoHJldCA9IC1FTk9ERVY7Cj4gPiArwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgZ290byBvdXQ7Cj4gCj4gQm90aCAnb3V0JyBsYWJlbCBhbmQgJ3JldCcg dmFyaWFibGUgY291bGQgYmUgZHJvcHBlZCBoZXJlLCBqdXN0IGRvCj4gJ3JldHVybiAtRVRJTUVE T1VULy1FTk9ERVYnIGRpcmVjdGx5IGFuZCAncmV0dXJuIDAnIGF0IHRoZSBlbmQuCj4gCj4gPiAr wqDCoMKgwqDCoMKgwqB9Cj4gPiArCj4gPiArwqDCoMKgwqDCoMKgwqBodi0+c3ludGh2aWRfdmVy c2lvbiA9IHZlcjsKPiA+ICvCoMKgwqDCoMKgwqDCoGRybV9pbmZvKGRldiwgIlN5bnRodmlkIFZl cnNpb24gbWFqb3IgJWQsIG1pbm9yICVkXG4iLAo+ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoCBTWU5USFZJRF9WRVJfR0VUX01BSk9SKHZlciksCj4gPiBTWU5USFZJRF9WRVJfR0VU X01JTk9SKHZlcikpOwo+ID4gKwo+ID4gK291dDoKPiA+ICvCoMKgwqDCoMKgwqDCoHJldHVybiBy ZXQ7Cj4gPiArfQo+ID4gKwo+ID4gK2ludCBoeXBlcnZfdXBkYXRlX3ZyYW1fbG9jYXRpb24oc3Ry dWN0IGh2X2RldmljZSAqaGRldiwKPiA+IHBoeXNfYWRkcl90IHZyYW1fcHApCj4gPiArewo+ID4g K8KgwqDCoMKgwqDCoMKgc3RydWN0IGh5cGVydl9kcm1fZGV2aWNlICpodiA9IGh2X2dldF9kcnZk YXRhKGhkZXYpOwo+ID4gK8KgwqDCoMKgwqDCoMKgc3RydWN0IHN5bnRodmlkX21zZyAqbXNnID0g KHN0cnVjdCBzeW50aHZpZF9tc2cgKilodi0KPiA+ID5pbml0X2J1ZjsKPiA+ICvCoMKgwqDCoMKg wqDCoHN0cnVjdCBkcm1fZGV2aWNlICpkZXYgPSAmaHYtPmRldjsKPiA+ICvCoMKgwqDCoMKgwqDC oHVuc2lnbmVkIGxvbmcgdDsKPiA+ICvCoMKgwqDCoMKgwqDCoGludCByZXQgPSAwOwo+ID4gKwo+ ID4gK8KgwqDCoMKgwqDCoMKgbWVtc2V0KG1zZywgMCwgc2l6ZW9mKHN0cnVjdCBzeW50aHZpZF9t c2cpKTsKPiA+ICvCoMKgwqDCoMKgwqDCoG1zZy0+dmlkX2hkci50eXBlID0gU1lOVEhWSURfVlJB TV9MT0NBVElPTjsKPiA+ICvCoMKgwqDCoMKgwqDCoG1zZy0+dmlkX2hkci5zaXplID0gc2l6ZW9m KHN0cnVjdCBzeW50aHZpZF9tc2dfaGRyKSArCj4gPiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgc2l6ZW9mKHN0cnVjdCBzeW50aHZpZF92cmFtX2xvY2F0aW9uKTsKPiA+ICvCoMKgwqDC oMKgwqDCoG1zZy0+dnJhbS51c2VyX2N0eCA9IHZyYW1fcHA7Cj4gPiArwqDCoMKgwqDCoMKgwqBt c2ctPnZyYW0udnJhbV9ncGEgPSB2cmFtX3BwOwo+ID4gK8KgwqDCoMKgwqDCoMKgbXNnLT52cmFt LmlzX3ZyYW1fZ3BhX3NwZWNpZmllZCA9IDE7Cj4gPiArwqDCoMKgwqDCoMKgwqBoeXBlcnZfc2Vu ZHBhY2tldChoZGV2LCBtc2cpOwo+ID4gKwo+ID4gK8KgwqDCoMKgwqDCoMKgdCA9IHdhaXRfZm9y X2NvbXBsZXRpb25fdGltZW91dCgmaHYtPndhaXQsCj4gPiBWTUJVU19WU1BfVElNRU9VVCk7Cj4g PiArwqDCoMKgwqDCoMKgwqBpZiAoIXQpIHsKPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqBkcm1fZXJyKGRldiwgIlRpbWUgb3V0IG9uIHdhaXRpbmcgdnJhbSBsb2NhdGlvbgo+ID4g YWNrXG4iKTsKPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqByZXQgPSAtRVRJTUVE T1VUOwo+ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoGdvdG8gb3V0Owo+ID4gK8Kg wqDCoMKgwqDCoMKgfQo+ID4gK8KgwqDCoMKgwqDCoMKgaWYgKG1zZy0+dnJhbV9hY2sudXNlcl9j dHggIT0gdnJhbV9wcCkgewo+ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoGRybV9l cnIoZGV2LCAiVW5hYmxlIHRvIHNldCBWUkFNIGxvY2F0aW9uXG4iKTsKPiA+ICvCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqByZXQgPSAtRU5PREVWOwo+ID4gK8KgwqDCoMKgwqDCoMKgfQo+ ID4gKwo+ID4gK291dDoKPiA+ICvCoMKgwqDCoMKgwqDCoHJldHVybiByZXQ7Cj4gCj4gc2FtZSBo ZXJlOiAnb3V0JyBhbmQgJ3JldCcgY291bGQgYmUgZHJvcHBlZC4KPiAKPiA+ICt9Cj4gPiArCj4g PiAraW50IGh5cGVydl91cGRhdGVfc2l0dWF0aW9uKHN0cnVjdCBodl9kZXZpY2UgKmhkZXYsIHU4 IGFjdGl2ZSwgdTMyCj4gPiBicHAsCj4gPiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB1MzIgdywgdTMyIGgsIHUzMiBwaXRjaCkKPiA+ICt7Cj4g PiArwqDCoMKgwqDCoMKgwqBzdHJ1Y3Qgc3ludGh2aWRfbXNnIG1zZzsKPiA+ICsKPiA+ICvCoMKg wqDCoMKgwqDCoG1lbXNldCgmbXNnLCAwLCBzaXplb2Yoc3RydWN0IHN5bnRodmlkX21zZykpOwo+ ID4gKwo+ID4gK8KgwqDCoMKgwqDCoMKgbXNnLnZpZF9oZHIudHlwZSA9IFNZTlRIVklEX1NJVFVB VElPTl9VUERBVEU7Cj4gPiArwqDCoMKgwqDCoMKgwqBtc2cudmlkX2hkci5zaXplID0gc2l6ZW9m KHN0cnVjdCBzeW50aHZpZF9tc2dfaGRyKSArCj4gPiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgc2l6ZW9mKHN0cnVjdCBzeW50aHZpZF9zaXR1YXRpb25fdXBkYXRlKTsKPiA+ICvCoMKg wqDCoMKgwqDCoG1zZy5zaXR1LnVzZXJfY3R4ID0gMDsKPiA+ICvCoMKgwqDCoMKgwqDCoG1zZy5z aXR1LnZpZGVvX291dHB1dF9jb3VudCA9IDE7Cj4gPiArwqDCoMKgwqDCoMKgwqBtc2cuc2l0dS52 aWRlb19vdXRwdXRbMF0uYWN0aXZlID0gYWN0aXZlOwo+ID4gK8KgwqDCoMKgwqDCoMKgLyogdnJh bV9vZmZzZXQgc2hvdWxkIGFsd2F5cyBiZSAwICovCj4gPiArwqDCoMKgwqDCoMKgwqBtc2cuc2l0 dS52aWRlb19vdXRwdXRbMF0udnJhbV9vZmZzZXQgPSAwOwo+ID4gK8KgwqDCoMKgwqDCoMKgbXNn LnNpdHUudmlkZW9fb3V0cHV0WzBdLmRlcHRoX2JpdHMgPSBicHA7Cj4gPiArwqDCoMKgwqDCoMKg wqBtc2cuc2l0dS52aWRlb19vdXRwdXRbMF0ud2lkdGhfcGl4ZWxzID0gdzsKPiA+ICvCoMKgwqDC oMKgwqDCoG1zZy5zaXR1LnZpZGVvX291dHB1dFswXS5oZWlnaHRfcGl4ZWxzID0gaDsKPiA+ICvC oMKgwqDCoMKgwqDCoG1zZy5zaXR1LnZpZGVvX291dHB1dFswXS5waXRjaF9ieXRlcyA9IHBpdGNo Owo+ID4gKwo+ID4gK8KgwqDCoMKgwqDCoMKgaHlwZXJ2X3NlbmRwYWNrZXQoaGRldiwgJm1zZyk7 Cj4gPiArCj4gPiArwqDCoMKgwqDCoMKgwqByZXR1cm4gMDsKPiA+ICt9Cj4gPiArCj4gPiAraW50 IGh5cGVydl91cGRhdGVfZGlydChzdHJ1Y3QgaHZfZGV2aWNlICpoZGV2LCBzdHJ1Y3QgZHJtX3Jl Y3QKPiA+ICpyZWN0KQo+ID4gK3sKPiA+ICvCoMKgwqDCoMKgwqDCoHN0cnVjdCBzeW50aHZpZF9t c2cgbXNnOwo+ID4gKwo+ID4gK8KgwqDCoMKgwqDCoMKgbWVtc2V0KCZtc2csIDAsIHNpemVvZihz dHJ1Y3Qgc3ludGh2aWRfbXNnKSk7Cj4gPiArCj4gPiArwqDCoMKgwqDCoMKgwqBtc2cudmlkX2hk ci50eXBlID0gU1lOVEhWSURfRElSVDsKPiA+ICvCoMKgwqDCoMKgwqDCoG1zZy52aWRfaGRyLnNp emUgPSBzaXplb2Yoc3RydWN0IHN5bnRodmlkX21zZ19oZHIpICsKPiA+ICvCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqBzaXplb2Yoc3RydWN0IHN5bnRodmlkX2RpcnQpOwo+ID4gK8KgwqDC oMKgwqDCoMKgbXNnLmRpcnQudmlkZW9fb3V0cHV0ID0gMDsKPiA+ICvCoMKgwqDCoMKgwqDCoG1z Zy5kaXJ0LmRpcnRfY291bnQgPSAxOwo+ID4gK8KgwqDCoMKgwqDCoMKgbXNnLmRpcnQucmVjdFsw XS54MSA9IHJlY3QtPngxOwo+ID4gK8KgwqDCoMKgwqDCoMKgbXNnLmRpcnQucmVjdFswXS55MSA9 IHJlY3QtPnkxOwo+ID4gK8KgwqDCoMKgwqDCoMKgbXNnLmRpcnQucmVjdFswXS54MiA9IHJlY3Qt PngyOwo+ID4gK8KgwqDCoMKgwqDCoMKgbXNnLmRpcnQucmVjdFswXS55MiA9IHJlY3QtPnkyOwo+ ID4gKwo+ID4gK8KgwqDCoMKgwqDCoMKgaHlwZXJ2X3NlbmRwYWNrZXQoaGRldiwgJm1zZyk7Cj4g PiArCj4gPiArwqDCoMKgwqDCoMKgwqByZXR1cm4gMDsKPiA+ICt9Cj4gPiArCj4gPiArc3RhdGlj IGludCBoeXBlcnZfZ2V0X3N1cHBvcnRlZF9yZXNvbHV0aW9uKHN0cnVjdCBodl9kZXZpY2UgKmhk ZXYpCj4gPiArewo+ID4gK8KgwqDCoMKgwqDCoMKgc3RydWN0IGh5cGVydl9kcm1fZGV2aWNlICpo diA9IGh2X2dldF9kcnZkYXRhKGhkZXYpOwo+ID4gK8KgwqDCoMKgwqDCoMKgc3RydWN0IHN5bnRo dmlkX21zZyAqbXNnID0gKHN0cnVjdCBzeW50aHZpZF9tc2cgKilodi0KPiA+ID5pbml0X2J1ZjsK PiA+ICvCoMKgwqDCoMKgwqDCoHN0cnVjdCBkcm1fZGV2aWNlICpkZXYgPSAmaHYtPmRldjsKPiA+ ICvCoMKgwqDCoMKgwqDCoHVuc2lnbmVkIGxvbmcgdDsKPiA+ICvCoMKgwqDCoMKgwqDCoGludCBy ZXQgPSAwOwo+ID4gK8KgwqDCoMKgwqDCoMKgdTggaW5kZXg7Cj4gPiArwqDCoMKgwqDCoMKgwqBp bnQgaTsKPiA+ICsKPiA+ICvCoMKgwqDCoMKgwqDCoG1lbXNldChtc2csIDAsIHNpemVvZihzdHJ1 Y3Qgc3ludGh2aWRfbXNnKSk7Cj4gPiArwqDCoMKgwqDCoMKgwqBtc2ctPnZpZF9oZHIudHlwZSA9 IFNZTlRIVklEX1JFU09MVVRJT05fUkVRVUVTVDsKPiA+ICvCoMKgwqDCoMKgwqDCoG1zZy0+dmlk X2hkci5zaXplID0gc2l6ZW9mKHN0cnVjdCBzeW50aHZpZF9tc2dfaGRyKSArCj4gPiArwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgc2l6ZW9mKHN0cnVjdCBzeW50aHZpZF9zdXBwb3J0ZWRf cmVzb2x1dGlvbl9yZXEpOwo+ID4gK8KgwqDCoMKgwqDCoMKgbXNnLT5yZXNvbHV0aW9uX3JlcS5t YXhpbXVtX3Jlc29sdXRpb25fY291bnQgPQo+ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoFNZTlRIVklEX01BWF9SRVNPTFVUSU9OX0NPVU5UOwo+ID4gK8KgwqDCoMKgwqDCoMKgaHlw ZXJ2X3NlbmRwYWNrZXQoaGRldiwgbXNnKTsKPiA+ICsKPiA+ICvCoMKgwqDCoMKgwqDCoHQgPSB3 YWl0X2Zvcl9jb21wbGV0aW9uX3RpbWVvdXQoJmh2LT53YWl0LAo+ID4gVk1CVVNfVlNQX1RJTUVP VVQpOwo+ID4gK8KgwqDCoMKgwqDCoMKgaWYgKCF0KSB7Cj4gPiArwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgZHJtX2VycihkZXYsICJUaW1lIG91dCBvbiB3YWl0aW5nIHJlc29sdXRpb24K PiA+IHJlc3BvbnNlXG4iKTsKPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqByZXQg PSAtRVRJTUVET1VUOwo+ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoGdvdG8gb3V0 Owo+ID4gK8KgwqDCoMKgwqDCoMKgfQo+ID4gKwo+ID4gK8KgwqDCoMKgwqDCoMKgaWYgKG1zZy0+ cmVzb2x1dGlvbl9yZXNwLnJlc29sdXRpb25fY291bnQgPT0gMCkgewo+ID4gK8KgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoGRybV9lcnIoZGV2LCAiTm8gc3VwcG9ydGVkIHJlc29sdXRpb25z XG4iKTsKPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqByZXQgPSAtRU5PREVWOwo+ ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoGdvdG8gb3V0Owo+ID4gK8KgwqDCoMKg wqDCoMKgfQo+ID4gKwo+ID4gK8KgwqDCoMKgwqDCoMKgaW5kZXggPSBtc2ctPnJlc29sdXRpb25f cmVzcC5kZWZhdWx0X3Jlc29sdXRpb25faW5kZXg7Cj4gPiArwqDCoMKgwqDCoMKgwqBpZiAoaW5k ZXggPj0gbXNnLT5yZXNvbHV0aW9uX3Jlc3AucmVzb2x1dGlvbl9jb3VudCkgewo+ID4gK8KgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoGRybV9lcnIoZGV2LCAiSW52YWxpZCByZXNvbHV0aW9u IGluZGV4OiAlZFxuIiwKPiA+IGluZGV4KTsKPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqByZXQgPSAtRU5PREVWOwo+ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoGdv dG8gb3V0Owo+ID4gK8KgwqDCoMKgwqDCoMKgfQo+ID4gKwo+ID4gK8KgwqDCoMKgwqDCoMKgZm9y IChpID0gMDsgaSA8IG1zZy0+cmVzb2x1dGlvbl9yZXNwLnJlc29sdXRpb25fY291bnQ7IGkrKykK PiA+IHsKPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqBodi0+c2NyZWVuX3dpZHRo X21heCA9IG1heF90KHUzMiwgaHYtCj4gPiA+c2NyZWVuX3dpZHRoX21heCwKPiA+ICvCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgbXNnLQo+ID4gPnJlc29sdXRp b25fcmVzcC5zdXBwb3J0ZWRfcmVzb2x1dGlvbltpXS53aWR0aCk7Cj4gPiArwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgaHYtPnNjcmVlbl9oZWlnaHRfbWF4ID0gbWF4X3QodTMyLCBodi0K PiA+ID5zY3JlZW5faGVpZ2h0X21heCwKPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgbXNnLQo+ID4gPnJlc29sdXRpb25fcmVzcC5zdXBwb3J0ZWRfcmVz b2x1dGlvbltpXS5oZWlnaHQpOwo+ID4gK8KgwqDCoMKgwqDCoMKgfQo+ID4gKwo+ID4gK8KgwqDC oMKgwqDCoMKgaHYtPnByZWZlcnJlZF93aWR0aCA9Cj4gPiArwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgbXNnLQo+ID4gPnJlc29sdXRpb25fcmVzcC5zdXBwb3J0ZWRfcmVzb2x1dGlvbltp bmRleF0ud2lkdGg7Cj4gPiArwqDCoMKgwqDCoMKgwqBodi0+cHJlZmVycmVkX2hlaWdodCA9Cj4g PiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgbXNnLQo+ID4gPnJlc29sdXRpb25fcmVz cC5zdXBwb3J0ZWRfcmVzb2x1dGlvbltpbmRleF0uaGVpZ2h0Owo+ID4gKwo+ID4gK291dDoKPiA+ ICvCoMKgwqDCoMKgwqDCoHJldHVybiByZXQ7Cj4gCj4gQW5kIGhlcmUuCj4gCj4gPiArfQo+ID4g Kwo+ID4gK3N0YXRpYyB2b2lkIGh5cGVydl9yZWNlaXZlX3N1YihzdHJ1Y3QgaHZfZGV2aWNlICpo ZGV2KQo+ID4gK3sKPiA+ICvCoMKgwqDCoMKgwqDCoHN0cnVjdCBoeXBlcnZfZHJtX2RldmljZSAq aHYgPSBodl9nZXRfZHJ2ZGF0YShoZGV2KTsKPiA+ICvCoMKgwqDCoMKgwqDCoHN0cnVjdCBzeW50 aHZpZF9tc2cgKm1zZzsKPiA+ICsKPiA+ICvCoMKgwqDCoMKgwqDCoGlmICghaHYpCj4gPiArwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgcmV0dXJuOwo+ID4gKwo+ID4gK8KgwqDCoMKgwqDC oMKgbXNnID0gKHN0cnVjdCBzeW50aHZpZF9tc2cgKilodi0+cmVjdl9idWY7Cj4gPiArCj4gPiAr wqDCoMKgwqDCoMKgwqAvKiBDb21wbGV0ZSB0aGUgd2FpdCBldmVudCAqLwo+ID4gK8KgwqDCoMKg wqDCoMKgaWYgKG1zZy0+dmlkX2hkci50eXBlID09IFNZTlRIVklEX1ZFUlNJT05fUkVTUE9OU0Ug fHwKPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoCBtc2ctPnZpZF9oZHIudHlwZSA9PSBTWU5USFZJ RF9SRVNPTFVUSU9OX1JFU1BPTlNFIHx8Cj4gPiArwqDCoMKgwqDCoMKgwqDCoMKgwqAgbXNnLT52 aWRfaGRyLnR5cGUgPT0gU1lOVEhWSURfVlJBTV9MT0NBVElPTl9BQ0spIHsKPiA+ICvCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqBtZW1jcHkoaHYtPmluaXRfYnVmLCBtc2csIFZNQlVTX01B WF9QQUNLRVRfU0laRSk7Cj4gPiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgY29tcGxl dGUoJmh2LT53YWl0KTsKPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqByZXR1cm47 Cj4gPiArwqDCoMKgwqDCoMKgwqB9Cj4gPiArfQo+ID4gKwo+ID4gK3N0YXRpYyB2b2lkIGh5cGVy dl9yZWNlaXZlKHZvaWQgKmN0eCkKPiA+ICt7Cj4gPiArwqDCoMKgwqDCoMKgwqBzdHJ1Y3QgaHZf ZGV2aWNlICpoZGV2ID0gY3R4Owo+ID4gK8KgwqDCoMKgwqDCoMKgc3RydWN0IGh5cGVydl9kcm1f ZGV2aWNlICpodiA9IGh2X2dldF9kcnZkYXRhKGhkZXYpOwo+ID4gK8KgwqDCoMKgwqDCoMKgc3Ry dWN0IHN5bnRodmlkX21zZyAqcmVjdl9idWY7Cj4gPiArwqDCoMKgwqDCoMKgwqB1MzIgYnl0ZXNf cmVjdmQ7Cj4gPiArwqDCoMKgwqDCoMKgwqB1NjQgcmVxX2lkOwo+ID4gK8KgwqDCoMKgwqDCoMKg aW50IHJldDsKPiA+ICsKPiA+ICvCoMKgwqDCoMKgwqDCoGlmICghaHYpCj4gPiArwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgcmV0dXJuOwo+ID4gKwo+ID4gK8KgwqDCoMKgwqDCoMKgcmVj dl9idWYgPSAoc3RydWN0IHN5bnRodmlkX21zZyAqKWh2LT5yZWN2X2J1ZjsKPiA+ICsKPiA+ICvC oMKgwqDCoMKgwqDCoGRvIHsKPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqByZXQg PSB2bWJ1c19yZWN2cGFja2V0KGhkZXYtPmNoYW5uZWwsIHJlY3ZfYnVmLAo+ID4gK8KgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgIFZNQlVTX01BWF9QQUNLRVRfU0laRSwKPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCAm Ynl0ZXNfcmVjdmQsICZyZXFfaWQpOwo+ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oGlmIChieXRlc19yZWN2ZCA+IDAgJiYKPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqAgcmVjdl9idWYtPnBpcGVfaGRyLnR5cGUgPT0gUElQRV9NU0dfREFUQSkKPiA+ICvC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgaHlwZXJ2X3JlY2Vp dmVfc3ViKGhkZXYpOwo+ID4gK8KgwqDCoMKgwqDCoMKgfSB3aGlsZSAoYnl0ZXNfcmVjdmQgPiAw ICYmIHJldCA9PSAwKTsKPiA+ICt9Cj4gPiArCj4gPiAraW50IGh5cGVydl9jb25uZWN0X3ZzcChz dHJ1Y3QgaHZfZGV2aWNlICpoZGV2KQo+ID4gK3sKPiA+ICvCoMKgwqDCoMKgwqDCoHN0cnVjdCBo eXBlcnZfZHJtX2RldmljZSAqaHYgPSBodl9nZXRfZHJ2ZGF0YShoZGV2KTsKPiA+ICvCoMKgwqDC oMKgwqDCoHN0cnVjdCBkcm1fZGV2aWNlICpkZXYgPSAmaHYtPmRldjsKPiA+ICvCoMKgwqDCoMKg wqDCoGludCByZXQ7Cj4gPiArCj4gPiArwqDCoMKgwqDCoMKgwqByZXQgPSB2bWJ1c19vcGVuKGhk ZXYtPmNoYW5uZWwsIFZNQlVTX1JJTkdfQlVGU0laRSwKPiA+IFZNQlVTX1JJTkdfQlVGU0laRSwK PiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIE5VTEws IDAsIGh5cGVydl9yZWNlaXZlLCBoZGV2KTsKPiA+ICvCoMKgwqDCoMKgwqDCoGlmIChyZXQpIHsK PiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqBkcm1fZXJyKGRldiwgIlVuYWJsZSB0 byBvcGVuIHZtYnVzIGNoYW5uZWxcbiIpOwo+ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoHJldHVybiByZXQ7Cj4gPiArwqDCoMKgwqDCoMKgwqB9Cj4gPiArCj4gPiArwqDCoMKgwqDC oMKgwqAvKiBOZWdvdGlhdGUgdGhlIHByb3RvY29sIHZlcnNpb24gd2l0aCBob3N0ICovCj4gPiAr wqDCoMKgwqDCoMKgwqBzd2l0Y2ggKHZtYnVzX3Byb3RvX3ZlcnNpb24pIHsKPiA+ICvCoMKgwqDC oMKgwqDCoGNhc2UgVkVSU0lPTl9XSU4xMDoKPiA+ICvCoMKgwqDCoMKgwqDCoGNhc2UgVkVSU0lP Tl9XSU4xMF9WNToKPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqByZXQgPSBoeXBl cnZfbmVnb3RpYXRlX3ZlcnNpb24oaGRldiwKPiA+IFNZTlRIVklEX1ZFUlNJT05fV0lOMTApOwo+ ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoGlmICghcmV0KQo+ID4gK8KgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqBicmVhazsKPiA+ICvCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqBmYWxsdGhyb3VnaDsKPiA+ICvCoMKgwqDCoMKgwqDCoGNh c2UgVkVSU0lPTl9XSU44Ogo+ID4gK8KgwqDCoMKgwqDCoMKgY2FzZSBWRVJTSU9OX1dJTjhfMToK PiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqByZXQgPSBoeXBlcnZfbmVnb3RpYXRl X3ZlcnNpb24oaGRldiwKPiA+IFNZTlRIVklEX1ZFUlNJT05fV0lOOCk7Cj4gPiArwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgaWYgKCFyZXQpCj4gPiArwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoGJyZWFrOwo+ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoGZhbGx0aHJvdWdoOwo+ID4gK8KgwqDCoMKgwqDCoMKgY2FzZSBWRVJTSU9OX1dT MjAwODoKPiA+ICvCoMKgwqDCoMKgwqDCoGNhc2UgVkVSU0lPTl9XSU43Ogo+ID4gK8KgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoHJldCA9IGh5cGVydl9uZWdvdGlhdGVfdmVyc2lvbihoZGV2 LAo+ID4gU1lOVEhWSURfVkVSU0lPTl9XSU43KTsKPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqBicmVhazsKPiA+ICvCoMKgwqDCoMKgwqDCoGRlZmF1bHQ6Cj4gPiArwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgcmV0ID0gaHlwZXJ2X25lZ290aWF0ZV92ZXJzaW9uKGhkZXYs Cj4gPiBTWU5USFZJRF9WRVJTSU9OX1dJTjEwKTsKPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqBicmVhazsKPiA+ICvCoMKgwqDCoMKgwqDCoH0KPiA+ICsKPiA+ICvCoMKgwqDCoMKg wqDCoGlmIChyZXQpIHsKPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqBkcm1fZXJy KGRldiwgIlN5bnRoZXRpYyB2aWRlbyBkZXZpY2UgdmVyc2lvbiBub3QKPiA+IGFjY2VwdGVkICVk XG4iLCByZXQpOwo+ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoGdvdG8gZXJyb3I7 Cj4gPiArwqDCoMKgwqDCoMKgwqB9Cj4gPiArCj4gPiArwqDCoMKgwqDCoMKgwqBpZiAoaHYtPnN5 bnRodmlkX3ZlcnNpb24gPT0gU1lOVEhWSURfVkVSU0lPTl9XSU43KQo+ID4gK8KgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoGh2LT5zY3JlZW5fZGVwdGggPSBTWU5USFZJRF9ERVBUSF9XSU43 Owo+ID4gK8KgwqDCoMKgwqDCoMKgZWxzZQo+ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoGh2LT5zY3JlZW5fZGVwdGggPSBTWU5USFZJRF9ERVBUSF9XSU44Owo+ID4gKwo+ID4gK8Kg wqDCoMKgwqDCoMKgaWYgKGh5cGVydl92ZXJzaW9uX2dlKGh2LT5zeW50aHZpZF92ZXJzaW9uLAo+ ID4gU1lOVEhWSURfVkVSU0lPTl9XSU4xMCkpIHsKPiA+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqByZXQgPSBoeXBlcnZfZ2V0X3N1cHBvcnRlZF9yZXNvbHV0aW9uKGhkZXYpOwo+ID4g K8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoGlmIChyZXQpCj4gPiArwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoGRybV9lcnIoZGV2LCAiRmFpbGVkIHRv IGdldCBzdXBwb3J0ZWQKPiA+IHJlc29sdXRpb24gZnJvbSBob3N0LCB1c2UgZGVmYXVsdFxuIik7 Cj4gPiArwqDCoMKgwqDCoMKgwqB9IGVsc2Ugewo+ID4gK8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoGh2LT5zY3JlZW5fd2lkdGhfbWF4ID0gU1lOVEhWSURfV0lEVEhfTUFYX1dJTjc7Cj4g PiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgaHYtPnNjcmVlbl9oZWlnaHRfbWF4ID0g U1lOVEhWSURfSEVJR0hUX01BWF9XSU43Owo+ID4gK8KgwqDCoMKgwqDCoMKgfQo+ID4gKwo+ID4g K8KgwqDCoMKgwqDCoMKgaHYtPm1taW9fbWVnYWJ5dGVzID0gaGRldi0+Y2hhbm5lbC0KPiA+ID5v ZmZlcm1zZy5vZmZlci5tbWlvX21lZ2FieXRlczsKPiA+ICsKPiA+ICvCoMKgwqDCoMKgwqDCoHJl dHVybiAwOwo+ID4gKwo+ID4gK2Vycm9yOgo+ID4gK8KgwqDCoMKgwqDCoMKgdm1idXNfY2xvc2Uo aGRldi0+Y2hhbm5lbCk7Cj4gPiArwqDCoMKgwqDCoMKgwqByZXR1cm4gcmV0Owo+ID4gK30KPiAK CgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2 ZWwgbWFpbGluZyBsaXN0CmRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9s aXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9kcmktZGV2ZWwK