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 050C1C4646F 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 E5D6664EF6 for ; Mon, 15 Mar 2021 11:43:26 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230500AbhCOLnH (ORCPT ); Mon, 15 Mar 2021 07:43:07 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:43214 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230252AbhCOLm2 (ORCPT ); Mon, 15 Mar 2021 07:42:28 -0400 Received: from mail-wm1-x330.google.com (mail-wm1-x330.google.com [IPv6:2a00:1450:4864:20::330]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 5EA3BC061574; Mon, 15 Mar 2021 04:42:28 -0700 (PDT) Received: by mail-wm1-x330.google.com with SMTP id r10-20020a05600c35cab029010c946c95easo19250484wmq.4; Mon, 15 Mar 2021 04:42:28 -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=hp2b7HqZrlu9nZxQ2UONj+JMKa0I7VIeOfw3ugl/Fbg=; b=rcoNb99TqhF/HD+niE32F/sr6whjW5EkEU0h4B3TBkFuTU4fqbiX+6uhT+iKQtdGSV +fzDYTxuAofeiVnXFdSexHNvETqPgpc2lGbb07bFnLehUSPvJpvIdqlg+V1E3o4uhnK9 xUzDOKyiJC8YJpg6mAb+EcfKrpFf/M0LmvdrhViqgmXJcGIGUZMJSxjJFaI4bjGYCHT+ OI6Ys24poF2qBackZ3F1C3/3QyA1Y2B1ICrg+1s1dIYeBqVs9vc0JJH3/aC6TuJPSruS cIoG0wJWOdrCc7P/Fz+28t9eUpHMMrepV81a9RNJ2owaMEpj2NyUIg2N5WvvyvPETmxj nvtQ== 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=hp2b7HqZrlu9nZxQ2UONj+JMKa0I7VIeOfw3ugl/Fbg=; b=RnFgrY9Dy04cwY/3DZE4SxyCrr+t+tElJzaoBMIp2QOLdMoP6avBI6OtxJ43MukC1U zhRdJZ9Y1iFpBsFDc+0wLt5rLHckS+JdT3zZR/HnPx6DB07RO4x+WzaapIhTq/vsZUWS Rvh+8SQNW3jIYL4jeYLYRkmDDTUM0/uoSqq14uohU3tAtFlqnwwCwxzVrsFyzEg9dc5i xNQrj9WGi4NvG8l3r0wRRSKMNKkW55LAnMW4VAyKj5+yn1pBx0ySZ8UFE4vuEW4MaagS /ukWLvHABozPdVjCEG3PyBVvOcxb1blJWCGnol/Te2IE9ysz7SX8tRHdAiVzwO5QH7nt 0bLA== X-Gm-Message-State: AOAM533VLBV3A2TZBiZ9Gu7UIhvLypO0kq6BbXmODaZXULF50EY9Osxl /UR8CaB50c7l3ye2S90poxs= X-Google-Smtp-Source: ABdhPJwXk8D5DRiGnrlKhIRr6R2S2qZ+Wu6BygOPYKdWEpcGHC7qCIy2OEWLUq0o/MedzDDAhL5zZg== X-Received: by 2002:a05:600c:2ca:: with SMTP id 10mr25911245wmn.40.1615808546964; Mon, 15 Mar 2021 04:42:26 -0700 (PDT) Received: from skynet.lan ([80.31.204.166]) by smtp.gmail.com with ESMTPSA id v189sm12648187wme.39.2021.03.15.04.42.25 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 15 Mar 2021 04:42:26 -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 10/22] pinctrl: add a pincontrol driver for BCM6358 Date: Mon, 15 Mar 2021 12:42:02 +0100 Message-Id: <20210315114214.3096-11-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 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 --- 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,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 B2849C433E0 for ; Mon, 15 Mar 2021 11:55: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 170E364E90 for ; Mon, 15 Mar 2021 11:55:31 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 170E364E90 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=PefYOdMZi7mBYlCRdQwhw5lYT7/36/8mfpVKraEw1h8=; b=W6rzC8FYiQc7Y48DbSYPiCnyn rtzkHs8OtfV/Kj2rlgXrGJhE2+LJfENusrNKzqlaEGEZLHo8+26BhELBAiCccRJy7MYdJ6IMMVnE9 7eGCiaUkx0FqwwRg242ceinWA/yLRf4OAWyE+/0CXB4PwSwEpPIS8YnrP6H7vkcf6TPEuUNy4DpOH 61daxD+fXvFgHgld0NGIrgjOdztMeJ+1UCTvBXfjSP0xMisWLpOhS7puvNUPXcdRofXSfzoEwDZp7 rSk9V7j71Yg7AfsHOfEMtVKvzbpjNiK15E9jlDgP0DzYOpyr/KhqZcfM2GhnNRwS3DH7jc5JV9wg1 nKuJqkysA==; Received: from localhost ([::1] helo=desiato.infradead.org) by desiato.infradead.org with esmtp (Exim 4.94 #2 (Red Hat Linux)) id 1lLlkn-00FiI0-Oh; Mon, 15 Mar 2021 11:51:22 +0000 Received: from mail-wm1-x334.google.com ([2a00:1450:4864:20::334]) by desiato.infradead.org with esmtps (Exim 4.94 #2 (Red Hat Linux)) id 1lLlcB-00Fgt3-FU for linux-arm-kernel@lists.infradead.org; Mon, 15 Mar 2021 11:42:39 +0000 Received: by mail-wm1-x334.google.com with SMTP id r15-20020a05600c35cfb029010e639ca09eso20072851wmq.1 for ; Mon, 15 Mar 2021 04:42:27 -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=hp2b7HqZrlu9nZxQ2UONj+JMKa0I7VIeOfw3ugl/Fbg=; b=rcoNb99TqhF/HD+niE32F/sr6whjW5EkEU0h4B3TBkFuTU4fqbiX+6uhT+iKQtdGSV +fzDYTxuAofeiVnXFdSexHNvETqPgpc2lGbb07bFnLehUSPvJpvIdqlg+V1E3o4uhnK9 xUzDOKyiJC8YJpg6mAb+EcfKrpFf/M0LmvdrhViqgmXJcGIGUZMJSxjJFaI4bjGYCHT+ OI6Ys24poF2qBackZ3F1C3/3QyA1Y2B1ICrg+1s1dIYeBqVs9vc0JJH3/aC6TuJPSruS cIoG0wJWOdrCc7P/Fz+28t9eUpHMMrepV81a9RNJ2owaMEpj2NyUIg2N5WvvyvPETmxj nvtQ== 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=hp2b7HqZrlu9nZxQ2UONj+JMKa0I7VIeOfw3ugl/Fbg=; b=kZK8/PLhYR0OAjxq0y2xCfx+9yCZmapmRNnq/hQGSi4qOuytgoDwzh31tp7x8yxYq4 LBuRd1OXm9sO1YdZWA98kQgYrm5M7vH92TaQdnslAbLVYQ+sdYue3hXi/vtrzjZ1wOaq FNfM/husOq9aIhdfkDiotEiEkm53F3iBEez3pH21SGFkpF5Eb9dp9Isjr23h9fawRFdy iEk0TMxsmZxfmXHpxP5dIk3hoGlTfHC4a8HpbgZqfpgu5rGYz9ekHZr6R07dpNzvCu+3 FZs3G9tqYDCoH7am8w/+epQwWpKsbFRLb8O3rOZSWlxtJS+puIys7HNDIAvGHpJPq/Bs ISjg== X-Gm-Message-State: AOAM530v/4aBLdPK2/TMJN1UTG84ZLeWNly8LzDU/2ZfuygwBtX+ZETO Vjhco71mGBrhdaJyv5a6ivo= X-Google-Smtp-Source: ABdhPJwXk8D5DRiGnrlKhIRr6R2S2qZ+Wu6BygOPYKdWEpcGHC7qCIy2OEWLUq0o/MedzDDAhL5zZg== X-Received: by 2002:a05:600c:2ca:: with SMTP id 10mr25911245wmn.40.1615808546964; Mon, 15 Mar 2021 04:42:26 -0700 (PDT) Received: from skynet.lan ([80.31.204.166]) by smtp.gmail.com with ESMTPSA id v189sm12648187wme.39.2021.03.15.04.42.25 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 15 Mar 2021 04:42:26 -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 10/22] pinctrl: add a pincontrol driver for BCM6358 Date: Mon, 15 Mar 2021 12:42:02 +0100 Message-Id: <20210315114214.3096-11-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_114227_949169_A0B14A9A X-CRM114-Status: GOOD ( 24.74 ) 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+Ci0tLQogdjc6IG5vIGNoYW5nZXMKIHY2OiBubyBjaGFuZ2VzCiB2NTog YWRkIGNoYW5nZXMgc3VnZ2VzdGVkIGJ5IEFuZHkgU2hldmNoZW5rbwogdjQ6IG5vIGNoYW5nZXMK IHYzOiB1c2UgbmV3IHNoYXJlZCBjb2RlCiB2Mjogc3dpdGNoIHRvIEdQSU9fUkVHTUFQCgogZHJp dmVycy9waW5jdHJsL2JjbS9LY29uZmlnICAgICAgICAgICB8ICAgOCArCiBkcml2ZXJzL3BpbmN0 cmwvYmNtL01ha2VmaWxlICAgICAgICAgIHwgICAxICsKIGRyaXZlcnMvcGluY3RybC9iY20vcGlu Y3RybC1iY202MzU4LmMgfCAzNjkgKysrKysrKysrKysrKysrKysrKysrKysrKysKIDMgZmlsZXMg Y2hhbmdlZCwgMzc4IGluc2VydGlvbnMoKykKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL3Bp bmN0cmwvYmNtL3BpbmN0cmwtYmNtNjM1OC5jCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9waW5jdHJs L2JjbS9LY29uZmlnIGIvZHJpdmVycy9waW5jdHJsL2JjbS9LY29uZmlnCmluZGV4IGQzNWU1ZDNm ZTI2Zi4uY2VkN2NjNmFiNDRmIDEwMDY0NAotLS0gYS9kcml2ZXJzL3BpbmN0cmwvYmNtL0tjb25m aWcKKysrIGIvZHJpdmVycy9waW5jdHJsL2JjbS9LY29uZmlnCkBAIC00NCw2ICs0NCwxNCBAQCBj b25maWcgUElOQ1RSTF9CQ002MzI4CiAJaGVscAogCSAgIFNheSBZIGhlcmUgdG8gZW5hYmxlIHRo ZSBCcm9hZGNvbSBCQ002MzI4IEdQSU8gZHJpdmVyLgogCitjb25maWcgUElOQ1RSTF9CQ002MzU4 CisJYm9vbCAiQnJvYWRjb20gQkNNNjM1OCBHUElPIGRyaXZlciIKKwlkZXBlbmRzIG9uIChCTUlQ U19HRU5FUklDIHx8IENPTVBJTEVfVEVTVCkKKwlzZWxlY3QgUElOQ1RSTF9CQ002M1hYCisJZGVm YXVsdCBCTUlQU19HRU5FUklDCisJaGVscAorCSAgIFNheSBZIGhlcmUgdG8gZW5hYmxlIHRoZSBC cm9hZGNvbSBCQ002MzU4IEdQSU8gZHJpdmVyLgorCiBjb25maWcgUElOQ1RSTF9JUFJPQ19HUElP CiAJYm9vbCAiQnJvYWRjb20gaVByb2MgR1BJTyAod2l0aCBQSU5DT05GKSBkcml2ZXIiCiAJZGVw ZW5kcyBvbiBPRl9HUElPICYmIChBUkNIX0JDTV9JUFJPQyB8fCBDT01QSUxFX1RFU1QpCmRpZmYg LS1naXQgYS9kcml2ZXJzL3BpbmN0cmwvYmNtL01ha2VmaWxlIGIvZHJpdmVycy9waW5jdHJsL2Jj bS9NYWtlZmlsZQppbmRleCA1N2U1NDM0YTZkYjYuLmMzZjViN2IyZjJmMCAxMDA2NDQKLS0tIGEv ZHJpdmVycy9waW5jdHJsL2JjbS9NYWtlZmlsZQorKysgYi9kcml2ZXJzL3BpbmN0cmwvYmNtL01h a2VmaWxlCkBAIC01LDYgKzUsNyBAQCBvYmotJChDT05GSUdfUElOQ1RSTF9CQ00yODFYWCkJCSs9 IHBpbmN0cmwtYmNtMjgxeHgubwogb2JqLSQoQ09ORklHX1BJTkNUUkxfQkNNMjgzNSkJCSs9IHBp bmN0cmwtYmNtMjgzNS5vCiBvYmotJChDT05GSUdfUElOQ1RSTF9CQ002M1hYKQkJKz0gcGluY3Ry bC1iY202M3h4Lm8KIG9iai0kKENPTkZJR19QSU5DVFJMX0JDTTYzMjgpCQkrPSBwaW5jdHJsLWJj bTYzMjgubworb2JqLSQoQ09ORklHX1BJTkNUUkxfQkNNNjM1OCkJCSs9IHBpbmN0cmwtYmNtNjM1 OC5vCiBvYmotJChDT05GSUdfUElOQ1RSTF9JUFJPQ19HUElPKQkrPSBwaW5jdHJsLWlwcm9jLWdw aW8ubwogb2JqLSQoQ09ORklHX1BJTkNUUkxfQ1lHTlVTX01VWCkJKz0gcGluY3RybC1jeWdudXMt bXV4Lm8KIG9iai0kKENPTkZJR19QSU5DVFJMX05TKQkJKz0gcGluY3RybC1ucy5vCmRpZmYgLS1n aXQgYS9kcml2ZXJzL3BpbmN0cmwvYmNtL3BpbmN0cmwtYmNtNjM1OC5jIGIvZHJpdmVycy9waW5j dHJsL2JjbS9waW5jdHJsLWJjbTYzNTguYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwMDAwMDAuLmQ2Mzg1Nzg3MjdmMwotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvcGluY3Ry bC9iY20vcGluY3RybC1iY202MzU4LmMKQEAgLTAsMCArMSwzNjkgQEAKKy8vIFNQRFgtTGljZW5z ZS1JZGVudGlmaWVyOiBHUEwtMi4wKworLyoKKyAqIERyaXZlciBmb3IgQkNNNjM1OCBHUElPIHVu aXQgKHBpbmN0cmwgKyBHUElPKQorICoKKyAqIENvcHlyaWdodCAoQykgMjAyMSDDgWx2YXJvIEZl cm7DoW5kZXogUm9qYXMgPG5vbHRhcmlAZ21haWwuY29tPgorICogQ29weXJpZ2h0IChDKSAyMDE2 IEpvbmFzIEdvcnNraSA8am9uYXMuZ29yc2tpQGdtYWlsLmNvbT4KKyAqLworCisjaW5jbHVkZSA8 bGludXgvYml0cy5oPgorI2luY2x1ZGUgPGxpbnV4L2dwaW8vZHJpdmVyLmg+CisjaW5jbHVkZSA8 bGludXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgvb2YuaD4KKyNpbmNsdWRlIDxsaW51eC9w aW5jdHJsL3Bpbm11eC5oPgorI2luY2x1ZGUgPGxpbnV4L3BsYXRmb3JtX2RldmljZS5oPgorI2lu Y2x1ZGUgPGxpbnV4L3JlZ21hcC5oPgorCisjaW5jbHVkZSAiLi4vcGluY3RybC11dGlscy5oIgor CisjaW5jbHVkZSAicGluY3RybC1iY202M3h4LmgiCisKKyNkZWZpbmUgQkNNNjM1OF9OVU1fR1BJ T1MJCTQwCisKKyNkZWZpbmUgQkNNNjM1OF9NT0RFX1JFRwkJMHgxOAorI2RlZmluZSAgQkNNNjM1 OF9NT0RFX01VWF9OT05FCQkwCisjZGVmaW5lICBCQ002MzU4X01PREVfTVVYX0VCSV9DUwlCSVQo NSkKKyNkZWZpbmUgIEJDTTYzNThfTU9ERV9NVVhfVUFSVDEJCUJJVCg2KQorI2RlZmluZSAgQkNN NjM1OF9NT0RFX01VWF9TUElfQ1MJQklUKDcpCisjZGVmaW5lICBCQ002MzU4X01PREVfTVVYX0FT WU5DX01PREVNCUJJVCg4KQorI2RlZmluZSAgQkNNNjM1OF9NT0RFX01VWF9MRUdBQ1lfTEVECUJJ VCg5KQorI2RlZmluZSAgQkNNNjM1OF9NT0RFX01VWF9TRVJJQUxfTEVECUJJVCgxMCkKKyNkZWZp bmUgIEJDTTYzNThfTU9ERV9NVVhfTEVECQlCSVQoMTEpCisjZGVmaW5lICBCQ002MzU4X01PREVf TVVYX1VUT1BJQQlCSVQoMTIpCisjZGVmaW5lICBCQ002MzU4X01PREVfTVVYX0NMS1JTVAlCSVQo MTMpCisjZGVmaW5lICBCQ002MzU4X01PREVfTVVYX1BXTV9TWU5fQ0xLCUJJVCgxNCkKKyNkZWZp bmUgIEJDTTYzNThfTU9ERV9NVVhfU1lTX0lSUQlCSVQoMTUpCisKK3N0cnVjdCBiY202MzU4X3Bp bmdyb3VwIHsKKwljb25zdCBjaGFyICpuYW1lOworCWNvbnN0IHVuc2lnbmVkICogY29uc3QgcGlu czsKKwljb25zdCB1bnNpZ25lZCBudW1fcGluczsKKworCWNvbnN0IHVpbnQxNl90IG1vZGVfdmFs OworCisJLyogbm9uLUdQSU8gZnVuY3Rpb24gbXV4ZXMgcmVxdWlyZSB0aGUgZ3BpbyBkaXJlY3Rp b24gdG8gYmUgc2V0ICovCisJY29uc3QgdWludDE2X3QgZGlyZWN0aW9uOworfTsKKworc3RydWN0 IGJjbTYzNThfZnVuY3Rpb24geworCWNvbnN0IGNoYXIgKm5hbWU7CisJY29uc3QgY2hhciAqIGNv bnN0ICpncm91cHM7CisJY29uc3QgdW5zaWduZWQgbnVtX2dyb3VwczsKK307CisKK3N0cnVjdCBi Y202MzU4X3ByaXYgeworCXN0cnVjdCByZWdtYXBfZmllbGQgKm92ZXJsYXlzOworfTsKKworI2Rl ZmluZSBCQ002MzU4X0dQSU9fUElOKGEsIGIsIGJpdDEsIGJpdDIsIGJpdDMpCQlcCisJewkJCQkJ CQlcCisJCS5udW1iZXIgPSBhLAkJCQkJXAorCQkubmFtZSA9IGIsCQkJCQlcCisJCS5kcnZfZGF0 YSA9ICh2b2lkICopKEJDTTYzNThfTU9ERV9NVVhfIyNiaXQxIHwJXAorCQkJCSAgICAgQkNNNjM1 OF9NT0RFX01VWF8jI2JpdDIgfAlcCisJCQkJICAgICBCQ002MzU4X01PREVfTVVYXyMjYml0Myks CVwKKwl9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgcGluY3RybF9waW5fZGVzYyBiY202MzU4X3Bp bnNbXSA9IHsKKwlCQ002MzU4X0dQSU9fUElOKDAsICJncGlvMCIsIExFRCwgTk9ORSwgTk9ORSks CisJQkNNNjM1OF9HUElPX1BJTigxLCAiZ3BpbzEiLCBMRUQsIE5PTkUsIE5PTkUpLAorCUJDTTYz NThfR1BJT19QSU4oMiwgImdwaW8yIiwgTEVELCBOT05FLCBOT05FKSwKKwlCQ002MzU4X0dQSU9f UElOKDMsICJncGlvMyIsIExFRCwgTk9ORSwgTk9ORSksCisJUElOQ1RSTF9QSU4oNCwgImdwaW80 IiksCisJQkNNNjM1OF9HUElPX1BJTig1LCAiZ3BpbzUiLCBTWVNfSVJRLCBOT05FLCBOT05FKSwK KwlCQ002MzU4X0dQSU9fUElOKDYsICJncGlvNiIsIFNFUklBTF9MRUQsIE5PTkUsIE5PTkUpLAor CUJDTTYzNThfR1BJT19QSU4oNywgImdwaW83IiwgU0VSSUFMX0xFRCwgTk9ORSwgTk9ORSksCisJ QkNNNjM1OF9HUElPX1BJTig4LCAiZ3BpbzgiLCBQV01fU1lOX0NMSywgTk9ORSwgTk9ORSksCisJ QkNNNjM1OF9HUElPX1BJTig5LCAiZ3BpbzA5IiwgTEVHQUNZX0xFRCwgTk9ORSwgTk9ORSksCisJ QkNNNjM1OF9HUElPX1BJTigxMCwgImdwaW8xMCIsIExFR0FDWV9MRUQsIE5PTkUsIE5PTkUpLAor CUJDTTYzNThfR1BJT19QSU4oMTEsICJncGlvMTEiLCBMRUdBQ1lfTEVELCBOT05FLCBOT05FKSwK KwlCQ002MzU4X0dQSU9fUElOKDEyLCAiZ3BpbzEyIiwgTEVHQUNZX0xFRCwgQVNZTkNfTU9ERU0s IFVUT1BJQSksCisJQkNNNjM1OF9HUElPX1BJTigxMywgImdwaW8xMyIsIExFR0FDWV9MRUQsIEFT WU5DX01PREVNLCBVVE9QSUEpLAorCUJDTTYzNThfR1BJT19QSU4oMTQsICJncGlvMTQiLCBMRUdB Q1lfTEVELCBBU1lOQ19NT0RFTSwgVVRPUElBKSwKKwlCQ002MzU4X0dQSU9fUElOKDE1LCAiZ3Bp bzE1IiwgTEVHQUNZX0xFRCwgQVNZTkNfTU9ERU0sIFVUT1BJQSksCisJUElOQ1RSTF9QSU4oMTYs ICJncGlvMTYiKSwKKwlQSU5DVFJMX1BJTigxNywgImdwaW8xNyIpLAorCVBJTkNUUkxfUElOKDE4 LCAiZ3BpbzE4IiksCisJUElOQ1RSTF9QSU4oMTksICJncGlvMTkiKSwKKwlQSU5DVFJMX1BJTigy MCwgImdwaW8yMCIpLAorCVBJTkNUUkxfUElOKDIxLCAiZ3BpbzIxIiksCisJQkNNNjM1OF9HUElP X1BJTigyMiwgImdwaW8yMiIsIFVUT1BJQSwgTk9ORSwgTk9ORSksCisJQkNNNjM1OF9HUElPX1BJ TigyMywgImdwaW8yMyIsIFVUT1BJQSwgTk9ORSwgTk9ORSksCisJQkNNNjM1OF9HUElPX1BJTigy NCwgImdwaW8yNCIsIFVUT1BJQSwgTk9ORSwgTk9ORSksCisJQkNNNjM1OF9HUElPX1BJTigyNSwg ImdwaW8yNSIsIFVUT1BJQSwgTk9ORSwgTk9ORSksCisJQkNNNjM1OF9HUElPX1BJTigyNiwgImdw aW8yNiIsIFVUT1BJQSwgTk9ORSwgTk9ORSksCisJQkNNNjM1OF9HUElPX1BJTigyNywgImdwaW8y NyIsIFVUT1BJQSwgTk9ORSwgTk9ORSksCisJQkNNNjM1OF9HUElPX1BJTigyOCwgImdwaW8yOCIs IFVUT1BJQSwgVUFSVDEsIE5PTkUpLAorCUJDTTYzNThfR1BJT19QSU4oMjksICJncGlvMjkiLCBV VE9QSUEsIFVBUlQxLCBOT05FKSwKKwlCQ002MzU4X0dQSU9fUElOKDMwLCAiZ3BpbzMwIiwgVVRP UElBLCBVQVJUMSwgRUJJX0NTKSwKKwlCQ002MzU4X0dQSU9fUElOKDMxLCAiZ3BpbzMxIiwgVVRP UElBLCBVQVJUMSwgRUJJX0NTKSwKKwlCQ002MzU4X0dQSU9fUElOKDMyLCAiZ3BpbzMyIiwgU1BJ X0NTLCBOT05FLCBOT05FKSwKKwlCQ002MzU4X0dQSU9fUElOKDMzLCAiZ3BpbzMzIiwgU1BJX0NT LCBOT05FLCBOT05FKSwKKwlQSU5DVFJMX1BJTigzNCwgImdwaW8zNCIpLAorCVBJTkNUUkxfUElO KDM1LCAiZ3BpbzM1IiksCisJUElOQ1RSTF9QSU4oMzYsICJncGlvMzYiKSwKKwlQSU5DVFJMX1BJ TigzNywgImdwaW8zNyIpLAorCVBJTkNUUkxfUElOKDM4LCAiZ3BpbzM4IiksCisJUElOQ1RSTF9Q SU4oMzksICJncGlvMzkiKSwKK307CisKK3N0YXRpYyB1bnNpZ25lZCBlYmlfY3NfZ3JwX3BpbnNb XSA9IHsgMzAsIDMxIH07CisKK3N0YXRpYyB1bnNpZ25lZCB1YXJ0MV9ncnBfcGluc1tdID0geyAy OCwgMjksIDMwLCAzMSB9OworCitzdGF0aWMgdW5zaWduZWQgc3BpX2NzX2dycF9waW5zW10gPSB7 IDMyLCAzMyB9OworCitzdGF0aWMgdW5zaWduZWQgYXN5bmNfbW9kZW1fZ3JwX3BpbnNbXSA9IHsg MTIsIDEzLCAxNCwgMTUgfTsKKworc3RhdGljIHVuc2lnbmVkIHNlcmlhbF9sZWRfZ3JwX3BpbnNb XSA9IHsgNiwgNyB9OworCitzdGF0aWMgdW5zaWduZWQgbGVnYWN5X2xlZF9ncnBfcGluc1tdID0g eyA5LCAxMCwgMTEsIDEyLCAxMywgMTQsIDE1IH07CisKK3N0YXRpYyB1bnNpZ25lZCBsZWRfZ3Jw X3BpbnNbXSA9IHsgMCwgMSwgMiwgMyB9OworCitzdGF0aWMgdW5zaWduZWQgdXRvcGlhX2dycF9w aW5zW10gPSB7CisJMTIsIDEzLCAxNCwgMTUsIDIyLCAyMywgMjQsIDI1LCAyNiwgMjcsIDI4LCAy OSwgMzAsIDMxLAorfTsKKworc3RhdGljIHVuc2lnbmVkIHB3bV9zeW5fY2xrX2dycF9waW5zW10g PSB7IDggfTsKKworc3RhdGljIHVuc2lnbmVkIHN5c19pcnFfZ3JwX3BpbnNbXSA9IHsgNSB9Owor CisjZGVmaW5lIEJDTTYzNThfR1BJT19NVVhfR1JPVVAobiwgYml0LCBkaXIpCQkJXAorCXsJCQkJ CQkJXAorCQkubmFtZSA9ICNuLAkJCQkJXAorCQkucGlucyA9IG4jI19waW5zLAkJCQlcCisJCS5u dW1fcGlucyA9IEFSUkFZX1NJWkUobiMjX3BpbnMpLAkJXAorCQkubW9kZV92YWwgPSBCQ002MzU4 X01PREVfTVVYXyMjYml0LAkJXAorCQkuZGlyZWN0aW9uID0gZGlyLAkJCQlcCisJfQorCitzdGF0 aWMgY29uc3Qgc3RydWN0IGJjbTYzNThfcGluZ3JvdXAgYmNtNjM1OF9ncm91cHNbXSA9IHsKKwlC Q002MzU4X0dQSU9fTVVYX0dST1VQKGViaV9jc19ncnAsIEVCSV9DUywgMHgzKSwKKwlCQ002MzU4 X0dQSU9fTVVYX0dST1VQKHVhcnQxX2dycCwgVUFSVDEsIDB4MiksCisJQkNNNjM1OF9HUElPX01V WF9HUk9VUChzcGlfY3NfZ3JwLCBTUElfQ1MsIDB4NiksCisJQkNNNjM1OF9HUElPX01VWF9HUk9V UChhc3luY19tb2RlbV9ncnAsIEFTWU5DX01PREVNLCAweDYpLAorCUJDTTYzNThfR1BJT19NVVhf R1JPVVAobGVnYWN5X2xlZF9ncnAsIExFR0FDWV9MRUQsIDB4N2YpLAorCUJDTTYzNThfR1BJT19N VVhfR1JPVVAoc2VyaWFsX2xlZF9ncnAsIFNFUklBTF9MRUQsIDB4MyksCisJQkNNNjM1OF9HUElP X01VWF9HUk9VUChsZWRfZ3JwLCBMRUQsIDB4ZiksCisJQkNNNjM1OF9HUElPX01VWF9HUk9VUCh1 dG9waWFfZ3JwLCBVVE9QSUEsIDB4MDAwZiksCisJQkNNNjM1OF9HUElPX01VWF9HUk9VUChwd21f c3luX2Nsa19ncnAsIFBXTV9TWU5fQ0xLLCAweDEpLAorCUJDTTYzNThfR1BJT19NVVhfR1JPVVAo c3lzX2lycV9ncnAsIFNZU19JUlEsIDB4MSksCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNv bnN0IGViaV9jc19ncm91cHNbXSA9IHsKKwkiZWJpX2NzX2dycCIKK307CisKK3N0YXRpYyBjb25z dCBjaGFyICogY29uc3QgdWFydDFfZ3JvdXBzW10gPSB7CisJInVhcnQxX2dycCIKK307CisKK3N0 YXRpYyBjb25zdCBjaGFyICogY29uc3Qgc3BpX2NzXzJfM19ncm91cHNbXSA9IHsKKwkic3BpX2Nz XzJfM19ncnAiCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGFzeW5jX21vZGVtX2dy b3Vwc1tdID0geworCSJhc3luY19tb2RlbV9ncnAiCit9OworCitzdGF0aWMgY29uc3QgY2hhciAq IGNvbnN0IGxlZ2FjeV9sZWRfZ3JvdXBzW10gPSB7CisJImxlZ2FjeV9sZWRfZ3JwIiwKK307CisK K3N0YXRpYyBjb25zdCBjaGFyICogY29uc3Qgc2VyaWFsX2xlZF9ncm91cHNbXSA9IHsKKwkic2Vy aWFsX2xlZF9ncnAiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBsZWRfZ3JvdXBz W10gPSB7CisJImxlZF9ncnAiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBjbGty c3RfZ3JvdXBzW10gPSB7CisJImNsa3JzdF9ncnAiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIg KiBjb25zdCBwd21fc3luX2Nsa19ncm91cHNbXSA9IHsKKwkicHdtX3N5bl9jbGtfZ3JwIiwKK307 CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3Qgc3lzX2lycV9ncm91cHNbXSA9IHsKKwkic3lz X2lycV9ncnAiLAorfTsKKworI2RlZmluZSBCQ002MzU4X0ZVTihuKQkJCQkJXAorCXsJCQkJCQlc CisJCS5uYW1lID0gI24sCQkJCVwKKwkJLmdyb3VwcyA9IG4jI19ncm91cHMsCQkJXAorCQkubnVt X2dyb3VwcyA9IEFSUkFZX1NJWkUobiMjX2dyb3VwcyksCVwKKwl9CisKK3N0YXRpYyBjb25zdCBz dHJ1Y3QgYmNtNjM1OF9mdW5jdGlvbiBiY202MzU4X2Z1bmNzW10gPSB7CisJQkNNNjM1OF9GVU4o ZWJpX2NzKSwKKwlCQ002MzU4X0ZVTih1YXJ0MSksCisJQkNNNjM1OF9GVU4oc3BpX2NzXzJfMyks CisJQkNNNjM1OF9GVU4oYXN5bmNfbW9kZW0pLAorCUJDTTYzNThfRlVOKGxlZ2FjeV9sZWQpLAor CUJDTTYzNThfRlVOKHNlcmlhbF9sZWQpLAorCUJDTTYzNThfRlVOKGxlZCksCisJQkNNNjM1OF9G VU4oY2xrcnN0KSwKKwlCQ002MzU4X0ZVTihwd21fc3luX2NsayksCisJQkNNNjM1OF9GVU4oc3lz X2lycSksCit9OworCitzdGF0aWMgaW50IGJjbTYzNThfcGluY3RybF9nZXRfZ3JvdXBfY291bnQo c3RydWN0IHBpbmN0cmxfZGV2ICpwY3RsZGV2KQoreworCXJldHVybiBBUlJBWV9TSVpFKGJjbTYz NThfZ3JvdXBzKTsKK30KKworc3RhdGljIGNvbnN0IGNoYXIgKmJjbTYzNThfcGluY3RybF9nZXRf Z3JvdXBfbmFtZShzdHJ1Y3QgcGluY3RybF9kZXYgKnBjdGxkZXYsCisJCQkJCQkgIHVuc2lnbmVk IGdyb3VwKQoreworCXJldHVybiBiY202MzU4X2dyb3Vwc1tncm91cF0ubmFtZTsKK30KKworc3Rh dGljIGludCBiY202MzU4X3BpbmN0cmxfZ2V0X2dyb3VwX3BpbnMoc3RydWN0IHBpbmN0cmxfZGV2 ICpwY3RsZGV2LAorCQkJCQkgIHVuc2lnbmVkIGdyb3VwLCBjb25zdCB1bnNpZ25lZCAqKnBpbnMs CisJCQkJCSAgdW5zaWduZWQgKm51bV9waW5zKQoreworCSpwaW5zID0gYmNtNjM1OF9ncm91cHNb Z3JvdXBdLnBpbnM7CisJKm51bV9waW5zID0gYmNtNjM1OF9ncm91cHNbZ3JvdXBdLm51bV9waW5z OworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgYmNtNjM1OF9waW5jdHJsX2dldF9mdW5j X2NvdW50KHN0cnVjdCBwaW5jdHJsX2RldiAqcGN0bGRldikKK3sKKwlyZXR1cm4gQVJSQVlfU0la RShiY202MzU4X2Z1bmNzKTsKK30KKworc3RhdGljIGNvbnN0IGNoYXIgKmJjbTYzNThfcGluY3Ry bF9nZXRfZnVuY19uYW1lKHN0cnVjdCBwaW5jdHJsX2RldiAqcGN0bGRldiwKKwkJCQkJCSB1bnNp Z25lZCBzZWxlY3RvcikKK3sKKwlyZXR1cm4gYmNtNjM1OF9mdW5jc1tzZWxlY3Rvcl0ubmFtZTsK K30KKworc3RhdGljIGludCBiY202MzU4X3BpbmN0cmxfZ2V0X2dyb3VwcyhzdHJ1Y3QgcGluY3Ry bF9kZXYgKnBjdGxkZXYsCisJCQkJICAgICAgdW5zaWduZWQgc2VsZWN0b3IsCisJCQkJICAgICAg Y29uc3QgY2hhciAqIGNvbnN0ICoqZ3JvdXBzLAorCQkJCSAgICAgIHVuc2lnbmVkICogY29uc3Qg bnVtX2dyb3VwcykKK3sKKwkqZ3JvdXBzID0gYmNtNjM1OF9mdW5jc1tzZWxlY3Rvcl0uZ3JvdXBz OworCSpudW1fZ3JvdXBzID0gYmNtNjM1OF9mdW5jc1tzZWxlY3Rvcl0ubnVtX2dyb3VwczsKKwor CXJldHVybiAwOworfQorCitzdGF0aWMgaW50IGJjbTYzNThfcGluY3RybF9zZXRfbXV4KHN0cnVj dCBwaW5jdHJsX2RldiAqcGN0bGRldiwKKwkJCQkgICB1bnNpZ25lZCBzZWxlY3RvciwgdW5zaWdu ZWQgZ3JvdXApCit7CisJc3RydWN0IGJjbTYzeHhfcGluY3RybCAqcGMgPSBwaW5jdHJsX2Rldl9n ZXRfZHJ2ZGF0YShwY3RsZGV2KTsKKwlzdHJ1Y3QgYmNtNjM1OF9wcml2ICpwcml2ID0gcGMtPmRy aXZlcl9kYXRhOworCWNvbnN0IHN0cnVjdCBiY202MzU4X3Bpbmdyb3VwICpwZyA9ICZiY202MzU4 X2dyb3Vwc1tncm91cF07CisJdW5zaWduZWQgaW50IHZhbCA9IHBnLT5tb2RlX3ZhbDsKKwl1bnNp Z25lZCBpbnQgbWFzayA9IHZhbDsKKwl1bnNpZ25lZCBwaW47CisKKwlmb3IgKHBpbiA9IDA7IHBp biA8IHBnLT5udW1fcGluczsgcGluKyspCisJCW1hc2sgfD0gKHVuc2lnbmVkIGxvbmcpYmNtNjM1 OF9waW5zW3Bpbl0uZHJ2X2RhdGE7CisKKwlyZWdtYXBfZmllbGRfdXBkYXRlX2JpdHMocHJpdi0+ b3ZlcmxheXMsIG1hc2ssIHZhbCk7CisKKwlmb3IgKHBpbiA9IDA7IHBpbiA8IHBnLT5udW1fcGlu czsgcGluKyspIHsKKwkJc3RydWN0IHBpbmN0cmxfZ3Bpb19yYW5nZSAqcmFuZ2U7CisJCXVuc2ln bmVkIGludCBod19ncGlvID0gYmNtNjM1OF9waW5zW3Bpbl0ubnVtYmVyOworCisJCXJhbmdlID0g cGluY3RybF9maW5kX2dwaW9fcmFuZ2VfZnJvbV9waW4ocGN0bGRldiwgaHdfZ3Bpbyk7CisJCWlm IChyYW5nZSkgeworCQkJc3RydWN0IGdwaW9fY2hpcCAqZ2MgPSByYW5nZS0+Z2M7CisKKwkJCWlm IChwZy0+ZGlyZWN0aW9uICYgQklUKHBpbikpCisJCQkJZ2MtPmRpcmVjdGlvbl9vdXRwdXQoZ2Ms IGh3X2dwaW8sIDApOworCQkJZWxzZQorCQkJCWdjLT5kaXJlY3Rpb25faW5wdXQoZ2MsIGh3X2dw aW8pOworCQl9CisJfQorCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgYmNtNjM1OF9ncGlv X3JlcXVlc3RfZW5hYmxlKHN0cnVjdCBwaW5jdHJsX2RldiAqcGN0bGRldiwKKwkJCQkgICAgICAg c3RydWN0IHBpbmN0cmxfZ3Bpb19yYW5nZSAqcmFuZ2UsCisJCQkJICAgICAgIHVuc2lnbmVkIG9m ZnNldCkKK3sKKwlzdHJ1Y3QgYmNtNjN4eF9waW5jdHJsICpwYyA9IHBpbmN0cmxfZGV2X2dldF9k cnZkYXRhKHBjdGxkZXYpOworCXN0cnVjdCBiY202MzU4X3ByaXYgKnByaXYgPSBwYy0+ZHJpdmVy X2RhdGE7CisJdW5zaWduZWQgaW50IG1hc2s7CisKKwltYXNrID0gKHVuc2lnbmVkIGxvbmcpIGJj bTYzNThfcGluc1tvZmZzZXRdLmRydl9kYXRhOworCWlmICghbWFzaykKKwkJcmV0dXJuIDA7CisK KwkvKiBkaXNhYmxlIGFsbCBmdW5jdGlvbnMgdXNpbmcgdGhpcyBwaW4gKi8KKwlyZXR1cm4gcmVn bWFwX2ZpZWxkX3VwZGF0ZV9iaXRzKHByaXYtPm92ZXJsYXlzLCBtYXNrLCAwKTsKK30KKworc3Rh dGljIHN0cnVjdCBwaW5jdHJsX29wcyBiY202MzU4X3BjdGxfb3BzID0geworCS5kdF9mcmVlX21h cCA9IHBpbmN0cmxfdXRpbHNfZnJlZV9tYXAsCisJLmR0X25vZGVfdG9fbWFwID0gcGluY29uZl9n ZW5lcmljX2R0X25vZGVfdG9fbWFwX3BpbiwKKwkuZ2V0X2dyb3VwX25hbWUgPSBiY202MzU4X3Bp bmN0cmxfZ2V0X2dyb3VwX25hbWUsCisJLmdldF9ncm91cF9waW5zID0gYmNtNjM1OF9waW5jdHJs X2dldF9ncm91cF9waW5zLAorCS5nZXRfZ3JvdXBzX2NvdW50ID0gYmNtNjM1OF9waW5jdHJsX2dl dF9ncm91cF9jb3VudCwKK307CisKK3N0YXRpYyBzdHJ1Y3QgcGlubXV4X29wcyBiY202MzU4X3Bt eF9vcHMgPSB7CisJLmdldF9mdW5jdGlvbl9ncm91cHMgPSBiY202MzU4X3BpbmN0cmxfZ2V0X2dy b3VwcywKKwkuZ2V0X2Z1bmN0aW9uX25hbWUgPSBiY202MzU4X3BpbmN0cmxfZ2V0X2Z1bmNfbmFt ZSwKKwkuZ2V0X2Z1bmN0aW9uc19jb3VudCA9IGJjbTYzNThfcGluY3RybF9nZXRfZnVuY19jb3Vu dCwKKwkuZ3Bpb19yZXF1ZXN0X2VuYWJsZSA9IGJjbTYzNThfZ3Bpb19yZXF1ZXN0X2VuYWJsZSwK Kwkuc2V0X211eCA9IGJjbTYzNThfcGluY3RybF9zZXRfbXV4LAorCS5zdHJpY3QgPSB0cnVlLAor fTsKKworc3RhdGljIGNvbnN0IHN0cnVjdCBiY202M3h4X3BpbmN0cmxfc29jIGJjbTYzNThfc29j ID0geworCS5uZ3Bpb3MgPSBCQ002MzU4X05VTV9HUElPUywKKwkubnBpbnMgPSBBUlJBWV9TSVpF KGJjbTYzNThfcGlucyksCisJLnBjdGxfb3BzID0gJmJjbTYzNThfcGN0bF9vcHMsCisJLnBpbnMg PSBiY202MzU4X3BpbnMsCisJLnBteF9vcHMgPSAmYmNtNjM1OF9wbXhfb3BzLAorfTsKKworc3Rh dGljIGludCBiY202MzU4X3BpbmN0cmxfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRl dikKK3sKKwlzdHJ1Y3QgcmVnX2ZpZWxkIG92ZXJsYXlzID0gUkVHX0ZJRUxEKEJDTTYzNThfTU9E RV9SRUcsIDAsIDE1KTsKKwlzdHJ1Y3QgZGV2aWNlICpkZXYgPSAmcGRldi0+ZGV2OworCXN0cnVj dCBiY202M3h4X3BpbmN0cmwgKnBjOworCXN0cnVjdCBiY202MzU4X3ByaXYgKnByaXY7CisJaW50 IGVycjsKKworCXByaXYgPSBkZXZtX2t6YWxsb2MoZGV2LCBzaXplb2YoKnByaXYpLCBHRlBfS0VS TkVMKTsKKwlpZiAoIXByaXYpCisJCXJldHVybiAtRU5PTUVNOworCisJZXJyID0gYmNtNjN4eF9w aW5jdHJsX3Byb2JlKHBkZXYsICZiY202MzU4X3NvYywgKHZvaWQgKikgcHJpdik7CisJaWYgKGVy cikKKwkJcmV0dXJuIGVycjsKKworCXBjID0gcGxhdGZvcm1fZ2V0X2RydmRhdGEocGRldik7CisK Kwlwcml2LT5vdmVybGF5cyA9IGRldm1fcmVnbWFwX2ZpZWxkX2FsbG9jKGRldiwgcGMtPnJlZ3Ms IG92ZXJsYXlzKTsKKwlpZiAoSVNfRVJSKHByaXYtPm92ZXJsYXlzKSkKKwkJcmV0dXJuIFBUUl9F UlIocHJpdi0+b3ZlcmxheXMpOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBjb25zdCBzdHJ1 Y3Qgb2ZfZGV2aWNlX2lkIGJjbTYzNThfcGluY3RybF9tYXRjaFtdID0geworCXsgLmNvbXBhdGli bGUgPSAiYnJjbSxiY202MzU4LXBpbmN0cmwiLCB9LAorCXsgLyogc2VudGluZWwgKi8gfQorfTsK Kworc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kcml2ZXIgYmNtNjM1OF9waW5jdHJsX2RyaXZlciA9 IHsKKwkucHJvYmUgPSBiY202MzU4X3BpbmN0cmxfcHJvYmUsCisJLmRyaXZlciA9IHsKKwkJLm5h bWUgPSAiYmNtNjM1OC1waW5jdHJsIiwKKwkJLm9mX21hdGNoX3RhYmxlID0gYmNtNjM1OF9waW5j dHJsX21hdGNoLAorCX0sCit9OworCitidWlsdGluX3BsYXRmb3JtX2RyaXZlcihiY202MzU4X3Bp bmN0cmxfZHJpdmVyKTsKLS0gCjIuMjAuMQoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fCmxpbnV4LWFybS1rZXJuZWwgbWFpbGluZyBsaXN0CmxpbnV4LWFy bS1rZXJuZWxAbGlzdHMuaW5mcmFkZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9t YWlsbWFuL2xpc3RpbmZvL2xpbnV4LWFybS1rZXJuZWwK