From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-15.7 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_NONE,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 08A9FC4332D for ; Wed, 24 Mar 2021 08:20:52 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id DED05619AE for ; Wed, 24 Mar 2021 08:20:51 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S236121AbhCXIUW (ORCPT ); Wed, 24 Mar 2021 04:20:22 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:54038 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233580AbhCXITo (ORCPT ); Wed, 24 Mar 2021 04:19:44 -0400 Received: from mail-wm1-x32d.google.com (mail-wm1-x32d.google.com [IPv6:2a00:1450:4864:20::32d]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 688FCC0613DC; Wed, 24 Mar 2021 01:19:43 -0700 (PDT) Received: by mail-wm1-x32d.google.com with SMTP id y124-20020a1c32820000b029010c93864955so630564wmy.5; Wed, 24 Mar 2021 01:19:43 -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=nBekn0zB4O7mrv13ZxVYMfLLI+quIkOdXbfpsLxsNSc=; b=Jjuqp/jOipLUburufXtKsHyTfXOell+WNZo+9iMRdjCmU9VHkQwAZrvNbSq3ksGWff 1KIp2Y89iqVH/5Fd87/3MVEdgRriMNqNncX3oZcXgkoO/19Nwj1mg3Wq81L+C2JD8Msh XgeH2R19rn3qz9s9+tuej23XipOnfjkj7tqfIyhdvSuhgi08HU9iT98F29dtcheUblvi WTbOjtmw81fj2xPW8GkvI6PJZAFpi62FlcWSr/jXh77E1OmEwRjWA9XI0b1EVlPD1Jgm Ji6ojf0Up4PisXGsVJSYhmkm6fCVpg3vMQK2s2AhF8odt97bQHDEUfUOdZJx1NKQyK9m 6PLA== 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=nBekn0zB4O7mrv13ZxVYMfLLI+quIkOdXbfpsLxsNSc=; b=W6oq/iGPFr3tZpEeYzrZI0koH/Ii6nJmSIiXEtVq1yOrasJ2AOebY29RQL0gXkyYZJ cT0P7X8fOLcKyqpCSqhJ47O1Ghga/WLIJwLN8Ej1v5oO6orZXh0hnbMymFFUczpKt7pl l9vF4WgTA0OB88DXlROfgtuXGcP2NNvsm09L3gGEksGysvOTmmNFQlBbAsyedDQyIWDL s7v/YCfZ3FG+BUv4cnOZjw+/EA+9JyVUtr7lv+WWn+dd9lhjp22+02B5bF25JCQjkfrK BfjESlAx2lw4UJPSafoAM+YjfbUf4QyJtlaiXmNkgE2a53EaicZttkmAVx51MR2+aKWW avzw== X-Gm-Message-State: AOAM531RkXDXwh67k3ooCSThDzC2jwE8XDMJXZqcg6WfstoBvA4cyeZn k3XPsXIEd4mJ/L38mgR0Fbc= X-Google-Smtp-Source: ABdhPJzRrBBvfBaZdEHKiLtOz47i9pizukZpmTA1FggYs9X0vBnL9/g38DDj2kmToKFCtp68hOMPYA== X-Received: by 2002:a1c:5f54:: with SMTP id t81mr1719018wmb.84.1616573982070; Wed, 24 Mar 2021 01:19:42 -0700 (PDT) Received: from skynet.lan (51.red-83-44-13.dynamicip.rima-tde.net. [83.44.13.51]) by smtp.gmail.com with ESMTPSA id x25sm1498578wmj.14.2021.03.24.01.19.41 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 24 Mar 2021 01:19:41 -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 v9 16/22] pinctrl: add a pincontrol driver for BCM6368 Date: Wed, 24 Mar 2021 09:19:17 +0100 Message-Id: <20210324081923.20379-17-noltari@gmail.com> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20210324081923.20379-1-noltari@gmail.com> References: <20210324081923.20379-1-noltari@gmail.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-gpio@vger.kernel.org Add a pincontrol driver for BCM6368. BCM6368 allows muxing the first 32 GPIOs onto alternative functions. Not all are documented. Co-developed-by: Jonas Gorski Signed-off-by: Jonas Gorski Signed-off-by: Álvaro Fernández Rojas --- v9: no changes 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-bcm6368.c | 523 ++++++++++++++++++++++++++ 3 files changed, 532 insertions(+) create mode 100644 drivers/pinctrl/bcm/pinctrl-bcm6368.c diff --git a/drivers/pinctrl/bcm/Kconfig b/drivers/pinctrl/bcm/Kconfig index d3101d5e750f..aabd4b762aed 100644 --- a/drivers/pinctrl/bcm/Kconfig +++ b/drivers/pinctrl/bcm/Kconfig @@ -60,6 +60,14 @@ config PINCTRL_BCM6362 help Say Y here to enable the Broadcom BCM6362 GPIO driver. +config PINCTRL_BCM6368 + bool "Broadcom BCM6368 GPIO driver" + depends on (BMIPS_GENERIC || COMPILE_TEST) + select PINCTRL_BCM63XX + default BMIPS_GENERIC + help + Say Y here to enable the Broadcom BCM6368 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 b9b09e5b914c..a1331bb9680e 100644 --- a/drivers/pinctrl/bcm/Makefile +++ b/drivers/pinctrl/bcm/Makefile @@ -7,6 +7,7 @@ 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_BCM6368) += pinctrl-bcm6368.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-bcm6368.c b/drivers/pinctrl/bcm/pinctrl-bcm6368.c new file mode 100644 index 000000000000..838095f9e890 --- /dev/null +++ b/drivers/pinctrl/bcm/pinctrl-bcm6368.c @@ -0,0 +1,523 @@ +// SPDX-License-Identifier: GPL-2.0+ +/* + * Driver for BCM6368 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 BCM6368_NUM_GPIOS 38 + +#define BCM6368_MODE_REG 0x18 +#define BCM6368_BASEMODE_REG 0x38 +#define BCM6368_BASEMODE_MASK 0x7 +#define BCM6368_BASEMODE_GPIO 0x0 +#define BCM6368_BASEMODE_UART1 0x1 + +struct bcm6368_pingroup { + const char *name; + const unsigned * const pins; + const unsigned num_pins; +}; + +struct bcm6368_function { + const char *name; + const char * const *groups; + const unsigned num_groups; + + unsigned dir_out:16; + unsigned basemode:3; +}; + +struct bcm6368_priv { + struct regmap_field *overlays; +}; + +#define BCM6368_BASEMODE_PIN(a, b) \ + { \ + .number = a, \ + .name = b, \ + .drv_data = (void *)true \ + } + +static const struct pinctrl_pin_desc bcm6368_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"), + PINCTRL_PIN(8, "gpio8"), + PINCTRL_PIN(9, "gpio9"), + PINCTRL_PIN(10, "gpio10"), + PINCTRL_PIN(11, "gpio11"), + PINCTRL_PIN(12, "gpio12"), + PINCTRL_PIN(13, "gpio13"), + PINCTRL_PIN(14, "gpio14"), + PINCTRL_PIN(15, "gpio15"), + PINCTRL_PIN(16, "gpio16"), + PINCTRL_PIN(17, "gpio17"), + PINCTRL_PIN(18, "gpio18"), + PINCTRL_PIN(19, "gpio19"), + PINCTRL_PIN(20, "gpio20"), + PINCTRL_PIN(21, "gpio21"), + PINCTRL_PIN(22, "gpio22"), + PINCTRL_PIN(23, "gpio23"), + PINCTRL_PIN(24, "gpio24"), + PINCTRL_PIN(25, "gpio25"), + PINCTRL_PIN(26, "gpio26"), + PINCTRL_PIN(27, "gpio27"), + PINCTRL_PIN(28, "gpio28"), + PINCTRL_PIN(29, "gpio29"), + BCM6368_BASEMODE_PIN(30, "gpio30"), + BCM6368_BASEMODE_PIN(31, "gpio31"), + BCM6368_BASEMODE_PIN(32, "gpio32"), + BCM6368_BASEMODE_PIN(33, "gpio33"), + PINCTRL_PIN(34, "gpio34"), + PINCTRL_PIN(35, "gpio35"), + PINCTRL_PIN(36, "gpio36"), + PINCTRL_PIN(37, "gpio37"), +}; + +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 uart1_grp_pins[] = { 30, 31, 32, 33 }; + +#define BCM6368_GROUP(n) \ + { \ + .name = #n, \ + .pins = n##_pins, \ + .num_pins = ARRAY_SIZE(n##_pins), \ + } + +static struct bcm6368_pingroup bcm6368_groups[] = { + BCM6368_GROUP(gpio0), + BCM6368_GROUP(gpio1), + BCM6368_GROUP(gpio2), + BCM6368_GROUP(gpio3), + BCM6368_GROUP(gpio4), + BCM6368_GROUP(gpio5), + BCM6368_GROUP(gpio6), + BCM6368_GROUP(gpio7), + BCM6368_GROUP(gpio8), + BCM6368_GROUP(gpio9), + BCM6368_GROUP(gpio10), + BCM6368_GROUP(gpio11), + BCM6368_GROUP(gpio12), + BCM6368_GROUP(gpio13), + BCM6368_GROUP(gpio14), + BCM6368_GROUP(gpio15), + BCM6368_GROUP(gpio16), + BCM6368_GROUP(gpio17), + BCM6368_GROUP(gpio18), + BCM6368_GROUP(gpio19), + BCM6368_GROUP(gpio20), + BCM6368_GROUP(gpio21), + BCM6368_GROUP(gpio22), + BCM6368_GROUP(gpio23), + BCM6368_GROUP(gpio24), + BCM6368_GROUP(gpio25), + BCM6368_GROUP(gpio26), + BCM6368_GROUP(gpio27), + BCM6368_GROUP(gpio28), + BCM6368_GROUP(gpio29), + BCM6368_GROUP(gpio30), + BCM6368_GROUP(gpio31), + BCM6368_GROUP(uart1_grp), +}; + +static const char * const analog_afe_0_groups[] = { + "gpio0", +}; + +static const char * const analog_afe_1_groups[] = { + "gpio1", +}; + +static const char * const sys_irq_groups[] = { + "gpio2", +}; + +static const char * const serial_led_data_groups[] = { + "gpio3", +}; + +static const char * const serial_led_clk_groups[] = { + "gpio4", +}; + +static const char * const inet_led_groups[] = { + "gpio5", +}; + +static const char * const ephy0_led_groups[] = { + "gpio6", +}; + +static const char * const ephy1_led_groups[] = { + "gpio7", +}; + +static const char * const ephy2_led_groups[] = { + "gpio8", +}; + +static const char * const ephy3_led_groups[] = { + "gpio9", +}; + +static const char * const robosw_led_data_groups[] = { + "gpio10", +}; + +static const char * const robosw_led_clk_groups[] = { + "gpio11", +}; + +static const char * const robosw_led0_groups[] = { + "gpio12", +}; + +static const char * const robosw_led1_groups[] = { + "gpio13", +}; + +static const char * const usb_device_led_groups[] = { + "gpio14", +}; + +static const char * const pci_req1_groups[] = { + "gpio16", +}; + +static const char * const pci_gnt1_groups[] = { + "gpio17", +}; + +static const char * const pci_intb_groups[] = { + "gpio18", +}; + +static const char * const pci_req0_groups[] = { + "gpio19", +}; + +static const char * const pci_gnt0_groups[] = { + "gpio20", +}; + +static const char * const pcmcia_cd1_groups[] = { + "gpio22", +}; + +static const char * const pcmcia_cd2_groups[] = { + "gpio23", +}; + +static const char * const pcmcia_vs1_groups[] = { + "gpio24", +}; + +static const char * const pcmcia_vs2_groups[] = { + "gpio25", +}; + +static const char * const ebi_cs2_groups[] = { + "gpio26", +}; + +static const char * const ebi_cs3_groups[] = { + "gpio27", +}; + +static const char * const spi_cs2_groups[] = { + "gpio28", +}; + +static const char * const spi_cs3_groups[] = { + "gpio29", +}; + +static const char * const spi_cs4_groups[] = { + "gpio30", +}; + +static const char * const spi_cs5_groups[] = { + "gpio31", +}; + +static const char * const uart1_groups[] = { + "uart1_grp", +}; + +#define BCM6368_FUN(n, out) \ + { \ + .name = #n, \ + .groups = n##_groups, \ + .num_groups = ARRAY_SIZE(n##_groups), \ + .dir_out = out, \ + } + +#define BCM6368_BASEMODE_FUN(n, val, out) \ + { \ + .name = #n, \ + .groups = n##_groups, \ + .num_groups = ARRAY_SIZE(n##_groups), \ + .basemode = BCM6368_BASEMODE_##val, \ + .dir_out = out, \ + } + +static const struct bcm6368_function bcm6368_funcs[] = { + BCM6368_FUN(analog_afe_0, 1), + BCM6368_FUN(analog_afe_1, 1), + BCM6368_FUN(sys_irq, 1), + BCM6368_FUN(serial_led_data, 1), + BCM6368_FUN(serial_led_clk, 1), + BCM6368_FUN(inet_led, 1), + BCM6368_FUN(ephy0_led, 1), + BCM6368_FUN(ephy1_led, 1), + BCM6368_FUN(ephy2_led, 1), + BCM6368_FUN(ephy3_led, 1), + BCM6368_FUN(robosw_led_data, 1), + BCM6368_FUN(robosw_led_clk, 1), + BCM6368_FUN(robosw_led0, 1), + BCM6368_FUN(robosw_led1, 1), + BCM6368_FUN(usb_device_led, 1), + BCM6368_FUN(pci_req1, 0), + BCM6368_FUN(pci_gnt1, 0), + BCM6368_FUN(pci_intb, 0), + BCM6368_FUN(pci_req0, 0), + BCM6368_FUN(pci_gnt0, 0), + BCM6368_FUN(pcmcia_cd1, 0), + BCM6368_FUN(pcmcia_cd2, 0), + BCM6368_FUN(pcmcia_vs1, 0), + BCM6368_FUN(pcmcia_vs2, 0), + BCM6368_FUN(ebi_cs2, 1), + BCM6368_FUN(ebi_cs3, 1), + BCM6368_FUN(spi_cs2, 1), + BCM6368_FUN(spi_cs3, 1), + BCM6368_FUN(spi_cs4, 1), + BCM6368_FUN(spi_cs5, 1), + BCM6368_BASEMODE_FUN(uart1, UART1, 0x6), +}; + +static int bcm6368_pinctrl_get_group_count(struct pinctrl_dev *pctldev) +{ + return ARRAY_SIZE(bcm6368_groups); +} + +static const char *bcm6368_pinctrl_get_group_name(struct pinctrl_dev *pctldev, + unsigned group) +{ + return bcm6368_groups[group].name; +} + +static int bcm6368_pinctrl_get_group_pins(struct pinctrl_dev *pctldev, + unsigned group, const unsigned **pins, + unsigned *num_pins) +{ + *pins = bcm6368_groups[group].pins; + *num_pins = bcm6368_groups[group].num_pins; + + return 0; +} + +static int bcm6368_pinctrl_get_func_count(struct pinctrl_dev *pctldev) +{ + return ARRAY_SIZE(bcm6368_funcs); +} + +static const char *bcm6368_pinctrl_get_func_name(struct pinctrl_dev *pctldev, + unsigned selector) +{ + return bcm6368_funcs[selector].name; +} + +static int bcm6368_pinctrl_get_groups(struct pinctrl_dev *pctldev, + unsigned selector, + const char * const **groups, + unsigned * const num_groups) +{ + *groups = bcm6368_funcs[selector].groups; + *num_groups = bcm6368_funcs[selector].num_groups; + + return 0; +} + +static int bcm6368_pinctrl_set_mux(struct pinctrl_dev *pctldev, + unsigned selector, unsigned group) +{ + struct bcm63xx_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev); + struct bcm6368_priv *priv = pc->driver_data; + const struct bcm6368_pingroup *pg = &bcm6368_groups[group]; + const struct bcm6368_function *fun = &bcm6368_funcs[selector]; + int i, pin; + + if (fun->basemode) { + unsigned int mask = 0; + + for (i = 0; i < pg->num_pins; i++) { + pin = pg->pins[i]; + if (pin < BCM63XX_BANK_GPIOS) + mask |= BIT(pin); + } + + regmap_update_bits(pc->regs, BCM6368_MODE_REG, mask, 0); + regmap_field_write(priv->overlays, fun->basemode); + } else { + pin = pg->pins[0]; + + if (bcm6368_pins[pin].drv_data) + regmap_field_write(priv->overlays, + BCM6368_BASEMODE_GPIO); + + regmap_update_bits(pc->regs, BCM6368_MODE_REG, BIT(pin), + BIT(pin)); + } + + for (pin = 0; pin < pg->num_pins; pin++) { + struct pinctrl_gpio_range *range; + int hw_gpio = bcm6368_pins[pin].number; + + range = pinctrl_find_gpio_range_from_pin(pctldev, hw_gpio); + if (range) { + struct gpio_chip *gc = range->gc; + + if (fun->dir_out & BIT(pin)) + gc->direction_output(gc, hw_gpio, 0); + else + gc->direction_input(gc, hw_gpio); + } + } + + return 0; +} + +static int bcm6368_gpio_request_enable(struct pinctrl_dev *pctldev, + struct pinctrl_gpio_range *range, + unsigned offset) +{ + struct bcm63xx_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev); + struct bcm6368_priv *priv = pc->driver_data; + + if (offset >= BCM63XX_BANK_GPIOS && !bcm6368_pins[offset].drv_data) + return 0; + + /* disable all functions using this pin */ + if (offset < BCM63XX_BANK_GPIOS) + regmap_update_bits(pc->regs, BCM6368_MODE_REG, BIT(offset), 0); + + if (bcm6368_pins[offset].drv_data) + regmap_field_write(priv->overlays, BCM6368_BASEMODE_GPIO); + + return 0; +} + +static struct pinctrl_ops bcm6368_pctl_ops = { + .dt_free_map = pinctrl_utils_free_map, + .dt_node_to_map = pinconf_generic_dt_node_to_map_pin, + .get_group_name = bcm6368_pinctrl_get_group_name, + .get_group_pins = bcm6368_pinctrl_get_group_pins, + .get_groups_count = bcm6368_pinctrl_get_group_count, +}; + +static struct pinmux_ops bcm6368_pmx_ops = { + .get_function_groups = bcm6368_pinctrl_get_groups, + .get_function_name = bcm6368_pinctrl_get_func_name, + .get_functions_count = bcm6368_pinctrl_get_func_count, + .gpio_request_enable = bcm6368_gpio_request_enable, + .set_mux = bcm6368_pinctrl_set_mux, + .strict = true, +}; + +static const struct bcm63xx_pinctrl_soc bcm6368_soc = { + .ngpios = BCM6368_NUM_GPIOS, + .npins = ARRAY_SIZE(bcm6368_pins), + .pctl_ops = &bcm6368_pctl_ops, + .pins = bcm6368_pins, + .pmx_ops = &bcm6368_pmx_ops, +}; + +static int bcm6368_pinctrl_probe(struct platform_device *pdev) +{ + struct reg_field overlays = REG_FIELD(BCM6368_BASEMODE_REG, 0, 15); + struct device *dev = &pdev->dev; + struct bcm63xx_pinctrl *pc; + struct bcm6368_priv *priv; + int err; + + priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); + if (!priv) + return -ENOMEM; + + err = bcm63xx_pinctrl_probe(pdev, &bcm6368_soc, (void *) priv); + if (err) + return err; + + pc = platform_get_drvdata(pdev); + + priv->overlays = devm_regmap_field_alloc(dev, pc->regs, overlays); + if (IS_ERR(priv->overlays)) + return PTR_ERR(priv->overlays); + + return 0; +} + +static const struct of_device_id bcm6368_pinctrl_match[] = { + { .compatible = "brcm,bcm6368-pinctrl", }, + { /* sentinel */ } +}; + +static struct platform_driver bcm6368_pinctrl_driver = { + .probe = bcm6368_pinctrl_probe, + .driver = { + .name = "bcm6368-pinctrl", + .of_match_table = bcm6368_pinctrl_match, + }, +}; + +builtin_platform_driver(bcm6368_pinctrl_driver); -- 2.20.1 From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-13.7 required=3.0 tests=BAYES_00, DKIM_ADSP_CUSTOM_MED,DKIM_SIGNED,DKIM_VALID,FREEMAIL_FORGED_FROMDOMAIN, FREEMAIL_FROM,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER, INCLUDES_PATCH,MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED, USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 301D6C433DB for ; Wed, 24 Mar 2021 08:27:25 +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 145D3619C2 for ; Wed, 24 Mar 2021 08:27:24 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 145D3619C2 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=nHbgJYZMGBMtLvcF86VcPDqgsURoiAeTScYhS2YhNjg=; b=WogI2xRgEiF49BgWueDswllB4 2ZSwTAOKazi9hTVn3Vf8QJxkvX28/IeSV2w1dSJ30gIJrwnS6qya7s2mP+NjEpf0On+B4xnvzdDax LycMuQUkpFacAienJ5xM5C7SXSR7O7yDLc4IKa26vmW6BGS2nHxa18vMuO1DMyt9yn9glJjjFZ6Cs C2VoiigdE99QxumLbngfXXimYq+bMahX28pa+jW7Y5/vnSMbXzbOmrmyzjcRtOr5vO/2eL1IJnxah 76KvdsdNR8M/EXqxMxh7STk/TkKvsYgiLWfjX4NMM811AupnVhlXfaVEf5x8qtx8/tcvIoH3wdsvv Lvpp6QMgw==; Received: from localhost ([::1] helo=desiato.infradead.org) by desiato.infradead.org with esmtp (Exim 4.94 #2 (Red Hat Linux)) id 1lOyp0-00Gawl-Bs; Wed, 24 Mar 2021 08:24:59 +0000 Received: from mail-wm1-x332.google.com ([2a00:1450:4864:20::332]) by desiato.infradead.org with esmtps (Exim 4.94 #2 (Red Hat Linux)) id 1lOyju-00GYtL-Qg for linux-arm-kernel@lists.infradead.org; Wed, 24 Mar 2021 08:19:47 +0000 Received: by mail-wm1-x332.google.com with SMTP id j20-20020a05600c1914b029010f31e15a7fso650058wmq.1 for ; Wed, 24 Mar 2021 01:19:42 -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=nBekn0zB4O7mrv13ZxVYMfLLI+quIkOdXbfpsLxsNSc=; b=Jjuqp/jOipLUburufXtKsHyTfXOell+WNZo+9iMRdjCmU9VHkQwAZrvNbSq3ksGWff 1KIp2Y89iqVH/5Fd87/3MVEdgRriMNqNncX3oZcXgkoO/19Nwj1mg3Wq81L+C2JD8Msh XgeH2R19rn3qz9s9+tuej23XipOnfjkj7tqfIyhdvSuhgi08HU9iT98F29dtcheUblvi WTbOjtmw81fj2xPW8GkvI6PJZAFpi62FlcWSr/jXh77E1OmEwRjWA9XI0b1EVlPD1Jgm Ji6ojf0Up4PisXGsVJSYhmkm6fCVpg3vMQK2s2AhF8odt97bQHDEUfUOdZJx1NKQyK9m 6PLA== 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=nBekn0zB4O7mrv13ZxVYMfLLI+quIkOdXbfpsLxsNSc=; b=CYvIjBgipJo48Jm1a2e6zMa34Q3OviYbf9C/OVjo5G26iseLcxg2+43uTXxi3uuhkH nDXfzFo60qm+LaICOHJLISvDeMsQ8dT+tMXXI97ALhq2dKiKG2YueJRia/lMjJxceUqZ eThHXpm2xz2OzJq4s+xS7Qi4swZIvYbZVmaxUBcYfiYMdImw9CrmLmvxjDg/XPGYcJRW NwprIcWRAdIUcyXzzGefRY1321NMEjeVRt/jbZEbyFGup+2gSWFXPokW9j/8dizDGuKi dwGClfGS9KtJKgzPXOM8XAA5m9ysaahWFZqHzu/zN0vM4Pozs4n1aicNqCqFDjljmKqs 0X/Q== X-Gm-Message-State: AOAM5306ogQBQqvKrYqyC82TLaXLZ6e0ROl71frWo0IW98dmaGIoX077 prqLPAaV7HldDDEO6VT2Meo= X-Google-Smtp-Source: ABdhPJzRrBBvfBaZdEHKiLtOz47i9pizukZpmTA1FggYs9X0vBnL9/g38DDj2kmToKFCtp68hOMPYA== X-Received: by 2002:a1c:5f54:: with SMTP id t81mr1719018wmb.84.1616573982070; Wed, 24 Mar 2021 01:19:42 -0700 (PDT) Received: from skynet.lan (51.red-83-44-13.dynamicip.rima-tde.net. [83.44.13.51]) by smtp.gmail.com with ESMTPSA id x25sm1498578wmj.14.2021.03.24.01.19.41 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 24 Mar 2021 01:19:41 -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 v9 16/22] pinctrl: add a pincontrol driver for BCM6368 Date: Wed, 24 Mar 2021 09:19:17 +0100 Message-Id: <20210324081923.20379-17-noltari@gmail.com> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20210324081923.20379-1-noltari@gmail.com> References: <20210324081923.20379-1-noltari@gmail.com> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20210324_081943_068189_8B4C27CD X-CRM114-Status: GOOD ( 21.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 QWRkIGEgcGluY29udHJvbCBkcml2ZXIgZm9yIEJDTTYzNjguIEJDTTYzNjggYWxsb3dzIG11eGlu ZyB0aGUgZmlyc3QgMzIKR1BJT3Mgb250byBhbHRlcm5hdGl2ZSBmdW5jdGlvbnMuIE5vdCBhbGwg YXJlIGRvY3VtZW50ZWQuCgpDby1kZXZlbG9wZWQtYnk6IEpvbmFzIEdvcnNraSA8am9uYXMuZ29y c2tpQGdtYWlsLmNvbT4KU2lnbmVkLW9mZi1ieTogSm9uYXMgR29yc2tpIDxqb25hcy5nb3Jza2lA Z21haWwuY29tPgpTaWduZWQtb2ZmLWJ5OiDDgWx2YXJvIEZlcm7DoW5kZXogUm9qYXMgPG5vbHRh cmlAZ21haWwuY29tPgotLS0KIHY5OiBubyBjaGFuZ2VzCiB2ODogbm8gY2hhbmdlcwogdjc6IG5v IGNoYW5nZXMKIHY2OiBubyBjaGFuZ2VzCiB2NTogYWRkIGNoYW5nZXMgc3VnZ2VzdGVkIGJ5IEFu ZHkgU2hldmNoZW5rbwogdjQ6IG5vIGNoYW5nZXMKIHYzOiB1c2UgbmV3IHNoYXJlZCBjb2RlCiB2 Mjogc3dpdGNoIHRvIEdQSU9fUkVHTUFQCgogZHJpdmVycy9waW5jdHJsL2JjbS9LY29uZmlnICAg ICAgICAgICB8ICAgOCArCiBkcml2ZXJzL3BpbmN0cmwvYmNtL01ha2VmaWxlICAgICAgICAgIHwg ICAxICsKIGRyaXZlcnMvcGluY3RybC9iY20vcGluY3RybC1iY202MzY4LmMgfCA1MjMgKysrKysr KysrKysrKysrKysrKysrKysrKysKIDMgZmlsZXMgY2hhbmdlZCwgNTMyIGluc2VydGlvbnMoKykK IGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL3BpbmN0cmwvYmNtL3BpbmN0cmwtYmNtNjM2OC5j CgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9waW5jdHJsL2JjbS9LY29uZmlnIGIvZHJpdmVycy9waW5j dHJsL2JjbS9LY29uZmlnCmluZGV4IGQzMTAxZDVlNzUwZi4uYWFiZDRiNzYyYWVkIDEwMDY0NAot LS0gYS9kcml2ZXJzL3BpbmN0cmwvYmNtL0tjb25maWcKKysrIGIvZHJpdmVycy9waW5jdHJsL2Jj bS9LY29uZmlnCkBAIC02MCw2ICs2MCwxNCBAQCBjb25maWcgUElOQ1RSTF9CQ002MzYyCiAJaGVs cAogCSAgIFNheSBZIGhlcmUgdG8gZW5hYmxlIHRoZSBCcm9hZGNvbSBCQ002MzYyIEdQSU8gZHJp dmVyLgogCitjb25maWcgUElOQ1RSTF9CQ002MzY4CisJYm9vbCAiQnJvYWRjb20gQkNNNjM2OCBH UElPIGRyaXZlciIKKwlkZXBlbmRzIG9uIChCTUlQU19HRU5FUklDIHx8IENPTVBJTEVfVEVTVCkK KwlzZWxlY3QgUElOQ1RSTF9CQ002M1hYCisJZGVmYXVsdCBCTUlQU19HRU5FUklDCisJaGVscAor CSAgIFNheSBZIGhlcmUgdG8gZW5hYmxlIHRoZSBCcm9hZGNvbSBCQ002MzY4IEdQSU8gZHJpdmVy LgorCiBjb25maWcgUElOQ1RSTF9JUFJPQ19HUElPCiAJYm9vbCAiQnJvYWRjb20gaVByb2MgR1BJ TyAod2l0aCBQSU5DT05GKSBkcml2ZXIiCiAJZGVwZW5kcyBvbiBPRl9HUElPICYmIChBUkNIX0JD TV9JUFJPQyB8fCBDT01QSUxFX1RFU1QpCmRpZmYgLS1naXQgYS9kcml2ZXJzL3BpbmN0cmwvYmNt L01ha2VmaWxlIGIvZHJpdmVycy9waW5jdHJsL2JjbS9NYWtlZmlsZQppbmRleCBiOWIwOWU1Yjkx NGMuLmExMzMxYmI5NjgwZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9waW5jdHJsL2JjbS9NYWtlZmls ZQorKysgYi9kcml2ZXJzL3BpbmN0cmwvYmNtL01ha2VmaWxlCkBAIC03LDYgKzcsNyBAQCBvYmot JChDT05GSUdfUElOQ1RSTF9CQ002M1hYKQkJKz0gcGluY3RybC1iY202M3h4Lm8KIG9iai0kKENP TkZJR19QSU5DVFJMX0JDTTYzMjgpCQkrPSBwaW5jdHJsLWJjbTYzMjgubwogb2JqLSQoQ09ORklH X1BJTkNUUkxfQkNNNjM1OCkJCSs9IHBpbmN0cmwtYmNtNjM1OC5vCiBvYmotJChDT05GSUdfUElO Q1RSTF9CQ002MzYyKQkJKz0gcGluY3RybC1iY202MzYyLm8KK29iai0kKENPTkZJR19QSU5DVFJM X0JDTTYzNjgpCQkrPSBwaW5jdHJsLWJjbTYzNjgubwogb2JqLSQoQ09ORklHX1BJTkNUUkxfSVBS T0NfR1BJTykJKz0gcGluY3RybC1pcHJvYy1ncGlvLm8KIG9iai0kKENPTkZJR19QSU5DVFJMX0NZ R05VU19NVVgpCSs9IHBpbmN0cmwtY3lnbnVzLW11eC5vCiBvYmotJChDT05GSUdfUElOQ1RSTF9O UykJCSs9IHBpbmN0cmwtbnMubwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9waW5jdHJsL2JjbS9waW5j dHJsLWJjbTYzNjguYyBiL2RyaXZlcnMvcGluY3RybC9iY20vcGluY3RybC1iY202MzY4LmMKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi44MzgwOTVmOWU4OTAKLS0tIC9k ZXYvbnVsbAorKysgYi9kcml2ZXJzL3BpbmN0cmwvYmNtL3BpbmN0cmwtYmNtNjM2OC5jCkBAIC0w LDAgKzEsNTIzIEBACisvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMCsKKy8qCisg KiBEcml2ZXIgZm9yIEJDTTYzNjggR1BJTyB1bml0IChwaW5jdHJsICsgR1BJTykKKyAqCisgKiBD b3B5cmlnaHQgKEMpIDIwMjEgw4FsdmFybyBGZXJuw6FuZGV6IFJvamFzIDxub2x0YXJpQGdtYWls LmNvbT4KKyAqIENvcHlyaWdodCAoQykgMjAxNiBKb25hcyBHb3Jza2kgPGpvbmFzLmdvcnNraUBn bWFpbC5jb20+CisgKi8KKworI2luY2x1ZGUgPGxpbnV4L2JpdHMuaD4KKyNpbmNsdWRlIDxsaW51 eC9ncGlvL2RyaXZlci5oPgorI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgorI2luY2x1ZGUgPGxp bnV4L29mLmg+CisjaW5jbHVkZSA8bGludXgvcGluY3RybC9waW5tdXguaD4KKyNpbmNsdWRlIDxs aW51eC9wbGF0Zm9ybV9kZXZpY2UuaD4KKyNpbmNsdWRlIDxsaW51eC9yZWdtYXAuaD4KKworI2lu Y2x1ZGUgIi4uL3BpbmN0cmwtdXRpbHMuaCIKKworI2luY2x1ZGUgInBpbmN0cmwtYmNtNjN4eC5o IgorCisjZGVmaW5lIEJDTTYzNjhfTlVNX0dQSU9TCTM4CisKKyNkZWZpbmUgQkNNNjM2OF9NT0RF X1JFRwkweDE4CisjZGVmaW5lIEJDTTYzNjhfQkFTRU1PREVfUkVHCTB4MzgKKyNkZWZpbmUgIEJD TTYzNjhfQkFTRU1PREVfTUFTSwkweDcKKyNkZWZpbmUgIEJDTTYzNjhfQkFTRU1PREVfR1BJTwkw eDAKKyNkZWZpbmUgIEJDTTYzNjhfQkFTRU1PREVfVUFSVDEJMHgxCisKK3N0cnVjdCBiY202MzY4 X3Bpbmdyb3VwIHsKKwljb25zdCBjaGFyICpuYW1lOworCWNvbnN0IHVuc2lnbmVkICogY29uc3Qg cGluczsKKwljb25zdCB1bnNpZ25lZCBudW1fcGluczsKK307CisKK3N0cnVjdCBiY202MzY4X2Z1 bmN0aW9uIHsKKwljb25zdCBjaGFyICpuYW1lOworCWNvbnN0IGNoYXIgKiBjb25zdCAqZ3JvdXBz OworCWNvbnN0IHVuc2lnbmVkIG51bV9ncm91cHM7CisKKwl1bnNpZ25lZCBkaXJfb3V0OjE2Owor CXVuc2lnbmVkIGJhc2Vtb2RlOjM7Cit9OworCitzdHJ1Y3QgYmNtNjM2OF9wcml2IHsKKwlzdHJ1 Y3QgcmVnbWFwX2ZpZWxkICpvdmVybGF5czsKK307CisKKyNkZWZpbmUgQkNNNjM2OF9CQVNFTU9E RV9QSU4oYSwgYikJCVwKKwl7CQkJCQlcCisJCS5udW1iZXIgPSBhLAkJCVwKKwkJLm5hbWUgPSBi LAkJCVwKKwkJLmRydl9kYXRhID0gKHZvaWQgKil0cnVlCVwKKwl9CisKK3N0YXRpYyBjb25zdCBz dHJ1Y3QgcGluY3RybF9waW5fZGVzYyBiY202MzY4X3BpbnNbXSA9IHsKKwlQSU5DVFJMX1BJTigw LCAiZ3BpbzAiKSwKKwlQSU5DVFJMX1BJTigxLCAiZ3BpbzEiKSwKKwlQSU5DVFJMX1BJTigyLCAi Z3BpbzIiKSwKKwlQSU5DVFJMX1BJTigzLCAiZ3BpbzMiKSwKKwlQSU5DVFJMX1BJTig0LCAiZ3Bp bzQiKSwKKwlQSU5DVFJMX1BJTig1LCAiZ3BpbzUiKSwKKwlQSU5DVFJMX1BJTig2LCAiZ3BpbzYi KSwKKwlQSU5DVFJMX1BJTig3LCAiZ3BpbzciKSwKKwlQSU5DVFJMX1BJTig4LCAiZ3BpbzgiKSwK KwlQSU5DVFJMX1BJTig5LCAiZ3BpbzkiKSwKKwlQSU5DVFJMX1BJTigxMCwgImdwaW8xMCIpLAor CVBJTkNUUkxfUElOKDExLCAiZ3BpbzExIiksCisJUElOQ1RSTF9QSU4oMTIsICJncGlvMTIiKSwK KwlQSU5DVFJMX1BJTigxMywgImdwaW8xMyIpLAorCVBJTkNUUkxfUElOKDE0LCAiZ3BpbzE0Iiks CisJUElOQ1RSTF9QSU4oMTUsICJncGlvMTUiKSwKKwlQSU5DVFJMX1BJTigxNiwgImdwaW8xNiIp LAorCVBJTkNUUkxfUElOKDE3LCAiZ3BpbzE3IiksCisJUElOQ1RSTF9QSU4oMTgsICJncGlvMTgi KSwKKwlQSU5DVFJMX1BJTigxOSwgImdwaW8xOSIpLAorCVBJTkNUUkxfUElOKDIwLCAiZ3BpbzIw IiksCisJUElOQ1RSTF9QSU4oMjEsICJncGlvMjEiKSwKKwlQSU5DVFJMX1BJTigyMiwgImdwaW8y MiIpLAorCVBJTkNUUkxfUElOKDIzLCAiZ3BpbzIzIiksCisJUElOQ1RSTF9QSU4oMjQsICJncGlv MjQiKSwKKwlQSU5DVFJMX1BJTigyNSwgImdwaW8yNSIpLAorCVBJTkNUUkxfUElOKDI2LCAiZ3Bp bzI2IiksCisJUElOQ1RSTF9QSU4oMjcsICJncGlvMjciKSwKKwlQSU5DVFJMX1BJTigyOCwgImdw aW8yOCIpLAorCVBJTkNUUkxfUElOKDI5LCAiZ3BpbzI5IiksCisJQkNNNjM2OF9CQVNFTU9ERV9Q SU4oMzAsICJncGlvMzAiKSwKKwlCQ002MzY4X0JBU0VNT0RFX1BJTigzMSwgImdwaW8zMSIpLAor CUJDTTYzNjhfQkFTRU1PREVfUElOKDMyLCAiZ3BpbzMyIiksCisJQkNNNjM2OF9CQVNFTU9ERV9Q SU4oMzMsICJncGlvMzMiKSwKKwlQSU5DVFJMX1BJTigzNCwgImdwaW8zNCIpLAorCVBJTkNUUkxf UElOKDM1LCAiZ3BpbzM1IiksCisJUElOQ1RSTF9QSU4oMzYsICJncGlvMzYiKSwKKwlQSU5DVFJM X1BJTigzNywgImdwaW8zNyIpLAorfTsKKworc3RhdGljIHVuc2lnbmVkIGdwaW8wX3BpbnNbXSA9 IHsgMCB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8xX3BpbnNbXSA9IHsgMSB9Oworc3RhdGljIHVu c2lnbmVkIGdwaW8yX3BpbnNbXSA9IHsgMiB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8zX3BpbnNb XSA9IHsgMyB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW80X3BpbnNbXSA9IHsgNCB9Oworc3RhdGlj IHVuc2lnbmVkIGdwaW81X3BpbnNbXSA9IHsgNSB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW82X3Bp bnNbXSA9IHsgNiB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW83X3BpbnNbXSA9IHsgNyB9Oworc3Rh dGljIHVuc2lnbmVkIGdwaW84X3BpbnNbXSA9IHsgOCB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW85 X3BpbnNbXSA9IHsgOSB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8xMF9waW5zW10gPSB7IDEwIH07 CitzdGF0aWMgdW5zaWduZWQgZ3BpbzExX3BpbnNbXSA9IHsgMTEgfTsKK3N0YXRpYyB1bnNpZ25l ZCBncGlvMTJfcGluc1tdID0geyAxMiB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8xM19waW5zW10g PSB7IDEzIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzE0X3BpbnNbXSA9IHsgMTQgfTsKK3N0YXRp YyB1bnNpZ25lZCBncGlvMTVfcGluc1tdID0geyAxNSB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8x Nl9waW5zW10gPSB7IDE2IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzE3X3BpbnNbXSA9IHsgMTcg fTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMThfcGluc1tdID0geyAxOCB9Oworc3RhdGljIHVuc2ln bmVkIGdwaW8xOV9waW5zW10gPSB7IDE5IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzIwX3BpbnNb XSA9IHsgMjAgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMjFfcGluc1tdID0geyAyMSB9Oworc3Rh dGljIHVuc2lnbmVkIGdwaW8yMl9waW5zW10gPSB7IDIyIH07CitzdGF0aWMgdW5zaWduZWQgZ3Bp bzIzX3BpbnNbXSA9IHsgMjMgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMjRfcGluc1tdID0geyAy NCB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8yNV9waW5zW10gPSB7IDI1IH07CitzdGF0aWMgdW5z aWduZWQgZ3BpbzI2X3BpbnNbXSA9IHsgMjYgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMjdfcGlu c1tdID0geyAyNyB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8yOF9waW5zW10gPSB7IDI4IH07Citz dGF0aWMgdW5zaWduZWQgZ3BpbzI5X3BpbnNbXSA9IHsgMjkgfTsKK3N0YXRpYyB1bnNpZ25lZCBn cGlvMzBfcGluc1tdID0geyAzMCB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8zMV9waW5zW10gPSB7 IDMxIH07CitzdGF0aWMgdW5zaWduZWQgdWFydDFfZ3JwX3BpbnNbXSA9IHsgMzAsIDMxLCAzMiwg MzMgfTsKKworI2RlZmluZSBCQ002MzY4X0dST1VQKG4pCQkJCVwKKwl7CQkJCQkJXAorCQkubmFt ZSA9ICNuLAkJCQlcCisJCS5waW5zID0gbiMjX3BpbnMsCQkJXAorCQkubnVtX3BpbnMgPSBBUlJB WV9TSVpFKG4jI19waW5zKSwJXAorCX0KKworc3RhdGljIHN0cnVjdCBiY202MzY4X3Bpbmdyb3Vw IGJjbTYzNjhfZ3JvdXBzW10gPSB7CisJQkNNNjM2OF9HUk9VUChncGlvMCksCisJQkNNNjM2OF9H Uk9VUChncGlvMSksCisJQkNNNjM2OF9HUk9VUChncGlvMiksCisJQkNNNjM2OF9HUk9VUChncGlv MyksCisJQkNNNjM2OF9HUk9VUChncGlvNCksCisJQkNNNjM2OF9HUk9VUChncGlvNSksCisJQkNN NjM2OF9HUk9VUChncGlvNiksCisJQkNNNjM2OF9HUk9VUChncGlvNyksCisJQkNNNjM2OF9HUk9V UChncGlvOCksCisJQkNNNjM2OF9HUk9VUChncGlvOSksCisJQkNNNjM2OF9HUk9VUChncGlvMTAp LAorCUJDTTYzNjhfR1JPVVAoZ3BpbzExKSwKKwlCQ002MzY4X0dST1VQKGdwaW8xMiksCisJQkNN NjM2OF9HUk9VUChncGlvMTMpLAorCUJDTTYzNjhfR1JPVVAoZ3BpbzE0KSwKKwlCQ002MzY4X0dS T1VQKGdwaW8xNSksCisJQkNNNjM2OF9HUk9VUChncGlvMTYpLAorCUJDTTYzNjhfR1JPVVAoZ3Bp bzE3KSwKKwlCQ002MzY4X0dST1VQKGdwaW8xOCksCisJQkNNNjM2OF9HUk9VUChncGlvMTkpLAor CUJDTTYzNjhfR1JPVVAoZ3BpbzIwKSwKKwlCQ002MzY4X0dST1VQKGdwaW8yMSksCisJQkNNNjM2 OF9HUk9VUChncGlvMjIpLAorCUJDTTYzNjhfR1JPVVAoZ3BpbzIzKSwKKwlCQ002MzY4X0dST1VQ KGdwaW8yNCksCisJQkNNNjM2OF9HUk9VUChncGlvMjUpLAorCUJDTTYzNjhfR1JPVVAoZ3BpbzI2 KSwKKwlCQ002MzY4X0dST1VQKGdwaW8yNyksCisJQkNNNjM2OF9HUk9VUChncGlvMjgpLAorCUJD TTYzNjhfR1JPVVAoZ3BpbzI5KSwKKwlCQ002MzY4X0dST1VQKGdwaW8zMCksCisJQkNNNjM2OF9H Uk9VUChncGlvMzEpLAorCUJDTTYzNjhfR1JPVVAodWFydDFfZ3JwKSwKK307CisKK3N0YXRpYyBj b25zdCBjaGFyICogY29uc3QgYW5hbG9nX2FmZV8wX2dyb3Vwc1tdID0geworCSJncGlvMCIsCit9 OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGFuYWxvZ19hZmVfMV9ncm91cHNbXSA9IHsK KwkiZ3BpbzEiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBzeXNfaXJxX2dyb3Vw c1tdID0geworCSJncGlvMiIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHNlcmlh bF9sZWRfZGF0YV9ncm91cHNbXSA9IHsKKwkiZ3BpbzMiLAorfTsKKworc3RhdGljIGNvbnN0IGNo YXIgKiBjb25zdCBzZXJpYWxfbGVkX2Nsa19ncm91cHNbXSA9IHsKKwkiZ3BpbzQiLAorfTsKKwor c3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBpbmV0X2xlZF9ncm91cHNbXSA9IHsKKwkiZ3BpbzUi LAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBlcGh5MF9sZWRfZ3JvdXBzW10gPSB7 CisJImdwaW82IiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgZXBoeTFfbGVkX2dy b3Vwc1tdID0geworCSJncGlvNyIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGVw aHkyX2xlZF9ncm91cHNbXSA9IHsKKwkiZ3BpbzgiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIg KiBjb25zdCBlcGh5M19sZWRfZ3JvdXBzW10gPSB7CisJImdwaW85IiwKK307CisKK3N0YXRpYyBj b25zdCBjaGFyICogY29uc3Qgcm9ib3N3X2xlZF9kYXRhX2dyb3Vwc1tdID0geworCSJncGlvMTAi LAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCByb2Jvc3dfbGVkX2Nsa19ncm91cHNb XSA9IHsKKwkiZ3BpbzExIiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3Qgcm9ib3N3 X2xlZDBfZ3JvdXBzW10gPSB7CisJImdwaW8xMiIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAq IGNvbnN0IHJvYm9zd19sZWQxX2dyb3Vwc1tdID0geworCSJncGlvMTMiLAorfTsKKworc3RhdGlj IGNvbnN0IGNoYXIgKiBjb25zdCB1c2JfZGV2aWNlX2xlZF9ncm91cHNbXSA9IHsKKwkiZ3BpbzE0 IiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgcGNpX3JlcTFfZ3JvdXBzW10gPSB7 CisJImdwaW8xNiIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHBjaV9nbnQxX2dy b3Vwc1tdID0geworCSJncGlvMTciLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBw Y2lfaW50Yl9ncm91cHNbXSA9IHsKKwkiZ3BpbzE4IiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFy ICogY29uc3QgcGNpX3JlcTBfZ3JvdXBzW10gPSB7CisJImdwaW8xOSIsCit9OworCitzdGF0aWMg Y29uc3QgY2hhciAqIGNvbnN0IHBjaV9nbnQwX2dyb3Vwc1tdID0geworCSJncGlvMjAiLAorfTsK Kworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBwY21jaWFfY2QxX2dyb3Vwc1tdID0geworCSJn cGlvMjIiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBwY21jaWFfY2QyX2dyb3Vw c1tdID0geworCSJncGlvMjMiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBwY21j aWFfdnMxX2dyb3Vwc1tdID0geworCSJncGlvMjQiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIg KiBjb25zdCBwY21jaWFfdnMyX2dyb3Vwc1tdID0geworCSJncGlvMjUiLAorfTsKKworc3RhdGlj IGNvbnN0IGNoYXIgKiBjb25zdCBlYmlfY3MyX2dyb3Vwc1tdID0geworCSJncGlvMjYiLAorfTsK Kworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBlYmlfY3MzX2dyb3Vwc1tdID0geworCSJncGlv MjciLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBzcGlfY3MyX2dyb3Vwc1tdID0g eworCSJncGlvMjgiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBzcGlfY3MzX2dy b3Vwc1tdID0geworCSJncGlvMjkiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBz cGlfY3M0X2dyb3Vwc1tdID0geworCSJncGlvMzAiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIg KiBjb25zdCBzcGlfY3M1X2dyb3Vwc1tdID0geworCSJncGlvMzEiLAorfTsKKworc3RhdGljIGNv bnN0IGNoYXIgKiBjb25zdCB1YXJ0MV9ncm91cHNbXSA9IHsKKwkidWFydDFfZ3JwIiwKK307CisK KyNkZWZpbmUgQkNNNjM2OF9GVU4obiwgb3V0KQkJCQlcCisJewkJCQkJCVwKKwkJLm5hbWUgPSAj biwJCQkJXAorCQkuZ3JvdXBzID0gbiMjX2dyb3VwcywJCQlcCisJCS5udW1fZ3JvdXBzID0gQVJS QVlfU0laRShuIyNfZ3JvdXBzKSwJXAorCQkuZGlyX291dCA9IG91dCwJCQkJXAorCX0KKworI2Rl ZmluZSBCQ002MzY4X0JBU0VNT0RFX0ZVTihuLCB2YWwsIG91dCkJCVwKKwl7CQkJCQkJXAorCQku bmFtZSA9ICNuLAkJCQlcCisJCS5ncm91cHMgPSBuIyNfZ3JvdXBzLAkJCVwKKwkJLm51bV9ncm91 cHMgPSBBUlJBWV9TSVpFKG4jI19ncm91cHMpLAlcCisJCS5iYXNlbW9kZSA9IEJDTTYzNjhfQkFT RU1PREVfIyN2YWwsCVwKKwkJLmRpcl9vdXQgPSBvdXQsCQkJCVwKKwl9CisKK3N0YXRpYyBjb25z dCBzdHJ1Y3QgYmNtNjM2OF9mdW5jdGlvbiBiY202MzY4X2Z1bmNzW10gPSB7CisJQkNNNjM2OF9G VU4oYW5hbG9nX2FmZV8wLCAxKSwKKwlCQ002MzY4X0ZVTihhbmFsb2dfYWZlXzEsIDEpLAorCUJD TTYzNjhfRlVOKHN5c19pcnEsIDEpLAorCUJDTTYzNjhfRlVOKHNlcmlhbF9sZWRfZGF0YSwgMSks CisJQkNNNjM2OF9GVU4oc2VyaWFsX2xlZF9jbGssIDEpLAorCUJDTTYzNjhfRlVOKGluZXRfbGVk LCAxKSwKKwlCQ002MzY4X0ZVTihlcGh5MF9sZWQsIDEpLAorCUJDTTYzNjhfRlVOKGVwaHkxX2xl ZCwgMSksCisJQkNNNjM2OF9GVU4oZXBoeTJfbGVkLCAxKSwKKwlCQ002MzY4X0ZVTihlcGh5M19s ZWQsIDEpLAorCUJDTTYzNjhfRlVOKHJvYm9zd19sZWRfZGF0YSwgMSksCisJQkNNNjM2OF9GVU4o cm9ib3N3X2xlZF9jbGssIDEpLAorCUJDTTYzNjhfRlVOKHJvYm9zd19sZWQwLCAxKSwKKwlCQ002 MzY4X0ZVTihyb2Jvc3dfbGVkMSwgMSksCisJQkNNNjM2OF9GVU4odXNiX2RldmljZV9sZWQsIDEp LAorCUJDTTYzNjhfRlVOKHBjaV9yZXExLCAwKSwKKwlCQ002MzY4X0ZVTihwY2lfZ250MSwgMCks CisJQkNNNjM2OF9GVU4ocGNpX2ludGIsIDApLAorCUJDTTYzNjhfRlVOKHBjaV9yZXEwLCAwKSwK KwlCQ002MzY4X0ZVTihwY2lfZ250MCwgMCksCisJQkNNNjM2OF9GVU4ocGNtY2lhX2NkMSwgMCks CisJQkNNNjM2OF9GVU4ocGNtY2lhX2NkMiwgMCksCisJQkNNNjM2OF9GVU4ocGNtY2lhX3ZzMSwg MCksCisJQkNNNjM2OF9GVU4ocGNtY2lhX3ZzMiwgMCksCisJQkNNNjM2OF9GVU4oZWJpX2NzMiwg MSksCisJQkNNNjM2OF9GVU4oZWJpX2NzMywgMSksCisJQkNNNjM2OF9GVU4oc3BpX2NzMiwgMSks CisJQkNNNjM2OF9GVU4oc3BpX2NzMywgMSksCisJQkNNNjM2OF9GVU4oc3BpX2NzNCwgMSksCisJ QkNNNjM2OF9GVU4oc3BpX2NzNSwgMSksCisJQkNNNjM2OF9CQVNFTU9ERV9GVU4odWFydDEsIFVB UlQxLCAweDYpLAorfTsKKworc3RhdGljIGludCBiY202MzY4X3BpbmN0cmxfZ2V0X2dyb3VwX2Nv dW50KHN0cnVjdCBwaW5jdHJsX2RldiAqcGN0bGRldikKK3sKKwlyZXR1cm4gQVJSQVlfU0laRShi Y202MzY4X2dyb3Vwcyk7Cit9CisKK3N0YXRpYyBjb25zdCBjaGFyICpiY202MzY4X3BpbmN0cmxf Z2V0X2dyb3VwX25hbWUoc3RydWN0IHBpbmN0cmxfZGV2ICpwY3RsZGV2LAorCQkJCQkJICB1bnNp Z25lZCBncm91cCkKK3sKKwlyZXR1cm4gYmNtNjM2OF9ncm91cHNbZ3JvdXBdLm5hbWU7Cit9CisK K3N0YXRpYyBpbnQgYmNtNjM2OF9waW5jdHJsX2dldF9ncm91cF9waW5zKHN0cnVjdCBwaW5jdHJs X2RldiAqcGN0bGRldiwKKwkJCQkJICB1bnNpZ25lZCBncm91cCwgY29uc3QgdW5zaWduZWQgKipw aW5zLAorCQkJCQkgIHVuc2lnbmVkICpudW1fcGlucykKK3sKKwkqcGlucyA9IGJjbTYzNjhfZ3Jv dXBzW2dyb3VwXS5waW5zOworCSpudW1fcGlucyA9IGJjbTYzNjhfZ3JvdXBzW2dyb3VwXS5udW1f cGluczsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IGJjbTYzNjhfcGluY3RybF9nZXRf ZnVuY19jb3VudChzdHJ1Y3QgcGluY3RybF9kZXYgKnBjdGxkZXYpCit7CisJcmV0dXJuIEFSUkFZ X1NJWkUoYmNtNjM2OF9mdW5jcyk7Cit9CisKK3N0YXRpYyBjb25zdCBjaGFyICpiY202MzY4X3Bp bmN0cmxfZ2V0X2Z1bmNfbmFtZShzdHJ1Y3QgcGluY3RybF9kZXYgKnBjdGxkZXYsCisJCQkJCQkg dW5zaWduZWQgc2VsZWN0b3IpCit7CisJcmV0dXJuIGJjbTYzNjhfZnVuY3Nbc2VsZWN0b3JdLm5h bWU7Cit9CisKK3N0YXRpYyBpbnQgYmNtNjM2OF9waW5jdHJsX2dldF9ncm91cHMoc3RydWN0IHBp bmN0cmxfZGV2ICpwY3RsZGV2LAorCQkJCSAgICAgIHVuc2lnbmVkIHNlbGVjdG9yLAorCQkJCSAg ICAgIGNvbnN0IGNoYXIgKiBjb25zdCAqKmdyb3VwcywKKwkJCQkgICAgICB1bnNpZ25lZCAqIGNv bnN0IG51bV9ncm91cHMpCit7CisJKmdyb3VwcyA9IGJjbTYzNjhfZnVuY3Nbc2VsZWN0b3JdLmdy b3VwczsKKwkqbnVtX2dyb3VwcyA9IGJjbTYzNjhfZnVuY3Nbc2VsZWN0b3JdLm51bV9ncm91cHM7 CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBiY202MzY4X3BpbmN0cmxfc2V0X211eChz dHJ1Y3QgcGluY3RybF9kZXYgKnBjdGxkZXYsCisJCQkJICAgdW5zaWduZWQgc2VsZWN0b3IsIHVu c2lnbmVkIGdyb3VwKQoreworCXN0cnVjdCBiY202M3h4X3BpbmN0cmwgKnBjID0gcGluY3RybF9k ZXZfZ2V0X2RydmRhdGEocGN0bGRldik7CisJc3RydWN0IGJjbTYzNjhfcHJpdiAqcHJpdiA9IHBj LT5kcml2ZXJfZGF0YTsKKwljb25zdCBzdHJ1Y3QgYmNtNjM2OF9waW5ncm91cCAqcGcgPSAmYmNt NjM2OF9ncm91cHNbZ3JvdXBdOworCWNvbnN0IHN0cnVjdCBiY202MzY4X2Z1bmN0aW9uICpmdW4g PSAmYmNtNjM2OF9mdW5jc1tzZWxlY3Rvcl07CisJaW50IGksIHBpbjsKKworCWlmIChmdW4tPmJh c2Vtb2RlKSB7CisJCXVuc2lnbmVkIGludCBtYXNrID0gMDsKKworCQlmb3IgKGkgPSAwOyBpIDwg cGctPm51bV9waW5zOyBpKyspIHsKKwkJCXBpbiA9IHBnLT5waW5zW2ldOworCQkJaWYgKHBpbiA8 IEJDTTYzWFhfQkFOS19HUElPUykKKwkJCQltYXNrIHw9IEJJVChwaW4pOworCQl9CisKKwkJcmVn bWFwX3VwZGF0ZV9iaXRzKHBjLT5yZWdzLCBCQ002MzY4X01PREVfUkVHLCBtYXNrLCAwKTsKKwkJ cmVnbWFwX2ZpZWxkX3dyaXRlKHByaXYtPm92ZXJsYXlzLCBmdW4tPmJhc2Vtb2RlKTsKKwl9IGVs c2UgeworCQlwaW4gPSBwZy0+cGluc1swXTsKKworCQlpZiAoYmNtNjM2OF9waW5zW3Bpbl0uZHJ2 X2RhdGEpCisJCQlyZWdtYXBfZmllbGRfd3JpdGUocHJpdi0+b3ZlcmxheXMsCisJCQkJCSAgIEJD TTYzNjhfQkFTRU1PREVfR1BJTyk7CisKKwkJcmVnbWFwX3VwZGF0ZV9iaXRzKHBjLT5yZWdzLCBC Q002MzY4X01PREVfUkVHLCBCSVQocGluKSwKKwkJCQkgICBCSVQocGluKSk7CisJfQorCisJZm9y IChwaW4gPSAwOyBwaW4gPCBwZy0+bnVtX3BpbnM7IHBpbisrKSB7CisJCXN0cnVjdCBwaW5jdHJs X2dwaW9fcmFuZ2UgKnJhbmdlOworCQlpbnQgaHdfZ3BpbyA9IGJjbTYzNjhfcGluc1twaW5dLm51 bWJlcjsKKworCQlyYW5nZSA9IHBpbmN0cmxfZmluZF9ncGlvX3JhbmdlX2Zyb21fcGluKHBjdGxk ZXYsIGh3X2dwaW8pOworCQlpZiAocmFuZ2UpIHsKKwkJCXN0cnVjdCBncGlvX2NoaXAgKmdjID0g cmFuZ2UtPmdjOworCisJCQlpZiAoZnVuLT5kaXJfb3V0ICYgQklUKHBpbikpCisJCQkJZ2MtPmRp cmVjdGlvbl9vdXRwdXQoZ2MsIGh3X2dwaW8sIDApOworCQkJZWxzZQorCQkJCWdjLT5kaXJlY3Rp b25faW5wdXQoZ2MsIGh3X2dwaW8pOworCQl9CisJfQorCisJcmV0dXJuIDA7Cit9CisKK3N0YXRp YyBpbnQgYmNtNjM2OF9ncGlvX3JlcXVlc3RfZW5hYmxlKHN0cnVjdCBwaW5jdHJsX2RldiAqcGN0 bGRldiwKKwkJCQkgICAgICAgc3RydWN0IHBpbmN0cmxfZ3Bpb19yYW5nZSAqcmFuZ2UsCisJCQkJ ICAgICAgIHVuc2lnbmVkIG9mZnNldCkKK3sKKwlzdHJ1Y3QgYmNtNjN4eF9waW5jdHJsICpwYyA9 IHBpbmN0cmxfZGV2X2dldF9kcnZkYXRhKHBjdGxkZXYpOworCXN0cnVjdCBiY202MzY4X3ByaXYg KnByaXYgPSBwYy0+ZHJpdmVyX2RhdGE7CisKKwlpZiAob2Zmc2V0ID49IEJDTTYzWFhfQkFOS19H UElPUyAmJiAhYmNtNjM2OF9waW5zW29mZnNldF0uZHJ2X2RhdGEpCisJCXJldHVybiAwOworCisJ LyogZGlzYWJsZSBhbGwgZnVuY3Rpb25zIHVzaW5nIHRoaXMgcGluICovCisJaWYgKG9mZnNldCA8 IEJDTTYzWFhfQkFOS19HUElPUykKKwkJcmVnbWFwX3VwZGF0ZV9iaXRzKHBjLT5yZWdzLCBCQ002 MzY4X01PREVfUkVHLCBCSVQob2Zmc2V0KSwgMCk7CisKKwlpZiAoYmNtNjM2OF9waW5zW29mZnNl dF0uZHJ2X2RhdGEpCisJCXJlZ21hcF9maWVsZF93cml0ZShwcml2LT5vdmVybGF5cywgQkNNNjM2 OF9CQVNFTU9ERV9HUElPKTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgc3RydWN0IHBpbmN0 cmxfb3BzIGJjbTYzNjhfcGN0bF9vcHMgPSB7CisJLmR0X2ZyZWVfbWFwID0gcGluY3RybF91dGls c19mcmVlX21hcCwKKwkuZHRfbm9kZV90b19tYXAgPSBwaW5jb25mX2dlbmVyaWNfZHRfbm9kZV90 b19tYXBfcGluLAorCS5nZXRfZ3JvdXBfbmFtZSA9IGJjbTYzNjhfcGluY3RybF9nZXRfZ3JvdXBf bmFtZSwKKwkuZ2V0X2dyb3VwX3BpbnMgPSBiY202MzY4X3BpbmN0cmxfZ2V0X2dyb3VwX3BpbnMs CisJLmdldF9ncm91cHNfY291bnQgPSBiY202MzY4X3BpbmN0cmxfZ2V0X2dyb3VwX2NvdW50LAor fTsKKworc3RhdGljIHN0cnVjdCBwaW5tdXhfb3BzIGJjbTYzNjhfcG14X29wcyA9IHsKKwkuZ2V0 X2Z1bmN0aW9uX2dyb3VwcyA9IGJjbTYzNjhfcGluY3RybF9nZXRfZ3JvdXBzLAorCS5nZXRfZnVu Y3Rpb25fbmFtZSA9IGJjbTYzNjhfcGluY3RybF9nZXRfZnVuY19uYW1lLAorCS5nZXRfZnVuY3Rp b25zX2NvdW50ID0gYmNtNjM2OF9waW5jdHJsX2dldF9mdW5jX2NvdW50LAorCS5ncGlvX3JlcXVl c3RfZW5hYmxlID0gYmNtNjM2OF9ncGlvX3JlcXVlc3RfZW5hYmxlLAorCS5zZXRfbXV4ID0gYmNt NjM2OF9waW5jdHJsX3NldF9tdXgsCisJLnN0cmljdCA9IHRydWUsCit9OworCitzdGF0aWMgY29u c3Qgc3RydWN0IGJjbTYzeHhfcGluY3RybF9zb2MgYmNtNjM2OF9zb2MgPSB7CisJLm5ncGlvcyA9 IEJDTTYzNjhfTlVNX0dQSU9TLAorCS5ucGlucyA9IEFSUkFZX1NJWkUoYmNtNjM2OF9waW5zKSwK KwkucGN0bF9vcHMgPSAmYmNtNjM2OF9wY3RsX29wcywKKwkucGlucyA9IGJjbTYzNjhfcGlucywK KwkucG14X29wcyA9ICZiY202MzY4X3BteF9vcHMsCit9OworCitzdGF0aWMgaW50IGJjbTYzNjhf cGluY3RybF9wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQoreworCXN0cnVjdCBy ZWdfZmllbGQgb3ZlcmxheXMgPSBSRUdfRklFTEQoQkNNNjM2OF9CQVNFTU9ERV9SRUcsIDAsIDE1 KTsKKwlzdHJ1Y3QgZGV2aWNlICpkZXYgPSAmcGRldi0+ZGV2OworCXN0cnVjdCBiY202M3h4X3Bp bmN0cmwgKnBjOworCXN0cnVjdCBiY202MzY4X3ByaXYgKnByaXY7CisJaW50IGVycjsKKworCXBy aXYgPSBkZXZtX2t6YWxsb2MoZGV2LCBzaXplb2YoKnByaXYpLCBHRlBfS0VSTkVMKTsKKwlpZiAo IXByaXYpCisJCXJldHVybiAtRU5PTUVNOworCisJZXJyID0gYmNtNjN4eF9waW5jdHJsX3Byb2Jl KHBkZXYsICZiY202MzY4X3NvYywgKHZvaWQgKikgcHJpdik7CisJaWYgKGVycikKKwkJcmV0dXJu IGVycjsKKworCXBjID0gcGxhdGZvcm1fZ2V0X2RydmRhdGEocGRldik7CisKKwlwcml2LT5vdmVy bGF5cyA9IGRldm1fcmVnbWFwX2ZpZWxkX2FsbG9jKGRldiwgcGMtPnJlZ3MsIG92ZXJsYXlzKTsK KwlpZiAoSVNfRVJSKHByaXYtPm92ZXJsYXlzKSkKKwkJcmV0dXJuIFBUUl9FUlIocHJpdi0+b3Zl cmxheXMpOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgb2ZfZGV2aWNl X2lkIGJjbTYzNjhfcGluY3RybF9tYXRjaFtdID0geworCXsgLmNvbXBhdGlibGUgPSAiYnJjbSxi Y202MzY4LXBpbmN0cmwiLCB9LAorCXsgLyogc2VudGluZWwgKi8gfQorfTsKKworc3RhdGljIHN0 cnVjdCBwbGF0Zm9ybV9kcml2ZXIgYmNtNjM2OF9waW5jdHJsX2RyaXZlciA9IHsKKwkucHJvYmUg PSBiY202MzY4X3BpbmN0cmxfcHJvYmUsCisJLmRyaXZlciA9IHsKKwkJLm5hbWUgPSAiYmNtNjM2 OC1waW5jdHJsIiwKKwkJLm9mX21hdGNoX3RhYmxlID0gYmNtNjM2OF9waW5jdHJsX21hdGNoLAor CX0sCit9OworCitidWlsdGluX3BsYXRmb3JtX2RyaXZlcihiY202MzY4X3BpbmN0cmxfZHJpdmVy KTsKLS0gCjIuMjAuMQoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fCmxpbnV4LWFybS1rZXJuZWwgbWFpbGluZyBsaXN0CmxpbnV4LWFybS1rZXJuZWxAbGlz dHMuaW5mcmFkZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3Rp bmZvL2xpbnV4LWFybS1rZXJuZWwK