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.7 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 24367C1550A for ; Sat, 6 Mar 2021 15:58:21 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 055B065009 for ; Sat, 6 Mar 2021 15:58:20 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231255AbhCFP5y (ORCPT ); Sat, 6 Mar 2021 10:57:54 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:50968 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231142AbhCFP51 (ORCPT ); Sat, 6 Mar 2021 10:57:27 -0500 Received: from mail-wm1-x335.google.com (mail-wm1-x335.google.com [IPv6:2a00:1450:4864:20::335]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 7DADAC06174A; Sat, 6 Mar 2021 07:57:25 -0800 (PST) Received: by mail-wm1-x335.google.com with SMTP id b2-20020a7bc2420000b029010be1081172so1124639wmj.1; Sat, 06 Mar 2021 07:57:25 -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=FnDxfVBuXGYDXbYq6hYkf61qKjIohseT+4Lo557WZhk=; b=nZ3u4oCZaFvbyJsiUSc7xh2nL/RIK3DDIvs7pjqUtVUtaNvCRS4eV9G42w8yaX4Leb QS49CZT469XUv0bLro3rHNRvVgyp9pU0VoTsuNbqc7OmWv/MoI4q4F7LGVtLRi/PWT5S 35r6MiI7i9tfJzM8BRgvfmQQx+J4lYsJeu/dRX1yfFQMRfb0JW9e6iwPlI63lyhBqbb+ DKIHNSwJRjsZulywa9xprT2++7HgzxfyNMfKhkhKpS/Xgreo3BlldpTLrn5WCCfYNrVL /PBDYt3nV92BQY9LV8l5nZ65Yncv7YnGsViVayiU3EGwwVKZS5vToayUf+C8iZMFDZUt INYg== 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=FnDxfVBuXGYDXbYq6hYkf61qKjIohseT+4Lo557WZhk=; b=P8UNTNKVDITMMbD4apQJ9PIBthFxc9Rf3rekzWxIPP6h4pjMc9jH+lEzkrHlr0iUdC 7gRJSumzuzyLdOiqH09HIEbeuoLoXUt1Nu2I6p6HGrfF+XG8E39Cz6Wk76RoUjdfMs1j N3cwzl0zjXihPA6zh1nX9yNWyH9NtJ+rzymGY7d9bGqcmkLYXJJTvKenSLoqd4aqezC+ tw4r3FNceZXlRqctL8ZDFNZvpEay/SCFhmb5ow4k1mPo6znWLNMN+HOOUpky2jm8R1il zsxWP6o499vmOQb+PS8VbQdqucfp/YOszg3szepXJS3iRwlz4Gi6m3chhQ/biNIEkDXc NZcw== X-Gm-Message-State: AOAM533Omi9MTiy4P67PyUV36f9y0u3IEW/HOsvXNifrG59/vEl2vwxD qgecg69V1q3Yra9ASusARmw= X-Google-Smtp-Source: ABdhPJyYMXWxMitFm+c1KbUayG88FRAUPzIvQjmofWhNk78urlOXdpllAvQ+awdjOw2VbGPfvba6AA== X-Received: by 2002:a7b:c92d:: with SMTP id h13mr14070000wml.96.1615046244145; Sat, 06 Mar 2021 07:57:24 -0800 (PST) Received: from skynet.lan (224.red-2-138-103.dynamicip.rima-tde.net. [2.138.103.224]) by smtp.gmail.com with ESMTPSA id p6sm9315188wru.2.2021.03.06.07.57.23 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 06 Mar 2021 07:57:23 -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 v5 13/15] pinctrl: add a pincontrol driver for BCM63268 Date: Sat, 6 Mar 2021 16:57:10 +0100 Message-Id: <20210306155712.4298-14-noltari@gmail.com> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20210306155712.4298-1-noltari@gmail.com> References: <20210306155712.4298-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 --- 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 1BE72C433DB for ; Sat, 6 Mar 2021 16:01:30 +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 5A5F264FEA for ; Sat, 6 Mar 2021 16:01:29 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 5A5F264FEA 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=eDqy75fMGoK53s9Co5seESe+H+lQpEM959D6aAMKvg0=; b=E6hinsK1slKogwCEIG60oPLp/ i+wM0nzWzB++52i/fH4QnHtjGOhotkBkR9MfX53640/Gi8wvAOgdf+f7B18tkEabhCYfAkJsUzEel pNcURrAlk2JIumvFmBDTz9irnc9fBTsktDrBdglLrGqPzsrFR3HGH2ycW4IDUwW3KPz26WvQSATSG 7wFZAfws4CZQRkL8SEHptSebSowrB3snKO2mGMcAIk1YJV8nILHaHpEi28MstSuhJepNXf1r25ItH TP2B7y2nfe2f7lY8Etip9y5UfynEEwwzJfIySocKOQ7OiXZNUi03P8rMqK51YBBCYFhf1IP4C3TYy xp09bGTxQ==; Received: from localhost ([::1] helo=desiato.infradead.org) by desiato.infradead.org with esmtp (Exim 4.94 #2 (Red Hat Linux)) id 1lIZKx-003Vn3-2v; Sat, 06 Mar 2021 15:59:27 +0000 Received: from mail-wm1-x32f.google.com ([2a00:1450:4864:20::32f]) by desiato.infradead.org with esmtps (Exim 4.94 #2 (Red Hat Linux)) id 1lIZIy-003Uug-QJ for linux-arm-kernel@lists.infradead.org; Sat, 06 Mar 2021 15:57:27 +0000 Received: by mail-wm1-x32f.google.com with SMTP id 124-20020a1c00820000b029010b871409cfso1156001wma.4 for ; Sat, 06 Mar 2021 07:57:24 -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=FnDxfVBuXGYDXbYq6hYkf61qKjIohseT+4Lo557WZhk=; b=nZ3u4oCZaFvbyJsiUSc7xh2nL/RIK3DDIvs7pjqUtVUtaNvCRS4eV9G42w8yaX4Leb QS49CZT469XUv0bLro3rHNRvVgyp9pU0VoTsuNbqc7OmWv/MoI4q4F7LGVtLRi/PWT5S 35r6MiI7i9tfJzM8BRgvfmQQx+J4lYsJeu/dRX1yfFQMRfb0JW9e6iwPlI63lyhBqbb+ DKIHNSwJRjsZulywa9xprT2++7HgzxfyNMfKhkhKpS/Xgreo3BlldpTLrn5WCCfYNrVL /PBDYt3nV92BQY9LV8l5nZ65Yncv7YnGsViVayiU3EGwwVKZS5vToayUf+C8iZMFDZUt INYg== 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=FnDxfVBuXGYDXbYq6hYkf61qKjIohseT+4Lo557WZhk=; b=eZLUov62wjiQZCqBb+b1Plky9v6xj8M2ioNHZzhWBl2PVRfUhprRDi4KPkfbezWreH XS8PhjaC1rATEm06GeZwFGyLrfFrxrRyTChF9MriqrqGaqumSXxiNwuzK7o1CZ3+ZfT4 MSPbT6hu/PvRv2H+KKShFIqC7ObNYm+RGsdbVo+aSoMYbE/yr1492ev3rE5sVHmM2D67 e842oAGQ8fjiYFrvZ5h9wg/zLrD7hbkzo+FUX0kgmPf8vm1/9PzwqJG82XbwlYD0EMOz hYHOUSECsox4DCaLr7kjE0aDW2ME1WoFNBEkYOHHWgjbLiZxmb3OR4oNS4n1s6SoJ64E 8jxw== X-Gm-Message-State: AOAM533UYy0XSzeowAvQUk24JAfw1X/IAeIQJ42VsxJQmkuF8mZNKgdg 3h23jdsipiyM9hVt3JvfI/c= X-Google-Smtp-Source: ABdhPJyYMXWxMitFm+c1KbUayG88FRAUPzIvQjmofWhNk78urlOXdpllAvQ+awdjOw2VbGPfvba6AA== X-Received: by 2002:a7b:c92d:: with SMTP id h13mr14070000wml.96.1615046244145; Sat, 06 Mar 2021 07:57:24 -0800 (PST) Received: from skynet.lan (224.red-2-138-103.dynamicip.rima-tde.net. [2.138.103.224]) by smtp.gmail.com with ESMTPSA id p6sm9315188wru.2.2021.03.06.07.57.23 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 06 Mar 2021 07:57:23 -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 v5 13/15] pinctrl: add a pincontrol driver for BCM63268 Date: Sat, 6 Mar 2021 16:57:10 +0100 Message-Id: <20210306155712.4298-14-noltari@gmail.com> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20210306155712.4298-1-noltari@gmail.com> References: <20210306155712.4298-1-noltari@gmail.com> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20210306_155724_978569_61754655 X-CRM114-Status: GOOD ( 17.54 ) 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+Ci0tLQogdjU6IGFkZCBjaGFuZ2VzIHN1Z2dlc3RlZCBieSBBbmR5IFNoZXZjaGVua28KIHY0 OiBubyBjaGFuZ2VzCiB2MzogdXNlIG5ldyBzaGFyZWQgY29kZQogdjI6IHN3aXRjaCB0byBHUElP X1JFR01BUAoKIGRyaXZlcnMvcGluY3RybC9iY20vS2NvbmZpZyAgICAgICAgICAgIHwgICA4ICsK IGRyaXZlcnMvcGluY3RybC9iY20vTWFrZWZpbGUgICAgICAgICAgIHwgICAxICsKIGRyaXZlcnMv cGluY3RybC9iY20vcGluY3RybC1iY202MzI2OC5jIHwgNjQzICsrKysrKysrKysrKysrKysrKysr KysrKysKIDMgZmlsZXMgY2hhbmdlZCwgNjUyIGluc2VydGlvbnMoKykKIGNyZWF0ZSBtb2RlIDEw MDY0NCBkcml2ZXJzL3BpbmN0cmwvYmNtL3BpbmN0cmwtYmNtNjMyNjguYwoKZGlmZiAtLWdpdCBh L2RyaXZlcnMvcGluY3RybC9iY20vS2NvbmZpZyBiL2RyaXZlcnMvcGluY3RybC9iY20vS2NvbmZp ZwppbmRleCBhYWJkNGI3NjJhZWQuLjE4Njk4NTg0NjEyMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9w aW5jdHJsL2JjbS9LY29uZmlnCisrKyBiL2RyaXZlcnMvcGluY3RybC9iY20vS2NvbmZpZwpAQCAt NjgsNiArNjgsMTQgQEAgY29uZmlnIFBJTkNUUkxfQkNNNjM2OAogCWhlbHAKIAkgICBTYXkgWSBo ZXJlIHRvIGVuYWJsZSB0aGUgQnJvYWRjb20gQkNNNjM2OCBHUElPIGRyaXZlci4KIAorY29uZmln IFBJTkNUUkxfQkNNNjMyNjgKKwlib29sICJCcm9hZGNvbSBCQ002MzI2OCBHUElPIGRyaXZlciIK KwlkZXBlbmRzIG9uIChCTUlQU19HRU5FUklDIHx8IENPTVBJTEVfVEVTVCkKKwlzZWxlY3QgUElO Q1RSTF9CQ002M1hYCisJZGVmYXVsdCBCTUlQU19HRU5FUklDCisJaGVscAorCSAgIFNheSBZIGhl cmUgdG8gZW5hYmxlIHRoZSBCcm9hZGNvbSBCQ002MzI2OCBHUElPIGRyaXZlci4KKwogY29uZmln IFBJTkNUUkxfSVBST0NfR1BJTwogCWJvb2wgIkJyb2FkY29tIGlQcm9jIEdQSU8gKHdpdGggUElO Q09ORikgZHJpdmVyIgogCWRlcGVuZHMgb24gT0ZfR1BJTyAmJiAoQVJDSF9CQ01fSVBST0MgfHwg Q09NUElMRV9URVNUKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9waW5jdHJsL2JjbS9NYWtlZmlsZSBi L2RyaXZlcnMvcGluY3RybC9iY20vTWFrZWZpbGUKaW5kZXggYTEzMzFiYjk2ODBlLi40MTE3ODQ3 ZmQyNzkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcGluY3RybC9iY20vTWFrZWZpbGUKKysrIGIvZHJp dmVycy9waW5jdHJsL2JjbS9NYWtlZmlsZQpAQCAtOCw2ICs4LDcgQEAgb2JqLSQoQ09ORklHX1BJ TkNUUkxfQkNNNjMyOCkJCSs9IHBpbmN0cmwtYmNtNjMyOC5vCiBvYmotJChDT05GSUdfUElOQ1RS TF9CQ002MzU4KQkJKz0gcGluY3RybC1iY202MzU4Lm8KIG9iai0kKENPTkZJR19QSU5DVFJMX0JD TTYzNjIpCQkrPSBwaW5jdHJsLWJjbTYzNjIubwogb2JqLSQoQ09ORklHX1BJTkNUUkxfQkNNNjM2 OCkJCSs9IHBpbmN0cmwtYmNtNjM2OC5vCitvYmotJChDT05GSUdfUElOQ1RSTF9CQ002MzI2OCkJ CSs9IHBpbmN0cmwtYmNtNjMyNjgubwogb2JqLSQoQ09ORklHX1BJTkNUUkxfSVBST0NfR1BJTykJ Kz0gcGluY3RybC1pcHJvYy1ncGlvLm8KIG9iai0kKENPTkZJR19QSU5DVFJMX0NZR05VU19NVVgp CSs9IHBpbmN0cmwtY3lnbnVzLW11eC5vCiBvYmotJChDT05GSUdfUElOQ1RSTF9OUykJCSs9IHBp bmN0cmwtbnMubwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9waW5jdHJsL2JjbS9waW5jdHJsLWJjbTYz MjY4LmMgYi9kcml2ZXJzL3BpbmN0cmwvYmNtL3BpbmN0cmwtYmNtNjMyNjguYwpuZXcgZmlsZSBt b2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLmQ0YzVmYWQ3ZmI3ZAotLS0gL2Rldi9udWxs CisrKyBiL2RyaXZlcnMvcGluY3RybC9iY20vcGluY3RybC1iY202MzI2OC5jCkBAIC0wLDAgKzEs NjQzIEBACisvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMCsKKy8qCisgKiBEcml2 ZXIgZm9yIEJDTTYzMjY4IEdQSU8gdW5pdCAocGluY3RybCArIEdQSU8pCisgKgorICogQ29weXJp Z2h0IChDKSAyMDIxIMOBbHZhcm8gRmVybsOhbmRleiBSb2phcyA8bm9sdGFyaUBnbWFpbC5jb20+ CisgKiBDb3B5cmlnaHQgKEMpIDIwMTYgSm9uYXMgR29yc2tpIDxqb25hcy5nb3Jza2lAZ21haWwu Y29tPgorICovCisKKyNpbmNsdWRlIDxsaW51eC9iaXRzLmg+CisjaW5jbHVkZSA8bGludXgvZ3Bp by9kcml2ZXIuaD4KKyNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KKyNpbmNsdWRlIDxsaW51eC9v Zi5oPgorI2luY2x1ZGUgPGxpbnV4L3BpbmN0cmwvcGlubXV4Lmg+CisjaW5jbHVkZSA8bGludXgv cGxhdGZvcm1fZGV2aWNlLmg+CisjaW5jbHVkZSA8bGludXgvcmVnbWFwLmg+CisKKyNpbmNsdWRl ICIuLi9waW5jdHJsLXV0aWxzLmgiCisKKyNpbmNsdWRlICJwaW5jdHJsLWJjbTYzeHguaCIKKwor I2RlZmluZSBCQ002MzI2OF9OVU1fR1BJT1MJCTUyCisjZGVmaW5lIEJDTTYzMjY4X05VTV9MRURT CQkyNAorCisjZGVmaW5lIEJDTTYzMjY4X0xFRF9SRUcJCTB4MTAKKyNkZWZpbmUgQkNNNjMyNjhf TU9ERV9SRUcJCTB4MTgKKyNkZWZpbmUgQkNNNjMyNjhfQ1RSTF9SRUcJCTB4MWMKKyNkZWZpbmUg QkNNNjMyNjhfQkFTRU1PREVfUkVHCQkweDM4CisjZGVmaW5lICBCQ002MzI2OF9CQVNFTU9ERV9O QU5ECQlCSVQoMikgLyogR1BJT3MgMi03LCAyNC0zMSAqLworI2RlZmluZSAgQkNNNjMyNjhfQkFT RU1PREVfR1BJTzM1CUJJVCg0KSAvKiBHUElPIDM1ICovCisjZGVmaW5lICBCQ002MzI2OF9CQVNF TU9ERV9ERUNUUEQJQklUKDUpIC8qIEdQSU9zIDgvOSAqLworI2RlZmluZSAgQkNNNjMyNjhfQkFT RU1PREVfVkRTTF9QSFlfMAlCSVQoNikgLyogR1BJT3MgMTAvMTEgKi8KKyNkZWZpbmUgIEJDTTYz MjY4X0JBU0VNT0RFX1ZEU0xfUEhZXzEJQklUKDcpIC8qIEdQSU9zIDEyLzEzICovCisjZGVmaW5l ICBCQ002MzI2OF9CQVNFTU9ERV9WRFNMX1BIWV8yCUJJVCg4KSAvKiBHUElPcyAyNC8yNSAqLwor I2RlZmluZSAgQkNNNjMyNjhfQkFTRU1PREVfVkRTTF9QSFlfMwlCSVQoOSkgLyogR1BJT3MgMjYv MjcgKi8KKworZW51bSBiY202MzI2OF9waW5jdHJsX3JlZyB7CisJQkNNNjMyNjhfTEVEQ1RSTCwK KwlCQ002MzI2OF9NT0RFLAorCUJDTTYzMjY4X0NUUkwsCisJQkNNNjMyNjhfQkFTRU1PREUsCit9 OworCitzdHJ1Y3QgYmNtNjMyNjhfcGluZ3JvdXAgeworCWNvbnN0IGNoYXIgKm5hbWU7CisJY29u c3QgdW5zaWduZWQgKiBjb25zdCBwaW5zOworCWNvbnN0IHVuc2lnbmVkIG51bV9waW5zOworfTsK Kworc3RydWN0IGJjbTYzMjY4X2Z1bmN0aW9uIHsKKwljb25zdCBjaGFyICpuYW1lOworCWNvbnN0 IGNoYXIgKiBjb25zdCAqZ3JvdXBzOworCWNvbnN0IHVuc2lnbmVkIG51bV9ncm91cHM7CisKKwll bnVtIGJjbTYzMjY4X3BpbmN0cmxfcmVnIHJlZzsKKwl1aW50MzJfdCBtYXNrOworfTsKKworI2Rl ZmluZSBCQ002MzI2OF9QSU4oYSwgYiwgYmFzZW1vZGUpCQkJXAorCXsJCQkJCQlcCisJCS5udW1i ZXIgPSBhLAkJCQlcCisJCS5uYW1lID0gYiwJCQkJXAorCQkuZHJ2X2RhdGEgPSAodm9pZCAqKShi YXNlbW9kZSkJCVwKKwl9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgcGluY3RybF9waW5fZGVzYyBi Y202MzI2OF9waW5zW10gPSB7CisJUElOQ1RSTF9QSU4oMCwgImdwaW8wIiksCisJUElOQ1RSTF9Q SU4oMSwgImdwaW8xIiksCisJQkNNNjMyNjhfUElOKDIsICJncGlvMiIsIEJDTTYzMjY4X0JBU0VN T0RFX05BTkQpLAorCUJDTTYzMjY4X1BJTigzLCAiZ3BpbzMiLCBCQ002MzI2OF9CQVNFTU9ERV9O QU5EKSwKKwlCQ002MzI2OF9QSU4oNCwgImdwaW80IiwgQkNNNjMyNjhfQkFTRU1PREVfTkFORCks CisJQkNNNjMyNjhfUElOKDUsICJncGlvNSIsIEJDTTYzMjY4X0JBU0VNT0RFX05BTkQpLAorCUJD TTYzMjY4X1BJTig2LCAiZ3BpbzYiLCBCQ002MzI2OF9CQVNFTU9ERV9OQU5EKSwKKwlCQ002MzI2 OF9QSU4oNywgImdwaW83IiwgQkNNNjMyNjhfQkFTRU1PREVfTkFORCksCisJQkNNNjMyNjhfUElO KDgsICJncGlvOCIsIEJDTTYzMjY4X0JBU0VNT0RFX0RFQ1RQRCksCisJQkNNNjMyNjhfUElOKDks ICJncGlvOSIsIEJDTTYzMjY4X0JBU0VNT0RFX0RFQ1RQRCksCisJQkNNNjMyNjhfUElOKDEwLCAi Z3BpbzEwIiwgQkNNNjMyNjhfQkFTRU1PREVfVkRTTF9QSFlfMCksCisJQkNNNjMyNjhfUElOKDEx LCAiZ3BpbzExIiwgQkNNNjMyNjhfQkFTRU1PREVfVkRTTF9QSFlfMCksCisJQkNNNjMyNjhfUElO KDEyLCAiZ3BpbzEyIiwgQkNNNjMyNjhfQkFTRU1PREVfVkRTTF9QSFlfMSksCisJQkNNNjMyNjhf UElOKDEzLCAiZ3BpbzEzIiwgQkNNNjMyNjhfQkFTRU1PREVfVkRTTF9QSFlfMSksCisJUElOQ1RS TF9QSU4oMTQsICJncGlvMTQiKSwKKwlQSU5DVFJMX1BJTigxNSwgImdwaW8xNSIpLAorCVBJTkNU UkxfUElOKDE2LCAiZ3BpbzE2IiksCisJUElOQ1RSTF9QSU4oMTcsICJncGlvMTciKSwKKwlQSU5D VFJMX1BJTigxOCwgImdwaW8xOCIpLAorCVBJTkNUUkxfUElOKDE5LCAiZ3BpbzE5IiksCisJUElO Q1RSTF9QSU4oMjAsICJncGlvMjAiKSwKKwlQSU5DVFJMX1BJTigyMSwgImdwaW8yMSIpLAorCVBJ TkNUUkxfUElOKDIyLCAiZ3BpbzIyIiksCisJUElOQ1RSTF9QSU4oMjMsICJncGlvMjMiKSwKKwlC Q002MzI2OF9QSU4oMjQsICJncGlvMjQiLAorCQkgICAgIEJDTTYzMjY4X0JBU0VNT0RFX05BTkQg fCBCQ002MzI2OF9CQVNFTU9ERV9WRFNMX1BIWV8yKSwKKwlCQ002MzI2OF9QSU4oMjUsICJncGlv MjUiLAorCQkgICAgIEJDTTYzMjY4X0JBU0VNT0RFX05BTkQgfCBCQ002MzI2OF9CQVNFTU9ERV9W RFNMX1BIWV8yKSwKKwlCQ002MzI2OF9QSU4oMjYsICJncGlvMjYiLAorCQkgICAgIEJDTTYzMjY4 X0JBU0VNT0RFX05BTkQgfCBCQ002MzI2OF9CQVNFTU9ERV9WRFNMX1BIWV8zKSwKKwlCQ002MzI2 OF9QSU4oMjcsICJncGlvMjciLAorCQkgICAgIEJDTTYzMjY4X0JBU0VNT0RFX05BTkQgfCBCQ002 MzI2OF9CQVNFTU9ERV9WRFNMX1BIWV8zKSwKKwlCQ002MzI2OF9QSU4oMjgsICJncGlvMjgiLCBC Q002MzI2OF9CQVNFTU9ERV9OQU5EKSwKKwlCQ002MzI2OF9QSU4oMjksICJncGlvMjkiLCBCQ002 MzI2OF9CQVNFTU9ERV9OQU5EKSwKKwlCQ002MzI2OF9QSU4oMzAsICJncGlvMzAiLCBCQ002MzI2 OF9CQVNFTU9ERV9OQU5EKSwKKwlCQ002MzI2OF9QSU4oMzEsICJncGlvMzEiLCBCQ002MzI2OF9C QVNFTU9ERV9OQU5EKSwKKwlQSU5DVFJMX1BJTigzMiwgImdwaW8zMiIpLAorCVBJTkNUUkxfUElO KDMzLCAiZ3BpbzMzIiksCisJUElOQ1RSTF9QSU4oMzQsICJncGlvMzQiKSwKKwlQSU5DVFJMX1BJ TigzNSwgImdwaW8zNSIpLAorCVBJTkNUUkxfUElOKDM2LCAiZ3BpbzM2IiksCisJUElOQ1RSTF9Q SU4oMzcsICJncGlvMzciKSwKKwlQSU5DVFJMX1BJTigzOCwgImdwaW8zOCIpLAorCVBJTkNUUkxf UElOKDM5LCAiZ3BpbzM5IiksCisJUElOQ1RSTF9QSU4oNDAsICJncGlvNDAiKSwKKwlQSU5DVFJM X1BJTig0MSwgImdwaW80MSIpLAorCVBJTkNUUkxfUElOKDQyLCAiZ3BpbzQyIiksCisJUElOQ1RS TF9QSU4oNDMsICJncGlvNDMiKSwKKwlQSU5DVFJMX1BJTig0NCwgImdwaW80NCIpLAorCVBJTkNU UkxfUElOKDQ1LCAiZ3BpbzQ1IiksCisJUElOQ1RSTF9QSU4oNDYsICJncGlvNDYiKSwKKwlQSU5D VFJMX1BJTig0NywgImdwaW80NyIpLAorCVBJTkNUUkxfUElOKDQ4LCAiZ3BpbzQ4IiksCisJUElO Q1RSTF9QSU4oNDksICJncGlvNDkiKSwKKwlQSU5DVFJMX1BJTig1MCwgImdwaW81MCIpLAorCVBJ TkNUUkxfUElOKDUxLCAiZ3BpbzUxIiksCit9OworCitzdGF0aWMgdW5zaWduZWQgZ3BpbzBfcGlu c1tdID0geyAwIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzFfcGluc1tdID0geyAxIH07CitzdGF0 aWMgdW5zaWduZWQgZ3BpbzJfcGluc1tdID0geyAyIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzNf cGluc1tdID0geyAzIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzRfcGluc1tdID0geyA0IH07Citz dGF0aWMgdW5zaWduZWQgZ3BpbzVfcGluc1tdID0geyA1IH07CitzdGF0aWMgdW5zaWduZWQgZ3Bp bzZfcGluc1tdID0geyA2IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzdfcGluc1tdID0geyA3IH07 CitzdGF0aWMgdW5zaWduZWQgZ3BpbzhfcGluc1tdID0geyA4IH07CitzdGF0aWMgdW5zaWduZWQg Z3BpbzlfcGluc1tdID0geyA5IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzEwX3BpbnNbXSA9IHsg MTAgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMTFfcGluc1tdID0geyAxMSB9Oworc3RhdGljIHVu c2lnbmVkIGdwaW8xMl9waW5zW10gPSB7IDEyIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzEzX3Bp bnNbXSA9IHsgMTMgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMTRfcGluc1tdID0geyAxNCB9Owor c3RhdGljIHVuc2lnbmVkIGdwaW8xNV9waW5zW10gPSB7IDE1IH07CitzdGF0aWMgdW5zaWduZWQg Z3BpbzE2X3BpbnNbXSA9IHsgMTYgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMTdfcGluc1tdID0g eyAxNyB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8xOF9waW5zW10gPSB7IDE4IH07CitzdGF0aWMg dW5zaWduZWQgZ3BpbzE5X3BpbnNbXSA9IHsgMTkgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMjBf cGluc1tdID0geyAyMCB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8yMV9waW5zW10gPSB7IDIxIH07 CitzdGF0aWMgdW5zaWduZWQgZ3BpbzIyX3BpbnNbXSA9IHsgMjIgfTsKK3N0YXRpYyB1bnNpZ25l ZCBncGlvMjNfcGluc1tdID0geyAyMyB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8yNF9waW5zW10g PSB7IDI0IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzI1X3BpbnNbXSA9IHsgMjUgfTsKK3N0YXRp YyB1bnNpZ25lZCBncGlvMjZfcGluc1tdID0geyAyNiB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8y N19waW5zW10gPSB7IDI3IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzI4X3BpbnNbXSA9IHsgMjgg fTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMjlfcGluc1tdID0geyAyOSB9Oworc3RhdGljIHVuc2ln bmVkIGdwaW8zMF9waW5zW10gPSB7IDMwIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzMxX3BpbnNb XSA9IHsgMzEgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMzJfcGluc1tdID0geyAzMiB9Oworc3Rh dGljIHVuc2lnbmVkIGdwaW8zM19waW5zW10gPSB7IDMzIH07CitzdGF0aWMgdW5zaWduZWQgZ3Bp bzM0X3BpbnNbXSA9IHsgMzQgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMzVfcGluc1tdID0geyAz NSB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8zNl9waW5zW10gPSB7IDM2IH07CitzdGF0aWMgdW5z aWduZWQgZ3BpbzM3X3BpbnNbXSA9IHsgMzcgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMzhfcGlu c1tdID0geyAzOCB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8zOV9waW5zW10gPSB7IDM5IH07Citz dGF0aWMgdW5zaWduZWQgZ3BpbzQwX3BpbnNbXSA9IHsgNDAgfTsKK3N0YXRpYyB1bnNpZ25lZCBn cGlvNDFfcGluc1tdID0geyA0MSB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW80Ml9waW5zW10gPSB7 IDQyIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzQzX3BpbnNbXSA9IHsgNDMgfTsKK3N0YXRpYyB1 bnNpZ25lZCBncGlvNDRfcGluc1tdID0geyA0NCB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW80NV9w aW5zW10gPSB7IDQ1IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzQ2X3BpbnNbXSA9IHsgNDYgfTsK K3N0YXRpYyB1bnNpZ25lZCBncGlvNDdfcGluc1tdID0geyA0NyB9Oworc3RhdGljIHVuc2lnbmVk IGdwaW80OF9waW5zW10gPSB7IDQ4IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzQ5X3BpbnNbXSA9 IHsgNDkgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvNTBfcGluc1tdID0geyA1MCB9Oworc3RhdGlj IHVuc2lnbmVkIGdwaW81MV9waW5zW10gPSB7IDUxIH07CisKK3N0YXRpYyB1bnNpZ25lZCBuYW5k X2dycF9waW5zW10gPSB7CisJMiwgMywgNCwgNSwgNiwgNywgMjQsCisJMjUsIDI2LCAyNywgMjgs IDI5LCAzMCwgMzEsCit9OworCitzdGF0aWMgdW5zaWduZWQgZGVjdHBkX2dycF9waW5zW10gPSB7 IDgsIDkgfTsKK3N0YXRpYyB1bnNpZ25lZCB2ZHNsX3BoeTBfZ3JwX3BpbnNbXSA9IHsgMTAsIDEx IH07CitzdGF0aWMgdW5zaWduZWQgdmRzbF9waHkxX2dycF9waW5zW10gPSB7IDEyLCAxMyB9Owor c3RhdGljIHVuc2lnbmVkIHZkc2xfcGh5Ml9ncnBfcGluc1tdID0geyAyNCwgMjUgfTsKK3N0YXRp YyB1bnNpZ25lZCB2ZHNsX3BoeTNfZ3JwX3BpbnNbXSA9IHsgMjYsIDI3IH07CisKKyNkZWZpbmUg QkNNNjMyNjhfR1JPVVAobikJCQkJCVwKKwl7CQkJCQkJCVwKKwkJLm5hbWUgPSAjbiwJCQkJCVwK KwkJLnBpbnMgPSBuIyNfcGlucywJCQkJXAorCQkubnVtX3BpbnMgPSBBUlJBWV9TSVpFKG4jI19w aW5zKSwJCVwKKwl9CisKK3N0YXRpYyBzdHJ1Y3QgYmNtNjMyNjhfcGluZ3JvdXAgYmNtNjMyNjhf Z3JvdXBzW10gPSB7CisJQkNNNjMyNjhfR1JPVVAoZ3BpbzApLAorCUJDTTYzMjY4X0dST1VQKGdw aW8xKSwKKwlCQ002MzI2OF9HUk9VUChncGlvMiksCisJQkNNNjMyNjhfR1JPVVAoZ3BpbzMpLAor CUJDTTYzMjY4X0dST1VQKGdwaW80KSwKKwlCQ002MzI2OF9HUk9VUChncGlvNSksCisJQkNNNjMy NjhfR1JPVVAoZ3BpbzYpLAorCUJDTTYzMjY4X0dST1VQKGdwaW83KSwKKwlCQ002MzI2OF9HUk9V UChncGlvOCksCisJQkNNNjMyNjhfR1JPVVAoZ3BpbzkpLAorCUJDTTYzMjY4X0dST1VQKGdwaW8x MCksCisJQkNNNjMyNjhfR1JPVVAoZ3BpbzExKSwKKwlCQ002MzI2OF9HUk9VUChncGlvMTIpLAor CUJDTTYzMjY4X0dST1VQKGdwaW8xMyksCisJQkNNNjMyNjhfR1JPVVAoZ3BpbzE0KSwKKwlCQ002 MzI2OF9HUk9VUChncGlvMTUpLAorCUJDTTYzMjY4X0dST1VQKGdwaW8xNiksCisJQkNNNjMyNjhf R1JPVVAoZ3BpbzE3KSwKKwlCQ002MzI2OF9HUk9VUChncGlvMTgpLAorCUJDTTYzMjY4X0dST1VQ KGdwaW8xOSksCisJQkNNNjMyNjhfR1JPVVAoZ3BpbzIwKSwKKwlCQ002MzI2OF9HUk9VUChncGlv MjEpLAorCUJDTTYzMjY4X0dST1VQKGdwaW8yMiksCisJQkNNNjMyNjhfR1JPVVAoZ3BpbzIzKSwK KwlCQ002MzI2OF9HUk9VUChncGlvMjQpLAorCUJDTTYzMjY4X0dST1VQKGdwaW8yNSksCisJQkNN NjMyNjhfR1JPVVAoZ3BpbzI2KSwKKwlCQ002MzI2OF9HUk9VUChncGlvMjcpLAorCUJDTTYzMjY4 X0dST1VQKGdwaW8yOCksCisJQkNNNjMyNjhfR1JPVVAoZ3BpbzI5KSwKKwlCQ002MzI2OF9HUk9V UChncGlvMzApLAorCUJDTTYzMjY4X0dST1VQKGdwaW8zMSksCisJQkNNNjMyNjhfR1JPVVAoZ3Bp bzMyKSwKKwlCQ002MzI2OF9HUk9VUChncGlvMzMpLAorCUJDTTYzMjY4X0dST1VQKGdwaW8zNCks CisJQkNNNjMyNjhfR1JPVVAoZ3BpbzM1KSwKKwlCQ002MzI2OF9HUk9VUChncGlvMzYpLAorCUJD TTYzMjY4X0dST1VQKGdwaW8zNyksCisJQkNNNjMyNjhfR1JPVVAoZ3BpbzM4KSwKKwlCQ002MzI2 OF9HUk9VUChncGlvMzkpLAorCUJDTTYzMjY4X0dST1VQKGdwaW80MCksCisJQkNNNjMyNjhfR1JP VVAoZ3BpbzQxKSwKKwlCQ002MzI2OF9HUk9VUChncGlvNDIpLAorCUJDTTYzMjY4X0dST1VQKGdw aW80MyksCisJQkNNNjMyNjhfR1JPVVAoZ3BpbzQ0KSwKKwlCQ002MzI2OF9HUk9VUChncGlvNDUp LAorCUJDTTYzMjY4X0dST1VQKGdwaW80NiksCisJQkNNNjMyNjhfR1JPVVAoZ3BpbzQ3KSwKKwlC Q002MzI2OF9HUk9VUChncGlvNDgpLAorCUJDTTYzMjY4X0dST1VQKGdwaW80OSksCisJQkNNNjMy NjhfR1JPVVAoZ3BpbzUwKSwKKwlCQ002MzI2OF9HUk9VUChncGlvNTEpLAorCisJLyogbXVsdGkg cGluIGdyb3VwcyAqLworCUJDTTYzMjY4X0dST1VQKG5hbmRfZ3JwKSwKKwlCQ002MzI2OF9HUk9V UChkZWN0cGRfZ3JwKSwKKwlCQ002MzI2OF9HUk9VUCh2ZHNsX3BoeTBfZ3JwKSwKKwlCQ002MzI2 OF9HUk9VUCh2ZHNsX3BoeTFfZ3JwKSwKKwlCQ002MzI2OF9HUk9VUCh2ZHNsX3BoeTJfZ3JwKSwK KwlCQ002MzI2OF9HUk9VUCh2ZHNsX3BoeTNfZ3JwKSwKK307CisKK3N0YXRpYyBjb25zdCBjaGFy ICogY29uc3QgbGVkX2dyb3Vwc1tdID0geworCSJncGlvMCIsCisJImdwaW8xIiwKKwkiZ3BpbzIi LAorCSJncGlvMyIsCisJImdwaW80IiwKKwkiZ3BpbzUiLAorCSJncGlvNiIsCisJImdwaW83IiwK KwkiZ3BpbzgiLAorCSJncGlvOSIsCisJImdwaW8xMCIsCisJImdwaW8xMSIsCisJImdwaW8xMiIs CisJImdwaW8xMyIsCisJImdwaW8xNCIsCisJImdwaW8xNSIsCisJImdwaW8xNiIsCisJImdwaW8x NyIsCisJImdwaW8xOCIsCisJImdwaW8xOSIsCisJImdwaW8yMCIsCisJImdwaW8yMSIsCisJImdw aW8yMiIsCisJImdwaW8yMyIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHNlcmlh bF9sZWRfY2xrX2dyb3Vwc1tdID0geworCSJncGlvMCIsCit9OworCitzdGF0aWMgY29uc3QgY2hh ciAqIGNvbnN0IHNlcmlhbF9sZWRfZGF0YV9ncm91cHNbXSA9IHsKKwkiZ3BpbzEiLAorfTsKKwor c3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBoc3NwaV9jczRfZ3JvdXBzW10gPSB7CisJImdwaW8x NiIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGhzc3BpX2NzNV9ncm91cHNbXSA9 IHsKKwkiZ3BpbzE3IiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgaHNzcGlfY3M2 X2dyb3Vwc1tdID0geworCSJncGlvOCIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0 IGhzc3BpX2NzN19ncm91cHNbXSA9IHsKKwkiZ3BpbzkiLAorfTsKKworc3RhdGljIGNvbnN0IGNo YXIgKiBjb25zdCB1YXJ0MV9zY3RzX2dyb3Vwc1tdID0geworCSJncGlvMTAiLAorCSJncGlvMjQi LAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCB1YXJ0MV9zcnRzX2dyb3Vwc1tdID0g eworCSJncGlvMTEiLAorCSJncGlvMjUiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25z dCB1YXJ0MV9zZGluX2dyb3Vwc1tdID0geworCSJncGlvMTIiLAorCSJncGlvMjYiLAorfTsKKwor c3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCB1YXJ0MV9zZG91dF9ncm91cHNbXSA9IHsKKwkiZ3Bp bzEzIiwKKwkiZ3BpbzI3IiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgbnRyX3B1 bHNlX2luX2dyb3Vwc1tdID0geworCSJncGlvMTQiLAorCSJncGlvMjgiLAorfTsKKworc3RhdGlj IGNvbnN0IGNoYXIgKiBjb25zdCBkc2xfbnRyX3B1bHNlX291dF9ncm91cHNbXSA9IHsKKwkiZ3Bp bzE1IiwKKwkiZ3BpbzI5IiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgYWRzbF9z cGlfbWlzb19ncm91cHNbXSA9IHsKKwkiZ3BpbzE4IiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFy ICogY29uc3QgYWRzbF9zcGlfbW9zaV9ncm91cHNbXSA9IHsKKwkiZ3BpbzE5IiwKK307CisKK3N0 YXRpYyBjb25zdCBjaGFyICogY29uc3QgdnJlZ19jbGtfZ3JvdXBzW10gPSB7CisJImdwaW8yMiIs Cit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHBjaWVfY2xrcmVxX2JfZ3JvdXBzW10g PSB7CisJImdwaW8yMyIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHN3aXRjaF9s ZWRfY2xrX2dyb3Vwc1tdID0geworCSJncGlvMzAiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIg KiBjb25zdCBzd2l0Y2hfbGVkX2RhdGFfZ3JvdXBzW10gPSB7CisJImdwaW8zMSIsCit9OworCitz dGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHdpZmlfZ3JvdXBzW10gPSB7CisJImdwaW8zMiIsCisJ ImdwaW8zMyIsCisJImdwaW8zNCIsCisJImdwaW8zNSIsCisJImdwaW8zNiIsCisJImdwaW8zNyIs CisJImdwaW8zOCIsCisJImdwaW8zOSIsCisJImdwaW80MCIsCisJImdwaW80MSIsCisJImdwaW80 MiIsCisJImdwaW80MyIsCisJImdwaW80NCIsCisJImdwaW80NSIsCisJImdwaW80NiIsCisJImdw aW80NyIsCisJImdwaW80OCIsCisJImdwaW80OSIsCisJImdwaW81MCIsCisJImdwaW81MSIsCit9 OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IG5hbmRfZ3JvdXBzW10gPSB7CisJIm5hbmRf Z3JwIiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgZGVjdHBkX2dyb3Vwc1tdID0g eworCSJkZWN0cGRfZ3JwIiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgdmRzbF9w aHlfb3ZlcnJpZGVfMF9ncm91cHNbXSA9IHsKKwkidmRzbF9waHlfb3ZlcnJpZGVfMF9ncnAiLAor fTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCB2ZHNsX3BoeV9vdmVycmlkZV8xX2dyb3Vw c1tdID0geworCSJ2ZHNsX3BoeV9vdmVycmlkZV8xX2dycCIsCit9OworCitzdGF0aWMgY29uc3Qg Y2hhciAqIGNvbnN0IHZkc2xfcGh5X292ZXJyaWRlXzJfZ3JvdXBzW10gPSB7CisJInZkc2xfcGh5 X292ZXJyaWRlXzJfZ3JwIiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgdmRzbF9w aHlfb3ZlcnJpZGVfM19ncm91cHNbXSA9IHsKKwkidmRzbF9waHlfb3ZlcnJpZGVfM19ncnAiLAor fTsKKworI2RlZmluZSBCQ002MzI2OF9MRURfRlVOKG4pCQkJCVwKKwl7CQkJCQkJXAorCQkubmFt ZSA9ICNuLAkJCQlcCisJCS5ncm91cHMgPSBuIyNfZ3JvdXBzLAkJCVwKKwkJLm51bV9ncm91cHMg PSBBUlJBWV9TSVpFKG4jI19ncm91cHMpLAlcCisJCS5yZWcgPSBCQ002MzI2OF9MRURDVFJMLAkJ XAorCX0KKworI2RlZmluZSBCQ002MzI2OF9NT0RFX0ZVTihuKQkJCQlcCisJewkJCQkJCVwKKwkJ Lm5hbWUgPSAjbiwJCQkJXAorCQkuZ3JvdXBzID0gbiMjX2dyb3VwcywJCQlcCisJCS5udW1fZ3Jv dXBzID0gQVJSQVlfU0laRShuIyNfZ3JvdXBzKSwJXAorCQkucmVnID0gQkNNNjMyNjhfTU9ERSwJ CQlcCisJfQorCisjZGVmaW5lIEJDTTYzMjY4X0NUUkxfRlVOKG4pCQkJCVwKKwl7CQkJCQkJXAor CQkubmFtZSA9ICNuLAkJCQlcCisJCS5ncm91cHMgPSBuIyNfZ3JvdXBzLAkJCVwKKwkJLm51bV9n cm91cHMgPSBBUlJBWV9TSVpFKG4jI19ncm91cHMpLAlcCisJCS5yZWcgPSBCQ002MzI2OF9DVFJM LAkJCVwKKwl9CisKKyNkZWZpbmUgQkNNNjMyNjhfQkFTRU1PREVfRlVOKG4sIHZhbCkJCQlcCisJ ewkJCQkJCVwKKwkJLm5hbWUgPSAjbiwJCQkJXAorCQkuZ3JvdXBzID0gbiMjX2dyb3VwcywJCQlc CisJCS5udW1fZ3JvdXBzID0gQVJSQVlfU0laRShuIyNfZ3JvdXBzKSwJXAorCQkucmVnID0gQkNN NjMyNjhfQkFTRU1PREUsCQlcCisJCS5tYXNrID0gdmFsLAkJCQlcCisJfQorCitzdGF0aWMgY29u c3Qgc3RydWN0IGJjbTYzMjY4X2Z1bmN0aW9uIGJjbTYzMjY4X2Z1bmNzW10gPSB7CisJQkNNNjMy NjhfTEVEX0ZVTihsZWQpLAorCUJDTTYzMjY4X01PREVfRlVOKHNlcmlhbF9sZWRfY2xrKSwKKwlC Q002MzI2OF9NT0RFX0ZVTihzZXJpYWxfbGVkX2RhdGEpLAorCUJDTTYzMjY4X01PREVfRlVOKGhz c3BpX2NzNiksCisJQkNNNjMyNjhfTU9ERV9GVU4oaHNzcGlfY3M3KSwKKwlCQ002MzI2OF9NT0RF X0ZVTih1YXJ0MV9zY3RzKSwKKwlCQ002MzI2OF9NT0RFX0ZVTih1YXJ0MV9zcnRzKSwKKwlCQ002 MzI2OF9NT0RFX0ZVTih1YXJ0MV9zZGluKSwKKwlCQ002MzI2OF9NT0RFX0ZVTih1YXJ0MV9zZG91 dCksCisJQkNNNjMyNjhfTU9ERV9GVU4obnRyX3B1bHNlX2luKSwKKwlCQ002MzI2OF9NT0RFX0ZV Tihkc2xfbnRyX3B1bHNlX291dCksCisJQkNNNjMyNjhfTU9ERV9GVU4oaHNzcGlfY3M0KSwKKwlC Q002MzI2OF9NT0RFX0ZVTihoc3NwaV9jczUpLAorCUJDTTYzMjY4X01PREVfRlVOKGFkc2xfc3Bp X21pc28pLAorCUJDTTYzMjY4X01PREVfRlVOKGFkc2xfc3BpX21vc2kpLAorCUJDTTYzMjY4X01P REVfRlVOKHZyZWdfY2xrKSwKKwlCQ002MzI2OF9NT0RFX0ZVTihwY2llX2Nsa3JlcV9iKSwKKwlC Q002MzI2OF9NT0RFX0ZVTihzd2l0Y2hfbGVkX2NsayksCisJQkNNNjMyNjhfTU9ERV9GVU4oc3dp dGNoX2xlZF9kYXRhKSwKKwlCQ002MzI2OF9DVFJMX0ZVTih3aWZpKSwKKwlCQ002MzI2OF9CQVNF TU9ERV9GVU4obmFuZCwgQkNNNjMyNjhfQkFTRU1PREVfTkFORCksCisJQkNNNjMyNjhfQkFTRU1P REVfRlVOKGRlY3RwZCwgQkNNNjMyNjhfQkFTRU1PREVfREVDVFBEKSwKKwlCQ002MzI2OF9CQVNF TU9ERV9GVU4odmRzbF9waHlfb3ZlcnJpZGVfMCwKKwkJCSAgICAgIEJDTTYzMjY4X0JBU0VNT0RF X1ZEU0xfUEhZXzApLAorCUJDTTYzMjY4X0JBU0VNT0RFX0ZVTih2ZHNsX3BoeV9vdmVycmlkZV8x LAorCQkJICAgICAgQkNNNjMyNjhfQkFTRU1PREVfVkRTTF9QSFlfMSksCisJQkNNNjMyNjhfQkFT RU1PREVfRlVOKHZkc2xfcGh5X292ZXJyaWRlXzIsCisJCQkgICAgICBCQ002MzI2OF9CQVNFTU9E RV9WRFNMX1BIWV8yKSwKKwlCQ002MzI2OF9CQVNFTU9ERV9GVU4odmRzbF9waHlfb3ZlcnJpZGVf MywKKwkJCSAgICAgIEJDTTYzMjY4X0JBU0VNT0RFX1ZEU0xfUEhZXzMpLAorfTsKKworc3RhdGlj IGludCBiY202MzI2OF9waW5jdHJsX2dldF9ncm91cF9jb3VudChzdHJ1Y3QgcGluY3RybF9kZXYg KnBjdGxkZXYpCit7CisJcmV0dXJuIEFSUkFZX1NJWkUoYmNtNjMyNjhfZ3JvdXBzKTsKK30KKwor c3RhdGljIGNvbnN0IGNoYXIgKmJjbTYzMjY4X3BpbmN0cmxfZ2V0X2dyb3VwX25hbWUoc3RydWN0 IHBpbmN0cmxfZGV2ICpwY3RsZGV2LAorCQkJCQkJICAgdW5zaWduZWQgZ3JvdXApCit7CisJcmV0 dXJuIGJjbTYzMjY4X2dyb3Vwc1tncm91cF0ubmFtZTsKK30KKworc3RhdGljIGludCBiY202MzI2 OF9waW5jdHJsX2dldF9ncm91cF9waW5zKHN0cnVjdCBwaW5jdHJsX2RldiAqcGN0bGRldiwKKwkJ CQkJICAgdW5zaWduZWQgZ3JvdXAsCisJCQkJCSAgIGNvbnN0IHVuc2lnbmVkICoqcGlucywKKwkJ CQkJICAgdW5zaWduZWQgKm51bV9waW5zKQoreworCSpwaW5zID0gYmNtNjMyNjhfZ3JvdXBzW2dy b3VwXS5waW5zOworCSpudW1fcGlucyA9IGJjbTYzMjY4X2dyb3Vwc1tncm91cF0ubnVtX3BpbnM7 CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBiY202MzI2OF9waW5jdHJsX2dldF9mdW5j X2NvdW50KHN0cnVjdCBwaW5jdHJsX2RldiAqcGN0bGRldikKK3sKKwlyZXR1cm4gQVJSQVlfU0la RShiY202MzI2OF9mdW5jcyk7Cit9CisKK3N0YXRpYyBjb25zdCBjaGFyICpiY202MzI2OF9waW5j dHJsX2dldF9mdW5jX25hbWUoc3RydWN0IHBpbmN0cmxfZGV2ICpwY3RsZGV2LAorCQkJCQkJICB1 bnNpZ25lZCBzZWxlY3RvcikKK3sKKwlyZXR1cm4gYmNtNjMyNjhfZnVuY3Nbc2VsZWN0b3JdLm5h bWU7Cit9CisKK3N0YXRpYyBpbnQgYmNtNjMyNjhfcGluY3RybF9nZXRfZ3JvdXBzKHN0cnVjdCBw aW5jdHJsX2RldiAqcGN0bGRldiwKKwkJCQkgICAgICAgdW5zaWduZWQgc2VsZWN0b3IsCisJCQkJ ICAgICAgIGNvbnN0IGNoYXIgKiBjb25zdCAqKmdyb3VwcywKKwkJCQkgICAgICAgdW5zaWduZWQg KiBjb25zdCBudW1fZ3JvdXBzKQoreworCSpncm91cHMgPSBiY202MzI2OF9mdW5jc1tzZWxlY3Rv cl0uZ3JvdXBzOworCSpudW1fZ3JvdXBzID0gYmNtNjMyNjhfZnVuY3Nbc2VsZWN0b3JdLm51bV9n cm91cHM7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHZvaWQgYmNtNjMyNjhfc2V0X2dwaW8o c3RydWN0IGJjbTYzeHhfcGluY3RybCAqcGMsIHVuc2lnbmVkIHBpbikKK3sKKwljb25zdCBzdHJ1 Y3QgcGluY3RybF9waW5fZGVzYyAqZGVzYyA9ICZiY202MzI2OF9waW5zW3Bpbl07CisJdW5zaWdu ZWQgaW50IGJhc2Vtb2RlID0gKHVuc2lnbmVkIGxvbmcpIGRlc2MtPmRydl9kYXRhOworCXVuc2ln bmVkIGludCBtYXNrID0gQklUKGJjbTYzeHhfYmFua19waW4ocGluKSk7CisKKwlpZiAoYmFzZW1v ZGUpCisJCXJlZ21hcF91cGRhdGVfYml0cyhwYy0+cmVncywgQkNNNjMyNjhfQkFTRU1PREVfUkVH LCBiYXNlbW9kZSwKKwkJCQkgICAwKTsKKworCWlmIChwaW4gPCBCQ002M1hYX0JBTktfR1BJT1Mp IHsKKwkJLyogYmFzZSBtb2RlOiAwID0+IGdwaW8sIDEgPT4gbXV4IGZ1bmN0aW9uICovCisJCXJl Z21hcF91cGRhdGVfYml0cyhwYy0+cmVncywgQkNNNjMyNjhfTU9ERV9SRUcsIG1hc2ssIDApOwor CisJCS8qIHBpbnMgMC0yMyBtaWdodCBiZSBtdXhlZCB0byBsZWQgKi8KKwkJaWYgKHBpbiA8IEJD TTYzMjY4X05VTV9MRURTKQorCQkJcmVnbWFwX3VwZGF0ZV9iaXRzKHBjLT5yZWdzLCBCQ002MzI2 OF9MRURfUkVHLCBtYXNrLAorCQkJCQkgICAwKTsKKwl9IGVsc2UgaWYgKHBpbiA8IEJDTTYzMjY4 X05VTV9HUElPUykgeworCQkvKiBjdHJsIHJlZzogMCA9PiB3aWZpIGZ1bmN0aW9uLCAxID0+IGdw aW8gKi8KKwkJcmVnbWFwX3VwZGF0ZV9iaXRzKHBjLT5yZWdzLCBCQ002MzI2OF9DVFJMX1JFRywg bWFzaywgbWFzayk7CisJfQorfQorCitzdGF0aWMgaW50IGJjbTYzMjY4X3BpbmN0cmxfc2V0X211 eChzdHJ1Y3QgcGluY3RybF9kZXYgKnBjdGxkZXYsCisJCQkJICAgIHVuc2lnbmVkIHNlbGVjdG9y LCB1bnNpZ25lZCBncm91cCkKK3sKKwlzdHJ1Y3QgYmNtNjN4eF9waW5jdHJsICpwYyA9IHBpbmN0 cmxfZGV2X2dldF9kcnZkYXRhKHBjdGxkZXYpOworCWNvbnN0IHN0cnVjdCBiY202MzI2OF9waW5n cm91cCAqcGcgPSAmYmNtNjMyNjhfZ3JvdXBzW2dyb3VwXTsKKwljb25zdCBzdHJ1Y3QgYmNtNjMy NjhfZnVuY3Rpb24gKmYgPSAmYmNtNjMyNjhfZnVuY3Nbc2VsZWN0b3JdOworCXVuc2lnbmVkIGk7 CisJdW5zaWduZWQgaW50IHJlZzsKKwl1bnNpZ25lZCBpbnQgdmFsLCBtYXNrOworCisJZm9yIChp ID0gMDsgaSA8IHBnLT5udW1fcGluczsgaSsrKQorCQliY202MzI2OF9zZXRfZ3BpbyhwYywgcGct PnBpbnNbaV0pOworCisJc3dpdGNoIChmLT5yZWcpIHsKKwljYXNlIEJDTTYzMjY4X0xFRENUUkw6 CisJCXJlZyA9IEJDTTYzMjY4X0xFRF9SRUc7CisJCW1hc2sgPSBCSVQocGctPnBpbnNbMF0pOwor CQl2YWwgPSBCSVQocGctPnBpbnNbMF0pOworCQlicmVhazsKKwljYXNlIEJDTTYzMjY4X01PREU6 CisJCXJlZyA9IEJDTTYzMjY4X01PREVfUkVHOworCQltYXNrID0gQklUKHBnLT5waW5zWzBdKTsK KwkJdmFsID0gQklUKHBnLT5waW5zWzBdKTsKKwkJYnJlYWs7CisJY2FzZSBCQ002MzI2OF9DVFJM OgorCQlyZWcgPSBCQ002MzI2OF9DVFJMX1JFRzsKKwkJbWFzayA9IEJJVChwZy0+cGluc1swXSk7 CisJCXZhbCA9IDA7CisJCWJyZWFrOworCWNhc2UgQkNNNjMyNjhfQkFTRU1PREU6CisJCXJlZyA9 IEJDTTYzMjY4X0JBU0VNT0RFX1JFRzsKKwkJbWFzayA9IGYtPm1hc2s7CisJCXZhbCA9IGYtPm1h c2s7CisJCWJyZWFrOworCWRlZmF1bHQ6CisJCVdBUk5fT04oMSk7CisJCXJldHVybiAtRUlOVkFM OworCX0KKworCXJlZ21hcF91cGRhdGVfYml0cyhwYy0+cmVncywgcmVnLCBtYXNrLCB2YWwpOwor CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgYmNtNjMyNjhfZ3Bpb19yZXF1ZXN0X2VuYWJs ZShzdHJ1Y3QgcGluY3RybF9kZXYgKnBjdGxkZXYsCisJCQkJCXN0cnVjdCBwaW5jdHJsX2dwaW9f cmFuZ2UgKnJhbmdlLAorCQkJCQl1bnNpZ25lZCBvZmZzZXQpCit7CisJc3RydWN0IGJjbTYzeHhf cGluY3RybCAqcGMgPSBwaW5jdHJsX2Rldl9nZXRfZHJ2ZGF0YShwY3RsZGV2KTsKKworCS8qIGRp c2FibGUgYWxsIGZ1bmN0aW9ucyB1c2luZyB0aGlzIHBpbiAqLworCWJjbTYzMjY4X3NldF9ncGlv KHBjLCBvZmZzZXQpOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBzdHJ1Y3QgcGluY3RybF9v cHMgYmNtNjMyNjhfcGN0bF9vcHMgPSB7CisJLmR0X2ZyZWVfbWFwID0gcGluY3RybF91dGlsc19m cmVlX21hcCwKKwkuZHRfbm9kZV90b19tYXAgPSBwaW5jb25mX2dlbmVyaWNfZHRfbm9kZV90b19t YXBfcGluLAorCS5nZXRfZ3JvdXBfbmFtZSA9IGJjbTYzMjY4X3BpbmN0cmxfZ2V0X2dyb3VwX25h bWUsCisJLmdldF9ncm91cF9waW5zID0gYmNtNjMyNjhfcGluY3RybF9nZXRfZ3JvdXBfcGlucywK KwkuZ2V0X2dyb3Vwc19jb3VudCA9IGJjbTYzMjY4X3BpbmN0cmxfZ2V0X2dyb3VwX2NvdW50LAor fTsKKworc3RhdGljIHN0cnVjdCBwaW5tdXhfb3BzIGJjbTYzMjY4X3BteF9vcHMgPSB7CisJLmdl dF9mdW5jdGlvbl9ncm91cHMgPSBiY202MzI2OF9waW5jdHJsX2dldF9ncm91cHMsCisJLmdldF9m dW5jdGlvbl9uYW1lID0gYmNtNjMyNjhfcGluY3RybF9nZXRfZnVuY19uYW1lLAorCS5nZXRfZnVu Y3Rpb25zX2NvdW50ID0gYmNtNjMyNjhfcGluY3RybF9nZXRfZnVuY19jb3VudCwKKwkuZ3Bpb19y ZXF1ZXN0X2VuYWJsZSA9IGJjbTYzMjY4X2dwaW9fcmVxdWVzdF9lbmFibGUsCisJLnNldF9tdXgg PSBiY202MzI2OF9waW5jdHJsX3NldF9tdXgsCisJLnN0cmljdCA9IHRydWUsCit9OworCitzdGF0 aWMgY29uc3Qgc3RydWN0IGJjbTYzeHhfcGluY3RybF9zb2MgYmNtNjMyNjhfc29jID0geworCS5u Z3Bpb3MgPSBCQ002MzI2OF9OVU1fR1BJT1MsCisJLm5waW5zID0gQVJSQVlfU0laRShiY202MzI2 OF9waW5zKSwKKwkucGN0bF9vcHMgPSAmYmNtNjMyNjhfcGN0bF9vcHMsCisJLnBpbnMgPSBiY202 MzI2OF9waW5zLAorCS5wbXhfb3BzID0gJmJjbTYzMjY4X3BteF9vcHMsCit9OworCitzdGF0aWMg aW50IGJjbTYzMjY4X3BpbmN0cmxfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikK K3sKKwlyZXR1cm4gYmNtNjN4eF9waW5jdHJsX3Byb2JlKHBkZXYsICZiY202MzI2OF9zb2MsIE5V TEwpOworfQorCitzdGF0aWMgY29uc3Qgc3RydWN0IG9mX2RldmljZV9pZCBiY202MzI2OF9waW5j dHJsX21hdGNoW10gPSB7CisJeyAuY29tcGF0aWJsZSA9ICJicmNtLGJjbTYzMjY4LXBpbmN0cmwi LCB9LAorCXsgLyogc2VudGluZWwgKi8gfQorfTsKKworc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9k cml2ZXIgYmNtNjMyNjhfcGluY3RybF9kcml2ZXIgPSB7CisJLnByb2JlID0gYmNtNjMyNjhfcGlu Y3RybF9wcm9iZSwKKwkuZHJpdmVyID0geworCQkubmFtZSA9ICJiY202MzI2OC1waW5jdHJsIiwK KwkJLm9mX21hdGNoX3RhYmxlID0gYmNtNjMyNjhfcGluY3RybF9tYXRjaCwKKwl9LAorfTsKKwor YnVpbHRpbl9wbGF0Zm9ybV9kcml2ZXIoYmNtNjMyNjhfcGluY3RybF9kcml2ZXIpOwotLSAKMi4y MC4xCgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KbGlu dXgtYXJtLWtlcm5lbCBtYWlsaW5nIGxpc3QKbGludXgtYXJtLWtlcm5lbEBsaXN0cy5pbmZyYWRl YWQub3JnCmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vbGludXgt YXJtLWtlcm5lbAo=