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 CC2A8C2BB9A for ; Mon, 15 Mar 2021 11:43:26 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id B4B4064ED2 for ; Mon, 15 Mar 2021 11:43:26 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230473AbhCOLnE (ORCPT ); Mon, 15 Mar 2021 07:43:04 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:43198 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229523AbhCOLmZ (ORCPT ); Mon, 15 Mar 2021 07:42:25 -0400 Received: from mail-wr1-x432.google.com (mail-wr1-x432.google.com [IPv6:2a00:1450:4864:20::432]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 5937BC061574; Mon, 15 Mar 2021 04:42:25 -0700 (PDT) Received: by mail-wr1-x432.google.com with SMTP id j18so5520535wra.2; Mon, 15 Mar 2021 04:42:25 -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=HapdoTE6GA2BDYZIWB7IpdygWH/oJ1iHlnpu/icVdRI=; b=pvssBeB3TdxZ2AbjGAqR4hg0qWb8yJvjs9E4WFaHFpnFuNuBAihNuSVML1YOpvuKwV aECo1MDHCTX5KCcWMWB0zFL+puD1atzuTL/u4S1CXVNoiTdNwd3ZWbvs6+5h71ztGxWq pFV+6tLnyk496TOwRGBLLmc5bhk1dNIDDfUIV2giAdWJEzeluDh7Kch7TfyOqN4q52Hp G1BZ2doiziUFlrWr5xfLQx3lf5nTBhemK7Z31NWvl+FO7pchRpFvY9QmVpxGT0ajNPS9 71kRlvMXXue5sMSxMVPC5UhDK0RyumHPpK2ie4qB7oykeOnr4R/pH8CG9q0GTpt2Ncyw HL2g== 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=HapdoTE6GA2BDYZIWB7IpdygWH/oJ1iHlnpu/icVdRI=; b=gjh3FXsgalB8oEUqlAITElHRF0y5hrqhigpI7jzz/MA1SNh5lGx6/hx6Gw/TKI66sG PqqpmgIhdAAhOdO6xujWsKJWmomwMFdcIy9PxU15oxZ4xnPhtiRSuforgq/jTlGSOE9R 1YCwwRsvBWNDDzIulsd8lbNBsqKdzBjw1s8ooNF8eOB/QvEEDQQeFHlR7T9vpsOoY48P u6eUXUHHFxOBj87XvviceV0/Cyji5lFTkmRJdQ9zJJspU7bvvydrw2GCfrP9txJ0qI7S ZyzcKTASmmz7Bf3r7i2VAaFFzyQNgzARfkC1ssJ0vMdLP0XD8dNz7a93ozueqX5LRRnz 58Qg== X-Gm-Message-State: AOAM533F7WDokzyAV9DIl81zu92Sk/GhdBaPss8ODattbN65Kk8m34ak 2DYBvTqeytWfZ2jpe/ied/I= X-Google-Smtp-Source: ABdhPJwadfGIAbyrZXAySTTpmmQ8Nyfth81YK3ZBDE87tcnEesvCYpSCqmEl4KvaCwoEIdRnFjFT7Q== X-Received: by 2002:a05:6000:ca:: with SMTP id q10mr26292491wrx.371.1615808543938; Mon, 15 Mar 2021 04:42:23 -0700 (PDT) Received: from skynet.lan ([80.31.204.166]) by smtp.gmail.com with ESMTPSA id v189sm12648187wme.39.2021.03.15.04.42.23 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 15 Mar 2021 04:42:23 -0700 (PDT) From: =?UTF-8?q?=C3=81lvaro=20Fern=C3=A1ndez=20Rojas?= To: Linus Walleij , Bartosz Golaszewski , Rob Herring , Florian Fainelli , bcm-kernel-feedback-list@broadcom.com, Lee Jones , Michael Walle , =?UTF-8?q?=C3=81lvaro=20Fern=C3=A1ndez=20Rojas?= , Jonas Gorski , Necip Fazil Yildiran , Andy Shevchenko , linux-gpio@vger.kernel.org, devicetree@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org Subject: [PATCH v7 07/22] pinctrl: add a pincontrol driver for BCM6328 Date: Mon, 15 Mar 2021 12:41:59 +0100 Message-Id: <20210315114214.3096-8-noltari@gmail.com> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20210315114214.3096-1-noltari@gmail.com> References: <20210315114214.3096-1-noltari@gmail.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Add a 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 --- 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,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 0DA87C433E0 for ; Mon, 15 Mar 2021 11:57:48 +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 D908B64E90 for ; Mon, 15 Mar 2021 11:57:46 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org D908B64E90 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=kZ2C7tIa1IWyymMip9MyURocUOJtqMpPePoDHMxNJuM=; b=g7QufLWWC/7bgPnC15YAz7raf GGzkzz5nhpUg5TEJfR1CoctZ6HLnhG+awl8Ij84uP0Q8ULCCIfTYn3v623kZIPC/bUf70wCjkY5Ra SS+eJtC5++K6VrGPbgEStAek19ZUsM77H0TMg3inxkcl194uCQBgWBdwwXkOsS2kzOCSjn2N+mSj/ B2cl/Dg07+uABWGoHFvfFEYQbwI+8Klv5D8unh35fFqB1i8chtF0U7Qq7R4nbRxv+mpmBA0ZN9msF mCh0+RBqyD7RoV08+aJJ4zYxoA8KWUz0QTOZLBjjYsukSll8VV8/CjuALWEkwyhKCHVnOcKSMXmSv kjBildhAg==; Received: from localhost ([::1] helo=desiato.infradead.org) by desiato.infradead.org with esmtp (Exim 4.94 #2 (Red Hat Linux)) id 1lLlmL-00FiYv-8a; Mon, 15 Mar 2021 11:53:15 +0000 Received: from mail-wr1-x432.google.com ([2a00:1450:4864:20::432]) by desiato.infradead.org with esmtps (Exim 4.94 #2 (Red Hat Linux)) id 1lLlc8-00Fgrk-RR for linux-arm-kernel@lists.infradead.org; Mon, 15 Mar 2021 11:42:55 +0000 Received: by mail-wr1-x432.google.com with SMTP id v15so8523351wrx.4 for ; Mon, 15 Mar 2021 04:42:24 -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=HapdoTE6GA2BDYZIWB7IpdygWH/oJ1iHlnpu/icVdRI=; b=pvssBeB3TdxZ2AbjGAqR4hg0qWb8yJvjs9E4WFaHFpnFuNuBAihNuSVML1YOpvuKwV aECo1MDHCTX5KCcWMWB0zFL+puD1atzuTL/u4S1CXVNoiTdNwd3ZWbvs6+5h71ztGxWq pFV+6tLnyk496TOwRGBLLmc5bhk1dNIDDfUIV2giAdWJEzeluDh7Kch7TfyOqN4q52Hp G1BZ2doiziUFlrWr5xfLQx3lf5nTBhemK7Z31NWvl+FO7pchRpFvY9QmVpxGT0ajNPS9 71kRlvMXXue5sMSxMVPC5UhDK0RyumHPpK2ie4qB7oykeOnr4R/pH8CG9q0GTpt2Ncyw HL2g== 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=HapdoTE6GA2BDYZIWB7IpdygWH/oJ1iHlnpu/icVdRI=; b=X38ff0e4w44NBVbDLO7lKkRw6yBKCw8U7IhY9Mz7TckSMIk/rBqPYbUW4Z38pferIL fhMdPUX8iludaroViEsVo2FmAC43PE5EYGMI0HdauewzAmD8c6dVZGS3J0vOJ4GS0GmH 4eBa8i6QYE8JtGb/MrpSLWSLw9UGYEXyrMq3LEQ448OsJO/CgQYdFSrTo2dv/4VmriVM stO4btDT2zfcQcOGh4stLwXsZ0JG3705dpJqpJItppH98+LqAth3xKoXM4sKLENQa8Rs 4lpbL3Lolb9SgmL/6pyMzcsPMpSmmxyBcVBQUvTly6sbDRkVrfifrq21b9C/3nDg7+lr TBcA== X-Gm-Message-State: AOAM532fuBQ+Y/7ivK4CZMkrfRo/luPRZeRuMceHYmMNr4X98hdmeLpH rwAbmlA9Xf5/uhnlG9BoF7M= X-Google-Smtp-Source: ABdhPJwadfGIAbyrZXAySTTpmmQ8Nyfth81YK3ZBDE87tcnEesvCYpSCqmEl4KvaCwoEIdRnFjFT7Q== X-Received: by 2002:a05:6000:ca:: with SMTP id q10mr26292491wrx.371.1615808543938; Mon, 15 Mar 2021 04:42:23 -0700 (PDT) Received: from skynet.lan ([80.31.204.166]) by smtp.gmail.com with ESMTPSA id v189sm12648187wme.39.2021.03.15.04.42.23 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 15 Mar 2021 04:42:23 -0700 (PDT) From: =?UTF-8?q?=C3=81lvaro=20Fern=C3=A1ndez=20Rojas?= To: Linus Walleij , Bartosz Golaszewski , Rob Herring , Florian Fainelli , bcm-kernel-feedback-list@broadcom.com, Lee Jones , Michael Walle , =?UTF-8?q?=C3=81lvaro=20Fern=C3=A1ndez=20Rojas?= , Jonas Gorski , Necip Fazil Yildiran , Andy Shevchenko , linux-gpio@vger.kernel.org, devicetree@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org Subject: [PATCH v7 07/22] pinctrl: add a pincontrol driver for BCM6328 Date: Mon, 15 Mar 2021 12:41:59 +0100 Message-Id: <20210315114214.3096-8-noltari@gmail.com> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20210315114214.3096-1-noltari@gmail.com> References: <20210315114214.3096-1-noltari@gmail.com> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20210315_114226_993780_5EB6D915 X-CRM114-Status: GOOD ( 23.23 ) 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 dmFybyBGZXJuw6FuZGV6IFJvamFzIDxub2x0YXJpQGdtYWlsLmNvbT4KLS0tCiB2Nzogbm8gY2hh bmdlcwogdjY6IG5vIGNoYW5nZXMKIHY1OiBhZGQgY2hhbmdlcyBzdWdnZXN0ZWQgYnkgQW5keSBT aGV2Y2hlbmtvCiB2NDogbm8gY2hhbmdlcwogdjM6IHVzZSBuZXcgc2hhcmVkIGNvZGUKIHYyOiBz d2l0Y2ggdG8gR1BJT19SRUdNQVAKCiBkcml2ZXJzL3BpbmN0cmwvYmNtL0tjb25maWcgICAgICAg ICAgIHwgICA4ICsKIGRyaXZlcnMvcGluY3RybC9iY20vTWFrZWZpbGUgICAgICAgICAgfCAgIDEg KwogZHJpdmVycy9waW5jdHJsL2JjbS9waW5jdHJsLWJjbTYzMjguYyB8IDQwNCArKysrKysrKysr KysrKysrKysrKysrKysrKwogMyBmaWxlcyBjaGFuZ2VkLCA0MTMgaW5zZXJ0aW9ucygrKQogY3Jl YXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvcGluY3RybC9iY20vcGluY3RybC1iY202MzI4LmMKCmRp ZmYgLS1naXQgYS9kcml2ZXJzL3BpbmN0cmwvYmNtL0tjb25maWcgYi9kcml2ZXJzL3BpbmN0cmwv YmNtL0tjb25maWcKaW5kZXggODgyZjE5YmRjMjQzLi5kMzVlNWQzZmUyNmYgMTAwNjQ0Ci0tLSBh L2RyaXZlcnMvcGluY3RybC9iY20vS2NvbmZpZworKysgYi9kcml2ZXJzL3BpbmN0cmwvYmNtL0tj b25maWcKQEAgLTM2LDYgKzM2LDE0IEBAIGNvbmZpZyBQSU5DVFJMX0JDTTYzWFgKIAlzZWxlY3Qg UElOQ09ORgogCXNlbGVjdCBQSU5NVVgKIAorY29uZmlnIFBJTkNUUkxfQkNNNjMyOAorCWJvb2wg IkJyb2FkY29tIEJDTTYzMjggR1BJTyBkcml2ZXIiCisJZGVwZW5kcyBvbiAoQk1JUFNfR0VORVJJ QyB8fCBDT01QSUxFX1RFU1QpCisJc2VsZWN0IFBJTkNUUkxfQkNNNjNYWAorCWRlZmF1bHQgQk1J UFNfR0VORVJJQworCWhlbHAKKwkgICBTYXkgWSBoZXJlIHRvIGVuYWJsZSB0aGUgQnJvYWRjb20g QkNNNjMyOCBHUElPIGRyaXZlci4KKwogY29uZmlnIFBJTkNUUkxfSVBST0NfR1BJTwogCWJvb2wg IkJyb2FkY29tIGlQcm9jIEdQSU8gKHdpdGggUElOQ09ORikgZHJpdmVyIgogCWRlcGVuZHMgb24g T0ZfR1BJTyAmJiAoQVJDSF9CQ01fSVBST0MgfHwgQ09NUElMRV9URVNUKQpkaWZmIC0tZ2l0IGEv ZHJpdmVycy9waW5jdHJsL2JjbS9NYWtlZmlsZSBiL2RyaXZlcnMvcGluY3RybC9iY20vTWFrZWZp bGUKaW5kZXggMGUzY2Y5YjE1YzY1Li41N2U1NDM0YTZkYjYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMv cGluY3RybC9iY20vTWFrZWZpbGUKKysrIGIvZHJpdmVycy9waW5jdHJsL2JjbS9NYWtlZmlsZQpA QCAtNCw2ICs0LDcgQEAKIG9iai0kKENPTkZJR19QSU5DVFJMX0JDTTI4MVhYKQkJKz0gcGluY3Ry bC1iY20yODF4eC5vCiBvYmotJChDT05GSUdfUElOQ1RSTF9CQ00yODM1KQkJKz0gcGluY3RybC1i Y20yODM1Lm8KIG9iai0kKENPTkZJR19QSU5DVFJMX0JDTTYzWFgpCQkrPSBwaW5jdHJsLWJjbTYz eHgubworb2JqLSQoQ09ORklHX1BJTkNUUkxfQkNNNjMyOCkJCSs9IHBpbmN0cmwtYmNtNjMyOC5v CiBvYmotJChDT05GSUdfUElOQ1RSTF9JUFJPQ19HUElPKQkrPSBwaW5jdHJsLWlwcm9jLWdwaW8u bwogb2JqLSQoQ09ORklHX1BJTkNUUkxfQ1lHTlVTX01VWCkJKz0gcGluY3RybC1jeWdudXMtbXV4 Lm8KIG9iai0kKENPTkZJR19QSU5DVFJMX05TKQkJKz0gcGluY3RybC1ucy5vCmRpZmYgLS1naXQg YS9kcml2ZXJzL3BpbmN0cmwvYmNtL3BpbmN0cmwtYmNtNjMyOC5jIGIvZHJpdmVycy9waW5jdHJs L2JjbS9waW5jdHJsLWJjbTYzMjguYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw MDAwMDAuLmM5ZWZjZTYwMDU1MAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvcGluY3RybC9i Y20vcGluY3RybC1iY202MzI4LmMKQEAgLTAsMCArMSw0MDQgQEAKKy8vIFNQRFgtTGljZW5zZS1J ZGVudGlmaWVyOiBHUEwtMi4wKworLyoKKyAqIERyaXZlciBmb3IgQkNNNjMyOCBHUElPIHVuaXQg KHBpbmN0cmwgKyBHUElPKQorICoKKyAqIENvcHlyaWdodCAoQykgMjAyMSDDgWx2YXJvIEZlcm7D oW5kZXogUm9qYXMgPG5vbHRhcmlAZ21haWwuY29tPgorICogQ29weXJpZ2h0IChDKSAyMDE2IEpv bmFzIEdvcnNraSA8am9uYXMuZ29yc2tpQGdtYWlsLmNvbT4KKyAqLworCisjaW5jbHVkZSA8bGlu dXgvYml0cy5oPgorI2luY2x1ZGUgPGxpbnV4L2dwaW8vZHJpdmVyLmg+CisjaW5jbHVkZSA8bGlu dXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgvb2YuaD4KKyNpbmNsdWRlIDxsaW51eC9waW5j dHJsL3Bpbm11eC5oPgorI2luY2x1ZGUgPGxpbnV4L3BsYXRmb3JtX2RldmljZS5oPgorI2luY2x1 ZGUgPGxpbnV4L3JlZ21hcC5oPgorCisjaW5jbHVkZSAiLi4vcGluY3RybC11dGlscy5oIgorCisj aW5jbHVkZSAicGluY3RybC1iY202M3h4LmgiCisKKyNkZWZpbmUgQkNNNjMyOF9OVU1fR1BJT1MJ MzIKKworI2RlZmluZSBCQ002MzI4X01PREVfUkVHCTB4MTgKKyNkZWZpbmUgQkNNNjMyOF9NVVhf SElfUkVHCTB4MWMKKyNkZWZpbmUgQkNNNjMyOF9NVVhfTE9fUkVHCTB4MjAKKyNkZWZpbmUgQkNN NjMyOF9NVVhfT1RIRVJfUkVHCTB4MjQKKyNkZWZpbmUgIEJDTTYzMjhfTVVYX01BU0sJR0VOTUFT SygxLCAwKQorCitzdHJ1Y3QgYmNtNjMyOF9waW5ncm91cCB7CisJY29uc3QgY2hhciAqbmFtZTsK Kwljb25zdCB1bnNpZ25lZCAqIGNvbnN0IHBpbnM7CisJY29uc3QgdW5zaWduZWQgbnVtX3BpbnM7 Cit9OworCitzdHJ1Y3QgYmNtNjMyOF9mdW5jdGlvbiB7CisJY29uc3QgY2hhciAqbmFtZTsKKwlj b25zdCBjaGFyICogY29uc3QgKmdyb3VwczsKKwljb25zdCB1bnNpZ25lZCBudW1fZ3JvdXBzOwor CisJdW5zaWduZWQgbW9kZV92YWw6MTsKKwl1bnNpZ25lZCBtdXhfdmFsOjI7Cit9OworCitzdGF0 aWMgY29uc3QgdW5zaWduZWQgaW50IGJjbTYzMjhfbXV4W10gPSB7CisJQkNNNjMyOF9NVVhfTE9f UkVHLAorCUJDTTYzMjhfTVVYX0hJX1JFRywKKwlCQ002MzI4X01VWF9PVEhFUl9SRUcKK307CisK K3N0YXRpYyBjb25zdCBzdHJ1Y3QgcGluY3RybF9waW5fZGVzYyBiY202MzI4X3BpbnNbXSA9IHsK KwlQSU5DVFJMX1BJTigwLCAiZ3BpbzAiKSwKKwlQSU5DVFJMX1BJTigxLCAiZ3BpbzEiKSwKKwlQ SU5DVFJMX1BJTigyLCAiZ3BpbzIiKSwKKwlQSU5DVFJMX1BJTigzLCAiZ3BpbzMiKSwKKwlQSU5D VFJMX1BJTig0LCAiZ3BpbzQiKSwKKwlQSU5DVFJMX1BJTig1LCAiZ3BpbzUiKSwKKwlQSU5DVFJM X1BJTig2LCAiZ3BpbzYiKSwKKwlQSU5DVFJMX1BJTig3LCAiZ3BpbzciKSwKKwlQSU5DVFJMX1BJ Tig4LCAiZ3BpbzgiKSwKKwlQSU5DVFJMX1BJTig5LCAiZ3BpbzkiKSwKKwlQSU5DVFJMX1BJTigx MCwgImdwaW8xMCIpLAorCVBJTkNUUkxfUElOKDExLCAiZ3BpbzExIiksCisJUElOQ1RSTF9QSU4o MTIsICJncGlvMTIiKSwKKwlQSU5DVFJMX1BJTigxMywgImdwaW8xMyIpLAorCVBJTkNUUkxfUElO KDE0LCAiZ3BpbzE0IiksCisJUElOQ1RSTF9QSU4oMTUsICJncGlvMTUiKSwKKwlQSU5DVFJMX1BJ TigxNiwgImdwaW8xNiIpLAorCVBJTkNUUkxfUElOKDE3LCAiZ3BpbzE3IiksCisJUElOQ1RSTF9Q SU4oMTgsICJncGlvMTgiKSwKKwlQSU5DVFJMX1BJTigxOSwgImdwaW8xOSIpLAorCVBJTkNUUkxf UElOKDIwLCAiZ3BpbzIwIiksCisJUElOQ1RSTF9QSU4oMjEsICJncGlvMjEiKSwKKwlQSU5DVFJM X1BJTigyMiwgImdwaW8yMiIpLAorCVBJTkNUUkxfUElOKDIzLCAiZ3BpbzIzIiksCisJUElOQ1RS TF9QSU4oMjQsICJncGlvMjQiKSwKKwlQSU5DVFJMX1BJTigyNSwgImdwaW8yNSIpLAorCVBJTkNU UkxfUElOKDI2LCAiZ3BpbzI2IiksCisJUElOQ1RSTF9QSU4oMjcsICJncGlvMjciKSwKKwlQSU5D VFJMX1BJTigyOCwgImdwaW8yOCIpLAorCVBJTkNUUkxfUElOKDI5LCAiZ3BpbzI5IiksCisJUElO Q1RSTF9QSU4oMzAsICJncGlvMzAiKSwKKwlQSU5DVFJMX1BJTigzMSwgImdwaW8zMSIpLAorCisJ LyoKKwkgKiBObyBpZGVhIHdoZXJlIHRoZXkgcmVhbGx5IGFyZTsgc28gbGV0J3MgcHV0IHRoZW0g YWNjb3JkaW5nCisJICogdG8gdGhlaXIgbXV4IG9mZnNldHMuCisJICovCisJUElOQ1RSTF9QSU4o MzYsICJoc3NwaV9jczEiKSwKKwlQSU5DVFJMX1BJTigzOCwgInVzYl9wMiIpLAorfTsKKworc3Rh dGljIHVuc2lnbmVkIGdwaW8wX3BpbnNbXSA9IHsgMCB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8x X3BpbnNbXSA9IHsgMSB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8yX3BpbnNbXSA9IHsgMiB9Owor c3RhdGljIHVuc2lnbmVkIGdwaW8zX3BpbnNbXSA9IHsgMyB9Oworc3RhdGljIHVuc2lnbmVkIGdw aW80X3BpbnNbXSA9IHsgNCB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW81X3BpbnNbXSA9IHsgNSB9 Oworc3RhdGljIHVuc2lnbmVkIGdwaW82X3BpbnNbXSA9IHsgNiB9Oworc3RhdGljIHVuc2lnbmVk IGdwaW83X3BpbnNbXSA9IHsgNyB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW84X3BpbnNbXSA9IHsg OCB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW85X3BpbnNbXSA9IHsgOSB9Oworc3RhdGljIHVuc2ln bmVkIGdwaW8xMF9waW5zW10gPSB7IDEwIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzExX3BpbnNb XSA9IHsgMTEgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMTJfcGluc1tdID0geyAxMiB9Oworc3Rh dGljIHVuc2lnbmVkIGdwaW8xM19waW5zW10gPSB7IDEzIH07CitzdGF0aWMgdW5zaWduZWQgZ3Bp bzE0X3BpbnNbXSA9IHsgMTQgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMTVfcGluc1tdID0geyAx NSB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8xNl9waW5zW10gPSB7IDE2IH07CitzdGF0aWMgdW5z aWduZWQgZ3BpbzE3X3BpbnNbXSA9IHsgMTcgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMThfcGlu c1tdID0geyAxOCB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8xOV9waW5zW10gPSB7IDE5IH07Citz dGF0aWMgdW5zaWduZWQgZ3BpbzIwX3BpbnNbXSA9IHsgMjAgfTsKK3N0YXRpYyB1bnNpZ25lZCBn cGlvMjFfcGluc1tdID0geyAyMSB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8yMl9waW5zW10gPSB7 IDIyIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzIzX3BpbnNbXSA9IHsgMjMgfTsKK3N0YXRpYyB1 bnNpZ25lZCBncGlvMjRfcGluc1tdID0geyAyNCB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8yNV9w aW5zW10gPSB7IDI1IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzI2X3BpbnNbXSA9IHsgMjYgfTsK K3N0YXRpYyB1bnNpZ25lZCBncGlvMjdfcGluc1tdID0geyAyNyB9Oworc3RhdGljIHVuc2lnbmVk IGdwaW8yOF9waW5zW10gPSB7IDI4IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzI5X3BpbnNbXSA9 IHsgMjkgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMzBfcGluc1tdID0geyAzMCB9Oworc3RhdGlj IHVuc2lnbmVkIGdwaW8zMV9waW5zW10gPSB7IDMxIH07CisKK3N0YXRpYyB1bnNpZ25lZCBoc3Nw aV9jczFfcGluc1tdID0geyAzNiB9Oworc3RhdGljIHVuc2lnbmVkIHVzYl9wb3J0MV9waW5zW10g PSB7IDM4IH07CisKKyNkZWZpbmUgQkNNNjMyOF9HUk9VUChuKQkJCQkJXAorCXsJCQkJCQkJXAor CQkubmFtZSA9ICNuLAkJCQkJXAorCQkucGlucyA9IG4jI19waW5zLAkJCQlcCisJCS5udW1fcGlu cyA9IEFSUkFZX1NJWkUobiMjX3BpbnMpLAkJXAorCX0KKworc3RhdGljIHN0cnVjdCBiY202MzI4 X3Bpbmdyb3VwIGJjbTYzMjhfZ3JvdXBzW10gPSB7CisJQkNNNjMyOF9HUk9VUChncGlvMCksCisJ QkNNNjMyOF9HUk9VUChncGlvMSksCisJQkNNNjMyOF9HUk9VUChncGlvMiksCisJQkNNNjMyOF9H Uk9VUChncGlvMyksCisJQkNNNjMyOF9HUk9VUChncGlvNCksCisJQkNNNjMyOF9HUk9VUChncGlv NSksCisJQkNNNjMyOF9HUk9VUChncGlvNiksCisJQkNNNjMyOF9HUk9VUChncGlvNyksCisJQkNN NjMyOF9HUk9VUChncGlvOCksCisJQkNNNjMyOF9HUk9VUChncGlvOSksCisJQkNNNjMyOF9HUk9V UChncGlvMTApLAorCUJDTTYzMjhfR1JPVVAoZ3BpbzExKSwKKwlCQ002MzI4X0dST1VQKGdwaW8x MiksCisJQkNNNjMyOF9HUk9VUChncGlvMTMpLAorCUJDTTYzMjhfR1JPVVAoZ3BpbzE0KSwKKwlC Q002MzI4X0dST1VQKGdwaW8xNSksCisJQkNNNjMyOF9HUk9VUChncGlvMTYpLAorCUJDTTYzMjhf R1JPVVAoZ3BpbzE3KSwKKwlCQ002MzI4X0dST1VQKGdwaW8xOCksCisJQkNNNjMyOF9HUk9VUChn cGlvMTkpLAorCUJDTTYzMjhfR1JPVVAoZ3BpbzIwKSwKKwlCQ002MzI4X0dST1VQKGdwaW8yMSks CisJQkNNNjMyOF9HUk9VUChncGlvMjIpLAorCUJDTTYzMjhfR1JPVVAoZ3BpbzIzKSwKKwlCQ002 MzI4X0dST1VQKGdwaW8yNCksCisJQkNNNjMyOF9HUk9VUChncGlvMjUpLAorCUJDTTYzMjhfR1JP VVAoZ3BpbzI2KSwKKwlCQ002MzI4X0dST1VQKGdwaW8yNyksCisJQkNNNjMyOF9HUk9VUChncGlv MjgpLAorCUJDTTYzMjhfR1JPVVAoZ3BpbzI5KSwKKwlCQ002MzI4X0dST1VQKGdwaW8zMCksCisJ QkNNNjMyOF9HUk9VUChncGlvMzEpLAorCisJQkNNNjMyOF9HUk9VUChoc3NwaV9jczEpLAorCUJD TTYzMjhfR1JPVVAodXNiX3BvcnQxKSwKK307CisKKy8qIEdQSU9fTU9ERSAqLworc3RhdGljIGNv bnN0IGNoYXIgKiBjb25zdCBsZWRfZ3JvdXBzW10gPSB7CisJImdwaW8wIiwKKwkiZ3BpbzEiLAor CSJncGlvMiIsCisJImdwaW8zIiwKKwkiZ3BpbzQiLAorCSJncGlvNSIsCisJImdwaW82IiwKKwki Z3BpbzciLAorCSJncGlvOCIsCisJImdwaW85IiwKKwkiZ3BpbzEwIiwKKwkiZ3BpbzExIiwKKwki Z3BpbzEyIiwKKwkiZ3BpbzEzIiwKKwkiZ3BpbzE0IiwKKwkiZ3BpbzE1IiwKKwkiZ3BpbzE2IiwK KwkiZ3BpbzE3IiwKKwkiZ3BpbzE4IiwKKwkiZ3BpbzE5IiwKKwkiZ3BpbzIwIiwKKwkiZ3BpbzIx IiwKKwkiZ3BpbzIyIiwKKwkiZ3BpbzIzIiwKK307CisKKy8qIFBJTk1VWF9TRUwgKi8KK3N0YXRp YyBjb25zdCBjaGFyICogY29uc3Qgc2VyaWFsX2xlZF9kYXRhX2dyb3Vwc1tdID0geworCSJncGlv NiIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHNlcmlhbF9sZWRfY2xrX2dyb3Vw c1tdID0geworCSJncGlvNyIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGluZXRf YWN0X2xlZF9ncm91cHNbXSA9IHsKKwkiZ3BpbzExIiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFy ICogY29uc3QgcGNpZV9jbGtyZXFfZ3JvdXBzW10gPSB7CisJImdwaW8xNiIsCit9OworCitzdGF0 aWMgY29uc3QgY2hhciAqIGNvbnN0IGVwaHkwX2FjdF9sZWRfZ3JvdXBzW10gPSB7CisJImdwaW8y NSIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGVwaHkxX2FjdF9sZWRfZ3JvdXBz W10gPSB7CisJImdwaW8yNiIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGVwaHky X2FjdF9sZWRfZ3JvdXBzW10gPSB7CisJImdwaW8yNyIsCit9OworCitzdGF0aWMgY29uc3QgY2hh ciAqIGNvbnN0IGVwaHkzX2FjdF9sZWRfZ3JvdXBzW10gPSB7CisJImdwaW8yOCIsCit9OworCitz dGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGhzc3BpX2NzMV9ncm91cHNbXSA9IHsKKwkiaHNzcGlf Y3MxIgorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCB1c2JfaG9zdF9wb3J0X2dyb3Vw c1tdID0geworCSJ1c2JfcG9ydDEiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCB1 c2JfZGV2aWNlX3BvcnRfZ3JvdXBzW10gPSB7CisJInVzYl9wb3J0MSIsCit9OworCisjZGVmaW5l IEJDTTYzMjhfTU9ERV9GVU4obikJCQkJXAorCXsJCQkJCQlcCisJCS5uYW1lID0gI24sCQkJCVwK KwkJLmdyb3VwcyA9IG4jI19ncm91cHMsCQkJXAorCQkubnVtX2dyb3VwcyA9IEFSUkFZX1NJWkUo biMjX2dyb3VwcyksCVwKKwkJLm1vZGVfdmFsID0gMSwJCQkJXAorCX0KKworI2RlZmluZSBCQ002 MzI4X01VWF9GVU4obiwgbXV4KQkJCQlcCisJewkJCQkJCVwKKwkJLm5hbWUgPSAjbiwJCQkJXAor CQkuZ3JvdXBzID0gbiMjX2dyb3VwcywJCQlcCisJCS5udW1fZ3JvdXBzID0gQVJSQVlfU0laRShu IyNfZ3JvdXBzKSwJXAorCQkubXV4X3ZhbCA9IG11eCwJCQkJXAorCX0KKworc3RhdGljIGNvbnN0 IHN0cnVjdCBiY202MzI4X2Z1bmN0aW9uIGJjbTYzMjhfZnVuY3NbXSA9IHsKKwlCQ002MzI4X01P REVfRlVOKGxlZCksCisJQkNNNjMyOF9NVVhfRlVOKHNlcmlhbF9sZWRfZGF0YSwgMiksCisJQkNN NjMyOF9NVVhfRlVOKHNlcmlhbF9sZWRfY2xrLCAyKSwKKwlCQ002MzI4X01VWF9GVU4oaW5ldF9h Y3RfbGVkLCAxKSwKKwlCQ002MzI4X01VWF9GVU4ocGNpZV9jbGtyZXEsIDIpLAorCUJDTTYzMjhf TVVYX0ZVTihlcGh5MF9hY3RfbGVkLCAxKSwKKwlCQ002MzI4X01VWF9GVU4oZXBoeTFfYWN0X2xl ZCwgMSksCisJQkNNNjMyOF9NVVhfRlVOKGVwaHkyX2FjdF9sZWQsIDEpLAorCUJDTTYzMjhfTVVY X0ZVTihlcGh5M19hY3RfbGVkLCAxKSwKKwlCQ002MzI4X01VWF9GVU4oaHNzcGlfY3MxLCAyKSwK KwlCQ002MzI4X01VWF9GVU4odXNiX2hvc3RfcG9ydCwgMSksCisJQkNNNjMyOF9NVVhfRlVOKHVz Yl9kZXZpY2VfcG9ydCwgMiksCit9OworCitzdGF0aWMgaW5saW5lIHVuc2lnbmVkIGludCBiY202 MzI4X211eF9vZmYodW5zaWduZWQgaW50IHBpbikKK3sKKwlyZXR1cm4gYmNtNjMyOF9tdXhbcGlu IC8gMTZdOworfQorCitzdGF0aWMgaW50IGJjbTYzMjhfcGluY3RybF9nZXRfZ3JvdXBfY291bnQo c3RydWN0IHBpbmN0cmxfZGV2ICpwY3RsZGV2KQoreworCXJldHVybiBBUlJBWV9TSVpFKGJjbTYz MjhfZ3JvdXBzKTsKK30KKworc3RhdGljIGNvbnN0IGNoYXIgKmJjbTYzMjhfcGluY3RybF9nZXRf Z3JvdXBfbmFtZShzdHJ1Y3QgcGluY3RybF9kZXYgKnBjdGxkZXYsCisJCQkJCQkgIHVuc2lnbmVk IGdyb3VwKQoreworCXJldHVybiBiY202MzI4X2dyb3Vwc1tncm91cF0ubmFtZTsKK30KKworc3Rh dGljIGludCBiY202MzI4X3BpbmN0cmxfZ2V0X2dyb3VwX3BpbnMoc3RydWN0IHBpbmN0cmxfZGV2 ICpwY3RsZGV2LAorCQkJCQkgIHVuc2lnbmVkIGdyb3VwLCBjb25zdCB1bnNpZ25lZCAqKnBpbnMs CisJCQkJCSAgdW5zaWduZWQgKm51bV9waW5zKQoreworCSpwaW5zID0gYmNtNjMyOF9ncm91cHNb Z3JvdXBdLnBpbnM7CisJKm51bV9waW5zID0gYmNtNjMyOF9ncm91cHNbZ3JvdXBdLm51bV9waW5z OworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgYmNtNjMyOF9waW5jdHJsX2dldF9mdW5j X2NvdW50KHN0cnVjdCBwaW5jdHJsX2RldiAqcGN0bGRldikKK3sKKwlyZXR1cm4gQVJSQVlfU0la RShiY202MzI4X2Z1bmNzKTsKK30KKworc3RhdGljIGNvbnN0IGNoYXIgKmJjbTYzMjhfcGluY3Ry bF9nZXRfZnVuY19uYW1lKHN0cnVjdCBwaW5jdHJsX2RldiAqcGN0bGRldiwKKwkJCQkJCSB1bnNp Z25lZCBzZWxlY3RvcikKK3sKKwlyZXR1cm4gYmNtNjMyOF9mdW5jc1tzZWxlY3Rvcl0ubmFtZTsK K30KKworc3RhdGljIGludCBiY202MzI4X3BpbmN0cmxfZ2V0X2dyb3VwcyhzdHJ1Y3QgcGluY3Ry bF9kZXYgKnBjdGxkZXYsCisJCQkJICAgICAgdW5zaWduZWQgc2VsZWN0b3IsCisJCQkJICAgICAg Y29uc3QgY2hhciAqIGNvbnN0ICoqZ3JvdXBzLAorCQkJCSAgICAgIHVuc2lnbmVkICogY29uc3Qg bnVtX2dyb3VwcykKK3sKKwkqZ3JvdXBzID0gYmNtNjMyOF9mdW5jc1tzZWxlY3Rvcl0uZ3JvdXBz OworCSpudW1fZ3JvdXBzID0gYmNtNjMyOF9mdW5jc1tzZWxlY3Rvcl0ubnVtX2dyb3VwczsKKwor CXJldHVybiAwOworfQorCitzdGF0aWMgdm9pZCBiY202MzI4X3Jtd19tdXgoc3RydWN0IGJjbTYz eHhfcGluY3RybCAqcGMsIHVuc2lnbmVkIHBpbiwKKwkJCSAgICB1bnNpZ25lZCBpbnQgbW9kZSwg dW5zaWduZWQgaW50IG11eCkKK3sKKwlpZiAocGluIDwgQkNNNjMyOF9OVU1fR1BJT1MpCisJCXJl Z21hcF91cGRhdGVfYml0cyhwYy0+cmVncywgQkNNNjMyOF9NT0RFX1JFRywgQklUKHBpbiksCisJ CQkJICAgbW9kZSA/IEJJVChwaW4pIDogMCk7CisKKwlyZWdtYXBfdXBkYXRlX2JpdHMocGMtPnJl Z3MsIGJjbTYzMjhfbXV4X29mZihwaW4pLAorCQkJICAgQkNNNjMyOF9NVVhfTUFTSyA8PCAoKHBp biAlIDE2KSAqIDIpLAorCQkJICAgbXV4IDw8ICgocGluICUgMTYpICogMikpOworfQorCitzdGF0 aWMgaW50IGJjbTYzMjhfcGluY3RybF9zZXRfbXV4KHN0cnVjdCBwaW5jdHJsX2RldiAqcGN0bGRl diwKKwkJCQkgICB1bnNpZ25lZCBzZWxlY3RvciwgdW5zaWduZWQgZ3JvdXApCit7CisJc3RydWN0 IGJjbTYzeHhfcGluY3RybCAqcGMgPSBwaW5jdHJsX2Rldl9nZXRfZHJ2ZGF0YShwY3RsZGV2KTsK Kwljb25zdCBzdHJ1Y3QgYmNtNjMyOF9waW5ncm91cCAqcGcgPSAmYmNtNjMyOF9ncm91cHNbZ3Jv dXBdOworCWNvbnN0IHN0cnVjdCBiY202MzI4X2Z1bmN0aW9uICpmID0gJmJjbTYzMjhfZnVuY3Nb c2VsZWN0b3JdOworCisJYmNtNjMyOF9ybXdfbXV4KHBjLCBwZy0+cGluc1swXSwgZi0+bW9kZV92 YWwsIGYtPm11eF92YWwpOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgYmNtNjMyOF9n cGlvX3JlcXVlc3RfZW5hYmxlKHN0cnVjdCBwaW5jdHJsX2RldiAqcGN0bGRldiwKKwkJCQkgICAg ICAgc3RydWN0IHBpbmN0cmxfZ3Bpb19yYW5nZSAqcmFuZ2UsCisJCQkJICAgICAgIHVuc2lnbmVk IG9mZnNldCkKK3sKKwlzdHJ1Y3QgYmNtNjN4eF9waW5jdHJsICpwYyA9IHBpbmN0cmxfZGV2X2dl dF9kcnZkYXRhKHBjdGxkZXYpOworCisJLyogZGlzYWJsZSBhbGwgZnVuY3Rpb25zIHVzaW5nIHRo aXMgcGluICovCisJYmNtNjMyOF9ybXdfbXV4KHBjLCBvZmZzZXQsIDAsIDApOworCisJcmV0dXJu IDA7Cit9CisKK3N0YXRpYyBzdHJ1Y3QgcGluY3RybF9vcHMgYmNtNjMyOF9wY3RsX29wcyA9IHsK KwkuZHRfZnJlZV9tYXAgPSBwaW5jdHJsX3V0aWxzX2ZyZWVfbWFwLAorCS5kdF9ub2RlX3RvX21h cCA9IHBpbmNvbmZfZ2VuZXJpY19kdF9ub2RlX3RvX21hcF9waW4sCisJLmdldF9ncm91cF9uYW1l ID0gYmNtNjMyOF9waW5jdHJsX2dldF9ncm91cF9uYW1lLAorCS5nZXRfZ3JvdXBfcGlucyA9IGJj bTYzMjhfcGluY3RybF9nZXRfZ3JvdXBfcGlucywKKwkuZ2V0X2dyb3Vwc19jb3VudCA9IGJjbTYz MjhfcGluY3RybF9nZXRfZ3JvdXBfY291bnQsCit9OworCitzdGF0aWMgc3RydWN0IHBpbm11eF9v cHMgYmNtNjMyOF9wbXhfb3BzID0geworCS5nZXRfZnVuY3Rpb25fZ3JvdXBzID0gYmNtNjMyOF9w aW5jdHJsX2dldF9ncm91cHMsCisJLmdldF9mdW5jdGlvbl9uYW1lID0gYmNtNjMyOF9waW5jdHJs X2dldF9mdW5jX25hbWUsCisJLmdldF9mdW5jdGlvbnNfY291bnQgPSBiY202MzI4X3BpbmN0cmxf Z2V0X2Z1bmNfY291bnQsCisJLmdwaW9fcmVxdWVzdF9lbmFibGUgPSBiY202MzI4X2dwaW9fcmVx dWVzdF9lbmFibGUsCisJLnNldF9tdXggPSBiY202MzI4X3BpbmN0cmxfc2V0X211eCwKKwkuc3Ry aWN0ID0gdHJ1ZSwKK307CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgYmNtNjN4eF9waW5jdHJsX3Nv YyBiY202MzI4X3NvYyA9IHsKKwkubmdwaW9zID0gQkNNNjMyOF9OVU1fR1BJT1MsCisJLm5waW5z ID0gQVJSQVlfU0laRShiY202MzI4X3BpbnMpLAorCS5wY3RsX29wcyA9ICZiY202MzI4X3BjdGxf b3BzLAorCS5waW5zID0gYmNtNjMyOF9waW5zLAorCS5wbXhfb3BzID0gJmJjbTYzMjhfcG14X29w cywKK307CisKK3N0YXRpYyBpbnQgYmNtNjMyOF9waW5jdHJsX3Byb2JlKHN0cnVjdCBwbGF0Zm9y bV9kZXZpY2UgKnBkZXYpCit7CisJcmV0dXJuIGJjbTYzeHhfcGluY3RybF9wcm9iZShwZGV2LCAm YmNtNjMyOF9zb2MsIE5VTEwpOworfQorCitzdGF0aWMgY29uc3Qgc3RydWN0IG9mX2RldmljZV9p ZCBiY202MzI4X3BpbmN0cmxfbWF0Y2hbXSA9IHsKKwl7IC5jb21wYXRpYmxlID0gImJyY20sYmNt NjMyOC1waW5jdHJsIiwgfSwKKwl7IC8qIHNlbnRpbmVsICovIH0KK307CisKK3N0YXRpYyBzdHJ1 Y3QgcGxhdGZvcm1fZHJpdmVyIGJjbTYzMjhfcGluY3RybF9kcml2ZXIgPSB7CisJLnByb2JlID0g YmNtNjMyOF9waW5jdHJsX3Byb2JlLAorCS5kcml2ZXIgPSB7CisJCS5uYW1lID0gImJjbTYzMjgt cGluY3RybCIsCisJCS5vZl9tYXRjaF90YWJsZSA9IGJjbTYzMjhfcGluY3RybF9tYXRjaCwKKwl9 LAorfTsKKworYnVpbHRpbl9wbGF0Zm9ybV9kcml2ZXIoYmNtNjMyOF9waW5jdHJsX2RyaXZlcik7 Ci0tIAoyLjIwLjEKCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fXwpsaW51eC1hcm0ta2VybmVsIG1haWxpbmcgbGlzdApsaW51eC1hcm0ta2VybmVsQGxpc3Rz LmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5m by9saW51eC1hcm0ta2VybmVsCg==