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 E4AB2C433E1 for ; Wed, 24 Mar 2021 08:20:53 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 9FB1A61A0D for ; Wed, 24 Mar 2021 08:20:53 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S236139AbhCXIUZ (ORCPT ); Wed, 24 Mar 2021 04:20:25 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:54070 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S236044AbhCXITu (ORCPT ); Wed, 24 Mar 2021 04:19:50 -0400 Received: from mail-wm1-x330.google.com (mail-wm1-x330.google.com [IPv6:2a00:1450:4864:20::330]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 3B6B1C061763; Wed, 24 Mar 2021 01:19:49 -0700 (PDT) Received: by mail-wm1-x330.google.com with SMTP id b2-20020a7bc2420000b029010be1081172so660754wmj.1; Wed, 24 Mar 2021 01:19:49 -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=wLlJZoOJRqGcNn638bEGDVMd9eW3ekMwGm75enWvQ1U=; b=QBcDlCdO3jrtL1WUl+6Tf4fM47afkaBsXGMfVaC9fOP5BC81uwUMXRL5JNxoR79KfF A3gqZGkspgPG5KPe73iTH8MtpnesMsSw9w9kF2gcHdh72PopNUJQhYZtn0wMCXFTbwNp tcDj6fEs18Usm1cixh1BBdOu8vsZhNNsvDF/q+GfUuX6JWAPRH7MCzhWplhjnU3Ho3Yl K5h0nvgtqX21k92STs7RD/jtolUqnpJhUq40sQY/ipIdpwK/1W3FWPY37WQ0WVtMxuXS pbBc0b5U4PB9wsPsQ0mKHcbuZKXEcFl+30bQGJiWebM6HaBvzbU0EvY3XlrUAoSfyOwO Gx2g== 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=wLlJZoOJRqGcNn638bEGDVMd9eW3ekMwGm75enWvQ1U=; b=LY1IGNEyN7Zxbb0NE5mq1ibnpIYVD4hWqeLzW5BDeyhyCJMiotonXPUr7iK7fy/21U avbWWfJjxtWZQhGZ2t7iPrKbphp27mbfAJtwCj9Q3Y6JZ27ZF/Xr01d81OiYGM1yOmIL BklWVT3J2H9E2CI90z5cVu6jiCfPjfHI9K/bPmdsryee5k+fLL85UuCHxNbCt4d6sXC6 iMw19Aun5MDmj4OSICP0IaoSqKmBdWWyaW65w7ik0w1FqyqwzSUb8wXwT9LpvjCggWtD yCvf6CLxg7/xeT7OH/NyMoKMYk6E+bVvyNamW5FNulrrpV4mAKKkJ14cEE418UKHh/mL 3Axg== X-Gm-Message-State: AOAM530wozLHTC+d9dn3fXr3uJbzUzAArnR1AlcE92+pp+WI/LQwrILI CxqahJJ+kaQLDEmrEuZsjnQSFhaqwmslyQ== X-Google-Smtp-Source: ABdhPJw/bjdhsRPLNczByNceP88+N6VQHVxDJHUaBrpkyxNBK3vofL6/3l7JQLPrkRpXrY8kwzVCqg== X-Received: by 2002:a05:600c:252:: with SMTP id 18mr1641697wmj.67.1616573987893; Wed, 24 Mar 2021 01:19:47 -0700 (PDT) Received: from skynet.lan (51.red-83-44-13.dynamicip.rima-tde.net. [83.44.13.51]) by smtp.gmail.com with ESMTPSA id x25sm1498578wmj.14.2021.03.24.01.19.46 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 24 Mar 2021 01:19:47 -0700 (PDT) From: =?UTF-8?q?=C3=81lvaro=20Fern=C3=A1ndez=20Rojas?= To: Linus Walleij , Bartosz Golaszewski , Rob Herring , Lee Jones , Michael Walle , Florian Fainelli , bcm-kernel-feedback-list@broadcom.com, Jonas Gorski , =?UTF-8?q?=C3=81lvaro=20Fern=C3=A1ndez=20Rojas?= , Necip Fazil Yildiran , Andy Shevchenko , linux-gpio@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [PATCH v9 22/22] pinctrl: add a pincontrol driver for BCM6318 Date: Wed, 24 Mar 2021 09:19:23 +0100 Message-Id: <20210324081923.20379-23-noltari@gmail.com> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20210324081923.20379-1-noltari@gmail.com> References: <20210324081923.20379-1-noltari@gmail.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-gpio@vger.kernel.org Add a pincontrol driver for BCM6318. BCM6318 allows muxing most GPIOs to different functions. BCM6318 is similar to BCM6328 with the addition of a pad register, and the GPIO meaning of the mux register changes based on the GPIO number. Co-developed-by: Jonas Gorski Signed-off-by: Jonas Gorski Signed-off-by: Álvaro Fernández Rojas --- v9: no changes v8: no changes v7: no changes v6: no changes v5: add changes suggested by Andy Shevchenko v4: no changes v3: use new shared code v2: switch to GPIO_REGMAP drivers/pinctrl/bcm/Kconfig | 8 + drivers/pinctrl/bcm/Makefile | 1 + drivers/pinctrl/bcm/pinctrl-bcm6318.c | 498 ++++++++++++++++++++++++++ 3 files changed, 507 insertions(+) create mode 100644 drivers/pinctrl/bcm/pinctrl-bcm6318.c diff --git a/drivers/pinctrl/bcm/Kconfig b/drivers/pinctrl/bcm/Kconfig index 186985846120..33660e8fec05 100644 --- a/drivers/pinctrl/bcm/Kconfig +++ b/drivers/pinctrl/bcm/Kconfig @@ -36,6 +36,14 @@ config PINCTRL_BCM63XX select PINCONF select PINMUX +config PINCTRL_BCM6318 + bool "Broadcom BCM6318 GPIO driver" + depends on (BMIPS_GENERIC || COMPILE_TEST) + select PINCTRL_BCM63XX + default BMIPS_GENERIC + help + Say Y here to enable the Broadcom BCM6318 GPIO driver. + config PINCTRL_BCM6328 bool "Broadcom BCM6328 GPIO driver" depends on (BMIPS_GENERIC || COMPILE_TEST) diff --git a/drivers/pinctrl/bcm/Makefile b/drivers/pinctrl/bcm/Makefile index 4117847fd279..00c7b7775e63 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_BCM6318) += pinctrl-bcm6318.o obj-$(CONFIG_PINCTRL_BCM6328) += pinctrl-bcm6328.o obj-$(CONFIG_PINCTRL_BCM6358) += pinctrl-bcm6358.o obj-$(CONFIG_PINCTRL_BCM6362) += pinctrl-bcm6362.o diff --git a/drivers/pinctrl/bcm/pinctrl-bcm6318.c b/drivers/pinctrl/bcm/pinctrl-bcm6318.c new file mode 100644 index 000000000000..77fd9b58067d --- /dev/null +++ b/drivers/pinctrl/bcm/pinctrl-bcm6318.c @@ -0,0 +1,498 @@ +// SPDX-License-Identifier: GPL-2.0+ +/* + * Driver for BCM6318 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 BCM6318_NUM_GPIOS 50 +#define BCM6318_NUM_MUX 48 + +#define BCM6318_MODE_REG 0x18 +#define BCM6318_MUX_REG 0x1c +#define BCM6328_MUX_MASK GENMASK(1, 0) +#define BCM6318_PAD_REG 0x54 +#define BCM6328_PAD_MASK GENMASK(3, 0) + +struct bcm6318_pingroup { + const char *name; + const unsigned * const pins; + const unsigned num_pins; +}; + +struct bcm6318_function { + const char *name; + const char * const *groups; + const unsigned num_groups; + + unsigned mode_val:1; + unsigned mux_val:2; +}; + +static const struct pinctrl_pin_desc bcm6318_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"), + PINCTRL_PIN(32, "gpio32"), + PINCTRL_PIN(33, "gpio33"), + PINCTRL_PIN(34, "gpio34"), + PINCTRL_PIN(35, "gpio35"), + PINCTRL_PIN(36, "gpio36"), + PINCTRL_PIN(37, "gpio37"), + PINCTRL_PIN(38, "gpio38"), + PINCTRL_PIN(39, "gpio39"), + PINCTRL_PIN(40, "gpio40"), + PINCTRL_PIN(41, "gpio41"), + PINCTRL_PIN(42, "gpio42"), + PINCTRL_PIN(43, "gpio43"), + PINCTRL_PIN(44, "gpio44"), + PINCTRL_PIN(45, "gpio45"), + PINCTRL_PIN(46, "gpio46"), + PINCTRL_PIN(47, "gpio47"), + PINCTRL_PIN(48, "gpio48"), + PINCTRL_PIN(49, "gpio49"), +}; + +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 gpio32_pins[] = { 32 }; +static unsigned gpio33_pins[] = { 33 }; +static unsigned gpio34_pins[] = { 34 }; +static unsigned gpio35_pins[] = { 35 }; +static unsigned gpio36_pins[] = { 36 }; +static unsigned gpio37_pins[] = { 37 }; +static unsigned gpio38_pins[] = { 38 }; +static unsigned gpio39_pins[] = { 39 }; +static unsigned gpio40_pins[] = { 40 }; +static unsigned gpio41_pins[] = { 41 }; +static unsigned gpio42_pins[] = { 42 }; +static unsigned gpio43_pins[] = { 43 }; +static unsigned gpio44_pins[] = { 44 }; +static unsigned gpio45_pins[] = { 45 }; +static unsigned gpio46_pins[] = { 46 }; +static unsigned gpio47_pins[] = { 47 }; +static unsigned gpio48_pins[] = { 48 }; +static unsigned gpio49_pins[] = { 49 }; + +#define BCM6318_GROUP(n) \ + { \ + .name = #n, \ + .pins = n##_pins, \ + .num_pins = ARRAY_SIZE(n##_pins), \ + } + +static struct bcm6318_pingroup bcm6318_groups[] = { + BCM6318_GROUP(gpio0), + BCM6318_GROUP(gpio1), + BCM6318_GROUP(gpio2), + BCM6318_GROUP(gpio3), + BCM6318_GROUP(gpio4), + BCM6318_GROUP(gpio5), + BCM6318_GROUP(gpio6), + BCM6318_GROUP(gpio7), + BCM6318_GROUP(gpio8), + BCM6318_GROUP(gpio9), + BCM6318_GROUP(gpio10), + BCM6318_GROUP(gpio11), + BCM6318_GROUP(gpio12), + BCM6318_GROUP(gpio13), + BCM6318_GROUP(gpio14), + BCM6318_GROUP(gpio15), + BCM6318_GROUP(gpio16), + BCM6318_GROUP(gpio17), + BCM6318_GROUP(gpio18), + BCM6318_GROUP(gpio19), + BCM6318_GROUP(gpio20), + BCM6318_GROUP(gpio21), + BCM6318_GROUP(gpio22), + BCM6318_GROUP(gpio23), + BCM6318_GROUP(gpio24), + BCM6318_GROUP(gpio25), + BCM6318_GROUP(gpio26), + BCM6318_GROUP(gpio27), + BCM6318_GROUP(gpio28), + BCM6318_GROUP(gpio29), + BCM6318_GROUP(gpio30), + BCM6318_GROUP(gpio31), + BCM6318_GROUP(gpio32), + BCM6318_GROUP(gpio33), + BCM6318_GROUP(gpio34), + BCM6318_GROUP(gpio35), + BCM6318_GROUP(gpio36), + BCM6318_GROUP(gpio37), + BCM6318_GROUP(gpio38), + BCM6318_GROUP(gpio39), + BCM6318_GROUP(gpio40), + BCM6318_GROUP(gpio41), + BCM6318_GROUP(gpio42), + BCM6318_GROUP(gpio43), + BCM6318_GROUP(gpio44), + BCM6318_GROUP(gpio45), + BCM6318_GROUP(gpio46), + BCM6318_GROUP(gpio47), + BCM6318_GROUP(gpio48), + BCM6318_GROUP(gpio49), +}; + +/* 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 ephy0_spd_led_groups[] = { + "gpio0", +}; + +static const char * const ephy1_spd_led_groups[] = { + "gpio1", +}; + +static const char * const ephy2_spd_led_groups[] = { + "gpio2", +}; + +static const char * const ephy3_spd_led_groups[] = { + "gpio3", +}; + +static const char * const ephy0_act_led_groups[] = { + "gpio4", +}; + +static const char * const ephy1_act_led_groups[] = { + "gpio5", +}; + +static const char * const ephy2_act_led_groups[] = { + "gpio6", +}; + +static const char * const ephy3_act_led_groups[] = { + "gpio7", +}; + +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[] = { + "gpio8", +}; + +static const char * const inet_fail_led_groups[] = { + "gpio9", +}; + +static const char * const dsl_led_groups[] = { + "gpio10", +}; + +static const char * const post_fail_led_groups[] = { + "gpio11", +}; + +static const char * const wlan_wps_led_groups[] = { + "gpio12", +}; + +static const char * const usb_pwron_groups[] = { + "gpio13", +}; + +static const char * const usb_device_led_groups[] = { + "gpio13", +}; + +static const char * const usb_active_groups[] = { + "gpio40", +}; + +#define BCM6318_MODE_FUN(n) \ + { \ + .name = #n, \ + .groups = n##_groups, \ + .num_groups = ARRAY_SIZE(n##_groups), \ + .mode_val = 1, \ + } + +#define BCM6318_MUX_FUN(n, mux) \ + { \ + .name = #n, \ + .groups = n##_groups, \ + .num_groups = ARRAY_SIZE(n##_groups), \ + .mux_val = mux, \ + } + +static const struct bcm6318_function bcm6318_funcs[] = { + BCM6318_MODE_FUN(led), + BCM6318_MUX_FUN(ephy0_spd_led, 1), + BCM6318_MUX_FUN(ephy1_spd_led, 1), + BCM6318_MUX_FUN(ephy2_spd_led, 1), + BCM6318_MUX_FUN(ephy3_spd_led, 1), + BCM6318_MUX_FUN(ephy0_act_led, 1), + BCM6318_MUX_FUN(ephy1_act_led, 1), + BCM6318_MUX_FUN(ephy2_act_led, 1), + BCM6318_MUX_FUN(ephy3_act_led, 1), + BCM6318_MUX_FUN(serial_led_data, 3), + BCM6318_MUX_FUN(serial_led_clk, 3), + BCM6318_MUX_FUN(inet_act_led, 1), + BCM6318_MUX_FUN(inet_fail_led, 1), + BCM6318_MUX_FUN(dsl_led, 1), + BCM6318_MUX_FUN(post_fail_led, 1), + BCM6318_MUX_FUN(wlan_wps_led, 1), + BCM6318_MUX_FUN(usb_pwron, 1), + BCM6318_MUX_FUN(usb_device_led, 2), + BCM6318_MUX_FUN(usb_active, 2), +}; + +static inline unsigned int bcm6318_mux_off(unsigned int pin) +{ + return BCM6318_MUX_REG + (pin / 16) * 4; +} + +static inline unsigned int bcm6318_pad_off(unsigned int pin) +{ + return BCM6318_PAD_REG + (pin / 8) * 4; +} + +static int bcm6318_pinctrl_get_group_count(struct pinctrl_dev *pctldev) +{ + return ARRAY_SIZE(bcm6318_groups); +} + +static const char *bcm6318_pinctrl_get_group_name(struct pinctrl_dev *pctldev, + unsigned group) +{ + return bcm6318_groups[group].name; +} + +static int bcm6318_pinctrl_get_group_pins(struct pinctrl_dev *pctldev, + unsigned group, const unsigned **pins, + unsigned *num_pins) +{ + *pins = bcm6318_groups[group].pins; + *num_pins = bcm6318_groups[group].num_pins; + + return 0; +} + +static int bcm6318_pinctrl_get_func_count(struct pinctrl_dev *pctldev) +{ + return ARRAY_SIZE(bcm6318_funcs); +} + +static const char *bcm6318_pinctrl_get_func_name(struct pinctrl_dev *pctldev, + unsigned selector) +{ + return bcm6318_funcs[selector].name; +} + +static int bcm6318_pinctrl_get_groups(struct pinctrl_dev *pctldev, + unsigned selector, + const char * const **groups, + unsigned * const num_groups) +{ + *groups = bcm6318_funcs[selector].groups; + *num_groups = bcm6318_funcs[selector].num_groups; + + return 0; +} + +static inline void bcm6318_rmw_mux(struct bcm63xx_pinctrl *pc, unsigned pin, + unsigned int mode, unsigned int mux) +{ + if (pin < BCM63XX_BANK_GPIOS) + regmap_update_bits(pc->regs, BCM6318_MODE_REG, BIT(pin), + mode ? BIT(pin) : 0); + + if (pin < BCM6318_NUM_MUX) + regmap_update_bits(pc->regs, + bcm6318_mux_off(pin), + BCM6328_MUX_MASK << ((pin % 16) * 2), + mux << ((pin % 16) * 2)); +} + +static inline void bcm6318_set_pad(struct bcm63xx_pinctrl *pc, unsigned pin, + uint8_t val) +{ + regmap_update_bits(pc->regs, bcm6318_pad_off(pin), + BCM6328_PAD_MASK << ((pin % 8) * 4), + val << ((pin % 8) * 4)); +} + +static int bcm6318_pinctrl_set_mux(struct pinctrl_dev *pctldev, + unsigned selector, unsigned group) +{ + struct bcm63xx_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev); + const struct bcm6318_pingroup *pg = &bcm6318_groups[group]; + const struct bcm6318_function *f = &bcm6318_funcs[selector]; + + bcm6318_rmw_mux(pc, pg->pins[0], f->mode_val, f->mux_val); + + return 0; +} + +static int bcm6318_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 */ + if (offset < 13) { + /* GPIOs 0-12 use mux 0 as GPIO function */ + bcm6318_rmw_mux(pc, offset, 0, 0); + } else if (offset < 42) { + /* GPIOs 13-41 use mux 3 as GPIO function */ + bcm6318_rmw_mux(pc, offset, 0, 3); + + bcm6318_set_pad(pc, offset, 0); + } + + return 0; +} + +static struct pinctrl_ops bcm6318_pctl_ops = { + .dt_free_map = pinctrl_utils_free_map, + .dt_node_to_map = pinconf_generic_dt_node_to_map_pin, + .get_group_name = bcm6318_pinctrl_get_group_name, + .get_group_pins = bcm6318_pinctrl_get_group_pins, + .get_groups_count = bcm6318_pinctrl_get_group_count, +}; + +static struct pinmux_ops bcm6318_pmx_ops = { + .get_function_groups = bcm6318_pinctrl_get_groups, + .get_function_name = bcm6318_pinctrl_get_func_name, + .get_functions_count = bcm6318_pinctrl_get_func_count, + .gpio_request_enable = bcm6318_gpio_request_enable, + .set_mux = bcm6318_pinctrl_set_mux, + .strict = true, +}; + +static const struct bcm63xx_pinctrl_soc bcm6318_soc = { + .ngpios = BCM6318_NUM_GPIOS, + .npins = ARRAY_SIZE(bcm6318_pins), + .pctl_ops = &bcm6318_pctl_ops, + .pins = bcm6318_pins, + .pmx_ops = &bcm6318_pmx_ops, +}; + +static int bcm6318_pinctrl_probe(struct platform_device *pdev) +{ + return bcm63xx_pinctrl_probe(pdev, &bcm6318_soc, NULL); +} + +static const struct of_device_id bcm6318_pinctrl_match[] = { + { .compatible = "brcm,bcm6318-pinctrl", }, + { /* sentinel */ } +}; + +static struct platform_driver bcm6318_pinctrl_driver = { + .probe = bcm6318_pinctrl_probe, + .driver = { + .name = "bcm6318-pinctrl", + .of_match_table = bcm6318_pinctrl_match, + }, +}; + +builtin_platform_driver(bcm6318_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 5F560C433C1 for ; Wed, 24 Mar 2021 08:28:24 +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 9E67C619C2 for ; Wed, 24 Mar 2021 08:28:23 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 9E67C619C2 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=/nN5TiJaAPodUgYZi+j8NVC2tx+XFFEbFTQlNLMeZDY=; b=DntJ0tMWXlRYvt1NiRROQshoD VA8z9q/CLyXBkA/TecYp/u0cWLc/UT+N3FHNWq8EHMshYO3uJ99IMBUZDSCs9kvzDg/QX8Uxhl9o8 KEjL6A7t50lxnBhcWbdM3AT3RSZJOEPbDBmU/jPdaSkL1/RhnnO1H6aw425TMlxm/KOEUiaY8ctWE vEkHJ4RDDAL+29sZ9FrnH/HKGXD6lE9xQ14IzYUQaZmKExUswCps4OTggNu8g97drWdIlscFzW4/6 FPuj9z/8XJPBn21iVP2GEZaGVRSuYi0cHSyrLAKgz0lKFIRcMea5bKq25iNnBgcxYGgy/dbVVJDbm BW6UnIOhA==; Received: from localhost ([::1] helo=desiato.infradead.org) by desiato.infradead.org with esmtp (Exim 4.94 #2 (Red Hat Linux)) id 1lOypl-00GbHh-Ht; Wed, 24 Mar 2021 08:25:45 +0000 Received: from mail-wm1-x32f.google.com ([2a00:1450:4864:20::32f]) by desiato.infradead.org with esmtps (Exim 4.94 #2 (Red Hat Linux)) id 1lOyk1-00GYvW-EA for linux-arm-kernel@lists.infradead.org; Wed, 24 Mar 2021 08:19:53 +0000 Received: by mail-wm1-x32f.google.com with SMTP id g25so12418808wmh.0 for ; Wed, 24 Mar 2021 01:19:48 -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=wLlJZoOJRqGcNn638bEGDVMd9eW3ekMwGm75enWvQ1U=; b=QBcDlCdO3jrtL1WUl+6Tf4fM47afkaBsXGMfVaC9fOP5BC81uwUMXRL5JNxoR79KfF A3gqZGkspgPG5KPe73iTH8MtpnesMsSw9w9kF2gcHdh72PopNUJQhYZtn0wMCXFTbwNp tcDj6fEs18Usm1cixh1BBdOu8vsZhNNsvDF/q+GfUuX6JWAPRH7MCzhWplhjnU3Ho3Yl K5h0nvgtqX21k92STs7RD/jtolUqnpJhUq40sQY/ipIdpwK/1W3FWPY37WQ0WVtMxuXS pbBc0b5U4PB9wsPsQ0mKHcbuZKXEcFl+30bQGJiWebM6HaBvzbU0EvY3XlrUAoSfyOwO Gx2g== 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=wLlJZoOJRqGcNn638bEGDVMd9eW3ekMwGm75enWvQ1U=; b=Q3MHOR6wTpS0FT5vnL2DcmV6tiGJaOARIn81mocxCxwZfkB98e3qA5Sfe3sci+5BrQ SQEGCrts6xaxkWGfEVk15GsPk3D05hzcONK89X9SKB4rNLaCdPRz4x5OPizrOkY7KrIo SLcjMh4QMx7skKiyJfxDucbHCca56DV3bCu9CGRm4rRuR1wlvxnYT87/Y+W8WYe0qzW2 RVzsaXLC9aopzhd60YAdM5mqgTbLaf8d7qBxgzlnNgTLj36rVtRgoWc//nuCjWTGoGju wKzteGB42MUcp4MhrXet7LuYVYSWmOr+/foE0L0njuyj8F/OOhWi9QxNN7EGCQskkpXt aM0A== X-Gm-Message-State: AOAM532NwXOSHjCqvKGKHYTZb7TfKJ4N6xiDUsyGqKqz5jdlTQBW+roc 144VvyVgaOdclRmpZguWtAU= X-Google-Smtp-Source: ABdhPJw/bjdhsRPLNczByNceP88+N6VQHVxDJHUaBrpkyxNBK3vofL6/3l7JQLPrkRpXrY8kwzVCqg== X-Received: by 2002:a05:600c:252:: with SMTP id 18mr1641697wmj.67.1616573987893; Wed, 24 Mar 2021 01:19:47 -0700 (PDT) Received: from skynet.lan (51.red-83-44-13.dynamicip.rima-tde.net. [83.44.13.51]) by smtp.gmail.com with ESMTPSA id x25sm1498578wmj.14.2021.03.24.01.19.46 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 24 Mar 2021 01:19:47 -0700 (PDT) From: =?UTF-8?q?=C3=81lvaro=20Fern=C3=A1ndez=20Rojas?= To: Linus Walleij , Bartosz Golaszewski , Rob Herring , Lee Jones , Michael Walle , Florian Fainelli , bcm-kernel-feedback-list@broadcom.com, Jonas Gorski , =?UTF-8?q?=C3=81lvaro=20Fern=C3=A1ndez=20Rojas?= , Necip Fazil Yildiran , Andy Shevchenko , linux-gpio@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [PATCH v9 22/22] pinctrl: add a pincontrol driver for BCM6318 Date: Wed, 24 Mar 2021 09:19:23 +0100 Message-Id: <20210324081923.20379-23-noltari@gmail.com> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20210324081923.20379-1-noltari@gmail.com> References: <20210324081923.20379-1-noltari@gmail.com> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20210324_081950_788722_1630BB6D X-CRM114-Status: GOOD ( 19.89 ) 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 QWRkIGEgcGluY29udHJvbCBkcml2ZXIgZm9yIEJDTTYzMTguIEJDTTYzMTggYWxsb3dzIG11eGlu ZyBtb3N0IEdQSU9zCnRvIGRpZmZlcmVudCBmdW5jdGlvbnMuIEJDTTYzMTggaXMgc2ltaWxhciB0 byBCQ002MzI4IHdpdGggdGhlIGFkZGl0aW9uCm9mIGEgcGFkIHJlZ2lzdGVyLCBhbmQgdGhlIEdQ SU8gbWVhbmluZyBvZiB0aGUgbXV4IHJlZ2lzdGVyIGNoYW5nZXMKYmFzZWQgb24gdGhlIEdQSU8g bnVtYmVyLgoKQ28tZGV2ZWxvcGVkLWJ5OiBKb25hcyBHb3Jza2kgPGpvbmFzLmdvcnNraUBnbWFp bC5jb20+ClNpZ25lZC1vZmYtYnk6IEpvbmFzIEdvcnNraSA8am9uYXMuZ29yc2tpQGdtYWlsLmNv bT4KU2lnbmVkLW9mZi1ieTogw4FsdmFybyBGZXJuw6FuZGV6IFJvamFzIDxub2x0YXJpQGdtYWls LmNvbT4KLS0tCiB2OTogbm8gY2hhbmdlcwogdjg6IG5vIGNoYW5nZXMKIHY3OiBubyBjaGFuZ2Vz CiB2Njogbm8gY2hhbmdlcwogdjU6IGFkZCBjaGFuZ2VzIHN1Z2dlc3RlZCBieSBBbmR5IFNoZXZj aGVua28KIHY0OiBubyBjaGFuZ2VzCiB2MzogdXNlIG5ldyBzaGFyZWQgY29kZQogdjI6IHN3aXRj aCB0byBHUElPX1JFR01BUAoKIGRyaXZlcnMvcGluY3RybC9iY20vS2NvbmZpZyAgICAgICAgICAg fCAgIDggKwogZHJpdmVycy9waW5jdHJsL2JjbS9NYWtlZmlsZSAgICAgICAgICB8ICAgMSArCiBk cml2ZXJzL3BpbmN0cmwvYmNtL3BpbmN0cmwtYmNtNjMxOC5jIHwgNDk4ICsrKysrKysrKysrKysr KysrKysrKysrKysrCiAzIGZpbGVzIGNoYW5nZWQsIDUwNyBpbnNlcnRpb25zKCspCiBjcmVhdGUg bW9kZSAxMDA2NDQgZHJpdmVycy9waW5jdHJsL2JjbS9waW5jdHJsLWJjbTYzMTguYwoKZGlmZiAt LWdpdCBhL2RyaXZlcnMvcGluY3RybC9iY20vS2NvbmZpZyBiL2RyaXZlcnMvcGluY3RybC9iY20v S2NvbmZpZwppbmRleCAxODY5ODU4NDYxMjAuLjMzNjYwZThmZWMwNSAxMDA2NDQKLS0tIGEvZHJp dmVycy9waW5jdHJsL2JjbS9LY29uZmlnCisrKyBiL2RyaXZlcnMvcGluY3RybC9iY20vS2NvbmZp ZwpAQCAtMzYsNiArMzYsMTQgQEAgY29uZmlnIFBJTkNUUkxfQkNNNjNYWAogCXNlbGVjdCBQSU5D T05GCiAJc2VsZWN0IFBJTk1VWAogCitjb25maWcgUElOQ1RSTF9CQ002MzE4CisJYm9vbCAiQnJv YWRjb20gQkNNNjMxOCBHUElPIGRyaXZlciIKKwlkZXBlbmRzIG9uIChCTUlQU19HRU5FUklDIHx8 IENPTVBJTEVfVEVTVCkKKwlzZWxlY3QgUElOQ1RSTF9CQ002M1hYCisJZGVmYXVsdCBCTUlQU19H RU5FUklDCisJaGVscAorCSAgIFNheSBZIGhlcmUgdG8gZW5hYmxlIHRoZSBCcm9hZGNvbSBCQ002 MzE4IEdQSU8gZHJpdmVyLgorCiBjb25maWcgUElOQ1RSTF9CQ002MzI4CiAJYm9vbCAiQnJvYWRj b20gQkNNNjMyOCBHUElPIGRyaXZlciIKIAlkZXBlbmRzIG9uIChCTUlQU19HRU5FUklDIHx8IENP TVBJTEVfVEVTVCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGluY3RybC9iY20vTWFrZWZpbGUgYi9k cml2ZXJzL3BpbmN0cmwvYmNtL01ha2VmaWxlCmluZGV4IDQxMTc4NDdmZDI3OS4uMDBjN2I3Nzc1 ZTYzIDEwMDY0NAotLS0gYS9kcml2ZXJzL3BpbmN0cmwvYmNtL01ha2VmaWxlCisrKyBiL2RyaXZl cnMvcGluY3RybC9iY20vTWFrZWZpbGUKQEAgLTQsNiArNCw3IEBACiBvYmotJChDT05GSUdfUElO Q1RSTF9CQ00yODFYWCkJCSs9IHBpbmN0cmwtYmNtMjgxeHgubwogb2JqLSQoQ09ORklHX1BJTkNU UkxfQkNNMjgzNSkJCSs9IHBpbmN0cmwtYmNtMjgzNS5vCiBvYmotJChDT05GSUdfUElOQ1RSTF9C Q002M1hYKQkJKz0gcGluY3RybC1iY202M3h4Lm8KK29iai0kKENPTkZJR19QSU5DVFJMX0JDTTYz MTgpCQkrPSBwaW5jdHJsLWJjbTYzMTgubwogb2JqLSQoQ09ORklHX1BJTkNUUkxfQkNNNjMyOCkJ CSs9IHBpbmN0cmwtYmNtNjMyOC5vCiBvYmotJChDT05GSUdfUElOQ1RSTF9CQ002MzU4KQkJKz0g cGluY3RybC1iY202MzU4Lm8KIG9iai0kKENPTkZJR19QSU5DVFJMX0JDTTYzNjIpCQkrPSBwaW5j dHJsLWJjbTYzNjIubwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9waW5jdHJsL2JjbS9waW5jdHJsLWJj bTYzMTguYyBiL2RyaXZlcnMvcGluY3RybC9iY20vcGluY3RybC1iY202MzE4LmMKbmV3IGZpbGUg bW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi43N2ZkOWI1ODA2N2QKLS0tIC9kZXYvbnVs bAorKysgYi9kcml2ZXJzL3BpbmN0cmwvYmNtL3BpbmN0cmwtYmNtNjMxOC5jCkBAIC0wLDAgKzEs NDk4IEBACisvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMCsKKy8qCisgKiBEcml2 ZXIgZm9yIEJDTTYzMTggR1BJTyB1bml0IChwaW5jdHJsICsgR1BJTykKKyAqCisgKiBDb3B5cmln aHQgKEMpIDIwMjEgw4FsdmFybyBGZXJuw6FuZGV6IFJvamFzIDxub2x0YXJpQGdtYWlsLmNvbT4K KyAqIENvcHlyaWdodCAoQykgMjAxNiBKb25hcyBHb3Jza2kgPGpvbmFzLmdvcnNraUBnbWFpbC5j b20+CisgKi8KKworI2luY2x1ZGUgPGxpbnV4L2JpdHMuaD4KKyNpbmNsdWRlIDxsaW51eC9ncGlv L2RyaXZlci5oPgorI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgorI2luY2x1ZGUgPGxpbnV4L29m Lmg+CisjaW5jbHVkZSA8bGludXgvcGluY3RybC9waW5tdXguaD4KKyNpbmNsdWRlIDxsaW51eC9w bGF0Zm9ybV9kZXZpY2UuaD4KKyNpbmNsdWRlIDxsaW51eC9yZWdtYXAuaD4KKworI2luY2x1ZGUg Ii4uL3BpbmN0cmwtdXRpbHMuaCIKKworI2luY2x1ZGUgInBpbmN0cmwtYmNtNjN4eC5oIgorCisj ZGVmaW5lIEJDTTYzMThfTlVNX0dQSU9TCTUwCisjZGVmaW5lIEJDTTYzMThfTlVNX01VWAkJNDgK KworI2RlZmluZSBCQ002MzE4X01PREVfUkVHCTB4MTgKKyNkZWZpbmUgQkNNNjMxOF9NVVhfUkVH CQkweDFjCisjZGVmaW5lICBCQ002MzI4X01VWF9NQVNLCUdFTk1BU0soMSwgMCkKKyNkZWZpbmUg QkNNNjMxOF9QQURfUkVHCQkweDU0CisjZGVmaW5lICBCQ002MzI4X1BBRF9NQVNLCUdFTk1BU0so MywgMCkKKworc3RydWN0IGJjbTYzMThfcGluZ3JvdXAgeworCWNvbnN0IGNoYXIgKm5hbWU7CisJ Y29uc3QgdW5zaWduZWQgKiBjb25zdCBwaW5zOworCWNvbnN0IHVuc2lnbmVkIG51bV9waW5zOwor fTsKKworc3RydWN0IGJjbTYzMThfZnVuY3Rpb24geworCWNvbnN0IGNoYXIgKm5hbWU7CisJY29u c3QgY2hhciAqIGNvbnN0ICpncm91cHM7CisJY29uc3QgdW5zaWduZWQgbnVtX2dyb3VwczsKKwor CXVuc2lnbmVkIG1vZGVfdmFsOjE7CisJdW5zaWduZWQgbXV4X3ZhbDoyOworfTsKKworc3RhdGlj IGNvbnN0IHN0cnVjdCBwaW5jdHJsX3Bpbl9kZXNjIGJjbTYzMThfcGluc1tdID0geworCVBJTkNU UkxfUElOKDAsICJncGlvMCIpLAorCVBJTkNUUkxfUElOKDEsICJncGlvMSIpLAorCVBJTkNUUkxf UElOKDIsICJncGlvMiIpLAorCVBJTkNUUkxfUElOKDMsICJncGlvMyIpLAorCVBJTkNUUkxfUElO KDQsICJncGlvNCIpLAorCVBJTkNUUkxfUElOKDUsICJncGlvNSIpLAorCVBJTkNUUkxfUElOKDYs ICJncGlvNiIpLAorCVBJTkNUUkxfUElOKDcsICJncGlvNyIpLAorCVBJTkNUUkxfUElOKDgsICJn cGlvOCIpLAorCVBJTkNUUkxfUElOKDksICJncGlvOSIpLAorCVBJTkNUUkxfUElOKDEwLCAiZ3Bp bzEwIiksCisJUElOQ1RSTF9QSU4oMTEsICJncGlvMTEiKSwKKwlQSU5DVFJMX1BJTigxMiwgImdw aW8xMiIpLAorCVBJTkNUUkxfUElOKDEzLCAiZ3BpbzEzIiksCisJUElOQ1RSTF9QSU4oMTQsICJn cGlvMTQiKSwKKwlQSU5DVFJMX1BJTigxNSwgImdwaW8xNSIpLAorCVBJTkNUUkxfUElOKDE2LCAi Z3BpbzE2IiksCisJUElOQ1RSTF9QSU4oMTcsICJncGlvMTciKSwKKwlQSU5DVFJMX1BJTigxOCwg ImdwaW8xOCIpLAorCVBJTkNUUkxfUElOKDE5LCAiZ3BpbzE5IiksCisJUElOQ1RSTF9QSU4oMjAs ICJncGlvMjAiKSwKKwlQSU5DVFJMX1BJTigyMSwgImdwaW8yMSIpLAorCVBJTkNUUkxfUElOKDIy LCAiZ3BpbzIyIiksCisJUElOQ1RSTF9QSU4oMjMsICJncGlvMjMiKSwKKwlQSU5DVFJMX1BJTigy NCwgImdwaW8yNCIpLAorCVBJTkNUUkxfUElOKDI1LCAiZ3BpbzI1IiksCisJUElOQ1RSTF9QSU4o MjYsICJncGlvMjYiKSwKKwlQSU5DVFJMX1BJTigyNywgImdwaW8yNyIpLAorCVBJTkNUUkxfUElO KDI4LCAiZ3BpbzI4IiksCisJUElOQ1RSTF9QSU4oMjksICJncGlvMjkiKSwKKwlQSU5DVFJMX1BJ TigzMCwgImdwaW8zMCIpLAorCVBJTkNUUkxfUElOKDMxLCAiZ3BpbzMxIiksCisJUElOQ1RSTF9Q SU4oMzIsICJncGlvMzIiKSwKKwlQSU5DVFJMX1BJTigzMywgImdwaW8zMyIpLAorCVBJTkNUUkxf UElOKDM0LCAiZ3BpbzM0IiksCisJUElOQ1RSTF9QSU4oMzUsICJncGlvMzUiKSwKKwlQSU5DVFJM X1BJTigzNiwgImdwaW8zNiIpLAorCVBJTkNUUkxfUElOKDM3LCAiZ3BpbzM3IiksCisJUElOQ1RS TF9QSU4oMzgsICJncGlvMzgiKSwKKwlQSU5DVFJMX1BJTigzOSwgImdwaW8zOSIpLAorCVBJTkNU UkxfUElOKDQwLCAiZ3BpbzQwIiksCisJUElOQ1RSTF9QSU4oNDEsICJncGlvNDEiKSwKKwlQSU5D VFJMX1BJTig0MiwgImdwaW80MiIpLAorCVBJTkNUUkxfUElOKDQzLCAiZ3BpbzQzIiksCisJUElO Q1RSTF9QSU4oNDQsICJncGlvNDQiKSwKKwlQSU5DVFJMX1BJTig0NSwgImdwaW80NSIpLAorCVBJ TkNUUkxfUElOKDQ2LCAiZ3BpbzQ2IiksCisJUElOQ1RSTF9QSU4oNDcsICJncGlvNDciKSwKKwlQ SU5DVFJMX1BJTig0OCwgImdwaW80OCIpLAorCVBJTkNUUkxfUElOKDQ5LCAiZ3BpbzQ5IiksCit9 OworCitzdGF0aWMgdW5zaWduZWQgZ3BpbzBfcGluc1tdID0geyAwIH07CitzdGF0aWMgdW5zaWdu ZWQgZ3BpbzFfcGluc1tdID0geyAxIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzJfcGluc1tdID0g eyAyIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzNfcGluc1tdID0geyAzIH07CitzdGF0aWMgdW5z aWduZWQgZ3BpbzRfcGluc1tdID0geyA0IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzVfcGluc1td ID0geyA1IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzZfcGluc1tdID0geyA2IH07CitzdGF0aWMg dW5zaWduZWQgZ3BpbzdfcGluc1tdID0geyA3IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzhfcGlu c1tdID0geyA4IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzlfcGluc1tdID0geyA5IH07CitzdGF0 aWMgdW5zaWduZWQgZ3BpbzEwX3BpbnNbXSA9IHsgMTAgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlv MTFfcGluc1tdID0geyAxMSB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8xMl9waW5zW10gPSB7IDEy IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzEzX3BpbnNbXSA9IHsgMTMgfTsKK3N0YXRpYyB1bnNp Z25lZCBncGlvMTRfcGluc1tdID0geyAxNCB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8xNV9waW5z W10gPSB7IDE1IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzE2X3BpbnNbXSA9IHsgMTYgfTsKK3N0 YXRpYyB1bnNpZ25lZCBncGlvMTdfcGluc1tdID0geyAxNyB9Oworc3RhdGljIHVuc2lnbmVkIGdw aW8xOF9waW5zW10gPSB7IDE4IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzE5X3BpbnNbXSA9IHsg MTkgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMjBfcGluc1tdID0geyAyMCB9Oworc3RhdGljIHVu c2lnbmVkIGdwaW8yMV9waW5zW10gPSB7IDIxIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzIyX3Bp bnNbXSA9IHsgMjIgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMjNfcGluc1tdID0geyAyMyB9Owor c3RhdGljIHVuc2lnbmVkIGdwaW8yNF9waW5zW10gPSB7IDI0IH07CitzdGF0aWMgdW5zaWduZWQg Z3BpbzI1X3BpbnNbXSA9IHsgMjUgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMjZfcGluc1tdID0g eyAyNiB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8yN19waW5zW10gPSB7IDI3IH07CitzdGF0aWMg dW5zaWduZWQgZ3BpbzI4X3BpbnNbXSA9IHsgMjggfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMjlf cGluc1tdID0geyAyOSB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8zMF9waW5zW10gPSB7IDMwIH07 CitzdGF0aWMgdW5zaWduZWQgZ3BpbzMxX3BpbnNbXSA9IHsgMzEgfTsKK3N0YXRpYyB1bnNpZ25l ZCBncGlvMzJfcGluc1tdID0geyAzMiB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8zM19waW5zW10g PSB7IDMzIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzM0X3BpbnNbXSA9IHsgMzQgfTsKK3N0YXRp YyB1bnNpZ25lZCBncGlvMzVfcGluc1tdID0geyAzNSB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8z Nl9waW5zW10gPSB7IDM2IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzM3X3BpbnNbXSA9IHsgMzcg fTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMzhfcGluc1tdID0geyAzOCB9Oworc3RhdGljIHVuc2ln bmVkIGdwaW8zOV9waW5zW10gPSB7IDM5IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzQwX3BpbnNb XSA9IHsgNDAgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvNDFfcGluc1tdID0geyA0MSB9Oworc3Rh dGljIHVuc2lnbmVkIGdwaW80Ml9waW5zW10gPSB7IDQyIH07CitzdGF0aWMgdW5zaWduZWQgZ3Bp bzQzX3BpbnNbXSA9IHsgNDMgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvNDRfcGluc1tdID0geyA0 NCB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW80NV9waW5zW10gPSB7IDQ1IH07CitzdGF0aWMgdW5z aWduZWQgZ3BpbzQ2X3BpbnNbXSA9IHsgNDYgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvNDdfcGlu c1tdID0geyA0NyB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW80OF9waW5zW10gPSB7IDQ4IH07Citz dGF0aWMgdW5zaWduZWQgZ3BpbzQ5X3BpbnNbXSA9IHsgNDkgfTsKKworI2RlZmluZSBCQ002MzE4 X0dST1VQKG4pCQkJCQlcCisJewkJCQkJCQlcCisJCS5uYW1lID0gI24sCQkJCQlcCisJCS5waW5z ID0gbiMjX3BpbnMsCQkJCVwKKwkJLm51bV9waW5zID0gQVJSQVlfU0laRShuIyNfcGlucyksCQlc CisJfQorCitzdGF0aWMgc3RydWN0IGJjbTYzMThfcGluZ3JvdXAgYmNtNjMxOF9ncm91cHNbXSA9 IHsKKwlCQ002MzE4X0dST1VQKGdwaW8wKSwKKwlCQ002MzE4X0dST1VQKGdwaW8xKSwKKwlCQ002 MzE4X0dST1VQKGdwaW8yKSwKKwlCQ002MzE4X0dST1VQKGdwaW8zKSwKKwlCQ002MzE4X0dST1VQ KGdwaW80KSwKKwlCQ002MzE4X0dST1VQKGdwaW81KSwKKwlCQ002MzE4X0dST1VQKGdwaW82KSwK KwlCQ002MzE4X0dST1VQKGdwaW83KSwKKwlCQ002MzE4X0dST1VQKGdwaW84KSwKKwlCQ002MzE4 X0dST1VQKGdwaW85KSwKKwlCQ002MzE4X0dST1VQKGdwaW8xMCksCisJQkNNNjMxOF9HUk9VUChn cGlvMTEpLAorCUJDTTYzMThfR1JPVVAoZ3BpbzEyKSwKKwlCQ002MzE4X0dST1VQKGdwaW8xMyks CisJQkNNNjMxOF9HUk9VUChncGlvMTQpLAorCUJDTTYzMThfR1JPVVAoZ3BpbzE1KSwKKwlCQ002 MzE4X0dST1VQKGdwaW8xNiksCisJQkNNNjMxOF9HUk9VUChncGlvMTcpLAorCUJDTTYzMThfR1JP VVAoZ3BpbzE4KSwKKwlCQ002MzE4X0dST1VQKGdwaW8xOSksCisJQkNNNjMxOF9HUk9VUChncGlv MjApLAorCUJDTTYzMThfR1JPVVAoZ3BpbzIxKSwKKwlCQ002MzE4X0dST1VQKGdwaW8yMiksCisJ QkNNNjMxOF9HUk9VUChncGlvMjMpLAorCUJDTTYzMThfR1JPVVAoZ3BpbzI0KSwKKwlCQ002MzE4 X0dST1VQKGdwaW8yNSksCisJQkNNNjMxOF9HUk9VUChncGlvMjYpLAorCUJDTTYzMThfR1JPVVAo Z3BpbzI3KSwKKwlCQ002MzE4X0dST1VQKGdwaW8yOCksCisJQkNNNjMxOF9HUk9VUChncGlvMjkp LAorCUJDTTYzMThfR1JPVVAoZ3BpbzMwKSwKKwlCQ002MzE4X0dST1VQKGdwaW8zMSksCisJQkNN NjMxOF9HUk9VUChncGlvMzIpLAorCUJDTTYzMThfR1JPVVAoZ3BpbzMzKSwKKwlCQ002MzE4X0dS T1VQKGdwaW8zNCksCisJQkNNNjMxOF9HUk9VUChncGlvMzUpLAorCUJDTTYzMThfR1JPVVAoZ3Bp bzM2KSwKKwlCQ002MzE4X0dST1VQKGdwaW8zNyksCisJQkNNNjMxOF9HUk9VUChncGlvMzgpLAor CUJDTTYzMThfR1JPVVAoZ3BpbzM5KSwKKwlCQ002MzE4X0dST1VQKGdwaW80MCksCisJQkNNNjMx OF9HUk9VUChncGlvNDEpLAorCUJDTTYzMThfR1JPVVAoZ3BpbzQyKSwKKwlCQ002MzE4X0dST1VQ KGdwaW80MyksCisJQkNNNjMxOF9HUk9VUChncGlvNDQpLAorCUJDTTYzMThfR1JPVVAoZ3BpbzQ1 KSwKKwlCQ002MzE4X0dST1VQKGdwaW80NiksCisJQkNNNjMxOF9HUk9VUChncGlvNDcpLAorCUJD TTYzMThfR1JPVVAoZ3BpbzQ4KSwKKwlCQ002MzE4X0dST1VQKGdwaW80OSksCit9OworCisvKiBH UElPX01PREUgKi8KK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgbGVkX2dyb3Vwc1tdID0gewor CSJncGlvMCIsCisJImdwaW8xIiwKKwkiZ3BpbzIiLAorCSJncGlvMyIsCisJImdwaW80IiwKKwki Z3BpbzUiLAorCSJncGlvNiIsCisJImdwaW83IiwKKwkiZ3BpbzgiLAorCSJncGlvOSIsCisJImdw aW8xMCIsCisJImdwaW8xMSIsCisJImdwaW8xMiIsCisJImdwaW8xMyIsCisJImdwaW8xNCIsCisJ ImdwaW8xNSIsCisJImdwaW8xNiIsCisJImdwaW8xNyIsCisJImdwaW8xOCIsCisJImdwaW8xOSIs CisJImdwaW8yMCIsCisJImdwaW8yMSIsCisJImdwaW8yMiIsCisJImdwaW8yMyIsCit9OworCisv KiBQSU5NVVhfU0VMICovCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGVwaHkwX3NwZF9sZWRf Z3JvdXBzW10gPSB7CisJImdwaW8wIiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3Qg ZXBoeTFfc3BkX2xlZF9ncm91cHNbXSA9IHsKKwkiZ3BpbzEiLAorfTsKKworc3RhdGljIGNvbnN0 IGNoYXIgKiBjb25zdCBlcGh5Ml9zcGRfbGVkX2dyb3Vwc1tdID0geworCSJncGlvMiIsCit9Owor CitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGVwaHkzX3NwZF9sZWRfZ3JvdXBzW10gPSB7CisJ ImdwaW8zIiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgZXBoeTBfYWN0X2xlZF9n cm91cHNbXSA9IHsKKwkiZ3BpbzQiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBl cGh5MV9hY3RfbGVkX2dyb3Vwc1tdID0geworCSJncGlvNSIsCit9OworCitzdGF0aWMgY29uc3Qg Y2hhciAqIGNvbnN0IGVwaHkyX2FjdF9sZWRfZ3JvdXBzW10gPSB7CisJImdwaW82IiwKK307CisK K3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgZXBoeTNfYWN0X2xlZF9ncm91cHNbXSA9IHsKKwki Z3BpbzciLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBzZXJpYWxfbGVkX2RhdGFf Z3JvdXBzW10gPSB7CisJImdwaW82IiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3Qg c2VyaWFsX2xlZF9jbGtfZ3JvdXBzW10gPSB7CisJImdwaW83IiwKK307CisKK3N0YXRpYyBjb25z dCBjaGFyICogY29uc3QgaW5ldF9hY3RfbGVkX2dyb3Vwc1tdID0geworCSJncGlvOCIsCit9Owor CitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGluZXRfZmFpbF9sZWRfZ3JvdXBzW10gPSB7CisJ ImdwaW85IiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgZHNsX2xlZF9ncm91cHNb XSA9IHsKKwkiZ3BpbzEwIiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgcG9zdF9m YWlsX2xlZF9ncm91cHNbXSA9IHsKKwkiZ3BpbzExIiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFy ICogY29uc3Qgd2xhbl93cHNfbGVkX2dyb3Vwc1tdID0geworCSJncGlvMTIiLAorfTsKKworc3Rh dGljIGNvbnN0IGNoYXIgKiBjb25zdCB1c2JfcHdyb25fZ3JvdXBzW10gPSB7CisJImdwaW8xMyIs Cit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHVzYl9kZXZpY2VfbGVkX2dyb3Vwc1td ID0geworCSJncGlvMTMiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCB1c2JfYWN0 aXZlX2dyb3Vwc1tdID0geworCSJncGlvNDAiLAorfTsKKworI2RlZmluZSBCQ002MzE4X01PREVf RlVOKG4pCQkJCVwKKwl7CQkJCQkJXAorCQkubmFtZSA9ICNuLAkJCQlcCisJCS5ncm91cHMgPSBu IyNfZ3JvdXBzLAkJCVwKKwkJLm51bV9ncm91cHMgPSBBUlJBWV9TSVpFKG4jI19ncm91cHMpLAlc CisJCS5tb2RlX3ZhbCA9IDEsCQkJCVwKKwl9CisKKyNkZWZpbmUgQkNNNjMxOF9NVVhfRlVOKG4s IG11eCkJCQkJXAorCXsJCQkJCQlcCisJCS5uYW1lID0gI24sCQkJCVwKKwkJLmdyb3VwcyA9IG4j I19ncm91cHMsCQkJXAorCQkubnVtX2dyb3VwcyA9IEFSUkFZX1NJWkUobiMjX2dyb3VwcyksCVwK KwkJLm11eF92YWwgPSBtdXgsCQkJCVwKKwl9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgYmNtNjMx OF9mdW5jdGlvbiBiY202MzE4X2Z1bmNzW10gPSB7CisJQkNNNjMxOF9NT0RFX0ZVTihsZWQpLAor CUJDTTYzMThfTVVYX0ZVTihlcGh5MF9zcGRfbGVkLCAxKSwKKwlCQ002MzE4X01VWF9GVU4oZXBo eTFfc3BkX2xlZCwgMSksCisJQkNNNjMxOF9NVVhfRlVOKGVwaHkyX3NwZF9sZWQsIDEpLAorCUJD TTYzMThfTVVYX0ZVTihlcGh5M19zcGRfbGVkLCAxKSwKKwlCQ002MzE4X01VWF9GVU4oZXBoeTBf YWN0X2xlZCwgMSksCisJQkNNNjMxOF9NVVhfRlVOKGVwaHkxX2FjdF9sZWQsIDEpLAorCUJDTTYz MThfTVVYX0ZVTihlcGh5Ml9hY3RfbGVkLCAxKSwKKwlCQ002MzE4X01VWF9GVU4oZXBoeTNfYWN0 X2xlZCwgMSksCisJQkNNNjMxOF9NVVhfRlVOKHNlcmlhbF9sZWRfZGF0YSwgMyksCisJQkNNNjMx OF9NVVhfRlVOKHNlcmlhbF9sZWRfY2xrLCAzKSwKKwlCQ002MzE4X01VWF9GVU4oaW5ldF9hY3Rf bGVkLCAxKSwKKwlCQ002MzE4X01VWF9GVU4oaW5ldF9mYWlsX2xlZCwgMSksCisJQkNNNjMxOF9N VVhfRlVOKGRzbF9sZWQsIDEpLAorCUJDTTYzMThfTVVYX0ZVTihwb3N0X2ZhaWxfbGVkLCAxKSwK KwlCQ002MzE4X01VWF9GVU4od2xhbl93cHNfbGVkLCAxKSwKKwlCQ002MzE4X01VWF9GVU4odXNi X3B3cm9uLCAxKSwKKwlCQ002MzE4X01VWF9GVU4odXNiX2RldmljZV9sZWQsIDIpLAorCUJDTTYz MThfTVVYX0ZVTih1c2JfYWN0aXZlLCAyKSwKK307CisKK3N0YXRpYyBpbmxpbmUgdW5zaWduZWQg aW50IGJjbTYzMThfbXV4X29mZih1bnNpZ25lZCBpbnQgcGluKQoreworCXJldHVybiBCQ002MzE4 X01VWF9SRUcgKyAocGluIC8gMTYpICogNDsKK30KKworc3RhdGljIGlubGluZSB1bnNpZ25lZCBp bnQgYmNtNjMxOF9wYWRfb2ZmKHVuc2lnbmVkIGludCBwaW4pCit7CisJcmV0dXJuIEJDTTYzMThf UEFEX1JFRyArIChwaW4gLyA4KSAqIDQ7Cit9CisKK3N0YXRpYyBpbnQgYmNtNjMxOF9waW5jdHJs X2dldF9ncm91cF9jb3VudChzdHJ1Y3QgcGluY3RybF9kZXYgKnBjdGxkZXYpCit7CisJcmV0dXJu IEFSUkFZX1NJWkUoYmNtNjMxOF9ncm91cHMpOworfQorCitzdGF0aWMgY29uc3QgY2hhciAqYmNt NjMxOF9waW5jdHJsX2dldF9ncm91cF9uYW1lKHN0cnVjdCBwaW5jdHJsX2RldiAqcGN0bGRldiwK KwkJCQkJCSAgdW5zaWduZWQgZ3JvdXApCit7CisJcmV0dXJuIGJjbTYzMThfZ3JvdXBzW2dyb3Vw XS5uYW1lOworfQorCitzdGF0aWMgaW50IGJjbTYzMThfcGluY3RybF9nZXRfZ3JvdXBfcGlucyhz dHJ1Y3QgcGluY3RybF9kZXYgKnBjdGxkZXYsCisJCQkJCSAgdW5zaWduZWQgZ3JvdXAsIGNvbnN0 IHVuc2lnbmVkICoqcGlucywKKwkJCQkJICB1bnNpZ25lZCAqbnVtX3BpbnMpCit7CisJKnBpbnMg PSBiY202MzE4X2dyb3Vwc1tncm91cF0ucGluczsKKwkqbnVtX3BpbnMgPSBiY202MzE4X2dyb3Vw c1tncm91cF0ubnVtX3BpbnM7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBiY202MzE4 X3BpbmN0cmxfZ2V0X2Z1bmNfY291bnQoc3RydWN0IHBpbmN0cmxfZGV2ICpwY3RsZGV2KQorewor CXJldHVybiBBUlJBWV9TSVpFKGJjbTYzMThfZnVuY3MpOworfQorCitzdGF0aWMgY29uc3QgY2hh ciAqYmNtNjMxOF9waW5jdHJsX2dldF9mdW5jX25hbWUoc3RydWN0IHBpbmN0cmxfZGV2ICpwY3Rs ZGV2LAorCQkJCQkJIHVuc2lnbmVkIHNlbGVjdG9yKQoreworCXJldHVybiBiY202MzE4X2Z1bmNz W3NlbGVjdG9yXS5uYW1lOworfQorCitzdGF0aWMgaW50IGJjbTYzMThfcGluY3RybF9nZXRfZ3Jv dXBzKHN0cnVjdCBwaW5jdHJsX2RldiAqcGN0bGRldiwKKwkJCQkgICAgICB1bnNpZ25lZCBzZWxl Y3RvciwKKwkJCQkgICAgICBjb25zdCBjaGFyICogY29uc3QgKipncm91cHMsCisJCQkJICAgICAg dW5zaWduZWQgKiBjb25zdCBudW1fZ3JvdXBzKQoreworCSpncm91cHMgPSBiY202MzE4X2Z1bmNz W3NlbGVjdG9yXS5ncm91cHM7CisJKm51bV9ncm91cHMgPSBiY202MzE4X2Z1bmNzW3NlbGVjdG9y XS5udW1fZ3JvdXBzOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBiY202 MzE4X3Jtd19tdXgoc3RydWN0IGJjbTYzeHhfcGluY3RybCAqcGMsIHVuc2lnbmVkIHBpbiwKKwkJ CQkgICB1bnNpZ25lZCBpbnQgbW9kZSwgdW5zaWduZWQgaW50IG11eCkKK3sKKwlpZiAocGluIDwg QkNNNjNYWF9CQU5LX0dQSU9TKQorCQlyZWdtYXBfdXBkYXRlX2JpdHMocGMtPnJlZ3MsIEJDTTYz MThfTU9ERV9SRUcsIEJJVChwaW4pLAorCQkJCSAgIG1vZGUgPyBCSVQocGluKSA6IDApOworCisJ aWYgKHBpbiA8IEJDTTYzMThfTlVNX01VWCkKKwkJcmVnbWFwX3VwZGF0ZV9iaXRzKHBjLT5yZWdz LAorCQkJCSAgIGJjbTYzMThfbXV4X29mZihwaW4pLAorCQkJCSAgIEJDTTYzMjhfTVVYX01BU0sg PDwgKChwaW4gJSAxNikgKiAyKSwKKwkJCQkgICBtdXggPDwgKChwaW4gJSAxNikgKiAyKSk7Cit9 CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBiY202MzE4X3NldF9wYWQoc3RydWN0IGJjbTYzeHhfcGlu Y3RybCAqcGMsIHVuc2lnbmVkIHBpbiwKKwkJCQkgICB1aW50OF90IHZhbCkKK3sKKwlyZWdtYXBf dXBkYXRlX2JpdHMocGMtPnJlZ3MsIGJjbTYzMThfcGFkX29mZihwaW4pLAorCQkJICAgQkNNNjMy OF9QQURfTUFTSyA8PCAoKHBpbiAlIDgpICogNCksCisJCQkgICB2YWwgPDwgKChwaW4gJSA4KSAq IDQpKTsKK30KKworc3RhdGljIGludCBiY202MzE4X3BpbmN0cmxfc2V0X211eChzdHJ1Y3QgcGlu Y3RybF9kZXYgKnBjdGxkZXYsCisJCQkJICAgdW5zaWduZWQgc2VsZWN0b3IsIHVuc2lnbmVkIGdy b3VwKQoreworCXN0cnVjdCBiY202M3h4X3BpbmN0cmwgKnBjID0gcGluY3RybF9kZXZfZ2V0X2Ry dmRhdGEocGN0bGRldik7CisJY29uc3Qgc3RydWN0IGJjbTYzMThfcGluZ3JvdXAgKnBnID0gJmJj bTYzMThfZ3JvdXBzW2dyb3VwXTsKKwljb25zdCBzdHJ1Y3QgYmNtNjMxOF9mdW5jdGlvbiAqZiA9 ICZiY202MzE4X2Z1bmNzW3NlbGVjdG9yXTsKKworCWJjbTYzMThfcm13X211eChwYywgcGctPnBp bnNbMF0sIGYtPm1vZGVfdmFsLCBmLT5tdXhfdmFsKTsKKworCXJldHVybiAwOworfQorCitzdGF0 aWMgaW50IGJjbTYzMThfZ3Bpb19yZXF1ZXN0X2VuYWJsZShzdHJ1Y3QgcGluY3RybF9kZXYgKnBj dGxkZXYsCisJCQkJICAgICAgIHN0cnVjdCBwaW5jdHJsX2dwaW9fcmFuZ2UgKnJhbmdlLAorCQkJ CSAgICAgICB1bnNpZ25lZCBvZmZzZXQpCit7CisJc3RydWN0IGJjbTYzeHhfcGluY3RybCAqcGMg PSBwaW5jdHJsX2Rldl9nZXRfZHJ2ZGF0YShwY3RsZGV2KTsKKworCS8qIGRpc2FibGUgYWxsIGZ1 bmN0aW9ucyB1c2luZyB0aGlzIHBpbiAqLworCWlmIChvZmZzZXQgPCAxMykgeworCQkvKiBHUElP cyAwLTEyIHVzZSBtdXggMCBhcyBHUElPIGZ1bmN0aW9uICovCisJCWJjbTYzMThfcm13X211eChw Yywgb2Zmc2V0LCAwLCAwKTsKKwl9IGVsc2UgaWYgKG9mZnNldCA8IDQyKSB7CisJCS8qIEdQSU9z IDEzLTQxIHVzZSBtdXggMyBhcyBHUElPIGZ1bmN0aW9uICovCisJCWJjbTYzMThfcm13X211eChw Yywgb2Zmc2V0LCAwLCAzKTsKKworCQliY202MzE4X3NldF9wYWQocGMsIG9mZnNldCwgMCk7CisJ fQorCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBzdHJ1Y3QgcGluY3RybF9vcHMgYmNtNjMxOF9w Y3RsX29wcyA9IHsKKwkuZHRfZnJlZV9tYXAgPSBwaW5jdHJsX3V0aWxzX2ZyZWVfbWFwLAorCS5k dF9ub2RlX3RvX21hcCA9IHBpbmNvbmZfZ2VuZXJpY19kdF9ub2RlX3RvX21hcF9waW4sCisJLmdl dF9ncm91cF9uYW1lID0gYmNtNjMxOF9waW5jdHJsX2dldF9ncm91cF9uYW1lLAorCS5nZXRfZ3Jv dXBfcGlucyA9IGJjbTYzMThfcGluY3RybF9nZXRfZ3JvdXBfcGlucywKKwkuZ2V0X2dyb3Vwc19j b3VudCA9IGJjbTYzMThfcGluY3RybF9nZXRfZ3JvdXBfY291bnQsCit9OworCitzdGF0aWMgc3Ry dWN0IHBpbm11eF9vcHMgYmNtNjMxOF9wbXhfb3BzID0geworCS5nZXRfZnVuY3Rpb25fZ3JvdXBz ID0gYmNtNjMxOF9waW5jdHJsX2dldF9ncm91cHMsCisJLmdldF9mdW5jdGlvbl9uYW1lID0gYmNt NjMxOF9waW5jdHJsX2dldF9mdW5jX25hbWUsCisJLmdldF9mdW5jdGlvbnNfY291bnQgPSBiY202 MzE4X3BpbmN0cmxfZ2V0X2Z1bmNfY291bnQsCisJLmdwaW9fcmVxdWVzdF9lbmFibGUgPSBiY202 MzE4X2dwaW9fcmVxdWVzdF9lbmFibGUsCisJLnNldF9tdXggPSBiY202MzE4X3BpbmN0cmxfc2V0 X211eCwKKwkuc3RyaWN0ID0gdHJ1ZSwKK307CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgYmNtNjN4 eF9waW5jdHJsX3NvYyBiY202MzE4X3NvYyA9IHsKKwkubmdwaW9zID0gQkNNNjMxOF9OVU1fR1BJ T1MsCisJLm5waW5zID0gQVJSQVlfU0laRShiY202MzE4X3BpbnMpLAorCS5wY3RsX29wcyA9ICZi Y202MzE4X3BjdGxfb3BzLAorCS5waW5zID0gYmNtNjMxOF9waW5zLAorCS5wbXhfb3BzID0gJmJj bTYzMThfcG14X29wcywKK307CisKK3N0YXRpYyBpbnQgYmNtNjMxOF9waW5jdHJsX3Byb2JlKHN0 cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCit7CisJcmV0dXJuIGJjbTYzeHhfcGluY3RybF9w cm9iZShwZGV2LCAmYmNtNjMxOF9zb2MsIE5VTEwpOworfQorCitzdGF0aWMgY29uc3Qgc3RydWN0 IG9mX2RldmljZV9pZCBiY202MzE4X3BpbmN0cmxfbWF0Y2hbXSA9IHsKKwl7IC5jb21wYXRpYmxl ID0gImJyY20sYmNtNjMxOC1waW5jdHJsIiwgfSwKKwl7IC8qIHNlbnRpbmVsICovIH0KK307CisK K3N0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZHJpdmVyIGJjbTYzMThfcGluY3RybF9kcml2ZXIgPSB7 CisJLnByb2JlID0gYmNtNjMxOF9waW5jdHJsX3Byb2JlLAorCS5kcml2ZXIgPSB7CisJCS5uYW1l ID0gImJjbTYzMTgtcGluY3RybCIsCisJCS5vZl9tYXRjaF90YWJsZSA9IGJjbTYzMThfcGluY3Ry bF9tYXRjaCwKKwl9LAorfTsKKworYnVpbHRpbl9wbGF0Zm9ybV9kcml2ZXIoYmNtNjMxOF9waW5j dHJsX2RyaXZlcik7Ci0tIAoyLjIwLjEKCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fXwpsaW51eC1hcm0ta2VybmVsIG1haWxpbmcgbGlzdApsaW51eC1hcm0t a2VybmVsQGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFp bG1hbi9saXN0aW5mby9saW51eC1hcm0ta2VybmVsCg==