From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.1 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id E5AD1C43219 for ; Thu, 2 May 2019 19:50:32 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 85BCB214DA for ; Thu, 2 May 2019 19:50:32 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=poorly.run header.i=@poorly.run header.b="BuDKcgA+" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726434AbfEBTua (ORCPT ); Thu, 2 May 2019 15:50:30 -0400 Received: from mail-qk1-f193.google.com ([209.85.222.193]:42732 "EHLO mail-qk1-f193.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726607AbfEBTu2 (ORCPT ); Thu, 2 May 2019 15:50:28 -0400 Received: by mail-qk1-f193.google.com with SMTP id x19so2263932qki.9 for ; Thu, 02 May 2019 12:50:26 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=poorly.run; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=ngu51nmMLLFgcTUL5IoXJpQ0pecAfd3JLlcbeSD++h8=; b=BuDKcgA+PET4ak53qby6RiOXmCMEqC+RvH7Mi/Sb4RM+Qrmx7iNBZxgPq/Nb4PQ+BZ shw8u1VsAoKN8i7L2dHDstWHs5HiRH1p0s8nfBph8vb04FHG6eqOIccnNQIgWTb9HZAN JP6Gyk4ZgOf+p7HgSSBBqFmUnYALeoHR8HunADl3ix5JyAaPW6ORoVU2U0o6YXXw6VWG KTd3/7VQeCw/RobFibukHzIqa9YQDhj4JBwrnOGX/+eOoumWlWH5rMD6OA7bClC9bfly hTwXQA/cDmLgl2DGcBvRzo1HXIwp17H1EYHhEPwJuONcr18l3pJjKGJV4LdAkn60BJQH 13sg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=ngu51nmMLLFgcTUL5IoXJpQ0pecAfd3JLlcbeSD++h8=; b=CWsm8IQI/uXRhi+nV/HTm5QvAQVFuNRhxE+Z+WjG1tvzDENc4IsHJzRcBRXyTO/2iV zVRP5qROY0FtLKdQ7iux+l0gSH9mZWlbmx/z4BA7xDZBnYP3N5NXjv00m/UpO1InJdpL E6Ocv4kXEj3kBRG9cyw+wsKLcDWZyknXh66GJEuohhfMxJ++r3MOQng7yxk43StR+ff+ rVW0Y3wV1/SMT+Hn3qZyCRQoSiHqpj2xZQaeCaHQk9Um24U8CaG2EfqgWi5fHFzsQJVa EAWulJ5ydbGmGHJvHl/JOOAlS9v9v874rIGADLNeLObVbWGC0T3xE3Xo6N5cnhXbzv9q 7HAg== X-Gm-Message-State: APjAAAUakNgExtzbgLqL5/Oa+vp7OMcSO/GSEu2uhll5p51qG1XrwuGu cht6xh+ZcxY9xt4Auu0hAidPyA== X-Google-Smtp-Source: APXvYqycI9LkSrktiPATxaRP8WODGoM0WZ7LxSQq9mLFElIoa1mDR9WnzkTj1WYvMlXhYeYeGMFkSA== X-Received: by 2002:a05:620a:124e:: with SMTP id a14mr4198765qkl.43.1556826626237; Thu, 02 May 2019 12:50:26 -0700 (PDT) Received: from rosewood.cam.corp.google.com ([2620:0:1013:11:89c6:2139:5435:371d]) by smtp.gmail.com with ESMTPSA id k36sm34366qtc.52.2019.05.02.12.50.24 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Thu, 02 May 2019 12:50:25 -0700 (PDT) From: Sean Paul To: dri-devel@lists.freedesktop.org Cc: Sean Paul , Daniel Vetter , Jose Souza , Zain Wang , Tomasz Figa , =?UTF-8?q?Ville=20Syrj=C3=A4l=C3=A4?= , Maarten Lankhorst , Maxime Ripard , Sean Paul , David Airlie , Jonathan Corbet , linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org Subject: [PATCH v3 05/10] drm: Add helpers to kick off self refresh mode in drivers Date: Thu, 2 May 2019 15:49:47 -0400 Message-Id: <20190502194956.218441-6-sean@poorly.run> X-Mailer: git-send-email 2.21.0.593.g511ec345e18-goog In-Reply-To: <20190502194956.218441-1-sean@poorly.run> References: <20190502194956.218441-1-sean@poorly.run> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org From: Sean Paul This patch adds a new drm helper library to help drivers implement self refresh. Drivers choosing to use it will register crtcs and will receive callbacks when it's time to enter or exit self refresh mode. In its current form, it has a timer which will trigger after a driver-specified amount of inactivity. When the timer triggers, the helpers will submit a new atomic commit to shut the refreshing pipe off. On the next atomic commit, the drm core will revert the self refresh state and bring everything back up to be actively driven. >From the driver's perspective, this works like a regular disable/enable cycle. The driver need only check the 'self_refresh_active' state in crtc_state. It should initiate self refresh mode on the panel and enter an off or low-power state. Changes in v2: - s/psr/self_refresh/ (Daniel) - integrated the psr exit into the commit that wakes it up (Jose/Daniel) - made the psr state per-crtc (Jose/Daniel) Changes in v3: - Remove the self_refresh_(active|changed) from connector state (Daniel) - Simplify loop in drm_self_refresh_helper_alter_state (Daniel) - Improve self_refresh_aware comment (Daniel) - s/self_refresh_state/self_refresh_data/ (Daniel) Link to v1: https://patchwork.freedesktop.org/patch/msgid/20190228210939.83386-2-sean@poorly.run Link to v2: https://patchwork.freedesktop.org/patch/msgid/20190326204509.96515-1-sean@poorly.run Cc: Daniel Vetter Cc: Jose Souza Cc: Zain Wang Cc: Tomasz Figa Cc: Ville Syrjälä Signed-off-by: Sean Paul --- Documentation/gpu/drm-kms-helpers.rst | 9 + drivers/gpu/drm/Makefile | 2 +- drivers/gpu/drm/drm_atomic.c | 2 + drivers/gpu/drm/drm_atomic_helper.c | 35 +++- drivers/gpu/drm/drm_atomic_state_helper.c | 4 + drivers/gpu/drm/drm_atomic_uapi.c | 7 +- drivers/gpu/drm/drm_self_refresh_helper.c | 205 ++++++++++++++++++++++ include/drm/drm_atomic.h | 15 ++ include/drm/drm_connector.h | 14 ++ include/drm/drm_crtc.h | 19 ++ include/drm/drm_self_refresh_helper.h | 22 +++ 11 files changed, 329 insertions(+), 5 deletions(-) create mode 100644 drivers/gpu/drm/drm_self_refresh_helper.c create mode 100644 include/drm/drm_self_refresh_helper.h diff --git a/Documentation/gpu/drm-kms-helpers.rst b/Documentation/gpu/drm-kms-helpers.rst index 14102ae035dc..d8a13c6b4db3 100644 --- a/Documentation/gpu/drm-kms-helpers.rst +++ b/Documentation/gpu/drm-kms-helpers.rst @@ -113,6 +113,15 @@ format Helper Functions Reference .. kernel-doc:: drivers/gpu/drm/drm_format_helper.c :export: +Panel Self Refresh Helper Reference +=================================== + +.. kernel-doc:: drivers/gpu/drm/drm_self_refresh_helper.c + :doc: overview + +.. kernel-doc:: drivers/gpu/drm/drm_self_refresh_helper.c + :export: + Framebuffer CMA Helper Functions Reference ========================================== diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile index 3d0c75cd687c..c4852604fc1d 100644 --- a/drivers/gpu/drm/Makefile +++ b/drivers/gpu/drm/Makefile @@ -39,7 +39,7 @@ drm_kms_helper-y := drm_crtc_helper.o drm_dp_helper.o drm_dsc.o drm_probe_helper drm_simple_kms_helper.o drm_modeset_helper.o \ drm_scdc_helper.o drm_gem_framebuffer_helper.o \ drm_atomic_state_helper.o drm_damage_helper.o \ - drm_format_helper.o + drm_format_helper.o drm_self_refresh_helper.o drm_kms_helper-$(CONFIG_DRM_PANEL_BRIDGE) += bridge/panel.o drm_kms_helper-$(CONFIG_DRM_FBDEV_EMULATION) += drm_fb_helper.o diff --git a/drivers/gpu/drm/drm_atomic.c b/drivers/gpu/drm/drm_atomic.c index 5eb40130fafb..4449956241f2 100644 --- a/drivers/gpu/drm/drm_atomic.c +++ b/drivers/gpu/drm/drm_atomic.c @@ -379,6 +379,7 @@ static void drm_atomic_crtc_print_state(struct drm_printer *p, drm_printf(p, "crtc[%u]: %s\n", crtc->base.id, crtc->name); drm_printf(p, "\tenable=%d\n", state->enable); drm_printf(p, "\tactive=%d\n", state->active); + drm_printf(p, "\tself_refresh_active=%d\n", state->self_refresh_active); drm_printf(p, "\tplanes_changed=%d\n", state->planes_changed); drm_printf(p, "\tmode_changed=%d\n", state->mode_changed); drm_printf(p, "\tactive_changed=%d\n", state->active_changed); @@ -881,6 +882,7 @@ static void drm_atomic_connector_print_state(struct drm_printer *p, drm_printf(p, "connector[%u]: %s\n", connector->base.id, connector->name); drm_printf(p, "\tcrtc=%s\n", state->crtc ? state->crtc->name : "(null)"); + drm_printf(p, "\tself_refresh_aware=%d\n", state->self_refresh_aware); if (connector->connector_type == DRM_MODE_CONNECTOR_WRITEBACK) if (state->writeback_job && state->writeback_job->fb) diff --git a/drivers/gpu/drm/drm_atomic_helper.c b/drivers/gpu/drm/drm_atomic_helper.c index fa5a367507c1..3c26f04cd6b8 100644 --- a/drivers/gpu/drm/drm_atomic_helper.c +++ b/drivers/gpu/drm/drm_atomic_helper.c @@ -30,6 +30,7 @@ #include #include #include +#include #include #include #include @@ -950,10 +951,33 @@ int drm_atomic_helper_check(struct drm_device *dev, if (state->legacy_cursor_update) state->async_update = !drm_atomic_helper_async_check(dev, state); + drm_self_refresh_helper_alter_state(state); + return ret; } EXPORT_SYMBOL(drm_atomic_helper_check); +static bool +crtc_needs_disable(struct drm_crtc_state *old_state, + struct drm_crtc_state *new_state) +{ + /* + * No new_state means the crtc is off, so the only criteria is whether + * it's currently active or in self refresh mode. + */ + if (!new_state) + return drm_atomic_crtc_effectively_active(old_state); + + /* + * We need to run through the crtc_funcs->disable() function if the crtc + * is currently on, if it's transitioning to self refresh mode, or if + * it's in self refresh mode and needs to be fully disabled. + */ + return old_state->active || + (old_state->self_refresh_active && !new_state->enable) || + new_state->self_refresh_active; +} + static void disable_outputs(struct drm_device *dev, struct drm_atomic_state *old_state) { @@ -974,7 +998,14 @@ disable_outputs(struct drm_device *dev, struct drm_atomic_state *old_state) old_crtc_state = drm_atomic_get_old_crtc_state(old_state, old_conn_state->crtc); - if (!old_crtc_state->active || + if (new_conn_state->crtc) + new_crtc_state = drm_atomic_get_new_crtc_state( + old_state, + new_conn_state->crtc); + else + new_crtc_state = NULL; + + if (!crtc_needs_disable(old_crtc_state, new_crtc_state) || !drm_atomic_crtc_needs_modeset(old_conn_state->crtc->state)) continue; @@ -1020,7 +1051,7 @@ disable_outputs(struct drm_device *dev, struct drm_atomic_state *old_state) if (!drm_atomic_crtc_needs_modeset(new_crtc_state)) continue; - if (!old_crtc_state->active) + if (!crtc_needs_disable(old_crtc_state, new_crtc_state)) continue; funcs = crtc->helper_private; diff --git a/drivers/gpu/drm/drm_atomic_state_helper.c b/drivers/gpu/drm/drm_atomic_state_helper.c index ac929f68ff31..ca18008043e5 100644 --- a/drivers/gpu/drm/drm_atomic_state_helper.c +++ b/drivers/gpu/drm/drm_atomic_state_helper.c @@ -128,6 +128,10 @@ void __drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc, state->commit = NULL; state->event = NULL; state->pageflip_flags = 0; + + /* Self refresh should be canceled when a new update is available */ + state->active = drm_atomic_crtc_effectively_active(state); + state->self_refresh_active = false; } EXPORT_SYMBOL(__drm_atomic_helper_crtc_duplicate_state); diff --git a/drivers/gpu/drm/drm_atomic_uapi.c b/drivers/gpu/drm/drm_atomic_uapi.c index ea797d4c82ee..a75c633ff0c0 100644 --- a/drivers/gpu/drm/drm_atomic_uapi.c +++ b/drivers/gpu/drm/drm_atomic_uapi.c @@ -490,7 +490,7 @@ drm_atomic_crtc_get_property(struct drm_crtc *crtc, struct drm_mode_config *config = &dev->mode_config; if (property == config->prop_active) - *val = state->active; + *val = drm_atomic_crtc_effectively_active(state); else if (property == config->prop_mode_id) *val = (state->mode_blob) ? state->mode_blob->base.id : 0; else if (property == config->prop_vrr_enabled) @@ -772,7 +772,10 @@ drm_atomic_connector_get_property(struct drm_connector *connector, if (property == config->prop_crtc_id) { *val = (state->crtc) ? state->crtc->base.id : 0; } else if (property == config->dpms_property) { - *val = connector->dpms; + if (state->crtc && state->crtc->state->self_refresh_active) + *val = DRM_MODE_DPMS_ON; + else + *val = connector->dpms; } else if (property == config->tv_select_subconnector_property) { *val = state->tv.subconnector; } else if (property == config->tv_left_margin_property) { diff --git a/drivers/gpu/drm/drm_self_refresh_helper.c b/drivers/gpu/drm/drm_self_refresh_helper.c new file mode 100644 index 000000000000..f46e7639d277 --- /dev/null +++ b/drivers/gpu/drm/drm_self_refresh_helper.c @@ -0,0 +1,205 @@ +/* SPDX-License-Identifier: MIT */ +/* + * Copyright (C) 2019 Google, Inc. + * + * Authors: + * Sean Paul + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/** + * DOC: overview + * + * This helper library provides an easy way for drivers to leverage the atomic + * framework to implement panel self refresh (SR) support. Drivers are + * responsible for registering and unregistering the SR helpers on load/unload. + * + * Once a crtc has enabled SR, the helpers will monitor activity and + * call back into the driver to enable/disable SR as appropriate. The best way + * to think about this is that it's a DPMS on/off request with a flag set in + * state that tells you to disable/enable SR on the panel instead of power- + * cycling it. + * + * Drivers may choose to fully disable their crtc/encoder/bridge hardware, or + * they can use the "self_refresh_active" flags in crtc state if they want to + * enter low power mode without full disable (in case full disable/enable is too + * slow). + * + * SR will be deactivated if there are any atomic updates affecting the + * pipe that is in SR mode. If a crtc is driving multiple connectors, all + * connectors must be SR aware and all will enter SR mode. + */ + +struct drm_self_refresh_data { + struct drm_crtc *crtc; + struct delayed_work entry_work; + struct drm_atomic_state *save_state; + unsigned int entry_delay_ms; +}; + +static void drm_self_refresh_helper_entry_work(struct work_struct *work) +{ + struct drm_self_refresh_data *sr_data = container_of( + to_delayed_work(work), + struct drm_self_refresh_data, entry_work); + struct drm_crtc *crtc = sr_data->crtc; + struct drm_device *dev = crtc->dev; + struct drm_modeset_acquire_ctx ctx; + struct drm_atomic_state *state; + struct drm_connector *conn; + struct drm_connector_state *conn_state; + struct drm_crtc_state *crtc_state; + int i, ret; + + drm_modeset_acquire_init(&ctx, 0); + + state = drm_atomic_state_alloc(dev); + if (!state) { + ret = -ENOMEM; + goto out; + } + +retry: + state->acquire_ctx = &ctx; + + crtc_state = drm_atomic_get_crtc_state(state, crtc); + if (IS_ERR(crtc_state)) { + ret = PTR_ERR(crtc_state); + goto out; + } + + if (!crtc_state->enable) + goto out; + + ret = drm_atomic_add_affected_connectors(state, crtc); + if (ret) + goto out; + + for_each_new_connector_in_state(state, conn, conn_state, i) { + if (!conn_state->self_refresh_aware) + goto out; + } + + crtc_state->active = false; + crtc_state->self_refresh_active = true; + + ret = drm_atomic_commit(state); + if (ret) + goto out; + +out: + if (ret == -EDEADLK) { + drm_atomic_state_clear(state); + ret = drm_modeset_backoff(&ctx); + if (!ret) + goto retry; + } + + drm_atomic_state_put(state); + drm_modeset_drop_locks(&ctx); + drm_modeset_acquire_fini(&ctx); +} + +/** + * drm_self_refresh_helper_alter_state - Alters the atomic state for SR exit + * @state: the state currently being checked + * + * Called at the end of atomic check. This function checks the state for flags + * incompatible with self refresh exit and changes them. This is a bit + * disingenuous since userspace is expecting one thing and we're giving it + * another. However in order to keep self refresh entirely hidden from + * userspace, this is required. + * + * At the end, we queue up the self refresh entry work so we can enter PSR after + * the desired delay. + */ +void drm_self_refresh_helper_alter_state(struct drm_atomic_state *state) +{ + struct drm_crtc *crtc; + struct drm_crtc_state *crtc_state; + int i; + + if (state->async_update || !state->allow_modeset) { + for_each_old_crtc_in_state(state, crtc, crtc_state, i) { + if (crtc_state->self_refresh_active) { + state->async_update = false; + state->allow_modeset = true; + break; + } + } + } + + for_each_new_crtc_in_state(state, crtc, crtc_state, i) { + struct drm_self_refresh_data *sr_data; + + /* Don't trigger the entry timer when we're already in SR */ + if (crtc_state->self_refresh_active) + continue; + + sr_data = crtc->self_refresh_data; + if (!sr_data) + continue; + + mod_delayed_work(system_wq, &sr_data->entry_work, + msecs_to_jiffies(sr_data->entry_delay_ms)); + } +} +EXPORT_SYMBOL(drm_self_refresh_helper_alter_state); + +/** + * drm_self_refresh_helper_register - Registers self refresh helpers for a crtc + * @crtc: the crtc which supports self refresh supported displays + * @entry_delay_ms: amount of inactivity to wait before entering self refresh + */ +int drm_self_refresh_helper_register(struct drm_crtc *crtc, + unsigned int entry_delay_ms) +{ + struct drm_self_refresh_data *sr_data = crtc->self_refresh_data; + + /* Helper is already registered */ + if (WARN_ON(sr_data)) + return -EINVAL; + + sr_data = kzalloc(sizeof(*sr_data), GFP_KERNEL); + if (!sr_data) + return -ENOMEM; + + INIT_DELAYED_WORK(&sr_data->entry_work, + drm_self_refresh_helper_entry_work); + sr_data->entry_delay_ms = entry_delay_ms; + sr_data->crtc = crtc; + + crtc->self_refresh_data = sr_data; + return 0; +} +EXPORT_SYMBOL(drm_self_refresh_helper_register); + +/** + * drm_self_refresh_helper_unregister - Unregisters self refresh helpers + * @crtc: the crtc to unregister + */ +void drm_self_refresh_helper_unregister(struct drm_crtc *crtc) +{ + struct drm_self_refresh_data *sr_data = crtc->self_refresh_data; + + /* Helper is already unregistered */ + if (sr_data) + return; + + crtc->self_refresh_data = NULL; + + cancel_delayed_work_sync(&sr_data->entry_work); + kfree(sr_data); +} +EXPORT_SYMBOL(drm_self_refresh_helper_unregister); diff --git a/include/drm/drm_atomic.h b/include/drm/drm_atomic.h index 824a5ed4e216..1e9cab1da97a 100644 --- a/include/drm/drm_atomic.h +++ b/include/drm/drm_atomic.h @@ -944,4 +944,19 @@ drm_atomic_crtc_needs_modeset(const struct drm_crtc_state *state) state->connectors_changed; } +/** + * drm_atomic_crtc_effectively_active - compute whether crtc is actually active + * @state: &drm_crtc_state for the CRTC + * + * When in self refresh mode, the crtc_state->active value will be false, since + * the crtc is off. However in some cases we're interested in whether the crtc + * is active, or effectively active (ie: it's connected to an active display). + * In these cases, use this function instead of just checking active. + */ +static inline bool +drm_atomic_crtc_effectively_active(const struct drm_crtc_state *state) +{ + return state->active || state->self_refresh_active; +} + #endif /* DRM_ATOMIC_H_ */ diff --git a/include/drm/drm_connector.h b/include/drm/drm_connector.h index 02a131202add..9b40eb6f0ef4 100644 --- a/include/drm/drm_connector.h +++ b/include/drm/drm_connector.h @@ -539,6 +539,20 @@ struct drm_connector_state { /** @tv: TV connector state */ struct drm_tv_connector_state tv; + /** + * @self_refresh_aware: + * + * This tracks whether a connector is aware of the self refresh state. + * It should be set to true for those connector implementations which + * understand the self refresh state. This is needed since the crtc + * registers the self refresh helpers and it doesn't know if the + * connectors downstream have implemented self refresh entry/exit. + * + * Drivers should set this to true in atomic_check if they know how to + * handle self_refresh requests. + */ + bool self_refresh_aware; + /** * @picture_aspect_ratio: Connector property to control the * HDMI infoframe aspect ratio setting. diff --git a/include/drm/drm_crtc.h b/include/drm/drm_crtc.h index 58ad983d7cd6..67e3075a8784 100644 --- a/include/drm/drm_crtc.h +++ b/include/drm/drm_crtc.h @@ -53,6 +53,7 @@ struct drm_mode_set; struct drm_file; struct drm_clip_rect; struct drm_printer; +struct drm_self_refresh_data; struct device_node; struct dma_fence; struct edid; @@ -299,6 +300,17 @@ struct drm_crtc_state { */ bool vrr_enabled; + /** + * @self_refresh_active: + * + * Used by the self refresh helpers to denote when a self refresh + * transition is occuring. This will be set on enable/disable callbacks + * when self refresh is being enabled or disabled. In some cases, it may + * not be desirable to fully shut off the crtc during self refresh. + * CRTC's can inspect this flag and determine the best course of action. + */ + bool self_refresh_active; + /** * @event: * @@ -1087,6 +1099,13 @@ struct drm_crtc { * The name of the CRTC's fence timeline. */ char timeline_name[32]; + + /** + * @self_refresh_data: Holds the state for the self refresh helpers + * + * Initialized via drm_self_refresh_helper_register(). + */ + struct drm_self_refresh_data *self_refresh_data; }; /** diff --git a/include/drm/drm_self_refresh_helper.h b/include/drm/drm_self_refresh_helper.h new file mode 100644 index 000000000000..efb2e6e3249f --- /dev/null +++ b/include/drm/drm_self_refresh_helper.h @@ -0,0 +1,22 @@ +/* SPDX-License-Identifier: MIT */ +/* + * Copyright (C) 2019 Google, Inc. + * + * Authors: + * Sean Paul + */ +#ifndef DRM_SELF_REFRESH_HELPER_H_ +#define DRM_SELF_REFRESH_HELPER_H_ + +struct drm_atomic_state; +struct drm_connector; +struct drm_device; +struct drm_modeset_acquire_ctx; + +void drm_self_refresh_helper_alter_state(struct drm_atomic_state *state); + +int drm_self_refresh_helper_register(struct drm_crtc *crtc, + unsigned int entry_delay_ms); + +void drm_self_refresh_helper_unregister(struct drm_crtc *crtc); +#endif -- Sean Paul, Software Engineer, Google / Chromium OS From mboxrd@z Thu Jan 1 00:00:00 1970 From: Sean Paul Subject: [PATCH v3 05/10] drm: Add helpers to kick off self refresh mode in drivers Date: Thu, 2 May 2019 15:49:47 -0400 Message-ID: <20190502194956.218441-6-sean@poorly.run> References: <20190502194956.218441-1-sean@poorly.run> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail-qk1-x742.google.com (mail-qk1-x742.google.com [IPv6:2607:f8b0:4864:20::742]) by gabe.freedesktop.org (Postfix) with ESMTPS id 655A788E57 for ; Thu, 2 May 2019 19:50:27 +0000 (UTC) Received: by mail-qk1-x742.google.com with SMTP id d14so2253127qkl.11 for ; Thu, 02 May 2019 12:50:27 -0700 (PDT) In-Reply-To: <20190502194956.218441-1-sean@poorly.run> 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: Zain Wang , Jonathan Corbet , Maxime Ripard , linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org, Jose Souza , Tomasz Figa , David Airlie , Sean Paul , Sean Paul List-Id: dri-devel@lists.freedesktop.org RnJvbTogU2VhbiBQYXVsIDxzZWFucGF1bEBjaHJvbWl1bS5vcmc+CgpUaGlzIHBhdGNoIGFkZHMg YSBuZXcgZHJtIGhlbHBlciBsaWJyYXJ5IHRvIGhlbHAgZHJpdmVycyBpbXBsZW1lbnQKc2VsZiBy ZWZyZXNoLiBEcml2ZXJzIGNob29zaW5nIHRvIHVzZSBpdCB3aWxsIHJlZ2lzdGVyIGNydGNzIGFu ZAp3aWxsIHJlY2VpdmUgY2FsbGJhY2tzIHdoZW4gaXQncyB0aW1lIHRvIGVudGVyIG9yIGV4aXQg c2VsZiByZWZyZXNoCm1vZGUuCgpJbiBpdHMgY3VycmVudCBmb3JtLCBpdCBoYXMgYSB0aW1lciB3 aGljaCB3aWxsIHRyaWdnZXIgYWZ0ZXIgYQpkcml2ZXItc3BlY2lmaWVkIGFtb3VudCBvZiBpbmFj dGl2aXR5LiBXaGVuIHRoZSB0aW1lciB0cmlnZ2VycywgdGhlCmhlbHBlcnMgd2lsbCBzdWJtaXQg YSBuZXcgYXRvbWljIGNvbW1pdCB0byBzaHV0IHRoZSByZWZyZXNoaW5nIHBpcGUKb2ZmLiBPbiB0 aGUgbmV4dCBhdG9taWMgY29tbWl0LCB0aGUgZHJtIGNvcmUgd2lsbCByZXZlcnQgdGhlIHNlbGYK cmVmcmVzaCBzdGF0ZSBhbmQgYnJpbmcgZXZlcnl0aGluZyBiYWNrIHVwIHRvIGJlIGFjdGl2ZWx5 IGRyaXZlbi4KCkZyb20gdGhlIGRyaXZlcidzIHBlcnNwZWN0aXZlLCB0aGlzIHdvcmtzIGxpa2Ug YSByZWd1bGFyIGRpc2FibGUvZW5hYmxlCmN5Y2xlLiBUaGUgZHJpdmVyIG5lZWQgb25seSBjaGVj ayB0aGUgJ3NlbGZfcmVmcmVzaF9hY3RpdmUnIHN0YXRlIGluCmNydGNfc3RhdGUuIEl0IHNob3Vs ZCBpbml0aWF0ZSBzZWxmIHJlZnJlc2ggbW9kZSBvbiB0aGUgcGFuZWwgYW5kIGVudGVyCmFuIG9m ZiBvciBsb3ctcG93ZXIgc3RhdGUuCgpDaGFuZ2VzIGluIHYyOgotIHMvcHNyL3NlbGZfcmVmcmVz aC8gKERhbmllbCkKLSBpbnRlZ3JhdGVkIHRoZSBwc3IgZXhpdCBpbnRvIHRoZSBjb21taXQgdGhh dCB3YWtlcyBpdCB1cCAoSm9zZS9EYW5pZWwpCi0gbWFkZSB0aGUgcHNyIHN0YXRlIHBlci1jcnRj IChKb3NlL0RhbmllbCkKQ2hhbmdlcyBpbiB2MzoKLSBSZW1vdmUgdGhlIHNlbGZfcmVmcmVzaF8o YWN0aXZlfGNoYW5nZWQpIGZyb20gY29ubmVjdG9yIHN0YXRlIChEYW5pZWwpCi0gU2ltcGxpZnkg bG9vcCBpbiBkcm1fc2VsZl9yZWZyZXNoX2hlbHBlcl9hbHRlcl9zdGF0ZSAoRGFuaWVsKQotIElt cHJvdmUgc2VsZl9yZWZyZXNoX2F3YXJlIGNvbW1lbnQgKERhbmllbCkKLSBzL3NlbGZfcmVmcmVz aF9zdGF0ZS9zZWxmX3JlZnJlc2hfZGF0YS8gKERhbmllbCkKCkxpbmsgdG8gdjE6IGh0dHBzOi8v cGF0Y2h3b3JrLmZyZWVkZXNrdG9wLm9yZy9wYXRjaC9tc2dpZC8yMDE5MDIyODIxMDkzOS44MzM4 Ni0yLXNlYW5AcG9vcmx5LnJ1bgpMaW5rIHRvIHYyOiBodHRwczovL3BhdGNod29yay5mcmVlZGVz a3RvcC5vcmcvcGF0Y2gvbXNnaWQvMjAxOTAzMjYyMDQ1MDkuOTY1MTUtMS1zZWFuQHBvb3JseS5y dW4KCkNjOiBEYW5pZWwgVmV0dGVyIDxkYW5pZWxAZmZ3bGwuY2g+CkNjOiBKb3NlIFNvdXphIDxq b3NlLnNvdXphQGludGVsLmNvbT4KQ2M6IFphaW4gV2FuZyA8d3p6QHJvY2stY2hpcHMuY29tPgpD YzogVG9tYXN6IEZpZ2EgPHRmaWdhQGNocm9taXVtLm9yZz4KQ2M6IFZpbGxlIFN5cmrDpGzDpCA8 dmlsbGUuc3lyamFsYUBsaW51eC5pbnRlbC5jb20+ClNpZ25lZC1vZmYtYnk6IFNlYW4gUGF1bCA8 c2VhbnBhdWxAY2hyb21pdW0ub3JnPgotLS0KIERvY3VtZW50YXRpb24vZ3B1L2RybS1rbXMtaGVs cGVycy5yc3QgICAgIHwgICA5ICsKIGRyaXZlcnMvZ3B1L2RybS9NYWtlZmlsZSAgICAgICAgICAg ICAgICAgIHwgICAyICstCiBkcml2ZXJzL2dwdS9kcm0vZHJtX2F0b21pYy5jICAgICAgICAgICAg ICB8ICAgMiArCiBkcml2ZXJzL2dwdS9kcm0vZHJtX2F0b21pY19oZWxwZXIuYyAgICAgICB8ICAz NSArKystCiBkcml2ZXJzL2dwdS9kcm0vZHJtX2F0b21pY19zdGF0ZV9oZWxwZXIuYyB8ICAgNCAr CiBkcml2ZXJzL2dwdS9kcm0vZHJtX2F0b21pY191YXBpLmMgICAgICAgICB8ICAgNyArLQogZHJp dmVycy9ncHUvZHJtL2RybV9zZWxmX3JlZnJlc2hfaGVscGVyLmMgfCAyMDUgKysrKysrKysrKysr KysrKysrKysrKwogaW5jbHVkZS9kcm0vZHJtX2F0b21pYy5oICAgICAgICAgICAgICAgICAgfCAg MTUgKysKIGluY2x1ZGUvZHJtL2RybV9jb25uZWN0b3IuaCAgICAgICAgICAgICAgIHwgIDE0ICsr CiBpbmNsdWRlL2RybS9kcm1fY3J0Yy5oICAgICAgICAgICAgICAgICAgICB8ICAxOSArKwogaW5j bHVkZS9kcm0vZHJtX3NlbGZfcmVmcmVzaF9oZWxwZXIuaCAgICAgfCAgMjIgKysrCiAxMSBmaWxl cyBjaGFuZ2VkLCAzMjkgaW5zZXJ0aW9ucygrKSwgNSBkZWxldGlvbnMoLSkKIGNyZWF0ZSBtb2Rl IDEwMDY0NCBkcml2ZXJzL2dwdS9kcm0vZHJtX3NlbGZfcmVmcmVzaF9oZWxwZXIuYwogY3JlYXRl IG1vZGUgMTAwNjQ0IGluY2x1ZGUvZHJtL2RybV9zZWxmX3JlZnJlc2hfaGVscGVyLmgKCmRpZmYg LS1naXQgYS9Eb2N1bWVudGF0aW9uL2dwdS9kcm0ta21zLWhlbHBlcnMucnN0IGIvRG9jdW1lbnRh dGlvbi9ncHUvZHJtLWttcy1oZWxwZXJzLnJzdAppbmRleCAxNDEwMmFlMDM1ZGMuLmQ4YTEzYzZi NGRiMyAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9ncHUvZHJtLWttcy1oZWxwZXJzLnJzdAor KysgYi9Eb2N1bWVudGF0aW9uL2dwdS9kcm0ta21zLWhlbHBlcnMucnN0CkBAIC0xMTMsNiArMTEz LDE1IEBAIGZvcm1hdCBIZWxwZXIgRnVuY3Rpb25zIFJlZmVyZW5jZQogLi4ga2VybmVsLWRvYzo6 IGRyaXZlcnMvZ3B1L2RybS9kcm1fZm9ybWF0X2hlbHBlci5jCiAgICA6ZXhwb3J0OgogCitQYW5l bCBTZWxmIFJlZnJlc2ggSGVscGVyIFJlZmVyZW5jZQorPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KKworLi4ga2VybmVsLWRvYzo6IGRyaXZlcnMvZ3B1L2RybS9kcm1fc2VsZl9y ZWZyZXNoX2hlbHBlci5jCisgICA6ZG9jOiBvdmVydmlldworCisuLiBrZXJuZWwtZG9jOjogZHJp dmVycy9ncHUvZHJtL2RybV9zZWxmX3JlZnJlc2hfaGVscGVyLmMKKyAgIDpleHBvcnQ6CisKIEZy YW1lYnVmZmVyIENNQSBIZWxwZXIgRnVuY3Rpb25zIFJlZmVyZW5jZQogPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2Ry bS9NYWtlZmlsZSBiL2RyaXZlcnMvZ3B1L2RybS9NYWtlZmlsZQppbmRleCAzZDBjNzVjZDY4N2Mu LmM0ODUyNjA0ZmMxZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL01ha2VmaWxlCisrKyBi L2RyaXZlcnMvZ3B1L2RybS9NYWtlZmlsZQpAQCAtMzksNyArMzksNyBAQCBkcm1fa21zX2hlbHBl ci15IDo9IGRybV9jcnRjX2hlbHBlci5vIGRybV9kcF9oZWxwZXIubyBkcm1fZHNjLm8gZHJtX3By b2JlX2hlbHBlcgogCQlkcm1fc2ltcGxlX2ttc19oZWxwZXIubyBkcm1fbW9kZXNldF9oZWxwZXIu byBcCiAJCWRybV9zY2RjX2hlbHBlci5vIGRybV9nZW1fZnJhbWVidWZmZXJfaGVscGVyLm8gXAog CQlkcm1fYXRvbWljX3N0YXRlX2hlbHBlci5vIGRybV9kYW1hZ2VfaGVscGVyLm8gXAotCQlkcm1f Zm9ybWF0X2hlbHBlci5vCisJCWRybV9mb3JtYXRfaGVscGVyLm8gZHJtX3NlbGZfcmVmcmVzaF9o ZWxwZXIubwogCiBkcm1fa21zX2hlbHBlci0kKENPTkZJR19EUk1fUEFORUxfQlJJREdFKSArPSBi cmlkZ2UvcGFuZWwubwogZHJtX2ttc19oZWxwZXItJChDT05GSUdfRFJNX0ZCREVWX0VNVUxBVElP TikgKz0gZHJtX2ZiX2hlbHBlci5vCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vZHJtX2F0 b21pYy5jIGIvZHJpdmVycy9ncHUvZHJtL2RybV9hdG9taWMuYwppbmRleCA1ZWI0MDEzMGZhZmIu LjQ0NDk5NTYyNDFmMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2RybV9hdG9taWMuYwor KysgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX2F0b21pYy5jCkBAIC0zNzksNiArMzc5LDcgQEAgc3Rh dGljIHZvaWQgZHJtX2F0b21pY19jcnRjX3ByaW50X3N0YXRlKHN0cnVjdCBkcm1fcHJpbnRlciAq cCwKIAlkcm1fcHJpbnRmKHAsICJjcnRjWyV1XTogJXNcbiIsIGNydGMtPmJhc2UuaWQsIGNydGMt Pm5hbWUpOwogCWRybV9wcmludGYocCwgIlx0ZW5hYmxlPSVkXG4iLCBzdGF0ZS0+ZW5hYmxlKTsK IAlkcm1fcHJpbnRmKHAsICJcdGFjdGl2ZT0lZFxuIiwgc3RhdGUtPmFjdGl2ZSk7CisJZHJtX3By aW50ZihwLCAiXHRzZWxmX3JlZnJlc2hfYWN0aXZlPSVkXG4iLCBzdGF0ZS0+c2VsZl9yZWZyZXNo X2FjdGl2ZSk7CiAJZHJtX3ByaW50ZihwLCAiXHRwbGFuZXNfY2hhbmdlZD0lZFxuIiwgc3RhdGUt PnBsYW5lc19jaGFuZ2VkKTsKIAlkcm1fcHJpbnRmKHAsICJcdG1vZGVfY2hhbmdlZD0lZFxuIiwg c3RhdGUtPm1vZGVfY2hhbmdlZCk7CiAJZHJtX3ByaW50ZihwLCAiXHRhY3RpdmVfY2hhbmdlZD0l ZFxuIiwgc3RhdGUtPmFjdGl2ZV9jaGFuZ2VkKTsKQEAgLTg4MSw2ICs4ODIsNyBAQCBzdGF0aWMg dm9pZCBkcm1fYXRvbWljX2Nvbm5lY3Rvcl9wcmludF9zdGF0ZShzdHJ1Y3QgZHJtX3ByaW50ZXIg KnAsCiAKIAlkcm1fcHJpbnRmKHAsICJjb25uZWN0b3JbJXVdOiAlc1xuIiwgY29ubmVjdG9yLT5i YXNlLmlkLCBjb25uZWN0b3ItPm5hbWUpOwogCWRybV9wcmludGYocCwgIlx0Y3J0Yz0lc1xuIiwg c3RhdGUtPmNydGMgPyBzdGF0ZS0+Y3J0Yy0+bmFtZSA6ICIobnVsbCkiKTsKKwlkcm1fcHJpbnRm KHAsICJcdHNlbGZfcmVmcmVzaF9hd2FyZT0lZFxuIiwgc3RhdGUtPnNlbGZfcmVmcmVzaF9hd2Fy ZSk7CiAKIAlpZiAoY29ubmVjdG9yLT5jb25uZWN0b3JfdHlwZSA9PSBEUk1fTU9ERV9DT05ORUNU T1JfV1JJVEVCQUNLKQogCQlpZiAoc3RhdGUtPndyaXRlYmFja19qb2IgJiYgc3RhdGUtPndyaXRl YmFja19qb2ItPmZiKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2RybV9hdG9taWNfaGVs cGVyLmMgYi9kcml2ZXJzL2dwdS9kcm0vZHJtX2F0b21pY19oZWxwZXIuYwppbmRleCBmYTVhMzY3 NTA3YzEuLjNjMjZmMDRjZDZiOCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2RybV9hdG9t aWNfaGVscGVyLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2RybV9hdG9taWNfaGVscGVyLmMKQEAg LTMwLDYgKzMwLDcgQEAKICNpbmNsdWRlIDxkcm0vZHJtX2F0b21pY191YXBpLmg+CiAjaW5jbHVk ZSA8ZHJtL2RybV9wbGFuZV9oZWxwZXIuaD4KICNpbmNsdWRlIDxkcm0vZHJtX2F0b21pY19oZWxw ZXIuaD4KKyNpbmNsdWRlIDxkcm0vZHJtX3NlbGZfcmVmcmVzaF9oZWxwZXIuaD4KICNpbmNsdWRl IDxkcm0vZHJtX3dyaXRlYmFjay5oPgogI2luY2x1ZGUgPGRybS9kcm1fZGFtYWdlX2hlbHBlci5o PgogI2luY2x1ZGUgPGxpbnV4L2RtYS1mZW5jZS5oPgpAQCAtOTUwLDEwICs5NTEsMzMgQEAgaW50 IGRybV9hdG9taWNfaGVscGVyX2NoZWNrKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsCiAJaWYgKHN0 YXRlLT5sZWdhY3lfY3Vyc29yX3VwZGF0ZSkKIAkJc3RhdGUtPmFzeW5jX3VwZGF0ZSA9ICFkcm1f YXRvbWljX2hlbHBlcl9hc3luY19jaGVjayhkZXYsIHN0YXRlKTsKIAorCWRybV9zZWxmX3JlZnJl c2hfaGVscGVyX2FsdGVyX3N0YXRlKHN0YXRlKTsKKwogCXJldHVybiByZXQ7CiB9CiBFWFBPUlRf U1lNQk9MKGRybV9hdG9taWNfaGVscGVyX2NoZWNrKTsKIAorc3RhdGljIGJvb2wKK2NydGNfbmVl ZHNfZGlzYWJsZShzdHJ1Y3QgZHJtX2NydGNfc3RhdGUgKm9sZF9zdGF0ZSwKKwkJICAgc3RydWN0 IGRybV9jcnRjX3N0YXRlICpuZXdfc3RhdGUpCit7CisJLyoKKwkgKiBObyBuZXdfc3RhdGUgbWVh bnMgdGhlIGNydGMgaXMgb2ZmLCBzbyB0aGUgb25seSBjcml0ZXJpYSBpcyB3aGV0aGVyCisJICog aXQncyBjdXJyZW50bHkgYWN0aXZlIG9yIGluIHNlbGYgcmVmcmVzaCBtb2RlLgorCSAqLworCWlm ICghbmV3X3N0YXRlKQorCQlyZXR1cm4gZHJtX2F0b21pY19jcnRjX2VmZmVjdGl2ZWx5X2FjdGl2 ZShvbGRfc3RhdGUpOworCisJLyoKKwkgKiBXZSBuZWVkIHRvIHJ1biB0aHJvdWdoIHRoZSBjcnRj X2Z1bmNzLT5kaXNhYmxlKCkgZnVuY3Rpb24gaWYgdGhlIGNydGMKKwkgKiBpcyBjdXJyZW50bHkg b24sIGlmIGl0J3MgdHJhbnNpdGlvbmluZyB0byBzZWxmIHJlZnJlc2ggbW9kZSwgb3IgaWYKKwkg KiBpdCdzIGluIHNlbGYgcmVmcmVzaCBtb2RlIGFuZCBuZWVkcyB0byBiZSBmdWxseSBkaXNhYmxl ZC4KKwkgKi8KKwlyZXR1cm4gb2xkX3N0YXRlLT5hY3RpdmUgfHwKKwkgICAgICAgKG9sZF9zdGF0 ZS0+c2VsZl9yZWZyZXNoX2FjdGl2ZSAmJiAhbmV3X3N0YXRlLT5lbmFibGUpIHx8CisJICAgICAg IG5ld19zdGF0ZS0+c2VsZl9yZWZyZXNoX2FjdGl2ZTsKK30KKwogc3RhdGljIHZvaWQKIGRpc2Fi bGVfb3V0cHV0cyhzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LCBzdHJ1Y3QgZHJtX2F0b21pY19zdGF0 ZSAqb2xkX3N0YXRlKQogewpAQCAtOTc0LDcgKzk5OCwxNCBAQCBkaXNhYmxlX291dHB1dHMoc3Ry dWN0IGRybV9kZXZpY2UgKmRldiwgc3RydWN0IGRybV9hdG9taWNfc3RhdGUgKm9sZF9zdGF0ZSkK IAogCQlvbGRfY3J0Y19zdGF0ZSA9IGRybV9hdG9taWNfZ2V0X29sZF9jcnRjX3N0YXRlKG9sZF9z dGF0ZSwgb2xkX2Nvbm5fc3RhdGUtPmNydGMpOwogCi0JCWlmICghb2xkX2NydGNfc3RhdGUtPmFj dGl2ZSB8fAorCQlpZiAobmV3X2Nvbm5fc3RhdGUtPmNydGMpCisJCQluZXdfY3J0Y19zdGF0ZSA9 IGRybV9hdG9taWNfZ2V0X25ld19jcnRjX3N0YXRlKAorCQkJCQkJb2xkX3N0YXRlLAorCQkJCQkJ bmV3X2Nvbm5fc3RhdGUtPmNydGMpOworCQllbHNlCisJCQluZXdfY3J0Y19zdGF0ZSA9IE5VTEw7 CisKKwkJaWYgKCFjcnRjX25lZWRzX2Rpc2FibGUob2xkX2NydGNfc3RhdGUsIG5ld19jcnRjX3N0 YXRlKSB8fAogCQkgICAgIWRybV9hdG9taWNfY3J0Y19uZWVkc19tb2Rlc2V0KG9sZF9jb25uX3N0 YXRlLT5jcnRjLT5zdGF0ZSkpCiAJCQljb250aW51ZTsKIApAQCAtMTAyMCw3ICsxMDUxLDcgQEAg ZGlzYWJsZV9vdXRwdXRzKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYsIHN0cnVjdCBkcm1fYXRvbWlj X3N0YXRlICpvbGRfc3RhdGUpCiAJCWlmICghZHJtX2F0b21pY19jcnRjX25lZWRzX21vZGVzZXQo bmV3X2NydGNfc3RhdGUpKQogCQkJY29udGludWU7CiAKLQkJaWYgKCFvbGRfY3J0Y19zdGF0ZS0+ YWN0aXZlKQorCQlpZiAoIWNydGNfbmVlZHNfZGlzYWJsZShvbGRfY3J0Y19zdGF0ZSwgbmV3X2Ny dGNfc3RhdGUpKQogCQkJY29udGludWU7CiAKIAkJZnVuY3MgPSBjcnRjLT5oZWxwZXJfcHJpdmF0 ZTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9kcm1fYXRvbWljX3N0YXRlX2hlbHBlci5j IGIvZHJpdmVycy9ncHUvZHJtL2RybV9hdG9taWNfc3RhdGVfaGVscGVyLmMKaW5kZXggYWM5Mjlm NjhmZjMxLi5jYTE4MDA4MDQzZTUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9kcm1fYXRv bWljX3N0YXRlX2hlbHBlci5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fYXRvbWljX3N0YXRl X2hlbHBlci5jCkBAIC0xMjgsNiArMTI4LDEwIEBAIHZvaWQgX19kcm1fYXRvbWljX2hlbHBlcl9j cnRjX2R1cGxpY2F0ZV9zdGF0ZShzdHJ1Y3QgZHJtX2NydGMgKmNydGMsCiAJc3RhdGUtPmNvbW1p dCA9IE5VTEw7CiAJc3RhdGUtPmV2ZW50ID0gTlVMTDsKIAlzdGF0ZS0+cGFnZWZsaXBfZmxhZ3Mg PSAwOworCisJLyogU2VsZiByZWZyZXNoIHNob3VsZCBiZSBjYW5jZWxlZCB3aGVuIGEgbmV3IHVw ZGF0ZSBpcyBhdmFpbGFibGUgKi8KKwlzdGF0ZS0+YWN0aXZlID0gZHJtX2F0b21pY19jcnRjX2Vm ZmVjdGl2ZWx5X2FjdGl2ZShzdGF0ZSk7CisJc3RhdGUtPnNlbGZfcmVmcmVzaF9hY3RpdmUgPSBm YWxzZTsKIH0KIEVYUE9SVF9TWU1CT0woX19kcm1fYXRvbWljX2hlbHBlcl9jcnRjX2R1cGxpY2F0 ZV9zdGF0ZSk7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9kcm1fYXRvbWljX3VhcGku YyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fYXRvbWljX3VhcGkuYwppbmRleCBlYTc5N2Q0YzgyZWUu LmE3NWM2MzNmZjBjMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2RybV9hdG9taWNfdWFw aS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fYXRvbWljX3VhcGkuYwpAQCAtNDkwLDcgKzQ5 MCw3IEBAIGRybV9hdG9taWNfY3J0Y19nZXRfcHJvcGVydHkoc3RydWN0IGRybV9jcnRjICpjcnRj LAogCXN0cnVjdCBkcm1fbW9kZV9jb25maWcgKmNvbmZpZyA9ICZkZXYtPm1vZGVfY29uZmlnOwog CiAJaWYgKHByb3BlcnR5ID09IGNvbmZpZy0+cHJvcF9hY3RpdmUpCi0JCSp2YWwgPSBzdGF0ZS0+ YWN0aXZlOworCQkqdmFsID0gZHJtX2F0b21pY19jcnRjX2VmZmVjdGl2ZWx5X2FjdGl2ZShzdGF0 ZSk7CiAJZWxzZSBpZiAocHJvcGVydHkgPT0gY29uZmlnLT5wcm9wX21vZGVfaWQpCiAJCSp2YWwg PSAoc3RhdGUtPm1vZGVfYmxvYikgPyBzdGF0ZS0+bW9kZV9ibG9iLT5iYXNlLmlkIDogMDsKIAll bHNlIGlmIChwcm9wZXJ0eSA9PSBjb25maWctPnByb3BfdnJyX2VuYWJsZWQpCkBAIC03NzIsNyAr NzcyLDEwIEBAIGRybV9hdG9taWNfY29ubmVjdG9yX2dldF9wcm9wZXJ0eShzdHJ1Y3QgZHJtX2Nv bm5lY3RvciAqY29ubmVjdG9yLAogCWlmIChwcm9wZXJ0eSA9PSBjb25maWctPnByb3BfY3J0Y19p ZCkgewogCQkqdmFsID0gKHN0YXRlLT5jcnRjKSA/IHN0YXRlLT5jcnRjLT5iYXNlLmlkIDogMDsK IAl9IGVsc2UgaWYgKHByb3BlcnR5ID09IGNvbmZpZy0+ZHBtc19wcm9wZXJ0eSkgewotCQkqdmFs ID0gY29ubmVjdG9yLT5kcG1zOworCQlpZiAoc3RhdGUtPmNydGMgJiYgc3RhdGUtPmNydGMtPnN0 YXRlLT5zZWxmX3JlZnJlc2hfYWN0aXZlKQorCQkJKnZhbCA9IERSTV9NT0RFX0RQTVNfT047CisJ CWVsc2UKKwkJCSp2YWwgPSBjb25uZWN0b3ItPmRwbXM7CiAJfSBlbHNlIGlmIChwcm9wZXJ0eSA9 PSBjb25maWctPnR2X3NlbGVjdF9zdWJjb25uZWN0b3JfcHJvcGVydHkpIHsKIAkJKnZhbCA9IHN0 YXRlLT50di5zdWJjb25uZWN0b3I7CiAJfSBlbHNlIGlmIChwcm9wZXJ0eSA9PSBjb25maWctPnR2 X2xlZnRfbWFyZ2luX3Byb3BlcnR5KSB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vZHJt X3NlbGZfcmVmcmVzaF9oZWxwZXIuYyBiL2RyaXZlcnMvZ3B1L2RybS9kcm1fc2VsZl9yZWZyZXNo X2hlbHBlci5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uZjQ2ZTc2 MzlkMjc3Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9ncHUvZHJtL2RybV9zZWxmX3JlZnJl c2hfaGVscGVyLmMKQEAgLTAsMCArMSwyMDUgQEAKKy8qIFNQRFgtTGljZW5zZS1JZGVudGlmaWVy OiBNSVQgKi8KKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTkgR29vZ2xlLCBJbmMuCisgKgorICog QXV0aG9yczoKKyAqIFNlYW4gUGF1bCA8c2VhbnBhdWxAY2hyb21pdW0ub3JnPgorICovCisjaW5j bHVkZSA8ZHJtL2RybV9hdG9taWMuaD4KKyNpbmNsdWRlIDxkcm0vZHJtX2F0b21pY19oZWxwZXIu aD4KKyNpbmNsdWRlIDxkcm0vZHJtX2Nvbm5lY3Rvci5oPgorI2luY2x1ZGUgPGRybS9kcm1fY3J0 Yy5oPgorI2luY2x1ZGUgPGRybS9kcm1fZGV2aWNlLmg+CisjaW5jbHVkZSA8ZHJtL2RybV9tb2Rl X2NvbmZpZy5oPgorI2luY2x1ZGUgPGRybS9kcm1fbW9kZXNldF9sb2NrLmg+CisjaW5jbHVkZSA8 ZHJtL2RybV9wcmludC5oPgorI2luY2x1ZGUgPGRybS9kcm1fc2VsZl9yZWZyZXNoX2hlbHBlci5o PgorI2luY2x1ZGUgPGxpbnV4L2JpdG9wcy5oPgorI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KKyNp bmNsdWRlIDxsaW51eC93b3JrcXVldWUuaD4KKworLyoqCisgKiBET0M6IG92ZXJ2aWV3CisgKgor ICogVGhpcyBoZWxwZXIgbGlicmFyeSBwcm92aWRlcyBhbiBlYXN5IHdheSBmb3IgZHJpdmVycyB0 byBsZXZlcmFnZSB0aGUgYXRvbWljCisgKiBmcmFtZXdvcmsgdG8gaW1wbGVtZW50IHBhbmVsIHNl bGYgcmVmcmVzaCAoU1IpIHN1cHBvcnQuIERyaXZlcnMgYXJlCisgKiByZXNwb25zaWJsZSBmb3Ig cmVnaXN0ZXJpbmcgYW5kIHVucmVnaXN0ZXJpbmcgdGhlIFNSIGhlbHBlcnMgb24gbG9hZC91bmxv YWQuCisgKgorICogT25jZSBhIGNydGMgaGFzIGVuYWJsZWQgU1IsIHRoZSBoZWxwZXJzIHdpbGwg bW9uaXRvciBhY3Rpdml0eSBhbmQKKyAqIGNhbGwgYmFjayBpbnRvIHRoZSBkcml2ZXIgdG8gZW5h YmxlL2Rpc2FibGUgU1IgYXMgYXBwcm9wcmlhdGUuIFRoZSBiZXN0IHdheQorICogdG8gdGhpbmsg YWJvdXQgdGhpcyBpcyB0aGF0IGl0J3MgYSBEUE1TIG9uL29mZiByZXF1ZXN0IHdpdGggYSBmbGFn IHNldCBpbgorICogc3RhdGUgdGhhdCB0ZWxscyB5b3UgdG8gZGlzYWJsZS9lbmFibGUgU1Igb24g dGhlIHBhbmVsIGluc3RlYWQgb2YgcG93ZXItCisgKiBjeWNsaW5nIGl0LgorICoKKyAqIERyaXZl cnMgbWF5IGNob29zZSB0byBmdWxseSBkaXNhYmxlIHRoZWlyIGNydGMvZW5jb2Rlci9icmlkZ2Ug aGFyZHdhcmUsIG9yCisgKiB0aGV5IGNhbiB1c2UgdGhlICJzZWxmX3JlZnJlc2hfYWN0aXZlIiBm bGFncyBpbiBjcnRjIHN0YXRlIGlmIHRoZXkgd2FudCB0bworICogZW50ZXIgbG93IHBvd2VyIG1v ZGUgd2l0aG91dCBmdWxsIGRpc2FibGUgKGluIGNhc2UgZnVsbCBkaXNhYmxlL2VuYWJsZSBpcyB0 b28KKyAqIHNsb3cpLgorICoKKyAqIFNSIHdpbGwgYmUgZGVhY3RpdmF0ZWQgaWYgdGhlcmUgYXJl IGFueSBhdG9taWMgdXBkYXRlcyBhZmZlY3RpbmcgdGhlCisgKiBwaXBlIHRoYXQgaXMgaW4gU1Ig bW9kZS4gSWYgYSBjcnRjIGlzIGRyaXZpbmcgbXVsdGlwbGUgY29ubmVjdG9ycywgYWxsCisgKiBj b25uZWN0b3JzIG11c3QgYmUgU1IgYXdhcmUgYW5kIGFsbCB3aWxsIGVudGVyIFNSIG1vZGUuCisg Ki8KKworc3RydWN0IGRybV9zZWxmX3JlZnJlc2hfZGF0YSB7CisJc3RydWN0IGRybV9jcnRjICpj cnRjOworCXN0cnVjdCBkZWxheWVkX3dvcmsgZW50cnlfd29yazsKKwlzdHJ1Y3QgZHJtX2F0b21p Y19zdGF0ZSAqc2F2ZV9zdGF0ZTsKKwl1bnNpZ25lZCBpbnQgZW50cnlfZGVsYXlfbXM7Cit9Owor CitzdGF0aWMgdm9pZCBkcm1fc2VsZl9yZWZyZXNoX2hlbHBlcl9lbnRyeV93b3JrKHN0cnVjdCB3 b3JrX3N0cnVjdCAqd29yaykKK3sKKwlzdHJ1Y3QgZHJtX3NlbGZfcmVmcmVzaF9kYXRhICpzcl9k YXRhID0gY29udGFpbmVyX29mKAorCQkJCXRvX2RlbGF5ZWRfd29yayh3b3JrKSwKKwkJCQlzdHJ1 Y3QgZHJtX3NlbGZfcmVmcmVzaF9kYXRhLCBlbnRyeV93b3JrKTsKKwlzdHJ1Y3QgZHJtX2NydGMg KmNydGMgPSBzcl9kYXRhLT5jcnRjOworCXN0cnVjdCBkcm1fZGV2aWNlICpkZXYgPSBjcnRjLT5k ZXY7CisJc3RydWN0IGRybV9tb2Rlc2V0X2FjcXVpcmVfY3R4IGN0eDsKKwlzdHJ1Y3QgZHJtX2F0 b21pY19zdGF0ZSAqc3RhdGU7CisJc3RydWN0IGRybV9jb25uZWN0b3IgKmNvbm47CisJc3RydWN0 IGRybV9jb25uZWN0b3Jfc3RhdGUgKmNvbm5fc3RhdGU7CisJc3RydWN0IGRybV9jcnRjX3N0YXRl ICpjcnRjX3N0YXRlOworCWludCBpLCByZXQ7CisKKwlkcm1fbW9kZXNldF9hY3F1aXJlX2luaXQo JmN0eCwgMCk7CisKKwlzdGF0ZSA9IGRybV9hdG9taWNfc3RhdGVfYWxsb2MoZGV2KTsKKwlpZiAo IXN0YXRlKSB7CisJCXJldCA9IC1FTk9NRU07CisJCWdvdG8gb3V0OworCX0KKworcmV0cnk6CisJ c3RhdGUtPmFjcXVpcmVfY3R4ID0gJmN0eDsKKworCWNydGNfc3RhdGUgPSBkcm1fYXRvbWljX2dl dF9jcnRjX3N0YXRlKHN0YXRlLCBjcnRjKTsKKwlpZiAoSVNfRVJSKGNydGNfc3RhdGUpKSB7CisJ CXJldCA9IFBUUl9FUlIoY3J0Y19zdGF0ZSk7CisJCWdvdG8gb3V0OworCX0KKworCWlmICghY3J0 Y19zdGF0ZS0+ZW5hYmxlKQorCQlnb3RvIG91dDsKKworCXJldCA9IGRybV9hdG9taWNfYWRkX2Fm ZmVjdGVkX2Nvbm5lY3RvcnMoc3RhdGUsIGNydGMpOworCWlmIChyZXQpCisJCWdvdG8gb3V0Owor CisJZm9yX2VhY2hfbmV3X2Nvbm5lY3Rvcl9pbl9zdGF0ZShzdGF0ZSwgY29ubiwgY29ubl9zdGF0 ZSwgaSkgeworCQlpZiAoIWNvbm5fc3RhdGUtPnNlbGZfcmVmcmVzaF9hd2FyZSkKKwkJCWdvdG8g b3V0OworCX0KKworCWNydGNfc3RhdGUtPmFjdGl2ZSA9IGZhbHNlOworCWNydGNfc3RhdGUtPnNl bGZfcmVmcmVzaF9hY3RpdmUgPSB0cnVlOworCisJcmV0ID0gZHJtX2F0b21pY19jb21taXQoc3Rh dGUpOworCWlmIChyZXQpCisJCWdvdG8gb3V0OworCitvdXQ6CisJaWYgKHJldCA9PSAtRURFQURM SykgeworCQlkcm1fYXRvbWljX3N0YXRlX2NsZWFyKHN0YXRlKTsKKwkJcmV0ID0gZHJtX21vZGVz ZXRfYmFja29mZigmY3R4KTsKKwkJaWYgKCFyZXQpCisJCQlnb3RvIHJldHJ5OworCX0KKworCWRy bV9hdG9taWNfc3RhdGVfcHV0KHN0YXRlKTsKKwlkcm1fbW9kZXNldF9kcm9wX2xvY2tzKCZjdHgp OworCWRybV9tb2Rlc2V0X2FjcXVpcmVfZmluaSgmY3R4KTsKK30KKworLyoqCisgKiBkcm1fc2Vs Zl9yZWZyZXNoX2hlbHBlcl9hbHRlcl9zdGF0ZSAtIEFsdGVycyB0aGUgYXRvbWljIHN0YXRlIGZv ciBTUiBleGl0CisgKiBAc3RhdGU6IHRoZSBzdGF0ZSBjdXJyZW50bHkgYmVpbmcgY2hlY2tlZAor ICoKKyAqIENhbGxlZCBhdCB0aGUgZW5kIG9mIGF0b21pYyBjaGVjay4gVGhpcyBmdW5jdGlvbiBj aGVja3MgdGhlIHN0YXRlIGZvciBmbGFncworICogaW5jb21wYXRpYmxlIHdpdGggc2VsZiByZWZy ZXNoIGV4aXQgYW5kIGNoYW5nZXMgdGhlbS4gVGhpcyBpcyBhIGJpdAorICogZGlzaW5nZW51b3Vz IHNpbmNlIHVzZXJzcGFjZSBpcyBleHBlY3Rpbmcgb25lIHRoaW5nIGFuZCB3ZSdyZSBnaXZpbmcg aXQKKyAqIGFub3RoZXIuIEhvd2V2ZXIgaW4gb3JkZXIgdG8ga2VlcCBzZWxmIHJlZnJlc2ggZW50 aXJlbHkgaGlkZGVuIGZyb20KKyAqIHVzZXJzcGFjZSwgdGhpcyBpcyByZXF1aXJlZC4KKyAqCisg KiBBdCB0aGUgZW5kLCB3ZSBxdWV1ZSB1cCB0aGUgc2VsZiByZWZyZXNoIGVudHJ5IHdvcmsgc28g d2UgY2FuIGVudGVyIFBTUiBhZnRlcgorICogdGhlIGRlc2lyZWQgZGVsYXkuCisgKi8KK3ZvaWQg ZHJtX3NlbGZfcmVmcmVzaF9oZWxwZXJfYWx0ZXJfc3RhdGUoc3RydWN0IGRybV9hdG9taWNfc3Rh dGUgKnN0YXRlKQoreworCXN0cnVjdCBkcm1fY3J0YyAqY3J0YzsKKwlzdHJ1Y3QgZHJtX2NydGNf c3RhdGUgKmNydGNfc3RhdGU7CisJaW50IGk7CisKKwlpZiAoc3RhdGUtPmFzeW5jX3VwZGF0ZSB8 fCAhc3RhdGUtPmFsbG93X21vZGVzZXQpIHsKKwkJZm9yX2VhY2hfb2xkX2NydGNfaW5fc3RhdGUo c3RhdGUsIGNydGMsIGNydGNfc3RhdGUsIGkpIHsKKwkJCWlmIChjcnRjX3N0YXRlLT5zZWxmX3Jl ZnJlc2hfYWN0aXZlKSB7CisJCQkJc3RhdGUtPmFzeW5jX3VwZGF0ZSA9IGZhbHNlOworCQkJCXN0 YXRlLT5hbGxvd19tb2Rlc2V0ID0gdHJ1ZTsKKwkJCQlicmVhazsKKwkJCX0KKwkJfQorCX0KKwor CWZvcl9lYWNoX25ld19jcnRjX2luX3N0YXRlKHN0YXRlLCBjcnRjLCBjcnRjX3N0YXRlLCBpKSB7 CisJCXN0cnVjdCBkcm1fc2VsZl9yZWZyZXNoX2RhdGEgKnNyX2RhdGE7CisKKwkJLyogRG9uJ3Qg dHJpZ2dlciB0aGUgZW50cnkgdGltZXIgd2hlbiB3ZSdyZSBhbHJlYWR5IGluIFNSICovCisJCWlm IChjcnRjX3N0YXRlLT5zZWxmX3JlZnJlc2hfYWN0aXZlKQorCQkJY29udGludWU7CisKKwkJc3Jf ZGF0YSA9IGNydGMtPnNlbGZfcmVmcmVzaF9kYXRhOworCQlpZiAoIXNyX2RhdGEpCisJCQljb250 aW51ZTsKKworCQltb2RfZGVsYXllZF93b3JrKHN5c3RlbV93cSwgJnNyX2RhdGEtPmVudHJ5X3dv cmssCisJCQkJIG1zZWNzX3RvX2ppZmZpZXMoc3JfZGF0YS0+ZW50cnlfZGVsYXlfbXMpKTsKKwl9 Cit9CitFWFBPUlRfU1lNQk9MKGRybV9zZWxmX3JlZnJlc2hfaGVscGVyX2FsdGVyX3N0YXRlKTsK KworLyoqCisgKiBkcm1fc2VsZl9yZWZyZXNoX2hlbHBlcl9yZWdpc3RlciAtIFJlZ2lzdGVycyBz ZWxmIHJlZnJlc2ggaGVscGVycyBmb3IgYSBjcnRjCisgKiBAY3J0YzogdGhlIGNydGMgd2hpY2gg c3VwcG9ydHMgc2VsZiByZWZyZXNoIHN1cHBvcnRlZCBkaXNwbGF5cworICogQGVudHJ5X2RlbGF5 X21zOiBhbW91bnQgb2YgaW5hY3Rpdml0eSB0byB3YWl0IGJlZm9yZSBlbnRlcmluZyBzZWxmIHJl ZnJlc2gKKyAqLworaW50IGRybV9zZWxmX3JlZnJlc2hfaGVscGVyX3JlZ2lzdGVyKHN0cnVjdCBk cm1fY3J0YyAqY3J0YywKKwkJCQkgICAgIHVuc2lnbmVkIGludCBlbnRyeV9kZWxheV9tcykKK3sK KwlzdHJ1Y3QgZHJtX3NlbGZfcmVmcmVzaF9kYXRhICpzcl9kYXRhID0gY3J0Yy0+c2VsZl9yZWZy ZXNoX2RhdGE7CisKKwkvKiBIZWxwZXIgaXMgYWxyZWFkeSByZWdpc3RlcmVkICovCisJaWYgKFdB Uk5fT04oc3JfZGF0YSkpCisJCXJldHVybiAtRUlOVkFMOworCisJc3JfZGF0YSA9IGt6YWxsb2Mo c2l6ZW9mKCpzcl9kYXRhKSwgR0ZQX0tFUk5FTCk7CisJaWYgKCFzcl9kYXRhKQorCQlyZXR1cm4g LUVOT01FTTsKKworCUlOSVRfREVMQVlFRF9XT1JLKCZzcl9kYXRhLT5lbnRyeV93b3JrLAorCQkJ ICBkcm1fc2VsZl9yZWZyZXNoX2hlbHBlcl9lbnRyeV93b3JrKTsKKwlzcl9kYXRhLT5lbnRyeV9k ZWxheV9tcyA9IGVudHJ5X2RlbGF5X21zOworCXNyX2RhdGEtPmNydGMgPSBjcnRjOworCisJY3J0 Yy0+c2VsZl9yZWZyZXNoX2RhdGEgPSBzcl9kYXRhOworCXJldHVybiAwOworfQorRVhQT1JUX1NZ TUJPTChkcm1fc2VsZl9yZWZyZXNoX2hlbHBlcl9yZWdpc3Rlcik7CisKKy8qKgorICogZHJtX3Nl bGZfcmVmcmVzaF9oZWxwZXJfdW5yZWdpc3RlciAtIFVucmVnaXN0ZXJzIHNlbGYgcmVmcmVzaCBo ZWxwZXJzCisgKiBAY3J0YzogdGhlIGNydGMgdG8gdW5yZWdpc3RlcgorICovCit2b2lkIGRybV9z ZWxmX3JlZnJlc2hfaGVscGVyX3VucmVnaXN0ZXIoc3RydWN0IGRybV9jcnRjICpjcnRjKQorewor CXN0cnVjdCBkcm1fc2VsZl9yZWZyZXNoX2RhdGEgKnNyX2RhdGEgPSBjcnRjLT5zZWxmX3JlZnJl c2hfZGF0YTsKKworCS8qIEhlbHBlciBpcyBhbHJlYWR5IHVucmVnaXN0ZXJlZCAqLworCWlmIChz cl9kYXRhKQorCQlyZXR1cm47CisKKwljcnRjLT5zZWxmX3JlZnJlc2hfZGF0YSA9IE5VTEw7CisK KwljYW5jZWxfZGVsYXllZF93b3JrX3N5bmMoJnNyX2RhdGEtPmVudHJ5X3dvcmspOworCWtmcmVl KHNyX2RhdGEpOworfQorRVhQT1JUX1NZTUJPTChkcm1fc2VsZl9yZWZyZXNoX2hlbHBlcl91bnJl Z2lzdGVyKTsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvZHJtL2RybV9hdG9taWMuaCBiL2luY2x1ZGUv ZHJtL2RybV9hdG9taWMuaAppbmRleCA4MjRhNWVkNGUyMTYuLjFlOWNhYjFkYTk3YSAxMDA2NDQK LS0tIGEvaW5jbHVkZS9kcm0vZHJtX2F0b21pYy5oCisrKyBiL2luY2x1ZGUvZHJtL2RybV9hdG9t aWMuaApAQCAtOTQ0LDQgKzk0NCwxOSBAQCBkcm1fYXRvbWljX2NydGNfbmVlZHNfbW9kZXNldChj b25zdCBzdHJ1Y3QgZHJtX2NydGNfc3RhdGUgKnN0YXRlKQogCSAgICAgICBzdGF0ZS0+Y29ubmVj dG9yc19jaGFuZ2VkOwogfQogCisvKioKKyAqIGRybV9hdG9taWNfY3J0Y19lZmZlY3RpdmVseV9h Y3RpdmUgLSBjb21wdXRlIHdoZXRoZXIgY3J0YyBpcyBhY3R1YWxseSBhY3RpdmUKKyAqIEBzdGF0 ZTogJmRybV9jcnRjX3N0YXRlIGZvciB0aGUgQ1JUQworICoKKyAqIFdoZW4gaW4gc2VsZiByZWZy ZXNoIG1vZGUsIHRoZSBjcnRjX3N0YXRlLT5hY3RpdmUgdmFsdWUgd2lsbCBiZSBmYWxzZSwgc2lu Y2UKKyAqIHRoZSBjcnRjIGlzIG9mZi4gSG93ZXZlciBpbiBzb21lIGNhc2VzIHdlJ3JlIGludGVy ZXN0ZWQgaW4gd2hldGhlciB0aGUgY3J0YworICogaXMgYWN0aXZlLCBvciBlZmZlY3RpdmVseSBh Y3RpdmUgKGllOiBpdCdzIGNvbm5lY3RlZCB0byBhbiBhY3RpdmUgZGlzcGxheSkuCisgKiBJbiB0 aGVzZSBjYXNlcywgdXNlIHRoaXMgZnVuY3Rpb24gaW5zdGVhZCBvZiBqdXN0IGNoZWNraW5nIGFj dGl2ZS4KKyAqLworc3RhdGljIGlubGluZSBib29sCitkcm1fYXRvbWljX2NydGNfZWZmZWN0aXZl bHlfYWN0aXZlKGNvbnN0IHN0cnVjdCBkcm1fY3J0Y19zdGF0ZSAqc3RhdGUpCit7CisJcmV0dXJu IHN0YXRlLT5hY3RpdmUgfHwgc3RhdGUtPnNlbGZfcmVmcmVzaF9hY3RpdmU7Cit9CisKICNlbmRp ZiAvKiBEUk1fQVRPTUlDX0hfICovCmRpZmYgLS1naXQgYS9pbmNsdWRlL2RybS9kcm1fY29ubmVj dG9yLmggYi9pbmNsdWRlL2RybS9kcm1fY29ubmVjdG9yLmgKaW5kZXggMDJhMTMxMjAyYWRkLi45 YjQwZWI2ZjBlZjQgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvZHJtL2RybV9jb25uZWN0b3IuaAorKysg Yi9pbmNsdWRlL2RybS9kcm1fY29ubmVjdG9yLmgKQEAgLTUzOSw2ICs1MzksMjAgQEAgc3RydWN0 IGRybV9jb25uZWN0b3Jfc3RhdGUgewogCS8qKiBAdHY6IFRWIGNvbm5lY3RvciBzdGF0ZSAqLwog CXN0cnVjdCBkcm1fdHZfY29ubmVjdG9yX3N0YXRlIHR2OwogCisJLyoqCisJICogQHNlbGZfcmVm cmVzaF9hd2FyZToKKwkgKgorCSAqIFRoaXMgdHJhY2tzIHdoZXRoZXIgYSBjb25uZWN0b3IgaXMg YXdhcmUgb2YgdGhlIHNlbGYgcmVmcmVzaCBzdGF0ZS4KKwkgKiBJdCBzaG91bGQgYmUgc2V0IHRv IHRydWUgZm9yIHRob3NlIGNvbm5lY3RvciBpbXBsZW1lbnRhdGlvbnMgd2hpY2gKKwkgKiB1bmRl cnN0YW5kIHRoZSBzZWxmIHJlZnJlc2ggc3RhdGUuIFRoaXMgaXMgbmVlZGVkIHNpbmNlIHRoZSBj cnRjCisJICogcmVnaXN0ZXJzIHRoZSBzZWxmIHJlZnJlc2ggaGVscGVycyBhbmQgaXQgZG9lc24n dCBrbm93IGlmIHRoZQorCSAqIGNvbm5lY3RvcnMgZG93bnN0cmVhbSBoYXZlIGltcGxlbWVudGVk IHNlbGYgcmVmcmVzaCBlbnRyeS9leGl0LgorCSAqCisJICogRHJpdmVycyBzaG91bGQgc2V0IHRo aXMgdG8gdHJ1ZSBpbiBhdG9taWNfY2hlY2sgaWYgdGhleSBrbm93IGhvdyB0bworCSAqIGhhbmRs ZSBzZWxmX3JlZnJlc2ggcmVxdWVzdHMuCisJICovCisJYm9vbCBzZWxmX3JlZnJlc2hfYXdhcmU7 CisKIAkvKioKIAkgKiBAcGljdHVyZV9hc3BlY3RfcmF0aW86IENvbm5lY3RvciBwcm9wZXJ0eSB0 byBjb250cm9sIHRoZQogCSAqIEhETUkgaW5mb2ZyYW1lIGFzcGVjdCByYXRpbyBzZXR0aW5nLgpk aWZmIC0tZ2l0IGEvaW5jbHVkZS9kcm0vZHJtX2NydGMuaCBiL2luY2x1ZGUvZHJtL2RybV9jcnRj LmgKaW5kZXggNThhZDk4M2Q3Y2Q2Li42N2UzMDc1YTg3ODQgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUv ZHJtL2RybV9jcnRjLmgKKysrIGIvaW5jbHVkZS9kcm0vZHJtX2NydGMuaApAQCAtNTMsNiArNTMs NyBAQCBzdHJ1Y3QgZHJtX21vZGVfc2V0Owogc3RydWN0IGRybV9maWxlOwogc3RydWN0IGRybV9j bGlwX3JlY3Q7CiBzdHJ1Y3QgZHJtX3ByaW50ZXI7CitzdHJ1Y3QgZHJtX3NlbGZfcmVmcmVzaF9k YXRhOwogc3RydWN0IGRldmljZV9ub2RlOwogc3RydWN0IGRtYV9mZW5jZTsKIHN0cnVjdCBlZGlk OwpAQCAtMjk5LDYgKzMwMCwxNyBAQCBzdHJ1Y3QgZHJtX2NydGNfc3RhdGUgewogCSAqLwogCWJv b2wgdnJyX2VuYWJsZWQ7CiAKKwkvKioKKwkgKiBAc2VsZl9yZWZyZXNoX2FjdGl2ZToKKwkgKgor CSAqIFVzZWQgYnkgdGhlIHNlbGYgcmVmcmVzaCBoZWxwZXJzIHRvIGRlbm90ZSB3aGVuIGEgc2Vs ZiByZWZyZXNoCisJICogdHJhbnNpdGlvbiBpcyBvY2N1cmluZy4gVGhpcyB3aWxsIGJlIHNldCBv biBlbmFibGUvZGlzYWJsZSBjYWxsYmFja3MKKwkgKiB3aGVuIHNlbGYgcmVmcmVzaCBpcyBiZWlu ZyBlbmFibGVkIG9yIGRpc2FibGVkLiBJbiBzb21lIGNhc2VzLCBpdCBtYXkKKwkgKiBub3QgYmUg ZGVzaXJhYmxlIHRvIGZ1bGx5IHNodXQgb2ZmIHRoZSBjcnRjIGR1cmluZyBzZWxmIHJlZnJlc2gu CisJICogQ1JUQydzIGNhbiBpbnNwZWN0IHRoaXMgZmxhZyBhbmQgZGV0ZXJtaW5lIHRoZSBiZXN0 IGNvdXJzZSBvZiBhY3Rpb24uCisJICovCisJYm9vbCBzZWxmX3JlZnJlc2hfYWN0aXZlOworCiAJ LyoqCiAJICogQGV2ZW50OgogCSAqCkBAIC0xMDg3LDYgKzEwOTksMTMgQEAgc3RydWN0IGRybV9j cnRjIHsKIAkgKiBUaGUgbmFtZSBvZiB0aGUgQ1JUQydzIGZlbmNlIHRpbWVsaW5lLgogCSAqLwog CWNoYXIgdGltZWxpbmVfbmFtZVszMl07CisKKwkvKioKKwkgKiBAc2VsZl9yZWZyZXNoX2RhdGE6 IEhvbGRzIHRoZSBzdGF0ZSBmb3IgdGhlIHNlbGYgcmVmcmVzaCBoZWxwZXJzCisJICoKKwkgKiBJ bml0aWFsaXplZCB2aWEgZHJtX3NlbGZfcmVmcmVzaF9oZWxwZXJfcmVnaXN0ZXIoKS4KKwkgKi8K KwlzdHJ1Y3QgZHJtX3NlbGZfcmVmcmVzaF9kYXRhICpzZWxmX3JlZnJlc2hfZGF0YTsKIH07CiAK IC8qKgpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9kcm0vZHJtX3NlbGZfcmVmcmVzaF9oZWxwZXIuaCBi L2luY2x1ZGUvZHJtL2RybV9zZWxmX3JlZnJlc2hfaGVscGVyLmgKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMDAwMDAwLi5lZmIyZTZlMzI0OWYKLS0tIC9kZXYvbnVsbAorKysgYi9p bmNsdWRlL2RybS9kcm1fc2VsZl9yZWZyZXNoX2hlbHBlci5oCkBAIC0wLDAgKzEsMjIgQEAKKy8q IFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBNSVQgKi8KKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIw MTkgR29vZ2xlLCBJbmMuCisgKgorICogQXV0aG9yczoKKyAqIFNlYW4gUGF1bCA8c2VhbnBhdWxA Y2hyb21pdW0ub3JnPgorICovCisjaWZuZGVmIERSTV9TRUxGX1JFRlJFU0hfSEVMUEVSX0hfCisj ZGVmaW5lIERSTV9TRUxGX1JFRlJFU0hfSEVMUEVSX0hfCisKK3N0cnVjdCBkcm1fYXRvbWljX3N0 YXRlOworc3RydWN0IGRybV9jb25uZWN0b3I7CitzdHJ1Y3QgZHJtX2RldmljZTsKK3N0cnVjdCBk cm1fbW9kZXNldF9hY3F1aXJlX2N0eDsKKwordm9pZCBkcm1fc2VsZl9yZWZyZXNoX2hlbHBlcl9h bHRlcl9zdGF0ZShzdHJ1Y3QgZHJtX2F0b21pY19zdGF0ZSAqc3RhdGUpOworCitpbnQgZHJtX3Nl bGZfcmVmcmVzaF9oZWxwZXJfcmVnaXN0ZXIoc3RydWN0IGRybV9jcnRjICpjcnRjLAorCQkJCSAg ICAgdW5zaWduZWQgaW50IGVudHJ5X2RlbGF5X21zKTsKKwordm9pZCBkcm1fc2VsZl9yZWZyZXNo X2hlbHBlcl91bnJlZ2lzdGVyKHN0cnVjdCBkcm1fY3J0YyAqY3J0Yyk7CisjZW5kaWYKLS0gClNl YW4gUGF1bCwgU29mdHdhcmUgRW5naW5lZXIsIEdvb2dsZSAvIENocm9taXVtIE9TCgpfX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGlu ZyBsaXN0CmRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVl ZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9kcmktZGV2ZWw=