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 EE32EC433ED for ; Wed, 24 Mar 2021 08:20:48 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id ACF7F619D5 for ; Wed, 24 Mar 2021 08:20:48 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S236090AbhCXIUQ (ORCPT ); Wed, 24 Mar 2021 04:20:16 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:53984 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233304AbhCXITf (ORCPT ); Wed, 24 Mar 2021 04:19:35 -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 38538C0613DD; Wed, 24 Mar 2021 01:19:34 -0700 (PDT) Received: by mail-wm1-x330.google.com with SMTP id 12so12371323wmf.5; Wed, 24 Mar 2021 01:19:34 -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=1kfluqEmAMnMwbmUQ3tSyH8HDW9gBVB/ZQflES+0Mvw=; b=rd7yXJEQ2QzW7Wn3Toa2MFF9TdJZeM8wWSX4sP+9Fyvc1YiRcIjdJheKc+4w3ihfUH 1vp7uSxY7eWrGyZJQSZozPTi1DzbJA+jOr1ufiZkYf0HRHJ6ALO7irEPc79wkNnBl2fq UBXULdtesg/s6bLwfaRPbT/pdkNNXfhGCy3kVdukuUuqeeSqD7lGTNmHWvBkJNK2ReDU 2ekhznKuue0lTo1S8R2LMNlKGV0WEHsDW0aAunlAdNG1W81k68XjmWgwJc4Kx/M2hdV/ wMgf6u2P+IK56jQHrXwlL0oIACEfO2Pe82KXcjSYhi0RXG0EL4aH8Bt4qk2uOPg5irsF JS0Q== 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=1kfluqEmAMnMwbmUQ3tSyH8HDW9gBVB/ZQflES+0Mvw=; b=M1/DOJdvcUSvg26Va/REVC8aZZu5dZkElzRRjeVDxUepaXzySMucoUK00zevVyw5B7 bJBZInu64KJ8EQ1Vkf3hHibniJHAClCIOEP5gHNOK25W5bR+1HXVm5abu2RWKXVu3Irx eNlCNszOHFGkR+8IpotRTEgxo0xz3YzydbIZnU1djTDhYn53/zxh4Ilk/4XSXdFgC0qN Y+WBEJiWqsjg2YUmsIeUhYa+G9o6mZpq8y09UvDD1yg0hO5l4/BmP1a+9Agq2u0NzGUq msEssUjwrwR9idzLbE9Ct6t+yVna03HpFNE7YcwX5Nhg5I2NArqw1mR3znHRr9y+/QCX sLKQ== X-Gm-Message-State: AOAM5315QLHjhcYTAgqoh0bYw6YT27fYiNHJ3nIDevjeCH+/2YGSRpLh 9X1I45RoJ4Phq7zuTczQW2c= X-Google-Smtp-Source: ABdhPJypHwcKJTgToFbwCIg1BxByQR/egIzbtmCSG3kdnK5aL3YDYOOEKbB9ipcF5bFgoa8WN5jq6w== X-Received: by 2002:a7b:c346:: with SMTP id l6mr1735366wmj.34.1616573972877; Wed, 24 Mar 2021 01:19:32 -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.31 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 24 Mar 2021 01:19:32 -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 07/22] pinctrl: add a pincontrol driver for BCM6328 Date: Wed, 24 Mar 2021 09:19:08 +0100 Message-Id: <20210324081923.20379-8-noltari@gmail.com> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20210324081923.20379-1-noltari@gmail.com> References: <20210324081923.20379-1-noltari@gmail.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-gpio@vger.kernel.org Add a pincontrol driver for BCM6328. BCM6328 supports muxing 32 pins as GPIOs, as LEDs for the integrated LED controller, or various other functions. Its pincontrol mux registers also control other aspects, like switching the second USB port between host and device mode. 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-bcm6328.c | 404 ++++++++++++++++++++++++++ 3 files changed, 413 insertions(+) create mode 100644 drivers/pinctrl/bcm/pinctrl-bcm6328.c diff --git a/drivers/pinctrl/bcm/Kconfig b/drivers/pinctrl/bcm/Kconfig index 882f19bdc243..d35e5d3fe26f 100644 --- a/drivers/pinctrl/bcm/Kconfig +++ b/drivers/pinctrl/bcm/Kconfig @@ -36,6 +36,14 @@ config PINCTRL_BCM63XX select PINCONF select PINMUX +config PINCTRL_BCM6328 + bool "Broadcom BCM6328 GPIO driver" + depends on (BMIPS_GENERIC || COMPILE_TEST) + select PINCTRL_BCM63XX + default BMIPS_GENERIC + help + Say Y here to enable the Broadcom BCM6328 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 0e3cf9b15c65..57e5434a6db6 100644 --- a/drivers/pinctrl/bcm/Makefile +++ b/drivers/pinctrl/bcm/Makefile @@ -4,6 +4,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_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-bcm6328.c b/drivers/pinctrl/bcm/pinctrl-bcm6328.c new file mode 100644 index 000000000000..c9efce600550 --- /dev/null +++ b/drivers/pinctrl/bcm/pinctrl-bcm6328.c @@ -0,0 +1,404 @@ +// SPDX-License-Identifier: GPL-2.0+ +/* + * Driver for BCM6328 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 BCM6328_NUM_GPIOS 32 + +#define BCM6328_MODE_REG 0x18 +#define BCM6328_MUX_HI_REG 0x1c +#define BCM6328_MUX_LO_REG 0x20 +#define BCM6328_MUX_OTHER_REG 0x24 +#define BCM6328_MUX_MASK GENMASK(1, 0) + +struct bcm6328_pingroup { + const char *name; + const unsigned * const pins; + const unsigned num_pins; +}; + +struct bcm6328_function { + const char *name; + const char * const *groups; + const unsigned num_groups; + + unsigned mode_val:1; + unsigned mux_val:2; +}; + +static const unsigned int bcm6328_mux[] = { + BCM6328_MUX_LO_REG, + BCM6328_MUX_HI_REG, + BCM6328_MUX_OTHER_REG +}; + +static const struct pinctrl_pin_desc bcm6328_pins[] = { + PINCTRL_PIN(0, "gpio0"), + PINCTRL_PIN(1, "gpio1"), + PINCTRL_PIN(2, "gpio2"), + PINCTRL_PIN(3, "gpio3"), + PINCTRL_PIN(4, "gpio4"), + PINCTRL_PIN(5, "gpio5"), + PINCTRL_PIN(6, "gpio6"), + PINCTRL_PIN(7, "gpio7"), + PINCTRL_PIN(8, "gpio8"), + PINCTRL_PIN(9, "gpio9"), + PINCTRL_PIN(10, "gpio10"), + PINCTRL_PIN(11, "gpio11"), + PINCTRL_PIN(12, "gpio12"), + PINCTRL_PIN(13, "gpio13"), + PINCTRL_PIN(14, "gpio14"), + PINCTRL_PIN(15, "gpio15"), + PINCTRL_PIN(16, "gpio16"), + PINCTRL_PIN(17, "gpio17"), + PINCTRL_PIN(18, "gpio18"), + PINCTRL_PIN(19, "gpio19"), + PINCTRL_PIN(20, "gpio20"), + PINCTRL_PIN(21, "gpio21"), + PINCTRL_PIN(22, "gpio22"), + PINCTRL_PIN(23, "gpio23"), + PINCTRL_PIN(24, "gpio24"), + PINCTRL_PIN(25, "gpio25"), + PINCTRL_PIN(26, "gpio26"), + PINCTRL_PIN(27, "gpio27"), + PINCTRL_PIN(28, "gpio28"), + PINCTRL_PIN(29, "gpio29"), + PINCTRL_PIN(30, "gpio30"), + PINCTRL_PIN(31, "gpio31"), + + /* + * No idea where they really are; so let's put them according + * to their mux offsets. + */ + PINCTRL_PIN(36, "hsspi_cs1"), + PINCTRL_PIN(38, "usb_p2"), +}; + +static unsigned gpio0_pins[] = { 0 }; +static unsigned gpio1_pins[] = { 1 }; +static unsigned gpio2_pins[] = { 2 }; +static unsigned gpio3_pins[] = { 3 }; +static unsigned gpio4_pins[] = { 4 }; +static unsigned gpio5_pins[] = { 5 }; +static unsigned gpio6_pins[] = { 6 }; +static unsigned gpio7_pins[] = { 7 }; +static unsigned gpio8_pins[] = { 8 }; +static unsigned gpio9_pins[] = { 9 }; +static unsigned gpio10_pins[] = { 10 }; +static unsigned gpio11_pins[] = { 11 }; +static unsigned gpio12_pins[] = { 12 }; +static unsigned gpio13_pins[] = { 13 }; +static unsigned gpio14_pins[] = { 14 }; +static unsigned gpio15_pins[] = { 15 }; +static unsigned gpio16_pins[] = { 16 }; +static unsigned gpio17_pins[] = { 17 }; +static unsigned gpio18_pins[] = { 18 }; +static unsigned gpio19_pins[] = { 19 }; +static unsigned gpio20_pins[] = { 20 }; +static unsigned gpio21_pins[] = { 21 }; +static unsigned gpio22_pins[] = { 22 }; +static unsigned gpio23_pins[] = { 23 }; +static unsigned gpio24_pins[] = { 24 }; +static unsigned gpio25_pins[] = { 25 }; +static unsigned gpio26_pins[] = { 26 }; +static unsigned gpio27_pins[] = { 27 }; +static unsigned gpio28_pins[] = { 28 }; +static unsigned gpio29_pins[] = { 29 }; +static unsigned gpio30_pins[] = { 30 }; +static unsigned gpio31_pins[] = { 31 }; + +static unsigned hsspi_cs1_pins[] = { 36 }; +static unsigned usb_port1_pins[] = { 38 }; + +#define BCM6328_GROUP(n) \ + { \ + .name = #n, \ + .pins = n##_pins, \ + .num_pins = ARRAY_SIZE(n##_pins), \ + } + +static struct bcm6328_pingroup bcm6328_groups[] = { + BCM6328_GROUP(gpio0), + BCM6328_GROUP(gpio1), + BCM6328_GROUP(gpio2), + BCM6328_GROUP(gpio3), + BCM6328_GROUP(gpio4), + BCM6328_GROUP(gpio5), + BCM6328_GROUP(gpio6), + BCM6328_GROUP(gpio7), + BCM6328_GROUP(gpio8), + BCM6328_GROUP(gpio9), + BCM6328_GROUP(gpio10), + BCM6328_GROUP(gpio11), + BCM6328_GROUP(gpio12), + BCM6328_GROUP(gpio13), + BCM6328_GROUP(gpio14), + BCM6328_GROUP(gpio15), + BCM6328_GROUP(gpio16), + BCM6328_GROUP(gpio17), + BCM6328_GROUP(gpio18), + BCM6328_GROUP(gpio19), + BCM6328_GROUP(gpio20), + BCM6328_GROUP(gpio21), + BCM6328_GROUP(gpio22), + BCM6328_GROUP(gpio23), + BCM6328_GROUP(gpio24), + BCM6328_GROUP(gpio25), + BCM6328_GROUP(gpio26), + BCM6328_GROUP(gpio27), + BCM6328_GROUP(gpio28), + BCM6328_GROUP(gpio29), + BCM6328_GROUP(gpio30), + BCM6328_GROUP(gpio31), + + BCM6328_GROUP(hsspi_cs1), + BCM6328_GROUP(usb_port1), +}; + +/* GPIO_MODE */ +static const char * const led_groups[] = { + "gpio0", + "gpio1", + "gpio2", + "gpio3", + "gpio4", + "gpio5", + "gpio6", + "gpio7", + "gpio8", + "gpio9", + "gpio10", + "gpio11", + "gpio12", + "gpio13", + "gpio14", + "gpio15", + "gpio16", + "gpio17", + "gpio18", + "gpio19", + "gpio20", + "gpio21", + "gpio22", + "gpio23", +}; + +/* PINMUX_SEL */ +static const char * const serial_led_data_groups[] = { + "gpio6", +}; + +static const char * const serial_led_clk_groups[] = { + "gpio7", +}; + +static const char * const inet_act_led_groups[] = { + "gpio11", +}; + +static const char * const pcie_clkreq_groups[] = { + "gpio16", +}; + +static const char * const ephy0_act_led_groups[] = { + "gpio25", +}; + +static const char * const ephy1_act_led_groups[] = { + "gpio26", +}; + +static const char * const ephy2_act_led_groups[] = { + "gpio27", +}; + +static const char * const ephy3_act_led_groups[] = { + "gpio28", +}; + +static const char * const hsspi_cs1_groups[] = { + "hsspi_cs1" +}; + +static const char * const usb_host_port_groups[] = { + "usb_port1", +}; + +static const char * const usb_device_port_groups[] = { + "usb_port1", +}; + +#define BCM6328_MODE_FUN(n) \ + { \ + .name = #n, \ + .groups = n##_groups, \ + .num_groups = ARRAY_SIZE(n##_groups), \ + .mode_val = 1, \ + } + +#define BCM6328_MUX_FUN(n, mux) \ + { \ + .name = #n, \ + .groups = n##_groups, \ + .num_groups = ARRAY_SIZE(n##_groups), \ + .mux_val = mux, \ + } + +static const struct bcm6328_function bcm6328_funcs[] = { + BCM6328_MODE_FUN(led), + BCM6328_MUX_FUN(serial_led_data, 2), + BCM6328_MUX_FUN(serial_led_clk, 2), + BCM6328_MUX_FUN(inet_act_led, 1), + BCM6328_MUX_FUN(pcie_clkreq, 2), + BCM6328_MUX_FUN(ephy0_act_led, 1), + BCM6328_MUX_FUN(ephy1_act_led, 1), + BCM6328_MUX_FUN(ephy2_act_led, 1), + BCM6328_MUX_FUN(ephy3_act_led, 1), + BCM6328_MUX_FUN(hsspi_cs1, 2), + BCM6328_MUX_FUN(usb_host_port, 1), + BCM6328_MUX_FUN(usb_device_port, 2), +}; + +static inline unsigned int bcm6328_mux_off(unsigned int pin) +{ + return bcm6328_mux[pin / 16]; +} + +static int bcm6328_pinctrl_get_group_count(struct pinctrl_dev *pctldev) +{ + return ARRAY_SIZE(bcm6328_groups); +} + +static const char *bcm6328_pinctrl_get_group_name(struct pinctrl_dev *pctldev, + unsigned group) +{ + return bcm6328_groups[group].name; +} + +static int bcm6328_pinctrl_get_group_pins(struct pinctrl_dev *pctldev, + unsigned group, const unsigned **pins, + unsigned *num_pins) +{ + *pins = bcm6328_groups[group].pins; + *num_pins = bcm6328_groups[group].num_pins; + + return 0; +} + +static int bcm6328_pinctrl_get_func_count(struct pinctrl_dev *pctldev) +{ + return ARRAY_SIZE(bcm6328_funcs); +} + +static const char *bcm6328_pinctrl_get_func_name(struct pinctrl_dev *pctldev, + unsigned selector) +{ + return bcm6328_funcs[selector].name; +} + +static int bcm6328_pinctrl_get_groups(struct pinctrl_dev *pctldev, + unsigned selector, + const char * const **groups, + unsigned * const num_groups) +{ + *groups = bcm6328_funcs[selector].groups; + *num_groups = bcm6328_funcs[selector].num_groups; + + return 0; +} + +static void bcm6328_rmw_mux(struct bcm63xx_pinctrl *pc, unsigned pin, + unsigned int mode, unsigned int mux) +{ + if (pin < BCM6328_NUM_GPIOS) + regmap_update_bits(pc->regs, BCM6328_MODE_REG, BIT(pin), + mode ? BIT(pin) : 0); + + regmap_update_bits(pc->regs, bcm6328_mux_off(pin), + BCM6328_MUX_MASK << ((pin % 16) * 2), + mux << ((pin % 16) * 2)); +} + +static int bcm6328_pinctrl_set_mux(struct pinctrl_dev *pctldev, + unsigned selector, unsigned group) +{ + struct bcm63xx_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev); + const struct bcm6328_pingroup *pg = &bcm6328_groups[group]; + const struct bcm6328_function *f = &bcm6328_funcs[selector]; + + bcm6328_rmw_mux(pc, pg->pins[0], f->mode_val, f->mux_val); + + return 0; +} + +static int bcm6328_gpio_request_enable(struct pinctrl_dev *pctldev, + struct pinctrl_gpio_range *range, + unsigned offset) +{ + struct bcm63xx_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev); + + /* disable all functions using this pin */ + bcm6328_rmw_mux(pc, offset, 0, 0); + + return 0; +} + +static struct pinctrl_ops bcm6328_pctl_ops = { + .dt_free_map = pinctrl_utils_free_map, + .dt_node_to_map = pinconf_generic_dt_node_to_map_pin, + .get_group_name = bcm6328_pinctrl_get_group_name, + .get_group_pins = bcm6328_pinctrl_get_group_pins, + .get_groups_count = bcm6328_pinctrl_get_group_count, +}; + +static struct pinmux_ops bcm6328_pmx_ops = { + .get_function_groups = bcm6328_pinctrl_get_groups, + .get_function_name = bcm6328_pinctrl_get_func_name, + .get_functions_count = bcm6328_pinctrl_get_func_count, + .gpio_request_enable = bcm6328_gpio_request_enable, + .set_mux = bcm6328_pinctrl_set_mux, + .strict = true, +}; + +static const struct bcm63xx_pinctrl_soc bcm6328_soc = { + .ngpios = BCM6328_NUM_GPIOS, + .npins = ARRAY_SIZE(bcm6328_pins), + .pctl_ops = &bcm6328_pctl_ops, + .pins = bcm6328_pins, + .pmx_ops = &bcm6328_pmx_ops, +}; + +static int bcm6328_pinctrl_probe(struct platform_device *pdev) +{ + return bcm63xx_pinctrl_probe(pdev, &bcm6328_soc, NULL); +} + +static const struct of_device_id bcm6328_pinctrl_match[] = { + { .compatible = "brcm,bcm6328-pinctrl", }, + { /* sentinel */ } +}; + +static struct platform_driver bcm6328_pinctrl_driver = { + .probe = bcm6328_pinctrl_probe, + .driver = { + .name = "bcm6328-pinctrl", + .of_match_table = bcm6328_pinctrl_match, + }, +}; + +builtin_platform_driver(bcm6328_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 A285FC433C1 for ; Wed, 24 Mar 2021 08:23:38 +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 E1C55619AE for ; Wed, 24 Mar 2021 08:23:37 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org E1C55619AE 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=rka1XTYDgSMOVRlsrhH5TPvMo/EEml8tw9aFBg5uDqg=; b=jmnMLKIR+f+Ppu8zWgxKUb7Vv V3IkjaUoDVUNjR/oxUEX0uCqkK4yh2VtlT50htHcfMuJpsYvXF+CwKEoY7KQG+UVmNvY0Q7tNqqjF URCYV3bzmyXAsc6mljrK00hQdf1shzJBGvVXuYxtnBGmE7ueh/NKQezKi3K9ygrKabtkM4ik4T5Dw LDKdUr7MDBIrPbr6AQenxZaLdNWEnXCDENl5DR0avK4Np0A1LGnWSMMlxDedCL+klCOwMqhlAd6Cx rtohsCZs8Gv1/Xf7I2h9JvOWAO9jh2iomkyfUsaZt6p9TqtjddZMDkiQgUQIE72YafYDO1Z+J+Nd9 y5+zjiMwg==; Received: from localhost ([::1] helo=desiato.infradead.org) by desiato.infradead.org with esmtp (Exim 4.94 #2 (Red Hat Linux)) id 1lOykr-00GZ86-0K; Wed, 24 Mar 2021 08:20:41 +0000 Received: from mail-wm1-x330.google.com ([2a00:1450:4864:20::330]) by desiato.infradead.org with esmtps (Exim 4.94 #2 (Red Hat Linux)) id 1lOyjl-00GYqI-Gi for linux-arm-kernel@lists.infradead.org; Wed, 24 Mar 2021 08:19:36 +0000 Received: by mail-wm1-x330.google.com with SMTP id u5-20020a7bcb050000b029010e9316b9d5so658274wmj.2 for ; Wed, 24 Mar 2021 01:19:33 -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=1kfluqEmAMnMwbmUQ3tSyH8HDW9gBVB/ZQflES+0Mvw=; b=rd7yXJEQ2QzW7Wn3Toa2MFF9TdJZeM8wWSX4sP+9Fyvc1YiRcIjdJheKc+4w3ihfUH 1vp7uSxY7eWrGyZJQSZozPTi1DzbJA+jOr1ufiZkYf0HRHJ6ALO7irEPc79wkNnBl2fq UBXULdtesg/s6bLwfaRPbT/pdkNNXfhGCy3kVdukuUuqeeSqD7lGTNmHWvBkJNK2ReDU 2ekhznKuue0lTo1S8R2LMNlKGV0WEHsDW0aAunlAdNG1W81k68XjmWgwJc4Kx/M2hdV/ wMgf6u2P+IK56jQHrXwlL0oIACEfO2Pe82KXcjSYhi0RXG0EL4aH8Bt4qk2uOPg5irsF JS0Q== 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=1kfluqEmAMnMwbmUQ3tSyH8HDW9gBVB/ZQflES+0Mvw=; b=Vii9es+O6aJZ+g4XNisONO3sSZDoiUx8qjkxfpTIrssHxQuk0T4M5TyqBwdPYVYCt6 NXgxm3C47eJECBd10WV+UsNFADx9JycF/lnOt1MnNG2OXgC1UuB6Oi81kQUqtU98lnGH NkF5wNtUX+Go96sjp91doKpNUVzMBJRB1P2WRctSQwMe9P9hQPSmpjc3px19XWNcZBE2 TQtgmk3UeC0JJa2le+vugjDD9sFkjQMT2Lo/85X8K4ltDGzMugP7Jrz9It94Jedj2aMZ NLpLHPjGVLGxIN75UWYP/GVnr/5YgTHsl7R1RiFHlhBV1hMT25JTWemCKm0Zmkb+JgU2 3W6Q== X-Gm-Message-State: AOAM532A7cH97WAzIY+AjxJXuZlhQLfVbbcT8yFZWWe8ac6Tq8/gxLu7 jaO4Ljx2KR5wa4VU8HVzaTY= X-Google-Smtp-Source: ABdhPJypHwcKJTgToFbwCIg1BxByQR/egIzbtmCSG3kdnK5aL3YDYOOEKbB9ipcF5bFgoa8WN5jq6w== X-Received: by 2002:a7b:c346:: with SMTP id l6mr1735366wmj.34.1616573972877; Wed, 24 Mar 2021 01:19:32 -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.31 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 24 Mar 2021 01:19:32 -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 07/22] pinctrl: add a pincontrol driver for BCM6328 Date: Wed, 24 Mar 2021 09:19:08 +0100 Message-Id: <20210324081923.20379-8-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_081934_291465_485C538F X-CRM114-Status: GOOD ( 22.31 ) 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 QWRkIGEgcGluY29udHJvbCBkcml2ZXIgZm9yIEJDTTYzMjguIEJDTTYzMjggc3VwcG9ydHMgbXV4 aW5nIDMyIHBpbnMgYXMKR1BJT3MsIGFzIExFRHMgZm9yIHRoZSBpbnRlZ3JhdGVkIExFRCBjb250 cm9sbGVyLCBvciB2YXJpb3VzIG90aGVyCmZ1bmN0aW9ucy4gSXRzIHBpbmNvbnRyb2wgbXV4IHJl Z2lzdGVycyBhbHNvIGNvbnRyb2wgb3RoZXIgYXNwZWN0cywgbGlrZQpzd2l0Y2hpbmcgdGhlIHNl Y29uZCBVU0IgcG9ydCBiZXR3ZWVuIGhvc3QgYW5kIGRldmljZSBtb2RlLgoKQ28tZGV2ZWxvcGVk LWJ5OiBKb25hcyBHb3Jza2kgPGpvbmFzLmdvcnNraUBnbWFpbC5jb20+ClNpZ25lZC1vZmYtYnk6 IEpvbmFzIEdvcnNraSA8am9uYXMuZ29yc2tpQGdtYWlsLmNvbT4KU2lnbmVkLW9mZi1ieTogw4Fs dmFybyBGZXJuw6FuZGV6IFJvamFzIDxub2x0YXJpQGdtYWlsLmNvbT4KLS0tCiB2OTogbm8gY2hh bmdlcwogdjg6IG5vIGNoYW5nZXMKIHY3OiBubyBjaGFuZ2VzCiB2Njogbm8gY2hhbmdlcwogdjU6 IGFkZCBjaGFuZ2VzIHN1Z2dlc3RlZCBieSBBbmR5IFNoZXZjaGVua28KIHY0OiBubyBjaGFuZ2Vz CiB2MzogdXNlIG5ldyBzaGFyZWQgY29kZQogdjI6IHN3aXRjaCB0byBHUElPX1JFR01BUAoKIGRy aXZlcnMvcGluY3RybC9iY20vS2NvbmZpZyAgICAgICAgICAgfCAgIDggKwogZHJpdmVycy9waW5j dHJsL2JjbS9NYWtlZmlsZSAgICAgICAgICB8ICAgMSArCiBkcml2ZXJzL3BpbmN0cmwvYmNtL3Bp bmN0cmwtYmNtNjMyOC5jIHwgNDA0ICsrKysrKysrKysrKysrKysrKysrKysrKysrCiAzIGZpbGVz IGNoYW5nZWQsIDQxMyBpbnNlcnRpb25zKCspCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9w aW5jdHJsL2JjbS9waW5jdHJsLWJjbTYzMjguYwoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGluY3Ry bC9iY20vS2NvbmZpZyBiL2RyaXZlcnMvcGluY3RybC9iY20vS2NvbmZpZwppbmRleCA4ODJmMTli ZGMyNDMuLmQzNWU1ZDNmZTI2ZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9waW5jdHJsL2JjbS9LY29u ZmlnCisrKyBiL2RyaXZlcnMvcGluY3RybC9iY20vS2NvbmZpZwpAQCAtMzYsNiArMzYsMTQgQEAg Y29uZmlnIFBJTkNUUkxfQkNNNjNYWAogCXNlbGVjdCBQSU5DT05GCiAJc2VsZWN0IFBJTk1VWAog Citjb25maWcgUElOQ1RSTF9CQ002MzI4CisJYm9vbCAiQnJvYWRjb20gQkNNNjMyOCBHUElPIGRy aXZlciIKKwlkZXBlbmRzIG9uIChCTUlQU19HRU5FUklDIHx8IENPTVBJTEVfVEVTVCkKKwlzZWxl Y3QgUElOQ1RSTF9CQ002M1hYCisJZGVmYXVsdCBCTUlQU19HRU5FUklDCisJaGVscAorCSAgIFNh eSBZIGhlcmUgdG8gZW5hYmxlIHRoZSBCcm9hZGNvbSBCQ002MzI4IEdQSU8gZHJpdmVyLgorCiBj b25maWcgUElOQ1RSTF9JUFJPQ19HUElPCiAJYm9vbCAiQnJvYWRjb20gaVByb2MgR1BJTyAod2l0 aCBQSU5DT05GKSBkcml2ZXIiCiAJZGVwZW5kcyBvbiBPRl9HUElPICYmIChBUkNIX0JDTV9JUFJP QyB8fCBDT01QSUxFX1RFU1QpCmRpZmYgLS1naXQgYS9kcml2ZXJzL3BpbmN0cmwvYmNtL01ha2Vm aWxlIGIvZHJpdmVycy9waW5jdHJsL2JjbS9NYWtlZmlsZQppbmRleCAwZTNjZjliMTVjNjUuLjU3 ZTU0MzRhNmRiNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9waW5jdHJsL2JjbS9NYWtlZmlsZQorKysg Yi9kcml2ZXJzL3BpbmN0cmwvYmNtL01ha2VmaWxlCkBAIC00LDYgKzQsNyBAQAogb2JqLSQoQ09O RklHX1BJTkNUUkxfQkNNMjgxWFgpCQkrPSBwaW5jdHJsLWJjbTI4MXh4Lm8KIG9iai0kKENPTkZJ R19QSU5DVFJMX0JDTTI4MzUpCQkrPSBwaW5jdHJsLWJjbTI4MzUubwogb2JqLSQoQ09ORklHX1BJ TkNUUkxfQkNNNjNYWCkJCSs9IHBpbmN0cmwtYmNtNjN4eC5vCitvYmotJChDT05GSUdfUElOQ1RS TF9CQ002MzI4KQkJKz0gcGluY3RybC1iY202MzI4Lm8KIG9iai0kKENPTkZJR19QSU5DVFJMX0lQ Uk9DX0dQSU8pCSs9IHBpbmN0cmwtaXByb2MtZ3Bpby5vCiBvYmotJChDT05GSUdfUElOQ1RSTF9D WUdOVVNfTVVYKQkrPSBwaW5jdHJsLWN5Z251cy1tdXgubwogb2JqLSQoQ09ORklHX1BJTkNUUkxf TlMpCQkrPSBwaW5jdHJsLW5zLm8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGluY3RybC9iY20vcGlu Y3RybC1iY202MzI4LmMgYi9kcml2ZXJzL3BpbmN0cmwvYmNtL3BpbmN0cmwtYmNtNjMyOC5jCm5l dyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uYzllZmNlNjAwNTUwCi0tLSAv ZGV2L251bGwKKysrIGIvZHJpdmVycy9waW5jdHJsL2JjbS9waW5jdHJsLWJjbTYzMjguYwpAQCAt MCwwICsxLDQwNCBAQAorLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjArCisvKgor ICogRHJpdmVyIGZvciBCQ002MzI4IEdQSU8gdW5pdCAocGluY3RybCArIEdQSU8pCisgKgorICog Q29weXJpZ2h0IChDKSAyMDIxIMOBbHZhcm8gRmVybsOhbmRleiBSb2phcyA8bm9sdGFyaUBnbWFp bC5jb20+CisgKiBDb3B5cmlnaHQgKEMpIDIwMTYgSm9uYXMgR29yc2tpIDxqb25hcy5nb3Jza2lA Z21haWwuY29tPgorICovCisKKyNpbmNsdWRlIDxsaW51eC9iaXRzLmg+CisjaW5jbHVkZSA8bGlu dXgvZ3Bpby9kcml2ZXIuaD4KKyNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KKyNpbmNsdWRlIDxs aW51eC9vZi5oPgorI2luY2x1ZGUgPGxpbnV4L3BpbmN0cmwvcGlubXV4Lmg+CisjaW5jbHVkZSA8 bGludXgvcGxhdGZvcm1fZGV2aWNlLmg+CisjaW5jbHVkZSA8bGludXgvcmVnbWFwLmg+CisKKyNp bmNsdWRlICIuLi9waW5jdHJsLXV0aWxzLmgiCisKKyNpbmNsdWRlICJwaW5jdHJsLWJjbTYzeHgu aCIKKworI2RlZmluZSBCQ002MzI4X05VTV9HUElPUwkzMgorCisjZGVmaW5lIEJDTTYzMjhfTU9E RV9SRUcJMHgxOAorI2RlZmluZSBCQ002MzI4X01VWF9ISV9SRUcJMHgxYworI2RlZmluZSBCQ002 MzI4X01VWF9MT19SRUcJMHgyMAorI2RlZmluZSBCQ002MzI4X01VWF9PVEhFUl9SRUcJMHgyNAor I2RlZmluZSAgQkNNNjMyOF9NVVhfTUFTSwlHRU5NQVNLKDEsIDApCisKK3N0cnVjdCBiY202MzI4 X3Bpbmdyb3VwIHsKKwljb25zdCBjaGFyICpuYW1lOworCWNvbnN0IHVuc2lnbmVkICogY29uc3Qg cGluczsKKwljb25zdCB1bnNpZ25lZCBudW1fcGluczsKK307CisKK3N0cnVjdCBiY202MzI4X2Z1 bmN0aW9uIHsKKwljb25zdCBjaGFyICpuYW1lOworCWNvbnN0IGNoYXIgKiBjb25zdCAqZ3JvdXBz OworCWNvbnN0IHVuc2lnbmVkIG51bV9ncm91cHM7CisKKwl1bnNpZ25lZCBtb2RlX3ZhbDoxOwor CXVuc2lnbmVkIG11eF92YWw6MjsKK307CisKK3N0YXRpYyBjb25zdCB1bnNpZ25lZCBpbnQgYmNt NjMyOF9tdXhbXSA9IHsKKwlCQ002MzI4X01VWF9MT19SRUcsCisJQkNNNjMyOF9NVVhfSElfUkVH LAorCUJDTTYzMjhfTVVYX09USEVSX1JFRworfTsKKworc3RhdGljIGNvbnN0IHN0cnVjdCBwaW5j dHJsX3Bpbl9kZXNjIGJjbTYzMjhfcGluc1tdID0geworCVBJTkNUUkxfUElOKDAsICJncGlvMCIp LAorCVBJTkNUUkxfUElOKDEsICJncGlvMSIpLAorCVBJTkNUUkxfUElOKDIsICJncGlvMiIpLAor CVBJTkNUUkxfUElOKDMsICJncGlvMyIpLAorCVBJTkNUUkxfUElOKDQsICJncGlvNCIpLAorCVBJ TkNUUkxfUElOKDUsICJncGlvNSIpLAorCVBJTkNUUkxfUElOKDYsICJncGlvNiIpLAorCVBJTkNU UkxfUElOKDcsICJncGlvNyIpLAorCVBJTkNUUkxfUElOKDgsICJncGlvOCIpLAorCVBJTkNUUkxf UElOKDksICJncGlvOSIpLAorCVBJTkNUUkxfUElOKDEwLCAiZ3BpbzEwIiksCisJUElOQ1RSTF9Q SU4oMTEsICJncGlvMTEiKSwKKwlQSU5DVFJMX1BJTigxMiwgImdwaW8xMiIpLAorCVBJTkNUUkxf UElOKDEzLCAiZ3BpbzEzIiksCisJUElOQ1RSTF9QSU4oMTQsICJncGlvMTQiKSwKKwlQSU5DVFJM X1BJTigxNSwgImdwaW8xNSIpLAorCVBJTkNUUkxfUElOKDE2LCAiZ3BpbzE2IiksCisJUElOQ1RS TF9QSU4oMTcsICJncGlvMTciKSwKKwlQSU5DVFJMX1BJTigxOCwgImdwaW8xOCIpLAorCVBJTkNU UkxfUElOKDE5LCAiZ3BpbzE5IiksCisJUElOQ1RSTF9QSU4oMjAsICJncGlvMjAiKSwKKwlQSU5D VFJMX1BJTigyMSwgImdwaW8yMSIpLAorCVBJTkNUUkxfUElOKDIyLCAiZ3BpbzIyIiksCisJUElO Q1RSTF9QSU4oMjMsICJncGlvMjMiKSwKKwlQSU5DVFJMX1BJTigyNCwgImdwaW8yNCIpLAorCVBJ TkNUUkxfUElOKDI1LCAiZ3BpbzI1IiksCisJUElOQ1RSTF9QSU4oMjYsICJncGlvMjYiKSwKKwlQ SU5DVFJMX1BJTigyNywgImdwaW8yNyIpLAorCVBJTkNUUkxfUElOKDI4LCAiZ3BpbzI4IiksCisJ UElOQ1RSTF9QSU4oMjksICJncGlvMjkiKSwKKwlQSU5DVFJMX1BJTigzMCwgImdwaW8zMCIpLAor CVBJTkNUUkxfUElOKDMxLCAiZ3BpbzMxIiksCisKKwkvKgorCSAqIE5vIGlkZWEgd2hlcmUgdGhl eSByZWFsbHkgYXJlOyBzbyBsZXQncyBwdXQgdGhlbSBhY2NvcmRpbmcKKwkgKiB0byB0aGVpciBt dXggb2Zmc2V0cy4KKwkgKi8KKwlQSU5DVFJMX1BJTigzNiwgImhzc3BpX2NzMSIpLAorCVBJTkNU UkxfUElOKDM4LCAidXNiX3AyIiksCit9OworCitzdGF0aWMgdW5zaWduZWQgZ3BpbzBfcGluc1td ID0geyAwIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzFfcGluc1tdID0geyAxIH07CitzdGF0aWMg dW5zaWduZWQgZ3BpbzJfcGluc1tdID0geyAyIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzNfcGlu c1tdID0geyAzIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzRfcGluc1tdID0geyA0IH07CitzdGF0 aWMgdW5zaWduZWQgZ3BpbzVfcGluc1tdID0geyA1IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzZf cGluc1tdID0geyA2IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzdfcGluc1tdID0geyA3IH07Citz dGF0aWMgdW5zaWduZWQgZ3BpbzhfcGluc1tdID0geyA4IH07CitzdGF0aWMgdW5zaWduZWQgZ3Bp bzlfcGluc1tdID0geyA5IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzEwX3BpbnNbXSA9IHsgMTAg fTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMTFfcGluc1tdID0geyAxMSB9Oworc3RhdGljIHVuc2ln bmVkIGdwaW8xMl9waW5zW10gPSB7IDEyIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzEzX3BpbnNb XSA9IHsgMTMgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMTRfcGluc1tdID0geyAxNCB9Oworc3Rh dGljIHVuc2lnbmVkIGdwaW8xNV9waW5zW10gPSB7IDE1IH07CitzdGF0aWMgdW5zaWduZWQgZ3Bp bzE2X3BpbnNbXSA9IHsgMTYgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMTdfcGluc1tdID0geyAx NyB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8xOF9waW5zW10gPSB7IDE4IH07CitzdGF0aWMgdW5z aWduZWQgZ3BpbzE5X3BpbnNbXSA9IHsgMTkgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMjBfcGlu c1tdID0geyAyMCB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8yMV9waW5zW10gPSB7IDIxIH07Citz dGF0aWMgdW5zaWduZWQgZ3BpbzIyX3BpbnNbXSA9IHsgMjIgfTsKK3N0YXRpYyB1bnNpZ25lZCBn cGlvMjNfcGluc1tdID0geyAyMyB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8yNF9waW5zW10gPSB7 IDI0IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzI1X3BpbnNbXSA9IHsgMjUgfTsKK3N0YXRpYyB1 bnNpZ25lZCBncGlvMjZfcGluc1tdID0geyAyNiB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8yN19w aW5zW10gPSB7IDI3IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzI4X3BpbnNbXSA9IHsgMjggfTsK K3N0YXRpYyB1bnNpZ25lZCBncGlvMjlfcGluc1tdID0geyAyOSB9Oworc3RhdGljIHVuc2lnbmVk IGdwaW8zMF9waW5zW10gPSB7IDMwIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzMxX3BpbnNbXSA9 IHsgMzEgfTsKKworc3RhdGljIHVuc2lnbmVkIGhzc3BpX2NzMV9waW5zW10gPSB7IDM2IH07Citz dGF0aWMgdW5zaWduZWQgdXNiX3BvcnQxX3BpbnNbXSA9IHsgMzggfTsKKworI2RlZmluZSBCQ002 MzI4X0dST1VQKG4pCQkJCQlcCisJewkJCQkJCQlcCisJCS5uYW1lID0gI24sCQkJCQlcCisJCS5w aW5zID0gbiMjX3BpbnMsCQkJCVwKKwkJLm51bV9waW5zID0gQVJSQVlfU0laRShuIyNfcGlucyks CQlcCisJfQorCitzdGF0aWMgc3RydWN0IGJjbTYzMjhfcGluZ3JvdXAgYmNtNjMyOF9ncm91cHNb XSA9IHsKKwlCQ002MzI4X0dST1VQKGdwaW8wKSwKKwlCQ002MzI4X0dST1VQKGdwaW8xKSwKKwlC Q002MzI4X0dST1VQKGdwaW8yKSwKKwlCQ002MzI4X0dST1VQKGdwaW8zKSwKKwlCQ002MzI4X0dS T1VQKGdwaW80KSwKKwlCQ002MzI4X0dST1VQKGdwaW81KSwKKwlCQ002MzI4X0dST1VQKGdwaW82 KSwKKwlCQ002MzI4X0dST1VQKGdwaW83KSwKKwlCQ002MzI4X0dST1VQKGdwaW84KSwKKwlCQ002 MzI4X0dST1VQKGdwaW85KSwKKwlCQ002MzI4X0dST1VQKGdwaW8xMCksCisJQkNNNjMyOF9HUk9V UChncGlvMTEpLAorCUJDTTYzMjhfR1JPVVAoZ3BpbzEyKSwKKwlCQ002MzI4X0dST1VQKGdwaW8x MyksCisJQkNNNjMyOF9HUk9VUChncGlvMTQpLAorCUJDTTYzMjhfR1JPVVAoZ3BpbzE1KSwKKwlC Q002MzI4X0dST1VQKGdwaW8xNiksCisJQkNNNjMyOF9HUk9VUChncGlvMTcpLAorCUJDTTYzMjhf R1JPVVAoZ3BpbzE4KSwKKwlCQ002MzI4X0dST1VQKGdwaW8xOSksCisJQkNNNjMyOF9HUk9VUChn cGlvMjApLAorCUJDTTYzMjhfR1JPVVAoZ3BpbzIxKSwKKwlCQ002MzI4X0dST1VQKGdwaW8yMiks CisJQkNNNjMyOF9HUk9VUChncGlvMjMpLAorCUJDTTYzMjhfR1JPVVAoZ3BpbzI0KSwKKwlCQ002 MzI4X0dST1VQKGdwaW8yNSksCisJQkNNNjMyOF9HUk9VUChncGlvMjYpLAorCUJDTTYzMjhfR1JP VVAoZ3BpbzI3KSwKKwlCQ002MzI4X0dST1VQKGdwaW8yOCksCisJQkNNNjMyOF9HUk9VUChncGlv MjkpLAorCUJDTTYzMjhfR1JPVVAoZ3BpbzMwKSwKKwlCQ002MzI4X0dST1VQKGdwaW8zMSksCisK KwlCQ002MzI4X0dST1VQKGhzc3BpX2NzMSksCisJQkNNNjMyOF9HUk9VUCh1c2JfcG9ydDEpLAor fTsKKworLyogR1BJT19NT0RFICovCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGxlZF9ncm91 cHNbXSA9IHsKKwkiZ3BpbzAiLAorCSJncGlvMSIsCisJImdwaW8yIiwKKwkiZ3BpbzMiLAorCSJn cGlvNCIsCisJImdwaW81IiwKKwkiZ3BpbzYiLAorCSJncGlvNyIsCisJImdwaW84IiwKKwkiZ3Bp bzkiLAorCSJncGlvMTAiLAorCSJncGlvMTEiLAorCSJncGlvMTIiLAorCSJncGlvMTMiLAorCSJn cGlvMTQiLAorCSJncGlvMTUiLAorCSJncGlvMTYiLAorCSJncGlvMTciLAorCSJncGlvMTgiLAor CSJncGlvMTkiLAorCSJncGlvMjAiLAorCSJncGlvMjEiLAorCSJncGlvMjIiLAorCSJncGlvMjMi LAorfTsKKworLyogUElOTVVYX1NFTCAqLworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBzZXJp YWxfbGVkX2RhdGFfZ3JvdXBzW10gPSB7CisJImdwaW82IiwKK307CisKK3N0YXRpYyBjb25zdCBj aGFyICogY29uc3Qgc2VyaWFsX2xlZF9jbGtfZ3JvdXBzW10gPSB7CisJImdwaW83IiwKK307CisK K3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgaW5ldF9hY3RfbGVkX2dyb3Vwc1tdID0geworCSJn cGlvMTEiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBwY2llX2Nsa3JlcV9ncm91 cHNbXSA9IHsKKwkiZ3BpbzE2IiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgZXBo eTBfYWN0X2xlZF9ncm91cHNbXSA9IHsKKwkiZ3BpbzI1IiwKK307CisKK3N0YXRpYyBjb25zdCBj aGFyICogY29uc3QgZXBoeTFfYWN0X2xlZF9ncm91cHNbXSA9IHsKKwkiZ3BpbzI2IiwKK307CisK K3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgZXBoeTJfYWN0X2xlZF9ncm91cHNbXSA9IHsKKwki Z3BpbzI3IiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgZXBoeTNfYWN0X2xlZF9n cm91cHNbXSA9IHsKKwkiZ3BpbzI4IiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3Qg aHNzcGlfY3MxX2dyb3Vwc1tdID0geworCSJoc3NwaV9jczEiCit9OworCitzdGF0aWMgY29uc3Qg Y2hhciAqIGNvbnN0IHVzYl9ob3N0X3BvcnRfZ3JvdXBzW10gPSB7CisJInVzYl9wb3J0MSIsCit9 OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHVzYl9kZXZpY2VfcG9ydF9ncm91cHNbXSA9 IHsKKwkidXNiX3BvcnQxIiwKK307CisKKyNkZWZpbmUgQkNNNjMyOF9NT0RFX0ZVTihuKQkJCQlc CisJewkJCQkJCVwKKwkJLm5hbWUgPSAjbiwJCQkJXAorCQkuZ3JvdXBzID0gbiMjX2dyb3VwcywJ CQlcCisJCS5udW1fZ3JvdXBzID0gQVJSQVlfU0laRShuIyNfZ3JvdXBzKSwJXAorCQkubW9kZV92 YWwgPSAxLAkJCQlcCisJfQorCisjZGVmaW5lIEJDTTYzMjhfTVVYX0ZVTihuLCBtdXgpCQkJCVwK Kwl7CQkJCQkJXAorCQkubmFtZSA9ICNuLAkJCQlcCisJCS5ncm91cHMgPSBuIyNfZ3JvdXBzLAkJ CVwKKwkJLm51bV9ncm91cHMgPSBBUlJBWV9TSVpFKG4jI19ncm91cHMpLAlcCisJCS5tdXhfdmFs ID0gbXV4LAkJCQlcCisJfQorCitzdGF0aWMgY29uc3Qgc3RydWN0IGJjbTYzMjhfZnVuY3Rpb24g YmNtNjMyOF9mdW5jc1tdID0geworCUJDTTYzMjhfTU9ERV9GVU4obGVkKSwKKwlCQ002MzI4X01V WF9GVU4oc2VyaWFsX2xlZF9kYXRhLCAyKSwKKwlCQ002MzI4X01VWF9GVU4oc2VyaWFsX2xlZF9j bGssIDIpLAorCUJDTTYzMjhfTVVYX0ZVTihpbmV0X2FjdF9sZWQsIDEpLAorCUJDTTYzMjhfTVVY X0ZVTihwY2llX2Nsa3JlcSwgMiksCisJQkNNNjMyOF9NVVhfRlVOKGVwaHkwX2FjdF9sZWQsIDEp LAorCUJDTTYzMjhfTVVYX0ZVTihlcGh5MV9hY3RfbGVkLCAxKSwKKwlCQ002MzI4X01VWF9GVU4o ZXBoeTJfYWN0X2xlZCwgMSksCisJQkNNNjMyOF9NVVhfRlVOKGVwaHkzX2FjdF9sZWQsIDEpLAor CUJDTTYzMjhfTVVYX0ZVTihoc3NwaV9jczEsIDIpLAorCUJDTTYzMjhfTVVYX0ZVTih1c2JfaG9z dF9wb3J0LCAxKSwKKwlCQ002MzI4X01VWF9GVU4odXNiX2RldmljZV9wb3J0LCAyKSwKK307CisK K3N0YXRpYyBpbmxpbmUgdW5zaWduZWQgaW50IGJjbTYzMjhfbXV4X29mZih1bnNpZ25lZCBpbnQg cGluKQoreworCXJldHVybiBiY202MzI4X211eFtwaW4gLyAxNl07Cit9CisKK3N0YXRpYyBpbnQg YmNtNjMyOF9waW5jdHJsX2dldF9ncm91cF9jb3VudChzdHJ1Y3QgcGluY3RybF9kZXYgKnBjdGxk ZXYpCit7CisJcmV0dXJuIEFSUkFZX1NJWkUoYmNtNjMyOF9ncm91cHMpOworfQorCitzdGF0aWMg Y29uc3QgY2hhciAqYmNtNjMyOF9waW5jdHJsX2dldF9ncm91cF9uYW1lKHN0cnVjdCBwaW5jdHJs X2RldiAqcGN0bGRldiwKKwkJCQkJCSAgdW5zaWduZWQgZ3JvdXApCit7CisJcmV0dXJuIGJjbTYz MjhfZ3JvdXBzW2dyb3VwXS5uYW1lOworfQorCitzdGF0aWMgaW50IGJjbTYzMjhfcGluY3RybF9n ZXRfZ3JvdXBfcGlucyhzdHJ1Y3QgcGluY3RybF9kZXYgKnBjdGxkZXYsCisJCQkJCSAgdW5zaWdu ZWQgZ3JvdXAsIGNvbnN0IHVuc2lnbmVkICoqcGlucywKKwkJCQkJICB1bnNpZ25lZCAqbnVtX3Bp bnMpCit7CisJKnBpbnMgPSBiY202MzI4X2dyb3Vwc1tncm91cF0ucGluczsKKwkqbnVtX3BpbnMg PSBiY202MzI4X2dyb3Vwc1tncm91cF0ubnVtX3BpbnM7CisKKwlyZXR1cm4gMDsKK30KKworc3Rh dGljIGludCBiY202MzI4X3BpbmN0cmxfZ2V0X2Z1bmNfY291bnQoc3RydWN0IHBpbmN0cmxfZGV2 ICpwY3RsZGV2KQoreworCXJldHVybiBBUlJBWV9TSVpFKGJjbTYzMjhfZnVuY3MpOworfQorCitz dGF0aWMgY29uc3QgY2hhciAqYmNtNjMyOF9waW5jdHJsX2dldF9mdW5jX25hbWUoc3RydWN0IHBp bmN0cmxfZGV2ICpwY3RsZGV2LAorCQkJCQkJIHVuc2lnbmVkIHNlbGVjdG9yKQoreworCXJldHVy biBiY202MzI4X2Z1bmNzW3NlbGVjdG9yXS5uYW1lOworfQorCitzdGF0aWMgaW50IGJjbTYzMjhf cGluY3RybF9nZXRfZ3JvdXBzKHN0cnVjdCBwaW5jdHJsX2RldiAqcGN0bGRldiwKKwkJCQkgICAg ICB1bnNpZ25lZCBzZWxlY3RvciwKKwkJCQkgICAgICBjb25zdCBjaGFyICogY29uc3QgKipncm91 cHMsCisJCQkJICAgICAgdW5zaWduZWQgKiBjb25zdCBudW1fZ3JvdXBzKQoreworCSpncm91cHMg PSBiY202MzI4X2Z1bmNzW3NlbGVjdG9yXS5ncm91cHM7CisJKm51bV9ncm91cHMgPSBiY202MzI4 X2Z1bmNzW3NlbGVjdG9yXS5udW1fZ3JvdXBzOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyB2 b2lkIGJjbTYzMjhfcm13X211eChzdHJ1Y3QgYmNtNjN4eF9waW5jdHJsICpwYywgdW5zaWduZWQg cGluLAorCQkJICAgIHVuc2lnbmVkIGludCBtb2RlLCB1bnNpZ25lZCBpbnQgbXV4KQoreworCWlm IChwaW4gPCBCQ002MzI4X05VTV9HUElPUykKKwkJcmVnbWFwX3VwZGF0ZV9iaXRzKHBjLT5yZWdz LCBCQ002MzI4X01PREVfUkVHLCBCSVQocGluKSwKKwkJCQkgICBtb2RlID8gQklUKHBpbikgOiAw KTsKKworCXJlZ21hcF91cGRhdGVfYml0cyhwYy0+cmVncywgYmNtNjMyOF9tdXhfb2ZmKHBpbiks CisJCQkgICBCQ002MzI4X01VWF9NQVNLIDw8ICgocGluICUgMTYpICogMiksCisJCQkgICBtdXgg PDwgKChwaW4gJSAxNikgKiAyKSk7Cit9CisKK3N0YXRpYyBpbnQgYmNtNjMyOF9waW5jdHJsX3Nl dF9tdXgoc3RydWN0IHBpbmN0cmxfZGV2ICpwY3RsZGV2LAorCQkJCSAgIHVuc2lnbmVkIHNlbGVj dG9yLCB1bnNpZ25lZCBncm91cCkKK3sKKwlzdHJ1Y3QgYmNtNjN4eF9waW5jdHJsICpwYyA9IHBp bmN0cmxfZGV2X2dldF9kcnZkYXRhKHBjdGxkZXYpOworCWNvbnN0IHN0cnVjdCBiY202MzI4X3Bp bmdyb3VwICpwZyA9ICZiY202MzI4X2dyb3Vwc1tncm91cF07CisJY29uc3Qgc3RydWN0IGJjbTYz MjhfZnVuY3Rpb24gKmYgPSAmYmNtNjMyOF9mdW5jc1tzZWxlY3Rvcl07CisKKwliY202MzI4X3Jt d19tdXgocGMsIHBnLT5waW5zWzBdLCBmLT5tb2RlX3ZhbCwgZi0+bXV4X3ZhbCk7CisKKwlyZXR1 cm4gMDsKK30KKworc3RhdGljIGludCBiY202MzI4X2dwaW9fcmVxdWVzdF9lbmFibGUoc3RydWN0 IHBpbmN0cmxfZGV2ICpwY3RsZGV2LAorCQkJCSAgICAgICBzdHJ1Y3QgcGluY3RybF9ncGlvX3Jh bmdlICpyYW5nZSwKKwkJCQkgICAgICAgdW5zaWduZWQgb2Zmc2V0KQoreworCXN0cnVjdCBiY202 M3h4X3BpbmN0cmwgKnBjID0gcGluY3RybF9kZXZfZ2V0X2RydmRhdGEocGN0bGRldik7CisKKwkv KiBkaXNhYmxlIGFsbCBmdW5jdGlvbnMgdXNpbmcgdGhpcyBwaW4gKi8KKwliY202MzI4X3Jtd19t dXgocGMsIG9mZnNldCwgMCwgMCk7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHN0cnVjdCBw aW5jdHJsX29wcyBiY202MzI4X3BjdGxfb3BzID0geworCS5kdF9mcmVlX21hcCA9IHBpbmN0cmxf dXRpbHNfZnJlZV9tYXAsCisJLmR0X25vZGVfdG9fbWFwID0gcGluY29uZl9nZW5lcmljX2R0X25v ZGVfdG9fbWFwX3BpbiwKKwkuZ2V0X2dyb3VwX25hbWUgPSBiY202MzI4X3BpbmN0cmxfZ2V0X2dy b3VwX25hbWUsCisJLmdldF9ncm91cF9waW5zID0gYmNtNjMyOF9waW5jdHJsX2dldF9ncm91cF9w aW5zLAorCS5nZXRfZ3JvdXBzX2NvdW50ID0gYmNtNjMyOF9waW5jdHJsX2dldF9ncm91cF9jb3Vu dCwKK307CisKK3N0YXRpYyBzdHJ1Y3QgcGlubXV4X29wcyBiY202MzI4X3BteF9vcHMgPSB7CisJ LmdldF9mdW5jdGlvbl9ncm91cHMgPSBiY202MzI4X3BpbmN0cmxfZ2V0X2dyb3VwcywKKwkuZ2V0 X2Z1bmN0aW9uX25hbWUgPSBiY202MzI4X3BpbmN0cmxfZ2V0X2Z1bmNfbmFtZSwKKwkuZ2V0X2Z1 bmN0aW9uc19jb3VudCA9IGJjbTYzMjhfcGluY3RybF9nZXRfZnVuY19jb3VudCwKKwkuZ3Bpb19y ZXF1ZXN0X2VuYWJsZSA9IGJjbTYzMjhfZ3Bpb19yZXF1ZXN0X2VuYWJsZSwKKwkuc2V0X211eCA9 IGJjbTYzMjhfcGluY3RybF9zZXRfbXV4LAorCS5zdHJpY3QgPSB0cnVlLAorfTsKKworc3RhdGlj IGNvbnN0IHN0cnVjdCBiY202M3h4X3BpbmN0cmxfc29jIGJjbTYzMjhfc29jID0geworCS5uZ3Bp b3MgPSBCQ002MzI4X05VTV9HUElPUywKKwkubnBpbnMgPSBBUlJBWV9TSVpFKGJjbTYzMjhfcGlu cyksCisJLnBjdGxfb3BzID0gJmJjbTYzMjhfcGN0bF9vcHMsCisJLnBpbnMgPSBiY202MzI4X3Bp bnMsCisJLnBteF9vcHMgPSAmYmNtNjMyOF9wbXhfb3BzLAorfTsKKworc3RhdGljIGludCBiY202 MzI4X3BpbmN0cmxfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKK3sKKwlyZXR1 cm4gYmNtNjN4eF9waW5jdHJsX3Byb2JlKHBkZXYsICZiY202MzI4X3NvYywgTlVMTCk7Cit9CisK K3N0YXRpYyBjb25zdCBzdHJ1Y3Qgb2ZfZGV2aWNlX2lkIGJjbTYzMjhfcGluY3RybF9tYXRjaFtd ID0geworCXsgLmNvbXBhdGlibGUgPSAiYnJjbSxiY202MzI4LXBpbmN0cmwiLCB9LAorCXsgLyog c2VudGluZWwgKi8gfQorfTsKKworc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kcml2ZXIgYmNtNjMy OF9waW5jdHJsX2RyaXZlciA9IHsKKwkucHJvYmUgPSBiY202MzI4X3BpbmN0cmxfcHJvYmUsCisJ LmRyaXZlciA9IHsKKwkJLm5hbWUgPSAiYmNtNjMyOC1waW5jdHJsIiwKKwkJLm9mX21hdGNoX3Rh YmxlID0gYmNtNjMyOF9waW5jdHJsX21hdGNoLAorCX0sCit9OworCitidWlsdGluX3BsYXRmb3Jt X2RyaXZlcihiY202MzI4X3BpbmN0cmxfZHJpdmVyKTsKLS0gCjIuMjAuMQoKCl9fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmxpbnV4LWFybS1rZXJuZWwgbWFp bGluZyBsaXN0CmxpbnV4LWFybS1rZXJuZWxAbGlzdHMuaW5mcmFkZWFkLm9yZwpodHRwOi8vbGlz dHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LWFybS1rZXJuZWwK