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 B1B7AC433E9 for ; Wed, 17 Mar 2021 14:39:27 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 613AB64F69 for ; Wed, 17 Mar 2021 14:39:27 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S232166AbhCQOjD (ORCPT ); Wed, 17 Mar 2021 10:39:03 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:57110 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232019AbhCQOi1 (ORCPT ); Wed, 17 Mar 2021 10:38:27 -0400 Received: from mail-wm1-x331.google.com (mail-wm1-x331.google.com [IPv6:2a00:1450:4864:20::331]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 598C0C06174A; Wed, 17 Mar 2021 07:38:27 -0700 (PDT) Received: by mail-wm1-x331.google.com with SMTP id g25so1641667wmh.0; Wed, 17 Mar 2021 07:38:27 -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=iX7CLxlDDYTgpu7A0UdLIQo4C7RFTt6S1zrTy0aR36o=; b=JO5+lKwr4NSCfPCvwnvTY0YC8+80tyI+24629uIMMbMlivmWsjoexgoeszsWj3PI6A Wc9ptTHTLnU+KUBiKCKilejYSd9sGEyXOdmBcK2GNMz5UGgsYhmkAmkaM7MtOapT8l6G WzyvLYvhSsbDu2Om1LQUU8x4Tu0rQSqu4MbJXV4jhyO4+ZpL8uoZLRoPm4y+ApqafOZS D8PVmnakK9yCZRKbsPjNEig+8n/jp/FWvFvp+RS2fM7WzUSlBUoIdQLwIsaTyffyJ4IG /xD1TBUngcGZj+9WDgdBNZzx5EPzWD3IAj6354m8qXAZdNMr1nxYz0ZJELfKmzAH9Yeq txCw== 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=iX7CLxlDDYTgpu7A0UdLIQo4C7RFTt6S1zrTy0aR36o=; b=CecysuS4+fVyh3UTI+O5uuWoGwABOMXmZV1cboXjHr53mjff7llqkLCEy/Zrexme3z nKPqNaVLgFIgnyw9qtpk9IPTDzVaiOK+QkdK5Qx+ATYSMnpstRHNEqNW4gjizKMChHZI kHFvofVtG2SZjCyHZQ425Wisr2jzemaMziwWl/wSr13CRxv05NWGccQTAqKvUVw2fNYg 2d0y+LVAixvg+kjD9AaqTrSXpqlvCbNkyIn8wNHcaYwAaUCTriuvktyjEaYFmuVREcIY 4483ICAeiLWTqX0xlcBMs0ozZGRwgf5ZMRkQeAWHEZ40iacUAUbEOkcmug+k4AgoBrqf n0RQ== X-Gm-Message-State: AOAM531NjgCCBTS1VKkTb/WuS9lJHXwtoPu5CYA28G3KwqFMrQugRXSa 0e+79n/cjaApflOHqusfo6c= X-Google-Smtp-Source: ABdhPJyBPkEawblkkjZwmp8ft4zEVzL78U5/LNhPFrBtT9dL3HmrlRGRvrTpQoeQaa5v6I+xw7cT/g== X-Received: by 2002:a05:600c:c4:: with SMTP id u4mr4043018wmm.27.1615991906014; Wed, 17 Mar 2021 07:38:26 -0700 (PDT) Received: from skynet.lan ([80.31.204.166]) by smtp.gmail.com with ESMTPSA id a75sm2518948wme.10.2021.03.17.07.38.25 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 17 Mar 2021 07:38:25 -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 v8 22/22] pinctrl: add a pincontrol driver for BCM6318 Date: Wed, 17 Mar 2021 15:38:03 +0100 Message-Id: <20210317143803.26127-23-noltari@gmail.com> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20210317143803.26127-1-noltari@gmail.com> References: <20210317143803.26127-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 --- 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,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 B0584C433DB for ; Wed, 17 Mar 2021 14:46:06 +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 2E9B864F44 for ; Wed, 17 Mar 2021 14:46:05 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 2E9B864F44 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=NUqtUJExGvH18q/eu7UUYx7xeQ/i9A8v1mCLCeXM1Gs=; b=JCPtYFgRaX/r4cpRKI968tB/r qlEbuOjMDid6UBRFgs6wAKE4vRA41f2SfOfyveChx3N4ComsoyOK3DEr1rh4jjTGszGECeo6wD3W/ WPs9N32U70grLlZ9wW7Rr9PgQmR7HSacEtYirNcZQm8axcmAj+OtaIX0cU8Dw5mdcxlekhAdkfRJm D+HO0zFEPPyGbx9MMbcs4GJYW1h+jy58zsuWZ5JNZBJuZwdxo/zr2HGnPqTiMfm0I1Ti2pn9exhUO jorA2MErwobmw9Qu4gy1VIrYX8MebPT4TA3VeBS04UL7K+RooFIXyGupfLjSaiwJt5GI+nqE4wPTg 5dVnUjPQg==; Received: from localhost ([::1] helo=desiato.infradead.org) by desiato.infradead.org with esmtp (Exim 4.94 #2 (Red Hat Linux)) id 1lMXOh-003K6t-MQ; Wed, 17 Mar 2021 14:43:44 +0000 Received: from mail-wm1-x336.google.com ([2a00:1450:4864:20::336]) by desiato.infradead.org with esmtps (Exim 4.94 #2 (Red Hat Linux)) id 1lMXJa-003HiX-Nc for linux-arm-kernel@lists.infradead.org; Wed, 17 Mar 2021 14:38:29 +0000 Received: by mail-wm1-x336.google.com with SMTP id j4-20020a05600c4104b029010c62bc1e20so1429915wmi.3 for ; Wed, 17 Mar 2021 07:38:26 -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=iX7CLxlDDYTgpu7A0UdLIQo4C7RFTt6S1zrTy0aR36o=; b=JO5+lKwr4NSCfPCvwnvTY0YC8+80tyI+24629uIMMbMlivmWsjoexgoeszsWj3PI6A Wc9ptTHTLnU+KUBiKCKilejYSd9sGEyXOdmBcK2GNMz5UGgsYhmkAmkaM7MtOapT8l6G WzyvLYvhSsbDu2Om1LQUU8x4Tu0rQSqu4MbJXV4jhyO4+ZpL8uoZLRoPm4y+ApqafOZS D8PVmnakK9yCZRKbsPjNEig+8n/jp/FWvFvp+RS2fM7WzUSlBUoIdQLwIsaTyffyJ4IG /xD1TBUngcGZj+9WDgdBNZzx5EPzWD3IAj6354m8qXAZdNMr1nxYz0ZJELfKmzAH9Yeq txCw== 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=iX7CLxlDDYTgpu7A0UdLIQo4C7RFTt6S1zrTy0aR36o=; b=eFWQPxUiHsaq+JINgy/o2/euc2FEhAucJDsK0JfOSntpe0GmTnutLlKKpImPDzaCCZ rPIOBJlE/0/qH8EiVe1m2UwxmvIziu/q3TD3L8/3FX5RuDcmFlOfxLIpnaBte1qmm2NE mg8CgVXWIrmKkhXFgnFxns/dcAGrkA+KOJ/3WKOeeXSb1B6agh9ur2xOvj3c9gFiJZ4k vOnSOLu2abfrKuHbiXoLl3xsOeCIH+/1FIChVzdX/9vPw51z+tr5r3DDUsKZf5vfSWD5 gPIrsS0EHi4sPX4hMfPVwcoZFYAm/XCtQ/UBVdYgw4cmPv48MkFmGjSqley0Rhvc9JAc rujA== X-Gm-Message-State: AOAM532qwOCMH0GeK7IV3MdnHeNOxnT4XFgaY5MqBe6d6mjvHc2bwqLc ZPUn2vaX8oo0mkH/ffNB2Ss= X-Google-Smtp-Source: ABdhPJyBPkEawblkkjZwmp8ft4zEVzL78U5/LNhPFrBtT9dL3HmrlRGRvrTpQoeQaa5v6I+xw7cT/g== X-Received: by 2002:a05:600c:c4:: with SMTP id u4mr4043018wmm.27.1615991906014; Wed, 17 Mar 2021 07:38:26 -0700 (PDT) Received: from skynet.lan ([80.31.204.166]) by smtp.gmail.com with ESMTPSA id a75sm2518948wme.10.2021.03.17.07.38.25 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 17 Mar 2021 07:38:25 -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 v8 22/22] pinctrl: add a pincontrol driver for BCM6318 Date: Wed, 17 Mar 2021 15:38:03 +0100 Message-Id: <20210317143803.26127-23-noltari@gmail.com> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20210317143803.26127-1-noltari@gmail.com> References: <20210317143803.26127-1-noltari@gmail.com> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20210317_143826_928441_6020004B X-CRM114-Status: GOOD ( 19.39 ) 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 LmNvbT4KLS0tCiB2ODogbm8gY2hhbmdlcwogdjc6IG5vIGNoYW5nZXMKIHY2OiBubyBjaGFuZ2Vz CiB2NTogYWRkIGNoYW5nZXMgc3VnZ2VzdGVkIGJ5IEFuZHkgU2hldmNoZW5rbwogdjQ6IG5vIGNo YW5nZXMKIHYzOiB1c2UgbmV3IHNoYXJlZCBjb2RlCiB2Mjogc3dpdGNoIHRvIEdQSU9fUkVHTUFQ CgogZHJpdmVycy9waW5jdHJsL2JjbS9LY29uZmlnICAgICAgICAgICB8ICAgOCArCiBkcml2ZXJz L3BpbmN0cmwvYmNtL01ha2VmaWxlICAgICAgICAgIHwgICAxICsKIGRyaXZlcnMvcGluY3RybC9i Y20vcGluY3RybC1iY202MzE4LmMgfCA0OTggKysrKysrKysrKysrKysrKysrKysrKysrKysKIDMg ZmlsZXMgY2hhbmdlZCwgNTA3IGluc2VydGlvbnMoKykKIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2 ZXJzL3BpbmN0cmwvYmNtL3BpbmN0cmwtYmNtNjMxOC5jCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9w aW5jdHJsL2JjbS9LY29uZmlnIGIvZHJpdmVycy9waW5jdHJsL2JjbS9LY29uZmlnCmluZGV4IDE4 Njk4NTg0NjEyMC4uMzM2NjBlOGZlYzA1IDEwMDY0NAotLS0gYS9kcml2ZXJzL3BpbmN0cmwvYmNt L0tjb25maWcKKysrIGIvZHJpdmVycy9waW5jdHJsL2JjbS9LY29uZmlnCkBAIC0zNiw2ICszNiwx NCBAQCBjb25maWcgUElOQ1RSTF9CQ002M1hYCiAJc2VsZWN0IFBJTkNPTkYKIAlzZWxlY3QgUElO TVVYCiAKK2NvbmZpZyBQSU5DVFJMX0JDTTYzMTgKKwlib29sICJCcm9hZGNvbSBCQ002MzE4IEdQ SU8gZHJpdmVyIgorCWRlcGVuZHMgb24gKEJNSVBTX0dFTkVSSUMgfHwgQ09NUElMRV9URVNUKQor CXNlbGVjdCBQSU5DVFJMX0JDTTYzWFgKKwlkZWZhdWx0IEJNSVBTX0dFTkVSSUMKKwloZWxwCisJ ICAgU2F5IFkgaGVyZSB0byBlbmFibGUgdGhlIEJyb2FkY29tIEJDTTYzMTggR1BJTyBkcml2ZXIu CisKIGNvbmZpZyBQSU5DVFJMX0JDTTYzMjgKIAlib29sICJCcm9hZGNvbSBCQ002MzI4IEdQSU8g ZHJpdmVyIgogCWRlcGVuZHMgb24gKEJNSVBTX0dFTkVSSUMgfHwgQ09NUElMRV9URVNUKQpkaWZm IC0tZ2l0IGEvZHJpdmVycy9waW5jdHJsL2JjbS9NYWtlZmlsZSBiL2RyaXZlcnMvcGluY3RybC9i Y20vTWFrZWZpbGUKaW5kZXggNDExNzg0N2ZkMjc5Li4wMGM3Yjc3NzVlNjMgMTAwNjQ0Ci0tLSBh L2RyaXZlcnMvcGluY3RybC9iY20vTWFrZWZpbGUKKysrIGIvZHJpdmVycy9waW5jdHJsL2JjbS9N YWtlZmlsZQpAQCAtNCw2ICs0LDcgQEAKIG9iai0kKENPTkZJR19QSU5DVFJMX0JDTTI4MVhYKQkJ Kz0gcGluY3RybC1iY20yODF4eC5vCiBvYmotJChDT05GSUdfUElOQ1RSTF9CQ00yODM1KQkJKz0g cGluY3RybC1iY20yODM1Lm8KIG9iai0kKENPTkZJR19QSU5DVFJMX0JDTTYzWFgpCQkrPSBwaW5j dHJsLWJjbTYzeHgubworb2JqLSQoQ09ORklHX1BJTkNUUkxfQkNNNjMxOCkJCSs9IHBpbmN0cmwt YmNtNjMxOC5vCiBvYmotJChDT05GSUdfUElOQ1RSTF9CQ002MzI4KQkJKz0gcGluY3RybC1iY202 MzI4Lm8KIG9iai0kKENPTkZJR19QSU5DVFJMX0JDTTYzNTgpCQkrPSBwaW5jdHJsLWJjbTYzNTgu bwogb2JqLSQoQ09ORklHX1BJTkNUUkxfQkNNNjM2MikJCSs9IHBpbmN0cmwtYmNtNjM2Mi5vCmRp ZmYgLS1naXQgYS9kcml2ZXJzL3BpbmN0cmwvYmNtL3BpbmN0cmwtYmNtNjMxOC5jIGIvZHJpdmVy cy9waW5jdHJsL2JjbS9waW5jdHJsLWJjbTYzMTguYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwMDAwMDAuLjc3ZmQ5YjU4MDY3ZAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMv cGluY3RybC9iY20vcGluY3RybC1iY202MzE4LmMKQEAgLTAsMCArMSw0OTggQEAKKy8vIFNQRFgt TGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wKworLyoKKyAqIERyaXZlciBmb3IgQkNNNjMxOCBH UElPIHVuaXQgKHBpbmN0cmwgKyBHUElPKQorICoKKyAqIENvcHlyaWdodCAoQykgMjAyMSDDgWx2 YXJvIEZlcm7DoW5kZXogUm9qYXMgPG5vbHRhcmlAZ21haWwuY29tPgorICogQ29weXJpZ2h0IChD KSAyMDE2IEpvbmFzIEdvcnNraSA8am9uYXMuZ29yc2tpQGdtYWlsLmNvbT4KKyAqLworCisjaW5j bHVkZSA8bGludXgvYml0cy5oPgorI2luY2x1ZGUgPGxpbnV4L2dwaW8vZHJpdmVyLmg+CisjaW5j bHVkZSA8bGludXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgvb2YuaD4KKyNpbmNsdWRlIDxs aW51eC9waW5jdHJsL3Bpbm11eC5oPgorI2luY2x1ZGUgPGxpbnV4L3BsYXRmb3JtX2RldmljZS5o PgorI2luY2x1ZGUgPGxpbnV4L3JlZ21hcC5oPgorCisjaW5jbHVkZSAiLi4vcGluY3RybC11dGls cy5oIgorCisjaW5jbHVkZSAicGluY3RybC1iY202M3h4LmgiCisKKyNkZWZpbmUgQkNNNjMxOF9O VU1fR1BJT1MJNTAKKyNkZWZpbmUgQkNNNjMxOF9OVU1fTVVYCQk0OAorCisjZGVmaW5lIEJDTTYz MThfTU9ERV9SRUcJMHgxOAorI2RlZmluZSBCQ002MzE4X01VWF9SRUcJCTB4MWMKKyNkZWZpbmUg IEJDTTYzMjhfTVVYX01BU0sJR0VOTUFTSygxLCAwKQorI2RlZmluZSBCQ002MzE4X1BBRF9SRUcJ CTB4NTQKKyNkZWZpbmUgIEJDTTYzMjhfUEFEX01BU0sJR0VOTUFTSygzLCAwKQorCitzdHJ1Y3Qg YmNtNjMxOF9waW5ncm91cCB7CisJY29uc3QgY2hhciAqbmFtZTsKKwljb25zdCB1bnNpZ25lZCAq IGNvbnN0IHBpbnM7CisJY29uc3QgdW5zaWduZWQgbnVtX3BpbnM7Cit9OworCitzdHJ1Y3QgYmNt NjMxOF9mdW5jdGlvbiB7CisJY29uc3QgY2hhciAqbmFtZTsKKwljb25zdCBjaGFyICogY29uc3Qg Kmdyb3VwczsKKwljb25zdCB1bnNpZ25lZCBudW1fZ3JvdXBzOworCisJdW5zaWduZWQgbW9kZV92 YWw6MTsKKwl1bnNpZ25lZCBtdXhfdmFsOjI7Cit9OworCitzdGF0aWMgY29uc3Qgc3RydWN0IHBp bmN0cmxfcGluX2Rlc2MgYmNtNjMxOF9waW5zW10gPSB7CisJUElOQ1RSTF9QSU4oMCwgImdwaW8w IiksCisJUElOQ1RSTF9QSU4oMSwgImdwaW8xIiksCisJUElOQ1RSTF9QSU4oMiwgImdwaW8yIiks CisJUElOQ1RSTF9QSU4oMywgImdwaW8zIiksCisJUElOQ1RSTF9QSU4oNCwgImdwaW80IiksCisJ UElOQ1RSTF9QSU4oNSwgImdwaW81IiksCisJUElOQ1RSTF9QSU4oNiwgImdwaW82IiksCisJUElO Q1RSTF9QSU4oNywgImdwaW83IiksCisJUElOQ1RSTF9QSU4oOCwgImdwaW84IiksCisJUElOQ1RS TF9QSU4oOSwgImdwaW85IiksCisJUElOQ1RSTF9QSU4oMTAsICJncGlvMTAiKSwKKwlQSU5DVFJM X1BJTigxMSwgImdwaW8xMSIpLAorCVBJTkNUUkxfUElOKDEyLCAiZ3BpbzEyIiksCisJUElOQ1RS TF9QSU4oMTMsICJncGlvMTMiKSwKKwlQSU5DVFJMX1BJTigxNCwgImdwaW8xNCIpLAorCVBJTkNU UkxfUElOKDE1LCAiZ3BpbzE1IiksCisJUElOQ1RSTF9QSU4oMTYsICJncGlvMTYiKSwKKwlQSU5D VFJMX1BJTigxNywgImdwaW8xNyIpLAorCVBJTkNUUkxfUElOKDE4LCAiZ3BpbzE4IiksCisJUElO Q1RSTF9QSU4oMTksICJncGlvMTkiKSwKKwlQSU5DVFJMX1BJTigyMCwgImdwaW8yMCIpLAorCVBJ TkNUUkxfUElOKDIxLCAiZ3BpbzIxIiksCisJUElOQ1RSTF9QSU4oMjIsICJncGlvMjIiKSwKKwlQ SU5DVFJMX1BJTigyMywgImdwaW8yMyIpLAorCVBJTkNUUkxfUElOKDI0LCAiZ3BpbzI0IiksCisJ UElOQ1RSTF9QSU4oMjUsICJncGlvMjUiKSwKKwlQSU5DVFJMX1BJTigyNiwgImdwaW8yNiIpLAor CVBJTkNUUkxfUElOKDI3LCAiZ3BpbzI3IiksCisJUElOQ1RSTF9QSU4oMjgsICJncGlvMjgiKSwK KwlQSU5DVFJMX1BJTigyOSwgImdwaW8yOSIpLAorCVBJTkNUUkxfUElOKDMwLCAiZ3BpbzMwIiks CisJUElOQ1RSTF9QSU4oMzEsICJncGlvMzEiKSwKKwlQSU5DVFJMX1BJTigzMiwgImdwaW8zMiIp LAorCVBJTkNUUkxfUElOKDMzLCAiZ3BpbzMzIiksCisJUElOQ1RSTF9QSU4oMzQsICJncGlvMzQi KSwKKwlQSU5DVFJMX1BJTigzNSwgImdwaW8zNSIpLAorCVBJTkNUUkxfUElOKDM2LCAiZ3BpbzM2 IiksCisJUElOQ1RSTF9QSU4oMzcsICJncGlvMzciKSwKKwlQSU5DVFJMX1BJTigzOCwgImdwaW8z OCIpLAorCVBJTkNUUkxfUElOKDM5LCAiZ3BpbzM5IiksCisJUElOQ1RSTF9QSU4oNDAsICJncGlv NDAiKSwKKwlQSU5DVFJMX1BJTig0MSwgImdwaW80MSIpLAorCVBJTkNUUkxfUElOKDQyLCAiZ3Bp bzQyIiksCisJUElOQ1RSTF9QSU4oNDMsICJncGlvNDMiKSwKKwlQSU5DVFJMX1BJTig0NCwgImdw aW80NCIpLAorCVBJTkNUUkxfUElOKDQ1LCAiZ3BpbzQ1IiksCisJUElOQ1RSTF9QSU4oNDYsICJn cGlvNDYiKSwKKwlQSU5DVFJMX1BJTig0NywgImdwaW80NyIpLAorCVBJTkNUUkxfUElOKDQ4LCAi Z3BpbzQ4IiksCisJUElOQ1RSTF9QSU4oNDksICJncGlvNDkiKSwKK307CisKK3N0YXRpYyB1bnNp Z25lZCBncGlvMF9waW5zW10gPSB7IDAgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMV9waW5zW10g PSB7IDEgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMl9waW5zW10gPSB7IDIgfTsKK3N0YXRpYyB1 bnNpZ25lZCBncGlvM19waW5zW10gPSB7IDMgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvNF9waW5z W10gPSB7IDQgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvNV9waW5zW10gPSB7IDUgfTsKK3N0YXRp YyB1bnNpZ25lZCBncGlvNl9waW5zW10gPSB7IDYgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvN19w aW5zW10gPSB7IDcgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvOF9waW5zW10gPSB7IDggfTsKK3N0 YXRpYyB1bnNpZ25lZCBncGlvOV9waW5zW10gPSB7IDkgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlv MTBfcGluc1tdID0geyAxMCB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8xMV9waW5zW10gPSB7IDEx IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzEyX3BpbnNbXSA9IHsgMTIgfTsKK3N0YXRpYyB1bnNp Z25lZCBncGlvMTNfcGluc1tdID0geyAxMyB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8xNF9waW5z W10gPSB7IDE0IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzE1X3BpbnNbXSA9IHsgMTUgfTsKK3N0 YXRpYyB1bnNpZ25lZCBncGlvMTZfcGluc1tdID0geyAxNiB9Oworc3RhdGljIHVuc2lnbmVkIGdw aW8xN19waW5zW10gPSB7IDE3IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzE4X3BpbnNbXSA9IHsg MTggfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMTlfcGluc1tdID0geyAxOSB9Oworc3RhdGljIHVu c2lnbmVkIGdwaW8yMF9waW5zW10gPSB7IDIwIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzIxX3Bp bnNbXSA9IHsgMjEgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMjJfcGluc1tdID0geyAyMiB9Owor c3RhdGljIHVuc2lnbmVkIGdwaW8yM19waW5zW10gPSB7IDIzIH07CitzdGF0aWMgdW5zaWduZWQg Z3BpbzI0X3BpbnNbXSA9IHsgMjQgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMjVfcGluc1tdID0g eyAyNSB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8yNl9waW5zW10gPSB7IDI2IH07CitzdGF0aWMg dW5zaWduZWQgZ3BpbzI3X3BpbnNbXSA9IHsgMjcgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMjhf cGluc1tdID0geyAyOCB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8yOV9waW5zW10gPSB7IDI5IH07 CitzdGF0aWMgdW5zaWduZWQgZ3BpbzMwX3BpbnNbXSA9IHsgMzAgfTsKK3N0YXRpYyB1bnNpZ25l ZCBncGlvMzFfcGluc1tdID0geyAzMSB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8zMl9waW5zW10g PSB7IDMyIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzMzX3BpbnNbXSA9IHsgMzMgfTsKK3N0YXRp YyB1bnNpZ25lZCBncGlvMzRfcGluc1tdID0geyAzNCB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8z NV9waW5zW10gPSB7IDM1IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzM2X3BpbnNbXSA9IHsgMzYg fTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMzdfcGluc1tdID0geyAzNyB9Oworc3RhdGljIHVuc2ln bmVkIGdwaW8zOF9waW5zW10gPSB7IDM4IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzM5X3BpbnNb XSA9IHsgMzkgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvNDBfcGluc1tdID0geyA0MCB9Oworc3Rh dGljIHVuc2lnbmVkIGdwaW80MV9waW5zW10gPSB7IDQxIH07CitzdGF0aWMgdW5zaWduZWQgZ3Bp bzQyX3BpbnNbXSA9IHsgNDIgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvNDNfcGluc1tdID0geyA0 MyB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW80NF9waW5zW10gPSB7IDQ0IH07CitzdGF0aWMgdW5z aWduZWQgZ3BpbzQ1X3BpbnNbXSA9IHsgNDUgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvNDZfcGlu c1tdID0geyA0NiB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW80N19waW5zW10gPSB7IDQ3IH07Citz dGF0aWMgdW5zaWduZWQgZ3BpbzQ4X3BpbnNbXSA9IHsgNDggfTsKK3N0YXRpYyB1bnNpZ25lZCBn cGlvNDlfcGluc1tdID0geyA0OSB9OworCisjZGVmaW5lIEJDTTYzMThfR1JPVVAobikJCQkJCVwK Kwl7CQkJCQkJCVwKKwkJLm5hbWUgPSAjbiwJCQkJCVwKKwkJLnBpbnMgPSBuIyNfcGlucywJCQkJ XAorCQkubnVtX3BpbnMgPSBBUlJBWV9TSVpFKG4jI19waW5zKSwJCVwKKwl9CisKK3N0YXRpYyBz dHJ1Y3QgYmNtNjMxOF9waW5ncm91cCBiY202MzE4X2dyb3Vwc1tdID0geworCUJDTTYzMThfR1JP VVAoZ3BpbzApLAorCUJDTTYzMThfR1JPVVAoZ3BpbzEpLAorCUJDTTYzMThfR1JPVVAoZ3BpbzIp LAorCUJDTTYzMThfR1JPVVAoZ3BpbzMpLAorCUJDTTYzMThfR1JPVVAoZ3BpbzQpLAorCUJDTTYz MThfR1JPVVAoZ3BpbzUpLAorCUJDTTYzMThfR1JPVVAoZ3BpbzYpLAorCUJDTTYzMThfR1JPVVAo Z3BpbzcpLAorCUJDTTYzMThfR1JPVVAoZ3BpbzgpLAorCUJDTTYzMThfR1JPVVAoZ3BpbzkpLAor CUJDTTYzMThfR1JPVVAoZ3BpbzEwKSwKKwlCQ002MzE4X0dST1VQKGdwaW8xMSksCisJQkNNNjMx OF9HUk9VUChncGlvMTIpLAorCUJDTTYzMThfR1JPVVAoZ3BpbzEzKSwKKwlCQ002MzE4X0dST1VQ KGdwaW8xNCksCisJQkNNNjMxOF9HUk9VUChncGlvMTUpLAorCUJDTTYzMThfR1JPVVAoZ3BpbzE2 KSwKKwlCQ002MzE4X0dST1VQKGdwaW8xNyksCisJQkNNNjMxOF9HUk9VUChncGlvMTgpLAorCUJD TTYzMThfR1JPVVAoZ3BpbzE5KSwKKwlCQ002MzE4X0dST1VQKGdwaW8yMCksCisJQkNNNjMxOF9H Uk9VUChncGlvMjEpLAorCUJDTTYzMThfR1JPVVAoZ3BpbzIyKSwKKwlCQ002MzE4X0dST1VQKGdw aW8yMyksCisJQkNNNjMxOF9HUk9VUChncGlvMjQpLAorCUJDTTYzMThfR1JPVVAoZ3BpbzI1KSwK KwlCQ002MzE4X0dST1VQKGdwaW8yNiksCisJQkNNNjMxOF9HUk9VUChncGlvMjcpLAorCUJDTTYz MThfR1JPVVAoZ3BpbzI4KSwKKwlCQ002MzE4X0dST1VQKGdwaW8yOSksCisJQkNNNjMxOF9HUk9V UChncGlvMzApLAorCUJDTTYzMThfR1JPVVAoZ3BpbzMxKSwKKwlCQ002MzE4X0dST1VQKGdwaW8z MiksCisJQkNNNjMxOF9HUk9VUChncGlvMzMpLAorCUJDTTYzMThfR1JPVVAoZ3BpbzM0KSwKKwlC Q002MzE4X0dST1VQKGdwaW8zNSksCisJQkNNNjMxOF9HUk9VUChncGlvMzYpLAorCUJDTTYzMThf R1JPVVAoZ3BpbzM3KSwKKwlCQ002MzE4X0dST1VQKGdwaW8zOCksCisJQkNNNjMxOF9HUk9VUChn cGlvMzkpLAorCUJDTTYzMThfR1JPVVAoZ3BpbzQwKSwKKwlCQ002MzE4X0dST1VQKGdwaW80MSks CisJQkNNNjMxOF9HUk9VUChncGlvNDIpLAorCUJDTTYzMThfR1JPVVAoZ3BpbzQzKSwKKwlCQ002 MzE4X0dST1VQKGdwaW80NCksCisJQkNNNjMxOF9HUk9VUChncGlvNDUpLAorCUJDTTYzMThfR1JP VVAoZ3BpbzQ2KSwKKwlCQ002MzE4X0dST1VQKGdwaW80NyksCisJQkNNNjMxOF9HUk9VUChncGlv NDgpLAorCUJDTTYzMThfR1JPVVAoZ3BpbzQ5KSwKK307CisKKy8qIEdQSU9fTU9ERSAqLworc3Rh dGljIGNvbnN0IGNoYXIgKiBjb25zdCBsZWRfZ3JvdXBzW10gPSB7CisJImdwaW8wIiwKKwkiZ3Bp bzEiLAorCSJncGlvMiIsCisJImdwaW8zIiwKKwkiZ3BpbzQiLAorCSJncGlvNSIsCisJImdwaW82 IiwKKwkiZ3BpbzciLAorCSJncGlvOCIsCisJImdwaW85IiwKKwkiZ3BpbzEwIiwKKwkiZ3BpbzEx IiwKKwkiZ3BpbzEyIiwKKwkiZ3BpbzEzIiwKKwkiZ3BpbzE0IiwKKwkiZ3BpbzE1IiwKKwkiZ3Bp bzE2IiwKKwkiZ3BpbzE3IiwKKwkiZ3BpbzE4IiwKKwkiZ3BpbzE5IiwKKwkiZ3BpbzIwIiwKKwki Z3BpbzIxIiwKKwkiZ3BpbzIyIiwKKwkiZ3BpbzIzIiwKK307CisKKy8qIFBJTk1VWF9TRUwgKi8K K3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgZXBoeTBfc3BkX2xlZF9ncm91cHNbXSA9IHsKKwki Z3BpbzAiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBlcGh5MV9zcGRfbGVkX2dy b3Vwc1tdID0geworCSJncGlvMSIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGVw aHkyX3NwZF9sZWRfZ3JvdXBzW10gPSB7CisJImdwaW8yIiwKK307CisKK3N0YXRpYyBjb25zdCBj aGFyICogY29uc3QgZXBoeTNfc3BkX2xlZF9ncm91cHNbXSA9IHsKKwkiZ3BpbzMiLAorfTsKKwor c3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBlcGh5MF9hY3RfbGVkX2dyb3Vwc1tdID0geworCSJn cGlvNCIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGVwaHkxX2FjdF9sZWRfZ3Jv dXBzW10gPSB7CisJImdwaW81IiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgZXBo eTJfYWN0X2xlZF9ncm91cHNbXSA9IHsKKwkiZ3BpbzYiLAorfTsKKworc3RhdGljIGNvbnN0IGNo YXIgKiBjb25zdCBlcGh5M19hY3RfbGVkX2dyb3Vwc1tdID0geworCSJncGlvNyIsCit9OworCitz dGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHNlcmlhbF9sZWRfZGF0YV9ncm91cHNbXSA9IHsKKwki Z3BpbzYiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBzZXJpYWxfbGVkX2Nsa19n cm91cHNbXSA9IHsKKwkiZ3BpbzciLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBp bmV0X2FjdF9sZWRfZ3JvdXBzW10gPSB7CisJImdwaW84IiwKK307CisKK3N0YXRpYyBjb25zdCBj aGFyICogY29uc3QgaW5ldF9mYWlsX2xlZF9ncm91cHNbXSA9IHsKKwkiZ3BpbzkiLAorfTsKKwor c3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBkc2xfbGVkX2dyb3Vwc1tdID0geworCSJncGlvMTAi LAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBwb3N0X2ZhaWxfbGVkX2dyb3Vwc1td ID0geworCSJncGlvMTEiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCB3bGFuX3dw c19sZWRfZ3JvdXBzW10gPSB7CisJImdwaW8xMiIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAq IGNvbnN0IHVzYl9wd3Jvbl9ncm91cHNbXSA9IHsKKwkiZ3BpbzEzIiwKK307CisKK3N0YXRpYyBj b25zdCBjaGFyICogY29uc3QgdXNiX2RldmljZV9sZWRfZ3JvdXBzW10gPSB7CisJImdwaW8xMyIs Cit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHVzYl9hY3RpdmVfZ3JvdXBzW10gPSB7 CisJImdwaW80MCIsCit9OworCisjZGVmaW5lIEJDTTYzMThfTU9ERV9GVU4obikJCQkJXAorCXsJ CQkJCQlcCisJCS5uYW1lID0gI24sCQkJCVwKKwkJLmdyb3VwcyA9IG4jI19ncm91cHMsCQkJXAor CQkubnVtX2dyb3VwcyA9IEFSUkFZX1NJWkUobiMjX2dyb3VwcyksCVwKKwkJLm1vZGVfdmFsID0g MSwJCQkJXAorCX0KKworI2RlZmluZSBCQ002MzE4X01VWF9GVU4obiwgbXV4KQkJCQlcCisJewkJ CQkJCVwKKwkJLm5hbWUgPSAjbiwJCQkJXAorCQkuZ3JvdXBzID0gbiMjX2dyb3VwcywJCQlcCisJ CS5udW1fZ3JvdXBzID0gQVJSQVlfU0laRShuIyNfZ3JvdXBzKSwJXAorCQkubXV4X3ZhbCA9IG11 eCwJCQkJXAorCX0KKworc3RhdGljIGNvbnN0IHN0cnVjdCBiY202MzE4X2Z1bmN0aW9uIGJjbTYz MThfZnVuY3NbXSA9IHsKKwlCQ002MzE4X01PREVfRlVOKGxlZCksCisJQkNNNjMxOF9NVVhfRlVO KGVwaHkwX3NwZF9sZWQsIDEpLAorCUJDTTYzMThfTVVYX0ZVTihlcGh5MV9zcGRfbGVkLCAxKSwK KwlCQ002MzE4X01VWF9GVU4oZXBoeTJfc3BkX2xlZCwgMSksCisJQkNNNjMxOF9NVVhfRlVOKGVw aHkzX3NwZF9sZWQsIDEpLAorCUJDTTYzMThfTVVYX0ZVTihlcGh5MF9hY3RfbGVkLCAxKSwKKwlC Q002MzE4X01VWF9GVU4oZXBoeTFfYWN0X2xlZCwgMSksCisJQkNNNjMxOF9NVVhfRlVOKGVwaHky X2FjdF9sZWQsIDEpLAorCUJDTTYzMThfTVVYX0ZVTihlcGh5M19hY3RfbGVkLCAxKSwKKwlCQ002 MzE4X01VWF9GVU4oc2VyaWFsX2xlZF9kYXRhLCAzKSwKKwlCQ002MzE4X01VWF9GVU4oc2VyaWFs X2xlZF9jbGssIDMpLAorCUJDTTYzMThfTVVYX0ZVTihpbmV0X2FjdF9sZWQsIDEpLAorCUJDTTYz MThfTVVYX0ZVTihpbmV0X2ZhaWxfbGVkLCAxKSwKKwlCQ002MzE4X01VWF9GVU4oZHNsX2xlZCwg MSksCisJQkNNNjMxOF9NVVhfRlVOKHBvc3RfZmFpbF9sZWQsIDEpLAorCUJDTTYzMThfTVVYX0ZV Tih3bGFuX3dwc19sZWQsIDEpLAorCUJDTTYzMThfTVVYX0ZVTih1c2JfcHdyb24sIDEpLAorCUJD TTYzMThfTVVYX0ZVTih1c2JfZGV2aWNlX2xlZCwgMiksCisJQkNNNjMxOF9NVVhfRlVOKHVzYl9h Y3RpdmUsIDIpLAorfTsKKworc3RhdGljIGlubGluZSB1bnNpZ25lZCBpbnQgYmNtNjMxOF9tdXhf b2ZmKHVuc2lnbmVkIGludCBwaW4pCit7CisJcmV0dXJuIEJDTTYzMThfTVVYX1JFRyArIChwaW4g LyAxNikgKiA0OworfQorCitzdGF0aWMgaW5saW5lIHVuc2lnbmVkIGludCBiY202MzE4X3BhZF9v ZmYodW5zaWduZWQgaW50IHBpbikKK3sKKwlyZXR1cm4gQkNNNjMxOF9QQURfUkVHICsgKHBpbiAv IDgpICogNDsKK30KKworc3RhdGljIGludCBiY202MzE4X3BpbmN0cmxfZ2V0X2dyb3VwX2NvdW50 KHN0cnVjdCBwaW5jdHJsX2RldiAqcGN0bGRldikKK3sKKwlyZXR1cm4gQVJSQVlfU0laRShiY202 MzE4X2dyb3Vwcyk7Cit9CisKK3N0YXRpYyBjb25zdCBjaGFyICpiY202MzE4X3BpbmN0cmxfZ2V0 X2dyb3VwX25hbWUoc3RydWN0IHBpbmN0cmxfZGV2ICpwY3RsZGV2LAorCQkJCQkJICB1bnNpZ25l ZCBncm91cCkKK3sKKwlyZXR1cm4gYmNtNjMxOF9ncm91cHNbZ3JvdXBdLm5hbWU7Cit9CisKK3N0 YXRpYyBpbnQgYmNtNjMxOF9waW5jdHJsX2dldF9ncm91cF9waW5zKHN0cnVjdCBwaW5jdHJsX2Rl diAqcGN0bGRldiwKKwkJCQkJICB1bnNpZ25lZCBncm91cCwgY29uc3QgdW5zaWduZWQgKipwaW5z LAorCQkJCQkgIHVuc2lnbmVkICpudW1fcGlucykKK3sKKwkqcGlucyA9IGJjbTYzMThfZ3JvdXBz W2dyb3VwXS5waW5zOworCSpudW1fcGlucyA9IGJjbTYzMThfZ3JvdXBzW2dyb3VwXS5udW1fcGlu czsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IGJjbTYzMThfcGluY3RybF9nZXRfZnVu Y19jb3VudChzdHJ1Y3QgcGluY3RybF9kZXYgKnBjdGxkZXYpCit7CisJcmV0dXJuIEFSUkFZX1NJ WkUoYmNtNjMxOF9mdW5jcyk7Cit9CisKK3N0YXRpYyBjb25zdCBjaGFyICpiY202MzE4X3BpbmN0 cmxfZ2V0X2Z1bmNfbmFtZShzdHJ1Y3QgcGluY3RybF9kZXYgKnBjdGxkZXYsCisJCQkJCQkgdW5z aWduZWQgc2VsZWN0b3IpCit7CisJcmV0dXJuIGJjbTYzMThfZnVuY3Nbc2VsZWN0b3JdLm5hbWU7 Cit9CisKK3N0YXRpYyBpbnQgYmNtNjMxOF9waW5jdHJsX2dldF9ncm91cHMoc3RydWN0IHBpbmN0 cmxfZGV2ICpwY3RsZGV2LAorCQkJCSAgICAgIHVuc2lnbmVkIHNlbGVjdG9yLAorCQkJCSAgICAg IGNvbnN0IGNoYXIgKiBjb25zdCAqKmdyb3VwcywKKwkJCQkgICAgICB1bnNpZ25lZCAqIGNvbnN0 IG51bV9ncm91cHMpCit7CisJKmdyb3VwcyA9IGJjbTYzMThfZnVuY3Nbc2VsZWN0b3JdLmdyb3Vw czsKKwkqbnVtX2dyb3VwcyA9IGJjbTYzMThfZnVuY3Nbc2VsZWN0b3JdLm51bV9ncm91cHM7CisK KwlyZXR1cm4gMDsKK30KKworc3RhdGljIGlubGluZSB2b2lkIGJjbTYzMThfcm13X211eChzdHJ1 Y3QgYmNtNjN4eF9waW5jdHJsICpwYywgdW5zaWduZWQgcGluLAorCQkJCSAgIHVuc2lnbmVkIGlu dCBtb2RlLCB1bnNpZ25lZCBpbnQgbXV4KQoreworCWlmIChwaW4gPCBCQ002M1hYX0JBTktfR1BJ T1MpCisJCXJlZ21hcF91cGRhdGVfYml0cyhwYy0+cmVncywgQkNNNjMxOF9NT0RFX1JFRywgQklU KHBpbiksCisJCQkJICAgbW9kZSA/IEJJVChwaW4pIDogMCk7CisKKwlpZiAocGluIDwgQkNNNjMx OF9OVU1fTVVYKQorCQlyZWdtYXBfdXBkYXRlX2JpdHMocGMtPnJlZ3MsCisJCQkJICAgYmNtNjMx OF9tdXhfb2ZmKHBpbiksCisJCQkJICAgQkNNNjMyOF9NVVhfTUFTSyA8PCAoKHBpbiAlIDE2KSAq IDIpLAorCQkJCSAgIG11eCA8PCAoKHBpbiAlIDE2KSAqIDIpKTsKK30KKworc3RhdGljIGlubGlu ZSB2b2lkIGJjbTYzMThfc2V0X3BhZChzdHJ1Y3QgYmNtNjN4eF9waW5jdHJsICpwYywgdW5zaWdu ZWQgcGluLAorCQkJCSAgIHVpbnQ4X3QgdmFsKQoreworCXJlZ21hcF91cGRhdGVfYml0cyhwYy0+ cmVncywgYmNtNjMxOF9wYWRfb2ZmKHBpbiksCisJCQkgICBCQ002MzI4X1BBRF9NQVNLIDw8ICgo cGluICUgOCkgKiA0KSwKKwkJCSAgIHZhbCA8PCAoKHBpbiAlIDgpICogNCkpOworfQorCitzdGF0 aWMgaW50IGJjbTYzMThfcGluY3RybF9zZXRfbXV4KHN0cnVjdCBwaW5jdHJsX2RldiAqcGN0bGRl diwKKwkJCQkgICB1bnNpZ25lZCBzZWxlY3RvciwgdW5zaWduZWQgZ3JvdXApCit7CisJc3RydWN0 IGJjbTYzeHhfcGluY3RybCAqcGMgPSBwaW5jdHJsX2Rldl9nZXRfZHJ2ZGF0YShwY3RsZGV2KTsK Kwljb25zdCBzdHJ1Y3QgYmNtNjMxOF9waW5ncm91cCAqcGcgPSAmYmNtNjMxOF9ncm91cHNbZ3Jv dXBdOworCWNvbnN0IHN0cnVjdCBiY202MzE4X2Z1bmN0aW9uICpmID0gJmJjbTYzMThfZnVuY3Nb c2VsZWN0b3JdOworCisJYmNtNjMxOF9ybXdfbXV4KHBjLCBwZy0+cGluc1swXSwgZi0+bW9kZV92 YWwsIGYtPm11eF92YWwpOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgYmNtNjMxOF9n cGlvX3JlcXVlc3RfZW5hYmxlKHN0cnVjdCBwaW5jdHJsX2RldiAqcGN0bGRldiwKKwkJCQkgICAg ICAgc3RydWN0IHBpbmN0cmxfZ3Bpb19yYW5nZSAqcmFuZ2UsCisJCQkJICAgICAgIHVuc2lnbmVk IG9mZnNldCkKK3sKKwlzdHJ1Y3QgYmNtNjN4eF9waW5jdHJsICpwYyA9IHBpbmN0cmxfZGV2X2dl dF9kcnZkYXRhKHBjdGxkZXYpOworCisJLyogZGlzYWJsZSBhbGwgZnVuY3Rpb25zIHVzaW5nIHRo aXMgcGluICovCisJaWYgKG9mZnNldCA8IDEzKSB7CisJCS8qIEdQSU9zIDAtMTIgdXNlIG11eCAw IGFzIEdQSU8gZnVuY3Rpb24gKi8KKwkJYmNtNjMxOF9ybXdfbXV4KHBjLCBvZmZzZXQsIDAsIDAp OworCX0gZWxzZSBpZiAob2Zmc2V0IDwgNDIpIHsKKwkJLyogR1BJT3MgMTMtNDEgdXNlIG11eCAz IGFzIEdQSU8gZnVuY3Rpb24gKi8KKwkJYmNtNjMxOF9ybXdfbXV4KHBjLCBvZmZzZXQsIDAsIDMp OworCisJCWJjbTYzMThfc2V0X3BhZChwYywgb2Zmc2V0LCAwKTsKKwl9CisKKwlyZXR1cm4gMDsK K30KKworc3RhdGljIHN0cnVjdCBwaW5jdHJsX29wcyBiY202MzE4X3BjdGxfb3BzID0geworCS5k dF9mcmVlX21hcCA9IHBpbmN0cmxfdXRpbHNfZnJlZV9tYXAsCisJLmR0X25vZGVfdG9fbWFwID0g cGluY29uZl9nZW5lcmljX2R0X25vZGVfdG9fbWFwX3BpbiwKKwkuZ2V0X2dyb3VwX25hbWUgPSBi Y202MzE4X3BpbmN0cmxfZ2V0X2dyb3VwX25hbWUsCisJLmdldF9ncm91cF9waW5zID0gYmNtNjMx OF9waW5jdHJsX2dldF9ncm91cF9waW5zLAorCS5nZXRfZ3JvdXBzX2NvdW50ID0gYmNtNjMxOF9w aW5jdHJsX2dldF9ncm91cF9jb3VudCwKK307CisKK3N0YXRpYyBzdHJ1Y3QgcGlubXV4X29wcyBi Y202MzE4X3BteF9vcHMgPSB7CisJLmdldF9mdW5jdGlvbl9ncm91cHMgPSBiY202MzE4X3BpbmN0 cmxfZ2V0X2dyb3VwcywKKwkuZ2V0X2Z1bmN0aW9uX25hbWUgPSBiY202MzE4X3BpbmN0cmxfZ2V0 X2Z1bmNfbmFtZSwKKwkuZ2V0X2Z1bmN0aW9uc19jb3VudCA9IGJjbTYzMThfcGluY3RybF9nZXRf ZnVuY19jb3VudCwKKwkuZ3Bpb19yZXF1ZXN0X2VuYWJsZSA9IGJjbTYzMThfZ3Bpb19yZXF1ZXN0 X2VuYWJsZSwKKwkuc2V0X211eCA9IGJjbTYzMThfcGluY3RybF9zZXRfbXV4LAorCS5zdHJpY3Qg PSB0cnVlLAorfTsKKworc3RhdGljIGNvbnN0IHN0cnVjdCBiY202M3h4X3BpbmN0cmxfc29jIGJj bTYzMThfc29jID0geworCS5uZ3Bpb3MgPSBCQ002MzE4X05VTV9HUElPUywKKwkubnBpbnMgPSBB UlJBWV9TSVpFKGJjbTYzMThfcGlucyksCisJLnBjdGxfb3BzID0gJmJjbTYzMThfcGN0bF9vcHMs CisJLnBpbnMgPSBiY202MzE4X3BpbnMsCisJLnBteF9vcHMgPSAmYmNtNjMxOF9wbXhfb3BzLAor fTsKKworc3RhdGljIGludCBiY202MzE4X3BpbmN0cmxfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2Rl dmljZSAqcGRldikKK3sKKwlyZXR1cm4gYmNtNjN4eF9waW5jdHJsX3Byb2JlKHBkZXYsICZiY202 MzE4X3NvYywgTlVMTCk7Cit9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgb2ZfZGV2aWNlX2lkIGJj bTYzMThfcGluY3RybF9tYXRjaFtdID0geworCXsgLmNvbXBhdGlibGUgPSAiYnJjbSxiY202MzE4 LXBpbmN0cmwiLCB9LAorCXsgLyogc2VudGluZWwgKi8gfQorfTsKKworc3RhdGljIHN0cnVjdCBw bGF0Zm9ybV9kcml2ZXIgYmNtNjMxOF9waW5jdHJsX2RyaXZlciA9IHsKKwkucHJvYmUgPSBiY202 MzE4X3BpbmN0cmxfcHJvYmUsCisJLmRyaXZlciA9IHsKKwkJLm5hbWUgPSAiYmNtNjMxOC1waW5j dHJsIiwKKwkJLm9mX21hdGNoX3RhYmxlID0gYmNtNjMxOF9waW5jdHJsX21hdGNoLAorCX0sCit9 OworCitidWlsdGluX3BsYXRmb3JtX2RyaXZlcihiY202MzE4X3BpbmN0cmxfZHJpdmVyKTsKLS0g CjIuMjAuMQoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f CmxpbnV4LWFybS1rZXJuZWwgbWFpbGluZyBsaXN0CmxpbnV4LWFybS1rZXJuZWxAbGlzdHMuaW5m cmFkZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xp bnV4LWFybS1rZXJuZWwK