From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751977AbeBUIEG (ORCPT ); Wed, 21 Feb 2018 03:04:06 -0500 Received: from mail-lf0-f44.google.com ([209.85.215.44]:42114 "EHLO mail-lf0-f44.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751843AbeBUIEA (ORCPT ); Wed, 21 Feb 2018 03:04:00 -0500 X-Google-Smtp-Source: AH8x226piYxdZCMHaHZeXO2hcN8swAuXDshicPEQfkYo43jcVpLhUKqteVAsfI6oqVACKDmxOx4pSw== From: Oleksandr Andrushchenko To: xen-devel@lists.xenproject.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, airlied@linux.ie, daniel.vetter@intel.com, seanpaul@chromium.org, gustavo@padovan.org, jgross@suse.com, boris.ostrovsky@oracle.com, konrad.wilk@oracle.com Cc: andr2000@gmail.com, Oleksandr Andrushchenko Subject: [PATCH 4/9] drm/xen-front: Implement Xen event channel handling Date: Wed, 21 Feb 2018 10:03:37 +0200 Message-Id: <1519200222-20623-5-git-send-email-andr2000@gmail.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1519200222-20623-1-git-send-email-andr2000@gmail.com> References: <1519200222-20623-1-git-send-email-andr2000@gmail.com> Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org From: Oleksandr Andrushchenko Handle Xen event channels: - create for all configured connectors and publish corresponding ring references and event channels in Xen store, so backend can connect - implement event channels interrupt handlers - create and destroy event channels with respect to Xen bus state Signed-off-by: Oleksandr Andrushchenko --- drivers/gpu/drm/xen/Makefile | 1 + drivers/gpu/drm/xen/xen_drm_front.c | 16 +- drivers/gpu/drm/xen/xen_drm_front.h | 22 ++ drivers/gpu/drm/xen/xen_drm_front_evtchnl.c | 399 ++++++++++++++++++++++++++++ drivers/gpu/drm/xen/xen_drm_front_evtchnl.h | 89 +++++++ 5 files changed, 526 insertions(+), 1 deletion(-) create mode 100644 drivers/gpu/drm/xen/xen_drm_front_evtchnl.c create mode 100644 drivers/gpu/drm/xen/xen_drm_front_evtchnl.h diff --git a/drivers/gpu/drm/xen/Makefile b/drivers/gpu/drm/xen/Makefile index 0a2eae757f0c..4ce7756b8437 100644 --- a/drivers/gpu/drm/xen/Makefile +++ b/drivers/gpu/drm/xen/Makefile @@ -1,6 +1,7 @@ # SPDX-License-Identifier: GPL-2.0 drm_xen_front-objs := xen_drm_front.o \ + xen_drm_front_evtchnl.o \ xen_drm_front_cfg.o obj-$(CONFIG_DRM_XEN_FRONTEND) += drm_xen_front.o diff --git a/drivers/gpu/drm/xen/xen_drm_front.c b/drivers/gpu/drm/xen/xen_drm_front.c index 0a90c474c7ce..b558e0ae3b33 100644 --- a/drivers/gpu/drm/xen/xen_drm_front.c +++ b/drivers/gpu/drm/xen/xen_drm_front.c @@ -25,9 +25,15 @@ #include #include "xen_drm_front.h" +#include "xen_drm_front_evtchnl.h" + +static struct xen_drm_front_ops front_ops = { + /* placeholder for now */ +}; static void xen_drv_remove_internal(struct xen_drm_front_info *front_info) { + xen_drm_front_evtchnl_free_all(front_info); } static int backend_on_initwait(struct xen_drm_front_info *front_info) @@ -41,16 +47,23 @@ static int backend_on_initwait(struct xen_drm_front_info *front_info) return ret; DRM_INFO("Have %d conector(s)\n", cfg->num_connectors); - return 0; + /* Create event channels for all connectors and publish */ + ret = xen_drm_front_evtchnl_create_all(front_info, &front_ops); + if (ret < 0) + return ret; + + return xen_drm_front_evtchnl_publish_all(front_info); } static int backend_on_connected(struct xen_drm_front_info *front_info) { + xen_drm_front_evtchnl_set_state(front_info, EVTCHNL_STATE_CONNECTED); return 0; } static void backend_on_disconnected(struct xen_drm_front_info *front_info) { + xen_drm_front_evtchnl_set_state(front_info, EVTCHNL_STATE_DISCONNECTED); xenbus_switch_state(front_info->xb_dev, XenbusStateInitialising); } @@ -133,6 +146,7 @@ static int xen_drv_probe(struct xenbus_device *xb_dev, } front_info->xb_dev = xb_dev; + spin_lock_init(&front_info->io_lock); dev_set_drvdata(&xb_dev->dev, front_info); return xenbus_switch_state(xb_dev, XenbusStateInitialising); } diff --git a/drivers/gpu/drm/xen/xen_drm_front.h b/drivers/gpu/drm/xen/xen_drm_front.h index 62b0d4e3e12b..13f22736ae02 100644 --- a/drivers/gpu/drm/xen/xen_drm_front.h +++ b/drivers/gpu/drm/xen/xen_drm_front.h @@ -21,8 +21,30 @@ #include "xen_drm_front_cfg.h" +#ifndef GRANT_INVALID_REF +/* + * Note on usage of grant reference 0 as invalid grant reference: + * grant reference 0 is valid, but never exposed to a PV driver, + * because of the fact it is already in use/reserved by the PV console. + */ +#define GRANT_INVALID_REF 0 +#endif + +struct xen_drm_front_ops { + /* CAUTION! this is called with a spin_lock held! */ + void (*on_frame_done)(struct platform_device *pdev, + int conn_idx, uint64_t fb_cookie); +}; + struct xen_drm_front_info { struct xenbus_device *xb_dev; + /* to protect data between backend IO code and interrupt handler */ + spinlock_t io_lock; + /* virtual DRM platform device */ + struct platform_device *drm_pdev; + + int num_evt_pairs; + struct xen_drm_front_evtchnl_pair *evt_pairs; struct xen_drm_front_cfg cfg; }; diff --git a/drivers/gpu/drm/xen/xen_drm_front_evtchnl.c b/drivers/gpu/drm/xen/xen_drm_front_evtchnl.c new file mode 100644 index 000000000000..697a0e4dcaed --- /dev/null +++ b/drivers/gpu/drm/xen/xen_drm_front_evtchnl.c @@ -0,0 +1,399 @@ +/* + * Xen para-virtual DRM device + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * Copyright (C) 2016-2018 EPAM Systems Inc. + * + * Author: Oleksandr Andrushchenko + */ + +#include + +#include +#include + +#include +#include +#include + +#include "xen_drm_front.h" +#include "xen_drm_front_evtchnl.h" + +static irqreturn_t evtchnl_interrupt_ctrl(int irq, void *dev_id) +{ + struct xen_drm_front_evtchnl *evtchnl = dev_id; + struct xen_drm_front_info *front_info = evtchnl->front_info; + struct xendispl_resp *resp; + RING_IDX i, rp; + unsigned long flags; + + spin_lock_irqsave(&front_info->io_lock, flags); + + if (unlikely(evtchnl->state != EVTCHNL_STATE_CONNECTED)) + goto out; + +again: + rp = evtchnl->u.req.ring.sring->rsp_prod; + /* ensure we see queued responses up to rp */ + virt_rmb(); + + for (i = evtchnl->u.req.ring.rsp_cons; i != rp; i++) { + resp = RING_GET_RESPONSE(&evtchnl->u.req.ring, i); + if (unlikely(resp->id != evtchnl->evt_id)) + continue; + + switch (resp->operation) { + case XENDISPL_OP_PG_FLIP: + case XENDISPL_OP_FB_ATTACH: + case XENDISPL_OP_FB_DETACH: + case XENDISPL_OP_DBUF_CREATE: + case XENDISPL_OP_DBUF_DESTROY: + case XENDISPL_OP_SET_CONFIG: + evtchnl->u.req.resp_status = resp->status; + complete(&evtchnl->u.req.completion); + break; + + default: + DRM_ERROR("Operation %d is not supported\n", + resp->operation); + break; + } + } + + evtchnl->u.req.ring.rsp_cons = i; + + if (i != evtchnl->u.req.ring.req_prod_pvt) { + int more_to_do; + + RING_FINAL_CHECK_FOR_RESPONSES(&evtchnl->u.req.ring, + more_to_do); + if (more_to_do) + goto again; + } else + evtchnl->u.req.ring.sring->rsp_event = i + 1; + +out: + spin_unlock_irqrestore(&front_info->io_lock, flags); + return IRQ_HANDLED; +} + +static irqreturn_t evtchnl_interrupt_evt(int irq, void *dev_id) +{ + struct xen_drm_front_evtchnl *evtchnl = dev_id; + struct xen_drm_front_info *front_info = evtchnl->front_info; + struct xendispl_event_page *page = evtchnl->u.evt.page; + uint32_t cons, prod; + unsigned long flags; + + spin_lock_irqsave(&front_info->io_lock, flags); + if (unlikely(evtchnl->state != EVTCHNL_STATE_CONNECTED)) + goto out; + + prod = page->in_prod; + /* ensure we see ring contents up to prod */ + virt_rmb(); + if (prod == page->in_cons) + goto out; + + for (cons = page->in_cons; cons != prod; cons++) { + struct xendispl_evt *event; + + event = &XENDISPL_IN_RING_REF(page, cons); + if (unlikely(event->id != evtchnl->evt_id++)) + continue; + + switch (event->type) { + case XENDISPL_EVT_PG_FLIP: + evtchnl->u.evt.front_ops->on_frame_done( + front_info->drm_pdev, evtchnl->index, + event->op.pg_flip.fb_cookie); + break; + } + } + page->in_cons = cons; + /* ensure ring contents */ + virt_wmb(); + +out: + spin_unlock_irqrestore(&front_info->io_lock, flags); + return IRQ_HANDLED; +} + +static void evtchnl_free(struct xen_drm_front_info *front_info, + struct xen_drm_front_evtchnl *evtchnl) +{ + unsigned long page = 0; + + if (evtchnl->type == EVTCHNL_TYPE_REQ) + page = (unsigned long)evtchnl->u.req.ring.sring; + else if (evtchnl->type == EVTCHNL_TYPE_EVT) + page = (unsigned long)evtchnl->u.evt.page; + if (!page) + return; + + evtchnl->state = EVTCHNL_STATE_DISCONNECTED; + + if (evtchnl->type == EVTCHNL_TYPE_REQ) { + /* release all who still waits for response if any */ + evtchnl->u.req.resp_status = -EIO; + complete_all(&evtchnl->u.req.completion); + } + + if (evtchnl->irq) + unbind_from_irqhandler(evtchnl->irq, evtchnl); + + if (evtchnl->port) + xenbus_free_evtchn(front_info->xb_dev, evtchnl->port); + + /* end access and free the page */ + if (evtchnl->gref != GRANT_INVALID_REF) + gnttab_end_foreign_access(evtchnl->gref, 0, page); + + if (evtchnl->type == EVTCHNL_TYPE_REQ) + evtchnl->u.req.ring.sring = NULL; + else + evtchnl->u.evt.page = NULL; + + memset(evtchnl, 0, sizeof(*evtchnl)); +} + +static int evtchnl_alloc(struct xen_drm_front_info *front_info, int index, + struct xen_drm_front_evtchnl *evtchnl, + enum xen_drm_front_evtchnl_type type) +{ + struct xenbus_device *xb_dev = front_info->xb_dev; + unsigned long page; + grant_ref_t gref; + irq_handler_t handler; + int ret; + + memset(evtchnl, 0, sizeof(*evtchnl)); + evtchnl->type = type; + evtchnl->index = index; + evtchnl->front_info = front_info; + evtchnl->state = EVTCHNL_STATE_DISCONNECTED; + evtchnl->gref = GRANT_INVALID_REF; + + page = get_zeroed_page(GFP_NOIO | __GFP_HIGH); + if (!page) { + ret = -ENOMEM; + goto fail; + } + + if (type == EVTCHNL_TYPE_REQ) { + struct xen_displif_sring *sring; + + init_completion(&evtchnl->u.req.completion); + sring = (struct xen_displif_sring *)page; + SHARED_RING_INIT(sring); + FRONT_RING_INIT(&evtchnl->u.req.ring, + sring, XEN_PAGE_SIZE); + + ret = xenbus_grant_ring(xb_dev, sring, 1, &gref); + if (ret < 0) + goto fail; + + handler = evtchnl_interrupt_ctrl; + } else { + evtchnl->u.evt.page = (struct xendispl_event_page *)page; + + ret = gnttab_grant_foreign_access(xb_dev->otherend_id, + virt_to_gfn((void *)page), 0); + if (ret < 0) + goto fail; + + gref = ret; + handler = evtchnl_interrupt_evt; + } + evtchnl->gref = gref; + + ret = xenbus_alloc_evtchn(xb_dev, &evtchnl->port); + if (ret < 0) + goto fail; + + ret = bind_evtchn_to_irqhandler(evtchnl->port, + handler, 0, xb_dev->devicetype, evtchnl); + if (ret < 0) + goto fail; + + evtchnl->irq = ret; + return 0; + +fail: + DRM_ERROR("Failed to allocate ring: %d\n", ret); + return ret; +} + +int xen_drm_front_evtchnl_create_all(struct xen_drm_front_info *front_info, + struct xen_drm_front_ops *front_ops) +{ + struct xen_drm_front_cfg *cfg; + int ret, conn; + + cfg = &front_info->cfg; + + front_info->evt_pairs = devm_kcalloc(&front_info->xb_dev->dev, + cfg->num_connectors, + sizeof(struct xen_drm_front_evtchnl_pair), GFP_KERNEL); + if (!front_info->evt_pairs) { + ret = -ENOMEM; + goto fail; + } + + for (conn = 0; conn < cfg->num_connectors; conn++) { + ret = evtchnl_alloc(front_info, conn, + &front_info->evt_pairs[conn].req, + EVTCHNL_TYPE_REQ); + if (ret < 0) { + DRM_ERROR("Error allocating control channel\n"); + goto fail; + } + + ret = evtchnl_alloc(front_info, conn, + &front_info->evt_pairs[conn].evt, + EVTCHNL_TYPE_EVT); + if (ret < 0) { + DRM_ERROR("Error allocating in-event channel\n"); + goto fail; + } + + front_info->evt_pairs[conn].evt.u.evt.front_ops = front_ops; + } + front_info->num_evt_pairs = cfg->num_connectors; + return 0; + +fail: + xen_drm_front_evtchnl_free_all(front_info); + return ret; +} + +static int evtchnl_publish(struct xenbus_transaction xbt, + struct xen_drm_front_evtchnl *evtchnl, const char *path, + const char *node_ring, const char *node_chnl) +{ + struct xenbus_device *xb_dev = evtchnl->front_info->xb_dev; + int ret; + + /* write control channel ring reference */ + ret = xenbus_printf(xbt, path, node_ring, "%u", evtchnl->gref); + if (ret < 0) { + xenbus_dev_error(xb_dev, ret, "writing ring-ref"); + return ret; + } + + /* write event channel ring reference */ + ret = xenbus_printf(xbt, path, node_chnl, "%u", evtchnl->port); + if (ret < 0) { + xenbus_dev_error(xb_dev, ret, "writing event channel"); + return ret; + } + + return 0; +} + +int xen_drm_front_evtchnl_publish_all(struct xen_drm_front_info *front_info) +{ + struct xenbus_transaction xbt; + struct xen_drm_front_cfg *plat_data; + int ret, conn; + + plat_data = &front_info->cfg; + +again: + ret = xenbus_transaction_start(&xbt); + if (ret < 0) { + xenbus_dev_fatal(front_info->xb_dev, ret, + "starting transaction"); + return ret; + } + + for (conn = 0; conn < plat_data->num_connectors; conn++) { + ret = evtchnl_publish(xbt, + &front_info->evt_pairs[conn].req, + plat_data->connectors[conn].xenstore_path, + XENDISPL_FIELD_REQ_RING_REF, + XENDISPL_FIELD_REQ_CHANNEL); + if (ret < 0) + goto fail; + + ret = evtchnl_publish(xbt, + &front_info->evt_pairs[conn].evt, + plat_data->connectors[conn].xenstore_path, + XENDISPL_FIELD_EVT_RING_REF, + XENDISPL_FIELD_EVT_CHANNEL); + if (ret < 0) + goto fail; + } + + ret = xenbus_transaction_end(xbt, 0); + if (ret < 0) { + if (ret == -EAGAIN) + goto again; + + xenbus_dev_fatal(front_info->xb_dev, ret, + "completing transaction"); + goto fail_to_end; + } + + return 0; + +fail: + xenbus_transaction_end(xbt, 1); + +fail_to_end: + xenbus_dev_fatal(front_info->xb_dev, ret, "writing Xen store"); + return ret; +} + +void xen_drm_front_evtchnl_flush(struct xen_drm_front_evtchnl *evtchnl) +{ + int notify; + + evtchnl->u.req.ring.req_prod_pvt++; + RING_PUSH_REQUESTS_AND_CHECK_NOTIFY(&evtchnl->u.req.ring, notify); + if (notify) + notify_remote_via_irq(evtchnl->irq); +} + +void xen_drm_front_evtchnl_set_state(struct xen_drm_front_info *front_info, + enum xen_drm_front_evtchnl_state state) +{ + unsigned long flags; + int i; + + if (!front_info->evt_pairs) + return; + + spin_lock_irqsave(&front_info->io_lock, flags); + for (i = 0; i < front_info->num_evt_pairs; i++) { + front_info->evt_pairs[i].req.state = state; + front_info->evt_pairs[i].evt.state = state; + } + spin_unlock_irqrestore(&front_info->io_lock, flags); + +} + +void xen_drm_front_evtchnl_free_all(struct xen_drm_front_info *front_info) +{ + int i; + + if (!front_info->evt_pairs) + return; + + for (i = 0; i < front_info->num_evt_pairs; i++) { + evtchnl_free(front_info, &front_info->evt_pairs[i].req); + evtchnl_free(front_info, &front_info->evt_pairs[i].evt); + } + + devm_kfree(&front_info->xb_dev->dev, front_info->evt_pairs); + front_info->evt_pairs = NULL; +} diff --git a/drivers/gpu/drm/xen/xen_drm_front_evtchnl.h b/drivers/gpu/drm/xen/xen_drm_front_evtchnl.h new file mode 100644 index 000000000000..e72d3aa68b4e --- /dev/null +++ b/drivers/gpu/drm/xen/xen_drm_front_evtchnl.h @@ -0,0 +1,89 @@ +/* + * Xen para-virtual DRM device + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * Copyright (C) 2016-2018 EPAM Systems Inc. + * + * Author: Oleksandr Andrushchenko + */ + +#ifndef __XEN_DRM_FRONT_EVTCHNL_H_ +#define __XEN_DRM_FRONT_EVTCHNL_H_ + +#include +#include + +#include +#include + +/* + * All operations which are not connector oriented use this ctrl event channel, + * e.g. fb_attach/destroy which belong to a DRM device, not to a CRTC. + */ +#define GENERIC_OP_EVT_CHNL 0 + +enum xen_drm_front_evtchnl_state { + EVTCHNL_STATE_DISCONNECTED, + EVTCHNL_STATE_CONNECTED, +}; + +enum xen_drm_front_evtchnl_type { + EVTCHNL_TYPE_REQ, + EVTCHNL_TYPE_EVT, +}; + +struct xen_drm_front_drm_info; + +struct xen_drm_front_evtchnl { + struct xen_drm_front_info *front_info; + int gref; + int port; + int irq; + int index; + enum xen_drm_front_evtchnl_state state; + enum xen_drm_front_evtchnl_type type; + /* either response id or incoming event id */ + uint16_t evt_id; + /* next request id or next expected event id */ + uint16_t evt_next_id; + union { + struct { + struct xen_displif_front_ring ring; + struct completion completion; + /* latest response status */ + int resp_status; + } req; + struct { + struct xendispl_event_page *page; + struct xen_drm_front_ops *front_ops; + } evt; + } u; +}; + +struct xen_drm_front_evtchnl_pair { + struct xen_drm_front_evtchnl req; + struct xen_drm_front_evtchnl evt; +}; + +int xen_drm_front_evtchnl_create_all(struct xen_drm_front_info *front_info, + struct xen_drm_front_ops *front_ops); + +int xen_drm_front_evtchnl_publish_all(struct xen_drm_front_info *front_info); + +void xen_drm_front_evtchnl_flush(struct xen_drm_front_evtchnl *evtchnl); + +void xen_drm_front_evtchnl_set_state(struct xen_drm_front_info *front_info, + enum xen_drm_front_evtchnl_state state); + +void xen_drm_front_evtchnl_free_all(struct xen_drm_front_info *front_info); + +#endif /* __XEN_DRM_FRONT_EVTCHNL_H_ */ -- 2.7.4 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Oleksandr Andrushchenko Subject: [PATCH 4/9] drm/xen-front: Implement Xen event channel handling Date: Wed, 21 Feb 2018 10:03:37 +0200 Message-ID: <1519200222-20623-5-git-send-email-andr2000@gmail.com> References: <1519200222-20623-1-git-send-email-andr2000@gmail.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail-lf0-x22c.google.com (mail-lf0-x22c.google.com [IPv6:2a00:1450:4010:c07::22c]) by gabe.freedesktop.org (Postfix) with ESMTPS id 404816E52A for ; Wed, 21 Feb 2018 08:04:00 +0000 (UTC) Received: by mail-lf0-x22c.google.com with SMTP id q69so1063485lfi.10 for ; Wed, 21 Feb 2018 00:04:00 -0800 (PST) In-Reply-To: <1519200222-20623-1-git-send-email-andr2000@gmail.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: xen-devel@lists.xenproject.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, airlied@linux.ie, daniel.vetter@intel.com, seanpaul@chromium.org, gustavo@padovan.org, jgross@suse.com, boris.ostrovsky@oracle.com, konrad.wilk@oracle.com Cc: andr2000@gmail.com, Oleksandr Andrushchenko List-Id: dri-devel@lists.freedesktop.org RnJvbTogT2xla3NhbmRyIEFuZHJ1c2hjaGVua28gPG9sZWtzYW5kcl9hbmRydXNoY2hlbmtvQGVw YW0uY29tPgoKSGFuZGxlIFhlbiBldmVudCBjaGFubmVsczoKICAtIGNyZWF0ZSBmb3IgYWxsIGNv bmZpZ3VyZWQgY29ubmVjdG9ycyBhbmQgcHVibGlzaAogICAgY29ycmVzcG9uZGluZyByaW5nIHJl ZmVyZW5jZXMgYW5kIGV2ZW50IGNoYW5uZWxzIGluIFhlbiBzdG9yZSwKICAgIHNvIGJhY2tlbmQg Y2FuIGNvbm5lY3QKICAtIGltcGxlbWVudCBldmVudCBjaGFubmVscyBpbnRlcnJ1cHQgaGFuZGxl cnMKICAtIGNyZWF0ZSBhbmQgZGVzdHJveSBldmVudCBjaGFubmVscyB3aXRoIHJlc3BlY3QgdG8g WGVuIGJ1cyBzdGF0ZQoKU2lnbmVkLW9mZi1ieTogT2xla3NhbmRyIEFuZHJ1c2hjaGVua28gPG9s ZWtzYW5kcl9hbmRydXNoY2hlbmtvQGVwYW0uY29tPgotLS0KIGRyaXZlcnMvZ3B1L2RybS94ZW4v TWFrZWZpbGUgICAgICAgICAgICAgICAgfCAgIDEgKwogZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5f ZHJtX2Zyb250LmMgICAgICAgICB8ICAxNiArLQogZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJt X2Zyb250LmggICAgICAgICB8ICAyMiArKwogZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zy b250X2V2dGNobmwuYyB8IDM5OSArKysrKysrKysrKysrKysrKysrKysrKysrKysrCiBkcml2ZXJz L2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfZXZ0Y2hubC5oIHwgIDg5ICsrKysrKysKIDUgZmls ZXMgY2hhbmdlZCwgNTI2IGluc2VydGlvbnMoKyksIDEgZGVsZXRpb24oLSkKIGNyZWF0ZSBtb2Rl IDEwMDY0NCBkcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfZXZ0Y2hubC5jCiBjcmVh dGUgbW9kZSAxMDA2NDQgZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2V2dGNobmwu aAoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS94ZW4vTWFrZWZpbGUgYi9kcml2ZXJzL2dw dS9kcm0veGVuL01ha2VmaWxlCmluZGV4IDBhMmVhZTc1N2YwYy4uNGNlNzc1NmI4NDM3IDEwMDY0 NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0veGVuL01ha2VmaWxlCisrKyBiL2RyaXZlcnMvZ3B1L2Ry bS94ZW4vTWFrZWZpbGUKQEAgLTEsNiArMSw3IEBACiAjIFNQRFgtTGljZW5zZS1JZGVudGlmaWVy OiBHUEwtMi4wCiAKIGRybV94ZW5fZnJvbnQtb2JqcyA6PSB4ZW5fZHJtX2Zyb250Lm8gXAorCQkg ICAgICB4ZW5fZHJtX2Zyb250X2V2dGNobmwubyBcCiAJCSAgICAgIHhlbl9kcm1fZnJvbnRfY2Zn Lm8KIAogb2JqLSQoQ09ORklHX0RSTV9YRU5fRlJPTlRFTkQpICs9IGRybV94ZW5fZnJvbnQubwpk aWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250LmMgYi9kcml2ZXJz L2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnQuYwppbmRleCAwYTkwYzQ3NGM3Y2UuLmI1NThlMGFl M2IzMyAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250LmMKKysr IGIvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250LmMKQEAgLTI1LDkgKzI1LDE1IEBA CiAjaW5jbHVkZSA8eGVuL2ludGVyZmFjZS9pby9kaXNwbGlmLmg+CiAKICNpbmNsdWRlICJ4ZW5f ZHJtX2Zyb250LmgiCisjaW5jbHVkZSAieGVuX2RybV9mcm9udF9ldnRjaG5sLmgiCisKK3N0YXRp YyBzdHJ1Y3QgeGVuX2RybV9mcm9udF9vcHMgZnJvbnRfb3BzID0geworCS8qIHBsYWNlaG9sZGVy IGZvciBub3cgKi8KK307CiAKIHN0YXRpYyB2b2lkIHhlbl9kcnZfcmVtb3ZlX2ludGVybmFsKHN0 cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2luZm8pCiB7CisJeGVuX2RybV9mcm9udF9l dnRjaG5sX2ZyZWVfYWxsKGZyb250X2luZm8pOwogfQogCiBzdGF0aWMgaW50IGJhY2tlbmRfb25f aW5pdHdhaXQoc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbykKQEAgLTQxLDE2 ICs0NywyMyBAQCBzdGF0aWMgaW50IGJhY2tlbmRfb25faW5pdHdhaXQoc3RydWN0IHhlbl9kcm1f ZnJvbnRfaW5mbyAqZnJvbnRfaW5mbykKIAkJcmV0dXJuIHJldDsKIAogCURSTV9JTkZPKCJIYXZl ICVkIGNvbmVjdG9yKHMpXG4iLCBjZmctPm51bV9jb25uZWN0b3JzKTsKLQlyZXR1cm4gMDsKKwkv KiBDcmVhdGUgZXZlbnQgY2hhbm5lbHMgZm9yIGFsbCBjb25uZWN0b3JzIGFuZCBwdWJsaXNoICov CisJcmV0ID0geGVuX2RybV9mcm9udF9ldnRjaG5sX2NyZWF0ZV9hbGwoZnJvbnRfaW5mbywgJmZy b250X29wcyk7CisJaWYgKHJldCA8IDApCisJCXJldHVybiByZXQ7CisKKwlyZXR1cm4geGVuX2Ry bV9mcm9udF9ldnRjaG5sX3B1Ymxpc2hfYWxsKGZyb250X2luZm8pOwogfQogCiBzdGF0aWMgaW50 IGJhY2tlbmRfb25fY29ubmVjdGVkKHN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2lu Zm8pCiB7CisJeGVuX2RybV9mcm9udF9ldnRjaG5sX3NldF9zdGF0ZShmcm9udF9pbmZvLCBFVlRD SE5MX1NUQVRFX0NPTk5FQ1RFRCk7CiAJcmV0dXJuIDA7CiB9CiAKIHN0YXRpYyB2b2lkIGJhY2tl bmRfb25fZGlzY29ubmVjdGVkKHN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2luZm8p CiB7CisJeGVuX2RybV9mcm9udF9ldnRjaG5sX3NldF9zdGF0ZShmcm9udF9pbmZvLCBFVlRDSE5M X1NUQVRFX0RJU0NPTk5FQ1RFRCk7CiAJeGVuYnVzX3N3aXRjaF9zdGF0ZShmcm9udF9pbmZvLT54 Yl9kZXYsIFhlbmJ1c1N0YXRlSW5pdGlhbGlzaW5nKTsKIH0KIApAQCAtMTMzLDYgKzE0Niw3IEBA IHN0YXRpYyBpbnQgeGVuX2Rydl9wcm9iZShzdHJ1Y3QgeGVuYnVzX2RldmljZSAqeGJfZGV2LAog CX0KIAogCWZyb250X2luZm8tPnhiX2RldiA9IHhiX2RldjsKKwlzcGluX2xvY2tfaW5pdCgmZnJv bnRfaW5mby0+aW9fbG9jayk7CiAJZGV2X3NldF9kcnZkYXRhKCZ4Yl9kZXYtPmRldiwgZnJvbnRf aW5mbyk7CiAJcmV0dXJuIHhlbmJ1c19zd2l0Y2hfc3RhdGUoeGJfZGV2LCBYZW5idXNTdGF0ZUlu aXRpYWxpc2luZyk7CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1f ZnJvbnQuaCBiL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udC5oCmluZGV4IDYyYjBk NGUzZTEyYi4uMTNmMjI3MzZhZTAyIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0veGVuL3hl bl9kcm1fZnJvbnQuaAorKysgYi9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnQuaApA QCAtMjEsOCArMjEsMzAgQEAKIAogI2luY2x1ZGUgInhlbl9kcm1fZnJvbnRfY2ZnLmgiCiAKKyNp Zm5kZWYgR1JBTlRfSU5WQUxJRF9SRUYKKy8qCisgKiBOb3RlIG9uIHVzYWdlIG9mIGdyYW50IHJl ZmVyZW5jZSAwIGFzIGludmFsaWQgZ3JhbnQgcmVmZXJlbmNlOgorICogZ3JhbnQgcmVmZXJlbmNl IDAgaXMgdmFsaWQsIGJ1dCBuZXZlciBleHBvc2VkIHRvIGEgUFYgZHJpdmVyLAorICogYmVjYXVz ZSBvZiB0aGUgZmFjdCBpdCBpcyBhbHJlYWR5IGluIHVzZS9yZXNlcnZlZCBieSB0aGUgUFYgY29u c29sZS4KKyAqLworI2RlZmluZSBHUkFOVF9JTlZBTElEX1JFRgkwCisjZW5kaWYKKworc3RydWN0 IHhlbl9kcm1fZnJvbnRfb3BzIHsKKwkvKiBDQVVUSU9OISB0aGlzIGlzIGNhbGxlZCB3aXRoIGEg c3Bpbl9sb2NrIGhlbGQhICovCisJdm9pZCAoKm9uX2ZyYW1lX2RvbmUpKHN0cnVjdCBwbGF0Zm9y bV9kZXZpY2UgKnBkZXYsCisJCQlpbnQgY29ubl9pZHgsIHVpbnQ2NF90IGZiX2Nvb2tpZSk7Cit9 OworCiBzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvIHsKIAlzdHJ1Y3QgeGVuYnVzX2RldmljZSAq eGJfZGV2OworCS8qIHRvIHByb3RlY3QgZGF0YSBiZXR3ZWVuIGJhY2tlbmQgSU8gY29kZSBhbmQg aW50ZXJydXB0IGhhbmRsZXIgKi8KKwlzcGlubG9ja190IGlvX2xvY2s7CisJLyogdmlydHVhbCBE Uk0gcGxhdGZvcm0gZGV2aWNlICovCisJc3RydWN0IHBsYXRmb3JtX2RldmljZSAqZHJtX3BkZXY7 CisKKwlpbnQgbnVtX2V2dF9wYWlyczsKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9ldnRjaG5sX3Bh aXIgKmV2dF9wYWlyczsKIAlzdHJ1Y3QgeGVuX2RybV9mcm9udF9jZmcgY2ZnOwogfTsKIApkaWZm IC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3hlbi94ZW5fZHJtX2Zyb250X2V2dGNobmwuYyBiL2Ry aXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9udF9ldnRjaG5sLmMKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi42OTdhMGU0ZGNhZWQKLS0tIC9kZXYvbnVsbAorKysg Yi9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1fZnJvbnRfZXZ0Y2hubC5jCkBAIC0wLDAgKzEs Mzk5IEBACisvKgorICogIFhlbiBwYXJhLXZpcnR1YWwgRFJNIGRldmljZQorICoKKyAqICAgVGhp cyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9v ciBtb2RpZnkKKyAqICAgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJs aWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKKyAqICAgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRh dGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKKyAqICAgKGF0IHlvdXIg b3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiAgIFRoaXMgcHJvZ3JhbSBpcyBkaXN0 cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICogICBidXQgV0lU SE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgor ICogICBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0Uu ICBTZWUgdGhlCisgKiAgIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFp bHMuCisgKgorICogQ29weXJpZ2h0IChDKSAyMDE2LTIwMTggRVBBTSBTeXN0ZW1zIEluYy4KKyAq CisgKiBBdXRob3I6IE9sZWtzYW5kciBBbmRydXNoY2hlbmtvIDxvbGVrc2FuZHJfYW5kcnVzaGNo ZW5rb0BlcGFtLmNvbT4KKyAqLworCisjaW5jbHVkZSA8ZHJtL2RybVAuaD4KKworI2luY2x1ZGUg PGxpbnV4L2Vycm5vLmg+CisjaW5jbHVkZSA8bGludXgvaXJxLmg+CisKKyNpbmNsdWRlIDx4ZW4v eGVuYnVzLmg+CisjaW5jbHVkZSA8eGVuL2V2ZW50cy5oPgorI2luY2x1ZGUgPHhlbi9ncmFudF90 YWJsZS5oPgorCisjaW5jbHVkZSAieGVuX2RybV9mcm9udC5oIgorI2luY2x1ZGUgInhlbl9kcm1f ZnJvbnRfZXZ0Y2hubC5oIgorCitzdGF0aWMgaXJxcmV0dXJuX3QgZXZ0Y2hubF9pbnRlcnJ1cHRf Y3RybChpbnQgaXJxLCB2b2lkICpkZXZfaWQpCit7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfZXZ0 Y2hubCAqZXZ0Y2hubCA9IGRldl9pZDsKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvICpmcm9u dF9pbmZvID0gZXZ0Y2hubC0+ZnJvbnRfaW5mbzsKKwlzdHJ1Y3QgeGVuZGlzcGxfcmVzcCAqcmVz cDsKKwlSSU5HX0lEWCBpLCBycDsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCisJc3Bpbl9sb2Nr X2lycXNhdmUoJmZyb250X2luZm8tPmlvX2xvY2ssIGZsYWdzKTsKKworCWlmICh1bmxpa2VseShl dnRjaG5sLT5zdGF0ZSAhPSBFVlRDSE5MX1NUQVRFX0NPTk5FQ1RFRCkpCisJCWdvdG8gb3V0Owor CithZ2FpbjoKKwlycCA9IGV2dGNobmwtPnUucmVxLnJpbmcuc3JpbmctPnJzcF9wcm9kOworCS8q IGVuc3VyZSB3ZSBzZWUgcXVldWVkIHJlc3BvbnNlcyB1cCB0byBycCAqLworCXZpcnRfcm1iKCk7 CisKKwlmb3IgKGkgPSBldnRjaG5sLT51LnJlcS5yaW5nLnJzcF9jb25zOyBpICE9IHJwOyBpKysp IHsKKwkJcmVzcCA9IFJJTkdfR0VUX1JFU1BPTlNFKCZldnRjaG5sLT51LnJlcS5yaW5nLCBpKTsK KwkJaWYgKHVubGlrZWx5KHJlc3AtPmlkICE9IGV2dGNobmwtPmV2dF9pZCkpCisJCQljb250aW51 ZTsKKworCQlzd2l0Y2ggKHJlc3AtPm9wZXJhdGlvbikgeworCQljYXNlIFhFTkRJU1BMX09QX1BH X0ZMSVA6CisJCWNhc2UgWEVORElTUExfT1BfRkJfQVRUQUNIOgorCQljYXNlIFhFTkRJU1BMX09Q X0ZCX0RFVEFDSDoKKwkJY2FzZSBYRU5ESVNQTF9PUF9EQlVGX0NSRUFURToKKwkJY2FzZSBYRU5E SVNQTF9PUF9EQlVGX0RFU1RST1k6CisJCWNhc2UgWEVORElTUExfT1BfU0VUX0NPTkZJRzoKKwkJ CWV2dGNobmwtPnUucmVxLnJlc3Bfc3RhdHVzID0gcmVzcC0+c3RhdHVzOworCQkJY29tcGxldGUo JmV2dGNobmwtPnUucmVxLmNvbXBsZXRpb24pOworCQkJYnJlYWs7CisKKwkJZGVmYXVsdDoKKwkJ CURSTV9FUlJPUigiT3BlcmF0aW9uICVkIGlzIG5vdCBzdXBwb3J0ZWRcbiIsCisJCQkJcmVzcC0+ b3BlcmF0aW9uKTsKKwkJCWJyZWFrOworCQl9CisJfQorCisJZXZ0Y2hubC0+dS5yZXEucmluZy5y c3BfY29ucyA9IGk7CisKKwlpZiAoaSAhPSBldnRjaG5sLT51LnJlcS5yaW5nLnJlcV9wcm9kX3B2 dCkgeworCQlpbnQgbW9yZV90b19kbzsKKworCQlSSU5HX0ZJTkFMX0NIRUNLX0ZPUl9SRVNQT05T RVMoJmV2dGNobmwtPnUucmVxLnJpbmcsCisJCQkJbW9yZV90b19kbyk7CisJCWlmIChtb3JlX3Rv X2RvKQorCQkJZ290byBhZ2FpbjsKKwl9IGVsc2UKKwkJZXZ0Y2hubC0+dS5yZXEucmluZy5zcmlu Zy0+cnNwX2V2ZW50ID0gaSArIDE7CisKK291dDoKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZm cm9udF9pbmZvLT5pb19sb2NrLCBmbGFncyk7CisJcmV0dXJuIElSUV9IQU5ETEVEOworfQorCitz dGF0aWMgaXJxcmV0dXJuX3QgZXZ0Y2hubF9pbnRlcnJ1cHRfZXZ0KGludCBpcnEsIHZvaWQgKmRl dl9pZCkKK3sKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9ldnRjaG5sICpldnRjaG5sID0gZGV2X2lk OworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2luZm8gPSBldnRjaG5sLT5mcm9u dF9pbmZvOworCXN0cnVjdCB4ZW5kaXNwbF9ldmVudF9wYWdlICpwYWdlID0gZXZ0Y2hubC0+dS5l dnQucGFnZTsKKwl1aW50MzJfdCBjb25zLCBwcm9kOworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisK KwlzcGluX2xvY2tfaXJxc2F2ZSgmZnJvbnRfaW5mby0+aW9fbG9jaywgZmxhZ3MpOworCWlmICh1 bmxpa2VseShldnRjaG5sLT5zdGF0ZSAhPSBFVlRDSE5MX1NUQVRFX0NPTk5FQ1RFRCkpCisJCWdv dG8gb3V0OworCisJcHJvZCA9IHBhZ2UtPmluX3Byb2Q7CisJLyogZW5zdXJlIHdlIHNlZSByaW5n IGNvbnRlbnRzIHVwIHRvIHByb2QgKi8KKwl2aXJ0X3JtYigpOworCWlmIChwcm9kID09IHBhZ2Ut PmluX2NvbnMpCisJCWdvdG8gb3V0OworCisJZm9yIChjb25zID0gcGFnZS0+aW5fY29uczsgY29u cyAhPSBwcm9kOyBjb25zKyspIHsKKwkJc3RydWN0IHhlbmRpc3BsX2V2dCAqZXZlbnQ7CisKKwkJ ZXZlbnQgPSAmWEVORElTUExfSU5fUklOR19SRUYocGFnZSwgY29ucyk7CisJCWlmICh1bmxpa2Vs eShldmVudC0+aWQgIT0gZXZ0Y2hubC0+ZXZ0X2lkKyspKQorCQkJY29udGludWU7CisKKwkJc3dp dGNoIChldmVudC0+dHlwZSkgeworCQljYXNlIFhFTkRJU1BMX0VWVF9QR19GTElQOgorCQkJZXZ0 Y2hubC0+dS5ldnQuZnJvbnRfb3BzLT5vbl9mcmFtZV9kb25lKAorCQkJCWZyb250X2luZm8tPmRy bV9wZGV2LCBldnRjaG5sLT5pbmRleCwKKwkJCQlldmVudC0+b3AucGdfZmxpcC5mYl9jb29raWUp OworCQkJYnJlYWs7CisJCX0KKwl9CisJcGFnZS0+aW5fY29ucyA9IGNvbnM7CisJLyogZW5zdXJl IHJpbmcgY29udGVudHMgKi8KKwl2aXJ0X3dtYigpOworCitvdXQ6CisJc3Bpbl91bmxvY2tfaXJx cmVzdG9yZSgmZnJvbnRfaW5mby0+aW9fbG9jaywgZmxhZ3MpOworCXJldHVybiBJUlFfSEFORExF RDsKK30KKworc3RhdGljIHZvaWQgZXZ0Y2hubF9mcmVlKHN0cnVjdCB4ZW5fZHJtX2Zyb250X2lu Zm8gKmZyb250X2luZm8sCisJCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2V2dGNobmwgKmV2dGNobmwp Cit7CisJdW5zaWduZWQgbG9uZyBwYWdlID0gMDsKKworCWlmIChldnRjaG5sLT50eXBlID09IEVW VENITkxfVFlQRV9SRVEpCisJCXBhZ2UgPSAodW5zaWduZWQgbG9uZylldnRjaG5sLT51LnJlcS5y aW5nLnNyaW5nOworCWVsc2UgaWYgKGV2dGNobmwtPnR5cGUgPT0gRVZUQ0hOTF9UWVBFX0VWVCkK KwkJcGFnZSA9ICh1bnNpZ25lZCBsb25nKWV2dGNobmwtPnUuZXZ0LnBhZ2U7CisJaWYgKCFwYWdl KQorCQlyZXR1cm47CisKKwlldnRjaG5sLT5zdGF0ZSA9IEVWVENITkxfU1RBVEVfRElTQ09OTkVD VEVEOworCisJaWYgKGV2dGNobmwtPnR5cGUgPT0gRVZUQ0hOTF9UWVBFX1JFUSkgeworCQkvKiBy ZWxlYXNlIGFsbCB3aG8gc3RpbGwgd2FpdHMgZm9yIHJlc3BvbnNlIGlmIGFueSAqLworCQlldnRj aG5sLT51LnJlcS5yZXNwX3N0YXR1cyA9IC1FSU87CisJCWNvbXBsZXRlX2FsbCgmZXZ0Y2hubC0+ dS5yZXEuY29tcGxldGlvbik7CisJfQorCisJaWYgKGV2dGNobmwtPmlycSkKKwkJdW5iaW5kX2Zy b21faXJxaGFuZGxlcihldnRjaG5sLT5pcnEsIGV2dGNobmwpOworCisJaWYgKGV2dGNobmwtPnBv cnQpCisJCXhlbmJ1c19mcmVlX2V2dGNobihmcm9udF9pbmZvLT54Yl9kZXYsIGV2dGNobmwtPnBv cnQpOworCisJLyogZW5kIGFjY2VzcyBhbmQgZnJlZSB0aGUgcGFnZSAqLworCWlmIChldnRjaG5s LT5ncmVmICE9IEdSQU5UX0lOVkFMSURfUkVGKQorCQlnbnR0YWJfZW5kX2ZvcmVpZ25fYWNjZXNz KGV2dGNobmwtPmdyZWYsIDAsIHBhZ2UpOworCisJaWYgKGV2dGNobmwtPnR5cGUgPT0gRVZUQ0hO TF9UWVBFX1JFUSkKKwkJZXZ0Y2hubC0+dS5yZXEucmluZy5zcmluZyA9IE5VTEw7CisJZWxzZQor CQlldnRjaG5sLT51LmV2dC5wYWdlID0gTlVMTDsKKworCW1lbXNldChldnRjaG5sLCAwLCBzaXpl b2YoKmV2dGNobmwpKTsKK30KKworc3RhdGljIGludCBldnRjaG5sX2FsbG9jKHN0cnVjdCB4ZW5f ZHJtX2Zyb250X2luZm8gKmZyb250X2luZm8sIGludCBpbmRleCwKKwkJc3RydWN0IHhlbl9kcm1f ZnJvbnRfZXZ0Y2hubCAqZXZ0Y2hubCwKKwkJZW51bSB4ZW5fZHJtX2Zyb250X2V2dGNobmxfdHlw ZSB0eXBlKQoreworCXN0cnVjdCB4ZW5idXNfZGV2aWNlICp4Yl9kZXYgPSBmcm9udF9pbmZvLT54 Yl9kZXY7CisJdW5zaWduZWQgbG9uZyBwYWdlOworCWdyYW50X3JlZl90IGdyZWY7CisJaXJxX2hh bmRsZXJfdCBoYW5kbGVyOworCWludCByZXQ7CisKKwltZW1zZXQoZXZ0Y2hubCwgMCwgc2l6ZW9m KCpldnRjaG5sKSk7CisJZXZ0Y2hubC0+dHlwZSA9IHR5cGU7CisJZXZ0Y2hubC0+aW5kZXggPSBp bmRleDsKKwlldnRjaG5sLT5mcm9udF9pbmZvID0gZnJvbnRfaW5mbzsKKwlldnRjaG5sLT5zdGF0 ZSA9IEVWVENITkxfU1RBVEVfRElTQ09OTkVDVEVEOworCWV2dGNobmwtPmdyZWYgPSBHUkFOVF9J TlZBTElEX1JFRjsKKworCXBhZ2UgPSBnZXRfemVyb2VkX3BhZ2UoR0ZQX05PSU8gfCBfX0dGUF9I SUdIKTsKKwlpZiAoIXBhZ2UpIHsKKwkJcmV0ID0gLUVOT01FTTsKKwkJZ290byBmYWlsOworCX0K KworCWlmICh0eXBlID09IEVWVENITkxfVFlQRV9SRVEpIHsKKwkJc3RydWN0IHhlbl9kaXNwbGlm X3NyaW5nICpzcmluZzsKKworCQlpbml0X2NvbXBsZXRpb24oJmV2dGNobmwtPnUucmVxLmNvbXBs ZXRpb24pOworCQlzcmluZyA9IChzdHJ1Y3QgeGVuX2Rpc3BsaWZfc3JpbmcgKilwYWdlOworCQlT SEFSRURfUklOR19JTklUKHNyaW5nKTsKKwkJRlJPTlRfUklOR19JTklUKCZldnRjaG5sLT51LnJl cS5yaW5nLAorCQkJCXNyaW5nLCBYRU5fUEFHRV9TSVpFKTsKKworCQlyZXQgPSB4ZW5idXNfZ3Jh bnRfcmluZyh4Yl9kZXYsIHNyaW5nLCAxLCAmZ3JlZik7CisJCWlmIChyZXQgPCAwKQorCQkJZ290 byBmYWlsOworCisJCWhhbmRsZXIgPSBldnRjaG5sX2ludGVycnVwdF9jdHJsOworCX0gZWxzZSB7 CisJCWV2dGNobmwtPnUuZXZ0LnBhZ2UgPSAoc3RydWN0IHhlbmRpc3BsX2V2ZW50X3BhZ2UgKilw YWdlOworCisJCXJldCA9IGdudHRhYl9ncmFudF9mb3JlaWduX2FjY2Vzcyh4Yl9kZXYtPm90aGVy ZW5kX2lkLAorCQkJCXZpcnRfdG9fZ2ZuKCh2b2lkICopcGFnZSksIDApOworCQlpZiAocmV0IDwg MCkKKwkJCWdvdG8gZmFpbDsKKworCQlncmVmID0gcmV0OworCQloYW5kbGVyID0gZXZ0Y2hubF9p bnRlcnJ1cHRfZXZ0OworCX0KKwlldnRjaG5sLT5ncmVmID0gZ3JlZjsKKworCXJldCA9IHhlbmJ1 c19hbGxvY19ldnRjaG4oeGJfZGV2LCAmZXZ0Y2hubC0+cG9ydCk7CisJaWYgKHJldCA8IDApCisJ CWdvdG8gZmFpbDsKKworCXJldCA9IGJpbmRfZXZ0Y2huX3RvX2lycWhhbmRsZXIoZXZ0Y2hubC0+ cG9ydCwKKwkJCWhhbmRsZXIsIDAsIHhiX2Rldi0+ZGV2aWNldHlwZSwgZXZ0Y2hubCk7CisJaWYg KHJldCA8IDApCisJCWdvdG8gZmFpbDsKKworCWV2dGNobmwtPmlycSA9IHJldDsKKwlyZXR1cm4g MDsKKworZmFpbDoKKwlEUk1fRVJST1IoIkZhaWxlZCB0byBhbGxvY2F0ZSByaW5nOiAlZFxuIiwg cmV0KTsKKwlyZXR1cm4gcmV0OworfQorCitpbnQgeGVuX2RybV9mcm9udF9ldnRjaG5sX2NyZWF0 ZV9hbGwoc3RydWN0IHhlbl9kcm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbywKKwkJc3RydWN0IHhl bl9kcm1fZnJvbnRfb3BzICpmcm9udF9vcHMpCit7CisJc3RydWN0IHhlbl9kcm1fZnJvbnRfY2Zn ICpjZmc7CisJaW50IHJldCwgY29ubjsKKworCWNmZyA9ICZmcm9udF9pbmZvLT5jZmc7CisKKwlm cm9udF9pbmZvLT5ldnRfcGFpcnMgPSBkZXZtX2tjYWxsb2MoJmZyb250X2luZm8tPnhiX2Rldi0+ ZGV2LAorCQkJY2ZnLT5udW1fY29ubmVjdG9ycywKKwkJCXNpemVvZihzdHJ1Y3QgeGVuX2RybV9m cm9udF9ldnRjaG5sX3BhaXIpLCBHRlBfS0VSTkVMKTsKKwlpZiAoIWZyb250X2luZm8tPmV2dF9w YWlycykgeworCQlyZXQgPSAtRU5PTUVNOworCQlnb3RvIGZhaWw7CisJfQorCisJZm9yIChjb25u ID0gMDsgY29ubiA8IGNmZy0+bnVtX2Nvbm5lY3RvcnM7IGNvbm4rKykgeworCQlyZXQgPSBldnRj aG5sX2FsbG9jKGZyb250X2luZm8sIGNvbm4sCisJCQkJJmZyb250X2luZm8tPmV2dF9wYWlyc1tj b25uXS5yZXEsCisJCQkJRVZUQ0hOTF9UWVBFX1JFUSk7CisJCWlmIChyZXQgPCAwKSB7CisJCQlE Uk1fRVJST1IoIkVycm9yIGFsbG9jYXRpbmcgY29udHJvbCBjaGFubmVsXG4iKTsKKwkJCWdvdG8g ZmFpbDsKKwkJfQorCisJCXJldCA9IGV2dGNobmxfYWxsb2MoZnJvbnRfaW5mbywgY29ubiwKKwkJ CQkmZnJvbnRfaW5mby0+ZXZ0X3BhaXJzW2Nvbm5dLmV2dCwKKwkJCQlFVlRDSE5MX1RZUEVfRVZU KTsKKwkJaWYgKHJldCA8IDApIHsKKwkJCURSTV9FUlJPUigiRXJyb3IgYWxsb2NhdGluZyBpbi1l dmVudCBjaGFubmVsXG4iKTsKKwkJCWdvdG8gZmFpbDsKKwkJfQorCisJCWZyb250X2luZm8tPmV2 dF9wYWlyc1tjb25uXS5ldnQudS5ldnQuZnJvbnRfb3BzID0gZnJvbnRfb3BzOworCX0KKwlmcm9u dF9pbmZvLT5udW1fZXZ0X3BhaXJzID0gY2ZnLT5udW1fY29ubmVjdG9yczsKKwlyZXR1cm4gMDsK KworZmFpbDoKKwl4ZW5fZHJtX2Zyb250X2V2dGNobmxfZnJlZV9hbGwoZnJvbnRfaW5mbyk7CisJ cmV0dXJuIHJldDsKK30KKworc3RhdGljIGludCBldnRjaG5sX3B1Ymxpc2goc3RydWN0IHhlbmJ1 c190cmFuc2FjdGlvbiB4YnQsCisJCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2V2dGNobmwgKmV2dGNo bmwsIGNvbnN0IGNoYXIgKnBhdGgsCisJCWNvbnN0IGNoYXIgKm5vZGVfcmluZywgY29uc3QgY2hh ciAqbm9kZV9jaG5sKQoreworCXN0cnVjdCB4ZW5idXNfZGV2aWNlICp4Yl9kZXYgPSBldnRjaG5s LT5mcm9udF9pbmZvLT54Yl9kZXY7CisJaW50IHJldDsKKworCS8qIHdyaXRlIGNvbnRyb2wgY2hh bm5lbCByaW5nIHJlZmVyZW5jZSAqLworCXJldCA9IHhlbmJ1c19wcmludGYoeGJ0LCBwYXRoLCBu b2RlX3JpbmcsICIldSIsIGV2dGNobmwtPmdyZWYpOworCWlmIChyZXQgPCAwKSB7CisJCXhlbmJ1 c19kZXZfZXJyb3IoeGJfZGV2LCByZXQsICJ3cml0aW5nIHJpbmctcmVmIik7CisJCXJldHVybiBy ZXQ7CisJfQorCisJLyogd3JpdGUgZXZlbnQgY2hhbm5lbCByaW5nIHJlZmVyZW5jZSAqLworCXJl dCA9IHhlbmJ1c19wcmludGYoeGJ0LCBwYXRoLCBub2RlX2NobmwsICIldSIsIGV2dGNobmwtPnBv cnQpOworCWlmIChyZXQgPCAwKSB7CisJCXhlbmJ1c19kZXZfZXJyb3IoeGJfZGV2LCByZXQsICJ3 cml0aW5nIGV2ZW50IGNoYW5uZWwiKTsKKwkJcmV0dXJuIHJldDsKKwl9CisKKwlyZXR1cm4gMDsK K30KKworaW50IHhlbl9kcm1fZnJvbnRfZXZ0Y2hubF9wdWJsaXNoX2FsbChzdHJ1Y3QgeGVuX2Ry bV9mcm9udF9pbmZvICpmcm9udF9pbmZvKQoreworCXN0cnVjdCB4ZW5idXNfdHJhbnNhY3Rpb24g eGJ0OworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2NmZyAqcGxhdF9kYXRhOworCWludCByZXQsIGNv bm47CisKKwlwbGF0X2RhdGEgPSAmZnJvbnRfaW5mby0+Y2ZnOworCithZ2FpbjoKKwlyZXQgPSB4 ZW5idXNfdHJhbnNhY3Rpb25fc3RhcnQoJnhidCk7CisJaWYgKHJldCA8IDApIHsKKwkJeGVuYnVz X2Rldl9mYXRhbChmcm9udF9pbmZvLT54Yl9kZXYsIHJldCwKKwkJCQkic3RhcnRpbmcgdHJhbnNh Y3Rpb24iKTsKKwkJcmV0dXJuIHJldDsKKwl9CisKKwlmb3IgKGNvbm4gPSAwOyBjb25uIDwgcGxh dF9kYXRhLT5udW1fY29ubmVjdG9yczsgY29ubisrKSB7CisJCXJldCA9IGV2dGNobmxfcHVibGlz aCh4YnQsCisJCQkJJmZyb250X2luZm8tPmV2dF9wYWlyc1tjb25uXS5yZXEsCisJCQkJcGxhdF9k YXRhLT5jb25uZWN0b3JzW2Nvbm5dLnhlbnN0b3JlX3BhdGgsCisJCQkJWEVORElTUExfRklFTERf UkVRX1JJTkdfUkVGLAorCQkJCVhFTkRJU1BMX0ZJRUxEX1JFUV9DSEFOTkVMKTsKKwkJaWYgKHJl dCA8IDApCisJCQlnb3RvIGZhaWw7CisKKwkJcmV0ID0gZXZ0Y2hubF9wdWJsaXNoKHhidCwKKwkJ CQkmZnJvbnRfaW5mby0+ZXZ0X3BhaXJzW2Nvbm5dLmV2dCwKKwkJCQlwbGF0X2RhdGEtPmNvbm5l Y3RvcnNbY29ubl0ueGVuc3RvcmVfcGF0aCwKKwkJCQlYRU5ESVNQTF9GSUVMRF9FVlRfUklOR19S RUYsCisJCQkJWEVORElTUExfRklFTERfRVZUX0NIQU5ORUwpOworCQlpZiAocmV0IDwgMCkKKwkJ CWdvdG8gZmFpbDsKKwl9CisKKwlyZXQgPSB4ZW5idXNfdHJhbnNhY3Rpb25fZW5kKHhidCwgMCk7 CisJaWYgKHJldCA8IDApIHsKKwkJaWYgKHJldCA9PSAtRUFHQUlOKQorCQkJZ290byBhZ2FpbjsK KworCQl4ZW5idXNfZGV2X2ZhdGFsKGZyb250X2luZm8tPnhiX2RldiwgcmV0LAorCQkJCSJjb21w bGV0aW5nIHRyYW5zYWN0aW9uIik7CisJCWdvdG8gZmFpbF90b19lbmQ7CisJfQorCisJcmV0dXJu IDA7CisKK2ZhaWw6CisJeGVuYnVzX3RyYW5zYWN0aW9uX2VuZCh4YnQsIDEpOworCitmYWlsX3Rv X2VuZDoKKwl4ZW5idXNfZGV2X2ZhdGFsKGZyb250X2luZm8tPnhiX2RldiwgcmV0LCAid3JpdGlu ZyBYZW4gc3RvcmUiKTsKKwlyZXR1cm4gcmV0OworfQorCit2b2lkIHhlbl9kcm1fZnJvbnRfZXZ0 Y2hubF9mbHVzaChzdHJ1Y3QgeGVuX2RybV9mcm9udF9ldnRjaG5sICpldnRjaG5sKQoreworCWlu dCBub3RpZnk7CisKKwlldnRjaG5sLT51LnJlcS5yaW5nLnJlcV9wcm9kX3B2dCsrOworCVJJTkdf UFVTSF9SRVFVRVNUU19BTkRfQ0hFQ0tfTk9USUZZKCZldnRjaG5sLT51LnJlcS5yaW5nLCBub3Rp ZnkpOworCWlmIChub3RpZnkpCisJCW5vdGlmeV9yZW1vdGVfdmlhX2lycShldnRjaG5sLT5pcnEp OworfQorCit2b2lkIHhlbl9kcm1fZnJvbnRfZXZ0Y2hubF9zZXRfc3RhdGUoc3RydWN0IHhlbl9k cm1fZnJvbnRfaW5mbyAqZnJvbnRfaW5mbywKKwkJZW51bSB4ZW5fZHJtX2Zyb250X2V2dGNobmxf c3RhdGUgc3RhdGUpCit7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKwlpbnQgaTsKKworCWlmICgh ZnJvbnRfaW5mby0+ZXZ0X3BhaXJzKQorCQlyZXR1cm47CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgm ZnJvbnRfaW5mby0+aW9fbG9jaywgZmxhZ3MpOworCWZvciAoaSA9IDA7IGkgPCBmcm9udF9pbmZv LT5udW1fZXZ0X3BhaXJzOyBpKyspIHsKKwkJZnJvbnRfaW5mby0+ZXZ0X3BhaXJzW2ldLnJlcS5z dGF0ZSA9IHN0YXRlOworCQlmcm9udF9pbmZvLT5ldnRfcGFpcnNbaV0uZXZ0LnN0YXRlID0gc3Rh dGU7CisJfQorCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmZyb250X2luZm8tPmlvX2xvY2ssIGZs YWdzKTsKKworfQorCit2b2lkIHhlbl9kcm1fZnJvbnRfZXZ0Y2hubF9mcmVlX2FsbChzdHJ1Y3Qg eGVuX2RybV9mcm9udF9pbmZvICpmcm9udF9pbmZvKQoreworCWludCBpOworCisJaWYgKCFmcm9u dF9pbmZvLT5ldnRfcGFpcnMpCisJCXJldHVybjsKKworCWZvciAoaSA9IDA7IGkgPCBmcm9udF9p bmZvLT5udW1fZXZ0X3BhaXJzOyBpKyspIHsKKwkJZXZ0Y2hubF9mcmVlKGZyb250X2luZm8sICZm cm9udF9pbmZvLT5ldnRfcGFpcnNbaV0ucmVxKTsKKwkJZXZ0Y2hubF9mcmVlKGZyb250X2luZm8s ICZmcm9udF9pbmZvLT5ldnRfcGFpcnNbaV0uZXZ0KTsKKwl9CisKKwlkZXZtX2tmcmVlKCZmcm9u dF9pbmZvLT54Yl9kZXYtPmRldiwgZnJvbnRfaW5mby0+ZXZ0X3BhaXJzKTsKKwlmcm9udF9pbmZv LT5ldnRfcGFpcnMgPSBOVUxMOworfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3hlbi94 ZW5fZHJtX2Zyb250X2V2dGNobmwuaCBiL2RyaXZlcnMvZ3B1L2RybS94ZW4veGVuX2RybV9mcm9u dF9ldnRjaG5sLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi5lNzJk M2FhNjhiNGUKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2dwdS9kcm0veGVuL3hlbl9kcm1f ZnJvbnRfZXZ0Y2hubC5oCkBAIC0wLDAgKzEsODkgQEAKKy8qCisgKiAgWGVuIHBhcmEtdmlydHVh bCBEUk0gZGV2aWNlCisgKgorICogICBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91 IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQorICogICBpdCB1bmRlciB0aGUgdGVy bXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQorICog ICB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBM aWNlbnNlLCBvcgorICogICAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICoK KyAqICAgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2ls bCBiZSB1c2VmdWwsCisgKiAgIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVu IHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiAgIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNT IEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKKyAqICAgR05VIEdlbmVyYWwgUHVi bGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMTYt MjAxOCBFUEFNIFN5c3RlbXMgSW5jLgorICoKKyAqIEF1dGhvcjogT2xla3NhbmRyIEFuZHJ1c2hj aGVua28gPG9sZWtzYW5kcl9hbmRydXNoY2hlbmtvQGVwYW0uY29tPgorICovCisKKyNpZm5kZWYg X19YRU5fRFJNX0ZST05UX0VWVENITkxfSF8KKyNkZWZpbmUgX19YRU5fRFJNX0ZST05UX0VWVENI TkxfSF8KKworI2luY2x1ZGUgPGxpbnV4L2NvbXBsZXRpb24uaD4KKyNpbmNsdWRlIDxsaW51eC90 eXBlcy5oPgorCisjaW5jbHVkZSA8eGVuL2ludGVyZmFjZS9pby9yaW5nLmg+CisjaW5jbHVkZSA8 eGVuL2ludGVyZmFjZS9pby9kaXNwbGlmLmg+CisKKy8qCisgKiBBbGwgb3BlcmF0aW9ucyB3aGlj aCBhcmUgbm90IGNvbm5lY3RvciBvcmllbnRlZCB1c2UgdGhpcyBjdHJsIGV2ZW50IGNoYW5uZWws CisgKiBlLmcuIGZiX2F0dGFjaC9kZXN0cm95IHdoaWNoIGJlbG9uZyB0byBhIERSTSBkZXZpY2Us IG5vdCB0byBhIENSVEMuCisgKi8KKyNkZWZpbmUgR0VORVJJQ19PUF9FVlRfQ0hOTAkwCisKK2Vu dW0geGVuX2RybV9mcm9udF9ldnRjaG5sX3N0YXRlIHsKKwlFVlRDSE5MX1NUQVRFX0RJU0NPTk5F Q1RFRCwKKwlFVlRDSE5MX1NUQVRFX0NPTk5FQ1RFRCwKK307CisKK2VudW0geGVuX2RybV9mcm9u dF9ldnRjaG5sX3R5cGUgeworCUVWVENITkxfVFlQRV9SRVEsCisJRVZUQ0hOTF9UWVBFX0VWVCwK K307CisKK3N0cnVjdCB4ZW5fZHJtX2Zyb250X2RybV9pbmZvOworCitzdHJ1Y3QgeGVuX2RybV9m cm9udF9ldnRjaG5sIHsKKwlzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvICpmcm9udF9pbmZvOwor CWludCBncmVmOworCWludCBwb3J0OworCWludCBpcnE7CisJaW50IGluZGV4OworCWVudW0geGVu X2RybV9mcm9udF9ldnRjaG5sX3N0YXRlIHN0YXRlOworCWVudW0geGVuX2RybV9mcm9udF9ldnRj aG5sX3R5cGUgdHlwZTsKKwkvKiBlaXRoZXIgcmVzcG9uc2UgaWQgb3IgaW5jb21pbmcgZXZlbnQg aWQgKi8KKwl1aW50MTZfdCBldnRfaWQ7CisJLyogbmV4dCByZXF1ZXN0IGlkIG9yIG5leHQgZXhw ZWN0ZWQgZXZlbnQgaWQgKi8KKwl1aW50MTZfdCBldnRfbmV4dF9pZDsKKwl1bmlvbiB7CisJCXN0 cnVjdCB7CisJCQlzdHJ1Y3QgeGVuX2Rpc3BsaWZfZnJvbnRfcmluZyByaW5nOworCQkJc3RydWN0 IGNvbXBsZXRpb24gY29tcGxldGlvbjsKKwkJCS8qIGxhdGVzdCByZXNwb25zZSBzdGF0dXMgKi8K KwkJCWludCByZXNwX3N0YXR1czsKKwkJfSByZXE7CisJCXN0cnVjdCB7CisJCQlzdHJ1Y3QgeGVu ZGlzcGxfZXZlbnRfcGFnZSAqcGFnZTsKKwkJCXN0cnVjdCB4ZW5fZHJtX2Zyb250X29wcyAqZnJv bnRfb3BzOworCQl9IGV2dDsKKwl9IHU7Cit9OworCitzdHJ1Y3QgeGVuX2RybV9mcm9udF9ldnRj aG5sX3BhaXIgeworCXN0cnVjdCB4ZW5fZHJtX2Zyb250X2V2dGNobmwgcmVxOworCXN0cnVjdCB4 ZW5fZHJtX2Zyb250X2V2dGNobmwgZXZ0OworfTsKKworaW50IHhlbl9kcm1fZnJvbnRfZXZ0Y2hu bF9jcmVhdGVfYWxsKHN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2luZm8sCisJCXN0 cnVjdCB4ZW5fZHJtX2Zyb250X29wcyAqZnJvbnRfb3BzKTsKKworaW50IHhlbl9kcm1fZnJvbnRf ZXZ0Y2hubF9wdWJsaXNoX2FsbChzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvICpmcm9udF9pbmZv KTsKKwordm9pZCB4ZW5fZHJtX2Zyb250X2V2dGNobmxfZmx1c2goc3RydWN0IHhlbl9kcm1fZnJv bnRfZXZ0Y2hubCAqZXZ0Y2hubCk7CisKK3ZvaWQgeGVuX2RybV9mcm9udF9ldnRjaG5sX3NldF9z dGF0ZShzdHJ1Y3QgeGVuX2RybV9mcm9udF9pbmZvICpmcm9udF9pbmZvLAorCQllbnVtIHhlbl9k cm1fZnJvbnRfZXZ0Y2hubF9zdGF0ZSBzdGF0ZSk7CisKK3ZvaWQgeGVuX2RybV9mcm9udF9ldnRj aG5sX2ZyZWVfYWxsKHN0cnVjdCB4ZW5fZHJtX2Zyb250X2luZm8gKmZyb250X2luZm8pOworCisj ZW5kaWYgLyogX19YRU5fRFJNX0ZST05UX0VWVENITkxfSF8gKi8KLS0gCjIuNy40CgpfX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGlu ZyBsaXN0CmRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVl ZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9kcmktZGV2ZWwK