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=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 9B490C433DB for ; Wed, 17 Mar 2021 14:39:20 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 51A2E64F6E for ; Wed, 17 Mar 2021 14:39:20 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231960AbhCQOis (ORCPT ); Wed, 17 Mar 2021 10:38:48 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57054 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231968AbhCQOiR (ORCPT ); Wed, 17 Mar 2021 10:38:17 -0400 Received: from mail-wr1-x42a.google.com (mail-wr1-x42a.google.com [IPv6:2a00:1450:4864:20::42a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 5066FC06175F; Wed, 17 Mar 2021 07:38:17 -0700 (PDT) Received: by mail-wr1-x42a.google.com with SMTP id x13so2074685wrs.9; Wed, 17 Mar 2021 07:38:17 -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=GnNP8aK9PFtVzTE8gSQnI0L/ItPaLAHiWeaZpGqpsH0=; b=hPp3LfBoeNMykJeRzJs3BxpuuMJkJHNXOB++ZHSNwg2OLZVPzFmAIn5jxc1pupzaG0 FzuQn6yb68WJmCFzVw0Z6z/RIg8axlIM9iFvTwbhAipc2MSqVUBMXOV6PbhP/x+8jM9L UzOCYWcoTKmJxc5nDdE2ubDSkJO69jEA4IfHw7unsaA7Cg1pNLADQWYMyXY8N0/Es7wX /SsTBbz0FvLMmAtG6ckOU00azqCuocNIGy1n6QgXj2iDnf1RcVE0AmhYoRstxwhCMw0s zsRm5KsUuzdhLQvZzr7GQriXFOfaBPFbQiEjFimn2FUHQ6RkCtUpFOxg6lXJE/K/mFON Cshg== 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=GnNP8aK9PFtVzTE8gSQnI0L/ItPaLAHiWeaZpGqpsH0=; b=mH+ticUdXWZaKNyWQ9B+ZnFac3IrlZ8nN66FlQOLpXPtzqEzSL6QsyxvX4yIYrZpvi WujSLoweYC1YCtKUb4jMVxchvnKbUBfoNcaLG58f+sOKbv1qr3JzlCUztV3n9vU812dy ALOaI8JSmtkxChHd6Y8KqqURyi+2kApN/bgv7Z/eCRB0eO7MwyONgveVK0iiPhgoshmb SMjw4XVuCE1+euTqBCZwMeSI+maMTv0if9YDwDDu6/BdpkLGPW5P8osfMsj/UfKIKPLq lTPPFCZkXg9bRJjttGFyMcpfIKwNCQ65TORlTog/reiFSU3aNx2x0/PXVXOGwGrSQk3T aLGA== X-Gm-Message-State: AOAM5338+O/bOWHUTRQCkQTr0yVphdfjiTFI4AbzB1uecHO0UuijK7IR 3NgQQsZYzhQ/GcYyaFdvbpA= X-Google-Smtp-Source: ABdhPJzJu93wuQ3Ywz74S3/N0jKQFySc0fLBPjvqM2o3niU4lnc3DVZEDCBn4nVnuCC/kMuOXbNyXg== X-Received: by 2002:a05:6000:1ce:: with SMTP id t14mr3586069wrx.85.1615991895019; Wed, 17 Mar 2021 07:38:15 -0700 (PDT) Received: from skynet.lan ([80.31.204.166]) by smtp.gmail.com with ESMTPSA id a75sm2518948wme.10.2021.03.17.07.38.14 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 17 Mar 2021 07:38:14 -0700 (PDT) From: =?UTF-8?q?=C3=81lvaro=20Fern=C3=A1ndez=20Rojas?= To: Linus Walleij , Bartosz Golaszewski , Rob Herring , Lee Jones , Michael Walle , Florian Fainelli , bcm-kernel-feedback-list@broadcom.com, Jonas Gorski , =?UTF-8?q?=C3=81lvaro=20Fern=C3=A1ndez=20Rojas?= , Necip Fazil Yildiran , Andy Shevchenko , linux-gpio@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [PATCH v8 10/22] pinctrl: add a pincontrol driver for BCM6358 Date: Wed, 17 Mar 2021 15:37:51 +0100 Message-Id: <20210317143803.26127-11-noltari@gmail.com> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20210317143803.26127-1-noltari@gmail.com> References: <20210317143803.26127-1-noltari@gmail.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-gpio@vger.kernel.org Add a pincotrol driver for 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 --- 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,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 ED441C433E6 for ; Wed, 17 Mar 2021 14:42:12 +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 304F564F26 for ; Wed, 17 Mar 2021 14:42:12 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 304F564F26 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=gqdKOU7ee5jZPEnEeV2jP3DsEa9OCsp/x3zbaiuZxTI=; b=V+Jqhs64nGjaJqxCyOYfdhw6N 1i2rNuduV5KOBwB9AGBVn4sDZIAyYpm+AvJoueKGbDa0eX1XYEyjJnrnsK7fYYj7D00IBIhqmEGqB R5fDu3qLNlfgHEeSWBIC+OVffhA25npfGDxPo/GBI0R3o6iHK12yUku4+7ZjvIsILUCNGcSMNaC0O XXIkmARdlo6BrX9+ApGKaShlGilatLpKJv7SqZHOEtLbbCRWpDswDb5HlYk6i+35B3YrR23fx90Va uykkOEN4hxLV3yU+8C8LQFaDLNUNZAUKxvPj06u6opPL+U0C3Fq9tkbndrdaFpySWwSqEufbwwUw/ D+hLyGSIQ==; Received: from localhost ([::1] helo=desiato.infradead.org) by desiato.infradead.org with esmtp (Exim 4.94 #2 (Red Hat Linux)) id 1lMXLJ-003IMM-VJ; Wed, 17 Mar 2021 14:40:14 +0000 Received: from mail-wr1-x42f.google.com ([2a00:1450:4864:20::42f]) by desiato.infradead.org with esmtps (Exim 4.94 #2 (Red Hat Linux)) id 1lMXJP-003He1-JW for linux-arm-kernel@lists.infradead.org; Wed, 17 Mar 2021 14:38:18 +0000 Received: by mail-wr1-x42f.google.com with SMTP id t9so2062355wrn.11 for ; Wed, 17 Mar 2021 07:38:15 -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=GnNP8aK9PFtVzTE8gSQnI0L/ItPaLAHiWeaZpGqpsH0=; b=hPp3LfBoeNMykJeRzJs3BxpuuMJkJHNXOB++ZHSNwg2OLZVPzFmAIn5jxc1pupzaG0 FzuQn6yb68WJmCFzVw0Z6z/RIg8axlIM9iFvTwbhAipc2MSqVUBMXOV6PbhP/x+8jM9L UzOCYWcoTKmJxc5nDdE2ubDSkJO69jEA4IfHw7unsaA7Cg1pNLADQWYMyXY8N0/Es7wX /SsTBbz0FvLMmAtG6ckOU00azqCuocNIGy1n6QgXj2iDnf1RcVE0AmhYoRstxwhCMw0s zsRm5KsUuzdhLQvZzr7GQriXFOfaBPFbQiEjFimn2FUHQ6RkCtUpFOxg6lXJE/K/mFON Cshg== 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=GnNP8aK9PFtVzTE8gSQnI0L/ItPaLAHiWeaZpGqpsH0=; b=RYp5z94S/2ptholD0W5TAsw8R7Dnx/25/ixvHmpVFS/Ow+EAEPooaKtz7ehPMGLKsZ 3Ia9y8p3a0D0eftbudslKPUCvM4xRql1XmNKGEKaVemedhbEew4K68uQ7AbY0hllfUQF xwu+5G7+NuKzapIyYaIlsCNN9g30IiXA1W+xmmkpGwZAcNPlPFqgAXyylfrxijTfE3PL SX0BLq/X5WAufpc9a8+V/vfXExQDYwTYbxfQOtEGb8edFR1l7lTp04VJkoTvFHScvvSR HzayvH9e+l5Q1/EtBB7kOzhH2C+K3ibV7H8ly6T+qCadmjOAyyVVpITo//PH8ajWQEII CFOA== X-Gm-Message-State: AOAM530R5iYIOvZrIdrb9bwK7Iy8z2+llSY8fnciy0npWCyEhyoU7X40 3Il3vF6ycHCPcMqAGpDyQ8A= X-Google-Smtp-Source: ABdhPJzJu93wuQ3Ywz74S3/N0jKQFySc0fLBPjvqM2o3niU4lnc3DVZEDCBn4nVnuCC/kMuOXbNyXg== X-Received: by 2002:a05:6000:1ce:: with SMTP id t14mr3586069wrx.85.1615991895019; Wed, 17 Mar 2021 07:38:15 -0700 (PDT) Received: from skynet.lan ([80.31.204.166]) by smtp.gmail.com with ESMTPSA id a75sm2518948wme.10.2021.03.17.07.38.14 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 17 Mar 2021 07:38:14 -0700 (PDT) From: =?UTF-8?q?=C3=81lvaro=20Fern=C3=A1ndez=20Rojas?= To: Linus Walleij , Bartosz Golaszewski , Rob Herring , Lee Jones , Michael Walle , Florian Fainelli , bcm-kernel-feedback-list@broadcom.com, Jonas Gorski , =?UTF-8?q?=C3=81lvaro=20Fern=C3=A1ndez=20Rojas?= , Necip Fazil Yildiran , Andy Shevchenko , linux-gpio@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [PATCH v8 10/22] pinctrl: add a pincontrol driver for BCM6358 Date: Wed, 17 Mar 2021 15:37:51 +0100 Message-Id: <20210317143803.26127-11-noltari@gmail.com> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20210317143803.26127-1-noltari@gmail.com> References: <20210317143803.26127-1-noltari@gmail.com> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20210317_143815_704320_2CCEA1C8 X-CRM114-Status: GOOD ( 23.97 ) 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+Ci0tLQogdjg6IG5vIGNoYW5nZXMKIHY3OiBubyBjaGFuZ2VzCiB2Njog bm8gY2hhbmdlcwogdjU6IGFkZCBjaGFuZ2VzIHN1Z2dlc3RlZCBieSBBbmR5IFNoZXZjaGVua28K IHY0OiBubyBjaGFuZ2VzCiB2MzogdXNlIG5ldyBzaGFyZWQgY29kZQogdjI6IHN3aXRjaCB0byBH UElPX1JFR01BUAoKIGRyaXZlcnMvcGluY3RybC9iY20vS2NvbmZpZyAgICAgICAgICAgfCAgIDgg KwogZHJpdmVycy9waW5jdHJsL2JjbS9NYWtlZmlsZSAgICAgICAgICB8ICAgMSArCiBkcml2ZXJz L3BpbmN0cmwvYmNtL3BpbmN0cmwtYmNtNjM1OC5jIHwgMzY5ICsrKysrKysrKysrKysrKysrKysr KysrKysrCiAzIGZpbGVzIGNoYW5nZWQsIDM3OCBpbnNlcnRpb25zKCspCiBjcmVhdGUgbW9kZSAx MDA2NDQgZHJpdmVycy9waW5jdHJsL2JjbS9waW5jdHJsLWJjbTYzNTguYwoKZGlmZiAtLWdpdCBh L2RyaXZlcnMvcGluY3RybC9iY20vS2NvbmZpZyBiL2RyaXZlcnMvcGluY3RybC9iY20vS2NvbmZp ZwppbmRleCBkMzVlNWQzZmUyNmYuLmNlZDdjYzZhYjQ0ZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9w aW5jdHJsL2JjbS9LY29uZmlnCisrKyBiL2RyaXZlcnMvcGluY3RybC9iY20vS2NvbmZpZwpAQCAt NDQsNiArNDQsMTQgQEAgY29uZmlnIFBJTkNUUkxfQkNNNjMyOAogCWhlbHAKIAkgICBTYXkgWSBo ZXJlIHRvIGVuYWJsZSB0aGUgQnJvYWRjb20gQkNNNjMyOCBHUElPIGRyaXZlci4KIAorY29uZmln IFBJTkNUUkxfQkNNNjM1OAorCWJvb2wgIkJyb2FkY29tIEJDTTYzNTggR1BJTyBkcml2ZXIiCisJ ZGVwZW5kcyBvbiAoQk1JUFNfR0VORVJJQyB8fCBDT01QSUxFX1RFU1QpCisJc2VsZWN0IFBJTkNU UkxfQkNNNjNYWAorCWRlZmF1bHQgQk1JUFNfR0VORVJJQworCWhlbHAKKwkgICBTYXkgWSBoZXJl IHRvIGVuYWJsZSB0aGUgQnJvYWRjb20gQkNNNjM1OCBHUElPIGRyaXZlci4KKwogY29uZmlnIFBJ TkNUUkxfSVBST0NfR1BJTwogCWJvb2wgIkJyb2FkY29tIGlQcm9jIEdQSU8gKHdpdGggUElOQ09O RikgZHJpdmVyIgogCWRlcGVuZHMgb24gT0ZfR1BJTyAmJiAoQVJDSF9CQ01fSVBST0MgfHwgQ09N UElMRV9URVNUKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9waW5jdHJsL2JjbS9NYWtlZmlsZSBiL2Ry aXZlcnMvcGluY3RybC9iY20vTWFrZWZpbGUKaW5kZXggNTdlNTQzNGE2ZGI2Li5jM2Y1YjdiMmYy ZjAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcGluY3RybC9iY20vTWFrZWZpbGUKKysrIGIvZHJpdmVy cy9waW5jdHJsL2JjbS9NYWtlZmlsZQpAQCAtNSw2ICs1LDcgQEAgb2JqLSQoQ09ORklHX1BJTkNU UkxfQkNNMjgxWFgpCQkrPSBwaW5jdHJsLWJjbTI4MXh4Lm8KIG9iai0kKENPTkZJR19QSU5DVFJM X0JDTTI4MzUpCQkrPSBwaW5jdHJsLWJjbTI4MzUubwogb2JqLSQoQ09ORklHX1BJTkNUUkxfQkNN NjNYWCkJCSs9IHBpbmN0cmwtYmNtNjN4eC5vCiBvYmotJChDT05GSUdfUElOQ1RSTF9CQ002MzI4 KQkJKz0gcGluY3RybC1iY202MzI4Lm8KK29iai0kKENPTkZJR19QSU5DVFJMX0JDTTYzNTgpCQkr PSBwaW5jdHJsLWJjbTYzNTgubwogb2JqLSQoQ09ORklHX1BJTkNUUkxfSVBST0NfR1BJTykJKz0g cGluY3RybC1pcHJvYy1ncGlvLm8KIG9iai0kKENPTkZJR19QSU5DVFJMX0NZR05VU19NVVgpCSs9 IHBpbmN0cmwtY3lnbnVzLW11eC5vCiBvYmotJChDT05GSUdfUElOQ1RSTF9OUykJCSs9IHBpbmN0 cmwtbnMubwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9waW5jdHJsL2JjbS9waW5jdHJsLWJjbTYzNTgu YyBiL2RyaXZlcnMvcGluY3RybC9iY20vcGluY3RybC1iY202MzU4LmMKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi5kNjM4NTc4NzI3ZjMKLS0tIC9kZXYvbnVsbAorKysg Yi9kcml2ZXJzL3BpbmN0cmwvYmNtL3BpbmN0cmwtYmNtNjM1OC5jCkBAIC0wLDAgKzEsMzY5IEBA CisvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMCsKKy8qCisgKiBEcml2ZXIgZm9y IEJDTTYzNTggR1BJTyB1bml0IChwaW5jdHJsICsgR1BJTykKKyAqCisgKiBDb3B5cmlnaHQgKEMp IDIwMjEgw4FsdmFybyBGZXJuw6FuZGV6IFJvamFzIDxub2x0YXJpQGdtYWlsLmNvbT4KKyAqIENv cHlyaWdodCAoQykgMjAxNiBKb25hcyBHb3Jza2kgPGpvbmFzLmdvcnNraUBnbWFpbC5jb20+Cisg Ki8KKworI2luY2x1ZGUgPGxpbnV4L2JpdHMuaD4KKyNpbmNsdWRlIDxsaW51eC9ncGlvL2RyaXZl ci5oPgorI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgorI2luY2x1ZGUgPGxpbnV4L29mLmg+Cisj aW5jbHVkZSA8bGludXgvcGluY3RybC9waW5tdXguaD4KKyNpbmNsdWRlIDxsaW51eC9wbGF0Zm9y bV9kZXZpY2UuaD4KKyNpbmNsdWRlIDxsaW51eC9yZWdtYXAuaD4KKworI2luY2x1ZGUgIi4uL3Bp bmN0cmwtdXRpbHMuaCIKKworI2luY2x1ZGUgInBpbmN0cmwtYmNtNjN4eC5oIgorCisjZGVmaW5l IEJDTTYzNThfTlVNX0dQSU9TCQk0MAorCisjZGVmaW5lIEJDTTYzNThfTU9ERV9SRUcJCTB4MTgK KyNkZWZpbmUgIEJDTTYzNThfTU9ERV9NVVhfTk9ORQkJMAorI2RlZmluZSAgQkNNNjM1OF9NT0RF X01VWF9FQklfQ1MJQklUKDUpCisjZGVmaW5lICBCQ002MzU4X01PREVfTVVYX1VBUlQxCQlCSVQo NikKKyNkZWZpbmUgIEJDTTYzNThfTU9ERV9NVVhfU1BJX0NTCUJJVCg3KQorI2RlZmluZSAgQkNN NjM1OF9NT0RFX01VWF9BU1lOQ19NT0RFTQlCSVQoOCkKKyNkZWZpbmUgIEJDTTYzNThfTU9ERV9N VVhfTEVHQUNZX0xFRAlCSVQoOSkKKyNkZWZpbmUgIEJDTTYzNThfTU9ERV9NVVhfU0VSSUFMX0xF RAlCSVQoMTApCisjZGVmaW5lICBCQ002MzU4X01PREVfTVVYX0xFRAkJQklUKDExKQorI2RlZmlu ZSAgQkNNNjM1OF9NT0RFX01VWF9VVE9QSUEJQklUKDEyKQorI2RlZmluZSAgQkNNNjM1OF9NT0RF X01VWF9DTEtSU1QJQklUKDEzKQorI2RlZmluZSAgQkNNNjM1OF9NT0RFX01VWF9QV01fU1lOX0NM SwlCSVQoMTQpCisjZGVmaW5lICBCQ002MzU4X01PREVfTVVYX1NZU19JUlEJQklUKDE1KQorCitz dHJ1Y3QgYmNtNjM1OF9waW5ncm91cCB7CisJY29uc3QgY2hhciAqbmFtZTsKKwljb25zdCB1bnNp Z25lZCAqIGNvbnN0IHBpbnM7CisJY29uc3QgdW5zaWduZWQgbnVtX3BpbnM7CisKKwljb25zdCB1 aW50MTZfdCBtb2RlX3ZhbDsKKworCS8qIG5vbi1HUElPIGZ1bmN0aW9uIG11eGVzIHJlcXVpcmUg dGhlIGdwaW8gZGlyZWN0aW9uIHRvIGJlIHNldCAqLworCWNvbnN0IHVpbnQxNl90IGRpcmVjdGlv bjsKK307CisKK3N0cnVjdCBiY202MzU4X2Z1bmN0aW9uIHsKKwljb25zdCBjaGFyICpuYW1lOwor CWNvbnN0IGNoYXIgKiBjb25zdCAqZ3JvdXBzOworCWNvbnN0IHVuc2lnbmVkIG51bV9ncm91cHM7 Cit9OworCitzdHJ1Y3QgYmNtNjM1OF9wcml2IHsKKwlzdHJ1Y3QgcmVnbWFwX2ZpZWxkICpvdmVy bGF5czsKK307CisKKyNkZWZpbmUgQkNNNjM1OF9HUElPX1BJTihhLCBiLCBiaXQxLCBiaXQyLCBi aXQzKQkJXAorCXsJCQkJCQkJXAorCQkubnVtYmVyID0gYSwJCQkJCVwKKwkJLm5hbWUgPSBiLAkJ CQkJXAorCQkuZHJ2X2RhdGEgPSAodm9pZCAqKShCQ002MzU4X01PREVfTVVYXyMjYml0MSB8CVwK KwkJCQkgICAgIEJDTTYzNThfTU9ERV9NVVhfIyNiaXQyIHwJXAorCQkJCSAgICAgQkNNNjM1OF9N T0RFX01VWF8jI2JpdDMpLAlcCisJfQorCitzdGF0aWMgY29uc3Qgc3RydWN0IHBpbmN0cmxfcGlu X2Rlc2MgYmNtNjM1OF9waW5zW10gPSB7CisJQkNNNjM1OF9HUElPX1BJTigwLCAiZ3BpbzAiLCBM RUQsIE5PTkUsIE5PTkUpLAorCUJDTTYzNThfR1BJT19QSU4oMSwgImdwaW8xIiwgTEVELCBOT05F LCBOT05FKSwKKwlCQ002MzU4X0dQSU9fUElOKDIsICJncGlvMiIsIExFRCwgTk9ORSwgTk9ORSks CisJQkNNNjM1OF9HUElPX1BJTigzLCAiZ3BpbzMiLCBMRUQsIE5PTkUsIE5PTkUpLAorCVBJTkNU UkxfUElOKDQsICJncGlvNCIpLAorCUJDTTYzNThfR1BJT19QSU4oNSwgImdwaW81IiwgU1lTX0lS USwgTk9ORSwgTk9ORSksCisJQkNNNjM1OF9HUElPX1BJTig2LCAiZ3BpbzYiLCBTRVJJQUxfTEVE LCBOT05FLCBOT05FKSwKKwlCQ002MzU4X0dQSU9fUElOKDcsICJncGlvNyIsIFNFUklBTF9MRUQs IE5PTkUsIE5PTkUpLAorCUJDTTYzNThfR1BJT19QSU4oOCwgImdwaW84IiwgUFdNX1NZTl9DTEss IE5PTkUsIE5PTkUpLAorCUJDTTYzNThfR1BJT19QSU4oOSwgImdwaW8wOSIsIExFR0FDWV9MRUQs IE5PTkUsIE5PTkUpLAorCUJDTTYzNThfR1BJT19QSU4oMTAsICJncGlvMTAiLCBMRUdBQ1lfTEVE LCBOT05FLCBOT05FKSwKKwlCQ002MzU4X0dQSU9fUElOKDExLCAiZ3BpbzExIiwgTEVHQUNZX0xF RCwgTk9ORSwgTk9ORSksCisJQkNNNjM1OF9HUElPX1BJTigxMiwgImdwaW8xMiIsIExFR0FDWV9M RUQsIEFTWU5DX01PREVNLCBVVE9QSUEpLAorCUJDTTYzNThfR1BJT19QSU4oMTMsICJncGlvMTMi LCBMRUdBQ1lfTEVELCBBU1lOQ19NT0RFTSwgVVRPUElBKSwKKwlCQ002MzU4X0dQSU9fUElOKDE0 LCAiZ3BpbzE0IiwgTEVHQUNZX0xFRCwgQVNZTkNfTU9ERU0sIFVUT1BJQSksCisJQkNNNjM1OF9H UElPX1BJTigxNSwgImdwaW8xNSIsIExFR0FDWV9MRUQsIEFTWU5DX01PREVNLCBVVE9QSUEpLAor CVBJTkNUUkxfUElOKDE2LCAiZ3BpbzE2IiksCisJUElOQ1RSTF9QSU4oMTcsICJncGlvMTciKSwK KwlQSU5DVFJMX1BJTigxOCwgImdwaW8xOCIpLAorCVBJTkNUUkxfUElOKDE5LCAiZ3BpbzE5Iiks CisJUElOQ1RSTF9QSU4oMjAsICJncGlvMjAiKSwKKwlQSU5DVFJMX1BJTigyMSwgImdwaW8yMSIp LAorCUJDTTYzNThfR1BJT19QSU4oMjIsICJncGlvMjIiLCBVVE9QSUEsIE5PTkUsIE5PTkUpLAor CUJDTTYzNThfR1BJT19QSU4oMjMsICJncGlvMjMiLCBVVE9QSUEsIE5PTkUsIE5PTkUpLAorCUJD TTYzNThfR1BJT19QSU4oMjQsICJncGlvMjQiLCBVVE9QSUEsIE5PTkUsIE5PTkUpLAorCUJDTTYz NThfR1BJT19QSU4oMjUsICJncGlvMjUiLCBVVE9QSUEsIE5PTkUsIE5PTkUpLAorCUJDTTYzNThf R1BJT19QSU4oMjYsICJncGlvMjYiLCBVVE9QSUEsIE5PTkUsIE5PTkUpLAorCUJDTTYzNThfR1BJ T19QSU4oMjcsICJncGlvMjciLCBVVE9QSUEsIE5PTkUsIE5PTkUpLAorCUJDTTYzNThfR1BJT19Q SU4oMjgsICJncGlvMjgiLCBVVE9QSUEsIFVBUlQxLCBOT05FKSwKKwlCQ002MzU4X0dQSU9fUElO KDI5LCAiZ3BpbzI5IiwgVVRPUElBLCBVQVJUMSwgTk9ORSksCisJQkNNNjM1OF9HUElPX1BJTigz MCwgImdwaW8zMCIsIFVUT1BJQSwgVUFSVDEsIEVCSV9DUyksCisJQkNNNjM1OF9HUElPX1BJTigz MSwgImdwaW8zMSIsIFVUT1BJQSwgVUFSVDEsIEVCSV9DUyksCisJQkNNNjM1OF9HUElPX1BJTigz MiwgImdwaW8zMiIsIFNQSV9DUywgTk9ORSwgTk9ORSksCisJQkNNNjM1OF9HUElPX1BJTigzMywg ImdwaW8zMyIsIFNQSV9DUywgTk9ORSwgTk9ORSksCisJUElOQ1RSTF9QSU4oMzQsICJncGlvMzQi KSwKKwlQSU5DVFJMX1BJTigzNSwgImdwaW8zNSIpLAorCVBJTkNUUkxfUElOKDM2LCAiZ3BpbzM2 IiksCisJUElOQ1RSTF9QSU4oMzcsICJncGlvMzciKSwKKwlQSU5DVFJMX1BJTigzOCwgImdwaW8z OCIpLAorCVBJTkNUUkxfUElOKDM5LCAiZ3BpbzM5IiksCit9OworCitzdGF0aWMgdW5zaWduZWQg ZWJpX2NzX2dycF9waW5zW10gPSB7IDMwLCAzMSB9OworCitzdGF0aWMgdW5zaWduZWQgdWFydDFf Z3JwX3BpbnNbXSA9IHsgMjgsIDI5LCAzMCwgMzEgfTsKKworc3RhdGljIHVuc2lnbmVkIHNwaV9j c19ncnBfcGluc1tdID0geyAzMiwgMzMgfTsKKworc3RhdGljIHVuc2lnbmVkIGFzeW5jX21vZGVt X2dycF9waW5zW10gPSB7IDEyLCAxMywgMTQsIDE1IH07CisKK3N0YXRpYyB1bnNpZ25lZCBzZXJp YWxfbGVkX2dycF9waW5zW10gPSB7IDYsIDcgfTsKKworc3RhdGljIHVuc2lnbmVkIGxlZ2FjeV9s ZWRfZ3JwX3BpbnNbXSA9IHsgOSwgMTAsIDExLCAxMiwgMTMsIDE0LCAxNSB9OworCitzdGF0aWMg dW5zaWduZWQgbGVkX2dycF9waW5zW10gPSB7IDAsIDEsIDIsIDMgfTsKKworc3RhdGljIHVuc2ln bmVkIHV0b3BpYV9ncnBfcGluc1tdID0geworCTEyLCAxMywgMTQsIDE1LCAyMiwgMjMsIDI0LCAy NSwgMjYsIDI3LCAyOCwgMjksIDMwLCAzMSwKK307CisKK3N0YXRpYyB1bnNpZ25lZCBwd21fc3lu X2Nsa19ncnBfcGluc1tdID0geyA4IH07CisKK3N0YXRpYyB1bnNpZ25lZCBzeXNfaXJxX2dycF9w aW5zW10gPSB7IDUgfTsKKworI2RlZmluZSBCQ002MzU4X0dQSU9fTVVYX0dST1VQKG4sIGJpdCwg ZGlyKQkJCVwKKwl7CQkJCQkJCVwKKwkJLm5hbWUgPSAjbiwJCQkJCVwKKwkJLnBpbnMgPSBuIyNf cGlucywJCQkJXAorCQkubnVtX3BpbnMgPSBBUlJBWV9TSVpFKG4jI19waW5zKSwJCVwKKwkJLm1v ZGVfdmFsID0gQkNNNjM1OF9NT0RFX01VWF8jI2JpdCwJCVwKKwkJLmRpcmVjdGlvbiA9IGRpciwJ CQkJXAorCX0KKworc3RhdGljIGNvbnN0IHN0cnVjdCBiY202MzU4X3Bpbmdyb3VwIGJjbTYzNThf Z3JvdXBzW10gPSB7CisJQkNNNjM1OF9HUElPX01VWF9HUk9VUChlYmlfY3NfZ3JwLCBFQklfQ1Ms IDB4MyksCisJQkNNNjM1OF9HUElPX01VWF9HUk9VUCh1YXJ0MV9ncnAsIFVBUlQxLCAweDIpLAor CUJDTTYzNThfR1BJT19NVVhfR1JPVVAoc3BpX2NzX2dycCwgU1BJX0NTLCAweDYpLAorCUJDTTYz NThfR1BJT19NVVhfR1JPVVAoYXN5bmNfbW9kZW1fZ3JwLCBBU1lOQ19NT0RFTSwgMHg2KSwKKwlC Q002MzU4X0dQSU9fTVVYX0dST1VQKGxlZ2FjeV9sZWRfZ3JwLCBMRUdBQ1lfTEVELCAweDdmKSwK KwlCQ002MzU4X0dQSU9fTVVYX0dST1VQKHNlcmlhbF9sZWRfZ3JwLCBTRVJJQUxfTEVELCAweDMp LAorCUJDTTYzNThfR1BJT19NVVhfR1JPVVAobGVkX2dycCwgTEVELCAweGYpLAorCUJDTTYzNThf R1BJT19NVVhfR1JPVVAodXRvcGlhX2dycCwgVVRPUElBLCAweDAwMGYpLAorCUJDTTYzNThfR1BJ T19NVVhfR1JPVVAocHdtX3N5bl9jbGtfZ3JwLCBQV01fU1lOX0NMSywgMHgxKSwKKwlCQ002MzU4 X0dQSU9fTVVYX0dST1VQKHN5c19pcnFfZ3JwLCBTWVNfSVJRLCAweDEpLAorfTsKKworc3RhdGlj IGNvbnN0IGNoYXIgKiBjb25zdCBlYmlfY3NfZ3JvdXBzW10gPSB7CisJImViaV9jc19ncnAiCit9 OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHVhcnQxX2dyb3Vwc1tdID0geworCSJ1YXJ0 MV9ncnAiCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHNwaV9jc18yXzNfZ3JvdXBz W10gPSB7CisJInNwaV9jc18yXzNfZ3JwIgorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25z dCBhc3luY19tb2RlbV9ncm91cHNbXSA9IHsKKwkiYXN5bmNfbW9kZW1fZ3JwIgorfTsKKworc3Rh dGljIGNvbnN0IGNoYXIgKiBjb25zdCBsZWdhY3lfbGVkX2dyb3Vwc1tdID0geworCSJsZWdhY3lf bGVkX2dycCIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHNlcmlhbF9sZWRfZ3Jv dXBzW10gPSB7CisJInNlcmlhbF9sZWRfZ3JwIiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICog Y29uc3QgbGVkX2dyb3Vwc1tdID0geworCSJsZWRfZ3JwIiwKK307CisKK3N0YXRpYyBjb25zdCBj aGFyICogY29uc3QgY2xrcnN0X2dyb3Vwc1tdID0geworCSJjbGtyc3RfZ3JwIiwKK307CisKK3N0 YXRpYyBjb25zdCBjaGFyICogY29uc3QgcHdtX3N5bl9jbGtfZ3JvdXBzW10gPSB7CisJInB3bV9z eW5fY2xrX2dycCIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHN5c19pcnFfZ3Jv dXBzW10gPSB7CisJInN5c19pcnFfZ3JwIiwKK307CisKKyNkZWZpbmUgQkNNNjM1OF9GVU4obikJ CQkJCVwKKwl7CQkJCQkJXAorCQkubmFtZSA9ICNuLAkJCQlcCisJCS5ncm91cHMgPSBuIyNfZ3Jv dXBzLAkJCVwKKwkJLm51bV9ncm91cHMgPSBBUlJBWV9TSVpFKG4jI19ncm91cHMpLAlcCisJfQor CitzdGF0aWMgY29uc3Qgc3RydWN0IGJjbTYzNThfZnVuY3Rpb24gYmNtNjM1OF9mdW5jc1tdID0g eworCUJDTTYzNThfRlVOKGViaV9jcyksCisJQkNNNjM1OF9GVU4odWFydDEpLAorCUJDTTYzNThf RlVOKHNwaV9jc18yXzMpLAorCUJDTTYzNThfRlVOKGFzeW5jX21vZGVtKSwKKwlCQ002MzU4X0ZV TihsZWdhY3lfbGVkKSwKKwlCQ002MzU4X0ZVTihzZXJpYWxfbGVkKSwKKwlCQ002MzU4X0ZVTihs ZWQpLAorCUJDTTYzNThfRlVOKGNsa3JzdCksCisJQkNNNjM1OF9GVU4ocHdtX3N5bl9jbGspLAor CUJDTTYzNThfRlVOKHN5c19pcnEpLAorfTsKKworc3RhdGljIGludCBiY202MzU4X3BpbmN0cmxf Z2V0X2dyb3VwX2NvdW50KHN0cnVjdCBwaW5jdHJsX2RldiAqcGN0bGRldikKK3sKKwlyZXR1cm4g QVJSQVlfU0laRShiY202MzU4X2dyb3Vwcyk7Cit9CisKK3N0YXRpYyBjb25zdCBjaGFyICpiY202 MzU4X3BpbmN0cmxfZ2V0X2dyb3VwX25hbWUoc3RydWN0IHBpbmN0cmxfZGV2ICpwY3RsZGV2LAor CQkJCQkJICB1bnNpZ25lZCBncm91cCkKK3sKKwlyZXR1cm4gYmNtNjM1OF9ncm91cHNbZ3JvdXBd Lm5hbWU7Cit9CisKK3N0YXRpYyBpbnQgYmNtNjM1OF9waW5jdHJsX2dldF9ncm91cF9waW5zKHN0 cnVjdCBwaW5jdHJsX2RldiAqcGN0bGRldiwKKwkJCQkJICB1bnNpZ25lZCBncm91cCwgY29uc3Qg dW5zaWduZWQgKipwaW5zLAorCQkJCQkgIHVuc2lnbmVkICpudW1fcGlucykKK3sKKwkqcGlucyA9 IGJjbTYzNThfZ3JvdXBzW2dyb3VwXS5waW5zOworCSpudW1fcGlucyA9IGJjbTYzNThfZ3JvdXBz W2dyb3VwXS5udW1fcGluczsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IGJjbTYzNThf cGluY3RybF9nZXRfZnVuY19jb3VudChzdHJ1Y3QgcGluY3RybF9kZXYgKnBjdGxkZXYpCit7CisJ cmV0dXJuIEFSUkFZX1NJWkUoYmNtNjM1OF9mdW5jcyk7Cit9CisKK3N0YXRpYyBjb25zdCBjaGFy ICpiY202MzU4X3BpbmN0cmxfZ2V0X2Z1bmNfbmFtZShzdHJ1Y3QgcGluY3RybF9kZXYgKnBjdGxk ZXYsCisJCQkJCQkgdW5zaWduZWQgc2VsZWN0b3IpCit7CisJcmV0dXJuIGJjbTYzNThfZnVuY3Nb c2VsZWN0b3JdLm5hbWU7Cit9CisKK3N0YXRpYyBpbnQgYmNtNjM1OF9waW5jdHJsX2dldF9ncm91 cHMoc3RydWN0IHBpbmN0cmxfZGV2ICpwY3RsZGV2LAorCQkJCSAgICAgIHVuc2lnbmVkIHNlbGVj dG9yLAorCQkJCSAgICAgIGNvbnN0IGNoYXIgKiBjb25zdCAqKmdyb3VwcywKKwkJCQkgICAgICB1 bnNpZ25lZCAqIGNvbnN0IG51bV9ncm91cHMpCit7CisJKmdyb3VwcyA9IGJjbTYzNThfZnVuY3Nb c2VsZWN0b3JdLmdyb3VwczsKKwkqbnVtX2dyb3VwcyA9IGJjbTYzNThfZnVuY3Nbc2VsZWN0b3Jd Lm51bV9ncm91cHM7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBiY202MzU4X3BpbmN0 cmxfc2V0X211eChzdHJ1Y3QgcGluY3RybF9kZXYgKnBjdGxkZXYsCisJCQkJICAgdW5zaWduZWQg c2VsZWN0b3IsIHVuc2lnbmVkIGdyb3VwKQoreworCXN0cnVjdCBiY202M3h4X3BpbmN0cmwgKnBj ID0gcGluY3RybF9kZXZfZ2V0X2RydmRhdGEocGN0bGRldik7CisJc3RydWN0IGJjbTYzNThfcHJp diAqcHJpdiA9IHBjLT5kcml2ZXJfZGF0YTsKKwljb25zdCBzdHJ1Y3QgYmNtNjM1OF9waW5ncm91 cCAqcGcgPSAmYmNtNjM1OF9ncm91cHNbZ3JvdXBdOworCXVuc2lnbmVkIGludCB2YWwgPSBwZy0+ bW9kZV92YWw7CisJdW5zaWduZWQgaW50IG1hc2sgPSB2YWw7CisJdW5zaWduZWQgcGluOworCisJ Zm9yIChwaW4gPSAwOyBwaW4gPCBwZy0+bnVtX3BpbnM7IHBpbisrKQorCQltYXNrIHw9ICh1bnNp Z25lZCBsb25nKWJjbTYzNThfcGluc1twaW5dLmRydl9kYXRhOworCisJcmVnbWFwX2ZpZWxkX3Vw ZGF0ZV9iaXRzKHByaXYtPm92ZXJsYXlzLCBtYXNrLCB2YWwpOworCisJZm9yIChwaW4gPSAwOyBw aW4gPCBwZy0+bnVtX3BpbnM7IHBpbisrKSB7CisJCXN0cnVjdCBwaW5jdHJsX2dwaW9fcmFuZ2Ug KnJhbmdlOworCQl1bnNpZ25lZCBpbnQgaHdfZ3BpbyA9IGJjbTYzNThfcGluc1twaW5dLm51bWJl cjsKKworCQlyYW5nZSA9IHBpbmN0cmxfZmluZF9ncGlvX3JhbmdlX2Zyb21fcGluKHBjdGxkZXYs IGh3X2dwaW8pOworCQlpZiAocmFuZ2UpIHsKKwkJCXN0cnVjdCBncGlvX2NoaXAgKmdjID0gcmFu Z2UtPmdjOworCisJCQlpZiAocGctPmRpcmVjdGlvbiAmIEJJVChwaW4pKQorCQkJCWdjLT5kaXJl Y3Rpb25fb3V0cHV0KGdjLCBod19ncGlvLCAwKTsKKwkJCWVsc2UKKwkJCQlnYy0+ZGlyZWN0aW9u X2lucHV0KGdjLCBod19ncGlvKTsKKwkJfQorCX0KKworCXJldHVybiAwOworfQorCitzdGF0aWMg aW50IGJjbTYzNThfZ3Bpb19yZXF1ZXN0X2VuYWJsZShzdHJ1Y3QgcGluY3RybF9kZXYgKnBjdGxk ZXYsCisJCQkJICAgICAgIHN0cnVjdCBwaW5jdHJsX2dwaW9fcmFuZ2UgKnJhbmdlLAorCQkJCSAg ICAgICB1bnNpZ25lZCBvZmZzZXQpCit7CisJc3RydWN0IGJjbTYzeHhfcGluY3RybCAqcGMgPSBw aW5jdHJsX2Rldl9nZXRfZHJ2ZGF0YShwY3RsZGV2KTsKKwlzdHJ1Y3QgYmNtNjM1OF9wcml2ICpw cml2ID0gcGMtPmRyaXZlcl9kYXRhOworCXVuc2lnbmVkIGludCBtYXNrOworCisJbWFzayA9ICh1 bnNpZ25lZCBsb25nKSBiY202MzU4X3BpbnNbb2Zmc2V0XS5kcnZfZGF0YTsKKwlpZiAoIW1hc2sp CisJCXJldHVybiAwOworCisJLyogZGlzYWJsZSBhbGwgZnVuY3Rpb25zIHVzaW5nIHRoaXMgcGlu ICovCisJcmV0dXJuIHJlZ21hcF9maWVsZF91cGRhdGVfYml0cyhwcml2LT5vdmVybGF5cywgbWFz aywgMCk7Cit9CisKK3N0YXRpYyBzdHJ1Y3QgcGluY3RybF9vcHMgYmNtNjM1OF9wY3RsX29wcyA9 IHsKKwkuZHRfZnJlZV9tYXAgPSBwaW5jdHJsX3V0aWxzX2ZyZWVfbWFwLAorCS5kdF9ub2RlX3Rv X21hcCA9IHBpbmNvbmZfZ2VuZXJpY19kdF9ub2RlX3RvX21hcF9waW4sCisJLmdldF9ncm91cF9u YW1lID0gYmNtNjM1OF9waW5jdHJsX2dldF9ncm91cF9uYW1lLAorCS5nZXRfZ3JvdXBfcGlucyA9 IGJjbTYzNThfcGluY3RybF9nZXRfZ3JvdXBfcGlucywKKwkuZ2V0X2dyb3Vwc19jb3VudCA9IGJj bTYzNThfcGluY3RybF9nZXRfZ3JvdXBfY291bnQsCit9OworCitzdGF0aWMgc3RydWN0IHBpbm11 eF9vcHMgYmNtNjM1OF9wbXhfb3BzID0geworCS5nZXRfZnVuY3Rpb25fZ3JvdXBzID0gYmNtNjM1 OF9waW5jdHJsX2dldF9ncm91cHMsCisJLmdldF9mdW5jdGlvbl9uYW1lID0gYmNtNjM1OF9waW5j dHJsX2dldF9mdW5jX25hbWUsCisJLmdldF9mdW5jdGlvbnNfY291bnQgPSBiY202MzU4X3BpbmN0 cmxfZ2V0X2Z1bmNfY291bnQsCisJLmdwaW9fcmVxdWVzdF9lbmFibGUgPSBiY202MzU4X2dwaW9f cmVxdWVzdF9lbmFibGUsCisJLnNldF9tdXggPSBiY202MzU4X3BpbmN0cmxfc2V0X211eCwKKwku c3RyaWN0ID0gdHJ1ZSwKK307CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgYmNtNjN4eF9waW5jdHJs X3NvYyBiY202MzU4X3NvYyA9IHsKKwkubmdwaW9zID0gQkNNNjM1OF9OVU1fR1BJT1MsCisJLm5w aW5zID0gQVJSQVlfU0laRShiY202MzU4X3BpbnMpLAorCS5wY3RsX29wcyA9ICZiY202MzU4X3Bj dGxfb3BzLAorCS5waW5zID0gYmNtNjM1OF9waW5zLAorCS5wbXhfb3BzID0gJmJjbTYzNThfcG14 X29wcywKK307CisKK3N0YXRpYyBpbnQgYmNtNjM1OF9waW5jdHJsX3Byb2JlKHN0cnVjdCBwbGF0 Zm9ybV9kZXZpY2UgKnBkZXYpCit7CisJc3RydWN0IHJlZ19maWVsZCBvdmVybGF5cyA9IFJFR19G SUVMRChCQ002MzU4X01PREVfUkVHLCAwLCAxNSk7CisJc3RydWN0IGRldmljZSAqZGV2ID0gJnBk ZXYtPmRldjsKKwlzdHJ1Y3QgYmNtNjN4eF9waW5jdHJsICpwYzsKKwlzdHJ1Y3QgYmNtNjM1OF9w cml2ICpwcml2OworCWludCBlcnI7CisKKwlwcml2ID0gZGV2bV9remFsbG9jKGRldiwgc2l6ZW9m KCpwcml2KSwgR0ZQX0tFUk5FTCk7CisJaWYgKCFwcml2KQorCQlyZXR1cm4gLUVOT01FTTsKKwor CWVyciA9IGJjbTYzeHhfcGluY3RybF9wcm9iZShwZGV2LCAmYmNtNjM1OF9zb2MsICh2b2lkICop IHByaXYpOworCWlmIChlcnIpCisJCXJldHVybiBlcnI7CisKKwlwYyA9IHBsYXRmb3JtX2dldF9k cnZkYXRhKHBkZXYpOworCisJcHJpdi0+b3ZlcmxheXMgPSBkZXZtX3JlZ21hcF9maWVsZF9hbGxv YyhkZXYsIHBjLT5yZWdzLCBvdmVybGF5cyk7CisJaWYgKElTX0VSUihwcml2LT5vdmVybGF5cykp CisJCXJldHVybiBQVFJfRVJSKHByaXYtPm92ZXJsYXlzKTsKKworCXJldHVybiAwOworfQorCitz dGF0aWMgY29uc3Qgc3RydWN0IG9mX2RldmljZV9pZCBiY202MzU4X3BpbmN0cmxfbWF0Y2hbXSA9 IHsKKwl7IC5jb21wYXRpYmxlID0gImJyY20sYmNtNjM1OC1waW5jdHJsIiwgfSwKKwl7IC8qIHNl bnRpbmVsICovIH0KK307CisKK3N0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZHJpdmVyIGJjbTYzNThf cGluY3RybF9kcml2ZXIgPSB7CisJLnByb2JlID0gYmNtNjM1OF9waW5jdHJsX3Byb2JlLAorCS5k cml2ZXIgPSB7CisJCS5uYW1lID0gImJjbTYzNTgtcGluY3RybCIsCisJCS5vZl9tYXRjaF90YWJs ZSA9IGJjbTYzNThfcGluY3RybF9tYXRjaCwKKwl9LAorfTsKKworYnVpbHRpbl9wbGF0Zm9ybV9k cml2ZXIoYmNtNjM1OF9waW5jdHJsX2RyaXZlcik7Ci0tIAoyLjIwLjEKCgpfX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpsaW51eC1hcm0ta2VybmVsIG1haWxp bmcgbGlzdApsaW51eC1hcm0ta2VybmVsQGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3Rz LmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1hcm0ta2VybmVsCg==