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=-15.8 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,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 3E3CDC41518 for ; Wed, 10 Mar 2021 12:56:09 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 1CA1D65003 for ; Wed, 10 Mar 2021 12:56:09 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232839AbhCJMzk (ORCPT ); Wed, 10 Mar 2021 07:55:40 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:39488 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232704AbhCJMzT (ORCPT ); Wed, 10 Mar 2021 07:55:19 -0500 Received: from mail-wr1-x42d.google.com (mail-wr1-x42d.google.com [IPv6:2a00:1450:4864:20::42d]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 1C614C061760; Wed, 10 Mar 2021 04:55:19 -0800 (PST) Received: by mail-wr1-x42d.google.com with SMTP id l11so19829798wrp.7; Wed, 10 Mar 2021 04:55:19 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:subject:date:message-id:in-reply-to:references:mime-version :content-transfer-encoding; bh=3320+MoZxrxkq93TTc+1vsgHBOZIg6vN/kNNz1BkBkg=; b=SQCAHZPVuL/7hUnYRdvOGSLs7MCVezhF0iofBuAT0KFRXNDq2kd1F06U4Pm86sBHDP suVP6toc6hcvJAOurUQegHIcbx2w1aB9qFUAE03HMr6YPUJcA8OJwc+C20YsSlaTd91U groJumQTgPDbfeRHjNJj5ZhY9+qEi6GUSbq/hAEA+aGUkMoiyGhsRr8NeWYWy5gJHl2l +hTkd0sp6ssA/NXBvAHGdveikaQj+CXc4kiEvpvJqqHRhY2NI1cilCHuYSw2E3kA+IfL g+vByyvyZm1htgS4h74Ip9hT9VEKXJKRp8MAjyrmqJbRbFKCu+eNMZd/r3aKH9fLQKqA TaOQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=3320+MoZxrxkq93TTc+1vsgHBOZIg6vN/kNNz1BkBkg=; b=WaSG/kUHtivW+hFK1FAOKTCIKJ6qC4A05q8jzQXzJDevsUJl0SU9OuFP3u4jvfewR7 lAM1cSHC2rmtc71uakV1t7jw+oCaj4yHo6PMqHG4KbqaGrFMLYHRrsRTzHcTYkKR8zU5 qEU1a+vubqH/ZMXyrh20V2KSPNwpH0ZwbVvHfAxznf9tU1gBNHLbsp92NI9zLOlW5E0p M5xd7hr2gPbzX95fuCQZliTH4gYfMoXZqrtV2P1kc50sS6zr8B97b1+w4OTyaq74zizS Nio37HSyGIfWYhA8iUJbZQynUreXZNjx8fu8nqgflj93pl0wNruArzxnVzw5Tf+0I/wo A3fA== X-Gm-Message-State: AOAM53033CpxbS4KBT+5/GQcNsbbUEgqd7tj4+g1ExDXw3VyB2c6h5c/ LLgrpOoPvGPYiE9zmDJ+OMU= X-Google-Smtp-Source: ABdhPJz3nl8xxl3Xdp+ZefPRUKOke1BSrJdVMgOxmdh6K/SVyyLN2GSjuBxyzPxG67BmHaGYucrCrQ== X-Received: by 2002:adf:ef08:: with SMTP id e8mr3595248wro.200.1615380917781; Wed, 10 Mar 2021 04:55:17 -0800 (PST) Received: from skynet.lan ([80.31.204.166]) by smtp.gmail.com with ESMTPSA id v6sm29403398wrx.32.2021.03.10.04.55.17 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 10 Mar 2021 04:55:17 -0800 (PST) From: =?UTF-8?q?=C3=81lvaro=20Fern=C3=A1ndez=20Rojas?= To: Linus Walleij , Rob Herring , Michael Walle , Bartosz Golaszewski , Florian Fainelli , bcm-kernel-feedback-list@broadcom.com, Jonas Gorski , =?UTF-8?q?=C3=81lvaro=20Fern=C3=A1ndez=20Rojas?= , Necip Fazil Yildiran , Andy Shevchenko , linux-gpio@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [PATCH v6 13/15] pinctrl: add a pincontrol driver for BCM63268 Date: Wed, 10 Mar 2021 13:55:01 +0100 Message-Id: <20210310125504.31886-14-noltari@gmail.com> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20210310125504.31886-1-noltari@gmail.com> References: <20210310125504.31886-1-noltari@gmail.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-gpio@vger.kernel.org Add a pincontrol driver for BCM63268. BCM63268 allows muxing GPIOs to different functions. Depending on the mux, these are either single pin configurations or whole pin groups. Signed-off-by: Jonas Gorski Co-developed-by: Jonas Gorski Signed-off-by: Álvaro Fernández Rojas --- v6: no changes v5: add changes suggested by Andy Shevchenko v4: no changes v3: use new shared code v2: switch to GPIO_REGMAP drivers/pinctrl/bcm/Kconfig | 8 + drivers/pinctrl/bcm/Makefile | 1 + drivers/pinctrl/bcm/pinctrl-bcm63268.c | 643 +++++++++++++++++++++++++ 3 files changed, 652 insertions(+) create mode 100644 drivers/pinctrl/bcm/pinctrl-bcm63268.c diff --git a/drivers/pinctrl/bcm/Kconfig b/drivers/pinctrl/bcm/Kconfig index aabd4b762aed..186985846120 100644 --- a/drivers/pinctrl/bcm/Kconfig +++ b/drivers/pinctrl/bcm/Kconfig @@ -68,6 +68,14 @@ config PINCTRL_BCM6368 help Say Y here to enable the Broadcom BCM6368 GPIO driver. +config PINCTRL_BCM63268 + bool "Broadcom BCM63268 GPIO driver" + depends on (BMIPS_GENERIC || COMPILE_TEST) + select PINCTRL_BCM63XX + default BMIPS_GENERIC + help + Say Y here to enable the Broadcom BCM63268 GPIO driver. + config PINCTRL_IPROC_GPIO bool "Broadcom iProc GPIO (with PINCONF) driver" depends on OF_GPIO && (ARCH_BCM_IPROC || COMPILE_TEST) diff --git a/drivers/pinctrl/bcm/Makefile b/drivers/pinctrl/bcm/Makefile index a1331bb9680e..4117847fd279 100644 --- a/drivers/pinctrl/bcm/Makefile +++ b/drivers/pinctrl/bcm/Makefile @@ -8,6 +8,7 @@ obj-$(CONFIG_PINCTRL_BCM6328) += pinctrl-bcm6328.o obj-$(CONFIG_PINCTRL_BCM6358) += pinctrl-bcm6358.o obj-$(CONFIG_PINCTRL_BCM6362) += pinctrl-bcm6362.o obj-$(CONFIG_PINCTRL_BCM6368) += pinctrl-bcm6368.o +obj-$(CONFIG_PINCTRL_BCM63268) += pinctrl-bcm63268.o obj-$(CONFIG_PINCTRL_IPROC_GPIO) += pinctrl-iproc-gpio.o obj-$(CONFIG_PINCTRL_CYGNUS_MUX) += pinctrl-cygnus-mux.o obj-$(CONFIG_PINCTRL_NS) += pinctrl-ns.o diff --git a/drivers/pinctrl/bcm/pinctrl-bcm63268.c b/drivers/pinctrl/bcm/pinctrl-bcm63268.c new file mode 100644 index 000000000000..d4c5fad7fb7d --- /dev/null +++ b/drivers/pinctrl/bcm/pinctrl-bcm63268.c @@ -0,0 +1,643 @@ +// SPDX-License-Identifier: GPL-2.0+ +/* + * Driver for BCM63268 GPIO unit (pinctrl + GPIO) + * + * Copyright (C) 2021 Álvaro Fernández Rojas + * Copyright (C) 2016 Jonas Gorski + */ + +#include +#include +#include +#include +#include +#include +#include + +#include "../pinctrl-utils.h" + +#include "pinctrl-bcm63xx.h" + +#define BCM63268_NUM_GPIOS 52 +#define BCM63268_NUM_LEDS 24 + +#define BCM63268_LED_REG 0x10 +#define BCM63268_MODE_REG 0x18 +#define BCM63268_CTRL_REG 0x1c +#define BCM63268_BASEMODE_REG 0x38 +#define BCM63268_BASEMODE_NAND BIT(2) /* GPIOs 2-7, 24-31 */ +#define BCM63268_BASEMODE_GPIO35 BIT(4) /* GPIO 35 */ +#define BCM63268_BASEMODE_DECTPD BIT(5) /* GPIOs 8/9 */ +#define BCM63268_BASEMODE_VDSL_PHY_0 BIT(6) /* GPIOs 10/11 */ +#define BCM63268_BASEMODE_VDSL_PHY_1 BIT(7) /* GPIOs 12/13 */ +#define BCM63268_BASEMODE_VDSL_PHY_2 BIT(8) /* GPIOs 24/25 */ +#define BCM63268_BASEMODE_VDSL_PHY_3 BIT(9) /* GPIOs 26/27 */ + +enum bcm63268_pinctrl_reg { + BCM63268_LEDCTRL, + BCM63268_MODE, + BCM63268_CTRL, + BCM63268_BASEMODE, +}; + +struct bcm63268_pingroup { + const char *name; + const unsigned * const pins; + const unsigned num_pins; +}; + +struct bcm63268_function { + const char *name; + const char * const *groups; + const unsigned num_groups; + + enum bcm63268_pinctrl_reg reg; + uint32_t mask; +}; + +#define BCM63268_PIN(a, b, basemode) \ + { \ + .number = a, \ + .name = b, \ + .drv_data = (void *)(basemode) \ + } + +static const struct pinctrl_pin_desc bcm63268_pins[] = { + PINCTRL_PIN(0, "gpio0"), + PINCTRL_PIN(1, "gpio1"), + BCM63268_PIN(2, "gpio2", BCM63268_BASEMODE_NAND), + BCM63268_PIN(3, "gpio3", BCM63268_BASEMODE_NAND), + BCM63268_PIN(4, "gpio4", BCM63268_BASEMODE_NAND), + BCM63268_PIN(5, "gpio5", BCM63268_BASEMODE_NAND), + BCM63268_PIN(6, "gpio6", BCM63268_BASEMODE_NAND), + BCM63268_PIN(7, "gpio7", BCM63268_BASEMODE_NAND), + BCM63268_PIN(8, "gpio8", BCM63268_BASEMODE_DECTPD), + BCM63268_PIN(9, "gpio9", BCM63268_BASEMODE_DECTPD), + BCM63268_PIN(10, "gpio10", BCM63268_BASEMODE_VDSL_PHY_0), + BCM63268_PIN(11, "gpio11", BCM63268_BASEMODE_VDSL_PHY_0), + BCM63268_PIN(12, "gpio12", BCM63268_BASEMODE_VDSL_PHY_1), + BCM63268_PIN(13, "gpio13", BCM63268_BASEMODE_VDSL_PHY_1), + PINCTRL_PIN(14, "gpio14"), + PINCTRL_PIN(15, "gpio15"), + PINCTRL_PIN(16, "gpio16"), + PINCTRL_PIN(17, "gpio17"), + PINCTRL_PIN(18, "gpio18"), + PINCTRL_PIN(19, "gpio19"), + PINCTRL_PIN(20, "gpio20"), + PINCTRL_PIN(21, "gpio21"), + PINCTRL_PIN(22, "gpio22"), + PINCTRL_PIN(23, "gpio23"), + BCM63268_PIN(24, "gpio24", + BCM63268_BASEMODE_NAND | BCM63268_BASEMODE_VDSL_PHY_2), + BCM63268_PIN(25, "gpio25", + BCM63268_BASEMODE_NAND | BCM63268_BASEMODE_VDSL_PHY_2), + BCM63268_PIN(26, "gpio26", + BCM63268_BASEMODE_NAND | BCM63268_BASEMODE_VDSL_PHY_3), + BCM63268_PIN(27, "gpio27", + BCM63268_BASEMODE_NAND | BCM63268_BASEMODE_VDSL_PHY_3), + BCM63268_PIN(28, "gpio28", BCM63268_BASEMODE_NAND), + BCM63268_PIN(29, "gpio29", BCM63268_BASEMODE_NAND), + BCM63268_PIN(30, "gpio30", BCM63268_BASEMODE_NAND), + BCM63268_PIN(31, "gpio31", BCM63268_BASEMODE_NAND), + PINCTRL_PIN(32, "gpio32"), + PINCTRL_PIN(33, "gpio33"), + PINCTRL_PIN(34, "gpio34"), + PINCTRL_PIN(35, "gpio35"), + PINCTRL_PIN(36, "gpio36"), + PINCTRL_PIN(37, "gpio37"), + PINCTRL_PIN(38, "gpio38"), + PINCTRL_PIN(39, "gpio39"), + PINCTRL_PIN(40, "gpio40"), + PINCTRL_PIN(41, "gpio41"), + PINCTRL_PIN(42, "gpio42"), + PINCTRL_PIN(43, "gpio43"), + PINCTRL_PIN(44, "gpio44"), + PINCTRL_PIN(45, "gpio45"), + PINCTRL_PIN(46, "gpio46"), + PINCTRL_PIN(47, "gpio47"), + PINCTRL_PIN(48, "gpio48"), + PINCTRL_PIN(49, "gpio49"), + PINCTRL_PIN(50, "gpio50"), + PINCTRL_PIN(51, "gpio51"), +}; + +static unsigned gpio0_pins[] = { 0 }; +static unsigned gpio1_pins[] = { 1 }; +static unsigned gpio2_pins[] = { 2 }; +static unsigned gpio3_pins[] = { 3 }; +static unsigned gpio4_pins[] = { 4 }; +static unsigned gpio5_pins[] = { 5 }; +static unsigned gpio6_pins[] = { 6 }; +static unsigned gpio7_pins[] = { 7 }; +static unsigned gpio8_pins[] = { 8 }; +static unsigned gpio9_pins[] = { 9 }; +static unsigned gpio10_pins[] = { 10 }; +static unsigned gpio11_pins[] = { 11 }; +static unsigned gpio12_pins[] = { 12 }; +static unsigned gpio13_pins[] = { 13 }; +static unsigned gpio14_pins[] = { 14 }; +static unsigned gpio15_pins[] = { 15 }; +static unsigned gpio16_pins[] = { 16 }; +static unsigned gpio17_pins[] = { 17 }; +static unsigned gpio18_pins[] = { 18 }; +static unsigned gpio19_pins[] = { 19 }; +static unsigned gpio20_pins[] = { 20 }; +static unsigned gpio21_pins[] = { 21 }; +static unsigned gpio22_pins[] = { 22 }; +static unsigned gpio23_pins[] = { 23 }; +static unsigned gpio24_pins[] = { 24 }; +static unsigned gpio25_pins[] = { 25 }; +static unsigned gpio26_pins[] = { 26 }; +static unsigned gpio27_pins[] = { 27 }; +static unsigned gpio28_pins[] = { 28 }; +static unsigned gpio29_pins[] = { 29 }; +static unsigned gpio30_pins[] = { 30 }; +static unsigned gpio31_pins[] = { 31 }; +static unsigned gpio32_pins[] = { 32 }; +static unsigned gpio33_pins[] = { 33 }; +static unsigned gpio34_pins[] = { 34 }; +static unsigned gpio35_pins[] = { 35 }; +static unsigned gpio36_pins[] = { 36 }; +static unsigned gpio37_pins[] = { 37 }; +static unsigned gpio38_pins[] = { 38 }; +static unsigned gpio39_pins[] = { 39 }; +static unsigned gpio40_pins[] = { 40 }; +static unsigned gpio41_pins[] = { 41 }; +static unsigned gpio42_pins[] = { 42 }; +static unsigned gpio43_pins[] = { 43 }; +static unsigned gpio44_pins[] = { 44 }; +static unsigned gpio45_pins[] = { 45 }; +static unsigned gpio46_pins[] = { 46 }; +static unsigned gpio47_pins[] = { 47 }; +static unsigned gpio48_pins[] = { 48 }; +static unsigned gpio49_pins[] = { 49 }; +static unsigned gpio50_pins[] = { 50 }; +static unsigned gpio51_pins[] = { 51 }; + +static unsigned nand_grp_pins[] = { + 2, 3, 4, 5, 6, 7, 24, + 25, 26, 27, 28, 29, 30, 31, +}; + +static unsigned dectpd_grp_pins[] = { 8, 9 }; +static unsigned vdsl_phy0_grp_pins[] = { 10, 11 }; +static unsigned vdsl_phy1_grp_pins[] = { 12, 13 }; +static unsigned vdsl_phy2_grp_pins[] = { 24, 25 }; +static unsigned vdsl_phy3_grp_pins[] = { 26, 27 }; + +#define BCM63268_GROUP(n) \ + { \ + .name = #n, \ + .pins = n##_pins, \ + .num_pins = ARRAY_SIZE(n##_pins), \ + } + +static struct bcm63268_pingroup bcm63268_groups[] = { + BCM63268_GROUP(gpio0), + BCM63268_GROUP(gpio1), + BCM63268_GROUP(gpio2), + BCM63268_GROUP(gpio3), + BCM63268_GROUP(gpio4), + BCM63268_GROUP(gpio5), + BCM63268_GROUP(gpio6), + BCM63268_GROUP(gpio7), + BCM63268_GROUP(gpio8), + BCM63268_GROUP(gpio9), + BCM63268_GROUP(gpio10), + BCM63268_GROUP(gpio11), + BCM63268_GROUP(gpio12), + BCM63268_GROUP(gpio13), + BCM63268_GROUP(gpio14), + BCM63268_GROUP(gpio15), + BCM63268_GROUP(gpio16), + BCM63268_GROUP(gpio17), + BCM63268_GROUP(gpio18), + BCM63268_GROUP(gpio19), + BCM63268_GROUP(gpio20), + BCM63268_GROUP(gpio21), + BCM63268_GROUP(gpio22), + BCM63268_GROUP(gpio23), + BCM63268_GROUP(gpio24), + BCM63268_GROUP(gpio25), + BCM63268_GROUP(gpio26), + BCM63268_GROUP(gpio27), + BCM63268_GROUP(gpio28), + BCM63268_GROUP(gpio29), + BCM63268_GROUP(gpio30), + BCM63268_GROUP(gpio31), + BCM63268_GROUP(gpio32), + BCM63268_GROUP(gpio33), + BCM63268_GROUP(gpio34), + BCM63268_GROUP(gpio35), + BCM63268_GROUP(gpio36), + BCM63268_GROUP(gpio37), + BCM63268_GROUP(gpio38), + BCM63268_GROUP(gpio39), + BCM63268_GROUP(gpio40), + BCM63268_GROUP(gpio41), + BCM63268_GROUP(gpio42), + BCM63268_GROUP(gpio43), + BCM63268_GROUP(gpio44), + BCM63268_GROUP(gpio45), + BCM63268_GROUP(gpio46), + BCM63268_GROUP(gpio47), + BCM63268_GROUP(gpio48), + BCM63268_GROUP(gpio49), + BCM63268_GROUP(gpio50), + BCM63268_GROUP(gpio51), + + /* multi pin groups */ + BCM63268_GROUP(nand_grp), + BCM63268_GROUP(dectpd_grp), + BCM63268_GROUP(vdsl_phy0_grp), + BCM63268_GROUP(vdsl_phy1_grp), + BCM63268_GROUP(vdsl_phy2_grp), + BCM63268_GROUP(vdsl_phy3_grp), +}; + +static const char * const led_groups[] = { + "gpio0", + "gpio1", + "gpio2", + "gpio3", + "gpio4", + "gpio5", + "gpio6", + "gpio7", + "gpio8", + "gpio9", + "gpio10", + "gpio11", + "gpio12", + "gpio13", + "gpio14", + "gpio15", + "gpio16", + "gpio17", + "gpio18", + "gpio19", + "gpio20", + "gpio21", + "gpio22", + "gpio23", +}; + +static const char * const serial_led_clk_groups[] = { + "gpio0", +}; + +static const char * const serial_led_data_groups[] = { + "gpio1", +}; + +static const char * const hsspi_cs4_groups[] = { + "gpio16", +}; + +static const char * const hsspi_cs5_groups[] = { + "gpio17", +}; + +static const char * const hsspi_cs6_groups[] = { + "gpio8", +}; + +static const char * const hsspi_cs7_groups[] = { + "gpio9", +}; + +static const char * const uart1_scts_groups[] = { + "gpio10", + "gpio24", +}; + +static const char * const uart1_srts_groups[] = { + "gpio11", + "gpio25", +}; + +static const char * const uart1_sdin_groups[] = { + "gpio12", + "gpio26", +}; + +static const char * const uart1_sdout_groups[] = { + "gpio13", + "gpio27", +}; + +static const char * const ntr_pulse_in_groups[] = { + "gpio14", + "gpio28", +}; + +static const char * const dsl_ntr_pulse_out_groups[] = { + "gpio15", + "gpio29", +}; + +static const char * const adsl_spi_miso_groups[] = { + "gpio18", +}; + +static const char * const adsl_spi_mosi_groups[] = { + "gpio19", +}; + +static const char * const vreg_clk_groups[] = { + "gpio22", +}; + +static const char * const pcie_clkreq_b_groups[] = { + "gpio23", +}; + +static const char * const switch_led_clk_groups[] = { + "gpio30", +}; + +static const char * const switch_led_data_groups[] = { + "gpio31", +}; + +static const char * const wifi_groups[] = { + "gpio32", + "gpio33", + "gpio34", + "gpio35", + "gpio36", + "gpio37", + "gpio38", + "gpio39", + "gpio40", + "gpio41", + "gpio42", + "gpio43", + "gpio44", + "gpio45", + "gpio46", + "gpio47", + "gpio48", + "gpio49", + "gpio50", + "gpio51", +}; + +static const char * const nand_groups[] = { + "nand_grp", +}; + +static const char * const dectpd_groups[] = { + "dectpd_grp", +}; + +static const char * const vdsl_phy_override_0_groups[] = { + "vdsl_phy_override_0_grp", +}; + +static const char * const vdsl_phy_override_1_groups[] = { + "vdsl_phy_override_1_grp", +}; + +static const char * const vdsl_phy_override_2_groups[] = { + "vdsl_phy_override_2_grp", +}; + +static const char * const vdsl_phy_override_3_groups[] = { + "vdsl_phy_override_3_grp", +}; + +#define BCM63268_LED_FUN(n) \ + { \ + .name = #n, \ + .groups = n##_groups, \ + .num_groups = ARRAY_SIZE(n##_groups), \ + .reg = BCM63268_LEDCTRL, \ + } + +#define BCM63268_MODE_FUN(n) \ + { \ + .name = #n, \ + .groups = n##_groups, \ + .num_groups = ARRAY_SIZE(n##_groups), \ + .reg = BCM63268_MODE, \ + } + +#define BCM63268_CTRL_FUN(n) \ + { \ + .name = #n, \ + .groups = n##_groups, \ + .num_groups = ARRAY_SIZE(n##_groups), \ + .reg = BCM63268_CTRL, \ + } + +#define BCM63268_BASEMODE_FUN(n, val) \ + { \ + .name = #n, \ + .groups = n##_groups, \ + .num_groups = ARRAY_SIZE(n##_groups), \ + .reg = BCM63268_BASEMODE, \ + .mask = val, \ + } + +static const struct bcm63268_function bcm63268_funcs[] = { + BCM63268_LED_FUN(led), + BCM63268_MODE_FUN(serial_led_clk), + BCM63268_MODE_FUN(serial_led_data), + BCM63268_MODE_FUN(hsspi_cs6), + BCM63268_MODE_FUN(hsspi_cs7), + BCM63268_MODE_FUN(uart1_scts), + BCM63268_MODE_FUN(uart1_srts), + BCM63268_MODE_FUN(uart1_sdin), + BCM63268_MODE_FUN(uart1_sdout), + BCM63268_MODE_FUN(ntr_pulse_in), + BCM63268_MODE_FUN(dsl_ntr_pulse_out), + BCM63268_MODE_FUN(hsspi_cs4), + BCM63268_MODE_FUN(hsspi_cs5), + BCM63268_MODE_FUN(adsl_spi_miso), + BCM63268_MODE_FUN(adsl_spi_mosi), + BCM63268_MODE_FUN(vreg_clk), + BCM63268_MODE_FUN(pcie_clkreq_b), + BCM63268_MODE_FUN(switch_led_clk), + BCM63268_MODE_FUN(switch_led_data), + BCM63268_CTRL_FUN(wifi), + BCM63268_BASEMODE_FUN(nand, BCM63268_BASEMODE_NAND), + BCM63268_BASEMODE_FUN(dectpd, BCM63268_BASEMODE_DECTPD), + BCM63268_BASEMODE_FUN(vdsl_phy_override_0, + BCM63268_BASEMODE_VDSL_PHY_0), + BCM63268_BASEMODE_FUN(vdsl_phy_override_1, + BCM63268_BASEMODE_VDSL_PHY_1), + BCM63268_BASEMODE_FUN(vdsl_phy_override_2, + BCM63268_BASEMODE_VDSL_PHY_2), + BCM63268_BASEMODE_FUN(vdsl_phy_override_3, + BCM63268_BASEMODE_VDSL_PHY_3), +}; + +static int bcm63268_pinctrl_get_group_count(struct pinctrl_dev *pctldev) +{ + return ARRAY_SIZE(bcm63268_groups); +} + +static const char *bcm63268_pinctrl_get_group_name(struct pinctrl_dev *pctldev, + unsigned group) +{ + return bcm63268_groups[group].name; +} + +static int bcm63268_pinctrl_get_group_pins(struct pinctrl_dev *pctldev, + unsigned group, + const unsigned **pins, + unsigned *num_pins) +{ + *pins = bcm63268_groups[group].pins; + *num_pins = bcm63268_groups[group].num_pins; + + return 0; +} + +static int bcm63268_pinctrl_get_func_count(struct pinctrl_dev *pctldev) +{ + return ARRAY_SIZE(bcm63268_funcs); +} + +static const char *bcm63268_pinctrl_get_func_name(struct pinctrl_dev *pctldev, + unsigned selector) +{ + return bcm63268_funcs[selector].name; +} + +static int bcm63268_pinctrl_get_groups(struct pinctrl_dev *pctldev, + unsigned selector, + const char * const **groups, + unsigned * const num_groups) +{ + *groups = bcm63268_funcs[selector].groups; + *num_groups = bcm63268_funcs[selector].num_groups; + + return 0; +} + +static void bcm63268_set_gpio(struct bcm63xx_pinctrl *pc, unsigned pin) +{ + const struct pinctrl_pin_desc *desc = &bcm63268_pins[pin]; + unsigned int basemode = (unsigned long) desc->drv_data; + unsigned int mask = BIT(bcm63xx_bank_pin(pin)); + + if (basemode) + regmap_update_bits(pc->regs, BCM63268_BASEMODE_REG, basemode, + 0); + + if (pin < BCM63XX_BANK_GPIOS) { + /* base mode: 0 => gpio, 1 => mux function */ + regmap_update_bits(pc->regs, BCM63268_MODE_REG, mask, 0); + + /* pins 0-23 might be muxed to led */ + if (pin < BCM63268_NUM_LEDS) + regmap_update_bits(pc->regs, BCM63268_LED_REG, mask, + 0); + } else if (pin < BCM63268_NUM_GPIOS) { + /* ctrl reg: 0 => wifi function, 1 => gpio */ + regmap_update_bits(pc->regs, BCM63268_CTRL_REG, mask, mask); + } +} + +static int bcm63268_pinctrl_set_mux(struct pinctrl_dev *pctldev, + unsigned selector, unsigned group) +{ + struct bcm63xx_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev); + const struct bcm63268_pingroup *pg = &bcm63268_groups[group]; + const struct bcm63268_function *f = &bcm63268_funcs[selector]; + unsigned i; + unsigned int reg; + unsigned int val, mask; + + for (i = 0; i < pg->num_pins; i++) + bcm63268_set_gpio(pc, pg->pins[i]); + + switch (f->reg) { + case BCM63268_LEDCTRL: + reg = BCM63268_LED_REG; + mask = BIT(pg->pins[0]); + val = BIT(pg->pins[0]); + break; + case BCM63268_MODE: + reg = BCM63268_MODE_REG; + mask = BIT(pg->pins[0]); + val = BIT(pg->pins[0]); + break; + case BCM63268_CTRL: + reg = BCM63268_CTRL_REG; + mask = BIT(pg->pins[0]); + val = 0; + break; + case BCM63268_BASEMODE: + reg = BCM63268_BASEMODE_REG; + mask = f->mask; + val = f->mask; + break; + default: + WARN_ON(1); + return -EINVAL; + } + + regmap_update_bits(pc->regs, reg, mask, val); + + return 0; +} + +static int bcm63268_gpio_request_enable(struct pinctrl_dev *pctldev, + struct pinctrl_gpio_range *range, + unsigned offset) +{ + struct bcm63xx_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev); + + /* disable all functions using this pin */ + bcm63268_set_gpio(pc, offset); + + return 0; +} + +static struct pinctrl_ops bcm63268_pctl_ops = { + .dt_free_map = pinctrl_utils_free_map, + .dt_node_to_map = pinconf_generic_dt_node_to_map_pin, + .get_group_name = bcm63268_pinctrl_get_group_name, + .get_group_pins = bcm63268_pinctrl_get_group_pins, + .get_groups_count = bcm63268_pinctrl_get_group_count, +}; + +static struct pinmux_ops bcm63268_pmx_ops = { + .get_function_groups = bcm63268_pinctrl_get_groups, + .get_function_name = bcm63268_pinctrl_get_func_name, + .get_functions_count = bcm63268_pinctrl_get_func_count, + .gpio_request_enable = bcm63268_gpio_request_enable, + .set_mux = bcm63268_pinctrl_set_mux, + .strict = true, +}; + +static const struct bcm63xx_pinctrl_soc bcm63268_soc = { + .ngpios = BCM63268_NUM_GPIOS, + .npins = ARRAY_SIZE(bcm63268_pins), + .pctl_ops = &bcm63268_pctl_ops, + .pins = bcm63268_pins, + .pmx_ops = &bcm63268_pmx_ops, +}; + +static int bcm63268_pinctrl_probe(struct platform_device *pdev) +{ + return bcm63xx_pinctrl_probe(pdev, &bcm63268_soc, NULL); +} + +static const struct of_device_id bcm63268_pinctrl_match[] = { + { .compatible = "brcm,bcm63268-pinctrl", }, + { /* sentinel */ } +}; + +static struct platform_driver bcm63268_pinctrl_driver = { + .probe = bcm63268_pinctrl_probe, + .driver = { + .name = "bcm63268-pinctrl", + .of_match_table = bcm63268_pinctrl_match, + }, +}; + +builtin_platform_driver(bcm63268_pinctrl_driver); -- 2.20.1 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=-13.7 required=3.0 tests=BAYES_00, DKIM_ADSP_CUSTOM_MED,DKIM_SIGNED,DKIM_VALID,FREEMAIL_FORGED_FROMDOMAIN, FREEMAIL_FROM,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER, INCLUDES_PATCH,MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED, 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 B4E33C433DB for ; Wed, 10 Mar 2021 13:21:31 +0000 (UTC) Received: from desiato.infradead.org (desiato.infradead.org [90.155.92.199]) (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 1D0D464FE0 for ; Wed, 10 Mar 2021 13:21:31 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 1D0D464FE0 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=gmail.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=desiato.20200630; 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:To:From:Reply-To:Cc:Content-ID:Content-Description:Resent-Date: Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Owner; bh=2tw2a2wLVnTEWhDdp6UuLmD+akHaE9dC0q6P0rXacqw=; b=A71gDIcA4qJjflekyOZsX16Vs zrHn+Z8X7buWXaBVzNGUdv+BWVbxUyVlqVTLZvCHgZZhLVxsGxEYUEKbcR60qPwUy0BxfD7+VEt6e RFRSHWTVSwsytipytNUR1Wm/Zx4GzEMUf1SEqC7wT//MWYyKAm35uZE9ov6hZIXKCWjB43LYcl/DZ poIzDYMCjgaeR7u0TqfwbnR4SNnqkWAOcBMSqf6rweC+h1rPlA7w9P4E2cmu9XsrH4IN8YmEJIbIw S8jWIuuZxHZ1Q6NJAED8+oOqz7Ap2fGgH28ozDQinMhplAczMj0nK1+i7RyIFZb/6dLEMHEmts/hU pELRwfGIQ==; Received: from localhost ([::1] helo=desiato.infradead.org) by desiato.infradead.org with esmtp (Exim 4.94 #2 (Red Hat Linux)) id 1lJyl4-006sz8-VS; Wed, 10 Mar 2021 13:20:15 +0000 Received: from casper.infradead.org ([2001:8b0:10b:1236::1]) by desiato.infradead.org with esmtps (Exim 4.94 #2 (Red Hat Linux)) id 1lJykn-006swY-QZ for linux-arm-kernel@desiato.infradead.org; Wed, 10 Mar 2021 13:19:57 +0000 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=casper.20170209; h=Content-Transfer-Encoding:Content-Type: MIME-Version:References:In-Reply-To:Message-Id:Date:Subject:To:From:Sender: Reply-To:Cc:Content-ID:Content-Description; bh=3320+MoZxrxkq93TTc+1vsgHBOZIg6vN/kNNz1BkBkg=; b=kmBAR50plo/kDrUcPLb4Rm5V6e A7dD1SIMGsO25abs4rb38UvSt53BoMOmKyLnIlAe/o4tvx1INe8E5vN5M9FJSxlkmtuOUWXOBuqOA 3RpvcvzK0S82+mz7NhTDGnoSgrnK00ZYi7+aRTX24sOwOD0zcAuM+6fh0YDfxTKO9lPlT8H3N4/HH UyDeca6WtrSkIfX9VHa9OIW7Zp1aXZWRM9P1bKtQ3bwS/imSkH1ZP9eGlM10kPm9oqJ3+E3tg/bOl nvJ0T/fWFRy+wYQl2lwPLOQRq0W0G7ShJ9mI+Q4SZDBdNcc3Y3fVNUezc8VhXr+IbFbmQ2VCllAgm tOVlPnBw==; Received: from mail-wr1-x42f.google.com ([2a00:1450:4864:20::42f]) by casper.infradead.org with esmtps (Exim 4.94 #2 (Red Hat Linux)) id 1lJyMw-003TC0-H0 for linux-arm-kernel@lists.infradead.org; Wed, 10 Mar 2021 12:55:30 +0000 Received: by mail-wr1-x42f.google.com with SMTP id w11so23210396wrr.10 for ; Wed, 10 Mar 2021 04:55:18 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:subject:date:message-id:in-reply-to:references:mime-version :content-transfer-encoding; bh=3320+MoZxrxkq93TTc+1vsgHBOZIg6vN/kNNz1BkBkg=; b=SQCAHZPVuL/7hUnYRdvOGSLs7MCVezhF0iofBuAT0KFRXNDq2kd1F06U4Pm86sBHDP suVP6toc6hcvJAOurUQegHIcbx2w1aB9qFUAE03HMr6YPUJcA8OJwc+C20YsSlaTd91U groJumQTgPDbfeRHjNJj5ZhY9+qEi6GUSbq/hAEA+aGUkMoiyGhsRr8NeWYWy5gJHl2l +hTkd0sp6ssA/NXBvAHGdveikaQj+CXc4kiEvpvJqqHRhY2NI1cilCHuYSw2E3kA+IfL g+vByyvyZm1htgS4h74Ip9hT9VEKXJKRp8MAjyrmqJbRbFKCu+eNMZd/r3aKH9fLQKqA TaOQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=3320+MoZxrxkq93TTc+1vsgHBOZIg6vN/kNNz1BkBkg=; b=boRUAbUyjju1C8DV60pzXntH/1oyBEQO0qSGgkycToA01NiO+F8LbVZpKkcVcVzmjL Vhzbw2KkDV2362vrwzdeVQXoAEJsnWRfWtpxoA/vWbKEytJQrFJQDt/T8MfP2ofboYo3 fVbHz3KPAG/2MX5cS6/QPQB6Xt2iZfwneO/gKi/1JP1q1Imo4VALa5Xa/BJDWd1gW9t3 r1LQTwA69A7KYLp8Hk4JtfIH4tO6TXBYW8XAKtYPg/qUKiWjwyEO9F1FYp18COfwdqEd vcghQEw5peDEn0A3znXeyiH1QCnuYFPBDc5D3C6zOX1V8R9dXFcDTHwxmNuIrSLgK5XX aJtQ== X-Gm-Message-State: AOAM533y2frctyVshEKF4mw9eNbUmQX8695YkvYP29KJIJVDvJgVMnTB H9G6uN1QmWFzd4GBt/j06+c= X-Google-Smtp-Source: ABdhPJz3nl8xxl3Xdp+ZefPRUKOke1BSrJdVMgOxmdh6K/SVyyLN2GSjuBxyzPxG67BmHaGYucrCrQ== X-Received: by 2002:adf:ef08:: with SMTP id e8mr3595248wro.200.1615380917781; Wed, 10 Mar 2021 04:55:17 -0800 (PST) Received: from skynet.lan ([80.31.204.166]) by smtp.gmail.com with ESMTPSA id v6sm29403398wrx.32.2021.03.10.04.55.17 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 10 Mar 2021 04:55:17 -0800 (PST) From: =?UTF-8?q?=C3=81lvaro=20Fern=C3=A1ndez=20Rojas?= To: Linus Walleij , Rob Herring , Michael Walle , Bartosz Golaszewski , Florian Fainelli , bcm-kernel-feedback-list@broadcom.com, Jonas Gorski , =?UTF-8?q?=C3=81lvaro=20Fern=C3=A1ndez=20Rojas?= , Necip Fazil Yildiran , Andy Shevchenko , linux-gpio@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [PATCH v6 13/15] pinctrl: add a pincontrol driver for BCM63268 Date: Wed, 10 Mar 2021 13:55:01 +0100 Message-Id: <20210310125504.31886-14-noltari@gmail.com> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20210310125504.31886-1-noltari@gmail.com> References: <20210310125504.31886-1-noltari@gmail.com> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20210310_125520_860283_B6B73FAC X-CRM114-Status: GOOD ( 18.56 ) 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 QWRkIGEgcGluY29udHJvbCBkcml2ZXIgZm9yIEJDTTYzMjY4LiBCQ002MzI2OCBhbGxvd3MgbXV4 aW5nIEdQSU9zCnRvIGRpZmZlcmVudCBmdW5jdGlvbnMuIERlcGVuZGluZyBvbiB0aGUgbXV4LCB0 aGVzZSBhcmUgZWl0aGVyIHNpbmdsZQpwaW4gY29uZmlndXJhdGlvbnMgb3Igd2hvbGUgcGluIGdy b3Vwcy4KClNpZ25lZC1vZmYtYnk6IEpvbmFzIEdvcnNraSA8am9uYXMuZ29yc2tpQGdtYWlsLmNv bT4KQ28tZGV2ZWxvcGVkLWJ5OiBKb25hcyBHb3Jza2kgPGpvbmFzLmdvcnNraUBnbWFpbC5jb20+ ClNpZ25lZC1vZmYtYnk6IMOBbHZhcm8gRmVybsOhbmRleiBSb2phcyA8bm9sdGFyaUBnbWFpbC5j b20+Ci0tLQogdjY6IG5vIGNoYW5nZXMKIHY1OiBhZGQgY2hhbmdlcyBzdWdnZXN0ZWQgYnkgQW5k eSBTaGV2Y2hlbmtvCiB2NDogbm8gY2hhbmdlcwogdjM6IHVzZSBuZXcgc2hhcmVkIGNvZGUKIHYy OiBzd2l0Y2ggdG8gR1BJT19SRUdNQVAKCiBkcml2ZXJzL3BpbmN0cmwvYmNtL0tjb25maWcgICAg ICAgICAgICB8ICAgOCArCiBkcml2ZXJzL3BpbmN0cmwvYmNtL01ha2VmaWxlICAgICAgICAgICB8 ICAgMSArCiBkcml2ZXJzL3BpbmN0cmwvYmNtL3BpbmN0cmwtYmNtNjMyNjguYyB8IDY0MyArKysr KysrKysrKysrKysrKysrKysrKysrCiAzIGZpbGVzIGNoYW5nZWQsIDY1MiBpbnNlcnRpb25zKCsp CiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9waW5jdHJsL2JjbS9waW5jdHJsLWJjbTYzMjY4 LmMKCmRpZmYgLS1naXQgYS9kcml2ZXJzL3BpbmN0cmwvYmNtL0tjb25maWcgYi9kcml2ZXJzL3Bp bmN0cmwvYmNtL0tjb25maWcKaW5kZXggYWFiZDRiNzYyYWVkLi4xODY5ODU4NDYxMjAgMTAwNjQ0 Ci0tLSBhL2RyaXZlcnMvcGluY3RybC9iY20vS2NvbmZpZworKysgYi9kcml2ZXJzL3BpbmN0cmwv YmNtL0tjb25maWcKQEAgLTY4LDYgKzY4LDE0IEBAIGNvbmZpZyBQSU5DVFJMX0JDTTYzNjgKIAlo ZWxwCiAJICAgU2F5IFkgaGVyZSB0byBlbmFibGUgdGhlIEJyb2FkY29tIEJDTTYzNjggR1BJTyBk cml2ZXIuCiAKK2NvbmZpZyBQSU5DVFJMX0JDTTYzMjY4CisJYm9vbCAiQnJvYWRjb20gQkNNNjMy NjggR1BJTyBkcml2ZXIiCisJZGVwZW5kcyBvbiAoQk1JUFNfR0VORVJJQyB8fCBDT01QSUxFX1RF U1QpCisJc2VsZWN0IFBJTkNUUkxfQkNNNjNYWAorCWRlZmF1bHQgQk1JUFNfR0VORVJJQworCWhl bHAKKwkgICBTYXkgWSBoZXJlIHRvIGVuYWJsZSB0aGUgQnJvYWRjb20gQkNNNjMyNjggR1BJTyBk cml2ZXIuCisKIGNvbmZpZyBQSU5DVFJMX0lQUk9DX0dQSU8KIAlib29sICJCcm9hZGNvbSBpUHJv YyBHUElPICh3aXRoIFBJTkNPTkYpIGRyaXZlciIKIAlkZXBlbmRzIG9uIE9GX0dQSU8gJiYgKEFS Q0hfQkNNX0lQUk9DIHx8IENPTVBJTEVfVEVTVCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGluY3Ry bC9iY20vTWFrZWZpbGUgYi9kcml2ZXJzL3BpbmN0cmwvYmNtL01ha2VmaWxlCmluZGV4IGExMzMx YmI5NjgwZS4uNDExNzg0N2ZkMjc5IDEwMDY0NAotLS0gYS9kcml2ZXJzL3BpbmN0cmwvYmNtL01h a2VmaWxlCisrKyBiL2RyaXZlcnMvcGluY3RybC9iY20vTWFrZWZpbGUKQEAgLTgsNiArOCw3IEBA IG9iai0kKENPTkZJR19QSU5DVFJMX0JDTTYzMjgpCQkrPSBwaW5jdHJsLWJjbTYzMjgubwogb2Jq LSQoQ09ORklHX1BJTkNUUkxfQkNNNjM1OCkJCSs9IHBpbmN0cmwtYmNtNjM1OC5vCiBvYmotJChD T05GSUdfUElOQ1RSTF9CQ002MzYyKQkJKz0gcGluY3RybC1iY202MzYyLm8KIG9iai0kKENPTkZJ R19QSU5DVFJMX0JDTTYzNjgpCQkrPSBwaW5jdHJsLWJjbTYzNjgubworb2JqLSQoQ09ORklHX1BJ TkNUUkxfQkNNNjMyNjgpCQkrPSBwaW5jdHJsLWJjbTYzMjY4Lm8KIG9iai0kKENPTkZJR19QSU5D VFJMX0lQUk9DX0dQSU8pCSs9IHBpbmN0cmwtaXByb2MtZ3Bpby5vCiBvYmotJChDT05GSUdfUElO Q1RSTF9DWUdOVVNfTVVYKQkrPSBwaW5jdHJsLWN5Z251cy1tdXgubwogb2JqLSQoQ09ORklHX1BJ TkNUUkxfTlMpCQkrPSBwaW5jdHJsLW5zLm8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGluY3RybC9i Y20vcGluY3RybC1iY202MzI2OC5jIGIvZHJpdmVycy9waW5jdHJsL2JjbS9waW5jdHJsLWJjbTYz MjY4LmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi5kNGM1ZmFkN2Zi N2QKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3BpbmN0cmwvYmNtL3BpbmN0cmwtYmNtNjMy NjguYwpAQCAtMCwwICsxLDY0MyBAQAorLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0y LjArCisvKgorICogRHJpdmVyIGZvciBCQ002MzI2OCBHUElPIHVuaXQgKHBpbmN0cmwgKyBHUElP KQorICoKKyAqIENvcHlyaWdodCAoQykgMjAyMSDDgWx2YXJvIEZlcm7DoW5kZXogUm9qYXMgPG5v bHRhcmlAZ21haWwuY29tPgorICogQ29weXJpZ2h0IChDKSAyMDE2IEpvbmFzIEdvcnNraSA8am9u YXMuZ29yc2tpQGdtYWlsLmNvbT4KKyAqLworCisjaW5jbHVkZSA8bGludXgvYml0cy5oPgorI2lu Y2x1ZGUgPGxpbnV4L2dwaW8vZHJpdmVyLmg+CisjaW5jbHVkZSA8bGludXgva2VybmVsLmg+Cisj aW5jbHVkZSA8bGludXgvb2YuaD4KKyNpbmNsdWRlIDxsaW51eC9waW5jdHJsL3Bpbm11eC5oPgor I2luY2x1ZGUgPGxpbnV4L3BsYXRmb3JtX2RldmljZS5oPgorI2luY2x1ZGUgPGxpbnV4L3JlZ21h cC5oPgorCisjaW5jbHVkZSAiLi4vcGluY3RybC11dGlscy5oIgorCisjaW5jbHVkZSAicGluY3Ry bC1iY202M3h4LmgiCisKKyNkZWZpbmUgQkNNNjMyNjhfTlVNX0dQSU9TCQk1MgorI2RlZmluZSBC Q002MzI2OF9OVU1fTEVEUwkJMjQKKworI2RlZmluZSBCQ002MzI2OF9MRURfUkVHCQkweDEwCisj ZGVmaW5lIEJDTTYzMjY4X01PREVfUkVHCQkweDE4CisjZGVmaW5lIEJDTTYzMjY4X0NUUkxfUkVH CQkweDFjCisjZGVmaW5lIEJDTTYzMjY4X0JBU0VNT0RFX1JFRwkJMHgzOAorI2RlZmluZSAgQkNN NjMyNjhfQkFTRU1PREVfTkFORAkJQklUKDIpIC8qIEdQSU9zIDItNywgMjQtMzEgKi8KKyNkZWZp bmUgIEJDTTYzMjY4X0JBU0VNT0RFX0dQSU8zNQlCSVQoNCkgLyogR1BJTyAzNSAqLworI2RlZmlu ZSAgQkNNNjMyNjhfQkFTRU1PREVfREVDVFBECUJJVCg1KSAvKiBHUElPcyA4LzkgKi8KKyNkZWZp bmUgIEJDTTYzMjY4X0JBU0VNT0RFX1ZEU0xfUEhZXzAJQklUKDYpIC8qIEdQSU9zIDEwLzExICov CisjZGVmaW5lICBCQ002MzI2OF9CQVNFTU9ERV9WRFNMX1BIWV8xCUJJVCg3KSAvKiBHUElPcyAx Mi8xMyAqLworI2RlZmluZSAgQkNNNjMyNjhfQkFTRU1PREVfVkRTTF9QSFlfMglCSVQoOCkgLyog R1BJT3MgMjQvMjUgKi8KKyNkZWZpbmUgIEJDTTYzMjY4X0JBU0VNT0RFX1ZEU0xfUEhZXzMJQklU KDkpIC8qIEdQSU9zIDI2LzI3ICovCisKK2VudW0gYmNtNjMyNjhfcGluY3RybF9yZWcgeworCUJD TTYzMjY4X0xFRENUUkwsCisJQkNNNjMyNjhfTU9ERSwKKwlCQ002MzI2OF9DVFJMLAorCUJDTTYz MjY4X0JBU0VNT0RFLAorfTsKKworc3RydWN0IGJjbTYzMjY4X3Bpbmdyb3VwIHsKKwljb25zdCBj aGFyICpuYW1lOworCWNvbnN0IHVuc2lnbmVkICogY29uc3QgcGluczsKKwljb25zdCB1bnNpZ25l ZCBudW1fcGluczsKK307CisKK3N0cnVjdCBiY202MzI2OF9mdW5jdGlvbiB7CisJY29uc3QgY2hh ciAqbmFtZTsKKwljb25zdCBjaGFyICogY29uc3QgKmdyb3VwczsKKwljb25zdCB1bnNpZ25lZCBu dW1fZ3JvdXBzOworCisJZW51bSBiY202MzI2OF9waW5jdHJsX3JlZyByZWc7CisJdWludDMyX3Qg bWFzazsKK307CisKKyNkZWZpbmUgQkNNNjMyNjhfUElOKGEsIGIsIGJhc2Vtb2RlKQkJCVwKKwl7 CQkJCQkJXAorCQkubnVtYmVyID0gYSwJCQkJXAorCQkubmFtZSA9IGIsCQkJCVwKKwkJLmRydl9k YXRhID0gKHZvaWQgKikoYmFzZW1vZGUpCQlcCisJfQorCitzdGF0aWMgY29uc3Qgc3RydWN0IHBp bmN0cmxfcGluX2Rlc2MgYmNtNjMyNjhfcGluc1tdID0geworCVBJTkNUUkxfUElOKDAsICJncGlv MCIpLAorCVBJTkNUUkxfUElOKDEsICJncGlvMSIpLAorCUJDTTYzMjY4X1BJTigyLCAiZ3BpbzIi LCBCQ002MzI2OF9CQVNFTU9ERV9OQU5EKSwKKwlCQ002MzI2OF9QSU4oMywgImdwaW8zIiwgQkNN NjMyNjhfQkFTRU1PREVfTkFORCksCisJQkNNNjMyNjhfUElOKDQsICJncGlvNCIsIEJDTTYzMjY4 X0JBU0VNT0RFX05BTkQpLAorCUJDTTYzMjY4X1BJTig1LCAiZ3BpbzUiLCBCQ002MzI2OF9CQVNF TU9ERV9OQU5EKSwKKwlCQ002MzI2OF9QSU4oNiwgImdwaW82IiwgQkNNNjMyNjhfQkFTRU1PREVf TkFORCksCisJQkNNNjMyNjhfUElOKDcsICJncGlvNyIsIEJDTTYzMjY4X0JBU0VNT0RFX05BTkQp LAorCUJDTTYzMjY4X1BJTig4LCAiZ3BpbzgiLCBCQ002MzI2OF9CQVNFTU9ERV9ERUNUUEQpLAor CUJDTTYzMjY4X1BJTig5LCAiZ3BpbzkiLCBCQ002MzI2OF9CQVNFTU9ERV9ERUNUUEQpLAorCUJD TTYzMjY4X1BJTigxMCwgImdwaW8xMCIsIEJDTTYzMjY4X0JBU0VNT0RFX1ZEU0xfUEhZXzApLAor CUJDTTYzMjY4X1BJTigxMSwgImdwaW8xMSIsIEJDTTYzMjY4X0JBU0VNT0RFX1ZEU0xfUEhZXzAp LAorCUJDTTYzMjY4X1BJTigxMiwgImdwaW8xMiIsIEJDTTYzMjY4X0JBU0VNT0RFX1ZEU0xfUEhZ XzEpLAorCUJDTTYzMjY4X1BJTigxMywgImdwaW8xMyIsIEJDTTYzMjY4X0JBU0VNT0RFX1ZEU0xf UEhZXzEpLAorCVBJTkNUUkxfUElOKDE0LCAiZ3BpbzE0IiksCisJUElOQ1RSTF9QSU4oMTUsICJn cGlvMTUiKSwKKwlQSU5DVFJMX1BJTigxNiwgImdwaW8xNiIpLAorCVBJTkNUUkxfUElOKDE3LCAi Z3BpbzE3IiksCisJUElOQ1RSTF9QSU4oMTgsICJncGlvMTgiKSwKKwlQSU5DVFJMX1BJTigxOSwg ImdwaW8xOSIpLAorCVBJTkNUUkxfUElOKDIwLCAiZ3BpbzIwIiksCisJUElOQ1RSTF9QSU4oMjEs ICJncGlvMjEiKSwKKwlQSU5DVFJMX1BJTigyMiwgImdwaW8yMiIpLAorCVBJTkNUUkxfUElOKDIz LCAiZ3BpbzIzIiksCisJQkNNNjMyNjhfUElOKDI0LCAiZ3BpbzI0IiwKKwkJICAgICBCQ002MzI2 OF9CQVNFTU9ERV9OQU5EIHwgQkNNNjMyNjhfQkFTRU1PREVfVkRTTF9QSFlfMiksCisJQkNNNjMy NjhfUElOKDI1LCAiZ3BpbzI1IiwKKwkJICAgICBCQ002MzI2OF9CQVNFTU9ERV9OQU5EIHwgQkNN NjMyNjhfQkFTRU1PREVfVkRTTF9QSFlfMiksCisJQkNNNjMyNjhfUElOKDI2LCAiZ3BpbzI2IiwK KwkJICAgICBCQ002MzI2OF9CQVNFTU9ERV9OQU5EIHwgQkNNNjMyNjhfQkFTRU1PREVfVkRTTF9Q SFlfMyksCisJQkNNNjMyNjhfUElOKDI3LCAiZ3BpbzI3IiwKKwkJICAgICBCQ002MzI2OF9CQVNF TU9ERV9OQU5EIHwgQkNNNjMyNjhfQkFTRU1PREVfVkRTTF9QSFlfMyksCisJQkNNNjMyNjhfUElO KDI4LCAiZ3BpbzI4IiwgQkNNNjMyNjhfQkFTRU1PREVfTkFORCksCisJQkNNNjMyNjhfUElOKDI5 LCAiZ3BpbzI5IiwgQkNNNjMyNjhfQkFTRU1PREVfTkFORCksCisJQkNNNjMyNjhfUElOKDMwLCAi Z3BpbzMwIiwgQkNNNjMyNjhfQkFTRU1PREVfTkFORCksCisJQkNNNjMyNjhfUElOKDMxLCAiZ3Bp bzMxIiwgQkNNNjMyNjhfQkFTRU1PREVfTkFORCksCisJUElOQ1RSTF9QSU4oMzIsICJncGlvMzIi KSwKKwlQSU5DVFJMX1BJTigzMywgImdwaW8zMyIpLAorCVBJTkNUUkxfUElOKDM0LCAiZ3BpbzM0 IiksCisJUElOQ1RSTF9QSU4oMzUsICJncGlvMzUiKSwKKwlQSU5DVFJMX1BJTigzNiwgImdwaW8z NiIpLAorCVBJTkNUUkxfUElOKDM3LCAiZ3BpbzM3IiksCisJUElOQ1RSTF9QSU4oMzgsICJncGlv MzgiKSwKKwlQSU5DVFJMX1BJTigzOSwgImdwaW8zOSIpLAorCVBJTkNUUkxfUElOKDQwLCAiZ3Bp bzQwIiksCisJUElOQ1RSTF9QSU4oNDEsICJncGlvNDEiKSwKKwlQSU5DVFJMX1BJTig0MiwgImdw aW80MiIpLAorCVBJTkNUUkxfUElOKDQzLCAiZ3BpbzQzIiksCisJUElOQ1RSTF9QSU4oNDQsICJn cGlvNDQiKSwKKwlQSU5DVFJMX1BJTig0NSwgImdwaW80NSIpLAorCVBJTkNUUkxfUElOKDQ2LCAi Z3BpbzQ2IiksCisJUElOQ1RSTF9QSU4oNDcsICJncGlvNDciKSwKKwlQSU5DVFJMX1BJTig0OCwg ImdwaW80OCIpLAorCVBJTkNUUkxfUElOKDQ5LCAiZ3BpbzQ5IiksCisJUElOQ1RSTF9QSU4oNTAs ICJncGlvNTAiKSwKKwlQSU5DVFJMX1BJTig1MSwgImdwaW81MSIpLAorfTsKKworc3RhdGljIHVu c2lnbmVkIGdwaW8wX3BpbnNbXSA9IHsgMCB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8xX3BpbnNb XSA9IHsgMSB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8yX3BpbnNbXSA9IHsgMiB9Oworc3RhdGlj IHVuc2lnbmVkIGdwaW8zX3BpbnNbXSA9IHsgMyB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW80X3Bp bnNbXSA9IHsgNCB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW81X3BpbnNbXSA9IHsgNSB9Oworc3Rh dGljIHVuc2lnbmVkIGdwaW82X3BpbnNbXSA9IHsgNiB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW83 X3BpbnNbXSA9IHsgNyB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW84X3BpbnNbXSA9IHsgOCB9Owor c3RhdGljIHVuc2lnbmVkIGdwaW85X3BpbnNbXSA9IHsgOSB9Oworc3RhdGljIHVuc2lnbmVkIGdw aW8xMF9waW5zW10gPSB7IDEwIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzExX3BpbnNbXSA9IHsg MTEgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMTJfcGluc1tdID0geyAxMiB9Oworc3RhdGljIHVu c2lnbmVkIGdwaW8xM19waW5zW10gPSB7IDEzIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzE0X3Bp bnNbXSA9IHsgMTQgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMTVfcGluc1tdID0geyAxNSB9Owor c3RhdGljIHVuc2lnbmVkIGdwaW8xNl9waW5zW10gPSB7IDE2IH07CitzdGF0aWMgdW5zaWduZWQg Z3BpbzE3X3BpbnNbXSA9IHsgMTcgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMThfcGluc1tdID0g eyAxOCB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8xOV9waW5zW10gPSB7IDE5IH07CitzdGF0aWMg dW5zaWduZWQgZ3BpbzIwX3BpbnNbXSA9IHsgMjAgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMjFf cGluc1tdID0geyAyMSB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8yMl9waW5zW10gPSB7IDIyIH07 CitzdGF0aWMgdW5zaWduZWQgZ3BpbzIzX3BpbnNbXSA9IHsgMjMgfTsKK3N0YXRpYyB1bnNpZ25l ZCBncGlvMjRfcGluc1tdID0geyAyNCB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8yNV9waW5zW10g PSB7IDI1IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzI2X3BpbnNbXSA9IHsgMjYgfTsKK3N0YXRp YyB1bnNpZ25lZCBncGlvMjdfcGluc1tdID0geyAyNyB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8y OF9waW5zW10gPSB7IDI4IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzI5X3BpbnNbXSA9IHsgMjkg fTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMzBfcGluc1tdID0geyAzMCB9Oworc3RhdGljIHVuc2ln bmVkIGdwaW8zMV9waW5zW10gPSB7IDMxIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzMyX3BpbnNb XSA9IHsgMzIgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMzNfcGluc1tdID0geyAzMyB9Oworc3Rh dGljIHVuc2lnbmVkIGdwaW8zNF9waW5zW10gPSB7IDM0IH07CitzdGF0aWMgdW5zaWduZWQgZ3Bp bzM1X3BpbnNbXSA9IHsgMzUgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMzZfcGluc1tdID0geyAz NiB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8zN19waW5zW10gPSB7IDM3IH07CitzdGF0aWMgdW5z aWduZWQgZ3BpbzM4X3BpbnNbXSA9IHsgMzggfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMzlfcGlu c1tdID0geyAzOSB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW80MF9waW5zW10gPSB7IDQwIH07Citz dGF0aWMgdW5zaWduZWQgZ3BpbzQxX3BpbnNbXSA9IHsgNDEgfTsKK3N0YXRpYyB1bnNpZ25lZCBn cGlvNDJfcGluc1tdID0geyA0MiB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW80M19waW5zW10gPSB7 IDQzIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzQ0X3BpbnNbXSA9IHsgNDQgfTsKK3N0YXRpYyB1 bnNpZ25lZCBncGlvNDVfcGluc1tdID0geyA0NSB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW80Nl9w aW5zW10gPSB7IDQ2IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzQ3X3BpbnNbXSA9IHsgNDcgfTsK K3N0YXRpYyB1bnNpZ25lZCBncGlvNDhfcGluc1tdID0geyA0OCB9Oworc3RhdGljIHVuc2lnbmVk IGdwaW80OV9waW5zW10gPSB7IDQ5IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzUwX3BpbnNbXSA9 IHsgNTAgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvNTFfcGluc1tdID0geyA1MSB9OworCitzdGF0 aWMgdW5zaWduZWQgbmFuZF9ncnBfcGluc1tdID0geworCTIsIDMsIDQsIDUsIDYsIDcsIDI0LAor CTI1LCAyNiwgMjcsIDI4LCAyOSwgMzAsIDMxLAorfTsKKworc3RhdGljIHVuc2lnbmVkIGRlY3Rw ZF9ncnBfcGluc1tdID0geyA4LCA5IH07CitzdGF0aWMgdW5zaWduZWQgdmRzbF9waHkwX2dycF9w aW5zW10gPSB7IDEwLCAxMSB9Oworc3RhdGljIHVuc2lnbmVkIHZkc2xfcGh5MV9ncnBfcGluc1td ID0geyAxMiwgMTMgfTsKK3N0YXRpYyB1bnNpZ25lZCB2ZHNsX3BoeTJfZ3JwX3BpbnNbXSA9IHsg MjQsIDI1IH07CitzdGF0aWMgdW5zaWduZWQgdmRzbF9waHkzX2dycF9waW5zW10gPSB7IDI2LCAy NyB9OworCisjZGVmaW5lIEJDTTYzMjY4X0dST1VQKG4pCQkJCQlcCisJewkJCQkJCQlcCisJCS5u YW1lID0gI24sCQkJCQlcCisJCS5waW5zID0gbiMjX3BpbnMsCQkJCVwKKwkJLm51bV9waW5zID0g QVJSQVlfU0laRShuIyNfcGlucyksCQlcCisJfQorCitzdGF0aWMgc3RydWN0IGJjbTYzMjY4X3Bp bmdyb3VwIGJjbTYzMjY4X2dyb3Vwc1tdID0geworCUJDTTYzMjY4X0dST1VQKGdwaW8wKSwKKwlC Q002MzI2OF9HUk9VUChncGlvMSksCisJQkNNNjMyNjhfR1JPVVAoZ3BpbzIpLAorCUJDTTYzMjY4 X0dST1VQKGdwaW8zKSwKKwlCQ002MzI2OF9HUk9VUChncGlvNCksCisJQkNNNjMyNjhfR1JPVVAo Z3BpbzUpLAorCUJDTTYzMjY4X0dST1VQKGdwaW82KSwKKwlCQ002MzI2OF9HUk9VUChncGlvNyks CisJQkNNNjMyNjhfR1JPVVAoZ3BpbzgpLAorCUJDTTYzMjY4X0dST1VQKGdwaW85KSwKKwlCQ002 MzI2OF9HUk9VUChncGlvMTApLAorCUJDTTYzMjY4X0dST1VQKGdwaW8xMSksCisJQkNNNjMyNjhf R1JPVVAoZ3BpbzEyKSwKKwlCQ002MzI2OF9HUk9VUChncGlvMTMpLAorCUJDTTYzMjY4X0dST1VQ KGdwaW8xNCksCisJQkNNNjMyNjhfR1JPVVAoZ3BpbzE1KSwKKwlCQ002MzI2OF9HUk9VUChncGlv MTYpLAorCUJDTTYzMjY4X0dST1VQKGdwaW8xNyksCisJQkNNNjMyNjhfR1JPVVAoZ3BpbzE4KSwK KwlCQ002MzI2OF9HUk9VUChncGlvMTkpLAorCUJDTTYzMjY4X0dST1VQKGdwaW8yMCksCisJQkNN NjMyNjhfR1JPVVAoZ3BpbzIxKSwKKwlCQ002MzI2OF9HUk9VUChncGlvMjIpLAorCUJDTTYzMjY4 X0dST1VQKGdwaW8yMyksCisJQkNNNjMyNjhfR1JPVVAoZ3BpbzI0KSwKKwlCQ002MzI2OF9HUk9V UChncGlvMjUpLAorCUJDTTYzMjY4X0dST1VQKGdwaW8yNiksCisJQkNNNjMyNjhfR1JPVVAoZ3Bp bzI3KSwKKwlCQ002MzI2OF9HUk9VUChncGlvMjgpLAorCUJDTTYzMjY4X0dST1VQKGdwaW8yOSks CisJQkNNNjMyNjhfR1JPVVAoZ3BpbzMwKSwKKwlCQ002MzI2OF9HUk9VUChncGlvMzEpLAorCUJD TTYzMjY4X0dST1VQKGdwaW8zMiksCisJQkNNNjMyNjhfR1JPVVAoZ3BpbzMzKSwKKwlCQ002MzI2 OF9HUk9VUChncGlvMzQpLAorCUJDTTYzMjY4X0dST1VQKGdwaW8zNSksCisJQkNNNjMyNjhfR1JP VVAoZ3BpbzM2KSwKKwlCQ002MzI2OF9HUk9VUChncGlvMzcpLAorCUJDTTYzMjY4X0dST1VQKGdw aW8zOCksCisJQkNNNjMyNjhfR1JPVVAoZ3BpbzM5KSwKKwlCQ002MzI2OF9HUk9VUChncGlvNDAp LAorCUJDTTYzMjY4X0dST1VQKGdwaW80MSksCisJQkNNNjMyNjhfR1JPVVAoZ3BpbzQyKSwKKwlC Q002MzI2OF9HUk9VUChncGlvNDMpLAorCUJDTTYzMjY4X0dST1VQKGdwaW80NCksCisJQkNNNjMy NjhfR1JPVVAoZ3BpbzQ1KSwKKwlCQ002MzI2OF9HUk9VUChncGlvNDYpLAorCUJDTTYzMjY4X0dS T1VQKGdwaW80NyksCisJQkNNNjMyNjhfR1JPVVAoZ3BpbzQ4KSwKKwlCQ002MzI2OF9HUk9VUChn cGlvNDkpLAorCUJDTTYzMjY4X0dST1VQKGdwaW81MCksCisJQkNNNjMyNjhfR1JPVVAoZ3BpbzUx KSwKKworCS8qIG11bHRpIHBpbiBncm91cHMgKi8KKwlCQ002MzI2OF9HUk9VUChuYW5kX2dycCks CisJQkNNNjMyNjhfR1JPVVAoZGVjdHBkX2dycCksCisJQkNNNjMyNjhfR1JPVVAodmRzbF9waHkw X2dycCksCisJQkNNNjMyNjhfR1JPVVAodmRzbF9waHkxX2dycCksCisJQkNNNjMyNjhfR1JPVVAo dmRzbF9waHkyX2dycCksCisJQkNNNjMyNjhfR1JPVVAodmRzbF9waHkzX2dycCksCit9OworCitz dGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGxlZF9ncm91cHNbXSA9IHsKKwkiZ3BpbzAiLAorCSJn cGlvMSIsCisJImdwaW8yIiwKKwkiZ3BpbzMiLAorCSJncGlvNCIsCisJImdwaW81IiwKKwkiZ3Bp bzYiLAorCSJncGlvNyIsCisJImdwaW84IiwKKwkiZ3BpbzkiLAorCSJncGlvMTAiLAorCSJncGlv MTEiLAorCSJncGlvMTIiLAorCSJncGlvMTMiLAorCSJncGlvMTQiLAorCSJncGlvMTUiLAorCSJn cGlvMTYiLAorCSJncGlvMTciLAorCSJncGlvMTgiLAorCSJncGlvMTkiLAorCSJncGlvMjAiLAor CSJncGlvMjEiLAorCSJncGlvMjIiLAorCSJncGlvMjMiLAorfTsKKworc3RhdGljIGNvbnN0IGNo YXIgKiBjb25zdCBzZXJpYWxfbGVkX2Nsa19ncm91cHNbXSA9IHsKKwkiZ3BpbzAiLAorfTsKKwor c3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBzZXJpYWxfbGVkX2RhdGFfZ3JvdXBzW10gPSB7CisJ ImdwaW8xIiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgaHNzcGlfY3M0X2dyb3Vw c1tdID0geworCSJncGlvMTYiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBoc3Nw aV9jczVfZ3JvdXBzW10gPSB7CisJImdwaW8xNyIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAq IGNvbnN0IGhzc3BpX2NzNl9ncm91cHNbXSA9IHsKKwkiZ3BpbzgiLAorfTsKKworc3RhdGljIGNv bnN0IGNoYXIgKiBjb25zdCBoc3NwaV9jczdfZ3JvdXBzW10gPSB7CisJImdwaW85IiwKK307CisK K3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgdWFydDFfc2N0c19ncm91cHNbXSA9IHsKKwkiZ3Bp bzEwIiwKKwkiZ3BpbzI0IiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgdWFydDFf c3J0c19ncm91cHNbXSA9IHsKKwkiZ3BpbzExIiwKKwkiZ3BpbzI1IiwKK307CisKK3N0YXRpYyBj b25zdCBjaGFyICogY29uc3QgdWFydDFfc2Rpbl9ncm91cHNbXSA9IHsKKwkiZ3BpbzEyIiwKKwki Z3BpbzI2IiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgdWFydDFfc2RvdXRfZ3Jv dXBzW10gPSB7CisJImdwaW8xMyIsCisJImdwaW8yNyIsCit9OworCitzdGF0aWMgY29uc3QgY2hh ciAqIGNvbnN0IG50cl9wdWxzZV9pbl9ncm91cHNbXSA9IHsKKwkiZ3BpbzE0IiwKKwkiZ3BpbzI4 IiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgZHNsX250cl9wdWxzZV9vdXRfZ3Jv dXBzW10gPSB7CisJImdwaW8xNSIsCisJImdwaW8yOSIsCit9OworCitzdGF0aWMgY29uc3QgY2hh ciAqIGNvbnN0IGFkc2xfc3BpX21pc29fZ3JvdXBzW10gPSB7CisJImdwaW8xOCIsCit9OworCitz dGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGFkc2xfc3BpX21vc2lfZ3JvdXBzW10gPSB7CisJImdw aW8xOSIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHZyZWdfY2xrX2dyb3Vwc1td ID0geworCSJncGlvMjIiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBwY2llX2Ns a3JlcV9iX2dyb3Vwc1tdID0geworCSJncGlvMjMiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIg KiBjb25zdCBzd2l0Y2hfbGVkX2Nsa19ncm91cHNbXSA9IHsKKwkiZ3BpbzMwIiwKK307CisKK3N0 YXRpYyBjb25zdCBjaGFyICogY29uc3Qgc3dpdGNoX2xlZF9kYXRhX2dyb3Vwc1tdID0geworCSJn cGlvMzEiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCB3aWZpX2dyb3Vwc1tdID0g eworCSJncGlvMzIiLAorCSJncGlvMzMiLAorCSJncGlvMzQiLAorCSJncGlvMzUiLAorCSJncGlv MzYiLAorCSJncGlvMzciLAorCSJncGlvMzgiLAorCSJncGlvMzkiLAorCSJncGlvNDAiLAorCSJn cGlvNDEiLAorCSJncGlvNDIiLAorCSJncGlvNDMiLAorCSJncGlvNDQiLAorCSJncGlvNDUiLAor CSJncGlvNDYiLAorCSJncGlvNDciLAorCSJncGlvNDgiLAorCSJncGlvNDkiLAorCSJncGlvNTAi LAorCSJncGlvNTEiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBuYW5kX2dyb3Vw c1tdID0geworCSJuYW5kX2dycCIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGRl Y3RwZF9ncm91cHNbXSA9IHsKKwkiZGVjdHBkX2dycCIsCit9OworCitzdGF0aWMgY29uc3QgY2hh ciAqIGNvbnN0IHZkc2xfcGh5X292ZXJyaWRlXzBfZ3JvdXBzW10gPSB7CisJInZkc2xfcGh5X292 ZXJyaWRlXzBfZ3JwIiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgdmRzbF9waHlf b3ZlcnJpZGVfMV9ncm91cHNbXSA9IHsKKwkidmRzbF9waHlfb3ZlcnJpZGVfMV9ncnAiLAorfTsK Kworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCB2ZHNsX3BoeV9vdmVycmlkZV8yX2dyb3Vwc1td ID0geworCSJ2ZHNsX3BoeV9vdmVycmlkZV8yX2dycCIsCit9OworCitzdGF0aWMgY29uc3QgY2hh ciAqIGNvbnN0IHZkc2xfcGh5X292ZXJyaWRlXzNfZ3JvdXBzW10gPSB7CisJInZkc2xfcGh5X292 ZXJyaWRlXzNfZ3JwIiwKK307CisKKyNkZWZpbmUgQkNNNjMyNjhfTEVEX0ZVTihuKQkJCQlcCisJ ewkJCQkJCVwKKwkJLm5hbWUgPSAjbiwJCQkJXAorCQkuZ3JvdXBzID0gbiMjX2dyb3VwcywJCQlc CisJCS5udW1fZ3JvdXBzID0gQVJSQVlfU0laRShuIyNfZ3JvdXBzKSwJXAorCQkucmVnID0gQkNN NjMyNjhfTEVEQ1RSTCwJCVwKKwl9CisKKyNkZWZpbmUgQkNNNjMyNjhfTU9ERV9GVU4obikJCQkJ XAorCXsJCQkJCQlcCisJCS5uYW1lID0gI24sCQkJCVwKKwkJLmdyb3VwcyA9IG4jI19ncm91cHMs CQkJXAorCQkubnVtX2dyb3VwcyA9IEFSUkFZX1NJWkUobiMjX2dyb3VwcyksCVwKKwkJLnJlZyA9 IEJDTTYzMjY4X01PREUsCQkJXAorCX0KKworI2RlZmluZSBCQ002MzI2OF9DVFJMX0ZVTihuKQkJ CQlcCisJewkJCQkJCVwKKwkJLm5hbWUgPSAjbiwJCQkJXAorCQkuZ3JvdXBzID0gbiMjX2dyb3Vw cywJCQlcCisJCS5udW1fZ3JvdXBzID0gQVJSQVlfU0laRShuIyNfZ3JvdXBzKSwJXAorCQkucmVn ID0gQkNNNjMyNjhfQ1RSTCwJCQlcCisJfQorCisjZGVmaW5lIEJDTTYzMjY4X0JBU0VNT0RFX0ZV TihuLCB2YWwpCQkJXAorCXsJCQkJCQlcCisJCS5uYW1lID0gI24sCQkJCVwKKwkJLmdyb3VwcyA9 IG4jI19ncm91cHMsCQkJXAorCQkubnVtX2dyb3VwcyA9IEFSUkFZX1NJWkUobiMjX2dyb3Vwcyks CVwKKwkJLnJlZyA9IEJDTTYzMjY4X0JBU0VNT0RFLAkJXAorCQkubWFzayA9IHZhbCwJCQkJXAor CX0KKworc3RhdGljIGNvbnN0IHN0cnVjdCBiY202MzI2OF9mdW5jdGlvbiBiY202MzI2OF9mdW5j c1tdID0geworCUJDTTYzMjY4X0xFRF9GVU4obGVkKSwKKwlCQ002MzI2OF9NT0RFX0ZVTihzZXJp YWxfbGVkX2NsayksCisJQkNNNjMyNjhfTU9ERV9GVU4oc2VyaWFsX2xlZF9kYXRhKSwKKwlCQ002 MzI2OF9NT0RFX0ZVTihoc3NwaV9jczYpLAorCUJDTTYzMjY4X01PREVfRlVOKGhzc3BpX2NzNyks CisJQkNNNjMyNjhfTU9ERV9GVU4odWFydDFfc2N0cyksCisJQkNNNjMyNjhfTU9ERV9GVU4odWFy dDFfc3J0cyksCisJQkNNNjMyNjhfTU9ERV9GVU4odWFydDFfc2RpbiksCisJQkNNNjMyNjhfTU9E RV9GVU4odWFydDFfc2RvdXQpLAorCUJDTTYzMjY4X01PREVfRlVOKG50cl9wdWxzZV9pbiksCisJ QkNNNjMyNjhfTU9ERV9GVU4oZHNsX250cl9wdWxzZV9vdXQpLAorCUJDTTYzMjY4X01PREVfRlVO KGhzc3BpX2NzNCksCisJQkNNNjMyNjhfTU9ERV9GVU4oaHNzcGlfY3M1KSwKKwlCQ002MzI2OF9N T0RFX0ZVTihhZHNsX3NwaV9taXNvKSwKKwlCQ002MzI2OF9NT0RFX0ZVTihhZHNsX3NwaV9tb3Np KSwKKwlCQ002MzI2OF9NT0RFX0ZVTih2cmVnX2NsayksCisJQkNNNjMyNjhfTU9ERV9GVU4ocGNp ZV9jbGtyZXFfYiksCisJQkNNNjMyNjhfTU9ERV9GVU4oc3dpdGNoX2xlZF9jbGspLAorCUJDTTYz MjY4X01PREVfRlVOKHN3aXRjaF9sZWRfZGF0YSksCisJQkNNNjMyNjhfQ1RSTF9GVU4od2lmaSks CisJQkNNNjMyNjhfQkFTRU1PREVfRlVOKG5hbmQsIEJDTTYzMjY4X0JBU0VNT0RFX05BTkQpLAor CUJDTTYzMjY4X0JBU0VNT0RFX0ZVTihkZWN0cGQsIEJDTTYzMjY4X0JBU0VNT0RFX0RFQ1RQRCks CisJQkNNNjMyNjhfQkFTRU1PREVfRlVOKHZkc2xfcGh5X292ZXJyaWRlXzAsCisJCQkgICAgICBC Q002MzI2OF9CQVNFTU9ERV9WRFNMX1BIWV8wKSwKKwlCQ002MzI2OF9CQVNFTU9ERV9GVU4odmRz bF9waHlfb3ZlcnJpZGVfMSwKKwkJCSAgICAgIEJDTTYzMjY4X0JBU0VNT0RFX1ZEU0xfUEhZXzEp LAorCUJDTTYzMjY4X0JBU0VNT0RFX0ZVTih2ZHNsX3BoeV9vdmVycmlkZV8yLAorCQkJICAgICAg QkNNNjMyNjhfQkFTRU1PREVfVkRTTF9QSFlfMiksCisJQkNNNjMyNjhfQkFTRU1PREVfRlVOKHZk c2xfcGh5X292ZXJyaWRlXzMsCisJCQkgICAgICBCQ002MzI2OF9CQVNFTU9ERV9WRFNMX1BIWV8z KSwKK307CisKK3N0YXRpYyBpbnQgYmNtNjMyNjhfcGluY3RybF9nZXRfZ3JvdXBfY291bnQoc3Ry dWN0IHBpbmN0cmxfZGV2ICpwY3RsZGV2KQoreworCXJldHVybiBBUlJBWV9TSVpFKGJjbTYzMjY4 X2dyb3Vwcyk7Cit9CisKK3N0YXRpYyBjb25zdCBjaGFyICpiY202MzI2OF9waW5jdHJsX2dldF9n cm91cF9uYW1lKHN0cnVjdCBwaW5jdHJsX2RldiAqcGN0bGRldiwKKwkJCQkJCSAgIHVuc2lnbmVk IGdyb3VwKQoreworCXJldHVybiBiY202MzI2OF9ncm91cHNbZ3JvdXBdLm5hbWU7Cit9CisKK3N0 YXRpYyBpbnQgYmNtNjMyNjhfcGluY3RybF9nZXRfZ3JvdXBfcGlucyhzdHJ1Y3QgcGluY3RybF9k ZXYgKnBjdGxkZXYsCisJCQkJCSAgIHVuc2lnbmVkIGdyb3VwLAorCQkJCQkgICBjb25zdCB1bnNp Z25lZCAqKnBpbnMsCisJCQkJCSAgIHVuc2lnbmVkICpudW1fcGlucykKK3sKKwkqcGlucyA9IGJj bTYzMjY4X2dyb3Vwc1tncm91cF0ucGluczsKKwkqbnVtX3BpbnMgPSBiY202MzI2OF9ncm91cHNb Z3JvdXBdLm51bV9waW5zOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgYmNtNjMyNjhf cGluY3RybF9nZXRfZnVuY19jb3VudChzdHJ1Y3QgcGluY3RybF9kZXYgKnBjdGxkZXYpCit7CisJ cmV0dXJuIEFSUkFZX1NJWkUoYmNtNjMyNjhfZnVuY3MpOworfQorCitzdGF0aWMgY29uc3QgY2hh ciAqYmNtNjMyNjhfcGluY3RybF9nZXRfZnVuY19uYW1lKHN0cnVjdCBwaW5jdHJsX2RldiAqcGN0 bGRldiwKKwkJCQkJCSAgdW5zaWduZWQgc2VsZWN0b3IpCit7CisJcmV0dXJuIGJjbTYzMjY4X2Z1 bmNzW3NlbGVjdG9yXS5uYW1lOworfQorCitzdGF0aWMgaW50IGJjbTYzMjY4X3BpbmN0cmxfZ2V0 X2dyb3VwcyhzdHJ1Y3QgcGluY3RybF9kZXYgKnBjdGxkZXYsCisJCQkJICAgICAgIHVuc2lnbmVk IHNlbGVjdG9yLAorCQkJCSAgICAgICBjb25zdCBjaGFyICogY29uc3QgKipncm91cHMsCisJCQkJ ICAgICAgIHVuc2lnbmVkICogY29uc3QgbnVtX2dyb3VwcykKK3sKKwkqZ3JvdXBzID0gYmNtNjMy NjhfZnVuY3Nbc2VsZWN0b3JdLmdyb3VwczsKKwkqbnVtX2dyb3VwcyA9IGJjbTYzMjY4X2Z1bmNz W3NlbGVjdG9yXS5udW1fZ3JvdXBzOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyB2b2lkIGJj bTYzMjY4X3NldF9ncGlvKHN0cnVjdCBiY202M3h4X3BpbmN0cmwgKnBjLCB1bnNpZ25lZCBwaW4p Cit7CisJY29uc3Qgc3RydWN0IHBpbmN0cmxfcGluX2Rlc2MgKmRlc2MgPSAmYmNtNjMyNjhfcGlu c1twaW5dOworCXVuc2lnbmVkIGludCBiYXNlbW9kZSA9ICh1bnNpZ25lZCBsb25nKSBkZXNjLT5k cnZfZGF0YTsKKwl1bnNpZ25lZCBpbnQgbWFzayA9IEJJVChiY202M3h4X2JhbmtfcGluKHBpbikp OworCisJaWYgKGJhc2Vtb2RlKQorCQlyZWdtYXBfdXBkYXRlX2JpdHMocGMtPnJlZ3MsIEJDTTYz MjY4X0JBU0VNT0RFX1JFRywgYmFzZW1vZGUsCisJCQkJICAgMCk7CisKKwlpZiAocGluIDwgQkNN NjNYWF9CQU5LX0dQSU9TKSB7CisJCS8qIGJhc2UgbW9kZTogMCA9PiBncGlvLCAxID0+IG11eCBm dW5jdGlvbiAqLworCQlyZWdtYXBfdXBkYXRlX2JpdHMocGMtPnJlZ3MsIEJDTTYzMjY4X01PREVf UkVHLCBtYXNrLCAwKTsKKworCQkvKiBwaW5zIDAtMjMgbWlnaHQgYmUgbXV4ZWQgdG8gbGVkICov CisJCWlmIChwaW4gPCBCQ002MzI2OF9OVU1fTEVEUykKKwkJCXJlZ21hcF91cGRhdGVfYml0cyhw Yy0+cmVncywgQkNNNjMyNjhfTEVEX1JFRywgbWFzaywKKwkJCQkJICAgMCk7CisJfSBlbHNlIGlm IChwaW4gPCBCQ002MzI2OF9OVU1fR1BJT1MpIHsKKwkJLyogY3RybCByZWc6IDAgPT4gd2lmaSBm dW5jdGlvbiwgMSA9PiBncGlvICovCisJCXJlZ21hcF91cGRhdGVfYml0cyhwYy0+cmVncywgQkNN NjMyNjhfQ1RSTF9SRUcsIG1hc2ssIG1hc2spOworCX0KK30KKworc3RhdGljIGludCBiY202MzI2 OF9waW5jdHJsX3NldF9tdXgoc3RydWN0IHBpbmN0cmxfZGV2ICpwY3RsZGV2LAorCQkJCSAgICB1 bnNpZ25lZCBzZWxlY3RvciwgdW5zaWduZWQgZ3JvdXApCit7CisJc3RydWN0IGJjbTYzeHhfcGlu Y3RybCAqcGMgPSBwaW5jdHJsX2Rldl9nZXRfZHJ2ZGF0YShwY3RsZGV2KTsKKwljb25zdCBzdHJ1 Y3QgYmNtNjMyNjhfcGluZ3JvdXAgKnBnID0gJmJjbTYzMjY4X2dyb3Vwc1tncm91cF07CisJY29u c3Qgc3RydWN0IGJjbTYzMjY4X2Z1bmN0aW9uICpmID0gJmJjbTYzMjY4X2Z1bmNzW3NlbGVjdG9y XTsKKwl1bnNpZ25lZCBpOworCXVuc2lnbmVkIGludCByZWc7CisJdW5zaWduZWQgaW50IHZhbCwg bWFzazsKKworCWZvciAoaSA9IDA7IGkgPCBwZy0+bnVtX3BpbnM7IGkrKykKKwkJYmNtNjMyNjhf c2V0X2dwaW8ocGMsIHBnLT5waW5zW2ldKTsKKworCXN3aXRjaCAoZi0+cmVnKSB7CisJY2FzZSBC Q002MzI2OF9MRURDVFJMOgorCQlyZWcgPSBCQ002MzI2OF9MRURfUkVHOworCQltYXNrID0gQklU KHBnLT5waW5zWzBdKTsKKwkJdmFsID0gQklUKHBnLT5waW5zWzBdKTsKKwkJYnJlYWs7CisJY2Fz ZSBCQ002MzI2OF9NT0RFOgorCQlyZWcgPSBCQ002MzI2OF9NT0RFX1JFRzsKKwkJbWFzayA9IEJJ VChwZy0+cGluc1swXSk7CisJCXZhbCA9IEJJVChwZy0+cGluc1swXSk7CisJCWJyZWFrOworCWNh c2UgQkNNNjMyNjhfQ1RSTDoKKwkJcmVnID0gQkNNNjMyNjhfQ1RSTF9SRUc7CisJCW1hc2sgPSBC SVQocGctPnBpbnNbMF0pOworCQl2YWwgPSAwOworCQlicmVhazsKKwljYXNlIEJDTTYzMjY4X0JB U0VNT0RFOgorCQlyZWcgPSBCQ002MzI2OF9CQVNFTU9ERV9SRUc7CisJCW1hc2sgPSBmLT5tYXNr OworCQl2YWwgPSBmLT5tYXNrOworCQlicmVhazsKKwlkZWZhdWx0OgorCQlXQVJOX09OKDEpOwor CQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKKwlyZWdtYXBfdXBkYXRlX2JpdHMocGMtPnJlZ3MsIHJl ZywgbWFzaywgdmFsKTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IGJjbTYzMjY4X2dw aW9fcmVxdWVzdF9lbmFibGUoc3RydWN0IHBpbmN0cmxfZGV2ICpwY3RsZGV2LAorCQkJCQlzdHJ1 Y3QgcGluY3RybF9ncGlvX3JhbmdlICpyYW5nZSwKKwkJCQkJdW5zaWduZWQgb2Zmc2V0KQorewor CXN0cnVjdCBiY202M3h4X3BpbmN0cmwgKnBjID0gcGluY3RybF9kZXZfZ2V0X2RydmRhdGEocGN0 bGRldik7CisKKwkvKiBkaXNhYmxlIGFsbCBmdW5jdGlvbnMgdXNpbmcgdGhpcyBwaW4gKi8KKwli Y202MzI2OF9zZXRfZ3BpbyhwYywgb2Zmc2V0KTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMg c3RydWN0IHBpbmN0cmxfb3BzIGJjbTYzMjY4X3BjdGxfb3BzID0geworCS5kdF9mcmVlX21hcCA9 IHBpbmN0cmxfdXRpbHNfZnJlZV9tYXAsCisJLmR0X25vZGVfdG9fbWFwID0gcGluY29uZl9nZW5l cmljX2R0X25vZGVfdG9fbWFwX3BpbiwKKwkuZ2V0X2dyb3VwX25hbWUgPSBiY202MzI2OF9waW5j dHJsX2dldF9ncm91cF9uYW1lLAorCS5nZXRfZ3JvdXBfcGlucyA9IGJjbTYzMjY4X3BpbmN0cmxf Z2V0X2dyb3VwX3BpbnMsCisJLmdldF9ncm91cHNfY291bnQgPSBiY202MzI2OF9waW5jdHJsX2dl dF9ncm91cF9jb3VudCwKK307CisKK3N0YXRpYyBzdHJ1Y3QgcGlubXV4X29wcyBiY202MzI2OF9w bXhfb3BzID0geworCS5nZXRfZnVuY3Rpb25fZ3JvdXBzID0gYmNtNjMyNjhfcGluY3RybF9nZXRf Z3JvdXBzLAorCS5nZXRfZnVuY3Rpb25fbmFtZSA9IGJjbTYzMjY4X3BpbmN0cmxfZ2V0X2Z1bmNf bmFtZSwKKwkuZ2V0X2Z1bmN0aW9uc19jb3VudCA9IGJjbTYzMjY4X3BpbmN0cmxfZ2V0X2Z1bmNf Y291bnQsCisJLmdwaW9fcmVxdWVzdF9lbmFibGUgPSBiY202MzI2OF9ncGlvX3JlcXVlc3RfZW5h YmxlLAorCS5zZXRfbXV4ID0gYmNtNjMyNjhfcGluY3RybF9zZXRfbXV4LAorCS5zdHJpY3QgPSB0 cnVlLAorfTsKKworc3RhdGljIGNvbnN0IHN0cnVjdCBiY202M3h4X3BpbmN0cmxfc29jIGJjbTYz MjY4X3NvYyA9IHsKKwkubmdwaW9zID0gQkNNNjMyNjhfTlVNX0dQSU9TLAorCS5ucGlucyA9IEFS UkFZX1NJWkUoYmNtNjMyNjhfcGlucyksCisJLnBjdGxfb3BzID0gJmJjbTYzMjY4X3BjdGxfb3Bz LAorCS5waW5zID0gYmNtNjMyNjhfcGlucywKKwkucG14X29wcyA9ICZiY202MzI2OF9wbXhfb3Bz LAorfTsKKworc3RhdGljIGludCBiY202MzI2OF9waW5jdHJsX3Byb2JlKHN0cnVjdCBwbGF0Zm9y bV9kZXZpY2UgKnBkZXYpCit7CisJcmV0dXJuIGJjbTYzeHhfcGluY3RybF9wcm9iZShwZGV2LCAm YmNtNjMyNjhfc29jLCBOVUxMKTsKK30KKworc3RhdGljIGNvbnN0IHN0cnVjdCBvZl9kZXZpY2Vf aWQgYmNtNjMyNjhfcGluY3RybF9tYXRjaFtdID0geworCXsgLmNvbXBhdGlibGUgPSAiYnJjbSxi Y202MzI2OC1waW5jdHJsIiwgfSwKKwl7IC8qIHNlbnRpbmVsICovIH0KK307CisKK3N0YXRpYyBz dHJ1Y3QgcGxhdGZvcm1fZHJpdmVyIGJjbTYzMjY4X3BpbmN0cmxfZHJpdmVyID0geworCS5wcm9i ZSA9IGJjbTYzMjY4X3BpbmN0cmxfcHJvYmUsCisJLmRyaXZlciA9IHsKKwkJLm5hbWUgPSAiYmNt NjMyNjgtcGluY3RybCIsCisJCS5vZl9tYXRjaF90YWJsZSA9IGJjbTYzMjY4X3BpbmN0cmxfbWF0 Y2gsCisJfSwKK307CisKK2J1aWx0aW5fcGxhdGZvcm1fZHJpdmVyKGJjbTYzMjY4X3BpbmN0cmxf ZHJpdmVyKTsKLS0gCjIuMjAuMQoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fCmxpbnV4LWFybS1rZXJuZWwgbWFpbGluZyBsaXN0CmxpbnV4LWFybS1rZXJu ZWxAbGlzdHMuaW5mcmFkZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFu L2xpc3RpbmZvL2xpbnV4LWFybS1rZXJuZWwK