From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S933374AbeCEJNq (ORCPT ); Mon, 5 Mar 2018 04:13:46 -0500 Received: from mail-wm0-f65.google.com ([74.125.82.65]:55766 "EHLO mail-wm0-f65.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S932721AbeCEJNk (ORCPT ); Mon, 5 Mar 2018 04:13:40 -0500 X-Google-Smtp-Source: AG47ELtt3o+SwHuNgs+xbpsvsxr4qYA5DIda9NmIkiK0Z9JWa4L0IqY3FDok0MjVJ5sUoHGxs88UuQ== Date: Mon, 5 Mar 2018 10:13:35 +0100 From: Daniel Vetter To: Oleksandr Andrushchenko Cc: xen-devel@lists.xenproject.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, airlied@linux.ie, daniel.vetter@intel.com, seanpaul@chromium.org, gustavo@padovan.org, jgross@suse.com, boris.ostrovsky@oracle.com, konrad.wilk@oracle.com, Oleksandr Andrushchenko Subject: Re: [PATCH 6/9] drm/xen-front: Introduce DRM/KMS virtual display driver Message-ID: <20180305091335.GH22212@phenom.ffwll.local> Mail-Followup-To: Oleksandr Andrushchenko , xen-devel@lists.xenproject.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, airlied@linux.ie, daniel.vetter@intel.com, seanpaul@chromium.org, gustavo@padovan.org, jgross@suse.com, boris.ostrovsky@oracle.com, konrad.wilk@oracle.com, Oleksandr Andrushchenko References: <1519200222-20623-1-git-send-email-andr2000@gmail.com> <1519200222-20623-7-git-send-email-andr2000@gmail.com> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <1519200222-20623-7-git-send-email-andr2000@gmail.com> X-Operating-System: Linux phenom 4.14.0-3-amd64 User-Agent: Mutt/1.9.3 (2018-01-21) Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Wed, Feb 21, 2018 at 10:03:39AM +0200, Oleksandr Andrushchenko wrote: > From: Oleksandr Andrushchenko > > Implement essential initialization of the display driver: > - introduce required data structures > - handle DRM/KMS driver registration > - perform basic DRM driver initialization > - register driver on backend connection > - remove driver on backend disconnect > - introduce essential callbacks required by DRM/KMS core > - introduce essential callbacks required for frontend operations > > Signed-off-by: Oleksandr Andrushchenko > --- > drivers/gpu/drm/xen/Makefile | 1 + > drivers/gpu/drm/xen/xen_drm_front.c | 169 ++++++++++++++++++++++++- > drivers/gpu/drm/xen/xen_drm_front.h | 24 ++++ > drivers/gpu/drm/xen/xen_drm_front_drv.c | 211 ++++++++++++++++++++++++++++++++ > drivers/gpu/drm/xen/xen_drm_front_drv.h | 60 +++++++++ > 5 files changed, 462 insertions(+), 3 deletions(-) > create mode 100644 drivers/gpu/drm/xen/xen_drm_front_drv.c > create mode 100644 drivers/gpu/drm/xen/xen_drm_front_drv.h > > diff --git a/drivers/gpu/drm/xen/Makefile b/drivers/gpu/drm/xen/Makefile > index f1823cb596c5..d3068202590f 100644 > --- a/drivers/gpu/drm/xen/Makefile > +++ b/drivers/gpu/drm/xen/Makefile > @@ -1,6 +1,7 @@ > # SPDX-License-Identifier: GPL-2.0 > > drm_xen_front-objs := xen_drm_front.o \ > + xen_drm_front_drv.o \ > xen_drm_front_evtchnl.o \ > xen_drm_front_shbuf.o \ > xen_drm_front_cfg.o > diff --git a/drivers/gpu/drm/xen/xen_drm_front.c b/drivers/gpu/drm/xen/xen_drm_front.c > index 0d94ff272da3..8de88e359d5e 100644 > --- a/drivers/gpu/drm/xen/xen_drm_front.c > +++ b/drivers/gpu/drm/xen/xen_drm_front.c > @@ -18,6 +18,8 @@ > > #include > > +#include > + > #include > #include > #include > @@ -25,15 +27,161 @@ > #include > > #include "xen_drm_front.h" > +#include "xen_drm_front_drv.h" > #include "xen_drm_front_evtchnl.h" > #include "xen_drm_front_shbuf.h" > > +static int be_mode_set(struct xen_drm_front_drm_pipeline *pipeline, uint32_t x, > + uint32_t y, uint32_t width, uint32_t height, uint32_t bpp, > + uint64_t fb_cookie) > + > +{ > + return 0; > +} > + > +static int be_dbuf_create_int(struct xen_drm_front_info *front_info, > + uint64_t dbuf_cookie, uint32_t width, uint32_t height, > + uint32_t bpp, uint64_t size, struct page **pages, > + struct sg_table *sgt) > +{ > + return 0; > +} > + > +static int be_dbuf_create_from_sgt(struct xen_drm_front_info *front_info, > + uint64_t dbuf_cookie, uint32_t width, uint32_t height, > + uint32_t bpp, uint64_t size, struct sg_table *sgt) > +{ > + return be_dbuf_create_int(front_info, dbuf_cookie, width, height, > + bpp, size, NULL, sgt); > +} > + > +static int be_dbuf_create_from_pages(struct xen_drm_front_info *front_info, > + uint64_t dbuf_cookie, uint32_t width, uint32_t height, > + uint32_t bpp, uint64_t size, struct page **pages) > +{ > + return be_dbuf_create_int(front_info, dbuf_cookie, width, height, > + bpp, size, pages, NULL); > +} > + > +static int be_dbuf_destroy(struct xen_drm_front_info *front_info, > + uint64_t dbuf_cookie) > +{ > + return 0; > +} > + > +static int be_fb_attach(struct xen_drm_front_info *front_info, > + uint64_t dbuf_cookie, uint64_t fb_cookie, uint32_t width, > + uint32_t height, uint32_t pixel_format) > +{ > + return 0; > +} > + > +static int be_fb_detach(struct xen_drm_front_info *front_info, > + uint64_t fb_cookie) > +{ > + return 0; > +} > + > +static int be_page_flip(struct xen_drm_front_info *front_info, int conn_idx, > + uint64_t fb_cookie) > +{ > + return 0; > +} > + > +static void xen_drm_drv_unload(struct xen_drm_front_info *front_info) > +{ > + if (front_info->xb_dev->state != XenbusStateReconfiguring) > + return; > + > + DRM_DEBUG("Can try removing driver now\n"); > + xenbus_switch_state(front_info->xb_dev, XenbusStateInitialising); > +} > + > static struct xen_drm_front_ops front_ops = { > - /* placeholder for now */ > + .mode_set = be_mode_set, > + .dbuf_create_from_pages = be_dbuf_create_from_pages, > + .dbuf_create_from_sgt = be_dbuf_create_from_sgt, > + .dbuf_destroy = be_dbuf_destroy, > + .fb_attach = be_fb_attach, > + .fb_detach = be_fb_detach, > + .page_flip = be_page_flip, > + .drm_last_close = xen_drm_drv_unload, > +}; This looks like a midlayer/DRM-abstraction in your driver. Please remove, and instead directly hook your xen-front code into the relevant drm callbacks. In general also pls make sure you don't implement dummy callbacks that do nothing, we've tried really hard to make them all optional in the drm infrastructure. -Daniel > + > +static int xen_drm_drv_probe(struct platform_device *pdev) > +{ > + /* > + * The device is not spawn from a device tree, so arch_setup_dma_ops > + * is not called, thus leaving the device with dummy DMA ops. > + * This makes the device return error on PRIME buffer import, which > + * is not correct: to fix this call of_dma_configure() with a NULL > + * node to set default DMA ops. > + */ > + of_dma_configure(&pdev->dev, NULL); > + return xen_drm_front_drv_probe(pdev, &front_ops); > +} > + > +static int xen_drm_drv_remove(struct platform_device *pdev) > +{ > + return xen_drm_front_drv_remove(pdev); > +} > + > +struct platform_device_info xen_drm_front_platform_info = { > + .name = XENDISPL_DRIVER_NAME, > + .id = 0, > + .num_res = 0, > + .dma_mask = DMA_BIT_MASK(32), > }; > > +static struct platform_driver xen_drm_front_front_info = { > + .probe = xen_drm_drv_probe, > + .remove = xen_drm_drv_remove, > + .driver = { > + .name = XENDISPL_DRIVER_NAME, > + }, > +}; > + > +static void xen_drm_drv_deinit(struct xen_drm_front_info *front_info) > +{ > + if (!front_info->drm_pdrv_registered) > + return; > + > + if (front_info->drm_pdev) > + platform_device_unregister(front_info->drm_pdev); > + > + platform_driver_unregister(&xen_drm_front_front_info); > + front_info->drm_pdrv_registered = false; > + front_info->drm_pdev = NULL; > +} > + > +static int xen_drm_drv_init(struct xen_drm_front_info *front_info) > +{ > + int ret; > + > + ret = platform_driver_register(&xen_drm_front_front_info); > + if (ret < 0) > + return ret; > + > + front_info->drm_pdrv_registered = true; > + /* pass card configuration via platform data */ > + xen_drm_front_platform_info.data = &front_info->cfg; > + xen_drm_front_platform_info.size_data = sizeof(front_info->cfg); > + > + front_info->drm_pdev = platform_device_register_full( > + &xen_drm_front_platform_info); > + if (IS_ERR_OR_NULL(front_info->drm_pdev)) { > + DRM_ERROR("Failed to register " XENDISPL_DRIVER_NAME " PV DRM driver\n"); > + front_info->drm_pdev = NULL; > + xen_drm_drv_deinit(front_info); > + return -ENODEV; > + } > + > + return 0; > +} > + > static void xen_drv_remove_internal(struct xen_drm_front_info *front_info) > { > + xen_drm_drv_deinit(front_info); > xen_drm_front_evtchnl_free_all(front_info); > } > > @@ -59,13 +207,27 @@ static int backend_on_initwait(struct xen_drm_front_info *front_info) > static int backend_on_connected(struct xen_drm_front_info *front_info) > { > xen_drm_front_evtchnl_set_state(front_info, EVTCHNL_STATE_CONNECTED); > - return 0; > + return xen_drm_drv_init(front_info); > } > > static void backend_on_disconnected(struct xen_drm_front_info *front_info) > { > + bool removed = true; > + > + if (front_info->drm_pdev) { > + if (xen_drm_front_drv_is_used(front_info->drm_pdev)) { > + DRM_WARN("DRM driver still in use, deferring removal\n"); > + removed = false; > + } else > + xen_drv_remove_internal(front_info); > + } > + > xen_drm_front_evtchnl_set_state(front_info, EVTCHNL_STATE_DISCONNECTED); > - xenbus_switch_state(front_info->xb_dev, XenbusStateInitialising); > + > + if (removed) > + xenbus_switch_state(front_info->xb_dev, XenbusStateInitialising); > + else > + xenbus_switch_state(front_info->xb_dev, XenbusStateReconfiguring); > } > > static void backend_on_changed(struct xenbus_device *xb_dev, > @@ -148,6 +310,7 @@ static int xen_drv_probe(struct xenbus_device *xb_dev, > > front_info->xb_dev = xb_dev; > spin_lock_init(&front_info->io_lock); > + front_info->drm_pdrv_registered = false; > dev_set_drvdata(&xb_dev->dev, front_info); > return xenbus_switch_state(xb_dev, XenbusStateInitialising); > } > diff --git a/drivers/gpu/drm/xen/xen_drm_front.h b/drivers/gpu/drm/xen/xen_drm_front.h > index 13f22736ae02..9ed5bfb248d0 100644 > --- a/drivers/gpu/drm/xen/xen_drm_front.h > +++ b/drivers/gpu/drm/xen/xen_drm_front.h > @@ -19,6 +19,8 @@ > #ifndef __XEN_DRM_FRONT_H_ > #define __XEN_DRM_FRONT_H_ > > +#include > + > #include "xen_drm_front_cfg.h" > > #ifndef GRANT_INVALID_REF > @@ -30,16 +32,38 @@ > #define GRANT_INVALID_REF 0 > #endif > > +struct xen_drm_front_drm_pipeline; > + > struct xen_drm_front_ops { > + int (*mode_set)(struct xen_drm_front_drm_pipeline *pipeline, > + uint32_t x, uint32_t y, uint32_t width, uint32_t height, > + uint32_t bpp, uint64_t fb_cookie); > + int (*dbuf_create_from_pages)(struct xen_drm_front_info *front_info, > + uint64_t dbuf_cookie, uint32_t width, uint32_t height, > + uint32_t bpp, uint64_t size, struct page **pages); > + int (*dbuf_create_from_sgt)(struct xen_drm_front_info *front_info, > + uint64_t dbuf_cookie, uint32_t width, uint32_t height, > + uint32_t bpp, uint64_t size, struct sg_table *sgt); > + int (*dbuf_destroy)(struct xen_drm_front_info *front_info, > + uint64_t dbuf_cookie); > + int (*fb_attach)(struct xen_drm_front_info *front_info, > + uint64_t dbuf_cookie, uint64_t fb_cookie, > + uint32_t width, uint32_t height, uint32_t pixel_format); > + int (*fb_detach)(struct xen_drm_front_info *front_info, > + uint64_t fb_cookie); > + int (*page_flip)(struct xen_drm_front_info *front_info, > + int conn_idx, uint64_t fb_cookie); > /* CAUTION! this is called with a spin_lock held! */ > void (*on_frame_done)(struct platform_device *pdev, > int conn_idx, uint64_t fb_cookie); > + void (*drm_last_close)(struct xen_drm_front_info *front_info); > }; > > struct xen_drm_front_info { > struct xenbus_device *xb_dev; > /* to protect data between backend IO code and interrupt handler */ > spinlock_t io_lock; > + bool drm_pdrv_registered; > /* virtual DRM platform device */ > struct platform_device *drm_pdev; > > diff --git a/drivers/gpu/drm/xen/xen_drm_front_drv.c b/drivers/gpu/drm/xen/xen_drm_front_drv.c > new file mode 100644 > index 000000000000..b3764d5ed0f6 > --- /dev/null > +++ b/drivers/gpu/drm/xen/xen_drm_front_drv.c > @@ -0,0 +1,211 @@ > +/* > + * Xen para-virtual DRM device > + * > + * This program is free software; you can redistribute it and/or modify > + * it under the terms of the GNU General Public License as published by > + * the Free Software Foundation; either version 2 of the License, or > + * (at your option) any later version. > + * > + * This program is distributed in the hope that it will be useful, > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > + * GNU General Public License for more details. > + * > + * Copyright (C) 2016-2018 EPAM Systems Inc. > + * > + * Author: Oleksandr Andrushchenko > + */ > + > +#include > +#include > +#include > + > +#include "xen_drm_front.h" > +#include "xen_drm_front_cfg.h" > +#include "xen_drm_front_drv.h" > + > +static int dumb_create(struct drm_file *filp, > + struct drm_device *dev, struct drm_mode_create_dumb *args) > +{ > + return -EINVAL; > +} > + > +static void free_object(struct drm_gem_object *obj) > +{ > + struct xen_drm_front_drm_info *drm_info = obj->dev->dev_private; > + > + drm_info->front_ops->dbuf_destroy(drm_info->front_info, > + xen_drm_front_dbuf_to_cookie(obj)); > +} > + > +static void on_frame_done(struct platform_device *pdev, > + int conn_idx, uint64_t fb_cookie) > +{ > +} > + > +static void lastclose(struct drm_device *dev) > +{ > + struct xen_drm_front_drm_info *drm_info = dev->dev_private; > + > + drm_info->front_ops->drm_last_close(drm_info->front_info); > +} > + > +static int gem_mmap(struct file *filp, struct vm_area_struct *vma) > +{ > + return -EINVAL; > +} > + > +static struct sg_table *prime_get_sg_table(struct drm_gem_object *obj) > +{ > + return NULL; > +} > + > +static struct drm_gem_object *prime_import_sg_table(struct drm_device *dev, > + struct dma_buf_attachment *attach, struct sg_table *sgt) > +{ > + return NULL; > +} > + > +static void *prime_vmap(struct drm_gem_object *obj) > +{ > + return NULL; > +} > + > +static void prime_vunmap(struct drm_gem_object *obj, void *vaddr) > +{ > +} > + > +static int prime_mmap(struct drm_gem_object *obj, struct vm_area_struct *vma) > +{ > + return -EINVAL; > +} > + > +static const struct file_operations xendrm_fops = { > + .owner = THIS_MODULE, > + .open = drm_open, > + .release = drm_release, > + .unlocked_ioctl = drm_ioctl, > +#ifdef CONFIG_COMPAT > + .compat_ioctl = drm_compat_ioctl, > +#endif > + .poll = drm_poll, > + .read = drm_read, > + .llseek = no_llseek, > + .mmap = gem_mmap, > +}; > + > +static const struct vm_operations_struct xen_drm_vm_ops = { > + .open = drm_gem_vm_open, > + .close = drm_gem_vm_close, > +}; > + > +struct drm_driver xen_drm_driver = { > + .driver_features = DRIVER_GEM | DRIVER_MODESET | > + DRIVER_PRIME | DRIVER_ATOMIC, > + .lastclose = lastclose, > + .gem_free_object_unlocked = free_object, > + .gem_vm_ops = &xen_drm_vm_ops, > + .prime_handle_to_fd = drm_gem_prime_handle_to_fd, > + .prime_fd_to_handle = drm_gem_prime_fd_to_handle, > + .gem_prime_import = drm_gem_prime_import, > + .gem_prime_export = drm_gem_prime_export, > + .gem_prime_get_sg_table = prime_get_sg_table, > + .gem_prime_import_sg_table = prime_import_sg_table, > + .gem_prime_vmap = prime_vmap, > + .gem_prime_vunmap = prime_vunmap, > + .gem_prime_mmap = prime_mmap, > + .dumb_create = dumb_create, > + .fops = &xendrm_fops, > + .name = "xendrm-du", > + .desc = "Xen PV DRM Display Unit", > + .date = "20161109", > + .major = 1, > + .minor = 0, > +}; > + > +int xen_drm_front_drv_probe(struct platform_device *pdev, > + struct xen_drm_front_ops *front_ops) > +{ > + struct xen_drm_front_cfg *cfg = dev_get_platdata(&pdev->dev); > + struct xen_drm_front_drm_info *drm_info; > + struct drm_device *dev; > + int ret; > + > + DRM_INFO("Creating %s\n", xen_drm_driver.desc); > + > + drm_info = devm_kzalloc(&pdev->dev, sizeof(*drm_info), GFP_KERNEL); > + if (!drm_info) > + return -ENOMEM; > + > + drm_info->front_ops = front_ops; > + drm_info->front_ops->on_frame_done = on_frame_done; > + drm_info->front_info = cfg->front_info; > + > + dev = drm_dev_alloc(&xen_drm_driver, &pdev->dev); > + if (!dev) > + return -ENOMEM; > + > + drm_info->drm_dev = dev; > + > + drm_info->cfg = cfg; > + dev->dev_private = drm_info; > + platform_set_drvdata(pdev, drm_info); > + > + ret = drm_vblank_init(dev, cfg->num_connectors); > + if (ret) { > + DRM_ERROR("Failed to initialize vblank, ret %d\n", ret); > + return ret; > + } > + > + dev->irq_enabled = 1; > + > + ret = drm_dev_register(dev, 0); > + if (ret) > + goto fail_register; > + > + DRM_INFO("Initialized %s %d.%d.%d %s on minor %d\n", > + xen_drm_driver.name, xen_drm_driver.major, > + xen_drm_driver.minor, xen_drm_driver.patchlevel, > + xen_drm_driver.date, dev->primary->index); > + > + return 0; > + > +fail_register: > + drm_dev_unregister(dev); > + drm_mode_config_cleanup(dev); > + return ret; > +} > + > +int xen_drm_front_drv_remove(struct platform_device *pdev) > +{ > + struct xen_drm_front_drm_info *drm_info = platform_get_drvdata(pdev); > + struct drm_device *dev = drm_info->drm_dev; > + > + if (dev) { > + drm_dev_unregister(dev); > + drm_atomic_helper_shutdown(dev); > + drm_mode_config_cleanup(dev); > + drm_dev_unref(dev); > + } > + return 0; > +} > + > +bool xen_drm_front_drv_is_used(struct platform_device *pdev) > +{ > + struct xen_drm_front_drm_info *drm_info = platform_get_drvdata(pdev); > + struct drm_device *dev; > + > + if (!drm_info) > + return false; > + > + dev = drm_info->drm_dev; > + if (!dev) > + return false; > + > + /* > + * FIXME: the code below must be protected by drm_global_mutex, > + * but it is not accessible to us. Anyways there is a race condition, > + * but we will re-try. > + */ > + return dev->open_count != 0; > +} > diff --git a/drivers/gpu/drm/xen/xen_drm_front_drv.h b/drivers/gpu/drm/xen/xen_drm_front_drv.h > new file mode 100644 > index 000000000000..aaa476535c13 > --- /dev/null > +++ b/drivers/gpu/drm/xen/xen_drm_front_drv.h > @@ -0,0 +1,60 @@ > +/* > + * Xen para-virtual DRM device > + * > + * This program is free software; you can redistribute it and/or modify > + * it under the terms of the GNU General Public License as published by > + * the Free Software Foundation; either version 2 of the License, or > + * (at your option) any later version. > + * > + * This program is distributed in the hope that it will be useful, > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > + * GNU General Public License for more details. > + * > + * Copyright (C) 2016-2018 EPAM Systems Inc. > + * > + * Author: Oleksandr Andrushchenko > + */ > + > +#ifndef __XEN_DRM_FRONT_DRV_H_ > +#define __XEN_DRM_FRONT_DRV_H_ > + > +#include > + > +#include "xen_drm_front.h" > +#include "xen_drm_front_cfg.h" > + > +struct xen_drm_front_drm_pipeline { > + struct xen_drm_front_drm_info *drm_info; > + > + int index; > +}; > + > +struct xen_drm_front_drm_info { > + struct xen_drm_front_info *front_info; > + struct xen_drm_front_ops *front_ops; > + struct drm_device *drm_dev; > + struct xen_drm_front_cfg *cfg; > +}; > + > +static inline uint64_t xen_drm_front_fb_to_cookie( > + struct drm_framebuffer *fb) > +{ > + return (uint64_t)fb; > +} > + > +static inline uint64_t xen_drm_front_dbuf_to_cookie( > + struct drm_gem_object *gem_obj) > +{ > + return (uint64_t)gem_obj; > +} > + > +int xen_drm_front_drv_probe(struct platform_device *pdev, > + struct xen_drm_front_ops *front_ops); > + > +int xen_drm_front_drv_remove(struct platform_device *pdev); > + > +bool xen_drm_front_drv_is_used(struct platform_device *pdev); > + > +#endif /* __XEN_DRM_FRONT_DRV_H_ */ > + > -- > 2.7.4 > > _______________________________________________ > dri-devel mailing list > dri-devel@lists.freedesktop.org > https://lists.freedesktop.org/mailman/listinfo/dri-devel -- Daniel Vetter Software Engineer, Intel Corporation http://blog.ffwll.ch From mboxrd@z Thu Jan 1 00:00:00 1970 From: Daniel Vetter Subject: Re: [PATCH 6/9] drm/xen-front: Introduce DRM/KMS virtual display driver Date: Mon, 5 Mar 2018 10:13:35 +0100 Message-ID: <20180305091335.GH22212@phenom.ffwll.local> References: <1519200222-20623-1-git-send-email-andr2000@gmail.com> <1519200222-20623-7-git-send-email-andr2000@gmail.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail-wm0-x244.google.com (mail-wm0-x244.google.com [IPv6:2a00:1450:400c:c09::244]) by gabe.freedesktop.org (Postfix) with ESMTPS id 75EC76E3E4 for ; Mon, 5 Mar 2018 09:13:40 +0000 (UTC) Received: by mail-wm0-x244.google.com with SMTP id h21so14275770wmd.1 for ; Mon, 05 Mar 2018 01:13:40 -0800 (PST) Content-Disposition: inline In-Reply-To: <1519200222-20623-7-git-send-email-andr2000@gmail.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Oleksandr Andrushchenko Cc: jgross@suse.com, konrad.wilk@oracle.com, airlied@linux.ie, Oleksandr Andrushchenko , linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, daniel.vetter@intel.com, xen-devel@lists.xenproject.org, boris.ostrovsky@oracle.com List-Id: dri-devel@lists.freedesktop.org T24gV2VkLCBGZWIgMjEsIDIwMTggYXQgMTA6MDM6MzlBTSArMDIwMCwgT2xla3NhbmRyIEFuZHJ1 c2hjaGVua28gd3JvdGU6Cj4gRnJvbTogT2xla3NhbmRyIEFuZHJ1c2hjaGVua28gPG9sZWtzYW5k cl9hbmRydXNoY2hlbmtvQGVwYW0uY29tPgo+IAo+IEltcGxlbWVudCBlc3NlbnRpYWwgaW5pdGlh bGl6YXRpb24gb2YgdGhlIGRpc3BsYXkgZHJpdmVyOgo+ICAgLSBpbnRyb2R1Y2UgcmVxdWlyZWQg ZGF0YSBzdHJ1Y3R1cmVzCj4gICAtIGhhbmRsZSBEUk0vS01TIGRyaXZlciByZWdpc3RyYXRpb24K PiAgIC0gcGVyZm9ybSBiYXNpYyBEUk0gZHJpdmVyIGluaXRpYWxpemF0aW9uCj4gICAtIHJlZ2lz dGVyIGRyaXZlciBvbiBiYWNrZW5kIGNvbm5lY3Rpb24KPiAgIC0gcmVtb3ZlIGRyaXZlciBvbiBi YWNrZW5kIGRpc2Nvbm5lY3QKPiAgIC0gaW50cm9kdWNlIGVzc2VudGlhbCBjYWxsYmFja3MgcmVx dWlyZWQgYnkgRFJNL0tNUyBjb3JlCj4gICAtIGludHJvZHVjZSBlc3NlbnRpYWwgY2FsbGJhY2tz IHJlcXVpcmVkIGZvciBmcm9udGVuZCBvcGVyYXRpb25zCj4gCj4gU2lnbmVkLW9mZi1ieTogT2xl a3NhbmRyIEFuZHJ1c2hjaGVua28gPG9sZWtzYW5kcl9hbmRydXNoY2hlbmtvQGVwYW0uY29tPgo+ IC0tLQo+ICBkcml2ZXJzL2dwdS9kcm0veGVuL01ha2VmaWxlICAgICAgICAgICAgfCAgIDEgKwo+ ICBkcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnQuYyAgICAgfCAxNjkgKysrKysrKysr KysrKysrKysrKysrKysrLQo+ICBkcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnQuaCAg ICAgfCAgMjQgKysrKwo+ICBkcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfZHJ2LmMg fCAyMTEgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysKPiAgZHJpdmVycy9ncHUvZHJt L3hlbi94ZW5fZHJtX2Zyb250X2Rydi5oIHwgIDYwICsrKysrKysrKwo+ICA1IGZpbGVzIGNoYW5n ZWQsIDQ2MiBpbnNlcnRpb25zKCspLCAzIGRlbGV0aW9ucygtKQo+ICBjcmVhdGUgbW9kZSAxMDA2 NDQgZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2Rydi5jCj4gIGNyZWF0ZSBtb2Rl IDEwMDY0NCBkcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfZHJ2LmgKPiAKPiBkaWZm IC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3hlbi9NYWtlZmlsZSBiL2RyaXZlcnMvZ3B1L2RybS94 ZW4vTWFrZWZpbGUKPiBpbmRleCBmMTgyM2NiNTk2YzUuLmQzMDY4MjAyNTkwZiAxMDA2NDQKPiAt LS0gYS9kcml2ZXJzL2dwdS9kcm0veGVuL01ha2VmaWxlCj4gKysrIGIvZHJpdmVycy9ncHUvZHJt L3hlbi9NYWtlZmlsZQo+IEBAIC0xLDYgKzEsNyBAQAo+ICAjIFNQRFgtTGljZW5zZS1JZGVudGlm aWVyOiBHUEwtMi4wCj4gIAo+ICBkcm1feGVuX2Zyb250LW9ianMgOj0geGVuX2RybV9mcm9udC5v IFwKPiArCQkgICAgICB4ZW5fZHJtX2Zyb250X2Rydi5vIFwKPiAgCQkgICAgICB4ZW5fZHJtX2Zy b250X2V2dGNobmwubyBcCj4gIAkJICAgICAgeGVuX2RybV9mcm9udF9zaGJ1Zi5vIFwKPiAgCQkg ICAgICB4ZW5fZHJtX2Zyb250X2NmZy5vCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS94 ZW4veGVuX2RybV9mcm9udC5jIGIvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250LmMK PiBpbmRleCAwZDk0ZmYyNzJkYTMuLjhkZTg4ZTM1OWQ1ZSAxMDA2NDQKPiAtLS0gYS9kcml2ZXJz L2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnQuYwo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS94ZW4v eGVuX2RybV9mcm9udC5jCj4gQEAgLTE4LDYgKzE4LDggQEAKPiAgCj4gICNpbmNsdWRlIDxkcm0v ZHJtUC5oPgo+ICAKPiArI2luY2x1ZGUgPGxpbnV4L29mX2RldmljZS5oPgo+ICsKPiAgI2luY2x1 ZGUgPHhlbi9wbGF0Zm9ybV9wY2kuaD4KPiAgI2luY2x1ZGUgPHhlbi94ZW4uaD4KPiAgI2luY2x1 ZGUgPHhlbi94ZW5idXMuaD4KPiBAQCAtMjUsMTUgKzI3LDE2MSBAQAo+ICAjaW5jbHVkZSA8eGVu L2ludGVyZmFjZS9pby9kaXNwbGlmLmg+Cj4gIAo+ICAjaW5jbHVkZSAieGVuX2RybV9mcm9udC5o Igo+ICsjaW5jbHVkZSAieGVuX2RybV9mcm9udF9kcnYuaCIKPiAgI2luY2x1ZGUgInhlbl9kcm1f ZnJvbnRfZXZ0Y2hubC5oIgo+ICAjaW5jbHVkZSAieGVuX2RybV9mcm9udF9zaGJ1Zi5oIgo+ICAK PiArc3RhdGljIGludCBiZV9tb2RlX3NldChzdHJ1Y3QgeGVuX2RybV9mcm9udF9kcm1fcGlwZWxp bmUgKnBpcGVsaW5lLCB1aW50MzJfdCB4LAo+ICsJCXVpbnQzMl90IHksIHVpbnQzMl90IHdpZHRo LCB1aW50MzJfdCBoZWlnaHQsIHVpbnQzMl90IGJwcCwKPiArCQl1aW50NjRfdCBmYl9jb29raWUp Cj4gKwo+ICt7Cj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiArc3RhdGljIGludCBiZV9kYnVmX2Ny ZWF0ZV9pbnQoc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbywKPiArCQl1aW50 NjRfdCBkYnVmX2Nvb2tpZSwgdWludDMyX3Qgd2lkdGgsIHVpbnQzMl90IGhlaWdodCwKPiArCQl1 aW50MzJfdCBicHAsIHVpbnQ2NF90IHNpemUsIHN0cnVjdCBwYWdlICoqcGFnZXMsCj4gKwkJc3Ry dWN0IHNnX3RhYmxlICpzZ3QpCj4gK3sKPiArCXJldHVybiAwOwo+ICt9Cj4gKwo+ICtzdGF0aWMg aW50IGJlX2RidWZfY3JlYXRlX2Zyb21fc2d0KHN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZy b250X2luZm8sCj4gKwkJdWludDY0X3QgZGJ1Zl9jb29raWUsIHVpbnQzMl90IHdpZHRoLCB1aW50 MzJfdCBoZWlnaHQsCj4gKwkJdWludDMyX3QgYnBwLCB1aW50NjRfdCBzaXplLCBzdHJ1Y3Qgc2df dGFibGUgKnNndCkKPiArewo+ICsJcmV0dXJuIGJlX2RidWZfY3JlYXRlX2ludChmcm9udF9pbmZv LCBkYnVmX2Nvb2tpZSwgd2lkdGgsIGhlaWdodCwKPiArCQkJYnBwLCBzaXplLCBOVUxMLCBzZ3Qp Owo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IGJlX2RidWZfY3JlYXRlX2Zyb21fcGFnZXMoc3RydWN0 IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbywKPiArCQl1aW50NjRfdCBkYnVmX2Nvb2tp ZSwgdWludDMyX3Qgd2lkdGgsIHVpbnQzMl90IGhlaWdodCwKPiArCQl1aW50MzJfdCBicHAsIHVp bnQ2NF90IHNpemUsIHN0cnVjdCBwYWdlICoqcGFnZXMpCj4gK3sKPiArCXJldHVybiBiZV9kYnVm X2NyZWF0ZV9pbnQoZnJvbnRfaW5mbywgZGJ1Zl9jb29raWUsIHdpZHRoLCBoZWlnaHQsCj4gKwkJ CWJwcCwgc2l6ZSwgcGFnZXMsIE5VTEwpOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IGJlX2RidWZf ZGVzdHJveShzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvICpmcm9udF9pbmZvLAo+ICsJCXVpbnQ2 NF90IGRidWZfY29va2llKQo+ICt7Cj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiArc3RhdGljIGlu dCBiZV9mYl9hdHRhY2goc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbywKPiAr CQl1aW50NjRfdCBkYnVmX2Nvb2tpZSwgdWludDY0X3QgZmJfY29va2llLCB1aW50MzJfdCB3aWR0 aCwKPiArCQl1aW50MzJfdCBoZWlnaHQsIHVpbnQzMl90IHBpeGVsX2Zvcm1hdCkKPiArewo+ICsJ cmV0dXJuIDA7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgYmVfZmJfZGV0YWNoKHN0cnVjdCB4ZW5f ZHJtX2Zyb250X2luZm8gKmZyb250X2luZm8sCj4gKwkJdWludDY0X3QgZmJfY29va2llKQo+ICt7 Cj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiArc3RhdGljIGludCBiZV9wYWdlX2ZsaXAoc3RydWN0 IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbywgaW50IGNvbm5faWR4LAo+ICsJCXVpbnQ2 NF90IGZiX2Nvb2tpZSkKPiArewo+ICsJcmV0dXJuIDA7Cj4gK30KPiArCj4gK3N0YXRpYyB2b2lk IHhlbl9kcm1fZHJ2X3VubG9hZChzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvICpmcm9udF9pbmZv KQo+ICt7Cj4gKwlpZiAoZnJvbnRfaW5mby0+eGJfZGV2LT5zdGF0ZSAhPSBYZW5idXNTdGF0ZVJl Y29uZmlndXJpbmcpCj4gKwkJcmV0dXJuOwo+ICsKPiArCURSTV9ERUJVRygiQ2FuIHRyeSByZW1v dmluZyBkcml2ZXIgbm93XG4iKTsKPiArCXhlbmJ1c19zd2l0Y2hfc3RhdGUoZnJvbnRfaW5mby0+ eGJfZGV2LCBYZW5idXNTdGF0ZUluaXRpYWxpc2luZyk7Cj4gK30KPiArCj4gIHN0YXRpYyBzdHJ1 Y3QgeGVuX2RybV9mcm9udF9vcHMgZnJvbnRfb3BzID0gewo+IC0JLyogcGxhY2Vob2xkZXIgZm9y IG5vdyAqLwo+ICsJLm1vZGVfc2V0ID0gYmVfbW9kZV9zZXQsCj4gKwkuZGJ1Zl9jcmVhdGVfZnJv bV9wYWdlcyA9IGJlX2RidWZfY3JlYXRlX2Zyb21fcGFnZXMsCj4gKwkuZGJ1Zl9jcmVhdGVfZnJv bV9zZ3QgPSBiZV9kYnVmX2NyZWF0ZV9mcm9tX3NndCwKPiArCS5kYnVmX2Rlc3Ryb3kgPSBiZV9k YnVmX2Rlc3Ryb3ksCj4gKwkuZmJfYXR0YWNoID0gYmVfZmJfYXR0YWNoLAo+ICsJLmZiX2RldGFj aCA9IGJlX2ZiX2RldGFjaCwKPiArCS5wYWdlX2ZsaXAgPSBiZV9wYWdlX2ZsaXAsCj4gKwkuZHJt X2xhc3RfY2xvc2UgPSB4ZW5fZHJtX2Rydl91bmxvYWQsCj4gK307CgpUaGlzIGxvb2tzIGxpa2Ug YSBtaWRsYXllci9EUk0tYWJzdHJhY3Rpb24gaW4geW91ciBkcml2ZXIuIFBsZWFzZSByZW1vdmUs CmFuZCBpbnN0ZWFkIGRpcmVjdGx5IGhvb2sgeW91ciB4ZW4tZnJvbnQgY29kZSBpbnRvIHRoZSBy ZWxldmFudCBkcm0KY2FsbGJhY2tzLgoKSW4gZ2VuZXJhbCBhbHNvIHBscyBtYWtlIHN1cmUgeW91 IGRvbid0IGltcGxlbWVudCBkdW1teSBjYWxsYmFja3MgdGhhdCBkbwpub3RoaW5nLCB3ZSd2ZSB0 cmllZCByZWFsbHkgaGFyZCB0byBtYWtlIHRoZW0gYWxsIG9wdGlvbmFsIGluIHRoZSBkcm0KaW5m cmFzdHJ1Y3R1cmUuCi1EYW5pZWwKCj4gKwo+ICtzdGF0aWMgaW50IHhlbl9kcm1fZHJ2X3Byb2Jl KHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCj4gK3sKPiArCS8qCj4gKwkgKiBUaGUgZGV2 aWNlIGlzIG5vdCBzcGF3biBmcm9tIGEgZGV2aWNlIHRyZWUsIHNvIGFyY2hfc2V0dXBfZG1hX29w cwo+ICsJICogaXMgbm90IGNhbGxlZCwgdGh1cyBsZWF2aW5nIHRoZSBkZXZpY2Ugd2l0aCBkdW1t eSBETUEgb3BzLgo+ICsJICogVGhpcyBtYWtlcyB0aGUgZGV2aWNlIHJldHVybiBlcnJvciBvbiBQ UklNRSBidWZmZXIgaW1wb3J0LCB3aGljaAo+ICsJICogaXMgbm90IGNvcnJlY3Q6IHRvIGZpeCB0 aGlzIGNhbGwgb2ZfZG1hX2NvbmZpZ3VyZSgpIHdpdGggYSBOVUxMCj4gKwkgKiBub2RlIHRvIHNl dCBkZWZhdWx0IERNQSBvcHMuCj4gKwkgKi8KPiArCW9mX2RtYV9jb25maWd1cmUoJnBkZXYtPmRl diwgTlVMTCk7Cj4gKwlyZXR1cm4geGVuX2RybV9mcm9udF9kcnZfcHJvYmUocGRldiwgJmZyb250 X29wcyk7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgeGVuX2RybV9kcnZfcmVtb3ZlKHN0cnVjdCBw bGF0Zm9ybV9kZXZpY2UgKnBkZXYpCj4gK3sKPiArCXJldHVybiB4ZW5fZHJtX2Zyb250X2Rydl9y ZW1vdmUocGRldik7Cj4gK30KPiArCj4gK3N0cnVjdCBwbGF0Zm9ybV9kZXZpY2VfaW5mbyB4ZW5f ZHJtX2Zyb250X3BsYXRmb3JtX2luZm8gPSB7Cj4gKwkubmFtZSA9IFhFTkRJU1BMX0RSSVZFUl9O QU1FLAo+ICsJLmlkID0gMCwKPiArCS5udW1fcmVzID0gMCwKPiArCS5kbWFfbWFzayA9IERNQV9C SVRfTUFTSygzMiksCj4gIH07Cj4gIAo+ICtzdGF0aWMgc3RydWN0IHBsYXRmb3JtX2RyaXZlciB4 ZW5fZHJtX2Zyb250X2Zyb250X2luZm8gPSB7Cj4gKwkucHJvYmUJCT0geGVuX2RybV9kcnZfcHJv YmUsCj4gKwkucmVtb3ZlCQk9IHhlbl9kcm1fZHJ2X3JlbW92ZSwKPiArCS5kcml2ZXIJCT0gewo+ ICsJCS5uYW1lCT0gWEVORElTUExfRFJJVkVSX05BTUUsCj4gKwl9LAo+ICt9Owo+ICsKPiArc3Rh dGljIHZvaWQgeGVuX2RybV9kcnZfZGVpbml0KHN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZy b250X2luZm8pCj4gK3sKPiArCWlmICghZnJvbnRfaW5mby0+ZHJtX3BkcnZfcmVnaXN0ZXJlZCkK PiArCQlyZXR1cm47Cj4gKwo+ICsJaWYgKGZyb250X2luZm8tPmRybV9wZGV2KQo+ICsJCXBsYXRm b3JtX2RldmljZV91bnJlZ2lzdGVyKGZyb250X2luZm8tPmRybV9wZGV2KTsKPiArCj4gKwlwbGF0 Zm9ybV9kcml2ZXJfdW5yZWdpc3RlcigmeGVuX2RybV9mcm9udF9mcm9udF9pbmZvKTsKPiArCWZy b250X2luZm8tPmRybV9wZHJ2X3JlZ2lzdGVyZWQgPSBmYWxzZTsKPiArCWZyb250X2luZm8tPmRy bV9wZGV2ID0gTlVMTDsKPiArfQo+ICsKPiArc3RhdGljIGludCB4ZW5fZHJtX2Rydl9pbml0KHN0 cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2luZm8pCj4gK3sKPiArCWludCByZXQ7Cj4g Kwo+ICsJcmV0ID0gcGxhdGZvcm1fZHJpdmVyX3JlZ2lzdGVyKCZ4ZW5fZHJtX2Zyb250X2Zyb250 X2luZm8pOwo+ICsJaWYgKHJldCA8IDApCj4gKwkJcmV0dXJuIHJldDsKPiArCj4gKwlmcm9udF9p bmZvLT5kcm1fcGRydl9yZWdpc3RlcmVkID0gdHJ1ZTsKPiArCS8qIHBhc3MgY2FyZCBjb25maWd1 cmF0aW9uIHZpYSBwbGF0Zm9ybSBkYXRhICovCj4gKwl4ZW5fZHJtX2Zyb250X3BsYXRmb3JtX2lu Zm8uZGF0YSA9ICZmcm9udF9pbmZvLT5jZmc7Cj4gKwl4ZW5fZHJtX2Zyb250X3BsYXRmb3JtX2lu Zm8uc2l6ZV9kYXRhID0gc2l6ZW9mKGZyb250X2luZm8tPmNmZyk7Cj4gKwo+ICsJZnJvbnRfaW5m by0+ZHJtX3BkZXYgPSBwbGF0Zm9ybV9kZXZpY2VfcmVnaXN0ZXJfZnVsbCgKPiArCQkJJnhlbl9k cm1fZnJvbnRfcGxhdGZvcm1faW5mbyk7Cj4gKwlpZiAoSVNfRVJSX09SX05VTEwoZnJvbnRfaW5m by0+ZHJtX3BkZXYpKSB7Cj4gKwkJRFJNX0VSUk9SKCJGYWlsZWQgdG8gcmVnaXN0ZXIgIiBYRU5E SVNQTF9EUklWRVJfTkFNRSAiIFBWIERSTSBkcml2ZXJcbiIpOwo+ICsJCWZyb250X2luZm8tPmRy bV9wZGV2ID0gTlVMTDsKPiArCQl4ZW5fZHJtX2Rydl9kZWluaXQoZnJvbnRfaW5mbyk7Cj4gKwkJ cmV0dXJuIC1FTk9ERVY7Cj4gKwl9Cj4gKwo+ICsJcmV0dXJuIDA7Cj4gK30KPiArCj4gIHN0YXRp YyB2b2lkIHhlbl9kcnZfcmVtb3ZlX2ludGVybmFsKHN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8g KmZyb250X2luZm8pCj4gIHsKPiArCXhlbl9kcm1fZHJ2X2RlaW5pdChmcm9udF9pbmZvKTsKPiAg CXhlbl9kcm1fZnJvbnRfZXZ0Y2hubF9mcmVlX2FsbChmcm9udF9pbmZvKTsKPiAgfQo+ICAKPiBA QCAtNTksMTMgKzIwNywyNyBAQCBzdGF0aWMgaW50IGJhY2tlbmRfb25faW5pdHdhaXQoc3RydWN0 IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbykKPiAgc3RhdGljIGludCBiYWNrZW5kX29u X2Nvbm5lY3RlZChzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvICpmcm9udF9pbmZvKQo+ICB7Cj4g IAl4ZW5fZHJtX2Zyb250X2V2dGNobmxfc2V0X3N0YXRlKGZyb250X2luZm8sIEVWVENITkxfU1RB VEVfQ09OTkVDVEVEKTsKPiAtCXJldHVybiAwOwo+ICsJcmV0dXJuIHhlbl9kcm1fZHJ2X2luaXQo ZnJvbnRfaW5mbyk7Cj4gIH0KPiAgCj4gIHN0YXRpYyB2b2lkIGJhY2tlbmRfb25fZGlzY29ubmVj dGVkKHN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2luZm8pCj4gIHsKPiArCWJvb2wg cmVtb3ZlZCA9IHRydWU7Cj4gKwo+ICsJaWYgKGZyb250X2luZm8tPmRybV9wZGV2KSB7Cj4gKwkJ aWYgKHhlbl9kcm1fZnJvbnRfZHJ2X2lzX3VzZWQoZnJvbnRfaW5mby0+ZHJtX3BkZXYpKSB7Cj4g KwkJCURSTV9XQVJOKCJEUk0gZHJpdmVyIHN0aWxsIGluIHVzZSwgZGVmZXJyaW5nIHJlbW92YWxc biIpOwo+ICsJCQlyZW1vdmVkID0gZmFsc2U7Cj4gKwkJfSBlbHNlCj4gKwkJCXhlbl9kcnZfcmVt b3ZlX2ludGVybmFsKGZyb250X2luZm8pOwo+ICsJfQo+ICsKPiAgCXhlbl9kcm1fZnJvbnRfZXZ0 Y2hubF9zZXRfc3RhdGUoZnJvbnRfaW5mbywgRVZUQ0hOTF9TVEFURV9ESVNDT05ORUNURUQpOwo+ IC0JeGVuYnVzX3N3aXRjaF9zdGF0ZShmcm9udF9pbmZvLT54Yl9kZXYsIFhlbmJ1c1N0YXRlSW5p dGlhbGlzaW5nKTsKPiArCj4gKwlpZiAocmVtb3ZlZCkKPiArCQl4ZW5idXNfc3dpdGNoX3N0YXRl KGZyb250X2luZm8tPnhiX2RldiwgWGVuYnVzU3RhdGVJbml0aWFsaXNpbmcpOwo+ICsJZWxzZQo+ ICsJCXhlbmJ1c19zd2l0Y2hfc3RhdGUoZnJvbnRfaW5mby0+eGJfZGV2LCBYZW5idXNTdGF0ZVJl Y29uZmlndXJpbmcpOwo+ICB9Cj4gIAo+ICBzdGF0aWMgdm9pZCBiYWNrZW5kX29uX2NoYW5nZWQo c3RydWN0IHhlbmJ1c19kZXZpY2UgKnhiX2RldiwKPiBAQCAtMTQ4LDYgKzMxMCw3IEBAIHN0YXRp YyBpbnQgeGVuX2Rydl9wcm9iZShzdHJ1Y3QgeGVuYnVzX2RldmljZSAqeGJfZGV2LAo+ICAKPiAg CWZyb250X2luZm8tPnhiX2RldiA9IHhiX2RldjsKPiAgCXNwaW5fbG9ja19pbml0KCZmcm9udF9p bmZvLT5pb19sb2NrKTsKPiArCWZyb250X2luZm8tPmRybV9wZHJ2X3JlZ2lzdGVyZWQgPSBmYWxz ZTsKPiAgCWRldl9zZXRfZHJ2ZGF0YSgmeGJfZGV2LT5kZXYsIGZyb250X2luZm8pOwo+ICAJcmV0 dXJuIHhlbmJ1c19zd2l0Y2hfc3RhdGUoeGJfZGV2LCBYZW5idXNTdGF0ZUluaXRpYWxpc2luZyk7 Cj4gIH0KPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250Lmgg Yi9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnQuaAo+IGluZGV4IDEzZjIyNzM2YWUw Mi4uOWVkNWJmYjI0OGQwIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2Ry bV9mcm9udC5oCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250LmgKPiBA QCAtMTksNiArMTksOCBAQAo+ICAjaWZuZGVmIF9fWEVOX0RSTV9GUk9OVF9IXwo+ICAjZGVmaW5l IF9fWEVOX0RSTV9GUk9OVF9IXwo+ICAKPiArI2luY2x1ZGUgPGxpbnV4L3NjYXR0ZXJsaXN0Lmg+ Cj4gKwo+ICAjaW5jbHVkZSAieGVuX2RybV9mcm9udF9jZmcuaCIKPiAgCj4gICNpZm5kZWYgR1JB TlRfSU5WQUxJRF9SRUYKPiBAQCAtMzAsMTYgKzMyLDM4IEBACj4gICNkZWZpbmUgR1JBTlRfSU5W QUxJRF9SRUYJMAo+ICAjZW5kaWYKPiAgCj4gK3N0cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9waXBl bGluZTsKPiArCj4gIHN0cnVjdCB4ZW5fZHJtX2Zyb250X29wcyB7Cj4gKwlpbnQgKCptb2RlX3Nl dCkoc3RydWN0IHhlbl9kcm1fZnJvbnRfZHJtX3BpcGVsaW5lICpwaXBlbGluZSwKPiArCQkJdWlu dDMyX3QgeCwgdWludDMyX3QgeSwgdWludDMyX3Qgd2lkdGgsIHVpbnQzMl90IGhlaWdodCwKPiAr CQkJdWludDMyX3QgYnBwLCB1aW50NjRfdCBmYl9jb29raWUpOwo+ICsJaW50ICgqZGJ1Zl9jcmVh dGVfZnJvbV9wYWdlcykoc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbywKPiAr CQkJdWludDY0X3QgZGJ1Zl9jb29raWUsIHVpbnQzMl90IHdpZHRoLCB1aW50MzJfdCBoZWlnaHQs Cj4gKwkJCXVpbnQzMl90IGJwcCwgdWludDY0X3Qgc2l6ZSwgc3RydWN0IHBhZ2UgKipwYWdlcyk7 Cj4gKwlpbnQgKCpkYnVmX2NyZWF0ZV9mcm9tX3NndCkoc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5m byAqZnJvbnRfaW5mbywKPiArCQkJdWludDY0X3QgZGJ1Zl9jb29raWUsIHVpbnQzMl90IHdpZHRo LCB1aW50MzJfdCBoZWlnaHQsCj4gKwkJCXVpbnQzMl90IGJwcCwgdWludDY0X3Qgc2l6ZSwgc3Ry dWN0IHNnX3RhYmxlICpzZ3QpOwo+ICsJaW50ICgqZGJ1Zl9kZXN0cm95KShzdHJ1Y3QgeGVuX2Ry bV9mcm9udF9pbmZvICpmcm9udF9pbmZvLAo+ICsJCQl1aW50NjRfdCBkYnVmX2Nvb2tpZSk7Cj4g KwlpbnQgKCpmYl9hdHRhY2gpKHN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2luZm8s Cj4gKwkJCXVpbnQ2NF90IGRidWZfY29va2llLCB1aW50NjRfdCBmYl9jb29raWUsCj4gKwkJCXVp bnQzMl90IHdpZHRoLCB1aW50MzJfdCBoZWlnaHQsIHVpbnQzMl90IHBpeGVsX2Zvcm1hdCk7Cj4g KwlpbnQgKCpmYl9kZXRhY2gpKHN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2luZm8s Cj4gKwkJCXVpbnQ2NF90IGZiX2Nvb2tpZSk7Cj4gKwlpbnQgKCpwYWdlX2ZsaXApKHN0cnVjdCB4 ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2luZm8sCj4gKwkJCWludCBjb25uX2lkeCwgdWludDY0 X3QgZmJfY29va2llKTsKPiAgCS8qIENBVVRJT04hIHRoaXMgaXMgY2FsbGVkIHdpdGggYSBzcGlu X2xvY2sgaGVsZCEgKi8KPiAgCXZvaWQgKCpvbl9mcmFtZV9kb25lKShzdHJ1Y3QgcGxhdGZvcm1f ZGV2aWNlICpwZGV2LAo+ICAJCQlpbnQgY29ubl9pZHgsIHVpbnQ2NF90IGZiX2Nvb2tpZSk7Cj4g Kwl2b2lkICgqZHJtX2xhc3RfY2xvc2UpKHN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250 X2luZm8pOwo+ICB9Owo+ICAKPiAgc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyB7Cj4gIAlzdHJ1 Y3QgeGVuYnVzX2RldmljZSAqeGJfZGV2Owo+ICAJLyogdG8gcHJvdGVjdCBkYXRhIGJldHdlZW4g YmFja2VuZCBJTyBjb2RlIGFuZCBpbnRlcnJ1cHQgaGFuZGxlciAqLwo+ICAJc3BpbmxvY2tfdCBp b19sb2NrOwo+ICsJYm9vbCBkcm1fcGRydl9yZWdpc3RlcmVkOwo+ICAJLyogdmlydHVhbCBEUk0g cGxhdGZvcm0gZGV2aWNlICovCj4gIAlzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpkcm1fcGRldjsK PiAgCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9kcnYu YyBiL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9kcnYuYwo+IG5ldyBmaWxlIG1v ZGUgMTAwNjQ0Cj4gaW5kZXggMDAwMDAwMDAwMDAwLi5iMzc2NGQ1ZWQwZjYKPiAtLS0gL2Rldi9u dWxsCj4gKysrIGIvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2Rydi5jCj4gQEAg LTAsMCArMSwyMTEgQEAKPiArLyoKPiArICogIFhlbiBwYXJhLXZpcnR1YWwgRFJNIGRldmljZQo+ ICsgKgo+ICsgKiAgIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlz dHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Cj4gKyAqICAgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRo ZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKPiArICogICB0aGUg RnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNl LCBvcgo+ICsgKiAgIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCj4gKyAqCj4g KyAqICAgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2ls bCBiZSB1c2VmdWwsCj4gKyAqICAgYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2 ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKPiArICogICBNRVJDSEFOVEFCSUxJVFkgb3IgRklU TkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCj4gKyAqICAgR05VIEdlbmVy YWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KPiArICoKPiArICogQ29weXJpZ2h0 IChDKSAyMDE2LTIwMTggRVBBTSBTeXN0ZW1zIEluYy4KPiArICoKPiArICogQXV0aG9yOiBPbGVr c2FuZHIgQW5kcnVzaGNoZW5rbyA8b2xla3NhbmRyX2FuZHJ1c2hjaGVua29AZXBhbS5jb20+Cj4g KyAqLwo+ICsKPiArI2luY2x1ZGUgPGRybS9kcm1QLmg+Cj4gKyNpbmNsdWRlIDxkcm0vZHJtX2dl bS5oPgo+ICsjaW5jbHVkZSA8ZHJtL2RybV9hdG9taWNfaGVscGVyLmg+Cj4gKwo+ICsjaW5jbHVk ZSAieGVuX2RybV9mcm9udC5oIgo+ICsjaW5jbHVkZSAieGVuX2RybV9mcm9udF9jZmcuaCIKPiAr I2luY2x1ZGUgInhlbl9kcm1fZnJvbnRfZHJ2LmgiCj4gKwo+ICtzdGF0aWMgaW50IGR1bWJfY3Jl YXRlKHN0cnVjdCBkcm1fZmlsZSAqZmlscCwKPiArCQlzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LCBz dHJ1Y3QgZHJtX21vZGVfY3JlYXRlX2R1bWIgKmFyZ3MpCj4gK3sKPiArCXJldHVybiAtRUlOVkFM Owo+ICt9Cj4gKwo+ICtzdGF0aWMgdm9pZCBmcmVlX29iamVjdChzdHJ1Y3QgZHJtX2dlbV9vYmpl Y3QgKm9iaikKPiArewo+ICsJc3RydWN0IHhlbl9kcm1fZnJvbnRfZHJtX2luZm8gKmRybV9pbmZv ID0gb2JqLT5kZXYtPmRldl9wcml2YXRlOwo+ICsKPiArCWRybV9pbmZvLT5mcm9udF9vcHMtPmRi dWZfZGVzdHJveShkcm1faW5mby0+ZnJvbnRfaW5mbywKPiArCQkJeGVuX2RybV9mcm9udF9kYnVm X3RvX2Nvb2tpZShvYmopKTsKPiArfQo+ICsKPiArc3RhdGljIHZvaWQgb25fZnJhbWVfZG9uZShz dHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2LAo+ICsJCWludCBjb25uX2lkeCwgdWludDY0X3Qg ZmJfY29va2llKQo+ICt7Cj4gK30KPiArCj4gK3N0YXRpYyB2b2lkIGxhc3RjbG9zZShzdHJ1Y3Qg ZHJtX2RldmljZSAqZGV2KQo+ICt7Cj4gKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9kcm1faW5mbyAq ZHJtX2luZm8gPSBkZXYtPmRldl9wcml2YXRlOwo+ICsKPiArCWRybV9pbmZvLT5mcm9udF9vcHMt PmRybV9sYXN0X2Nsb3NlKGRybV9pbmZvLT5mcm9udF9pbmZvKTsKPiArfQo+ICsKPiArc3RhdGlj IGludCBnZW1fbW1hcChzdHJ1Y3QgZmlsZSAqZmlscCwgc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2 bWEpCj4gK3sKPiArCXJldHVybiAtRUlOVkFMOwo+ICt9Cj4gKwo+ICtzdGF0aWMgc3RydWN0IHNn X3RhYmxlICpwcmltZV9nZXRfc2dfdGFibGUoc3RydWN0IGRybV9nZW1fb2JqZWN0ICpvYmopCj4g K3sKPiArCXJldHVybiBOVUxMOwo+ICt9Cj4gKwo+ICtzdGF0aWMgc3RydWN0IGRybV9nZW1fb2Jq ZWN0ICpwcmltZV9pbXBvcnRfc2dfdGFibGUoc3RydWN0IGRybV9kZXZpY2UgKmRldiwKPiArCQlz dHJ1Y3QgZG1hX2J1Zl9hdHRhY2htZW50ICphdHRhY2gsIHN0cnVjdCBzZ190YWJsZSAqc2d0KQo+ ICt7Cj4gKwlyZXR1cm4gTlVMTDsKPiArfQo+ICsKPiArc3RhdGljIHZvaWQgKnByaW1lX3ZtYXAo c3RydWN0IGRybV9nZW1fb2JqZWN0ICpvYmopCj4gK3sKPiArCXJldHVybiBOVUxMOwo+ICt9Cj4g Kwo+ICtzdGF0aWMgdm9pZCBwcmltZV92dW5tYXAoc3RydWN0IGRybV9nZW1fb2JqZWN0ICpvYmos IHZvaWQgKnZhZGRyKQo+ICt7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgcHJpbWVfbW1hcChzdHJ1 Y3QgZHJtX2dlbV9vYmplY3QgKm9iaiwgc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEpCj4gK3sK PiArCXJldHVybiAtRUlOVkFMOwo+ICt9Cj4gKwo+ICtzdGF0aWMgY29uc3Qgc3RydWN0IGZpbGVf b3BlcmF0aW9ucyB4ZW5kcm1fZm9wcyA9IHsKPiArCS5vd25lciAgICAgICAgICA9IFRISVNfTU9E VUxFLAo+ICsJLm9wZW4gICAgICAgICAgID0gZHJtX29wZW4sCj4gKwkucmVsZWFzZSAgICAgICAg PSBkcm1fcmVsZWFzZSwKPiArCS51bmxvY2tlZF9pb2N0bCA9IGRybV9pb2N0bCwKPiArI2lmZGVm IENPTkZJR19DT01QQVQKPiArCS5jb21wYXRfaW9jdGwgICA9IGRybV9jb21wYXRfaW9jdGwsCj4g KyNlbmRpZgo+ICsJLnBvbGwgICAgICAgICAgID0gZHJtX3BvbGwsCj4gKwkucmVhZCAgICAgICAg ICAgPSBkcm1fcmVhZCwKPiArCS5sbHNlZWsgICAgICAgICA9IG5vX2xsc2VlaywKPiArCS5tbWFw ICAgICAgICAgICA9IGdlbV9tbWFwLAo+ICt9Owo+ICsKPiArc3RhdGljIGNvbnN0IHN0cnVjdCB2 bV9vcGVyYXRpb25zX3N0cnVjdCB4ZW5fZHJtX3ZtX29wcyA9IHsKPiArCS5vcGVuICAgICAgICAg ICA9IGRybV9nZW1fdm1fb3BlbiwKPiArCS5jbG9zZSAgICAgICAgICA9IGRybV9nZW1fdm1fY2xv c2UsCj4gK307Cj4gKwo+ICtzdHJ1Y3QgZHJtX2RyaXZlciB4ZW5fZHJtX2RyaXZlciA9IHsKPiAr CS5kcml2ZXJfZmVhdHVyZXMgICAgICAgICAgID0gRFJJVkVSX0dFTSB8IERSSVZFUl9NT0RFU0VU IHwKPiArCQkJCSAgICAgRFJJVkVSX1BSSU1FIHwgRFJJVkVSX0FUT01JQywKPiArCS5sYXN0Y2xv c2UgICAgICAgICAgICAgICAgID0gbGFzdGNsb3NlLAo+ICsJLmdlbV9mcmVlX29iamVjdF91bmxv Y2tlZCAgPSBmcmVlX29iamVjdCwKPiArCS5nZW1fdm1fb3BzICAgICAgICAgICAgICAgID0gJnhl bl9kcm1fdm1fb3BzLAo+ICsJLnByaW1lX2hhbmRsZV90b19mZCAgICAgICAgPSBkcm1fZ2VtX3By aW1lX2hhbmRsZV90b19mZCwKPiArCS5wcmltZV9mZF90b19oYW5kbGUgICAgICAgID0gZHJtX2dl bV9wcmltZV9mZF90b19oYW5kbGUsCj4gKwkuZ2VtX3ByaW1lX2ltcG9ydCAgICAgICAgICA9IGRy bV9nZW1fcHJpbWVfaW1wb3J0LAo+ICsJLmdlbV9wcmltZV9leHBvcnQgICAgICAgICAgPSBkcm1f Z2VtX3ByaW1lX2V4cG9ydCwKPiArCS5nZW1fcHJpbWVfZ2V0X3NnX3RhYmxlICAgID0gcHJpbWVf Z2V0X3NnX3RhYmxlLAo+ICsJLmdlbV9wcmltZV9pbXBvcnRfc2dfdGFibGUgPSBwcmltZV9pbXBv cnRfc2dfdGFibGUsCj4gKwkuZ2VtX3ByaW1lX3ZtYXAgICAgICAgICAgICA9IHByaW1lX3ZtYXAs Cj4gKwkuZ2VtX3ByaW1lX3Z1bm1hcCAgICAgICAgICA9IHByaW1lX3Z1bm1hcCwKPiArCS5nZW1f cHJpbWVfbW1hcCAgICAgICAgICAgID0gcHJpbWVfbW1hcCwKPiArCS5kdW1iX2NyZWF0ZSAgICAg ICAgICAgICAgID0gZHVtYl9jcmVhdGUsCj4gKwkuZm9wcyAgICAgICAgICAgICAgICAgICAgICA9 ICZ4ZW5kcm1fZm9wcywKPiArCS5uYW1lICAgICAgICAgICAgICAgICAgICAgID0gInhlbmRybS1k dSIsCj4gKwkuZGVzYyAgICAgICAgICAgICAgICAgICAgICA9ICJYZW4gUFYgRFJNIERpc3BsYXkg VW5pdCIsCj4gKwkuZGF0ZSAgICAgICAgICAgICAgICAgICAgICA9ICIyMDE2MTEwOSIsCj4gKwku bWFqb3IgICAgICAgICAgICAgICAgICAgICA9IDEsCj4gKwkubWlub3IgICAgICAgICAgICAgICAg ICAgICA9IDAsCj4gK307Cj4gKwo+ICtpbnQgeGVuX2RybV9mcm9udF9kcnZfcHJvYmUoc3RydWN0 IHBsYXRmb3JtX2RldmljZSAqcGRldiwKPiArCQlzdHJ1Y3QgeGVuX2RybV9mcm9udF9vcHMgKmZy b250X29wcykKPiArewo+ICsJc3RydWN0IHhlbl9kcm1fZnJvbnRfY2ZnICpjZmcgPSBkZXZfZ2V0 X3BsYXRkYXRhKCZwZGV2LT5kZXYpOwo+ICsJc3RydWN0IHhlbl9kcm1fZnJvbnRfZHJtX2luZm8g KmRybV9pbmZvOwo+ICsJc3RydWN0IGRybV9kZXZpY2UgKmRldjsKPiArCWludCByZXQ7Cj4gKwo+ ICsJRFJNX0lORk8oIkNyZWF0aW5nICVzXG4iLCB4ZW5fZHJtX2RyaXZlci5kZXNjKTsKPiArCj4g Kwlkcm1faW5mbyA9IGRldm1fa3phbGxvYygmcGRldi0+ZGV2LCBzaXplb2YoKmRybV9pbmZvKSwg R0ZQX0tFUk5FTCk7Cj4gKwlpZiAoIWRybV9pbmZvKQo+ICsJCXJldHVybiAtRU5PTUVNOwo+ICsK PiArCWRybV9pbmZvLT5mcm9udF9vcHMgPSBmcm9udF9vcHM7Cj4gKwlkcm1faW5mby0+ZnJvbnRf b3BzLT5vbl9mcmFtZV9kb25lID0gb25fZnJhbWVfZG9uZTsKPiArCWRybV9pbmZvLT5mcm9udF9p bmZvID0gY2ZnLT5mcm9udF9pbmZvOwo+ICsKPiArCWRldiA9IGRybV9kZXZfYWxsb2MoJnhlbl9k cm1fZHJpdmVyLCAmcGRldi0+ZGV2KTsKPiArCWlmICghZGV2KQo+ICsJCXJldHVybiAtRU5PTUVN Owo+ICsKPiArCWRybV9pbmZvLT5kcm1fZGV2ID0gZGV2Owo+ICsKPiArCWRybV9pbmZvLT5jZmcg PSBjZmc7Cj4gKwlkZXYtPmRldl9wcml2YXRlID0gZHJtX2luZm87Cj4gKwlwbGF0Zm9ybV9zZXRf ZHJ2ZGF0YShwZGV2LCBkcm1faW5mbyk7Cj4gKwo+ICsJcmV0ID0gZHJtX3ZibGFua19pbml0KGRl diwgY2ZnLT5udW1fY29ubmVjdG9ycyk7Cj4gKwlpZiAocmV0KSB7Cj4gKwkJRFJNX0VSUk9SKCJG YWlsZWQgdG8gaW5pdGlhbGl6ZSB2YmxhbmssIHJldCAlZFxuIiwgcmV0KTsKPiArCQlyZXR1cm4g cmV0Owo+ICsJfQo+ICsKPiArCWRldi0+aXJxX2VuYWJsZWQgPSAxOwo+ICsKPiArCXJldCA9IGRy bV9kZXZfcmVnaXN0ZXIoZGV2LCAwKTsKPiArCWlmIChyZXQpCj4gKwkJZ290byBmYWlsX3JlZ2lz dGVyOwo+ICsKPiArCURSTV9JTkZPKCJJbml0aWFsaXplZCAlcyAlZC4lZC4lZCAlcyBvbiBtaW5v ciAlZFxuIiwKPiArCQkJeGVuX2RybV9kcml2ZXIubmFtZSwgeGVuX2RybV9kcml2ZXIubWFqb3Is Cj4gKwkJCXhlbl9kcm1fZHJpdmVyLm1pbm9yLCB4ZW5fZHJtX2RyaXZlci5wYXRjaGxldmVsLAo+ ICsJCQl4ZW5fZHJtX2RyaXZlci5kYXRlLCBkZXYtPnByaW1hcnktPmluZGV4KTsKPiArCj4gKwly ZXR1cm4gMDsKPiArCj4gK2ZhaWxfcmVnaXN0ZXI6Cj4gKwlkcm1fZGV2X3VucmVnaXN0ZXIoZGV2 KTsKPiArCWRybV9tb2RlX2NvbmZpZ19jbGVhbnVwKGRldik7Cj4gKwlyZXR1cm4gcmV0Owo+ICt9 Cj4gKwo+ICtpbnQgeGVuX2RybV9mcm9udF9kcnZfcmVtb3ZlKHN0cnVjdCBwbGF0Zm9ybV9kZXZp Y2UgKnBkZXYpCj4gK3sKPiArCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9pbmZvICpkcm1faW5m byA9IHBsYXRmb3JtX2dldF9kcnZkYXRhKHBkZXYpOwo+ICsJc3RydWN0IGRybV9kZXZpY2UgKmRl diA9IGRybV9pbmZvLT5kcm1fZGV2Owo+ICsKPiArCWlmIChkZXYpIHsKPiArCQlkcm1fZGV2X3Vu cmVnaXN0ZXIoZGV2KTsKPiArCQlkcm1fYXRvbWljX2hlbHBlcl9zaHV0ZG93bihkZXYpOwo+ICsJ CWRybV9tb2RlX2NvbmZpZ19jbGVhbnVwKGRldik7Cj4gKwkJZHJtX2Rldl91bnJlZihkZXYpOwo+ ICsJfQo+ICsJcmV0dXJuIDA7Cj4gK30KPiArCj4gK2Jvb2wgeGVuX2RybV9mcm9udF9kcnZfaXNf dXNlZChzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQo+ICt7Cj4gKwlzdHJ1Y3QgeGVuX2Ry bV9mcm9udF9kcm1faW5mbyAqZHJtX2luZm8gPSBwbGF0Zm9ybV9nZXRfZHJ2ZGF0YShwZGV2KTsK PiArCXN0cnVjdCBkcm1fZGV2aWNlICpkZXY7Cj4gKwo+ICsJaWYgKCFkcm1faW5mbykKPiArCQly ZXR1cm4gZmFsc2U7Cj4gKwo+ICsJZGV2ID0gZHJtX2luZm8tPmRybV9kZXY7Cj4gKwlpZiAoIWRl dikKPiArCQlyZXR1cm4gZmFsc2U7Cj4gKwo+ICsJLyoKPiArCSAqIEZJWE1FOiB0aGUgY29kZSBi ZWxvdyBtdXN0IGJlIHByb3RlY3RlZCBieSBkcm1fZ2xvYmFsX211dGV4LAo+ICsJICogYnV0IGl0 IGlzIG5vdCBhY2Nlc3NpYmxlIHRvIHVzLiBBbnl3YXlzIHRoZXJlIGlzIGEgcmFjZSBjb25kaXRp b24sCj4gKwkgKiBidXQgd2Ugd2lsbCByZS10cnkuCj4gKwkgKi8KPiArCXJldHVybiBkZXYtPm9w ZW5fY291bnQgIT0gMDsKPiArfQo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0veGVuL3hl bl9kcm1fZnJvbnRfZHJ2LmggYi9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfZHJ2 LmgKPiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+IGluZGV4IDAwMDAwMDAwMDAwMC4uYWFhNDc2NTM1 YzEzCj4gLS0tIC9kZXYvbnVsbAo+ICsrKyBiL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9m cm9udF9kcnYuaAo+IEBAIC0wLDAgKzEsNjAgQEAKPiArLyoKPiArICogIFhlbiBwYXJhLXZpcnR1 YWwgRFJNIGRldmljZQo+ICsgKgo+ICsgKiAgIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJl OyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Cj4gKyAqICAgaXQgdW5kZXIg dGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQg YnkKPiArICogICB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAy IG9mIHRoZSBMaWNlbnNlLCBvcgo+ICsgKiAgIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZl cnNpb24uCj4gKyAqCj4gKyAqICAgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBo b3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCj4gKyAqICAgYnV0IFdJVEhPVVQgQU5ZIFdBUlJB TlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKPiArICogICBNRVJDSEFO VEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCj4g KyAqICAgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KPiArICoK PiArICogQ29weXJpZ2h0IChDKSAyMDE2LTIwMTggRVBBTSBTeXN0ZW1zIEluYy4KPiArICoKPiAr ICogQXV0aG9yOiBPbGVrc2FuZHIgQW5kcnVzaGNoZW5rbyA8b2xla3NhbmRyX2FuZHJ1c2hjaGVu a29AZXBhbS5jb20+Cj4gKyAqLwo+ICsKPiArI2lmbmRlZiBfX1hFTl9EUk1fRlJPTlRfRFJWX0hf Cj4gKyNkZWZpbmUgX19YRU5fRFJNX0ZST05UX0RSVl9IXwo+ICsKPiArI2luY2x1ZGUgPGRybS9k cm1QLmg+Cj4gKwo+ICsjaW5jbHVkZSAieGVuX2RybV9mcm9udC5oIgo+ICsjaW5jbHVkZSAieGVu X2RybV9mcm9udF9jZmcuaCIKPiArCj4gK3N0cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9waXBlbGlu ZSB7Cj4gKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9kcm1faW5mbyAqZHJtX2luZm87Cj4gKwo+ICsJ aW50IGluZGV4Owo+ICt9Owo+ICsKPiArc3RydWN0IHhlbl9kcm1fZnJvbnRfZHJtX2luZm8gewo+ ICsJc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbzsKPiArCXN0cnVjdCB4ZW5f ZHJtX2Zyb250X29wcyAqZnJvbnRfb3BzOwo+ICsJc3RydWN0IGRybV9kZXZpY2UgKmRybV9kZXY7 Cj4gKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9jZmcgKmNmZzsKPiArfTsKPiArCj4gK3N0YXRpYyBp bmxpbmUgdWludDY0X3QgeGVuX2RybV9mcm9udF9mYl90b19jb29raWUoCj4gKwkJc3RydWN0IGRy bV9mcmFtZWJ1ZmZlciAqZmIpCj4gK3sKPiArCXJldHVybiAodWludDY0X3QpZmI7Cj4gK30KPiAr Cj4gK3N0YXRpYyBpbmxpbmUgdWludDY0X3QgeGVuX2RybV9mcm9udF9kYnVmX3RvX2Nvb2tpZSgK PiArCQlzdHJ1Y3QgZHJtX2dlbV9vYmplY3QgKmdlbV9vYmopCj4gK3sKPiArCXJldHVybiAodWlu dDY0X3QpZ2VtX29iajsKPiArfQo+ICsKPiAraW50IHhlbl9kcm1fZnJvbnRfZHJ2X3Byb2JlKHN0 cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYsCj4gKwkJc3RydWN0IHhlbl9kcm1fZnJvbnRfb3Bz ICpmcm9udF9vcHMpOwo+ICsKPiAraW50IHhlbl9kcm1fZnJvbnRfZHJ2X3JlbW92ZShzdHJ1Y3Qg cGxhdGZvcm1fZGV2aWNlICpwZGV2KTsKPiArCj4gK2Jvb2wgeGVuX2RybV9mcm9udF9kcnZfaXNf dXNlZChzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KTsKPiArCj4gKyNlbmRpZiAvKiBfX1hF Tl9EUk1fRlJPTlRfRFJWX0hfICovCj4gKwo+IC0tIAo+IDIuNy40Cj4gCj4gX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KPiBkcmktZGV2ZWwgbWFpbGluZyBs aXN0Cj4gZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwo+IGh0dHBzOi8vbGlzdHMuZnJl ZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVsCgotLSAKRGFuaWVsIFZldHRl cgpTb2Z0d2FyZSBFbmdpbmVlciwgSW50ZWwgQ29ycG9yYXRpb24KaHR0cDovL2Jsb2cuZmZ3bGwu Y2gKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KZHJpLWRl dmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8v bGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVsCg==