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 32C5CC468C0 for ; Mon, 15 Mar 2021 11:43:27 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 1D77664EE3 for ; Mon, 15 Mar 2021 11:43:27 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230526AbhCOLnK (ORCPT ); Mon, 15 Mar 2021 07:43:10 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:43234 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230259AbhCOLmb (ORCPT ); Mon, 15 Mar 2021 07:42:31 -0400 Received: from mail-wm1-x334.google.com (mail-wm1-x334.google.com [IPv6:2a00:1450:4864:20::334]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 76429C061574; Mon, 15 Mar 2021 04:42:31 -0700 (PDT) Received: by mail-wm1-x334.google.com with SMTP id b2-20020a7bc2420000b029010be1081172so19263424wmj.1; Mon, 15 Mar 2021 04:42:31 -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=DsYOoTGrCGsWGikinYM0EG70X/f2vOR/RMz8iuKcrmI=; b=mevoouUtLKG829pgkVByj/dOjWKBisgE+7XPdUwo8SDuZ7dh87maIG8djPhphLpnZ+ gp5IjXMK0BtSPjg5vtx+z5HIvN+/cicET6aimneBidtu0qx2D0Az8LRDsprPzeKURC7S +sgpwi0peCTmX6ozYQtiJrCXkJP8pA4m/6UcLbozqNTA8ErBu2uzte9jRHJFH/qFBphl pbov9J9765sZ/y2vb4sL1HfxnpH/11e5QXyy0EtGBxcPAskq5MP5v/cBf590pT0AdKk2 rTGbXeeUsIYLcgUFVcZY68zgqilIZMDhxfyq/0VBBXl2net69QvtnteP74MEF6GmABNz keVw== 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=DsYOoTGrCGsWGikinYM0EG70X/f2vOR/RMz8iuKcrmI=; b=A563yCM+hajOLB1uHwm9ZQUx6ey3XLBGCwlwsStLZi//mQsASiWJfAP1+iU0TXfmeZ ZCO30pn9rmWbk4Vw6XsDXTELWoil2NBglLFAv3jCix3lYRe0vUe95+dkryXFH+RCPw5b +iJuTtNwGZMbobzGLzjN+0eHK1TN3SlppcDcRE1G1ZGeR+Aj9VuOia3chObU6KyzAtJa 7mABMHZdKOeeDMqVBPcRke0RY0BvPqUFZk2BXVcSi7JJ13zb6NRgzQZiGJAncs9Knmzz JK/X1lSL5G/bnYD2Ghbn/qG583yCv29vRzKpfnUxL73a5NequkvVSPUajYxpvh+V9XIS QFIw== X-Gm-Message-State: AOAM533MMJRRNWNgZ46ViPUW2AGn9P6r725WgstmyH7ZDRgwqDdYQVxa 5qdm4MgQ/NExmx8kV5K3xKM= X-Google-Smtp-Source: ABdhPJwWWDda+iP/13Nh9MvQMNLvauCyzJuaL0/15PG5itBOa6fkNBPe1iZU+FpnOvSe6PaOWUesSw== X-Received: by 2002:a1c:e244:: with SMTP id z65mr25629656wmg.130.1615808550031; Mon, 15 Mar 2021 04:42:30 -0700 (PDT) Received: from skynet.lan ([80.31.204.166]) by smtp.gmail.com with ESMTPSA id v189sm12648187wme.39.2021.03.15.04.42.29 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 15 Mar 2021 04:42:29 -0700 (PDT) From: =?UTF-8?q?=C3=81lvaro=20Fern=C3=A1ndez=20Rojas?= To: Linus Walleij , Bartosz Golaszewski , Rob Herring , Florian Fainelli , bcm-kernel-feedback-list@broadcom.com, Lee Jones , Michael Walle , =?UTF-8?q?=C3=81lvaro=20Fern=C3=A1ndez=20Rojas?= , Jonas Gorski , Necip Fazil Yildiran , Andy Shevchenko , linux-gpio@vger.kernel.org, devicetree@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org Subject: [PATCH v7 13/22] pinctrl: add a pincontrol driver for BCM6362 Date: Mon, 15 Mar 2021 12:42:05 +0100 Message-Id: <20210315114214.3096-14-noltari@gmail.com> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20210315114214.3096-1-noltari@gmail.com> References: <20210315114214.3096-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-kernel@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 --- 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 ADC09C433E9 for ; Mon, 15 Mar 2021 12:00:31 +0000 (UTC) Received: from desiato.infradead.org (desiato.infradead.org [90.155.92.199]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id C844B64DD7 for ; Mon, 15 Mar 2021 12:00:30 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org C844B64DD7 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=vaN5KV/vBhPRqY9AqZ84yuBxCpkl2vSnOcntvciM77Y=; b=l+8zJhHF+AuTIhdpc5iqrlnNI L6VVilfcX0HxO2j0sRuhY61te9tmn3w86ipck4AKF+Xlj9uO8t5onbnztyvJTOWSRRhzTCdtYlpas 1bdhaPmrmuvLjnAPWnFL6Plr9jQBhQUcvTJGr8fuiayWB1PPCionoi6RXbl8IQAhqWToC+0GBMWQ4 EqDcaxgVv4vKAObCJEdGRzRhLsmkxL5QBR+1s5Q+QlN75CDZ5cZFYQAfNQxxktBe+Wr4DPlxlJMKW Hq7yvtAByHc4G297QcdRuFwf8hjULi/3/Lklkp3yiGuYjG8Rc5S5QlWqqi8DdV+Wk5OaAXgNHXGrU S9Xvq0KJg==; Received: from localhost ([::1] helo=desiato.infradead.org) by desiato.infradead.org with esmtp (Exim 4.94 #2 (Red Hat Linux)) id 1lLlom-00Fj1S-2h; Mon, 15 Mar 2021 11:55:29 +0000 Received: from mail-wm1-x331.google.com ([2a00:1450:4864:20::331]) by desiato.infradead.org with esmtps (Exim 4.94 #2 (Red Hat Linux)) id 1lLlcE-00Fgu5-Qz for linux-arm-kernel@lists.infradead.org; Mon, 15 Mar 2021 11:43:03 +0000 Received: by mail-wm1-x331.google.com with SMTP id d139-20020a1c1d910000b029010b895cb6f2so19241284wmd.5 for ; Mon, 15 Mar 2021 04:42:30 -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=DsYOoTGrCGsWGikinYM0EG70X/f2vOR/RMz8iuKcrmI=; b=mevoouUtLKG829pgkVByj/dOjWKBisgE+7XPdUwo8SDuZ7dh87maIG8djPhphLpnZ+ gp5IjXMK0BtSPjg5vtx+z5HIvN+/cicET6aimneBidtu0qx2D0Az8LRDsprPzeKURC7S +sgpwi0peCTmX6ozYQtiJrCXkJP8pA4m/6UcLbozqNTA8ErBu2uzte9jRHJFH/qFBphl pbov9J9765sZ/y2vb4sL1HfxnpH/11e5QXyy0EtGBxcPAskq5MP5v/cBf590pT0AdKk2 rTGbXeeUsIYLcgUFVcZY68zgqilIZMDhxfyq/0VBBXl2net69QvtnteP74MEF6GmABNz keVw== 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=DsYOoTGrCGsWGikinYM0EG70X/f2vOR/RMz8iuKcrmI=; b=Ye2ysGaOViF1Hk6hRiJew6fDDrrDkJf2Bd23OJ8yefGG7lDOQd4JlsfNDSqctTkx8q KgFAW88rZUTi3YSv9z/2AMzMC4YBK6hAreRb8cFgPdOkN+9PTv1Ga7OcjPvUlcQ46WRa HGKHnfneVftN6U8KRsnZEYDaLjL37KEI7uuzIkZ02cMux0qDB+cq6DHHSmSJzY0OtInT VXoP4oW6+ispo33/m6fHmlRy3Wc2GtOYw3dsbnWsvWJU8kZQm77JZnIVW3/ugwVEJKr6 mHxQ/AtnTQUhT/avY4f3jgJwl3cy6Sz26Whv0yNMyhh+9dUUM8MwZL5SNrOxEHQ3pSmb NUAA== X-Gm-Message-State: AOAM533px72YiXVlkjGD5uZC5hCS4CnE15/Nq+/gFw6/XFNIjf0SwM22 NWuZgM/IF9/oDPbO1QJjW8hq7oflB/Mg+A== X-Google-Smtp-Source: ABdhPJwWWDda+iP/13Nh9MvQMNLvauCyzJuaL0/15PG5itBOa6fkNBPe1iZU+FpnOvSe6PaOWUesSw== X-Received: by 2002:a1c:e244:: with SMTP id z65mr25629656wmg.130.1615808550031; Mon, 15 Mar 2021 04:42:30 -0700 (PDT) Received: from skynet.lan ([80.31.204.166]) by smtp.gmail.com with ESMTPSA id v189sm12648187wme.39.2021.03.15.04.42.29 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 15 Mar 2021 04:42:29 -0700 (PDT) From: =?UTF-8?q?=C3=81lvaro=20Fern=C3=A1ndez=20Rojas?= To: Linus Walleij , Bartosz Golaszewski , Rob Herring , Florian Fainelli , bcm-kernel-feedback-list@broadcom.com, Lee Jones , Michael Walle , =?UTF-8?q?=C3=81lvaro=20Fern=C3=A1ndez=20Rojas?= , Jonas Gorski , Necip Fazil Yildiran , Andy Shevchenko , linux-gpio@vger.kernel.org, devicetree@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org Subject: [PATCH v7 13/22] pinctrl: add a pincontrol driver for BCM6362 Date: Mon, 15 Mar 2021 12:42:05 +0100 Message-Id: <20210315114214.3096-14-noltari@gmail.com> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20210315114214.3096-1-noltari@gmail.com> References: <20210315114214.3096-1-noltari@gmail.com> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20210315_114257_407331_BF4966DC X-CRM114-Status: GOOD ( 19.00 ) 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 LS0KIHY3OiBubyBjaGFuZ2VzCiB2Njogbm8gY2hhbmdlcwogdjU6IGFkZCBjaGFuZ2VzIHN1Z2dl c3RlZCBieSBBbmR5IFNoZXZjaGVua28KIHY0OiBubyBjaGFuZ2VzCiB2MzogdXNlIG5ldyBzaGFy ZWQgY29kZQogdjI6IHN3aXRjaCB0byBHUElPX1JFR01BUAoKIGRyaXZlcnMvcGluY3RybC9iY20v S2NvbmZpZyAgICAgICAgICAgfCAgIDggKwogZHJpdmVycy9waW5jdHJsL2JjbS9NYWtlZmlsZSAg ICAgICAgICB8ICAgMSArCiBkcml2ZXJzL3BpbmN0cmwvYmNtL3BpbmN0cmwtYmNtNjM2Mi5jIHwg NjE3ICsrKysrKysrKysrKysrKysrKysrKysrKysrCiAzIGZpbGVzIGNoYW5nZWQsIDYyNiBpbnNl cnRpb25zKCspCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9waW5jdHJsL2JjbS9waW5jdHJs LWJjbTYzNjIuYwoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGluY3RybC9iY20vS2NvbmZpZyBiL2Ry aXZlcnMvcGluY3RybC9iY20vS2NvbmZpZwppbmRleCBjZWQ3Y2M2YWI0NGYuLmQzMTAxZDVlNzUw ZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9waW5jdHJsL2JjbS9LY29uZmlnCisrKyBiL2RyaXZlcnMv cGluY3RybC9iY20vS2NvbmZpZwpAQCAtNTIsNiArNTIsMTQgQEAgY29uZmlnIFBJTkNUUkxfQkNN NjM1OAogCWhlbHAKIAkgICBTYXkgWSBoZXJlIHRvIGVuYWJsZSB0aGUgQnJvYWRjb20gQkNNNjM1 OCBHUElPIGRyaXZlci4KIAorY29uZmlnIFBJTkNUUkxfQkNNNjM2MgorCWJvb2wgIkJyb2FkY29t IEJDTTYzNjIgR1BJTyBkcml2ZXIiCisJZGVwZW5kcyBvbiAoQk1JUFNfR0VORVJJQyB8fCBDT01Q SUxFX1RFU1QpCisJc2VsZWN0IFBJTkNUUkxfQkNNNjNYWAorCWRlZmF1bHQgQk1JUFNfR0VORVJJ QworCWhlbHAKKwkgICBTYXkgWSBoZXJlIHRvIGVuYWJsZSB0aGUgQnJvYWRjb20gQkNNNjM2MiBH UElPIGRyaXZlci4KKwogY29uZmlnIFBJTkNUUkxfSVBST0NfR1BJTwogCWJvb2wgIkJyb2FkY29t IGlQcm9jIEdQSU8gKHdpdGggUElOQ09ORikgZHJpdmVyIgogCWRlcGVuZHMgb24gT0ZfR1BJTyAm JiAoQVJDSF9CQ01fSVBST0MgfHwgQ09NUElMRV9URVNUKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9w aW5jdHJsL2JjbS9NYWtlZmlsZSBiL2RyaXZlcnMvcGluY3RybC9iY20vTWFrZWZpbGUKaW5kZXgg YzNmNWI3YjJmMmYwLi5iOWIwOWU1YjkxNGMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcGluY3RybC9i Y20vTWFrZWZpbGUKKysrIGIvZHJpdmVycy9waW5jdHJsL2JjbS9NYWtlZmlsZQpAQCAtNiw2ICs2 LDcgQEAgb2JqLSQoQ09ORklHX1BJTkNUUkxfQkNNMjgzNSkJCSs9IHBpbmN0cmwtYmNtMjgzNS5v CiBvYmotJChDT05GSUdfUElOQ1RSTF9CQ002M1hYKQkJKz0gcGluY3RybC1iY202M3h4Lm8KIG9i ai0kKENPTkZJR19QSU5DVFJMX0JDTTYzMjgpCQkrPSBwaW5jdHJsLWJjbTYzMjgubwogb2JqLSQo Q09ORklHX1BJTkNUUkxfQkNNNjM1OCkJCSs9IHBpbmN0cmwtYmNtNjM1OC5vCitvYmotJChDT05G SUdfUElOQ1RSTF9CQ002MzYyKQkJKz0gcGluY3RybC1iY202MzYyLm8KIG9iai0kKENPTkZJR19Q SU5DVFJMX0lQUk9DX0dQSU8pCSs9IHBpbmN0cmwtaXByb2MtZ3Bpby5vCiBvYmotJChDT05GSUdf UElOQ1RSTF9DWUdOVVNfTVVYKQkrPSBwaW5jdHJsLWN5Z251cy1tdXgubwogb2JqLSQoQ09ORklH X1BJTkNUUkxfTlMpCQkrPSBwaW5jdHJsLW5zLm8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGluY3Ry bC9iY20vcGluY3RybC1iY202MzYyLmMgYi9kcml2ZXJzL3BpbmN0cmwvYmNtL3BpbmN0cmwtYmNt NjM2Mi5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uZWI3ZWM4MDM1 M2U5Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9waW5jdHJsL2JjbS9waW5jdHJsLWJjbTYz NjIuYwpAQCAtMCwwICsxLDYxNyBAQAorLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0y LjArCisvKgorICogRHJpdmVyIGZvciBCQ002MzYyIEdQSU8gdW5pdCAocGluY3RybCArIEdQSU8p CisgKgorICogQ29weXJpZ2h0IChDKSAyMDIxIMOBbHZhcm8gRmVybsOhbmRleiBSb2phcyA8bm9s dGFyaUBnbWFpbC5jb20+CisgKiBDb3B5cmlnaHQgKEMpIDIwMTYgSm9uYXMgR29yc2tpIDxqb25h cy5nb3Jza2lAZ21haWwuY29tPgorICovCisKKyNpbmNsdWRlIDxsaW51eC9iaXRzLmg+CisjaW5j bHVkZSA8bGludXgvZ3Bpby9kcml2ZXIuaD4KKyNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KKyNp bmNsdWRlIDxsaW51eC9vZi5oPgorI2luY2x1ZGUgPGxpbnV4L3BpbmN0cmwvcGlubXV4Lmg+Cisj aW5jbHVkZSA8bGludXgvcGxhdGZvcm1fZGV2aWNlLmg+CisjaW5jbHVkZSA8bGludXgvcmVnbWFw Lmg+CisKKyNpbmNsdWRlICIuLi9waW5jdHJsLXV0aWxzLmgiCisKKyNpbmNsdWRlICJwaW5jdHJs LWJjbTYzeHguaCIKKworI2RlZmluZSBCQ002MzYyX0JBTktfR1BJT1MJMzIKKyNkZWZpbmUgQkNN NjM2Ml9OVU1fR1BJT1MJNDgKKyNkZWZpbmUgQkNNNjM2Ml9OVU1fTEVEUwkyNAorCisjZGVmaW5l IEJDTTYzNjJfTEVEX1JFRwkJMHgxMAorI2RlZmluZSBCQ002MzYyX01PREVfUkVHCTB4MTgKKyNk ZWZpbmUgQkNNNjM2Ml9DVFJMX1JFRwkweDFjCisjZGVmaW5lIEJDTTYzNjJfQkFTRU1PREVfUkVH CTB4MzgKKyNkZWZpbmUgIEJBU0VNT0RFX05BTkQJCUJJVCgyKQorCitlbnVtIGJjbTYzNjJfcGlu Y3RybF9yZWcgeworCUJDTTYzNjJfTEVEQ1RSTCwKKwlCQ002MzYyX01PREUsCisJQkNNNjM2Ml9D VFJMLAorCUJDTTYzNjJfQkFTRU1PREUsCit9OworCitzdHJ1Y3QgYmNtNjM2Ml9waW5ncm91cCB7 CisJY29uc3QgY2hhciAqbmFtZTsKKwljb25zdCB1bnNpZ25lZCAqIGNvbnN0IHBpbnM7CisJY29u c3QgdW5zaWduZWQgbnVtX3BpbnM7Cit9OworCitzdHJ1Y3QgYmNtNjM2Ml9mdW5jdGlvbiB7CisJ Y29uc3QgY2hhciAqbmFtZTsKKwljb25zdCBjaGFyICogY29uc3QgKmdyb3VwczsKKwljb25zdCB1 bnNpZ25lZCBudW1fZ3JvdXBzOworCisJZW51bSBiY202MzYyX3BpbmN0cmxfcmVnIHJlZzsKKwl1 aW50MzJfdCBiYXNlbW9kZV9tYXNrOworfTsKKworI2RlZmluZSBCQ002MzYyX1BJTihhLCBiLCBt YXNrKQkJCVwKKwl7CQkJCQlcCisJCS5udW1iZXIgPSBhLAkJCVwKKwkJLm5hbWUgPSBiLAkJCVwK KwkJLmRydl9kYXRhID0gKHZvaWQgKikobWFzayksCVwKKwl9CisKK3N0YXRpYyBjb25zdCBzdHJ1 Y3QgcGluY3RybF9waW5fZGVzYyBiY202MzYyX3BpbnNbXSA9IHsKKwlQSU5DVFJMX1BJTigwLCAi Z3BpbzAiKSwKKwlQSU5DVFJMX1BJTigxLCAiZ3BpbzEiKSwKKwlQSU5DVFJMX1BJTigyLCAiZ3Bp bzIiKSwKKwlQSU5DVFJMX1BJTigzLCAiZ3BpbzMiKSwKKwlQSU5DVFJMX1BJTig0LCAiZ3BpbzQi KSwKKwlQSU5DVFJMX1BJTig1LCAiZ3BpbzUiKSwKKwlQSU5DVFJMX1BJTig2LCAiZ3BpbzYiKSwK KwlQSU5DVFJMX1BJTig3LCAiZ3BpbzciKSwKKwlCQ002MzYyX1BJTig4LCAiZ3BpbzgiLCBCQVNF TU9ERV9OQU5EKSwKKwlQSU5DVFJMX1BJTig5LCAiZ3BpbzkiKSwKKwlQSU5DVFJMX1BJTigxMCwg ImdwaW8xMCIpLAorCVBJTkNUUkxfUElOKDExLCAiZ3BpbzExIiksCisJQkNNNjM2Ml9QSU4oMTIs ICJncGlvMTIiLCBCQVNFTU9ERV9OQU5EKSwKKwlCQ002MzYyX1BJTigxMywgImdwaW8xMyIsIEJB U0VNT0RFX05BTkQpLAorCUJDTTYzNjJfUElOKDE0LCAiZ3BpbzE0IiwgQkFTRU1PREVfTkFORCks CisJQkNNNjM2Ml9QSU4oMTUsICJncGlvMTUiLCBCQVNFTU9ERV9OQU5EKSwKKwlCQ002MzYyX1BJ TigxNiwgImdwaW8xNiIsIEJBU0VNT0RFX05BTkQpLAorCUJDTTYzNjJfUElOKDE3LCAiZ3BpbzE3 IiwgQkFTRU1PREVfTkFORCksCisJQkNNNjM2Ml9QSU4oMTgsICJncGlvMTgiLCBCQVNFTU9ERV9O QU5EKSwKKwlCQ002MzYyX1BJTigxOSwgImdwaW8xOSIsIEJBU0VNT0RFX05BTkQpLAorCUJDTTYz NjJfUElOKDIwLCAiZ3BpbzIwIiwgQkFTRU1PREVfTkFORCksCisJQkNNNjM2Ml9QSU4oMjEsICJn cGlvMjEiLCBCQVNFTU9ERV9OQU5EKSwKKwlCQ002MzYyX1BJTigyMiwgImdwaW8yMiIsIEJBU0VN T0RFX05BTkQpLAorCUJDTTYzNjJfUElOKDIzLCAiZ3BpbzIzIiwgQkFTRU1PREVfTkFORCksCisJ UElOQ1RSTF9QSU4oMjQsICJncGlvMjQiKSwKKwlQSU5DVFJMX1BJTigyNSwgImdwaW8yNSIpLAor CVBJTkNUUkxfUElOKDI2LCAiZ3BpbzI2IiksCisJQkNNNjM2Ml9QSU4oMjcsICJncGlvMjciLCBC QVNFTU9ERV9OQU5EKSwKKwlQSU5DVFJMX1BJTigyOCwgImdwaW8yOCIpLAorCVBJTkNUUkxfUElO KDI5LCAiZ3BpbzI5IiksCisJUElOQ1RSTF9QSU4oMzAsICJncGlvMzAiKSwKKwlQSU5DVFJMX1BJ TigzMSwgImdwaW8zMSIpLAorCVBJTkNUUkxfUElOKDMyLCAiZ3BpbzMyIiksCisJUElOQ1RSTF9Q SU4oMzMsICJncGlvMzMiKSwKKwlQSU5DVFJMX1BJTigzNCwgImdwaW8zNCIpLAorCVBJTkNUUkxf UElOKDM1LCAiZ3BpbzM1IiksCisJUElOQ1RSTF9QSU4oMzYsICJncGlvMzYiKSwKKwlQSU5DVFJM X1BJTigzNywgImdwaW8zNyIpLAorCVBJTkNUUkxfUElOKDM4LCAiZ3BpbzM4IiksCisJUElOQ1RS TF9QSU4oMzksICJncGlvMzkiKSwKKwlQSU5DVFJMX1BJTig0MCwgImdwaW80MCIpLAorCVBJTkNU UkxfUElOKDQxLCAiZ3BpbzQxIiksCisJUElOQ1RSTF9QSU4oNDIsICJncGlvNDIiKSwKKwlQSU5D VFJMX1BJTig0MywgImdwaW80MyIpLAorCVBJTkNUUkxfUElOKDQ0LCAiZ3BpbzQ0IiksCisJUElO Q1RSTF9QSU4oNDUsICJncGlvNDUiKSwKKwlQSU5DVFJMX1BJTig0NiwgImdwaW80NiIpLAorCVBJ TkNUUkxfUElOKDQ3LCAiZ3BpbzQ3IiksCit9OworCitzdGF0aWMgdW5zaWduZWQgZ3BpbzBfcGlu c1tdID0geyAwIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzFfcGluc1tdID0geyAxIH07CitzdGF0 aWMgdW5zaWduZWQgZ3BpbzJfcGluc1tdID0geyAyIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzNf cGluc1tdID0geyAzIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzRfcGluc1tdID0geyA0IH07Citz dGF0aWMgdW5zaWduZWQgZ3BpbzVfcGluc1tdID0geyA1IH07CitzdGF0aWMgdW5zaWduZWQgZ3Bp bzZfcGluc1tdID0geyA2IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzdfcGluc1tdID0geyA3IH07 CitzdGF0aWMgdW5zaWduZWQgZ3BpbzhfcGluc1tdID0geyA4IH07CitzdGF0aWMgdW5zaWduZWQg Z3BpbzlfcGluc1tdID0geyA5IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzEwX3BpbnNbXSA9IHsg MTAgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMTFfcGluc1tdID0geyAxMSB9Oworc3RhdGljIHVu c2lnbmVkIGdwaW8xMl9waW5zW10gPSB7IDEyIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzEzX3Bp bnNbXSA9IHsgMTMgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMTRfcGluc1tdID0geyAxNCB9Owor c3RhdGljIHVuc2lnbmVkIGdwaW8xNV9waW5zW10gPSB7IDE1IH07CitzdGF0aWMgdW5zaWduZWQg Z3BpbzE2X3BpbnNbXSA9IHsgMTYgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMTdfcGluc1tdID0g eyAxNyB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8xOF9waW5zW10gPSB7IDE4IH07CitzdGF0aWMg dW5zaWduZWQgZ3BpbzE5X3BpbnNbXSA9IHsgMTkgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMjBf cGluc1tdID0geyAyMCB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8yMV9waW5zW10gPSB7IDIxIH07 CitzdGF0aWMgdW5zaWduZWQgZ3BpbzIyX3BpbnNbXSA9IHsgMjIgfTsKK3N0YXRpYyB1bnNpZ25l ZCBncGlvMjNfcGluc1tdID0geyAyMyB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8yNF9waW5zW10g PSB7IDI0IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzI1X3BpbnNbXSA9IHsgMjUgfTsKK3N0YXRp YyB1bnNpZ25lZCBncGlvMjZfcGluc1tdID0geyAyNiB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8y N19waW5zW10gPSB7IDI3IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzI4X3BpbnNbXSA9IHsgMjgg fTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMjlfcGluc1tdID0geyAyOSB9Oworc3RhdGljIHVuc2ln bmVkIGdwaW8zMF9waW5zW10gPSB7IDMwIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzMxX3BpbnNb XSA9IHsgMzEgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMzJfcGluc1tdID0geyAzMiB9Oworc3Rh dGljIHVuc2lnbmVkIGdwaW8zM19waW5zW10gPSB7IDMzIH07CitzdGF0aWMgdW5zaWduZWQgZ3Bp bzM0X3BpbnNbXSA9IHsgMzQgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMzVfcGluc1tdID0geyAz NSB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8zNl9waW5zW10gPSB7IDM2IH07CitzdGF0aWMgdW5z aWduZWQgZ3BpbzM3X3BpbnNbXSA9IHsgMzcgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMzhfcGlu c1tdID0geyAzOCB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8zOV9waW5zW10gPSB7IDM5IH07Citz dGF0aWMgdW5zaWduZWQgZ3BpbzQwX3BpbnNbXSA9IHsgNDAgfTsKK3N0YXRpYyB1bnNpZ25lZCBn cGlvNDFfcGluc1tdID0geyA0MSB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW80Ml9waW5zW10gPSB7 IDQyIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzQzX3BpbnNbXSA9IHsgNDMgfTsKK3N0YXRpYyB1 bnNpZ25lZCBncGlvNDRfcGluc1tdID0geyA0NCB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW80NV9w aW5zW10gPSB7IDQ1IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzQ2X3BpbnNbXSA9IHsgNDYgfTsK K3N0YXRpYyB1bnNpZ25lZCBncGlvNDdfcGluc1tdID0geyA0NyB9OworCitzdGF0aWMgdW5zaWdu ZWQgbmFuZF9ncnBfcGluc1tdID0geworCTgsIDEyLCAxMywgMTQsIDE1LCAxNiwgMTcsCisJMTgs IDE5LCAyMCwgMjEsIDIyLCAyMywgMjcsCit9OworCisjZGVmaW5lIEJDTTYzNjJfR1JPVVAobikJ CQkJXAorCXsJCQkJCQlcCisJCS5uYW1lID0gI24sCQkJCVwKKwkJLnBpbnMgPSBuIyNfcGlucywJ CQlcCisJCS5udW1fcGlucyA9IEFSUkFZX1NJWkUobiMjX3BpbnMpLAlcCisJfQorCitzdGF0aWMg c3RydWN0IGJjbTYzNjJfcGluZ3JvdXAgYmNtNjM2Ml9ncm91cHNbXSA9IHsKKwlCQ002MzYyX0dS T1VQKGdwaW8wKSwKKwlCQ002MzYyX0dST1VQKGdwaW8xKSwKKwlCQ002MzYyX0dST1VQKGdwaW8y KSwKKwlCQ002MzYyX0dST1VQKGdwaW8zKSwKKwlCQ002MzYyX0dST1VQKGdwaW80KSwKKwlCQ002 MzYyX0dST1VQKGdwaW81KSwKKwlCQ002MzYyX0dST1VQKGdwaW82KSwKKwlCQ002MzYyX0dST1VQ KGdwaW83KSwKKwlCQ002MzYyX0dST1VQKGdwaW84KSwKKwlCQ002MzYyX0dST1VQKGdwaW85KSwK KwlCQ002MzYyX0dST1VQKGdwaW8xMCksCisJQkNNNjM2Ml9HUk9VUChncGlvMTEpLAorCUJDTTYz NjJfR1JPVVAoZ3BpbzEyKSwKKwlCQ002MzYyX0dST1VQKGdwaW8xMyksCisJQkNNNjM2Ml9HUk9V UChncGlvMTQpLAorCUJDTTYzNjJfR1JPVVAoZ3BpbzE1KSwKKwlCQ002MzYyX0dST1VQKGdwaW8x NiksCisJQkNNNjM2Ml9HUk9VUChncGlvMTcpLAorCUJDTTYzNjJfR1JPVVAoZ3BpbzE4KSwKKwlC Q002MzYyX0dST1VQKGdwaW8xOSksCisJQkNNNjM2Ml9HUk9VUChncGlvMjApLAorCUJDTTYzNjJf R1JPVVAoZ3BpbzIxKSwKKwlCQ002MzYyX0dST1VQKGdwaW8yMiksCisJQkNNNjM2Ml9HUk9VUChn cGlvMjMpLAorCUJDTTYzNjJfR1JPVVAoZ3BpbzI0KSwKKwlCQ002MzYyX0dST1VQKGdwaW8yNSks CisJQkNNNjM2Ml9HUk9VUChncGlvMjYpLAorCUJDTTYzNjJfR1JPVVAoZ3BpbzI3KSwKKwlCQ002 MzYyX0dST1VQKGdwaW8yOCksCisJQkNNNjM2Ml9HUk9VUChncGlvMjkpLAorCUJDTTYzNjJfR1JP VVAoZ3BpbzMwKSwKKwlCQ002MzYyX0dST1VQKGdwaW8zMSksCisJQkNNNjM2Ml9HUk9VUChncGlv MzIpLAorCUJDTTYzNjJfR1JPVVAoZ3BpbzMzKSwKKwlCQ002MzYyX0dST1VQKGdwaW8zNCksCisJ QkNNNjM2Ml9HUk9VUChncGlvMzUpLAorCUJDTTYzNjJfR1JPVVAoZ3BpbzM2KSwKKwlCQ002MzYy X0dST1VQKGdwaW8zNyksCisJQkNNNjM2Ml9HUk9VUChncGlvMzgpLAorCUJDTTYzNjJfR1JPVVAo Z3BpbzM5KSwKKwlCQ002MzYyX0dST1VQKGdwaW80MCksCisJQkNNNjM2Ml9HUk9VUChncGlvNDEp LAorCUJDTTYzNjJfR1JPVVAoZ3BpbzQyKSwKKwlCQ002MzYyX0dST1VQKGdwaW80MyksCisJQkNN NjM2Ml9HUk9VUChncGlvNDQpLAorCUJDTTYzNjJfR1JPVVAoZ3BpbzQ1KSwKKwlCQ002MzYyX0dS T1VQKGdwaW80NiksCisJQkNNNjM2Ml9HUk9VUChncGlvNDcpLAorCUJDTTYzNjJfR1JPVVAobmFu ZF9ncnApLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBsZWRfZ3JvdXBzW10gPSB7 CisJImdwaW8wIiwKKwkiZ3BpbzEiLAorCSJncGlvMiIsCisJImdwaW8zIiwKKwkiZ3BpbzQiLAor CSJncGlvNSIsCisJImdwaW82IiwKKwkiZ3BpbzciLAorCSJncGlvOCIsCisJImdwaW85IiwKKwki Z3BpbzEwIiwKKwkiZ3BpbzExIiwKKwkiZ3BpbzEyIiwKKwkiZ3BpbzEzIiwKKwkiZ3BpbzE0IiwK KwkiZ3BpbzE1IiwKKwkiZ3BpbzE2IiwKKwkiZ3BpbzE3IiwKKwkiZ3BpbzE4IiwKKwkiZ3BpbzE5 IiwKKwkiZ3BpbzIwIiwKKwkiZ3BpbzIxIiwKKwkiZ3BpbzIyIiwKKwkiZ3BpbzIzIiwKK307CisK K3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgdXNiX2RldmljZV9sZWRfZ3JvdXBzW10gPSB7CisJ ImdwaW8wIiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3Qgc3lzX2lycV9ncm91cHNb XSA9IHsKKwkiZ3BpbzEiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBzZXJpYWxf bGVkX2Nsa19ncm91cHNbXSA9IHsKKwkiZ3BpbzIiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIg KiBjb25zdCBzZXJpYWxfbGVkX2RhdGFfZ3JvdXBzW10gPSB7CisJImdwaW8zIiwKK307CisKK3N0 YXRpYyBjb25zdCBjaGFyICogY29uc3Qgcm9ib3N3X2xlZF9kYXRhX2dyb3Vwc1tdID0geworCSJn cGlvNCIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHJvYm9zd19sZWRfY2xrX2dy b3Vwc1tdID0geworCSJncGlvNSIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHJv Ym9zd19sZWQwX2dyb3Vwc1tdID0geworCSJncGlvNiIsCit9OworCitzdGF0aWMgY29uc3QgY2hh ciAqIGNvbnN0IHJvYm9zd19sZWQxX2dyb3Vwc1tdID0geworCSJncGlvNyIsCit9OworCitzdGF0 aWMgY29uc3QgY2hhciAqIGNvbnN0IGluZXRfbGVkX2dyb3Vwc1tdID0geworCSJncGlvOCIsCit9 OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHNwaV9jczJfZ3JvdXBzW10gPSB7CisJImdw aW85IiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3Qgc3BpX2NzM19ncm91cHNbXSA9 IHsKKwkiZ3BpbzEwIiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgbnRyX3B1bHNl X2dyb3Vwc1tdID0geworCSJncGlvMTEiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25z dCB1YXJ0MV9zY3RzX2dyb3Vwc1tdID0geworCSJncGlvMTIiLAorfTsKKworc3RhdGljIGNvbnN0 IGNoYXIgKiBjb25zdCB1YXJ0MV9zcnRzX2dyb3Vwc1tdID0geworCSJncGlvMTMiLAorfTsKKwor c3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCB1YXJ0MV9zZGluX2dyb3Vwc1tdID0geworCSJncGlv MTQiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCB1YXJ0MV9zZG91dF9ncm91cHNb XSA9IHsKKwkiZ3BpbzE1IiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgYWRzbF9z cGlfbWlzb19ncm91cHNbXSA9IHsKKwkiZ3BpbzE2IiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFy ICogY29uc3QgYWRzbF9zcGlfbW9zaV9ncm91cHNbXSA9IHsKKwkiZ3BpbzE3IiwKK307CisKK3N0 YXRpYyBjb25zdCBjaGFyICogY29uc3QgYWRzbF9zcGlfY2xrX2dyb3Vwc1tdID0geworCSJncGlv MTgiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBhZHNsX3NwaV9jc19ncm91cHNb XSA9IHsKKwkiZ3BpbzE5IiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgZXBoeTBf bGVkX2dyb3Vwc1tdID0geworCSJncGlvMjAiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBj b25zdCBlcGh5MV9sZWRfZ3JvdXBzW10gPSB7CisJImdwaW8yMSIsCit9OworCitzdGF0aWMgY29u c3QgY2hhciAqIGNvbnN0IGVwaHkyX2xlZF9ncm91cHNbXSA9IHsKKwkiZ3BpbzIyIiwKK307CisK K3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgZXBoeTNfbGVkX2dyb3Vwc1tdID0geworCSJncGlv MjMiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBleHRfaXJxMF9ncm91cHNbXSA9 IHsKKwkiZ3BpbzI0IiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgZXh0X2lycTFf Z3JvdXBzW10gPSB7CisJImdwaW8yNSIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0 IGV4dF9pcnEyX2dyb3Vwc1tdID0geworCSJncGlvMjYiLAorfTsKKworc3RhdGljIGNvbnN0IGNo YXIgKiBjb25zdCBleHRfaXJxM19ncm91cHNbXSA9IHsKKwkiZ3BpbzI3IiwKK307CisKK3N0YXRp YyBjb25zdCBjaGFyICogY29uc3Qgd2lmaV9ncm91cHNbXSA9IHsKKwkiZ3BpbzMyIiwKKwkiZ3Bp bzMzIiwKKwkiZ3BpbzM0IiwKKwkiZ3BpbzM1IiwKKwkiZ3BpbzM2IiwKKwkiZ3BpbzM3IiwKKwki Z3BpbzM4IiwKKwkiZ3BpbzM5IiwKKwkiZ3BpbzQwIiwKKwkiZ3BpbzQxIiwKKwkiZ3BpbzQyIiwK KwkiZ3BpbzQzIiwKKwkiZ3BpbzQ0IiwKKwkiZ3BpbzQ1IiwKKwkiZ3BpbzQ2IiwKKwkiZ3BpbzQ3 IiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgbmFuZF9ncm91cHNbXSA9IHsKKwki bmFuZF9ncnAiLAorfTsKKworI2RlZmluZSBCQ002MzYyX0xFRF9GVU4obikJCQkJXAorCXsJCQkJ CQlcCisJCS5uYW1lID0gI24sCQkJCVwKKwkJLmdyb3VwcyA9IG4jI19ncm91cHMsCQkJXAorCQku bnVtX2dyb3VwcyA9IEFSUkFZX1NJWkUobiMjX2dyb3VwcyksCVwKKwkJLnJlZyA9IEJDTTYzNjJf TEVEQ1RSTCwJCQlcCisJfQorCisjZGVmaW5lIEJDTTYzNjJfTU9ERV9GVU4obikJCQkJXAorCXsJ CQkJCQlcCisJCS5uYW1lID0gI24sCQkJCVwKKwkJLmdyb3VwcyA9IG4jI19ncm91cHMsCQkJXAor CQkubnVtX2dyb3VwcyA9IEFSUkFZX1NJWkUobiMjX2dyb3VwcyksCVwKKwkJLnJlZyA9IEJDTTYz NjJfTU9ERSwJCQlcCisJfQorCisjZGVmaW5lIEJDTTYzNjJfQ1RSTF9GVU4obikJCQkJXAorCXsJ CQkJCQlcCisJCS5uYW1lID0gI24sCQkJCVwKKwkJLmdyb3VwcyA9IG4jI19ncm91cHMsCQkJXAor CQkubnVtX2dyb3VwcyA9IEFSUkFZX1NJWkUobiMjX2dyb3VwcyksCVwKKwkJLnJlZyA9IEJDTTYz NjJfQ1RSTCwJCQlcCisJfQorCisjZGVmaW5lIEJDTTYzNjJfQkFTRU1PREVfRlVOKG4sIG1hc2sp CQkJXAorCXsJCQkJCQlcCisJCS5uYW1lID0gI24sCQkJCVwKKwkJLmdyb3VwcyA9IG4jI19ncm91 cHMsCQkJXAorCQkubnVtX2dyb3VwcyA9IEFSUkFZX1NJWkUobiMjX2dyb3VwcyksCVwKKwkJLnJl ZyA9IEJDTTYzNjJfQkFTRU1PREUsCQlcCisJCS5iYXNlbW9kZV9tYXNrID0gKG1hc2spLAkJXAor CX0KKworc3RhdGljIGNvbnN0IHN0cnVjdCBiY202MzYyX2Z1bmN0aW9uIGJjbTYzNjJfZnVuY3Nb XSA9IHsKKwlCQ002MzYyX0xFRF9GVU4obGVkKSwKKwlCQ002MzYyX01PREVfRlVOKHVzYl9kZXZp Y2VfbGVkKSwKKwlCQ002MzYyX01PREVfRlVOKHN5c19pcnEpLAorCUJDTTYzNjJfTU9ERV9GVU4o c2VyaWFsX2xlZF9jbGspLAorCUJDTTYzNjJfTU9ERV9GVU4oc2VyaWFsX2xlZF9kYXRhKSwKKwlC Q002MzYyX01PREVfRlVOKHJvYm9zd19sZWRfZGF0YSksCisJQkNNNjM2Ml9NT0RFX0ZVTihyb2Jv c3dfbGVkX2NsayksCisJQkNNNjM2Ml9NT0RFX0ZVTihyb2Jvc3dfbGVkMCksCisJQkNNNjM2Ml9N T0RFX0ZVTihyb2Jvc3dfbGVkMSksCisJQkNNNjM2Ml9NT0RFX0ZVTihpbmV0X2xlZCksCisJQkNN NjM2Ml9NT0RFX0ZVTihzcGlfY3MyKSwKKwlCQ002MzYyX01PREVfRlVOKHNwaV9jczMpLAorCUJD TTYzNjJfTU9ERV9GVU4obnRyX3B1bHNlKSwKKwlCQ002MzYyX01PREVfRlVOKHVhcnQxX3NjdHMp LAorCUJDTTYzNjJfTU9ERV9GVU4odWFydDFfc3J0cyksCisJQkNNNjM2Ml9NT0RFX0ZVTih1YXJ0 MV9zZGluKSwKKwlCQ002MzYyX01PREVfRlVOKHVhcnQxX3Nkb3V0KSwKKwlCQ002MzYyX01PREVf RlVOKGFkc2xfc3BpX21pc28pLAorCUJDTTYzNjJfTU9ERV9GVU4oYWRzbF9zcGlfbW9zaSksCisJ QkNNNjM2Ml9NT0RFX0ZVTihhZHNsX3NwaV9jbGspLAorCUJDTTYzNjJfTU9ERV9GVU4oYWRzbF9z cGlfY3MpLAorCUJDTTYzNjJfTU9ERV9GVU4oZXBoeTBfbGVkKSwKKwlCQ002MzYyX01PREVfRlVO KGVwaHkxX2xlZCksCisJQkNNNjM2Ml9NT0RFX0ZVTihlcGh5Ml9sZWQpLAorCUJDTTYzNjJfTU9E RV9GVU4oZXBoeTNfbGVkKSwKKwlCQ002MzYyX01PREVfRlVOKGV4dF9pcnEwKSwKKwlCQ002MzYy X01PREVfRlVOKGV4dF9pcnExKSwKKwlCQ002MzYyX01PREVfRlVOKGV4dF9pcnEyKSwKKwlCQ002 MzYyX01PREVfRlVOKGV4dF9pcnEzKSwKKwlCQ002MzYyX0NUUkxfRlVOKHdpZmkpLAorCUJDTTYz NjJfQkFTRU1PREVfRlVOKG5hbmQsIEJBU0VNT0RFX05BTkQpLAorfTsKKworc3RhdGljIGludCBi Y202MzYyX3BpbmN0cmxfZ2V0X2dyb3VwX2NvdW50KHN0cnVjdCBwaW5jdHJsX2RldiAqcGN0bGRl dikKK3sKKwlyZXR1cm4gQVJSQVlfU0laRShiY202MzYyX2dyb3Vwcyk7Cit9CisKK3N0YXRpYyBj b25zdCBjaGFyICpiY202MzYyX3BpbmN0cmxfZ2V0X2dyb3VwX25hbWUoc3RydWN0IHBpbmN0cmxf ZGV2ICpwY3RsZGV2LAorCQkJCQkJICB1bnNpZ25lZCBncm91cCkKK3sKKwlyZXR1cm4gYmNtNjM2 Ml9ncm91cHNbZ3JvdXBdLm5hbWU7Cit9CisKK3N0YXRpYyBpbnQgYmNtNjM2Ml9waW5jdHJsX2dl dF9ncm91cF9waW5zKHN0cnVjdCBwaW5jdHJsX2RldiAqcGN0bGRldiwKKwkJCQkJICB1bnNpZ25l ZCBncm91cCwgY29uc3QgdW5zaWduZWQgKipwaW5zLAorCQkJCQkgIHVuc2lnbmVkICpudW1fcGlu cykKK3sKKwkqcGlucyA9IGJjbTYzNjJfZ3JvdXBzW2dyb3VwXS5waW5zOworCSpudW1fcGlucyA9 IGJjbTYzNjJfZ3JvdXBzW2dyb3VwXS5udW1fcGluczsKKworCXJldHVybiAwOworfQorCitzdGF0 aWMgaW50IGJjbTYzNjJfcGluY3RybF9nZXRfZnVuY19jb3VudChzdHJ1Y3QgcGluY3RybF9kZXYg KnBjdGxkZXYpCit7CisJcmV0dXJuIEFSUkFZX1NJWkUoYmNtNjM2Ml9mdW5jcyk7Cit9CisKK3N0 YXRpYyBjb25zdCBjaGFyICpiY202MzYyX3BpbmN0cmxfZ2V0X2Z1bmNfbmFtZShzdHJ1Y3QgcGlu Y3RybF9kZXYgKnBjdGxkZXYsCisJCQkJCQkgdW5zaWduZWQgc2VsZWN0b3IpCit7CisJcmV0dXJu IGJjbTYzNjJfZnVuY3Nbc2VsZWN0b3JdLm5hbWU7Cit9CisKK3N0YXRpYyBpbnQgYmNtNjM2Ml9w aW5jdHJsX2dldF9ncm91cHMoc3RydWN0IHBpbmN0cmxfZGV2ICpwY3RsZGV2LAorCQkJCSAgICAg IHVuc2lnbmVkIHNlbGVjdG9yLAorCQkJCSAgICAgIGNvbnN0IGNoYXIgKiBjb25zdCAqKmdyb3Vw cywKKwkJCQkgICAgICB1bnNpZ25lZCAqIGNvbnN0IG51bV9ncm91cHMpCit7CisJKmdyb3VwcyA9 IGJjbTYzNjJfZnVuY3Nbc2VsZWN0b3JdLmdyb3VwczsKKwkqbnVtX2dyb3VwcyA9IGJjbTYzNjJf ZnVuY3Nbc2VsZWN0b3JdLm51bV9ncm91cHM7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHZv aWQgYmNtNjM2Ml9zZXRfZ3BpbyhzdHJ1Y3QgYmNtNjN4eF9waW5jdHJsICpwYywgdW5zaWduZWQg cGluKQoreworCWNvbnN0IHN0cnVjdCBwaW5jdHJsX3Bpbl9kZXNjICpkZXNjID0gJmJjbTYzNjJf cGluc1twaW5dOworCXVuc2lnbmVkIGludCBtYXNrID0gYmNtNjN4eF9iYW5rX3BpbihwaW4pOwor CisJaWYgKGRlc2MtPmRydl9kYXRhKQorCQlyZWdtYXBfdXBkYXRlX2JpdHMocGMtPnJlZ3MsIEJD TTYzNjJfQkFTRU1PREVfUkVHLAorCQkJCSAgICh1aW50MzJfdCkgZGVzYy0+ZHJ2X2RhdGEsIDAp OworCisJaWYgKHBpbiA8IEJDTTYzWFhfQkFOS19HUElPUykgeworCQkvKiBiYXNlIG1vZGUgMCA9 PiBncGlvIDEgPT4gbXV4IGZ1bmN0aW9uICovCisJCXJlZ21hcF91cGRhdGVfYml0cyhwYy0+cmVn cywgQkNNNjM2Ml9NT0RFX1JFRywgbWFzaywgMCk7CisKKwkJLyogcGlucyAwLTIzIG1pZ2h0IGJl IG11eGVkIHRvIGxlZCAqLworCQlpZiAocGluIDwgQkNNNjM2Ml9OVU1fTEVEUykKKwkJCXJlZ21h cF91cGRhdGVfYml0cyhwYy0+cmVncywgQkNNNjM2Ml9MRURfUkVHLCBtYXNrLCAwKTsKKwl9IGVs c2UgeworCQkvKiBjdHJsIHJlZyAwID0+IHdpZmkgZnVuY3Rpb24gMSA9PiBncGlvICovCisJCXJl Z21hcF91cGRhdGVfYml0cyhwYy0+cmVncywgQkNNNjM2Ml9DVFJMX1JFRywgbWFzaywgbWFzayk7 CisJfQorfQorCitzdGF0aWMgaW50IGJjbTYzNjJfcGluY3RybF9zZXRfbXV4KHN0cnVjdCBwaW5j dHJsX2RldiAqcGN0bGRldiwKKwkJCQkgICB1bnNpZ25lZCBzZWxlY3RvciwgdW5zaWduZWQgZ3Jv dXApCit7CisJc3RydWN0IGJjbTYzeHhfcGluY3RybCAqcGMgPSBwaW5jdHJsX2Rldl9nZXRfZHJ2 ZGF0YShwY3RsZGV2KTsKKwljb25zdCBzdHJ1Y3QgYmNtNjM2Ml9waW5ncm91cCAqcGcgPSAmYmNt NjM2Ml9ncm91cHNbZ3JvdXBdOworCWNvbnN0IHN0cnVjdCBiY202MzYyX2Z1bmN0aW9uICpmID0g JmJjbTYzNjJfZnVuY3Nbc2VsZWN0b3JdOworCXVuc2lnbmVkIGk7CisJdW5zaWduZWQgaW50IHJl ZzsKKwl1bnNpZ25lZCBpbnQgdmFsLCBtYXNrOworCisJZm9yIChpID0gMDsgaSA8IHBnLT5udW1f cGluczsgaSsrKQorCQliY202MzYyX3NldF9ncGlvKHBjLCBwZy0+cGluc1tpXSk7CisKKwlzd2l0 Y2ggKGYtPnJlZykgeworCWNhc2UgQkNNNjM2Ml9MRURDVFJMOgorCQlyZWcgPSBCQ002MzYyX0xF RF9SRUc7CisJCW1hc2sgPSBCSVQocGctPnBpbnNbMF0pOworCQl2YWwgPSBCSVQocGctPnBpbnNb MF0pOworCQlicmVhazsKKwljYXNlIEJDTTYzNjJfTU9ERToKKwkJcmVnID0gQkNNNjM2Ml9NT0RF X1JFRzsKKwkJbWFzayA9IEJJVChwZy0+cGluc1swXSk7CisJCXZhbCA9IEJJVChwZy0+cGluc1sw XSk7CisJCWJyZWFrOworCWNhc2UgQkNNNjM2Ml9DVFJMOgorCQlyZWcgPSBCQ002MzYyX0NUUkxf UkVHOworCQltYXNrID0gQklUKHBnLT5waW5zWzBdKTsKKwkJdmFsID0gMDsKKwkJYnJlYWs7CisJ Y2FzZSBCQ002MzYyX0JBU0VNT0RFOgorCQlyZWcgPSBCQ002MzYyX0JBU0VNT0RFX1JFRzsKKwkJ bWFzayA9IGYtPmJhc2Vtb2RlX21hc2s7CisJCXZhbCA9IGYtPmJhc2Vtb2RlX21hc2s7CisJCWJy ZWFrOworCWRlZmF1bHQ6CisJCVdBUk5fT04oMSk7CisJCXJldHVybiAtRUlOVkFMOworCX0KKwor CXJlZ21hcF91cGRhdGVfYml0cyhwYy0+cmVncywgcmVnLCBtYXNrLCB2YWwpOworCisJcmV0dXJu IDA7Cit9CisKK3N0YXRpYyBpbnQgYmNtNjM2Ml9ncGlvX3JlcXVlc3RfZW5hYmxlKHN0cnVjdCBw aW5jdHJsX2RldiAqcGN0bGRldiwKKwkJCQkgICAgICAgc3RydWN0IHBpbmN0cmxfZ3Bpb19yYW5n ZSAqcmFuZ2UsCisJCQkJICAgICAgIHVuc2lnbmVkIG9mZnNldCkKK3sKKwlzdHJ1Y3QgYmNtNjN4 eF9waW5jdHJsICpwYyA9IHBpbmN0cmxfZGV2X2dldF9kcnZkYXRhKHBjdGxkZXYpOworCisJLyog ZGlzYWJsZSBhbGwgZnVuY3Rpb25zIHVzaW5nIHRoaXMgcGluICovCisJYmNtNjM2Ml9zZXRfZ3Bp byhwYywgb2Zmc2V0KTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgc3RydWN0IHBpbmN0cmxf b3BzIGJjbTYzNjJfcGN0bF9vcHMgPSB7CisJLmR0X2ZyZWVfbWFwID0gcGluY3RybF91dGlsc19m cmVlX21hcCwKKwkuZHRfbm9kZV90b19tYXAgPSBwaW5jb25mX2dlbmVyaWNfZHRfbm9kZV90b19t YXBfcGluLAorCS5nZXRfZ3JvdXBfbmFtZSA9IGJjbTYzNjJfcGluY3RybF9nZXRfZ3JvdXBfbmFt ZSwKKwkuZ2V0X2dyb3VwX3BpbnMgPSBiY202MzYyX3BpbmN0cmxfZ2V0X2dyb3VwX3BpbnMsCisJ LmdldF9ncm91cHNfY291bnQgPSBiY202MzYyX3BpbmN0cmxfZ2V0X2dyb3VwX2NvdW50LAorfTsK Kworc3RhdGljIHN0cnVjdCBwaW5tdXhfb3BzIGJjbTYzNjJfcG14X29wcyA9IHsKKwkuZ2V0X2Z1 bmN0aW9uX2dyb3VwcyA9IGJjbTYzNjJfcGluY3RybF9nZXRfZ3JvdXBzLAorCS5nZXRfZnVuY3Rp b25fbmFtZSA9IGJjbTYzNjJfcGluY3RybF9nZXRfZnVuY19uYW1lLAorCS5nZXRfZnVuY3Rpb25z X2NvdW50ID0gYmNtNjM2Ml9waW5jdHJsX2dldF9mdW5jX2NvdW50LAorCS5ncGlvX3JlcXVlc3Rf ZW5hYmxlID0gYmNtNjM2Ml9ncGlvX3JlcXVlc3RfZW5hYmxlLAorCS5zZXRfbXV4ID0gYmNtNjM2 Ml9waW5jdHJsX3NldF9tdXgsCisJLnN0cmljdCA9IHRydWUsCit9OworCitzdGF0aWMgY29uc3Qg c3RydWN0IGJjbTYzeHhfcGluY3RybF9zb2MgYmNtNjM2Ml9zb2MgPSB7CisJLm5ncGlvcyA9IEJD TTYzNjJfTlVNX0dQSU9TLAorCS5ucGlucyA9IEFSUkFZX1NJWkUoYmNtNjM2Ml9waW5zKSwKKwku cGN0bF9vcHMgPSAmYmNtNjM2Ml9wY3RsX29wcywKKwkucGlucyA9IGJjbTYzNjJfcGlucywKKwku cG14X29wcyA9ICZiY202MzYyX3BteF9vcHMsCit9OworCitzdGF0aWMgaW50IGJjbTYzNjJfcGlu Y3RybF9wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQoreworCXJldHVybiBiY202 M3h4X3BpbmN0cmxfcHJvYmUocGRldiwgJmJjbTYzNjJfc29jLCBOVUxMKTsKK30KKworc3RhdGlj IGNvbnN0IHN0cnVjdCBvZl9kZXZpY2VfaWQgYmNtNjM2Ml9waW5jdHJsX21hdGNoW10gPSB7CisJ eyAuY29tcGF0aWJsZSA9ICJicmNtLGJjbTYzNjItcGluY3RybCIsIH0sCisJeyAvKiBzZW50aW5l bCAqLyB9Cit9OworCitzdGF0aWMgc3RydWN0IHBsYXRmb3JtX2RyaXZlciBiY202MzYyX3BpbmN0 cmxfZHJpdmVyID0geworCS5wcm9iZSA9IGJjbTYzNjJfcGluY3RybF9wcm9iZSwKKwkuZHJpdmVy ID0geworCQkubmFtZSA9ICJiY202MzYyLXBpbmN0cmwiLAorCQkub2ZfbWF0Y2hfdGFibGUgPSBi Y202MzYyX3BpbmN0cmxfbWF0Y2gsCisJfSwKK307CisKK2J1aWx0aW5fcGxhdGZvcm1fZHJpdmVy KGJjbTYzNjJfcGluY3RybF9kcml2ZXIpOwotLSAKMi4yMC4xCgoKX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX18KbGludXgtYXJtLWtlcm5lbCBtYWlsaW5nIGxp c3QKbGludXgtYXJtLWtlcm5lbEBsaXN0cy5pbmZyYWRlYWQub3JnCmh0dHA6Ly9saXN0cy5pbmZy YWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vbGludXgtYXJtLWtlcm5lbAo=