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.7 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 59907C4332B for ; Sat, 6 Mar 2021 15:58:19 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 39BBE65025 for ; Sat, 6 Mar 2021 15:58:19 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231177AbhCFP5r (ORCPT ); Sat, 6 Mar 2021 10:57:47 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:50930 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230486AbhCFP5T (ORCPT ); Sat, 6 Mar 2021 10:57:19 -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 4C711C06175F; Sat, 6 Mar 2021 07:57:19 -0800 (PST) Received: by mail-wm1-x32d.google.com with SMTP id d139-20020a1c1d910000b029010b895cb6f2so1125034wmd.5; Sat, 06 Mar 2021 07:57:19 -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=LGvJtJYk6EnL3AiJxzIcxenQCPp0bjlOuORpNviqpXg=; b=dYUEZzn43pSRHUQDgo1Ui8cJWrAlboN6wo6vtdsG77upT6WPiVUpCuR0TZDTIkbcEE NxeIbG2KhGfZ+7Ib/bGFSKex/6uyItCIeyawo45hFjJpVUBXzxb2g00BvLwdhJdqXuNO O6NUWRx3+9x/OKEdIs+vInkHg6vtPsa8/ZokF6ZW0vCxx3uKn2lAbPo4xr2RmTlI/Osj j2y4q3hHQSV4LQWc16KExO69hTDmkQo403N6K8ncFYfk1nZaLwbgwJ1c02ZUZ+2HosVY 7ujlosTK8qeQj5xU66rRaged446OQZYCAS7Qu8Ju/RUWoBeIdSnHUVs7csf5IbcU4yD6 M8cg== 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=LGvJtJYk6EnL3AiJxzIcxenQCPp0bjlOuORpNviqpXg=; b=Tx8NAVfmdcls1siU9EUHNph3gdGJROp2kvWwhxOmHEeWdtkk2/bJI44LQjwWtIWoAE 139+aI2h/G0duGNn8TQpHK4QOB9u0/8niUDWCwN+CPMTuqvg6xdcuVzFmPNhP+krtGZz ZzimUZfDjUC4fmWEEsYwam3YshL748XMLwmfPbAQegXrpFMOQrSxVhXMqhbAfZSmL1iM N84cThGvqmntSoPeVMPVUGBbA6+RJJ7O+h1qMp7PNem4Q2qTTxScr6qUnXF1hUJkJJUT xeDxlPGz16o90LJcyB8howkxpddIw0VNKezf16nlkFO8UXm36bM1xV7R+KBD8MGBj+zj MyHw== X-Gm-Message-State: AOAM531K1fr9GSGXmDvBxPmnPiqcXDQKkwAwloHtetJShc3MhMDTYgVj 5RaPhbNpF8TO74HDiBGcCEU= X-Google-Smtp-Source: ABdhPJwGH4yuvyA9sfPe8W+RvbbPeLoukTTeWTv77gkbkinQvJXcg1KFjYB33ySeY0L5dP3q/qYQIg== X-Received: by 2002:a1c:32ca:: with SMTP id y193mr11382903wmy.56.1615046237949; Sat, 06 Mar 2021 07:57:17 -0800 (PST) Received: from skynet.lan (224.red-2-138-103.dynamicip.rima-tde.net. [2.138.103.224]) by smtp.gmail.com with ESMTPSA id p6sm9315188wru.2.2021.03.06.07.57.17 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 06 Mar 2021 07:57:17 -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 v5 05/15] pinctrl: add a pincontrol driver for BCM6328 Date: Sat, 6 Mar 2021 16:57:02 +0100 Message-Id: <20210306155712.4298-6-noltari@gmail.com> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20210306155712.4298-1-noltari@gmail.com> References: <20210306155712.4298-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 --- 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 A2884C433E6 for ; Sat, 6 Mar 2021 15:59: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 A84EA65004 for ; Sat, 6 Mar 2021 15:59:11 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org A84EA65004 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=e+gXhoDIq9Xk+czgvruafAGhY5dIw7Hks3uHWOrtP30=; b=Wu3i+jvgSGcGn172RK4p57tvN Q8oZbcdIzQzGgjFCZhbRAiEV+wDqeH4wEqsRXbaOG2AhOZB6ocsmkT0Y1UReumkgH/lgn5TBMfJgk gzttacf8eVSUTlgbgIILQZ9PMOfcvPFuMIqdUEPw10VMEJSe8Ko+OGcgTkD3Aql7ektU02WWbhTqS qhzjS2AFRBkop7l/wevrounvJegPo/rg1r7r73UiZ7DB2nJfmZq4aaHMsasL+dR9WR1IPkchvXUky Ojj09aKtaGlbqGjuDe5bpFaisi1qMAek/dl+6r3duMZt4uLYdUSkNR9XqMp0rjR+EdJyCxBMjOm/L nIeBpoLCA==; Received: from localhost ([::1] helo=desiato.infradead.org) by desiato.infradead.org with esmtp (Exim 4.94 #2 (Red Hat Linux)) id 1lIZJ9-003UxW-DB; Sat, 06 Mar 2021 15:57:35 +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 1lIZIt-003Uqn-UR for linux-arm-kernel@lists.infradead.org; Sat, 06 Mar 2021 15:57:22 +0000 Received: by mail-wm1-x32a.google.com with SMTP id j4-20020a05600c4104b029010c62bc1e20so1127103wmi.3 for ; Sat, 06 Mar 2021 07:57:18 -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=LGvJtJYk6EnL3AiJxzIcxenQCPp0bjlOuORpNviqpXg=; b=dYUEZzn43pSRHUQDgo1Ui8cJWrAlboN6wo6vtdsG77upT6WPiVUpCuR0TZDTIkbcEE NxeIbG2KhGfZ+7Ib/bGFSKex/6uyItCIeyawo45hFjJpVUBXzxb2g00BvLwdhJdqXuNO O6NUWRx3+9x/OKEdIs+vInkHg6vtPsa8/ZokF6ZW0vCxx3uKn2lAbPo4xr2RmTlI/Osj j2y4q3hHQSV4LQWc16KExO69hTDmkQo403N6K8ncFYfk1nZaLwbgwJ1c02ZUZ+2HosVY 7ujlosTK8qeQj5xU66rRaged446OQZYCAS7Qu8Ju/RUWoBeIdSnHUVs7csf5IbcU4yD6 M8cg== 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=LGvJtJYk6EnL3AiJxzIcxenQCPp0bjlOuORpNviqpXg=; b=L+v+DSlLQt8D2+hq6h1wxHrMhGUhSb+53bV7KKEmkNrRtUSbCcIOW29r2OPM0r91cD cLw1Ua0ZnzxSWBCM5y2afDvbZxNfNERgwKF7BwljxHimj4BTI1YwAGeOvmj24E/rtgAZ a3+K6t3Gh/wclKD2+oGk6NPQbGe1eiyB6hqHp36uQymoL1n4CiyRFk1B6MmXDcymRGTa N/P4RNmJ0EpXpFOVSR265Rv1Zphg17GqXuanKuPQUxCMFz75gAAyWFywzsKvxb8IIKd+ eJKjrrL7/4kaU8kxroyt5dWgvf38QpPU2HaXjofK+Vfg0FCts8Q8nq4K9OYwTmAo/VE9 zb5g== X-Gm-Message-State: AOAM531NhstYidEVhFHRD3mQ0BaKmT9zZNBmNxz4HRZN1kS+rcCK3227 26yQ7uDLQOEfcdiVMgzgpQU= X-Google-Smtp-Source: ABdhPJwGH4yuvyA9sfPe8W+RvbbPeLoukTTeWTv77gkbkinQvJXcg1KFjYB33ySeY0L5dP3q/qYQIg== X-Received: by 2002:a1c:32ca:: with SMTP id y193mr11382903wmy.56.1615046237949; Sat, 06 Mar 2021 07:57:17 -0800 (PST) Received: from skynet.lan (224.red-2-138-103.dynamicip.rima-tde.net. [2.138.103.224]) by smtp.gmail.com with ESMTPSA id p6sm9315188wru.2.2021.03.06.07.57.17 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 06 Mar 2021 07:57:17 -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 v5 05/15] pinctrl: add a pincontrol driver for BCM6328 Date: Sat, 6 Mar 2021 16:57:02 +0100 Message-Id: <20210306155712.4298-6-noltari@gmail.com> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20210306155712.4298-1-noltari@gmail.com> References: <20210306155712.4298-1-noltari@gmail.com> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20210306_155720_237086_18A847A3 X-CRM114-Status: GOOD ( 21.75 ) 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 dmFybyBGZXJuw6FuZGV6IFJvamFzIDxub2x0YXJpQGdtYWlsLmNvbT4KLS0tCiB2NTogYWRkIGNo YW5nZXMgc3VnZ2VzdGVkIGJ5IEFuZHkgU2hldmNoZW5rbwogdjQ6IG5vIGNoYW5nZXMKIHYzOiB1 c2UgbmV3IHNoYXJlZCBjb2RlCiB2Mjogc3dpdGNoIHRvIEdQSU9fUkVHTUFQCgogZHJpdmVycy9w aW5jdHJsL2JjbS9LY29uZmlnICAgICAgICAgICB8ICAgOCArCiBkcml2ZXJzL3BpbmN0cmwvYmNt L01ha2VmaWxlICAgICAgICAgIHwgICAxICsKIGRyaXZlcnMvcGluY3RybC9iY20vcGluY3RybC1i Y202MzI4LmMgfCA0MDQgKysrKysrKysrKysrKysrKysrKysrKysrKysKIDMgZmlsZXMgY2hhbmdl ZCwgNDEzIGluc2VydGlvbnMoKykKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL3BpbmN0cmwv YmNtL3BpbmN0cmwtYmNtNjMyOC5jCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9waW5jdHJsL2JjbS9L Y29uZmlnIGIvZHJpdmVycy9waW5jdHJsL2JjbS9LY29uZmlnCmluZGV4IDg4MmYxOWJkYzI0My4u ZDM1ZTVkM2ZlMjZmIDEwMDY0NAotLS0gYS9kcml2ZXJzL3BpbmN0cmwvYmNtL0tjb25maWcKKysr IGIvZHJpdmVycy9waW5jdHJsL2JjbS9LY29uZmlnCkBAIC0zNiw2ICszNiwxNCBAQCBjb25maWcg UElOQ1RSTF9CQ002M1hYCiAJc2VsZWN0IFBJTkNPTkYKIAlzZWxlY3QgUElOTVVYCiAKK2NvbmZp ZyBQSU5DVFJMX0JDTTYzMjgKKwlib29sICJCcm9hZGNvbSBCQ002MzI4IEdQSU8gZHJpdmVyIgor CWRlcGVuZHMgb24gKEJNSVBTX0dFTkVSSUMgfHwgQ09NUElMRV9URVNUKQorCXNlbGVjdCBQSU5D VFJMX0JDTTYzWFgKKwlkZWZhdWx0IEJNSVBTX0dFTkVSSUMKKwloZWxwCisJICAgU2F5IFkgaGVy ZSB0byBlbmFibGUgdGhlIEJyb2FkY29tIEJDTTYzMjggR1BJTyBkcml2ZXIuCisKIGNvbmZpZyBQ SU5DVFJMX0lQUk9DX0dQSU8KIAlib29sICJCcm9hZGNvbSBpUHJvYyBHUElPICh3aXRoIFBJTkNP TkYpIGRyaXZlciIKIAlkZXBlbmRzIG9uIE9GX0dQSU8gJiYgKEFSQ0hfQkNNX0lQUk9DIHx8IENP TVBJTEVfVEVTVCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGluY3RybC9iY20vTWFrZWZpbGUgYi9k cml2ZXJzL3BpbmN0cmwvYmNtL01ha2VmaWxlCmluZGV4IDBlM2NmOWIxNWM2NS4uNTdlNTQzNGE2 ZGI2IDEwMDY0NAotLS0gYS9kcml2ZXJzL3BpbmN0cmwvYmNtL01ha2VmaWxlCisrKyBiL2RyaXZl cnMvcGluY3RybC9iY20vTWFrZWZpbGUKQEAgLTQsNiArNCw3IEBACiBvYmotJChDT05GSUdfUElO Q1RSTF9CQ00yODFYWCkJCSs9IHBpbmN0cmwtYmNtMjgxeHgubwogb2JqLSQoQ09ORklHX1BJTkNU UkxfQkNNMjgzNSkJCSs9IHBpbmN0cmwtYmNtMjgzNS5vCiBvYmotJChDT05GSUdfUElOQ1RSTF9C Q002M1hYKQkJKz0gcGluY3RybC1iY202M3h4Lm8KK29iai0kKENPTkZJR19QSU5DVFJMX0JDTTYz MjgpCQkrPSBwaW5jdHJsLWJjbTYzMjgubwogb2JqLSQoQ09ORklHX1BJTkNUUkxfSVBST0NfR1BJ TykJKz0gcGluY3RybC1pcHJvYy1ncGlvLm8KIG9iai0kKENPTkZJR19QSU5DVFJMX0NZR05VU19N VVgpCSs9IHBpbmN0cmwtY3lnbnVzLW11eC5vCiBvYmotJChDT05GSUdfUElOQ1RSTF9OUykJCSs9 IHBpbmN0cmwtbnMubwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9waW5jdHJsL2JjbS9waW5jdHJsLWJj bTYzMjguYyBiL2RyaXZlcnMvcGluY3RybC9iY20vcGluY3RybC1iY202MzI4LmMKbmV3IGZpbGUg bW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi5jOWVmY2U2MDA1NTAKLS0tIC9kZXYvbnVs bAorKysgYi9kcml2ZXJzL3BpbmN0cmwvYmNtL3BpbmN0cmwtYmNtNjMyOC5jCkBAIC0wLDAgKzEs NDA0IEBACisvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMCsKKy8qCisgKiBEcml2 ZXIgZm9yIEJDTTYzMjggR1BJTyB1bml0IChwaW5jdHJsICsgR1BJTykKKyAqCisgKiBDb3B5cmln aHQgKEMpIDIwMjEgw4FsdmFybyBGZXJuw6FuZGV6IFJvamFzIDxub2x0YXJpQGdtYWlsLmNvbT4K KyAqIENvcHlyaWdodCAoQykgMjAxNiBKb25hcyBHb3Jza2kgPGpvbmFzLmdvcnNraUBnbWFpbC5j b20+CisgKi8KKworI2luY2x1ZGUgPGxpbnV4L2JpdHMuaD4KKyNpbmNsdWRlIDxsaW51eC9ncGlv L2RyaXZlci5oPgorI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgorI2luY2x1ZGUgPGxpbnV4L29m Lmg+CisjaW5jbHVkZSA8bGludXgvcGluY3RybC9waW5tdXguaD4KKyNpbmNsdWRlIDxsaW51eC9w bGF0Zm9ybV9kZXZpY2UuaD4KKyNpbmNsdWRlIDxsaW51eC9yZWdtYXAuaD4KKworI2luY2x1ZGUg Ii4uL3BpbmN0cmwtdXRpbHMuaCIKKworI2luY2x1ZGUgInBpbmN0cmwtYmNtNjN4eC5oIgorCisj ZGVmaW5lIEJDTTYzMjhfTlVNX0dQSU9TCTMyCisKKyNkZWZpbmUgQkNNNjMyOF9NT0RFX1JFRwkw eDE4CisjZGVmaW5lIEJDTTYzMjhfTVVYX0hJX1JFRwkweDFjCisjZGVmaW5lIEJDTTYzMjhfTVVY X0xPX1JFRwkweDIwCisjZGVmaW5lIEJDTTYzMjhfTVVYX09USEVSX1JFRwkweDI0CisjZGVmaW5l ICBCQ002MzI4X01VWF9NQVNLCUdFTk1BU0soMSwgMCkKKworc3RydWN0IGJjbTYzMjhfcGluZ3Jv dXAgeworCWNvbnN0IGNoYXIgKm5hbWU7CisJY29uc3QgdW5zaWduZWQgKiBjb25zdCBwaW5zOwor CWNvbnN0IHVuc2lnbmVkIG51bV9waW5zOworfTsKKworc3RydWN0IGJjbTYzMjhfZnVuY3Rpb24g eworCWNvbnN0IGNoYXIgKm5hbWU7CisJY29uc3QgY2hhciAqIGNvbnN0ICpncm91cHM7CisJY29u c3QgdW5zaWduZWQgbnVtX2dyb3VwczsKKworCXVuc2lnbmVkIG1vZGVfdmFsOjE7CisJdW5zaWdu ZWQgbXV4X3ZhbDoyOworfTsKKworc3RhdGljIGNvbnN0IHVuc2lnbmVkIGludCBiY202MzI4X211 eFtdID0geworCUJDTTYzMjhfTVVYX0xPX1JFRywKKwlCQ002MzI4X01VWF9ISV9SRUcsCisJQkNN NjMyOF9NVVhfT1RIRVJfUkVHCit9OworCitzdGF0aWMgY29uc3Qgc3RydWN0IHBpbmN0cmxfcGlu X2Rlc2MgYmNtNjMyOF9waW5zW10gPSB7CisJUElOQ1RSTF9QSU4oMCwgImdwaW8wIiksCisJUElO Q1RSTF9QSU4oMSwgImdwaW8xIiksCisJUElOQ1RSTF9QSU4oMiwgImdwaW8yIiksCisJUElOQ1RS TF9QSU4oMywgImdwaW8zIiksCisJUElOQ1RSTF9QSU4oNCwgImdwaW80IiksCisJUElOQ1RSTF9Q SU4oNSwgImdwaW81IiksCisJUElOQ1RSTF9QSU4oNiwgImdwaW82IiksCisJUElOQ1RSTF9QSU4o NywgImdwaW83IiksCisJUElOQ1RSTF9QSU4oOCwgImdwaW84IiksCisJUElOQ1RSTF9QSU4oOSwg ImdwaW85IiksCisJUElOQ1RSTF9QSU4oMTAsICJncGlvMTAiKSwKKwlQSU5DVFJMX1BJTigxMSwg ImdwaW8xMSIpLAorCVBJTkNUUkxfUElOKDEyLCAiZ3BpbzEyIiksCisJUElOQ1RSTF9QSU4oMTMs ICJncGlvMTMiKSwKKwlQSU5DVFJMX1BJTigxNCwgImdwaW8xNCIpLAorCVBJTkNUUkxfUElOKDE1 LCAiZ3BpbzE1IiksCisJUElOQ1RSTF9QSU4oMTYsICJncGlvMTYiKSwKKwlQSU5DVFJMX1BJTigx NywgImdwaW8xNyIpLAorCVBJTkNUUkxfUElOKDE4LCAiZ3BpbzE4IiksCisJUElOQ1RSTF9QSU4o MTksICJncGlvMTkiKSwKKwlQSU5DVFJMX1BJTigyMCwgImdwaW8yMCIpLAorCVBJTkNUUkxfUElO KDIxLCAiZ3BpbzIxIiksCisJUElOQ1RSTF9QSU4oMjIsICJncGlvMjIiKSwKKwlQSU5DVFJMX1BJ TigyMywgImdwaW8yMyIpLAorCVBJTkNUUkxfUElOKDI0LCAiZ3BpbzI0IiksCisJUElOQ1RSTF9Q SU4oMjUsICJncGlvMjUiKSwKKwlQSU5DVFJMX1BJTigyNiwgImdwaW8yNiIpLAorCVBJTkNUUkxf UElOKDI3LCAiZ3BpbzI3IiksCisJUElOQ1RSTF9QSU4oMjgsICJncGlvMjgiKSwKKwlQSU5DVFJM X1BJTigyOSwgImdwaW8yOSIpLAorCVBJTkNUUkxfUElOKDMwLCAiZ3BpbzMwIiksCisJUElOQ1RS TF9QSU4oMzEsICJncGlvMzEiKSwKKworCS8qCisJICogTm8gaWRlYSB3aGVyZSB0aGV5IHJlYWxs eSBhcmU7IHNvIGxldCdzIHB1dCB0aGVtIGFjY29yZGluZworCSAqIHRvIHRoZWlyIG11eCBvZmZz ZXRzLgorCSAqLworCVBJTkNUUkxfUElOKDM2LCAiaHNzcGlfY3MxIiksCisJUElOQ1RSTF9QSU4o MzgsICJ1c2JfcDIiKSwKK307CisKK3N0YXRpYyB1bnNpZ25lZCBncGlvMF9waW5zW10gPSB7IDAg fTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMV9waW5zW10gPSB7IDEgfTsKK3N0YXRpYyB1bnNpZ25l ZCBncGlvMl9waW5zW10gPSB7IDIgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvM19waW5zW10gPSB7 IDMgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvNF9waW5zW10gPSB7IDQgfTsKK3N0YXRpYyB1bnNp Z25lZCBncGlvNV9waW5zW10gPSB7IDUgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvNl9waW5zW10g PSB7IDYgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvN19waW5zW10gPSB7IDcgfTsKK3N0YXRpYyB1 bnNpZ25lZCBncGlvOF9waW5zW10gPSB7IDggfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvOV9waW5z W10gPSB7IDkgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMTBfcGluc1tdID0geyAxMCB9Oworc3Rh dGljIHVuc2lnbmVkIGdwaW8xMV9waW5zW10gPSB7IDExIH07CitzdGF0aWMgdW5zaWduZWQgZ3Bp bzEyX3BpbnNbXSA9IHsgMTIgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMTNfcGluc1tdID0geyAx MyB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8xNF9waW5zW10gPSB7IDE0IH07CitzdGF0aWMgdW5z aWduZWQgZ3BpbzE1X3BpbnNbXSA9IHsgMTUgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMTZfcGlu c1tdID0geyAxNiB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8xN19waW5zW10gPSB7IDE3IH07Citz dGF0aWMgdW5zaWduZWQgZ3BpbzE4X3BpbnNbXSA9IHsgMTggfTsKK3N0YXRpYyB1bnNpZ25lZCBn cGlvMTlfcGluc1tdID0geyAxOSB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8yMF9waW5zW10gPSB7 IDIwIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzIxX3BpbnNbXSA9IHsgMjEgfTsKK3N0YXRpYyB1 bnNpZ25lZCBncGlvMjJfcGluc1tdID0geyAyMiB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8yM19w aW5zW10gPSB7IDIzIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzI0X3BpbnNbXSA9IHsgMjQgfTsK K3N0YXRpYyB1bnNpZ25lZCBncGlvMjVfcGluc1tdID0geyAyNSB9Oworc3RhdGljIHVuc2lnbmVk IGdwaW8yNl9waW5zW10gPSB7IDI2IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzI3X3BpbnNbXSA9 IHsgMjcgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMjhfcGluc1tdID0geyAyOCB9Oworc3RhdGlj IHVuc2lnbmVkIGdwaW8yOV9waW5zW10gPSB7IDI5IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzMw X3BpbnNbXSA9IHsgMzAgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMzFfcGluc1tdID0geyAzMSB9 OworCitzdGF0aWMgdW5zaWduZWQgaHNzcGlfY3MxX3BpbnNbXSA9IHsgMzYgfTsKK3N0YXRpYyB1 bnNpZ25lZCB1c2JfcG9ydDFfcGluc1tdID0geyAzOCB9OworCisjZGVmaW5lIEJDTTYzMjhfR1JP VVAobikJCQkJCVwKKwl7CQkJCQkJCVwKKwkJLm5hbWUgPSAjbiwJCQkJCVwKKwkJLnBpbnMgPSBu IyNfcGlucywJCQkJXAorCQkubnVtX3BpbnMgPSBBUlJBWV9TSVpFKG4jI19waW5zKSwJCVwKKwl9 CisKK3N0YXRpYyBzdHJ1Y3QgYmNtNjMyOF9waW5ncm91cCBiY202MzI4X2dyb3Vwc1tdID0gewor CUJDTTYzMjhfR1JPVVAoZ3BpbzApLAorCUJDTTYzMjhfR1JPVVAoZ3BpbzEpLAorCUJDTTYzMjhf R1JPVVAoZ3BpbzIpLAorCUJDTTYzMjhfR1JPVVAoZ3BpbzMpLAorCUJDTTYzMjhfR1JPVVAoZ3Bp bzQpLAorCUJDTTYzMjhfR1JPVVAoZ3BpbzUpLAorCUJDTTYzMjhfR1JPVVAoZ3BpbzYpLAorCUJD TTYzMjhfR1JPVVAoZ3BpbzcpLAorCUJDTTYzMjhfR1JPVVAoZ3BpbzgpLAorCUJDTTYzMjhfR1JP VVAoZ3BpbzkpLAorCUJDTTYzMjhfR1JPVVAoZ3BpbzEwKSwKKwlCQ002MzI4X0dST1VQKGdwaW8x MSksCisJQkNNNjMyOF9HUk9VUChncGlvMTIpLAorCUJDTTYzMjhfR1JPVVAoZ3BpbzEzKSwKKwlC Q002MzI4X0dST1VQKGdwaW8xNCksCisJQkNNNjMyOF9HUk9VUChncGlvMTUpLAorCUJDTTYzMjhf R1JPVVAoZ3BpbzE2KSwKKwlCQ002MzI4X0dST1VQKGdwaW8xNyksCisJQkNNNjMyOF9HUk9VUChn cGlvMTgpLAorCUJDTTYzMjhfR1JPVVAoZ3BpbzE5KSwKKwlCQ002MzI4X0dST1VQKGdwaW8yMCks CisJQkNNNjMyOF9HUk9VUChncGlvMjEpLAorCUJDTTYzMjhfR1JPVVAoZ3BpbzIyKSwKKwlCQ002 MzI4X0dST1VQKGdwaW8yMyksCisJQkNNNjMyOF9HUk9VUChncGlvMjQpLAorCUJDTTYzMjhfR1JP VVAoZ3BpbzI1KSwKKwlCQ002MzI4X0dST1VQKGdwaW8yNiksCisJQkNNNjMyOF9HUk9VUChncGlv MjcpLAorCUJDTTYzMjhfR1JPVVAoZ3BpbzI4KSwKKwlCQ002MzI4X0dST1VQKGdwaW8yOSksCisJ QkNNNjMyOF9HUk9VUChncGlvMzApLAorCUJDTTYzMjhfR1JPVVAoZ3BpbzMxKSwKKworCUJDTTYz MjhfR1JPVVAoaHNzcGlfY3MxKSwKKwlCQ002MzI4X0dST1VQKHVzYl9wb3J0MSksCit9OworCisv KiBHUElPX01PREUgKi8KK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgbGVkX2dyb3Vwc1tdID0g eworCSJncGlvMCIsCisJImdwaW8xIiwKKwkiZ3BpbzIiLAorCSJncGlvMyIsCisJImdwaW80IiwK KwkiZ3BpbzUiLAorCSJncGlvNiIsCisJImdwaW83IiwKKwkiZ3BpbzgiLAorCSJncGlvOSIsCisJ ImdwaW8xMCIsCisJImdwaW8xMSIsCisJImdwaW8xMiIsCisJImdwaW8xMyIsCisJImdwaW8xNCIs CisJImdwaW8xNSIsCisJImdwaW8xNiIsCisJImdwaW8xNyIsCisJImdwaW8xOCIsCisJImdwaW8x OSIsCisJImdwaW8yMCIsCisJImdwaW8yMSIsCisJImdwaW8yMiIsCisJImdwaW8yMyIsCit9Owor CisvKiBQSU5NVVhfU0VMICovCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHNlcmlhbF9sZWRf ZGF0YV9ncm91cHNbXSA9IHsKKwkiZ3BpbzYiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBj b25zdCBzZXJpYWxfbGVkX2Nsa19ncm91cHNbXSA9IHsKKwkiZ3BpbzciLAorfTsKKworc3RhdGlj IGNvbnN0IGNoYXIgKiBjb25zdCBpbmV0X2FjdF9sZWRfZ3JvdXBzW10gPSB7CisJImdwaW8xMSIs Cit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHBjaWVfY2xrcmVxX2dyb3Vwc1tdID0g eworCSJncGlvMTYiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBlcGh5MF9hY3Rf bGVkX2dyb3Vwc1tdID0geworCSJncGlvMjUiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBj b25zdCBlcGh5MV9hY3RfbGVkX2dyb3Vwc1tdID0geworCSJncGlvMjYiLAorfTsKKworc3RhdGlj IGNvbnN0IGNoYXIgKiBjb25zdCBlcGh5Ml9hY3RfbGVkX2dyb3Vwc1tdID0geworCSJncGlvMjci LAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBlcGh5M19hY3RfbGVkX2dyb3Vwc1td ID0geworCSJncGlvMjgiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBoc3NwaV9j czFfZ3JvdXBzW10gPSB7CisJImhzc3BpX2NzMSIKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICog Y29uc3QgdXNiX2hvc3RfcG9ydF9ncm91cHNbXSA9IHsKKwkidXNiX3BvcnQxIiwKK307CisKK3N0 YXRpYyBjb25zdCBjaGFyICogY29uc3QgdXNiX2RldmljZV9wb3J0X2dyb3Vwc1tdID0geworCSJ1 c2JfcG9ydDEiLAorfTsKKworI2RlZmluZSBCQ002MzI4X01PREVfRlVOKG4pCQkJCVwKKwl7CQkJ CQkJXAorCQkubmFtZSA9ICNuLAkJCQlcCisJCS5ncm91cHMgPSBuIyNfZ3JvdXBzLAkJCVwKKwkJ Lm51bV9ncm91cHMgPSBBUlJBWV9TSVpFKG4jI19ncm91cHMpLAlcCisJCS5tb2RlX3ZhbCA9IDEs CQkJCVwKKwl9CisKKyNkZWZpbmUgQkNNNjMyOF9NVVhfRlVOKG4sIG11eCkJCQkJXAorCXsJCQkJ CQlcCisJCS5uYW1lID0gI24sCQkJCVwKKwkJLmdyb3VwcyA9IG4jI19ncm91cHMsCQkJXAorCQku bnVtX2dyb3VwcyA9IEFSUkFZX1NJWkUobiMjX2dyb3VwcyksCVwKKwkJLm11eF92YWwgPSBtdXgs CQkJCVwKKwl9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgYmNtNjMyOF9mdW5jdGlvbiBiY202MzI4 X2Z1bmNzW10gPSB7CisJQkNNNjMyOF9NT0RFX0ZVTihsZWQpLAorCUJDTTYzMjhfTVVYX0ZVTihz ZXJpYWxfbGVkX2RhdGEsIDIpLAorCUJDTTYzMjhfTVVYX0ZVTihzZXJpYWxfbGVkX2NsaywgMiks CisJQkNNNjMyOF9NVVhfRlVOKGluZXRfYWN0X2xlZCwgMSksCisJQkNNNjMyOF9NVVhfRlVOKHBj aWVfY2xrcmVxLCAyKSwKKwlCQ002MzI4X01VWF9GVU4oZXBoeTBfYWN0X2xlZCwgMSksCisJQkNN NjMyOF9NVVhfRlVOKGVwaHkxX2FjdF9sZWQsIDEpLAorCUJDTTYzMjhfTVVYX0ZVTihlcGh5Ml9h Y3RfbGVkLCAxKSwKKwlCQ002MzI4X01VWF9GVU4oZXBoeTNfYWN0X2xlZCwgMSksCisJQkNNNjMy OF9NVVhfRlVOKGhzc3BpX2NzMSwgMiksCisJQkNNNjMyOF9NVVhfRlVOKHVzYl9ob3N0X3BvcnQs IDEpLAorCUJDTTYzMjhfTVVYX0ZVTih1c2JfZGV2aWNlX3BvcnQsIDIpLAorfTsKKworc3RhdGlj IGlubGluZSB1bnNpZ25lZCBpbnQgYmNtNjMyOF9tdXhfb2ZmKHVuc2lnbmVkIGludCBwaW4pCit7 CisJcmV0dXJuIGJjbTYzMjhfbXV4W3BpbiAvIDE2XTsKK30KKworc3RhdGljIGludCBiY202MzI4 X3BpbmN0cmxfZ2V0X2dyb3VwX2NvdW50KHN0cnVjdCBwaW5jdHJsX2RldiAqcGN0bGRldikKK3sK KwlyZXR1cm4gQVJSQVlfU0laRShiY202MzI4X2dyb3Vwcyk7Cit9CisKK3N0YXRpYyBjb25zdCBj aGFyICpiY202MzI4X3BpbmN0cmxfZ2V0X2dyb3VwX25hbWUoc3RydWN0IHBpbmN0cmxfZGV2ICpw Y3RsZGV2LAorCQkJCQkJICB1bnNpZ25lZCBncm91cCkKK3sKKwlyZXR1cm4gYmNtNjMyOF9ncm91 cHNbZ3JvdXBdLm5hbWU7Cit9CisKK3N0YXRpYyBpbnQgYmNtNjMyOF9waW5jdHJsX2dldF9ncm91 cF9waW5zKHN0cnVjdCBwaW5jdHJsX2RldiAqcGN0bGRldiwKKwkJCQkJICB1bnNpZ25lZCBncm91 cCwgY29uc3QgdW5zaWduZWQgKipwaW5zLAorCQkJCQkgIHVuc2lnbmVkICpudW1fcGlucykKK3sK KwkqcGlucyA9IGJjbTYzMjhfZ3JvdXBzW2dyb3VwXS5waW5zOworCSpudW1fcGlucyA9IGJjbTYz MjhfZ3JvdXBzW2dyb3VwXS5udW1fcGluczsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50 IGJjbTYzMjhfcGluY3RybF9nZXRfZnVuY19jb3VudChzdHJ1Y3QgcGluY3RybF9kZXYgKnBjdGxk ZXYpCit7CisJcmV0dXJuIEFSUkFZX1NJWkUoYmNtNjMyOF9mdW5jcyk7Cit9CisKK3N0YXRpYyBj b25zdCBjaGFyICpiY202MzI4X3BpbmN0cmxfZ2V0X2Z1bmNfbmFtZShzdHJ1Y3QgcGluY3RybF9k ZXYgKnBjdGxkZXYsCisJCQkJCQkgdW5zaWduZWQgc2VsZWN0b3IpCit7CisJcmV0dXJuIGJjbTYz MjhfZnVuY3Nbc2VsZWN0b3JdLm5hbWU7Cit9CisKK3N0YXRpYyBpbnQgYmNtNjMyOF9waW5jdHJs X2dldF9ncm91cHMoc3RydWN0IHBpbmN0cmxfZGV2ICpwY3RsZGV2LAorCQkJCSAgICAgIHVuc2ln bmVkIHNlbGVjdG9yLAorCQkJCSAgICAgIGNvbnN0IGNoYXIgKiBjb25zdCAqKmdyb3VwcywKKwkJ CQkgICAgICB1bnNpZ25lZCAqIGNvbnN0IG51bV9ncm91cHMpCit7CisJKmdyb3VwcyA9IGJjbTYz MjhfZnVuY3Nbc2VsZWN0b3JdLmdyb3VwczsKKwkqbnVtX2dyb3VwcyA9IGJjbTYzMjhfZnVuY3Nb c2VsZWN0b3JdLm51bV9ncm91cHM7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHZvaWQgYmNt NjMyOF9ybXdfbXV4KHN0cnVjdCBiY202M3h4X3BpbmN0cmwgKnBjLCB1bnNpZ25lZCBwaW4sCisJ CQkgICAgdW5zaWduZWQgaW50IG1vZGUsIHVuc2lnbmVkIGludCBtdXgpCit7CisJaWYgKHBpbiA8 IEJDTTYzMjhfTlVNX0dQSU9TKQorCQlyZWdtYXBfdXBkYXRlX2JpdHMocGMtPnJlZ3MsIEJDTTYz MjhfTU9ERV9SRUcsIEJJVChwaW4pLAorCQkJCSAgIG1vZGUgPyBCSVQocGluKSA6IDApOworCisJ cmVnbWFwX3VwZGF0ZV9iaXRzKHBjLT5yZWdzLCBiY202MzI4X211eF9vZmYocGluKSwKKwkJCSAg IEJDTTYzMjhfTVVYX01BU0sgPDwgKChwaW4gJSAxNikgKiAyKSwKKwkJCSAgIG11eCA8PCAoKHBp biAlIDE2KSAqIDIpKTsKK30KKworc3RhdGljIGludCBiY202MzI4X3BpbmN0cmxfc2V0X211eChz dHJ1Y3QgcGluY3RybF9kZXYgKnBjdGxkZXYsCisJCQkJICAgdW5zaWduZWQgc2VsZWN0b3IsIHVu c2lnbmVkIGdyb3VwKQoreworCXN0cnVjdCBiY202M3h4X3BpbmN0cmwgKnBjID0gcGluY3RybF9k ZXZfZ2V0X2RydmRhdGEocGN0bGRldik7CisJY29uc3Qgc3RydWN0IGJjbTYzMjhfcGluZ3JvdXAg KnBnID0gJmJjbTYzMjhfZ3JvdXBzW2dyb3VwXTsKKwljb25zdCBzdHJ1Y3QgYmNtNjMyOF9mdW5j dGlvbiAqZiA9ICZiY202MzI4X2Z1bmNzW3NlbGVjdG9yXTsKKworCWJjbTYzMjhfcm13X211eChw YywgcGctPnBpbnNbMF0sIGYtPm1vZGVfdmFsLCBmLT5tdXhfdmFsKTsKKworCXJldHVybiAwOwor fQorCitzdGF0aWMgaW50IGJjbTYzMjhfZ3Bpb19yZXF1ZXN0X2VuYWJsZShzdHJ1Y3QgcGluY3Ry bF9kZXYgKnBjdGxkZXYsCisJCQkJICAgICAgIHN0cnVjdCBwaW5jdHJsX2dwaW9fcmFuZ2UgKnJh bmdlLAorCQkJCSAgICAgICB1bnNpZ25lZCBvZmZzZXQpCit7CisJc3RydWN0IGJjbTYzeHhfcGlu Y3RybCAqcGMgPSBwaW5jdHJsX2Rldl9nZXRfZHJ2ZGF0YShwY3RsZGV2KTsKKworCS8qIGRpc2Fi bGUgYWxsIGZ1bmN0aW9ucyB1c2luZyB0aGlzIHBpbiAqLworCWJjbTYzMjhfcm13X211eChwYywg b2Zmc2V0LCAwLCAwKTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgc3RydWN0IHBpbmN0cmxf b3BzIGJjbTYzMjhfcGN0bF9vcHMgPSB7CisJLmR0X2ZyZWVfbWFwID0gcGluY3RybF91dGlsc19m cmVlX21hcCwKKwkuZHRfbm9kZV90b19tYXAgPSBwaW5jb25mX2dlbmVyaWNfZHRfbm9kZV90b19t YXBfcGluLAorCS5nZXRfZ3JvdXBfbmFtZSA9IGJjbTYzMjhfcGluY3RybF9nZXRfZ3JvdXBfbmFt ZSwKKwkuZ2V0X2dyb3VwX3BpbnMgPSBiY202MzI4X3BpbmN0cmxfZ2V0X2dyb3VwX3BpbnMsCisJ LmdldF9ncm91cHNfY291bnQgPSBiY202MzI4X3BpbmN0cmxfZ2V0X2dyb3VwX2NvdW50LAorfTsK Kworc3RhdGljIHN0cnVjdCBwaW5tdXhfb3BzIGJjbTYzMjhfcG14X29wcyA9IHsKKwkuZ2V0X2Z1 bmN0aW9uX2dyb3VwcyA9IGJjbTYzMjhfcGluY3RybF9nZXRfZ3JvdXBzLAorCS5nZXRfZnVuY3Rp b25fbmFtZSA9IGJjbTYzMjhfcGluY3RybF9nZXRfZnVuY19uYW1lLAorCS5nZXRfZnVuY3Rpb25z X2NvdW50ID0gYmNtNjMyOF9waW5jdHJsX2dldF9mdW5jX2NvdW50LAorCS5ncGlvX3JlcXVlc3Rf ZW5hYmxlID0gYmNtNjMyOF9ncGlvX3JlcXVlc3RfZW5hYmxlLAorCS5zZXRfbXV4ID0gYmNtNjMy OF9waW5jdHJsX3NldF9tdXgsCisJLnN0cmljdCA9IHRydWUsCit9OworCitzdGF0aWMgY29uc3Qg c3RydWN0IGJjbTYzeHhfcGluY3RybF9zb2MgYmNtNjMyOF9zb2MgPSB7CisJLm5ncGlvcyA9IEJD TTYzMjhfTlVNX0dQSU9TLAorCS5ucGlucyA9IEFSUkFZX1NJWkUoYmNtNjMyOF9waW5zKSwKKwku cGN0bF9vcHMgPSAmYmNtNjMyOF9wY3RsX29wcywKKwkucGlucyA9IGJjbTYzMjhfcGlucywKKwku cG14X29wcyA9ICZiY202MzI4X3BteF9vcHMsCit9OworCitzdGF0aWMgaW50IGJjbTYzMjhfcGlu Y3RybF9wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQoreworCXJldHVybiBiY202 M3h4X3BpbmN0cmxfcHJvYmUocGRldiwgJmJjbTYzMjhfc29jLCBOVUxMKTsKK30KKworc3RhdGlj IGNvbnN0IHN0cnVjdCBvZl9kZXZpY2VfaWQgYmNtNjMyOF9waW5jdHJsX21hdGNoW10gPSB7CisJ eyAuY29tcGF0aWJsZSA9ICJicmNtLGJjbTYzMjgtcGluY3RybCIsIH0sCisJeyAvKiBzZW50aW5l bCAqLyB9Cit9OworCitzdGF0aWMgc3RydWN0IHBsYXRmb3JtX2RyaXZlciBiY202MzI4X3BpbmN0 cmxfZHJpdmVyID0geworCS5wcm9iZSA9IGJjbTYzMjhfcGluY3RybF9wcm9iZSwKKwkuZHJpdmVy ID0geworCQkubmFtZSA9ICJiY202MzI4LXBpbmN0cmwiLAorCQkub2ZfbWF0Y2hfdGFibGUgPSBi Y202MzI4X3BpbmN0cmxfbWF0Y2gsCisJfSwKK307CisKK2J1aWx0aW5fcGxhdGZvcm1fZHJpdmVy KGJjbTYzMjhfcGluY3RybF9kcml2ZXIpOwotLSAKMi4yMC4xCgoKX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX18KbGludXgtYXJtLWtlcm5lbCBtYWlsaW5nIGxp c3QKbGludXgtYXJtLWtlcm5lbEBsaXN0cy5pbmZyYWRlYWQub3JnCmh0dHA6Ly9saXN0cy5pbmZy YWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vbGludXgtYXJtLWtlcm5lbAo=