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 E81A9C15514 for ; Wed, 10 Mar 2021 12:56:09 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id C4CC964FF3 for ; Wed, 10 Mar 2021 12:56:09 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232749AbhCJMzg (ORCPT ); Wed, 10 Mar 2021 07:55:36 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:39442 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232630AbhCJMzM (ORCPT ); Wed, 10 Mar 2021 07:55:12 -0500 Received: from mail-wm1-x32d.google.com (mail-wm1-x32d.google.com [IPv6:2a00:1450:4864:20::32d]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 63F36C061760; Wed, 10 Mar 2021 04:55:12 -0800 (PST) Received: by mail-wm1-x32d.google.com with SMTP id m20-20020a7bcb940000b029010cab7e5a9fso10933104wmi.3; Wed, 10 Mar 2021 04:55:12 -0800 (PST) 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=DQsKD0q0WgoB5EpAqNZvmhBBH8nVEe0J9QfQ6Iti7s8=; b=ZCflIiPpFb9i2p74dypcwQHYWBWVv2hVTAX2sbfm5h2bFAOpWd9RHpTJu+OVqIPnCr wlQXrmgVXS75NQy3Ja9dy7Edb6PS9NhkPOHUh37/JTEuFC2jLU7vvxwUzBsvG69g4YUv hmERcByLqRK2n/l5lWuS+064L/2+YfDc2NuNsKFwpxAuvBovZYq7PkB0vjd2uJYCC33x 4Qk8vr+4uP+IqHYsAzspPqoBrLg0eXjYvWeLmnylTh1bEOdMD53qsnFRRrt/eyZxPQrp lonII56w9mAHH0FUF5EXp3HBylZN//kyw3oJb/p/gcxIZS54MgYMuA1R8VN2/+MdCNqC gKGA== 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=DQsKD0q0WgoB5EpAqNZvmhBBH8nVEe0J9QfQ6Iti7s8=; b=pHOs+yQoKJnVqSFWE1pIixAScUQztzfvzb7qpWtxJialG+5UHCeGJKOGZYsoR0J/Nf wruXNdfDkcVEl6YVD6jBEOb7F6bJDJyiI2ghra6Y9+7JLfr3mr0R3Hf1XqicFu04Qt5P 0U1/RUvDFcIisaZGVGwSVdn5a4miwbE3L7g7Fe51AMiWmZHU5iQwj3o+fNXNh5rraLvv cNni1Kwvb3uBHB8zVDkrMiInmGU+d41zy7SVEZhxIuLRS0T3ingzjxTteLCjs9oCB/o8 oOhGh9ncOAMtukjT/eW5NxxqrF1AAPCFxL+DTTUKhNM5tAtmsFVNo/VFiTybipjpcV7x TqbQ== X-Gm-Message-State: AOAM5311kbdrenELbrJMNK7gi9n8OhxdpPo19tsW8Yxv9FuD8FhyywII 3uHuabAnS2gJGmGDNOvMd9g= X-Google-Smtp-Source: ABdhPJycAnz5Gwn4ZUGCitDLCqaQ5/bZnYIxYJpGIc85xudwh674V/fM8/BiwAIs1JplFeFCSBUqVA== X-Received: by 2002:a7b:c759:: with SMTP id w25mr3208161wmk.139.1615380911061; Wed, 10 Mar 2021 04:55:11 -0800 (PST) Received: from skynet.lan ([80.31.204.166]) by smtp.gmail.com with ESMTPSA id v6sm29403398wrx.32.2021.03.10.04.55.10 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 10 Mar 2021 04:55:10 -0800 (PST) From: =?UTF-8?q?=C3=81lvaro=20Fern=C3=A1ndez=20Rojas?= To: Linus Walleij , Rob Herring , Michael Walle , Bartosz Golaszewski , 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 v6 05/15] pinctrl: add a pincontrol driver for BCM6328 Date: Wed, 10 Mar 2021 13:54:53 +0100 Message-Id: <20210310125504.31886-6-noltari@gmail.com> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20210310125504.31886-1-noltari@gmail.com> References: <20210310125504.31886-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. Signed-off-by: Jonas Gorski Co-developed-by: Jonas Gorski Signed-off-by: Álvaro Fernández Rojas --- 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 A2C0FC433DB for ; Wed, 10 Mar 2021 12:59:21 +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 0FEFD64F4D for ; Wed, 10 Mar 2021 12:59:21 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 0FEFD64F4D 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=ymTzaS3hEvtQq4xbEQIx5T4ln/BUdsIKs0Exe3rxHF0=; b=WyvQXu3y+HSMsEMBVu8EAnzy7 rG2iNeCxs5LYVwlsCKrRP9TEVRUv/OlTnTHSO7QKAyJww5JRHrq6mjMzCU7p4c5JDT9zVOiL9EG7Z zYl/Z/Q0tlSvN3jaFmUdR20EmdgMitR4TrioUgZr9PusgMuo1f+uEuz5aENEZgP8Wl5csewbBo24S l26/WsNSRult5QnJwevPKIcILhUJHqtwMDmyl2fEHkn74c+PrGpNhX0uiUcy/ftI1+RS9RVn7bx6w 68fpYA1p1zMXHGAB8pHwp2nBC/4jdoL4NpVPWT5Va8tCCEOo9q5qtfHl+VV/o+Ppq9yFsf4j/B0jx 5gXpr4UXw==; Received: from localhost ([::1] helo=desiato.infradead.org) by desiato.infradead.org with esmtp (Exim 4.94 #2 (Red Hat Linux)) id 1lJyPW-006q7e-94; Wed, 10 Mar 2021 12:57:59 +0000 Received: from mail-wm1-x32a.google.com ([2a00:1450:4864:20::32a]) by desiato.infradead.org with esmtps (Exim 4.94 #2 (Red Hat Linux)) id 1lJyMp-006pih-MV for linux-arm-kernel@lists.infradead.org; Wed, 10 Mar 2021 12:57:14 +0000 Received: by mail-wm1-x32a.google.com with SMTP id t5-20020a1c77050000b029010e62cea9deso10634058wmi.0 for ; Wed, 10 Mar 2021 04:55:11 -0800 (PST) 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=DQsKD0q0WgoB5EpAqNZvmhBBH8nVEe0J9QfQ6Iti7s8=; b=ZCflIiPpFb9i2p74dypcwQHYWBWVv2hVTAX2sbfm5h2bFAOpWd9RHpTJu+OVqIPnCr wlQXrmgVXS75NQy3Ja9dy7Edb6PS9NhkPOHUh37/JTEuFC2jLU7vvxwUzBsvG69g4YUv hmERcByLqRK2n/l5lWuS+064L/2+YfDc2NuNsKFwpxAuvBovZYq7PkB0vjd2uJYCC33x 4Qk8vr+4uP+IqHYsAzspPqoBrLg0eXjYvWeLmnylTh1bEOdMD53qsnFRRrt/eyZxPQrp lonII56w9mAHH0FUF5EXp3HBylZN//kyw3oJb/p/gcxIZS54MgYMuA1R8VN2/+MdCNqC gKGA== 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=DQsKD0q0WgoB5EpAqNZvmhBBH8nVEe0J9QfQ6Iti7s8=; b=uQj9dJuBVrweslXDEzqiHxrpyaFaIKfpxKNImFvxyfXWTcQZstJXjcj5v6+jXNftyI sKwQNnmRgOGbi1k5ql2aHSSbCelXIsTluCsCtK3A5i3xdv6oEi+UEGdf3GnIqM8qx4H+ r1eCI9/lEqXPxtiv817lE/ynqezp0fsagrhK9PCTFdtD1UqEONW46vLakNB7kSOBvrlv 0SL9b/C+KgBcXW6q5PeE0F8sPiwcx3bHSKts+7KWAzl/0fY5eljKdUJ0/wOqP0TGbSBO ZysjWHXofirdszb9hA3qYu2iAZAlWalH2XnGtD/v+M4gIBy+bA4B3TCWZHQ4Ew9LWS7F uVUQ== X-Gm-Message-State: AOAM532fYD5ClQCGUy22gsChwp3Bx/9lShxXrHVEMVftFRCX2iuZ0Af9 BtSdKq6B+Clh+XUPhLQ/EHc= X-Google-Smtp-Source: ABdhPJycAnz5Gwn4ZUGCitDLCqaQ5/bZnYIxYJpGIc85xudwh674V/fM8/BiwAIs1JplFeFCSBUqVA== X-Received: by 2002:a7b:c759:: with SMTP id w25mr3208161wmk.139.1615380911061; Wed, 10 Mar 2021 04:55:11 -0800 (PST) Received: from skynet.lan ([80.31.204.166]) by smtp.gmail.com with ESMTPSA id v6sm29403398wrx.32.2021.03.10.04.55.10 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 10 Mar 2021 04:55:10 -0800 (PST) From: =?UTF-8?q?=C3=81lvaro=20Fern=C3=A1ndez=20Rojas?= To: Linus Walleij , Rob Herring , Michael Walle , Bartosz Golaszewski , 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 v6 05/15] pinctrl: add a pincontrol driver for BCM6328 Date: Wed, 10 Mar 2021 13:54:53 +0100 Message-Id: <20210310125504.31886-6-noltari@gmail.com> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20210310125504.31886-1-noltari@gmail.com> References: <20210310125504.31886-1-noltari@gmail.com> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20210310_125712_005298_EB0C0964 X-CRM114-Status: GOOD ( 23.17 ) 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 Y29uZCBVU0IgcG9ydCBiZXR3ZWVuIGhvc3QgYW5kIGRldmljZSBtb2RlLgoKU2lnbmVkLW9mZi1i eTogSm9uYXMgR29yc2tpIDxqb25hcy5nb3Jza2lAZ21haWwuY29tPgpDby1kZXZlbG9wZWQtYnk6 IEpvbmFzIEdvcnNraSA8am9uYXMuZ29yc2tpQGdtYWlsLmNvbT4KU2lnbmVkLW9mZi1ieTogw4Fs dmFybyBGZXJuw6FuZGV6IFJvamFzIDxub2x0YXJpQGdtYWlsLmNvbT4KLS0tCiB2Njogbm8gY2hh bmdlcwogdjU6IGFkZCBjaGFuZ2VzIHN1Z2dlc3RlZCBieSBBbmR5IFNoZXZjaGVua28KIHY0OiBu byBjaGFuZ2VzCiB2MzogdXNlIG5ldyBzaGFyZWQgY29kZQogdjI6IHN3aXRjaCB0byBHUElPX1JF R01BUAoKIGRyaXZlcnMvcGluY3RybC9iY20vS2NvbmZpZyAgICAgICAgICAgfCAgIDggKwogZHJp dmVycy9waW5jdHJsL2JjbS9NYWtlZmlsZSAgICAgICAgICB8ICAgMSArCiBkcml2ZXJzL3BpbmN0 cmwvYmNtL3BpbmN0cmwtYmNtNjMyOC5jIHwgNDA0ICsrKysrKysrKysrKysrKysrKysrKysrKysr CiAzIGZpbGVzIGNoYW5nZWQsIDQxMyBpbnNlcnRpb25zKCspCiBjcmVhdGUgbW9kZSAxMDA2NDQg ZHJpdmVycy9waW5jdHJsL2JjbS9waW5jdHJsLWJjbTYzMjguYwoKZGlmZiAtLWdpdCBhL2RyaXZl cnMvcGluY3RybC9iY20vS2NvbmZpZyBiL2RyaXZlcnMvcGluY3RybC9iY20vS2NvbmZpZwppbmRl eCA4ODJmMTliZGMyNDMuLmQzNWU1ZDNmZTI2ZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9waW5jdHJs L2JjbS9LY29uZmlnCisrKyBiL2RyaXZlcnMvcGluY3RybC9iY20vS2NvbmZpZwpAQCAtMzYsNiAr MzYsMTQgQEAgY29uZmlnIFBJTkNUUkxfQkNNNjNYWAogCXNlbGVjdCBQSU5DT05GCiAJc2VsZWN0 IFBJTk1VWAogCitjb25maWcgUElOQ1RSTF9CQ002MzI4CisJYm9vbCAiQnJvYWRjb20gQkNNNjMy OCBHUElPIGRyaXZlciIKKwlkZXBlbmRzIG9uIChCTUlQU19HRU5FUklDIHx8IENPTVBJTEVfVEVT VCkKKwlzZWxlY3QgUElOQ1RSTF9CQ002M1hYCisJZGVmYXVsdCBCTUlQU19HRU5FUklDCisJaGVs cAorCSAgIFNheSBZIGhlcmUgdG8gZW5hYmxlIHRoZSBCcm9hZGNvbSBCQ002MzI4IEdQSU8gZHJp dmVyLgorCiBjb25maWcgUElOQ1RSTF9JUFJPQ19HUElPCiAJYm9vbCAiQnJvYWRjb20gaVByb2Mg R1BJTyAod2l0aCBQSU5DT05GKSBkcml2ZXIiCiAJZGVwZW5kcyBvbiBPRl9HUElPICYmIChBUkNI X0JDTV9JUFJPQyB8fCBDT01QSUxFX1RFU1QpCmRpZmYgLS1naXQgYS9kcml2ZXJzL3BpbmN0cmwv YmNtL01ha2VmaWxlIGIvZHJpdmVycy9waW5jdHJsL2JjbS9NYWtlZmlsZQppbmRleCAwZTNjZjli MTVjNjUuLjU3ZTU0MzRhNmRiNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9waW5jdHJsL2JjbS9NYWtl ZmlsZQorKysgYi9kcml2ZXJzL3BpbmN0cmwvYmNtL01ha2VmaWxlCkBAIC00LDYgKzQsNyBAQAog b2JqLSQoQ09ORklHX1BJTkNUUkxfQkNNMjgxWFgpCQkrPSBwaW5jdHJsLWJjbTI4MXh4Lm8KIG9i ai0kKENPTkZJR19QSU5DVFJMX0JDTTI4MzUpCQkrPSBwaW5jdHJsLWJjbTI4MzUubwogb2JqLSQo Q09ORklHX1BJTkNUUkxfQkNNNjNYWCkJCSs9IHBpbmN0cmwtYmNtNjN4eC5vCitvYmotJChDT05G SUdfUElOQ1RSTF9CQ002MzI4KQkJKz0gcGluY3RybC1iY202MzI4Lm8KIG9iai0kKENPTkZJR19Q SU5DVFJMX0lQUk9DX0dQSU8pCSs9IHBpbmN0cmwtaXByb2MtZ3Bpby5vCiBvYmotJChDT05GSUdf UElOQ1RSTF9DWUdOVVNfTVVYKQkrPSBwaW5jdHJsLWN5Z251cy1tdXgubwogb2JqLSQoQ09ORklH X1BJTkNUUkxfTlMpCQkrPSBwaW5jdHJsLW5zLm8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGluY3Ry bC9iY20vcGluY3RybC1iY202MzI4LmMgYi9kcml2ZXJzL3BpbmN0cmwvYmNtL3BpbmN0cmwtYmNt NjMyOC5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uYzllZmNlNjAw NTUwCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9waW5jdHJsL2JjbS9waW5jdHJsLWJjbTYz MjguYwpAQCAtMCwwICsxLDQwNCBAQAorLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0y LjArCisvKgorICogRHJpdmVyIGZvciBCQ002MzI4IEdQSU8gdW5pdCAocGluY3RybCArIEdQSU8p CisgKgorICogQ29weXJpZ2h0IChDKSAyMDIxIMOBbHZhcm8gRmVybsOhbmRleiBSb2phcyA8bm9s dGFyaUBnbWFpbC5jb20+CisgKiBDb3B5cmlnaHQgKEMpIDIwMTYgSm9uYXMgR29yc2tpIDxqb25h cy5nb3Jza2lAZ21haWwuY29tPgorICovCisKKyNpbmNsdWRlIDxsaW51eC9iaXRzLmg+CisjaW5j bHVkZSA8bGludXgvZ3Bpby9kcml2ZXIuaD4KKyNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KKyNp bmNsdWRlIDxsaW51eC9vZi5oPgorI2luY2x1ZGUgPGxpbnV4L3BpbmN0cmwvcGlubXV4Lmg+Cisj aW5jbHVkZSA8bGludXgvcGxhdGZvcm1fZGV2aWNlLmg+CisjaW5jbHVkZSA8bGludXgvcmVnbWFw Lmg+CisKKyNpbmNsdWRlICIuLi9waW5jdHJsLXV0aWxzLmgiCisKKyNpbmNsdWRlICJwaW5jdHJs LWJjbTYzeHguaCIKKworI2RlZmluZSBCQ002MzI4X05VTV9HUElPUwkzMgorCisjZGVmaW5lIEJD TTYzMjhfTU9ERV9SRUcJMHgxOAorI2RlZmluZSBCQ002MzI4X01VWF9ISV9SRUcJMHgxYworI2Rl ZmluZSBCQ002MzI4X01VWF9MT19SRUcJMHgyMAorI2RlZmluZSBCQ002MzI4X01VWF9PVEhFUl9S RUcJMHgyNAorI2RlZmluZSAgQkNNNjMyOF9NVVhfTUFTSwlHRU5NQVNLKDEsIDApCisKK3N0cnVj dCBiY202MzI4X3Bpbmdyb3VwIHsKKwljb25zdCBjaGFyICpuYW1lOworCWNvbnN0IHVuc2lnbmVk ICogY29uc3QgcGluczsKKwljb25zdCB1bnNpZ25lZCBudW1fcGluczsKK307CisKK3N0cnVjdCBi Y202MzI4X2Z1bmN0aW9uIHsKKwljb25zdCBjaGFyICpuYW1lOworCWNvbnN0IGNoYXIgKiBjb25z dCAqZ3JvdXBzOworCWNvbnN0IHVuc2lnbmVkIG51bV9ncm91cHM7CisKKwl1bnNpZ25lZCBtb2Rl X3ZhbDoxOworCXVuc2lnbmVkIG11eF92YWw6MjsKK307CisKK3N0YXRpYyBjb25zdCB1bnNpZ25l ZCBpbnQgYmNtNjMyOF9tdXhbXSA9IHsKKwlCQ002MzI4X01VWF9MT19SRUcsCisJQkNNNjMyOF9N VVhfSElfUkVHLAorCUJDTTYzMjhfTVVYX09USEVSX1JFRworfTsKKworc3RhdGljIGNvbnN0IHN0 cnVjdCBwaW5jdHJsX3Bpbl9kZXNjIGJjbTYzMjhfcGluc1tdID0geworCVBJTkNUUkxfUElOKDAs ICJncGlvMCIpLAorCVBJTkNUUkxfUElOKDEsICJncGlvMSIpLAorCVBJTkNUUkxfUElOKDIsICJn cGlvMiIpLAorCVBJTkNUUkxfUElOKDMsICJncGlvMyIpLAorCVBJTkNUUkxfUElOKDQsICJncGlv NCIpLAorCVBJTkNUUkxfUElOKDUsICJncGlvNSIpLAorCVBJTkNUUkxfUElOKDYsICJncGlvNiIp LAorCVBJTkNUUkxfUElOKDcsICJncGlvNyIpLAorCVBJTkNUUkxfUElOKDgsICJncGlvOCIpLAor CVBJTkNUUkxfUElOKDksICJncGlvOSIpLAorCVBJTkNUUkxfUElOKDEwLCAiZ3BpbzEwIiksCisJ UElOQ1RSTF9QSU4oMTEsICJncGlvMTEiKSwKKwlQSU5DVFJMX1BJTigxMiwgImdwaW8xMiIpLAor CVBJTkNUUkxfUElOKDEzLCAiZ3BpbzEzIiksCisJUElOQ1RSTF9QSU4oMTQsICJncGlvMTQiKSwK KwlQSU5DVFJMX1BJTigxNSwgImdwaW8xNSIpLAorCVBJTkNUUkxfUElOKDE2LCAiZ3BpbzE2Iiks CisJUElOQ1RSTF9QSU4oMTcsICJncGlvMTciKSwKKwlQSU5DVFJMX1BJTigxOCwgImdwaW8xOCIp LAorCVBJTkNUUkxfUElOKDE5LCAiZ3BpbzE5IiksCisJUElOQ1RSTF9QSU4oMjAsICJncGlvMjAi KSwKKwlQSU5DVFJMX1BJTigyMSwgImdwaW8yMSIpLAorCVBJTkNUUkxfUElOKDIyLCAiZ3BpbzIy IiksCisJUElOQ1RSTF9QSU4oMjMsICJncGlvMjMiKSwKKwlQSU5DVFJMX1BJTigyNCwgImdwaW8y NCIpLAorCVBJTkNUUkxfUElOKDI1LCAiZ3BpbzI1IiksCisJUElOQ1RSTF9QSU4oMjYsICJncGlv MjYiKSwKKwlQSU5DVFJMX1BJTigyNywgImdwaW8yNyIpLAorCVBJTkNUUkxfUElOKDI4LCAiZ3Bp bzI4IiksCisJUElOQ1RSTF9QSU4oMjksICJncGlvMjkiKSwKKwlQSU5DVFJMX1BJTigzMCwgImdw aW8zMCIpLAorCVBJTkNUUkxfUElOKDMxLCAiZ3BpbzMxIiksCisKKwkvKgorCSAqIE5vIGlkZWEg d2hlcmUgdGhleSByZWFsbHkgYXJlOyBzbyBsZXQncyBwdXQgdGhlbSBhY2NvcmRpbmcKKwkgKiB0 byB0aGVpciBtdXggb2Zmc2V0cy4KKwkgKi8KKwlQSU5DVFJMX1BJTigzNiwgImhzc3BpX2NzMSIp LAorCVBJTkNUUkxfUElOKDM4LCAidXNiX3AyIiksCit9OworCitzdGF0aWMgdW5zaWduZWQgZ3Bp bzBfcGluc1tdID0geyAwIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzFfcGluc1tdID0geyAxIH07 CitzdGF0aWMgdW5zaWduZWQgZ3BpbzJfcGluc1tdID0geyAyIH07CitzdGF0aWMgdW5zaWduZWQg Z3BpbzNfcGluc1tdID0geyAzIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzRfcGluc1tdID0geyA0 IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzVfcGluc1tdID0geyA1IH07CitzdGF0aWMgdW5zaWdu ZWQgZ3BpbzZfcGluc1tdID0geyA2IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzdfcGluc1tdID0g eyA3IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzhfcGluc1tdID0geyA4IH07CitzdGF0aWMgdW5z aWduZWQgZ3BpbzlfcGluc1tdID0geyA5IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzEwX3BpbnNb XSA9IHsgMTAgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMTFfcGluc1tdID0geyAxMSB9Oworc3Rh dGljIHVuc2lnbmVkIGdwaW8xMl9waW5zW10gPSB7IDEyIH07CitzdGF0aWMgdW5zaWduZWQgZ3Bp bzEzX3BpbnNbXSA9IHsgMTMgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMTRfcGluc1tdID0geyAx NCB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8xNV9waW5zW10gPSB7IDE1IH07CitzdGF0aWMgdW5z aWduZWQgZ3BpbzE2X3BpbnNbXSA9IHsgMTYgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMTdfcGlu c1tdID0geyAxNyB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8xOF9waW5zW10gPSB7IDE4IH07Citz dGF0aWMgdW5zaWduZWQgZ3BpbzE5X3BpbnNbXSA9IHsgMTkgfTsKK3N0YXRpYyB1bnNpZ25lZCBn cGlvMjBfcGluc1tdID0geyAyMCB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8yMV9waW5zW10gPSB7 IDIxIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzIyX3BpbnNbXSA9IHsgMjIgfTsKK3N0YXRpYyB1 bnNpZ25lZCBncGlvMjNfcGluc1tdID0geyAyMyB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8yNF9w aW5zW10gPSB7IDI0IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzI1X3BpbnNbXSA9IHsgMjUgfTsK K3N0YXRpYyB1bnNpZ25lZCBncGlvMjZfcGluc1tdID0geyAyNiB9Oworc3RhdGljIHVuc2lnbmVk IGdwaW8yN19waW5zW10gPSB7IDI3IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzI4X3BpbnNbXSA9 IHsgMjggfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMjlfcGluc1tdID0geyAyOSB9Oworc3RhdGlj IHVuc2lnbmVkIGdwaW8zMF9waW5zW10gPSB7IDMwIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzMx X3BpbnNbXSA9IHsgMzEgfTsKKworc3RhdGljIHVuc2lnbmVkIGhzc3BpX2NzMV9waW5zW10gPSB7 IDM2IH07CitzdGF0aWMgdW5zaWduZWQgdXNiX3BvcnQxX3BpbnNbXSA9IHsgMzggfTsKKworI2Rl ZmluZSBCQ002MzI4X0dST1VQKG4pCQkJCQlcCisJewkJCQkJCQlcCisJCS5uYW1lID0gI24sCQkJ CQlcCisJCS5waW5zID0gbiMjX3BpbnMsCQkJCVwKKwkJLm51bV9waW5zID0gQVJSQVlfU0laRShu IyNfcGlucyksCQlcCisJfQorCitzdGF0aWMgc3RydWN0IGJjbTYzMjhfcGluZ3JvdXAgYmNtNjMy OF9ncm91cHNbXSA9IHsKKwlCQ002MzI4X0dST1VQKGdwaW8wKSwKKwlCQ002MzI4X0dST1VQKGdw aW8xKSwKKwlCQ002MzI4X0dST1VQKGdwaW8yKSwKKwlCQ002MzI4X0dST1VQKGdwaW8zKSwKKwlC Q002MzI4X0dST1VQKGdwaW80KSwKKwlCQ002MzI4X0dST1VQKGdwaW81KSwKKwlCQ002MzI4X0dS T1VQKGdwaW82KSwKKwlCQ002MzI4X0dST1VQKGdwaW83KSwKKwlCQ002MzI4X0dST1VQKGdwaW84 KSwKKwlCQ002MzI4X0dST1VQKGdwaW85KSwKKwlCQ002MzI4X0dST1VQKGdwaW8xMCksCisJQkNN NjMyOF9HUk9VUChncGlvMTEpLAorCUJDTTYzMjhfR1JPVVAoZ3BpbzEyKSwKKwlCQ002MzI4X0dS T1VQKGdwaW8xMyksCisJQkNNNjMyOF9HUk9VUChncGlvMTQpLAorCUJDTTYzMjhfR1JPVVAoZ3Bp bzE1KSwKKwlCQ002MzI4X0dST1VQKGdwaW8xNiksCisJQkNNNjMyOF9HUk9VUChncGlvMTcpLAor CUJDTTYzMjhfR1JPVVAoZ3BpbzE4KSwKKwlCQ002MzI4X0dST1VQKGdwaW8xOSksCisJQkNNNjMy OF9HUk9VUChncGlvMjApLAorCUJDTTYzMjhfR1JPVVAoZ3BpbzIxKSwKKwlCQ002MzI4X0dST1VQ KGdwaW8yMiksCisJQkNNNjMyOF9HUk9VUChncGlvMjMpLAorCUJDTTYzMjhfR1JPVVAoZ3BpbzI0 KSwKKwlCQ002MzI4X0dST1VQKGdwaW8yNSksCisJQkNNNjMyOF9HUk9VUChncGlvMjYpLAorCUJD TTYzMjhfR1JPVVAoZ3BpbzI3KSwKKwlCQ002MzI4X0dST1VQKGdwaW8yOCksCisJQkNNNjMyOF9H Uk9VUChncGlvMjkpLAorCUJDTTYzMjhfR1JPVVAoZ3BpbzMwKSwKKwlCQ002MzI4X0dST1VQKGdw aW8zMSksCisKKwlCQ002MzI4X0dST1VQKGhzc3BpX2NzMSksCisJQkNNNjMyOF9HUk9VUCh1c2Jf cG9ydDEpLAorfTsKKworLyogR1BJT19NT0RFICovCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0 IGxlZF9ncm91cHNbXSA9IHsKKwkiZ3BpbzAiLAorCSJncGlvMSIsCisJImdwaW8yIiwKKwkiZ3Bp bzMiLAorCSJncGlvNCIsCisJImdwaW81IiwKKwkiZ3BpbzYiLAorCSJncGlvNyIsCisJImdwaW84 IiwKKwkiZ3BpbzkiLAorCSJncGlvMTAiLAorCSJncGlvMTEiLAorCSJncGlvMTIiLAorCSJncGlv MTMiLAorCSJncGlvMTQiLAorCSJncGlvMTUiLAorCSJncGlvMTYiLAorCSJncGlvMTciLAorCSJn cGlvMTgiLAorCSJncGlvMTkiLAorCSJncGlvMjAiLAorCSJncGlvMjEiLAorCSJncGlvMjIiLAor CSJncGlvMjMiLAorfTsKKworLyogUElOTVVYX1NFTCAqLworc3RhdGljIGNvbnN0IGNoYXIgKiBj b25zdCBzZXJpYWxfbGVkX2RhdGFfZ3JvdXBzW10gPSB7CisJImdwaW82IiwKK307CisKK3N0YXRp YyBjb25zdCBjaGFyICogY29uc3Qgc2VyaWFsX2xlZF9jbGtfZ3JvdXBzW10gPSB7CisJImdwaW83 IiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgaW5ldF9hY3RfbGVkX2dyb3Vwc1td ID0geworCSJncGlvMTEiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBwY2llX2Ns a3JlcV9ncm91cHNbXSA9IHsKKwkiZ3BpbzE2IiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICog Y29uc3QgZXBoeTBfYWN0X2xlZF9ncm91cHNbXSA9IHsKKwkiZ3BpbzI1IiwKK307CisKK3N0YXRp YyBjb25zdCBjaGFyICogY29uc3QgZXBoeTFfYWN0X2xlZF9ncm91cHNbXSA9IHsKKwkiZ3BpbzI2 IiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgZXBoeTJfYWN0X2xlZF9ncm91cHNb XSA9IHsKKwkiZ3BpbzI3IiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgZXBoeTNf YWN0X2xlZF9ncm91cHNbXSA9IHsKKwkiZ3BpbzI4IiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFy ICogY29uc3QgaHNzcGlfY3MxX2dyb3Vwc1tdID0geworCSJoc3NwaV9jczEiCit9OworCitzdGF0 aWMgY29uc3QgY2hhciAqIGNvbnN0IHVzYl9ob3N0X3BvcnRfZ3JvdXBzW10gPSB7CisJInVzYl9w b3J0MSIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHVzYl9kZXZpY2VfcG9ydF9n cm91cHNbXSA9IHsKKwkidXNiX3BvcnQxIiwKK307CisKKyNkZWZpbmUgQkNNNjMyOF9NT0RFX0ZV TihuKQkJCQlcCisJewkJCQkJCVwKKwkJLm5hbWUgPSAjbiwJCQkJXAorCQkuZ3JvdXBzID0gbiMj X2dyb3VwcywJCQlcCisJCS5udW1fZ3JvdXBzID0gQVJSQVlfU0laRShuIyNfZ3JvdXBzKSwJXAor CQkubW9kZV92YWwgPSAxLAkJCQlcCisJfQorCisjZGVmaW5lIEJDTTYzMjhfTVVYX0ZVTihuLCBt dXgpCQkJCVwKKwl7CQkJCQkJXAorCQkubmFtZSA9ICNuLAkJCQlcCisJCS5ncm91cHMgPSBuIyNf Z3JvdXBzLAkJCVwKKwkJLm51bV9ncm91cHMgPSBBUlJBWV9TSVpFKG4jI19ncm91cHMpLAlcCisJ CS5tdXhfdmFsID0gbXV4LAkJCQlcCisJfQorCitzdGF0aWMgY29uc3Qgc3RydWN0IGJjbTYzMjhf ZnVuY3Rpb24gYmNtNjMyOF9mdW5jc1tdID0geworCUJDTTYzMjhfTU9ERV9GVU4obGVkKSwKKwlC Q002MzI4X01VWF9GVU4oc2VyaWFsX2xlZF9kYXRhLCAyKSwKKwlCQ002MzI4X01VWF9GVU4oc2Vy aWFsX2xlZF9jbGssIDIpLAorCUJDTTYzMjhfTVVYX0ZVTihpbmV0X2FjdF9sZWQsIDEpLAorCUJD TTYzMjhfTVVYX0ZVTihwY2llX2Nsa3JlcSwgMiksCisJQkNNNjMyOF9NVVhfRlVOKGVwaHkwX2Fj dF9sZWQsIDEpLAorCUJDTTYzMjhfTVVYX0ZVTihlcGh5MV9hY3RfbGVkLCAxKSwKKwlCQ002MzI4 X01VWF9GVU4oZXBoeTJfYWN0X2xlZCwgMSksCisJQkNNNjMyOF9NVVhfRlVOKGVwaHkzX2FjdF9s ZWQsIDEpLAorCUJDTTYzMjhfTVVYX0ZVTihoc3NwaV9jczEsIDIpLAorCUJDTTYzMjhfTVVYX0ZV Tih1c2JfaG9zdF9wb3J0LCAxKSwKKwlCQ002MzI4X01VWF9GVU4odXNiX2RldmljZV9wb3J0LCAy KSwKK307CisKK3N0YXRpYyBpbmxpbmUgdW5zaWduZWQgaW50IGJjbTYzMjhfbXV4X29mZih1bnNp Z25lZCBpbnQgcGluKQoreworCXJldHVybiBiY202MzI4X211eFtwaW4gLyAxNl07Cit9CisKK3N0 YXRpYyBpbnQgYmNtNjMyOF9waW5jdHJsX2dldF9ncm91cF9jb3VudChzdHJ1Y3QgcGluY3RybF9k ZXYgKnBjdGxkZXYpCit7CisJcmV0dXJuIEFSUkFZX1NJWkUoYmNtNjMyOF9ncm91cHMpOworfQor CitzdGF0aWMgY29uc3QgY2hhciAqYmNtNjMyOF9waW5jdHJsX2dldF9ncm91cF9uYW1lKHN0cnVj dCBwaW5jdHJsX2RldiAqcGN0bGRldiwKKwkJCQkJCSAgdW5zaWduZWQgZ3JvdXApCit7CisJcmV0 dXJuIGJjbTYzMjhfZ3JvdXBzW2dyb3VwXS5uYW1lOworfQorCitzdGF0aWMgaW50IGJjbTYzMjhf cGluY3RybF9nZXRfZ3JvdXBfcGlucyhzdHJ1Y3QgcGluY3RybF9kZXYgKnBjdGxkZXYsCisJCQkJ CSAgdW5zaWduZWQgZ3JvdXAsIGNvbnN0IHVuc2lnbmVkICoqcGlucywKKwkJCQkJICB1bnNpZ25l ZCAqbnVtX3BpbnMpCit7CisJKnBpbnMgPSBiY202MzI4X2dyb3Vwc1tncm91cF0ucGluczsKKwkq bnVtX3BpbnMgPSBiY202MzI4X2dyb3Vwc1tncm91cF0ubnVtX3BpbnM7CisKKwlyZXR1cm4gMDsK K30KKworc3RhdGljIGludCBiY202MzI4X3BpbmN0cmxfZ2V0X2Z1bmNfY291bnQoc3RydWN0IHBp bmN0cmxfZGV2ICpwY3RsZGV2KQoreworCXJldHVybiBBUlJBWV9TSVpFKGJjbTYzMjhfZnVuY3Mp OworfQorCitzdGF0aWMgY29uc3QgY2hhciAqYmNtNjMyOF9waW5jdHJsX2dldF9mdW5jX25hbWUo c3RydWN0IHBpbmN0cmxfZGV2ICpwY3RsZGV2LAorCQkJCQkJIHVuc2lnbmVkIHNlbGVjdG9yKQor eworCXJldHVybiBiY202MzI4X2Z1bmNzW3NlbGVjdG9yXS5uYW1lOworfQorCitzdGF0aWMgaW50 IGJjbTYzMjhfcGluY3RybF9nZXRfZ3JvdXBzKHN0cnVjdCBwaW5jdHJsX2RldiAqcGN0bGRldiwK KwkJCQkgICAgICB1bnNpZ25lZCBzZWxlY3RvciwKKwkJCQkgICAgICBjb25zdCBjaGFyICogY29u c3QgKipncm91cHMsCisJCQkJICAgICAgdW5zaWduZWQgKiBjb25zdCBudW1fZ3JvdXBzKQorewor CSpncm91cHMgPSBiY202MzI4X2Z1bmNzW3NlbGVjdG9yXS5ncm91cHM7CisJKm51bV9ncm91cHMg PSBiY202MzI4X2Z1bmNzW3NlbGVjdG9yXS5udW1fZ3JvdXBzOworCisJcmV0dXJuIDA7Cit9CisK K3N0YXRpYyB2b2lkIGJjbTYzMjhfcm13X211eChzdHJ1Y3QgYmNtNjN4eF9waW5jdHJsICpwYywg dW5zaWduZWQgcGluLAorCQkJICAgIHVuc2lnbmVkIGludCBtb2RlLCB1bnNpZ25lZCBpbnQgbXV4 KQoreworCWlmIChwaW4gPCBCQ002MzI4X05VTV9HUElPUykKKwkJcmVnbWFwX3VwZGF0ZV9iaXRz KHBjLT5yZWdzLCBCQ002MzI4X01PREVfUkVHLCBCSVQocGluKSwKKwkJCQkgICBtb2RlID8gQklU KHBpbikgOiAwKTsKKworCXJlZ21hcF91cGRhdGVfYml0cyhwYy0+cmVncywgYmNtNjMyOF9tdXhf b2ZmKHBpbiksCisJCQkgICBCQ002MzI4X01VWF9NQVNLIDw8ICgocGluICUgMTYpICogMiksCisJ CQkgICBtdXggPDwgKChwaW4gJSAxNikgKiAyKSk7Cit9CisKK3N0YXRpYyBpbnQgYmNtNjMyOF9w aW5jdHJsX3NldF9tdXgoc3RydWN0IHBpbmN0cmxfZGV2ICpwY3RsZGV2LAorCQkJCSAgIHVuc2ln bmVkIHNlbGVjdG9yLCB1bnNpZ25lZCBncm91cCkKK3sKKwlzdHJ1Y3QgYmNtNjN4eF9waW5jdHJs ICpwYyA9IHBpbmN0cmxfZGV2X2dldF9kcnZkYXRhKHBjdGxkZXYpOworCWNvbnN0IHN0cnVjdCBi Y202MzI4X3Bpbmdyb3VwICpwZyA9ICZiY202MzI4X2dyb3Vwc1tncm91cF07CisJY29uc3Qgc3Ry dWN0IGJjbTYzMjhfZnVuY3Rpb24gKmYgPSAmYmNtNjMyOF9mdW5jc1tzZWxlY3Rvcl07CisKKwli Y202MzI4X3Jtd19tdXgocGMsIHBnLT5waW5zWzBdLCBmLT5tb2RlX3ZhbCwgZi0+bXV4X3ZhbCk7 CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBiY202MzI4X2dwaW9fcmVxdWVzdF9lbmFi bGUoc3RydWN0IHBpbmN0cmxfZGV2ICpwY3RsZGV2LAorCQkJCSAgICAgICBzdHJ1Y3QgcGluY3Ry bF9ncGlvX3JhbmdlICpyYW5nZSwKKwkJCQkgICAgICAgdW5zaWduZWQgb2Zmc2V0KQoreworCXN0 cnVjdCBiY202M3h4X3BpbmN0cmwgKnBjID0gcGluY3RybF9kZXZfZ2V0X2RydmRhdGEocGN0bGRl dik7CisKKwkvKiBkaXNhYmxlIGFsbCBmdW5jdGlvbnMgdXNpbmcgdGhpcyBwaW4gKi8KKwliY202 MzI4X3Jtd19tdXgocGMsIG9mZnNldCwgMCwgMCk7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGlj IHN0cnVjdCBwaW5jdHJsX29wcyBiY202MzI4X3BjdGxfb3BzID0geworCS5kdF9mcmVlX21hcCA9 IHBpbmN0cmxfdXRpbHNfZnJlZV9tYXAsCisJLmR0X25vZGVfdG9fbWFwID0gcGluY29uZl9nZW5l cmljX2R0X25vZGVfdG9fbWFwX3BpbiwKKwkuZ2V0X2dyb3VwX25hbWUgPSBiY202MzI4X3BpbmN0 cmxfZ2V0X2dyb3VwX25hbWUsCisJLmdldF9ncm91cF9waW5zID0gYmNtNjMyOF9waW5jdHJsX2dl dF9ncm91cF9waW5zLAorCS5nZXRfZ3JvdXBzX2NvdW50ID0gYmNtNjMyOF9waW5jdHJsX2dldF9n cm91cF9jb3VudCwKK307CisKK3N0YXRpYyBzdHJ1Y3QgcGlubXV4X29wcyBiY202MzI4X3BteF9v cHMgPSB7CisJLmdldF9mdW5jdGlvbl9ncm91cHMgPSBiY202MzI4X3BpbmN0cmxfZ2V0X2dyb3Vw cywKKwkuZ2V0X2Z1bmN0aW9uX25hbWUgPSBiY202MzI4X3BpbmN0cmxfZ2V0X2Z1bmNfbmFtZSwK KwkuZ2V0X2Z1bmN0aW9uc19jb3VudCA9IGJjbTYzMjhfcGluY3RybF9nZXRfZnVuY19jb3VudCwK KwkuZ3Bpb19yZXF1ZXN0X2VuYWJsZSA9IGJjbTYzMjhfZ3Bpb19yZXF1ZXN0X2VuYWJsZSwKKwku c2V0X211eCA9IGJjbTYzMjhfcGluY3RybF9zZXRfbXV4LAorCS5zdHJpY3QgPSB0cnVlLAorfTsK Kworc3RhdGljIGNvbnN0IHN0cnVjdCBiY202M3h4X3BpbmN0cmxfc29jIGJjbTYzMjhfc29jID0g eworCS5uZ3Bpb3MgPSBCQ002MzI4X05VTV9HUElPUywKKwkubnBpbnMgPSBBUlJBWV9TSVpFKGJj bTYzMjhfcGlucyksCisJLnBjdGxfb3BzID0gJmJjbTYzMjhfcGN0bF9vcHMsCisJLnBpbnMgPSBi Y202MzI4X3BpbnMsCisJLnBteF9vcHMgPSAmYmNtNjMyOF9wbXhfb3BzLAorfTsKKworc3RhdGlj IGludCBiY202MzI4X3BpbmN0cmxfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikK K3sKKwlyZXR1cm4gYmNtNjN4eF9waW5jdHJsX3Byb2JlKHBkZXYsICZiY202MzI4X3NvYywgTlVM TCk7Cit9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgb2ZfZGV2aWNlX2lkIGJjbTYzMjhfcGluY3Ry bF9tYXRjaFtdID0geworCXsgLmNvbXBhdGlibGUgPSAiYnJjbSxiY202MzI4LXBpbmN0cmwiLCB9 LAorCXsgLyogc2VudGluZWwgKi8gfQorfTsKKworc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kcml2 ZXIgYmNtNjMyOF9waW5jdHJsX2RyaXZlciA9IHsKKwkucHJvYmUgPSBiY202MzI4X3BpbmN0cmxf cHJvYmUsCisJLmRyaXZlciA9IHsKKwkJLm5hbWUgPSAiYmNtNjMyOC1waW5jdHJsIiwKKwkJLm9m X21hdGNoX3RhYmxlID0gYmNtNjMyOF9waW5jdHJsX21hdGNoLAorCX0sCit9OworCitidWlsdGlu X3BsYXRmb3JtX2RyaXZlcihiY202MzI4X3BpbmN0cmxfZHJpdmVyKTsKLS0gCjIuMjAuMQoKCl9f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmxpbnV4LWFybS1r ZXJuZWwgbWFpbGluZyBsaXN0CmxpbnV4LWFybS1rZXJuZWxAbGlzdHMuaW5mcmFkZWFkLm9yZwpo dHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LWFybS1rZXJu ZWwK