From mboxrd@z Thu Jan 1 00:00:00 1970 From: Mikulas Patocka Date: Sun, 03 Jun 2018 14:41:00 +0000 Subject: [PATCH 07/21] udl-kms: avoid division Message-Id: <20180603144221.605787225@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 Division is slow, so it shouldn't be done by the pixel generating code. The driver supports only 2 or 4 bytes per pixel, so we can replace division with a shift. Signed-off-by: Mikulas Patocka Cc: stable@vger.kernel.org --- drivers/gpu/drm/udl/udl_drv.h | 2 - drivers/gpu/drm/udl/udl_fb.c | 15 ++++++++------ drivers/gpu/drm/udl/udl_transfer.c | 39 ++++++++++++++++++------------------- 3 files changed, 30 insertions(+), 26 deletions(-) Index: linux-4.17-rc7/drivers/gpu/drm/udl/udl_drv.h =================================--- linux-4.17-rc7.orig/drivers/gpu/drm/udl/udl_drv.h 2018-06-03 13:15:01.000000000 +0200 +++ linux-4.17-rc7/drivers/gpu/drm/udl/udl_drv.h 2018-06-03 13:15:01.000000000 +0200 @@ -110,7 +110,7 @@ udl_fb_user_fb_create(struct drm_device struct drm_file *file, const struct drm_mode_fb_cmd2 *mode_cmd); -int udl_render_hline(struct drm_device *dev, int bpp, struct urb **urb_ptr, +int udl_render_hline(struct drm_device *dev, int log_bpp, struct urb **urb_ptr, const char *front, char **urb_buf_ptr, u32 byte_offset, u32 device_byte_offset, u32 byte_width, int *ident_ptr, int *sent_ptr); Index: linux-4.17-rc7/drivers/gpu/drm/udl/udl_fb.c =================================--- linux-4.17-rc7.orig/drivers/gpu/drm/udl/udl_fb.c 2018-06-03 13:15:01.000000000 +0200 +++ linux-4.17-rc7/drivers/gpu/drm/udl/udl_fb.c 2018-06-03 13:15:01.000000000 +0200 @@ -91,7 +91,10 @@ int udl_handle_damage(struct udl_framebu int bytes_identical = 0; struct urb *urb; int aligned_x; - int bpp = fb->base.format->cpp[0]; + int log_bpp; + + BUG_ON(!is_power_of_2(fb->base.format->cpp[0])); + log_bpp = __ffs(fb->base.format->cpp[0]); if (!fb->active_16) return 0; @@ -126,12 +129,12 @@ int udl_handle_damage(struct udl_framebu for (i = y; i < y + height ; i++) { const int line_offset = fb->base.pitches[0] * i; - const int byte_offset = line_offset + (x * bpp); - const int dev_byte_offset = (fb->base.width * bpp * i) + (x * bpp); - if (udl_render_hline(dev, bpp, &urb, + const int byte_offset = line_offset + (x << log_bpp); + const int dev_byte_offset = (fb->base.width * i + x) << log_bpp; + if (udl_render_hline(dev, log_bpp, &urb, (char *) fb->obj->vmapping, &cmd, byte_offset, dev_byte_offset, - width * bpp, + width << log_bpp, &bytes_identical, &bytes_sent)) goto error; } @@ -150,7 +153,7 @@ int udl_handle_damage(struct udl_framebu error: atomic_add(bytes_sent, &udl->bytes_sent); atomic_add(bytes_identical, &udl->bytes_identical); - atomic_add(width*height*bpp, &udl->bytes_rendered); + atomic_add((width * height) << log_bpp, &udl->bytes_rendered); end_cycles = get_cycles(); atomic_add(((unsigned int) ((end_cycles - start_cycles) >> 10)), /* Kcycles */ Index: linux-4.17-rc7/drivers/gpu/drm/udl/udl_transfer.c =================================--- linux-4.17-rc7.orig/drivers/gpu/drm/udl/udl_transfer.c 2018-06-03 13:15:01.000000000 +0200 +++ linux-4.17-rc7/drivers/gpu/drm/udl/udl_transfer.c 2018-06-03 13:15:01.000000000 +0200 @@ -83,12 +83,12 @@ static inline u16 pixel32_to_be16(const ((pixel >> 8) & 0xf800)); } -static inline u16 get_pixel_val16(const uint8_t *pixel, int bpp) +static inline u16 get_pixel_val16(const uint8_t *pixel, int log_bpp) { - u16 pixel_val16 = 0; - if (bpp = 2) + u16 pixel_val16; + if (log_bpp = 1) pixel_val16 = *(const uint16_t *)pixel; - else if (bpp = 4) + else pixel_val16 = pixel32_to_be16(*(const uint32_t *)pixel); return pixel_val16; } @@ -125,8 +125,9 @@ static void udl_compress_hline16( const u8 *const pixel_end, uint32_t *device_address_ptr, uint8_t **command_buffer_ptr, - const uint8_t *const cmd_buffer_end, int bpp) + const uint8_t *const cmd_buffer_end, int log_bpp) { + const int bpp = 1 << log_bpp; const u8 *pixel = *pixel_start_ptr; uint32_t dev_addr = *device_address_ptr; uint8_t *cmd = *command_buffer_ptr; @@ -153,12 +154,12 @@ static void udl_compress_hline16( raw_pixels_count_byte = cmd++; /* we'll know this later */ raw_pixel_start = pixel; - cmd_pixel_end = pixel + min3(MAX_CMD_PIXELS + 1UL, - (unsigned long)(pixel_end - pixel) / bpp, - (unsigned long)(cmd_buffer_end - 1 - cmd) / 2) * bpp; + cmd_pixel_end = pixel + (min3(MAX_CMD_PIXELS + 1UL, + (unsigned long)(pixel_end - pixel) >> log_bpp, + (unsigned long)(cmd_buffer_end - 1 - cmd) / 2) << log_bpp); prefetch_range((void *) pixel, cmd_pixel_end - pixel); - pixel_val16 = get_pixel_val16(pixel, bpp); + pixel_val16 = get_pixel_val16(pixel, log_bpp); while (pixel < cmd_pixel_end) { const u8 *const start = pixel; @@ -170,7 +171,7 @@ static void udl_compress_hline16( pixel += bpp; while (pixel < cmd_pixel_end) { - pixel_val16 = get_pixel_val16(pixel, bpp); + pixel_val16 = get_pixel_val16(pixel, log_bpp); if (pixel_val16 != repeating_pixel_val16) break; pixel += bpp; @@ -179,10 +180,10 @@ static void udl_compress_hline16( if (unlikely(pixel > start + bpp)) { /* go back and fill in raw pixel count */ *raw_pixels_count_byte = (((start - - raw_pixel_start) / bpp) + 1) & 0xFF; + raw_pixel_start) >> log_bpp) + 1) & 0xFF; /* immediately after raw data is repeat byte */ - *cmd++ = (((pixel - start) / bpp) - 1) & 0xFF; + *cmd++ = (((pixel - start) >> log_bpp) - 1) & 0xFF; /* Then start another raw pixel span */ raw_pixel_start = pixel; @@ -192,14 +193,14 @@ static void udl_compress_hline16( if (pixel > raw_pixel_start) { /* finalize last RAW span */ - *raw_pixels_count_byte = ((pixel-raw_pixel_start) / bpp) & 0xFF; + *raw_pixels_count_byte = ((pixel - raw_pixel_start) >> log_bpp) & 0xFF; } else { /* undo unused byte */ cmd--; } - *cmd_pixels_count_byte = ((pixel - cmd_pixel_start) / bpp) & 0xFF; - dev_addr += ((pixel - cmd_pixel_start) / bpp) * 2; + *cmd_pixels_count_byte = ((pixel - cmd_pixel_start) >> log_bpp) & 0xFF; + dev_addr += ((pixel - cmd_pixel_start) >> log_bpp) * 2; } if (cmd_buffer_end <= MIN_RLX_CMD_BYTES + cmd) { @@ -222,19 +223,19 @@ static void udl_compress_hline16( * (that we can only write to, slowly, and can never read), and (optionally) * our shadow copy that tracks what's been sent to that hardware buffer. */ -int udl_render_hline(struct drm_device *dev, int bpp, struct urb **urb_ptr, +int udl_render_hline(struct drm_device *dev, int log_bpp, struct urb **urb_ptr, const char *front, char **urb_buf_ptr, u32 byte_offset, u32 device_byte_offset, u32 byte_width, int *ident_ptr, int *sent_ptr) { const u8 *line_start, *line_end, *next_pixel; - u32 base16 = 0 + (device_byte_offset / bpp) * 2; + u32 base16 = 0 + (device_byte_offset >> log_bpp) * 2; struct urb *urb = *urb_ptr; u8 *cmd = *urb_buf_ptr; u8 *cmd_end = (u8 *) urb->transfer_buffer + urb->transfer_buffer_length; - BUG_ON(!(bpp = 2 || bpp = 4)); + BUG_ON(!(log_bpp = 1 || log_bpp = 2)); line_start = (u8 *) (front + byte_offset); next_pixel = line_start; @@ -244,7 +245,7 @@ int udl_render_hline(struct drm_device * udl_compress_hline16(&next_pixel, line_end, &base16, - (u8 **) &cmd, (u8 *) cmd_end, bpp); + (u8 **) &cmd, (u8 *) cmd_end, log_bpp); if (cmd >= cmd_end) { int len = cmd - (u8 *) urb->transfer_buffer; From mboxrd@z Thu Jan 1 00:00:00 1970 From: Mikulas Patocka Subject: [PATCH 07/21] udl-kms: avoid division Date: Sun, 03 Jun 2018 16:41:00 +0200 Message-ID: <20180603144221.605787225@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 0B1A36E26B for ; Sun, 3 Jun 2018 15:18:55 +0000 (UTC) Content-Disposition: inline; filename=udlkms-avoid-division.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 RGl2aXNpb24gaXMgc2xvdywgc28gaXQgc2hvdWxkbid0IGJlIGRvbmUgYnkgdGhlIHBpeGVsIGdl bmVyYXRpbmcgY29kZS4KVGhlIGRyaXZlciBzdXBwb3J0cyBvbmx5IDIgb3IgNCBieXRlcyBwZXIg cGl4ZWwsIHNvIHdlIGNhbiByZXBsYWNlCmRpdmlzaW9uIHdpdGggYSBzaGlmdC4KClNpZ25lZC1v ZmYtYnk6IE1pa3VsYXMgUGF0b2NrYSA8bXBhdG9ja2FAcmVkaGF0LmNvbT4KQ2M6IHN0YWJsZUB2 Z2VyLmtlcm5lbC5vcmcKCi0tLQogZHJpdmVycy9ncHUvZHJtL3VkbC91ZGxfZHJ2LmggICAgICB8 ICAgIDIgLQogZHJpdmVycy9ncHUvZHJtL3VkbC91ZGxfZmIuYyAgICAgICB8ICAgMTUgKysrKysr KystLS0tLS0KIGRyaXZlcnMvZ3B1L2RybS91ZGwvdWRsX3RyYW5zZmVyLmMgfCAgIDM5ICsrKysr KysrKysrKysrKysrKy0tLS0tLS0tLS0tLS0tLS0tLS0KIDMgZmlsZXMgY2hhbmdlZCwgMzAgaW5z ZXJ0aW9ucygrKSwgMjYgZGVsZXRpb25zKC0pCgpJbmRleDogbGludXgtNC4xNy1yYzcvZHJpdmVy cy9ncHUvZHJtL3VkbC91ZGxfZHJ2LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gbGludXgtNC4xNy1yYzcub3Jp Zy9kcml2ZXJzL2dwdS9kcm0vdWRsL3VkbF9kcnYuaAkyMDE4LTA2LTAzIDEzOjE1OjAxLjAwMDAw MDAwMCArMDIwMAorKysgbGludXgtNC4xNy1yYzcvZHJpdmVycy9ncHUvZHJtL3VkbC91ZGxfZHJ2 LmgJMjAxOC0wNi0wMyAxMzoxNTowMS4wMDAwMDAwMDAgKzAyMDAKQEAgLTExMCw3ICsxMTAsNyBA QCB1ZGxfZmJfdXNlcl9mYl9jcmVhdGUoc3RydWN0IGRybV9kZXZpY2UKIAkJICAgICAgc3RydWN0 IGRybV9maWxlICpmaWxlLAogCQkgICAgICBjb25zdCBzdHJ1Y3QgZHJtX21vZGVfZmJfY21kMiAq bW9kZV9jbWQpOwogCi1pbnQgdWRsX3JlbmRlcl9obGluZShzdHJ1Y3QgZHJtX2RldmljZSAqZGV2 LCBpbnQgYnBwLCBzdHJ1Y3QgdXJiICoqdXJiX3B0ciwKK2ludCB1ZGxfcmVuZGVyX2hsaW5lKHN0 cnVjdCBkcm1fZGV2aWNlICpkZXYsIGludCBsb2dfYnBwLCBzdHJ1Y3QgdXJiICoqdXJiX3B0ciwK IAkJICAgICBjb25zdCBjaGFyICpmcm9udCwgY2hhciAqKnVyYl9idWZfcHRyLAogCQkgICAgIHUz MiBieXRlX29mZnNldCwgdTMyIGRldmljZV9ieXRlX29mZnNldCwgdTMyIGJ5dGVfd2lkdGgsCiAJ CSAgICAgaW50ICppZGVudF9wdHIsIGludCAqc2VudF9wdHIpOwpJbmRleDogbGludXgtNC4xNy1y YzcvZHJpdmVycy9ncHUvZHJtL3VkbC91ZGxfZmIuYwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBsaW51eC00LjE3 LXJjNy5vcmlnL2RyaXZlcnMvZ3B1L2RybS91ZGwvdWRsX2ZiLmMJMjAxOC0wNi0wMyAxMzoxNTow MS4wMDAwMDAwMDAgKzAyMDAKKysrIGxpbnV4LTQuMTctcmM3L2RyaXZlcnMvZ3B1L2RybS91ZGwv dWRsX2ZiLmMJMjAxOC0wNi0wMyAxMzoxNTowMS4wMDAwMDAwMDAgKzAyMDAKQEAgLTkxLDcgKzkx LDEwIEBAIGludCB1ZGxfaGFuZGxlX2RhbWFnZShzdHJ1Y3QgdWRsX2ZyYW1lYnUKIAlpbnQgYnl0 ZXNfaWRlbnRpY2FsID0gMDsKIAlzdHJ1Y3QgdXJiICp1cmI7CiAJaW50IGFsaWduZWRfeDsKLQlp bnQgYnBwID0gZmItPmJhc2UuZm9ybWF0LT5jcHBbMF07CisJaW50IGxvZ19icHA7CisKKwlCVUdf T04oIWlzX3Bvd2VyX29mXzIoZmItPmJhc2UuZm9ybWF0LT5jcHBbMF0pKTsKKwlsb2dfYnBwID0g X19mZnMoZmItPmJhc2UuZm9ybWF0LT5jcHBbMF0pOwogCiAJaWYgKCFmYi0+YWN0aXZlXzE2KQog CQlyZXR1cm4gMDsKQEAgLTEyNiwxMiArMTI5LDEyIEBAIGludCB1ZGxfaGFuZGxlX2RhbWFnZShz dHJ1Y3QgdWRsX2ZyYW1lYnUKIAogCWZvciAoaSA9IHk7IGkgPCB5ICsgaGVpZ2h0IDsgaSsrKSB7 CiAJCWNvbnN0IGludCBsaW5lX29mZnNldCA9IGZiLT5iYXNlLnBpdGNoZXNbMF0gKiBpOwotCQlj b25zdCBpbnQgYnl0ZV9vZmZzZXQgPSBsaW5lX29mZnNldCArICh4ICogYnBwKTsKLQkJY29uc3Qg aW50IGRldl9ieXRlX29mZnNldCA9IChmYi0+YmFzZS53aWR0aCAqIGJwcCAqIGkpICsgKHggKiBi cHApOwotCQlpZiAodWRsX3JlbmRlcl9obGluZShkZXYsIGJwcCwgJnVyYiwKKwkJY29uc3QgaW50 IGJ5dGVfb2Zmc2V0ID0gbGluZV9vZmZzZXQgKyAoeCA8PCBsb2dfYnBwKTsKKwkJY29uc3QgaW50 IGRldl9ieXRlX29mZnNldCA9IChmYi0+YmFzZS53aWR0aCAqIGkgKyB4KSA8PCBsb2dfYnBwOwor CQlpZiAodWRsX3JlbmRlcl9obGluZShkZXYsIGxvZ19icHAsICZ1cmIsCiAJCQkJICAgICAoY2hh ciAqKSBmYi0+b2JqLT52bWFwcGluZywKIAkJCQkgICAgICZjbWQsIGJ5dGVfb2Zmc2V0LCBkZXZf Ynl0ZV9vZmZzZXQsCi0JCQkJICAgICB3aWR0aCAqIGJwcCwKKwkJCQkgICAgIHdpZHRoIDw8IGxv Z19icHAsCiAJCQkJICAgICAmYnl0ZXNfaWRlbnRpY2FsLCAmYnl0ZXNfc2VudCkpCiAJCQlnb3Rv IGVycm9yOwogCX0KQEAgLTE1MCw3ICsxNTMsNyBAQCBpbnQgdWRsX2hhbmRsZV9kYW1hZ2Uoc3Ry dWN0IHVkbF9mcmFtZWJ1CiBlcnJvcjoKIAlhdG9taWNfYWRkKGJ5dGVzX3NlbnQsICZ1ZGwtPmJ5 dGVzX3NlbnQpOwogCWF0b21pY19hZGQoYnl0ZXNfaWRlbnRpY2FsLCAmdWRsLT5ieXRlc19pZGVu dGljYWwpOwotCWF0b21pY19hZGQod2lkdGgqaGVpZ2h0KmJwcCwgJnVkbC0+Ynl0ZXNfcmVuZGVy ZWQpOworCWF0b21pY19hZGQoKHdpZHRoICogaGVpZ2h0KSA8PCBsb2dfYnBwLCAmdWRsLT5ieXRl c19yZW5kZXJlZCk7CiAJZW5kX2N5Y2xlcyA9IGdldF9jeWNsZXMoKTsKIAlhdG9taWNfYWRkKCgo dW5zaWduZWQgaW50KSAoKGVuZF9jeWNsZXMgLSBzdGFydF9jeWNsZXMpCiAJCSAgICA+PiAxMCkp LCAvKiBLY3ljbGVzICovCkluZGV4OiBsaW51eC00LjE3LXJjNy9kcml2ZXJzL2dwdS9kcm0vdWRs L3VkbF90cmFuc2Zlci5jCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIGxpbnV4LTQuMTctcmM3Lm9yaWcvZHJpdmVy cy9ncHUvZHJtL3VkbC91ZGxfdHJhbnNmZXIuYwkyMDE4LTA2LTAzIDEzOjE1OjAxLjAwMDAwMDAw MCArMDIwMAorKysgbGludXgtNC4xNy1yYzcvZHJpdmVycy9ncHUvZHJtL3VkbC91ZGxfdHJhbnNm ZXIuYwkyMDE4LTA2LTAzIDEzOjE1OjAxLjAwMDAwMDAwMCArMDIwMApAQCAtODMsMTIgKzgzLDEy IEBAIHN0YXRpYyBpbmxpbmUgdTE2IHBpeGVsMzJfdG9fYmUxNihjb25zdAogCQkoKHBpeGVsID4+ IDgpICYgMHhmODAwKSk7CiB9CiAKLXN0YXRpYyBpbmxpbmUgdTE2IGdldF9waXhlbF92YWwxNihj b25zdCB1aW50OF90ICpwaXhlbCwgaW50IGJwcCkKK3N0YXRpYyBpbmxpbmUgdTE2IGdldF9waXhl bF92YWwxNihjb25zdCB1aW50OF90ICpwaXhlbCwgaW50IGxvZ19icHApCiB7Ci0JdTE2IHBpeGVs X3ZhbDE2ID0gMDsKLQlpZiAoYnBwID09IDIpCisJdTE2IHBpeGVsX3ZhbDE2OworCWlmIChsb2df YnBwID09IDEpCiAJCXBpeGVsX3ZhbDE2ID0gKihjb25zdCB1aW50MTZfdCAqKXBpeGVsOwotCWVs c2UgaWYgKGJwcCA9PSA0KQorCWVsc2UKIAkJcGl4ZWxfdmFsMTYgPSBwaXhlbDMyX3RvX2JlMTYo Kihjb25zdCB1aW50MzJfdCAqKXBpeGVsKTsKIAlyZXR1cm4gcGl4ZWxfdmFsMTY7CiB9CkBAIC0x MjUsOCArMTI1LDkgQEAgc3RhdGljIHZvaWQgdWRsX2NvbXByZXNzX2hsaW5lMTYoCiAJY29uc3Qg dTggKmNvbnN0IHBpeGVsX2VuZCwKIAl1aW50MzJfdCAqZGV2aWNlX2FkZHJlc3NfcHRyLAogCXVp bnQ4X3QgKipjb21tYW5kX2J1ZmZlcl9wdHIsCi0JY29uc3QgdWludDhfdCAqY29uc3QgY21kX2J1 ZmZlcl9lbmQsIGludCBicHApCisJY29uc3QgdWludDhfdCAqY29uc3QgY21kX2J1ZmZlcl9lbmQs IGludCBsb2dfYnBwKQogeworCWNvbnN0IGludCBicHAgPSAxIDw8IGxvZ19icHA7CiAJY29uc3Qg dTggKnBpeGVsID0gKnBpeGVsX3N0YXJ0X3B0cjsKIAl1aW50MzJfdCBkZXZfYWRkciAgPSAqZGV2 aWNlX2FkZHJlc3NfcHRyOwogCXVpbnQ4X3QgKmNtZCA9ICpjb21tYW5kX2J1ZmZlcl9wdHI7CkBA IC0xNTMsMTIgKzE1NCwxMiBAQCBzdGF0aWMgdm9pZCB1ZGxfY29tcHJlc3NfaGxpbmUxNigKIAkJ cmF3X3BpeGVsc19jb3VudF9ieXRlID0gY21kKys7IC8qICB3ZSdsbCBrbm93IHRoaXMgbGF0ZXIg Ki8KIAkJcmF3X3BpeGVsX3N0YXJ0ID0gcGl4ZWw7CiAKLQkJY21kX3BpeGVsX2VuZCA9IHBpeGVs ICsgbWluMyhNQVhfQ01EX1BJWEVMUyArIDFVTCwKLQkJCQkJKHVuc2lnbmVkIGxvbmcpKHBpeGVs X2VuZCAtIHBpeGVsKSAvIGJwcCwKLQkJCQkJKHVuc2lnbmVkIGxvbmcpKGNtZF9idWZmZXJfZW5k IC0gMSAtIGNtZCkgLyAyKSAqIGJwcDsKKwkJY21kX3BpeGVsX2VuZCA9IHBpeGVsICsgKG1pbjMo TUFYX0NNRF9QSVhFTFMgKyAxVUwsCisJCQkJCSh1bnNpZ25lZCBsb25nKShwaXhlbF9lbmQgLSBw aXhlbCkgPj4gbG9nX2JwcCwKKwkJCQkJKHVuc2lnbmVkIGxvbmcpKGNtZF9idWZmZXJfZW5kIC0g MSAtIGNtZCkgLyAyKSA8PCBsb2dfYnBwKTsKIAogCQlwcmVmZXRjaF9yYW5nZSgodm9pZCAqKSBw aXhlbCwgY21kX3BpeGVsX2VuZCAtIHBpeGVsKTsKLQkJcGl4ZWxfdmFsMTYgPSBnZXRfcGl4ZWxf dmFsMTYocGl4ZWwsIGJwcCk7CisJCXBpeGVsX3ZhbDE2ID0gZ2V0X3BpeGVsX3ZhbDE2KHBpeGVs LCBsb2dfYnBwKTsKIAogCQl3aGlsZSAocGl4ZWwgPCBjbWRfcGl4ZWxfZW5kKSB7CiAJCQljb25z dCB1OCAqY29uc3Qgc3RhcnQgPSBwaXhlbDsKQEAgLTE3MCw3ICsxNzEsNyBAQCBzdGF0aWMgdm9p ZCB1ZGxfY29tcHJlc3NfaGxpbmUxNigKIAkJCXBpeGVsICs9IGJwcDsKIAogCQkJd2hpbGUgKHBp eGVsIDwgY21kX3BpeGVsX2VuZCkgewotCQkJCXBpeGVsX3ZhbDE2ID0gZ2V0X3BpeGVsX3ZhbDE2 KHBpeGVsLCBicHApOworCQkJCXBpeGVsX3ZhbDE2ID0gZ2V0X3BpeGVsX3ZhbDE2KHBpeGVsLCBs b2dfYnBwKTsKIAkJCQlpZiAocGl4ZWxfdmFsMTYgIT0gcmVwZWF0aW5nX3BpeGVsX3ZhbDE2KQog CQkJCQlicmVhazsKIAkJCQlwaXhlbCArPSBicHA7CkBAIC0xNzksMTAgKzE4MCwxMCBAQCBzdGF0 aWMgdm9pZCB1ZGxfY29tcHJlc3NfaGxpbmUxNigKIAkJCWlmICh1bmxpa2VseShwaXhlbCA+IHN0 YXJ0ICsgYnBwKSkgewogCQkJCS8qIGdvIGJhY2sgYW5kIGZpbGwgaW4gcmF3IHBpeGVsIGNvdW50 ICovCiAJCQkJKnJhd19waXhlbHNfY291bnRfYnl0ZSA9ICgoKHN0YXJ0IC0KLQkJCQkJCXJhd19w aXhlbF9zdGFydCkgLyBicHApICsgMSkgJiAweEZGOworCQkJCQkJcmF3X3BpeGVsX3N0YXJ0KSA+ PiBsb2dfYnBwKSArIDEpICYgMHhGRjsKIAogCQkJCS8qIGltbWVkaWF0ZWx5IGFmdGVyIHJhdyBk YXRhIGlzIHJlcGVhdCBieXRlICovCi0JCQkJKmNtZCsrID0gKCgocGl4ZWwgLSBzdGFydCkgLyBi cHApIC0gMSkgJiAweEZGOworCQkJCSpjbWQrKyA9ICgoKHBpeGVsIC0gc3RhcnQpID4+IGxvZ19i cHApIC0gMSkgJiAweEZGOwogCiAJCQkJLyogVGhlbiBzdGFydCBhbm90aGVyIHJhdyBwaXhlbCBz cGFuICovCiAJCQkJcmF3X3BpeGVsX3N0YXJ0ID0gcGl4ZWw7CkBAIC0xOTIsMTQgKzE5MywxNCBA QCBzdGF0aWMgdm9pZCB1ZGxfY29tcHJlc3NfaGxpbmUxNigKIAogCQlpZiAocGl4ZWwgPiByYXdf cGl4ZWxfc3RhcnQpIHsKIAkJCS8qIGZpbmFsaXplIGxhc3QgUkFXIHNwYW4gKi8KLQkJCSpyYXdf cGl4ZWxzX2NvdW50X2J5dGUgPSAoKHBpeGVsLXJhd19waXhlbF9zdGFydCkgLyBicHApICYgMHhG RjsKKwkJCSpyYXdfcGl4ZWxzX2NvdW50X2J5dGUgPSAoKHBpeGVsIC0gcmF3X3BpeGVsX3N0YXJ0 KSA+PiBsb2dfYnBwKSAmIDB4RkY7CiAJCX0gZWxzZSB7CiAJCQkvKiB1bmRvIHVudXNlZCBieXRl ICovCiAJCQljbWQtLTsKIAkJfQogCi0JCSpjbWRfcGl4ZWxzX2NvdW50X2J5dGUgPSAoKHBpeGVs IC0gY21kX3BpeGVsX3N0YXJ0KSAvIGJwcCkgJiAweEZGOwotCQlkZXZfYWRkciArPSAoKHBpeGVs IC0gY21kX3BpeGVsX3N0YXJ0KSAvIGJwcCkgKiAyOworCQkqY21kX3BpeGVsc19jb3VudF9ieXRl ID0gKChwaXhlbCAtIGNtZF9waXhlbF9zdGFydCkgPj4gbG9nX2JwcCkgJiAweEZGOworCQlkZXZf YWRkciArPSAoKHBpeGVsIC0gY21kX3BpeGVsX3N0YXJ0KSA+PiBsb2dfYnBwKSAqIDI7CiAJfQog CiAJaWYgKGNtZF9idWZmZXJfZW5kIDw9IE1JTl9STFhfQ01EX0JZVEVTICsgY21kKSB7CkBAIC0y MjIsMTkgKzIyMywxOSBAQCBzdGF0aWMgdm9pZCB1ZGxfY29tcHJlc3NfaGxpbmUxNigKICAqICh0 aGF0IHdlIGNhbiBvbmx5IHdyaXRlIHRvLCBzbG93bHksIGFuZCBjYW4gbmV2ZXIgcmVhZCksIGFu ZCAob3B0aW9uYWxseSkKICAqIG91ciBzaGFkb3cgY29weSB0aGF0IHRyYWNrcyB3aGF0J3MgYmVl biBzZW50IHRvIHRoYXQgaGFyZHdhcmUgYnVmZmVyLgogICovCi1pbnQgdWRsX3JlbmRlcl9obGlu ZShzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LCBpbnQgYnBwLCBzdHJ1Y3QgdXJiICoqdXJiX3B0ciwK K2ludCB1ZGxfcmVuZGVyX2hsaW5lKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIGludCBsb2dfYnBw LCBzdHJ1Y3QgdXJiICoqdXJiX3B0ciwKIAkJICAgICBjb25zdCBjaGFyICpmcm9udCwgY2hhciAq KnVyYl9idWZfcHRyLAogCQkgICAgIHUzMiBieXRlX29mZnNldCwgdTMyIGRldmljZV9ieXRlX29m ZnNldCwKIAkJICAgICB1MzIgYnl0ZV93aWR0aCwKIAkJICAgICBpbnQgKmlkZW50X3B0ciwgaW50 ICpzZW50X3B0cikKIHsKIAljb25zdCB1OCAqbGluZV9zdGFydCwgKmxpbmVfZW5kLCAqbmV4dF9w aXhlbDsKLQl1MzIgYmFzZTE2ID0gMCArIChkZXZpY2VfYnl0ZV9vZmZzZXQgLyBicHApICogMjsK Kwl1MzIgYmFzZTE2ID0gMCArIChkZXZpY2VfYnl0ZV9vZmZzZXQgPj4gbG9nX2JwcCkgKiAyOwog CXN0cnVjdCB1cmIgKnVyYiA9ICp1cmJfcHRyOwogCXU4ICpjbWQgPSAqdXJiX2J1Zl9wdHI7CiAJ dTggKmNtZF9lbmQgPSAodTggKikgdXJiLT50cmFuc2Zlcl9idWZmZXIgKyB1cmItPnRyYW5zZmVy X2J1ZmZlcl9sZW5ndGg7CiAKLQlCVUdfT04oIShicHAgPT0gMiB8fCBicHAgPT0gNCkpOworCUJV R19PTighKGxvZ19icHAgPT0gMSB8fCBsb2dfYnBwID09IDIpKTsKIAogCWxpbmVfc3RhcnQgPSAo dTggKikgKGZyb250ICsgYnl0ZV9vZmZzZXQpOwogCW5leHRfcGl4ZWwgPSBsaW5lX3N0YXJ0OwpA QCAtMjQ0LDcgKzI0NSw3IEBAIGludCB1ZGxfcmVuZGVyX2hsaW5lKHN0cnVjdCBkcm1fZGV2aWNl ICoKIAogCQl1ZGxfY29tcHJlc3NfaGxpbmUxNigmbmV4dF9waXhlbCwKIAkJCSAgICAgbGluZV9l bmQsICZiYXNlMTYsCi0JCQkgICAgICh1OCAqKikgJmNtZCwgKHU4ICopIGNtZF9lbmQsIGJwcCk7 CisJCQkgICAgICh1OCAqKikgJmNtZCwgKHU4ICopIGNtZF9lbmQsIGxvZ19icHApOwogCiAJCWlm IChjbWQgPj0gY21kX2VuZCkgewogCQkJaW50IGxlbiA9IGNtZCAtICh1OCAqKSB1cmItPnRyYW5z ZmVyX2J1ZmZlcjsKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fCmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9y ZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZl bAo=