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 18748C432C3 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 BD37264F3E for ; Wed, 17 Mar 2021 14:39:23 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232114AbhCQOi5 (ORCPT ); Wed, 17 Mar 2021 10:38:57 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57060 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231923AbhCQOiT (ORCPT ); Wed, 17 Mar 2021 10:38:19 -0400 Received: from mail-wr1-x436.google.com (mail-wr1-x436.google.com [IPv6:2a00:1450:4864:20::436]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 08109C061762; Wed, 17 Mar 2021 07:38:19 -0700 (PDT) Received: by mail-wr1-x436.google.com with SMTP id x13so2074886wrs.9; Wed, 17 Mar 2021 07:38:18 -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=DacWKpKW+X87OnFBUmSMoGRhi8/nc3rLNa3jHgj6QhY=; b=YX0pcRTEUWHAMpIuO7GCVX4EPosgec0d5CcrG7z/L7StdwvwcgVnEcga5fz8aTCYsk Qn1lDS+q3ypQaGhv90+dRXVaunZtkni3v7k8g+7LPZp/2SP7FYOOwE+cBocgu3PFdUie vR/IaCWxZBn2C8RTTAoPzTRNIZmbQkpzC6jGwJWiXgMWvXa6AOz5sA4KniH79lM481Mz rdvlcp4I7XKq9cxsVgZLvf1UFebnh4Y0PERGj4v6LU6dvfIL5q2XSm+G2nc9lTtqA1Zh 2s32E0vQMzSgnIrulgECb3fWxGuXuKyGoWDLXnKk32dY7IDfVrGpyCoUYVBgoSnVbucc LZMA== 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=DacWKpKW+X87OnFBUmSMoGRhi8/nc3rLNa3jHgj6QhY=; b=LxvdtsEqwHX7VfrxN1GQIVub+vSXxfDvVCqg6J3dA9UK0FLWwsv/Ux2u5Q+zJCKVn9 KNJomP12yKkc+hCosrG8bQHR3fA4iXWYQ1Cjj3UZUYlgBphu+JHVE0cH8tdpWhQADUGd uVoyUQj0ZkCODnJEaeKFyd+6VRYtdDfnMQACnMqH9r77BNes6DjzItUkdiq0KpOC4x4R gVDjjCZKvSnZIxuxKrmgyH2yy+fiz3G+ec03b/nOYgeMPRRgiQGIExB3k44jooRMXcnW KuB+ymbh4QEsLTLTz9DEhPjPrSH0zY0OBtX8JRp7T5ISpLYJJ/ogkODmcZ/W27y/NFJr zXag== X-Gm-Message-State: AOAM532Xx3yOQ/XplnCp4ZKPg8O5BdtVvq3MW6a+7lQPaK/C3HZpT7MX PDgdiBwOgm503aufqYi97f4= X-Google-Smtp-Source: ABdhPJzi66z89vBO4pmJDM4O8TGjAO4GIwL4Jp3mbMAKm3L5bYkamb4SDiSQl/tvSRWL51E5jNLrrQ== X-Received: by 2002:adf:e54a:: with SMTP id z10mr4765970wrm.87.1615991897664; Wed, 17 Mar 2021 07:38:17 -0700 (PDT) Received: from skynet.lan ([80.31.204.166]) by smtp.gmail.com with ESMTPSA id a75sm2518948wme.10.2021.03.17.07.38.16 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 17 Mar 2021 07:38:17 -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 13/22] pinctrl: add a pincontrol driver for BCM6362 Date: Wed, 17 Mar 2021 15:37:54 +0100 Message-Id: <20210317143803.26127-14-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 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. 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-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,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 51FBDC433DB for ; Wed, 17 Mar 2021 14:42:58 +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 2ACE764F3E for ; Wed, 17 Mar 2021 14:42:57 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 2ACE764F3E 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=Nzns4icr3y0Ie3bYQXZ8MJwgIUpTqFeoYGSfDnQffcw=; b=aTjOBtuAZDO8Myq0tQXBZAva2 407T7JdSVwRgOHtcB/5yaVnhlAHu9zGDYP6RYoqCnWs0I+EFW2UliogmTG5CUXt67nrHNIJ2fyd4J i8AB7Y6hxeo2zgghCDtxZy8dRr/Qs4FDz9cufpx9WQ4BbKGmlXUxDkrT93MMy0xR5ytbZLs+hxbH6 1MY1UOFGjNQsIZrdyv9DUzIhIq+w1VHikrCf1JRm7KbkfopA824c8qi8FogJM7UHXd3RyaW9Sj/rb wk5HzkThU4/H1VQozMKhxqVkRm3+7FDF0Naw6aL+3osTpr3e+8IpCz9pPtyRm/HOT7/q65E9GikXY UOWdWMw5A==; Received: from localhost ([::1] helo=desiato.infradead.org) by desiato.infradead.org with esmtp (Exim 4.94 #2 (Red Hat Linux)) id 1lMXM2-003Img-BF; Wed, 17 Mar 2021 14:40:59 +0000 Received: from mail-wr1-x431.google.com ([2a00:1450:4864:20::431]) by desiato.infradead.org with esmtps (Exim 4.94 #2 (Red Hat Linux)) id 1lMXJS-003Hf4-B3 for linux-arm-kernel@lists.infradead.org; Wed, 17 Mar 2021 14:38:21 +0000 Received: by mail-wr1-x431.google.com with SMTP id o16so2089097wrn.0 for ; Wed, 17 Mar 2021 07:38:18 -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=DacWKpKW+X87OnFBUmSMoGRhi8/nc3rLNa3jHgj6QhY=; b=YX0pcRTEUWHAMpIuO7GCVX4EPosgec0d5CcrG7z/L7StdwvwcgVnEcga5fz8aTCYsk Qn1lDS+q3ypQaGhv90+dRXVaunZtkni3v7k8g+7LPZp/2SP7FYOOwE+cBocgu3PFdUie vR/IaCWxZBn2C8RTTAoPzTRNIZmbQkpzC6jGwJWiXgMWvXa6AOz5sA4KniH79lM481Mz rdvlcp4I7XKq9cxsVgZLvf1UFebnh4Y0PERGj4v6LU6dvfIL5q2XSm+G2nc9lTtqA1Zh 2s32E0vQMzSgnIrulgECb3fWxGuXuKyGoWDLXnKk32dY7IDfVrGpyCoUYVBgoSnVbucc LZMA== 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=DacWKpKW+X87OnFBUmSMoGRhi8/nc3rLNa3jHgj6QhY=; b=ViHAWJTiAzIr78peAx5iwcNOc7NrsBoQwoe5NukVKauTuTj782THHmmf01z6f7D2W3 NcLlnCRJ47uoY2k6Zl7IcIHdcC+fOlW450ZNNx4uMwKxZi8Y6xzyjv5BJDGIt99fTcPd JYolKCom8MZ3X0+jCidgcj/WoVHYLNpuhNU7/CLkJjaFnXZyA1sno28Ug7/OUZSUZ2yC JwCnv4I4xIYHRDFtdOQOz4bKknSppIYDR66ZWAzUWEoQ7PbZhEOdJCs+jhLAuDteyRMD 4Bnm3Bp2M7/P3TiRUpTnG5dLWZMXKOjKQEDJmly8lVzJJXU8UOCB2f+QKPyiAvpQjQHZ yLDw== X-Gm-Message-State: AOAM531txG9dvZURLg0Ziu0RcaSUf5ywuUDODVi1RVRuvs5gy4lK0ipx I6Mljj0s3hrxaam7IF+lN5U= X-Google-Smtp-Source: ABdhPJzi66z89vBO4pmJDM4O8TGjAO4GIwL4Jp3mbMAKm3L5bYkamb4SDiSQl/tvSRWL51E5jNLrrQ== X-Received: by 2002:adf:e54a:: with SMTP id z10mr4765970wrm.87.1615991897664; Wed, 17 Mar 2021 07:38:17 -0700 (PDT) Received: from skynet.lan ([80.31.204.166]) by smtp.gmail.com with ESMTPSA id a75sm2518948wme.10.2021.03.17.07.38.16 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 17 Mar 2021 07:38:17 -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 13/22] pinctrl: add a pincontrol driver for BCM6362 Date: Wed, 17 Mar 2021 15:37:54 +0100 Message-Id: <20210317143803.26127-14-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_143818_441259_160931E7 X-CRM114-Status: GOOD ( 17.58 ) 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 CgpDby1kZXZlbG9wZWQtYnk6IEpvbmFzIEdvcnNraSA8am9uYXMuZ29yc2tpQGdtYWlsLmNvbT4K U2lnbmVkLW9mZi1ieTogSm9uYXMgR29yc2tpIDxqb25hcy5nb3Jza2lAZ21haWwuY29tPgpTaWdu ZWQtb2ZmLWJ5OiDDgWx2YXJvIEZlcm7DoW5kZXogUm9qYXMgPG5vbHRhcmlAZ21haWwuY29tPgot LS0KIHY4OiBubyBjaGFuZ2VzCiB2Nzogbm8gY2hhbmdlcwogdjY6IG5vIGNoYW5nZXMKIHY1OiBh ZGQgY2hhbmdlcyBzdWdnZXN0ZWQgYnkgQW5keSBTaGV2Y2hlbmtvCiB2NDogbm8gY2hhbmdlcwog djM6IHVzZSBuZXcgc2hhcmVkIGNvZGUKIHYyOiBzd2l0Y2ggdG8gR1BJT19SRUdNQVAKCiBkcml2 ZXJzL3BpbmN0cmwvYmNtL0tjb25maWcgICAgICAgICAgIHwgICA4ICsKIGRyaXZlcnMvcGluY3Ry bC9iY20vTWFrZWZpbGUgICAgICAgICAgfCAgIDEgKwogZHJpdmVycy9waW5jdHJsL2JjbS9waW5j dHJsLWJjbTYzNjIuYyB8IDYxNyArKysrKysrKysrKysrKysrKysrKysrKysrKwogMyBmaWxlcyBj aGFuZ2VkLCA2MjYgaW5zZXJ0aW9ucygrKQogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvcGlu Y3RybC9iY20vcGluY3RybC1iY202MzYyLmMKCmRpZmYgLS1naXQgYS9kcml2ZXJzL3BpbmN0cmwv YmNtL0tjb25maWcgYi9kcml2ZXJzL3BpbmN0cmwvYmNtL0tjb25maWcKaW5kZXggY2VkN2NjNmFi NDRmLi5kMzEwMWQ1ZTc1MGYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcGluY3RybC9iY20vS2NvbmZp ZworKysgYi9kcml2ZXJzL3BpbmN0cmwvYmNtL0tjb25maWcKQEAgLTUyLDYgKzUyLDE0IEBAIGNv bmZpZyBQSU5DVFJMX0JDTTYzNTgKIAloZWxwCiAJICAgU2F5IFkgaGVyZSB0byBlbmFibGUgdGhl IEJyb2FkY29tIEJDTTYzNTggR1BJTyBkcml2ZXIuCiAKK2NvbmZpZyBQSU5DVFJMX0JDTTYzNjIK Kwlib29sICJCcm9hZGNvbSBCQ002MzYyIEdQSU8gZHJpdmVyIgorCWRlcGVuZHMgb24gKEJNSVBT X0dFTkVSSUMgfHwgQ09NUElMRV9URVNUKQorCXNlbGVjdCBQSU5DVFJMX0JDTTYzWFgKKwlkZWZh dWx0IEJNSVBTX0dFTkVSSUMKKwloZWxwCisJICAgU2F5IFkgaGVyZSB0byBlbmFibGUgdGhlIEJy b2FkY29tIEJDTTYzNjIgR1BJTyBkcml2ZXIuCisKIGNvbmZpZyBQSU5DVFJMX0lQUk9DX0dQSU8K IAlib29sICJCcm9hZGNvbSBpUHJvYyBHUElPICh3aXRoIFBJTkNPTkYpIGRyaXZlciIKIAlkZXBl bmRzIG9uIE9GX0dQSU8gJiYgKEFSQ0hfQkNNX0lQUk9DIHx8IENPTVBJTEVfVEVTVCkKZGlmZiAt LWdpdCBhL2RyaXZlcnMvcGluY3RybC9iY20vTWFrZWZpbGUgYi9kcml2ZXJzL3BpbmN0cmwvYmNt L01ha2VmaWxlCmluZGV4IGMzZjViN2IyZjJmMC4uYjliMDllNWI5MTRjIDEwMDY0NAotLS0gYS9k cml2ZXJzL3BpbmN0cmwvYmNtL01ha2VmaWxlCisrKyBiL2RyaXZlcnMvcGluY3RybC9iY20vTWFr ZWZpbGUKQEAgLTYsNiArNiw3IEBAIG9iai0kKENPTkZJR19QSU5DVFJMX0JDTTI4MzUpCQkrPSBw aW5jdHJsLWJjbTI4MzUubwogb2JqLSQoQ09ORklHX1BJTkNUUkxfQkNNNjNYWCkJCSs9IHBpbmN0 cmwtYmNtNjN4eC5vCiBvYmotJChDT05GSUdfUElOQ1RSTF9CQ002MzI4KQkJKz0gcGluY3RybC1i Y202MzI4Lm8KIG9iai0kKENPTkZJR19QSU5DVFJMX0JDTTYzNTgpCQkrPSBwaW5jdHJsLWJjbTYz NTgubworb2JqLSQoQ09ORklHX1BJTkNUUkxfQkNNNjM2MikJCSs9IHBpbmN0cmwtYmNtNjM2Mi5v CiBvYmotJChDT05GSUdfUElOQ1RSTF9JUFJPQ19HUElPKQkrPSBwaW5jdHJsLWlwcm9jLWdwaW8u bwogb2JqLSQoQ09ORklHX1BJTkNUUkxfQ1lHTlVTX01VWCkJKz0gcGluY3RybC1jeWdudXMtbXV4 Lm8KIG9iai0kKENPTkZJR19QSU5DVFJMX05TKQkJKz0gcGluY3RybC1ucy5vCmRpZmYgLS1naXQg YS9kcml2ZXJzL3BpbmN0cmwvYmNtL3BpbmN0cmwtYmNtNjM2Mi5jIGIvZHJpdmVycy9waW5jdHJs L2JjbS9waW5jdHJsLWJjbTYzNjIuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw MDAwMDAuLmViN2VjODAzNTNlOQotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvcGluY3RybC9i Y20vcGluY3RybC1iY202MzYyLmMKQEAgLTAsMCArMSw2MTcgQEAKKy8vIFNQRFgtTGljZW5zZS1J ZGVudGlmaWVyOiBHUEwtMi4wKworLyoKKyAqIERyaXZlciBmb3IgQkNNNjM2MiBHUElPIHVuaXQg KHBpbmN0cmwgKyBHUElPKQorICoKKyAqIENvcHlyaWdodCAoQykgMjAyMSDDgWx2YXJvIEZlcm7D oW5kZXogUm9qYXMgPG5vbHRhcmlAZ21haWwuY29tPgorICogQ29weXJpZ2h0IChDKSAyMDE2IEpv bmFzIEdvcnNraSA8am9uYXMuZ29yc2tpQGdtYWlsLmNvbT4KKyAqLworCisjaW5jbHVkZSA8bGlu dXgvYml0cy5oPgorI2luY2x1ZGUgPGxpbnV4L2dwaW8vZHJpdmVyLmg+CisjaW5jbHVkZSA8bGlu dXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgvb2YuaD4KKyNpbmNsdWRlIDxsaW51eC9waW5j dHJsL3Bpbm11eC5oPgorI2luY2x1ZGUgPGxpbnV4L3BsYXRmb3JtX2RldmljZS5oPgorI2luY2x1 ZGUgPGxpbnV4L3JlZ21hcC5oPgorCisjaW5jbHVkZSAiLi4vcGluY3RybC11dGlscy5oIgorCisj aW5jbHVkZSAicGluY3RybC1iY202M3h4LmgiCisKKyNkZWZpbmUgQkNNNjM2Ml9CQU5LX0dQSU9T CTMyCisjZGVmaW5lIEJDTTYzNjJfTlVNX0dQSU9TCTQ4CisjZGVmaW5lIEJDTTYzNjJfTlVNX0xF RFMJMjQKKworI2RlZmluZSBCQ002MzYyX0xFRF9SRUcJCTB4MTAKKyNkZWZpbmUgQkNNNjM2Ml9N T0RFX1JFRwkweDE4CisjZGVmaW5lIEJDTTYzNjJfQ1RSTF9SRUcJMHgxYworI2RlZmluZSBCQ002 MzYyX0JBU0VNT0RFX1JFRwkweDM4CisjZGVmaW5lICBCQVNFTU9ERV9OQU5ECQlCSVQoMikKKwor ZW51bSBiY202MzYyX3BpbmN0cmxfcmVnIHsKKwlCQ002MzYyX0xFRENUUkwsCisJQkNNNjM2Ml9N T0RFLAorCUJDTTYzNjJfQ1RSTCwKKwlCQ002MzYyX0JBU0VNT0RFLAorfTsKKworc3RydWN0IGJj bTYzNjJfcGluZ3JvdXAgeworCWNvbnN0IGNoYXIgKm5hbWU7CisJY29uc3QgdW5zaWduZWQgKiBj b25zdCBwaW5zOworCWNvbnN0IHVuc2lnbmVkIG51bV9waW5zOworfTsKKworc3RydWN0IGJjbTYz NjJfZnVuY3Rpb24geworCWNvbnN0IGNoYXIgKm5hbWU7CisJY29uc3QgY2hhciAqIGNvbnN0ICpn cm91cHM7CisJY29uc3QgdW5zaWduZWQgbnVtX2dyb3VwczsKKworCWVudW0gYmNtNjM2Ml9waW5j dHJsX3JlZyByZWc7CisJdWludDMyX3QgYmFzZW1vZGVfbWFzazsKK307CisKKyNkZWZpbmUgQkNN NjM2Ml9QSU4oYSwgYiwgbWFzaykJCQlcCisJewkJCQkJXAorCQkubnVtYmVyID0gYSwJCQlcCisJ CS5uYW1lID0gYiwJCQlcCisJCS5kcnZfZGF0YSA9ICh2b2lkICopKG1hc2spLAlcCisJfQorCitz dGF0aWMgY29uc3Qgc3RydWN0IHBpbmN0cmxfcGluX2Rlc2MgYmNtNjM2Ml9waW5zW10gPSB7CisJ UElOQ1RSTF9QSU4oMCwgImdwaW8wIiksCisJUElOQ1RSTF9QSU4oMSwgImdwaW8xIiksCisJUElO Q1RSTF9QSU4oMiwgImdwaW8yIiksCisJUElOQ1RSTF9QSU4oMywgImdwaW8zIiksCisJUElOQ1RS TF9QSU4oNCwgImdwaW80IiksCisJUElOQ1RSTF9QSU4oNSwgImdwaW81IiksCisJUElOQ1RSTF9Q SU4oNiwgImdwaW82IiksCisJUElOQ1RSTF9QSU4oNywgImdwaW83IiksCisJQkNNNjM2Ml9QSU4o OCwgImdwaW84IiwgQkFTRU1PREVfTkFORCksCisJUElOQ1RSTF9QSU4oOSwgImdwaW85IiksCisJ UElOQ1RSTF9QSU4oMTAsICJncGlvMTAiKSwKKwlQSU5DVFJMX1BJTigxMSwgImdwaW8xMSIpLAor CUJDTTYzNjJfUElOKDEyLCAiZ3BpbzEyIiwgQkFTRU1PREVfTkFORCksCisJQkNNNjM2Ml9QSU4o MTMsICJncGlvMTMiLCBCQVNFTU9ERV9OQU5EKSwKKwlCQ002MzYyX1BJTigxNCwgImdwaW8xNCIs IEJBU0VNT0RFX05BTkQpLAorCUJDTTYzNjJfUElOKDE1LCAiZ3BpbzE1IiwgQkFTRU1PREVfTkFO RCksCisJQkNNNjM2Ml9QSU4oMTYsICJncGlvMTYiLCBCQVNFTU9ERV9OQU5EKSwKKwlCQ002MzYy X1BJTigxNywgImdwaW8xNyIsIEJBU0VNT0RFX05BTkQpLAorCUJDTTYzNjJfUElOKDE4LCAiZ3Bp bzE4IiwgQkFTRU1PREVfTkFORCksCisJQkNNNjM2Ml9QSU4oMTksICJncGlvMTkiLCBCQVNFTU9E RV9OQU5EKSwKKwlCQ002MzYyX1BJTigyMCwgImdwaW8yMCIsIEJBU0VNT0RFX05BTkQpLAorCUJD TTYzNjJfUElOKDIxLCAiZ3BpbzIxIiwgQkFTRU1PREVfTkFORCksCisJQkNNNjM2Ml9QSU4oMjIs ICJncGlvMjIiLCBCQVNFTU9ERV9OQU5EKSwKKwlCQ002MzYyX1BJTigyMywgImdwaW8yMyIsIEJB U0VNT0RFX05BTkQpLAorCVBJTkNUUkxfUElOKDI0LCAiZ3BpbzI0IiksCisJUElOQ1RSTF9QSU4o MjUsICJncGlvMjUiKSwKKwlQSU5DVFJMX1BJTigyNiwgImdwaW8yNiIpLAorCUJDTTYzNjJfUElO KDI3LCAiZ3BpbzI3IiwgQkFTRU1PREVfTkFORCksCisJUElOQ1RSTF9QSU4oMjgsICJncGlvMjgi KSwKKwlQSU5DVFJMX1BJTigyOSwgImdwaW8yOSIpLAorCVBJTkNUUkxfUElOKDMwLCAiZ3BpbzMw IiksCisJUElOQ1RSTF9QSU4oMzEsICJncGlvMzEiKSwKKwlQSU5DVFJMX1BJTigzMiwgImdwaW8z MiIpLAorCVBJTkNUUkxfUElOKDMzLCAiZ3BpbzMzIiksCisJUElOQ1RSTF9QSU4oMzQsICJncGlv MzQiKSwKKwlQSU5DVFJMX1BJTigzNSwgImdwaW8zNSIpLAorCVBJTkNUUkxfUElOKDM2LCAiZ3Bp bzM2IiksCisJUElOQ1RSTF9QSU4oMzcsICJncGlvMzciKSwKKwlQSU5DVFJMX1BJTigzOCwgImdw aW8zOCIpLAorCVBJTkNUUkxfUElOKDM5LCAiZ3BpbzM5IiksCisJUElOQ1RSTF9QSU4oNDAsICJn cGlvNDAiKSwKKwlQSU5DVFJMX1BJTig0MSwgImdwaW80MSIpLAorCVBJTkNUUkxfUElOKDQyLCAi Z3BpbzQyIiksCisJUElOQ1RSTF9QSU4oNDMsICJncGlvNDMiKSwKKwlQSU5DVFJMX1BJTig0NCwg ImdwaW80NCIpLAorCVBJTkNUUkxfUElOKDQ1LCAiZ3BpbzQ1IiksCisJUElOQ1RSTF9QSU4oNDYs ICJncGlvNDYiKSwKKwlQSU5DVFJMX1BJTig0NywgImdwaW80NyIpLAorfTsKKworc3RhdGljIHVu c2lnbmVkIGdwaW8wX3BpbnNbXSA9IHsgMCB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8xX3BpbnNb XSA9IHsgMSB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8yX3BpbnNbXSA9IHsgMiB9Oworc3RhdGlj IHVuc2lnbmVkIGdwaW8zX3BpbnNbXSA9IHsgMyB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW80X3Bp bnNbXSA9IHsgNCB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW81X3BpbnNbXSA9IHsgNSB9Oworc3Rh dGljIHVuc2lnbmVkIGdwaW82X3BpbnNbXSA9IHsgNiB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW83 X3BpbnNbXSA9IHsgNyB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW84X3BpbnNbXSA9IHsgOCB9Owor c3RhdGljIHVuc2lnbmVkIGdwaW85X3BpbnNbXSA9IHsgOSB9Oworc3RhdGljIHVuc2lnbmVkIGdw aW8xMF9waW5zW10gPSB7IDEwIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzExX3BpbnNbXSA9IHsg MTEgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMTJfcGluc1tdID0geyAxMiB9Oworc3RhdGljIHVu c2lnbmVkIGdwaW8xM19waW5zW10gPSB7IDEzIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzE0X3Bp bnNbXSA9IHsgMTQgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMTVfcGluc1tdID0geyAxNSB9Owor c3RhdGljIHVuc2lnbmVkIGdwaW8xNl9waW5zW10gPSB7IDE2IH07CitzdGF0aWMgdW5zaWduZWQg Z3BpbzE3X3BpbnNbXSA9IHsgMTcgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMThfcGluc1tdID0g eyAxOCB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8xOV9waW5zW10gPSB7IDE5IH07CitzdGF0aWMg dW5zaWduZWQgZ3BpbzIwX3BpbnNbXSA9IHsgMjAgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMjFf cGluc1tdID0geyAyMSB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8yMl9waW5zW10gPSB7IDIyIH07 CitzdGF0aWMgdW5zaWduZWQgZ3BpbzIzX3BpbnNbXSA9IHsgMjMgfTsKK3N0YXRpYyB1bnNpZ25l ZCBncGlvMjRfcGluc1tdID0geyAyNCB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8yNV9waW5zW10g PSB7IDI1IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzI2X3BpbnNbXSA9IHsgMjYgfTsKK3N0YXRp YyB1bnNpZ25lZCBncGlvMjdfcGluc1tdID0geyAyNyB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8y OF9waW5zW10gPSB7IDI4IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzI5X3BpbnNbXSA9IHsgMjkg fTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMzBfcGluc1tdID0geyAzMCB9Oworc3RhdGljIHVuc2ln bmVkIGdwaW8zMV9waW5zW10gPSB7IDMxIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzMyX3BpbnNb XSA9IHsgMzIgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMzNfcGluc1tdID0geyAzMyB9Oworc3Rh dGljIHVuc2lnbmVkIGdwaW8zNF9waW5zW10gPSB7IDM0IH07CitzdGF0aWMgdW5zaWduZWQgZ3Bp bzM1X3BpbnNbXSA9IHsgMzUgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMzZfcGluc1tdID0geyAz NiB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8zN19waW5zW10gPSB7IDM3IH07CitzdGF0aWMgdW5z aWduZWQgZ3BpbzM4X3BpbnNbXSA9IHsgMzggfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMzlfcGlu c1tdID0geyAzOSB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW80MF9waW5zW10gPSB7IDQwIH07Citz dGF0aWMgdW5zaWduZWQgZ3BpbzQxX3BpbnNbXSA9IHsgNDEgfTsKK3N0YXRpYyB1bnNpZ25lZCBn cGlvNDJfcGluc1tdID0geyA0MiB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW80M19waW5zW10gPSB7 IDQzIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzQ0X3BpbnNbXSA9IHsgNDQgfTsKK3N0YXRpYyB1 bnNpZ25lZCBncGlvNDVfcGluc1tdID0geyA0NSB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW80Nl9w aW5zW10gPSB7IDQ2IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzQ3X3BpbnNbXSA9IHsgNDcgfTsK Kworc3RhdGljIHVuc2lnbmVkIG5hbmRfZ3JwX3BpbnNbXSA9IHsKKwk4LCAxMiwgMTMsIDE0LCAx NSwgMTYsIDE3LAorCTE4LCAxOSwgMjAsIDIxLCAyMiwgMjMsIDI3LAorfTsKKworI2RlZmluZSBC Q002MzYyX0dST1VQKG4pCQkJCVwKKwl7CQkJCQkJXAorCQkubmFtZSA9ICNuLAkJCQlcCisJCS5w aW5zID0gbiMjX3BpbnMsCQkJXAorCQkubnVtX3BpbnMgPSBBUlJBWV9TSVpFKG4jI19waW5zKSwJ XAorCX0KKworc3RhdGljIHN0cnVjdCBiY202MzYyX3Bpbmdyb3VwIGJjbTYzNjJfZ3JvdXBzW10g PSB7CisJQkNNNjM2Ml9HUk9VUChncGlvMCksCisJQkNNNjM2Ml9HUk9VUChncGlvMSksCisJQkNN NjM2Ml9HUk9VUChncGlvMiksCisJQkNNNjM2Ml9HUk9VUChncGlvMyksCisJQkNNNjM2Ml9HUk9V UChncGlvNCksCisJQkNNNjM2Ml9HUk9VUChncGlvNSksCisJQkNNNjM2Ml9HUk9VUChncGlvNiks CisJQkNNNjM2Ml9HUk9VUChncGlvNyksCisJQkNNNjM2Ml9HUk9VUChncGlvOCksCisJQkNNNjM2 Ml9HUk9VUChncGlvOSksCisJQkNNNjM2Ml9HUk9VUChncGlvMTApLAorCUJDTTYzNjJfR1JPVVAo Z3BpbzExKSwKKwlCQ002MzYyX0dST1VQKGdwaW8xMiksCisJQkNNNjM2Ml9HUk9VUChncGlvMTMp LAorCUJDTTYzNjJfR1JPVVAoZ3BpbzE0KSwKKwlCQ002MzYyX0dST1VQKGdwaW8xNSksCisJQkNN NjM2Ml9HUk9VUChncGlvMTYpLAorCUJDTTYzNjJfR1JPVVAoZ3BpbzE3KSwKKwlCQ002MzYyX0dS T1VQKGdwaW8xOCksCisJQkNNNjM2Ml9HUk9VUChncGlvMTkpLAorCUJDTTYzNjJfR1JPVVAoZ3Bp bzIwKSwKKwlCQ002MzYyX0dST1VQKGdwaW8yMSksCisJQkNNNjM2Ml9HUk9VUChncGlvMjIpLAor CUJDTTYzNjJfR1JPVVAoZ3BpbzIzKSwKKwlCQ002MzYyX0dST1VQKGdwaW8yNCksCisJQkNNNjM2 Ml9HUk9VUChncGlvMjUpLAorCUJDTTYzNjJfR1JPVVAoZ3BpbzI2KSwKKwlCQ002MzYyX0dST1VQ KGdwaW8yNyksCisJQkNNNjM2Ml9HUk9VUChncGlvMjgpLAorCUJDTTYzNjJfR1JPVVAoZ3BpbzI5 KSwKKwlCQ002MzYyX0dST1VQKGdwaW8zMCksCisJQkNNNjM2Ml9HUk9VUChncGlvMzEpLAorCUJD TTYzNjJfR1JPVVAoZ3BpbzMyKSwKKwlCQ002MzYyX0dST1VQKGdwaW8zMyksCisJQkNNNjM2Ml9H Uk9VUChncGlvMzQpLAorCUJDTTYzNjJfR1JPVVAoZ3BpbzM1KSwKKwlCQ002MzYyX0dST1VQKGdw aW8zNiksCisJQkNNNjM2Ml9HUk9VUChncGlvMzcpLAorCUJDTTYzNjJfR1JPVVAoZ3BpbzM4KSwK KwlCQ002MzYyX0dST1VQKGdwaW8zOSksCisJQkNNNjM2Ml9HUk9VUChncGlvNDApLAorCUJDTTYz NjJfR1JPVVAoZ3BpbzQxKSwKKwlCQ002MzYyX0dST1VQKGdwaW80MiksCisJQkNNNjM2Ml9HUk9V UChncGlvNDMpLAorCUJDTTYzNjJfR1JPVVAoZ3BpbzQ0KSwKKwlCQ002MzYyX0dST1VQKGdwaW80 NSksCisJQkNNNjM2Ml9HUk9VUChncGlvNDYpLAorCUJDTTYzNjJfR1JPVVAoZ3BpbzQ3KSwKKwlC Q002MzYyX0dST1VQKG5hbmRfZ3JwKSwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3Qg bGVkX2dyb3Vwc1tdID0geworCSJncGlvMCIsCisJImdwaW8xIiwKKwkiZ3BpbzIiLAorCSJncGlv MyIsCisJImdwaW80IiwKKwkiZ3BpbzUiLAorCSJncGlvNiIsCisJImdwaW83IiwKKwkiZ3Bpbzgi LAorCSJncGlvOSIsCisJImdwaW8xMCIsCisJImdwaW8xMSIsCisJImdwaW8xMiIsCisJImdwaW8x MyIsCisJImdwaW8xNCIsCisJImdwaW8xNSIsCisJImdwaW8xNiIsCisJImdwaW8xNyIsCisJImdw aW8xOCIsCisJImdwaW8xOSIsCisJImdwaW8yMCIsCisJImdwaW8yMSIsCisJImdwaW8yMiIsCisJ ImdwaW8yMyIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHVzYl9kZXZpY2VfbGVk X2dyb3Vwc1tdID0geworCSJncGlvMCIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0 IHN5c19pcnFfZ3JvdXBzW10gPSB7CisJImdwaW8xIiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFy ICogY29uc3Qgc2VyaWFsX2xlZF9jbGtfZ3JvdXBzW10gPSB7CisJImdwaW8yIiwKK307CisKK3N0 YXRpYyBjb25zdCBjaGFyICogY29uc3Qgc2VyaWFsX2xlZF9kYXRhX2dyb3Vwc1tdID0geworCSJn cGlvMyIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHJvYm9zd19sZWRfZGF0YV9n cm91cHNbXSA9IHsKKwkiZ3BpbzQiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBy b2Jvc3dfbGVkX2Nsa19ncm91cHNbXSA9IHsKKwkiZ3BpbzUiLAorfTsKKworc3RhdGljIGNvbnN0 IGNoYXIgKiBjb25zdCByb2Jvc3dfbGVkMF9ncm91cHNbXSA9IHsKKwkiZ3BpbzYiLAorfTsKKwor c3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCByb2Jvc3dfbGVkMV9ncm91cHNbXSA9IHsKKwkiZ3Bp bzciLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBpbmV0X2xlZF9ncm91cHNbXSA9 IHsKKwkiZ3BpbzgiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBzcGlfY3MyX2dy b3Vwc1tdID0geworCSJncGlvOSIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHNw aV9jczNfZ3JvdXBzW10gPSB7CisJImdwaW8xMCIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAq IGNvbnN0IG50cl9wdWxzZV9ncm91cHNbXSA9IHsKKwkiZ3BpbzExIiwKK307CisKK3N0YXRpYyBj b25zdCBjaGFyICogY29uc3QgdWFydDFfc2N0c19ncm91cHNbXSA9IHsKKwkiZ3BpbzEyIiwKK307 CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgdWFydDFfc3J0c19ncm91cHNbXSA9IHsKKwki Z3BpbzEzIiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgdWFydDFfc2Rpbl9ncm91 cHNbXSA9IHsKKwkiZ3BpbzE0IiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgdWFy dDFfc2RvdXRfZ3JvdXBzW10gPSB7CisJImdwaW8xNSIsCit9OworCitzdGF0aWMgY29uc3QgY2hh ciAqIGNvbnN0IGFkc2xfc3BpX21pc29fZ3JvdXBzW10gPSB7CisJImdwaW8xNiIsCit9OworCitz dGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGFkc2xfc3BpX21vc2lfZ3JvdXBzW10gPSB7CisJImdw aW8xNyIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGFkc2xfc3BpX2Nsa19ncm91 cHNbXSA9IHsKKwkiZ3BpbzE4IiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgYWRz bF9zcGlfY3NfZ3JvdXBzW10gPSB7CisJImdwaW8xOSIsCit9OworCitzdGF0aWMgY29uc3QgY2hh ciAqIGNvbnN0IGVwaHkwX2xlZF9ncm91cHNbXSA9IHsKKwkiZ3BpbzIwIiwKK307CisKK3N0YXRp YyBjb25zdCBjaGFyICogY29uc3QgZXBoeTFfbGVkX2dyb3Vwc1tdID0geworCSJncGlvMjEiLAor fTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBlcGh5Ml9sZWRfZ3JvdXBzW10gPSB7CisJ ImdwaW8yMiIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGVwaHkzX2xlZF9ncm91 cHNbXSA9IHsKKwkiZ3BpbzIzIiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgZXh0 X2lycTBfZ3JvdXBzW10gPSB7CisJImdwaW8yNCIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAq IGNvbnN0IGV4dF9pcnExX2dyb3Vwc1tdID0geworCSJncGlvMjUiLAorfTsKKworc3RhdGljIGNv bnN0IGNoYXIgKiBjb25zdCBleHRfaXJxMl9ncm91cHNbXSA9IHsKKwkiZ3BpbzI2IiwKK307CisK K3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgZXh0X2lycTNfZ3JvdXBzW10gPSB7CisJImdwaW8y NyIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHdpZmlfZ3JvdXBzW10gPSB7CisJ ImdwaW8zMiIsCisJImdwaW8zMyIsCisJImdwaW8zNCIsCisJImdwaW8zNSIsCisJImdwaW8zNiIs CisJImdwaW8zNyIsCisJImdwaW8zOCIsCisJImdwaW8zOSIsCisJImdwaW80MCIsCisJImdwaW80 MSIsCisJImdwaW80MiIsCisJImdwaW80MyIsCisJImdwaW80NCIsCisJImdwaW80NSIsCisJImdw aW80NiIsCisJImdwaW80NyIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IG5hbmRf Z3JvdXBzW10gPSB7CisJIm5hbmRfZ3JwIiwKK307CisKKyNkZWZpbmUgQkNNNjM2Ml9MRURfRlVO KG4pCQkJCVwKKwl7CQkJCQkJXAorCQkubmFtZSA9ICNuLAkJCQlcCisJCS5ncm91cHMgPSBuIyNf Z3JvdXBzLAkJCVwKKwkJLm51bV9ncm91cHMgPSBBUlJBWV9TSVpFKG4jI19ncm91cHMpLAlcCisJ CS5yZWcgPSBCQ002MzYyX0xFRENUUkwsCQkJXAorCX0KKworI2RlZmluZSBCQ002MzYyX01PREVf RlVOKG4pCQkJCVwKKwl7CQkJCQkJXAorCQkubmFtZSA9ICNuLAkJCQlcCisJCS5ncm91cHMgPSBu IyNfZ3JvdXBzLAkJCVwKKwkJLm51bV9ncm91cHMgPSBBUlJBWV9TSVpFKG4jI19ncm91cHMpLAlc CisJCS5yZWcgPSBCQ002MzYyX01PREUsCQkJXAorCX0KKworI2RlZmluZSBCQ002MzYyX0NUUkxf RlVOKG4pCQkJCVwKKwl7CQkJCQkJXAorCQkubmFtZSA9ICNuLAkJCQlcCisJCS5ncm91cHMgPSBu IyNfZ3JvdXBzLAkJCVwKKwkJLm51bV9ncm91cHMgPSBBUlJBWV9TSVpFKG4jI19ncm91cHMpLAlc CisJCS5yZWcgPSBCQ002MzYyX0NUUkwsCQkJXAorCX0KKworI2RlZmluZSBCQ002MzYyX0JBU0VN T0RFX0ZVTihuLCBtYXNrKQkJCVwKKwl7CQkJCQkJXAorCQkubmFtZSA9ICNuLAkJCQlcCisJCS5n cm91cHMgPSBuIyNfZ3JvdXBzLAkJCVwKKwkJLm51bV9ncm91cHMgPSBBUlJBWV9TSVpFKG4jI19n cm91cHMpLAlcCisJCS5yZWcgPSBCQ002MzYyX0JBU0VNT0RFLAkJXAorCQkuYmFzZW1vZGVfbWFz ayA9IChtYXNrKSwJCVwKKwl9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgYmNtNjM2Ml9mdW5jdGlv biBiY202MzYyX2Z1bmNzW10gPSB7CisJQkNNNjM2Ml9MRURfRlVOKGxlZCksCisJQkNNNjM2Ml9N T0RFX0ZVTih1c2JfZGV2aWNlX2xlZCksCisJQkNNNjM2Ml9NT0RFX0ZVTihzeXNfaXJxKSwKKwlC Q002MzYyX01PREVfRlVOKHNlcmlhbF9sZWRfY2xrKSwKKwlCQ002MzYyX01PREVfRlVOKHNlcmlh bF9sZWRfZGF0YSksCisJQkNNNjM2Ml9NT0RFX0ZVTihyb2Jvc3dfbGVkX2RhdGEpLAorCUJDTTYz NjJfTU9ERV9GVU4ocm9ib3N3X2xlZF9jbGspLAorCUJDTTYzNjJfTU9ERV9GVU4ocm9ib3N3X2xl ZDApLAorCUJDTTYzNjJfTU9ERV9GVU4ocm9ib3N3X2xlZDEpLAorCUJDTTYzNjJfTU9ERV9GVU4o aW5ldF9sZWQpLAorCUJDTTYzNjJfTU9ERV9GVU4oc3BpX2NzMiksCisJQkNNNjM2Ml9NT0RFX0ZV TihzcGlfY3MzKSwKKwlCQ002MzYyX01PREVfRlVOKG50cl9wdWxzZSksCisJQkNNNjM2Ml9NT0RF X0ZVTih1YXJ0MV9zY3RzKSwKKwlCQ002MzYyX01PREVfRlVOKHVhcnQxX3NydHMpLAorCUJDTTYz NjJfTU9ERV9GVU4odWFydDFfc2RpbiksCisJQkNNNjM2Ml9NT0RFX0ZVTih1YXJ0MV9zZG91dCks CisJQkNNNjM2Ml9NT0RFX0ZVTihhZHNsX3NwaV9taXNvKSwKKwlCQ002MzYyX01PREVfRlVOKGFk c2xfc3BpX21vc2kpLAorCUJDTTYzNjJfTU9ERV9GVU4oYWRzbF9zcGlfY2xrKSwKKwlCQ002MzYy X01PREVfRlVOKGFkc2xfc3BpX2NzKSwKKwlCQ002MzYyX01PREVfRlVOKGVwaHkwX2xlZCksCisJ QkNNNjM2Ml9NT0RFX0ZVTihlcGh5MV9sZWQpLAorCUJDTTYzNjJfTU9ERV9GVU4oZXBoeTJfbGVk KSwKKwlCQ002MzYyX01PREVfRlVOKGVwaHkzX2xlZCksCisJQkNNNjM2Ml9NT0RFX0ZVTihleHRf aXJxMCksCisJQkNNNjM2Ml9NT0RFX0ZVTihleHRfaXJxMSksCisJQkNNNjM2Ml9NT0RFX0ZVTihl eHRfaXJxMiksCisJQkNNNjM2Ml9NT0RFX0ZVTihleHRfaXJxMyksCisJQkNNNjM2Ml9DVFJMX0ZV Tih3aWZpKSwKKwlCQ002MzYyX0JBU0VNT0RFX0ZVTihuYW5kLCBCQVNFTU9ERV9OQU5EKSwKK307 CisKK3N0YXRpYyBpbnQgYmNtNjM2Ml9waW5jdHJsX2dldF9ncm91cF9jb3VudChzdHJ1Y3QgcGlu Y3RybF9kZXYgKnBjdGxkZXYpCit7CisJcmV0dXJuIEFSUkFZX1NJWkUoYmNtNjM2Ml9ncm91cHMp OworfQorCitzdGF0aWMgY29uc3QgY2hhciAqYmNtNjM2Ml9waW5jdHJsX2dldF9ncm91cF9uYW1l KHN0cnVjdCBwaW5jdHJsX2RldiAqcGN0bGRldiwKKwkJCQkJCSAgdW5zaWduZWQgZ3JvdXApCit7 CisJcmV0dXJuIGJjbTYzNjJfZ3JvdXBzW2dyb3VwXS5uYW1lOworfQorCitzdGF0aWMgaW50IGJj bTYzNjJfcGluY3RybF9nZXRfZ3JvdXBfcGlucyhzdHJ1Y3QgcGluY3RybF9kZXYgKnBjdGxkZXYs CisJCQkJCSAgdW5zaWduZWQgZ3JvdXAsIGNvbnN0IHVuc2lnbmVkICoqcGlucywKKwkJCQkJICB1 bnNpZ25lZCAqbnVtX3BpbnMpCit7CisJKnBpbnMgPSBiY202MzYyX2dyb3Vwc1tncm91cF0ucGlu czsKKwkqbnVtX3BpbnMgPSBiY202MzYyX2dyb3Vwc1tncm91cF0ubnVtX3BpbnM7CisKKwlyZXR1 cm4gMDsKK30KKworc3RhdGljIGludCBiY202MzYyX3BpbmN0cmxfZ2V0X2Z1bmNfY291bnQoc3Ry dWN0IHBpbmN0cmxfZGV2ICpwY3RsZGV2KQoreworCXJldHVybiBBUlJBWV9TSVpFKGJjbTYzNjJf ZnVuY3MpOworfQorCitzdGF0aWMgY29uc3QgY2hhciAqYmNtNjM2Ml9waW5jdHJsX2dldF9mdW5j X25hbWUoc3RydWN0IHBpbmN0cmxfZGV2ICpwY3RsZGV2LAorCQkJCQkJIHVuc2lnbmVkIHNlbGVj dG9yKQoreworCXJldHVybiBiY202MzYyX2Z1bmNzW3NlbGVjdG9yXS5uYW1lOworfQorCitzdGF0 aWMgaW50IGJjbTYzNjJfcGluY3RybF9nZXRfZ3JvdXBzKHN0cnVjdCBwaW5jdHJsX2RldiAqcGN0 bGRldiwKKwkJCQkgICAgICB1bnNpZ25lZCBzZWxlY3RvciwKKwkJCQkgICAgICBjb25zdCBjaGFy ICogY29uc3QgKipncm91cHMsCisJCQkJICAgICAgdW5zaWduZWQgKiBjb25zdCBudW1fZ3JvdXBz KQoreworCSpncm91cHMgPSBiY202MzYyX2Z1bmNzW3NlbGVjdG9yXS5ncm91cHM7CisJKm51bV9n cm91cHMgPSBiY202MzYyX2Z1bmNzW3NlbGVjdG9yXS5udW1fZ3JvdXBzOworCisJcmV0dXJuIDA7 Cit9CisKK3N0YXRpYyB2b2lkIGJjbTYzNjJfc2V0X2dwaW8oc3RydWN0IGJjbTYzeHhfcGluY3Ry bCAqcGMsIHVuc2lnbmVkIHBpbikKK3sKKwljb25zdCBzdHJ1Y3QgcGluY3RybF9waW5fZGVzYyAq ZGVzYyA9ICZiY202MzYyX3BpbnNbcGluXTsKKwl1bnNpZ25lZCBpbnQgbWFzayA9IGJjbTYzeHhf YmFua19waW4ocGluKTsKKworCWlmIChkZXNjLT5kcnZfZGF0YSkKKwkJcmVnbWFwX3VwZGF0ZV9i aXRzKHBjLT5yZWdzLCBCQ002MzYyX0JBU0VNT0RFX1JFRywKKwkJCQkgICAodWludDMyX3QpIGRl c2MtPmRydl9kYXRhLCAwKTsKKworCWlmIChwaW4gPCBCQ002M1hYX0JBTktfR1BJT1MpIHsKKwkJ LyogYmFzZSBtb2RlIDAgPT4gZ3BpbyAxID0+IG11eCBmdW5jdGlvbiAqLworCQlyZWdtYXBfdXBk YXRlX2JpdHMocGMtPnJlZ3MsIEJDTTYzNjJfTU9ERV9SRUcsIG1hc2ssIDApOworCisJCS8qIHBp bnMgMC0yMyBtaWdodCBiZSBtdXhlZCB0byBsZWQgKi8KKwkJaWYgKHBpbiA8IEJDTTYzNjJfTlVN X0xFRFMpCisJCQlyZWdtYXBfdXBkYXRlX2JpdHMocGMtPnJlZ3MsIEJDTTYzNjJfTEVEX1JFRywg bWFzaywgMCk7CisJfSBlbHNlIHsKKwkJLyogY3RybCByZWcgMCA9PiB3aWZpIGZ1bmN0aW9uIDEg PT4gZ3BpbyAqLworCQlyZWdtYXBfdXBkYXRlX2JpdHMocGMtPnJlZ3MsIEJDTTYzNjJfQ1RSTF9S RUcsIG1hc2ssIG1hc2spOworCX0KK30KKworc3RhdGljIGludCBiY202MzYyX3BpbmN0cmxfc2V0 X211eChzdHJ1Y3QgcGluY3RybF9kZXYgKnBjdGxkZXYsCisJCQkJICAgdW5zaWduZWQgc2VsZWN0 b3IsIHVuc2lnbmVkIGdyb3VwKQoreworCXN0cnVjdCBiY202M3h4X3BpbmN0cmwgKnBjID0gcGlu Y3RybF9kZXZfZ2V0X2RydmRhdGEocGN0bGRldik7CisJY29uc3Qgc3RydWN0IGJjbTYzNjJfcGlu Z3JvdXAgKnBnID0gJmJjbTYzNjJfZ3JvdXBzW2dyb3VwXTsKKwljb25zdCBzdHJ1Y3QgYmNtNjM2 Ml9mdW5jdGlvbiAqZiA9ICZiY202MzYyX2Z1bmNzW3NlbGVjdG9yXTsKKwl1bnNpZ25lZCBpOwor CXVuc2lnbmVkIGludCByZWc7CisJdW5zaWduZWQgaW50IHZhbCwgbWFzazsKKworCWZvciAoaSA9 IDA7IGkgPCBwZy0+bnVtX3BpbnM7IGkrKykKKwkJYmNtNjM2Ml9zZXRfZ3BpbyhwYywgcGctPnBp bnNbaV0pOworCisJc3dpdGNoIChmLT5yZWcpIHsKKwljYXNlIEJDTTYzNjJfTEVEQ1RSTDoKKwkJ cmVnID0gQkNNNjM2Ml9MRURfUkVHOworCQltYXNrID0gQklUKHBnLT5waW5zWzBdKTsKKwkJdmFs ID0gQklUKHBnLT5waW5zWzBdKTsKKwkJYnJlYWs7CisJY2FzZSBCQ002MzYyX01PREU6CisJCXJl ZyA9IEJDTTYzNjJfTU9ERV9SRUc7CisJCW1hc2sgPSBCSVQocGctPnBpbnNbMF0pOworCQl2YWwg PSBCSVQocGctPnBpbnNbMF0pOworCQlicmVhazsKKwljYXNlIEJDTTYzNjJfQ1RSTDoKKwkJcmVn ID0gQkNNNjM2Ml9DVFJMX1JFRzsKKwkJbWFzayA9IEJJVChwZy0+cGluc1swXSk7CisJCXZhbCA9 IDA7CisJCWJyZWFrOworCWNhc2UgQkNNNjM2Ml9CQVNFTU9ERToKKwkJcmVnID0gQkNNNjM2Ml9C QVNFTU9ERV9SRUc7CisJCW1hc2sgPSBmLT5iYXNlbW9kZV9tYXNrOworCQl2YWwgPSBmLT5iYXNl bW9kZV9tYXNrOworCQlicmVhazsKKwlkZWZhdWx0OgorCQlXQVJOX09OKDEpOworCQlyZXR1cm4g LUVJTlZBTDsKKwl9CisKKwlyZWdtYXBfdXBkYXRlX2JpdHMocGMtPnJlZ3MsIHJlZywgbWFzaywg dmFsKTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IGJjbTYzNjJfZ3Bpb19yZXF1ZXN0 X2VuYWJsZShzdHJ1Y3QgcGluY3RybF9kZXYgKnBjdGxkZXYsCisJCQkJICAgICAgIHN0cnVjdCBw aW5jdHJsX2dwaW9fcmFuZ2UgKnJhbmdlLAorCQkJCSAgICAgICB1bnNpZ25lZCBvZmZzZXQpCit7 CisJc3RydWN0IGJjbTYzeHhfcGluY3RybCAqcGMgPSBwaW5jdHJsX2Rldl9nZXRfZHJ2ZGF0YShw Y3RsZGV2KTsKKworCS8qIGRpc2FibGUgYWxsIGZ1bmN0aW9ucyB1c2luZyB0aGlzIHBpbiAqLwor CWJjbTYzNjJfc2V0X2dwaW8ocGMsIG9mZnNldCk7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGlj IHN0cnVjdCBwaW5jdHJsX29wcyBiY202MzYyX3BjdGxfb3BzID0geworCS5kdF9mcmVlX21hcCA9 IHBpbmN0cmxfdXRpbHNfZnJlZV9tYXAsCisJLmR0X25vZGVfdG9fbWFwID0gcGluY29uZl9nZW5l cmljX2R0X25vZGVfdG9fbWFwX3BpbiwKKwkuZ2V0X2dyb3VwX25hbWUgPSBiY202MzYyX3BpbmN0 cmxfZ2V0X2dyb3VwX25hbWUsCisJLmdldF9ncm91cF9waW5zID0gYmNtNjM2Ml9waW5jdHJsX2dl dF9ncm91cF9waW5zLAorCS5nZXRfZ3JvdXBzX2NvdW50ID0gYmNtNjM2Ml9waW5jdHJsX2dldF9n cm91cF9jb3VudCwKK307CisKK3N0YXRpYyBzdHJ1Y3QgcGlubXV4X29wcyBiY202MzYyX3BteF9v cHMgPSB7CisJLmdldF9mdW5jdGlvbl9ncm91cHMgPSBiY202MzYyX3BpbmN0cmxfZ2V0X2dyb3Vw cywKKwkuZ2V0X2Z1bmN0aW9uX25hbWUgPSBiY202MzYyX3BpbmN0cmxfZ2V0X2Z1bmNfbmFtZSwK KwkuZ2V0X2Z1bmN0aW9uc19jb3VudCA9IGJjbTYzNjJfcGluY3RybF9nZXRfZnVuY19jb3VudCwK KwkuZ3Bpb19yZXF1ZXN0X2VuYWJsZSA9IGJjbTYzNjJfZ3Bpb19yZXF1ZXN0X2VuYWJsZSwKKwku c2V0X211eCA9IGJjbTYzNjJfcGluY3RybF9zZXRfbXV4LAorCS5zdHJpY3QgPSB0cnVlLAorfTsK Kworc3RhdGljIGNvbnN0IHN0cnVjdCBiY202M3h4X3BpbmN0cmxfc29jIGJjbTYzNjJfc29jID0g eworCS5uZ3Bpb3MgPSBCQ002MzYyX05VTV9HUElPUywKKwkubnBpbnMgPSBBUlJBWV9TSVpFKGJj bTYzNjJfcGlucyksCisJLnBjdGxfb3BzID0gJmJjbTYzNjJfcGN0bF9vcHMsCisJLnBpbnMgPSBi Y202MzYyX3BpbnMsCisJLnBteF9vcHMgPSAmYmNtNjM2Ml9wbXhfb3BzLAorfTsKKworc3RhdGlj IGludCBiY202MzYyX3BpbmN0cmxfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikK K3sKKwlyZXR1cm4gYmNtNjN4eF9waW5jdHJsX3Byb2JlKHBkZXYsICZiY202MzYyX3NvYywgTlVM TCk7Cit9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgb2ZfZGV2aWNlX2lkIGJjbTYzNjJfcGluY3Ry bF9tYXRjaFtdID0geworCXsgLmNvbXBhdGlibGUgPSAiYnJjbSxiY202MzYyLXBpbmN0cmwiLCB9 LAorCXsgLyogc2VudGluZWwgKi8gfQorfTsKKworc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kcml2 ZXIgYmNtNjM2Ml9waW5jdHJsX2RyaXZlciA9IHsKKwkucHJvYmUgPSBiY202MzYyX3BpbmN0cmxf cHJvYmUsCisJLmRyaXZlciA9IHsKKwkJLm5hbWUgPSAiYmNtNjM2Mi1waW5jdHJsIiwKKwkJLm9m X21hdGNoX3RhYmxlID0gYmNtNjM2Ml9waW5jdHJsX21hdGNoLAorCX0sCit9OworCitidWlsdGlu X3BsYXRmb3JtX2RyaXZlcihiY202MzYyX3BpbmN0cmxfZHJpdmVyKTsKLS0gCjIuMjAuMQoKCl9f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmxpbnV4LWFybS1r ZXJuZWwgbWFpbGluZyBsaXN0CmxpbnV4LWFybS1rZXJuZWxAbGlzdHMuaW5mcmFkZWFkLm9yZwpo dHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LWFybS1rZXJu ZWwK