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=-16.8 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT 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 A332FC4332D for ; Wed, 3 Mar 2021 13:50:46 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 7418764EF4 for ; Wed, 3 Mar 2021 13:50:46 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1447243AbhCCNsZ (ORCPT ); Wed, 3 Mar 2021 08:48:25 -0500 Received: from mx2.suse.de ([195.135.220.15]:32884 "EHLO mx2.suse.de" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1358612AbhCCMOT (ORCPT ); Wed, 3 Mar 2021 07:14:19 -0500 X-Virus-Scanned: by amavisd-new at test-mx.suse.de Received: from relay2.suse.de (unknown [195.135.221.27]) by mx2.suse.de (Postfix) with ESMTP id 26107AF3F; Wed, 3 Mar 2021 08:45:19 +0000 (UTC) From: Thomas Zimmermann To: daniel@ffwll.ch, airlied@linux.ie, maarten.lankhorst@linux.intel.com, mripard@kernel.org, sumit.semwal@linaro.org, christian.koenig@amd.com, gregkh@linuxfoundation.org, hdegoede@redhat.com, sean@poorly.run, noralf@tronnes.org, stern@rowland.harvard.edu, dan.carpenter@oracle.com Cc: dri-devel@lists.freedesktop.org, Thomas Zimmermann , Pavel Machek , Daniel Vetter , Christoph Hellwig , stable@vger.kernel.org Subject: [PATCH v7] drm: Use USB controller's DMA mask when importing dmabufs Date: Wed, 3 Mar 2021 09:45:12 +0100 Message-Id: <20210303084512.25635-1-tzimmermann@suse.de> X-Mailer: git-send-email 2.30.1 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: stable@vger.kernel.org USB devices cannot perform DMA and hence have no dma_mask set in their device structure. Therefore importing dmabuf into a USB-based driver fails, which breaks joining and mirroring of display in X11. For USB devices, pick the associated USB controller as attachment device. This allows the DRM import helpers to perform the DMA setup. If the DMA controller does not support DMA transfers, we're out of luck and cannot import. Our current USB-based DRM drivers don't use DMA, so the actual DMA device is not important. Drivers should use DRM_GEM_SHMEM_DROVER_OPS_USB to initialize their instance of struct drm_driver. Tested by joining/mirroring displays of udl and radeon un der Gnome/X11. v7: * fix use-before-init bug in gm12u320 (Dan) v6: * implement workaround in DRM drivers and hold reference to DMA device while USB device is in use * remove dev_is_usb() (Greg) * collapse USB helper into usb_intf_get_dma_device() (Alan) * integrate Daniel's TODO statement (Daniel) * fix typos (Greg) v5: * provide a helper for USB interfaces (Alan) * add FIXME item to documentation and TODO list (Daniel) v4: * implement workaround with USB helper functions (Greg) * use struct usb_device->bus->sysdev as DMA device (Takashi) v3: * drop gem_create_object * use DMA mask of USB controller, if any (Daniel, Christian, Noralf) v2: * move fix to importer side (Christian, Daniel) * update SHMEM and CMA helpers for new PRIME callbacks Signed-off-by: Thomas Zimmermann Fixes: 6eb0233ec2d0 ("usb: don't inherity DMA properties for USB devices") Tested-by: Pavel Machek Reviewed-by: Greg Kroah-Hartman Acked-by: Christian König Acked-by: Daniel Vetter Cc: Christoph Hellwig Cc: Greg Kroah-Hartman Cc: # v5.10+ Signed-off-by: Thomas Zimmermann --- Documentation/gpu/todo.rst | 21 +++++++++++++++++++++ drivers/gpu/drm/tiny/gm12u320.c | 28 ++++++++++++++++++++++++++-- drivers/gpu/drm/udl/udl_drv.c | 17 +++++++++++++++++ drivers/gpu/drm/udl/udl_drv.h | 1 + drivers/gpu/drm/udl/udl_main.c | 9 +++++++++ drivers/usb/core/usb.c | 32 ++++++++++++++++++++++++++++++++ include/linux/usb.h | 2 ++ 7 files changed, 108 insertions(+), 2 deletions(-) diff --git a/Documentation/gpu/todo.rst b/Documentation/gpu/todo.rst index 0631b9b323d5..fdfd6a1081ec 100644 --- a/Documentation/gpu/todo.rst +++ b/Documentation/gpu/todo.rst @@ -571,6 +571,27 @@ Contact: Daniel Vetter Level: Intermediate +Remove automatic page mapping from dma-buf importing +---------------------------------------------------- + +When importing dma-bufs, the dma-buf and PRIME frameworks automatically map +imported pages into the importer's DMA area. drm_gem_prime_fd_to_handle() and +drm_gem_prime_handle_to_fd() require that importers call dma_buf_attach() +even if they never do actual device DMA, but only CPU access through +dma_buf_vmap(). This is a problem for USB devices, which do not support DMA +operations. + +To fix the issue, automatic page mappings should be removed from the +buffer-sharing code. Fixing this is a bit more involved, since the import/export +cache is also tied to &drm_gem_object.import_attach. Meanwhile we paper over +this problem for USB devices by fishing out the USB host controller device, as +long as that supports DMA. Otherwise importing can still needlessly fail. + +Contact: Thomas Zimmermann , Daniel Vetter + +Level: Advanced + + Better Testing ============== diff --git a/drivers/gpu/drm/tiny/gm12u320.c b/drivers/gpu/drm/tiny/gm12u320.c index 0b4f4f2af1ef..4fe372f43cf5 100644 --- a/drivers/gpu/drm/tiny/gm12u320.c +++ b/drivers/gpu/drm/tiny/gm12u320.c @@ -84,6 +84,7 @@ MODULE_PARM_DESC(eco_mode, "Turn on Eco mode (less bright, more silent)"); struct gm12u320_device { struct drm_device dev; + struct device *dmadev; struct drm_simple_display_pipe pipe; struct drm_connector conn; unsigned char *cmd_buf; @@ -599,6 +600,22 @@ static const uint64_t gm12u320_pipe_modifiers[] = { DRM_FORMAT_MOD_INVALID }; +/* + * FIXME: Dma-buf sharing requires DMA support by the importing device. + * This function is a workaround to make USB devices work as well. + * See todo.rst for how to fix the issue in the dma-buf framework. + */ +static struct drm_gem_object *gm12u320_gem_prime_import(struct drm_device *dev, + struct dma_buf *dma_buf) +{ + struct gm12u320_device *gm12u320 = to_gm12u320(dev); + + if (!gm12u320->dmadev) + return ERR_PTR(-ENODEV); + + return drm_gem_prime_import_dev(dev, dma_buf, gm12u320->dmadev); +} + DEFINE_DRM_GEM_FOPS(gm12u320_fops); static const struct drm_driver gm12u320_drm_driver = { @@ -612,6 +629,7 @@ static const struct drm_driver gm12u320_drm_driver = { .fops = &gm12u320_fops, DRM_GEM_SHMEM_DRIVER_OPS, + .gem_prime_import = gm12u320_gem_prime_import, }; static const struct drm_mode_config_funcs gm12u320_mode_config_funcs = { @@ -638,12 +656,15 @@ static int gm12u320_usb_probe(struct usb_interface *interface, struct gm12u320_device, dev); if (IS_ERR(gm12u320)) return PTR_ERR(gm12u320); + dev = &gm12u320->dev; + + gm12u320->dmadev = usb_intf_get_dma_device(to_usb_interface(dev->dev)); + if (!gm12u320->dmadev) + drm_warn(dev, "buffer sharing not supported"); /* not an error */ INIT_DELAYED_WORK(&gm12u320->fb_update.work, gm12u320_fb_update_work); mutex_init(&gm12u320->fb_update.lock); - dev = &gm12u320->dev; - ret = drmm_mode_config_init(dev); if (ret) return ret; @@ -691,7 +712,10 @@ static int gm12u320_usb_probe(struct usb_interface *interface, static void gm12u320_usb_disconnect(struct usb_interface *interface) { struct drm_device *dev = usb_get_intfdata(interface); + struct gm12u320_device *gm12u320 = to_gm12u320(dev); + put_device(gm12u320->dmadev); + gm12u320->dmadev = NULL; drm_dev_unplug(dev); drm_atomic_helper_shutdown(dev); } diff --git a/drivers/gpu/drm/udl/udl_drv.c b/drivers/gpu/drm/udl/udl_drv.c index 9269092697d8..5703277c6f52 100644 --- a/drivers/gpu/drm/udl/udl_drv.c +++ b/drivers/gpu/drm/udl/udl_drv.c @@ -32,6 +32,22 @@ static int udl_usb_resume(struct usb_interface *interface) return drm_mode_config_helper_resume(dev); } +/* + * FIXME: Dma-buf sharing requires DMA support by the importing device. + * This function is a workaround to make USB devices work as well. + * See todo.rst for how to fix the issue in the dma-buf framework. + */ +static struct drm_gem_object *udl_driver_gem_prime_import(struct drm_device *dev, + struct dma_buf *dma_buf) +{ + struct udl_device *udl = to_udl(dev); + + if (!udl->dmadev) + return ERR_PTR(-ENODEV); + + return drm_gem_prime_import_dev(dev, dma_buf, udl->dmadev); +} + DEFINE_DRM_GEM_FOPS(udl_driver_fops); static const struct drm_driver driver = { @@ -40,6 +56,7 @@ static const struct drm_driver driver = { /* GEM hooks */ .fops = &udl_driver_fops, DRM_GEM_SHMEM_DRIVER_OPS, + .gem_prime_import = udl_driver_gem_prime_import, .name = DRIVER_NAME, .desc = DRIVER_DESC, diff --git a/drivers/gpu/drm/udl/udl_drv.h b/drivers/gpu/drm/udl/udl_drv.h index 875e73551ae9..cc16a13316e4 100644 --- a/drivers/gpu/drm/udl/udl_drv.h +++ b/drivers/gpu/drm/udl/udl_drv.h @@ -50,6 +50,7 @@ struct urb_list { struct udl_device { struct drm_device drm; struct device *dev; + struct device *dmadev; struct drm_simple_display_pipe display_pipe; diff --git a/drivers/gpu/drm/udl/udl_main.c b/drivers/gpu/drm/udl/udl_main.c index 0e2a376cb075..7c0338bcadea 100644 --- a/drivers/gpu/drm/udl/udl_main.c +++ b/drivers/gpu/drm/udl/udl_main.c @@ -315,6 +315,10 @@ int udl_init(struct udl_device *udl) DRM_DEBUG("\n"); + udl->dmadev = usb_intf_get_dma_device(to_usb_interface(dev->dev)); + if (!udl->dmadev) + drm_warn(dev, "buffer sharing not supported"); /* not an error */ + mutex_init(&udl->gem_lock); if (!udl_parse_vendor_descriptor(udl)) { @@ -349,6 +353,11 @@ int udl_init(struct udl_device *udl) int udl_drop_usb(struct drm_device *dev) { + struct udl_device *udl = to_udl(dev); + udl_free_urb_list(dev); + put_device(udl->dmadev); + udl->dmadev = NULL; + return 0; } diff --git a/drivers/usb/core/usb.c b/drivers/usb/core/usb.c index 8f07b0516100..a566bb494e24 100644 --- a/drivers/usb/core/usb.c +++ b/drivers/usb/core/usb.c @@ -748,6 +748,38 @@ void usb_put_intf(struct usb_interface *intf) } EXPORT_SYMBOL_GPL(usb_put_intf); +/** + * usb_intf_get_dma_device - acquire a reference on the usb interface's DMA endpoint + * @intf: the usb interface + * + * While a USB device cannot perform DMA operations by itself, many USB + * controllers can. A call to usb_intf_get_dma_device() returns the DMA endpoint + * for the given USB interface, if any. The returned device structure must be + * released with put_device(). + * + * See also usb_get_dma_device(). + * + * Returns: A reference to the usb interface's DMA endpoint; or NULL if none + * exists. + */ +struct device *usb_intf_get_dma_device(struct usb_interface *intf) +{ + struct usb_device *udev = interface_to_usbdev(intf); + struct device *dmadev; + + if (!udev->bus) + return NULL; + + dmadev = get_device(udev->bus->sysdev); + if (!dmadev || !dmadev->dma_mask) { + put_device(dmadev); + return NULL; + } + + return dmadev; +} +EXPORT_SYMBOL_GPL(usb_intf_get_dma_device); + /* USB device locking * * USB devices and interfaces are locked using the semaphore in their diff --git a/include/linux/usb.h b/include/linux/usb.h index 7d72c4e0713c..d6a41841b93e 100644 --- a/include/linux/usb.h +++ b/include/linux/usb.h @@ -746,6 +746,8 @@ extern int usb_lock_device_for_reset(struct usb_device *udev, extern int usb_reset_device(struct usb_device *dev); extern void usb_queue_reset_device(struct usb_interface *dev); +extern struct device *usb_intf_get_dma_device(struct usb_interface *intf); + #ifdef CONFIG_ACPI extern int usb_acpi_set_power_state(struct usb_device *hdev, int index, bool enable); base-commit: b80182b9bffb51460e4a2ad7d96737ecd49126dc prerequisite-patch-id: c2b2f08f0eccc9f5df0c0da49fa1d36267deb11d -- 2.30.1 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=-16.8 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT 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 9B6A9C433E0 for ; Wed, 3 Mar 2021 08:45:23 +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 193B164EE1 for ; Wed, 3 Mar 2021 08:45:23 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 193B164EE1 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=suse.de 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 4DF3689E1B; Wed, 3 Mar 2021 08:45:22 +0000 (UTC) Received: from mx2.suse.de (mx2.suse.de [195.135.220.15]) by gabe.freedesktop.org (Postfix) with ESMTPS id 3B09F89E1B for ; Wed, 3 Mar 2021 08:45:21 +0000 (UTC) X-Virus-Scanned: by amavisd-new at test-mx.suse.de Received: from relay2.suse.de (unknown [195.135.221.27]) by mx2.suse.de (Postfix) with ESMTP id 26107AF3F; Wed, 3 Mar 2021 08:45:19 +0000 (UTC) From: Thomas Zimmermann To: daniel@ffwll.ch, airlied@linux.ie, maarten.lankhorst@linux.intel.com, mripard@kernel.org, sumit.semwal@linaro.org, christian.koenig@amd.com, gregkh@linuxfoundation.org, hdegoede@redhat.com, sean@poorly.run, noralf@tronnes.org, stern@rowland.harvard.edu, dan.carpenter@oracle.com Subject: [PATCH v7] drm: Use USB controller's DMA mask when importing dmabufs Date: Wed, 3 Mar 2021 09:45:12 +0100 Message-Id: <20210303084512.25635-1-tzimmermann@suse.de> X-Mailer: git-send-email 2.30.1 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: Thomas Zimmermann , Daniel Vetter , stable@vger.kernel.org, dri-devel@lists.freedesktop.org, Pavel Machek , Christoph Hellwig Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" VVNCIGRldmljZXMgY2Fubm90IHBlcmZvcm0gRE1BIGFuZCBoZW5jZSBoYXZlIG5vIGRtYV9tYXNr IHNldCBpbiB0aGVpcgpkZXZpY2Ugc3RydWN0dXJlLiBUaGVyZWZvcmUgaW1wb3J0aW5nIGRtYWJ1 ZiBpbnRvIGEgVVNCLWJhc2VkIGRyaXZlcgpmYWlscywgd2hpY2ggYnJlYWtzIGpvaW5pbmcgYW5k IG1pcnJvcmluZyBvZiBkaXNwbGF5IGluIFgxMS4KCkZvciBVU0IgZGV2aWNlcywgcGljayB0aGUg YXNzb2NpYXRlZCBVU0IgY29udHJvbGxlciBhcyBhdHRhY2htZW50IGRldmljZS4KVGhpcyBhbGxv d3MgdGhlIERSTSBpbXBvcnQgaGVscGVycyB0byBwZXJmb3JtIHRoZSBETUEgc2V0dXAuIElmIHRo ZSBETUEKY29udHJvbGxlciBkb2VzIG5vdCBzdXBwb3J0IERNQSB0cmFuc2ZlcnMsIHdlJ3JlIG91 dCBvZiBsdWNrIGFuZCBjYW5ub3QKaW1wb3J0LiBPdXIgY3VycmVudCBVU0ItYmFzZWQgRFJNIGRy aXZlcnMgZG9uJ3QgdXNlIERNQSwgc28gdGhlIGFjdHVhbApETUEgZGV2aWNlIGlzIG5vdCBpbXBv cnRhbnQuCgpEcml2ZXJzIHNob3VsZCB1c2UgRFJNX0dFTV9TSE1FTV9EUk9WRVJfT1BTX1VTQiB0 byBpbml0aWFsaXplIHRoZWlyCmluc3RhbmNlIG9mIHN0cnVjdCBkcm1fZHJpdmVyLgoKVGVzdGVk IGJ5IGpvaW5pbmcvbWlycm9yaW5nIGRpc3BsYXlzIG9mIHVkbCBhbmQgcmFkZW9uIHVuIGRlciBH bm9tZS9YMTEuCgp2NzoKCSogZml4IHVzZS1iZWZvcmUtaW5pdCBidWcgaW4gZ20xMnUzMjAgKERh bikKdjY6CgkqIGltcGxlbWVudCB3b3JrYXJvdW5kIGluIERSTSBkcml2ZXJzIGFuZCBob2xkIHJl ZmVyZW5jZSB0bwoJICBETUEgZGV2aWNlIHdoaWxlIFVTQiBkZXZpY2UgaXMgaW4gdXNlCgkqIHJl bW92ZSBkZXZfaXNfdXNiKCkgKEdyZWcpCgkqIGNvbGxhcHNlIFVTQiBoZWxwZXIgaW50byB1c2Jf aW50Zl9nZXRfZG1hX2RldmljZSgpIChBbGFuKQoJKiBpbnRlZ3JhdGUgRGFuaWVsJ3MgVE9ETyBz dGF0ZW1lbnQgKERhbmllbCkKCSogZml4IHR5cG9zIChHcmVnKQp2NToKCSogcHJvdmlkZSBhIGhl bHBlciBmb3IgVVNCIGludGVyZmFjZXMgKEFsYW4pCgkqIGFkZCBGSVhNRSBpdGVtIHRvIGRvY3Vt ZW50YXRpb24gYW5kIFRPRE8gbGlzdCAoRGFuaWVsKQp2NDoKCSogaW1wbGVtZW50IHdvcmthcm91 bmQgd2l0aCBVU0IgaGVscGVyIGZ1bmN0aW9ucyAoR3JlZykKCSogdXNlIHN0cnVjdCB1c2JfZGV2 aWNlLT5idXMtPnN5c2RldiBhcyBETUEgZGV2aWNlIChUYWthc2hpKQp2MzoKCSogZHJvcCBnZW1f Y3JlYXRlX29iamVjdAoJKiB1c2UgRE1BIG1hc2sgb2YgVVNCIGNvbnRyb2xsZXIsIGlmIGFueSAo RGFuaWVsLCBDaHJpc3RpYW4sIE5vcmFsZikKdjI6CgkqIG1vdmUgZml4IHRvIGltcG9ydGVyIHNp ZGUgKENocmlzdGlhbiwgRGFuaWVsKQoJKiB1cGRhdGUgU0hNRU0gYW5kIENNQSBoZWxwZXJzIGZv ciBuZXcgUFJJTUUgY2FsbGJhY2tzCgpTaWduZWQtb2ZmLWJ5OiBUaG9tYXMgWmltbWVybWFubiA8 dHppbW1lcm1hbm5Ac3VzZS5kZT4KRml4ZXM6IDZlYjAyMzNlYzJkMCAoInVzYjogZG9uJ3QgaW5o ZXJpdHkgRE1BIHByb3BlcnRpZXMgZm9yIFVTQiBkZXZpY2VzIikKVGVzdGVkLWJ5OiBQYXZlbCBN YWNoZWsgPHBhdmVsQHVjdy5jej4KUmV2aWV3ZWQtYnk6IEdyZWcgS3JvYWgtSGFydG1hbiA8Z3Jl Z2toQGxpbnV4Zm91bmRhdGlvbi5vcmc+CkFja2VkLWJ5OiBDaHJpc3RpYW4gS8O2bmlnIDxjaHJp c3RpYW4ua29lbmlnQGFtZC5jb20+CkFja2VkLWJ5OiBEYW5pZWwgVmV0dGVyIDxkYW5pZWwudmV0 dGVyQGZmd2xsLmNoPgpDYzogQ2hyaXN0b3BoIEhlbGx3aWcgPGhjaEBsc3QuZGU+CkNjOiBHcmVn IEtyb2FoLUhhcnRtYW4gPGdyZWdraEBsaW51eGZvdW5kYXRpb24ub3JnPgpDYzogPHN0YWJsZUB2 Z2VyLmtlcm5lbC5vcmc+ICMgdjUuMTArClNpZ25lZC1vZmYtYnk6IFRob21hcyBaaW1tZXJtYW5u IDx0emltbWVybWFubkBzdXNlLmRlPgotLS0KIERvY3VtZW50YXRpb24vZ3B1L3RvZG8ucnN0ICAg ICAgfCAyMSArKysrKysrKysrKysrKysrKysrKysKIGRyaXZlcnMvZ3B1L2RybS90aW55L2dtMTJ1 MzIwLmMgfCAyOCArKysrKysrKysrKysrKysrKysrKysrKysrKy0tCiBkcml2ZXJzL2dwdS9kcm0v dWRsL3VkbF9kcnYuYyAgIHwgMTcgKysrKysrKysrKysrKysrKysKIGRyaXZlcnMvZ3B1L2RybS91 ZGwvdWRsX2Rydi5oICAgfCAgMSArCiBkcml2ZXJzL2dwdS9kcm0vdWRsL3VkbF9tYWluLmMgIHwg IDkgKysrKysrKysrCiBkcml2ZXJzL3VzYi9jb3JlL3VzYi5jICAgICAgICAgIHwgMzIgKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysKIGluY2x1ZGUvbGludXgvdXNiLmggICAgICAgICAg ICAgfCAgMiArKwogNyBmaWxlcyBjaGFuZ2VkLCAxMDggaW5zZXJ0aW9ucygrKSwgMiBkZWxldGlv bnMoLSkKCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2dwdS90b2RvLnJzdCBiL0RvY3VtZW50 YXRpb24vZ3B1L3RvZG8ucnN0CmluZGV4IDA2MzFiOWIzMjNkNS4uZmRmZDZhMTA4MWVjIDEwMDY0 NAotLS0gYS9Eb2N1bWVudGF0aW9uL2dwdS90b2RvLnJzdAorKysgYi9Eb2N1bWVudGF0aW9uL2dw dS90b2RvLnJzdApAQCAtNTcxLDYgKzU3MSwyNyBAQCBDb250YWN0OiBEYW5pZWwgVmV0dGVyCiAK IExldmVsOiBJbnRlcm1lZGlhdGUKIAorUmVtb3ZlIGF1dG9tYXRpYyBwYWdlIG1hcHBpbmcgZnJv bSBkbWEtYnVmIGltcG9ydGluZworLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLQorCitXaGVuIGltcG9ydGluZyBkbWEtYnVmcywgdGhlIGRtYS1idWYg YW5kIFBSSU1FIGZyYW1ld29ya3MgYXV0b21hdGljYWxseSBtYXAKK2ltcG9ydGVkIHBhZ2VzIGlu dG8gdGhlIGltcG9ydGVyJ3MgRE1BIGFyZWEuIGRybV9nZW1fcHJpbWVfZmRfdG9faGFuZGxlKCkg YW5kCitkcm1fZ2VtX3ByaW1lX2hhbmRsZV90b19mZCgpIHJlcXVpcmUgdGhhdCBpbXBvcnRlcnMg Y2FsbCBkbWFfYnVmX2F0dGFjaCgpCitldmVuIGlmIHRoZXkgbmV2ZXIgZG8gYWN0dWFsIGRldmlj ZSBETUEsIGJ1dCBvbmx5IENQVSBhY2Nlc3MgdGhyb3VnaAorZG1hX2J1Zl92bWFwKCkuIFRoaXMg aXMgYSBwcm9ibGVtIGZvciBVU0IgZGV2aWNlcywgd2hpY2ggZG8gbm90IHN1cHBvcnQgRE1BCitv cGVyYXRpb25zLgorCitUbyBmaXggdGhlIGlzc3VlLCBhdXRvbWF0aWMgcGFnZSBtYXBwaW5ncyBz aG91bGQgYmUgcmVtb3ZlZCBmcm9tIHRoZQorYnVmZmVyLXNoYXJpbmcgY29kZS4gRml4aW5nIHRo aXMgaXMgYSBiaXQgbW9yZSBpbnZvbHZlZCwgc2luY2UgdGhlIGltcG9ydC9leHBvcnQKK2NhY2hl IGlzIGFsc28gdGllZCB0byAmZHJtX2dlbV9vYmplY3QuaW1wb3J0X2F0dGFjaC4gTWVhbndoaWxl IHdlIHBhcGVyIG92ZXIKK3RoaXMgcHJvYmxlbSBmb3IgVVNCIGRldmljZXMgYnkgZmlzaGluZyBv dXQgdGhlIFVTQiBob3N0IGNvbnRyb2xsZXIgZGV2aWNlLCBhcworbG9uZyBhcyB0aGF0IHN1cHBv cnRzIERNQS4gT3RoZXJ3aXNlIGltcG9ydGluZyBjYW4gc3RpbGwgbmVlZGxlc3NseSBmYWlsLgor CitDb250YWN0OiBUaG9tYXMgWmltbWVybWFubiA8dHppbW1lcm1hbm5Ac3VzZS5kZT4sIERhbmll bCBWZXR0ZXIKKworTGV2ZWw6IEFkdmFuY2VkCisKKwogQmV0dGVyIFRlc3RpbmcKID09PT09PT09 PT09PT09CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS90aW55L2dtMTJ1MzIwLmMgYi9k cml2ZXJzL2dwdS9kcm0vdGlueS9nbTEydTMyMC5jCmluZGV4IDBiNGY0ZjJhZjFlZi4uNGZlMzcy ZjQzY2Y1IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vdGlueS9nbTEydTMyMC5jCisrKyBi L2RyaXZlcnMvZ3B1L2RybS90aW55L2dtMTJ1MzIwLmMKQEAgLTg0LDYgKzg0LDcgQEAgTU9EVUxF X1BBUk1fREVTQyhlY29fbW9kZSwgIlR1cm4gb24gRWNvIG1vZGUgKGxlc3MgYnJpZ2h0LCBtb3Jl IHNpbGVudCkiKTsKIAogc3RydWN0IGdtMTJ1MzIwX2RldmljZSB7CiAJc3RydWN0IGRybV9kZXZp Y2UJICAgICAgICAgZGV2OworCXN0cnVjdCBkZXZpY2UgICAgICAgICAgICAgICAgICAgKmRtYWRl djsKIAlzdHJ1Y3QgZHJtX3NpbXBsZV9kaXNwbGF5X3BpcGUgICBwaXBlOwogCXN0cnVjdCBkcm1f Y29ubmVjdG9yCSAgICAgICAgIGNvbm47CiAJdW5zaWduZWQgY2hhciAgICAgICAgICAgICAgICAg ICAqY21kX2J1ZjsKQEAgLTU5OSw2ICs2MDAsMjIgQEAgc3RhdGljIGNvbnN0IHVpbnQ2NF90IGdt MTJ1MzIwX3BpcGVfbW9kaWZpZXJzW10gPSB7CiAJRFJNX0ZPUk1BVF9NT0RfSU5WQUxJRAogfTsK IAorLyoKKyAqIEZJWE1FOiBEbWEtYnVmIHNoYXJpbmcgcmVxdWlyZXMgRE1BIHN1cHBvcnQgYnkg dGhlIGltcG9ydGluZyBkZXZpY2UuCisgKiAgICAgICAgVGhpcyBmdW5jdGlvbiBpcyBhIHdvcmth cm91bmQgdG8gbWFrZSBVU0IgZGV2aWNlcyB3b3JrIGFzIHdlbGwuCisgKiAgICAgICAgU2VlIHRv ZG8ucnN0IGZvciBob3cgdG8gZml4IHRoZSBpc3N1ZSBpbiB0aGUgZG1hLWJ1ZiBmcmFtZXdvcmsu CisgKi8KK3N0YXRpYyBzdHJ1Y3QgZHJtX2dlbV9vYmplY3QgKmdtMTJ1MzIwX2dlbV9wcmltZV9p bXBvcnQoc3RydWN0IGRybV9kZXZpY2UgKmRldiwKKwkJCQkJCQlzdHJ1Y3QgZG1hX2J1ZiAqZG1h X2J1ZikKK3sKKwlzdHJ1Y3QgZ20xMnUzMjBfZGV2aWNlICpnbTEydTMyMCA9IHRvX2dtMTJ1MzIw KGRldik7CisKKwlpZiAoIWdtMTJ1MzIwLT5kbWFkZXYpCisJCXJldHVybiBFUlJfUFRSKC1FTk9E RVYpOworCisJcmV0dXJuIGRybV9nZW1fcHJpbWVfaW1wb3J0X2RldihkZXYsIGRtYV9idWYsIGdt MTJ1MzIwLT5kbWFkZXYpOworfQorCiBERUZJTkVfRFJNX0dFTV9GT1BTKGdtMTJ1MzIwX2ZvcHMp OwogCiBzdGF0aWMgY29uc3Qgc3RydWN0IGRybV9kcml2ZXIgZ20xMnUzMjBfZHJtX2RyaXZlciA9 IHsKQEAgLTYxMiw2ICs2MjksNyBAQCBzdGF0aWMgY29uc3Qgc3RydWN0IGRybV9kcml2ZXIgZ20x MnUzMjBfZHJtX2RyaXZlciA9IHsKIAogCS5mb3BzCQkgPSAmZ20xMnUzMjBfZm9wcywKIAlEUk1f R0VNX1NITUVNX0RSSVZFUl9PUFMsCisJLmdlbV9wcmltZV9pbXBvcnQgPSBnbTEydTMyMF9nZW1f cHJpbWVfaW1wb3J0LAogfTsKIAogc3RhdGljIGNvbnN0IHN0cnVjdCBkcm1fbW9kZV9jb25maWdf ZnVuY3MgZ20xMnUzMjBfbW9kZV9jb25maWdfZnVuY3MgPSB7CkBAIC02MzgsMTIgKzY1NiwxNSBA QCBzdGF0aWMgaW50IGdtMTJ1MzIwX3VzYl9wcm9iZShzdHJ1Y3QgdXNiX2ludGVyZmFjZSAqaW50 ZXJmYWNlLAogCQkJCSAgICAgIHN0cnVjdCBnbTEydTMyMF9kZXZpY2UsIGRldik7CiAJaWYgKElT X0VSUihnbTEydTMyMCkpCiAJCXJldHVybiBQVFJfRVJSKGdtMTJ1MzIwKTsKKwlkZXYgPSAmZ20x MnUzMjAtPmRldjsKKworCWdtMTJ1MzIwLT5kbWFkZXYgPSB1c2JfaW50Zl9nZXRfZG1hX2Rldmlj ZSh0b191c2JfaW50ZXJmYWNlKGRldi0+ZGV2KSk7CisJaWYgKCFnbTEydTMyMC0+ZG1hZGV2KQor CQlkcm1fd2FybihkZXYsICJidWZmZXIgc2hhcmluZyBub3Qgc3VwcG9ydGVkIik7IC8qIG5vdCBh biBlcnJvciAqLwogCiAJSU5JVF9ERUxBWUVEX1dPUksoJmdtMTJ1MzIwLT5mYl91cGRhdGUud29y aywgZ20xMnUzMjBfZmJfdXBkYXRlX3dvcmspOwogCW11dGV4X2luaXQoJmdtMTJ1MzIwLT5mYl91 cGRhdGUubG9jayk7CiAKLQlkZXYgPSAmZ20xMnUzMjAtPmRldjsKLQogCXJldCA9IGRybW1fbW9k ZV9jb25maWdfaW5pdChkZXYpOwogCWlmIChyZXQpCiAJCXJldHVybiByZXQ7CkBAIC02OTEsNyAr NzEyLDEwIEBAIHN0YXRpYyBpbnQgZ20xMnUzMjBfdXNiX3Byb2JlKHN0cnVjdCB1c2JfaW50ZXJm YWNlICppbnRlcmZhY2UsCiBzdGF0aWMgdm9pZCBnbTEydTMyMF91c2JfZGlzY29ubmVjdChzdHJ1 Y3QgdXNiX2ludGVyZmFjZSAqaW50ZXJmYWNlKQogewogCXN0cnVjdCBkcm1fZGV2aWNlICpkZXYg PSB1c2JfZ2V0X2ludGZkYXRhKGludGVyZmFjZSk7CisJc3RydWN0IGdtMTJ1MzIwX2RldmljZSAq Z20xMnUzMjAgPSB0b19nbTEydTMyMChkZXYpOwogCisJcHV0X2RldmljZShnbTEydTMyMC0+ZG1h ZGV2KTsKKwlnbTEydTMyMC0+ZG1hZGV2ID0gTlVMTDsKIAlkcm1fZGV2X3VucGx1ZyhkZXYpOwog CWRybV9hdG9taWNfaGVscGVyX3NodXRkb3duKGRldik7CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJz L2dwdS9kcm0vdWRsL3VkbF9kcnYuYyBiL2RyaXZlcnMvZ3B1L2RybS91ZGwvdWRsX2Rydi5jCmlu ZGV4IDkyNjkwOTI2OTdkOC4uNTcwMzI3N2M2ZjUyIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9k cm0vdWRsL3VkbF9kcnYuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vdWRsL3VkbF9kcnYuYwpAQCAt MzIsNiArMzIsMjIgQEAgc3RhdGljIGludCB1ZGxfdXNiX3Jlc3VtZShzdHJ1Y3QgdXNiX2ludGVy ZmFjZSAqaW50ZXJmYWNlKQogCXJldHVybiBkcm1fbW9kZV9jb25maWdfaGVscGVyX3Jlc3VtZShk ZXYpOwogfQogCisvKgorICogRklYTUU6IERtYS1idWYgc2hhcmluZyByZXF1aXJlcyBETUEgc3Vw cG9ydCBieSB0aGUgaW1wb3J0aW5nIGRldmljZS4KKyAqICAgICAgICBUaGlzIGZ1bmN0aW9uIGlz IGEgd29ya2Fyb3VuZCB0byBtYWtlIFVTQiBkZXZpY2VzIHdvcmsgYXMgd2VsbC4KKyAqICAgICAg ICBTZWUgdG9kby5yc3QgZm9yIGhvdyB0byBmaXggdGhlIGlzc3VlIGluIHRoZSBkbWEtYnVmIGZy YW1ld29yay4KKyAqLworc3RhdGljIHN0cnVjdCBkcm1fZ2VtX29iamVjdCAqdWRsX2RyaXZlcl9n ZW1fcHJpbWVfaW1wb3J0KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsCisJCQkJCQkJICBzdHJ1Y3Qg ZG1hX2J1ZiAqZG1hX2J1ZikKK3sKKwlzdHJ1Y3QgdWRsX2RldmljZSAqdWRsID0gdG9fdWRsKGRl dik7CisKKwlpZiAoIXVkbC0+ZG1hZGV2KQorCQlyZXR1cm4gRVJSX1BUUigtRU5PREVWKTsKKwor CXJldHVybiBkcm1fZ2VtX3ByaW1lX2ltcG9ydF9kZXYoZGV2LCBkbWFfYnVmLCB1ZGwtPmRtYWRl dik7Cit9CisKIERFRklORV9EUk1fR0VNX0ZPUFModWRsX2RyaXZlcl9mb3BzKTsKIAogc3RhdGlj IGNvbnN0IHN0cnVjdCBkcm1fZHJpdmVyIGRyaXZlciA9IHsKQEAgLTQwLDYgKzU2LDcgQEAgc3Rh dGljIGNvbnN0IHN0cnVjdCBkcm1fZHJpdmVyIGRyaXZlciA9IHsKIAkvKiBHRU0gaG9va3MgKi8K IAkuZm9wcyA9ICZ1ZGxfZHJpdmVyX2ZvcHMsCiAJRFJNX0dFTV9TSE1FTV9EUklWRVJfT1BTLAor CS5nZW1fcHJpbWVfaW1wb3J0ID0gdWRsX2RyaXZlcl9nZW1fcHJpbWVfaW1wb3J0LAogCiAJLm5h bWUgPSBEUklWRVJfTkFNRSwKIAkuZGVzYyA9IERSSVZFUl9ERVNDLApkaWZmIC0tZ2l0IGEvZHJp dmVycy9ncHUvZHJtL3VkbC91ZGxfZHJ2LmggYi9kcml2ZXJzL2dwdS9kcm0vdWRsL3VkbF9kcnYu aAppbmRleCA4NzVlNzM1NTFhZTkuLmNjMTZhMTMzMTZlNCAxMDA2NDQKLS0tIGEvZHJpdmVycy9n cHUvZHJtL3VkbC91ZGxfZHJ2LmgKKysrIGIvZHJpdmVycy9ncHUvZHJtL3VkbC91ZGxfZHJ2LmgK QEAgLTUwLDYgKzUwLDcgQEAgc3RydWN0IHVyYl9saXN0IHsKIHN0cnVjdCB1ZGxfZGV2aWNlIHsK IAlzdHJ1Y3QgZHJtX2RldmljZSBkcm07CiAJc3RydWN0IGRldmljZSAqZGV2OworCXN0cnVjdCBk ZXZpY2UgKmRtYWRldjsKIAogCXN0cnVjdCBkcm1fc2ltcGxlX2Rpc3BsYXlfcGlwZSBkaXNwbGF5 X3BpcGU7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS91ZGwvdWRsX21haW4uYyBiL2Ry aXZlcnMvZ3B1L2RybS91ZGwvdWRsX21haW4uYwppbmRleCAwZTJhMzc2Y2IwNzUuLjdjMDMzOGJj YWRlYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3VkbC91ZGxfbWFpbi5jCisrKyBiL2Ry aXZlcnMvZ3B1L2RybS91ZGwvdWRsX21haW4uYwpAQCAtMzE1LDYgKzMxNSwxMCBAQCBpbnQgdWRs X2luaXQoc3RydWN0IHVkbF9kZXZpY2UgKnVkbCkKIAogCURSTV9ERUJVRygiXG4iKTsKIAorCXVk bC0+ZG1hZGV2ID0gdXNiX2ludGZfZ2V0X2RtYV9kZXZpY2UodG9fdXNiX2ludGVyZmFjZShkZXYt PmRldikpOworCWlmICghdWRsLT5kbWFkZXYpCisJCWRybV93YXJuKGRldiwgImJ1ZmZlciBzaGFy aW5nIG5vdCBzdXBwb3J0ZWQiKTsgLyogbm90IGFuIGVycm9yICovCisKIAltdXRleF9pbml0KCZ1 ZGwtPmdlbV9sb2NrKTsKIAogCWlmICghdWRsX3BhcnNlX3ZlbmRvcl9kZXNjcmlwdG9yKHVkbCkp IHsKQEAgLTM0OSw2ICszNTMsMTEgQEAgaW50IHVkbF9pbml0KHN0cnVjdCB1ZGxfZGV2aWNlICp1 ZGwpCiAKIGludCB1ZGxfZHJvcF91c2Ioc3RydWN0IGRybV9kZXZpY2UgKmRldikKIHsKKwlzdHJ1 Y3QgdWRsX2RldmljZSAqdWRsID0gdG9fdWRsKGRldik7CisKIAl1ZGxfZnJlZV91cmJfbGlzdChk ZXYpOworCXB1dF9kZXZpY2UodWRsLT5kbWFkZXYpOworCXVkbC0+ZG1hZGV2ID0gTlVMTDsKKwog CXJldHVybiAwOwogfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2IvY29yZS91c2IuYyBiL2RyaXZl cnMvdXNiL2NvcmUvdXNiLmMKaW5kZXggOGYwN2IwNTE2MTAwLi5hNTY2YmI0OTRlMjQgMTAwNjQ0 Ci0tLSBhL2RyaXZlcnMvdXNiL2NvcmUvdXNiLmMKKysrIGIvZHJpdmVycy91c2IvY29yZS91c2Iu YwpAQCAtNzQ4LDYgKzc0OCwzOCBAQCB2b2lkIHVzYl9wdXRfaW50ZihzdHJ1Y3QgdXNiX2ludGVy ZmFjZSAqaW50ZikKIH0KIEVYUE9SVF9TWU1CT0xfR1BMKHVzYl9wdXRfaW50Zik7CiAKKy8qKgor ICogdXNiX2ludGZfZ2V0X2RtYV9kZXZpY2UgLSBhY3F1aXJlIGEgcmVmZXJlbmNlIG9uIHRoZSB1 c2IgaW50ZXJmYWNlJ3MgRE1BIGVuZHBvaW50CisgKiBAaW50ZjogdGhlIHVzYiBpbnRlcmZhY2UK KyAqCisgKiBXaGlsZSBhIFVTQiBkZXZpY2UgY2Fubm90IHBlcmZvcm0gRE1BIG9wZXJhdGlvbnMg YnkgaXRzZWxmLCBtYW55IFVTQgorICogY29udHJvbGxlcnMgY2FuLiBBIGNhbGwgdG8gdXNiX2lu dGZfZ2V0X2RtYV9kZXZpY2UoKSByZXR1cm5zIHRoZSBETUEgZW5kcG9pbnQKKyAqIGZvciB0aGUg Z2l2ZW4gVVNCIGludGVyZmFjZSwgaWYgYW55LiBUaGUgcmV0dXJuZWQgZGV2aWNlIHN0cnVjdHVy ZSBtdXN0IGJlCisgKiByZWxlYXNlZCB3aXRoIHB1dF9kZXZpY2UoKS4KKyAqCisgKiBTZWUgYWxz byB1c2JfZ2V0X2RtYV9kZXZpY2UoKS4KKyAqCisgKiBSZXR1cm5zOiBBIHJlZmVyZW5jZSB0byB0 aGUgdXNiIGludGVyZmFjZSdzIERNQSBlbmRwb2ludDsgb3IgTlVMTCBpZiBub25lCisgKiAgICAg ICAgICBleGlzdHMuCisgKi8KK3N0cnVjdCBkZXZpY2UgKnVzYl9pbnRmX2dldF9kbWFfZGV2aWNl KHN0cnVjdCB1c2JfaW50ZXJmYWNlICppbnRmKQoreworCXN0cnVjdCB1c2JfZGV2aWNlICp1ZGV2 ID0gaW50ZXJmYWNlX3RvX3VzYmRldihpbnRmKTsKKwlzdHJ1Y3QgZGV2aWNlICpkbWFkZXY7CisK KwlpZiAoIXVkZXYtPmJ1cykKKwkJcmV0dXJuIE5VTEw7CisKKwlkbWFkZXYgPSBnZXRfZGV2aWNl KHVkZXYtPmJ1cy0+c3lzZGV2KTsKKwlpZiAoIWRtYWRldiB8fCAhZG1hZGV2LT5kbWFfbWFzaykg eworCQlwdXRfZGV2aWNlKGRtYWRldik7CisJCXJldHVybiBOVUxMOworCX0KKworCXJldHVybiBk bWFkZXY7Cit9CitFWFBPUlRfU1lNQk9MX0dQTCh1c2JfaW50Zl9nZXRfZG1hX2RldmljZSk7CisK IC8qCQkJVVNCIGRldmljZSBsb2NraW5nCiAgKgogICogVVNCIGRldmljZXMgYW5kIGludGVyZmFj ZXMgYXJlIGxvY2tlZCB1c2luZyB0aGUgc2VtYXBob3JlIGluIHRoZWlyCmRpZmYgLS1naXQgYS9p bmNsdWRlL2xpbnV4L3VzYi5oIGIvaW5jbHVkZS9saW51eC91c2IuaAppbmRleCA3ZDcyYzRlMDcx M2MuLmQ2YTQxODQxYjkzZSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC91c2IuaAorKysgYi9p bmNsdWRlL2xpbnV4L3VzYi5oCkBAIC03NDYsNiArNzQ2LDggQEAgZXh0ZXJuIGludCB1c2JfbG9j a19kZXZpY2VfZm9yX3Jlc2V0KHN0cnVjdCB1c2JfZGV2aWNlICp1ZGV2LAogZXh0ZXJuIGludCB1 c2JfcmVzZXRfZGV2aWNlKHN0cnVjdCB1c2JfZGV2aWNlICpkZXYpOwogZXh0ZXJuIHZvaWQgdXNi X3F1ZXVlX3Jlc2V0X2RldmljZShzdHJ1Y3QgdXNiX2ludGVyZmFjZSAqZGV2KTsKIAorZXh0ZXJu IHN0cnVjdCBkZXZpY2UgKnVzYl9pbnRmX2dldF9kbWFfZGV2aWNlKHN0cnVjdCB1c2JfaW50ZXJm YWNlICppbnRmKTsKKwogI2lmZGVmIENPTkZJR19BQ1BJCiBleHRlcm4gaW50IHVzYl9hY3BpX3Nl dF9wb3dlcl9zdGF0ZShzdHJ1Y3QgdXNiX2RldmljZSAqaGRldiwgaW50IGluZGV4LAogCWJvb2wg ZW5hYmxlKTsKCmJhc2UtY29tbWl0OiBiODAxODJiOWJmZmI1MTQ2MGU0YTJhZDdkOTY3MzdlY2Q0 OTEyNmRjCnByZXJlcXVpc2l0ZS1wYXRjaC1pZDogYzJiMmYwOGYwZWNjYzlmNWRmMGMwZGE0OWZh MWQzNjI2N2RlYjExZAotLSAKMi4zMC4xCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1kZXZlbEBsaXN0cy5m cmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0 aW5mby9kcmktZGV2ZWwK