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=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id AC28CC433DB for ; Wed, 17 Mar 2021 14:39:24 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 61E6764F6E for ; Wed, 17 Mar 2021 14:39:24 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232122AbhCQOi6 (ORCPT ); Wed, 17 Mar 2021 10:38:58 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57094 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231992AbhCQOiZ (ORCPT ); Wed, 17 Mar 2021 10:38:25 -0400 Received: from mail-wm1-x332.google.com (mail-wm1-x332.google.com [IPv6:2a00:1450:4864:20::332]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id A532EC06174A; Wed, 17 Mar 2021 07:38:24 -0700 (PDT) Received: by mail-wm1-x332.google.com with SMTP id t5-20020a1c77050000b029010e62cea9deso1468494wmi.0; Wed, 17 Mar 2021 07:38:24 -0700 (PDT) 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=qn6o0e5vR723w+ne0etn5xqbJGUNdrckR7B/j1xzpt4=; b=grTbtpIa6l+/haNzY6qEnOgDmmsrKCML0QW7RIBB4isSkCpgvnzYffTdp3kyUeD6Yk WSzTDBcuJQx/9VSGnNkAqmy/cdjXsn3sJmt6GMJUkZGdHE+3dOj9dxyUAsjYMM2uz3gV TYjjMQwmK67FwxMs7oounM+/pBIdQ7055wFnUhu1vvWEc01g7nuQweSgsPayTgsO9P/T /klBauBrDuLqS69rTyAOU26frcB7gtJuZ1HG+u6UboOmHaJ5cQM3ArQs/GQU7CEieaeX jNtnyw+dTSnfso/4/Bf2d2cZm4aIYrOcrnPxilb+k7iCUYkUBb7UTITsX62jkQqqY9hK ViMw== 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=qn6o0e5vR723w+ne0etn5xqbJGUNdrckR7B/j1xzpt4=; b=ZVKmrcYppVv1LrAEASyYusDIIxteUGgaE2NihLDocqzWMv7T0cyAFn9OCpVIiNm0EJ ZiZjVm/95x7/w0+tbqWCIxRVP1BSpGpPaBPHpI8pfqZY+9caasEVoA6O2DlT5NQaXiox mBEQUt1stmGHxHj1ShemV5NAJ/iG2re2ZAa+xqQmMlSAwfXNd9bzY266ZL3DMnfwWT2I ju59mwKCSCz6m+bWYJWorfOoVX4apodKgKy1YO2XiqZCHoe7s13wfZ+E3CjhrUDWaeTt v3gpXCXbiOeLNB0WLJO88/n4wmCQM5OFHqUUFxSRgUcb+SsKmtcrydVJ/BJg1wQAmWvl +8wQ== X-Gm-Message-State: AOAM531yDmgTGfHzNaD6q3wX7Z86HWSp5e0xndh3BdaotBXL/wB4njHa etCUu7812G+e5t8JmNEwqFu9lWpLC8iH+A== X-Google-Smtp-Source: ABdhPJwWHC2fjOQuAwVby+H2D3vK77a6oLOTt7fPK88P1lKSRPwSOAlK/GJbwghfPIvmXdJS2Q1Q4Q== X-Received: by 2002:a7b:c0c4:: with SMTP id s4mr4151249wmh.9.1615991903285; Wed, 17 Mar 2021 07:38:23 -0700 (PDT) Received: from skynet.lan ([80.31.204.166]) by smtp.gmail.com with ESMTPSA id a75sm2518948wme.10.2021.03.17.07.38.22 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 17 Mar 2021 07:38:23 -0700 (PDT) From: =?UTF-8?q?=C3=81lvaro=20Fern=C3=A1ndez=20Rojas?= To: Linus Walleij , Bartosz Golaszewski , Rob Herring , Lee Jones , Michael Walle , 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 v8 19/22] pinctrl: add a pincontrol driver for BCM63268 Date: Wed, 17 Mar 2021 15:38:00 +0100 Message-Id: <20210317143803.26127-20-noltari@gmail.com> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20210317143803.26127-1-noltari@gmail.com> References: <20210317143803.26127-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. Co-developed-by: Jonas Gorski Signed-off-by: Jonas Gorski Signed-off-by: Álvaro Fernández Rojas --- v8: no changes v7: no changes 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,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 95137C433DB for ; Wed, 17 Mar 2021 14:45:36 +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 A1D6964E21 for ; Wed, 17 Mar 2021 14:45:35 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org A1D6964E21 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=9XmcBcGNwq2lHgsxNi4rBJoHq+Bv/icsKJzImGjsEn0=; b=q4kihZlWrn4c8IoPvjnfYHOK6 YVcCaGguhwas2ieHRsNcQND6w+RHUQpgVw8fb0+zNQtQ5Ph6CycP3lkLp2atvFmd0YbeJZaBNlMV8 JnDfQNigNWFw4jrAMm6hvB/FQKnmejwKbHung7T8tDyxKc1YMSaxfOf0vqHVal1QZnkCqa42F7yjY FoCgQ7JDjZ9k8qqHNEYdgyLuCfYYAlNugMhRcPvRMM775C+5nZPloUUmv/26NJL5Hr7VTPrs9HK8k VaQjQPPftDVMqzIWTSxb6JORbtzen+8a2LtdCHh6VQb1SnkaFT5D59AG4cpyQ45epxSX8V0GpBcKM vboJjbUcA==; Received: from localhost ([::1] helo=desiato.infradead.org) by desiato.infradead.org with esmtp (Exim 4.94 #2 (Red Hat Linux)) id 1lMXO2-003JrB-9f; Wed, 17 Mar 2021 14:43:02 +0000 Received: from mail-wm1-x331.google.com ([2a00:1450:4864:20::331]) by desiato.infradead.org with esmtps (Exim 4.94 #2 (Red Hat Linux)) id 1lMXJX-003Hgv-VU for linux-arm-kernel@lists.infradead.org; Wed, 17 Mar 2021 14:38:26 +0000 Received: by mail-wm1-x331.google.com with SMTP id n11-20020a05600c4f8bb029010e5cf86347so5442907wmq.1 for ; Wed, 17 Mar 2021 07:38:23 -0700 (PDT) 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=qn6o0e5vR723w+ne0etn5xqbJGUNdrckR7B/j1xzpt4=; b=grTbtpIa6l+/haNzY6qEnOgDmmsrKCML0QW7RIBB4isSkCpgvnzYffTdp3kyUeD6Yk WSzTDBcuJQx/9VSGnNkAqmy/cdjXsn3sJmt6GMJUkZGdHE+3dOj9dxyUAsjYMM2uz3gV TYjjMQwmK67FwxMs7oounM+/pBIdQ7055wFnUhu1vvWEc01g7nuQweSgsPayTgsO9P/T /klBauBrDuLqS69rTyAOU26frcB7gtJuZ1HG+u6UboOmHaJ5cQM3ArQs/GQU7CEieaeX jNtnyw+dTSnfso/4/Bf2d2cZm4aIYrOcrnPxilb+k7iCUYkUBb7UTITsX62jkQqqY9hK ViMw== 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=qn6o0e5vR723w+ne0etn5xqbJGUNdrckR7B/j1xzpt4=; b=BnpLrtSQqiyLDLJdjC1vS3h6XRkq/2tLi4hmW5EG4WRF2HlJ1mQC7esTvCnTtKryzZ cFmNkTkVskZzJty1TXWfl+3mn9LJoXVIzP13YeBqNWMlFNDs2wAAKrtHrh8oCSXhYmg3 2AVgQxot8RUast7Uwur0h6SZGA5HZbNcvXXf/bGaNvhAVzIp5A6g6A76a4CJIBcx29yg fXR6xTDlnQnnVJ8i0i7qfGcvo4OGcnlcp4V5waLwLRG8E6Jz8mJxnk7F+vWInHiuSYol ssHk60+FYkgPMtNhwplF9hc28tEg4JlKbbevgrrj8/jYTYsrtzF6wMtEVRo5cvsv2A0v lRKQ== X-Gm-Message-State: AOAM532lQrAg+5bvZUpm3dcYcWts5YU2P0mLFvEsvQFlApLDPTJmqQVp M9JXrCQjnuuaZnR/9t/0vxU= X-Google-Smtp-Source: ABdhPJwWHC2fjOQuAwVby+H2D3vK77a6oLOTt7fPK88P1lKSRPwSOAlK/GJbwghfPIvmXdJS2Q1Q4Q== X-Received: by 2002:a7b:c0c4:: with SMTP id s4mr4151249wmh.9.1615991903285; Wed, 17 Mar 2021 07:38:23 -0700 (PDT) Received: from skynet.lan ([80.31.204.166]) by smtp.gmail.com with ESMTPSA id a75sm2518948wme.10.2021.03.17.07.38.22 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 17 Mar 2021 07:38:23 -0700 (PDT) From: =?UTF-8?q?=C3=81lvaro=20Fern=C3=A1ndez=20Rojas?= To: Linus Walleij , Bartosz Golaszewski , Rob Herring , Lee Jones , Michael Walle , 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 v8 19/22] pinctrl: add a pincontrol driver for BCM63268 Date: Wed, 17 Mar 2021 15:38:00 +0100 Message-Id: <20210317143803.26127-20-noltari@gmail.com> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20210317143803.26127-1-noltari@gmail.com> References: <20210317143803.26127-1-noltari@gmail.com> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20210317_143824_577672_DA7C7E65 X-CRM114-Status: GOOD ( 18.17 ) 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 b3Vwcy4KCkNvLWRldmVsb3BlZC1ieTogSm9uYXMgR29yc2tpIDxqb25hcy5nb3Jza2lAZ21haWwu Y29tPgpTaWduZWQtb2ZmLWJ5OiBKb25hcyBHb3Jza2kgPGpvbmFzLmdvcnNraUBnbWFpbC5jb20+ ClNpZ25lZC1vZmYtYnk6IMOBbHZhcm8gRmVybsOhbmRleiBSb2phcyA8bm9sdGFyaUBnbWFpbC5j b20+Ci0tLQogdjg6IG5vIGNoYW5nZXMKIHY3OiBubyBjaGFuZ2VzCiB2Njogbm8gY2hhbmdlcwog djU6IGFkZCBjaGFuZ2VzIHN1Z2dlc3RlZCBieSBBbmR5IFNoZXZjaGVua28KIHY0OiBubyBjaGFu Z2VzCiB2MzogdXNlIG5ldyBzaGFyZWQgY29kZQogdjI6IHN3aXRjaCB0byBHUElPX1JFR01BUAoK IGRyaXZlcnMvcGluY3RybC9iY20vS2NvbmZpZyAgICAgICAgICAgIHwgICA4ICsKIGRyaXZlcnMv cGluY3RybC9iY20vTWFrZWZpbGUgICAgICAgICAgIHwgICAxICsKIGRyaXZlcnMvcGluY3RybC9i Y20vcGluY3RybC1iY202MzI2OC5jIHwgNjQzICsrKysrKysrKysrKysrKysrKysrKysrKysKIDMg ZmlsZXMgY2hhbmdlZCwgNjUyIGluc2VydGlvbnMoKykKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2 ZXJzL3BpbmN0cmwvYmNtL3BpbmN0cmwtYmNtNjMyNjguYwoKZGlmZiAtLWdpdCBhL2RyaXZlcnMv cGluY3RybC9iY20vS2NvbmZpZyBiL2RyaXZlcnMvcGluY3RybC9iY20vS2NvbmZpZwppbmRleCBh YWJkNGI3NjJhZWQuLjE4Njk4NTg0NjEyMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9waW5jdHJsL2Jj bS9LY29uZmlnCisrKyBiL2RyaXZlcnMvcGluY3RybC9iY20vS2NvbmZpZwpAQCAtNjgsNiArNjgs MTQgQEAgY29uZmlnIFBJTkNUUkxfQkNNNjM2OAogCWhlbHAKIAkgICBTYXkgWSBoZXJlIHRvIGVu YWJsZSB0aGUgQnJvYWRjb20gQkNNNjM2OCBHUElPIGRyaXZlci4KIAorY29uZmlnIFBJTkNUUkxf QkNNNjMyNjgKKwlib29sICJCcm9hZGNvbSBCQ002MzI2OCBHUElPIGRyaXZlciIKKwlkZXBlbmRz IG9uIChCTUlQU19HRU5FUklDIHx8IENPTVBJTEVfVEVTVCkKKwlzZWxlY3QgUElOQ1RSTF9CQ002 M1hYCisJZGVmYXVsdCBCTUlQU19HRU5FUklDCisJaGVscAorCSAgIFNheSBZIGhlcmUgdG8gZW5h YmxlIHRoZSBCcm9hZGNvbSBCQ002MzI2OCBHUElPIGRyaXZlci4KKwogY29uZmlnIFBJTkNUUkxf SVBST0NfR1BJTwogCWJvb2wgIkJyb2FkY29tIGlQcm9jIEdQSU8gKHdpdGggUElOQ09ORikgZHJp dmVyIgogCWRlcGVuZHMgb24gT0ZfR1BJTyAmJiAoQVJDSF9CQ01fSVBST0MgfHwgQ09NUElMRV9U RVNUKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9waW5jdHJsL2JjbS9NYWtlZmlsZSBiL2RyaXZlcnMv cGluY3RybC9iY20vTWFrZWZpbGUKaW5kZXggYTEzMzFiYjk2ODBlLi40MTE3ODQ3ZmQyNzkgMTAw NjQ0Ci0tLSBhL2RyaXZlcnMvcGluY3RybC9iY20vTWFrZWZpbGUKKysrIGIvZHJpdmVycy9waW5j dHJsL2JjbS9NYWtlZmlsZQpAQCAtOCw2ICs4LDcgQEAgb2JqLSQoQ09ORklHX1BJTkNUUkxfQkNN NjMyOCkJCSs9IHBpbmN0cmwtYmNtNjMyOC5vCiBvYmotJChDT05GSUdfUElOQ1RSTF9CQ002MzU4 KQkJKz0gcGluY3RybC1iY202MzU4Lm8KIG9iai0kKENPTkZJR19QSU5DVFJMX0JDTTYzNjIpCQkr PSBwaW5jdHJsLWJjbTYzNjIubwogb2JqLSQoQ09ORklHX1BJTkNUUkxfQkNNNjM2OCkJCSs9IHBp bmN0cmwtYmNtNjM2OC5vCitvYmotJChDT05GSUdfUElOQ1RSTF9CQ002MzI2OCkJCSs9IHBpbmN0 cmwtYmNtNjMyNjgubwogb2JqLSQoQ09ORklHX1BJTkNUUkxfSVBST0NfR1BJTykJKz0gcGluY3Ry bC1pcHJvYy1ncGlvLm8KIG9iai0kKENPTkZJR19QSU5DVFJMX0NZR05VU19NVVgpCSs9IHBpbmN0 cmwtY3lnbnVzLW11eC5vCiBvYmotJChDT05GSUdfUElOQ1RSTF9OUykJCSs9IHBpbmN0cmwtbnMu bwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9waW5jdHJsL2JjbS9waW5jdHJsLWJjbTYzMjY4LmMgYi9k cml2ZXJzL3BpbmN0cmwvYmNtL3BpbmN0cmwtYmNtNjMyNjguYwpuZXcgZmlsZSBtb2RlIDEwMDY0 NAppbmRleCAwMDAwMDAwMDAwMDAuLmQ0YzVmYWQ3ZmI3ZAotLS0gL2Rldi9udWxsCisrKyBiL2Ry aXZlcnMvcGluY3RybC9iY20vcGluY3RybC1iY202MzI2OC5jCkBAIC0wLDAgKzEsNjQzIEBACisv LyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMCsKKy8qCisgKiBEcml2ZXIgZm9yIEJD TTYzMjY4IEdQSU8gdW5pdCAocGluY3RybCArIEdQSU8pCisgKgorICogQ29weXJpZ2h0IChDKSAy MDIxIMOBbHZhcm8gRmVybsOhbmRleiBSb2phcyA8bm9sdGFyaUBnbWFpbC5jb20+CisgKiBDb3B5 cmlnaHQgKEMpIDIwMTYgSm9uYXMgR29yc2tpIDxqb25hcy5nb3Jza2lAZ21haWwuY29tPgorICov CisKKyNpbmNsdWRlIDxsaW51eC9iaXRzLmg+CisjaW5jbHVkZSA8bGludXgvZ3Bpby9kcml2ZXIu aD4KKyNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KKyNpbmNsdWRlIDxsaW51eC9vZi5oPgorI2lu Y2x1ZGUgPGxpbnV4L3BpbmN0cmwvcGlubXV4Lmg+CisjaW5jbHVkZSA8bGludXgvcGxhdGZvcm1f ZGV2aWNlLmg+CisjaW5jbHVkZSA8bGludXgvcmVnbWFwLmg+CisKKyNpbmNsdWRlICIuLi9waW5j dHJsLXV0aWxzLmgiCisKKyNpbmNsdWRlICJwaW5jdHJsLWJjbTYzeHguaCIKKworI2RlZmluZSBC Q002MzI2OF9OVU1fR1BJT1MJCTUyCisjZGVmaW5lIEJDTTYzMjY4X05VTV9MRURTCQkyNAorCisj ZGVmaW5lIEJDTTYzMjY4X0xFRF9SRUcJCTB4MTAKKyNkZWZpbmUgQkNNNjMyNjhfTU9ERV9SRUcJ CTB4MTgKKyNkZWZpbmUgQkNNNjMyNjhfQ1RSTF9SRUcJCTB4MWMKKyNkZWZpbmUgQkNNNjMyNjhf QkFTRU1PREVfUkVHCQkweDM4CisjZGVmaW5lICBCQ002MzI2OF9CQVNFTU9ERV9OQU5ECQlCSVQo MikgLyogR1BJT3MgMi03LCAyNC0zMSAqLworI2RlZmluZSAgQkNNNjMyNjhfQkFTRU1PREVfR1BJ TzM1CUJJVCg0KSAvKiBHUElPIDM1ICovCisjZGVmaW5lICBCQ002MzI2OF9CQVNFTU9ERV9ERUNU UEQJQklUKDUpIC8qIEdQSU9zIDgvOSAqLworI2RlZmluZSAgQkNNNjMyNjhfQkFTRU1PREVfVkRT TF9QSFlfMAlCSVQoNikgLyogR1BJT3MgMTAvMTEgKi8KKyNkZWZpbmUgIEJDTTYzMjY4X0JBU0VN T0RFX1ZEU0xfUEhZXzEJQklUKDcpIC8qIEdQSU9zIDEyLzEzICovCisjZGVmaW5lICBCQ002MzI2 OF9CQVNFTU9ERV9WRFNMX1BIWV8yCUJJVCg4KSAvKiBHUElPcyAyNC8yNSAqLworI2RlZmluZSAg QkNNNjMyNjhfQkFTRU1PREVfVkRTTF9QSFlfMwlCSVQoOSkgLyogR1BJT3MgMjYvMjcgKi8KKwor ZW51bSBiY202MzI2OF9waW5jdHJsX3JlZyB7CisJQkNNNjMyNjhfTEVEQ1RSTCwKKwlCQ002MzI2 OF9NT0RFLAorCUJDTTYzMjY4X0NUUkwsCisJQkNNNjMyNjhfQkFTRU1PREUsCit9OworCitzdHJ1 Y3QgYmNtNjMyNjhfcGluZ3JvdXAgeworCWNvbnN0IGNoYXIgKm5hbWU7CisJY29uc3QgdW5zaWdu ZWQgKiBjb25zdCBwaW5zOworCWNvbnN0IHVuc2lnbmVkIG51bV9waW5zOworfTsKKworc3RydWN0 IGJjbTYzMjY4X2Z1bmN0aW9uIHsKKwljb25zdCBjaGFyICpuYW1lOworCWNvbnN0IGNoYXIgKiBj b25zdCAqZ3JvdXBzOworCWNvbnN0IHVuc2lnbmVkIG51bV9ncm91cHM7CisKKwllbnVtIGJjbTYz MjY4X3BpbmN0cmxfcmVnIHJlZzsKKwl1aW50MzJfdCBtYXNrOworfTsKKworI2RlZmluZSBCQ002 MzI2OF9QSU4oYSwgYiwgYmFzZW1vZGUpCQkJXAorCXsJCQkJCQlcCisJCS5udW1iZXIgPSBhLAkJ CQlcCisJCS5uYW1lID0gYiwJCQkJXAorCQkuZHJ2X2RhdGEgPSAodm9pZCAqKShiYXNlbW9kZSkJ CVwKKwl9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgcGluY3RybF9waW5fZGVzYyBiY202MzI2OF9w aW5zW10gPSB7CisJUElOQ1RSTF9QSU4oMCwgImdwaW8wIiksCisJUElOQ1RSTF9QSU4oMSwgImdw aW8xIiksCisJQkNNNjMyNjhfUElOKDIsICJncGlvMiIsIEJDTTYzMjY4X0JBU0VNT0RFX05BTkQp LAorCUJDTTYzMjY4X1BJTigzLCAiZ3BpbzMiLCBCQ002MzI2OF9CQVNFTU9ERV9OQU5EKSwKKwlC Q002MzI2OF9QSU4oNCwgImdwaW80IiwgQkNNNjMyNjhfQkFTRU1PREVfTkFORCksCisJQkNNNjMy NjhfUElOKDUsICJncGlvNSIsIEJDTTYzMjY4X0JBU0VNT0RFX05BTkQpLAorCUJDTTYzMjY4X1BJ Tig2LCAiZ3BpbzYiLCBCQ002MzI2OF9CQVNFTU9ERV9OQU5EKSwKKwlCQ002MzI2OF9QSU4oNywg ImdwaW83IiwgQkNNNjMyNjhfQkFTRU1PREVfTkFORCksCisJQkNNNjMyNjhfUElOKDgsICJncGlv OCIsIEJDTTYzMjY4X0JBU0VNT0RFX0RFQ1RQRCksCisJQkNNNjMyNjhfUElOKDksICJncGlvOSIs IEJDTTYzMjY4X0JBU0VNT0RFX0RFQ1RQRCksCisJQkNNNjMyNjhfUElOKDEwLCAiZ3BpbzEwIiwg QkNNNjMyNjhfQkFTRU1PREVfVkRTTF9QSFlfMCksCisJQkNNNjMyNjhfUElOKDExLCAiZ3BpbzEx IiwgQkNNNjMyNjhfQkFTRU1PREVfVkRTTF9QSFlfMCksCisJQkNNNjMyNjhfUElOKDEyLCAiZ3Bp bzEyIiwgQkNNNjMyNjhfQkFTRU1PREVfVkRTTF9QSFlfMSksCisJQkNNNjMyNjhfUElOKDEzLCAi Z3BpbzEzIiwgQkNNNjMyNjhfQkFTRU1PREVfVkRTTF9QSFlfMSksCisJUElOQ1RSTF9QSU4oMTQs ICJncGlvMTQiKSwKKwlQSU5DVFJMX1BJTigxNSwgImdwaW8xNSIpLAorCVBJTkNUUkxfUElOKDE2 LCAiZ3BpbzE2IiksCisJUElOQ1RSTF9QSU4oMTcsICJncGlvMTciKSwKKwlQSU5DVFJMX1BJTigx OCwgImdwaW8xOCIpLAorCVBJTkNUUkxfUElOKDE5LCAiZ3BpbzE5IiksCisJUElOQ1RSTF9QSU4o MjAsICJncGlvMjAiKSwKKwlQSU5DVFJMX1BJTigyMSwgImdwaW8yMSIpLAorCVBJTkNUUkxfUElO KDIyLCAiZ3BpbzIyIiksCisJUElOQ1RSTF9QSU4oMjMsICJncGlvMjMiKSwKKwlCQ002MzI2OF9Q SU4oMjQsICJncGlvMjQiLAorCQkgICAgIEJDTTYzMjY4X0JBU0VNT0RFX05BTkQgfCBCQ002MzI2 OF9CQVNFTU9ERV9WRFNMX1BIWV8yKSwKKwlCQ002MzI2OF9QSU4oMjUsICJncGlvMjUiLAorCQkg ICAgIEJDTTYzMjY4X0JBU0VNT0RFX05BTkQgfCBCQ002MzI2OF9CQVNFTU9ERV9WRFNMX1BIWV8y KSwKKwlCQ002MzI2OF9QSU4oMjYsICJncGlvMjYiLAorCQkgICAgIEJDTTYzMjY4X0JBU0VNT0RF X05BTkQgfCBCQ002MzI2OF9CQVNFTU9ERV9WRFNMX1BIWV8zKSwKKwlCQ002MzI2OF9QSU4oMjcs ICJncGlvMjciLAorCQkgICAgIEJDTTYzMjY4X0JBU0VNT0RFX05BTkQgfCBCQ002MzI2OF9CQVNF TU9ERV9WRFNMX1BIWV8zKSwKKwlCQ002MzI2OF9QSU4oMjgsICJncGlvMjgiLCBCQ002MzI2OF9C QVNFTU9ERV9OQU5EKSwKKwlCQ002MzI2OF9QSU4oMjksICJncGlvMjkiLCBCQ002MzI2OF9CQVNF TU9ERV9OQU5EKSwKKwlCQ002MzI2OF9QSU4oMzAsICJncGlvMzAiLCBCQ002MzI2OF9CQVNFTU9E RV9OQU5EKSwKKwlCQ002MzI2OF9QSU4oMzEsICJncGlvMzEiLCBCQ002MzI2OF9CQVNFTU9ERV9O QU5EKSwKKwlQSU5DVFJMX1BJTigzMiwgImdwaW8zMiIpLAorCVBJTkNUUkxfUElOKDMzLCAiZ3Bp bzMzIiksCisJUElOQ1RSTF9QSU4oMzQsICJncGlvMzQiKSwKKwlQSU5DVFJMX1BJTigzNSwgImdw aW8zNSIpLAorCVBJTkNUUkxfUElOKDM2LCAiZ3BpbzM2IiksCisJUElOQ1RSTF9QSU4oMzcsICJn cGlvMzciKSwKKwlQSU5DVFJMX1BJTigzOCwgImdwaW8zOCIpLAorCVBJTkNUUkxfUElOKDM5LCAi Z3BpbzM5IiksCisJUElOQ1RSTF9QSU4oNDAsICJncGlvNDAiKSwKKwlQSU5DVFJMX1BJTig0MSwg ImdwaW80MSIpLAorCVBJTkNUUkxfUElOKDQyLCAiZ3BpbzQyIiksCisJUElOQ1RSTF9QSU4oNDMs ICJncGlvNDMiKSwKKwlQSU5DVFJMX1BJTig0NCwgImdwaW80NCIpLAorCVBJTkNUUkxfUElOKDQ1 LCAiZ3BpbzQ1IiksCisJUElOQ1RSTF9QSU4oNDYsICJncGlvNDYiKSwKKwlQSU5DVFJMX1BJTig0 NywgImdwaW80NyIpLAorCVBJTkNUUkxfUElOKDQ4LCAiZ3BpbzQ4IiksCisJUElOQ1RSTF9QSU4o NDksICJncGlvNDkiKSwKKwlQSU5DVFJMX1BJTig1MCwgImdwaW81MCIpLAorCVBJTkNUUkxfUElO KDUxLCAiZ3BpbzUxIiksCit9OworCitzdGF0aWMgdW5zaWduZWQgZ3BpbzBfcGluc1tdID0geyAw IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzFfcGluc1tdID0geyAxIH07CitzdGF0aWMgdW5zaWdu ZWQgZ3BpbzJfcGluc1tdID0geyAyIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzNfcGluc1tdID0g eyAzIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzRfcGluc1tdID0geyA0IH07CitzdGF0aWMgdW5z aWduZWQgZ3BpbzVfcGluc1tdID0geyA1IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzZfcGluc1td ID0geyA2IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzdfcGluc1tdID0geyA3IH07CitzdGF0aWMg dW5zaWduZWQgZ3BpbzhfcGluc1tdID0geyA4IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzlfcGlu c1tdID0geyA5IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzEwX3BpbnNbXSA9IHsgMTAgfTsKK3N0 YXRpYyB1bnNpZ25lZCBncGlvMTFfcGluc1tdID0geyAxMSB9Oworc3RhdGljIHVuc2lnbmVkIGdw aW8xMl9waW5zW10gPSB7IDEyIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzEzX3BpbnNbXSA9IHsg MTMgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMTRfcGluc1tdID0geyAxNCB9Oworc3RhdGljIHVu c2lnbmVkIGdwaW8xNV9waW5zW10gPSB7IDE1IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzE2X3Bp bnNbXSA9IHsgMTYgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMTdfcGluc1tdID0geyAxNyB9Owor c3RhdGljIHVuc2lnbmVkIGdwaW8xOF9waW5zW10gPSB7IDE4IH07CitzdGF0aWMgdW5zaWduZWQg Z3BpbzE5X3BpbnNbXSA9IHsgMTkgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMjBfcGluc1tdID0g eyAyMCB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8yMV9waW5zW10gPSB7IDIxIH07CitzdGF0aWMg dW5zaWduZWQgZ3BpbzIyX3BpbnNbXSA9IHsgMjIgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMjNf cGluc1tdID0geyAyMyB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8yNF9waW5zW10gPSB7IDI0IH07 CitzdGF0aWMgdW5zaWduZWQgZ3BpbzI1X3BpbnNbXSA9IHsgMjUgfTsKK3N0YXRpYyB1bnNpZ25l ZCBncGlvMjZfcGluc1tdID0geyAyNiB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8yN19waW5zW10g PSB7IDI3IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzI4X3BpbnNbXSA9IHsgMjggfTsKK3N0YXRp YyB1bnNpZ25lZCBncGlvMjlfcGluc1tdID0geyAyOSB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8z MF9waW5zW10gPSB7IDMwIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzMxX3BpbnNbXSA9IHsgMzEg fTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMzJfcGluc1tdID0geyAzMiB9Oworc3RhdGljIHVuc2ln bmVkIGdwaW8zM19waW5zW10gPSB7IDMzIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzM0X3BpbnNb XSA9IHsgMzQgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMzVfcGluc1tdID0geyAzNSB9Oworc3Rh dGljIHVuc2lnbmVkIGdwaW8zNl9waW5zW10gPSB7IDM2IH07CitzdGF0aWMgdW5zaWduZWQgZ3Bp bzM3X3BpbnNbXSA9IHsgMzcgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMzhfcGluc1tdID0geyAz OCB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8zOV9waW5zW10gPSB7IDM5IH07CitzdGF0aWMgdW5z aWduZWQgZ3BpbzQwX3BpbnNbXSA9IHsgNDAgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvNDFfcGlu c1tdID0geyA0MSB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW80Ml9waW5zW10gPSB7IDQyIH07Citz dGF0aWMgdW5zaWduZWQgZ3BpbzQzX3BpbnNbXSA9IHsgNDMgfTsKK3N0YXRpYyB1bnNpZ25lZCBn cGlvNDRfcGluc1tdID0geyA0NCB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW80NV9waW5zW10gPSB7 IDQ1IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzQ2X3BpbnNbXSA9IHsgNDYgfTsKK3N0YXRpYyB1 bnNpZ25lZCBncGlvNDdfcGluc1tdID0geyA0NyB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW80OF9w aW5zW10gPSB7IDQ4IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzQ5X3BpbnNbXSA9IHsgNDkgfTsK K3N0YXRpYyB1bnNpZ25lZCBncGlvNTBfcGluc1tdID0geyA1MCB9Oworc3RhdGljIHVuc2lnbmVk IGdwaW81MV9waW5zW10gPSB7IDUxIH07CisKK3N0YXRpYyB1bnNpZ25lZCBuYW5kX2dycF9waW5z W10gPSB7CisJMiwgMywgNCwgNSwgNiwgNywgMjQsCisJMjUsIDI2LCAyNywgMjgsIDI5LCAzMCwg MzEsCit9OworCitzdGF0aWMgdW5zaWduZWQgZGVjdHBkX2dycF9waW5zW10gPSB7IDgsIDkgfTsK K3N0YXRpYyB1bnNpZ25lZCB2ZHNsX3BoeTBfZ3JwX3BpbnNbXSA9IHsgMTAsIDExIH07CitzdGF0 aWMgdW5zaWduZWQgdmRzbF9waHkxX2dycF9waW5zW10gPSB7IDEyLCAxMyB9Oworc3RhdGljIHVu c2lnbmVkIHZkc2xfcGh5Ml9ncnBfcGluc1tdID0geyAyNCwgMjUgfTsKK3N0YXRpYyB1bnNpZ25l ZCB2ZHNsX3BoeTNfZ3JwX3BpbnNbXSA9IHsgMjYsIDI3IH07CisKKyNkZWZpbmUgQkNNNjMyNjhf R1JPVVAobikJCQkJCVwKKwl7CQkJCQkJCVwKKwkJLm5hbWUgPSAjbiwJCQkJCVwKKwkJLnBpbnMg PSBuIyNfcGlucywJCQkJXAorCQkubnVtX3BpbnMgPSBBUlJBWV9TSVpFKG4jI19waW5zKSwJCVwK Kwl9CisKK3N0YXRpYyBzdHJ1Y3QgYmNtNjMyNjhfcGluZ3JvdXAgYmNtNjMyNjhfZ3JvdXBzW10g PSB7CisJQkNNNjMyNjhfR1JPVVAoZ3BpbzApLAorCUJDTTYzMjY4X0dST1VQKGdwaW8xKSwKKwlC Q002MzI2OF9HUk9VUChncGlvMiksCisJQkNNNjMyNjhfR1JPVVAoZ3BpbzMpLAorCUJDTTYzMjY4 X0dST1VQKGdwaW80KSwKKwlCQ002MzI2OF9HUk9VUChncGlvNSksCisJQkNNNjMyNjhfR1JPVVAo Z3BpbzYpLAorCUJDTTYzMjY4X0dST1VQKGdwaW83KSwKKwlCQ002MzI2OF9HUk9VUChncGlvOCks CisJQkNNNjMyNjhfR1JPVVAoZ3BpbzkpLAorCUJDTTYzMjY4X0dST1VQKGdwaW8xMCksCisJQkNN NjMyNjhfR1JPVVAoZ3BpbzExKSwKKwlCQ002MzI2OF9HUk9VUChncGlvMTIpLAorCUJDTTYzMjY4 X0dST1VQKGdwaW8xMyksCisJQkNNNjMyNjhfR1JPVVAoZ3BpbzE0KSwKKwlCQ002MzI2OF9HUk9V UChncGlvMTUpLAorCUJDTTYzMjY4X0dST1VQKGdwaW8xNiksCisJQkNNNjMyNjhfR1JPVVAoZ3Bp bzE3KSwKKwlCQ002MzI2OF9HUk9VUChncGlvMTgpLAorCUJDTTYzMjY4X0dST1VQKGdwaW8xOSks CisJQkNNNjMyNjhfR1JPVVAoZ3BpbzIwKSwKKwlCQ002MzI2OF9HUk9VUChncGlvMjEpLAorCUJD TTYzMjY4X0dST1VQKGdwaW8yMiksCisJQkNNNjMyNjhfR1JPVVAoZ3BpbzIzKSwKKwlCQ002MzI2 OF9HUk9VUChncGlvMjQpLAorCUJDTTYzMjY4X0dST1VQKGdwaW8yNSksCisJQkNNNjMyNjhfR1JP VVAoZ3BpbzI2KSwKKwlCQ002MzI2OF9HUk9VUChncGlvMjcpLAorCUJDTTYzMjY4X0dST1VQKGdw aW8yOCksCisJQkNNNjMyNjhfR1JPVVAoZ3BpbzI5KSwKKwlCQ002MzI2OF9HUk9VUChncGlvMzAp LAorCUJDTTYzMjY4X0dST1VQKGdwaW8zMSksCisJQkNNNjMyNjhfR1JPVVAoZ3BpbzMyKSwKKwlC Q002MzI2OF9HUk9VUChncGlvMzMpLAorCUJDTTYzMjY4X0dST1VQKGdwaW8zNCksCisJQkNNNjMy NjhfR1JPVVAoZ3BpbzM1KSwKKwlCQ002MzI2OF9HUk9VUChncGlvMzYpLAorCUJDTTYzMjY4X0dS T1VQKGdwaW8zNyksCisJQkNNNjMyNjhfR1JPVVAoZ3BpbzM4KSwKKwlCQ002MzI2OF9HUk9VUChn cGlvMzkpLAorCUJDTTYzMjY4X0dST1VQKGdwaW80MCksCisJQkNNNjMyNjhfR1JPVVAoZ3BpbzQx KSwKKwlCQ002MzI2OF9HUk9VUChncGlvNDIpLAorCUJDTTYzMjY4X0dST1VQKGdwaW80MyksCisJ QkNNNjMyNjhfR1JPVVAoZ3BpbzQ0KSwKKwlCQ002MzI2OF9HUk9VUChncGlvNDUpLAorCUJDTTYz MjY4X0dST1VQKGdwaW80NiksCisJQkNNNjMyNjhfR1JPVVAoZ3BpbzQ3KSwKKwlCQ002MzI2OF9H Uk9VUChncGlvNDgpLAorCUJDTTYzMjY4X0dST1VQKGdwaW80OSksCisJQkNNNjMyNjhfR1JPVVAo Z3BpbzUwKSwKKwlCQ002MzI2OF9HUk9VUChncGlvNTEpLAorCisJLyogbXVsdGkgcGluIGdyb3Vw cyAqLworCUJDTTYzMjY4X0dST1VQKG5hbmRfZ3JwKSwKKwlCQ002MzI2OF9HUk9VUChkZWN0cGRf Z3JwKSwKKwlCQ002MzI2OF9HUk9VUCh2ZHNsX3BoeTBfZ3JwKSwKKwlCQ002MzI2OF9HUk9VUCh2 ZHNsX3BoeTFfZ3JwKSwKKwlCQ002MzI2OF9HUk9VUCh2ZHNsX3BoeTJfZ3JwKSwKKwlCQ002MzI2 OF9HUk9VUCh2ZHNsX3BoeTNfZ3JwKSwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3Qg bGVkX2dyb3Vwc1tdID0geworCSJncGlvMCIsCisJImdwaW8xIiwKKwkiZ3BpbzIiLAorCSJncGlv MyIsCisJImdwaW80IiwKKwkiZ3BpbzUiLAorCSJncGlvNiIsCisJImdwaW83IiwKKwkiZ3Bpbzgi LAorCSJncGlvOSIsCisJImdwaW8xMCIsCisJImdwaW8xMSIsCisJImdwaW8xMiIsCisJImdwaW8x MyIsCisJImdwaW8xNCIsCisJImdwaW8xNSIsCisJImdwaW8xNiIsCisJImdwaW8xNyIsCisJImdw aW8xOCIsCisJImdwaW8xOSIsCisJImdwaW8yMCIsCisJImdwaW8yMSIsCisJImdwaW8yMiIsCisJ ImdwaW8yMyIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHNlcmlhbF9sZWRfY2xr X2dyb3Vwc1tdID0geworCSJncGlvMCIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0 IHNlcmlhbF9sZWRfZGF0YV9ncm91cHNbXSA9IHsKKwkiZ3BpbzEiLAorfTsKKworc3RhdGljIGNv bnN0IGNoYXIgKiBjb25zdCBoc3NwaV9jczRfZ3JvdXBzW10gPSB7CisJImdwaW8xNiIsCit9Owor CitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGhzc3BpX2NzNV9ncm91cHNbXSA9IHsKKwkiZ3Bp bzE3IiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgaHNzcGlfY3M2X2dyb3Vwc1td ID0geworCSJncGlvOCIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGhzc3BpX2Nz N19ncm91cHNbXSA9IHsKKwkiZ3BpbzkiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25z dCB1YXJ0MV9zY3RzX2dyb3Vwc1tdID0geworCSJncGlvMTAiLAorCSJncGlvMjQiLAorfTsKKwor c3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCB1YXJ0MV9zcnRzX2dyb3Vwc1tdID0geworCSJncGlv MTEiLAorCSJncGlvMjUiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCB1YXJ0MV9z ZGluX2dyb3Vwc1tdID0geworCSJncGlvMTIiLAorCSJncGlvMjYiLAorfTsKKworc3RhdGljIGNv bnN0IGNoYXIgKiBjb25zdCB1YXJ0MV9zZG91dF9ncm91cHNbXSA9IHsKKwkiZ3BpbzEzIiwKKwki Z3BpbzI3IiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgbnRyX3B1bHNlX2luX2dy b3Vwc1tdID0geworCSJncGlvMTQiLAorCSJncGlvMjgiLAorfTsKKworc3RhdGljIGNvbnN0IGNo YXIgKiBjb25zdCBkc2xfbnRyX3B1bHNlX291dF9ncm91cHNbXSA9IHsKKwkiZ3BpbzE1IiwKKwki Z3BpbzI5IiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgYWRzbF9zcGlfbWlzb19n cm91cHNbXSA9IHsKKwkiZ3BpbzE4IiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3Qg YWRzbF9zcGlfbW9zaV9ncm91cHNbXSA9IHsKKwkiZ3BpbzE5IiwKK307CisKK3N0YXRpYyBjb25z dCBjaGFyICogY29uc3QgdnJlZ19jbGtfZ3JvdXBzW10gPSB7CisJImdwaW8yMiIsCit9OworCitz dGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHBjaWVfY2xrcmVxX2JfZ3JvdXBzW10gPSB7CisJImdw aW8yMyIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHN3aXRjaF9sZWRfY2xrX2dy b3Vwc1tdID0geworCSJncGlvMzAiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBz d2l0Y2hfbGVkX2RhdGFfZ3JvdXBzW10gPSB7CisJImdwaW8zMSIsCit9OworCitzdGF0aWMgY29u c3QgY2hhciAqIGNvbnN0IHdpZmlfZ3JvdXBzW10gPSB7CisJImdwaW8zMiIsCisJImdwaW8zMyIs CisJImdwaW8zNCIsCisJImdwaW8zNSIsCisJImdwaW8zNiIsCisJImdwaW8zNyIsCisJImdwaW8z OCIsCisJImdwaW8zOSIsCisJImdwaW80MCIsCisJImdwaW80MSIsCisJImdwaW80MiIsCisJImdw aW80MyIsCisJImdwaW80NCIsCisJImdwaW80NSIsCisJImdwaW80NiIsCisJImdwaW80NyIsCisJ ImdwaW80OCIsCisJImdwaW80OSIsCisJImdwaW81MCIsCisJImdwaW81MSIsCit9OworCitzdGF0 aWMgY29uc3QgY2hhciAqIGNvbnN0IG5hbmRfZ3JvdXBzW10gPSB7CisJIm5hbmRfZ3JwIiwKK307 CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgZGVjdHBkX2dyb3Vwc1tdID0geworCSJkZWN0 cGRfZ3JwIiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgdmRzbF9waHlfb3ZlcnJp ZGVfMF9ncm91cHNbXSA9IHsKKwkidmRzbF9waHlfb3ZlcnJpZGVfMF9ncnAiLAorfTsKKworc3Rh dGljIGNvbnN0IGNoYXIgKiBjb25zdCB2ZHNsX3BoeV9vdmVycmlkZV8xX2dyb3Vwc1tdID0gewor CSJ2ZHNsX3BoeV9vdmVycmlkZV8xX2dycCIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNv bnN0IHZkc2xfcGh5X292ZXJyaWRlXzJfZ3JvdXBzW10gPSB7CisJInZkc2xfcGh5X292ZXJyaWRl XzJfZ3JwIiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgdmRzbF9waHlfb3ZlcnJp ZGVfM19ncm91cHNbXSA9IHsKKwkidmRzbF9waHlfb3ZlcnJpZGVfM19ncnAiLAorfTsKKworI2Rl ZmluZSBCQ002MzI2OF9MRURfRlVOKG4pCQkJCVwKKwl7CQkJCQkJXAorCQkubmFtZSA9ICNuLAkJ CQlcCisJCS5ncm91cHMgPSBuIyNfZ3JvdXBzLAkJCVwKKwkJLm51bV9ncm91cHMgPSBBUlJBWV9T SVpFKG4jI19ncm91cHMpLAlcCisJCS5yZWcgPSBCQ002MzI2OF9MRURDVFJMLAkJXAorCX0KKwor I2RlZmluZSBCQ002MzI2OF9NT0RFX0ZVTihuKQkJCQlcCisJewkJCQkJCVwKKwkJLm5hbWUgPSAj biwJCQkJXAorCQkuZ3JvdXBzID0gbiMjX2dyb3VwcywJCQlcCisJCS5udW1fZ3JvdXBzID0gQVJS QVlfU0laRShuIyNfZ3JvdXBzKSwJXAorCQkucmVnID0gQkNNNjMyNjhfTU9ERSwJCQlcCisJfQor CisjZGVmaW5lIEJDTTYzMjY4X0NUUkxfRlVOKG4pCQkJCVwKKwl7CQkJCQkJXAorCQkubmFtZSA9 ICNuLAkJCQlcCisJCS5ncm91cHMgPSBuIyNfZ3JvdXBzLAkJCVwKKwkJLm51bV9ncm91cHMgPSBB UlJBWV9TSVpFKG4jI19ncm91cHMpLAlcCisJCS5yZWcgPSBCQ002MzI2OF9DVFJMLAkJCVwKKwl9 CisKKyNkZWZpbmUgQkNNNjMyNjhfQkFTRU1PREVfRlVOKG4sIHZhbCkJCQlcCisJewkJCQkJCVwK KwkJLm5hbWUgPSAjbiwJCQkJXAorCQkuZ3JvdXBzID0gbiMjX2dyb3VwcywJCQlcCisJCS5udW1f Z3JvdXBzID0gQVJSQVlfU0laRShuIyNfZ3JvdXBzKSwJXAorCQkucmVnID0gQkNNNjMyNjhfQkFT RU1PREUsCQlcCisJCS5tYXNrID0gdmFsLAkJCQlcCisJfQorCitzdGF0aWMgY29uc3Qgc3RydWN0 IGJjbTYzMjY4X2Z1bmN0aW9uIGJjbTYzMjY4X2Z1bmNzW10gPSB7CisJQkNNNjMyNjhfTEVEX0ZV TihsZWQpLAorCUJDTTYzMjY4X01PREVfRlVOKHNlcmlhbF9sZWRfY2xrKSwKKwlCQ002MzI2OF9N T0RFX0ZVTihzZXJpYWxfbGVkX2RhdGEpLAorCUJDTTYzMjY4X01PREVfRlVOKGhzc3BpX2NzNiks CisJQkNNNjMyNjhfTU9ERV9GVU4oaHNzcGlfY3M3KSwKKwlCQ002MzI2OF9NT0RFX0ZVTih1YXJ0 MV9zY3RzKSwKKwlCQ002MzI2OF9NT0RFX0ZVTih1YXJ0MV9zcnRzKSwKKwlCQ002MzI2OF9NT0RF X0ZVTih1YXJ0MV9zZGluKSwKKwlCQ002MzI2OF9NT0RFX0ZVTih1YXJ0MV9zZG91dCksCisJQkNN NjMyNjhfTU9ERV9GVU4obnRyX3B1bHNlX2luKSwKKwlCQ002MzI2OF9NT0RFX0ZVTihkc2xfbnRy X3B1bHNlX291dCksCisJQkNNNjMyNjhfTU9ERV9GVU4oaHNzcGlfY3M0KSwKKwlCQ002MzI2OF9N T0RFX0ZVTihoc3NwaV9jczUpLAorCUJDTTYzMjY4X01PREVfRlVOKGFkc2xfc3BpX21pc28pLAor CUJDTTYzMjY4X01PREVfRlVOKGFkc2xfc3BpX21vc2kpLAorCUJDTTYzMjY4X01PREVfRlVOKHZy ZWdfY2xrKSwKKwlCQ002MzI2OF9NT0RFX0ZVTihwY2llX2Nsa3JlcV9iKSwKKwlCQ002MzI2OF9N T0RFX0ZVTihzd2l0Y2hfbGVkX2NsayksCisJQkNNNjMyNjhfTU9ERV9GVU4oc3dpdGNoX2xlZF9k YXRhKSwKKwlCQ002MzI2OF9DVFJMX0ZVTih3aWZpKSwKKwlCQ002MzI2OF9CQVNFTU9ERV9GVU4o bmFuZCwgQkNNNjMyNjhfQkFTRU1PREVfTkFORCksCisJQkNNNjMyNjhfQkFTRU1PREVfRlVOKGRl Y3RwZCwgQkNNNjMyNjhfQkFTRU1PREVfREVDVFBEKSwKKwlCQ002MzI2OF9CQVNFTU9ERV9GVU4o dmRzbF9waHlfb3ZlcnJpZGVfMCwKKwkJCSAgICAgIEJDTTYzMjY4X0JBU0VNT0RFX1ZEU0xfUEhZ XzApLAorCUJDTTYzMjY4X0JBU0VNT0RFX0ZVTih2ZHNsX3BoeV9vdmVycmlkZV8xLAorCQkJICAg ICAgQkNNNjMyNjhfQkFTRU1PREVfVkRTTF9QSFlfMSksCisJQkNNNjMyNjhfQkFTRU1PREVfRlVO KHZkc2xfcGh5X292ZXJyaWRlXzIsCisJCQkgICAgICBCQ002MzI2OF9CQVNFTU9ERV9WRFNMX1BI WV8yKSwKKwlCQ002MzI2OF9CQVNFTU9ERV9GVU4odmRzbF9waHlfb3ZlcnJpZGVfMywKKwkJCSAg ICAgIEJDTTYzMjY4X0JBU0VNT0RFX1ZEU0xfUEhZXzMpLAorfTsKKworc3RhdGljIGludCBiY202 MzI2OF9waW5jdHJsX2dldF9ncm91cF9jb3VudChzdHJ1Y3QgcGluY3RybF9kZXYgKnBjdGxkZXYp Cit7CisJcmV0dXJuIEFSUkFZX1NJWkUoYmNtNjMyNjhfZ3JvdXBzKTsKK30KKworc3RhdGljIGNv bnN0IGNoYXIgKmJjbTYzMjY4X3BpbmN0cmxfZ2V0X2dyb3VwX25hbWUoc3RydWN0IHBpbmN0cmxf ZGV2ICpwY3RsZGV2LAorCQkJCQkJICAgdW5zaWduZWQgZ3JvdXApCit7CisJcmV0dXJuIGJjbTYz MjY4X2dyb3Vwc1tncm91cF0ubmFtZTsKK30KKworc3RhdGljIGludCBiY202MzI2OF9waW5jdHJs X2dldF9ncm91cF9waW5zKHN0cnVjdCBwaW5jdHJsX2RldiAqcGN0bGRldiwKKwkJCQkJICAgdW5z aWduZWQgZ3JvdXAsCisJCQkJCSAgIGNvbnN0IHVuc2lnbmVkICoqcGlucywKKwkJCQkJICAgdW5z aWduZWQgKm51bV9waW5zKQoreworCSpwaW5zID0gYmNtNjMyNjhfZ3JvdXBzW2dyb3VwXS5waW5z OworCSpudW1fcGlucyA9IGJjbTYzMjY4X2dyb3Vwc1tncm91cF0ubnVtX3BpbnM7CisKKwlyZXR1 cm4gMDsKK30KKworc3RhdGljIGludCBiY202MzI2OF9waW5jdHJsX2dldF9mdW5jX2NvdW50KHN0 cnVjdCBwaW5jdHJsX2RldiAqcGN0bGRldikKK3sKKwlyZXR1cm4gQVJSQVlfU0laRShiY202MzI2 OF9mdW5jcyk7Cit9CisKK3N0YXRpYyBjb25zdCBjaGFyICpiY202MzI2OF9waW5jdHJsX2dldF9m dW5jX25hbWUoc3RydWN0IHBpbmN0cmxfZGV2ICpwY3RsZGV2LAorCQkJCQkJICB1bnNpZ25lZCBz ZWxlY3RvcikKK3sKKwlyZXR1cm4gYmNtNjMyNjhfZnVuY3Nbc2VsZWN0b3JdLm5hbWU7Cit9CisK K3N0YXRpYyBpbnQgYmNtNjMyNjhfcGluY3RybF9nZXRfZ3JvdXBzKHN0cnVjdCBwaW5jdHJsX2Rl diAqcGN0bGRldiwKKwkJCQkgICAgICAgdW5zaWduZWQgc2VsZWN0b3IsCisJCQkJICAgICAgIGNv bnN0IGNoYXIgKiBjb25zdCAqKmdyb3VwcywKKwkJCQkgICAgICAgdW5zaWduZWQgKiBjb25zdCBu dW1fZ3JvdXBzKQoreworCSpncm91cHMgPSBiY202MzI2OF9mdW5jc1tzZWxlY3Rvcl0uZ3JvdXBz OworCSpudW1fZ3JvdXBzID0gYmNtNjMyNjhfZnVuY3Nbc2VsZWN0b3JdLm51bV9ncm91cHM7CisK KwlyZXR1cm4gMDsKK30KKworc3RhdGljIHZvaWQgYmNtNjMyNjhfc2V0X2dwaW8oc3RydWN0IGJj bTYzeHhfcGluY3RybCAqcGMsIHVuc2lnbmVkIHBpbikKK3sKKwljb25zdCBzdHJ1Y3QgcGluY3Ry bF9waW5fZGVzYyAqZGVzYyA9ICZiY202MzI2OF9waW5zW3Bpbl07CisJdW5zaWduZWQgaW50IGJh c2Vtb2RlID0gKHVuc2lnbmVkIGxvbmcpIGRlc2MtPmRydl9kYXRhOworCXVuc2lnbmVkIGludCBt YXNrID0gQklUKGJjbTYzeHhfYmFua19waW4ocGluKSk7CisKKwlpZiAoYmFzZW1vZGUpCisJCXJl Z21hcF91cGRhdGVfYml0cyhwYy0+cmVncywgQkNNNjMyNjhfQkFTRU1PREVfUkVHLCBiYXNlbW9k ZSwKKwkJCQkgICAwKTsKKworCWlmIChwaW4gPCBCQ002M1hYX0JBTktfR1BJT1MpIHsKKwkJLyog YmFzZSBtb2RlOiAwID0+IGdwaW8sIDEgPT4gbXV4IGZ1bmN0aW9uICovCisJCXJlZ21hcF91cGRh dGVfYml0cyhwYy0+cmVncywgQkNNNjMyNjhfTU9ERV9SRUcsIG1hc2ssIDApOworCisJCS8qIHBp bnMgMC0yMyBtaWdodCBiZSBtdXhlZCB0byBsZWQgKi8KKwkJaWYgKHBpbiA8IEJDTTYzMjY4X05V TV9MRURTKQorCQkJcmVnbWFwX3VwZGF0ZV9iaXRzKHBjLT5yZWdzLCBCQ002MzI2OF9MRURfUkVH LCBtYXNrLAorCQkJCQkgICAwKTsKKwl9IGVsc2UgaWYgKHBpbiA8IEJDTTYzMjY4X05VTV9HUElP UykgeworCQkvKiBjdHJsIHJlZzogMCA9PiB3aWZpIGZ1bmN0aW9uLCAxID0+IGdwaW8gKi8KKwkJ cmVnbWFwX3VwZGF0ZV9iaXRzKHBjLT5yZWdzLCBCQ002MzI2OF9DVFJMX1JFRywgbWFzaywgbWFz ayk7CisJfQorfQorCitzdGF0aWMgaW50IGJjbTYzMjY4X3BpbmN0cmxfc2V0X211eChzdHJ1Y3Qg cGluY3RybF9kZXYgKnBjdGxkZXYsCisJCQkJICAgIHVuc2lnbmVkIHNlbGVjdG9yLCB1bnNpZ25l ZCBncm91cCkKK3sKKwlzdHJ1Y3QgYmNtNjN4eF9waW5jdHJsICpwYyA9IHBpbmN0cmxfZGV2X2dl dF9kcnZkYXRhKHBjdGxkZXYpOworCWNvbnN0IHN0cnVjdCBiY202MzI2OF9waW5ncm91cCAqcGcg PSAmYmNtNjMyNjhfZ3JvdXBzW2dyb3VwXTsKKwljb25zdCBzdHJ1Y3QgYmNtNjMyNjhfZnVuY3Rp b24gKmYgPSAmYmNtNjMyNjhfZnVuY3Nbc2VsZWN0b3JdOworCXVuc2lnbmVkIGk7CisJdW5zaWdu ZWQgaW50IHJlZzsKKwl1bnNpZ25lZCBpbnQgdmFsLCBtYXNrOworCisJZm9yIChpID0gMDsgaSA8 IHBnLT5udW1fcGluczsgaSsrKQorCQliY202MzI2OF9zZXRfZ3BpbyhwYywgcGctPnBpbnNbaV0p OworCisJc3dpdGNoIChmLT5yZWcpIHsKKwljYXNlIEJDTTYzMjY4X0xFRENUUkw6CisJCXJlZyA9 IEJDTTYzMjY4X0xFRF9SRUc7CisJCW1hc2sgPSBCSVQocGctPnBpbnNbMF0pOworCQl2YWwgPSBC SVQocGctPnBpbnNbMF0pOworCQlicmVhazsKKwljYXNlIEJDTTYzMjY4X01PREU6CisJCXJlZyA9 IEJDTTYzMjY4X01PREVfUkVHOworCQltYXNrID0gQklUKHBnLT5waW5zWzBdKTsKKwkJdmFsID0g QklUKHBnLT5waW5zWzBdKTsKKwkJYnJlYWs7CisJY2FzZSBCQ002MzI2OF9DVFJMOgorCQlyZWcg PSBCQ002MzI2OF9DVFJMX1JFRzsKKwkJbWFzayA9IEJJVChwZy0+cGluc1swXSk7CisJCXZhbCA9 IDA7CisJCWJyZWFrOworCWNhc2UgQkNNNjMyNjhfQkFTRU1PREU6CisJCXJlZyA9IEJDTTYzMjY4 X0JBU0VNT0RFX1JFRzsKKwkJbWFzayA9IGYtPm1hc2s7CisJCXZhbCA9IGYtPm1hc2s7CisJCWJy ZWFrOworCWRlZmF1bHQ6CisJCVdBUk5fT04oMSk7CisJCXJldHVybiAtRUlOVkFMOworCX0KKwor CXJlZ21hcF91cGRhdGVfYml0cyhwYy0+cmVncywgcmVnLCBtYXNrLCB2YWwpOworCisJcmV0dXJu IDA7Cit9CisKK3N0YXRpYyBpbnQgYmNtNjMyNjhfZ3Bpb19yZXF1ZXN0X2VuYWJsZShzdHJ1Y3Qg cGluY3RybF9kZXYgKnBjdGxkZXYsCisJCQkJCXN0cnVjdCBwaW5jdHJsX2dwaW9fcmFuZ2UgKnJh bmdlLAorCQkJCQl1bnNpZ25lZCBvZmZzZXQpCit7CisJc3RydWN0IGJjbTYzeHhfcGluY3RybCAq cGMgPSBwaW5jdHJsX2Rldl9nZXRfZHJ2ZGF0YShwY3RsZGV2KTsKKworCS8qIGRpc2FibGUgYWxs IGZ1bmN0aW9ucyB1c2luZyB0aGlzIHBpbiAqLworCWJjbTYzMjY4X3NldF9ncGlvKHBjLCBvZmZz ZXQpOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBzdHJ1Y3QgcGluY3RybF9vcHMgYmNtNjMy NjhfcGN0bF9vcHMgPSB7CisJLmR0X2ZyZWVfbWFwID0gcGluY3RybF91dGlsc19mcmVlX21hcCwK KwkuZHRfbm9kZV90b19tYXAgPSBwaW5jb25mX2dlbmVyaWNfZHRfbm9kZV90b19tYXBfcGluLAor CS5nZXRfZ3JvdXBfbmFtZSA9IGJjbTYzMjY4X3BpbmN0cmxfZ2V0X2dyb3VwX25hbWUsCisJLmdl dF9ncm91cF9waW5zID0gYmNtNjMyNjhfcGluY3RybF9nZXRfZ3JvdXBfcGlucywKKwkuZ2V0X2dy b3Vwc19jb3VudCA9IGJjbTYzMjY4X3BpbmN0cmxfZ2V0X2dyb3VwX2NvdW50LAorfTsKKworc3Rh dGljIHN0cnVjdCBwaW5tdXhfb3BzIGJjbTYzMjY4X3BteF9vcHMgPSB7CisJLmdldF9mdW5jdGlv bl9ncm91cHMgPSBiY202MzI2OF9waW5jdHJsX2dldF9ncm91cHMsCisJLmdldF9mdW5jdGlvbl9u YW1lID0gYmNtNjMyNjhfcGluY3RybF9nZXRfZnVuY19uYW1lLAorCS5nZXRfZnVuY3Rpb25zX2Nv dW50ID0gYmNtNjMyNjhfcGluY3RybF9nZXRfZnVuY19jb3VudCwKKwkuZ3Bpb19yZXF1ZXN0X2Vu YWJsZSA9IGJjbTYzMjY4X2dwaW9fcmVxdWVzdF9lbmFibGUsCisJLnNldF9tdXggPSBiY202MzI2 OF9waW5jdHJsX3NldF9tdXgsCisJLnN0cmljdCA9IHRydWUsCit9OworCitzdGF0aWMgY29uc3Qg c3RydWN0IGJjbTYzeHhfcGluY3RybF9zb2MgYmNtNjMyNjhfc29jID0geworCS5uZ3Bpb3MgPSBC Q002MzI2OF9OVU1fR1BJT1MsCisJLm5waW5zID0gQVJSQVlfU0laRShiY202MzI2OF9waW5zKSwK KwkucGN0bF9vcHMgPSAmYmNtNjMyNjhfcGN0bF9vcHMsCisJLnBpbnMgPSBiY202MzI2OF9waW5z LAorCS5wbXhfb3BzID0gJmJjbTYzMjY4X3BteF9vcHMsCit9OworCitzdGF0aWMgaW50IGJjbTYz MjY4X3BpbmN0cmxfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKK3sKKwlyZXR1 cm4gYmNtNjN4eF9waW5jdHJsX3Byb2JlKHBkZXYsICZiY202MzI2OF9zb2MsIE5VTEwpOworfQor CitzdGF0aWMgY29uc3Qgc3RydWN0IG9mX2RldmljZV9pZCBiY202MzI2OF9waW5jdHJsX21hdGNo W10gPSB7CisJeyAuY29tcGF0aWJsZSA9ICJicmNtLGJjbTYzMjY4LXBpbmN0cmwiLCB9LAorCXsg Lyogc2VudGluZWwgKi8gfQorfTsKKworc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kcml2ZXIgYmNt NjMyNjhfcGluY3RybF9kcml2ZXIgPSB7CisJLnByb2JlID0gYmNtNjMyNjhfcGluY3RybF9wcm9i ZSwKKwkuZHJpdmVyID0geworCQkubmFtZSA9ICJiY202MzI2OC1waW5jdHJsIiwKKwkJLm9mX21h dGNoX3RhYmxlID0gYmNtNjMyNjhfcGluY3RybF9tYXRjaCwKKwl9LAorfTsKKworYnVpbHRpbl9w bGF0Zm9ybV9kcml2ZXIoYmNtNjMyNjhfcGluY3RybF9kcml2ZXIpOwotLSAKMi4yMC4xCgoKX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KbGludXgtYXJtLWtl cm5lbCBtYWlsaW5nIGxpc3QKbGludXgtYXJtLWtlcm5lbEBsaXN0cy5pbmZyYWRlYWQub3JnCmh0 dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vbGludXgtYXJtLWtlcm5l bAo=