From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from galahad.ideasonboard.com ([185.26.127.97]:59901 "EHLO galahad.ideasonboard.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752454AbdCFAKD (ORCPT ); Sun, 5 Mar 2017 19:10:03 -0500 From: Laurent Pinchart To: dri-devel@lists.freedesktop.org Cc: linux-renesas-soc@vger.kernel.org Subject: [PATCH v3 3/9] drm: rcar-du: Replace manual bridge implementation with DRM bridge Date: Mon, 6 Mar 2017 02:02:56 +0200 Message-Id: <20170306000302.14149-4-laurent.pinchart+renesas@ideasonboard.com> In-Reply-To: <20170306000302.14149-1-laurent.pinchart+renesas@ideasonboard.com> References: <20170306000302.14149-1-laurent.pinchart+renesas@ideasonboard.com> Sender: linux-renesas-soc-owner@vger.kernel.org List-ID: The rcar-du driver contains a manual implementation of HDMI and VGA bridges. Use DRM bridges to replace it. Signed-off-by: Laurent Pinchart --- drivers/gpu/drm/rcar-du/Kconfig | 6 -- drivers/gpu/drm/rcar-du/Makefile | 5 +- drivers/gpu/drm/rcar-du/rcar_du_encoder.c | 104 +++++++++++++---------- drivers/gpu/drm/rcar-du/rcar_du_encoder.h | 2 - drivers/gpu/drm/rcar-du/rcar_du_hdmienc.c | 134 ------------------------------ drivers/gpu/drm/rcar-du/rcar_du_hdmienc.h | 35 -------- drivers/gpu/drm/rcar-du/rcar_du_vgacon.c | 82 ------------------ drivers/gpu/drm/rcar-du/rcar_du_vgacon.h | 23 ----- 8 files changed, 60 insertions(+), 331 deletions(-) delete mode 100644 drivers/gpu/drm/rcar-du/rcar_du_hdmienc.c delete mode 100644 drivers/gpu/drm/rcar-du/rcar_du_hdmienc.h delete mode 100644 drivers/gpu/drm/rcar-du/rcar_du_vgacon.c delete mode 100644 drivers/gpu/drm/rcar-du/rcar_du_vgacon.h diff --git a/drivers/gpu/drm/rcar-du/Kconfig b/drivers/gpu/drm/rcar-du/Kconfig index 2bab449add76..06121eeba9e5 100644 --- a/drivers/gpu/drm/rcar-du/Kconfig +++ b/drivers/gpu/drm/rcar-du/Kconfig @@ -11,12 +11,6 @@ config DRM_RCAR_DU Choose this option if you have an R-Car chipset. If M is selected the module will be called rcar-du-drm. -config DRM_RCAR_HDMI - bool "R-Car DU HDMI Encoder Support" - depends on DRM_RCAR_DU - help - Enable support for external HDMI encoders. - config DRM_RCAR_LVDS bool "R-Car DU LVDS Encoder Support" depends on DRM_RCAR_DU diff --git a/drivers/gpu/drm/rcar-du/Makefile b/drivers/gpu/drm/rcar-du/Makefile index d3b44651061a..a492e6858691 100644 --- a/drivers/gpu/drm/rcar-du/Makefile +++ b/drivers/gpu/drm/rcar-du/Makefile @@ -4,10 +4,7 @@ rcar-du-drm-y := rcar_du_crtc.o \ rcar_du_group.o \ rcar_du_kms.o \ rcar_du_lvdscon.o \ - rcar_du_plane.o \ - rcar_du_vgacon.o - -rcar-du-drm-$(CONFIG_DRM_RCAR_HDMI) += rcar_du_hdmienc.o + rcar_du_plane.o rcar-du-drm-$(CONFIG_DRM_RCAR_LVDS) += rcar_du_lvdsenc.o diff --git a/drivers/gpu/drm/rcar-du/rcar_du_encoder.c b/drivers/gpu/drm/rcar-du/rcar_du_encoder.c index 3a3c9374794e..92a0405c2fb2 100644 --- a/drivers/gpu/drm/rcar-du/rcar_du_encoder.c +++ b/drivers/gpu/drm/rcar-du/rcar_du_encoder.c @@ -20,11 +20,9 @@ #include "rcar_du_drv.h" #include "rcar_du_encoder.h" -#include "rcar_du_hdmienc.h" #include "rcar_du_kms.h" #include "rcar_du_lvdscon.h" #include "rcar_du_lvdsenc.h" -#include "rcar_du_vgacon.h" /* ----------------------------------------------------------------------------- * Encoder @@ -63,29 +61,35 @@ static int rcar_du_encoder_atomic_check(struct drm_encoder *encoder, struct rcar_du_encoder *renc = to_rcar_encoder(encoder); struct drm_display_mode *adjusted_mode = &crtc_state->adjusted_mode; const struct drm_display_mode *mode = &crtc_state->mode; - const struct drm_display_mode *panel_mode; struct drm_connector *connector = conn_state->connector; struct drm_device *dev = encoder->dev; - /* DAC encoders have currently no restriction on the mode. */ - if (encoder->encoder_type == DRM_MODE_ENCODER_DAC) - return 0; + /* + * Only panel-related encoder types require validation here, everything + * else is handled by the bridge drivers. + */ + if (encoder->encoder_type == DRM_MODE_ENCODER_LVDS) { + const struct drm_display_mode *panel_mode; - if (list_empty(&connector->modes)) { - dev_dbg(dev->dev, "encoder: empty modes list\n"); - return -EINVAL; - } + if (list_empty(&connector->modes)) { + dev_dbg(dev->dev, "encoder: empty modes list\n"); + return -EINVAL; + } - panel_mode = list_first_entry(&connector->modes, - struct drm_display_mode, head); + panel_mode = list_first_entry(&connector->modes, + struct drm_display_mode, head); - /* We're not allowed to modify the resolution. */ - if (mode->hdisplay != panel_mode->hdisplay || - mode->vdisplay != panel_mode->vdisplay) - return -EINVAL; + /* We're not allowed to modify the resolution. */ + if (mode->hdisplay != panel_mode->hdisplay || + mode->vdisplay != panel_mode->vdisplay) + return -EINVAL; - /* The flat panel mode is fixed, just copy it to the adjusted mode. */ - drm_mode_copy(adjusted_mode, panel_mode); + /* + * The flat panel mode is fixed, just copy it to the adjusted + * mode. + */ + drm_mode_copy(adjusted_mode, panel_mode); + } if (renc->lvds) rcar_du_lvdsenc_atomic_check(renc->lvds, adjusted_mode); @@ -159,6 +163,7 @@ int rcar_du_encoder_init(struct rcar_du_device *rcdu, { struct rcar_du_encoder *renc; struct drm_encoder *encoder; + struct drm_bridge *bridge = NULL; unsigned int encoder_type; int ret; @@ -182,6 +187,15 @@ int rcar_du_encoder_init(struct rcar_du_device *rcdu, break; } + if (enc_node) { + /* Locate the DRM bridge from the encoder DT node. */ + bridge = of_drm_find_bridge(enc_node); + if (!bridge) { + ret = -EPROBE_DEFER; + goto done; + } + } + switch (type) { case RCAR_DU_ENCODER_VGA: encoder_type = DRM_MODE_ENCODER_DAC; @@ -199,35 +213,35 @@ int rcar_du_encoder_init(struct rcar_du_device *rcdu, break; } - if (type == RCAR_DU_ENCODER_HDMI) { - ret = rcar_du_hdmienc_init(rcdu, renc, enc_node); - if (ret < 0) - goto done; - } else { - ret = drm_encoder_init(rcdu->ddev, encoder, &encoder_funcs, - encoder_type, NULL); - if (ret < 0) - goto done; - - drm_encoder_helper_add(encoder, &encoder_helper_funcs); - } - - switch (encoder_type) { - case DRM_MODE_ENCODER_LVDS: - ret = rcar_du_lvds_connector_init(rcdu, renc, con_node); - break; - - case DRM_MODE_ENCODER_DAC: - ret = rcar_du_vga_connector_init(rcdu, renc); - break; + ret = drm_encoder_init(rcdu->ddev, encoder, &encoder_funcs, + encoder_type, NULL); + if (ret < 0) + goto done; - case DRM_MODE_ENCODER_TMDS: - /* connector managed by the bridge driver */ - break; + drm_encoder_helper_add(encoder, &encoder_helper_funcs); - default: - ret = -EINVAL; - break; + if (bridge) { + /* + * Attach the bridge to the encoder. The bridge will create the + * connector. + */ + ret = drm_bridge_attach(encoder, bridge, NULL); + if (ret) { + drm_encoder_cleanup(encoder); + return ret; + } + } else { + /* There's no bridge, create the connector manually. */ + switch (output) { + case RCAR_DU_OUTPUT_LVDS0: + case RCAR_DU_OUTPUT_LVDS1: + ret = rcar_du_lvds_connector_init(rcdu, renc, con_node); + break; + + default: + ret = -EINVAL; + break; + } } done: diff --git a/drivers/gpu/drm/rcar-du/rcar_du_encoder.h b/drivers/gpu/drm/rcar-du/rcar_du_encoder.h index b79b2f075a74..c1cfbe0d54ce 100644 --- a/drivers/gpu/drm/rcar-du/rcar_du_encoder.h +++ b/drivers/gpu/drm/rcar-du/rcar_du_encoder.h @@ -19,7 +19,6 @@ struct drm_panel; struct rcar_du_device; -struct rcar_du_hdmienc; struct rcar_du_lvdsenc; enum rcar_du_encoder_type { @@ -34,7 +33,6 @@ struct rcar_du_encoder { struct drm_encoder base; enum rcar_du_output output; struct rcar_du_connector *connector; - struct rcar_du_hdmienc *hdmi; struct rcar_du_lvdsenc *lvds; }; diff --git a/drivers/gpu/drm/rcar-du/rcar_du_hdmienc.c b/drivers/gpu/drm/rcar-du/rcar_du_hdmienc.c deleted file mode 100644 index 933a2547798e..000000000000 --- a/drivers/gpu/drm/rcar-du/rcar_du_hdmienc.c +++ /dev/null @@ -1,134 +0,0 @@ -/* - * R-Car Display Unit HDMI Encoder - * - * Copyright (C) 2014 Renesas Electronics Corporation - * - * Contact: Laurent Pinchart (laurent.pinchart@ideasonboard.com) - * - * 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. - */ - -#include - -#include -#include -#include - -#include "rcar_du_drv.h" -#include "rcar_du_encoder.h" -#include "rcar_du_hdmienc.h" -#include "rcar_du_lvdsenc.h" - -struct rcar_du_hdmienc { - struct rcar_du_encoder *renc; - bool enabled; -}; - -#define to_rcar_hdmienc(e) (to_rcar_encoder(e)->hdmi) - -static void rcar_du_hdmienc_disable(struct drm_encoder *encoder) -{ - struct rcar_du_hdmienc *hdmienc = to_rcar_hdmienc(encoder); - - if (hdmienc->renc->lvds) - rcar_du_lvdsenc_enable(hdmienc->renc->lvds, encoder->crtc, - false); - - hdmienc->enabled = false; -} - -static void rcar_du_hdmienc_enable(struct drm_encoder *encoder) -{ - struct rcar_du_hdmienc *hdmienc = to_rcar_hdmienc(encoder); - - if (hdmienc->renc->lvds) - rcar_du_lvdsenc_enable(hdmienc->renc->lvds, encoder->crtc, - true); - - hdmienc->enabled = true; -} - -static int rcar_du_hdmienc_atomic_check(struct drm_encoder *encoder, - struct drm_crtc_state *crtc_state, - struct drm_connector_state *conn_state) -{ - struct rcar_du_hdmienc *hdmienc = to_rcar_hdmienc(encoder); - struct drm_display_mode *adjusted_mode = &crtc_state->adjusted_mode; - - if (hdmienc->renc->lvds) - rcar_du_lvdsenc_atomic_check(hdmienc->renc->lvds, - adjusted_mode); - - return 0; -} - - -static void rcar_du_hdmienc_mode_set(struct drm_encoder *encoder, - struct drm_crtc_state *crtc_state, - struct drm_connector_state *conn_state) -{ - struct rcar_du_hdmienc *hdmienc = to_rcar_hdmienc(encoder); - - rcar_du_crtc_route_output(crtc_state->crtc, hdmienc->renc->output); -} - -static const struct drm_encoder_helper_funcs encoder_helper_funcs = { - .atomic_mode_set = rcar_du_hdmienc_mode_set, - .disable = rcar_du_hdmienc_disable, - .enable = rcar_du_hdmienc_enable, - .atomic_check = rcar_du_hdmienc_atomic_check, -}; - -static void rcar_du_hdmienc_cleanup(struct drm_encoder *encoder) -{ - struct rcar_du_hdmienc *hdmienc = to_rcar_hdmienc(encoder); - - if (hdmienc->enabled) - rcar_du_hdmienc_disable(encoder); - - drm_encoder_cleanup(encoder); -} - -static const struct drm_encoder_funcs encoder_funcs = { - .destroy = rcar_du_hdmienc_cleanup, -}; - -int rcar_du_hdmienc_init(struct rcar_du_device *rcdu, - struct rcar_du_encoder *renc, struct device_node *np) -{ - struct drm_encoder *encoder = rcar_encoder_to_drm_encoder(renc); - struct drm_bridge *bridge; - struct rcar_du_hdmienc *hdmienc; - int ret; - - hdmienc = devm_kzalloc(rcdu->dev, sizeof(*hdmienc), GFP_KERNEL); - if (hdmienc == NULL) - return -ENOMEM; - - /* Locate the DRM bridge from the HDMI encoder DT node. */ - bridge = of_drm_find_bridge(np); - if (!bridge) - return -EPROBE_DEFER; - - ret = drm_encoder_init(rcdu->ddev, encoder, &encoder_funcs, - DRM_MODE_ENCODER_TMDS, NULL); - if (ret < 0) - return ret; - - drm_encoder_helper_add(encoder, &encoder_helper_funcs); - - renc->hdmi = hdmienc; - hdmienc->renc = renc; - - /* Link the bridge to the encoder. */ - ret = drm_bridge_attach(encoder, bridge, NULL); - if (ret) { - drm_encoder_cleanup(encoder); - return ret; - } - - return 0; -} diff --git a/drivers/gpu/drm/rcar-du/rcar_du_hdmienc.h b/drivers/gpu/drm/rcar-du/rcar_du_hdmienc.h deleted file mode 100644 index 2ff0128ac8e1..000000000000 --- a/drivers/gpu/drm/rcar-du/rcar_du_hdmienc.h +++ /dev/null @@ -1,35 +0,0 @@ -/* - * R-Car Display Unit HDMI Encoder - * - * Copyright (C) 2014 Renesas Electronics Corporation - * - * Contact: Laurent Pinchart (laurent.pinchart@ideasonboard.com) - * - * 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. - */ - -#ifndef __RCAR_DU_HDMIENC_H__ -#define __RCAR_DU_HDMIENC_H__ - -#include - -struct device_node; -struct rcar_du_device; -struct rcar_du_encoder; - -#if IS_ENABLED(CONFIG_DRM_RCAR_HDMI) -int rcar_du_hdmienc_init(struct rcar_du_device *rcdu, - struct rcar_du_encoder *renc, struct device_node *np); -#else -static inline int rcar_du_hdmienc_init(struct rcar_du_device *rcdu, - struct rcar_du_encoder *renc, - struct device_node *np) -{ - return -ENOSYS; -} -#endif - -#endif /* __RCAR_DU_HDMIENC_H__ */ diff --git a/drivers/gpu/drm/rcar-du/rcar_du_vgacon.c b/drivers/gpu/drm/rcar-du/rcar_du_vgacon.c deleted file mode 100644 index 8d6125c1c0f9..000000000000 --- a/drivers/gpu/drm/rcar-du/rcar_du_vgacon.c +++ /dev/null @@ -1,82 +0,0 @@ -/* - * rcar_du_vgacon.c -- R-Car Display Unit VGA Connector - * - * Copyright (C) 2013-2014 Renesas Electronics Corporation - * - * Contact: Laurent Pinchart (laurent.pinchart@ideasonboard.com) - * - * 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. - */ - -#include -#include -#include -#include - -#include "rcar_du_drv.h" -#include "rcar_du_encoder.h" -#include "rcar_du_kms.h" -#include "rcar_du_vgacon.h" - -static int rcar_du_vga_connector_get_modes(struct drm_connector *connector) -{ - return 0; -} - -static const struct drm_connector_helper_funcs connector_helper_funcs = { - .get_modes = rcar_du_vga_connector_get_modes, -}; - -static enum drm_connector_status -rcar_du_vga_connector_detect(struct drm_connector *connector, bool force) -{ - return connector_status_connected; -} - -static const struct drm_connector_funcs connector_funcs = { - .dpms = drm_atomic_helper_connector_dpms, - .reset = drm_atomic_helper_connector_reset, - .detect = rcar_du_vga_connector_detect, - .fill_modes = drm_helper_probe_single_connector_modes, - .destroy = drm_connector_cleanup, - .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state, - .atomic_destroy_state = drm_atomic_helper_connector_destroy_state, -}; - -int rcar_du_vga_connector_init(struct rcar_du_device *rcdu, - struct rcar_du_encoder *renc) -{ - struct drm_encoder *encoder = rcar_encoder_to_drm_encoder(renc); - struct rcar_du_connector *rcon; - struct drm_connector *connector; - int ret; - - rcon = devm_kzalloc(rcdu->dev, sizeof(*rcon), GFP_KERNEL); - if (rcon == NULL) - return -ENOMEM; - - connector = &rcon->connector; - connector->display_info.width_mm = 0; - connector->display_info.height_mm = 0; - connector->interlace_allowed = true; - - ret = drm_connector_init(rcdu->ddev, connector, &connector_funcs, - DRM_MODE_CONNECTOR_VGA); - if (ret < 0) - return ret; - - drm_connector_helper_add(connector, &connector_helper_funcs); - - connector->dpms = DRM_MODE_DPMS_OFF; - drm_object_property_set_value(&connector->base, - rcdu->ddev->mode_config.dpms_property, DRM_MODE_DPMS_OFF); - - ret = drm_mode_connector_attach_encoder(connector, encoder); - if (ret < 0) - return ret; - - return 0; -} diff --git a/drivers/gpu/drm/rcar-du/rcar_du_vgacon.h b/drivers/gpu/drm/rcar-du/rcar_du_vgacon.h deleted file mode 100644 index 112f50316e01..000000000000 --- a/drivers/gpu/drm/rcar-du/rcar_du_vgacon.h +++ /dev/null @@ -1,23 +0,0 @@ -/* - * rcar_du_vgacon.h -- R-Car Display Unit VGA Connector - * - * Copyright (C) 2013-2014 Renesas Electronics Corporation - * - * Contact: Laurent Pinchart (laurent.pinchart@ideasonboard.com) - * - * 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. - */ - -#ifndef __RCAR_DU_VGACON_H__ -#define __RCAR_DU_VGACON_H__ - -struct rcar_du_device; -struct rcar_du_encoder; - -int rcar_du_vga_connector_init(struct rcar_du_device *rcdu, - struct rcar_du_encoder *renc); - -#endif /* __RCAR_DU_VGACON_H__ */ -- Regards, Laurent Pinchart From mboxrd@z Thu Jan 1 00:00:00 1970 From: Laurent Pinchart Subject: [PATCH v3 3/9] drm: rcar-du: Replace manual bridge implementation with DRM bridge Date: Mon, 6 Mar 2017 02:02:56 +0200 Message-ID: <20170306000302.14149-4-laurent.pinchart+renesas@ideasonboard.com> References: <20170306000302.14149-1-laurent.pinchart+renesas@ideasonboard.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from galahad.ideasonboard.com (galahad.ideasonboard.com [185.26.127.97]) by gabe.freedesktop.org (Postfix) with ESMTPS id B96426E31D for ; Mon, 6 Mar 2017 00:02:32 +0000 (UTC) In-Reply-To: <20170306000302.14149-1-laurent.pinchart+renesas@ideasonboard.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: dri-devel@lists.freedesktop.org Cc: linux-renesas-soc@vger.kernel.org List-Id: dri-devel@lists.freedesktop.org VGhlIHJjYXItZHUgZHJpdmVyIGNvbnRhaW5zIGEgbWFudWFsIGltcGxlbWVudGF0aW9uIG9mIEhE TUkgYW5kIFZHQQpicmlkZ2VzLiBVc2UgRFJNIGJyaWRnZXMgdG8gcmVwbGFjZSBpdC4KClNpZ25l ZC1vZmYtYnk6IExhdXJlbnQgUGluY2hhcnQgPGxhdXJlbnQucGluY2hhcnQrcmVuZXNhc0BpZGVh c29uYm9hcmQuY29tPgotLS0KIGRyaXZlcnMvZ3B1L2RybS9yY2FyLWR1L0tjb25maWcgICAgICAg ICAgIHwgICA2IC0tCiBkcml2ZXJzL2dwdS9kcm0vcmNhci1kdS9NYWtlZmlsZSAgICAgICAgICB8 ICAgNSArLQogZHJpdmVycy9ncHUvZHJtL3JjYXItZHUvcmNhcl9kdV9lbmNvZGVyLmMgfCAxMDQg KysrKysrKysrKysrKy0tLS0tLS0tLS0KIGRyaXZlcnMvZ3B1L2RybS9yY2FyLWR1L3JjYXJfZHVf ZW5jb2Rlci5oIHwgICAyIC0KIGRyaXZlcnMvZ3B1L2RybS9yY2FyLWR1L3JjYXJfZHVfaGRtaWVu Yy5jIHwgMTM0IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogZHJpdmVycy9ncHUvZHJt L3JjYXItZHUvcmNhcl9kdV9oZG1pZW5jLmggfCAgMzUgLS0tLS0tLS0KIGRyaXZlcnMvZ3B1L2Ry bS9yY2FyLWR1L3JjYXJfZHVfdmdhY29uLmMgIHwgIDgyIC0tLS0tLS0tLS0tLS0tLS0tLQogZHJp dmVycy9ncHUvZHJtL3JjYXItZHUvcmNhcl9kdV92Z2Fjb24uaCAgfCAgMjMgLS0tLS0KIDggZmls ZXMgY2hhbmdlZCwgNjAgaW5zZXJ0aW9ucygrKSwgMzMxIGRlbGV0aW9ucygtKQogZGVsZXRlIG1v ZGUgMTAwNjQ0IGRyaXZlcnMvZ3B1L2RybS9yY2FyLWR1L3JjYXJfZHVfaGRtaWVuYy5jCiBkZWxl dGUgbW9kZSAxMDA2NDQgZHJpdmVycy9ncHUvZHJtL3JjYXItZHUvcmNhcl9kdV9oZG1pZW5jLmgK IGRlbGV0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2dwdS9kcm0vcmNhci1kdS9yY2FyX2R1X3ZnYWNv bi5jCiBkZWxldGUgbW9kZSAxMDA2NDQgZHJpdmVycy9ncHUvZHJtL3JjYXItZHUvcmNhcl9kdV92 Z2Fjb24uaAoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9yY2FyLWR1L0tjb25maWcgYi9k cml2ZXJzL2dwdS9kcm0vcmNhci1kdS9LY29uZmlnCmluZGV4IDJiYWI0NDlhZGQ3Ni4uMDYxMjFl ZWJhOWU1IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vcmNhci1kdS9LY29uZmlnCisrKyBi L2RyaXZlcnMvZ3B1L2RybS9yY2FyLWR1L0tjb25maWcKQEAgLTExLDEyICsxMSw2IEBAIGNvbmZp ZyBEUk1fUkNBUl9EVQogCSAgQ2hvb3NlIHRoaXMgb3B0aW9uIGlmIHlvdSBoYXZlIGFuIFItQ2Fy IGNoaXBzZXQuCiAJICBJZiBNIGlzIHNlbGVjdGVkIHRoZSBtb2R1bGUgd2lsbCBiZSBjYWxsZWQg cmNhci1kdS1kcm0uCiAKLWNvbmZpZyBEUk1fUkNBUl9IRE1JCi0JYm9vbCAiUi1DYXIgRFUgSERN SSBFbmNvZGVyIFN1cHBvcnQiCi0JZGVwZW5kcyBvbiBEUk1fUkNBUl9EVQotCWhlbHAKLQkgIEVu YWJsZSBzdXBwb3J0IGZvciBleHRlcm5hbCBIRE1JIGVuY29kZXJzLgotCiBjb25maWcgRFJNX1JD QVJfTFZEUwogCWJvb2wgIlItQ2FyIERVIExWRFMgRW5jb2RlciBTdXBwb3J0IgogCWRlcGVuZHMg b24gRFJNX1JDQVJfRFUKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9yY2FyLWR1L01ha2Vm aWxlIGIvZHJpdmVycy9ncHUvZHJtL3JjYXItZHUvTWFrZWZpbGUKaW5kZXggZDNiNDQ2NTEwNjFh Li5hNDkyZTY4NTg2OTEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9yY2FyLWR1L01ha2Vm aWxlCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9yY2FyLWR1L01ha2VmaWxlCkBAIC00LDEwICs0LDcg QEAgcmNhci1kdS1kcm0teSA6PSByY2FyX2R1X2NydGMubyBcCiAJCSByY2FyX2R1X2dyb3VwLm8g XAogCQkgcmNhcl9kdV9rbXMubyBcCiAJCSByY2FyX2R1X2x2ZHNjb24ubyBcCi0JCSByY2FyX2R1 X3BsYW5lLm8gXAotCQkgcmNhcl9kdV92Z2Fjb24ubwotCi1yY2FyLWR1LWRybS0kKENPTkZJR19E Uk1fUkNBUl9IRE1JKQkrPSByY2FyX2R1X2hkbWllbmMubworCQkgcmNhcl9kdV9wbGFuZS5vCiAK IHJjYXItZHUtZHJtLSQoQ09ORklHX0RSTV9SQ0FSX0xWRFMpCSs9IHJjYXJfZHVfbHZkc2VuYy5v CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9yY2FyLWR1L3JjYXJfZHVfZW5jb2Rlci5j IGIvZHJpdmVycy9ncHUvZHJtL3JjYXItZHUvcmNhcl9kdV9lbmNvZGVyLmMKaW5kZXggM2EzYzkz NzQ3OTRlLi45MmEwNDA1YzJmYjIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9yY2FyLWR1 L3JjYXJfZHVfZW5jb2Rlci5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9yY2FyLWR1L3JjYXJfZHVf ZW5jb2Rlci5jCkBAIC0yMCwxMSArMjAsOSBAQAogCiAjaW5jbHVkZSAicmNhcl9kdV9kcnYuaCIK ICNpbmNsdWRlICJyY2FyX2R1X2VuY29kZXIuaCIKLSNpbmNsdWRlICJyY2FyX2R1X2hkbWllbmMu aCIKICNpbmNsdWRlICJyY2FyX2R1X2ttcy5oIgogI2luY2x1ZGUgInJjYXJfZHVfbHZkc2Nvbi5o IgogI2luY2x1ZGUgInJjYXJfZHVfbHZkc2VuYy5oIgotI2luY2x1ZGUgInJjYXJfZHVfdmdhY29u LmgiCiAKIC8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAgKiBFbmNvZGVyCkBAIC02MywyOSArNjEs MzUgQEAgc3RhdGljIGludCByY2FyX2R1X2VuY29kZXJfYXRvbWljX2NoZWNrKHN0cnVjdCBkcm1f ZW5jb2RlciAqZW5jb2RlciwKIAlzdHJ1Y3QgcmNhcl9kdV9lbmNvZGVyICpyZW5jID0gdG9fcmNh cl9lbmNvZGVyKGVuY29kZXIpOwogCXN0cnVjdCBkcm1fZGlzcGxheV9tb2RlICphZGp1c3RlZF9t b2RlID0gJmNydGNfc3RhdGUtPmFkanVzdGVkX21vZGU7CiAJY29uc3Qgc3RydWN0IGRybV9kaXNw bGF5X21vZGUgKm1vZGUgPSAmY3J0Y19zdGF0ZS0+bW9kZTsKLQljb25zdCBzdHJ1Y3QgZHJtX2Rp c3BsYXlfbW9kZSAqcGFuZWxfbW9kZTsKIAlzdHJ1Y3QgZHJtX2Nvbm5lY3RvciAqY29ubmVjdG9y ID0gY29ubl9zdGF0ZS0+Y29ubmVjdG9yOwogCXN0cnVjdCBkcm1fZGV2aWNlICpkZXYgPSBlbmNv ZGVyLT5kZXY7CiAKLQkvKiBEQUMgZW5jb2RlcnMgaGF2ZSBjdXJyZW50bHkgbm8gcmVzdHJpY3Rp b24gb24gdGhlIG1vZGUuICovCi0JaWYgKGVuY29kZXItPmVuY29kZXJfdHlwZSA9PSBEUk1fTU9E RV9FTkNPREVSX0RBQykKLQkJcmV0dXJuIDA7CisJLyoKKwkgKiBPbmx5IHBhbmVsLXJlbGF0ZWQg ZW5jb2RlciB0eXBlcyByZXF1aXJlIHZhbGlkYXRpb24gaGVyZSwgZXZlcnl0aGluZworCSAqIGVs c2UgaXMgaGFuZGxlZCBieSB0aGUgYnJpZGdlIGRyaXZlcnMuCisJICovCisJaWYgKGVuY29kZXIt PmVuY29kZXJfdHlwZSA9PSBEUk1fTU9ERV9FTkNPREVSX0xWRFMpIHsKKwkJY29uc3Qgc3RydWN0 IGRybV9kaXNwbGF5X21vZGUgKnBhbmVsX21vZGU7CiAKLQlpZiAobGlzdF9lbXB0eSgmY29ubmVj dG9yLT5tb2RlcykpIHsKLQkJZGV2X2RiZyhkZXYtPmRldiwgImVuY29kZXI6IGVtcHR5IG1vZGVz IGxpc3RcbiIpOwotCQlyZXR1cm4gLUVJTlZBTDsKLQl9CisJCWlmIChsaXN0X2VtcHR5KCZjb25u ZWN0b3ItPm1vZGVzKSkgeworCQkJZGV2X2RiZyhkZXYtPmRldiwgImVuY29kZXI6IGVtcHR5IG1v ZGVzIGxpc3RcbiIpOworCQkJcmV0dXJuIC1FSU5WQUw7CisJCX0KIAotCXBhbmVsX21vZGUgPSBs aXN0X2ZpcnN0X2VudHJ5KCZjb25uZWN0b3ItPm1vZGVzLAotCQkJCSAgICAgIHN0cnVjdCBkcm1f ZGlzcGxheV9tb2RlLCBoZWFkKTsKKwkJcGFuZWxfbW9kZSA9IGxpc3RfZmlyc3RfZW50cnkoJmNv bm5lY3Rvci0+bW9kZXMsCisJCQkJCSAgICAgIHN0cnVjdCBkcm1fZGlzcGxheV9tb2RlLCBoZWFk KTsKIAotCS8qIFdlJ3JlIG5vdCBhbGxvd2VkIHRvIG1vZGlmeSB0aGUgcmVzb2x1dGlvbi4gKi8K LQlpZiAobW9kZS0+aGRpc3BsYXkgIT0gcGFuZWxfbW9kZS0+aGRpc3BsYXkgfHwKLQkgICAgbW9k ZS0+dmRpc3BsYXkgIT0gcGFuZWxfbW9kZS0+dmRpc3BsYXkpCi0JCXJldHVybiAtRUlOVkFMOwor CQkvKiBXZSdyZSBub3QgYWxsb3dlZCB0byBtb2RpZnkgdGhlIHJlc29sdXRpb24uICovCisJCWlm IChtb2RlLT5oZGlzcGxheSAhPSBwYW5lbF9tb2RlLT5oZGlzcGxheSB8fAorCQkgICAgbW9kZS0+ dmRpc3BsYXkgIT0gcGFuZWxfbW9kZS0+dmRpc3BsYXkpCisJCQlyZXR1cm4gLUVJTlZBTDsKIAot CS8qIFRoZSBmbGF0IHBhbmVsIG1vZGUgaXMgZml4ZWQsIGp1c3QgY29weSBpdCB0byB0aGUgYWRq dXN0ZWQgbW9kZS4gKi8KLQlkcm1fbW9kZV9jb3B5KGFkanVzdGVkX21vZGUsIHBhbmVsX21vZGUp OworCQkvKgorCQkgKiBUaGUgZmxhdCBwYW5lbCBtb2RlIGlzIGZpeGVkLCBqdXN0IGNvcHkgaXQg dG8gdGhlIGFkanVzdGVkCisJCSAqIG1vZGUuCisJCSAqLworCQlkcm1fbW9kZV9jb3B5KGFkanVz dGVkX21vZGUsIHBhbmVsX21vZGUpOworCX0KIAogCWlmIChyZW5jLT5sdmRzKQogCQlyY2FyX2R1 X2x2ZHNlbmNfYXRvbWljX2NoZWNrKHJlbmMtPmx2ZHMsIGFkanVzdGVkX21vZGUpOwpAQCAtMTU5 LDYgKzE2Myw3IEBAIGludCByY2FyX2R1X2VuY29kZXJfaW5pdChzdHJ1Y3QgcmNhcl9kdV9kZXZp Y2UgKnJjZHUsCiB7CiAJc3RydWN0IHJjYXJfZHVfZW5jb2RlciAqcmVuYzsKIAlzdHJ1Y3QgZHJt X2VuY29kZXIgKmVuY29kZXI7CisJc3RydWN0IGRybV9icmlkZ2UgKmJyaWRnZSA9IE5VTEw7CiAJ dW5zaWduZWQgaW50IGVuY29kZXJfdHlwZTsKIAlpbnQgcmV0OwogCkBAIC0xODIsNiArMTg3LDE1 IEBAIGludCByY2FyX2R1X2VuY29kZXJfaW5pdChzdHJ1Y3QgcmNhcl9kdV9kZXZpY2UgKnJjZHUs CiAJCWJyZWFrOwogCX0KIAorCWlmIChlbmNfbm9kZSkgeworCQkvKiBMb2NhdGUgdGhlIERSTSBi cmlkZ2UgZnJvbSB0aGUgZW5jb2RlciBEVCBub2RlLiAqLworCQlicmlkZ2UgPSBvZl9kcm1fZmlu ZF9icmlkZ2UoZW5jX25vZGUpOworCQlpZiAoIWJyaWRnZSkgeworCQkJcmV0ID0gLUVQUk9CRV9E RUZFUjsKKwkJCWdvdG8gZG9uZTsKKwkJfQorCX0KKwogCXN3aXRjaCAodHlwZSkgewogCWNhc2Ug UkNBUl9EVV9FTkNPREVSX1ZHQToKIAkJZW5jb2Rlcl90eXBlID0gRFJNX01PREVfRU5DT0RFUl9E QUM7CkBAIC0xOTksMzUgKzIxMywzNSBAQCBpbnQgcmNhcl9kdV9lbmNvZGVyX2luaXQoc3RydWN0 IHJjYXJfZHVfZGV2aWNlICpyY2R1LAogCQlicmVhazsKIAl9CiAKLQlpZiAodHlwZSA9PSBSQ0FS X0RVX0VOQ09ERVJfSERNSSkgewotCQlyZXQgPSByY2FyX2R1X2hkbWllbmNfaW5pdChyY2R1LCBy ZW5jLCBlbmNfbm9kZSk7Ci0JCWlmIChyZXQgPCAwKQotCQkJZ290byBkb25lOwotCX0gZWxzZSB7 Ci0JCXJldCA9IGRybV9lbmNvZGVyX2luaXQocmNkdS0+ZGRldiwgZW5jb2RlciwgJmVuY29kZXJf ZnVuY3MsCi0JCQkJICAgICAgIGVuY29kZXJfdHlwZSwgTlVMTCk7Ci0JCWlmIChyZXQgPCAwKQot CQkJZ290byBkb25lOwotCi0JCWRybV9lbmNvZGVyX2hlbHBlcl9hZGQoZW5jb2RlciwgJmVuY29k ZXJfaGVscGVyX2Z1bmNzKTsKLQl9Ci0KLQlzd2l0Y2ggKGVuY29kZXJfdHlwZSkgewotCWNhc2Ug RFJNX01PREVfRU5DT0RFUl9MVkRTOgotCQlyZXQgPSByY2FyX2R1X2x2ZHNfY29ubmVjdG9yX2lu aXQocmNkdSwgcmVuYywgY29uX25vZGUpOwotCQlicmVhazsKLQotCWNhc2UgRFJNX01PREVfRU5D T0RFUl9EQUM6Ci0JCXJldCA9IHJjYXJfZHVfdmdhX2Nvbm5lY3Rvcl9pbml0KHJjZHUsIHJlbmMp OwotCQlicmVhazsKKwlyZXQgPSBkcm1fZW5jb2Rlcl9pbml0KHJjZHUtPmRkZXYsIGVuY29kZXIs ICZlbmNvZGVyX2Z1bmNzLAorCQkJICAgICAgIGVuY29kZXJfdHlwZSwgTlVMTCk7CisJaWYgKHJl dCA8IDApCisJCWdvdG8gZG9uZTsKIAotCWNhc2UgRFJNX01PREVfRU5DT0RFUl9UTURTOgotCQkv KiBjb25uZWN0b3IgbWFuYWdlZCBieSB0aGUgYnJpZGdlIGRyaXZlciAqLwotCQlicmVhazsKKwlk cm1fZW5jb2Rlcl9oZWxwZXJfYWRkKGVuY29kZXIsICZlbmNvZGVyX2hlbHBlcl9mdW5jcyk7CiAK LQlkZWZhdWx0OgotCQlyZXQgPSAtRUlOVkFMOwotCQlicmVhazsKKwlpZiAoYnJpZGdlKSB7CisJ CS8qCisJCSAqIEF0dGFjaCB0aGUgYnJpZGdlIHRvIHRoZSBlbmNvZGVyLiBUaGUgYnJpZGdlIHdp bGwgY3JlYXRlIHRoZQorCQkgKiBjb25uZWN0b3IuCisJCSAqLworCQlyZXQgPSBkcm1fYnJpZGdl X2F0dGFjaChlbmNvZGVyLCBicmlkZ2UsIE5VTEwpOworCQlpZiAocmV0KSB7CisJCQlkcm1fZW5j b2Rlcl9jbGVhbnVwKGVuY29kZXIpOworCQkJcmV0dXJuIHJldDsKKwkJfQorCX0gZWxzZSB7CisJ CS8qIFRoZXJlJ3Mgbm8gYnJpZGdlLCBjcmVhdGUgdGhlIGNvbm5lY3RvciBtYW51YWxseS4gKi8K KwkJc3dpdGNoIChvdXRwdXQpIHsKKwkJY2FzZSBSQ0FSX0RVX09VVFBVVF9MVkRTMDoKKwkJY2Fz ZSBSQ0FSX0RVX09VVFBVVF9MVkRTMToKKwkJCXJldCA9IHJjYXJfZHVfbHZkc19jb25uZWN0b3Jf aW5pdChyY2R1LCByZW5jLCBjb25fbm9kZSk7CisJCQlicmVhazsKKworCQlkZWZhdWx0OgorCQkJ cmV0ID0gLUVJTlZBTDsKKwkJCWJyZWFrOworCQl9CiAJfQogCiBkb25lOgpkaWZmIC0tZ2l0IGEv ZHJpdmVycy9ncHUvZHJtL3JjYXItZHUvcmNhcl9kdV9lbmNvZGVyLmggYi9kcml2ZXJzL2dwdS9k cm0vcmNhci1kdS9yY2FyX2R1X2VuY29kZXIuaAppbmRleCBiNzliMmYwNzVhNzQuLmMxY2ZiZTBk NTRjZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3JjYXItZHUvcmNhcl9kdV9lbmNvZGVy LmgKKysrIGIvZHJpdmVycy9ncHUvZHJtL3JjYXItZHUvcmNhcl9kdV9lbmNvZGVyLmgKQEAgLTE5 LDcgKzE5LDYgQEAKIAogc3RydWN0IGRybV9wYW5lbDsKIHN0cnVjdCByY2FyX2R1X2RldmljZTsK LXN0cnVjdCByY2FyX2R1X2hkbWllbmM7CiBzdHJ1Y3QgcmNhcl9kdV9sdmRzZW5jOwogCiBlbnVt IHJjYXJfZHVfZW5jb2Rlcl90eXBlIHsKQEAgLTM0LDcgKzMzLDYgQEAgc3RydWN0IHJjYXJfZHVf ZW5jb2RlciB7CiAJc3RydWN0IGRybV9lbmNvZGVyIGJhc2U7CiAJZW51bSByY2FyX2R1X291dHB1 dCBvdXRwdXQ7CiAJc3RydWN0IHJjYXJfZHVfY29ubmVjdG9yICpjb25uZWN0b3I7Ci0Jc3RydWN0 IHJjYXJfZHVfaGRtaWVuYyAqaGRtaTsKIAlzdHJ1Y3QgcmNhcl9kdV9sdmRzZW5jICpsdmRzOwog fTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3JjYXItZHUvcmNhcl9kdV9oZG1pZW5j LmMgYi9kcml2ZXJzL2dwdS9kcm0vcmNhci1kdS9yY2FyX2R1X2hkbWllbmMuYwpkZWxldGVkIGZp bGUgbW9kZSAxMDA2NDQKaW5kZXggOTMzYTI1NDc3OThlLi4wMDAwMDAwMDAwMDAKLS0tIGEvZHJp dmVycy9ncHUvZHJtL3JjYXItZHUvcmNhcl9kdV9oZG1pZW5jLmMKKysrIC9kZXYvbnVsbApAQCAt MSwxMzQgKzAsMCBAQAotLyoKLSAqIFItQ2FyIERpc3BsYXkgVW5pdCBIRE1JIEVuY29kZXIKLSAq Ci0gKiBDb3B5cmlnaHQgKEMpIDIwMTQgUmVuZXNhcyBFbGVjdHJvbmljcyBDb3Jwb3JhdGlvbgot ICoKLSAqIENvbnRhY3Q6IExhdXJlbnQgUGluY2hhcnQgKGxhdXJlbnQucGluY2hhcnRAaWRlYXNv bmJvYXJkLmNvbSkKLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNh biByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9m IHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBG cmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2Us IG9yCi0gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgotICovCi0KLSNpbmNs dWRlIDxsaW51eC9zbGFiLmg+Ci0KLSNpbmNsdWRlIDxkcm0vZHJtUC5oPgotI2luY2x1ZGUgPGRy bS9kcm1fY3J0Yy5oPgotI2luY2x1ZGUgPGRybS9kcm1fY3J0Y19oZWxwZXIuaD4KLQotI2luY2x1 ZGUgInJjYXJfZHVfZHJ2LmgiCi0jaW5jbHVkZSAicmNhcl9kdV9lbmNvZGVyLmgiCi0jaW5jbHVk ZSAicmNhcl9kdV9oZG1pZW5jLmgiCi0jaW5jbHVkZSAicmNhcl9kdV9sdmRzZW5jLmgiCi0KLXN0 cnVjdCByY2FyX2R1X2hkbWllbmMgewotCXN0cnVjdCByY2FyX2R1X2VuY29kZXIgKnJlbmM7Ci0J Ym9vbCBlbmFibGVkOwotfTsKLQotI2RlZmluZSB0b19yY2FyX2hkbWllbmMoZSkJKHRvX3JjYXJf ZW5jb2RlcihlKS0+aGRtaSkKLQotc3RhdGljIHZvaWQgcmNhcl9kdV9oZG1pZW5jX2Rpc2FibGUo c3RydWN0IGRybV9lbmNvZGVyICplbmNvZGVyKQotewotCXN0cnVjdCByY2FyX2R1X2hkbWllbmMg KmhkbWllbmMgPSB0b19yY2FyX2hkbWllbmMoZW5jb2Rlcik7Ci0KLQlpZiAoaGRtaWVuYy0+cmVu Yy0+bHZkcykKLQkJcmNhcl9kdV9sdmRzZW5jX2VuYWJsZShoZG1pZW5jLT5yZW5jLT5sdmRzLCBl bmNvZGVyLT5jcnRjLAotCQkJCSAgICAgICBmYWxzZSk7Ci0KLQloZG1pZW5jLT5lbmFibGVkID0g ZmFsc2U7Ci19Ci0KLXN0YXRpYyB2b2lkIHJjYXJfZHVfaGRtaWVuY19lbmFibGUoc3RydWN0IGRy bV9lbmNvZGVyICplbmNvZGVyKQotewotCXN0cnVjdCByY2FyX2R1X2hkbWllbmMgKmhkbWllbmMg PSB0b19yY2FyX2hkbWllbmMoZW5jb2Rlcik7Ci0KLQlpZiAoaGRtaWVuYy0+cmVuYy0+bHZkcykK LQkJcmNhcl9kdV9sdmRzZW5jX2VuYWJsZShoZG1pZW5jLT5yZW5jLT5sdmRzLCBlbmNvZGVyLT5j cnRjLAotCQkJCSAgICAgICB0cnVlKTsKLQotCWhkbWllbmMtPmVuYWJsZWQgPSB0cnVlOwotfQot Ci1zdGF0aWMgaW50IHJjYXJfZHVfaGRtaWVuY19hdG9taWNfY2hlY2soc3RydWN0IGRybV9lbmNv ZGVyICplbmNvZGVyLAotCQkJCQlzdHJ1Y3QgZHJtX2NydGNfc3RhdGUgKmNydGNfc3RhdGUsCi0J CQkJCXN0cnVjdCBkcm1fY29ubmVjdG9yX3N0YXRlICpjb25uX3N0YXRlKQotewotCXN0cnVjdCBy Y2FyX2R1X2hkbWllbmMgKmhkbWllbmMgPSB0b19yY2FyX2hkbWllbmMoZW5jb2Rlcik7Ci0Jc3Ry dWN0IGRybV9kaXNwbGF5X21vZGUgKmFkanVzdGVkX21vZGUgPSAmY3J0Y19zdGF0ZS0+YWRqdXN0 ZWRfbW9kZTsKLQotCWlmIChoZG1pZW5jLT5yZW5jLT5sdmRzKQotCQlyY2FyX2R1X2x2ZHNlbmNf YXRvbWljX2NoZWNrKGhkbWllbmMtPnJlbmMtPmx2ZHMsCi0JCQkJCSAgICAgYWRqdXN0ZWRfbW9k ZSk7Ci0KLQlyZXR1cm4gMDsKLX0KLQotCi1zdGF0aWMgdm9pZCByY2FyX2R1X2hkbWllbmNfbW9k ZV9zZXQoc3RydWN0IGRybV9lbmNvZGVyICplbmNvZGVyLAotCQkJCSAgICAgc3RydWN0IGRybV9j cnRjX3N0YXRlICpjcnRjX3N0YXRlLAotCQkJCSAgICAgc3RydWN0IGRybV9jb25uZWN0b3Jfc3Rh dGUgKmNvbm5fc3RhdGUpCi17Ci0Jc3RydWN0IHJjYXJfZHVfaGRtaWVuYyAqaGRtaWVuYyA9IHRv X3JjYXJfaGRtaWVuYyhlbmNvZGVyKTsKLQotCXJjYXJfZHVfY3J0Y19yb3V0ZV9vdXRwdXQoY3J0 Y19zdGF0ZS0+Y3J0YywgaGRtaWVuYy0+cmVuYy0+b3V0cHV0KTsKLX0KLQotc3RhdGljIGNvbnN0 IHN0cnVjdCBkcm1fZW5jb2Rlcl9oZWxwZXJfZnVuY3MgZW5jb2Rlcl9oZWxwZXJfZnVuY3MgPSB7 Ci0JLmF0b21pY19tb2RlX3NldCA9IHJjYXJfZHVfaGRtaWVuY19tb2RlX3NldCwKLQkuZGlzYWJs ZSA9IHJjYXJfZHVfaGRtaWVuY19kaXNhYmxlLAotCS5lbmFibGUgPSByY2FyX2R1X2hkbWllbmNf ZW5hYmxlLAotCS5hdG9taWNfY2hlY2sgPSByY2FyX2R1X2hkbWllbmNfYXRvbWljX2NoZWNrLAot fTsKLQotc3RhdGljIHZvaWQgcmNhcl9kdV9oZG1pZW5jX2NsZWFudXAoc3RydWN0IGRybV9lbmNv ZGVyICplbmNvZGVyKQotewotCXN0cnVjdCByY2FyX2R1X2hkbWllbmMgKmhkbWllbmMgPSB0b19y Y2FyX2hkbWllbmMoZW5jb2Rlcik7Ci0KLQlpZiAoaGRtaWVuYy0+ZW5hYmxlZCkKLQkJcmNhcl9k dV9oZG1pZW5jX2Rpc2FibGUoZW5jb2Rlcik7Ci0KLQlkcm1fZW5jb2Rlcl9jbGVhbnVwKGVuY29k ZXIpOwotfQotCi1zdGF0aWMgY29uc3Qgc3RydWN0IGRybV9lbmNvZGVyX2Z1bmNzIGVuY29kZXJf ZnVuY3MgPSB7Ci0JLmRlc3Ryb3kgPSByY2FyX2R1X2hkbWllbmNfY2xlYW51cCwKLX07Ci0KLWlu dCByY2FyX2R1X2hkbWllbmNfaW5pdChzdHJ1Y3QgcmNhcl9kdV9kZXZpY2UgKnJjZHUsCi0JCQkg c3RydWN0IHJjYXJfZHVfZW5jb2RlciAqcmVuYywgc3RydWN0IGRldmljZV9ub2RlICpucCkKLXsK LQlzdHJ1Y3QgZHJtX2VuY29kZXIgKmVuY29kZXIgPSByY2FyX2VuY29kZXJfdG9fZHJtX2VuY29k ZXIocmVuYyk7Ci0Jc3RydWN0IGRybV9icmlkZ2UgKmJyaWRnZTsKLQlzdHJ1Y3QgcmNhcl9kdV9o ZG1pZW5jICpoZG1pZW5jOwotCWludCByZXQ7Ci0KLQloZG1pZW5jID0gZGV2bV9remFsbG9jKHJj ZHUtPmRldiwgc2l6ZW9mKCpoZG1pZW5jKSwgR0ZQX0tFUk5FTCk7Ci0JaWYgKGhkbWllbmMgPT0g TlVMTCkKLQkJcmV0dXJuIC1FTk9NRU07Ci0KLQkvKiBMb2NhdGUgdGhlIERSTSBicmlkZ2UgZnJv bSB0aGUgSERNSSBlbmNvZGVyIERUIG5vZGUuICovCi0JYnJpZGdlID0gb2ZfZHJtX2ZpbmRfYnJp ZGdlKG5wKTsKLQlpZiAoIWJyaWRnZSkKLQkJcmV0dXJuIC1FUFJPQkVfREVGRVI7Ci0KLQlyZXQg PSBkcm1fZW5jb2Rlcl9pbml0KHJjZHUtPmRkZXYsIGVuY29kZXIsICZlbmNvZGVyX2Z1bmNzLAot CQkJICAgICAgIERSTV9NT0RFX0VOQ09ERVJfVE1EUywgTlVMTCk7Ci0JaWYgKHJldCA8IDApCi0J CXJldHVybiByZXQ7Ci0KLQlkcm1fZW5jb2Rlcl9oZWxwZXJfYWRkKGVuY29kZXIsICZlbmNvZGVy X2hlbHBlcl9mdW5jcyk7Ci0KLQlyZW5jLT5oZG1pID0gaGRtaWVuYzsKLQloZG1pZW5jLT5yZW5j ID0gcmVuYzsKLQotCS8qIExpbmsgdGhlIGJyaWRnZSB0byB0aGUgZW5jb2Rlci4gKi8KLQlyZXQg PSBkcm1fYnJpZGdlX2F0dGFjaChlbmNvZGVyLCBicmlkZ2UsIE5VTEwpOwotCWlmIChyZXQpIHsK LQkJZHJtX2VuY29kZXJfY2xlYW51cChlbmNvZGVyKTsKLQkJcmV0dXJuIHJldDsKLQl9Ci0KLQly ZXR1cm4gMDsKLX0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9yY2FyLWR1L3JjYXJfZHVf aGRtaWVuYy5oIGIvZHJpdmVycy9ncHUvZHJtL3JjYXItZHUvcmNhcl9kdV9oZG1pZW5jLmgKZGVs ZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDJmZjAxMjhhYzhlMS4uMDAwMDAwMDAwMDAwCi0t LSBhL2RyaXZlcnMvZ3B1L2RybS9yY2FyLWR1L3JjYXJfZHVfaGRtaWVuYy5oCisrKyAvZGV2L251 bGwKQEAgLTEsMzUgKzAsMCBAQAotLyoKLSAqIFItQ2FyIERpc3BsYXkgVW5pdCBIRE1JIEVuY29k ZXIKLSAqCi0gKiBDb3B5cmlnaHQgKEMpIDIwMTQgUmVuZXNhcyBFbGVjdHJvbmljcyBDb3Jwb3Jh dGlvbgotICoKLSAqIENvbnRhY3Q6IExhdXJlbnQgUGluY2hhcnQgKGxhdXJlbnQucGluY2hhcnRA aWRlYXNvbmJvYXJkLmNvbSkKLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsg eW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRl cm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAq IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExp Y2Vuc2UsIG9yCi0gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgotICovCi0K LSNpZm5kZWYgX19SQ0FSX0RVX0hETUlFTkNfSF9fCi0jZGVmaW5lIF9fUkNBUl9EVV9IRE1JRU5D X0hfXwotCi0jaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+Ci0KLXN0cnVjdCBkZXZpY2Vfbm9kZTsK LXN0cnVjdCByY2FyX2R1X2RldmljZTsKLXN0cnVjdCByY2FyX2R1X2VuY29kZXI7Ci0KLSNpZiBJ U19FTkFCTEVEKENPTkZJR19EUk1fUkNBUl9IRE1JKQotaW50IHJjYXJfZHVfaGRtaWVuY19pbml0 KHN0cnVjdCByY2FyX2R1X2RldmljZSAqcmNkdSwKLQkJCSBzdHJ1Y3QgcmNhcl9kdV9lbmNvZGVy ICpyZW5jLCBzdHJ1Y3QgZGV2aWNlX25vZGUgKm5wKTsKLSNlbHNlCi1zdGF0aWMgaW5saW5lIGlu dCByY2FyX2R1X2hkbWllbmNfaW5pdChzdHJ1Y3QgcmNhcl9kdV9kZXZpY2UgKnJjZHUsCi0JCQkJ ICAgICAgIHN0cnVjdCByY2FyX2R1X2VuY29kZXIgKnJlbmMsCi0JCQkJICAgICAgIHN0cnVjdCBk ZXZpY2Vfbm9kZSAqbnApCi17Ci0JcmV0dXJuIC1FTk9TWVM7Ci19Ci0jZW5kaWYKLQotI2VuZGlm IC8qIF9fUkNBUl9EVV9IRE1JRU5DX0hfXyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJt L3JjYXItZHUvcmNhcl9kdV92Z2Fjb24uYyBiL2RyaXZlcnMvZ3B1L2RybS9yY2FyLWR1L3JjYXJf ZHVfdmdhY29uLmMKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDhkNjEyNWMxYzBmOS4u MDAwMDAwMDAwMDAwCi0tLSBhL2RyaXZlcnMvZ3B1L2RybS9yY2FyLWR1L3JjYXJfZHVfdmdhY29u LmMKKysrIC9kZXYvbnVsbApAQCAtMSw4MiArMCwwIEBACi0vKgotICogcmNhcl9kdV92Z2Fjb24u YyAgLS0gIFItQ2FyIERpc3BsYXkgVW5pdCBWR0EgQ29ubmVjdG9yCi0gKgotICogQ29weXJpZ2h0 IChDKSAyMDEzLTIwMTQgUmVuZXNhcyBFbGVjdHJvbmljcyBDb3Jwb3JhdGlvbgotICoKLSAqIENv bnRhY3Q6IExhdXJlbnQgUGluY2hhcnQgKGxhdXJlbnQucGluY2hhcnRAaWRlYXNvbmJvYXJkLmNv bSkKLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3Ry aWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUg R2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3 YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCi0gKiAo YXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgotICovCi0KLSNpbmNsdWRlIDxkcm0v ZHJtUC5oPgotI2luY2x1ZGUgPGRybS9kcm1fYXRvbWljX2hlbHBlci5oPgotI2luY2x1ZGUgPGRy bS9kcm1fY3J0Yy5oPgotI2luY2x1ZGUgPGRybS9kcm1fY3J0Y19oZWxwZXIuaD4KLQotI2luY2x1 ZGUgInJjYXJfZHVfZHJ2LmgiCi0jaW5jbHVkZSAicmNhcl9kdV9lbmNvZGVyLmgiCi0jaW5jbHVk ZSAicmNhcl9kdV9rbXMuaCIKLSNpbmNsdWRlICJyY2FyX2R1X3ZnYWNvbi5oIgotCi1zdGF0aWMg aW50IHJjYXJfZHVfdmdhX2Nvbm5lY3Rvcl9nZXRfbW9kZXMoc3RydWN0IGRybV9jb25uZWN0b3Ig KmNvbm5lY3RvcikKLXsKLQlyZXR1cm4gMDsKLX0KLQotc3RhdGljIGNvbnN0IHN0cnVjdCBkcm1f Y29ubmVjdG9yX2hlbHBlcl9mdW5jcyBjb25uZWN0b3JfaGVscGVyX2Z1bmNzID0gewotCS5nZXRf bW9kZXMgPSByY2FyX2R1X3ZnYV9jb25uZWN0b3JfZ2V0X21vZGVzLAotfTsKLQotc3RhdGljIGVu dW0gZHJtX2Nvbm5lY3Rvcl9zdGF0dXMKLXJjYXJfZHVfdmdhX2Nvbm5lY3Rvcl9kZXRlY3Qoc3Ry dWN0IGRybV9jb25uZWN0b3IgKmNvbm5lY3RvciwgYm9vbCBmb3JjZSkKLXsKLQlyZXR1cm4gY29u bmVjdG9yX3N0YXR1c19jb25uZWN0ZWQ7Ci19Ci0KLXN0YXRpYyBjb25zdCBzdHJ1Y3QgZHJtX2Nv bm5lY3Rvcl9mdW5jcyBjb25uZWN0b3JfZnVuY3MgPSB7Ci0JLmRwbXMgPSBkcm1fYXRvbWljX2hl bHBlcl9jb25uZWN0b3JfZHBtcywKLQkucmVzZXQgPSBkcm1fYXRvbWljX2hlbHBlcl9jb25uZWN0 b3JfcmVzZXQsCi0JLmRldGVjdCA9IHJjYXJfZHVfdmdhX2Nvbm5lY3Rvcl9kZXRlY3QsCi0JLmZp bGxfbW9kZXMgPSBkcm1faGVscGVyX3Byb2JlX3NpbmdsZV9jb25uZWN0b3JfbW9kZXMsCi0JLmRl c3Ryb3kgPSBkcm1fY29ubmVjdG9yX2NsZWFudXAsCi0JLmF0b21pY19kdXBsaWNhdGVfc3RhdGUg PSBkcm1fYXRvbWljX2hlbHBlcl9jb25uZWN0b3JfZHVwbGljYXRlX3N0YXRlLAotCS5hdG9taWNf ZGVzdHJveV9zdGF0ZSA9IGRybV9hdG9taWNfaGVscGVyX2Nvbm5lY3Rvcl9kZXN0cm95X3N0YXRl LAotfTsKLQotaW50IHJjYXJfZHVfdmdhX2Nvbm5lY3Rvcl9pbml0KHN0cnVjdCByY2FyX2R1X2Rl dmljZSAqcmNkdSwKLQkJCSAgICAgICBzdHJ1Y3QgcmNhcl9kdV9lbmNvZGVyICpyZW5jKQotewot CXN0cnVjdCBkcm1fZW5jb2RlciAqZW5jb2RlciA9IHJjYXJfZW5jb2Rlcl90b19kcm1fZW5jb2Rl cihyZW5jKTsKLQlzdHJ1Y3QgcmNhcl9kdV9jb25uZWN0b3IgKnJjb247Ci0Jc3RydWN0IGRybV9j b25uZWN0b3IgKmNvbm5lY3RvcjsKLQlpbnQgcmV0OwotCi0JcmNvbiA9IGRldm1fa3phbGxvYyhy Y2R1LT5kZXYsIHNpemVvZigqcmNvbiksIEdGUF9LRVJORUwpOwotCWlmIChyY29uID09IE5VTEwp Ci0JCXJldHVybiAtRU5PTUVNOwotCi0JY29ubmVjdG9yID0gJnJjb24tPmNvbm5lY3RvcjsKLQlj b25uZWN0b3ItPmRpc3BsYXlfaW5mby53aWR0aF9tbSA9IDA7Ci0JY29ubmVjdG9yLT5kaXNwbGF5 X2luZm8uaGVpZ2h0X21tID0gMDsKLQljb25uZWN0b3ItPmludGVybGFjZV9hbGxvd2VkID0gdHJ1 ZTsKLQotCXJldCA9IGRybV9jb25uZWN0b3JfaW5pdChyY2R1LT5kZGV2LCBjb25uZWN0b3IsICZj b25uZWN0b3JfZnVuY3MsCi0JCQkJIERSTV9NT0RFX0NPTk5FQ1RPUl9WR0EpOwotCWlmIChyZXQg PCAwKQotCQlyZXR1cm4gcmV0OwotCi0JZHJtX2Nvbm5lY3Rvcl9oZWxwZXJfYWRkKGNvbm5lY3Rv ciwgJmNvbm5lY3Rvcl9oZWxwZXJfZnVuY3MpOwotCi0JY29ubmVjdG9yLT5kcG1zID0gRFJNX01P REVfRFBNU19PRkY7Ci0JZHJtX29iamVjdF9wcm9wZXJ0eV9zZXRfdmFsdWUoJmNvbm5lY3Rvci0+ YmFzZSwKLQkJcmNkdS0+ZGRldi0+bW9kZV9jb25maWcuZHBtc19wcm9wZXJ0eSwgRFJNX01PREVf RFBNU19PRkYpOwotCi0JcmV0ID0gZHJtX21vZGVfY29ubmVjdG9yX2F0dGFjaF9lbmNvZGVyKGNv bm5lY3RvciwgZW5jb2Rlcik7Ci0JaWYgKHJldCA8IDApCi0JCXJldHVybiByZXQ7Ci0KLQlyZXR1 cm4gMDsKLX0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9yY2FyLWR1L3JjYXJfZHVfdmdh Y29uLmggYi9kcml2ZXJzL2dwdS9kcm0vcmNhci1kdS9yY2FyX2R1X3ZnYWNvbi5oCmRlbGV0ZWQg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAxMTJmNTAzMTZlMDEuLjAwMDAwMDAwMDAwMAotLS0gYS9k cml2ZXJzL2dwdS9kcm0vcmNhci1kdS9yY2FyX2R1X3ZnYWNvbi5oCisrKyAvZGV2L251bGwKQEAg LTEsMjMgKzAsMCBAQAotLyoKLSAqIHJjYXJfZHVfdmdhY29uLmggIC0tICBSLUNhciBEaXNwbGF5 IFVuaXQgVkdBIENvbm5lY3RvcgotICoKLSAqIENvcHlyaWdodCAoQykgMjAxMy0yMDE0IFJlbmVz YXMgRWxlY3Ryb25pY3MgQ29ycG9yYXRpb24KLSAqCi0gKiBDb250YWN0OiBMYXVyZW50IFBpbmNo YXJ0IChsYXVyZW50LnBpbmNoYXJ0QGlkZWFzb25ib2FyZC5jb20pCi0gKgotICogVGhpcyBwcm9n cmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2Rp ZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vu c2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRo ZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgotICogKGF0IHlvdXIgb3B0aW9uKSBhbnkg bGF0ZXIgdmVyc2lvbi4KLSAqLwotCi0jaWZuZGVmIF9fUkNBUl9EVV9WR0FDT05fSF9fCi0jZGVm aW5lIF9fUkNBUl9EVV9WR0FDT05fSF9fCi0KLXN0cnVjdCByY2FyX2R1X2RldmljZTsKLXN0cnVj dCByY2FyX2R1X2VuY29kZXI7Ci0KLWludCByY2FyX2R1X3ZnYV9jb25uZWN0b3JfaW5pdChzdHJ1 Y3QgcmNhcl9kdV9kZXZpY2UgKnJjZHUsCi0JCQkgICAgICAgc3RydWN0IHJjYXJfZHVfZW5jb2Rl ciAqcmVuYyk7Ci0KLSNlbmRpZiAvKiBfX1JDQVJfRFVfVkdBQ09OX0hfXyAqLwotLSAKUmVnYXJk cywKCkxhdXJlbnQgUGluY2hhcnQKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fCmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZyZWVk ZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZv L2RyaS1kZXZlbAo=