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=-16.8 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,UNPARSEABLE_RELAY,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 DD4D4C48BCF for ; Wed, 9 Jun 2021 17:35:43 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id BEECA613CB for ; Wed, 9 Jun 2021 17:35:43 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231624AbhFIRhh (ORCPT ); Wed, 9 Jun 2021 13:37:37 -0400 Received: from out28-123.mail.aliyun.com ([115.124.28.123]:54252 "EHLO out28-123.mail.aliyun.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229947AbhFIRhb (ORCPT ); Wed, 9 Jun 2021 13:37:31 -0400 X-Alimail-AntiSpam: AC=CONTINUE;BC=0.07436282|-1;CH=green;DM=|CONTINUE|false|;DS=CONTINUE|ham_system_inform|0.0239554-0.000423683-0.975621;FP=0|0|0|0|0|-1|-1|-1;HT=ay29a033018047206;MF=zhouyanjie@wanyeetech.com;NM=1;PH=DS;RN=20;RT=20;SR=0;TI=SMTPD_---.KQ26pE3_1623260120; Received: from localhost.localdomain(mailfrom:zhouyanjie@wanyeetech.com fp:SMTPD_---.KQ26pE3_1623260120) by smtp.aliyun-inc.com(10.147.41.138); Thu, 10 Jun 2021 01:35:32 +0800 From: =?UTF-8?q?=E5=91=A8=E7=90=B0=E6=9D=B0=20=28Zhou=20Yanjie=29?= To: davem@davemloft.net, kuba@kernel.org, robh+dt@kernel.org, peppe.cavallaro@st.com, alexandre.torgue@foss.st.com, joabreu@synopsys.com, mcoquelin.stm32@gmail.com Cc: linux-mips@vger.kernel.org, linux-kernel@vger.kernel.org, netdev@vger.kernel.org, devicetree@vger.kernel.org, linux-stm32@st-md-mailman.stormreply.com, linux-arm-kernel@lists.infradead.org, dongsheng.qiu@ingenic.com, aric.pzqi@ingenic.com, rick.tyliu@ingenic.com, sihui.liu@ingenic.com, jun.jiang@ingenic.com, sernia.zhou@foxmail.com, paul@crapouillou.net Subject: [PATCH v2 2/2] net: stmmac: Add Ingenic SoCs MAC support. Date: Thu, 10 Jun 2021 01:35:10 +0800 Message-Id: <1623260110-25842-3-git-send-email-zhouyanjie@wanyeetech.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1623260110-25842-1-git-send-email-zhouyanjie@wanyeetech.com> References: <1623260110-25842-1-git-send-email-zhouyanjie@wanyeetech.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Add support for Ingenic SoC MAC glue layer support for the stmmac device driver. This driver is used on for the MAC ethernet controller found in the JZ4775 SoC, the X1000 SoC, the X1600 SoC, the X1830 SoC, and the X2000 SoC. Signed-off-by: 周琰杰 (Zhou Yanjie) --- Notes: v1->v2: 1.Fix uninitialized variable. 2.Add missing RGMII-ID, RGMII-RXID, and RGMII-TXID. 3.Change variable val from int to unsinged int. 4.Get tx clock delay and rx clock delay from devicetree. drivers/net/ethernet/stmicro/stmmac/Kconfig | 12 + drivers/net/ethernet/stmicro/stmmac/Makefile | 1 + .../net/ethernet/stmicro/stmmac/dwmac-ingenic.c | 434 +++++++++++++++++++++ 3 files changed, 447 insertions(+) create mode 100644 drivers/net/ethernet/stmicro/stmmac/dwmac-ingenic.c diff --git a/drivers/net/ethernet/stmicro/stmmac/Kconfig b/drivers/net/ethernet/stmicro/stmmac/Kconfig index 7737e4d0..9a19e4d 100644 --- a/drivers/net/ethernet/stmicro/stmmac/Kconfig +++ b/drivers/net/ethernet/stmicro/stmmac/Kconfig @@ -66,6 +66,18 @@ config DWMAC_ANARION This selects the Anarion SoC glue layer support for the stmmac driver. +config DWMAC_INGENIC + tristate "Ingenic MAC support" + default MACH_INGENIC + depends on OF && HAS_IOMEM && (MACH_INGENIC || COMPILE_TEST) + select MFD_SYSCON + help + Support for ethernet controller on Ingenic SoCs. + + This selects Ingenic SoCs glue layer support for the stmmac + device driver. This driver is used on for the Ingenic SoCs + MAC ethernet controller. + config DWMAC_IPQ806X tristate "QCA IPQ806x DWMAC support" default ARCH_QCOM diff --git a/drivers/net/ethernet/stmicro/stmmac/Makefile b/drivers/net/ethernet/stmicro/stmmac/Makefile index f2e478b..6471f93 100644 --- a/drivers/net/ethernet/stmicro/stmmac/Makefile +++ b/drivers/net/ethernet/stmicro/stmmac/Makefile @@ -14,6 +14,7 @@ stmmac-$(CONFIG_STMMAC_SELFTESTS) += stmmac_selftests.o # Ordering matters. Generic driver must be last. obj-$(CONFIG_STMMAC_PLATFORM) += stmmac-platform.o obj-$(CONFIG_DWMAC_ANARION) += dwmac-anarion.o +obj-$(CONFIG_DWMAC_INGENIC) += dwmac-ingenic.o obj-$(CONFIG_DWMAC_IPQ806X) += dwmac-ipq806x.o obj-$(CONFIG_DWMAC_LPC18XX) += dwmac-lpc18xx.o obj-$(CONFIG_DWMAC_MEDIATEK) += dwmac-mediatek.o diff --git a/drivers/net/ethernet/stmicro/stmmac/dwmac-ingenic.c b/drivers/net/ethernet/stmicro/stmmac/dwmac-ingenic.c new file mode 100644 index 00000000..fbe2727 --- /dev/null +++ b/drivers/net/ethernet/stmicro/stmmac/dwmac-ingenic.c @@ -0,0 +1,434 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * dwmac-ingenic.c - Ingenic SoCs DWMAC specific glue layer + * + * Copyright (c) 2021 周琰杰 (Zhou Yanjie) + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "stmmac_platform.h" + +#define MACPHYC_TXCLK_SEL_MASK GENMASK(31, 31) +#define MACPHYC_TXCLK_SEL_OUTPUT 0x1 +#define MACPHYC_TXCLK_SEL_INPUT 0x0 +#define MACPHYC_MODE_SEL_MASK GENMASK(31, 31) +#define MACPHYC_MODE_SEL_RMII 0x0 +#define MACPHYC_TX_SEL_MASK GENMASK(19, 19) +#define MACPHYC_TX_SEL_ORIGIN 0x0 +#define MACPHYC_TX_SEL_DELAY 0x1 +#define MACPHYC_TX_DELAY_MASK GENMASK(18, 12) +#define MACPHYC_TX_DELAY_MAX 0x80 +#define MACPHYC_RX_SEL_MASK GENMASK(11, 11) +#define MACPHYC_RX_SEL_ORIGIN 0x0 +#define MACPHYC_RX_SEL_DELAY 0x1 +#define MACPHYC_RX_DELAY_MASK GENMASK(10, 4) +#define MACPHYC_RX_DELAY_MAX 0x80 +#define MACPHYC_SOFT_RST_MASK GENMASK(3, 3) +#define MACPHYC_PHY_INFT_MASK GENMASK(2, 0) +#define MACPHYC_PHY_INFT_RMII 0x4 +#define MACPHYC_PHY_INFT_RGMII 0x1 +#define MACPHYC_PHY_INFT_GMII 0x0 +#define MACPHYC_PHY_INFT_MII 0x0 + +enum ingenic_mac_version { + ID_JZ4775, + ID_X1000, + ID_X1600, + ID_X1830, + ID_X2000, +}; + +struct ingenic_mac { + const struct ingenic_soc_info *soc_info; + struct device *dev; + struct regmap *regmap; + + int rx_delay; + int tx_delay; +}; + +struct ingenic_soc_info { + enum ingenic_mac_version version; + u32 mask; + + int (*set_mode)(struct plat_stmmacenet_data *plat_dat); +}; + +static int ingenic_mac_init(struct plat_stmmacenet_data *plat_dat) +{ + struct ingenic_mac *mac = plat_dat->bsp_priv; + int ret; + + if (mac->soc_info->set_mode) { + ret = mac->soc_info->set_mode(plat_dat); + if (ret) + return ret; + } + + return 0; +} + +static int jz4775_mac_set_mode(struct plat_stmmacenet_data *plat_dat) +{ + struct ingenic_mac *mac = plat_dat->bsp_priv; + unsigned int val; + + switch (plat_dat->interface) { + case PHY_INTERFACE_MODE_MII: + val = FIELD_PREP(MACPHYC_TXCLK_SEL_MASK, MACPHYC_TXCLK_SEL_INPUT) | + FIELD_PREP(MACPHYC_PHY_INFT_MASK, MACPHYC_PHY_INFT_MII); + dev_dbg(mac->dev, "MAC PHY Control Register: PHY_INTERFACE_MODE_MII\n"); + break; + + case PHY_INTERFACE_MODE_GMII: + val = FIELD_PREP(MACPHYC_TXCLK_SEL_MASK, MACPHYC_TXCLK_SEL_INPUT) | + FIELD_PREP(MACPHYC_PHY_INFT_MASK, MACPHYC_PHY_INFT_GMII); + dev_dbg(mac->dev, "MAC PHY Control Register: PHY_INTERFACE_MODE_GMII\n"); + break; + + case PHY_INTERFACE_MODE_RMII: + val = FIELD_PREP(MACPHYC_TXCLK_SEL_MASK, MACPHYC_TXCLK_SEL_INPUT) | + FIELD_PREP(MACPHYC_PHY_INFT_MASK, MACPHYC_PHY_INFT_RMII); + dev_dbg(mac->dev, "MAC PHY Control Register: PHY_INTERFACE_MODE_RMII\n"); + break; + + case PHY_INTERFACE_MODE_RGMII: + case PHY_INTERFACE_MODE_RGMII_ID: + case PHY_INTERFACE_MODE_RGMII_RXID: + case PHY_INTERFACE_MODE_RGMII_TXID: + val = FIELD_PREP(MACPHYC_TXCLK_SEL_MASK, MACPHYC_TXCLK_SEL_INPUT) | + FIELD_PREP(MACPHYC_PHY_INFT_MASK, MACPHYC_PHY_INFT_RGMII); + dev_dbg(mac->dev, "MAC PHY Control Register: PHY_INTERFACE_MODE_RGMII\n"); + break; + + default: + dev_err(mac->dev, "unsupported interface %d", plat_dat->interface); + return -EINVAL; + } + + /* Update MAC PHY control register */ + return regmap_update_bits(mac->regmap, 0, mac->soc_info->mask, val); +} + +static int x1000_mac_set_mode(struct plat_stmmacenet_data *plat_dat) +{ + struct ingenic_mac *mac = plat_dat->bsp_priv; + + switch (plat_dat->interface) { + case PHY_INTERFACE_MODE_RMII: + dev_dbg(mac->dev, "MAC PHY Control Register: PHY_INTERFACE_MODE_RMII\n"); + break; + + default: + dev_err(mac->dev, "unsupported interface %d", plat_dat->interface); + return -EINVAL; + } + + /* Update MAC PHY control register */ + return regmap_update_bits(mac->regmap, 0, mac->soc_info->mask, 0); +} + +static int x1600_mac_set_mode(struct plat_stmmacenet_data *plat_dat) +{ + struct ingenic_mac *mac = plat_dat->bsp_priv; + unsigned int val; + + switch (plat_dat->interface) { + case PHY_INTERFACE_MODE_RMII: + val = FIELD_PREP(MACPHYC_PHY_INFT_MASK, MACPHYC_PHY_INFT_RMII); + dev_dbg(mac->dev, "MAC PHY Control Register: PHY_INTERFACE_MODE_RMII\n"); + break; + + default: + dev_err(mac->dev, "unsupported interface %d", plat_dat->interface); + return -EINVAL; + } + + /* Update MAC PHY control register */ + return regmap_update_bits(mac->regmap, 0, mac->soc_info->mask, val); +} + +static int x1830_mac_set_mode(struct plat_stmmacenet_data *plat_dat) +{ + struct ingenic_mac *mac = plat_dat->bsp_priv; + unsigned int val; + + switch (plat_dat->interface) { + case PHY_INTERFACE_MODE_RMII: + val = FIELD_PREP(MACPHYC_MODE_SEL_MASK, MACPHYC_MODE_SEL_RMII) | + FIELD_PREP(MACPHYC_PHY_INFT_MASK, MACPHYC_PHY_INFT_RMII); + dev_dbg(mac->dev, "MAC PHY Control Register: PHY_INTERFACE_MODE_RMII\n"); + break; + + default: + dev_err(mac->dev, "unsupported interface %d", plat_dat->interface); + return -EINVAL; + } + + /* Update MAC PHY control register */ + return regmap_update_bits(mac->regmap, 0, mac->soc_info->mask, val); +} + +static int x2000_mac_set_mode(struct plat_stmmacenet_data *plat_dat) +{ + struct ingenic_mac *mac = plat_dat->bsp_priv; + unsigned int val; + + switch (plat_dat->interface) { + case PHY_INTERFACE_MODE_RMII: + val = FIELD_PREP(MACPHYC_TX_SEL_MASK, MACPHYC_TX_SEL_ORIGIN) | + FIELD_PREP(MACPHYC_RX_SEL_MASK, MACPHYC_RX_SEL_ORIGIN) | + FIELD_PREP(MACPHYC_PHY_INFT_MASK, MACPHYC_PHY_INFT_RMII); + dev_dbg(mac->dev, "MAC PHY Control Register: PHY_INTERFACE_MODE_RMII\n"); + break; + + case PHY_INTERFACE_MODE_RGMII: + val = FIELD_PREP(MACPHYC_PHY_INFT_MASK, MACPHYC_PHY_INFT_RGMII); + + if (mac->tx_delay == 0) { + val |= FIELD_PREP(MACPHYC_TX_SEL_MASK, MACPHYC_TX_SEL_ORIGIN); + } else { + val |= FIELD_PREP(MACPHYC_TX_SEL_MASK, MACPHYC_TX_SEL_DELAY); + + if (mac->tx_delay > MACPHYC_TX_DELAY_MAX) + val |= FIELD_PREP(MACPHYC_TX_DELAY_MASK, MACPHYC_TX_DELAY_MAX - 1); + else + val |= FIELD_PREP(MACPHYC_TX_DELAY_MASK, mac->tx_delay - 1); + } + + if (mac->rx_delay == 0) { + val |= FIELD_PREP(MACPHYC_RX_SEL_MASK, MACPHYC_RX_SEL_ORIGIN); + } else { + val |= FIELD_PREP(MACPHYC_RX_SEL_MASK, MACPHYC_RX_SEL_DELAY); + + if (mac->rx_delay > MACPHYC_RX_DELAY_MAX) + val |= FIELD_PREP(MACPHYC_RX_DELAY_MASK, MACPHYC_RX_DELAY_MAX - 1); + else + val |= FIELD_PREP(MACPHYC_RX_DELAY_MASK, mac->rx_delay - 1); + } + + dev_dbg(mac->dev, "MAC PHY Control Register: PHY_INTERFACE_MODE_RGMII\n"); + break; + + case PHY_INTERFACE_MODE_RGMII_ID: + val = FIELD_PREP(MACPHYC_TX_SEL_MASK, MACPHYC_TX_SEL_ORIGIN) | + FIELD_PREP(MACPHYC_RX_SEL_MASK, MACPHYC_RX_SEL_ORIGIN) | + FIELD_PREP(MACPHYC_PHY_INFT_MASK, MACPHYC_PHY_INFT_RGMII); + dev_dbg(mac->dev, "MAC PHY Control Register: PHY_INTERFACE_MODE_RGMII_ID\n"); + break; + + case PHY_INTERFACE_MODE_RGMII_RXID: + val = FIELD_PREP(MACPHYC_PHY_INFT_MASK, MACPHYC_PHY_INFT_RGMII) | + FIELD_PREP(MACPHYC_RX_SEL_MASK, MACPHYC_RX_SEL_ORIGIN); + + if (mac->tx_delay == 0) { + val |= FIELD_PREP(MACPHYC_TX_SEL_MASK, MACPHYC_TX_SEL_ORIGIN); + } else { + val |= FIELD_PREP(MACPHYC_TX_SEL_MASK, MACPHYC_TX_SEL_DELAY); + + if (mac->tx_delay > MACPHYC_TX_DELAY_MAX) + val |= FIELD_PREP(MACPHYC_TX_DELAY_MASK, MACPHYC_TX_DELAY_MAX - 1); + else + val |= FIELD_PREP(MACPHYC_TX_DELAY_MASK, mac->tx_delay - 1); + } + + dev_dbg(mac->dev, "MAC PHY Control Register: PHY_INTERFACE_MODE_RGMII_RXID\n"); + break; + + case PHY_INTERFACE_MODE_RGMII_TXID: + val = FIELD_PREP(MACPHYC_PHY_INFT_MASK, MACPHYC_PHY_INFT_RGMII) | + FIELD_PREP(MACPHYC_TX_SEL_MASK, MACPHYC_TX_SEL_ORIGIN); + + if (mac->rx_delay == 0) { + val |= FIELD_PREP(MACPHYC_RX_SEL_MASK, MACPHYC_RX_SEL_ORIGIN); + } else { + val |= FIELD_PREP(MACPHYC_RX_SEL_MASK, MACPHYC_RX_SEL_DELAY); + + if (mac->rx_delay > MACPHYC_RX_DELAY_MAX) + val |= FIELD_PREP(MACPHYC_RX_DELAY_MASK, MACPHYC_RX_DELAY_MAX - 1); + else + val |= FIELD_PREP(MACPHYC_RX_DELAY_MASK, mac->rx_delay - 1); + } + + dev_dbg(mac->dev, "MAC PHY Control Register: PHY_INTERFACE_MODE_RGMII_TXID\n"); + break; + + default: + dev_err(mac->dev, "unsupported interface %d", plat_dat->interface); + return -EINVAL; + } + + /* Update MAC PHY control register */ + return regmap_update_bits(mac->regmap, 0, mac->soc_info->mask, val); +} + +static int ingenic_mac_probe(struct platform_device *pdev) +{ + struct plat_stmmacenet_data *plat_dat; + struct stmmac_resources stmmac_res; + struct ingenic_mac *mac; + const struct ingenic_soc_info *data; + int ret; + + ret = stmmac_get_platform_resources(pdev, &stmmac_res); + if (ret) + return ret; + + plat_dat = stmmac_probe_config_dt(pdev, stmmac_res.mac); + if (IS_ERR(plat_dat)) + return PTR_ERR(plat_dat); + + mac = devm_kzalloc(&pdev->dev, sizeof(*mac), GFP_KERNEL); + if (!mac) { + ret = -ENOMEM; + goto err_remove_config_dt; + } + + data = of_device_get_match_data(&pdev->dev); + if (!data) { + dev_err(&pdev->dev, "no of match data provided\n"); + ret = -EINVAL; + goto err_remove_config_dt; + } + + /* Get MAC PHY control register */ + mac->regmap = syscon_regmap_lookup_by_phandle(pdev->dev.of_node, "mode-reg"); + if (IS_ERR(mac->regmap)) { + dev_err(&pdev->dev, "%s: failed to get syscon regmap\n", __func__); + goto err_remove_config_dt; + } + + ret = of_property_read_u32(pdev->dev.of_node, "rx-clk-delay", &mac->rx_delay); + if (ret) + mac->rx_delay = 0; + + ret = of_property_read_u32(pdev->dev.of_node, "tx-clk-delay", &mac->tx_delay); + if (ret) + mac->tx_delay = 0; + + mac->soc_info = data; + mac->dev = &pdev->dev; + + plat_dat->bsp_priv = mac; + + ret = ingenic_mac_init(plat_dat); + if (ret) + goto err_remove_config_dt; + + ret = stmmac_dvr_probe(&pdev->dev, plat_dat, &stmmac_res); + if (ret) + goto err_remove_config_dt; + + return 0; + +err_remove_config_dt: + stmmac_remove_config_dt(pdev, plat_dat); + + return ret; +} + +#ifdef CONFIG_PM_SLEEP +static int ingenic_mac_suspend(struct device *dev) +{ + struct net_device *ndev = dev_get_drvdata(dev); + struct stmmac_priv *priv = netdev_priv(ndev); + struct ingenic_mac *mac = priv->plat->bsp_priv; + int ret; + + ret = stmmac_suspend(dev); + + return ret; +} + +static int ingenic_mac_resume(struct device *dev) +{ + struct net_device *ndev = dev_get_drvdata(dev); + struct stmmac_priv *priv = netdev_priv(ndev); + struct ingenic_mac *mac = priv->plat->bsp_priv; + int ret; + + ret = ingenic_mac_init(priv->plat); + if (ret) + return ret; + + ret = stmmac_resume(dev); + + return ret; +} +#endif /* CONFIG_PM_SLEEP */ + +static SIMPLE_DEV_PM_OPS(ingenic_mac_pm_ops, ingenic_mac_suspend, ingenic_mac_resume); + +static struct ingenic_soc_info jz4775_soc_info = { + .version = ID_JZ4775, + .mask = MACPHYC_TXCLK_SEL_MASK | MACPHYC_SOFT_RST_MASK | MACPHYC_PHY_INFT_MASK, + + .set_mode = jz4775_mac_set_mode, +}; + +static struct ingenic_soc_info x1000_soc_info = { + .version = ID_X1000, + .mask = MACPHYC_SOFT_RST_MASK, + + .set_mode = x1000_mac_set_mode, +}; + +static struct ingenic_soc_info x1600_soc_info = { + .version = ID_X1600, + .mask = MACPHYC_SOFT_RST_MASK | MACPHYC_PHY_INFT_MASK, + + .set_mode = x1600_mac_set_mode, +}; + +static struct ingenic_soc_info x1830_soc_info = { + .version = ID_X1830, + .mask = MACPHYC_MODE_SEL_MASK | MACPHYC_SOFT_RST_MASK | MACPHYC_PHY_INFT_MASK, + + .set_mode = x1830_mac_set_mode, +}; + +static struct ingenic_soc_info x2000_soc_info = { + .version = ID_X2000, + .mask = MACPHYC_TX_SEL_MASK | MACPHYC_TX_DELAY_MASK | MACPHYC_RX_SEL_MASK | + MACPHYC_RX_DELAY_MASK | MACPHYC_SOFT_RST_MASK | MACPHYC_PHY_INFT_MASK, + + .set_mode = x2000_mac_set_mode, +}; + +static const struct of_device_id ingenic_mac_of_matches[] = { + { .compatible = "ingenic,jz4775-mac", .data = &jz4775_soc_info }, + { .compatible = "ingenic,x1000-mac", .data = &x1000_soc_info }, + { .compatible = "ingenic,x1600-mac", .data = &x1600_soc_info }, + { .compatible = "ingenic,x1830-mac", .data = &x1830_soc_info }, + { .compatible = "ingenic,x2000-mac", .data = &x2000_soc_info }, + { } +}; +MODULE_DEVICE_TABLE(of, ingenic_mac_of_matches); + +static struct platform_driver ingenic_mac_driver = { + .probe = ingenic_mac_probe, + .remove = stmmac_pltfr_remove, + .driver = { + .name = "ingenic-mac", + .pm = pm_ptr(&ingenic_mac_pm_ops), + .of_match_table = ingenic_mac_of_matches, + }, +}; +module_platform_driver(ingenic_mac_driver); + +MODULE_AUTHOR("周琰杰 (Zhou Yanjie) "); +MODULE_DESCRIPTION("Ingenic SoCs DWMAC specific glue layer"); +MODULE_LICENSE("GPL v2"); -- 2.7.4 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=-16.9 required=3.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER, INCLUDES_PATCH,MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,UNPARSEABLE_RELAY, 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 61F05C48BCD for ; Wed, 9 Jun 2021 17:51:06 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (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 2F40E613CB for ; Wed, 9 Jun 2021 17:51:06 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 2F40E613CB Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=wanyeetech.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Message-Id:Date:Subject:Cc:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=0oiWrN9RGZcVDlpdo7MSDjMDr6x/oUONe3P+vozeCSs=; b=3g0JopfHx32ifB mSSOumeaiOjviywwA9XgTd9Hl7+HmWFrCOukZplFVyK+y5RFfzX90opB4z/Z+95hx/mc5szHH1xyK llwSoshTOQaG01cHtrbvQ+kytktkaOvpJuqVyfdbNdPSTOtVgIXCv7m2aCPy6a7BnCurzgm2T5ZMl 9TdVACuEz0SvSB5UylDx1TUx80kBIEuG36mY/kPBuzrRGFvuf94UJ6BUHMtM04tVJPEjBRyblByky ZE3e2EKvx+ELFMqLNPWqzqLdj5vJmh5S1uXau6l+VoWcB+hdzVV5D6muJEV9vQmBiKNIMZvrgv4/W SCZiG5Ns/Kew/jEyqW7w==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1lr2KB-00FPv8-Th; Wed, 09 Jun 2021 17:49:08 +0000 Received: from out28-121.mail.aliyun.com ([115.124.28.121]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1lr278-00FL33-1h for linux-arm-kernel@lists.infradead.org; Wed, 09 Jun 2021 17:35:41 +0000 X-Alimail-AntiSpam: AC=CONTINUE; BC=0.07436282|-1; CH=green; DM=|CONTINUE|false|; DS=CONTINUE|ham_system_inform|0.0239554-0.000423683-0.975621; FP=0|0|0|0|0|-1|-1|-1; HT=ay29a033018047206; MF=zhouyanjie@wanyeetech.com; NM=1; PH=DS; RN=20; RT=20; SR=0; TI=SMTPD_---.KQ26pE3_1623260120; Received: from localhost.localdomain(mailfrom:zhouyanjie@wanyeetech.com fp:SMTPD_---.KQ26pE3_1623260120) by smtp.aliyun-inc.com(10.147.41.138); Thu, 10 Jun 2021 01:35:32 +0800 From: =?UTF-8?q?=E5=91=A8=E7=90=B0=E6=9D=B0=20=28Zhou=20Yanjie=29?= To: davem@davemloft.net, kuba@kernel.org, robh+dt@kernel.org, peppe.cavallaro@st.com, alexandre.torgue@foss.st.com, joabreu@synopsys.com, mcoquelin.stm32@gmail.com Cc: linux-mips@vger.kernel.org, linux-kernel@vger.kernel.org, netdev@vger.kernel.org, devicetree@vger.kernel.org, linux-stm32@st-md-mailman.stormreply.com, linux-arm-kernel@lists.infradead.org, dongsheng.qiu@ingenic.com, aric.pzqi@ingenic.com, rick.tyliu@ingenic.com, sihui.liu@ingenic.com, jun.jiang@ingenic.com, sernia.zhou@foxmail.com, paul@crapouillou.net Subject: [PATCH v2 2/2] net: stmmac: Add Ingenic SoCs MAC support. Date: Thu, 10 Jun 2021 01:35:10 +0800 Message-Id: <1623260110-25842-3-git-send-email-zhouyanjie@wanyeetech.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1623260110-25842-1-git-send-email-zhouyanjie@wanyeetech.com> References: <1623260110-25842-1-git-send-email-zhouyanjie@wanyeetech.com> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20210609_103538_525991_F25D095F X-CRM114-Status: GOOD ( 22.59 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org QWRkIHN1cHBvcnQgZm9yIEluZ2VuaWMgU29DIE1BQyBnbHVlIGxheWVyIHN1cHBvcnQgZm9yIHRo ZSBzdG1tYWMKZGV2aWNlIGRyaXZlci4gVGhpcyBkcml2ZXIgaXMgdXNlZCBvbiBmb3IgdGhlIE1B QyBldGhlcm5ldCBjb250cm9sbGVyCmZvdW5kIGluIHRoZSBKWjQ3NzUgU29DLCB0aGUgWDEwMDAg U29DLCB0aGUgWDE2MDAgU29DLCB0aGUgWDE4MzAgU29DLAphbmQgdGhlIFgyMDAwIFNvQy4KClNp Z25lZC1vZmYtYnk6IOWRqOeQsOadsCAoWmhvdSBZYW5qaWUpIDx6aG91eWFuamllQHdhbnllZXRl Y2guY29tPgotLS0KCk5vdGVzOgogICAgdjEtPnYyOgogICAgMS5GaXggdW5pbml0aWFsaXplZCB2 YXJpYWJsZS4KICAgIDIuQWRkIG1pc3NpbmcgUkdNSUktSUQsIFJHTUlJLVJYSUQsIGFuZCBSR01J SS1UWElELgogICAgMy5DaGFuZ2UgdmFyaWFibGUgdmFsIGZyb20gaW50IHRvIHVuc2luZ2VkIGlu dC4KICAgIDQuR2V0IHR4IGNsb2NrIGRlbGF5IGFuZCByeCBjbG9jayBkZWxheSBmcm9tIGRldmlj ZXRyZWUuCgogZHJpdmVycy9uZXQvZXRoZXJuZXQvc3RtaWNyby9zdG1tYWMvS2NvbmZpZyAgICAg ICAgfCAgMTIgKwogZHJpdmVycy9uZXQvZXRoZXJuZXQvc3RtaWNyby9zdG1tYWMvTWFrZWZpbGUg ICAgICAgfCAgIDEgKwogLi4uL25ldC9ldGhlcm5ldC9zdG1pY3JvL3N0bW1hYy9kd21hYy1pbmdl bmljLmMgICAgfCA0MzQgKysrKysrKysrKysrKysrKysrKysrCiAzIGZpbGVzIGNoYW5nZWQsIDQ0 NyBpbnNlcnRpb25zKCspCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9uZXQvZXRoZXJuZXQv c3RtaWNyby9zdG1tYWMvZHdtYWMtaW5nZW5pYy5jCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQv ZXRoZXJuZXQvc3RtaWNyby9zdG1tYWMvS2NvbmZpZyBiL2RyaXZlcnMvbmV0L2V0aGVybmV0L3N0 bWljcm8vc3RtbWFjL0tjb25maWcKaW5kZXggNzczN2U0ZDAuLjlhMTllNGQgMTAwNjQ0Ci0tLSBh L2RyaXZlcnMvbmV0L2V0aGVybmV0L3N0bWljcm8vc3RtbWFjL0tjb25maWcKKysrIGIvZHJpdmVy cy9uZXQvZXRoZXJuZXQvc3RtaWNyby9zdG1tYWMvS2NvbmZpZwpAQCAtNjYsNiArNjYsMTggQEAg Y29uZmlnIERXTUFDX0FOQVJJT04KIAogCSAgVGhpcyBzZWxlY3RzIHRoZSBBbmFyaW9uIFNvQyBn bHVlIGxheWVyIHN1cHBvcnQgZm9yIHRoZSBzdG1tYWMgZHJpdmVyLgogCitjb25maWcgRFdNQUNf SU5HRU5JQworCXRyaXN0YXRlICJJbmdlbmljIE1BQyBzdXBwb3J0IgorCWRlZmF1bHQgTUFDSF9J TkdFTklDCisJZGVwZW5kcyBvbiBPRiAmJiBIQVNfSU9NRU0gJiYgKE1BQ0hfSU5HRU5JQyB8fCBD T01QSUxFX1RFU1QpCisJc2VsZWN0IE1GRF9TWVNDT04KKwloZWxwCisJICBTdXBwb3J0IGZvciBl dGhlcm5ldCBjb250cm9sbGVyIG9uIEluZ2VuaWMgU29Dcy4KKworCSAgVGhpcyBzZWxlY3RzIElu Z2VuaWMgU29DcyBnbHVlIGxheWVyIHN1cHBvcnQgZm9yIHRoZSBzdG1tYWMKKwkgIGRldmljZSBk cml2ZXIuIFRoaXMgZHJpdmVyIGlzIHVzZWQgb24gZm9yIHRoZSBJbmdlbmljIFNvQ3MKKwkgIE1B QyBldGhlcm5ldCBjb250cm9sbGVyLgorCiBjb25maWcgRFdNQUNfSVBRODA2WAogCXRyaXN0YXRl ICJRQ0EgSVBRODA2eCBEV01BQyBzdXBwb3J0IgogCWRlZmF1bHQgQVJDSF9RQ09NCmRpZmYgLS1n aXQgYS9kcml2ZXJzL25ldC9ldGhlcm5ldC9zdG1pY3JvL3N0bW1hYy9NYWtlZmlsZSBiL2RyaXZl cnMvbmV0L2V0aGVybmV0L3N0bWljcm8vc3RtbWFjL01ha2VmaWxlCmluZGV4IGYyZTQ3OGIuLjY0 NzFmOTMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2V0aGVybmV0L3N0bWljcm8vc3RtbWFjL01h a2VmaWxlCisrKyBiL2RyaXZlcnMvbmV0L2V0aGVybmV0L3N0bWljcm8vc3RtbWFjL01ha2VmaWxl CkBAIC0xNCw2ICsxNCw3IEBAIHN0bW1hYy0kKENPTkZJR19TVE1NQUNfU0VMRlRFU1RTKSArPSBz dG1tYWNfc2VsZnRlc3RzLm8KICMgT3JkZXJpbmcgbWF0dGVycy4gR2VuZXJpYyBkcml2ZXIgbXVz dCBiZSBsYXN0Lgogb2JqLSQoQ09ORklHX1NUTU1BQ19QTEFURk9STSkJKz0gc3RtbWFjLXBsYXRm b3JtLm8KIG9iai0kKENPTkZJR19EV01BQ19BTkFSSU9OKQkrPSBkd21hYy1hbmFyaW9uLm8KK29i ai0kKENPTkZJR19EV01BQ19JTkdFTklDKQkrPSBkd21hYy1pbmdlbmljLm8KIG9iai0kKENPTkZJ R19EV01BQ19JUFE4MDZYKQkrPSBkd21hYy1pcHE4MDZ4Lm8KIG9iai0kKENPTkZJR19EV01BQ19M UEMxOFhYKQkrPSBkd21hYy1scGMxOHh4Lm8KIG9iai0kKENPTkZJR19EV01BQ19NRURJQVRFSykJ Kz0gZHdtYWMtbWVkaWF0ZWsubwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvZXRoZXJuZXQvc3Rt aWNyby9zdG1tYWMvZHdtYWMtaW5nZW5pYy5jIGIvZHJpdmVycy9uZXQvZXRoZXJuZXQvc3RtaWNy by9zdG1tYWMvZHdtYWMtaW5nZW5pYy5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAwLi5mYmUyNzI3Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9uZXQvZXRoZXJuZXQvc3Rt aWNyby9zdG1tYWMvZHdtYWMtaW5nZW5pYy5jCkBAIC0wLDAgKzEsNDM0IEBACisvLyBTUERYLUxp Y2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMAorLyoKKyAqIGR3bWFjLWluZ2VuaWMuYyAtIEluZ2Vu aWMgU29DcyBEV01BQyBzcGVjaWZpYyBnbHVlIGxheWVyCisgKgorICogQ29weXJpZ2h0IChjKSAy MDIxIOWRqOeQsOadsCAoWmhvdSBZYW5qaWUpIDx6aG91eWFuamllQHdhbnllZXRlY2guY29tPgor ICovCisKKyNpbmNsdWRlIDxsaW51eC9iaXRmaWVsZC5oPgorI2luY2x1ZGUgPGxpbnV4L2Nsay5o PgorI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgorI2luY2x1ZGUgPGxpbnV4L21mZC9zeXNjb24u aD4KKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KKyNpbmNsdWRlIDxsaW51eC9vZi5oPgorI2lu Y2x1ZGUgPGxpbnV4L29mX2RldmljZS5oPgorI2luY2x1ZGUgPGxpbnV4L29mX25ldC5oPgorI2lu Y2x1ZGUgPGxpbnV4L3BoeS5oPgorI2luY2x1ZGUgPGxpbnV4L3BsYXRmb3JtX2RldmljZS5oPgor I2luY2x1ZGUgPGxpbnV4L3JlZ21hcC5oPgorI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KKyNpbmNs dWRlIDxsaW51eC9zdG1tYWMuaD4KKworI2luY2x1ZGUgInN0bW1hY19wbGF0Zm9ybS5oIgorCisj ZGVmaW5lIE1BQ1BIWUNfVFhDTEtfU0VMX01BU0sJCUdFTk1BU0soMzEsIDMxKQorI2RlZmluZSBN QUNQSFlDX1RYQ0xLX1NFTF9PVVRQVVQJMHgxCisjZGVmaW5lIE1BQ1BIWUNfVFhDTEtfU0VMX0lO UFVUCQkweDAKKyNkZWZpbmUgTUFDUEhZQ19NT0RFX1NFTF9NQVNLCQlHRU5NQVNLKDMxLCAzMSkK KyNkZWZpbmUgTUFDUEhZQ19NT0RFX1NFTF9STUlJCQkweDAKKyNkZWZpbmUgTUFDUEhZQ19UWF9T RUxfTUFTSwkJCUdFTk1BU0soMTksIDE5KQorI2RlZmluZSBNQUNQSFlDX1RYX1NFTF9PUklHSU4J CTB4MAorI2RlZmluZSBNQUNQSFlDX1RYX1NFTF9ERUxBWQkJMHgxCisjZGVmaW5lIE1BQ1BIWUNf VFhfREVMQVlfTUFTSwkJR0VOTUFTSygxOCwgMTIpCisjZGVmaW5lIE1BQ1BIWUNfVFhfREVMQVlf TUFYCQkweDgwCisjZGVmaW5lIE1BQ1BIWUNfUlhfU0VMX01BU0sJCQlHRU5NQVNLKDExLCAxMSkK KyNkZWZpbmUgTUFDUEhZQ19SWF9TRUxfT1JJR0lOCQkweDAKKyNkZWZpbmUgTUFDUEhZQ19SWF9T RUxfREVMQVkJCTB4MQorI2RlZmluZSBNQUNQSFlDX1JYX0RFTEFZX01BU0sJCUdFTk1BU0soMTAs IDQpCisjZGVmaW5lIE1BQ1BIWUNfUlhfREVMQVlfTUFYCQkweDgwCisjZGVmaW5lIE1BQ1BIWUNf U09GVF9SU1RfTUFTSwkJR0VOTUFTSygzLCAzKQorI2RlZmluZSBNQUNQSFlDX1BIWV9JTkZUX01B U0sJCUdFTk1BU0soMiwgMCkKKyNkZWZpbmUgTUFDUEhZQ19QSFlfSU5GVF9STUlJCQkweDQKKyNk ZWZpbmUgTUFDUEhZQ19QSFlfSU5GVF9SR01JSQkJMHgxCisjZGVmaW5lIE1BQ1BIWUNfUEhZX0lO RlRfR01JSQkJMHgwCisjZGVmaW5lIE1BQ1BIWUNfUEhZX0lORlRfTUlJCQkweDAKKworZW51bSBp bmdlbmljX21hY192ZXJzaW9uIHsKKwlJRF9KWjQ3NzUsCisJSURfWDEwMDAsCisJSURfWDE2MDAs CisJSURfWDE4MzAsCisJSURfWDIwMDAsCit9OworCitzdHJ1Y3QgaW5nZW5pY19tYWMgeworCWNv bnN0IHN0cnVjdCBpbmdlbmljX3NvY19pbmZvICpzb2NfaW5mbzsKKwlzdHJ1Y3QgZGV2aWNlICpk ZXY7CisJc3RydWN0IHJlZ21hcCAqcmVnbWFwOworCisJaW50IHJ4X2RlbGF5OworCWludCB0eF9k ZWxheTsKK307CisKK3N0cnVjdCBpbmdlbmljX3NvY19pbmZvIHsKKwllbnVtIGluZ2VuaWNfbWFj X3ZlcnNpb24gdmVyc2lvbjsKKwl1MzIgbWFzazsKKworCWludCAoKnNldF9tb2RlKShzdHJ1Y3Qg cGxhdF9zdG1tYWNlbmV0X2RhdGEgKnBsYXRfZGF0KTsKK307CisKK3N0YXRpYyBpbnQgaW5nZW5p Y19tYWNfaW5pdChzdHJ1Y3QgcGxhdF9zdG1tYWNlbmV0X2RhdGEgKnBsYXRfZGF0KQoreworCXN0 cnVjdCBpbmdlbmljX21hYyAqbWFjID0gcGxhdF9kYXQtPmJzcF9wcml2OworCWludCByZXQ7CisK KwlpZiAobWFjLT5zb2NfaW5mby0+c2V0X21vZGUpIHsKKwkJcmV0ID0gbWFjLT5zb2NfaW5mby0+ c2V0X21vZGUocGxhdF9kYXQpOworCQlpZiAocmV0KQorCQkJcmV0dXJuIHJldDsKKwl9CisKKwly ZXR1cm4gMDsKK30KKworc3RhdGljIGludCBqejQ3NzVfbWFjX3NldF9tb2RlKHN0cnVjdCBwbGF0 X3N0bW1hY2VuZXRfZGF0YSAqcGxhdF9kYXQpCit7CisJc3RydWN0IGluZ2VuaWNfbWFjICptYWMg PSBwbGF0X2RhdC0+YnNwX3ByaXY7CisJdW5zaWduZWQgaW50IHZhbDsKKworCXN3aXRjaCAocGxh dF9kYXQtPmludGVyZmFjZSkgeworCWNhc2UgUEhZX0lOVEVSRkFDRV9NT0RFX01JSToKKwkJdmFs ID0gRklFTERfUFJFUChNQUNQSFlDX1RYQ0xLX1NFTF9NQVNLLCBNQUNQSFlDX1RYQ0xLX1NFTF9J TlBVVCkgfAorCQkJICBGSUVMRF9QUkVQKE1BQ1BIWUNfUEhZX0lORlRfTUFTSywgTUFDUEhZQ19Q SFlfSU5GVF9NSUkpOworCQlkZXZfZGJnKG1hYy0+ZGV2LCAiTUFDIFBIWSBDb250cm9sIFJlZ2lz dGVyOiBQSFlfSU5URVJGQUNFX01PREVfTUlJXG4iKTsKKwkJYnJlYWs7CisKKwljYXNlIFBIWV9J TlRFUkZBQ0VfTU9ERV9HTUlJOgorCQl2YWwgPSBGSUVMRF9QUkVQKE1BQ1BIWUNfVFhDTEtfU0VM X01BU0ssIE1BQ1BIWUNfVFhDTEtfU0VMX0lOUFVUKSB8CisJCQkgIEZJRUxEX1BSRVAoTUFDUEhZ Q19QSFlfSU5GVF9NQVNLLCBNQUNQSFlDX1BIWV9JTkZUX0dNSUkpOworCQlkZXZfZGJnKG1hYy0+ ZGV2LCAiTUFDIFBIWSBDb250cm9sIFJlZ2lzdGVyOiBQSFlfSU5URVJGQUNFX01PREVfR01JSVxu Iik7CisJCWJyZWFrOworCisJY2FzZSBQSFlfSU5URVJGQUNFX01PREVfUk1JSToKKwkJdmFsID0g RklFTERfUFJFUChNQUNQSFlDX1RYQ0xLX1NFTF9NQVNLLCBNQUNQSFlDX1RYQ0xLX1NFTF9JTlBV VCkgfAorCQkJICBGSUVMRF9QUkVQKE1BQ1BIWUNfUEhZX0lORlRfTUFTSywgTUFDUEhZQ19QSFlf SU5GVF9STUlJKTsKKwkJZGV2X2RiZyhtYWMtPmRldiwgIk1BQyBQSFkgQ29udHJvbCBSZWdpc3Rl cjogUEhZX0lOVEVSRkFDRV9NT0RFX1JNSUlcbiIpOworCQlicmVhazsKKworCWNhc2UgUEhZX0lO VEVSRkFDRV9NT0RFX1JHTUlJOgorCWNhc2UgUEhZX0lOVEVSRkFDRV9NT0RFX1JHTUlJX0lEOgor CWNhc2UgUEhZX0lOVEVSRkFDRV9NT0RFX1JHTUlJX1JYSUQ6CisJY2FzZSBQSFlfSU5URVJGQUNF X01PREVfUkdNSUlfVFhJRDoKKwkJdmFsID0gRklFTERfUFJFUChNQUNQSFlDX1RYQ0xLX1NFTF9N QVNLLCBNQUNQSFlDX1RYQ0xLX1NFTF9JTlBVVCkgfAorCQkJICBGSUVMRF9QUkVQKE1BQ1BIWUNf UEhZX0lORlRfTUFTSywgTUFDUEhZQ19QSFlfSU5GVF9SR01JSSk7CisJCWRldl9kYmcobWFjLT5k ZXYsICJNQUMgUEhZIENvbnRyb2wgUmVnaXN0ZXI6IFBIWV9JTlRFUkZBQ0VfTU9ERV9SR01JSVxu Iik7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJZGV2X2VycihtYWMtPmRldiwgInVuc3VwcG9y dGVkIGludGVyZmFjZSAlZCIsIHBsYXRfZGF0LT5pbnRlcmZhY2UpOworCQlyZXR1cm4gLUVJTlZB TDsKKwl9CisKKwkvKiBVcGRhdGUgTUFDIFBIWSBjb250cm9sIHJlZ2lzdGVyICovCisJcmV0dXJu IHJlZ21hcF91cGRhdGVfYml0cyhtYWMtPnJlZ21hcCwgMCwgbWFjLT5zb2NfaW5mby0+bWFzaywg dmFsKTsKK30KKworc3RhdGljIGludCB4MTAwMF9tYWNfc2V0X21vZGUoc3RydWN0IHBsYXRfc3Rt bWFjZW5ldF9kYXRhICpwbGF0X2RhdCkKK3sKKwlzdHJ1Y3QgaW5nZW5pY19tYWMgKm1hYyA9IHBs YXRfZGF0LT5ic3BfcHJpdjsKKworCXN3aXRjaCAocGxhdF9kYXQtPmludGVyZmFjZSkgeworCWNh c2UgUEhZX0lOVEVSRkFDRV9NT0RFX1JNSUk6CisJCWRldl9kYmcobWFjLT5kZXYsICJNQUMgUEhZ IENvbnRyb2wgUmVnaXN0ZXI6IFBIWV9JTlRFUkZBQ0VfTU9ERV9STUlJXG4iKTsKKwkJYnJlYWs7 CisKKwlkZWZhdWx0OgorCQlkZXZfZXJyKG1hYy0+ZGV2LCAidW5zdXBwb3J0ZWQgaW50ZXJmYWNl ICVkIiwgcGxhdF9kYXQtPmludGVyZmFjZSk7CisJCXJldHVybiAtRUlOVkFMOworCX0KKworCS8q IFVwZGF0ZSBNQUMgUEhZIGNvbnRyb2wgcmVnaXN0ZXIgKi8KKwlyZXR1cm4gcmVnbWFwX3VwZGF0 ZV9iaXRzKG1hYy0+cmVnbWFwLCAwLCBtYWMtPnNvY19pbmZvLT5tYXNrLCAwKTsKK30KKworc3Rh dGljIGludCB4MTYwMF9tYWNfc2V0X21vZGUoc3RydWN0IHBsYXRfc3RtbWFjZW5ldF9kYXRhICpw bGF0X2RhdCkKK3sKKwlzdHJ1Y3QgaW5nZW5pY19tYWMgKm1hYyA9IHBsYXRfZGF0LT5ic3BfcHJp djsKKwl1bnNpZ25lZCBpbnQgdmFsOworCisJc3dpdGNoIChwbGF0X2RhdC0+aW50ZXJmYWNlKSB7 CisJY2FzZSBQSFlfSU5URVJGQUNFX01PREVfUk1JSToKKwkJdmFsID0gRklFTERfUFJFUChNQUNQ SFlDX1BIWV9JTkZUX01BU0ssIE1BQ1BIWUNfUEhZX0lORlRfUk1JSSk7CisJCWRldl9kYmcobWFj LT5kZXYsICJNQUMgUEhZIENvbnRyb2wgUmVnaXN0ZXI6IFBIWV9JTlRFUkZBQ0VfTU9ERV9STUlJ XG4iKTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQlkZXZfZXJyKG1hYy0+ZGV2LCAidW5zdXBw b3J0ZWQgaW50ZXJmYWNlICVkIiwgcGxhdF9kYXQtPmludGVyZmFjZSk7CisJCXJldHVybiAtRUlO VkFMOworCX0KKworCS8qIFVwZGF0ZSBNQUMgUEhZIGNvbnRyb2wgcmVnaXN0ZXIgKi8KKwlyZXR1 cm4gcmVnbWFwX3VwZGF0ZV9iaXRzKG1hYy0+cmVnbWFwLCAwLCBtYWMtPnNvY19pbmZvLT5tYXNr LCB2YWwpOworfQorCitzdGF0aWMgaW50IHgxODMwX21hY19zZXRfbW9kZShzdHJ1Y3QgcGxhdF9z dG1tYWNlbmV0X2RhdGEgKnBsYXRfZGF0KQoreworCXN0cnVjdCBpbmdlbmljX21hYyAqbWFjID0g cGxhdF9kYXQtPmJzcF9wcml2OworCXVuc2lnbmVkIGludCB2YWw7CisKKwlzd2l0Y2ggKHBsYXRf ZGF0LT5pbnRlcmZhY2UpIHsKKwljYXNlIFBIWV9JTlRFUkZBQ0VfTU9ERV9STUlJOgorCQl2YWwg PSBGSUVMRF9QUkVQKE1BQ1BIWUNfTU9ERV9TRUxfTUFTSywgTUFDUEhZQ19NT0RFX1NFTF9STUlJ KSB8CisJCQkgIEZJRUxEX1BSRVAoTUFDUEhZQ19QSFlfSU5GVF9NQVNLLCBNQUNQSFlDX1BIWV9J TkZUX1JNSUkpOworCQlkZXZfZGJnKG1hYy0+ZGV2LCAiTUFDIFBIWSBDb250cm9sIFJlZ2lzdGVy OiBQSFlfSU5URVJGQUNFX01PREVfUk1JSVxuIik7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJ ZGV2X2VycihtYWMtPmRldiwgInVuc3VwcG9ydGVkIGludGVyZmFjZSAlZCIsIHBsYXRfZGF0LT5p bnRlcmZhY2UpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKKwkvKiBVcGRhdGUgTUFDIFBIWSBj b250cm9sIHJlZ2lzdGVyICovCisJcmV0dXJuIHJlZ21hcF91cGRhdGVfYml0cyhtYWMtPnJlZ21h cCwgMCwgbWFjLT5zb2NfaW5mby0+bWFzaywgdmFsKTsKK30KKworc3RhdGljIGludCB4MjAwMF9t YWNfc2V0X21vZGUoc3RydWN0IHBsYXRfc3RtbWFjZW5ldF9kYXRhICpwbGF0X2RhdCkKK3sKKwlz dHJ1Y3QgaW5nZW5pY19tYWMgKm1hYyA9IHBsYXRfZGF0LT5ic3BfcHJpdjsKKwl1bnNpZ25lZCBp bnQgdmFsOworCisJc3dpdGNoIChwbGF0X2RhdC0+aW50ZXJmYWNlKSB7CisJY2FzZSBQSFlfSU5U RVJGQUNFX01PREVfUk1JSToKKwkJdmFsID0gRklFTERfUFJFUChNQUNQSFlDX1RYX1NFTF9NQVNL LCBNQUNQSFlDX1RYX1NFTF9PUklHSU4pIHwKKwkJCSAgRklFTERfUFJFUChNQUNQSFlDX1JYX1NF TF9NQVNLLCBNQUNQSFlDX1JYX1NFTF9PUklHSU4pIHwKKwkJCSAgRklFTERfUFJFUChNQUNQSFlD X1BIWV9JTkZUX01BU0ssIE1BQ1BIWUNfUEhZX0lORlRfUk1JSSk7CisJCWRldl9kYmcobWFjLT5k ZXYsICJNQUMgUEhZIENvbnRyb2wgUmVnaXN0ZXI6IFBIWV9JTlRFUkZBQ0VfTU9ERV9STUlJXG4i KTsKKwkJYnJlYWs7CisKKwljYXNlIFBIWV9JTlRFUkZBQ0VfTU9ERV9SR01JSToKKwkJdmFsID0g RklFTERfUFJFUChNQUNQSFlDX1BIWV9JTkZUX01BU0ssIE1BQ1BIWUNfUEhZX0lORlRfUkdNSUkp OworCisJCWlmIChtYWMtPnR4X2RlbGF5ID09IDApIHsKKwkJCXZhbCB8PSBGSUVMRF9QUkVQKE1B Q1BIWUNfVFhfU0VMX01BU0ssIE1BQ1BIWUNfVFhfU0VMX09SSUdJTik7CisJCX0gZWxzZSB7CisJ CQl2YWwgfD0gRklFTERfUFJFUChNQUNQSFlDX1RYX1NFTF9NQVNLLCBNQUNQSFlDX1RYX1NFTF9E RUxBWSk7CisKKwkJCWlmIChtYWMtPnR4X2RlbGF5ID4gTUFDUEhZQ19UWF9ERUxBWV9NQVgpCisJ CQkJdmFsIHw9IEZJRUxEX1BSRVAoTUFDUEhZQ19UWF9ERUxBWV9NQVNLLCBNQUNQSFlDX1RYX0RF TEFZX01BWCAtIDEpOworCQkJZWxzZQorCQkJCXZhbCB8PSBGSUVMRF9QUkVQKE1BQ1BIWUNfVFhf REVMQVlfTUFTSywgbWFjLT50eF9kZWxheSAtIDEpOworCQl9CisKKwkJaWYgKG1hYy0+cnhfZGVs YXkgPT0gMCkgeworCQkJdmFsIHw9IEZJRUxEX1BSRVAoTUFDUEhZQ19SWF9TRUxfTUFTSywgTUFD UEhZQ19SWF9TRUxfT1JJR0lOKTsKKwkJfSBlbHNlIHsKKwkJCXZhbCB8PSBGSUVMRF9QUkVQKE1B Q1BIWUNfUlhfU0VMX01BU0ssIE1BQ1BIWUNfUlhfU0VMX0RFTEFZKTsKKworCQkJaWYgKG1hYy0+ cnhfZGVsYXkgPiBNQUNQSFlDX1JYX0RFTEFZX01BWCkKKwkJCQl2YWwgfD0gRklFTERfUFJFUChN QUNQSFlDX1JYX0RFTEFZX01BU0ssIE1BQ1BIWUNfUlhfREVMQVlfTUFYIC0gMSk7CisJCQllbHNl CisJCQkJdmFsIHw9IEZJRUxEX1BSRVAoTUFDUEhZQ19SWF9ERUxBWV9NQVNLLCBtYWMtPnJ4X2Rl bGF5IC0gMSk7CisJCX0KKworCQlkZXZfZGJnKG1hYy0+ZGV2LCAiTUFDIFBIWSBDb250cm9sIFJl Z2lzdGVyOiBQSFlfSU5URVJGQUNFX01PREVfUkdNSUlcbiIpOworCQlicmVhazsKKworCWNhc2Ug UEhZX0lOVEVSRkFDRV9NT0RFX1JHTUlJX0lEOgorCQl2YWwgPSBGSUVMRF9QUkVQKE1BQ1BIWUNf VFhfU0VMX01BU0ssIE1BQ1BIWUNfVFhfU0VMX09SSUdJTikgfAorCQkJICBGSUVMRF9QUkVQKE1B Q1BIWUNfUlhfU0VMX01BU0ssIE1BQ1BIWUNfUlhfU0VMX09SSUdJTikgfAorCQkJICBGSUVMRF9Q UkVQKE1BQ1BIWUNfUEhZX0lORlRfTUFTSywgTUFDUEhZQ19QSFlfSU5GVF9SR01JSSk7CisJCWRl dl9kYmcobWFjLT5kZXYsICJNQUMgUEhZIENvbnRyb2wgUmVnaXN0ZXI6IFBIWV9JTlRFUkZBQ0Vf TU9ERV9SR01JSV9JRFxuIik7CisJCWJyZWFrOworCisJY2FzZSBQSFlfSU5URVJGQUNFX01PREVf UkdNSUlfUlhJRDoKKwkJdmFsID0gRklFTERfUFJFUChNQUNQSFlDX1BIWV9JTkZUX01BU0ssIE1B Q1BIWUNfUEhZX0lORlRfUkdNSUkpIHwKKwkJCSAgRklFTERfUFJFUChNQUNQSFlDX1JYX1NFTF9N QVNLLCBNQUNQSFlDX1JYX1NFTF9PUklHSU4pOworCisJCWlmIChtYWMtPnR4X2RlbGF5ID09IDAp IHsKKwkJCXZhbCB8PSBGSUVMRF9QUkVQKE1BQ1BIWUNfVFhfU0VMX01BU0ssIE1BQ1BIWUNfVFhf U0VMX09SSUdJTik7CisJCX0gZWxzZSB7CisJCQl2YWwgfD0gRklFTERfUFJFUChNQUNQSFlDX1RY X1NFTF9NQVNLLCBNQUNQSFlDX1RYX1NFTF9ERUxBWSk7CisKKwkJCWlmIChtYWMtPnR4X2RlbGF5 ID4gTUFDUEhZQ19UWF9ERUxBWV9NQVgpCisJCQkJdmFsIHw9IEZJRUxEX1BSRVAoTUFDUEhZQ19U WF9ERUxBWV9NQVNLLCBNQUNQSFlDX1RYX0RFTEFZX01BWCAtIDEpOworCQkJZWxzZQorCQkJCXZh bCB8PSBGSUVMRF9QUkVQKE1BQ1BIWUNfVFhfREVMQVlfTUFTSywgbWFjLT50eF9kZWxheSAtIDEp OworCQl9CisKKwkJZGV2X2RiZyhtYWMtPmRldiwgIk1BQyBQSFkgQ29udHJvbCBSZWdpc3Rlcjog UEhZX0lOVEVSRkFDRV9NT0RFX1JHTUlJX1JYSURcbiIpOworCQlicmVhazsKKworCWNhc2UgUEhZ X0lOVEVSRkFDRV9NT0RFX1JHTUlJX1RYSUQ6CisJCXZhbCA9IEZJRUxEX1BSRVAoTUFDUEhZQ19Q SFlfSU5GVF9NQVNLLCBNQUNQSFlDX1BIWV9JTkZUX1JHTUlJKSB8CisJCQkgIEZJRUxEX1BSRVAo TUFDUEhZQ19UWF9TRUxfTUFTSywgTUFDUEhZQ19UWF9TRUxfT1JJR0lOKTsKKworCQlpZiAobWFj LT5yeF9kZWxheSA9PSAwKSB7CisJCQl2YWwgfD0gRklFTERfUFJFUChNQUNQSFlDX1JYX1NFTF9N QVNLLCBNQUNQSFlDX1JYX1NFTF9PUklHSU4pOworCQl9IGVsc2UgeworCQkJdmFsIHw9IEZJRUxE X1BSRVAoTUFDUEhZQ19SWF9TRUxfTUFTSywgTUFDUEhZQ19SWF9TRUxfREVMQVkpOworCisJCQlp ZiAobWFjLT5yeF9kZWxheSA+IE1BQ1BIWUNfUlhfREVMQVlfTUFYKQorCQkJCXZhbCB8PSBGSUVM RF9QUkVQKE1BQ1BIWUNfUlhfREVMQVlfTUFTSywgTUFDUEhZQ19SWF9ERUxBWV9NQVggLSAxKTsK KwkJCWVsc2UKKwkJCQl2YWwgfD0gRklFTERfUFJFUChNQUNQSFlDX1JYX0RFTEFZX01BU0ssIG1h Yy0+cnhfZGVsYXkgLSAxKTsKKwkJfQorCisJCWRldl9kYmcobWFjLT5kZXYsICJNQUMgUEhZIENv bnRyb2wgUmVnaXN0ZXI6IFBIWV9JTlRFUkZBQ0VfTU9ERV9SR01JSV9UWElEXG4iKTsKKwkJYnJl YWs7CisKKwlkZWZhdWx0OgorCQlkZXZfZXJyKG1hYy0+ZGV2LCAidW5zdXBwb3J0ZWQgaW50ZXJm YWNlICVkIiwgcGxhdF9kYXQtPmludGVyZmFjZSk7CisJCXJldHVybiAtRUlOVkFMOworCX0KKwor CS8qIFVwZGF0ZSBNQUMgUEhZIGNvbnRyb2wgcmVnaXN0ZXIgKi8KKwlyZXR1cm4gcmVnbWFwX3Vw ZGF0ZV9iaXRzKG1hYy0+cmVnbWFwLCAwLCBtYWMtPnNvY19pbmZvLT5tYXNrLCB2YWwpOworfQor CitzdGF0aWMgaW50IGluZ2VuaWNfbWFjX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBk ZXYpCit7CisJc3RydWN0IHBsYXRfc3RtbWFjZW5ldF9kYXRhICpwbGF0X2RhdDsKKwlzdHJ1Y3Qg c3RtbWFjX3Jlc291cmNlcyBzdG1tYWNfcmVzOworCXN0cnVjdCBpbmdlbmljX21hYyAqbWFjOwor CWNvbnN0IHN0cnVjdCBpbmdlbmljX3NvY19pbmZvICpkYXRhOworCWludCByZXQ7CisKKwlyZXQg PSBzdG1tYWNfZ2V0X3BsYXRmb3JtX3Jlc291cmNlcyhwZGV2LCAmc3RtbWFjX3Jlcyk7CisJaWYg KHJldCkKKwkJcmV0dXJuIHJldDsKKworCXBsYXRfZGF0ID0gc3RtbWFjX3Byb2JlX2NvbmZpZ19k dChwZGV2LCBzdG1tYWNfcmVzLm1hYyk7CisJaWYgKElTX0VSUihwbGF0X2RhdCkpCisJCXJldHVy biBQVFJfRVJSKHBsYXRfZGF0KTsKKworCW1hYyA9IGRldm1fa3phbGxvYygmcGRldi0+ZGV2LCBz aXplb2YoKm1hYyksIEdGUF9LRVJORUwpOworCWlmICghbWFjKSB7CisJCXJldCA9IC1FTk9NRU07 CisJCWdvdG8gZXJyX3JlbW92ZV9jb25maWdfZHQ7CisJfQorCisJZGF0YSA9IG9mX2RldmljZV9n ZXRfbWF0Y2hfZGF0YSgmcGRldi0+ZGV2KTsKKwlpZiAoIWRhdGEpIHsKKwkJZGV2X2VycigmcGRl di0+ZGV2LCAibm8gb2YgbWF0Y2ggZGF0YSBwcm92aWRlZFxuIik7CisJCXJldCA9IC1FSU5WQUw7 CisJCWdvdG8gZXJyX3JlbW92ZV9jb25maWdfZHQ7CisJfQorCisJLyogR2V0IE1BQyBQSFkgY29u dHJvbCByZWdpc3RlciAqLworCW1hYy0+cmVnbWFwID0gc3lzY29uX3JlZ21hcF9sb29rdXBfYnlf cGhhbmRsZShwZGV2LT5kZXYub2Zfbm9kZSwgIm1vZGUtcmVnIik7CisJaWYgKElTX0VSUihtYWMt PnJlZ21hcCkpIHsKKwkJZGV2X2VycigmcGRldi0+ZGV2LCAiJXM6IGZhaWxlZCB0byBnZXQgc3lz Y29uIHJlZ21hcFxuIiwgX19mdW5jX18pOworCQlnb3RvIGVycl9yZW1vdmVfY29uZmlnX2R0Owor CX0KKworCXJldCA9IG9mX3Byb3BlcnR5X3JlYWRfdTMyKHBkZXYtPmRldi5vZl9ub2RlLCAicngt Y2xrLWRlbGF5IiwgJm1hYy0+cnhfZGVsYXkpOworCWlmIChyZXQpCisJCW1hYy0+cnhfZGVsYXkg PSAwOworCisJcmV0ID0gb2ZfcHJvcGVydHlfcmVhZF91MzIocGRldi0+ZGV2Lm9mX25vZGUsICJ0 eC1jbGstZGVsYXkiLCAmbWFjLT50eF9kZWxheSk7CisJaWYgKHJldCkKKwkJbWFjLT50eF9kZWxh eSA9IDA7CisKKwltYWMtPnNvY19pbmZvID0gZGF0YTsKKwltYWMtPmRldiA9ICZwZGV2LT5kZXY7 CisKKwlwbGF0X2RhdC0+YnNwX3ByaXYgPSBtYWM7CisKKwlyZXQgPSBpbmdlbmljX21hY19pbml0 KHBsYXRfZGF0KTsKKwlpZiAocmV0KQorCQlnb3RvIGVycl9yZW1vdmVfY29uZmlnX2R0OworCisJ cmV0ID0gc3RtbWFjX2R2cl9wcm9iZSgmcGRldi0+ZGV2LCBwbGF0X2RhdCwgJnN0bW1hY19yZXMp OworCWlmIChyZXQpCisJCWdvdG8gZXJyX3JlbW92ZV9jb25maWdfZHQ7CisKKwlyZXR1cm4gMDsK KworZXJyX3JlbW92ZV9jb25maWdfZHQ6CisJc3RtbWFjX3JlbW92ZV9jb25maWdfZHQocGRldiwg cGxhdF9kYXQpOworCisJcmV0dXJuIHJldDsKK30KKworI2lmZGVmIENPTkZJR19QTV9TTEVFUAor c3RhdGljIGludCBpbmdlbmljX21hY19zdXNwZW5kKHN0cnVjdCBkZXZpY2UgKmRldikKK3sKKwlz dHJ1Y3QgbmV0X2RldmljZSAqbmRldiA9IGRldl9nZXRfZHJ2ZGF0YShkZXYpOworCXN0cnVjdCBz dG1tYWNfcHJpdiAqcHJpdiA9IG5ldGRldl9wcml2KG5kZXYpOworCXN0cnVjdCBpbmdlbmljX21h YyAqbWFjID0gcHJpdi0+cGxhdC0+YnNwX3ByaXY7CisJaW50IHJldDsKKworCXJldCA9IHN0bW1h Y19zdXNwZW5kKGRldik7CisKKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgaW50IGluZ2VuaWNf bWFjX3Jlc3VtZShzdHJ1Y3QgZGV2aWNlICpkZXYpCit7CisJc3RydWN0IG5ldF9kZXZpY2UgKm5k ZXYgPSBkZXZfZ2V0X2RydmRhdGEoZGV2KTsKKwlzdHJ1Y3Qgc3RtbWFjX3ByaXYgKnByaXYgPSBu ZXRkZXZfcHJpdihuZGV2KTsKKwlzdHJ1Y3QgaW5nZW5pY19tYWMgKm1hYyA9IHByaXYtPnBsYXQt PmJzcF9wcml2OworCWludCByZXQ7CisKKwlyZXQgPSBpbmdlbmljX21hY19pbml0KHByaXYtPnBs YXQpOworCWlmIChyZXQpCisJCXJldHVybiByZXQ7CisKKwlyZXQgPSBzdG1tYWNfcmVzdW1lKGRl dik7CisKKwlyZXR1cm4gcmV0OworfQorI2VuZGlmIC8qIENPTkZJR19QTV9TTEVFUCAqLworCitz dGF0aWMgU0lNUExFX0RFVl9QTV9PUFMoaW5nZW5pY19tYWNfcG1fb3BzLCBpbmdlbmljX21hY19z dXNwZW5kLCBpbmdlbmljX21hY19yZXN1bWUpOworCitzdGF0aWMgc3RydWN0IGluZ2VuaWNfc29j X2luZm8gano0Nzc1X3NvY19pbmZvID0geworCS52ZXJzaW9uID0gSURfSlo0Nzc1LAorCS5tYXNr ID0gTUFDUEhZQ19UWENMS19TRUxfTUFTSyB8IE1BQ1BIWUNfU09GVF9SU1RfTUFTSyB8IE1BQ1BI WUNfUEhZX0lORlRfTUFTSywKKworCS5zZXRfbW9kZSA9IGp6NDc3NV9tYWNfc2V0X21vZGUsCit9 OworCitzdGF0aWMgc3RydWN0IGluZ2VuaWNfc29jX2luZm8geDEwMDBfc29jX2luZm8gPSB7CisJ LnZlcnNpb24gPSBJRF9YMTAwMCwKKwkubWFzayA9IE1BQ1BIWUNfU09GVF9SU1RfTUFTSywKKwor CS5zZXRfbW9kZSA9IHgxMDAwX21hY19zZXRfbW9kZSwKK307CisKK3N0YXRpYyBzdHJ1Y3QgaW5n ZW5pY19zb2NfaW5mbyB4MTYwMF9zb2NfaW5mbyA9IHsKKwkudmVyc2lvbiA9IElEX1gxNjAwLAor CS5tYXNrID0gTUFDUEhZQ19TT0ZUX1JTVF9NQVNLIHwgTUFDUEhZQ19QSFlfSU5GVF9NQVNLLAor CisJLnNldF9tb2RlID0geDE2MDBfbWFjX3NldF9tb2RlLAorfTsKKworc3RhdGljIHN0cnVjdCBp bmdlbmljX3NvY19pbmZvIHgxODMwX3NvY19pbmZvID0geworCS52ZXJzaW9uID0gSURfWDE4MzAs CisJLm1hc2sgPSBNQUNQSFlDX01PREVfU0VMX01BU0sgfCBNQUNQSFlDX1NPRlRfUlNUX01BU0sg fCBNQUNQSFlDX1BIWV9JTkZUX01BU0ssCisKKwkuc2V0X21vZGUgPSB4MTgzMF9tYWNfc2V0X21v ZGUsCit9OworCitzdGF0aWMgc3RydWN0IGluZ2VuaWNfc29jX2luZm8geDIwMDBfc29jX2luZm8g PSB7CisJLnZlcnNpb24gPSBJRF9YMjAwMCwKKwkubWFzayA9IE1BQ1BIWUNfVFhfU0VMX01BU0sg fCBNQUNQSFlDX1RYX0RFTEFZX01BU0sgfCBNQUNQSFlDX1JYX1NFTF9NQVNLIHwKKwkJCU1BQ1BI WUNfUlhfREVMQVlfTUFTSyB8IE1BQ1BIWUNfU09GVF9SU1RfTUFTSyB8IE1BQ1BIWUNfUEhZX0lO RlRfTUFTSywKKworCS5zZXRfbW9kZSA9IHgyMDAwX21hY19zZXRfbW9kZSwKK307CisKK3N0YXRp YyBjb25zdCBzdHJ1Y3Qgb2ZfZGV2aWNlX2lkIGluZ2VuaWNfbWFjX29mX21hdGNoZXNbXSA9IHsK Kwl7IC5jb21wYXRpYmxlID0gImluZ2VuaWMsano0Nzc1LW1hYyIsIC5kYXRhID0gJmp6NDc3NV9z b2NfaW5mbyB9LAorCXsgLmNvbXBhdGlibGUgPSAiaW5nZW5pYyx4MTAwMC1tYWMiLCAuZGF0YSA9 ICZ4MTAwMF9zb2NfaW5mbyB9LAorCXsgLmNvbXBhdGlibGUgPSAiaW5nZW5pYyx4MTYwMC1tYWMi LCAuZGF0YSA9ICZ4MTYwMF9zb2NfaW5mbyB9LAorCXsgLmNvbXBhdGlibGUgPSAiaW5nZW5pYyx4 MTgzMC1tYWMiLCAuZGF0YSA9ICZ4MTgzMF9zb2NfaW5mbyB9LAorCXsgLmNvbXBhdGlibGUgPSAi aW5nZW5pYyx4MjAwMC1tYWMiLCAuZGF0YSA9ICZ4MjAwMF9zb2NfaW5mbyB9LAorCXsgfQorfTsK K01PRFVMRV9ERVZJQ0VfVEFCTEUob2YsIGluZ2VuaWNfbWFjX29mX21hdGNoZXMpOworCitzdGF0 aWMgc3RydWN0IHBsYXRmb3JtX2RyaXZlciBpbmdlbmljX21hY19kcml2ZXIgPSB7CisJLnByb2Jl CQk9IGluZ2VuaWNfbWFjX3Byb2JlLAorCS5yZW1vdmUJCT0gc3RtbWFjX3BsdGZyX3JlbW92ZSwK KwkuZHJpdmVyCQk9IHsKKwkJLm5hbWUJPSAiaW5nZW5pYy1tYWMiLAorCQkucG0JCT0gcG1fcHRy KCZpbmdlbmljX21hY19wbV9vcHMpLAorCQkub2ZfbWF0Y2hfdGFibGUgPSBpbmdlbmljX21hY19v Zl9tYXRjaGVzLAorCX0sCit9OworbW9kdWxlX3BsYXRmb3JtX2RyaXZlcihpbmdlbmljX21hY19k cml2ZXIpOworCitNT0RVTEVfQVVUSE9SKCLlkajnkLDmnbAgKFpob3UgWWFuamllKSA8emhvdXlh bmppZUB3YW55ZWV0ZWNoLmNvbT4iKTsKK01PRFVMRV9ERVNDUklQVElPTigiSW5nZW5pYyBTb0Nz IERXTUFDIHNwZWNpZmljIGdsdWUgbGF5ZXIiKTsKK01PRFVMRV9MSUNFTlNFKCJHUEwgdjIiKTsK LS0gCjIuNy40CgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X18KbGludXgtYXJtLWtlcm5lbCBtYWlsaW5nIGxpc3QKbGludXgtYXJtLWtlcm5lbEBsaXN0cy5p bmZyYWRlYWQub3JnCmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8v bGludXgtYXJtLWtlcm5lbAo=