From mboxrd@z Thu Jan 1 00:00:00 1970 From: Thomas Zimmermann Date: Tue, 12 Nov 2019 14:04:28 +0000 Subject: [PATCH v3 2/5] drm/udl: Replace fbdev code with generic emulation Message-Id: <20191112140431.7895-3-tzimmermann@suse.de> List-Id: References: <20191112140431.7895-1-tzimmermann@suse.de> In-Reply-To: <20191112140431.7895-1-tzimmermann@suse.de> MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit To: airlied@redhat.com, sean@poorly.run, daniel@ffwll.ch, b.zolnierkie@samsung.com, noralf@tronnes.org, kraxel@redhat.com, sam@ravnborg.org, emil.velikov@collabora.com Cc: linux-fbdev@vger.kernel.org, Thomas Zimmermann , dri-devel@lists.freedesktop.org The udl driver can use the generic fbdev implementation. Convert it. v3: * remove module parameter fb_bpp in favor of fbdev's video * call drm_fbdev_generic_setup() directly; remove udl_fbdev_init() * use default for struct drm_mode_config_funcs.output_poll_changed * use default for struct drm_driver.lastclose Signed-off-by: Thomas Zimmermann --- drivers/gpu/drm/udl/udl_drv.c | 1 - drivers/gpu/drm/udl/udl_drv.h | 6 - drivers/gpu/drm/udl/udl_fb.c | 282 ------------------------------ drivers/gpu/drm/udl/udl_main.c | 5 +- drivers/gpu/drm/udl/udl_modeset.c | 1 - 5 files changed, 2 insertions(+), 293 deletions(-) diff --git a/drivers/gpu/drm/udl/udl_drv.c b/drivers/gpu/drm/udl/udl_drv.c index 563cc5809e56..2b6d8f6b2e06 100644 --- a/drivers/gpu/drm/udl/udl_drv.c +++ b/drivers/gpu/drm/udl/udl_drv.c @@ -119,7 +119,6 @@ static void udl_usb_disconnect(struct usb_interface *interface) struct drm_device *dev = usb_get_intfdata(interface); drm_kms_helper_poll_disable(dev); - udl_fbdev_unplug(dev); udl_drop_usb(dev); drm_dev_unplug(dev); drm_dev_put(dev); diff --git a/drivers/gpu/drm/udl/udl_drv.h b/drivers/gpu/drm/udl/udl_drv.h index 987d99ae2dfa..be585e3e572d 100644 --- a/drivers/gpu/drm/udl/udl_drv.h +++ b/drivers/gpu/drm/udl/udl_drv.h @@ -47,8 +47,6 @@ struct urb_list { size_t size; }; -struct udl_fbdev; - struct udl_device { struct drm_device drm; struct device *dev; @@ -62,7 +60,6 @@ struct udl_device { struct urb_list urbs; atomic_t lost_pixels; /* 1 = a render op failed. Need screen refresh */ - struct udl_fbdev *fbdev; char mode_buf[1024]; uint32_t mode_buf_len; atomic_t bytes_rendered; /* raw pixel-bytes driver asked to render */ @@ -97,9 +94,6 @@ void udl_urb_completion(struct urb *urb); int udl_init(struct udl_device *udl); void udl_fini(struct drm_device *dev); -int udl_fbdev_init(struct drm_device *dev); -void udl_fbdev_cleanup(struct drm_device *dev); -void udl_fbdev_unplug(struct drm_device *dev); struct drm_framebuffer * udl_fb_user_fb_create(struct drm_device *dev, struct drm_file *file, diff --git a/drivers/gpu/drm/udl/udl_fb.c b/drivers/gpu/drm/udl/udl_fb.c index f8153b726343..8fe4d8cf3212 100644 --- a/drivers/gpu/drm/udl/udl_fb.c +++ b/drivers/gpu/drm/udl/udl_fb.c @@ -13,27 +13,12 @@ #include #include -#include #include #include #include #include "udl_drv.h" -#define DL_DEFIO_WRITE_DELAY (HZ/20) /* fb_deferred_io.delay in jiffies */ - -static int fb_defio = 0; /* Optionally enable experimental fb_defio mmap support */ -static int fb_bpp = 16; - -module_param(fb_bpp, int, S_IWUSR | S_IRUSR | S_IWGRP | S_IRGRP); -module_param(fb_defio, int, S_IWUSR | S_IRUSR | S_IWGRP | S_IRGRP); - -struct udl_fbdev { - struct drm_fb_helper helper; /* must be first */ - struct udl_framebuffer ufb; - int fb_count; -}; - #define DL_ALIGN_UP(x, a) ALIGN(x, a) #define DL_ALIGN_DOWN(x, a) ALIGN_DOWN(x, a) @@ -156,123 +141,6 @@ int udl_handle_damage(struct udl_framebuffer *fb, int x, int y, return 0; } -static int udl_fb_mmap(struct fb_info *info, struct vm_area_struct *vma) -{ - unsigned long start = vma->vm_start; - unsigned long size = vma->vm_end - vma->vm_start; - unsigned long offset; - unsigned long page, pos; - - if (vma->vm_pgoff > (~0UL >> PAGE_SHIFT)) - return -EINVAL; - - offset = vma->vm_pgoff << PAGE_SHIFT; - - if (offset > info->fix.smem_len || size > info->fix.smem_len - offset) - return -EINVAL; - - pos = (unsigned long)info->fix.smem_start + offset; - - pr_debug("mmap() framebuffer addr:%lu size:%lu\n", - pos, size); - - /* We don't want the framebuffer to be mapped encrypted */ - vma->vm_page_prot = pgprot_decrypted(vma->vm_page_prot); - - while (size > 0) { - page = vmalloc_to_pfn((void *)pos); - if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED)) - return -EAGAIN; - - start += PAGE_SIZE; - pos += PAGE_SIZE; - if (size > PAGE_SIZE) - size -= PAGE_SIZE; - else - size = 0; - } - - /* VM_IO | VM_DONTEXPAND | VM_DONTDUMP are set by remap_pfn_range() */ - return 0; -} - -/* - * It's common for several clients to have framebuffer open simultaneously. - * e.g. both fbcon and X. Makes things interesting. - * Assumes caller is holding info->lock (for open and release at least) - */ -static int udl_fb_open(struct fb_info *info, int user) -{ - struct udl_fbdev *ufbdev = info->par; - struct drm_device *dev = ufbdev->ufb.base.dev; - struct udl_device *udl = to_udl(dev); - - /* If the USB device is gone, we don't accept new opens */ - if (drm_dev_is_unplugged(&udl->drm)) - return -ENODEV; - - ufbdev->fb_count++; - -#ifdef CONFIG_DRM_FBDEV_EMULATION - if (fb_defio && (info->fbdefio = NULL)) { - /* enable defio at last moment if not disabled by client */ - - struct fb_deferred_io *fbdefio; - - fbdefio = kzalloc(sizeof(struct fb_deferred_io), GFP_KERNEL); - - if (fbdefio) { - fbdefio->delay = DL_DEFIO_WRITE_DELAY; - fbdefio->deferred_io = drm_fb_helper_deferred_io; - } - - info->fbdefio = fbdefio; - fb_deferred_io_init(info); - } -#endif - - pr_debug("open /dev/fb%d user=%d fb_info=%p count=%d\n", - info->node, user, info, ufbdev->fb_count); - - return 0; -} - - -/* - * Assumes caller is holding info->lock mutex (for open and release at least) - */ -static int udl_fb_release(struct fb_info *info, int user) -{ - struct udl_fbdev *ufbdev = info->par; - - ufbdev->fb_count--; - -#ifdef CONFIG_DRM_FBDEV_EMULATION - if ((ufbdev->fb_count = 0) && (info->fbdefio)) { - fb_deferred_io_cleanup(info); - kfree(info->fbdefio); - info->fbdefio = NULL; - info->fbops->fb_mmap = udl_fb_mmap; - } -#endif - - pr_debug("released /dev/fb%d user=%d count=%d\n", - info->node, user, ufbdev->fb_count); - - return 0; -} - -static struct fb_ops udlfb_ops = { - .owner = THIS_MODULE, - DRM_FB_HELPER_DEFAULT_OPS, - .fb_fillrect = drm_fb_helper_sys_fillrect, - .fb_copyarea = drm_fb_helper_sys_copyarea, - .fb_imageblit = drm_fb_helper_sys_imageblit, - .fb_mmap = udl_fb_mmap, - .fb_open = udl_fb_open, - .fb_release = udl_fb_release, -}; - static int udl_user_framebuffer_dirty(struct drm_framebuffer *fb, struct drm_file *file, unsigned flags, unsigned color, @@ -347,156 +215,6 @@ udl_framebuffer_init(struct drm_device *dev, return ret; } - -static int udlfb_create(struct drm_fb_helper *helper, - struct drm_fb_helper_surface_size *sizes) -{ - struct udl_fbdev *ufbdev - container_of(helper, struct udl_fbdev, helper); - struct drm_device *dev = ufbdev->helper.dev; - struct fb_info *info; - struct drm_framebuffer *fb; - struct drm_mode_fb_cmd2 mode_cmd; - struct drm_gem_shmem_object *shmem; - void *vaddr; - uint32_t size; - int ret = 0; - - if (sizes->surface_bpp = 24) - sizes->surface_bpp = 32; - - mode_cmd.width = sizes->surface_width; - mode_cmd.height = sizes->surface_height; - mode_cmd.pitches[0] = mode_cmd.width * ((sizes->surface_bpp + 7) / 8); - - mode_cmd.pixel_format = drm_mode_legacy_fb_format(sizes->surface_bpp, - sizes->surface_depth); - - size = mode_cmd.pitches[0] * mode_cmd.height; - size = ALIGN(size, PAGE_SIZE); - - shmem = drm_gem_shmem_create(dev, size); - if (IS_ERR(shmem)) { - ret = PTR_ERR(shmem); - goto out; - } - - vaddr = drm_gem_shmem_vmap(&shmem->base); - if (IS_ERR(vaddr)) { - ret = PTR_ERR(vaddr); - DRM_ERROR("failed to vmap fb\n"); - goto out_gfree; - } - - info = drm_fb_helper_alloc_fbi(helper); - if (IS_ERR(info)) { - ret = PTR_ERR(info); - goto out_gfree; - } - - ret = udl_framebuffer_init(dev, &ufbdev->ufb, &mode_cmd, shmem); - if (ret) - goto out_gfree; - - fb = &ufbdev->ufb.base; - - ufbdev->helper.fb = fb; - - info->screen_base = vaddr; - info->fix.smem_len = size; - info->fix.smem_start = (unsigned long)vaddr; - - info->fbops = &udlfb_ops; - drm_fb_helper_fill_info(info, &ufbdev->helper, sizes); - - DRM_DEBUG_KMS("allocated %dx%d vmal %p\n", - fb->width, fb->height, - ufbdev->ufb.shmem->vaddr); - - return ret; -out_gfree: - drm_gem_object_put_unlocked(&ufbdev->ufb.shmem->base); -out: - return ret; -} - -static const struct drm_fb_helper_funcs udl_fb_helper_funcs = { - .fb_probe = udlfb_create, -}; - -static void udl_fbdev_destroy(struct drm_device *dev, - struct udl_fbdev *ufbdev) -{ - drm_fb_helper_unregister_fbi(&ufbdev->helper); - drm_fb_helper_fini(&ufbdev->helper); - if (ufbdev->ufb.shmem) { - drm_framebuffer_unregister_private(&ufbdev->ufb.base); - drm_framebuffer_cleanup(&ufbdev->ufb.base); - drm_gem_object_put_unlocked(&ufbdev->ufb.shmem->base); - } -} - -int udl_fbdev_init(struct drm_device *dev) -{ - struct udl_device *udl = to_udl(dev); - int bpp_sel = fb_bpp; - struct udl_fbdev *ufbdev; - int ret; - - ufbdev = kzalloc(sizeof(struct udl_fbdev), GFP_KERNEL); - if (!ufbdev) - return -ENOMEM; - - udl->fbdev = ufbdev; - - drm_fb_helper_prepare(dev, &ufbdev->helper, &udl_fb_helper_funcs); - - ret = drm_fb_helper_init(dev, &ufbdev->helper, 1); - if (ret) - goto free; - - ret = drm_fb_helper_single_add_all_connectors(&ufbdev->helper); - if (ret) - goto fini; - - /* disable all the possible outputs/crtcs before entering KMS mode */ - drm_helper_disable_unused_functions(dev); - - ret = drm_fb_helper_initial_config(&ufbdev->helper, bpp_sel); - if (ret) - goto fini; - - return 0; - -fini: - drm_fb_helper_fini(&ufbdev->helper); -free: - kfree(ufbdev); - return ret; -} - -void udl_fbdev_cleanup(struct drm_device *dev) -{ - struct udl_device *udl = to_udl(dev); - if (!udl->fbdev) - return; - - udl_fbdev_destroy(dev, udl->fbdev); - kfree(udl->fbdev); - udl->fbdev = NULL; -} - -void udl_fbdev_unplug(struct drm_device *dev) -{ - struct udl_device *udl = to_udl(dev); - struct udl_fbdev *ufbdev; - if (!udl->fbdev) - return; - - ufbdev = udl->fbdev; - drm_fb_helper_unlink_fbi(&ufbdev->helper); -} - struct drm_framebuffer * udl_fb_user_fb_create(struct drm_device *dev, struct drm_file *file, diff --git a/drivers/gpu/drm/udl/udl_main.c b/drivers/gpu/drm/udl/udl_main.c index 4e854e017390..d4473f594b45 100644 --- a/drivers/gpu/drm/udl/udl_main.c +++ b/drivers/gpu/drm/udl/udl_main.c @@ -9,6 +9,7 @@ */ #include +#include #include #include @@ -338,7 +339,7 @@ int udl_init(struct udl_device *udl) if (ret) goto err; - ret = udl_fbdev_init(dev); + ret = drm_fbdev_generic_setup(dev, 0); if (ret) goto err; @@ -367,6 +368,4 @@ void udl_fini(struct drm_device *dev) if (udl->urbs.count) udl_free_urb_list(dev); - - udl_fbdev_cleanup(dev); } diff --git a/drivers/gpu/drm/udl/udl_modeset.c b/drivers/gpu/drm/udl/udl_modeset.c index 1f8ebcc595de..9b55958af238 100644 --- a/drivers/gpu/drm/udl/udl_modeset.c +++ b/drivers/gpu/drm/udl/udl_modeset.c @@ -422,7 +422,6 @@ static int udl_crtc_init(struct drm_device *dev) static const struct drm_mode_config_funcs udl_mode_funcs = { .fb_create = udl_fb_user_fb_create, - .output_poll_changed = NULL, }; int udl_modeset_init(struct drm_device *dev) -- 2.23.0 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Thomas Zimmermann Subject: [PATCH v3 2/5] drm/udl: Replace fbdev code with generic emulation Date: Tue, 12 Nov 2019 15:04:28 +0100 Message-ID: <20191112140431.7895-3-tzimmermann@suse.de> References: <20191112140431.7895-1-tzimmermann@suse.de> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mx1.suse.de (mx2.suse.de [195.135.220.15]) by gabe.freedesktop.org (Postfix) with ESMTPS id 578386E45E for ; Tue, 12 Nov 2019 14:04:36 +0000 (UTC) In-Reply-To: <20191112140431.7895-1-tzimmermann@suse.de> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: airlied@redhat.com, sean@poorly.run, daniel@ffwll.ch, b.zolnierkie@samsung.com, noralf@tronnes.org, kraxel@redhat.com, sam@ravnborg.org, emil.velikov@collabora.com Cc: linux-fbdev@vger.kernel.org, Thomas Zimmermann , dri-devel@lists.freedesktop.org List-Id: dri-devel@lists.freedesktop.org VGhlIHVkbCBkcml2ZXIgY2FuIHVzZSB0aGUgZ2VuZXJpYyBmYmRldiBpbXBsZW1lbnRhdGlvbi4g Q29udmVydCBpdC4KCnYzOgoJKiByZW1vdmUgbW9kdWxlIHBhcmFtZXRlciBmYl9icHAgaW4gZmF2 b3Igb2YgZmJkZXYncyB2aWRlbwoJKiBjYWxsIGRybV9mYmRldl9nZW5lcmljX3NldHVwKCkgZGly ZWN0bHk7IHJlbW92ZSB1ZGxfZmJkZXZfaW5pdCgpCgkqIHVzZSBkZWZhdWx0IGZvciBzdHJ1Y3Qg ZHJtX21vZGVfY29uZmlnX2Z1bmNzLm91dHB1dF9wb2xsX2NoYW5nZWQKCSogdXNlIGRlZmF1bHQg Zm9yIHN0cnVjdCBkcm1fZHJpdmVyLmxhc3RjbG9zZQoKU2lnbmVkLW9mZi1ieTogVGhvbWFzIFpp bW1lcm1hbm4gPHR6aW1tZXJtYW5uQHN1c2UuZGU+Ci0tLQogZHJpdmVycy9ncHUvZHJtL3VkbC91 ZGxfZHJ2LmMgICAgIHwgICAxIC0KIGRyaXZlcnMvZ3B1L2RybS91ZGwvdWRsX2Rydi5oICAgICB8 ICAgNiAtCiBkcml2ZXJzL2dwdS9kcm0vdWRsL3VkbF9mYi5jICAgICAgfCAyODIgLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tCiBkcml2ZXJzL2dwdS9kcm0vdWRsL3VkbF9tYWluLmMgICAg fCAgIDUgKy0KIGRyaXZlcnMvZ3B1L2RybS91ZGwvdWRsX21vZGVzZXQuYyB8ICAgMSAtCiA1IGZp bGVzIGNoYW5nZWQsIDIgaW5zZXJ0aW9ucygrKSwgMjkzIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdp dCBhL2RyaXZlcnMvZ3B1L2RybS91ZGwvdWRsX2Rydi5jIGIvZHJpdmVycy9ncHUvZHJtL3VkbC91 ZGxfZHJ2LmMKaW5kZXggNTYzY2M1ODA5ZTU2Li4yYjZkOGY2YjJlMDYgMTAwNjQ0Ci0tLSBhL2Ry aXZlcnMvZ3B1L2RybS91ZGwvdWRsX2Rydi5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS91ZGwvdWRs X2Rydi5jCkBAIC0xMTksNyArMTE5LDYgQEAgc3RhdGljIHZvaWQgdWRsX3VzYl9kaXNjb25uZWN0 KHN0cnVjdCB1c2JfaW50ZXJmYWNlICppbnRlcmZhY2UpCiAJc3RydWN0IGRybV9kZXZpY2UgKmRl diA9IHVzYl9nZXRfaW50ZmRhdGEoaW50ZXJmYWNlKTsKIAogCWRybV9rbXNfaGVscGVyX3BvbGxf ZGlzYWJsZShkZXYpOwotCXVkbF9mYmRldl91bnBsdWcoZGV2KTsKIAl1ZGxfZHJvcF91c2IoZGV2 KTsKIAlkcm1fZGV2X3VucGx1ZyhkZXYpOwogCWRybV9kZXZfcHV0KGRldik7CmRpZmYgLS1naXQg YS9kcml2ZXJzL2dwdS9kcm0vdWRsL3VkbF9kcnYuaCBiL2RyaXZlcnMvZ3B1L2RybS91ZGwvdWRs X2Rydi5oCmluZGV4IDk4N2Q5OWFlMmRmYS4uYmU1ODVlM2U1NzJkIDEwMDY0NAotLS0gYS9kcml2 ZXJzL2dwdS9kcm0vdWRsL3VkbF9kcnYuaAorKysgYi9kcml2ZXJzL2dwdS9kcm0vdWRsL3VkbF9k cnYuaApAQCAtNDcsOCArNDcsNiBAQCBzdHJ1Y3QgdXJiX2xpc3QgewogCXNpemVfdCBzaXplOwog fTsKIAotc3RydWN0IHVkbF9mYmRldjsKLQogc3RydWN0IHVkbF9kZXZpY2UgewogCXN0cnVjdCBk cm1fZGV2aWNlIGRybTsKIAlzdHJ1Y3QgZGV2aWNlICpkZXY7CkBAIC02Miw3ICs2MCw2IEBAIHN0 cnVjdCB1ZGxfZGV2aWNlIHsKIAlzdHJ1Y3QgdXJiX2xpc3QgdXJiczsKIAlhdG9taWNfdCBsb3N0 X3BpeGVsczsgLyogMSA9IGEgcmVuZGVyIG9wIGZhaWxlZC4gTmVlZCBzY3JlZW4gcmVmcmVzaCAq LwogCi0Jc3RydWN0IHVkbF9mYmRldiAqZmJkZXY7CiAJY2hhciBtb2RlX2J1ZlsxMDI0XTsKIAl1 aW50MzJfdCBtb2RlX2J1Zl9sZW47CiAJYXRvbWljX3QgYnl0ZXNfcmVuZGVyZWQ7IC8qIHJhdyBw aXhlbC1ieXRlcyBkcml2ZXIgYXNrZWQgdG8gcmVuZGVyICovCkBAIC05Nyw5ICs5NCw2IEBAIHZv aWQgdWRsX3VyYl9jb21wbGV0aW9uKHN0cnVjdCB1cmIgKnVyYik7CiBpbnQgdWRsX2luaXQoc3Ry dWN0IHVkbF9kZXZpY2UgKnVkbCk7CiB2b2lkIHVkbF9maW5pKHN0cnVjdCBkcm1fZGV2aWNlICpk ZXYpOwogCi1pbnQgdWRsX2ZiZGV2X2luaXQoc3RydWN0IGRybV9kZXZpY2UgKmRldik7Ci12b2lk IHVkbF9mYmRldl9jbGVhbnVwKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYpOwotdm9pZCB1ZGxfZmJk ZXZfdW5wbHVnKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYpOwogc3RydWN0IGRybV9mcmFtZWJ1ZmZl ciAqCiB1ZGxfZmJfdXNlcl9mYl9jcmVhdGUoc3RydWN0IGRybV9kZXZpY2UgKmRldiwKIAkJICAg ICAgc3RydWN0IGRybV9maWxlICpmaWxlLApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3Vk bC91ZGxfZmIuYyBiL2RyaXZlcnMvZ3B1L2RybS91ZGwvdWRsX2ZiLmMKaW5kZXggZjgxNTNiNzI2 MzQzLi44ZmU0ZDhjZjMyMTIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS91ZGwvdWRsX2Zi LmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL3VkbC91ZGxfZmIuYwpAQCAtMTMsMjcgKzEzLDEyIEBA CiAKICNpbmNsdWRlIDxkcm0vZHJtX2NydGNfaGVscGVyLmg+CiAjaW5jbHVkZSA8ZHJtL2RybV9k cnYuaD4KLSNpbmNsdWRlIDxkcm0vZHJtX2ZiX2hlbHBlci5oPgogI2luY2x1ZGUgPGRybS9kcm1f Zm91cmNjLmg+CiAjaW5jbHVkZSA8ZHJtL2RybV9nZW1fc2htZW1faGVscGVyLmg+CiAjaW5jbHVk ZSA8ZHJtL2RybV9tb2Rlc2V0X2hlbHBlci5oPgogCiAjaW5jbHVkZSAidWRsX2Rydi5oIgogCi0j ZGVmaW5lIERMX0RFRklPX1dSSVRFX0RFTEFZICAgIChIWi8yMCkgLyogZmJfZGVmZXJyZWRfaW8u ZGVsYXkgaW4gamlmZmllcyAqLwotCi1zdGF0aWMgaW50IGZiX2RlZmlvID0gMDsgIC8qIE9wdGlv bmFsbHkgZW5hYmxlIGV4cGVyaW1lbnRhbCBmYl9kZWZpbyBtbWFwIHN1cHBvcnQgKi8KLXN0YXRp YyBpbnQgZmJfYnBwID0gMTY7Ci0KLW1vZHVsZV9wYXJhbShmYl9icHAsIGludCwgU19JV1VTUiB8 IFNfSVJVU1IgfCBTX0lXR1JQIHwgU19JUkdSUCk7Ci1tb2R1bGVfcGFyYW0oZmJfZGVmaW8sIGlu dCwgU19JV1VTUiB8IFNfSVJVU1IgfCBTX0lXR1JQIHwgU19JUkdSUCk7Ci0KLXN0cnVjdCB1ZGxf ZmJkZXYgewotCXN0cnVjdCBkcm1fZmJfaGVscGVyIGhlbHBlcjsgLyogbXVzdCBiZSBmaXJzdCAq LwotCXN0cnVjdCB1ZGxfZnJhbWVidWZmZXIgdWZiOwotCWludCBmYl9jb3VudDsKLX07Ci0KICNk ZWZpbmUgRExfQUxJR05fVVAoeCwgYSkgQUxJR04oeCwgYSkKICNkZWZpbmUgRExfQUxJR05fRE9X Tih4LCBhKSBBTElHTl9ET1dOKHgsIGEpCiAKQEAgLTE1NiwxMjMgKzE0MSw2IEBAIGludCB1ZGxf aGFuZGxlX2RhbWFnZShzdHJ1Y3QgdWRsX2ZyYW1lYnVmZmVyICpmYiwgaW50IHgsIGludCB5LAog CXJldHVybiAwOwogfQogCi1zdGF0aWMgaW50IHVkbF9mYl9tbWFwKHN0cnVjdCBmYl9pbmZvICpp bmZvLCBzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSkKLXsKLQl1bnNpZ25lZCBsb25nIHN0YXJ0 ID0gdm1hLT52bV9zdGFydDsKLQl1bnNpZ25lZCBsb25nIHNpemUgPSB2bWEtPnZtX2VuZCAtIHZt YS0+dm1fc3RhcnQ7Ci0JdW5zaWduZWQgbG9uZyBvZmZzZXQ7Ci0JdW5zaWduZWQgbG9uZyBwYWdl LCBwb3M7Ci0KLQlpZiAodm1hLT52bV9wZ29mZiA+ICh+MFVMID4+IFBBR0VfU0hJRlQpKQotCQly ZXR1cm4gLUVJTlZBTDsKLQotCW9mZnNldCA9IHZtYS0+dm1fcGdvZmYgPDwgUEFHRV9TSElGVDsK LQotCWlmIChvZmZzZXQgPiBpbmZvLT5maXguc21lbV9sZW4gfHwgc2l6ZSA+IGluZm8tPmZpeC5z bWVtX2xlbiAtIG9mZnNldCkKLQkJcmV0dXJuIC1FSU5WQUw7Ci0KLQlwb3MgPSAodW5zaWduZWQg bG9uZylpbmZvLT5maXguc21lbV9zdGFydCArIG9mZnNldDsKLQotCXByX2RlYnVnKCJtbWFwKCkg ZnJhbWVidWZmZXIgYWRkcjolbHUgc2l6ZTolbHVcbiIsCi0JCSAgcG9zLCBzaXplKTsKLQotCS8q IFdlIGRvbid0IHdhbnQgdGhlIGZyYW1lYnVmZmVyIHRvIGJlIG1hcHBlZCBlbmNyeXB0ZWQgKi8K LQl2bWEtPnZtX3BhZ2VfcHJvdCA9IHBncHJvdF9kZWNyeXB0ZWQodm1hLT52bV9wYWdlX3Byb3Qp OwotCi0Jd2hpbGUgKHNpemUgPiAwKSB7Ci0JCXBhZ2UgPSB2bWFsbG9jX3RvX3Bmbigodm9pZCAq KXBvcyk7Ci0JCWlmIChyZW1hcF9wZm5fcmFuZ2Uodm1hLCBzdGFydCwgcGFnZSwgUEFHRV9TSVpF LCBQQUdFX1NIQVJFRCkpCi0JCQlyZXR1cm4gLUVBR0FJTjsKLQotCQlzdGFydCArPSBQQUdFX1NJ WkU7Ci0JCXBvcyArPSBQQUdFX1NJWkU7Ci0JCWlmIChzaXplID4gUEFHRV9TSVpFKQotCQkJc2l6 ZSAtPSBQQUdFX1NJWkU7Ci0JCWVsc2UKLQkJCXNpemUgPSAwOwotCX0KLQotCS8qIFZNX0lPIHwg Vk1fRE9OVEVYUEFORCB8IFZNX0RPTlREVU1QIGFyZSBzZXQgYnkgcmVtYXBfcGZuX3JhbmdlKCkg Ki8KLQlyZXR1cm4gMDsKLX0KLQotLyoKLSAqIEl0J3MgY29tbW9uIGZvciBzZXZlcmFsIGNsaWVu dHMgdG8gaGF2ZSBmcmFtZWJ1ZmZlciBvcGVuIHNpbXVsdGFuZW91c2x5LgotICogZS5nLiBib3Ro IGZiY29uIGFuZCBYLiBNYWtlcyB0aGluZ3MgaW50ZXJlc3RpbmcuCi0gKiBBc3N1bWVzIGNhbGxl ciBpcyBob2xkaW5nIGluZm8tPmxvY2sgKGZvciBvcGVuIGFuZCByZWxlYXNlIGF0IGxlYXN0KQot ICovCi1zdGF0aWMgaW50IHVkbF9mYl9vcGVuKHN0cnVjdCBmYl9pbmZvICppbmZvLCBpbnQgdXNl cikKLXsKLQlzdHJ1Y3QgdWRsX2ZiZGV2ICp1ZmJkZXYgPSBpbmZvLT5wYXI7Ci0Jc3RydWN0IGRy bV9kZXZpY2UgKmRldiA9IHVmYmRldi0+dWZiLmJhc2UuZGV2OwotCXN0cnVjdCB1ZGxfZGV2aWNl ICp1ZGwgPSB0b191ZGwoZGV2KTsKLQotCS8qIElmIHRoZSBVU0IgZGV2aWNlIGlzIGdvbmUsIHdl IGRvbid0IGFjY2VwdCBuZXcgb3BlbnMgKi8KLQlpZiAoZHJtX2Rldl9pc191bnBsdWdnZWQoJnVk bC0+ZHJtKSkKLQkJcmV0dXJuIC1FTk9ERVY7Ci0KLQl1ZmJkZXYtPmZiX2NvdW50Kys7Ci0KLSNp ZmRlZiBDT05GSUdfRFJNX0ZCREVWX0VNVUxBVElPTgotCWlmIChmYl9kZWZpbyAmJiAoaW5mby0+ ZmJkZWZpbyA9PSBOVUxMKSkgewotCQkvKiBlbmFibGUgZGVmaW8gYXQgbGFzdCBtb21lbnQgaWYg bm90IGRpc2FibGVkIGJ5IGNsaWVudCAqLwotCi0JCXN0cnVjdCBmYl9kZWZlcnJlZF9pbyAqZmJk ZWZpbzsKLQotCQlmYmRlZmlvID0ga3phbGxvYyhzaXplb2Yoc3RydWN0IGZiX2RlZmVycmVkX2lv KSwgR0ZQX0tFUk5FTCk7Ci0KLQkJaWYgKGZiZGVmaW8pIHsKLQkJCWZiZGVmaW8tPmRlbGF5ID0g RExfREVGSU9fV1JJVEVfREVMQVk7Ci0JCQlmYmRlZmlvLT5kZWZlcnJlZF9pbyA9IGRybV9mYl9o ZWxwZXJfZGVmZXJyZWRfaW87Ci0JCX0KLQotCQlpbmZvLT5mYmRlZmlvID0gZmJkZWZpbzsKLQkJ ZmJfZGVmZXJyZWRfaW9faW5pdChpbmZvKTsKLQl9Ci0jZW5kaWYKLQotCXByX2RlYnVnKCJvcGVu IC9kZXYvZmIlZCB1c2VyPSVkIGZiX2luZm89JXAgY291bnQ9JWRcbiIsCi0JCSAgaW5mby0+bm9k ZSwgdXNlciwgaW5mbywgdWZiZGV2LT5mYl9jb3VudCk7Ci0KLQlyZXR1cm4gMDsKLX0KLQotCi0v KgotICogQXNzdW1lcyBjYWxsZXIgaXMgaG9sZGluZyBpbmZvLT5sb2NrIG11dGV4IChmb3Igb3Bl biBhbmQgcmVsZWFzZSBhdCBsZWFzdCkKLSAqLwotc3RhdGljIGludCB1ZGxfZmJfcmVsZWFzZShz dHJ1Y3QgZmJfaW5mbyAqaW5mbywgaW50IHVzZXIpCi17Ci0Jc3RydWN0IHVkbF9mYmRldiAqdWZi ZGV2ID0gaW5mby0+cGFyOwotCi0JdWZiZGV2LT5mYl9jb3VudC0tOwotCi0jaWZkZWYgQ09ORklH X0RSTV9GQkRFVl9FTVVMQVRJT04KLQlpZiAoKHVmYmRldi0+ZmJfY291bnQgPT0gMCkgJiYgKGlu Zm8tPmZiZGVmaW8pKSB7Ci0JCWZiX2RlZmVycmVkX2lvX2NsZWFudXAoaW5mbyk7Ci0JCWtmcmVl KGluZm8tPmZiZGVmaW8pOwotCQlpbmZvLT5mYmRlZmlvID0gTlVMTDsKLQkJaW5mby0+ZmJvcHMt PmZiX21tYXAgPSB1ZGxfZmJfbW1hcDsKLQl9Ci0jZW5kaWYKLQotCXByX2RlYnVnKCJyZWxlYXNl ZCAvZGV2L2ZiJWQgdXNlcj0lZCBjb3VudD0lZFxuIiwKLQkJaW5mby0+bm9kZSwgdXNlciwgdWZi ZGV2LT5mYl9jb3VudCk7Ci0KLQlyZXR1cm4gMDsKLX0KLQotc3RhdGljIHN0cnVjdCBmYl9vcHMg dWRsZmJfb3BzID0gewotCS5vd25lciA9IFRISVNfTU9EVUxFLAotCURSTV9GQl9IRUxQRVJfREVG QVVMVF9PUFMsCi0JLmZiX2ZpbGxyZWN0ID0gZHJtX2ZiX2hlbHBlcl9zeXNfZmlsbHJlY3QsCi0J LmZiX2NvcHlhcmVhID0gZHJtX2ZiX2hlbHBlcl9zeXNfY29weWFyZWEsCi0JLmZiX2ltYWdlYmxp dCA9IGRybV9mYl9oZWxwZXJfc3lzX2ltYWdlYmxpdCwKLQkuZmJfbW1hcCA9IHVkbF9mYl9tbWFw LAotCS5mYl9vcGVuID0gdWRsX2ZiX29wZW4sCi0JLmZiX3JlbGVhc2UgPSB1ZGxfZmJfcmVsZWFz ZSwKLX07Ci0KIHN0YXRpYyBpbnQgdWRsX3VzZXJfZnJhbWVidWZmZXJfZGlydHkoc3RydWN0IGRy bV9mcmFtZWJ1ZmZlciAqZmIsCiAJCQkJICAgICAgc3RydWN0IGRybV9maWxlICpmaWxlLAogCQkJ CSAgICAgIHVuc2lnbmVkIGZsYWdzLCB1bnNpZ25lZCBjb2xvciwKQEAgLTM0NywxNTYgKzIxNSw2 IEBAIHVkbF9mcmFtZWJ1ZmZlcl9pbml0KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsCiAJcmV0dXJu IHJldDsKIH0KIAotCi1zdGF0aWMgaW50IHVkbGZiX2NyZWF0ZShzdHJ1Y3QgZHJtX2ZiX2hlbHBl ciAqaGVscGVyLAotCQkJc3RydWN0IGRybV9mYl9oZWxwZXJfc3VyZmFjZV9zaXplICpzaXplcykK LXsKLQlzdHJ1Y3QgdWRsX2ZiZGV2ICp1ZmJkZXYgPQotCQljb250YWluZXJfb2YoaGVscGVyLCBz dHJ1Y3QgdWRsX2ZiZGV2LCBoZWxwZXIpOwotCXN0cnVjdCBkcm1fZGV2aWNlICpkZXYgPSB1ZmJk ZXYtPmhlbHBlci5kZXY7Ci0Jc3RydWN0IGZiX2luZm8gKmluZm87Ci0Jc3RydWN0IGRybV9mcmFt ZWJ1ZmZlciAqZmI7Ci0Jc3RydWN0IGRybV9tb2RlX2ZiX2NtZDIgbW9kZV9jbWQ7Ci0Jc3RydWN0 IGRybV9nZW1fc2htZW1fb2JqZWN0ICpzaG1lbTsKLQl2b2lkICp2YWRkcjsKLQl1aW50MzJfdCBz aXplOwotCWludCByZXQgPSAwOwotCi0JaWYgKHNpemVzLT5zdXJmYWNlX2JwcCA9PSAyNCkKLQkJ c2l6ZXMtPnN1cmZhY2VfYnBwID0gMzI7Ci0KLQltb2RlX2NtZC53aWR0aCA9IHNpemVzLT5zdXJm YWNlX3dpZHRoOwotCW1vZGVfY21kLmhlaWdodCA9IHNpemVzLT5zdXJmYWNlX2hlaWdodDsKLQlt b2RlX2NtZC5waXRjaGVzWzBdID0gbW9kZV9jbWQud2lkdGggKiAoKHNpemVzLT5zdXJmYWNlX2Jw cCArIDcpIC8gOCk7Ci0KLQltb2RlX2NtZC5waXhlbF9mb3JtYXQgPSBkcm1fbW9kZV9sZWdhY3lf ZmJfZm9ybWF0KHNpemVzLT5zdXJmYWNlX2JwcCwKLQkJCQkJCQkgIHNpemVzLT5zdXJmYWNlX2Rl cHRoKTsKLQotCXNpemUgPSBtb2RlX2NtZC5waXRjaGVzWzBdICogbW9kZV9jbWQuaGVpZ2h0Owot CXNpemUgPSBBTElHTihzaXplLCBQQUdFX1NJWkUpOwotCi0Jc2htZW0gPSBkcm1fZ2VtX3NobWVt X2NyZWF0ZShkZXYsIHNpemUpOwotCWlmIChJU19FUlIoc2htZW0pKSB7Ci0JCXJldCA9IFBUUl9F UlIoc2htZW0pOwotCQlnb3RvIG91dDsKLQl9Ci0KLQl2YWRkciA9IGRybV9nZW1fc2htZW1fdm1h cCgmc2htZW0tPmJhc2UpOwotCWlmIChJU19FUlIodmFkZHIpKSB7Ci0JCXJldCA9IFBUUl9FUlIo dmFkZHIpOwotCQlEUk1fRVJST1IoImZhaWxlZCB0byB2bWFwIGZiXG4iKTsKLQkJZ290byBvdXRf Z2ZyZWU7Ci0JfQotCi0JaW5mbyA9IGRybV9mYl9oZWxwZXJfYWxsb2NfZmJpKGhlbHBlcik7Ci0J aWYgKElTX0VSUihpbmZvKSkgewotCQlyZXQgPSBQVFJfRVJSKGluZm8pOwotCQlnb3RvIG91dF9n ZnJlZTsKLQl9Ci0KLQlyZXQgPSB1ZGxfZnJhbWVidWZmZXJfaW5pdChkZXYsICZ1ZmJkZXYtPnVm YiwgJm1vZGVfY21kLCBzaG1lbSk7Ci0JaWYgKHJldCkKLQkJZ290byBvdXRfZ2ZyZWU7Ci0KLQlm YiA9ICZ1ZmJkZXYtPnVmYi5iYXNlOwotCi0JdWZiZGV2LT5oZWxwZXIuZmIgPSBmYjsKLQotCWlu Zm8tPnNjcmVlbl9iYXNlID0gdmFkZHI7Ci0JaW5mby0+Zml4LnNtZW1fbGVuID0gc2l6ZTsKLQlp bmZvLT5maXguc21lbV9zdGFydCA9ICh1bnNpZ25lZCBsb25nKXZhZGRyOwotCi0JaW5mby0+ZmJv cHMgPSAmdWRsZmJfb3BzOwotCWRybV9mYl9oZWxwZXJfZmlsbF9pbmZvKGluZm8sICZ1ZmJkZXYt PmhlbHBlciwgc2l6ZXMpOwotCi0JRFJNX0RFQlVHX0tNUygiYWxsb2NhdGVkICVkeCVkIHZtYWwg JXBcbiIsCi0JCSAgICAgIGZiLT53aWR0aCwgZmItPmhlaWdodCwKLQkJICAgICAgdWZiZGV2LT51 ZmIuc2htZW0tPnZhZGRyKTsKLQotCXJldHVybiByZXQ7Ci1vdXRfZ2ZyZWU6Ci0JZHJtX2dlbV9v YmplY3RfcHV0X3VubG9ja2VkKCZ1ZmJkZXYtPnVmYi5zaG1lbS0+YmFzZSk7Ci1vdXQ6Ci0JcmV0 dXJuIHJldDsKLX0KLQotc3RhdGljIGNvbnN0IHN0cnVjdCBkcm1fZmJfaGVscGVyX2Z1bmNzIHVk bF9mYl9oZWxwZXJfZnVuY3MgPSB7Ci0JLmZiX3Byb2JlID0gdWRsZmJfY3JlYXRlLAotfTsKLQot c3RhdGljIHZvaWQgdWRsX2ZiZGV2X2Rlc3Ryb3koc3RydWN0IGRybV9kZXZpY2UgKmRldiwKLQkJ CSAgICAgIHN0cnVjdCB1ZGxfZmJkZXYgKnVmYmRldikKLXsKLQlkcm1fZmJfaGVscGVyX3VucmVn aXN0ZXJfZmJpKCZ1ZmJkZXYtPmhlbHBlcik7Ci0JZHJtX2ZiX2hlbHBlcl9maW5pKCZ1ZmJkZXYt PmhlbHBlcik7Ci0JaWYgKHVmYmRldi0+dWZiLnNobWVtKSB7Ci0JCWRybV9mcmFtZWJ1ZmZlcl91 bnJlZ2lzdGVyX3ByaXZhdGUoJnVmYmRldi0+dWZiLmJhc2UpOwotCQlkcm1fZnJhbWVidWZmZXJf Y2xlYW51cCgmdWZiZGV2LT51ZmIuYmFzZSk7Ci0JCWRybV9nZW1fb2JqZWN0X3B1dF91bmxvY2tl ZCgmdWZiZGV2LT51ZmIuc2htZW0tPmJhc2UpOwotCX0KLX0KLQotaW50IHVkbF9mYmRldl9pbml0 KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYpCi17Ci0Jc3RydWN0IHVkbF9kZXZpY2UgKnVkbCA9IHRv X3VkbChkZXYpOwotCWludCBicHBfc2VsID0gZmJfYnBwOwotCXN0cnVjdCB1ZGxfZmJkZXYgKnVm YmRldjsKLQlpbnQgcmV0OwotCi0JdWZiZGV2ID0ga3phbGxvYyhzaXplb2Yoc3RydWN0IHVkbF9m YmRldiksIEdGUF9LRVJORUwpOwotCWlmICghdWZiZGV2KQotCQlyZXR1cm4gLUVOT01FTTsKLQot CXVkbC0+ZmJkZXYgPSB1ZmJkZXY7Ci0KLQlkcm1fZmJfaGVscGVyX3ByZXBhcmUoZGV2LCAmdWZi ZGV2LT5oZWxwZXIsICZ1ZGxfZmJfaGVscGVyX2Z1bmNzKTsKLQotCXJldCA9IGRybV9mYl9oZWxw ZXJfaW5pdChkZXYsICZ1ZmJkZXYtPmhlbHBlciwgMSk7Ci0JaWYgKHJldCkKLQkJZ290byBmcmVl OwotCi0JcmV0ID0gZHJtX2ZiX2hlbHBlcl9zaW5nbGVfYWRkX2FsbF9jb25uZWN0b3JzKCZ1ZmJk ZXYtPmhlbHBlcik7Ci0JaWYgKHJldCkKLQkJZ290byBmaW5pOwotCi0JLyogZGlzYWJsZSBhbGwg dGhlIHBvc3NpYmxlIG91dHB1dHMvY3J0Y3MgYmVmb3JlIGVudGVyaW5nIEtNUyBtb2RlICovCi0J ZHJtX2hlbHBlcl9kaXNhYmxlX3VudXNlZF9mdW5jdGlvbnMoZGV2KTsKLQotCXJldCA9IGRybV9m Yl9oZWxwZXJfaW5pdGlhbF9jb25maWcoJnVmYmRldi0+aGVscGVyLCBicHBfc2VsKTsKLQlpZiAo cmV0KQotCQlnb3RvIGZpbmk7Ci0KLQlyZXR1cm4gMDsKLQotZmluaToKLQlkcm1fZmJfaGVscGVy X2ZpbmkoJnVmYmRldi0+aGVscGVyKTsKLWZyZWU6Ci0Ja2ZyZWUodWZiZGV2KTsKLQlyZXR1cm4g cmV0OwotfQotCi12b2lkIHVkbF9mYmRldl9jbGVhbnVwKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYp Ci17Ci0Jc3RydWN0IHVkbF9kZXZpY2UgKnVkbCA9IHRvX3VkbChkZXYpOwotCWlmICghdWRsLT5m YmRldikKLQkJcmV0dXJuOwotCi0JdWRsX2ZiZGV2X2Rlc3Ryb3koZGV2LCB1ZGwtPmZiZGV2KTsK LQlrZnJlZSh1ZGwtPmZiZGV2KTsKLQl1ZGwtPmZiZGV2ID0gTlVMTDsKLX0KLQotdm9pZCB1ZGxf ZmJkZXZfdW5wbHVnKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYpCi17Ci0Jc3RydWN0IHVkbF9kZXZp Y2UgKnVkbCA9IHRvX3VkbChkZXYpOwotCXN0cnVjdCB1ZGxfZmJkZXYgKnVmYmRldjsKLQlpZiAo IXVkbC0+ZmJkZXYpCi0JCXJldHVybjsKLQotCXVmYmRldiA9IHVkbC0+ZmJkZXY7Ci0JZHJtX2Zi X2hlbHBlcl91bmxpbmtfZmJpKCZ1ZmJkZXYtPmhlbHBlcik7Ci19Ci0KIHN0cnVjdCBkcm1fZnJh bWVidWZmZXIgKgogdWRsX2ZiX3VzZXJfZmJfY3JlYXRlKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYs CiAJCSAgIHN0cnVjdCBkcm1fZmlsZSAqZmlsZSwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2Ry bS91ZGwvdWRsX21haW4uYyBiL2RyaXZlcnMvZ3B1L2RybS91ZGwvdWRsX21haW4uYwppbmRleCA0 ZTg1NGUwMTczOTAuLmQ0NDczZjU5NGI0NSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3Vk bC91ZGxfbWFpbi5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS91ZGwvdWRsX21haW4uYwpAQCAtOSw2 ICs5LDcgQEAKICAqLwogCiAjaW5jbHVkZSA8ZHJtL2RybS5oPgorI2luY2x1ZGUgPGRybS9kcm1f ZmJfaGVscGVyLmg+CiAjaW5jbHVkZSA8ZHJtL2RybV9wcmludC5oPgogI2luY2x1ZGUgPGRybS9k cm1fcHJvYmVfaGVscGVyLmg+CiAKQEAgLTMzOCw3ICszMzksNyBAQCBpbnQgdWRsX2luaXQoc3Ry dWN0IHVkbF9kZXZpY2UgKnVkbCkKIAlpZiAocmV0KQogCQlnb3RvIGVycjsKIAotCXJldCA9IHVk bF9mYmRldl9pbml0KGRldik7CisJcmV0ID0gZHJtX2ZiZGV2X2dlbmVyaWNfc2V0dXAoZGV2LCAw KTsKIAlpZiAocmV0KQogCQlnb3RvIGVycjsKIApAQCAtMzY3LDYgKzM2OCw0IEBAIHZvaWQgdWRs X2Zpbmkoc3RydWN0IGRybV9kZXZpY2UgKmRldikKIAogCWlmICh1ZGwtPnVyYnMuY291bnQpCiAJ CXVkbF9mcmVlX3VyYl9saXN0KGRldik7Ci0KLQl1ZGxfZmJkZXZfY2xlYW51cChkZXYpOwogfQpk aWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3VkbC91ZGxfbW9kZXNldC5jIGIvZHJpdmVycy9n cHUvZHJtL3VkbC91ZGxfbW9kZXNldC5jCmluZGV4IDFmOGViY2M1OTVkZS4uOWI1NTk1OGFmMjM4 IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vdWRsL3VkbF9tb2Rlc2V0LmMKKysrIGIvZHJp dmVycy9ncHUvZHJtL3VkbC91ZGxfbW9kZXNldC5jCkBAIC00MjIsNyArNDIyLDYgQEAgc3RhdGlj IGludCB1ZGxfY3J0Y19pbml0KHN0cnVjdCBkcm1fZGV2aWNlICpkZXYpCiAKIHN0YXRpYyBjb25z dCBzdHJ1Y3QgZHJtX21vZGVfY29uZmlnX2Z1bmNzIHVkbF9tb2RlX2Z1bmNzID0gewogCS5mYl9j cmVhdGUgPSB1ZGxfZmJfdXNlcl9mYl9jcmVhdGUsCi0JLm91dHB1dF9wb2xsX2NoYW5nZWQgPSBO VUxMLAogfTsKIAogaW50IHVkbF9tb2Rlc2V0X2luaXQoc3RydWN0IGRybV9kZXZpY2UgKmRldikK LS0gCjIuMjMuMAoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3Jn Cmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVs