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 961C1C4160E for ; Sat, 6 Mar 2021 15:58:20 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 7A9376501E for ; Sat, 6 Mar 2021 15:58:20 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231221AbhCFP5w (ORCPT ); Sat, 6 Mar 2021 10:57:52 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:50946 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230519AbhCFP5W (ORCPT ); Sat, 6 Mar 2021 10:57:22 -0500 Received: from mail-wm1-x336.google.com (mail-wm1-x336.google.com [IPv6:2a00:1450:4864:20::336]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 61E1FC06174A; Sat, 6 Mar 2021 07:57:22 -0800 (PST) Received: by mail-wm1-x336.google.com with SMTP id n11-20020a05600c4f8bb029010e5cf86347so1671952wmq.1; Sat, 06 Mar 2021 07:57:22 -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=iXfHMuxF/D5CTKC4AWK5GCKKWabCxhs1gEmwkiIOR8Q=; b=FEDVQp/05JHobKS4KiuTwK+bQ4zF8FFdBvBU2LhiDD3wzp6s30WDbR8rZDZJGHpDBm bTuv9DPD2puf3uf+zK/o4WTNCTMpXfYPlul196Ys8xcDUkQKjf/rvd9qhrfSiJLe9Vpi bxO2VImGIwlflT7rBWf6ncbYXNefoX9ZA/azkGxYxNZfjURCngSjPbtBurjmnDTJCYa0 chh+9l7qFNPjG1NUjC5we4ydPTKwUguubClQtrJvGRHmTJHS6VAEPVILUFM8n4Yu3tBh Ki2vT7HsMtH91cZ/agv9JPygRjUVIotvIoNBGYkksavcWcAeOE/DA+LJr5LLMej7xBzC sbfA== 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=iXfHMuxF/D5CTKC4AWK5GCKKWabCxhs1gEmwkiIOR8Q=; b=Xi9kmfsa5PUdlXQNw3kMmsW6YlEvlR+392HZ3ihDVYxM2ldkKJQPP5p6BbgrBK014Q h7yBvufv4mhRpxpDsZadkBp1tJYJwya86EeND3whMCpxGT5kfNMScrixu0zVHNpJLnFX cjOApeZxY6U4Ci3w6F/NFPWnBu4xt3U4AI70tPBaubNsuYKzxsFTKhMtngWbVQg0Mdh8 UfOFG8gh39lP1uhn+jt723FSKFT7nivqOceIv4aui1nPxqfUB4/nJjc1EQ3p+NQA2HDS +fdJcYx4yTo8wQ0m6C0R77gOHbA97EOXXKRwOFyCK/8EoE77C8gMCfMMT4G8tZi+jivs 5P/Q== X-Gm-Message-State: AOAM530+RIkVawTDRnvuc9zatPX7op0EaqXWaERBVmPy1gGI5oBXQ3EC PYcY+VRD+5uym2d9basN11Y= X-Google-Smtp-Source: ABdhPJyE04bS8bBlakAsSy8ZccB1og4M/fNFVF0KPZdwS1qFPHn7Lygwyou2Zs5KFfX6e3d2YUdY3g== X-Received: by 2002:a7b:cb5a:: with SMTP id v26mr14281075wmj.162.1615046241092; Sat, 06 Mar 2021 07:57:21 -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.20 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 06 Mar 2021 07:57:20 -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 09/15] pinctrl: add a pincontrol driver for BCM6362 Date: Sat, 6 Mar 2021 16:57:06 +0100 Message-Id: <20210306155712.4298-10-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 pincotrol driver for BCM6362. BCM6362 allows muxing individual GPIO pins to the LED controller, to be available by the integrated wifi, or other functions. It also supports overlay groups, of which only NAND is documented. 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-bcm6362.c | 617 ++++++++++++++++++++++++++ 3 files changed, 626 insertions(+) create mode 100644 drivers/pinctrl/bcm/pinctrl-bcm6362.c diff --git a/drivers/pinctrl/bcm/Kconfig b/drivers/pinctrl/bcm/Kconfig index ced7cc6ab44f..d3101d5e750f 100644 --- a/drivers/pinctrl/bcm/Kconfig +++ b/drivers/pinctrl/bcm/Kconfig @@ -52,6 +52,14 @@ config PINCTRL_BCM6358 help Say Y here to enable the Broadcom BCM6358 GPIO driver. +config PINCTRL_BCM6362 + bool "Broadcom BCM6362 GPIO driver" + depends on (BMIPS_GENERIC || COMPILE_TEST) + select PINCTRL_BCM63XX + default BMIPS_GENERIC + help + Say Y here to enable the Broadcom BCM6362 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 c3f5b7b2f2f0..b9b09e5b914c 100644 --- a/drivers/pinctrl/bcm/Makefile +++ b/drivers/pinctrl/bcm/Makefile @@ -6,6 +6,7 @@ obj-$(CONFIG_PINCTRL_BCM2835) += pinctrl-bcm2835.o obj-$(CONFIG_PINCTRL_BCM63XX) += pinctrl-bcm63xx.o obj-$(CONFIG_PINCTRL_BCM6328) += pinctrl-bcm6328.o obj-$(CONFIG_PINCTRL_BCM6358) += pinctrl-bcm6358.o +obj-$(CONFIG_PINCTRL_BCM6362) += pinctrl-bcm6362.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-bcm6362.c b/drivers/pinctrl/bcm/pinctrl-bcm6362.c new file mode 100644 index 000000000000..eb7ec80353e9 --- /dev/null +++ b/drivers/pinctrl/bcm/pinctrl-bcm6362.c @@ -0,0 +1,617 @@ +// SPDX-License-Identifier: GPL-2.0+ +/* + * Driver for BCM6362 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 BCM6362_BANK_GPIOS 32 +#define BCM6362_NUM_GPIOS 48 +#define BCM6362_NUM_LEDS 24 + +#define BCM6362_LED_REG 0x10 +#define BCM6362_MODE_REG 0x18 +#define BCM6362_CTRL_REG 0x1c +#define BCM6362_BASEMODE_REG 0x38 +#define BASEMODE_NAND BIT(2) + +enum bcm6362_pinctrl_reg { + BCM6362_LEDCTRL, + BCM6362_MODE, + BCM6362_CTRL, + BCM6362_BASEMODE, +}; + +struct bcm6362_pingroup { + const char *name; + const unsigned * const pins; + const unsigned num_pins; +}; + +struct bcm6362_function { + const char *name; + const char * const *groups; + const unsigned num_groups; + + enum bcm6362_pinctrl_reg reg; + uint32_t basemode_mask; +}; + +#define BCM6362_PIN(a, b, mask) \ + { \ + .number = a, \ + .name = b, \ + .drv_data = (void *)(mask), \ + } + +static const struct pinctrl_pin_desc bcm6362_pins[] = { + PINCTRL_PIN(0, "gpio0"), + PINCTRL_PIN(1, "gpio1"), + PINCTRL_PIN(2, "gpio2"), + PINCTRL_PIN(3, "gpio3"), + PINCTRL_PIN(4, "gpio4"), + PINCTRL_PIN(5, "gpio5"), + PINCTRL_PIN(6, "gpio6"), + PINCTRL_PIN(7, "gpio7"), + BCM6362_PIN(8, "gpio8", BASEMODE_NAND), + PINCTRL_PIN(9, "gpio9"), + PINCTRL_PIN(10, "gpio10"), + PINCTRL_PIN(11, "gpio11"), + BCM6362_PIN(12, "gpio12", BASEMODE_NAND), + BCM6362_PIN(13, "gpio13", BASEMODE_NAND), + BCM6362_PIN(14, "gpio14", BASEMODE_NAND), + BCM6362_PIN(15, "gpio15", BASEMODE_NAND), + BCM6362_PIN(16, "gpio16", BASEMODE_NAND), + BCM6362_PIN(17, "gpio17", BASEMODE_NAND), + BCM6362_PIN(18, "gpio18", BASEMODE_NAND), + BCM6362_PIN(19, "gpio19", BASEMODE_NAND), + BCM6362_PIN(20, "gpio20", BASEMODE_NAND), + BCM6362_PIN(21, "gpio21", BASEMODE_NAND), + BCM6362_PIN(22, "gpio22", BASEMODE_NAND), + BCM6362_PIN(23, "gpio23", BASEMODE_NAND), + PINCTRL_PIN(24, "gpio24"), + PINCTRL_PIN(25, "gpio25"), + PINCTRL_PIN(26, "gpio26"), + BCM6362_PIN(27, "gpio27", BASEMODE_NAND), + PINCTRL_PIN(28, "gpio28"), + PINCTRL_PIN(29, "gpio29"), + PINCTRL_PIN(30, "gpio30"), + PINCTRL_PIN(31, "gpio31"), + 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"), +}; + +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 nand_grp_pins[] = { + 8, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 27, +}; + +#define BCM6362_GROUP(n) \ + { \ + .name = #n, \ + .pins = n##_pins, \ + .num_pins = ARRAY_SIZE(n##_pins), \ + } + +static struct bcm6362_pingroup bcm6362_groups[] = { + BCM6362_GROUP(gpio0), + BCM6362_GROUP(gpio1), + BCM6362_GROUP(gpio2), + BCM6362_GROUP(gpio3), + BCM6362_GROUP(gpio4), + BCM6362_GROUP(gpio5), + BCM6362_GROUP(gpio6), + BCM6362_GROUP(gpio7), + BCM6362_GROUP(gpio8), + BCM6362_GROUP(gpio9), + BCM6362_GROUP(gpio10), + BCM6362_GROUP(gpio11), + BCM6362_GROUP(gpio12), + BCM6362_GROUP(gpio13), + BCM6362_GROUP(gpio14), + BCM6362_GROUP(gpio15), + BCM6362_GROUP(gpio16), + BCM6362_GROUP(gpio17), + BCM6362_GROUP(gpio18), + BCM6362_GROUP(gpio19), + BCM6362_GROUP(gpio20), + BCM6362_GROUP(gpio21), + BCM6362_GROUP(gpio22), + BCM6362_GROUP(gpio23), + BCM6362_GROUP(gpio24), + BCM6362_GROUP(gpio25), + BCM6362_GROUP(gpio26), + BCM6362_GROUP(gpio27), + BCM6362_GROUP(gpio28), + BCM6362_GROUP(gpio29), + BCM6362_GROUP(gpio30), + BCM6362_GROUP(gpio31), + BCM6362_GROUP(gpio32), + BCM6362_GROUP(gpio33), + BCM6362_GROUP(gpio34), + BCM6362_GROUP(gpio35), + BCM6362_GROUP(gpio36), + BCM6362_GROUP(gpio37), + BCM6362_GROUP(gpio38), + BCM6362_GROUP(gpio39), + BCM6362_GROUP(gpio40), + BCM6362_GROUP(gpio41), + BCM6362_GROUP(gpio42), + BCM6362_GROUP(gpio43), + BCM6362_GROUP(gpio44), + BCM6362_GROUP(gpio45), + BCM6362_GROUP(gpio46), + BCM6362_GROUP(gpio47), + BCM6362_GROUP(nand_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 usb_device_led_groups[] = { + "gpio0", +}; + +static const char * const sys_irq_groups[] = { + "gpio1", +}; + +static const char * const serial_led_clk_groups[] = { + "gpio2", +}; + +static const char * const serial_led_data_groups[] = { + "gpio3", +}; + +static const char * const robosw_led_data_groups[] = { + "gpio4", +}; + +static const char * const robosw_led_clk_groups[] = { + "gpio5", +}; + +static const char * const robosw_led0_groups[] = { + "gpio6", +}; + +static const char * const robosw_led1_groups[] = { + "gpio7", +}; + +static const char * const inet_led_groups[] = { + "gpio8", +}; + +static const char * const spi_cs2_groups[] = { + "gpio9", +}; + +static const char * const spi_cs3_groups[] = { + "gpio10", +}; + +static const char * const ntr_pulse_groups[] = { + "gpio11", +}; + +static const char * const uart1_scts_groups[] = { + "gpio12", +}; + +static const char * const uart1_srts_groups[] = { + "gpio13", +}; + +static const char * const uart1_sdin_groups[] = { + "gpio14", +}; + +static const char * const uart1_sdout_groups[] = { + "gpio15", +}; + +static const char * const adsl_spi_miso_groups[] = { + "gpio16", +}; + +static const char * const adsl_spi_mosi_groups[] = { + "gpio17", +}; + +static const char * const adsl_spi_clk_groups[] = { + "gpio18", +}; + +static const char * const adsl_spi_cs_groups[] = { + "gpio19", +}; + +static const char * const ephy0_led_groups[] = { + "gpio20", +}; + +static const char * const ephy1_led_groups[] = { + "gpio21", +}; + +static const char * const ephy2_led_groups[] = { + "gpio22", +}; + +static const char * const ephy3_led_groups[] = { + "gpio23", +}; + +static const char * const ext_irq0_groups[] = { + "gpio24", +}; + +static const char * const ext_irq1_groups[] = { + "gpio25", +}; + +static const char * const ext_irq2_groups[] = { + "gpio26", +}; + +static const char * const ext_irq3_groups[] = { + "gpio27", +}; + +static const char * const wifi_groups[] = { + "gpio32", + "gpio33", + "gpio34", + "gpio35", + "gpio36", + "gpio37", + "gpio38", + "gpio39", + "gpio40", + "gpio41", + "gpio42", + "gpio43", + "gpio44", + "gpio45", + "gpio46", + "gpio47", +}; + +static const char * const nand_groups[] = { + "nand_grp", +}; + +#define BCM6362_LED_FUN(n) \ + { \ + .name = #n, \ + .groups = n##_groups, \ + .num_groups = ARRAY_SIZE(n##_groups), \ + .reg = BCM6362_LEDCTRL, \ + } + +#define BCM6362_MODE_FUN(n) \ + { \ + .name = #n, \ + .groups = n##_groups, \ + .num_groups = ARRAY_SIZE(n##_groups), \ + .reg = BCM6362_MODE, \ + } + +#define BCM6362_CTRL_FUN(n) \ + { \ + .name = #n, \ + .groups = n##_groups, \ + .num_groups = ARRAY_SIZE(n##_groups), \ + .reg = BCM6362_CTRL, \ + } + +#define BCM6362_BASEMODE_FUN(n, mask) \ + { \ + .name = #n, \ + .groups = n##_groups, \ + .num_groups = ARRAY_SIZE(n##_groups), \ + .reg = BCM6362_BASEMODE, \ + .basemode_mask = (mask), \ + } + +static const struct bcm6362_function bcm6362_funcs[] = { + BCM6362_LED_FUN(led), + BCM6362_MODE_FUN(usb_device_led), + BCM6362_MODE_FUN(sys_irq), + BCM6362_MODE_FUN(serial_led_clk), + BCM6362_MODE_FUN(serial_led_data), + BCM6362_MODE_FUN(robosw_led_data), + BCM6362_MODE_FUN(robosw_led_clk), + BCM6362_MODE_FUN(robosw_led0), + BCM6362_MODE_FUN(robosw_led1), + BCM6362_MODE_FUN(inet_led), + BCM6362_MODE_FUN(spi_cs2), + BCM6362_MODE_FUN(spi_cs3), + BCM6362_MODE_FUN(ntr_pulse), + BCM6362_MODE_FUN(uart1_scts), + BCM6362_MODE_FUN(uart1_srts), + BCM6362_MODE_FUN(uart1_sdin), + BCM6362_MODE_FUN(uart1_sdout), + BCM6362_MODE_FUN(adsl_spi_miso), + BCM6362_MODE_FUN(adsl_spi_mosi), + BCM6362_MODE_FUN(adsl_spi_clk), + BCM6362_MODE_FUN(adsl_spi_cs), + BCM6362_MODE_FUN(ephy0_led), + BCM6362_MODE_FUN(ephy1_led), + BCM6362_MODE_FUN(ephy2_led), + BCM6362_MODE_FUN(ephy3_led), + BCM6362_MODE_FUN(ext_irq0), + BCM6362_MODE_FUN(ext_irq1), + BCM6362_MODE_FUN(ext_irq2), + BCM6362_MODE_FUN(ext_irq3), + BCM6362_CTRL_FUN(wifi), + BCM6362_BASEMODE_FUN(nand, BASEMODE_NAND), +}; + +static int bcm6362_pinctrl_get_group_count(struct pinctrl_dev *pctldev) +{ + return ARRAY_SIZE(bcm6362_groups); +} + +static const char *bcm6362_pinctrl_get_group_name(struct pinctrl_dev *pctldev, + unsigned group) +{ + return bcm6362_groups[group].name; +} + +static int bcm6362_pinctrl_get_group_pins(struct pinctrl_dev *pctldev, + unsigned group, const unsigned **pins, + unsigned *num_pins) +{ + *pins = bcm6362_groups[group].pins; + *num_pins = bcm6362_groups[group].num_pins; + + return 0; +} + +static int bcm6362_pinctrl_get_func_count(struct pinctrl_dev *pctldev) +{ + return ARRAY_SIZE(bcm6362_funcs); +} + +static const char *bcm6362_pinctrl_get_func_name(struct pinctrl_dev *pctldev, + unsigned selector) +{ + return bcm6362_funcs[selector].name; +} + +static int bcm6362_pinctrl_get_groups(struct pinctrl_dev *pctldev, + unsigned selector, + const char * const **groups, + unsigned * const num_groups) +{ + *groups = bcm6362_funcs[selector].groups; + *num_groups = bcm6362_funcs[selector].num_groups; + + return 0; +} + +static void bcm6362_set_gpio(struct bcm63xx_pinctrl *pc, unsigned pin) +{ + const struct pinctrl_pin_desc *desc = &bcm6362_pins[pin]; + unsigned int mask = bcm63xx_bank_pin(pin); + + if (desc->drv_data) + regmap_update_bits(pc->regs, BCM6362_BASEMODE_REG, + (uint32_t) desc->drv_data, 0); + + if (pin < BCM63XX_BANK_GPIOS) { + /* base mode 0 => gpio 1 => mux function */ + regmap_update_bits(pc->regs, BCM6362_MODE_REG, mask, 0); + + /* pins 0-23 might be muxed to led */ + if (pin < BCM6362_NUM_LEDS) + regmap_update_bits(pc->regs, BCM6362_LED_REG, mask, 0); + } else { + /* ctrl reg 0 => wifi function 1 => gpio */ + regmap_update_bits(pc->regs, BCM6362_CTRL_REG, mask, mask); + } +} + +static int bcm6362_pinctrl_set_mux(struct pinctrl_dev *pctldev, + unsigned selector, unsigned group) +{ + struct bcm63xx_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev); + const struct bcm6362_pingroup *pg = &bcm6362_groups[group]; + const struct bcm6362_function *f = &bcm6362_funcs[selector]; + unsigned i; + unsigned int reg; + unsigned int val, mask; + + for (i = 0; i < pg->num_pins; i++) + bcm6362_set_gpio(pc, pg->pins[i]); + + switch (f->reg) { + case BCM6362_LEDCTRL: + reg = BCM6362_LED_REG; + mask = BIT(pg->pins[0]); + val = BIT(pg->pins[0]); + break; + case BCM6362_MODE: + reg = BCM6362_MODE_REG; + mask = BIT(pg->pins[0]); + val = BIT(pg->pins[0]); + break; + case BCM6362_CTRL: + reg = BCM6362_CTRL_REG; + mask = BIT(pg->pins[0]); + val = 0; + break; + case BCM6362_BASEMODE: + reg = BCM6362_BASEMODE_REG; + mask = f->basemode_mask; + val = f->basemode_mask; + break; + default: + WARN_ON(1); + return -EINVAL; + } + + regmap_update_bits(pc->regs, reg, mask, val); + + return 0; +} + +static int bcm6362_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 */ + bcm6362_set_gpio(pc, offset); + + return 0; +} + +static struct pinctrl_ops bcm6362_pctl_ops = { + .dt_free_map = pinctrl_utils_free_map, + .dt_node_to_map = pinconf_generic_dt_node_to_map_pin, + .get_group_name = bcm6362_pinctrl_get_group_name, + .get_group_pins = bcm6362_pinctrl_get_group_pins, + .get_groups_count = bcm6362_pinctrl_get_group_count, +}; + +static struct pinmux_ops bcm6362_pmx_ops = { + .get_function_groups = bcm6362_pinctrl_get_groups, + .get_function_name = bcm6362_pinctrl_get_func_name, + .get_functions_count = bcm6362_pinctrl_get_func_count, + .gpio_request_enable = bcm6362_gpio_request_enable, + .set_mux = bcm6362_pinctrl_set_mux, + .strict = true, +}; + +static const struct bcm63xx_pinctrl_soc bcm6362_soc = { + .ngpios = BCM6362_NUM_GPIOS, + .npins = ARRAY_SIZE(bcm6362_pins), + .pctl_ops = &bcm6362_pctl_ops, + .pins = bcm6362_pins, + .pmx_ops = &bcm6362_pmx_ops, +}; + +static int bcm6362_pinctrl_probe(struct platform_device *pdev) +{ + return bcm63xx_pinctrl_probe(pdev, &bcm6362_soc, NULL); +} + +static const struct of_device_id bcm6362_pinctrl_match[] = { + { .compatible = "brcm,bcm6362-pinctrl", }, + { /* sentinel */ } +}; + +static struct platform_driver bcm6362_pinctrl_driver = { + .probe = bcm6362_pinctrl_probe, + .driver = { + .name = "bcm6362-pinctrl", + .of_match_table = bcm6362_pinctrl_match, + }, +}; + +builtin_platform_driver(bcm6362_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 8829BC433E0 for ; Sat, 6 Mar 2021 16:00:18 +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 B47A364FF0 for ; Sat, 6 Mar 2021 16:00:17 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org B47A364FF0 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=XbsTNNuSrSYX/b2l6OjcNNdWnMDKMCgnJW+lCCJzdRM=; b=p6COao9zW9T8RtxlxBD9k+z32 RKvex9zAW3nn2k8YB/bOKPCbGk3tRmc+p6sVpAhUtYVX5zpttZQEwIm+fmui6r0NDDQnJsYOCHmSa F/kBfKfHTKFbz+gQv9MwxcAO/cBKmN3z+oMCdb5XuljSeHr+XavT1AY0t8yWKQiKXKysXFWAVnL+P KjIOZGpZ9KyJOKAo9OI/gkySQpd7bjHWoqxMUjRMDFxeIrxxR6ICJsXShDVlglFHL+kvwQFukgm1l 3JHBs4am5dScjuSe8xXEdZFGO6vw9XoTch8L84eUHD5dreJtvNATBTLdKlQEsgKh3KII4Vmc1P9Ss q1YJn2Pig==; Received: from localhost ([::1] helo=desiato.infradead.org) by desiato.infradead.org with esmtp (Exim 4.94 #2 (Red Hat Linux)) id 1lIZK4-003VIU-BC; Sat, 06 Mar 2021 15:58:32 +0000 Received: from mail-wm1-x334.google.com ([2a00:1450:4864:20::334]) by desiato.infradead.org with esmtps (Exim 4.94 #2 (Red Hat Linux)) id 1lIZIv-003Usw-MM for linux-arm-kernel@lists.infradead.org; Sat, 06 Mar 2021 15:57:26 +0000 Received: by mail-wm1-x334.google.com with SMTP id f22-20020a7bc8d60000b029010c024a1407so1159163wml.2 for ; Sat, 06 Mar 2021 07:57:21 -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=iXfHMuxF/D5CTKC4AWK5GCKKWabCxhs1gEmwkiIOR8Q=; b=FEDVQp/05JHobKS4KiuTwK+bQ4zF8FFdBvBU2LhiDD3wzp6s30WDbR8rZDZJGHpDBm bTuv9DPD2puf3uf+zK/o4WTNCTMpXfYPlul196Ys8xcDUkQKjf/rvd9qhrfSiJLe9Vpi bxO2VImGIwlflT7rBWf6ncbYXNefoX9ZA/azkGxYxNZfjURCngSjPbtBurjmnDTJCYa0 chh+9l7qFNPjG1NUjC5we4ydPTKwUguubClQtrJvGRHmTJHS6VAEPVILUFM8n4Yu3tBh Ki2vT7HsMtH91cZ/agv9JPygRjUVIotvIoNBGYkksavcWcAeOE/DA+LJr5LLMej7xBzC sbfA== 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=iXfHMuxF/D5CTKC4AWK5GCKKWabCxhs1gEmwkiIOR8Q=; b=sid5KZes7485I2yoJ/dCiDF4J715hVPeMzLpSpSGaw3OYhK20DgYkmc8TneyOGH3CJ 35F7NRTXdROf5MYrBLOhu9HRSI1TgkGWIKfJ5j/IGinPqASsqX2QvfJasMGRq+mBdS7k R4WFcEJHx5N2Rhcpe2/2uV+5znEzjA33dIakVUFVBaK3I1LVNG8wFAkNsEvrdg0RLBGR 7qDeD5nz20BJsny3+EDpeTNtEuDch1V157JVs6pSbix0vaFQUnS8/wcBnXu7HMGBA493 7JAsLjE7wZspkg+3d0UTUxPXRWhNzTjJP3yLIwwFuVcieyFY0O7Vxuj6ItcsFTx10Uep sQAA== X-Gm-Message-State: AOAM530oeezSGNFc/UBSYzdZm7SRkH0kZQNxgLvjnVLXa4IOyRjvHYUN ugNuXXoh6+nThWJ2clXvuOA= X-Google-Smtp-Source: ABdhPJyE04bS8bBlakAsSy8ZccB1og4M/fNFVF0KPZdwS1qFPHn7Lygwyou2Zs5KFfX6e3d2YUdY3g== X-Received: by 2002:a7b:cb5a:: with SMTP id v26mr14281075wmj.162.1615046241092; Sat, 06 Mar 2021 07:57:21 -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.20 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 06 Mar 2021 07:57:20 -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 09/15] pinctrl: add a pincontrol driver for BCM6362 Date: Sat, 6 Mar 2021 16:57:06 +0100 Message-Id: <20210306155712.4298-10-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_155721_899604_86004A01 X-CRM114-Status: GOOD ( 17.42 ) 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 QWRkIGEgcGluY290cm9sIGRyaXZlciBmb3IgQkNNNjM2Mi4gQkNNNjM2MiBhbGxvd3MgbXV4aW5n IGluZGl2aWR1YWwKR1BJTyBwaW5zIHRvIHRoZSBMRUQgY29udHJvbGxlciwgdG8gYmUgYXZhaWxh YmxlIGJ5IHRoZSBpbnRlZ3JhdGVkCndpZmksIG9yIG90aGVyIGZ1bmN0aW9ucy4gSXQgYWxzbyBz dXBwb3J0cyBvdmVybGF5IGdyb3Vwcywgb2Ygd2hpY2gKb25seSBOQU5EIGlzIGRvY3VtZW50ZWQu CgpTaWduZWQtb2ZmLWJ5OiBKb25hcyBHb3Jza2kgPGpvbmFzLmdvcnNraUBnbWFpbC5jb20+CkNv LWRldmVsb3BlZC1ieTogSm9uYXMgR29yc2tpIDxqb25hcy5nb3Jza2lAZ21haWwuY29tPgpTaWdu ZWQtb2ZmLWJ5OiDDgWx2YXJvIEZlcm7DoW5kZXogUm9qYXMgPG5vbHRhcmlAZ21haWwuY29tPgot LS0KIHY1OiBhZGQgY2hhbmdlcyBzdWdnZXN0ZWQgYnkgQW5keSBTaGV2Y2hlbmtvCiB2NDogbm8g Y2hhbmdlcwogdjM6IHVzZSBuZXcgc2hhcmVkIGNvZGUKIHYyOiBzd2l0Y2ggdG8gR1BJT19SRUdN QVAKCiBkcml2ZXJzL3BpbmN0cmwvYmNtL0tjb25maWcgICAgICAgICAgIHwgICA4ICsKIGRyaXZl cnMvcGluY3RybC9iY20vTWFrZWZpbGUgICAgICAgICAgfCAgIDEgKwogZHJpdmVycy9waW5jdHJs L2JjbS9waW5jdHJsLWJjbTYzNjIuYyB8IDYxNyArKysrKysrKysrKysrKysrKysrKysrKysrKwog MyBmaWxlcyBjaGFuZ2VkLCA2MjYgaW5zZXJ0aW9ucygrKQogY3JlYXRlIG1vZGUgMTAwNjQ0IGRy aXZlcnMvcGluY3RybC9iY20vcGluY3RybC1iY202MzYyLmMKCmRpZmYgLS1naXQgYS9kcml2ZXJz L3BpbmN0cmwvYmNtL0tjb25maWcgYi9kcml2ZXJzL3BpbmN0cmwvYmNtL0tjb25maWcKaW5kZXgg Y2VkN2NjNmFiNDRmLi5kMzEwMWQ1ZTc1MGYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcGluY3RybC9i Y20vS2NvbmZpZworKysgYi9kcml2ZXJzL3BpbmN0cmwvYmNtL0tjb25maWcKQEAgLTUyLDYgKzUy LDE0IEBAIGNvbmZpZyBQSU5DVFJMX0JDTTYzNTgKIAloZWxwCiAJICAgU2F5IFkgaGVyZSB0byBl bmFibGUgdGhlIEJyb2FkY29tIEJDTTYzNTggR1BJTyBkcml2ZXIuCiAKK2NvbmZpZyBQSU5DVFJM X0JDTTYzNjIKKwlib29sICJCcm9hZGNvbSBCQ002MzYyIEdQSU8gZHJpdmVyIgorCWRlcGVuZHMg b24gKEJNSVBTX0dFTkVSSUMgfHwgQ09NUElMRV9URVNUKQorCXNlbGVjdCBQSU5DVFJMX0JDTTYz WFgKKwlkZWZhdWx0IEJNSVBTX0dFTkVSSUMKKwloZWxwCisJICAgU2F5IFkgaGVyZSB0byBlbmFi bGUgdGhlIEJyb2FkY29tIEJDTTYzNjIgR1BJTyBkcml2ZXIuCisKIGNvbmZpZyBQSU5DVFJMX0lQ Uk9DX0dQSU8KIAlib29sICJCcm9hZGNvbSBpUHJvYyBHUElPICh3aXRoIFBJTkNPTkYpIGRyaXZl ciIKIAlkZXBlbmRzIG9uIE9GX0dQSU8gJiYgKEFSQ0hfQkNNX0lQUk9DIHx8IENPTVBJTEVfVEVT VCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGluY3RybC9iY20vTWFrZWZpbGUgYi9kcml2ZXJzL3Bp bmN0cmwvYmNtL01ha2VmaWxlCmluZGV4IGMzZjViN2IyZjJmMC4uYjliMDllNWI5MTRjIDEwMDY0 NAotLS0gYS9kcml2ZXJzL3BpbmN0cmwvYmNtL01ha2VmaWxlCisrKyBiL2RyaXZlcnMvcGluY3Ry bC9iY20vTWFrZWZpbGUKQEAgLTYsNiArNiw3IEBAIG9iai0kKENPTkZJR19QSU5DVFJMX0JDTTI4 MzUpCQkrPSBwaW5jdHJsLWJjbTI4MzUubwogb2JqLSQoQ09ORklHX1BJTkNUUkxfQkNNNjNYWCkJ CSs9IHBpbmN0cmwtYmNtNjN4eC5vCiBvYmotJChDT05GSUdfUElOQ1RSTF9CQ002MzI4KQkJKz0g cGluY3RybC1iY202MzI4Lm8KIG9iai0kKENPTkZJR19QSU5DVFJMX0JDTTYzNTgpCQkrPSBwaW5j dHJsLWJjbTYzNTgubworb2JqLSQoQ09ORklHX1BJTkNUUkxfQkNNNjM2MikJCSs9IHBpbmN0cmwt YmNtNjM2Mi5vCiBvYmotJChDT05GSUdfUElOQ1RSTF9JUFJPQ19HUElPKQkrPSBwaW5jdHJsLWlw cm9jLWdwaW8ubwogb2JqLSQoQ09ORklHX1BJTkNUUkxfQ1lHTlVTX01VWCkJKz0gcGluY3RybC1j eWdudXMtbXV4Lm8KIG9iai0kKENPTkZJR19QSU5DVFJMX05TKQkJKz0gcGluY3RybC1ucy5vCmRp ZmYgLS1naXQgYS9kcml2ZXJzL3BpbmN0cmwvYmNtL3BpbmN0cmwtYmNtNjM2Mi5jIGIvZHJpdmVy cy9waW5jdHJsL2JjbS9waW5jdHJsLWJjbTYzNjIuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwMDAwMDAuLmViN2VjODAzNTNlOQotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMv cGluY3RybC9iY20vcGluY3RybC1iY202MzYyLmMKQEAgLTAsMCArMSw2MTcgQEAKKy8vIFNQRFgt TGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wKworLyoKKyAqIERyaXZlciBmb3IgQkNNNjM2MiBH UElPIHVuaXQgKHBpbmN0cmwgKyBHUElPKQorICoKKyAqIENvcHlyaWdodCAoQykgMjAyMSDDgWx2 YXJvIEZlcm7DoW5kZXogUm9qYXMgPG5vbHRhcmlAZ21haWwuY29tPgorICogQ29weXJpZ2h0IChD KSAyMDE2IEpvbmFzIEdvcnNraSA8am9uYXMuZ29yc2tpQGdtYWlsLmNvbT4KKyAqLworCisjaW5j bHVkZSA8bGludXgvYml0cy5oPgorI2luY2x1ZGUgPGxpbnV4L2dwaW8vZHJpdmVyLmg+CisjaW5j bHVkZSA8bGludXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgvb2YuaD4KKyNpbmNsdWRlIDxs aW51eC9waW5jdHJsL3Bpbm11eC5oPgorI2luY2x1ZGUgPGxpbnV4L3BsYXRmb3JtX2RldmljZS5o PgorI2luY2x1ZGUgPGxpbnV4L3JlZ21hcC5oPgorCisjaW5jbHVkZSAiLi4vcGluY3RybC11dGls cy5oIgorCisjaW5jbHVkZSAicGluY3RybC1iY202M3h4LmgiCisKKyNkZWZpbmUgQkNNNjM2Ml9C QU5LX0dQSU9TCTMyCisjZGVmaW5lIEJDTTYzNjJfTlVNX0dQSU9TCTQ4CisjZGVmaW5lIEJDTTYz NjJfTlVNX0xFRFMJMjQKKworI2RlZmluZSBCQ002MzYyX0xFRF9SRUcJCTB4MTAKKyNkZWZpbmUg QkNNNjM2Ml9NT0RFX1JFRwkweDE4CisjZGVmaW5lIEJDTTYzNjJfQ1RSTF9SRUcJMHgxYworI2Rl ZmluZSBCQ002MzYyX0JBU0VNT0RFX1JFRwkweDM4CisjZGVmaW5lICBCQVNFTU9ERV9OQU5ECQlC SVQoMikKKworZW51bSBiY202MzYyX3BpbmN0cmxfcmVnIHsKKwlCQ002MzYyX0xFRENUUkwsCisJ QkNNNjM2Ml9NT0RFLAorCUJDTTYzNjJfQ1RSTCwKKwlCQ002MzYyX0JBU0VNT0RFLAorfTsKKwor c3RydWN0IGJjbTYzNjJfcGluZ3JvdXAgeworCWNvbnN0IGNoYXIgKm5hbWU7CisJY29uc3QgdW5z aWduZWQgKiBjb25zdCBwaW5zOworCWNvbnN0IHVuc2lnbmVkIG51bV9waW5zOworfTsKKworc3Ry dWN0IGJjbTYzNjJfZnVuY3Rpb24geworCWNvbnN0IGNoYXIgKm5hbWU7CisJY29uc3QgY2hhciAq IGNvbnN0ICpncm91cHM7CisJY29uc3QgdW5zaWduZWQgbnVtX2dyb3VwczsKKworCWVudW0gYmNt NjM2Ml9waW5jdHJsX3JlZyByZWc7CisJdWludDMyX3QgYmFzZW1vZGVfbWFzazsKK307CisKKyNk ZWZpbmUgQkNNNjM2Ml9QSU4oYSwgYiwgbWFzaykJCQlcCisJewkJCQkJXAorCQkubnVtYmVyID0g YSwJCQlcCisJCS5uYW1lID0gYiwJCQlcCisJCS5kcnZfZGF0YSA9ICh2b2lkICopKG1hc2spLAlc CisJfQorCitzdGF0aWMgY29uc3Qgc3RydWN0IHBpbmN0cmxfcGluX2Rlc2MgYmNtNjM2Ml9waW5z W10gPSB7CisJUElOQ1RSTF9QSU4oMCwgImdwaW8wIiksCisJUElOQ1RSTF9QSU4oMSwgImdwaW8x IiksCisJUElOQ1RSTF9QSU4oMiwgImdwaW8yIiksCisJUElOQ1RSTF9QSU4oMywgImdwaW8zIiks CisJUElOQ1RSTF9QSU4oNCwgImdwaW80IiksCisJUElOQ1RSTF9QSU4oNSwgImdwaW81IiksCisJ UElOQ1RSTF9QSU4oNiwgImdwaW82IiksCisJUElOQ1RSTF9QSU4oNywgImdwaW83IiksCisJQkNN NjM2Ml9QSU4oOCwgImdwaW84IiwgQkFTRU1PREVfTkFORCksCisJUElOQ1RSTF9QSU4oOSwgImdw aW85IiksCisJUElOQ1RSTF9QSU4oMTAsICJncGlvMTAiKSwKKwlQSU5DVFJMX1BJTigxMSwgImdw aW8xMSIpLAorCUJDTTYzNjJfUElOKDEyLCAiZ3BpbzEyIiwgQkFTRU1PREVfTkFORCksCisJQkNN NjM2Ml9QSU4oMTMsICJncGlvMTMiLCBCQVNFTU9ERV9OQU5EKSwKKwlCQ002MzYyX1BJTigxNCwg ImdwaW8xNCIsIEJBU0VNT0RFX05BTkQpLAorCUJDTTYzNjJfUElOKDE1LCAiZ3BpbzE1IiwgQkFT RU1PREVfTkFORCksCisJQkNNNjM2Ml9QSU4oMTYsICJncGlvMTYiLCBCQVNFTU9ERV9OQU5EKSwK KwlCQ002MzYyX1BJTigxNywgImdwaW8xNyIsIEJBU0VNT0RFX05BTkQpLAorCUJDTTYzNjJfUElO KDE4LCAiZ3BpbzE4IiwgQkFTRU1PREVfTkFORCksCisJQkNNNjM2Ml9QSU4oMTksICJncGlvMTki LCBCQVNFTU9ERV9OQU5EKSwKKwlCQ002MzYyX1BJTigyMCwgImdwaW8yMCIsIEJBU0VNT0RFX05B TkQpLAorCUJDTTYzNjJfUElOKDIxLCAiZ3BpbzIxIiwgQkFTRU1PREVfTkFORCksCisJQkNNNjM2 Ml9QSU4oMjIsICJncGlvMjIiLCBCQVNFTU9ERV9OQU5EKSwKKwlCQ002MzYyX1BJTigyMywgImdw aW8yMyIsIEJBU0VNT0RFX05BTkQpLAorCVBJTkNUUkxfUElOKDI0LCAiZ3BpbzI0IiksCisJUElO Q1RSTF9QSU4oMjUsICJncGlvMjUiKSwKKwlQSU5DVFJMX1BJTigyNiwgImdwaW8yNiIpLAorCUJD TTYzNjJfUElOKDI3LCAiZ3BpbzI3IiwgQkFTRU1PREVfTkFORCksCisJUElOQ1RSTF9QSU4oMjgs ICJncGlvMjgiKSwKKwlQSU5DVFJMX1BJTigyOSwgImdwaW8yOSIpLAorCVBJTkNUUkxfUElOKDMw LCAiZ3BpbzMwIiksCisJUElOQ1RSTF9QSU4oMzEsICJncGlvMzEiKSwKKwlQSU5DVFJMX1BJTigz MiwgImdwaW8zMiIpLAorCVBJTkNUUkxfUElOKDMzLCAiZ3BpbzMzIiksCisJUElOQ1RSTF9QSU4o MzQsICJncGlvMzQiKSwKKwlQSU5DVFJMX1BJTigzNSwgImdwaW8zNSIpLAorCVBJTkNUUkxfUElO KDM2LCAiZ3BpbzM2IiksCisJUElOQ1RSTF9QSU4oMzcsICJncGlvMzciKSwKKwlQSU5DVFJMX1BJ TigzOCwgImdwaW8zOCIpLAorCVBJTkNUUkxfUElOKDM5LCAiZ3BpbzM5IiksCisJUElOQ1RSTF9Q SU4oNDAsICJncGlvNDAiKSwKKwlQSU5DVFJMX1BJTig0MSwgImdwaW80MSIpLAorCVBJTkNUUkxf UElOKDQyLCAiZ3BpbzQyIiksCisJUElOQ1RSTF9QSU4oNDMsICJncGlvNDMiKSwKKwlQSU5DVFJM X1BJTig0NCwgImdwaW80NCIpLAorCVBJTkNUUkxfUElOKDQ1LCAiZ3BpbzQ1IiksCisJUElOQ1RS TF9QSU4oNDYsICJncGlvNDYiKSwKKwlQSU5DVFJMX1BJTig0NywgImdwaW80NyIpLAorfTsKKwor c3RhdGljIHVuc2lnbmVkIGdwaW8wX3BpbnNbXSA9IHsgMCB9Oworc3RhdGljIHVuc2lnbmVkIGdw aW8xX3BpbnNbXSA9IHsgMSB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8yX3BpbnNbXSA9IHsgMiB9 Oworc3RhdGljIHVuc2lnbmVkIGdwaW8zX3BpbnNbXSA9IHsgMyB9Oworc3RhdGljIHVuc2lnbmVk IGdwaW80X3BpbnNbXSA9IHsgNCB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW81X3BpbnNbXSA9IHsg NSB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW82X3BpbnNbXSA9IHsgNiB9Oworc3RhdGljIHVuc2ln bmVkIGdwaW83X3BpbnNbXSA9IHsgNyB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW84X3BpbnNbXSA9 IHsgOCB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW85X3BpbnNbXSA9IHsgOSB9Oworc3RhdGljIHVu c2lnbmVkIGdwaW8xMF9waW5zW10gPSB7IDEwIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzExX3Bp bnNbXSA9IHsgMTEgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMTJfcGluc1tdID0geyAxMiB9Owor c3RhdGljIHVuc2lnbmVkIGdwaW8xM19waW5zW10gPSB7IDEzIH07CitzdGF0aWMgdW5zaWduZWQg Z3BpbzE0X3BpbnNbXSA9IHsgMTQgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMTVfcGluc1tdID0g eyAxNSB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8xNl9waW5zW10gPSB7IDE2IH07CitzdGF0aWMg dW5zaWduZWQgZ3BpbzE3X3BpbnNbXSA9IHsgMTcgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMThf cGluc1tdID0geyAxOCB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8xOV9waW5zW10gPSB7IDE5IH07 CitzdGF0aWMgdW5zaWduZWQgZ3BpbzIwX3BpbnNbXSA9IHsgMjAgfTsKK3N0YXRpYyB1bnNpZ25l ZCBncGlvMjFfcGluc1tdID0geyAyMSB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8yMl9waW5zW10g PSB7IDIyIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzIzX3BpbnNbXSA9IHsgMjMgfTsKK3N0YXRp YyB1bnNpZ25lZCBncGlvMjRfcGluc1tdID0geyAyNCB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8y NV9waW5zW10gPSB7IDI1IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzI2X3BpbnNbXSA9IHsgMjYg fTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMjdfcGluc1tdID0geyAyNyB9Oworc3RhdGljIHVuc2ln bmVkIGdwaW8yOF9waW5zW10gPSB7IDI4IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzI5X3BpbnNb XSA9IHsgMjkgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMzBfcGluc1tdID0geyAzMCB9Oworc3Rh dGljIHVuc2lnbmVkIGdwaW8zMV9waW5zW10gPSB7IDMxIH07CitzdGF0aWMgdW5zaWduZWQgZ3Bp bzMyX3BpbnNbXSA9IHsgMzIgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMzNfcGluc1tdID0geyAz MyB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8zNF9waW5zW10gPSB7IDM0IH07CitzdGF0aWMgdW5z aWduZWQgZ3BpbzM1X3BpbnNbXSA9IHsgMzUgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMzZfcGlu c1tdID0geyAzNiB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8zN19waW5zW10gPSB7IDM3IH07Citz dGF0aWMgdW5zaWduZWQgZ3BpbzM4X3BpbnNbXSA9IHsgMzggfTsKK3N0YXRpYyB1bnNpZ25lZCBn cGlvMzlfcGluc1tdID0geyAzOSB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW80MF9waW5zW10gPSB7 IDQwIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzQxX3BpbnNbXSA9IHsgNDEgfTsKK3N0YXRpYyB1 bnNpZ25lZCBncGlvNDJfcGluc1tdID0geyA0MiB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW80M19w aW5zW10gPSB7IDQzIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzQ0X3BpbnNbXSA9IHsgNDQgfTsK K3N0YXRpYyB1bnNpZ25lZCBncGlvNDVfcGluc1tdID0geyA0NSB9Oworc3RhdGljIHVuc2lnbmVk IGdwaW80Nl9waW5zW10gPSB7IDQ2IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzQ3X3BpbnNbXSA9 IHsgNDcgfTsKKworc3RhdGljIHVuc2lnbmVkIG5hbmRfZ3JwX3BpbnNbXSA9IHsKKwk4LCAxMiwg MTMsIDE0LCAxNSwgMTYsIDE3LAorCTE4LCAxOSwgMjAsIDIxLCAyMiwgMjMsIDI3LAorfTsKKwor I2RlZmluZSBCQ002MzYyX0dST1VQKG4pCQkJCVwKKwl7CQkJCQkJXAorCQkubmFtZSA9ICNuLAkJ CQlcCisJCS5waW5zID0gbiMjX3BpbnMsCQkJXAorCQkubnVtX3BpbnMgPSBBUlJBWV9TSVpFKG4j I19waW5zKSwJXAorCX0KKworc3RhdGljIHN0cnVjdCBiY202MzYyX3Bpbmdyb3VwIGJjbTYzNjJf Z3JvdXBzW10gPSB7CisJQkNNNjM2Ml9HUk9VUChncGlvMCksCisJQkNNNjM2Ml9HUk9VUChncGlv MSksCisJQkNNNjM2Ml9HUk9VUChncGlvMiksCisJQkNNNjM2Ml9HUk9VUChncGlvMyksCisJQkNN NjM2Ml9HUk9VUChncGlvNCksCisJQkNNNjM2Ml9HUk9VUChncGlvNSksCisJQkNNNjM2Ml9HUk9V UChncGlvNiksCisJQkNNNjM2Ml9HUk9VUChncGlvNyksCisJQkNNNjM2Ml9HUk9VUChncGlvOCks CisJQkNNNjM2Ml9HUk9VUChncGlvOSksCisJQkNNNjM2Ml9HUk9VUChncGlvMTApLAorCUJDTTYz NjJfR1JPVVAoZ3BpbzExKSwKKwlCQ002MzYyX0dST1VQKGdwaW8xMiksCisJQkNNNjM2Ml9HUk9V UChncGlvMTMpLAorCUJDTTYzNjJfR1JPVVAoZ3BpbzE0KSwKKwlCQ002MzYyX0dST1VQKGdwaW8x NSksCisJQkNNNjM2Ml9HUk9VUChncGlvMTYpLAorCUJDTTYzNjJfR1JPVVAoZ3BpbzE3KSwKKwlC Q002MzYyX0dST1VQKGdwaW8xOCksCisJQkNNNjM2Ml9HUk9VUChncGlvMTkpLAorCUJDTTYzNjJf R1JPVVAoZ3BpbzIwKSwKKwlCQ002MzYyX0dST1VQKGdwaW8yMSksCisJQkNNNjM2Ml9HUk9VUChn cGlvMjIpLAorCUJDTTYzNjJfR1JPVVAoZ3BpbzIzKSwKKwlCQ002MzYyX0dST1VQKGdwaW8yNCks CisJQkNNNjM2Ml9HUk9VUChncGlvMjUpLAorCUJDTTYzNjJfR1JPVVAoZ3BpbzI2KSwKKwlCQ002 MzYyX0dST1VQKGdwaW8yNyksCisJQkNNNjM2Ml9HUk9VUChncGlvMjgpLAorCUJDTTYzNjJfR1JP VVAoZ3BpbzI5KSwKKwlCQ002MzYyX0dST1VQKGdwaW8zMCksCisJQkNNNjM2Ml9HUk9VUChncGlv MzEpLAorCUJDTTYzNjJfR1JPVVAoZ3BpbzMyKSwKKwlCQ002MzYyX0dST1VQKGdwaW8zMyksCisJ QkNNNjM2Ml9HUk9VUChncGlvMzQpLAorCUJDTTYzNjJfR1JPVVAoZ3BpbzM1KSwKKwlCQ002MzYy X0dST1VQKGdwaW8zNiksCisJQkNNNjM2Ml9HUk9VUChncGlvMzcpLAorCUJDTTYzNjJfR1JPVVAo Z3BpbzM4KSwKKwlCQ002MzYyX0dST1VQKGdwaW8zOSksCisJQkNNNjM2Ml9HUk9VUChncGlvNDAp LAorCUJDTTYzNjJfR1JPVVAoZ3BpbzQxKSwKKwlCQ002MzYyX0dST1VQKGdwaW80MiksCisJQkNN NjM2Ml9HUk9VUChncGlvNDMpLAorCUJDTTYzNjJfR1JPVVAoZ3BpbzQ0KSwKKwlCQ002MzYyX0dS T1VQKGdwaW80NSksCisJQkNNNjM2Ml9HUk9VUChncGlvNDYpLAorCUJDTTYzNjJfR1JPVVAoZ3Bp bzQ3KSwKKwlCQ002MzYyX0dST1VQKG5hbmRfZ3JwKSwKK307CisKK3N0YXRpYyBjb25zdCBjaGFy ICogY29uc3QgbGVkX2dyb3Vwc1tdID0geworCSJncGlvMCIsCisJImdwaW8xIiwKKwkiZ3BpbzIi LAorCSJncGlvMyIsCisJImdwaW80IiwKKwkiZ3BpbzUiLAorCSJncGlvNiIsCisJImdwaW83IiwK KwkiZ3BpbzgiLAorCSJncGlvOSIsCisJImdwaW8xMCIsCisJImdwaW8xMSIsCisJImdwaW8xMiIs CisJImdwaW8xMyIsCisJImdwaW8xNCIsCisJImdwaW8xNSIsCisJImdwaW8xNiIsCisJImdwaW8x NyIsCisJImdwaW8xOCIsCisJImdwaW8xOSIsCisJImdwaW8yMCIsCisJImdwaW8yMSIsCisJImdw aW8yMiIsCisJImdwaW8yMyIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHVzYl9k ZXZpY2VfbGVkX2dyb3Vwc1tdID0geworCSJncGlvMCIsCit9OworCitzdGF0aWMgY29uc3QgY2hh ciAqIGNvbnN0IHN5c19pcnFfZ3JvdXBzW10gPSB7CisJImdwaW8xIiwKK307CisKK3N0YXRpYyBj b25zdCBjaGFyICogY29uc3Qgc2VyaWFsX2xlZF9jbGtfZ3JvdXBzW10gPSB7CisJImdwaW8yIiwK K307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3Qgc2VyaWFsX2xlZF9kYXRhX2dyb3Vwc1td ID0geworCSJncGlvMyIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHJvYm9zd19s ZWRfZGF0YV9ncm91cHNbXSA9IHsKKwkiZ3BpbzQiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIg KiBjb25zdCByb2Jvc3dfbGVkX2Nsa19ncm91cHNbXSA9IHsKKwkiZ3BpbzUiLAorfTsKKworc3Rh dGljIGNvbnN0IGNoYXIgKiBjb25zdCByb2Jvc3dfbGVkMF9ncm91cHNbXSA9IHsKKwkiZ3BpbzYi LAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCByb2Jvc3dfbGVkMV9ncm91cHNbXSA9 IHsKKwkiZ3BpbzciLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBpbmV0X2xlZF9n cm91cHNbXSA9IHsKKwkiZ3BpbzgiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBz cGlfY3MyX2dyb3Vwc1tdID0geworCSJncGlvOSIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAq IGNvbnN0IHNwaV9jczNfZ3JvdXBzW10gPSB7CisJImdwaW8xMCIsCit9OworCitzdGF0aWMgY29u c3QgY2hhciAqIGNvbnN0IG50cl9wdWxzZV9ncm91cHNbXSA9IHsKKwkiZ3BpbzExIiwKK307CisK K3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgdWFydDFfc2N0c19ncm91cHNbXSA9IHsKKwkiZ3Bp bzEyIiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgdWFydDFfc3J0c19ncm91cHNb XSA9IHsKKwkiZ3BpbzEzIiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgdWFydDFf c2Rpbl9ncm91cHNbXSA9IHsKKwkiZ3BpbzE0IiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICog Y29uc3QgdWFydDFfc2RvdXRfZ3JvdXBzW10gPSB7CisJImdwaW8xNSIsCit9OworCitzdGF0aWMg Y29uc3QgY2hhciAqIGNvbnN0IGFkc2xfc3BpX21pc29fZ3JvdXBzW10gPSB7CisJImdwaW8xNiIs Cit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGFkc2xfc3BpX21vc2lfZ3JvdXBzW10g PSB7CisJImdwaW8xNyIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGFkc2xfc3Bp X2Nsa19ncm91cHNbXSA9IHsKKwkiZ3BpbzE4IiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICog Y29uc3QgYWRzbF9zcGlfY3NfZ3JvdXBzW10gPSB7CisJImdwaW8xOSIsCit9OworCitzdGF0aWMg Y29uc3QgY2hhciAqIGNvbnN0IGVwaHkwX2xlZF9ncm91cHNbXSA9IHsKKwkiZ3BpbzIwIiwKK307 CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgZXBoeTFfbGVkX2dyb3Vwc1tdID0geworCSJn cGlvMjEiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBlcGh5Ml9sZWRfZ3JvdXBz W10gPSB7CisJImdwaW8yMiIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGVwaHkz X2xlZF9ncm91cHNbXSA9IHsKKwkiZ3BpbzIzIiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICog Y29uc3QgZXh0X2lycTBfZ3JvdXBzW10gPSB7CisJImdwaW8yNCIsCit9OworCitzdGF0aWMgY29u c3QgY2hhciAqIGNvbnN0IGV4dF9pcnExX2dyb3Vwc1tdID0geworCSJncGlvMjUiLAorfTsKKwor c3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBleHRfaXJxMl9ncm91cHNbXSA9IHsKKwkiZ3BpbzI2 IiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgZXh0X2lycTNfZ3JvdXBzW10gPSB7 CisJImdwaW8yNyIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHdpZmlfZ3JvdXBz W10gPSB7CisJImdwaW8zMiIsCisJImdwaW8zMyIsCisJImdwaW8zNCIsCisJImdwaW8zNSIsCisJ ImdwaW8zNiIsCisJImdwaW8zNyIsCisJImdwaW8zOCIsCisJImdwaW8zOSIsCisJImdwaW80MCIs CisJImdwaW80MSIsCisJImdwaW80MiIsCisJImdwaW80MyIsCisJImdwaW80NCIsCisJImdwaW80 NSIsCisJImdwaW80NiIsCisJImdwaW80NyIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNv bnN0IG5hbmRfZ3JvdXBzW10gPSB7CisJIm5hbmRfZ3JwIiwKK307CisKKyNkZWZpbmUgQkNNNjM2 Ml9MRURfRlVOKG4pCQkJCVwKKwl7CQkJCQkJXAorCQkubmFtZSA9ICNuLAkJCQlcCisJCS5ncm91 cHMgPSBuIyNfZ3JvdXBzLAkJCVwKKwkJLm51bV9ncm91cHMgPSBBUlJBWV9TSVpFKG4jI19ncm91 cHMpLAlcCisJCS5yZWcgPSBCQ002MzYyX0xFRENUUkwsCQkJXAorCX0KKworI2RlZmluZSBCQ002 MzYyX01PREVfRlVOKG4pCQkJCVwKKwl7CQkJCQkJXAorCQkubmFtZSA9ICNuLAkJCQlcCisJCS5n cm91cHMgPSBuIyNfZ3JvdXBzLAkJCVwKKwkJLm51bV9ncm91cHMgPSBBUlJBWV9TSVpFKG4jI19n cm91cHMpLAlcCisJCS5yZWcgPSBCQ002MzYyX01PREUsCQkJXAorCX0KKworI2RlZmluZSBCQ002 MzYyX0NUUkxfRlVOKG4pCQkJCVwKKwl7CQkJCQkJXAorCQkubmFtZSA9ICNuLAkJCQlcCisJCS5n cm91cHMgPSBuIyNfZ3JvdXBzLAkJCVwKKwkJLm51bV9ncm91cHMgPSBBUlJBWV9TSVpFKG4jI19n cm91cHMpLAlcCisJCS5yZWcgPSBCQ002MzYyX0NUUkwsCQkJXAorCX0KKworI2RlZmluZSBCQ002 MzYyX0JBU0VNT0RFX0ZVTihuLCBtYXNrKQkJCVwKKwl7CQkJCQkJXAorCQkubmFtZSA9ICNuLAkJ CQlcCisJCS5ncm91cHMgPSBuIyNfZ3JvdXBzLAkJCVwKKwkJLm51bV9ncm91cHMgPSBBUlJBWV9T SVpFKG4jI19ncm91cHMpLAlcCisJCS5yZWcgPSBCQ002MzYyX0JBU0VNT0RFLAkJXAorCQkuYmFz ZW1vZGVfbWFzayA9IChtYXNrKSwJCVwKKwl9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgYmNtNjM2 Ml9mdW5jdGlvbiBiY202MzYyX2Z1bmNzW10gPSB7CisJQkNNNjM2Ml9MRURfRlVOKGxlZCksCisJ QkNNNjM2Ml9NT0RFX0ZVTih1c2JfZGV2aWNlX2xlZCksCisJQkNNNjM2Ml9NT0RFX0ZVTihzeXNf aXJxKSwKKwlCQ002MzYyX01PREVfRlVOKHNlcmlhbF9sZWRfY2xrKSwKKwlCQ002MzYyX01PREVf RlVOKHNlcmlhbF9sZWRfZGF0YSksCisJQkNNNjM2Ml9NT0RFX0ZVTihyb2Jvc3dfbGVkX2RhdGEp LAorCUJDTTYzNjJfTU9ERV9GVU4ocm9ib3N3X2xlZF9jbGspLAorCUJDTTYzNjJfTU9ERV9GVU4o cm9ib3N3X2xlZDApLAorCUJDTTYzNjJfTU9ERV9GVU4ocm9ib3N3X2xlZDEpLAorCUJDTTYzNjJf TU9ERV9GVU4oaW5ldF9sZWQpLAorCUJDTTYzNjJfTU9ERV9GVU4oc3BpX2NzMiksCisJQkNNNjM2 Ml9NT0RFX0ZVTihzcGlfY3MzKSwKKwlCQ002MzYyX01PREVfRlVOKG50cl9wdWxzZSksCisJQkNN NjM2Ml9NT0RFX0ZVTih1YXJ0MV9zY3RzKSwKKwlCQ002MzYyX01PREVfRlVOKHVhcnQxX3NydHMp LAorCUJDTTYzNjJfTU9ERV9GVU4odWFydDFfc2RpbiksCisJQkNNNjM2Ml9NT0RFX0ZVTih1YXJ0 MV9zZG91dCksCisJQkNNNjM2Ml9NT0RFX0ZVTihhZHNsX3NwaV9taXNvKSwKKwlCQ002MzYyX01P REVfRlVOKGFkc2xfc3BpX21vc2kpLAorCUJDTTYzNjJfTU9ERV9GVU4oYWRzbF9zcGlfY2xrKSwK KwlCQ002MzYyX01PREVfRlVOKGFkc2xfc3BpX2NzKSwKKwlCQ002MzYyX01PREVfRlVOKGVwaHkw X2xlZCksCisJQkNNNjM2Ml9NT0RFX0ZVTihlcGh5MV9sZWQpLAorCUJDTTYzNjJfTU9ERV9GVU4o ZXBoeTJfbGVkKSwKKwlCQ002MzYyX01PREVfRlVOKGVwaHkzX2xlZCksCisJQkNNNjM2Ml9NT0RF X0ZVTihleHRfaXJxMCksCisJQkNNNjM2Ml9NT0RFX0ZVTihleHRfaXJxMSksCisJQkNNNjM2Ml9N T0RFX0ZVTihleHRfaXJxMiksCisJQkNNNjM2Ml9NT0RFX0ZVTihleHRfaXJxMyksCisJQkNNNjM2 Ml9DVFJMX0ZVTih3aWZpKSwKKwlCQ002MzYyX0JBU0VNT0RFX0ZVTihuYW5kLCBCQVNFTU9ERV9O QU5EKSwKK307CisKK3N0YXRpYyBpbnQgYmNtNjM2Ml9waW5jdHJsX2dldF9ncm91cF9jb3VudChz dHJ1Y3QgcGluY3RybF9kZXYgKnBjdGxkZXYpCit7CisJcmV0dXJuIEFSUkFZX1NJWkUoYmNtNjM2 Ml9ncm91cHMpOworfQorCitzdGF0aWMgY29uc3QgY2hhciAqYmNtNjM2Ml9waW5jdHJsX2dldF9n cm91cF9uYW1lKHN0cnVjdCBwaW5jdHJsX2RldiAqcGN0bGRldiwKKwkJCQkJCSAgdW5zaWduZWQg Z3JvdXApCit7CisJcmV0dXJuIGJjbTYzNjJfZ3JvdXBzW2dyb3VwXS5uYW1lOworfQorCitzdGF0 aWMgaW50IGJjbTYzNjJfcGluY3RybF9nZXRfZ3JvdXBfcGlucyhzdHJ1Y3QgcGluY3RybF9kZXYg KnBjdGxkZXYsCisJCQkJCSAgdW5zaWduZWQgZ3JvdXAsIGNvbnN0IHVuc2lnbmVkICoqcGlucywK KwkJCQkJICB1bnNpZ25lZCAqbnVtX3BpbnMpCit7CisJKnBpbnMgPSBiY202MzYyX2dyb3Vwc1tn cm91cF0ucGluczsKKwkqbnVtX3BpbnMgPSBiY202MzYyX2dyb3Vwc1tncm91cF0ubnVtX3BpbnM7 CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBiY202MzYyX3BpbmN0cmxfZ2V0X2Z1bmNf Y291bnQoc3RydWN0IHBpbmN0cmxfZGV2ICpwY3RsZGV2KQoreworCXJldHVybiBBUlJBWV9TSVpF KGJjbTYzNjJfZnVuY3MpOworfQorCitzdGF0aWMgY29uc3QgY2hhciAqYmNtNjM2Ml9waW5jdHJs X2dldF9mdW5jX25hbWUoc3RydWN0IHBpbmN0cmxfZGV2ICpwY3RsZGV2LAorCQkJCQkJIHVuc2ln bmVkIHNlbGVjdG9yKQoreworCXJldHVybiBiY202MzYyX2Z1bmNzW3NlbGVjdG9yXS5uYW1lOwor fQorCitzdGF0aWMgaW50IGJjbTYzNjJfcGluY3RybF9nZXRfZ3JvdXBzKHN0cnVjdCBwaW5jdHJs X2RldiAqcGN0bGRldiwKKwkJCQkgICAgICB1bnNpZ25lZCBzZWxlY3RvciwKKwkJCQkgICAgICBj b25zdCBjaGFyICogY29uc3QgKipncm91cHMsCisJCQkJICAgICAgdW5zaWduZWQgKiBjb25zdCBu dW1fZ3JvdXBzKQoreworCSpncm91cHMgPSBiY202MzYyX2Z1bmNzW3NlbGVjdG9yXS5ncm91cHM7 CisJKm51bV9ncm91cHMgPSBiY202MzYyX2Z1bmNzW3NlbGVjdG9yXS5udW1fZ3JvdXBzOworCisJ cmV0dXJuIDA7Cit9CisKK3N0YXRpYyB2b2lkIGJjbTYzNjJfc2V0X2dwaW8oc3RydWN0IGJjbTYz eHhfcGluY3RybCAqcGMsIHVuc2lnbmVkIHBpbikKK3sKKwljb25zdCBzdHJ1Y3QgcGluY3RybF9w aW5fZGVzYyAqZGVzYyA9ICZiY202MzYyX3BpbnNbcGluXTsKKwl1bnNpZ25lZCBpbnQgbWFzayA9 IGJjbTYzeHhfYmFua19waW4ocGluKTsKKworCWlmIChkZXNjLT5kcnZfZGF0YSkKKwkJcmVnbWFw X3VwZGF0ZV9iaXRzKHBjLT5yZWdzLCBCQ002MzYyX0JBU0VNT0RFX1JFRywKKwkJCQkgICAodWlu dDMyX3QpIGRlc2MtPmRydl9kYXRhLCAwKTsKKworCWlmIChwaW4gPCBCQ002M1hYX0JBTktfR1BJ T1MpIHsKKwkJLyogYmFzZSBtb2RlIDAgPT4gZ3BpbyAxID0+IG11eCBmdW5jdGlvbiAqLworCQly ZWdtYXBfdXBkYXRlX2JpdHMocGMtPnJlZ3MsIEJDTTYzNjJfTU9ERV9SRUcsIG1hc2ssIDApOwor CisJCS8qIHBpbnMgMC0yMyBtaWdodCBiZSBtdXhlZCB0byBsZWQgKi8KKwkJaWYgKHBpbiA8IEJD TTYzNjJfTlVNX0xFRFMpCisJCQlyZWdtYXBfdXBkYXRlX2JpdHMocGMtPnJlZ3MsIEJDTTYzNjJf TEVEX1JFRywgbWFzaywgMCk7CisJfSBlbHNlIHsKKwkJLyogY3RybCByZWcgMCA9PiB3aWZpIGZ1 bmN0aW9uIDEgPT4gZ3BpbyAqLworCQlyZWdtYXBfdXBkYXRlX2JpdHMocGMtPnJlZ3MsIEJDTTYz NjJfQ1RSTF9SRUcsIG1hc2ssIG1hc2spOworCX0KK30KKworc3RhdGljIGludCBiY202MzYyX3Bp bmN0cmxfc2V0X211eChzdHJ1Y3QgcGluY3RybF9kZXYgKnBjdGxkZXYsCisJCQkJICAgdW5zaWdu ZWQgc2VsZWN0b3IsIHVuc2lnbmVkIGdyb3VwKQoreworCXN0cnVjdCBiY202M3h4X3BpbmN0cmwg KnBjID0gcGluY3RybF9kZXZfZ2V0X2RydmRhdGEocGN0bGRldik7CisJY29uc3Qgc3RydWN0IGJj bTYzNjJfcGluZ3JvdXAgKnBnID0gJmJjbTYzNjJfZ3JvdXBzW2dyb3VwXTsKKwljb25zdCBzdHJ1 Y3QgYmNtNjM2Ml9mdW5jdGlvbiAqZiA9ICZiY202MzYyX2Z1bmNzW3NlbGVjdG9yXTsKKwl1bnNp Z25lZCBpOworCXVuc2lnbmVkIGludCByZWc7CisJdW5zaWduZWQgaW50IHZhbCwgbWFzazsKKwor CWZvciAoaSA9IDA7IGkgPCBwZy0+bnVtX3BpbnM7IGkrKykKKwkJYmNtNjM2Ml9zZXRfZ3Bpbyhw YywgcGctPnBpbnNbaV0pOworCisJc3dpdGNoIChmLT5yZWcpIHsKKwljYXNlIEJDTTYzNjJfTEVE Q1RSTDoKKwkJcmVnID0gQkNNNjM2Ml9MRURfUkVHOworCQltYXNrID0gQklUKHBnLT5waW5zWzBd KTsKKwkJdmFsID0gQklUKHBnLT5waW5zWzBdKTsKKwkJYnJlYWs7CisJY2FzZSBCQ002MzYyX01P REU6CisJCXJlZyA9IEJDTTYzNjJfTU9ERV9SRUc7CisJCW1hc2sgPSBCSVQocGctPnBpbnNbMF0p OworCQl2YWwgPSBCSVQocGctPnBpbnNbMF0pOworCQlicmVhazsKKwljYXNlIEJDTTYzNjJfQ1RS TDoKKwkJcmVnID0gQkNNNjM2Ml9DVFJMX1JFRzsKKwkJbWFzayA9IEJJVChwZy0+cGluc1swXSk7 CisJCXZhbCA9IDA7CisJCWJyZWFrOworCWNhc2UgQkNNNjM2Ml9CQVNFTU9ERToKKwkJcmVnID0g QkNNNjM2Ml9CQVNFTU9ERV9SRUc7CisJCW1hc2sgPSBmLT5iYXNlbW9kZV9tYXNrOworCQl2YWwg PSBmLT5iYXNlbW9kZV9tYXNrOworCQlicmVhazsKKwlkZWZhdWx0OgorCQlXQVJOX09OKDEpOwor CQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKKwlyZWdtYXBfdXBkYXRlX2JpdHMocGMtPnJlZ3MsIHJl ZywgbWFzaywgdmFsKTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IGJjbTYzNjJfZ3Bp b19yZXF1ZXN0X2VuYWJsZShzdHJ1Y3QgcGluY3RybF9kZXYgKnBjdGxkZXYsCisJCQkJICAgICAg IHN0cnVjdCBwaW5jdHJsX2dwaW9fcmFuZ2UgKnJhbmdlLAorCQkJCSAgICAgICB1bnNpZ25lZCBv ZmZzZXQpCit7CisJc3RydWN0IGJjbTYzeHhfcGluY3RybCAqcGMgPSBwaW5jdHJsX2Rldl9nZXRf ZHJ2ZGF0YShwY3RsZGV2KTsKKworCS8qIGRpc2FibGUgYWxsIGZ1bmN0aW9ucyB1c2luZyB0aGlz IHBpbiAqLworCWJjbTYzNjJfc2V0X2dwaW8ocGMsIG9mZnNldCk7CisKKwlyZXR1cm4gMDsKK30K Kworc3RhdGljIHN0cnVjdCBwaW5jdHJsX29wcyBiY202MzYyX3BjdGxfb3BzID0geworCS5kdF9m cmVlX21hcCA9IHBpbmN0cmxfdXRpbHNfZnJlZV9tYXAsCisJLmR0X25vZGVfdG9fbWFwID0gcGlu Y29uZl9nZW5lcmljX2R0X25vZGVfdG9fbWFwX3BpbiwKKwkuZ2V0X2dyb3VwX25hbWUgPSBiY202 MzYyX3BpbmN0cmxfZ2V0X2dyb3VwX25hbWUsCisJLmdldF9ncm91cF9waW5zID0gYmNtNjM2Ml9w aW5jdHJsX2dldF9ncm91cF9waW5zLAorCS5nZXRfZ3JvdXBzX2NvdW50ID0gYmNtNjM2Ml9waW5j dHJsX2dldF9ncm91cF9jb3VudCwKK307CisKK3N0YXRpYyBzdHJ1Y3QgcGlubXV4X29wcyBiY202 MzYyX3BteF9vcHMgPSB7CisJLmdldF9mdW5jdGlvbl9ncm91cHMgPSBiY202MzYyX3BpbmN0cmxf Z2V0X2dyb3VwcywKKwkuZ2V0X2Z1bmN0aW9uX25hbWUgPSBiY202MzYyX3BpbmN0cmxfZ2V0X2Z1 bmNfbmFtZSwKKwkuZ2V0X2Z1bmN0aW9uc19jb3VudCA9IGJjbTYzNjJfcGluY3RybF9nZXRfZnVu Y19jb3VudCwKKwkuZ3Bpb19yZXF1ZXN0X2VuYWJsZSA9IGJjbTYzNjJfZ3Bpb19yZXF1ZXN0X2Vu YWJsZSwKKwkuc2V0X211eCA9IGJjbTYzNjJfcGluY3RybF9zZXRfbXV4LAorCS5zdHJpY3QgPSB0 cnVlLAorfTsKKworc3RhdGljIGNvbnN0IHN0cnVjdCBiY202M3h4X3BpbmN0cmxfc29jIGJjbTYz NjJfc29jID0geworCS5uZ3Bpb3MgPSBCQ002MzYyX05VTV9HUElPUywKKwkubnBpbnMgPSBBUlJB WV9TSVpFKGJjbTYzNjJfcGlucyksCisJLnBjdGxfb3BzID0gJmJjbTYzNjJfcGN0bF9vcHMsCisJ LnBpbnMgPSBiY202MzYyX3BpbnMsCisJLnBteF9vcHMgPSAmYmNtNjM2Ml9wbXhfb3BzLAorfTsK Kworc3RhdGljIGludCBiY202MzYyX3BpbmN0cmxfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2Rldmlj ZSAqcGRldikKK3sKKwlyZXR1cm4gYmNtNjN4eF9waW5jdHJsX3Byb2JlKHBkZXYsICZiY202MzYy X3NvYywgTlVMTCk7Cit9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgb2ZfZGV2aWNlX2lkIGJjbTYz NjJfcGluY3RybF9tYXRjaFtdID0geworCXsgLmNvbXBhdGlibGUgPSAiYnJjbSxiY202MzYyLXBp bmN0cmwiLCB9LAorCXsgLyogc2VudGluZWwgKi8gfQorfTsKKworc3RhdGljIHN0cnVjdCBwbGF0 Zm9ybV9kcml2ZXIgYmNtNjM2Ml9waW5jdHJsX2RyaXZlciA9IHsKKwkucHJvYmUgPSBiY202MzYy X3BpbmN0cmxfcHJvYmUsCisJLmRyaXZlciA9IHsKKwkJLm5hbWUgPSAiYmNtNjM2Mi1waW5jdHJs IiwKKwkJLm9mX21hdGNoX3RhYmxlID0gYmNtNjM2Ml9waW5jdHJsX21hdGNoLAorCX0sCit9Owor CitidWlsdGluX3BsYXRmb3JtX2RyaXZlcihiY202MzYyX3BpbmN0cmxfZHJpdmVyKTsKLS0gCjIu MjAuMQoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmxp bnV4LWFybS1rZXJuZWwgbWFpbGluZyBsaXN0CmxpbnV4LWFybS1rZXJuZWxAbGlzdHMuaW5mcmFk ZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4 LWFybS1rZXJuZWwK