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 4DEA9C43446 for ; Wed, 24 Mar 2021 08:20:50 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 26433619B6 for ; Wed, 24 Mar 2021 08:20:50 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S236101AbhCXIUS (ORCPT ); Wed, 24 Mar 2021 04:20:18 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:54004 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233316AbhCXITh (ORCPT ); Wed, 24 Mar 2021 04:19:37 -0400 Received: from mail-wr1-x42d.google.com (mail-wr1-x42d.google.com [IPv6:2a00:1450:4864:20::42d]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 158BCC061763; Wed, 24 Mar 2021 01:19:37 -0700 (PDT) Received: by mail-wr1-x42d.google.com with SMTP id o16so23492203wrn.0; Wed, 24 Mar 2021 01:19:37 -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=62Fj3AscmjPir1TKwLi2CXf8GYLFSCEcrGzALLkQw8k=; b=qhPUb3UMYAwwL01aw6Xk3/IuJaUWkYiLjY83QEFiLpuTbCo0w9nD+hKV0U4OwV0wsJ 1XJfY7Hg0wMgQ6eiNp7EqJAMcaYwtUyoNQmlPVOXllO/zWq5d4xBjQtKWsi28o11WWaK /dMI26WdosMq9A8ViLWZPSrWdEcxLNQI5wwNQ/Wuwyecb0Yc8TpsLJ0IytnbiB6/HBNL 1zIYMMr3UfO28VVwS8ZDl4dtzOr1sPDHz8TtD14oYOccVrgN40f9luLCl3IbM85g3LIH f8D3NHHNDDsKChu1f5FjFkK2+1AjAHHO1lXzHpW2OT3ljCL88ybMm+tUgKD0Gzrf3xHf uHqA== 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=62Fj3AscmjPir1TKwLi2CXf8GYLFSCEcrGzALLkQw8k=; b=t2wK51tvFf34xfCyeTJ4OQXXEVE1JdiwlyuW96xn2OeKcZHrmHJpJTmunye3PoR5vP Ol2kNcSbW5Ha7p0LT2gOvS5Ij0fe2Y+SCZ+xLpTlnJbcylyorDKWUPPnAMO2dU7Fd13n NOc4rsUaITbK3rP4Rhy8tIsV7J1jL0EboZcJniTzNw8zR1/RAXOHAOyeK/n6+zP9OEmx 9UmuC7QaT8wp66CgZ557UDt4oGEhxKuXNi9OVZJLzP8hUn+kV0zAQ1mFQE1buTNWtrpX 8q7sdhcLtrqVbeAmoH4A20d1tgzMgmeTGDNCtCahL2J1v+Z27SbEwbI93SfMUXKRq2Q2 YpCQ== X-Gm-Message-State: AOAM531MLly5PzKeTRXc4yAuyF4LnxaOb8+r/gVRiqLPGDQpMgdDsiXu ld5qwXUl1zWubRNTHZ93Wvo= X-Google-Smtp-Source: ABdhPJyah964UIBiCQIZwyOSxxRrqm0DG7865uCEfWFqGbeP5ZUY7DT4vY1hI1ygcX64RgR4jbSnQA== X-Received: by 2002:adf:fa08:: with SMTP id m8mr2174804wrr.12.1616573975693; Wed, 24 Mar 2021 01:19:35 -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.34 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 24 Mar 2021 01:19:35 -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 10/22] pinctrl: add a pincontrol driver for BCM6358 Date: Wed, 24 Mar 2021 09:19:11 +0100 Message-Id: <20210324081923.20379-11-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 pincotrol driver for BCM6358. BCM6358 allow overlaying different functions onto the GPIO pins. It does not support configuring individual pins but only whole groups. These groups may overlap, and still require the directions to be set correctly in the GPIO register. In addition the functions register controls other, not directly mux related functions. 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-bcm6358.c | 369 ++++++++++++++++++++++++++ 3 files changed, 378 insertions(+) create mode 100644 drivers/pinctrl/bcm/pinctrl-bcm6358.c diff --git a/drivers/pinctrl/bcm/Kconfig b/drivers/pinctrl/bcm/Kconfig index d35e5d3fe26f..ced7cc6ab44f 100644 --- a/drivers/pinctrl/bcm/Kconfig +++ b/drivers/pinctrl/bcm/Kconfig @@ -44,6 +44,14 @@ config PINCTRL_BCM6328 help Say Y here to enable the Broadcom BCM6328 GPIO driver. +config PINCTRL_BCM6358 + bool "Broadcom BCM6358 GPIO driver" + depends on (BMIPS_GENERIC || COMPILE_TEST) + select PINCTRL_BCM63XX + default BMIPS_GENERIC + help + Say Y here to enable the Broadcom BCM6358 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 57e5434a6db6..c3f5b7b2f2f0 100644 --- a/drivers/pinctrl/bcm/Makefile +++ b/drivers/pinctrl/bcm/Makefile @@ -5,6 +5,7 @@ obj-$(CONFIG_PINCTRL_BCM281XX) += pinctrl-bcm281xx.o 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_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-bcm6358.c b/drivers/pinctrl/bcm/pinctrl-bcm6358.c new file mode 100644 index 000000000000..d638578727f3 --- /dev/null +++ b/drivers/pinctrl/bcm/pinctrl-bcm6358.c @@ -0,0 +1,369 @@ +// SPDX-License-Identifier: GPL-2.0+ +/* + * Driver for BCM6358 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 BCM6358_NUM_GPIOS 40 + +#define BCM6358_MODE_REG 0x18 +#define BCM6358_MODE_MUX_NONE 0 +#define BCM6358_MODE_MUX_EBI_CS BIT(5) +#define BCM6358_MODE_MUX_UART1 BIT(6) +#define BCM6358_MODE_MUX_SPI_CS BIT(7) +#define BCM6358_MODE_MUX_ASYNC_MODEM BIT(8) +#define BCM6358_MODE_MUX_LEGACY_LED BIT(9) +#define BCM6358_MODE_MUX_SERIAL_LED BIT(10) +#define BCM6358_MODE_MUX_LED BIT(11) +#define BCM6358_MODE_MUX_UTOPIA BIT(12) +#define BCM6358_MODE_MUX_CLKRST BIT(13) +#define BCM6358_MODE_MUX_PWM_SYN_CLK BIT(14) +#define BCM6358_MODE_MUX_SYS_IRQ BIT(15) + +struct bcm6358_pingroup { + const char *name; + const unsigned * const pins; + const unsigned num_pins; + + const uint16_t mode_val; + + /* non-GPIO function muxes require the gpio direction to be set */ + const uint16_t direction; +}; + +struct bcm6358_function { + const char *name; + const char * const *groups; + const unsigned num_groups; +}; + +struct bcm6358_priv { + struct regmap_field *overlays; +}; + +#define BCM6358_GPIO_PIN(a, b, bit1, bit2, bit3) \ + { \ + .number = a, \ + .name = b, \ + .drv_data = (void *)(BCM6358_MODE_MUX_##bit1 | \ + BCM6358_MODE_MUX_##bit2 | \ + BCM6358_MODE_MUX_##bit3), \ + } + +static const struct pinctrl_pin_desc bcm6358_pins[] = { + BCM6358_GPIO_PIN(0, "gpio0", LED, NONE, NONE), + BCM6358_GPIO_PIN(1, "gpio1", LED, NONE, NONE), + BCM6358_GPIO_PIN(2, "gpio2", LED, NONE, NONE), + BCM6358_GPIO_PIN(3, "gpio3", LED, NONE, NONE), + PINCTRL_PIN(4, "gpio4"), + BCM6358_GPIO_PIN(5, "gpio5", SYS_IRQ, NONE, NONE), + BCM6358_GPIO_PIN(6, "gpio6", SERIAL_LED, NONE, NONE), + BCM6358_GPIO_PIN(7, "gpio7", SERIAL_LED, NONE, NONE), + BCM6358_GPIO_PIN(8, "gpio8", PWM_SYN_CLK, NONE, NONE), + BCM6358_GPIO_PIN(9, "gpio09", LEGACY_LED, NONE, NONE), + BCM6358_GPIO_PIN(10, "gpio10", LEGACY_LED, NONE, NONE), + BCM6358_GPIO_PIN(11, "gpio11", LEGACY_LED, NONE, NONE), + BCM6358_GPIO_PIN(12, "gpio12", LEGACY_LED, ASYNC_MODEM, UTOPIA), + BCM6358_GPIO_PIN(13, "gpio13", LEGACY_LED, ASYNC_MODEM, UTOPIA), + BCM6358_GPIO_PIN(14, "gpio14", LEGACY_LED, ASYNC_MODEM, UTOPIA), + BCM6358_GPIO_PIN(15, "gpio15", LEGACY_LED, ASYNC_MODEM, UTOPIA), + PINCTRL_PIN(16, "gpio16"), + PINCTRL_PIN(17, "gpio17"), + PINCTRL_PIN(18, "gpio18"), + PINCTRL_PIN(19, "gpio19"), + PINCTRL_PIN(20, "gpio20"), + PINCTRL_PIN(21, "gpio21"), + BCM6358_GPIO_PIN(22, "gpio22", UTOPIA, NONE, NONE), + BCM6358_GPIO_PIN(23, "gpio23", UTOPIA, NONE, NONE), + BCM6358_GPIO_PIN(24, "gpio24", UTOPIA, NONE, NONE), + BCM6358_GPIO_PIN(25, "gpio25", UTOPIA, NONE, NONE), + BCM6358_GPIO_PIN(26, "gpio26", UTOPIA, NONE, NONE), + BCM6358_GPIO_PIN(27, "gpio27", UTOPIA, NONE, NONE), + BCM6358_GPIO_PIN(28, "gpio28", UTOPIA, UART1, NONE), + BCM6358_GPIO_PIN(29, "gpio29", UTOPIA, UART1, NONE), + BCM6358_GPIO_PIN(30, "gpio30", UTOPIA, UART1, EBI_CS), + BCM6358_GPIO_PIN(31, "gpio31", UTOPIA, UART1, EBI_CS), + BCM6358_GPIO_PIN(32, "gpio32", SPI_CS, NONE, NONE), + BCM6358_GPIO_PIN(33, "gpio33", SPI_CS, NONE, NONE), + PINCTRL_PIN(34, "gpio34"), + PINCTRL_PIN(35, "gpio35"), + PINCTRL_PIN(36, "gpio36"), + PINCTRL_PIN(37, "gpio37"), + PINCTRL_PIN(38, "gpio38"), + PINCTRL_PIN(39, "gpio39"), +}; + +static unsigned ebi_cs_grp_pins[] = { 30, 31 }; + +static unsigned uart1_grp_pins[] = { 28, 29, 30, 31 }; + +static unsigned spi_cs_grp_pins[] = { 32, 33 }; + +static unsigned async_modem_grp_pins[] = { 12, 13, 14, 15 }; + +static unsigned serial_led_grp_pins[] = { 6, 7 }; + +static unsigned legacy_led_grp_pins[] = { 9, 10, 11, 12, 13, 14, 15 }; + +static unsigned led_grp_pins[] = { 0, 1, 2, 3 }; + +static unsigned utopia_grp_pins[] = { + 12, 13, 14, 15, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, +}; + +static unsigned pwm_syn_clk_grp_pins[] = { 8 }; + +static unsigned sys_irq_grp_pins[] = { 5 }; + +#define BCM6358_GPIO_MUX_GROUP(n, bit, dir) \ + { \ + .name = #n, \ + .pins = n##_pins, \ + .num_pins = ARRAY_SIZE(n##_pins), \ + .mode_val = BCM6358_MODE_MUX_##bit, \ + .direction = dir, \ + } + +static const struct bcm6358_pingroup bcm6358_groups[] = { + BCM6358_GPIO_MUX_GROUP(ebi_cs_grp, EBI_CS, 0x3), + BCM6358_GPIO_MUX_GROUP(uart1_grp, UART1, 0x2), + BCM6358_GPIO_MUX_GROUP(spi_cs_grp, SPI_CS, 0x6), + BCM6358_GPIO_MUX_GROUP(async_modem_grp, ASYNC_MODEM, 0x6), + BCM6358_GPIO_MUX_GROUP(legacy_led_grp, LEGACY_LED, 0x7f), + BCM6358_GPIO_MUX_GROUP(serial_led_grp, SERIAL_LED, 0x3), + BCM6358_GPIO_MUX_GROUP(led_grp, LED, 0xf), + BCM6358_GPIO_MUX_GROUP(utopia_grp, UTOPIA, 0x000f), + BCM6358_GPIO_MUX_GROUP(pwm_syn_clk_grp, PWM_SYN_CLK, 0x1), + BCM6358_GPIO_MUX_GROUP(sys_irq_grp, SYS_IRQ, 0x1), +}; + +static const char * const ebi_cs_groups[] = { + "ebi_cs_grp" +}; + +static const char * const uart1_groups[] = { + "uart1_grp" +}; + +static const char * const spi_cs_2_3_groups[] = { + "spi_cs_2_3_grp" +}; + +static const char * const async_modem_groups[] = { + "async_modem_grp" +}; + +static const char * const legacy_led_groups[] = { + "legacy_led_grp", +}; + +static const char * const serial_led_groups[] = { + "serial_led_grp", +}; + +static const char * const led_groups[] = { + "led_grp", +}; + +static const char * const clkrst_groups[] = { + "clkrst_grp", +}; + +static const char * const pwm_syn_clk_groups[] = { + "pwm_syn_clk_grp", +}; + +static const char * const sys_irq_groups[] = { + "sys_irq_grp", +}; + +#define BCM6358_FUN(n) \ + { \ + .name = #n, \ + .groups = n##_groups, \ + .num_groups = ARRAY_SIZE(n##_groups), \ + } + +static const struct bcm6358_function bcm6358_funcs[] = { + BCM6358_FUN(ebi_cs), + BCM6358_FUN(uart1), + BCM6358_FUN(spi_cs_2_3), + BCM6358_FUN(async_modem), + BCM6358_FUN(legacy_led), + BCM6358_FUN(serial_led), + BCM6358_FUN(led), + BCM6358_FUN(clkrst), + BCM6358_FUN(pwm_syn_clk), + BCM6358_FUN(sys_irq), +}; + +static int bcm6358_pinctrl_get_group_count(struct pinctrl_dev *pctldev) +{ + return ARRAY_SIZE(bcm6358_groups); +} + +static const char *bcm6358_pinctrl_get_group_name(struct pinctrl_dev *pctldev, + unsigned group) +{ + return bcm6358_groups[group].name; +} + +static int bcm6358_pinctrl_get_group_pins(struct pinctrl_dev *pctldev, + unsigned group, const unsigned **pins, + unsigned *num_pins) +{ + *pins = bcm6358_groups[group].pins; + *num_pins = bcm6358_groups[group].num_pins; + + return 0; +} + +static int bcm6358_pinctrl_get_func_count(struct pinctrl_dev *pctldev) +{ + return ARRAY_SIZE(bcm6358_funcs); +} + +static const char *bcm6358_pinctrl_get_func_name(struct pinctrl_dev *pctldev, + unsigned selector) +{ + return bcm6358_funcs[selector].name; +} + +static int bcm6358_pinctrl_get_groups(struct pinctrl_dev *pctldev, + unsigned selector, + const char * const **groups, + unsigned * const num_groups) +{ + *groups = bcm6358_funcs[selector].groups; + *num_groups = bcm6358_funcs[selector].num_groups; + + return 0; +} + +static int bcm6358_pinctrl_set_mux(struct pinctrl_dev *pctldev, + unsigned selector, unsigned group) +{ + struct bcm63xx_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev); + struct bcm6358_priv *priv = pc->driver_data; + const struct bcm6358_pingroup *pg = &bcm6358_groups[group]; + unsigned int val = pg->mode_val; + unsigned int mask = val; + unsigned pin; + + for (pin = 0; pin < pg->num_pins; pin++) + mask |= (unsigned long)bcm6358_pins[pin].drv_data; + + regmap_field_update_bits(priv->overlays, mask, val); + + for (pin = 0; pin < pg->num_pins; pin++) { + struct pinctrl_gpio_range *range; + unsigned int hw_gpio = bcm6358_pins[pin].number; + + range = pinctrl_find_gpio_range_from_pin(pctldev, hw_gpio); + if (range) { + struct gpio_chip *gc = range->gc; + + if (pg->direction & BIT(pin)) + gc->direction_output(gc, hw_gpio, 0); + else + gc->direction_input(gc, hw_gpio); + } + } + + return 0; +} + +static int bcm6358_gpio_request_enable(struct pinctrl_dev *pctldev, + struct pinctrl_gpio_range *range, + unsigned offset) +{ + struct bcm63xx_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev); + struct bcm6358_priv *priv = pc->driver_data; + unsigned int mask; + + mask = (unsigned long) bcm6358_pins[offset].drv_data; + if (!mask) + return 0; + + /* disable all functions using this pin */ + return regmap_field_update_bits(priv->overlays, mask, 0); +} + +static struct pinctrl_ops bcm6358_pctl_ops = { + .dt_free_map = pinctrl_utils_free_map, + .dt_node_to_map = pinconf_generic_dt_node_to_map_pin, + .get_group_name = bcm6358_pinctrl_get_group_name, + .get_group_pins = bcm6358_pinctrl_get_group_pins, + .get_groups_count = bcm6358_pinctrl_get_group_count, +}; + +static struct pinmux_ops bcm6358_pmx_ops = { + .get_function_groups = bcm6358_pinctrl_get_groups, + .get_function_name = bcm6358_pinctrl_get_func_name, + .get_functions_count = bcm6358_pinctrl_get_func_count, + .gpio_request_enable = bcm6358_gpio_request_enable, + .set_mux = bcm6358_pinctrl_set_mux, + .strict = true, +}; + +static const struct bcm63xx_pinctrl_soc bcm6358_soc = { + .ngpios = BCM6358_NUM_GPIOS, + .npins = ARRAY_SIZE(bcm6358_pins), + .pctl_ops = &bcm6358_pctl_ops, + .pins = bcm6358_pins, + .pmx_ops = &bcm6358_pmx_ops, +}; + +static int bcm6358_pinctrl_probe(struct platform_device *pdev) +{ + struct reg_field overlays = REG_FIELD(BCM6358_MODE_REG, 0, 15); + struct device *dev = &pdev->dev; + struct bcm63xx_pinctrl *pc; + struct bcm6358_priv *priv; + int err; + + priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); + if (!priv) + return -ENOMEM; + + err = bcm63xx_pinctrl_probe(pdev, &bcm6358_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 bcm6358_pinctrl_match[] = { + { .compatible = "brcm,bcm6358-pinctrl", }, + { /* sentinel */ } +}; + +static struct platform_driver bcm6358_pinctrl_driver = { + .probe = bcm6358_pinctrl_probe, + .driver = { + .name = "bcm6358-pinctrl", + .of_match_table = bcm6358_pinctrl_match, + }, +}; + +builtin_platform_driver(bcm6358_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 012F3C433C1 for ; Wed, 24 Mar 2021 08:23: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 E178661992 for ; Wed, 24 Mar 2021 08:23:23 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org E178661992 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=sCIUhTF5MzCm1NCHdoeU9+2C46XehLO03pRKEZNnT9Q=; b=QoIGdzIJVFJ10Xvfrfr52JDMg qDAXiTvZx8SLlg9jPSIHmsx41/lXNTvhlA4LWsIWpaytE4xbmwAIFpVQVyRp8ssQnGMzVf0LxFHXJ KI0G6hIIcNKx7ufGuX4qN6M5kc37DJEuHSFhC6KNM/IRgnO2lXFI4xBzOyLiomdMNFpDPUoEzJkaY JRSPoTbaAeA5DuPV7FKP9c5BnEOXBbJWA67VH5ZC3UhDkTHSKDkdqRWzRJ5H33Fu5SPcWtFJ47/Ps MXDGlXATK2axKksYO0AQnaBcVNhae/kUfuXRL4amrOQRgWZimHP4tnlpwfDOgUbBcvNu2dmVFYKTs YyMB4sZrg==; Received: from localhost ([::1] helo=desiato.infradead.org) by desiato.infradead.org with esmtp (Exim 4.94 #2 (Red Hat Linux)) id 1lOylY-00GZPR-V6; Wed, 24 Mar 2021 08:21:25 +0000 Received: from mail-wr1-x436.google.com ([2a00:1450:4864:20::436]) by desiato.infradead.org with esmtps (Exim 4.94 #2 (Red Hat Linux)) id 1lOyjo-00GYrM-CX for linux-arm-kernel@lists.infradead.org; Wed, 24 Mar 2021 08:19:38 +0000 Received: by mail-wr1-x436.google.com with SMTP id 14so241316wrz.12 for ; Wed, 24 Mar 2021 01:19:36 -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=62Fj3AscmjPir1TKwLi2CXf8GYLFSCEcrGzALLkQw8k=; b=qhPUb3UMYAwwL01aw6Xk3/IuJaUWkYiLjY83QEFiLpuTbCo0w9nD+hKV0U4OwV0wsJ 1XJfY7Hg0wMgQ6eiNp7EqJAMcaYwtUyoNQmlPVOXllO/zWq5d4xBjQtKWsi28o11WWaK /dMI26WdosMq9A8ViLWZPSrWdEcxLNQI5wwNQ/Wuwyecb0Yc8TpsLJ0IytnbiB6/HBNL 1zIYMMr3UfO28VVwS8ZDl4dtzOr1sPDHz8TtD14oYOccVrgN40f9luLCl3IbM85g3LIH f8D3NHHNDDsKChu1f5FjFkK2+1AjAHHO1lXzHpW2OT3ljCL88ybMm+tUgKD0Gzrf3xHf uHqA== 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=62Fj3AscmjPir1TKwLi2CXf8GYLFSCEcrGzALLkQw8k=; b=S2hPivGxIZQU899abR8b8qCtMRK++iFG2CnA8wirGMDsUbnxd9Rxd7Ts2avzI1MYHn JmW4DvVCQVJFO65QD0bs7T7CpeYwwSHlsSvs3eXF2BCGgtjPMKgNboZzyVqJgS4ReBtW bDfvviNELtYC7wZersLyBUWPfkC9hW0WXj4o5fH+yvR1AJkYWV7J1ziIlCvZZ68aBkgo FFjEXIGHec//tv89prWDD0LsvIx8ckTc1FsdVW2cqw2KzRc4heYXNStwuAgJLsooKG6o HLJ/+3aobj5i7CZyFLLUlWiwkqDHCVLVNCtRZH0xabKDD/NB/mG3C03nVXBQXHcGSe0W 7H7w== X-Gm-Message-State: AOAM5316Gq8gyAVmwiMTn8eolj0/4K31y8jQ9s5mmvvSo8/A4rnAkVoQ JgrHgXqp4ntS+SDzA3TrAcL5SzyIKtmn8A== X-Google-Smtp-Source: ABdhPJyah964UIBiCQIZwyOSxxRrqm0DG7865uCEfWFqGbeP5ZUY7DT4vY1hI1ygcX64RgR4jbSnQA== X-Received: by 2002:adf:fa08:: with SMTP id m8mr2174804wrr.12.1616573975693; Wed, 24 Mar 2021 01:19:35 -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.34 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 24 Mar 2021 01:19:35 -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 10/22] pinctrl: add a pincontrol driver for BCM6358 Date: Wed, 24 Mar 2021 09:19:11 +0100 Message-Id: <20210324081923.20379-11-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_081936_566767_BFED0025 X-CRM114-Status: GOOD ( 24.19 ) 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 QWRkIGEgcGluY290cm9sIGRyaXZlciBmb3IgQkNNNjM1OC4gQkNNNjM1OCBhbGxvdyBvdmVybGF5 aW5nIGRpZmZlcmVudApmdW5jdGlvbnMgb250byB0aGUgR1BJTyBwaW5zLiBJdCBkb2VzIG5vdCBz dXBwb3J0IGNvbmZpZ3VyaW5nIGluZGl2aWR1YWwKcGlucyBidXQgb25seSB3aG9sZSBncm91cHMu IFRoZXNlIGdyb3VwcyBtYXkgb3ZlcmxhcCwgYW5kIHN0aWxsIHJlcXVpcmUKdGhlIGRpcmVjdGlv bnMgdG8gYmUgc2V0IGNvcnJlY3RseSBpbiB0aGUgR1BJTyByZWdpc3Rlci4gSW4gYWRkaXRpb24g dGhlCmZ1bmN0aW9ucyByZWdpc3RlciBjb250cm9scyBvdGhlciwgbm90IGRpcmVjdGx5IG11eCBy ZWxhdGVkIGZ1bmN0aW9ucy4KCkNvLWRldmVsb3BlZC1ieTogSm9uYXMgR29yc2tpIDxqb25hcy5n b3Jza2lAZ21haWwuY29tPgpTaWduZWQtb2ZmLWJ5OiBKb25hcyBHb3Jza2kgPGpvbmFzLmdvcnNr aUBnbWFpbC5jb20+ClNpZ25lZC1vZmYtYnk6IMOBbHZhcm8gRmVybsOhbmRleiBSb2phcyA8bm9s dGFyaUBnbWFpbC5jb20+Ci0tLQogdjk6IG5vIGNoYW5nZXMKIHY4OiBubyBjaGFuZ2VzCiB2Nzog bm8gY2hhbmdlcwogdjY6IG5vIGNoYW5nZXMKIHY1OiBhZGQgY2hhbmdlcyBzdWdnZXN0ZWQgYnkg QW5keSBTaGV2Y2hlbmtvCiB2NDogbm8gY2hhbmdlcwogdjM6IHVzZSBuZXcgc2hhcmVkIGNvZGUK IHYyOiBzd2l0Y2ggdG8gR1BJT19SRUdNQVAKCiBkcml2ZXJzL3BpbmN0cmwvYmNtL0tjb25maWcg ICAgICAgICAgIHwgICA4ICsKIGRyaXZlcnMvcGluY3RybC9iY20vTWFrZWZpbGUgICAgICAgICAg fCAgIDEgKwogZHJpdmVycy9waW5jdHJsL2JjbS9waW5jdHJsLWJjbTYzNTguYyB8IDM2OSArKysr KysrKysrKysrKysrKysrKysrKysrKwogMyBmaWxlcyBjaGFuZ2VkLCAzNzggaW5zZXJ0aW9ucygr KQogY3JlYXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvcGluY3RybC9iY20vcGluY3RybC1iY202MzU4 LmMKCmRpZmYgLS1naXQgYS9kcml2ZXJzL3BpbmN0cmwvYmNtL0tjb25maWcgYi9kcml2ZXJzL3Bp bmN0cmwvYmNtL0tjb25maWcKaW5kZXggZDM1ZTVkM2ZlMjZmLi5jZWQ3Y2M2YWI0NGYgMTAwNjQ0 Ci0tLSBhL2RyaXZlcnMvcGluY3RybC9iY20vS2NvbmZpZworKysgYi9kcml2ZXJzL3BpbmN0cmwv YmNtL0tjb25maWcKQEAgLTQ0LDYgKzQ0LDE0IEBAIGNvbmZpZyBQSU5DVFJMX0JDTTYzMjgKIAlo ZWxwCiAJICAgU2F5IFkgaGVyZSB0byBlbmFibGUgdGhlIEJyb2FkY29tIEJDTTYzMjggR1BJTyBk cml2ZXIuCiAKK2NvbmZpZyBQSU5DVFJMX0JDTTYzNTgKKwlib29sICJCcm9hZGNvbSBCQ002MzU4 IEdQSU8gZHJpdmVyIgorCWRlcGVuZHMgb24gKEJNSVBTX0dFTkVSSUMgfHwgQ09NUElMRV9URVNU KQorCXNlbGVjdCBQSU5DVFJMX0JDTTYzWFgKKwlkZWZhdWx0IEJNSVBTX0dFTkVSSUMKKwloZWxw CisJICAgU2F5IFkgaGVyZSB0byBlbmFibGUgdGhlIEJyb2FkY29tIEJDTTYzNTggR1BJTyBkcml2 ZXIuCisKIGNvbmZpZyBQSU5DVFJMX0lQUk9DX0dQSU8KIAlib29sICJCcm9hZGNvbSBpUHJvYyBH UElPICh3aXRoIFBJTkNPTkYpIGRyaXZlciIKIAlkZXBlbmRzIG9uIE9GX0dQSU8gJiYgKEFSQ0hf QkNNX0lQUk9DIHx8IENPTVBJTEVfVEVTVCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGluY3RybC9i Y20vTWFrZWZpbGUgYi9kcml2ZXJzL3BpbmN0cmwvYmNtL01ha2VmaWxlCmluZGV4IDU3ZTU0MzRh NmRiNi4uYzNmNWI3YjJmMmYwIDEwMDY0NAotLS0gYS9kcml2ZXJzL3BpbmN0cmwvYmNtL01ha2Vm aWxlCisrKyBiL2RyaXZlcnMvcGluY3RybC9iY20vTWFrZWZpbGUKQEAgLTUsNiArNSw3IEBAIG9i ai0kKENPTkZJR19QSU5DVFJMX0JDTTI4MVhYKQkJKz0gcGluY3RybC1iY20yODF4eC5vCiBvYmot JChDT05GSUdfUElOQ1RSTF9CQ00yODM1KQkJKz0gcGluY3RybC1iY20yODM1Lm8KIG9iai0kKENP TkZJR19QSU5DVFJMX0JDTTYzWFgpCQkrPSBwaW5jdHJsLWJjbTYzeHgubwogb2JqLSQoQ09ORklH X1BJTkNUUkxfQkNNNjMyOCkJCSs9IHBpbmN0cmwtYmNtNjMyOC5vCitvYmotJChDT05GSUdfUElO Q1RSTF9CQ002MzU4KQkJKz0gcGluY3RybC1iY202MzU4Lm8KIG9iai0kKENPTkZJR19QSU5DVFJM X0lQUk9DX0dQSU8pCSs9IHBpbmN0cmwtaXByb2MtZ3Bpby5vCiBvYmotJChDT05GSUdfUElOQ1RS TF9DWUdOVVNfTVVYKQkrPSBwaW5jdHJsLWN5Z251cy1tdXgubwogb2JqLSQoQ09ORklHX1BJTkNU UkxfTlMpCQkrPSBwaW5jdHJsLW5zLm8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGluY3RybC9iY20v cGluY3RybC1iY202MzU4LmMgYi9kcml2ZXJzL3BpbmN0cmwvYmNtL3BpbmN0cmwtYmNtNjM1OC5j Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uZDYzODU3ODcyN2YzCi0t LSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9waW5jdHJsL2JjbS9waW5jdHJsLWJjbTYzNTguYwpA QCAtMCwwICsxLDM2OSBAQAorLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjArCisv KgorICogRHJpdmVyIGZvciBCQ002MzU4IEdQSU8gdW5pdCAocGluY3RybCArIEdQSU8pCisgKgor ICogQ29weXJpZ2h0IChDKSAyMDIxIMOBbHZhcm8gRmVybsOhbmRleiBSb2phcyA8bm9sdGFyaUBn bWFpbC5jb20+CisgKiBDb3B5cmlnaHQgKEMpIDIwMTYgSm9uYXMgR29yc2tpIDxqb25hcy5nb3Jz a2lAZ21haWwuY29tPgorICovCisKKyNpbmNsdWRlIDxsaW51eC9iaXRzLmg+CisjaW5jbHVkZSA8 bGludXgvZ3Bpby9kcml2ZXIuaD4KKyNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KKyNpbmNsdWRl IDxsaW51eC9vZi5oPgorI2luY2x1ZGUgPGxpbnV4L3BpbmN0cmwvcGlubXV4Lmg+CisjaW5jbHVk ZSA8bGludXgvcGxhdGZvcm1fZGV2aWNlLmg+CisjaW5jbHVkZSA8bGludXgvcmVnbWFwLmg+CisK KyNpbmNsdWRlICIuLi9waW5jdHJsLXV0aWxzLmgiCisKKyNpbmNsdWRlICJwaW5jdHJsLWJjbTYz eHguaCIKKworI2RlZmluZSBCQ002MzU4X05VTV9HUElPUwkJNDAKKworI2RlZmluZSBCQ002MzU4 X01PREVfUkVHCQkweDE4CisjZGVmaW5lICBCQ002MzU4X01PREVfTVVYX05PTkUJCTAKKyNkZWZp bmUgIEJDTTYzNThfTU9ERV9NVVhfRUJJX0NTCUJJVCg1KQorI2RlZmluZSAgQkNNNjM1OF9NT0RF X01VWF9VQVJUMQkJQklUKDYpCisjZGVmaW5lICBCQ002MzU4X01PREVfTVVYX1NQSV9DUwlCSVQo NykKKyNkZWZpbmUgIEJDTTYzNThfTU9ERV9NVVhfQVNZTkNfTU9ERU0JQklUKDgpCisjZGVmaW5l ICBCQ002MzU4X01PREVfTVVYX0xFR0FDWV9MRUQJQklUKDkpCisjZGVmaW5lICBCQ002MzU4X01P REVfTVVYX1NFUklBTF9MRUQJQklUKDEwKQorI2RlZmluZSAgQkNNNjM1OF9NT0RFX01VWF9MRUQJ CUJJVCgxMSkKKyNkZWZpbmUgIEJDTTYzNThfTU9ERV9NVVhfVVRPUElBCUJJVCgxMikKKyNkZWZp bmUgIEJDTTYzNThfTU9ERV9NVVhfQ0xLUlNUCUJJVCgxMykKKyNkZWZpbmUgIEJDTTYzNThfTU9E RV9NVVhfUFdNX1NZTl9DTEsJQklUKDE0KQorI2RlZmluZSAgQkNNNjM1OF9NT0RFX01VWF9TWVNf SVJRCUJJVCgxNSkKKworc3RydWN0IGJjbTYzNThfcGluZ3JvdXAgeworCWNvbnN0IGNoYXIgKm5h bWU7CisJY29uc3QgdW5zaWduZWQgKiBjb25zdCBwaW5zOworCWNvbnN0IHVuc2lnbmVkIG51bV9w aW5zOworCisJY29uc3QgdWludDE2X3QgbW9kZV92YWw7CisKKwkvKiBub24tR1BJTyBmdW5jdGlv biBtdXhlcyByZXF1aXJlIHRoZSBncGlvIGRpcmVjdGlvbiB0byBiZSBzZXQgKi8KKwljb25zdCB1 aW50MTZfdCBkaXJlY3Rpb247Cit9OworCitzdHJ1Y3QgYmNtNjM1OF9mdW5jdGlvbiB7CisJY29u c3QgY2hhciAqbmFtZTsKKwljb25zdCBjaGFyICogY29uc3QgKmdyb3VwczsKKwljb25zdCB1bnNp Z25lZCBudW1fZ3JvdXBzOworfTsKKworc3RydWN0IGJjbTYzNThfcHJpdiB7CisJc3RydWN0IHJl Z21hcF9maWVsZCAqb3ZlcmxheXM7Cit9OworCisjZGVmaW5lIEJDTTYzNThfR1BJT19QSU4oYSwg YiwgYml0MSwgYml0MiwgYml0MykJCVwKKwl7CQkJCQkJCVwKKwkJLm51bWJlciA9IGEsCQkJCQlc CisJCS5uYW1lID0gYiwJCQkJCVwKKwkJLmRydl9kYXRhID0gKHZvaWQgKikoQkNNNjM1OF9NT0RF X01VWF8jI2JpdDEgfAlcCisJCQkJICAgICBCQ002MzU4X01PREVfTVVYXyMjYml0MiB8CVwKKwkJ CQkgICAgIEJDTTYzNThfTU9ERV9NVVhfIyNiaXQzKSwJXAorCX0KKworc3RhdGljIGNvbnN0IHN0 cnVjdCBwaW5jdHJsX3Bpbl9kZXNjIGJjbTYzNThfcGluc1tdID0geworCUJDTTYzNThfR1BJT19Q SU4oMCwgImdwaW8wIiwgTEVELCBOT05FLCBOT05FKSwKKwlCQ002MzU4X0dQSU9fUElOKDEsICJn cGlvMSIsIExFRCwgTk9ORSwgTk9ORSksCisJQkNNNjM1OF9HUElPX1BJTigyLCAiZ3BpbzIiLCBM RUQsIE5PTkUsIE5PTkUpLAorCUJDTTYzNThfR1BJT19QSU4oMywgImdwaW8zIiwgTEVELCBOT05F LCBOT05FKSwKKwlQSU5DVFJMX1BJTig0LCAiZ3BpbzQiKSwKKwlCQ002MzU4X0dQSU9fUElOKDUs ICJncGlvNSIsIFNZU19JUlEsIE5PTkUsIE5PTkUpLAorCUJDTTYzNThfR1BJT19QSU4oNiwgImdw aW82IiwgU0VSSUFMX0xFRCwgTk9ORSwgTk9ORSksCisJQkNNNjM1OF9HUElPX1BJTig3LCAiZ3Bp bzciLCBTRVJJQUxfTEVELCBOT05FLCBOT05FKSwKKwlCQ002MzU4X0dQSU9fUElOKDgsICJncGlv OCIsIFBXTV9TWU5fQ0xLLCBOT05FLCBOT05FKSwKKwlCQ002MzU4X0dQSU9fUElOKDksICJncGlv MDkiLCBMRUdBQ1lfTEVELCBOT05FLCBOT05FKSwKKwlCQ002MzU4X0dQSU9fUElOKDEwLCAiZ3Bp bzEwIiwgTEVHQUNZX0xFRCwgTk9ORSwgTk9ORSksCisJQkNNNjM1OF9HUElPX1BJTigxMSwgImdw aW8xMSIsIExFR0FDWV9MRUQsIE5PTkUsIE5PTkUpLAorCUJDTTYzNThfR1BJT19QSU4oMTIsICJn cGlvMTIiLCBMRUdBQ1lfTEVELCBBU1lOQ19NT0RFTSwgVVRPUElBKSwKKwlCQ002MzU4X0dQSU9f UElOKDEzLCAiZ3BpbzEzIiwgTEVHQUNZX0xFRCwgQVNZTkNfTU9ERU0sIFVUT1BJQSksCisJQkNN NjM1OF9HUElPX1BJTigxNCwgImdwaW8xNCIsIExFR0FDWV9MRUQsIEFTWU5DX01PREVNLCBVVE9Q SUEpLAorCUJDTTYzNThfR1BJT19QSU4oMTUsICJncGlvMTUiLCBMRUdBQ1lfTEVELCBBU1lOQ19N T0RFTSwgVVRPUElBKSwKKwlQSU5DVFJMX1BJTigxNiwgImdwaW8xNiIpLAorCVBJTkNUUkxfUElO KDE3LCAiZ3BpbzE3IiksCisJUElOQ1RSTF9QSU4oMTgsICJncGlvMTgiKSwKKwlQSU5DVFJMX1BJ TigxOSwgImdwaW8xOSIpLAorCVBJTkNUUkxfUElOKDIwLCAiZ3BpbzIwIiksCisJUElOQ1RSTF9Q SU4oMjEsICJncGlvMjEiKSwKKwlCQ002MzU4X0dQSU9fUElOKDIyLCAiZ3BpbzIyIiwgVVRPUElB LCBOT05FLCBOT05FKSwKKwlCQ002MzU4X0dQSU9fUElOKDIzLCAiZ3BpbzIzIiwgVVRPUElBLCBO T05FLCBOT05FKSwKKwlCQ002MzU4X0dQSU9fUElOKDI0LCAiZ3BpbzI0IiwgVVRPUElBLCBOT05F LCBOT05FKSwKKwlCQ002MzU4X0dQSU9fUElOKDI1LCAiZ3BpbzI1IiwgVVRPUElBLCBOT05FLCBO T05FKSwKKwlCQ002MzU4X0dQSU9fUElOKDI2LCAiZ3BpbzI2IiwgVVRPUElBLCBOT05FLCBOT05F KSwKKwlCQ002MzU4X0dQSU9fUElOKDI3LCAiZ3BpbzI3IiwgVVRPUElBLCBOT05FLCBOT05FKSwK KwlCQ002MzU4X0dQSU9fUElOKDI4LCAiZ3BpbzI4IiwgVVRPUElBLCBVQVJUMSwgTk9ORSksCisJ QkNNNjM1OF9HUElPX1BJTigyOSwgImdwaW8yOSIsIFVUT1BJQSwgVUFSVDEsIE5PTkUpLAorCUJD TTYzNThfR1BJT19QSU4oMzAsICJncGlvMzAiLCBVVE9QSUEsIFVBUlQxLCBFQklfQ1MpLAorCUJD TTYzNThfR1BJT19QSU4oMzEsICJncGlvMzEiLCBVVE9QSUEsIFVBUlQxLCBFQklfQ1MpLAorCUJD TTYzNThfR1BJT19QSU4oMzIsICJncGlvMzIiLCBTUElfQ1MsIE5PTkUsIE5PTkUpLAorCUJDTTYz NThfR1BJT19QSU4oMzMsICJncGlvMzMiLCBTUElfQ1MsIE5PTkUsIE5PTkUpLAorCVBJTkNUUkxf UElOKDM0LCAiZ3BpbzM0IiksCisJUElOQ1RSTF9QSU4oMzUsICJncGlvMzUiKSwKKwlQSU5DVFJM X1BJTigzNiwgImdwaW8zNiIpLAorCVBJTkNUUkxfUElOKDM3LCAiZ3BpbzM3IiksCisJUElOQ1RS TF9QSU4oMzgsICJncGlvMzgiKSwKKwlQSU5DVFJMX1BJTigzOSwgImdwaW8zOSIpLAorfTsKKwor c3RhdGljIHVuc2lnbmVkIGViaV9jc19ncnBfcGluc1tdID0geyAzMCwgMzEgfTsKKworc3RhdGlj IHVuc2lnbmVkIHVhcnQxX2dycF9waW5zW10gPSB7IDI4LCAyOSwgMzAsIDMxIH07CisKK3N0YXRp YyB1bnNpZ25lZCBzcGlfY3NfZ3JwX3BpbnNbXSA9IHsgMzIsIDMzIH07CisKK3N0YXRpYyB1bnNp Z25lZCBhc3luY19tb2RlbV9ncnBfcGluc1tdID0geyAxMiwgMTMsIDE0LCAxNSB9OworCitzdGF0 aWMgdW5zaWduZWQgc2VyaWFsX2xlZF9ncnBfcGluc1tdID0geyA2LCA3IH07CisKK3N0YXRpYyB1 bnNpZ25lZCBsZWdhY3lfbGVkX2dycF9waW5zW10gPSB7IDksIDEwLCAxMSwgMTIsIDEzLCAxNCwg MTUgfTsKKworc3RhdGljIHVuc2lnbmVkIGxlZF9ncnBfcGluc1tdID0geyAwLCAxLCAyLCAzIH07 CisKK3N0YXRpYyB1bnNpZ25lZCB1dG9waWFfZ3JwX3BpbnNbXSA9IHsKKwkxMiwgMTMsIDE0LCAx NSwgMjIsIDIzLCAyNCwgMjUsIDI2LCAyNywgMjgsIDI5LCAzMCwgMzEsCit9OworCitzdGF0aWMg dW5zaWduZWQgcHdtX3N5bl9jbGtfZ3JwX3BpbnNbXSA9IHsgOCB9OworCitzdGF0aWMgdW5zaWdu ZWQgc3lzX2lycV9ncnBfcGluc1tdID0geyA1IH07CisKKyNkZWZpbmUgQkNNNjM1OF9HUElPX01V WF9HUk9VUChuLCBiaXQsIGRpcikJCQlcCisJewkJCQkJCQlcCisJCS5uYW1lID0gI24sCQkJCQlc CisJCS5waW5zID0gbiMjX3BpbnMsCQkJCVwKKwkJLm51bV9waW5zID0gQVJSQVlfU0laRShuIyNf cGlucyksCQlcCisJCS5tb2RlX3ZhbCA9IEJDTTYzNThfTU9ERV9NVVhfIyNiaXQsCQlcCisJCS5k aXJlY3Rpb24gPSBkaXIsCQkJCVwKKwl9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgYmNtNjM1OF9w aW5ncm91cCBiY202MzU4X2dyb3Vwc1tdID0geworCUJDTTYzNThfR1BJT19NVVhfR1JPVVAoZWJp X2NzX2dycCwgRUJJX0NTLCAweDMpLAorCUJDTTYzNThfR1BJT19NVVhfR1JPVVAodWFydDFfZ3Jw LCBVQVJUMSwgMHgyKSwKKwlCQ002MzU4X0dQSU9fTVVYX0dST1VQKHNwaV9jc19ncnAsIFNQSV9D UywgMHg2KSwKKwlCQ002MzU4X0dQSU9fTVVYX0dST1VQKGFzeW5jX21vZGVtX2dycCwgQVNZTkNf TU9ERU0sIDB4NiksCisJQkNNNjM1OF9HUElPX01VWF9HUk9VUChsZWdhY3lfbGVkX2dycCwgTEVH QUNZX0xFRCwgMHg3ZiksCisJQkNNNjM1OF9HUElPX01VWF9HUk9VUChzZXJpYWxfbGVkX2dycCwg U0VSSUFMX0xFRCwgMHgzKSwKKwlCQ002MzU4X0dQSU9fTVVYX0dST1VQKGxlZF9ncnAsIExFRCwg MHhmKSwKKwlCQ002MzU4X0dQSU9fTVVYX0dST1VQKHV0b3BpYV9ncnAsIFVUT1BJQSwgMHgwMDBm KSwKKwlCQ002MzU4X0dQSU9fTVVYX0dST1VQKHB3bV9zeW5fY2xrX2dycCwgUFdNX1NZTl9DTEss IDB4MSksCisJQkNNNjM1OF9HUElPX01VWF9HUk9VUChzeXNfaXJxX2dycCwgU1lTX0lSUSwgMHgx KSwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgZWJpX2NzX2dyb3Vwc1tdID0gewor CSJlYmlfY3NfZ3JwIgorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCB1YXJ0MV9ncm91 cHNbXSA9IHsKKwkidWFydDFfZ3JwIgorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBz cGlfY3NfMl8zX2dyb3Vwc1tdID0geworCSJzcGlfY3NfMl8zX2dycCIKK307CisKK3N0YXRpYyBj b25zdCBjaGFyICogY29uc3QgYXN5bmNfbW9kZW1fZ3JvdXBzW10gPSB7CisJImFzeW5jX21vZGVt X2dycCIKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgbGVnYWN5X2xlZF9ncm91cHNb XSA9IHsKKwkibGVnYWN5X2xlZF9ncnAiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25z dCBzZXJpYWxfbGVkX2dyb3Vwc1tdID0geworCSJzZXJpYWxfbGVkX2dycCIsCit9OworCitzdGF0 aWMgY29uc3QgY2hhciAqIGNvbnN0IGxlZF9ncm91cHNbXSA9IHsKKwkibGVkX2dycCIsCit9Owor CitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGNsa3JzdF9ncm91cHNbXSA9IHsKKwkiY2xrcnN0 X2dycCIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHB3bV9zeW5fY2xrX2dyb3Vw c1tdID0geworCSJwd21fc3luX2Nsa19ncnAiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBj b25zdCBzeXNfaXJxX2dyb3Vwc1tdID0geworCSJzeXNfaXJxX2dycCIsCit9OworCisjZGVmaW5l IEJDTTYzNThfRlVOKG4pCQkJCQlcCisJewkJCQkJCVwKKwkJLm5hbWUgPSAjbiwJCQkJXAorCQku Z3JvdXBzID0gbiMjX2dyb3VwcywJCQlcCisJCS5udW1fZ3JvdXBzID0gQVJSQVlfU0laRShuIyNf Z3JvdXBzKSwJXAorCX0KKworc3RhdGljIGNvbnN0IHN0cnVjdCBiY202MzU4X2Z1bmN0aW9uIGJj bTYzNThfZnVuY3NbXSA9IHsKKwlCQ002MzU4X0ZVTihlYmlfY3MpLAorCUJDTTYzNThfRlVOKHVh cnQxKSwKKwlCQ002MzU4X0ZVTihzcGlfY3NfMl8zKSwKKwlCQ002MzU4X0ZVTihhc3luY19tb2Rl bSksCisJQkNNNjM1OF9GVU4obGVnYWN5X2xlZCksCisJQkNNNjM1OF9GVU4oc2VyaWFsX2xlZCks CisJQkNNNjM1OF9GVU4obGVkKSwKKwlCQ002MzU4X0ZVTihjbGtyc3QpLAorCUJDTTYzNThfRlVO KHB3bV9zeW5fY2xrKSwKKwlCQ002MzU4X0ZVTihzeXNfaXJxKSwKK307CisKK3N0YXRpYyBpbnQg YmNtNjM1OF9waW5jdHJsX2dldF9ncm91cF9jb3VudChzdHJ1Y3QgcGluY3RybF9kZXYgKnBjdGxk ZXYpCit7CisJcmV0dXJuIEFSUkFZX1NJWkUoYmNtNjM1OF9ncm91cHMpOworfQorCitzdGF0aWMg Y29uc3QgY2hhciAqYmNtNjM1OF9waW5jdHJsX2dldF9ncm91cF9uYW1lKHN0cnVjdCBwaW5jdHJs X2RldiAqcGN0bGRldiwKKwkJCQkJCSAgdW5zaWduZWQgZ3JvdXApCit7CisJcmV0dXJuIGJjbTYz NThfZ3JvdXBzW2dyb3VwXS5uYW1lOworfQorCitzdGF0aWMgaW50IGJjbTYzNThfcGluY3RybF9n ZXRfZ3JvdXBfcGlucyhzdHJ1Y3QgcGluY3RybF9kZXYgKnBjdGxkZXYsCisJCQkJCSAgdW5zaWdu ZWQgZ3JvdXAsIGNvbnN0IHVuc2lnbmVkICoqcGlucywKKwkJCQkJICB1bnNpZ25lZCAqbnVtX3Bp bnMpCit7CisJKnBpbnMgPSBiY202MzU4X2dyb3Vwc1tncm91cF0ucGluczsKKwkqbnVtX3BpbnMg PSBiY202MzU4X2dyb3Vwc1tncm91cF0ubnVtX3BpbnM7CisKKwlyZXR1cm4gMDsKK30KKworc3Rh dGljIGludCBiY202MzU4X3BpbmN0cmxfZ2V0X2Z1bmNfY291bnQoc3RydWN0IHBpbmN0cmxfZGV2 ICpwY3RsZGV2KQoreworCXJldHVybiBBUlJBWV9TSVpFKGJjbTYzNThfZnVuY3MpOworfQorCitz dGF0aWMgY29uc3QgY2hhciAqYmNtNjM1OF9waW5jdHJsX2dldF9mdW5jX25hbWUoc3RydWN0IHBp bmN0cmxfZGV2ICpwY3RsZGV2LAorCQkJCQkJIHVuc2lnbmVkIHNlbGVjdG9yKQoreworCXJldHVy biBiY202MzU4X2Z1bmNzW3NlbGVjdG9yXS5uYW1lOworfQorCitzdGF0aWMgaW50IGJjbTYzNThf cGluY3RybF9nZXRfZ3JvdXBzKHN0cnVjdCBwaW5jdHJsX2RldiAqcGN0bGRldiwKKwkJCQkgICAg ICB1bnNpZ25lZCBzZWxlY3RvciwKKwkJCQkgICAgICBjb25zdCBjaGFyICogY29uc3QgKipncm91 cHMsCisJCQkJICAgICAgdW5zaWduZWQgKiBjb25zdCBudW1fZ3JvdXBzKQoreworCSpncm91cHMg PSBiY202MzU4X2Z1bmNzW3NlbGVjdG9yXS5ncm91cHM7CisJKm51bV9ncm91cHMgPSBiY202MzU4 X2Z1bmNzW3NlbGVjdG9yXS5udW1fZ3JvdXBzOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBp bnQgYmNtNjM1OF9waW5jdHJsX3NldF9tdXgoc3RydWN0IHBpbmN0cmxfZGV2ICpwY3RsZGV2LAor CQkJCSAgIHVuc2lnbmVkIHNlbGVjdG9yLCB1bnNpZ25lZCBncm91cCkKK3sKKwlzdHJ1Y3QgYmNt NjN4eF9waW5jdHJsICpwYyA9IHBpbmN0cmxfZGV2X2dldF9kcnZkYXRhKHBjdGxkZXYpOworCXN0 cnVjdCBiY202MzU4X3ByaXYgKnByaXYgPSBwYy0+ZHJpdmVyX2RhdGE7CisJY29uc3Qgc3RydWN0 IGJjbTYzNThfcGluZ3JvdXAgKnBnID0gJmJjbTYzNThfZ3JvdXBzW2dyb3VwXTsKKwl1bnNpZ25l ZCBpbnQgdmFsID0gcGctPm1vZGVfdmFsOworCXVuc2lnbmVkIGludCBtYXNrID0gdmFsOworCXVu c2lnbmVkIHBpbjsKKworCWZvciAocGluID0gMDsgcGluIDwgcGctPm51bV9waW5zOyBwaW4rKykK KwkJbWFzayB8PSAodW5zaWduZWQgbG9uZyliY202MzU4X3BpbnNbcGluXS5kcnZfZGF0YTsKKwor CXJlZ21hcF9maWVsZF91cGRhdGVfYml0cyhwcml2LT5vdmVybGF5cywgbWFzaywgdmFsKTsKKwor CWZvciAocGluID0gMDsgcGluIDwgcGctPm51bV9waW5zOyBwaW4rKykgeworCQlzdHJ1Y3QgcGlu Y3RybF9ncGlvX3JhbmdlICpyYW5nZTsKKwkJdW5zaWduZWQgaW50IGh3X2dwaW8gPSBiY202MzU4 X3BpbnNbcGluXS5udW1iZXI7CisKKwkJcmFuZ2UgPSBwaW5jdHJsX2ZpbmRfZ3Bpb19yYW5nZV9m cm9tX3BpbihwY3RsZGV2LCBod19ncGlvKTsKKwkJaWYgKHJhbmdlKSB7CisJCQlzdHJ1Y3QgZ3Bp b19jaGlwICpnYyA9IHJhbmdlLT5nYzsKKworCQkJaWYgKHBnLT5kaXJlY3Rpb24gJiBCSVQocGlu KSkKKwkJCQlnYy0+ZGlyZWN0aW9uX291dHB1dChnYywgaHdfZ3BpbywgMCk7CisJCQllbHNlCisJ CQkJZ2MtPmRpcmVjdGlvbl9pbnB1dChnYywgaHdfZ3Bpbyk7CisJCX0KKwl9CisKKwlyZXR1cm4g MDsKK30KKworc3RhdGljIGludCBiY202MzU4X2dwaW9fcmVxdWVzdF9lbmFibGUoc3RydWN0IHBp bmN0cmxfZGV2ICpwY3RsZGV2LAorCQkJCSAgICAgICBzdHJ1Y3QgcGluY3RybF9ncGlvX3Jhbmdl ICpyYW5nZSwKKwkJCQkgICAgICAgdW5zaWduZWQgb2Zmc2V0KQoreworCXN0cnVjdCBiY202M3h4 X3BpbmN0cmwgKnBjID0gcGluY3RybF9kZXZfZ2V0X2RydmRhdGEocGN0bGRldik7CisJc3RydWN0 IGJjbTYzNThfcHJpdiAqcHJpdiA9IHBjLT5kcml2ZXJfZGF0YTsKKwl1bnNpZ25lZCBpbnQgbWFz azsKKworCW1hc2sgPSAodW5zaWduZWQgbG9uZykgYmNtNjM1OF9waW5zW29mZnNldF0uZHJ2X2Rh dGE7CisJaWYgKCFtYXNrKQorCQlyZXR1cm4gMDsKKworCS8qIGRpc2FibGUgYWxsIGZ1bmN0aW9u cyB1c2luZyB0aGlzIHBpbiAqLworCXJldHVybiByZWdtYXBfZmllbGRfdXBkYXRlX2JpdHMocHJp di0+b3ZlcmxheXMsIG1hc2ssIDApOworfQorCitzdGF0aWMgc3RydWN0IHBpbmN0cmxfb3BzIGJj bTYzNThfcGN0bF9vcHMgPSB7CisJLmR0X2ZyZWVfbWFwID0gcGluY3RybF91dGlsc19mcmVlX21h cCwKKwkuZHRfbm9kZV90b19tYXAgPSBwaW5jb25mX2dlbmVyaWNfZHRfbm9kZV90b19tYXBfcGlu LAorCS5nZXRfZ3JvdXBfbmFtZSA9IGJjbTYzNThfcGluY3RybF9nZXRfZ3JvdXBfbmFtZSwKKwku Z2V0X2dyb3VwX3BpbnMgPSBiY202MzU4X3BpbmN0cmxfZ2V0X2dyb3VwX3BpbnMsCisJLmdldF9n cm91cHNfY291bnQgPSBiY202MzU4X3BpbmN0cmxfZ2V0X2dyb3VwX2NvdW50LAorfTsKKworc3Rh dGljIHN0cnVjdCBwaW5tdXhfb3BzIGJjbTYzNThfcG14X29wcyA9IHsKKwkuZ2V0X2Z1bmN0aW9u X2dyb3VwcyA9IGJjbTYzNThfcGluY3RybF9nZXRfZ3JvdXBzLAorCS5nZXRfZnVuY3Rpb25fbmFt ZSA9IGJjbTYzNThfcGluY3RybF9nZXRfZnVuY19uYW1lLAorCS5nZXRfZnVuY3Rpb25zX2NvdW50 ID0gYmNtNjM1OF9waW5jdHJsX2dldF9mdW5jX2NvdW50LAorCS5ncGlvX3JlcXVlc3RfZW5hYmxl ID0gYmNtNjM1OF9ncGlvX3JlcXVlc3RfZW5hYmxlLAorCS5zZXRfbXV4ID0gYmNtNjM1OF9waW5j dHJsX3NldF9tdXgsCisJLnN0cmljdCA9IHRydWUsCit9OworCitzdGF0aWMgY29uc3Qgc3RydWN0 IGJjbTYzeHhfcGluY3RybF9zb2MgYmNtNjM1OF9zb2MgPSB7CisJLm5ncGlvcyA9IEJDTTYzNThf TlVNX0dQSU9TLAorCS5ucGlucyA9IEFSUkFZX1NJWkUoYmNtNjM1OF9waW5zKSwKKwkucGN0bF9v cHMgPSAmYmNtNjM1OF9wY3RsX29wcywKKwkucGlucyA9IGJjbTYzNThfcGlucywKKwkucG14X29w cyA9ICZiY202MzU4X3BteF9vcHMsCit9OworCitzdGF0aWMgaW50IGJjbTYzNThfcGluY3RybF9w cm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQoreworCXN0cnVjdCByZWdfZmllbGQg b3ZlcmxheXMgPSBSRUdfRklFTEQoQkNNNjM1OF9NT0RFX1JFRywgMCwgMTUpOworCXN0cnVjdCBk ZXZpY2UgKmRldiA9ICZwZGV2LT5kZXY7CisJc3RydWN0IGJjbTYzeHhfcGluY3RybCAqcGM7CisJ c3RydWN0IGJjbTYzNThfcHJpdiAqcHJpdjsKKwlpbnQgZXJyOworCisJcHJpdiA9IGRldm1fa3ph bGxvYyhkZXYsIHNpemVvZigqcHJpdiksIEdGUF9LRVJORUwpOworCWlmICghcHJpdikKKwkJcmV0 dXJuIC1FTk9NRU07CisKKwllcnIgPSBiY202M3h4X3BpbmN0cmxfcHJvYmUocGRldiwgJmJjbTYz NThfc29jLCAodm9pZCAqKSBwcml2KTsKKwlpZiAoZXJyKQorCQlyZXR1cm4gZXJyOworCisJcGMg PSBwbGF0Zm9ybV9nZXRfZHJ2ZGF0YShwZGV2KTsKKworCXByaXYtPm92ZXJsYXlzID0gZGV2bV9y ZWdtYXBfZmllbGRfYWxsb2MoZGV2LCBwYy0+cmVncywgb3ZlcmxheXMpOworCWlmIChJU19FUlIo cHJpdi0+b3ZlcmxheXMpKQorCQlyZXR1cm4gUFRSX0VSUihwcml2LT5vdmVybGF5cyk7CisKKwly ZXR1cm4gMDsKK30KKworc3RhdGljIGNvbnN0IHN0cnVjdCBvZl9kZXZpY2VfaWQgYmNtNjM1OF9w aW5jdHJsX21hdGNoW10gPSB7CisJeyAuY29tcGF0aWJsZSA9ICJicmNtLGJjbTYzNTgtcGluY3Ry bCIsIH0sCisJeyAvKiBzZW50aW5lbCAqLyB9Cit9OworCitzdGF0aWMgc3RydWN0IHBsYXRmb3Jt X2RyaXZlciBiY202MzU4X3BpbmN0cmxfZHJpdmVyID0geworCS5wcm9iZSA9IGJjbTYzNThfcGlu Y3RybF9wcm9iZSwKKwkuZHJpdmVyID0geworCQkubmFtZSA9ICJiY202MzU4LXBpbmN0cmwiLAor CQkub2ZfbWF0Y2hfdGFibGUgPSBiY202MzU4X3BpbmN0cmxfbWF0Y2gsCisJfSwKK307CisKK2J1 aWx0aW5fcGxhdGZvcm1fZHJpdmVyKGJjbTYzNThfcGluY3RybF9kcml2ZXIpOwotLSAKMi4yMC4x CgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KbGludXgt YXJtLWtlcm5lbCBtYWlsaW5nIGxpc3QKbGludXgtYXJtLWtlcm5lbEBsaXN0cy5pbmZyYWRlYWQu b3JnCmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vbGludXgtYXJt LWtlcm5lbAo=