From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1165130AbdD1JlE (ORCPT ); Fri, 28 Apr 2017 05:41:04 -0400 Received: from mga03.intel.com ([134.134.136.65]:1285 "EHLO mga03.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1165063AbdD1JkC (ORCPT ); Fri, 28 Apr 2017 05:40:02 -0400 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.37,387,1488873600"; d="scan'208";a="1124389938" From: Xiaoguang Chen To: kraxel@redhat.com, alex.williamson@redhat.com, intel-gfx@lists.freedesktop.org, intel-gvt-dev@lists.freedesktop.org, zhi.a.wang@intel.com, zhenyuw@linux.intel.com, linux-kernel@vger.kernel.org, zhiyuan.lv@intel.com, kevin.tian@intel.com Cc: Xiaoguang Chen Subject: [RFC PATCH 5/6] drm/i915/gvt: dmabuf support for GVT-g Date: Fri, 28 Apr 2017 17:35:29 +0800 Message-Id: <1493372130-27727-6-git-send-email-xiaoguang.chen@intel.com> X-Mailer: git-send-email 1.9.1 In-Reply-To: <1493372130-27727-1-git-send-email-xiaoguang.chen@intel.com> References: <1493372130-27727-1-git-send-email-xiaoguang.chen@intel.com> Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org dmabuf for GVT-g can be exported to users who can use the dmabuf to show the desktop of vm which use intel vgpu. Currently we provide query and create new dmabuf operations. Users of dmabuf can cache some created dmabufs and related information such as the framebuffer's address, size, tiling mode, width, height etc. When refresh the screen first query the currnet vgpu's frambuffer and compare with the cached ones(address, size, tiling, width, height etc) if found one then reuse the found dmabuf to gain performance improvment. If there is no dmabuf created yet or not found in the cached dmabufs then need to create a new dmabuf. To create a dmabuf first a gem object will be created and the backing storage of this gem object is the vgpu's framebuffer(primary/cursor). Then associate this gem object to a dmabuf and export this dmabuf. A file descriptor will be generated for this dmabuf and this file descriptor can be sent to user space to do display. Signed-off-by: Xiaoguang Chen --- drivers/gpu/drm/i915/gvt/Makefile | 2 +- drivers/gpu/drm/i915/gvt/dmabuf.c | 268 ++++++++++++++++++++++++++++++++++++++ drivers/gpu/drm/i915/gvt/dmabuf.h | 50 +++++++ drivers/gpu/drm/i915/gvt/gvt.h | 1 + 4 files changed, 320 insertions(+), 1 deletion(-) create mode 100644 drivers/gpu/drm/i915/gvt/dmabuf.c create mode 100644 drivers/gpu/drm/i915/gvt/dmabuf.h diff --git a/drivers/gpu/drm/i915/gvt/Makefile b/drivers/gpu/drm/i915/gvt/Makefile index 192ca26..e480f7d 100644 --- a/drivers/gpu/drm/i915/gvt/Makefile +++ b/drivers/gpu/drm/i915/gvt/Makefile @@ -2,7 +2,7 @@ GVT_DIR := gvt GVT_SOURCE := gvt.o aperture_gm.o handlers.o vgpu.o trace_points.o firmware.o \ interrupt.o gtt.o cfg_space.o opregion.o mmio.o display.o edid.o \ execlist.o scheduler.o sched_policy.o render.o cmd_parser.o \ - fb_decoder.o + fb_decoder.o dmabuf.o ccflags-y += -I$(src) -I$(src)/$(GVT_DIR) -Wall i915-y += $(addprefix $(GVT_DIR)/, $(GVT_SOURCE)) diff --git a/drivers/gpu/drm/i915/gvt/dmabuf.c b/drivers/gpu/drm/i915/gvt/dmabuf.c new file mode 100644 index 0000000..d776dfa --- /dev/null +++ b/drivers/gpu/drm/i915/gvt/dmabuf.c @@ -0,0 +1,268 @@ +/* + * Copyright 2017 Intel Corporation. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + * + * Authors: + * Zhiyuan Lv + * + * Contributors: + * Xiaoguang Chen + */ + +#include +#include + +#include "i915_drv.h" +#include "gvt.h" + +static struct sg_table *intel_vgpu_gem_get_pages( + struct drm_i915_gem_object *obj) +{ + WARN_ON(1); + return NULL; +} + +static void intel_vgpu_gem_put_pages(struct drm_i915_gem_object *obj, + struct sg_table *pages) +{ + /* like stolen memory, this should only be called during free + * after clearing pin count. + */ + sg_free_table(pages); + kfree(pages); +} + +static const struct drm_i915_gem_object_ops intel_vgpu_gem_ops = { + .get_pages = intel_vgpu_gem_get_pages, + .put_pages = intel_vgpu_gem_put_pages, +}; + +#define GEN8_DECODE_PTE(pte) \ + ((dma_addr_t)(((((u64)pte) >> 12) & 0x7ffffffULL) << 12)) + +#define GEN7_DECODE_PTE(pte) \ + ((dma_addr_t)(((((u64)pte) & 0x7f0) << 28) | (u64)(pte & 0xfffff000))) + +static struct sg_table * +intel_vgpu_create_sg_pages(struct drm_device *dev, u32 start, u32 num_pages) +{ + struct drm_i915_private *dev_priv = dev->dev_private; + struct sg_table *st; + struct scatterlist *sg; + int i; + gen8_pte_t __iomem *gtt_entries; + + st = kmalloc(sizeof(*st), GFP_KERNEL); + if (st == NULL) + return NULL; + + if (sg_alloc_table(st, num_pages, GFP_KERNEL)) { + kfree(st); + return NULL; + } + + gtt_entries = (gen8_pte_t __iomem *)dev_priv->ggtt.gsm + + (start >> PAGE_SHIFT); + for_each_sg(st->sgl, sg, num_pages, i) { + sg->offset = 0; + sg->length = PAGE_SIZE; + sg_dma_address(sg) = + GEN8_DECODE_PTE(readq(>t_entries[i])); + sg_dma_len(sg) = PAGE_SIZE; + } + + return st; +} + +static struct drm_i915_gem_object *intel_vgpu_create_gem(struct drm_device *dev, + struct intel_vgpu_dmabuf *info) +{ + struct drm_i915_gem_object *obj; + struct drm_i915_private *pri = dev->dev_private; + + obj = i915_gem_object_alloc(pri); + if (obj == NULL) + return NULL; + + drm_gem_private_object_init(dev, &obj->base, info->size << PAGE_SHIFT); + i915_gem_object_init(obj, &intel_vgpu_gem_ops); + obj->mm.pages = intel_vgpu_create_sg_pages(dev, info->start, + info->size); + if (obj->mm.pages == NULL) { + i915_gem_object_free(obj); + return NULL; + } + obj->cache_level = I915_CACHE_L3_LLC; + if (IS_SKYLAKE(pri)) { + unsigned int tiling_mode = 0; + + switch (info->tiled << 10) { + case PLANE_CTL_TILED_LINEAR: + tiling_mode = I915_TILING_NONE; + break; + case PLANE_CTL_TILED_X: + tiling_mode = I915_TILING_X; + break; + case PLANE_CTL_TILED_Y: + tiling_mode = I915_TILING_Y; + break; + default: + gvt_dbg_core("tile %d not supported\n", info->tiled); + } + obj->tiling_and_stride = tiling_mode | info->stride; + } else { + obj->tiling_and_stride = (info->tiled ? I915_TILING_X : + I915_TILING_NONE) | (info->tiled ? info->stride : 0); + } + + return obj; +} + +static int intel_vgpu_get_plane_info(struct drm_device *dev, + struct intel_vgpu *vgpu, + struct intel_vgpu_dmabuf *info) +{ + struct drm_i915_private *dev_priv = dev->dev_private; + struct intel_vgpu_primary_plane_format *p; + struct intel_vgpu_cursor_plane_format *c; + + if (info->plane_id == INTEL_GVT_PLANE_PRIMARY) { + p = (struct intel_vgpu_primary_plane_format *) + intel_vgpu_decode_plane(dev, vgpu, info->plane_id); + if (p != NULL) { + info->start = p->base; + info->width = p->width; + info->height = p->height; + info->stride = p->stride; + info->drm_format = p->drm_format; + info->tiled = p->tiled; + info->size = (((p->stride * p->height * p->bpp) / 8) + + (PAGE_SIZE - 1)) >> PAGE_SHIFT; + } else { + gvt_dbg_core("invalid primary plane\n"); + return -EINVAL; + } + } else if (info->plane_id == INTEL_GVT_PLANE_CURSOR) { + c = (struct intel_vgpu_cursor_plane_format *) + intel_vgpu_decode_plane(dev, vgpu, info->plane_id); + if (c != NULL) { + info->start = c->base; + info->width = c->width; + info->height = c->height; + info->stride = c->width * (c->bpp / 8); + info->tiled = 0; + info->x_pos = c->x_pos; + info->y_pos = c->y_pos; + info->size = (((info->stride * c->height * c->bpp) / 8) + + (PAGE_SIZE - 1)) >> PAGE_SHIFT; + } else { + gvt_dbg_core("invalid cursor plane\n"); + return -EINVAL; + } + } else { + gvt_vgpu_err("invalid plane id:%d\n", info->plane_id); + return -EINVAL; + } + + if (info->start & (PAGE_SIZE - 1)) { + gvt_vgpu_err("Not aligned fb address:0x%x\n", info->start); + return -EINVAL; + } + if (((info->start >> PAGE_SHIFT) + info->size) > + ggtt_total_entries(&dev_priv->ggtt)) { + gvt_vgpu_err("Invalid GTT offset or size\n"); + return -EINVAL; + } + + return 0; +} + +static struct drm_i915_gem_object *intel_vgpu_create_gem_from_vgpuid( + struct drm_device *dev, struct intel_vgpu *vgpu, + struct intel_vgpu_dmabuf *info) +{ + struct drm_i915_gem_object *obj; + int ret; + + ret = intel_vgpu_get_plane_info(dev, vgpu, info); + if (ret) { + gvt_vgpu_err("get plane info failed:%d\n", info->plane_id); + return NULL; + } + obj = intel_vgpu_create_gem(dev, info); + + return obj; +} + +int intel_vgpu_query_dmabuf(struct intel_vgpu *vgpu, void *args) +{ + struct drm_device *dev = &vgpu->gvt->dev_priv->drm; + int ret; + struct intel_vgpu_dmabuf *info = args; + + ret = intel_vgpu_get_plane_info(dev, vgpu, info); + if (ret) { + gvt_vgpu_err("get plane info failed:%d\n", info->plane_id); + return -EINVAL; + } + + return 0; +} + +int intel_vgpu_generate_dmabuf(struct intel_vgpu *vgpu, void *args) +{ + struct dma_buf *dmabuf; + struct drm_i915_gem_object *obj; + struct drm_device *dev = &vgpu->gvt->dev_priv->drm; + int ret; + struct intel_vgpu_dmabuf *info = args; + struct dma_buf_export_info exp_info = { + .exp_name = KBUILD_MODNAME, + .owner = THIS_MODULE }; + + obj = intel_vgpu_create_gem_from_vgpuid(dev, vgpu, info); + if (obj == NULL) { + gvt_vgpu_err("create gvt gem obj failed:%d\n", vgpu->id); + return -EINVAL; + } + + exp_info.ops = &i915_dmabuf_ops; + exp_info.size = obj->base.size; + exp_info.flags = DRM_CLOEXEC | DRM_RDWR; + exp_info.priv = &obj->base; + exp_info.resv = obj->resv; + + dmabuf = drm_gem_dmabuf_export(dev, &exp_info); + if (IS_ERR(dmabuf)) { + gvt_vgpu_err("intel vgpu export dma-buf failed\n"); + mutex_unlock(&dev->object_name_lock); + return -EINVAL; + } + + ret = dma_buf_fd(dmabuf, exp_info.flags); + if (ret < 0) { + gvt_vgpu_err("intel vgpu create dma-buf fd failed\n"); + return ret; + } + info->fd = ret; + + return 0; +} diff --git a/drivers/gpu/drm/i915/gvt/dmabuf.h b/drivers/gpu/drm/i915/gvt/dmabuf.h new file mode 100644 index 0000000..c590f4a --- /dev/null +++ b/drivers/gpu/drm/i915/gvt/dmabuf.h @@ -0,0 +1,50 @@ +/* + * Copyright(c) 2017 Intel Corporation. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + */ + +#ifndef _GVT_DMABUF_H_ +#define _GVT_DMABUF_H_ + +#define INTEL_VGPU_QUERY_DMABUF 0 +#define INTEL_VGPU_GENERATE_DMABUF 1 + +struct intel_vgpu_dmabuf { + __u32 plane_id; + /* out */ + __u32 fd; + __u32 drm_format; + __u32 width; + __u32 height; + __u32 stride; + __u32 start; + __u32 x_pos; + __u32 y_pos; + __u32 size; + __u32 tiled; +}; + +int intel_vgpu_query_dmabuf(struct intel_vgpu *vgpu, void *args); +int intel_vgpu_generate_dmabuf(struct intel_vgpu *vgpu, void *args); + +#endif + diff --git a/drivers/gpu/drm/i915/gvt/gvt.h b/drivers/gpu/drm/i915/gvt/gvt.h index c42266c..763a8c5 100644 --- a/drivers/gpu/drm/i915/gvt/gvt.h +++ b/drivers/gpu/drm/i915/gvt/gvt.h @@ -47,6 +47,7 @@ #include "render.h" #include "cmd_parser.h" #include "fb_decoder.h" +#include "dmabuf.h" #define GVT_MAX_VGPU 8 -- 1.9.1 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Xiaoguang Chen Subject: [RFC PATCH 5/6] drm/i915/gvt: dmabuf support for GVT-g Date: Fri, 28 Apr 2017 17:35:29 +0800 Message-ID: <1493372130-27727-6-git-send-email-xiaoguang.chen@intel.com> References: <1493372130-27727-1-git-send-email-xiaoguang.chen@intel.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1493372130-27727-1-git-send-email-xiaoguang.chen@intel.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" To: kraxel@redhat.com, alex.williamson@redhat.com, intel-gfx@lists.freedesktop.org, intel-gvt-dev@lists.freedesktop.org, zhi.a.wang@intel.com, zhenyuw@linux.intel.com, linux-kernel@vger.kernel.org, zhiyuan.lv@intel.com, kevin.tian@intel.com Cc: Xiaoguang Chen List-Id: intel-gfx@lists.freedesktop.org ZG1hYnVmIGZvciBHVlQtZyBjYW4gYmUgZXhwb3J0ZWQgdG8gdXNlcnMgd2hvIGNhbiB1c2UgdGhl IGRtYWJ1ZiB0byBzaG93CnRoZSBkZXNrdG9wIG9mIHZtIHdoaWNoIHVzZSBpbnRlbCB2Z3B1LgoK Q3VycmVudGx5IHdlIHByb3ZpZGUgcXVlcnkgYW5kIGNyZWF0ZSBuZXcgZG1hYnVmIG9wZXJhdGlv bnMuCgpVc2VycyBvZiBkbWFidWYgY2FuIGNhY2hlIHNvbWUgY3JlYXRlZCBkbWFidWZzIGFuZCBy ZWxhdGVkIGluZm9ybWF0aW9uIHN1Y2gKYXMgdGhlIGZyYW1lYnVmZmVyJ3MgYWRkcmVzcywgc2l6 ZSwgdGlsaW5nIG1vZGUsIHdpZHRoLCBoZWlnaHQgZXRjLiBXaGVuCnJlZnJlc2ggdGhlIHNjcmVl biBmaXJzdCBxdWVyeSB0aGUgY3Vycm5ldCB2Z3B1J3MgZnJhbWJ1ZmZlciBhbmQgY29tcGFyZQp3 aXRoIHRoZSBjYWNoZWQgb25lcyhhZGRyZXNzLCBzaXplLCB0aWxpbmcsIHdpZHRoLCBoZWlnaHQg ZXRjKSBpZiBmb3VuZCBvbmUKdGhlbiByZXVzZSB0aGUgZm91bmQgZG1hYnVmIHRvIGdhaW4gcGVy Zm9ybWFuY2UgaW1wcm92bWVudC4KCklmIHRoZXJlIGlzIG5vIGRtYWJ1ZiBjcmVhdGVkIHlldCBv ciBub3QgZm91bmQgaW4gdGhlIGNhY2hlZCBkbWFidWZzIHRoZW4KbmVlZCB0byBjcmVhdGUgYSBu ZXcgZG1hYnVmLiBUbyBjcmVhdGUgYSBkbWFidWYgZmlyc3QgYSBnZW0gb2JqZWN0IHdpbGwKYmUg Y3JlYXRlZCBhbmQgdGhlIGJhY2tpbmcgc3RvcmFnZSBvZiB0aGlzIGdlbSBvYmplY3QgaXMgdGhl IHZncHUncwpmcmFtZWJ1ZmZlcihwcmltYXJ5L2N1cnNvcikuIFRoZW4gYXNzb2NpYXRlIHRoaXMg Z2VtIG9iamVjdCB0byBhIGRtYWJ1ZgphbmQgZXhwb3J0IHRoaXMgZG1hYnVmLiBBIGZpbGUgZGVz Y3JpcHRvciB3aWxsIGJlIGdlbmVyYXRlZCBmb3IgdGhpcyBkbWFidWYKYW5kIHRoaXMgZmlsZSBk ZXNjcmlwdG9yIGNhbiBiZSBzZW50IHRvIHVzZXIgc3BhY2UgdG8gZG8gZGlzcGxheS4KClNpZ25l ZC1vZmYtYnk6IFhpYW9ndWFuZyBDaGVuIDx4aWFvZ3VhbmcuY2hlbkBpbnRlbC5jb20+Ci0tLQog ZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3Z0L01ha2VmaWxlIHwgICAyICstCiBkcml2ZXJzL2dwdS9k cm0vaTkxNS9ndnQvZG1hYnVmLmMgfCAyNjggKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysKIGRyaXZlcnMvZ3B1L2RybS9pOTE1L2d2dC9kbWFidWYuaCB8ICA1MCArKysrKysr CiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9ndnQvZ3Z0LmggICAgfCAgIDEgKwogNCBmaWxlcyBjaGFu Z2VkLCAzMjAgaW5zZXJ0aW9ucygrKSwgMSBkZWxldGlvbigtKQogY3JlYXRlIG1vZGUgMTAwNjQ0 IGRyaXZlcnMvZ3B1L2RybS9pOTE1L2d2dC9kbWFidWYuYwogY3JlYXRlIG1vZGUgMTAwNjQ0IGRy aXZlcnMvZ3B1L2RybS9pOTE1L2d2dC9kbWFidWYuaAoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1 L2RybS9pOTE1L2d2dC9NYWtlZmlsZSBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d2dC9NYWtlZmls ZQppbmRleCAxOTJjYTI2Li5lNDgwZjdkIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkx NS9ndnQvTWFrZWZpbGUKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3Z0L01ha2VmaWxlCkBA IC0yLDcgKzIsNyBAQCBHVlRfRElSIDo9IGd2dAogR1ZUX1NPVVJDRSA6PSBndnQubyBhcGVydHVy ZV9nbS5vIGhhbmRsZXJzLm8gdmdwdS5vIHRyYWNlX3BvaW50cy5vIGZpcm13YXJlLm8gXAogCWlu dGVycnVwdC5vIGd0dC5vIGNmZ19zcGFjZS5vIG9wcmVnaW9uLm8gbW1pby5vIGRpc3BsYXkubyBl ZGlkLm8gXAogCWV4ZWNsaXN0Lm8gc2NoZWR1bGVyLm8gc2NoZWRfcG9saWN5Lm8gcmVuZGVyLm8g Y21kX3BhcnNlci5vIFwKLQlmYl9kZWNvZGVyLm8KKwlmYl9kZWNvZGVyLm8gZG1hYnVmLm8KIAog Y2NmbGFncy15CQkJCSs9IC1JJChzcmMpIC1JJChzcmMpLyQoR1ZUX0RJUikgLVdhbGwKIGk5MTUt eQkJCQkJKz0gJChhZGRwcmVmaXggJChHVlRfRElSKS8sICQoR1ZUX1NPVVJDRSkpCmRpZmYgLS1n aXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndnQvZG1hYnVmLmMgYi9kcml2ZXJzL2dwdS9kcm0v aTkxNS9ndnQvZG1hYnVmLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZDc3 NmRmYQotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d2dC9kbWFidWYu YwpAQCAtMCwwICsxLDI2OCBAQAorLyoKKyAqIENvcHlyaWdodCAyMDE3IEludGVsIENvcnBvcmF0 aW9uLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFBlcm1pc3Npb24gaXMgaGVyZWJ5IGdy YW50ZWQsIGZyZWUgb2YgY2hhcmdlLCB0byBhbnkgcGVyc29uIG9idGFpbmluZyBhCisgKiBjb3B5 IG9mIHRoaXMgc29mdHdhcmUgYW5kIGFzc29jaWF0ZWQgZG9jdW1lbnRhdGlvbiBmaWxlcyAodGhl ICJTb2Z0d2FyZSIpLAorICogdG8gZGVhbCBpbiB0aGUgU29mdHdhcmUgd2l0aG91dCByZXN0cmlj dGlvbiwgaW5jbHVkaW5nIHdpdGhvdXQgbGltaXRhdGlvbgorICogdGhlIHJpZ2h0cyB0byB1c2Us IGNvcHksIG1vZGlmeSwgbWVyZ2UsIHB1Ymxpc2gsIGRpc3RyaWJ1dGUsIHN1YmxpY2Vuc2UsCisg KiBhbmQvb3Igc2VsbCBjb3BpZXMgb2YgdGhlIFNvZnR3YXJlLCBhbmQgdG8gcGVybWl0IHBlcnNv bnMgdG8gd2hvbSB0aGUKKyAqIFNvZnR3YXJlIGlzIGZ1cm5pc2hlZCB0byBkbyBzbywgc3ViamVj dCB0byB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnM6CisgKgorICogVGhlIGFib3ZlIGNvcHlyaWdo dCBub3RpY2UgYW5kIHRoaXMgcGVybWlzc2lvbiBub3RpY2UgKGluY2x1ZGluZyB0aGUgbmV4dAor ICogcGFyYWdyYXBoKSBzaGFsbCBiZSBpbmNsdWRlZCBpbiBhbGwgY29waWVzIG9yIHN1YnN0YW50 aWFsIHBvcnRpb25zIG9mIHRoZQorICogU29mdHdhcmUuCisgKgorICogVEhFIFNPRlRXQVJFIElT IFBST1ZJREVEICJBUyBJUyIsIFdJVEhPVVQgV0FSUkFOVFkgT0YgQU5ZIEtJTkQsIEVYUFJFU1Mg T1IKKyAqIElNUExJRUQsIElOQ0xVRElORyBCVVQgTk9UIExJTUlURUQgVE8gVEhFIFdBUlJBTlRJ RVMgT0YgTUVSQ0hBTlRBQklMSVRZLAorICogRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBP U0UgQU5EIE5PTklORlJJTkdFTUVOVC4gIElOIE5PIEVWRU5UIFNIQUxMCisgKiBUSEUgQVVUSE9S UyBPUiBDT1BZUklHSFQgSE9MREVSUyBCRSBMSUFCTEUgRk9SIEFOWSBDTEFJTSwgREFNQUdFUyBP UiBPVEhFUgorICogTElBQklMSVRZLCBXSEVUSEVSIElOIEFOIEFDVElPTiBPRiBDT05UUkFDVCwg VE9SVCBPUiBPVEhFUldJU0UsIEFSSVNJTkcKKyAqIEZST00sIE9VVCBPRiBPUiBJTiBDT05ORUNU SU9OIFdJVEggVEhFIFNPRlRXQVJFIE9SIFRIRSBVU0UgT1IgT1RIRVIKKyAqIERFQUxJTkdTIElO IFRIRSBTT0ZUV0FSRS4KKyAqCisgKiBBdXRob3JzOgorICogICAgWmhpeXVhbiBMdiA8emhpeXVh bi5sdkBpbnRlbC5jb20+CisgKgorICogQ29udHJpYnV0b3JzOgorICogICAgWGlhb2d1YW5nIENo ZW4gPHhpYW9ndWFuZy5jaGVuQGludGVsLmNvbT4KKyAqLworCisjaW5jbHVkZSA8bGludXgvZG1h LWJ1Zi5oPgorI2luY2x1ZGUgPGRybS9kcm1QLmg+CisKKyNpbmNsdWRlICJpOTE1X2Rydi5oIgor I2luY2x1ZGUgImd2dC5oIgorCitzdGF0aWMgc3RydWN0IHNnX3RhYmxlICppbnRlbF92Z3B1X2dl bV9nZXRfcGFnZXMoCisJCXN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmopCit7CisJV0FS Tl9PTigxKTsKKwlyZXR1cm4gTlVMTDsKK30KKworc3RhdGljIHZvaWQgaW50ZWxfdmdwdV9nZW1f cHV0X3BhZ2VzKHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpvYmosCisJCXN0cnVjdCBzZ190 YWJsZSAqcGFnZXMpCit7CisJLyogbGlrZSBzdG9sZW4gbWVtb3J5LCB0aGlzIHNob3VsZCBvbmx5 IGJlIGNhbGxlZCBkdXJpbmcgZnJlZQorCSAqIGFmdGVyIGNsZWFyaW5nIHBpbiBjb3VudC4KKwkg Ki8KKwlzZ19mcmVlX3RhYmxlKHBhZ2VzKTsKKwlrZnJlZShwYWdlcyk7Cit9CisKK3N0YXRpYyBj b25zdCBzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdF9vcHMgaW50ZWxfdmdwdV9nZW1fb3BzID0g eworCS5nZXRfcGFnZXMgPSBpbnRlbF92Z3B1X2dlbV9nZXRfcGFnZXMsCisJLnB1dF9wYWdlcyA9 IGludGVsX3ZncHVfZ2VtX3B1dF9wYWdlcywKK307CisKKyNkZWZpbmUgR0VOOF9ERUNPREVfUFRF KHB0ZSkgXAorCSgoZG1hX2FkZHJfdCkoKCgoKHU2NClwdGUpID4+IDEyKSAmIDB4N2ZmZmZmZlVM TCkgPDwgMTIpKQorCisjZGVmaW5lIEdFTjdfREVDT0RFX1BURShwdGUpIFwKKwkoKGRtYV9hZGRy X3QpKCgoKCh1NjQpcHRlKSAmIDB4N2YwKSA8PCAyOCkgfCAodTY0KShwdGUgJiAweGZmZmZmMDAw KSkpCisKK3N0YXRpYyBzdHJ1Y3Qgc2dfdGFibGUgKgoraW50ZWxfdmdwdV9jcmVhdGVfc2dfcGFn ZXMoc3RydWN0IGRybV9kZXZpY2UgKmRldiwgdTMyIHN0YXJ0LCB1MzIgbnVtX3BhZ2VzKQorewor CXN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiA9IGRldi0+ZGV2X3ByaXZhdGU7CisJ c3RydWN0IHNnX3RhYmxlICpzdDsKKwlzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNnOworCWludCBpOwor CWdlbjhfcHRlX3QgX19pb21lbSAqZ3R0X2VudHJpZXM7CisKKwlzdCA9IGttYWxsb2Moc2l6ZW9m KCpzdCksIEdGUF9LRVJORUwpOworCWlmIChzdCA9PSBOVUxMKQorCQlyZXR1cm4gTlVMTDsKKwor CWlmIChzZ19hbGxvY190YWJsZShzdCwgbnVtX3BhZ2VzLCBHRlBfS0VSTkVMKSkgeworCQlrZnJl ZShzdCk7CisJCXJldHVybiBOVUxMOworCX0KKworCWd0dF9lbnRyaWVzID0gKGdlbjhfcHRlX3Qg X19pb21lbSAqKWRldl9wcml2LT5nZ3R0LmdzbSArCisJCShzdGFydCA+PiBQQUdFX1NISUZUKTsK Kwlmb3JfZWFjaF9zZyhzdC0+c2dsLCBzZywgbnVtX3BhZ2VzLCBpKSB7CisJCXNnLT5vZmZzZXQg PSAwOworCQlzZy0+bGVuZ3RoID0gUEFHRV9TSVpFOworCQlzZ19kbWFfYWRkcmVzcyhzZykgPQor CQkJR0VOOF9ERUNPREVfUFRFKHJlYWRxKCZndHRfZW50cmllc1tpXSkpOworCQlzZ19kbWFfbGVu KHNnKSA9IFBBR0VfU0laRTsKKwl9CisKKwlyZXR1cm4gc3Q7Cit9CisKK3N0YXRpYyBzdHJ1Y3Qg ZHJtX2k5MTVfZ2VtX29iamVjdCAqaW50ZWxfdmdwdV9jcmVhdGVfZ2VtKHN0cnVjdCBkcm1fZGV2 aWNlICpkZXYsCisJCXN0cnVjdCBpbnRlbF92Z3B1X2RtYWJ1ZiAqaW5mbykKK3sKKwlzdHJ1Y3Qg ZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqOworCXN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpwcmkg PSBkZXYtPmRldl9wcml2YXRlOworCisJb2JqID0gaTkxNV9nZW1fb2JqZWN0X2FsbG9jKHByaSk7 CisJaWYgKG9iaiA9PSBOVUxMKQorCQlyZXR1cm4gTlVMTDsKKworCWRybV9nZW1fcHJpdmF0ZV9v YmplY3RfaW5pdChkZXYsICZvYmotPmJhc2UsIGluZm8tPnNpemUgPDwgUEFHRV9TSElGVCk7CisJ aTkxNV9nZW1fb2JqZWN0X2luaXQob2JqLCAmaW50ZWxfdmdwdV9nZW1fb3BzKTsKKwlvYmotPm1t LnBhZ2VzID0gaW50ZWxfdmdwdV9jcmVhdGVfc2dfcGFnZXMoZGV2LCBpbmZvLT5zdGFydCwKKwkJ CWluZm8tPnNpemUpOworCWlmIChvYmotPm1tLnBhZ2VzID09IE5VTEwpIHsKKwkJaTkxNV9nZW1f b2JqZWN0X2ZyZWUob2JqKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCW9iai0+Y2FjaGVfbGV2ZWwg PSBJOTE1X0NBQ0hFX0wzX0xMQzsKKwlpZiAoSVNfU0tZTEFLRShwcmkpKSB7CisJCXVuc2lnbmVk IGludCB0aWxpbmdfbW9kZSA9IDA7CisKKwkJc3dpdGNoIChpbmZvLT50aWxlZCA8PCAxMCkgewor CQljYXNlIFBMQU5FX0NUTF9USUxFRF9MSU5FQVI6CisJCQl0aWxpbmdfbW9kZSA9IEk5MTVfVElM SU5HX05PTkU7CisJCQlicmVhazsKKwkJY2FzZSBQTEFORV9DVExfVElMRURfWDoKKwkJCXRpbGlu Z19tb2RlID0gSTkxNV9USUxJTkdfWDsKKwkJCWJyZWFrOworCQljYXNlIFBMQU5FX0NUTF9USUxF RF9ZOgorCQkJdGlsaW5nX21vZGUgPSBJOTE1X1RJTElOR19ZOworCQkJYnJlYWs7CisJCWRlZmF1 bHQ6CisJCQlndnRfZGJnX2NvcmUoInRpbGUgJWQgbm90IHN1cHBvcnRlZFxuIiwgaW5mby0+dGls ZWQpOworCQl9CisJCW9iai0+dGlsaW5nX2FuZF9zdHJpZGUgPSB0aWxpbmdfbW9kZSB8IGluZm8t PnN0cmlkZTsKKwl9IGVsc2UgeworCQlvYmotPnRpbGluZ19hbmRfc3RyaWRlID0gKGluZm8tPnRp bGVkID8gSTkxNV9USUxJTkdfWCA6CisJCQlJOTE1X1RJTElOR19OT05FKSB8IChpbmZvLT50aWxl ZCA/IGluZm8tPnN0cmlkZSA6IDApOworCX0KKworCXJldHVybiBvYmo7Cit9CisKK3N0YXRpYyBp bnQgaW50ZWxfdmdwdV9nZXRfcGxhbmVfaW5mbyhzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LAorCQlz dHJ1Y3QgaW50ZWxfdmdwdSAqdmdwdSwKKwkJc3RydWN0IGludGVsX3ZncHVfZG1hYnVmICppbmZv KQoreworCXN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiA9IGRldi0+ZGV2X3ByaXZh dGU7CisJc3RydWN0IGludGVsX3ZncHVfcHJpbWFyeV9wbGFuZV9mb3JtYXQgKnA7CisJc3RydWN0 IGludGVsX3ZncHVfY3Vyc29yX3BsYW5lX2Zvcm1hdCAqYzsKKworCWlmIChpbmZvLT5wbGFuZV9p ZCA9PSBJTlRFTF9HVlRfUExBTkVfUFJJTUFSWSkgeworCQlwID0gKHN0cnVjdCBpbnRlbF92Z3B1 X3ByaW1hcnlfcGxhbmVfZm9ybWF0ICopCisJCQlpbnRlbF92Z3B1X2RlY29kZV9wbGFuZShkZXYs IHZncHUsIGluZm8tPnBsYW5lX2lkKTsKKwkJaWYgKHAgIT0gTlVMTCkgeworCQkJaW5mby0+c3Rh cnQgPSBwLT5iYXNlOworCQkJaW5mby0+d2lkdGggPSBwLT53aWR0aDsKKwkJCWluZm8tPmhlaWdo dCA9IHAtPmhlaWdodDsKKwkJCWluZm8tPnN0cmlkZSA9IHAtPnN0cmlkZTsKKwkJCWluZm8tPmRy bV9mb3JtYXQgPSBwLT5kcm1fZm9ybWF0OworCQkJaW5mby0+dGlsZWQgPSBwLT50aWxlZDsKKwkJ CWluZm8tPnNpemUgPSAoKChwLT5zdHJpZGUgKiBwLT5oZWlnaHQgKiBwLT5icHApIC8gOCkgKwor CQkJCQkoUEFHRV9TSVpFIC0gMSkpID4+IFBBR0VfU0hJRlQ7CisJCX0gZWxzZSB7CisJCQlndnRf ZGJnX2NvcmUoImludmFsaWQgcHJpbWFyeSBwbGFuZVxuIik7CisJCQlyZXR1cm4gLUVJTlZBTDsK KwkJfQorCX0gZWxzZSBpZiAoaW5mby0+cGxhbmVfaWQgPT0gSU5URUxfR1ZUX1BMQU5FX0NVUlNP UikgeworCQljID0gKHN0cnVjdCBpbnRlbF92Z3B1X2N1cnNvcl9wbGFuZV9mb3JtYXQgKikKKwkJ CWludGVsX3ZncHVfZGVjb2RlX3BsYW5lKGRldiwgdmdwdSwgaW5mby0+cGxhbmVfaWQpOworCQlp ZiAoYyAhPSBOVUxMKSB7CisJCQlpbmZvLT5zdGFydCA9IGMtPmJhc2U7CisJCQlpbmZvLT53aWR0 aCA9IGMtPndpZHRoOworCQkJaW5mby0+aGVpZ2h0ID0gYy0+aGVpZ2h0OworCQkJaW5mby0+c3Ry aWRlID0gYy0+d2lkdGggKiAoYy0+YnBwIC8gOCk7CisJCQlpbmZvLT50aWxlZCA9IDA7CisJCQlp bmZvLT54X3BvcyA9IGMtPnhfcG9zOworCQkJaW5mby0+eV9wb3MgPSBjLT55X3BvczsKKwkJCWlu Zm8tPnNpemUgPSAoKChpbmZvLT5zdHJpZGUgKiBjLT5oZWlnaHQgKiBjLT5icHApIC8gOCkgKwor CQkJCQkoUEFHRV9TSVpFIC0gMSkpID4+IFBBR0VfU0hJRlQ7CisJCX0gZWxzZSB7CisJCQlndnRf ZGJnX2NvcmUoImludmFsaWQgY3Vyc29yIHBsYW5lXG4iKTsKKwkJCXJldHVybiAtRUlOVkFMOwor CQl9CisJfSBlbHNlIHsKKwkJZ3Z0X3ZncHVfZXJyKCJpbnZhbGlkIHBsYW5lIGlkOiVkXG4iLCBp bmZvLT5wbGFuZV9pZCk7CisJCXJldHVybiAtRUlOVkFMOworCX0KKworCWlmIChpbmZvLT5zdGFy dCAmIChQQUdFX1NJWkUgLSAxKSkgeworCQlndnRfdmdwdV9lcnIoIk5vdCBhbGlnbmVkIGZiIGFk ZHJlc3M6MHgleFxuIiwgaW5mby0+c3RhcnQpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisJaWYg KCgoaW5mby0+c3RhcnQgPj4gUEFHRV9TSElGVCkgKyBpbmZvLT5zaXplKSA+CisJCWdndHRfdG90 YWxfZW50cmllcygmZGV2X3ByaXYtPmdndHQpKSB7CisJCWd2dF92Z3B1X2VycigiSW52YWxpZCBH VFQgb2Zmc2V0IG9yIHNpemVcbiIpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKKwlyZXR1cm4g MDsKK30KKworc3RhdGljIHN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICppbnRlbF92Z3B1X2Ny ZWF0ZV9nZW1fZnJvbV92Z3B1aWQoCisJCXN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIHN0cnVjdCBp bnRlbF92Z3B1ICp2Z3B1LAorCQlzdHJ1Y3QgaW50ZWxfdmdwdV9kbWFidWYgKmluZm8pCit7CisJ c3RydWN0IGRybV9pOTE1X2dlbV9vYmplY3QgKm9iajsKKwlpbnQgcmV0OworCisJcmV0ID0gaW50 ZWxfdmdwdV9nZXRfcGxhbmVfaW5mbyhkZXYsIHZncHUsIGluZm8pOworCWlmIChyZXQpIHsKKwkJ Z3Z0X3ZncHVfZXJyKCJnZXQgcGxhbmUgaW5mbyBmYWlsZWQ6JWRcbiIsIGluZm8tPnBsYW5lX2lk KTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCW9iaiA9IGludGVsX3ZncHVfY3JlYXRlX2dlbShkZXYs IGluZm8pOworCisJcmV0dXJuIG9iajsKK30KKworaW50IGludGVsX3ZncHVfcXVlcnlfZG1hYnVm KHN0cnVjdCBpbnRlbF92Z3B1ICp2Z3B1LCB2b2lkICphcmdzKQoreworCXN0cnVjdCBkcm1fZGV2 aWNlICpkZXYgPSAmdmdwdS0+Z3Z0LT5kZXZfcHJpdi0+ZHJtOworCWludCByZXQ7CisJc3RydWN0 IGludGVsX3ZncHVfZG1hYnVmICppbmZvID0gYXJnczsKKworCXJldCA9IGludGVsX3ZncHVfZ2V0 X3BsYW5lX2luZm8oZGV2LCB2Z3B1LCBpbmZvKTsKKwlpZiAocmV0KSB7CisJCWd2dF92Z3B1X2Vy cigiZ2V0IHBsYW5lIGluZm8gZmFpbGVkOiVkXG4iLCBpbmZvLT5wbGFuZV9pZCk7CisJCXJldHVy biAtRUlOVkFMOworCX0KKworCXJldHVybiAwOworfQorCitpbnQgaW50ZWxfdmdwdV9nZW5lcmF0 ZV9kbWFidWYoc3RydWN0IGludGVsX3ZncHUgKnZncHUsIHZvaWQgKmFyZ3MpCit7CisJc3RydWN0 IGRtYV9idWYgKmRtYWJ1ZjsKKwlzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqOworCXN0 cnVjdCBkcm1fZGV2aWNlICpkZXYgPSAmdmdwdS0+Z3Z0LT5kZXZfcHJpdi0+ZHJtOworCWludCBy ZXQ7CisJc3RydWN0IGludGVsX3ZncHVfZG1hYnVmICppbmZvID0gYXJnczsKKwlzdHJ1Y3QgZG1h X2J1Zl9leHBvcnRfaW5mbyBleHBfaW5mbyA9IHsKKwkJLmV4cF9uYW1lID0gS0JVSUxEX01PRE5B TUUsCisJCS5vd25lciA9IFRISVNfTU9EVUxFIH07CisKKwlvYmogPSBpbnRlbF92Z3B1X2NyZWF0 ZV9nZW1fZnJvbV92Z3B1aWQoZGV2LCB2Z3B1LCBpbmZvKTsKKwlpZiAob2JqID09IE5VTEwpIHsK KwkJZ3Z0X3ZncHVfZXJyKCJjcmVhdGUgZ3Z0IGdlbSBvYmogZmFpbGVkOiVkXG4iLCB2Z3B1LT5p ZCk7CisJCXJldHVybiAtRUlOVkFMOworCX0KKworCWV4cF9pbmZvLm9wcyA9ICZpOTE1X2RtYWJ1 Zl9vcHM7CisJZXhwX2luZm8uc2l6ZSA9IG9iai0+YmFzZS5zaXplOworCWV4cF9pbmZvLmZsYWdz ID0gRFJNX0NMT0VYRUMgfCBEUk1fUkRXUjsKKwlleHBfaW5mby5wcml2ID0gJm9iai0+YmFzZTsK KwlleHBfaW5mby5yZXN2ID0gb2JqLT5yZXN2OworCisJZG1hYnVmID0gZHJtX2dlbV9kbWFidWZf ZXhwb3J0KGRldiwgJmV4cF9pbmZvKTsKKwlpZiAoSVNfRVJSKGRtYWJ1ZikpIHsKKwkJZ3Z0X3Zn cHVfZXJyKCJpbnRlbCB2Z3B1IGV4cG9ydCBkbWEtYnVmIGZhaWxlZFxuIik7CisJCW11dGV4X3Vu bG9jaygmZGV2LT5vYmplY3RfbmFtZV9sb2NrKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCisJ cmV0ID0gZG1hX2J1Zl9mZChkbWFidWYsIGV4cF9pbmZvLmZsYWdzKTsKKwlpZiAocmV0IDwgMCkg eworCQlndnRfdmdwdV9lcnIoImludGVsIHZncHUgY3JlYXRlIGRtYS1idWYgZmQgZmFpbGVkXG4i KTsKKwkJcmV0dXJuIHJldDsKKwl9CisJaW5mby0+ZmQgPSByZXQ7CisKKwlyZXR1cm4gMDsKK30K ZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d2dC9kbWFidWYuaCBiL2RyaXZlcnMv Z3B1L2RybS9pOTE1L2d2dC9kbWFidWYuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwLi5jNTkwZjRhCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3Z0 L2RtYWJ1Zi5oCkBAIC0wLDAgKzEsNTAgQEAKKy8qCisgKiBDb3B5cmlnaHQoYykgMjAxNyBJbnRl bCBDb3Jwb3JhdGlvbi4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBQZXJtaXNzaW9uIGlz IGhlcmVieSBncmFudGVkLCBmcmVlIG9mIGNoYXJnZSwgdG8gYW55IHBlcnNvbiBvYnRhaW5pbmcg YQorICogY29weSBvZiB0aGlzIHNvZnR3YXJlIGFuZCBhc3NvY2lhdGVkIGRvY3VtZW50YXRpb24g ZmlsZXMgKHRoZSAiU29mdHdhcmUiKSwKKyAqIHRvIGRlYWwgaW4gdGhlIFNvZnR3YXJlIHdpdGhv dXQgcmVzdHJpY3Rpb24sIGluY2x1ZGluZyB3aXRob3V0IGxpbWl0YXRpb24KKyAqIHRoZSByaWdo dHMgdG8gdXNlLCBjb3B5LCBtb2RpZnksIG1lcmdlLCBwdWJsaXNoLCBkaXN0cmlidXRlLCBzdWJs aWNlbnNlLAorICogYW5kL29yIHNlbGwgY29waWVzIG9mIHRoZSBTb2Z0d2FyZSwgYW5kIHRvIHBl cm1pdCBwZXJzb25zIHRvIHdob20gdGhlCisgKiBTb2Z0d2FyZSBpcyBmdXJuaXNoZWQgdG8gZG8g c28sIHN1YmplY3QgdG8gdGhlIGZvbGxvd2luZyBjb25kaXRpb25zOgorICoKKyAqIFRoZSBhYm92 ZSBjb3B5cmlnaHQgbm90aWNlIGFuZCB0aGlzIHBlcm1pc3Npb24gbm90aWNlIChpbmNsdWRpbmcg dGhlIG5leHQKKyAqIHBhcmFncmFwaCkgc2hhbGwgYmUgaW5jbHVkZWQgaW4gYWxsIGNvcGllcyBv ciBzdWJzdGFudGlhbCBwb3J0aW9ucyBvZiB0aGUKKyAqIFNvZnR3YXJlLgorICoKKyAqIFRIRSBT T0ZUV0FSRSBJUyBQUk9WSURFRCAiQVMgSVMiLCBXSVRIT1VUIFdBUlJBTlRZIE9GIEFOWSBLSU5E LCBFWFBSRVNTIE9SCisgKiBJTVBMSUVELCBJTkNMVURJTkcgQlVUIE5PVCBMSU1JVEVEIFRPIFRI RSBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSwKKyAqIEZJVE5FU1MgRk9SIEEgUEFSVElD VUxBUiBQVVJQT1NFIEFORCBOT05JTkZSSU5HRU1FTlQuICBJTiBOTyBFVkVOVCBTSEFMTAorICog VEhFIEFVVEhPUlMgT1IgQ09QWVJJR0hUIEhPTERFUlMgQkUgTElBQkxFIEZPUiBBTlkgQ0xBSU0s IERBTUFHRVMgT1IgT1RIRVIKKyAqIExJQUJJTElUWSwgV0hFVEhFUiBJTiBBTiBBQ1RJT04gT0Yg Q09OVFJBQ1QsIFRPUlQgT1IgT1RIRVJXSVNFLCBBUklTSU5HIEZST00sCisgKiBPVVQgT0YgT1Ig SU4gQ09OTkVDVElPTiBXSVRIIFRIRSBTT0ZUV0FSRSBPUiBUSEUgVVNFIE9SIE9USEVSIERFQUxJ TkdTIElOIFRIRQorICogU09GVFdBUkUuCisgKgorICovCisKKyNpZm5kZWYgX0dWVF9ETUFCVUZf SF8KKyNkZWZpbmUgX0dWVF9ETUFCVUZfSF8KKworI2RlZmluZSBJTlRFTF9WR1BVX1FVRVJZX0RN QUJVRgkJMAorI2RlZmluZSBJTlRFTF9WR1BVX0dFTkVSQVRFX0RNQUJVRgkxCisKK3N0cnVjdCBp bnRlbF92Z3B1X2RtYWJ1ZiB7CisJX191MzIgcGxhbmVfaWQ7CisJLyogb3V0ICovCisJX191MzIg ZmQ7CisJX191MzIgZHJtX2Zvcm1hdDsKKwlfX3UzMiB3aWR0aDsKKwlfX3UzMiBoZWlnaHQ7CisJ X191MzIgc3RyaWRlOworCV9fdTMyIHN0YXJ0OworCV9fdTMyIHhfcG9zOworCV9fdTMyIHlfcG9z OworCV9fdTMyIHNpemU7CisJX191MzIgdGlsZWQ7Cit9OworCitpbnQgaW50ZWxfdmdwdV9xdWVy eV9kbWFidWYoc3RydWN0IGludGVsX3ZncHUgKnZncHUsIHZvaWQgKmFyZ3MpOworaW50IGludGVs X3ZncHVfZ2VuZXJhdGVfZG1hYnVmKHN0cnVjdCBpbnRlbF92Z3B1ICp2Z3B1LAl2b2lkICphcmdz KTsKKworI2VuZGlmCisKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d2dC9ndnQu aCBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d2dC9ndnQuaAppbmRleCBjNDIyNjZjLi43NjNhOGM1 IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndnQvZ3Z0LmgKKysrIGIvZHJpdmVy cy9ncHUvZHJtL2k5MTUvZ3Z0L2d2dC5oCkBAIC00Nyw2ICs0Nyw3IEBACiAjaW5jbHVkZSAicmVu ZGVyLmgiCiAjaW5jbHVkZSAiY21kX3BhcnNlci5oIgogI2luY2x1ZGUgImZiX2RlY29kZXIuaCIK KyNpbmNsdWRlICJkbWFidWYuaCIKIAogI2RlZmluZSBHVlRfTUFYX1ZHUFUgOAogCi0tIAoxLjku MQoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KSW50ZWwt Z2Z4IG1haWxpbmcgbGlzdApJbnRlbC1nZnhAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8v bGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vaW50ZWwtZ2Z4Cg==