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.7 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=unavailable 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 CCD74C432C0 for ; Mon, 18 Nov 2019 20:07:06 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 95A892231B for ; Mon, 18 Nov 2019 20:07:06 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="kS9P13J1" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727436AbfKRUHB (ORCPT ); Mon, 18 Nov 2019 15:07:01 -0500 Received: from mail-lj1-f196.google.com ([209.85.208.196]:40442 "EHLO mail-lj1-f196.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727114AbfKRUFq (ORCPT ); Mon, 18 Nov 2019 15:05:46 -0500 Received: by mail-lj1-f196.google.com with SMTP id q2so20470511ljg.7; Mon, 18 Nov 2019 12:05:43 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=wKn468nr2i6h8sTr6Rg9z7srsP/1nTrJr4onSkFRhrM=; b=kS9P13J1QW1JVGirOuxzkZSSrTkvRd5gz+pkBjDezAm+TFqLpj76qjEcs+6hWwQsIc C3d3bq88qiGwpN8gW+c86t9UQweQ8KDB1DI3rj624TGhs5pY11X8EdeqJYpTPplAEg4c g848E01m3vPV2dSRqN/GLIAUvjEKL3+nNCUjPTNhslpoRweJiCOXUgClzhb7oVtN6e2j 6m8ft1GrH8i60pJ0z4G5WlvRexuobXMHT+SZZCsHB8ow9gysf6iLORM094qTBqkBHfez zQ3XvoM1lEnVktiz+dv2ruNKF3Y22i1QeHlBf8nu0qVxoq0ztFASzDrTZ7KzGdKH2QYz +V1A== 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=wKn468nr2i6h8sTr6Rg9z7srsP/1nTrJr4onSkFRhrM=; b=IVpJ+Ibkxd+fHBftYNrA6kdwmZwIw7hR4C8v/jCD+wNdMJMFwjNf2Y6Zjf3XPKsYcP 7u+Ju5E/avYo53g+RqndvOlXP1K3LxRsDPEZIGLWIdmHPvExhmOAkh+98f/q8WP6UZjq QKDcjSjlhgph7IrV3dQb7MX24+j8E0B9Jr6BFT17dS6HtTTaGpPfxLVS4Sla1XJXAlrA RO6n/CDkLrTvIiqw8wFaBewqgXEDzeL8Berx3AH81vRbNZONS5S1gijDi9suSwuiQUNV pwMHsktmVm3n1cQ19Rg5sgb/TXBPcBRxo8HvBjB14b6ehZE3oYh82wlQLAI5SXn7cTPc 9GrQ== X-Gm-Message-State: APjAAAXOpcq7rEw96WEjdKC/g9g7UdNIpnynjxVYpZMcqyoHA+mU38gs pNiw7OdT9U3CQacADfm3Hdg= X-Google-Smtp-Source: APXvYqx0QO3LCy1M9cMqDrlT+1ew03n5115y0K6a1DhFS61aLBr5yTQ3ed/bTYOiow3sG8icwiTP0g== X-Received: by 2002:a2e:5451:: with SMTP id y17mr915326ljd.98.1574107542862; Mon, 18 Nov 2019 12:05:42 -0800 (PST) Received: from localhost.localdomain (79-139-233-37.dynamic.spd-mgts.ru. [79.139.233.37]) by smtp.gmail.com with ESMTPSA id j23sm9166942lji.41.2019.11.18.12.05.41 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 18 Nov 2019 12:05:42 -0800 (PST) From: Dmitry Osipenko To: Thierry Reding , Jonathan Hunter , Peter De Schrijver , Mikko Perttunen , Georgi Djakov , Rob Herring Cc: linux-tegra@vger.kernel.org, linux-pm@vger.kernel.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, devicetree@vger.kernel.org Subject: [PATCH v1 12/29] interconnect: Add memory interconnection providers for NVIDIA Tegra SoCs Date: Mon, 18 Nov 2019 23:02:30 +0300 Message-Id: <20191118200247.3567-13-digetx@gmail.com> X-Mailer: git-send-email 2.23.0 In-Reply-To: <20191118200247.3567-1-digetx@gmail.com> References: <20191118200247.3567-1-digetx@gmail.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Sender: linux-pm-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-pm@vger.kernel.org All NVIDIA Tegra SoCs have identical topology in regards to memory interconnection between memory clients and memory controllers. The memory controller (MC) and external memory controller (EMC) are providing memory clients with required memory bandwidth. The memory controller performs arbitration between memory clients, while the external memory controller transfers data from/to DRAM and pipes that data from/to memory controller. Memory controller interconnect provider aggregates bandwidth requests from memory clients and sends the aggregated request to EMC provider that scales DRAM frequency in order to satisfy the bandwidth requirement. Memory controller provider could adjust hardware configuration for a more optimal arbitration depending on bandwidth requirements from memory clients, but this is unimplemented for now. Signed-off-by: Dmitry Osipenko --- drivers/interconnect/Kconfig | 1 + drivers/interconnect/Makefile | 1 + drivers/interconnect/tegra/Kconfig | 6 + drivers/interconnect/tegra/Makefile | 4 + drivers/interconnect/tegra/tegra-icc-emc.c | 138 +++++++++++++++++++++ drivers/interconnect/tegra/tegra-icc-mc.c | 130 +++++++++++++++++++ include/soc/tegra/mc.h | 26 ++++ 7 files changed, 306 insertions(+) create mode 100644 drivers/interconnect/tegra/Kconfig create mode 100644 drivers/interconnect/tegra/Makefile create mode 100644 drivers/interconnect/tegra/tegra-icc-emc.c create mode 100644 drivers/interconnect/tegra/tegra-icc-mc.c diff --git a/drivers/interconnect/Kconfig b/drivers/interconnect/Kconfig index bfa4ca3ab7a9..b11ca09665bb 100644 --- a/drivers/interconnect/Kconfig +++ b/drivers/interconnect/Kconfig @@ -12,5 +12,6 @@ menuconfig INTERCONNECT if INTERCONNECT source "drivers/interconnect/qcom/Kconfig" +source "drivers/interconnect/tegra/Kconfig" endif diff --git a/drivers/interconnect/Makefile b/drivers/interconnect/Makefile index 28f2ab0824d5..a37d419e262c 100644 --- a/drivers/interconnect/Makefile +++ b/drivers/interconnect/Makefile @@ -4,3 +4,4 @@ icc-core-objs := core.o obj-$(CONFIG_INTERCONNECT) += icc-core.o obj-$(CONFIG_INTERCONNECT_QCOM) += qcom/ +obj-$(CONFIG_INTERCONNECT_TEGRA) += tegra/ diff --git a/drivers/interconnect/tegra/Kconfig b/drivers/interconnect/tegra/Kconfig new file mode 100644 index 000000000000..b724781da71e --- /dev/null +++ b/drivers/interconnect/tegra/Kconfig @@ -0,0 +1,6 @@ +# SPDX-License-Identifier: GPL-2.0-only +config INTERCONNECT_TEGRA + bool "NVIDIA Tegra interconnect drivers" + depends on ARCH_TEGRA || COMPILE_TEST + help + Say Y here to enable support for NVIDIA Tegra interconnect drivers. diff --git a/drivers/interconnect/tegra/Makefile b/drivers/interconnect/tegra/Makefile new file mode 100644 index 000000000000..74ff2e53dbdc --- /dev/null +++ b/drivers/interconnect/tegra/Makefile @@ -0,0 +1,4 @@ +# SPDX-License-Identifier: GPL-2.0 + +obj-$(CONFIG_INTERCONNECT_TEGRA) += tegra-icc-mc.o +obj-$(CONFIG_INTERCONNECT_TEGRA) += tegra-icc-emc.o diff --git a/drivers/interconnect/tegra/tegra-icc-emc.c b/drivers/interconnect/tegra/tegra-icc-emc.c new file mode 100644 index 000000000000..b594ce811153 --- /dev/null +++ b/drivers/interconnect/tegra/tegra-icc-emc.c @@ -0,0 +1,138 @@ +// SPDX-License-Identifier: GPL-2.0+ +/* + * Author: Dmitry Osipenko + * Copyright (C) 2019 GRATE-DRIVER project + */ + +#include + +#include +#include +#include +#include +#include +#include + +#include + +struct tegra_emc_provider { + struct icc_provider provider; + struct clk *clk; + unsigned int dram_data_bus_width_bytes; +}; + +static inline struct tegra_emc_provider * +to_tegra_emc_provider(struct icc_provider *provider) +{ + return container_of(provider, struct tegra_emc_provider, provider); +} + +static struct icc_node * +tegra_emc_of_icc_xlate_onecell(struct of_phandle_args *spec, void *data) +{ + struct icc_provider *provider = data; + struct icc_node *node; + + list_for_each_entry(node, &provider->nodes, node_list) { + if (node->id == spec->args[0]) + return node; + } + + return ERR_PTR(-EINVAL); +} + +static int tegra_emc_icc_set(struct icc_node *src, struct icc_node *dst) +{ + struct tegra_emc_provider *emc = to_tegra_emc_provider(dst->provider); + unsigned long long rate = icc_units_to_bps(dst->avg_bw); + unsigned int ddr = 2; + int err; + + do_div(rate, ddr * emc->dram_data_bus_width_bytes); + rate = min_t(u64, rate, U32_MAX); + + err = clk_set_min_rate(emc->clk, rate); + if (err) + return err; + + err = clk_set_rate(emc->clk, rate); + if (err) + return err; + + return 0; +} + +static int tegra_emc_icc_aggregate(struct icc_node *node, + u32 tag, u32 avg_bw, u32 peak_bw, + u32 *agg_avg, u32 *agg_peak) +{ + *agg_avg = min((u64)avg_bw + (*agg_avg), (u64)U32_MAX); + *agg_peak = max(*agg_peak, peak_bw); + + return 0; +} + +int tegra_icc_emc_setup_interconnect(struct device *emc_dev, + unsigned int dram_data_bus_width_bytes) +{ + struct tegra_emc_provider *emc; + struct icc_node *node, *tmp; + int err; + + emc = devm_kzalloc(emc_dev, sizeof(*emc), GFP_KERNEL); + if (!emc) + return -ENOMEM; + + emc->clk = devm_clk_get(emc_dev, "emc"); + err = PTR_ERR_OR_ZERO(emc->clk); + if (err) + return err; + + emc->dram_data_bus_width_bytes = dram_data_bus_width_bytes; + + emc->provider.dev = emc_dev; + emc->provider.set = tegra_emc_icc_set; + emc->provider.data = &emc->provider; + emc->provider.xlate = tegra_emc_of_icc_xlate_onecell; + emc->provider.aggregate = tegra_emc_icc_aggregate; + + err = icc_provider_add(&emc->provider); + if (err) + return err; + + /* create External Memory Controller node */ + node = icc_node_create(TEGRA_ICC_EMC); + err = PTR_ERR_OR_ZERO(node); + if (err) + goto del_provider; + + node->name = "EMC"; + icc_node_add(node, &emc->provider); + + /* link External Memory Controller with External Memory */ + err = icc_link_create(node, TEGRA_ICC_EMEM); + if (err) + goto destroy_nodes; + + /* create External Memory node */ + node = icc_node_create(TEGRA_ICC_EMEM); + err = PTR_ERR_OR_ZERO(node); + if (err) + goto destroy_nodes; + + node->name = "EMEM"; + icc_node_add(node, &emc->provider); + + return 0; + +destroy_nodes: + list_for_each_entry_safe(node, tmp, &emc->provider.nodes, node_list) { + icc_node_del(node); + icc_node_destroy(node->id); + } + +del_provider: + icc_provider_del(&emc->provider); + + return err; +} diff --git a/drivers/interconnect/tegra/tegra-icc-mc.c b/drivers/interconnect/tegra/tegra-icc-mc.c new file mode 100644 index 000000000000..f1ff8f98def3 --- /dev/null +++ b/drivers/interconnect/tegra/tegra-icc-mc.c @@ -0,0 +1,130 @@ +// SPDX-License-Identifier: GPL-2.0+ +/* + * Author: Dmitry Osipenko + * Copyright (C) 2019 GRATE-DRIVER project + */ + +#include + +#include +#include +#include +#include + +#include + +static struct icc_node * +tegra_mc_of_icc_xlate_onecell(struct of_phandle_args *spec, void *data) +{ + struct icc_provider *provider = data; + struct icc_node *node; + + list_for_each_entry(node, &provider->nodes, node_list) { + if (node->id == spec->args[0]) + return node; + } + + return ERR_PTR(-EINVAL); +} + +static int tegra_mc_icc_set(struct icc_node *src, struct icc_node *dst) +{ + return 0; +} + +static int tegra_mc_icc_aggregate(struct icc_node *node, + u32 tag, u32 avg_bw, u32 peak_bw, + u32 *agg_avg, u32 *agg_peak) +{ + *agg_avg = min((u64)avg_bw + (*agg_avg), (u64)U32_MAX); + *agg_peak = max(*agg_peak, peak_bw); + + return 0; +} + +/* + * Memory Controller (MC) has few Memory Clients that are issuing memory + * bandwidth allocation requests to the MC interconnect provider. The MC + * provider aggregates the requests and then sends the aggregated request + * up to the External Memory Controller (EMC) interconnect provider which + * re-configures hardware interface to External Memory (EMEM) in accordance + * to the required bandwidth. + * + * Memory interconnect topology: + * + * +----+ + * +-----+ | | + * | GPU +---->+ | + * +-----+ | | + * | | +-----+ +------+ + * ... | MC +---->+ EMC +---->+ EMEM | + * | | +-----+ +------+ + * +------+ | | + * | DISP +---->+ | + * +------+ | | + * +----+ + */ +int tegra_icc_mc_setup_interconnect(struct tegra_mc *mc) +{ + struct icc_provider *provider; + struct icc_node *node, *tmp; + unsigned int i; + int err; + + provider = devm_kzalloc(mc->dev, sizeof(*provider), GFP_KERNEL); + if (!provider) + return -ENOMEM; + + provider->dev = mc->dev; + provider->set = tegra_mc_icc_set; + provider->data = provider; + provider->xlate = tegra_mc_of_icc_xlate_onecell; + provider->aggregate = tegra_mc_icc_aggregate; + + err = icc_provider_add(provider); + if (err) + return err; + + /* create Memory Controller node */ + node = icc_node_create(TEGRA_ICC_MC); + err = PTR_ERR_OR_ZERO(node); + if (err) + goto del_provider; + + node->name = "MC"; + icc_node_add(node, provider); + + /* link Memory Controller with External Memory Controller */ + err = icc_link_create(node, TEGRA_ICC_EMC); + if (err) + goto destroy_nodes; + + for (i = 0; i < mc->soc->num_icc_nodes; i++) { + /* create MC client node */ + node = icc_node_create(mc->soc->icc_nodes[i].id); + err = PTR_ERR_OR_ZERO(node); + if (err) + goto destroy_nodes; + + node->name = mc->soc->icc_nodes[i].name; + icc_node_add(node, provider); + + /* link Memory Client with Memory Controller */ + err = icc_link_create(node, TEGRA_ICC_MC); + if (err) + goto destroy_nodes; + } + + return 0; + +destroy_nodes: + list_for_each_entry_safe(node, tmp, &provider->nodes, node_list) { + icc_node_del(node); + icc_node_destroy(node->id); + } + +del_provider: + icc_provider_del(provider); + + return err; +} diff --git a/include/soc/tegra/mc.h b/include/soc/tegra/mc.h index 1238e35653d1..593954324259 100644 --- a/include/soc/tegra/mc.h +++ b/include/soc/tegra/mc.h @@ -141,6 +141,11 @@ struct tegra_mc_reset_ops { const struct tegra_mc_reset *rst); }; +struct tegra_mc_icc_node { + const char *name; + unsigned int id; +}; + struct tegra_mc_soc { const struct tegra_mc_client *clients; unsigned int num_clients; @@ -160,6 +165,9 @@ struct tegra_mc_soc { const struct tegra_mc_reset_ops *reset_ops; const struct tegra_mc_reset *resets; unsigned int num_resets; + + const struct tegra_mc_icc_node *icc_nodes; + unsigned int num_icc_nodes; }; struct tegra_mc { @@ -184,4 +192,22 @@ struct tegra_mc { int tegra_mc_write_emem_configuration(struct tegra_mc *mc, unsigned long rate); unsigned int tegra_mc_get_emem_device_count(struct tegra_mc *mc); +#ifdef CONFIG_INTERCONNECT_TEGRA +int tegra_icc_mc_setup_interconnect(struct tegra_mc *mc); +int tegra_icc_emc_setup_interconnect(struct device *emc_dev, + unsigned int dram_data_bus_width_bytes); +#else +static inline int tegra_icc_mc_setup_interconnect(struct tegra_mc *mc); +{ + return 0; +} + +static inline int +tegra_icc_emc_setup_interconnect(struct device *emc_dev, + unsigned int dram_data_bus_width_bytes) +{ + return 0; +} +#endif + #endif /* __SOC_TEGRA_MC_H__ */ -- 2.23.0 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.5 required=3.0 tests=DKIM_ADSP_CUSTOM_MED, FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM,HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,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 E98FBC432C0 for ; Tue, 19 Nov 2019 08:05:15 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id CAE84222EF for ; Tue, 19 Nov 2019 08:05:15 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org CAE84222EF Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=gmail.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=dri-devel-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 2A1306EBBA; Tue, 19 Nov 2019 08:04:31 +0000 (UTC) Received: from mail-lj1-x244.google.com (mail-lj1-x244.google.com [IPv6:2a00:1450:4864:20::244]) by gabe.freedesktop.org (Postfix) with ESMTPS id 9220F6E82A for ; Mon, 18 Nov 2019 20:05:44 +0000 (UTC) Received: by mail-lj1-x244.google.com with SMTP id d5so20442935ljl.4 for ; Mon, 18 Nov 2019 12:05:44 -0800 (PST) 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=wKn468nr2i6h8sTr6Rg9z7srsP/1nTrJr4onSkFRhrM=; b=j99rQvUPTJHIyXBrM45xtzFQVnaoSsQuNXk5aB9sT/bgJhJ500l24FD4fgW6nHp19p jOQQuqptFy6wLcSkIYL0RLkeMn4A1muoxVfEBUkX8bDhm0yCFGfymr29Vzyl0PB45DcJ DkeemPvtVi00iF8js0I8tGFPr0DzevUFKy0tru/9kIWB+LktrFQcuZ/hOEyCw0j7+icE T+N2MxUqFcGLjjnuO4Lul22BieYkKM+kjKfyHEUhbHFcL9sCaYKMVzPN6Byls2MbQxdR BOMQz3H2dGmP3yIj5dZ5h4HV2RCpd7WdXz5YSipwdpU79c5+0uIoWs8DK0+74snoX8Do qJZw== X-Gm-Message-State: APjAAAXeu0LqGcnNxBAz5TqInSWn8cX3bAjq2gIuUpxfJQJ31lNZpLGu Co99rhvIzahCPsgMTEJ0DLk= X-Google-Smtp-Source: APXvYqx0QO3LCy1M9cMqDrlT+1ew03n5115y0K6a1DhFS61aLBr5yTQ3ed/bTYOiow3sG8icwiTP0g== X-Received: by 2002:a2e:5451:: with SMTP id y17mr915326ljd.98.1574107542862; Mon, 18 Nov 2019 12:05:42 -0800 (PST) Received: from localhost.localdomain (79-139-233-37.dynamic.spd-mgts.ru. [79.139.233.37]) by smtp.gmail.com with ESMTPSA id j23sm9166942lji.41.2019.11.18.12.05.41 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 18 Nov 2019 12:05:42 -0800 (PST) From: Dmitry Osipenko To: Thierry Reding , Jonathan Hunter , Peter De Schrijver , Mikko Perttunen , Georgi Djakov , Rob Herring Subject: [PATCH v1 12/29] interconnect: Add memory interconnection providers for NVIDIA Tegra SoCs Date: Mon, 18 Nov 2019 23:02:30 +0300 Message-Id: <20191118200247.3567-13-digetx@gmail.com> X-Mailer: git-send-email 2.23.0 In-Reply-To: <20191118200247.3567-1-digetx@gmail.com> References: <20191118200247.3567-1-digetx@gmail.com> MIME-Version: 1.0 X-Mailman-Approved-At: Tue, 19 Nov 2019 08:04:07 +0000 X-Mailman-Original-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=wKn468nr2i6h8sTr6Rg9z7srsP/1nTrJr4onSkFRhrM=; b=kS9P13J1QW1JVGirOuxzkZSSrTkvRd5gz+pkBjDezAm+TFqLpj76qjEcs+6hWwQsIc C3d3bq88qiGwpN8gW+c86t9UQweQ8KDB1DI3rj624TGhs5pY11X8EdeqJYpTPplAEg4c g848E01m3vPV2dSRqN/GLIAUvjEKL3+nNCUjPTNhslpoRweJiCOXUgClzhb7oVtN6e2j 6m8ft1GrH8i60pJ0z4G5WlvRexuobXMHT+SZZCsHB8ow9gysf6iLORM094qTBqkBHfez zQ3XvoM1lEnVktiz+dv2ruNKF3Y22i1QeHlBf8nu0qVxoq0ztFASzDrTZ7KzGdKH2QYz +V1A== X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: linux-tegra@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, linux-pm@vger.kernel.org Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" Message-ID: <20191118200230.w9FJBhBEplo9LKagNfRlEGKaqjiIeivmU9N4wWLrNDc@z> QWxsIE5WSURJQSBUZWdyYSBTb0NzIGhhdmUgaWRlbnRpY2FsIHRvcG9sb2d5IGluIHJlZ2FyZHMg dG8gbWVtb3J5CmludGVyY29ubmVjdGlvbiBiZXR3ZWVuIG1lbW9yeSBjbGllbnRzIGFuZCBtZW1v cnkgY29udHJvbGxlcnMuClRoZSBtZW1vcnkgY29udHJvbGxlciAoTUMpIGFuZCBleHRlcm5hbCBt ZW1vcnkgY29udHJvbGxlciAoRU1DKSBhcmUKcHJvdmlkaW5nIG1lbW9yeSBjbGllbnRzIHdpdGgg cmVxdWlyZWQgbWVtb3J5IGJhbmR3aWR0aC4gVGhlIG1lbW9yeQpjb250cm9sbGVyIHBlcmZvcm1z IGFyYml0cmF0aW9uIGJldHdlZW4gbWVtb3J5IGNsaWVudHMsIHdoaWxlIHRoZQpleHRlcm5hbCBt ZW1vcnkgY29udHJvbGxlciB0cmFuc2ZlcnMgZGF0YSBmcm9tL3RvIERSQU0gYW5kIHBpcGVzIHRo YXQKZGF0YSBmcm9tL3RvIG1lbW9yeSBjb250cm9sbGVyLiBNZW1vcnkgY29udHJvbGxlciBpbnRl cmNvbm5lY3QgcHJvdmlkZXIKYWdncmVnYXRlcyBiYW5kd2lkdGggcmVxdWVzdHMgZnJvbSBtZW1v cnkgY2xpZW50cyBhbmQgc2VuZHMgdGhlIGFnZ3JlZ2F0ZWQKcmVxdWVzdCB0byBFTUMgcHJvdmlk ZXIgdGhhdCBzY2FsZXMgRFJBTSBmcmVxdWVuY3kgaW4gb3JkZXIgdG8gc2F0aXNmeSB0aGUKYmFu ZHdpZHRoIHJlcXVpcmVtZW50LiBNZW1vcnkgY29udHJvbGxlciBwcm92aWRlciBjb3VsZCBhZGp1 c3QgaGFyZHdhcmUKY29uZmlndXJhdGlvbiBmb3IgYSBtb3JlIG9wdGltYWwgYXJiaXRyYXRpb24g ZGVwZW5kaW5nIG9uIGJhbmR3aWR0aApyZXF1aXJlbWVudHMgZnJvbSBtZW1vcnkgY2xpZW50cywg YnV0IHRoaXMgaXMgdW5pbXBsZW1lbnRlZCBmb3Igbm93LgoKU2lnbmVkLW9mZi1ieTogRG1pdHJ5 IE9zaXBlbmtvIDxkaWdldHhAZ21haWwuY29tPgotLS0KIGRyaXZlcnMvaW50ZXJjb25uZWN0L0tj b25maWcgICAgICAgICAgICAgICB8ICAgMSArCiBkcml2ZXJzL2ludGVyY29ubmVjdC9NYWtlZmls ZSAgICAgICAgICAgICAgfCAgIDEgKwogZHJpdmVycy9pbnRlcmNvbm5lY3QvdGVncmEvS2NvbmZp ZyAgICAgICAgIHwgICA2ICsKIGRyaXZlcnMvaW50ZXJjb25uZWN0L3RlZ3JhL01ha2VmaWxlICAg ICAgICB8ICAgNCArCiBkcml2ZXJzL2ludGVyY29ubmVjdC90ZWdyYS90ZWdyYS1pY2MtZW1jLmMg fCAxMzggKysrKysrKysrKysrKysrKysrKysrCiBkcml2ZXJzL2ludGVyY29ubmVjdC90ZWdyYS90 ZWdyYS1pY2MtbWMuYyAgfCAxMzAgKysrKysrKysrKysrKysrKysrKwogaW5jbHVkZS9zb2MvdGVn cmEvbWMuaCAgICAgICAgICAgICAgICAgICAgIHwgIDI2ICsrKysKIDcgZmlsZXMgY2hhbmdlZCwg MzA2IGluc2VydGlvbnMoKykKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2ludGVyY29ubmVj dC90ZWdyYS9LY29uZmlnCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9pbnRlcmNvbm5lY3Qv dGVncmEvTWFrZWZpbGUKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2ludGVyY29ubmVjdC90 ZWdyYS90ZWdyYS1pY2MtZW1jLmMKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL2ludGVyY29u bmVjdC90ZWdyYS90ZWdyYS1pY2MtbWMuYwoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW50ZXJjb25u ZWN0L0tjb25maWcgYi9kcml2ZXJzL2ludGVyY29ubmVjdC9LY29uZmlnCmluZGV4IGJmYTRjYTNh YjdhOS4uYjExY2EwOTY2NWJiIDEwMDY0NAotLS0gYS9kcml2ZXJzL2ludGVyY29ubmVjdC9LY29u ZmlnCisrKyBiL2RyaXZlcnMvaW50ZXJjb25uZWN0L0tjb25maWcKQEAgLTEyLDUgKzEyLDYgQEAg bWVudWNvbmZpZyBJTlRFUkNPTk5FQ1QKIGlmIElOVEVSQ09OTkVDVAogCiBzb3VyY2UgImRyaXZl cnMvaW50ZXJjb25uZWN0L3Fjb20vS2NvbmZpZyIKK3NvdXJjZSAiZHJpdmVycy9pbnRlcmNvbm5l Y3QvdGVncmEvS2NvbmZpZyIKIAogZW5kaWYKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW50ZXJjb25u ZWN0L01ha2VmaWxlIGIvZHJpdmVycy9pbnRlcmNvbm5lY3QvTWFrZWZpbGUKaW5kZXggMjhmMmFi MDgyNGQ1Li5hMzdkNDE5ZTI2MmMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW50ZXJjb25uZWN0L01h a2VmaWxlCisrKyBiL2RyaXZlcnMvaW50ZXJjb25uZWN0L01ha2VmaWxlCkBAIC00LDMgKzQsNCBA QCBpY2MtY29yZS1vYmpzCQkJCTo9IGNvcmUubwogCiBvYmotJChDT05GSUdfSU5URVJDT05ORUNU KQkJKz0gaWNjLWNvcmUubwogb2JqLSQoQ09ORklHX0lOVEVSQ09OTkVDVF9RQ09NKQkJKz0gcWNv bS8KK29iai0kKENPTkZJR19JTlRFUkNPTk5FQ1RfVEVHUkEpCSs9IHRlZ3JhLwpkaWZmIC0tZ2l0 IGEvZHJpdmVycy9pbnRlcmNvbm5lY3QvdGVncmEvS2NvbmZpZyBiL2RyaXZlcnMvaW50ZXJjb25u ZWN0L3RlZ3JhL0tjb25maWcKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAw Li5iNzI0NzgxZGE3MWUKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL2ludGVyY29ubmVjdC90 ZWdyYS9LY29uZmlnCkBAIC0wLDAgKzEsNiBAQAorIyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjog R1BMLTIuMC1vbmx5Citjb25maWcgSU5URVJDT05ORUNUX1RFR1JBCisJYm9vbCAiTlZJRElBIFRl Z3JhIGludGVyY29ubmVjdCBkcml2ZXJzIgorCWRlcGVuZHMgb24gQVJDSF9URUdSQSB8fCBDT01Q SUxFX1RFU1QKKwloZWxwCisJICBTYXkgWSBoZXJlIHRvIGVuYWJsZSBzdXBwb3J0IGZvciBOVklE SUEgVGVncmEgaW50ZXJjb25uZWN0IGRyaXZlcnMuCmRpZmYgLS1naXQgYS9kcml2ZXJzL2ludGVy Y29ubmVjdC90ZWdyYS9NYWtlZmlsZSBiL2RyaXZlcnMvaW50ZXJjb25uZWN0L3RlZ3JhL01ha2Vm aWxlCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uNzRmZjJlNTNkYmRj Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9pbnRlcmNvbm5lY3QvdGVncmEvTWFrZWZpbGUK QEAgLTAsMCArMSw0IEBACisjIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wCisKK29i ai0kKENPTkZJR19JTlRFUkNPTk5FQ1RfVEVHUkEpICs9IHRlZ3JhLWljYy1tYy5vCitvYmotJChD T05GSUdfSU5URVJDT05ORUNUX1RFR1JBKSArPSB0ZWdyYS1pY2MtZW1jLm8KZGlmZiAtLWdpdCBh L2RyaXZlcnMvaW50ZXJjb25uZWN0L3RlZ3JhL3RlZ3JhLWljYy1lbWMuYyBiL2RyaXZlcnMvaW50 ZXJjb25uZWN0L3RlZ3JhL3RlZ3JhLWljYy1lbWMuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwMDAwMDAuLmI1OTRjZTgxMTE1MwotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMv aW50ZXJjb25uZWN0L3RlZ3JhL3RlZ3JhLWljYy1lbWMuYwpAQCAtMCwwICsxLDEzOCBAQAorLy8g U1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjArCisvKgorICogQXV0aG9yOiBEbWl0cnkg T3NpcGVua28gPGRpZ2V0eEBnbWFpbC5jb20+CisgKiBDb3B5cmlnaHQgKEMpIDIwMTkgR1JBVEUt RFJJVkVSIHByb2plY3QKKyAqLworCisjaW5jbHVkZSA8ZHQtYmluZGluZ3MvaW50ZXJjb25uZWN0 L3RlZ3JhLWljYy5oPgorCisjaW5jbHVkZSA8bGludXgvY2xrLmg+CisjaW5jbHVkZSA8bGludXgv ZGV2aWNlLmg+CisjaW5jbHVkZSA8bGludXgvZXJyLmg+CisjaW5jbHVkZSA8bGludXgvaW50ZXJj b25uZWN0LXByb3ZpZGVyLmg+CisjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CisjaW5jbHVkZSA8 bGludXgvb2YuaD4KKworI2luY2x1ZGUgPHNvYy90ZWdyYS9tYy5oPgorCitzdHJ1Y3QgdGVncmFf ZW1jX3Byb3ZpZGVyIHsKKwlzdHJ1Y3QgaWNjX3Byb3ZpZGVyIHByb3ZpZGVyOworCXN0cnVjdCBj bGsgKmNsazsKKwl1bnNpZ25lZCBpbnQgZHJhbV9kYXRhX2J1c193aWR0aF9ieXRlczsKK307CisK K3N0YXRpYyBpbmxpbmUgc3RydWN0IHRlZ3JhX2VtY19wcm92aWRlciAqCit0b190ZWdyYV9lbWNf cHJvdmlkZXIoc3RydWN0IGljY19wcm92aWRlciAqcHJvdmlkZXIpCit7CisJcmV0dXJuIGNvbnRh aW5lcl9vZihwcm92aWRlciwgc3RydWN0IHRlZ3JhX2VtY19wcm92aWRlciwgcHJvdmlkZXIpOwor fQorCitzdGF0aWMgc3RydWN0IGljY19ub2RlICoKK3RlZ3JhX2VtY19vZl9pY2NfeGxhdGVfb25l Y2VsbChzdHJ1Y3Qgb2ZfcGhhbmRsZV9hcmdzICpzcGVjLCB2b2lkICpkYXRhKQoreworCXN0cnVj dCBpY2NfcHJvdmlkZXIgKnByb3ZpZGVyID0gZGF0YTsKKwlzdHJ1Y3QgaWNjX25vZGUgKm5vZGU7 CisKKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KG5vZGUsICZwcm92aWRlci0+bm9kZXMsIG5vZGVfbGlz dCkgeworCQlpZiAobm9kZS0+aWQgPT0gc3BlYy0+YXJnc1swXSkKKwkJCXJldHVybiBub2RlOwor CX0KKworCXJldHVybiBFUlJfUFRSKC1FSU5WQUwpOworfQorCitzdGF0aWMgaW50IHRlZ3JhX2Vt Y19pY2Nfc2V0KHN0cnVjdCBpY2Nfbm9kZSAqc3JjLCBzdHJ1Y3QgaWNjX25vZGUgKmRzdCkKK3sK KwlzdHJ1Y3QgdGVncmFfZW1jX3Byb3ZpZGVyICplbWMgPSB0b190ZWdyYV9lbWNfcHJvdmlkZXIo ZHN0LT5wcm92aWRlcik7CisJdW5zaWduZWQgbG9uZyBsb25nIHJhdGUgPSBpY2NfdW5pdHNfdG9f YnBzKGRzdC0+YXZnX2J3KTsKKwl1bnNpZ25lZCBpbnQgZGRyID0gMjsKKwlpbnQgZXJyOworCisJ ZG9fZGl2KHJhdGUsIGRkciAqIGVtYy0+ZHJhbV9kYXRhX2J1c193aWR0aF9ieXRlcyk7CisJcmF0 ZSA9IG1pbl90KHU2NCwgcmF0ZSwgVTMyX01BWCk7CisKKwllcnIgPSBjbGtfc2V0X21pbl9yYXRl KGVtYy0+Y2xrLCByYXRlKTsKKwlpZiAoZXJyKQorCQlyZXR1cm4gZXJyOworCisJZXJyID0gY2xr X3NldF9yYXRlKGVtYy0+Y2xrLCByYXRlKTsKKwlpZiAoZXJyKQorCQlyZXR1cm4gZXJyOworCisJ cmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgdGVncmFfZW1jX2ljY19hZ2dyZWdhdGUoc3RydWN0 IGljY19ub2RlICpub2RlLAorCQkJCSAgIHUzMiB0YWcsIHUzMiBhdmdfYncsIHUzMiBwZWFrX2J3 LAorCQkJCSAgIHUzMiAqYWdnX2F2ZywgdTMyICphZ2dfcGVhaykKK3sKKwkqYWdnX2F2ZyA9IG1p bigodTY0KWF2Z19idyArICgqYWdnX2F2ZyksICh1NjQpVTMyX01BWCk7CisJKmFnZ19wZWFrID0g bWF4KCphZ2dfcGVhaywgcGVha19idyk7CisKKwlyZXR1cm4gMDsKK30KKworaW50IHRlZ3JhX2lj Y19lbWNfc2V0dXBfaW50ZXJjb25uZWN0KHN0cnVjdCBkZXZpY2UgKmVtY19kZXYsCisJCQkJICAg ICB1bnNpZ25lZCBpbnQgZHJhbV9kYXRhX2J1c193aWR0aF9ieXRlcykKK3sKKwlzdHJ1Y3QgdGVn cmFfZW1jX3Byb3ZpZGVyICplbWM7CisJc3RydWN0IGljY19ub2RlICpub2RlLCAqdG1wOworCWlu dCBlcnI7CisKKwllbWMgPSBkZXZtX2t6YWxsb2MoZW1jX2Rldiwgc2l6ZW9mKCplbWMpLCBHRlBf S0VSTkVMKTsKKwlpZiAoIWVtYykKKwkJcmV0dXJuIC1FTk9NRU07CisKKwllbWMtPmNsayA9IGRl dm1fY2xrX2dldChlbWNfZGV2LCAiZW1jIik7CisJZXJyID0gUFRSX0VSUl9PUl9aRVJPKGVtYy0+ Y2xrKTsKKwlpZiAoZXJyKQorCQlyZXR1cm4gZXJyOworCisJZW1jLT5kcmFtX2RhdGFfYnVzX3dp ZHRoX2J5dGVzID0gZHJhbV9kYXRhX2J1c193aWR0aF9ieXRlczsKKworCWVtYy0+cHJvdmlkZXIu ZGV2ID0gZW1jX2RldjsKKwllbWMtPnByb3ZpZGVyLnNldCA9IHRlZ3JhX2VtY19pY2Nfc2V0Owor CWVtYy0+cHJvdmlkZXIuZGF0YSA9ICZlbWMtPnByb3ZpZGVyOworCWVtYy0+cHJvdmlkZXIueGxh dGUgPSB0ZWdyYV9lbWNfb2ZfaWNjX3hsYXRlX29uZWNlbGw7CisJZW1jLT5wcm92aWRlci5hZ2dy ZWdhdGUgPSB0ZWdyYV9lbWNfaWNjX2FnZ3JlZ2F0ZTsKKworCWVyciA9IGljY19wcm92aWRlcl9h ZGQoJmVtYy0+cHJvdmlkZXIpOworCWlmIChlcnIpCisJCXJldHVybiBlcnI7CisKKwkvKiBjcmVh dGUgRXh0ZXJuYWwgTWVtb3J5IENvbnRyb2xsZXIgbm9kZSAqLworCW5vZGUgPSBpY2Nfbm9kZV9j cmVhdGUoVEVHUkFfSUNDX0VNQyk7CisJZXJyID0gUFRSX0VSUl9PUl9aRVJPKG5vZGUpOworCWlm IChlcnIpCisJCWdvdG8gZGVsX3Byb3ZpZGVyOworCisJbm9kZS0+bmFtZSA9ICJFTUMiOworCWlj Y19ub2RlX2FkZChub2RlLCAmZW1jLT5wcm92aWRlcik7CisKKwkvKiBsaW5rIEV4dGVybmFsIE1l bW9yeSBDb250cm9sbGVyIHdpdGggRXh0ZXJuYWwgTWVtb3J5ICovCisJZXJyID0gaWNjX2xpbmtf Y3JlYXRlKG5vZGUsIFRFR1JBX0lDQ19FTUVNKTsKKwlpZiAoZXJyKQorCQlnb3RvIGRlc3Ryb3lf bm9kZXM7CisKKwkvKiBjcmVhdGUgRXh0ZXJuYWwgTWVtb3J5IG5vZGUgKi8KKwlub2RlID0gaWNj X25vZGVfY3JlYXRlKFRFR1JBX0lDQ19FTUVNKTsKKwllcnIgPSBQVFJfRVJSX09SX1pFUk8obm9k ZSk7CisJaWYgKGVycikKKwkJZ290byBkZXN0cm95X25vZGVzOworCisJbm9kZS0+bmFtZSA9ICJF TUVNIjsKKwlpY2Nfbm9kZV9hZGQobm9kZSwgJmVtYy0+cHJvdmlkZXIpOworCisJcmV0dXJuIDA7 CisKK2Rlc3Ryb3lfbm9kZXM6CisJbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKG5vZGUsIHRtcCwg JmVtYy0+cHJvdmlkZXIubm9kZXMsIG5vZGVfbGlzdCkgeworCQlpY2Nfbm9kZV9kZWwobm9kZSk7 CisJCWljY19ub2RlX2Rlc3Ryb3kobm9kZS0+aWQpOworCX0KKworZGVsX3Byb3ZpZGVyOgorCWlj Y19wcm92aWRlcl9kZWwoJmVtYy0+cHJvdmlkZXIpOworCisJcmV0dXJuIGVycjsKK30KZGlmZiAt LWdpdCBhL2RyaXZlcnMvaW50ZXJjb25uZWN0L3RlZ3JhL3RlZ3JhLWljYy1tYy5jIGIvZHJpdmVy cy9pbnRlcmNvbm5lY3QvdGVncmEvdGVncmEtaWNjLW1jLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMDAwMDAwLi5mMWZmOGY5OGRlZjMKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2 ZXJzL2ludGVyY29ubmVjdC90ZWdyYS90ZWdyYS1pY2MtbWMuYwpAQCAtMCwwICsxLDEzMCBAQAor Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjArCisvKgorICogQXV0aG9yOiBEbWl0 cnkgT3NpcGVua28gPGRpZ2V0eEBnbWFpbC5jb20+CisgKiBDb3B5cmlnaHQgKEMpIDIwMTkgR1JB VEUtRFJJVkVSIHByb2plY3QKKyAqLworCisjaW5jbHVkZSA8ZHQtYmluZGluZ3MvaW50ZXJjb25u ZWN0L3RlZ3JhLWljYy5oPgorCisjaW5jbHVkZSA8bGludXgvZGV2aWNlLmg+CisjaW5jbHVkZSA8 bGludXgvZXJyLmg+CisjaW5jbHVkZSA8bGludXgvaW50ZXJjb25uZWN0LXByb3ZpZGVyLmg+Cisj aW5jbHVkZSA8bGludXgvb2YuaD4KKworI2luY2x1ZGUgPHNvYy90ZWdyYS9tYy5oPgorCitzdGF0 aWMgc3RydWN0IGljY19ub2RlICoKK3RlZ3JhX21jX29mX2ljY194bGF0ZV9vbmVjZWxsKHN0cnVj dCBvZl9waGFuZGxlX2FyZ3MgKnNwZWMsIHZvaWQgKmRhdGEpCit7CisJc3RydWN0IGljY19wcm92 aWRlciAqcHJvdmlkZXIgPSBkYXRhOworCXN0cnVjdCBpY2Nfbm9kZSAqbm9kZTsKKworCWxpc3Rf Zm9yX2VhY2hfZW50cnkobm9kZSwgJnByb3ZpZGVyLT5ub2Rlcywgbm9kZV9saXN0KSB7CisJCWlm IChub2RlLT5pZCA9PSBzcGVjLT5hcmdzWzBdKQorCQkJcmV0dXJuIG5vZGU7CisJfQorCisJcmV0 dXJuIEVSUl9QVFIoLUVJTlZBTCk7Cit9CisKK3N0YXRpYyBpbnQgdGVncmFfbWNfaWNjX3NldChz dHJ1Y3QgaWNjX25vZGUgKnNyYywgc3RydWN0IGljY19ub2RlICpkc3QpCit7CisJcmV0dXJuIDA7 Cit9CisKK3N0YXRpYyBpbnQgdGVncmFfbWNfaWNjX2FnZ3JlZ2F0ZShzdHJ1Y3QgaWNjX25vZGUg Km5vZGUsCisJCQkJICB1MzIgdGFnLCB1MzIgYXZnX2J3LCB1MzIgcGVha19idywKKwkJCQkgIHUz MiAqYWdnX2F2ZywgdTMyICphZ2dfcGVhaykKK3sKKwkqYWdnX2F2ZyA9IG1pbigodTY0KWF2Z19i dyArICgqYWdnX2F2ZyksICh1NjQpVTMyX01BWCk7CisJKmFnZ19wZWFrID0gbWF4KCphZ2dfcGVh aywgcGVha19idyk7CisKKwlyZXR1cm4gMDsKK30KKworLyoKKyAqIE1lbW9yeSBDb250cm9sbGVy IChNQykgaGFzIGZldyBNZW1vcnkgQ2xpZW50cyB0aGF0IGFyZSBpc3N1aW5nIG1lbW9yeQorICog YmFuZHdpZHRoIGFsbG9jYXRpb24gcmVxdWVzdHMgdG8gdGhlIE1DIGludGVyY29ubmVjdCBwcm92 aWRlci4gVGhlIE1DCisgKiBwcm92aWRlciBhZ2dyZWdhdGVzIHRoZSByZXF1ZXN0cyBhbmQgdGhl biBzZW5kcyB0aGUgYWdncmVnYXRlZCByZXF1ZXN0CisgKiB1cCB0byB0aGUgRXh0ZXJuYWwgTWVt b3J5IENvbnRyb2xsZXIgKEVNQykgaW50ZXJjb25uZWN0IHByb3ZpZGVyIHdoaWNoCisgKiByZS1j b25maWd1cmVzIGhhcmR3YXJlIGludGVyZmFjZSB0byBFeHRlcm5hbCBNZW1vcnkgKEVNRU0pIGlu IGFjY29yZGFuY2UKKyAqIHRvIHRoZSByZXF1aXJlZCBiYW5kd2lkdGguCisgKgorICogTWVtb3J5 IGludGVyY29ubmVjdCB0b3BvbG9neToKKyAqCisgKiAgICAgICAgICAgICAgICstLS0tKworICog ICArLS0tLS0rICAgICB8ICAgIHwKKyAqICAgfCBHUFUgKy0tLS0+KyAgICB8CisgKiAgICstLS0t LSsgICAgIHwgICAgfAorICogICAgICAgICAgICAgICB8ICAgIHwgICAgICstLS0tLSsgICAgICst LS0tLS0rCisgKiAgICAuLi4gICAgICAgIHwgTUMgKy0tLS0+KyBFTUMgKy0tLS0+KyBFTUVNIHwK KyAqICAgICAgICAgICAgICAgfCAgICB8ICAgICArLS0tLS0rICAgICArLS0tLS0tKworICogICst LS0tLS0rICAgICB8ICAgIHwKKyAqICB8IERJU1AgKy0tLS0+KyAgICB8CisgKiAgKy0tLS0tLSsg ICAgIHwgICAgfAorICogICAgICAgICAgICAgICArLS0tLSsKKyAqLworaW50IHRlZ3JhX2ljY19t Y19zZXR1cF9pbnRlcmNvbm5lY3Qoc3RydWN0IHRlZ3JhX21jICptYykKK3sKKwlzdHJ1Y3QgaWNj X3Byb3ZpZGVyICpwcm92aWRlcjsKKwlzdHJ1Y3QgaWNjX25vZGUgKm5vZGUsICp0bXA7CisJdW5z aWduZWQgaW50IGk7CisJaW50IGVycjsKKworCXByb3ZpZGVyID0gZGV2bV9remFsbG9jKG1jLT5k ZXYsIHNpemVvZigqcHJvdmlkZXIpLCBHRlBfS0VSTkVMKTsKKwlpZiAoIXByb3ZpZGVyKQorCQly ZXR1cm4gLUVOT01FTTsKKworCXByb3ZpZGVyLT5kZXYgPSBtYy0+ZGV2OworCXByb3ZpZGVyLT5z ZXQgPSB0ZWdyYV9tY19pY2Nfc2V0OworCXByb3ZpZGVyLT5kYXRhID0gcHJvdmlkZXI7CisJcHJv dmlkZXItPnhsYXRlID0gdGVncmFfbWNfb2ZfaWNjX3hsYXRlX29uZWNlbGw7CisJcHJvdmlkZXIt PmFnZ3JlZ2F0ZSA9IHRlZ3JhX21jX2ljY19hZ2dyZWdhdGU7CisKKwllcnIgPSBpY2NfcHJvdmlk ZXJfYWRkKHByb3ZpZGVyKTsKKwlpZiAoZXJyKQorCQlyZXR1cm4gZXJyOworCisJLyogY3JlYXRl IE1lbW9yeSBDb250cm9sbGVyIG5vZGUgKi8KKwlub2RlID0gaWNjX25vZGVfY3JlYXRlKFRFR1JB X0lDQ19NQyk7CisJZXJyID0gUFRSX0VSUl9PUl9aRVJPKG5vZGUpOworCWlmIChlcnIpCisJCWdv dG8gZGVsX3Byb3ZpZGVyOworCisJbm9kZS0+bmFtZSA9ICJNQyI7CisJaWNjX25vZGVfYWRkKG5v ZGUsIHByb3ZpZGVyKTsKKworCS8qIGxpbmsgTWVtb3J5IENvbnRyb2xsZXIgd2l0aCBFeHRlcm5h bCBNZW1vcnkgQ29udHJvbGxlciAqLworCWVyciA9IGljY19saW5rX2NyZWF0ZShub2RlLCBURUdS QV9JQ0NfRU1DKTsKKwlpZiAoZXJyKQorCQlnb3RvIGRlc3Ryb3lfbm9kZXM7CisKKwlmb3IgKGkg PSAwOyBpIDwgbWMtPnNvYy0+bnVtX2ljY19ub2RlczsgaSsrKSB7CisJCS8qIGNyZWF0ZSBNQyBj bGllbnQgbm9kZSAqLworCQlub2RlID0gaWNjX25vZGVfY3JlYXRlKG1jLT5zb2MtPmljY19ub2Rl c1tpXS5pZCk7CisJCWVyciA9IFBUUl9FUlJfT1JfWkVSTyhub2RlKTsKKwkJaWYgKGVycikKKwkJ CWdvdG8gZGVzdHJveV9ub2RlczsKKworCQlub2RlLT5uYW1lID0gbWMtPnNvYy0+aWNjX25vZGVz W2ldLm5hbWU7CisJCWljY19ub2RlX2FkZChub2RlLCBwcm92aWRlcik7CisKKwkJLyogbGluayBN ZW1vcnkgQ2xpZW50IHdpdGggTWVtb3J5IENvbnRyb2xsZXIgKi8KKwkJZXJyID0gaWNjX2xpbmtf Y3JlYXRlKG5vZGUsIFRFR1JBX0lDQ19NQyk7CisJCWlmIChlcnIpCisJCQlnb3RvIGRlc3Ryb3lf bm9kZXM7CisJfQorCisJcmV0dXJuIDA7CisKK2Rlc3Ryb3lfbm9kZXM6CisJbGlzdF9mb3JfZWFj aF9lbnRyeV9zYWZlKG5vZGUsIHRtcCwgJnByb3ZpZGVyLT5ub2Rlcywgbm9kZV9saXN0KSB7CisJ CWljY19ub2RlX2RlbChub2RlKTsKKwkJaWNjX25vZGVfZGVzdHJveShub2RlLT5pZCk7CisJfQor CitkZWxfcHJvdmlkZXI6CisJaWNjX3Byb3ZpZGVyX2RlbChwcm92aWRlcik7CisKKwlyZXR1cm4g ZXJyOworfQpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9zb2MvdGVncmEvbWMuaCBiL2luY2x1ZGUvc29j L3RlZ3JhL21jLmgKaW5kZXggMTIzOGUzNTY1M2QxLi41OTM5NTQzMjQyNTkgMTAwNjQ0Ci0tLSBh L2luY2x1ZGUvc29jL3RlZ3JhL21jLmgKKysrIGIvaW5jbHVkZS9zb2MvdGVncmEvbWMuaApAQCAt MTQxLDYgKzE0MSwxMSBAQCBzdHJ1Y3QgdGVncmFfbWNfcmVzZXRfb3BzIHsKIAkJCSAgICBjb25z dCBzdHJ1Y3QgdGVncmFfbWNfcmVzZXQgKnJzdCk7CiB9OwogCitzdHJ1Y3QgdGVncmFfbWNfaWNj X25vZGUgeworCWNvbnN0IGNoYXIgKm5hbWU7CisJdW5zaWduZWQgaW50IGlkOworfTsKKwogc3Ry dWN0IHRlZ3JhX21jX3NvYyB7CiAJY29uc3Qgc3RydWN0IHRlZ3JhX21jX2NsaWVudCAqY2xpZW50 czsKIAl1bnNpZ25lZCBpbnQgbnVtX2NsaWVudHM7CkBAIC0xNjAsNiArMTY1LDkgQEAgc3RydWN0 IHRlZ3JhX21jX3NvYyB7CiAJY29uc3Qgc3RydWN0IHRlZ3JhX21jX3Jlc2V0X29wcyAqcmVzZXRf b3BzOwogCWNvbnN0IHN0cnVjdCB0ZWdyYV9tY19yZXNldCAqcmVzZXRzOwogCXVuc2lnbmVkIGlu dCBudW1fcmVzZXRzOworCisJY29uc3Qgc3RydWN0IHRlZ3JhX21jX2ljY19ub2RlICppY2Nfbm9k ZXM7CisJdW5zaWduZWQgaW50IG51bV9pY2Nfbm9kZXM7CiB9OwogCiBzdHJ1Y3QgdGVncmFfbWMg ewpAQCAtMTg0LDQgKzE5MiwyMiBAQCBzdHJ1Y3QgdGVncmFfbWMgewogaW50IHRlZ3JhX21jX3dy aXRlX2VtZW1fY29uZmlndXJhdGlvbihzdHJ1Y3QgdGVncmFfbWMgKm1jLCB1bnNpZ25lZCBsb25n IHJhdGUpOwogdW5zaWduZWQgaW50IHRlZ3JhX21jX2dldF9lbWVtX2RldmljZV9jb3VudChzdHJ1 Y3QgdGVncmFfbWMgKm1jKTsKIAorI2lmZGVmIENPTkZJR19JTlRFUkNPTk5FQ1RfVEVHUkEKK2lu dCB0ZWdyYV9pY2NfbWNfc2V0dXBfaW50ZXJjb25uZWN0KHN0cnVjdCB0ZWdyYV9tYyAqbWMpOwor aW50IHRlZ3JhX2ljY19lbWNfc2V0dXBfaW50ZXJjb25uZWN0KHN0cnVjdCBkZXZpY2UgKmVtY19k ZXYsCisJCQkJICAgICB1bnNpZ25lZCBpbnQgZHJhbV9kYXRhX2J1c193aWR0aF9ieXRlcyk7Cisj ZWxzZQorc3RhdGljIGlubGluZSBpbnQgdGVncmFfaWNjX21jX3NldHVwX2ludGVyY29ubmVjdChz dHJ1Y3QgdGVncmFfbWMgKm1jKTsKK3sKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGlubGluZSBp bnQKK3RlZ3JhX2ljY19lbWNfc2V0dXBfaW50ZXJjb25uZWN0KHN0cnVjdCBkZXZpY2UgKmVtY19k ZXYsCisJCQkJIHVuc2lnbmVkIGludCBkcmFtX2RhdGFfYnVzX3dpZHRoX2J5dGVzKQoreworCXJl dHVybiAwOworfQorI2VuZGlmCisKICNlbmRpZiAvKiBfX1NPQ19URUdSQV9NQ19IX18gKi8KLS0g CjIuMjMuMAoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18K ZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0 dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVs