From mboxrd@z Thu Jan 1 00:00:00 1970 From: Mikulas Patocka Date: Sun, 03 Jun 2018 14:41:11 +0000 Subject: [PATCH 18/21] udlfb: allow reallocating the framebuffer Message-Id: <20180603144225.463043082@twibright.com> List-Id: References: <20180603144053.875668929@twibright.com> MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit To: Mikulas Patocka , Bartlomiej Zolnierkiewicz , Dave Airlie , Bernie Thompson , Ladislav Michl Cc: linux-fbdev@vger.kernel.org, dri-devel@lists.freedesktop.org This patch changes udlfb so that it may reallocate the framebuffer when setting higher-resolution mode. If we boot the system without monitor attached, udlfb creates a framebuffer with the size 800x600. This patch makes it possible to select higher videomode with the fbset command when a monitor is attached. Note that there is no reliable way to prevent the system from touching the old framebuffer, so we must not free it. We add it to the list dlfb->deferred_free and free it when the driver is unloaded. Signed-off-by: Mikulas Patocka --- drivers/video/fbdev/udlfb.c | 70 +++++++++++++++++++++++++++++--------------- include/video/udlfb.h | 1 2 files changed, 48 insertions(+), 23 deletions(-) Index: linux-4.17-rc7/drivers/video/fbdev/udlfb.c =================================--- linux-4.17-rc7.orig/drivers/video/fbdev/udlfb.c 2018-06-03 13:17:41.000000000 +0200 +++ linux-4.17-rc7/drivers/video/fbdev/udlfb.c 2018-06-03 13:17:41.000000000 +0200 @@ -73,6 +73,13 @@ static bool fb_defio = 1; /* Detect mma static bool shadow = 1; /* Optionally disable shadow framebuffer */ static int pixel_limit; /* Optionally force a pixel resolution limit */ +struct dlfb_deferred_free { + struct list_head list; + void *mem; +}; + +static int dlfb_realloc_framebuffer(struct dlfb_data *dlfb, struct fb_info *info, u32 new_len); + /* dlfb keeps a list of urbs for efficient bulk transfers */ static void dlfb_urb_completion(struct urb *urb); static struct urb *dlfb_get_urb(struct dlfb_data *dlfb); @@ -927,6 +934,12 @@ static void dlfb_free(struct kref *kref) { struct dlfb_data *dlfb = container_of(kref, struct dlfb_data, kref); + while (!list_empty(&dlfb->deferred_free)) { + struct dlfb_deferred_free *d = list_entry(dlfb->deferred_free.next, struct dlfb_deferred_free, list); + list_del(&d->list); + vfree(d->mem); + kfree(d); + } vfree(dlfb->backing_buffer); kfree(dlfb->edid); kfree(dlfb); @@ -1020,10 +1033,6 @@ static int dlfb_ops_check_var(struct fb_ struct fb_videomode mode; struct dlfb_data *dlfb = info->par; - /* TODO: support dynamically changing framebuffer size */ - if ((var->xres * var->yres * 2) > info->fix.smem_len) - return -EINVAL; - /* set device-specific elements of var unrelated to mode */ dlfb_var_color_format(var); @@ -1042,6 +1051,7 @@ static int dlfb_ops_set_par(struct fb_in u16 *pix_framebuffer; int i; struct fb_var_screeninfo fvs; + u32 line_length = info->var.xres * (info->var.bits_per_pixel / 8); /* clear the activate field because it causes spurious miscompares */ fvs = info->var; @@ -1051,13 +1061,17 @@ static int dlfb_ops_set_par(struct fb_in if (!memcmp(&dlfb->current_mode, &fvs, sizeof(struct fb_var_screeninfo))) return 0; + result = dlfb_realloc_framebuffer(dlfb, info, info->var.yres * line_length); + if (result) + return result; + result = dlfb_set_video_mode(dlfb, &info->var); if (result) return result; dlfb->current_mode = fvs; - info->fix.line_length = info->var.xres * (info->var.bits_per_pixel / 8); + info->fix.line_length = line_length; if (dlfb->fb_count = 0) { @@ -1066,11 +1080,11 @@ static int dlfb_ops_set_par(struct fb_in pix_framebuffer = (u16 *) info->screen_base; for (i = 0; i < info->fix.smem_len / 2; i++) pix_framebuffer[i] = 0x37e6; - - dlfb_handle_damage(dlfb, 0, 0, info->var.xres, info->var.yres, - info->screen_base); } + dlfb_handle_damage(dlfb, 0, 0, info->var.xres, info->var.yres, + info->screen_base); + return 0; } @@ -1146,21 +1160,29 @@ static struct fb_ops dlfb_ops = { }; +static void dlfb_deferred_vfree(struct dlfb_data *dlfb, void *mem) +{ + struct dlfb_deferred_free *d = kmalloc(sizeof(struct dlfb_deferred_free), GFP_KERNEL); + if (!d) + return; + d->mem = mem; + list_add(&d->list, &dlfb->deferred_free); +} + /* * Assumes &info->lock held by caller * Assumes no active clients have framebuffer open */ -static int dlfb_realloc_framebuffer(struct dlfb_data *dlfb, struct fb_info *info) +static int dlfb_realloc_framebuffer(struct dlfb_data *dlfb, struct fb_info *info, u32 new_len) { - int old_len = info->fix.smem_len; - int new_len; + u32 old_len = info->fix.smem_len; unsigned char *old_fb = info->screen_base; unsigned char *new_fb; unsigned char *new_back = NULL; - new_len = info->fix.line_length * info->var.yres; + new_len = PAGE_ALIGN(new_len); - if (PAGE_ALIGN(new_len) > old_len) { + if (new_len > old_len) { /* * Alloc system memory for virtual framebuffer */ @@ -1169,14 +1191,15 @@ static int dlfb_realloc_framebuffer(stru dev_err(info->dev, "Virtual framebuffer alloc failed\n"); return -ENOMEM; } + memset(new_fb, 0xff, new_len); if (info->screen_base) { memcpy(new_fb, old_fb, old_len); - vfree(info->screen_base); + dlfb_deferred_vfree(dlfb, info->screen_base); } info->screen_base = new_fb; - info->fix.smem_len = PAGE_ALIGN(new_len); + info->fix.smem_len = new_len; info->fix.smem_start = (unsigned long) new_fb; info->flags = udlfb_info_flags; @@ -1192,7 +1215,7 @@ static int dlfb_realloc_framebuffer(stru dev_info(info->dev, "No shadow/backing buffer allocated\n"); else { - vfree(dlfb->backing_buffer); + dlfb_deferred_vfree(dlfb, dlfb->backing_buffer); dlfb->backing_buffer = new_back; } } @@ -1344,11 +1367,6 @@ static int dlfb_setup_modes(struct dlfb_ * with mode size info, we can now alloc our framebuffer. */ memcpy(&info->fix, &dlfb_fix, sizeof(dlfb_fix)); - info->fix.line_length = info->var.xres * - (info->var.bits_per_pixel / 8); - - result = dlfb_realloc_framebuffer(dlfb, info); - } else result = -EINVAL; @@ -1436,7 +1454,10 @@ static ssize_t edid_store( if (!dlfb->edid || memcmp(src, dlfb->edid, src_size)) return -EINVAL; - dlfb_ops_set_par(fb_info); + ret = dlfb_ops_set_par(fb_info); + if (ret) + return ret; + return src_size; } @@ -1596,6 +1617,7 @@ static int dlfb_usb_probe(struct usb_int } kref_init(&dlfb->kref); /* matching kref_put in usb .disconnect fn */ + INIT_LIST_HEAD(&dlfb->deferred_free); dlfb->udev = usbdev; usb_set_intfdata(intf, dlfb); @@ -1693,7 +1715,9 @@ static void dlfb_init_framebuffer_work(s dlfb_select_std_channel(dlfb); dlfb_ops_check_var(&info->var, info); - dlfb_ops_set_par(info); + retval = dlfb_ops_set_par(info); + if (retval) + goto error; retval = register_framebuffer(info); if (retval < 0) { Index: linux-4.17-rc7/include/video/udlfb.h =================================--- linux-4.17-rc7.orig/include/video/udlfb.h 2018-06-03 13:17:41.000000000 +0200 +++ linux-4.17-rc7/include/video/udlfb.h 2018-06-03 13:17:41.000000000 +0200 @@ -58,6 +58,7 @@ struct dlfb_data { atomic_t bytes_sent; /* to usb, after compression including overhead */ atomic_t cpu_kcycles_used; /* transpired during pixel processing */ struct fb_var_screeninfo current_mode; + struct list_head deferred_free; }; #define NR_USB_REQUEST_I2C_SUB_IO 0x02 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Mikulas Patocka Subject: [PATCH 18/21] udlfb: allow reallocating the framebuffer Date: Sun, 03 Jun 2018 16:41:11 +0200 Message-ID: <20180603144225.463043082@twibright.com> References: <20180603144053.875668929@twibright.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from leontynka.twibright.com (109-183-129-149.tmcz.cz [109.183.129.149]) by gabe.freedesktop.org (Postfix) with ESMTPS id 551D489C5E for ; Sun, 3 Jun 2018 15:19:09 +0000 (UTC) Content-Disposition: inline; filename=udl-realloc-framebuffer.patch List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: Mikulas Patocka , Bartlomiej Zolnierkiewicz , Dave Airlie , Bernie Thompson , Ladislav Michl Cc: linux-fbdev@vger.kernel.org, dri-devel@lists.freedesktop.org List-Id: dri-devel@lists.freedesktop.org VGhpcyBwYXRjaCBjaGFuZ2VzIHVkbGZiIHNvIHRoYXQgaXQgbWF5IHJlYWxsb2NhdGUgdGhlIGZy YW1lYnVmZmVyIHdoZW4Kc2V0dGluZyBoaWdoZXItcmVzb2x1dGlvbiBtb2RlLiBJZiB3ZSBib290 IHRoZSBzeXN0ZW0gd2l0aG91dCBtb25pdG9yCmF0dGFjaGVkLCB1ZGxmYiBjcmVhdGVzIGEgZnJh bWVidWZmZXIgd2l0aCB0aGUgc2l6ZSA4MDB4NjAwLiBUaGlzIHBhdGNoCm1ha2VzIGl0IHBvc3Np YmxlIHRvIHNlbGVjdCBoaWdoZXIgdmlkZW9tb2RlIHdpdGggdGhlIGZic2V0IGNvbW1hbmQgd2hl bgphIG1vbml0b3IgaXMgYXR0YWNoZWQuCgpOb3RlIHRoYXQgdGhlcmUgaXMgbm8gcmVsaWFibGUg d2F5IHRvIHByZXZlbnQgdGhlIHN5c3RlbSBmcm9tIHRvdWNoaW5nIHRoZQpvbGQgZnJhbWVidWZm ZXIsIHNvIHdlIG11c3Qgbm90IGZyZWUgaXQuIFdlIGFkZCBpdCB0byB0aGUgbGlzdApkbGZiLT5k ZWZlcnJlZF9mcmVlIGFuZCBmcmVlIGl0IHdoZW4gdGhlIGRyaXZlciBpcyB1bmxvYWRlZC4KClNp Z25lZC1vZmYtYnk6IE1pa3VsYXMgUGF0b2NrYSA8bXBhdG9ja2FAcmVkaGF0LmNvbT4KCi0tLQog ZHJpdmVycy92aWRlby9mYmRldi91ZGxmYi5jIHwgICA3MCArKysrKysrKysrKysrKysrKysrKysr KysrKysrKy0tLS0tLS0tLS0tLS0tLQogaW5jbHVkZS92aWRlby91ZGxmYi5oICAgICAgIHwgICAg MSAKIDIgZmlsZXMgY2hhbmdlZCwgNDggaW5zZXJ0aW9ucygrKSwgMjMgZGVsZXRpb25zKC0pCgpJ bmRleDogbGludXgtNC4xNy1yYzcvZHJpdmVycy92aWRlby9mYmRldi91ZGxmYi5jCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIGxpbnV4LTQuMTctcmM3Lm9yaWcvZHJpdmVycy92aWRlby9mYmRldi91ZGxmYi5jCTIw MTgtMDYtMDMgMTM6MTc6NDEuMDAwMDAwMDAwICswMjAwCisrKyBsaW51eC00LjE3LXJjNy9kcml2 ZXJzL3ZpZGVvL2ZiZGV2L3VkbGZiLmMJMjAxOC0wNi0wMyAxMzoxNzo0MS4wMDAwMDAwMDAgKzAy MDAKQEAgLTczLDYgKzczLDEzIEBAIHN0YXRpYyBib29sIGZiX2RlZmlvID0gMTsgIC8qIERldGVj dCBtbWEKIHN0YXRpYyBib29sIHNoYWRvdyA9IDE7IC8qIE9wdGlvbmFsbHkgZGlzYWJsZSBzaGFk b3cgZnJhbWVidWZmZXIgKi8KIHN0YXRpYyBpbnQgcGl4ZWxfbGltaXQ7IC8qIE9wdGlvbmFsbHkg Zm9yY2UgYSBwaXhlbCByZXNvbHV0aW9uIGxpbWl0ICovCiAKK3N0cnVjdCBkbGZiX2RlZmVycmVk X2ZyZWUgeworCXN0cnVjdCBsaXN0X2hlYWQgbGlzdDsKKwl2b2lkICptZW07Cit9OworCitzdGF0 aWMgaW50IGRsZmJfcmVhbGxvY19mcmFtZWJ1ZmZlcihzdHJ1Y3QgZGxmYl9kYXRhICpkbGZiLCBz dHJ1Y3QgZmJfaW5mbyAqaW5mbywgdTMyIG5ld19sZW4pOworCiAvKiBkbGZiIGtlZXBzIGEgbGlz dCBvZiB1cmJzIGZvciBlZmZpY2llbnQgYnVsayB0cmFuc2ZlcnMgKi8KIHN0YXRpYyB2b2lkIGRs ZmJfdXJiX2NvbXBsZXRpb24oc3RydWN0IHVyYiAqdXJiKTsKIHN0YXRpYyBzdHJ1Y3QgdXJiICpk bGZiX2dldF91cmIoc3RydWN0IGRsZmJfZGF0YSAqZGxmYik7CkBAIC05MjcsNiArOTM0LDEyIEBA IHN0YXRpYyB2b2lkIGRsZmJfZnJlZShzdHJ1Y3Qga3JlZiAqa3JlZikKIHsKIAlzdHJ1Y3QgZGxm Yl9kYXRhICpkbGZiID0gY29udGFpbmVyX29mKGtyZWYsIHN0cnVjdCBkbGZiX2RhdGEsIGtyZWYp OwogCisJd2hpbGUgKCFsaXN0X2VtcHR5KCZkbGZiLT5kZWZlcnJlZF9mcmVlKSkgeworCQlzdHJ1 Y3QgZGxmYl9kZWZlcnJlZF9mcmVlICpkID0gbGlzdF9lbnRyeShkbGZiLT5kZWZlcnJlZF9mcmVl Lm5leHQsIHN0cnVjdCBkbGZiX2RlZmVycmVkX2ZyZWUsIGxpc3QpOworCQlsaXN0X2RlbCgmZC0+ bGlzdCk7CisJCXZmcmVlKGQtPm1lbSk7CisJCWtmcmVlKGQpOworCX0KIAl2ZnJlZShkbGZiLT5i YWNraW5nX2J1ZmZlcik7CiAJa2ZyZWUoZGxmYi0+ZWRpZCk7CiAJa2ZyZWUoZGxmYik7CkBAIC0x MDIwLDEwICsxMDMzLDYgQEAgc3RhdGljIGludCBkbGZiX29wc19jaGVja192YXIoc3RydWN0IGZi XwogCXN0cnVjdCBmYl92aWRlb21vZGUgbW9kZTsKIAlzdHJ1Y3QgZGxmYl9kYXRhICpkbGZiID0g aW5mby0+cGFyOwogCi0JLyogVE9ETzogc3VwcG9ydCBkeW5hbWljYWxseSBjaGFuZ2luZyBmcmFt ZWJ1ZmZlciBzaXplICovCi0JaWYgKCh2YXItPnhyZXMgKiB2YXItPnlyZXMgKiAyKSA+IGluZm8t PmZpeC5zbWVtX2xlbikKLQkJcmV0dXJuIC1FSU5WQUw7Ci0KIAkvKiBzZXQgZGV2aWNlLXNwZWNp ZmljIGVsZW1lbnRzIG9mIHZhciB1bnJlbGF0ZWQgdG8gbW9kZSAqLwogCWRsZmJfdmFyX2NvbG9y X2Zvcm1hdCh2YXIpOwogCkBAIC0xMDQyLDYgKzEwNTEsNyBAQCBzdGF0aWMgaW50IGRsZmJfb3Bz X3NldF9wYXIoc3RydWN0IGZiX2luCiAJdTE2ICpwaXhfZnJhbWVidWZmZXI7CiAJaW50IGk7CiAJ c3RydWN0IGZiX3Zhcl9zY3JlZW5pbmZvIGZ2czsKKwl1MzIgbGluZV9sZW5ndGggPSBpbmZvLT52 YXIueHJlcyAqIChpbmZvLT52YXIuYml0c19wZXJfcGl4ZWwgLyA4KTsKIAogCS8qIGNsZWFyIHRo ZSBhY3RpdmF0ZSBmaWVsZCBiZWNhdXNlIGl0IGNhdXNlcyBzcHVyaW91cyBtaXNjb21wYXJlcyAq LwogCWZ2cyA9IGluZm8tPnZhcjsKQEAgLTEwNTEsMTMgKzEwNjEsMTcgQEAgc3RhdGljIGludCBk bGZiX29wc19zZXRfcGFyKHN0cnVjdCBmYl9pbgogCWlmICghbWVtY21wKCZkbGZiLT5jdXJyZW50 X21vZGUsICZmdnMsIHNpemVvZihzdHJ1Y3QgZmJfdmFyX3NjcmVlbmluZm8pKSkKIAkJcmV0dXJu IDA7CiAKKwlyZXN1bHQgPSBkbGZiX3JlYWxsb2NfZnJhbWVidWZmZXIoZGxmYiwgaW5mbywgaW5m by0+dmFyLnlyZXMgKiBsaW5lX2xlbmd0aCk7CisJaWYgKHJlc3VsdCkKKwkJcmV0dXJuIHJlc3Vs dDsKKwogCXJlc3VsdCA9IGRsZmJfc2V0X3ZpZGVvX21vZGUoZGxmYiwgJmluZm8tPnZhcik7CiAK IAlpZiAocmVzdWx0KQogCQlyZXR1cm4gcmVzdWx0OwogCiAJZGxmYi0+Y3VycmVudF9tb2RlID0g ZnZzOwotCWluZm8tPmZpeC5saW5lX2xlbmd0aCA9IGluZm8tPnZhci54cmVzICogKGluZm8tPnZh ci5iaXRzX3Blcl9waXhlbCAvIDgpOworCWluZm8tPmZpeC5saW5lX2xlbmd0aCA9IGxpbmVfbGVu Z3RoOwogCiAJaWYgKGRsZmItPmZiX2NvdW50ID09IDApIHsKIApAQCAtMTA2NiwxMSArMTA4MCwx MSBAQCBzdGF0aWMgaW50IGRsZmJfb3BzX3NldF9wYXIoc3RydWN0IGZiX2luCiAJCXBpeF9mcmFt ZWJ1ZmZlciA9ICh1MTYgKikgaW5mby0+c2NyZWVuX2Jhc2U7CiAJCWZvciAoaSA9IDA7IGkgPCBp bmZvLT5maXguc21lbV9sZW4gLyAyOyBpKyspCiAJCQlwaXhfZnJhbWVidWZmZXJbaV0gPSAweDM3 ZTY7Ci0KLQkJZGxmYl9oYW5kbGVfZGFtYWdlKGRsZmIsIDAsIDAsIGluZm8tPnZhci54cmVzLCBp bmZvLT52YXIueXJlcywKLQkJCQkgICBpbmZvLT5zY3JlZW5fYmFzZSk7CiAJfQogCisJZGxmYl9o YW5kbGVfZGFtYWdlKGRsZmIsIDAsIDAsIGluZm8tPnZhci54cmVzLCBpbmZvLT52YXIueXJlcywK KwkJCSAgIGluZm8tPnNjcmVlbl9iYXNlKTsKKwogCXJldHVybiAwOwogfQogCkBAIC0xMTQ2LDIx ICsxMTYwLDI5IEBAIHN0YXRpYyBzdHJ1Y3QgZmJfb3BzIGRsZmJfb3BzID0gewogfTsKIAogCitz dGF0aWMgdm9pZCBkbGZiX2RlZmVycmVkX3ZmcmVlKHN0cnVjdCBkbGZiX2RhdGEgKmRsZmIsIHZv aWQgKm1lbSkKK3sKKwlzdHJ1Y3QgZGxmYl9kZWZlcnJlZF9mcmVlICpkID0ga21hbGxvYyhzaXpl b2Yoc3RydWN0IGRsZmJfZGVmZXJyZWRfZnJlZSksIEdGUF9LRVJORUwpOworCWlmICghZCkKKwkJ cmV0dXJuOworCWQtPm1lbSA9IG1lbTsKKwlsaXN0X2FkZCgmZC0+bGlzdCwgJmRsZmItPmRlZmVy cmVkX2ZyZWUpOworfQorCiAvKgogICogQXNzdW1lcyAmaW5mby0+bG9jayBoZWxkIGJ5IGNhbGxl cgogICogQXNzdW1lcyBubyBhY3RpdmUgY2xpZW50cyBoYXZlIGZyYW1lYnVmZmVyIG9wZW4KICAq Lwotc3RhdGljIGludCBkbGZiX3JlYWxsb2NfZnJhbWVidWZmZXIoc3RydWN0IGRsZmJfZGF0YSAq ZGxmYiwgc3RydWN0IGZiX2luZm8gKmluZm8pCitzdGF0aWMgaW50IGRsZmJfcmVhbGxvY19mcmFt ZWJ1ZmZlcihzdHJ1Y3QgZGxmYl9kYXRhICpkbGZiLCBzdHJ1Y3QgZmJfaW5mbyAqaW5mbywgdTMy IG5ld19sZW4pCiB7Ci0JaW50IG9sZF9sZW4gPSBpbmZvLT5maXguc21lbV9sZW47Ci0JaW50IG5l d19sZW47CisJdTMyIG9sZF9sZW4gPSBpbmZvLT5maXguc21lbV9sZW47CiAJdW5zaWduZWQgY2hh ciAqb2xkX2ZiID0gaW5mby0+c2NyZWVuX2Jhc2U7CiAJdW5zaWduZWQgY2hhciAqbmV3X2ZiOwog CXVuc2lnbmVkIGNoYXIgKm5ld19iYWNrID0gTlVMTDsKIAotCW5ld19sZW4gPSBpbmZvLT5maXgu bGluZV9sZW5ndGggKiBpbmZvLT52YXIueXJlczsKKwluZXdfbGVuID0gUEFHRV9BTElHTihuZXdf bGVuKTsKIAotCWlmIChQQUdFX0FMSUdOKG5ld19sZW4pID4gb2xkX2xlbikgeworCWlmIChuZXdf bGVuID4gb2xkX2xlbikgewogCQkvKgogCQkgKiBBbGxvYyBzeXN0ZW0gbWVtb3J5IGZvciB2aXJ0 dWFsIGZyYW1lYnVmZmVyCiAJCSAqLwpAQCAtMTE2OSwxNCArMTE5MSwxNSBAQCBzdGF0aWMgaW50 IGRsZmJfcmVhbGxvY19mcmFtZWJ1ZmZlcihzdHJ1CiAJCQlkZXZfZXJyKGluZm8tPmRldiwgIlZp cnR1YWwgZnJhbWVidWZmZXIgYWxsb2MgZmFpbGVkXG4iKTsKIAkJCXJldHVybiAtRU5PTUVNOwog CQl9CisJCW1lbXNldChuZXdfZmIsIDB4ZmYsIG5ld19sZW4pOwogCiAJCWlmIChpbmZvLT5zY3Jl ZW5fYmFzZSkgewogCQkJbWVtY3B5KG5ld19mYiwgb2xkX2ZiLCBvbGRfbGVuKTsKLQkJCXZmcmVl KGluZm8tPnNjcmVlbl9iYXNlKTsKKwkJCWRsZmJfZGVmZXJyZWRfdmZyZWUoZGxmYiwgaW5mby0+ c2NyZWVuX2Jhc2UpOwogCQl9CiAKIAkJaW5mby0+c2NyZWVuX2Jhc2UgPSBuZXdfZmI7Ci0JCWlu Zm8tPmZpeC5zbWVtX2xlbiA9IFBBR0VfQUxJR04obmV3X2xlbik7CisJCWluZm8tPmZpeC5zbWVt X2xlbiA9IG5ld19sZW47CiAJCWluZm8tPmZpeC5zbWVtX3N0YXJ0ID0gKHVuc2lnbmVkIGxvbmcp IG5ld19mYjsKIAkJaW5mby0+ZmxhZ3MgPSB1ZGxmYl9pbmZvX2ZsYWdzOwogCkBAIC0xMTkyLDcg KzEyMTUsNyBAQCBzdGF0aWMgaW50IGRsZmJfcmVhbGxvY19mcmFtZWJ1ZmZlcihzdHJ1CiAJCQlk ZXZfaW5mbyhpbmZvLT5kZXYsCiAJCQkJICJObyBzaGFkb3cvYmFja2luZyBidWZmZXIgYWxsb2Nh dGVkXG4iKTsKIAkJZWxzZSB7Ci0JCQl2ZnJlZShkbGZiLT5iYWNraW5nX2J1ZmZlcik7CisJCQlk bGZiX2RlZmVycmVkX3ZmcmVlKGRsZmIsIGRsZmItPmJhY2tpbmdfYnVmZmVyKTsKIAkJCWRsZmIt PmJhY2tpbmdfYnVmZmVyID0gbmV3X2JhY2s7CiAJCX0KIAl9CkBAIC0xMzQ0LDExICsxMzY3LDYg QEAgc3RhdGljIGludCBkbGZiX3NldHVwX21vZGVzKHN0cnVjdCBkbGZiXwogCQkgKiB3aXRoIG1v ZGUgc2l6ZSBpbmZvLCB3ZSBjYW4gbm93IGFsbG9jIG91ciBmcmFtZWJ1ZmZlci4KIAkJICovCiAJ CW1lbWNweSgmaW5mby0+Zml4LCAmZGxmYl9maXgsIHNpemVvZihkbGZiX2ZpeCkpOwotCQlpbmZv LT5maXgubGluZV9sZW5ndGggPSBpbmZvLT52YXIueHJlcyAqCi0JCQkoaW5mby0+dmFyLmJpdHNf cGVyX3BpeGVsIC8gOCk7Ci0KLQkJcmVzdWx0ID0gZGxmYl9yZWFsbG9jX2ZyYW1lYnVmZmVyKGRs ZmIsIGluZm8pOwotCiAJfSBlbHNlCiAJCXJlc3VsdCA9IC1FSU5WQUw7CiAKQEAgLTE0MzYsNyAr MTQ1NCwxMCBAQCBzdGF0aWMgc3NpemVfdCBlZGlkX3N0b3JlKAogCWlmICghZGxmYi0+ZWRpZCB8 fCBtZW1jbXAoc3JjLCBkbGZiLT5lZGlkLCBzcmNfc2l6ZSkpCiAJCXJldHVybiAtRUlOVkFMOwog Ci0JZGxmYl9vcHNfc2V0X3BhcihmYl9pbmZvKTsKKwlyZXQgPSBkbGZiX29wc19zZXRfcGFyKGZi X2luZm8pOworCWlmIChyZXQpCisJCXJldHVybiByZXQ7CisKIAlyZXR1cm4gc3JjX3NpemU7CiB9 CiAKQEAgLTE1OTYsNiArMTYxNyw3IEBAIHN0YXRpYyBpbnQgZGxmYl91c2JfcHJvYmUoc3RydWN0 IHVzYl9pbnQKIAl9CiAKIAlrcmVmX2luaXQoJmRsZmItPmtyZWYpOyAvKiBtYXRjaGluZyBrcmVm X3B1dCBpbiB1c2IgLmRpc2Nvbm5lY3QgZm4gKi8KKwlJTklUX0xJU1RfSEVBRCgmZGxmYi0+ZGVm ZXJyZWRfZnJlZSk7CiAKIAlkbGZiLT51ZGV2ID0gdXNiZGV2OwogCXVzYl9zZXRfaW50ZmRhdGEo aW50ZiwgZGxmYik7CkBAIC0xNjkzLDcgKzE3MTUsOSBAQCBzdGF0aWMgdm9pZCBkbGZiX2luaXRf ZnJhbWVidWZmZXJfd29yayhzCiAJZGxmYl9zZWxlY3Rfc3RkX2NoYW5uZWwoZGxmYik7CiAKIAlk bGZiX29wc19jaGVja192YXIoJmluZm8tPnZhciwgaW5mbyk7Ci0JZGxmYl9vcHNfc2V0X3Bhcihp bmZvKTsKKwlyZXR2YWwgPSBkbGZiX29wc19zZXRfcGFyKGluZm8pOworCWlmIChyZXR2YWwpCisJ CWdvdG8gZXJyb3I7CiAKIAlyZXR2YWwgPSByZWdpc3Rlcl9mcmFtZWJ1ZmZlcihpbmZvKTsKIAlp ZiAocmV0dmFsIDwgMCkgewpJbmRleDogbGludXgtNC4xNy1yYzcvaW5jbHVkZS92aWRlby91ZGxm Yi5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIGxpbnV4LTQuMTctcmM3Lm9yaWcvaW5jbHVkZS92aWRlby91ZGxm Yi5oCTIwMTgtMDYtMDMgMTM6MTc6NDEuMDAwMDAwMDAwICswMjAwCisrKyBsaW51eC00LjE3LXJj Ny9pbmNsdWRlL3ZpZGVvL3VkbGZiLmgJMjAxOC0wNi0wMyAxMzoxNzo0MS4wMDAwMDAwMDAgKzAy MDAKQEAgLTU4LDYgKzU4LDcgQEAgc3RydWN0IGRsZmJfZGF0YSB7CiAJYXRvbWljX3QgYnl0ZXNf c2VudDsgLyogdG8gdXNiLCBhZnRlciBjb21wcmVzc2lvbiBpbmNsdWRpbmcgb3ZlcmhlYWQgKi8K IAlhdG9taWNfdCBjcHVfa2N5Y2xlc191c2VkOyAvKiB0cmFuc3BpcmVkIGR1cmluZyBwaXhlbCBw cm9jZXNzaW5nICovCiAJc3RydWN0IGZiX3Zhcl9zY3JlZW5pbmZvIGN1cnJlbnRfbW9kZTsKKwlz dHJ1Y3QgbGlzdF9oZWFkIGRlZmVycmVkX2ZyZWU7CiB9OwogCiAjZGVmaW5lIE5SX1VTQl9SRVFV RVNUX0kyQ19TVUJfSU8gMHgwMgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRl c2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8v ZHJpLWRldmVsCg==