From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-15.7 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 48877C1550D for ; Sat, 6 Mar 2021 15:58:21 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 344C565009 for ; Sat, 6 Mar 2021 15:58:21 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230449AbhCFP5x (ORCPT ); Sat, 6 Mar 2021 10:57:53 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:50958 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231135AbhCFP5Y (ORCPT ); Sat, 6 Mar 2021 10:57:24 -0500 Received: from mail-wr1-x42d.google.com (mail-wr1-x42d.google.com [IPv6:2a00:1450:4864:20::42d]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id E0F1FC06174A; Sat, 6 Mar 2021 07:57:23 -0800 (PST) Received: by mail-wr1-x42d.google.com with SMTP id v15so5944401wrx.4; Sat, 06 Mar 2021 07:57:23 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:subject:date:message-id:in-reply-to:references:mime-version :content-transfer-encoding; bh=wgH8bjPGd47U9CRhOpc3iN2RKJ/IPWk0EGAvTdFVyyI=; b=Ve1cOKHiinc3b7nUOkrVMyW3/G7WI5uG20PhksuWsKnKdrJufPkVRfDAMok+9RJDvO /i0SS1Y1+uxRO1rDrsNRO7jd4Pjk0PRrkw8Z6NTOAtNyUF8sX90IPtzg4vfiHKHOZWJN oEdv7b5KPpRly8IqOr3EHPnfbP99Ay2Yk2LAgXi1JErNdfZ6YvVFRmOwJT7Mw3IHKnT6 lalC/6skZUqREFdaWZWgTJlUYMdiznDXb9niK6b9oMVDN/XRfGib/Ru+6l4B7bU4JPrp vmy9svpkqZCDsaaWngZcbXZknHUkYBO1bPZGpeWrzQzgPYtGCqH6xdmq75o9SpbRn9au rf1g== 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=wgH8bjPGd47U9CRhOpc3iN2RKJ/IPWk0EGAvTdFVyyI=; b=ANTv91fAIt9npxG59BwsbO+Gcg4Pgfwsx/IKAsuRwTnu8GyMWxCqWCw5xcGTCr3Qs5 fvHd8jSSdDy4G8tj4eRewIiXz4LpOI9qXMV5NFN9sbX1WffG4Txe96KpCrTEl8ltd1b1 EIGcC8A90509GYMNaacfOFltNegK51qUCh/GnGLBXNOZ2FHLZ45cAzylaWQ82olFm1Yw nPCjqK12UaNg1crkK/C40qHnfhPILHZurH2zvGsFeaXlPLZs+SwiakIF/FcZkIHzmcwK hpKsqP4M+6/Pnxu1QX9hEY1QQqnmwfyzB7CZDMXelFwjenk1J1x4KWd9zdyxXcE8XyRI 0/Vw== X-Gm-Message-State: AOAM5332Ls40GZM2UD1yGT6worgbW32VCVA51WdtHK4tsrp8rHmqbsF+ Yezm17IJtvV7c/amGfs2Ypg= X-Google-Smtp-Source: ABdhPJyE97VJGEvIO+U2eyn2ER5hB6YWZllE9wFGJ47ReEVnVj/xNXQN4izsAFYS54Mku2FSuwTaww== X-Received: by 2002:a5d:6807:: with SMTP id w7mr14443526wru.103.1615046242572; Sat, 06 Mar 2021 07:57:22 -0800 (PST) Received: from skynet.lan (224.red-2-138-103.dynamicip.rima-tde.net. [2.138.103.224]) by smtp.gmail.com with ESMTPSA id p6sm9315188wru.2.2021.03.06.07.57.21 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 06 Mar 2021 07:57:22 -0800 (PST) From: =?UTF-8?q?=C3=81lvaro=20Fern=C3=A1ndez=20Rojas?= To: Linus Walleij , Rob Herring , Michael Walle , Bartosz Golaszewski , Florian Fainelli , bcm-kernel-feedback-list@broadcom.com, Jonas Gorski , =?UTF-8?q?=C3=81lvaro=20Fern=C3=A1ndez=20Rojas?= , Necip Fazil Yildiran , Andy Shevchenko , linux-gpio@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [PATCH v5 11/15] pinctrl: add a pincontrol driver for BCM6368 Date: Sat, 6 Mar 2021 16:57:08 +0100 Message-Id: <20210306155712.4298-12-noltari@gmail.com> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20210306155712.4298-1-noltari@gmail.com> References: <20210306155712.4298-1-noltari@gmail.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-gpio@vger.kernel.org Add a pincontrol driver for BCM6368. BCM6368 allows muxing the first 32 GPIOs onto alternative functions. Not all are documented. Signed-off-by: Jonas Gorski Co-developed-by: Jonas Gorski Signed-off-by: Álvaro Fernández Rojas --- v5: add changes suggested by Andy Shevchenko v4: no changes v3: use new shared code v2: switch to GPIO_REGMAP drivers/pinctrl/bcm/Kconfig | 8 + drivers/pinctrl/bcm/Makefile | 1 + drivers/pinctrl/bcm/pinctrl-bcm6368.c | 523 ++++++++++++++++++++++++++ 3 files changed, 532 insertions(+) create mode 100644 drivers/pinctrl/bcm/pinctrl-bcm6368.c diff --git a/drivers/pinctrl/bcm/Kconfig b/drivers/pinctrl/bcm/Kconfig index d3101d5e750f..aabd4b762aed 100644 --- a/drivers/pinctrl/bcm/Kconfig +++ b/drivers/pinctrl/bcm/Kconfig @@ -60,6 +60,14 @@ config PINCTRL_BCM6362 help Say Y here to enable the Broadcom BCM6362 GPIO driver. +config PINCTRL_BCM6368 + bool "Broadcom BCM6368 GPIO driver" + depends on (BMIPS_GENERIC || COMPILE_TEST) + select PINCTRL_BCM63XX + default BMIPS_GENERIC + help + Say Y here to enable the Broadcom BCM6368 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 b9b09e5b914c..a1331bb9680e 100644 --- a/drivers/pinctrl/bcm/Makefile +++ b/drivers/pinctrl/bcm/Makefile @@ -7,6 +7,7 @@ obj-$(CONFIG_PINCTRL_BCM63XX) += pinctrl-bcm63xx.o obj-$(CONFIG_PINCTRL_BCM6328) += pinctrl-bcm6328.o obj-$(CONFIG_PINCTRL_BCM6358) += pinctrl-bcm6358.o obj-$(CONFIG_PINCTRL_BCM6362) += pinctrl-bcm6362.o +obj-$(CONFIG_PINCTRL_BCM6368) += pinctrl-bcm6368.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-bcm6368.c b/drivers/pinctrl/bcm/pinctrl-bcm6368.c new file mode 100644 index 000000000000..838095f9e890 --- /dev/null +++ b/drivers/pinctrl/bcm/pinctrl-bcm6368.c @@ -0,0 +1,523 @@ +// SPDX-License-Identifier: GPL-2.0+ +/* + * Driver for BCM6368 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 BCM6368_NUM_GPIOS 38 + +#define BCM6368_MODE_REG 0x18 +#define BCM6368_BASEMODE_REG 0x38 +#define BCM6368_BASEMODE_MASK 0x7 +#define BCM6368_BASEMODE_GPIO 0x0 +#define BCM6368_BASEMODE_UART1 0x1 + +struct bcm6368_pingroup { + const char *name; + const unsigned * const pins; + const unsigned num_pins; +}; + +struct bcm6368_function { + const char *name; + const char * const *groups; + const unsigned num_groups; + + unsigned dir_out:16; + unsigned basemode:3; +}; + +struct bcm6368_priv { + struct regmap_field *overlays; +}; + +#define BCM6368_BASEMODE_PIN(a, b) \ + { \ + .number = a, \ + .name = b, \ + .drv_data = (void *)true \ + } + +static const struct pinctrl_pin_desc bcm6368_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"), + BCM6368_BASEMODE_PIN(30, "gpio30"), + BCM6368_BASEMODE_PIN(31, "gpio31"), + BCM6368_BASEMODE_PIN(32, "gpio32"), + BCM6368_BASEMODE_PIN(33, "gpio33"), + PINCTRL_PIN(34, "gpio34"), + PINCTRL_PIN(35, "gpio35"), + PINCTRL_PIN(36, "gpio36"), + PINCTRL_PIN(37, "gpio37"), +}; + +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 uart1_grp_pins[] = { 30, 31, 32, 33 }; + +#define BCM6368_GROUP(n) \ + { \ + .name = #n, \ + .pins = n##_pins, \ + .num_pins = ARRAY_SIZE(n##_pins), \ + } + +static struct bcm6368_pingroup bcm6368_groups[] = { + BCM6368_GROUP(gpio0), + BCM6368_GROUP(gpio1), + BCM6368_GROUP(gpio2), + BCM6368_GROUP(gpio3), + BCM6368_GROUP(gpio4), + BCM6368_GROUP(gpio5), + BCM6368_GROUP(gpio6), + BCM6368_GROUP(gpio7), + BCM6368_GROUP(gpio8), + BCM6368_GROUP(gpio9), + BCM6368_GROUP(gpio10), + BCM6368_GROUP(gpio11), + BCM6368_GROUP(gpio12), + BCM6368_GROUP(gpio13), + BCM6368_GROUP(gpio14), + BCM6368_GROUP(gpio15), + BCM6368_GROUP(gpio16), + BCM6368_GROUP(gpio17), + BCM6368_GROUP(gpio18), + BCM6368_GROUP(gpio19), + BCM6368_GROUP(gpio20), + BCM6368_GROUP(gpio21), + BCM6368_GROUP(gpio22), + BCM6368_GROUP(gpio23), + BCM6368_GROUP(gpio24), + BCM6368_GROUP(gpio25), + BCM6368_GROUP(gpio26), + BCM6368_GROUP(gpio27), + BCM6368_GROUP(gpio28), + BCM6368_GROUP(gpio29), + BCM6368_GROUP(gpio30), + BCM6368_GROUP(gpio31), + BCM6368_GROUP(uart1_grp), +}; + +static const char * const analog_afe_0_groups[] = { + "gpio0", +}; + +static const char * const analog_afe_1_groups[] = { + "gpio1", +}; + +static const char * const sys_irq_groups[] = { + "gpio2", +}; + +static const char * const serial_led_data_groups[] = { + "gpio3", +}; + +static const char * const serial_led_clk_groups[] = { + "gpio4", +}; + +static const char * const inet_led_groups[] = { + "gpio5", +}; + +static const char * const ephy0_led_groups[] = { + "gpio6", +}; + +static const char * const ephy1_led_groups[] = { + "gpio7", +}; + +static const char * const ephy2_led_groups[] = { + "gpio8", +}; + +static const char * const ephy3_led_groups[] = { + "gpio9", +}; + +static const char * const robosw_led_data_groups[] = { + "gpio10", +}; + +static const char * const robosw_led_clk_groups[] = { + "gpio11", +}; + +static const char * const robosw_led0_groups[] = { + "gpio12", +}; + +static const char * const robosw_led1_groups[] = { + "gpio13", +}; + +static const char * const usb_device_led_groups[] = { + "gpio14", +}; + +static const char * const pci_req1_groups[] = { + "gpio16", +}; + +static const char * const pci_gnt1_groups[] = { + "gpio17", +}; + +static const char * const pci_intb_groups[] = { + "gpio18", +}; + +static const char * const pci_req0_groups[] = { + "gpio19", +}; + +static const char * const pci_gnt0_groups[] = { + "gpio20", +}; + +static const char * const pcmcia_cd1_groups[] = { + "gpio22", +}; + +static const char * const pcmcia_cd2_groups[] = { + "gpio23", +}; + +static const char * const pcmcia_vs1_groups[] = { + "gpio24", +}; + +static const char * const pcmcia_vs2_groups[] = { + "gpio25", +}; + +static const char * const ebi_cs2_groups[] = { + "gpio26", +}; + +static const char * const ebi_cs3_groups[] = { + "gpio27", +}; + +static const char * const spi_cs2_groups[] = { + "gpio28", +}; + +static const char * const spi_cs3_groups[] = { + "gpio29", +}; + +static const char * const spi_cs4_groups[] = { + "gpio30", +}; + +static const char * const spi_cs5_groups[] = { + "gpio31", +}; + +static const char * const uart1_groups[] = { + "uart1_grp", +}; + +#define BCM6368_FUN(n, out) \ + { \ + .name = #n, \ + .groups = n##_groups, \ + .num_groups = ARRAY_SIZE(n##_groups), \ + .dir_out = out, \ + } + +#define BCM6368_BASEMODE_FUN(n, val, out) \ + { \ + .name = #n, \ + .groups = n##_groups, \ + .num_groups = ARRAY_SIZE(n##_groups), \ + .basemode = BCM6368_BASEMODE_##val, \ + .dir_out = out, \ + } + +static const struct bcm6368_function bcm6368_funcs[] = { + BCM6368_FUN(analog_afe_0, 1), + BCM6368_FUN(analog_afe_1, 1), + BCM6368_FUN(sys_irq, 1), + BCM6368_FUN(serial_led_data, 1), + BCM6368_FUN(serial_led_clk, 1), + BCM6368_FUN(inet_led, 1), + BCM6368_FUN(ephy0_led, 1), + BCM6368_FUN(ephy1_led, 1), + BCM6368_FUN(ephy2_led, 1), + BCM6368_FUN(ephy3_led, 1), + BCM6368_FUN(robosw_led_data, 1), + BCM6368_FUN(robosw_led_clk, 1), + BCM6368_FUN(robosw_led0, 1), + BCM6368_FUN(robosw_led1, 1), + BCM6368_FUN(usb_device_led, 1), + BCM6368_FUN(pci_req1, 0), + BCM6368_FUN(pci_gnt1, 0), + BCM6368_FUN(pci_intb, 0), + BCM6368_FUN(pci_req0, 0), + BCM6368_FUN(pci_gnt0, 0), + BCM6368_FUN(pcmcia_cd1, 0), + BCM6368_FUN(pcmcia_cd2, 0), + BCM6368_FUN(pcmcia_vs1, 0), + BCM6368_FUN(pcmcia_vs2, 0), + BCM6368_FUN(ebi_cs2, 1), + BCM6368_FUN(ebi_cs3, 1), + BCM6368_FUN(spi_cs2, 1), + BCM6368_FUN(spi_cs3, 1), + BCM6368_FUN(spi_cs4, 1), + BCM6368_FUN(spi_cs5, 1), + BCM6368_BASEMODE_FUN(uart1, UART1, 0x6), +}; + +static int bcm6368_pinctrl_get_group_count(struct pinctrl_dev *pctldev) +{ + return ARRAY_SIZE(bcm6368_groups); +} + +static const char *bcm6368_pinctrl_get_group_name(struct pinctrl_dev *pctldev, + unsigned group) +{ + return bcm6368_groups[group].name; +} + +static int bcm6368_pinctrl_get_group_pins(struct pinctrl_dev *pctldev, + unsigned group, const unsigned **pins, + unsigned *num_pins) +{ + *pins = bcm6368_groups[group].pins; + *num_pins = bcm6368_groups[group].num_pins; + + return 0; +} + +static int bcm6368_pinctrl_get_func_count(struct pinctrl_dev *pctldev) +{ + return ARRAY_SIZE(bcm6368_funcs); +} + +static const char *bcm6368_pinctrl_get_func_name(struct pinctrl_dev *pctldev, + unsigned selector) +{ + return bcm6368_funcs[selector].name; +} + +static int bcm6368_pinctrl_get_groups(struct pinctrl_dev *pctldev, + unsigned selector, + const char * const **groups, + unsigned * const num_groups) +{ + *groups = bcm6368_funcs[selector].groups; + *num_groups = bcm6368_funcs[selector].num_groups; + + return 0; +} + +static int bcm6368_pinctrl_set_mux(struct pinctrl_dev *pctldev, + unsigned selector, unsigned group) +{ + struct bcm63xx_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev); + struct bcm6368_priv *priv = pc->driver_data; + const struct bcm6368_pingroup *pg = &bcm6368_groups[group]; + const struct bcm6368_function *fun = &bcm6368_funcs[selector]; + int i, pin; + + if (fun->basemode) { + unsigned int mask = 0; + + for (i = 0; i < pg->num_pins; i++) { + pin = pg->pins[i]; + if (pin < BCM63XX_BANK_GPIOS) + mask |= BIT(pin); + } + + regmap_update_bits(pc->regs, BCM6368_MODE_REG, mask, 0); + regmap_field_write(priv->overlays, fun->basemode); + } else { + pin = pg->pins[0]; + + if (bcm6368_pins[pin].drv_data) + regmap_field_write(priv->overlays, + BCM6368_BASEMODE_GPIO); + + regmap_update_bits(pc->regs, BCM6368_MODE_REG, BIT(pin), + BIT(pin)); + } + + for (pin = 0; pin < pg->num_pins; pin++) { + struct pinctrl_gpio_range *range; + int hw_gpio = bcm6368_pins[pin].number; + + range = pinctrl_find_gpio_range_from_pin(pctldev, hw_gpio); + if (range) { + struct gpio_chip *gc = range->gc; + + if (fun->dir_out & BIT(pin)) + gc->direction_output(gc, hw_gpio, 0); + else + gc->direction_input(gc, hw_gpio); + } + } + + return 0; +} + +static int bcm6368_gpio_request_enable(struct pinctrl_dev *pctldev, + struct pinctrl_gpio_range *range, + unsigned offset) +{ + struct bcm63xx_pinctrl *pc = pinctrl_dev_get_drvdata(pctldev); + struct bcm6368_priv *priv = pc->driver_data; + + if (offset >= BCM63XX_BANK_GPIOS && !bcm6368_pins[offset].drv_data) + return 0; + + /* disable all functions using this pin */ + if (offset < BCM63XX_BANK_GPIOS) + regmap_update_bits(pc->regs, BCM6368_MODE_REG, BIT(offset), 0); + + if (bcm6368_pins[offset].drv_data) + regmap_field_write(priv->overlays, BCM6368_BASEMODE_GPIO); + + return 0; +} + +static struct pinctrl_ops bcm6368_pctl_ops = { + .dt_free_map = pinctrl_utils_free_map, + .dt_node_to_map = pinconf_generic_dt_node_to_map_pin, + .get_group_name = bcm6368_pinctrl_get_group_name, + .get_group_pins = bcm6368_pinctrl_get_group_pins, + .get_groups_count = bcm6368_pinctrl_get_group_count, +}; + +static struct pinmux_ops bcm6368_pmx_ops = { + .get_function_groups = bcm6368_pinctrl_get_groups, + .get_function_name = bcm6368_pinctrl_get_func_name, + .get_functions_count = bcm6368_pinctrl_get_func_count, + .gpio_request_enable = bcm6368_gpio_request_enable, + .set_mux = bcm6368_pinctrl_set_mux, + .strict = true, +}; + +static const struct bcm63xx_pinctrl_soc bcm6368_soc = { + .ngpios = BCM6368_NUM_GPIOS, + .npins = ARRAY_SIZE(bcm6368_pins), + .pctl_ops = &bcm6368_pctl_ops, + .pins = bcm6368_pins, + .pmx_ops = &bcm6368_pmx_ops, +}; + +static int bcm6368_pinctrl_probe(struct platform_device *pdev) +{ + struct reg_field overlays = REG_FIELD(BCM6368_BASEMODE_REG, 0, 15); + struct device *dev = &pdev->dev; + struct bcm63xx_pinctrl *pc; + struct bcm6368_priv *priv; + int err; + + priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); + if (!priv) + return -ENOMEM; + + err = bcm63xx_pinctrl_probe(pdev, &bcm6368_soc, (void *) priv); + if (err) + return err; + + pc = platform_get_drvdata(pdev); + + priv->overlays = devm_regmap_field_alloc(dev, pc->regs, overlays); + if (IS_ERR(priv->overlays)) + return PTR_ERR(priv->overlays); + + return 0; +} + +static const struct of_device_id bcm6368_pinctrl_match[] = { + { .compatible = "brcm,bcm6368-pinctrl", }, + { /* sentinel */ } +}; + +static struct platform_driver bcm6368_pinctrl_driver = { + .probe = bcm6368_pinctrl_probe, + .driver = { + .name = "bcm6368-pinctrl", + .of_match_table = bcm6368_pinctrl_match, + }, +}; + +builtin_platform_driver(bcm6368_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 08D01C433DB for ; Sat, 6 Mar 2021 16:00:35 +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 52F5164FF0 for ; Sat, 6 Mar 2021 16:00:34 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 52F5164FF0 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=RpgxJ13HIpEJ6lEqMaEMYSMw0508ayGnB5GusTcLAFI=; b=Glkjf30dXFqo7RQ+SaqU+Nk82 QJnbJ367F/AazMHPx/zJg7Ru9VYR6Wa1a4bSZf3rtMGIDE9gbDmZgzVxN5ycgM96S7+rrq6MiH+Y2 58ZGtsbw8D2JE22R6mWCqE5kNjY6sX81S0VuvxPGKmcbR2dNG9zp69RJGB6d2WprDrwQpWnR3sugt AEp2fWuBP7lv0zFopRCHjou5UX6hfZr4LR6did5n5wvoSAANdOz2tJf+A/q67QREfwvzfshcaszc3 SWMp6VC4pWu3b9aJ0TYMm+9FxplVghoLE4ELJy+56BsESt9C2q6VBgXysOKqBmgK+9iYrn2EhRlDE K5p37M38g==; Received: from localhost ([::1] helo=desiato.infradead.org) by desiato.infradead.org with esmtp (Exim 4.94 #2 (Red Hat Linux)) id 1lIZKQ-003VUz-WF; Sat, 06 Mar 2021 15:58:55 +0000 Received: from mail-wr1-x42d.google.com ([2a00:1450:4864:20::42d]) by desiato.infradead.org with esmtps (Exim 4.94 #2 (Red Hat Linux)) id 1lIZIx-003Utb-3H for linux-arm-kernel@lists.infradead.org; Sat, 06 Mar 2021 15:57:27 +0000 Received: by mail-wr1-x42d.google.com with SMTP id e10so5905057wro.12 for ; Sat, 06 Mar 2021 07:57:22 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:subject:date:message-id:in-reply-to:references:mime-version :content-transfer-encoding; bh=wgH8bjPGd47U9CRhOpc3iN2RKJ/IPWk0EGAvTdFVyyI=; b=Ve1cOKHiinc3b7nUOkrVMyW3/G7WI5uG20PhksuWsKnKdrJufPkVRfDAMok+9RJDvO /i0SS1Y1+uxRO1rDrsNRO7jd4Pjk0PRrkw8Z6NTOAtNyUF8sX90IPtzg4vfiHKHOZWJN oEdv7b5KPpRly8IqOr3EHPnfbP99Ay2Yk2LAgXi1JErNdfZ6YvVFRmOwJT7Mw3IHKnT6 lalC/6skZUqREFdaWZWgTJlUYMdiznDXb9niK6b9oMVDN/XRfGib/Ru+6l4B7bU4JPrp vmy9svpkqZCDsaaWngZcbXZknHUkYBO1bPZGpeWrzQzgPYtGCqH6xdmq75o9SpbRn9au rf1g== 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=wgH8bjPGd47U9CRhOpc3iN2RKJ/IPWk0EGAvTdFVyyI=; b=DidRsB6UOdbLit1ytAVHgcdJ/2RrC+z2NzIYsCLKMCveK64tHDCoyY/xKNe77UrbId 5rUrrmAXR9l5K2B0+aJVRt1g/Fj51u6NumJFKmHjzWL3JgMwAa4gV9H7iYu5Qd6+ue2e KXIFKL6YZ8qLXUUM2Vfoh9m8wfMWDoDZjP+w3A4fhzlpYqL639hoyEsiVs/JlHrPIfCO lw/vlPib7SgKcZl9pPKwePo59GPmzfTl93OIgKgsmI+J7sDm7LI/roTBBbW9pzg/atZj 0ozghsZqXZLSgj6WUGuqDK2Tyixzu+N6WCc1fNj7f2rD4wAgr+SnBckDftKVLTr1yS86 lVrg== X-Gm-Message-State: AOAM532Y9Zbl/FWEKBFgKr3/o1v1W3IRrkzQ7sxGm1KqcYP9GNLBOoNd WiDyV3J6cdSSNe2QN2jRp58= X-Google-Smtp-Source: ABdhPJyE97VJGEvIO+U2eyn2ER5hB6YWZllE9wFGJ47ReEVnVj/xNXQN4izsAFYS54Mku2FSuwTaww== X-Received: by 2002:a5d:6807:: with SMTP id w7mr14443526wru.103.1615046242572; Sat, 06 Mar 2021 07:57:22 -0800 (PST) Received: from skynet.lan (224.red-2-138-103.dynamicip.rima-tde.net. [2.138.103.224]) by smtp.gmail.com with ESMTPSA id p6sm9315188wru.2.2021.03.06.07.57.21 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 06 Mar 2021 07:57:22 -0800 (PST) From: =?UTF-8?q?=C3=81lvaro=20Fern=C3=A1ndez=20Rojas?= To: Linus Walleij , Rob Herring , Michael Walle , Bartosz Golaszewski , Florian Fainelli , bcm-kernel-feedback-list@broadcom.com, Jonas Gorski , =?UTF-8?q?=C3=81lvaro=20Fern=C3=A1ndez=20Rojas?= , Necip Fazil Yildiran , Andy Shevchenko , linux-gpio@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [PATCH v5 11/15] pinctrl: add a pincontrol driver for BCM6368 Date: Sat, 6 Mar 2021 16:57:08 +0100 Message-Id: <20210306155712.4298-12-noltari@gmail.com> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20210306155712.4298-1-noltari@gmail.com> References: <20210306155712.4298-1-noltari@gmail.com> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20210306_155723_566533_27B55D60 X-CRM114-Status: GOOD ( 20.76 ) 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 QWRkIGEgcGluY29udHJvbCBkcml2ZXIgZm9yIEJDTTYzNjguIEJDTTYzNjggYWxsb3dzIG11eGlu ZyB0aGUgZmlyc3QgMzIKR1BJT3Mgb250byBhbHRlcm5hdGl2ZSBmdW5jdGlvbnMuIE5vdCBhbGwg YXJlIGRvY3VtZW50ZWQuCgpTaWduZWQtb2ZmLWJ5OiBKb25hcyBHb3Jza2kgPGpvbmFzLmdvcnNr aUBnbWFpbC5jb20+CkNvLWRldmVsb3BlZC1ieTogSm9uYXMgR29yc2tpIDxqb25hcy5nb3Jza2lA Z21haWwuY29tPgpTaWduZWQtb2ZmLWJ5OiDDgWx2YXJvIEZlcm7DoW5kZXogUm9qYXMgPG5vbHRh cmlAZ21haWwuY29tPgotLS0KIHY1OiBhZGQgY2hhbmdlcyBzdWdnZXN0ZWQgYnkgQW5keSBTaGV2 Y2hlbmtvCiB2NDogbm8gY2hhbmdlcwogdjM6IHVzZSBuZXcgc2hhcmVkIGNvZGUKIHYyOiBzd2l0 Y2ggdG8gR1BJT19SRUdNQVAKCiBkcml2ZXJzL3BpbmN0cmwvYmNtL0tjb25maWcgICAgICAgICAg IHwgICA4ICsKIGRyaXZlcnMvcGluY3RybC9iY20vTWFrZWZpbGUgICAgICAgICAgfCAgIDEgKwog ZHJpdmVycy9waW5jdHJsL2JjbS9waW5jdHJsLWJjbTYzNjguYyB8IDUyMyArKysrKysrKysrKysr KysrKysrKysrKysrKwogMyBmaWxlcyBjaGFuZ2VkLCA1MzIgaW5zZXJ0aW9ucygrKQogY3JlYXRl IG1vZGUgMTAwNjQ0IGRyaXZlcnMvcGluY3RybC9iY20vcGluY3RybC1iY202MzY4LmMKCmRpZmYg LS1naXQgYS9kcml2ZXJzL3BpbmN0cmwvYmNtL0tjb25maWcgYi9kcml2ZXJzL3BpbmN0cmwvYmNt L0tjb25maWcKaW5kZXggZDMxMDFkNWU3NTBmLi5hYWJkNGI3NjJhZWQgMTAwNjQ0Ci0tLSBhL2Ry aXZlcnMvcGluY3RybC9iY20vS2NvbmZpZworKysgYi9kcml2ZXJzL3BpbmN0cmwvYmNtL0tjb25m aWcKQEAgLTYwLDYgKzYwLDE0IEBAIGNvbmZpZyBQSU5DVFJMX0JDTTYzNjIKIAloZWxwCiAJICAg U2F5IFkgaGVyZSB0byBlbmFibGUgdGhlIEJyb2FkY29tIEJDTTYzNjIgR1BJTyBkcml2ZXIuCiAK K2NvbmZpZyBQSU5DVFJMX0JDTTYzNjgKKwlib29sICJCcm9hZGNvbSBCQ002MzY4IEdQSU8gZHJp dmVyIgorCWRlcGVuZHMgb24gKEJNSVBTX0dFTkVSSUMgfHwgQ09NUElMRV9URVNUKQorCXNlbGVj dCBQSU5DVFJMX0JDTTYzWFgKKwlkZWZhdWx0IEJNSVBTX0dFTkVSSUMKKwloZWxwCisJICAgU2F5 IFkgaGVyZSB0byBlbmFibGUgdGhlIEJyb2FkY29tIEJDTTYzNjggR1BJTyBkcml2ZXIuCisKIGNv bmZpZyBQSU5DVFJMX0lQUk9DX0dQSU8KIAlib29sICJCcm9hZGNvbSBpUHJvYyBHUElPICh3aXRo IFBJTkNPTkYpIGRyaXZlciIKIAlkZXBlbmRzIG9uIE9GX0dQSU8gJiYgKEFSQ0hfQkNNX0lQUk9D IHx8IENPTVBJTEVfVEVTVCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGluY3RybC9iY20vTWFrZWZp bGUgYi9kcml2ZXJzL3BpbmN0cmwvYmNtL01ha2VmaWxlCmluZGV4IGI5YjA5ZTViOTE0Yy4uYTEz MzFiYjk2ODBlIDEwMDY0NAotLS0gYS9kcml2ZXJzL3BpbmN0cmwvYmNtL01ha2VmaWxlCisrKyBi L2RyaXZlcnMvcGluY3RybC9iY20vTWFrZWZpbGUKQEAgLTcsNiArNyw3IEBAIG9iai0kKENPTkZJ R19QSU5DVFJMX0JDTTYzWFgpCQkrPSBwaW5jdHJsLWJjbTYzeHgubwogb2JqLSQoQ09ORklHX1BJ TkNUUkxfQkNNNjMyOCkJCSs9IHBpbmN0cmwtYmNtNjMyOC5vCiBvYmotJChDT05GSUdfUElOQ1RS TF9CQ002MzU4KQkJKz0gcGluY3RybC1iY202MzU4Lm8KIG9iai0kKENPTkZJR19QSU5DVFJMX0JD TTYzNjIpCQkrPSBwaW5jdHJsLWJjbTYzNjIubworb2JqLSQoQ09ORklHX1BJTkNUUkxfQkNNNjM2 OCkJCSs9IHBpbmN0cmwtYmNtNjM2OC5vCiBvYmotJChDT05GSUdfUElOQ1RSTF9JUFJPQ19HUElP KQkrPSBwaW5jdHJsLWlwcm9jLWdwaW8ubwogb2JqLSQoQ09ORklHX1BJTkNUUkxfQ1lHTlVTX01V WCkJKz0gcGluY3RybC1jeWdudXMtbXV4Lm8KIG9iai0kKENPTkZJR19QSU5DVFJMX05TKQkJKz0g cGluY3RybC1ucy5vCmRpZmYgLS1naXQgYS9kcml2ZXJzL3BpbmN0cmwvYmNtL3BpbmN0cmwtYmNt NjM2OC5jIGIvZHJpdmVycy9waW5jdHJsL2JjbS9waW5jdHJsLWJjbTYzNjguYwpuZXcgZmlsZSBt b2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjgzODA5NWY5ZTg5MAotLS0gL2Rldi9udWxs CisrKyBiL2RyaXZlcnMvcGluY3RybC9iY20vcGluY3RybC1iY202MzY4LmMKQEAgLTAsMCArMSw1 MjMgQEAKKy8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wKworLyoKKyAqIERyaXZl ciBmb3IgQkNNNjM2OCBHUElPIHVuaXQgKHBpbmN0cmwgKyBHUElPKQorICoKKyAqIENvcHlyaWdo dCAoQykgMjAyMSDDgWx2YXJvIEZlcm7DoW5kZXogUm9qYXMgPG5vbHRhcmlAZ21haWwuY29tPgor ICogQ29weXJpZ2h0IChDKSAyMDE2IEpvbmFzIEdvcnNraSA8am9uYXMuZ29yc2tpQGdtYWlsLmNv bT4KKyAqLworCisjaW5jbHVkZSA8bGludXgvYml0cy5oPgorI2luY2x1ZGUgPGxpbnV4L2dwaW8v ZHJpdmVyLmg+CisjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgvb2Yu aD4KKyNpbmNsdWRlIDxsaW51eC9waW5jdHJsL3Bpbm11eC5oPgorI2luY2x1ZGUgPGxpbnV4L3Bs YXRmb3JtX2RldmljZS5oPgorI2luY2x1ZGUgPGxpbnV4L3JlZ21hcC5oPgorCisjaW5jbHVkZSAi Li4vcGluY3RybC11dGlscy5oIgorCisjaW5jbHVkZSAicGluY3RybC1iY202M3h4LmgiCisKKyNk ZWZpbmUgQkNNNjM2OF9OVU1fR1BJT1MJMzgKKworI2RlZmluZSBCQ002MzY4X01PREVfUkVHCTB4 MTgKKyNkZWZpbmUgQkNNNjM2OF9CQVNFTU9ERV9SRUcJMHgzOAorI2RlZmluZSAgQkNNNjM2OF9C QVNFTU9ERV9NQVNLCTB4NworI2RlZmluZSAgQkNNNjM2OF9CQVNFTU9ERV9HUElPCTB4MAorI2Rl ZmluZSAgQkNNNjM2OF9CQVNFTU9ERV9VQVJUMQkweDEKKworc3RydWN0IGJjbTYzNjhfcGluZ3Jv dXAgeworCWNvbnN0IGNoYXIgKm5hbWU7CisJY29uc3QgdW5zaWduZWQgKiBjb25zdCBwaW5zOwor CWNvbnN0IHVuc2lnbmVkIG51bV9waW5zOworfTsKKworc3RydWN0IGJjbTYzNjhfZnVuY3Rpb24g eworCWNvbnN0IGNoYXIgKm5hbWU7CisJY29uc3QgY2hhciAqIGNvbnN0ICpncm91cHM7CisJY29u c3QgdW5zaWduZWQgbnVtX2dyb3VwczsKKworCXVuc2lnbmVkIGRpcl9vdXQ6MTY7CisJdW5zaWdu ZWQgYmFzZW1vZGU6MzsKK307CisKK3N0cnVjdCBiY202MzY4X3ByaXYgeworCXN0cnVjdCByZWdt YXBfZmllbGQgKm92ZXJsYXlzOworfTsKKworI2RlZmluZSBCQ002MzY4X0JBU0VNT0RFX1BJTihh LCBiKQkJXAorCXsJCQkJCVwKKwkJLm51bWJlciA9IGEsCQkJXAorCQkubmFtZSA9IGIsCQkJXAor CQkuZHJ2X2RhdGEgPSAodm9pZCAqKXRydWUJXAorCX0KKworc3RhdGljIGNvbnN0IHN0cnVjdCBw aW5jdHJsX3Bpbl9kZXNjIGJjbTYzNjhfcGluc1tdID0geworCVBJTkNUUkxfUElOKDAsICJncGlv MCIpLAorCVBJTkNUUkxfUElOKDEsICJncGlvMSIpLAorCVBJTkNUUkxfUElOKDIsICJncGlvMiIp LAorCVBJTkNUUkxfUElOKDMsICJncGlvMyIpLAorCVBJTkNUUkxfUElOKDQsICJncGlvNCIpLAor CVBJTkNUUkxfUElOKDUsICJncGlvNSIpLAorCVBJTkNUUkxfUElOKDYsICJncGlvNiIpLAorCVBJ TkNUUkxfUElOKDcsICJncGlvNyIpLAorCVBJTkNUUkxfUElOKDgsICJncGlvOCIpLAorCVBJTkNU UkxfUElOKDksICJncGlvOSIpLAorCVBJTkNUUkxfUElOKDEwLCAiZ3BpbzEwIiksCisJUElOQ1RS TF9QSU4oMTEsICJncGlvMTEiKSwKKwlQSU5DVFJMX1BJTigxMiwgImdwaW8xMiIpLAorCVBJTkNU UkxfUElOKDEzLCAiZ3BpbzEzIiksCisJUElOQ1RSTF9QSU4oMTQsICJncGlvMTQiKSwKKwlQSU5D VFJMX1BJTigxNSwgImdwaW8xNSIpLAorCVBJTkNUUkxfUElOKDE2LCAiZ3BpbzE2IiksCisJUElO Q1RSTF9QSU4oMTcsICJncGlvMTciKSwKKwlQSU5DVFJMX1BJTigxOCwgImdwaW8xOCIpLAorCVBJ TkNUUkxfUElOKDE5LCAiZ3BpbzE5IiksCisJUElOQ1RSTF9QSU4oMjAsICJncGlvMjAiKSwKKwlQ SU5DVFJMX1BJTigyMSwgImdwaW8yMSIpLAorCVBJTkNUUkxfUElOKDIyLCAiZ3BpbzIyIiksCisJ UElOQ1RSTF9QSU4oMjMsICJncGlvMjMiKSwKKwlQSU5DVFJMX1BJTigyNCwgImdwaW8yNCIpLAor CVBJTkNUUkxfUElOKDI1LCAiZ3BpbzI1IiksCisJUElOQ1RSTF9QSU4oMjYsICJncGlvMjYiKSwK KwlQSU5DVFJMX1BJTigyNywgImdwaW8yNyIpLAorCVBJTkNUUkxfUElOKDI4LCAiZ3BpbzI4Iiks CisJUElOQ1RSTF9QSU4oMjksICJncGlvMjkiKSwKKwlCQ002MzY4X0JBU0VNT0RFX1BJTigzMCwg ImdwaW8zMCIpLAorCUJDTTYzNjhfQkFTRU1PREVfUElOKDMxLCAiZ3BpbzMxIiksCisJQkNNNjM2 OF9CQVNFTU9ERV9QSU4oMzIsICJncGlvMzIiKSwKKwlCQ002MzY4X0JBU0VNT0RFX1BJTigzMywg ImdwaW8zMyIpLAorCVBJTkNUUkxfUElOKDM0LCAiZ3BpbzM0IiksCisJUElOQ1RSTF9QSU4oMzUs ICJncGlvMzUiKSwKKwlQSU5DVFJMX1BJTigzNiwgImdwaW8zNiIpLAorCVBJTkNUUkxfUElOKDM3 LCAiZ3BpbzM3IiksCit9OworCitzdGF0aWMgdW5zaWduZWQgZ3BpbzBfcGluc1tdID0geyAwIH07 CitzdGF0aWMgdW5zaWduZWQgZ3BpbzFfcGluc1tdID0geyAxIH07CitzdGF0aWMgdW5zaWduZWQg Z3BpbzJfcGluc1tdID0geyAyIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzNfcGluc1tdID0geyAz IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzRfcGluc1tdID0geyA0IH07CitzdGF0aWMgdW5zaWdu ZWQgZ3BpbzVfcGluc1tdID0geyA1IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzZfcGluc1tdID0g eyA2IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzdfcGluc1tdID0geyA3IH07CitzdGF0aWMgdW5z aWduZWQgZ3BpbzhfcGluc1tdID0geyA4IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzlfcGluc1td ID0geyA5IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzEwX3BpbnNbXSA9IHsgMTAgfTsKK3N0YXRp YyB1bnNpZ25lZCBncGlvMTFfcGluc1tdID0geyAxMSB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8x Ml9waW5zW10gPSB7IDEyIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzEzX3BpbnNbXSA9IHsgMTMg fTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMTRfcGluc1tdID0geyAxNCB9Oworc3RhdGljIHVuc2ln bmVkIGdwaW8xNV9waW5zW10gPSB7IDE1IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzE2X3BpbnNb XSA9IHsgMTYgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMTdfcGluc1tdID0geyAxNyB9Oworc3Rh dGljIHVuc2lnbmVkIGdwaW8xOF9waW5zW10gPSB7IDE4IH07CitzdGF0aWMgdW5zaWduZWQgZ3Bp bzE5X3BpbnNbXSA9IHsgMTkgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMjBfcGluc1tdID0geyAy MCB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8yMV9waW5zW10gPSB7IDIxIH07CitzdGF0aWMgdW5z aWduZWQgZ3BpbzIyX3BpbnNbXSA9IHsgMjIgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMjNfcGlu c1tdID0geyAyMyB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8yNF9waW5zW10gPSB7IDI0IH07Citz dGF0aWMgdW5zaWduZWQgZ3BpbzI1X3BpbnNbXSA9IHsgMjUgfTsKK3N0YXRpYyB1bnNpZ25lZCBn cGlvMjZfcGluc1tdID0geyAyNiB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8yN19waW5zW10gPSB7 IDI3IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzI4X3BpbnNbXSA9IHsgMjggfTsKK3N0YXRpYyB1 bnNpZ25lZCBncGlvMjlfcGluc1tdID0geyAyOSB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8zMF9w aW5zW10gPSB7IDMwIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzMxX3BpbnNbXSA9IHsgMzEgfTsK K3N0YXRpYyB1bnNpZ25lZCB1YXJ0MV9ncnBfcGluc1tdID0geyAzMCwgMzEsIDMyLCAzMyB9Owor CisjZGVmaW5lIEJDTTYzNjhfR1JPVVAobikJCQkJXAorCXsJCQkJCQlcCisJCS5uYW1lID0gI24s CQkJCVwKKwkJLnBpbnMgPSBuIyNfcGlucywJCQlcCisJCS5udW1fcGlucyA9IEFSUkFZX1NJWkUo biMjX3BpbnMpLAlcCisJfQorCitzdGF0aWMgc3RydWN0IGJjbTYzNjhfcGluZ3JvdXAgYmNtNjM2 OF9ncm91cHNbXSA9IHsKKwlCQ002MzY4X0dST1VQKGdwaW8wKSwKKwlCQ002MzY4X0dST1VQKGdw aW8xKSwKKwlCQ002MzY4X0dST1VQKGdwaW8yKSwKKwlCQ002MzY4X0dST1VQKGdwaW8zKSwKKwlC Q002MzY4X0dST1VQKGdwaW80KSwKKwlCQ002MzY4X0dST1VQKGdwaW81KSwKKwlCQ002MzY4X0dS T1VQKGdwaW82KSwKKwlCQ002MzY4X0dST1VQKGdwaW83KSwKKwlCQ002MzY4X0dST1VQKGdwaW84 KSwKKwlCQ002MzY4X0dST1VQKGdwaW85KSwKKwlCQ002MzY4X0dST1VQKGdwaW8xMCksCisJQkNN NjM2OF9HUk9VUChncGlvMTEpLAorCUJDTTYzNjhfR1JPVVAoZ3BpbzEyKSwKKwlCQ002MzY4X0dS T1VQKGdwaW8xMyksCisJQkNNNjM2OF9HUk9VUChncGlvMTQpLAorCUJDTTYzNjhfR1JPVVAoZ3Bp bzE1KSwKKwlCQ002MzY4X0dST1VQKGdwaW8xNiksCisJQkNNNjM2OF9HUk9VUChncGlvMTcpLAor CUJDTTYzNjhfR1JPVVAoZ3BpbzE4KSwKKwlCQ002MzY4X0dST1VQKGdwaW8xOSksCisJQkNNNjM2 OF9HUk9VUChncGlvMjApLAorCUJDTTYzNjhfR1JPVVAoZ3BpbzIxKSwKKwlCQ002MzY4X0dST1VQ KGdwaW8yMiksCisJQkNNNjM2OF9HUk9VUChncGlvMjMpLAorCUJDTTYzNjhfR1JPVVAoZ3BpbzI0 KSwKKwlCQ002MzY4X0dST1VQKGdwaW8yNSksCisJQkNNNjM2OF9HUk9VUChncGlvMjYpLAorCUJD TTYzNjhfR1JPVVAoZ3BpbzI3KSwKKwlCQ002MzY4X0dST1VQKGdwaW8yOCksCisJQkNNNjM2OF9H Uk9VUChncGlvMjkpLAorCUJDTTYzNjhfR1JPVVAoZ3BpbzMwKSwKKwlCQ002MzY4X0dST1VQKGdw aW8zMSksCisJQkNNNjM2OF9HUk9VUCh1YXJ0MV9ncnApLAorfTsKKworc3RhdGljIGNvbnN0IGNo YXIgKiBjb25zdCBhbmFsb2dfYWZlXzBfZ3JvdXBzW10gPSB7CisJImdwaW8wIiwKK307CisKK3N0 YXRpYyBjb25zdCBjaGFyICogY29uc3QgYW5hbG9nX2FmZV8xX2dyb3Vwc1tdID0geworCSJncGlv MSIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHN5c19pcnFfZ3JvdXBzW10gPSB7 CisJImdwaW8yIiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3Qgc2VyaWFsX2xlZF9k YXRhX2dyb3Vwc1tdID0geworCSJncGlvMyIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNv bnN0IHNlcmlhbF9sZWRfY2xrX2dyb3Vwc1tdID0geworCSJncGlvNCIsCit9OworCitzdGF0aWMg Y29uc3QgY2hhciAqIGNvbnN0IGluZXRfbGVkX2dyb3Vwc1tdID0geworCSJncGlvNSIsCit9Owor CitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGVwaHkwX2xlZF9ncm91cHNbXSA9IHsKKwkiZ3Bp bzYiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBlcGh5MV9sZWRfZ3JvdXBzW10g PSB7CisJImdwaW83IiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgZXBoeTJfbGVk X2dyb3Vwc1tdID0geworCSJncGlvOCIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0 IGVwaHkzX2xlZF9ncm91cHNbXSA9IHsKKwkiZ3BpbzkiLAorfTsKKworc3RhdGljIGNvbnN0IGNo YXIgKiBjb25zdCByb2Jvc3dfbGVkX2RhdGFfZ3JvdXBzW10gPSB7CisJImdwaW8xMCIsCit9Owor CitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHJvYm9zd19sZWRfY2xrX2dyb3Vwc1tdID0gewor CSJncGlvMTEiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCByb2Jvc3dfbGVkMF9n cm91cHNbXSA9IHsKKwkiZ3BpbzEyIiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3Qg cm9ib3N3X2xlZDFfZ3JvdXBzW10gPSB7CisJImdwaW8xMyIsCit9OworCitzdGF0aWMgY29uc3Qg Y2hhciAqIGNvbnN0IHVzYl9kZXZpY2VfbGVkX2dyb3Vwc1tdID0geworCSJncGlvMTQiLAorfTsK Kworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBwY2lfcmVxMV9ncm91cHNbXSA9IHsKKwkiZ3Bp bzE2IiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgcGNpX2dudDFfZ3JvdXBzW10g PSB7CisJImdwaW8xNyIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHBjaV9pbnRi X2dyb3Vwc1tdID0geworCSJncGlvMTgiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25z dCBwY2lfcmVxMF9ncm91cHNbXSA9IHsKKwkiZ3BpbzE5IiwKK307CisKK3N0YXRpYyBjb25zdCBj aGFyICogY29uc3QgcGNpX2dudDBfZ3JvdXBzW10gPSB7CisJImdwaW8yMCIsCit9OworCitzdGF0 aWMgY29uc3QgY2hhciAqIGNvbnN0IHBjbWNpYV9jZDFfZ3JvdXBzW10gPSB7CisJImdwaW8yMiIs Cit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHBjbWNpYV9jZDJfZ3JvdXBzW10gPSB7 CisJImdwaW8yMyIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHBjbWNpYV92czFf Z3JvdXBzW10gPSB7CisJImdwaW8yNCIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0 IHBjbWNpYV92czJfZ3JvdXBzW10gPSB7CisJImdwaW8yNSIsCit9OworCitzdGF0aWMgY29uc3Qg Y2hhciAqIGNvbnN0IGViaV9jczJfZ3JvdXBzW10gPSB7CisJImdwaW8yNiIsCit9OworCitzdGF0 aWMgY29uc3QgY2hhciAqIGNvbnN0IGViaV9jczNfZ3JvdXBzW10gPSB7CisJImdwaW8yNyIsCit9 OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHNwaV9jczJfZ3JvdXBzW10gPSB7CisJImdw aW8yOCIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHNwaV9jczNfZ3JvdXBzW10g PSB7CisJImdwaW8yOSIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHNwaV9jczRf Z3JvdXBzW10gPSB7CisJImdwaW8zMCIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0 IHNwaV9jczVfZ3JvdXBzW10gPSB7CisJImdwaW8zMSIsCit9OworCitzdGF0aWMgY29uc3QgY2hh ciAqIGNvbnN0IHVhcnQxX2dyb3Vwc1tdID0geworCSJ1YXJ0MV9ncnAiLAorfTsKKworI2RlZmlu ZSBCQ002MzY4X0ZVTihuLCBvdXQpCQkJCVwKKwl7CQkJCQkJXAorCQkubmFtZSA9ICNuLAkJCQlc CisJCS5ncm91cHMgPSBuIyNfZ3JvdXBzLAkJCVwKKwkJLm51bV9ncm91cHMgPSBBUlJBWV9TSVpF KG4jI19ncm91cHMpLAlcCisJCS5kaXJfb3V0ID0gb3V0LAkJCQlcCisJfQorCisjZGVmaW5lIEJD TTYzNjhfQkFTRU1PREVfRlVOKG4sIHZhbCwgb3V0KQkJXAorCXsJCQkJCQlcCisJCS5uYW1lID0g I24sCQkJCVwKKwkJLmdyb3VwcyA9IG4jI19ncm91cHMsCQkJXAorCQkubnVtX2dyb3VwcyA9IEFS UkFZX1NJWkUobiMjX2dyb3VwcyksCVwKKwkJLmJhc2Vtb2RlID0gQkNNNjM2OF9CQVNFTU9ERV8j I3ZhbCwJXAorCQkuZGlyX291dCA9IG91dCwJCQkJXAorCX0KKworc3RhdGljIGNvbnN0IHN0cnVj dCBiY202MzY4X2Z1bmN0aW9uIGJjbTYzNjhfZnVuY3NbXSA9IHsKKwlCQ002MzY4X0ZVTihhbmFs b2dfYWZlXzAsIDEpLAorCUJDTTYzNjhfRlVOKGFuYWxvZ19hZmVfMSwgMSksCisJQkNNNjM2OF9G VU4oc3lzX2lycSwgMSksCisJQkNNNjM2OF9GVU4oc2VyaWFsX2xlZF9kYXRhLCAxKSwKKwlCQ002 MzY4X0ZVTihzZXJpYWxfbGVkX2NsaywgMSksCisJQkNNNjM2OF9GVU4oaW5ldF9sZWQsIDEpLAor CUJDTTYzNjhfRlVOKGVwaHkwX2xlZCwgMSksCisJQkNNNjM2OF9GVU4oZXBoeTFfbGVkLCAxKSwK KwlCQ002MzY4X0ZVTihlcGh5Ml9sZWQsIDEpLAorCUJDTTYzNjhfRlVOKGVwaHkzX2xlZCwgMSks CisJQkNNNjM2OF9GVU4ocm9ib3N3X2xlZF9kYXRhLCAxKSwKKwlCQ002MzY4X0ZVTihyb2Jvc3df bGVkX2NsaywgMSksCisJQkNNNjM2OF9GVU4ocm9ib3N3X2xlZDAsIDEpLAorCUJDTTYzNjhfRlVO KHJvYm9zd19sZWQxLCAxKSwKKwlCQ002MzY4X0ZVTih1c2JfZGV2aWNlX2xlZCwgMSksCisJQkNN NjM2OF9GVU4ocGNpX3JlcTEsIDApLAorCUJDTTYzNjhfRlVOKHBjaV9nbnQxLCAwKSwKKwlCQ002 MzY4X0ZVTihwY2lfaW50YiwgMCksCisJQkNNNjM2OF9GVU4ocGNpX3JlcTAsIDApLAorCUJDTTYz NjhfRlVOKHBjaV9nbnQwLCAwKSwKKwlCQ002MzY4X0ZVTihwY21jaWFfY2QxLCAwKSwKKwlCQ002 MzY4X0ZVTihwY21jaWFfY2QyLCAwKSwKKwlCQ002MzY4X0ZVTihwY21jaWFfdnMxLCAwKSwKKwlC Q002MzY4X0ZVTihwY21jaWFfdnMyLCAwKSwKKwlCQ002MzY4X0ZVTihlYmlfY3MyLCAxKSwKKwlC Q002MzY4X0ZVTihlYmlfY3MzLCAxKSwKKwlCQ002MzY4X0ZVTihzcGlfY3MyLCAxKSwKKwlCQ002 MzY4X0ZVTihzcGlfY3MzLCAxKSwKKwlCQ002MzY4X0ZVTihzcGlfY3M0LCAxKSwKKwlCQ002MzY4 X0ZVTihzcGlfY3M1LCAxKSwKKwlCQ002MzY4X0JBU0VNT0RFX0ZVTih1YXJ0MSwgVUFSVDEsIDB4 NiksCit9OworCitzdGF0aWMgaW50IGJjbTYzNjhfcGluY3RybF9nZXRfZ3JvdXBfY291bnQoc3Ry dWN0IHBpbmN0cmxfZGV2ICpwY3RsZGV2KQoreworCXJldHVybiBBUlJBWV9TSVpFKGJjbTYzNjhf Z3JvdXBzKTsKK30KKworc3RhdGljIGNvbnN0IGNoYXIgKmJjbTYzNjhfcGluY3RybF9nZXRfZ3Jv dXBfbmFtZShzdHJ1Y3QgcGluY3RybF9kZXYgKnBjdGxkZXYsCisJCQkJCQkgIHVuc2lnbmVkIGdy b3VwKQoreworCXJldHVybiBiY202MzY4X2dyb3Vwc1tncm91cF0ubmFtZTsKK30KKworc3RhdGlj IGludCBiY202MzY4X3BpbmN0cmxfZ2V0X2dyb3VwX3BpbnMoc3RydWN0IHBpbmN0cmxfZGV2ICpw Y3RsZGV2LAorCQkJCQkgIHVuc2lnbmVkIGdyb3VwLCBjb25zdCB1bnNpZ25lZCAqKnBpbnMsCisJ CQkJCSAgdW5zaWduZWQgKm51bV9waW5zKQoreworCSpwaW5zID0gYmNtNjM2OF9ncm91cHNbZ3Jv dXBdLnBpbnM7CisJKm51bV9waW5zID0gYmNtNjM2OF9ncm91cHNbZ3JvdXBdLm51bV9waW5zOwor CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgYmNtNjM2OF9waW5jdHJsX2dldF9mdW5jX2Nv dW50KHN0cnVjdCBwaW5jdHJsX2RldiAqcGN0bGRldikKK3sKKwlyZXR1cm4gQVJSQVlfU0laRShi Y202MzY4X2Z1bmNzKTsKK30KKworc3RhdGljIGNvbnN0IGNoYXIgKmJjbTYzNjhfcGluY3RybF9n ZXRfZnVuY19uYW1lKHN0cnVjdCBwaW5jdHJsX2RldiAqcGN0bGRldiwKKwkJCQkJCSB1bnNpZ25l ZCBzZWxlY3RvcikKK3sKKwlyZXR1cm4gYmNtNjM2OF9mdW5jc1tzZWxlY3Rvcl0ubmFtZTsKK30K Kworc3RhdGljIGludCBiY202MzY4X3BpbmN0cmxfZ2V0X2dyb3VwcyhzdHJ1Y3QgcGluY3RybF9k ZXYgKnBjdGxkZXYsCisJCQkJICAgICAgdW5zaWduZWQgc2VsZWN0b3IsCisJCQkJICAgICAgY29u c3QgY2hhciAqIGNvbnN0ICoqZ3JvdXBzLAorCQkJCSAgICAgIHVuc2lnbmVkICogY29uc3QgbnVt X2dyb3VwcykKK3sKKwkqZ3JvdXBzID0gYmNtNjM2OF9mdW5jc1tzZWxlY3Rvcl0uZ3JvdXBzOwor CSpudW1fZ3JvdXBzID0gYmNtNjM2OF9mdW5jc1tzZWxlY3Rvcl0ubnVtX2dyb3VwczsKKworCXJl dHVybiAwOworfQorCitzdGF0aWMgaW50IGJjbTYzNjhfcGluY3RybF9zZXRfbXV4KHN0cnVjdCBw aW5jdHJsX2RldiAqcGN0bGRldiwKKwkJCQkgICB1bnNpZ25lZCBzZWxlY3RvciwgdW5zaWduZWQg Z3JvdXApCit7CisJc3RydWN0IGJjbTYzeHhfcGluY3RybCAqcGMgPSBwaW5jdHJsX2Rldl9nZXRf ZHJ2ZGF0YShwY3RsZGV2KTsKKwlzdHJ1Y3QgYmNtNjM2OF9wcml2ICpwcml2ID0gcGMtPmRyaXZl cl9kYXRhOworCWNvbnN0IHN0cnVjdCBiY202MzY4X3Bpbmdyb3VwICpwZyA9ICZiY202MzY4X2dy b3Vwc1tncm91cF07CisJY29uc3Qgc3RydWN0IGJjbTYzNjhfZnVuY3Rpb24gKmZ1biA9ICZiY202 MzY4X2Z1bmNzW3NlbGVjdG9yXTsKKwlpbnQgaSwgcGluOworCisJaWYgKGZ1bi0+YmFzZW1vZGUp IHsKKwkJdW5zaWduZWQgaW50IG1hc2sgPSAwOworCisJCWZvciAoaSA9IDA7IGkgPCBwZy0+bnVt X3BpbnM7IGkrKykgeworCQkJcGluID0gcGctPnBpbnNbaV07CisJCQlpZiAocGluIDwgQkNNNjNY WF9CQU5LX0dQSU9TKQorCQkJCW1hc2sgfD0gQklUKHBpbik7CisJCX0KKworCQlyZWdtYXBfdXBk YXRlX2JpdHMocGMtPnJlZ3MsIEJDTTYzNjhfTU9ERV9SRUcsIG1hc2ssIDApOworCQlyZWdtYXBf ZmllbGRfd3JpdGUocHJpdi0+b3ZlcmxheXMsIGZ1bi0+YmFzZW1vZGUpOworCX0gZWxzZSB7CisJ CXBpbiA9IHBnLT5waW5zWzBdOworCisJCWlmIChiY202MzY4X3BpbnNbcGluXS5kcnZfZGF0YSkK KwkJCXJlZ21hcF9maWVsZF93cml0ZShwcml2LT5vdmVybGF5cywKKwkJCQkJICAgQkNNNjM2OF9C QVNFTU9ERV9HUElPKTsKKworCQlyZWdtYXBfdXBkYXRlX2JpdHMocGMtPnJlZ3MsIEJDTTYzNjhf TU9ERV9SRUcsIEJJVChwaW4pLAorCQkJCSAgIEJJVChwaW4pKTsKKwl9CisKKwlmb3IgKHBpbiA9 IDA7IHBpbiA8IHBnLT5udW1fcGluczsgcGluKyspIHsKKwkJc3RydWN0IHBpbmN0cmxfZ3Bpb19y YW5nZSAqcmFuZ2U7CisJCWludCBod19ncGlvID0gYmNtNjM2OF9waW5zW3Bpbl0ubnVtYmVyOwor CisJCXJhbmdlID0gcGluY3RybF9maW5kX2dwaW9fcmFuZ2VfZnJvbV9waW4ocGN0bGRldiwgaHdf Z3Bpbyk7CisJCWlmIChyYW5nZSkgeworCQkJc3RydWN0IGdwaW9fY2hpcCAqZ2MgPSByYW5nZS0+ Z2M7CisKKwkJCWlmIChmdW4tPmRpcl9vdXQgJiBCSVQocGluKSkKKwkJCQlnYy0+ZGlyZWN0aW9u X291dHB1dChnYywgaHdfZ3BpbywgMCk7CisJCQllbHNlCisJCQkJZ2MtPmRpcmVjdGlvbl9pbnB1 dChnYywgaHdfZ3Bpbyk7CisJCX0KKwl9CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBi Y202MzY4X2dwaW9fcmVxdWVzdF9lbmFibGUoc3RydWN0IHBpbmN0cmxfZGV2ICpwY3RsZGV2LAor CQkJCSAgICAgICBzdHJ1Y3QgcGluY3RybF9ncGlvX3JhbmdlICpyYW5nZSwKKwkJCQkgICAgICAg dW5zaWduZWQgb2Zmc2V0KQoreworCXN0cnVjdCBiY202M3h4X3BpbmN0cmwgKnBjID0gcGluY3Ry bF9kZXZfZ2V0X2RydmRhdGEocGN0bGRldik7CisJc3RydWN0IGJjbTYzNjhfcHJpdiAqcHJpdiA9 IHBjLT5kcml2ZXJfZGF0YTsKKworCWlmIChvZmZzZXQgPj0gQkNNNjNYWF9CQU5LX0dQSU9TICYm ICFiY202MzY4X3BpbnNbb2Zmc2V0XS5kcnZfZGF0YSkKKwkJcmV0dXJuIDA7CisKKwkvKiBkaXNh YmxlIGFsbCBmdW5jdGlvbnMgdXNpbmcgdGhpcyBwaW4gKi8KKwlpZiAob2Zmc2V0IDwgQkNNNjNY WF9CQU5LX0dQSU9TKQorCQlyZWdtYXBfdXBkYXRlX2JpdHMocGMtPnJlZ3MsIEJDTTYzNjhfTU9E RV9SRUcsIEJJVChvZmZzZXQpLCAwKTsKKworCWlmIChiY202MzY4X3BpbnNbb2Zmc2V0XS5kcnZf ZGF0YSkKKwkJcmVnbWFwX2ZpZWxkX3dyaXRlKHByaXYtPm92ZXJsYXlzLCBCQ002MzY4X0JBU0VN T0RFX0dQSU8pOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBzdHJ1Y3QgcGluY3RybF9vcHMg YmNtNjM2OF9wY3RsX29wcyA9IHsKKwkuZHRfZnJlZV9tYXAgPSBwaW5jdHJsX3V0aWxzX2ZyZWVf bWFwLAorCS5kdF9ub2RlX3RvX21hcCA9IHBpbmNvbmZfZ2VuZXJpY19kdF9ub2RlX3RvX21hcF9w aW4sCisJLmdldF9ncm91cF9uYW1lID0gYmNtNjM2OF9waW5jdHJsX2dldF9ncm91cF9uYW1lLAor CS5nZXRfZ3JvdXBfcGlucyA9IGJjbTYzNjhfcGluY3RybF9nZXRfZ3JvdXBfcGlucywKKwkuZ2V0 X2dyb3Vwc19jb3VudCA9IGJjbTYzNjhfcGluY3RybF9nZXRfZ3JvdXBfY291bnQsCit9OworCitz dGF0aWMgc3RydWN0IHBpbm11eF9vcHMgYmNtNjM2OF9wbXhfb3BzID0geworCS5nZXRfZnVuY3Rp b25fZ3JvdXBzID0gYmNtNjM2OF9waW5jdHJsX2dldF9ncm91cHMsCisJLmdldF9mdW5jdGlvbl9u YW1lID0gYmNtNjM2OF9waW5jdHJsX2dldF9mdW5jX25hbWUsCisJLmdldF9mdW5jdGlvbnNfY291 bnQgPSBiY202MzY4X3BpbmN0cmxfZ2V0X2Z1bmNfY291bnQsCisJLmdwaW9fcmVxdWVzdF9lbmFi bGUgPSBiY202MzY4X2dwaW9fcmVxdWVzdF9lbmFibGUsCisJLnNldF9tdXggPSBiY202MzY4X3Bp bmN0cmxfc2V0X211eCwKKwkuc3RyaWN0ID0gdHJ1ZSwKK307CisKK3N0YXRpYyBjb25zdCBzdHJ1 Y3QgYmNtNjN4eF9waW5jdHJsX3NvYyBiY202MzY4X3NvYyA9IHsKKwkubmdwaW9zID0gQkNNNjM2 OF9OVU1fR1BJT1MsCisJLm5waW5zID0gQVJSQVlfU0laRShiY202MzY4X3BpbnMpLAorCS5wY3Rs X29wcyA9ICZiY202MzY4X3BjdGxfb3BzLAorCS5waW5zID0gYmNtNjM2OF9waW5zLAorCS5wbXhf b3BzID0gJmJjbTYzNjhfcG14X29wcywKK307CisKK3N0YXRpYyBpbnQgYmNtNjM2OF9waW5jdHJs X3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCit7CisJc3RydWN0IHJlZ19maWVs ZCBvdmVybGF5cyA9IFJFR19GSUVMRChCQ002MzY4X0JBU0VNT0RFX1JFRywgMCwgMTUpOworCXN0 cnVjdCBkZXZpY2UgKmRldiA9ICZwZGV2LT5kZXY7CisJc3RydWN0IGJjbTYzeHhfcGluY3RybCAq cGM7CisJc3RydWN0IGJjbTYzNjhfcHJpdiAqcHJpdjsKKwlpbnQgZXJyOworCisJcHJpdiA9IGRl dm1fa3phbGxvYyhkZXYsIHNpemVvZigqcHJpdiksIEdGUF9LRVJORUwpOworCWlmICghcHJpdikK KwkJcmV0dXJuIC1FTk9NRU07CisKKwllcnIgPSBiY202M3h4X3BpbmN0cmxfcHJvYmUocGRldiwg JmJjbTYzNjhfc29jLCAodm9pZCAqKSBwcml2KTsKKwlpZiAoZXJyKQorCQlyZXR1cm4gZXJyOwor CisJcGMgPSBwbGF0Zm9ybV9nZXRfZHJ2ZGF0YShwZGV2KTsKKworCXByaXYtPm92ZXJsYXlzID0g ZGV2bV9yZWdtYXBfZmllbGRfYWxsb2MoZGV2LCBwYy0+cmVncywgb3ZlcmxheXMpOworCWlmIChJ U19FUlIocHJpdi0+b3ZlcmxheXMpKQorCQlyZXR1cm4gUFRSX0VSUihwcml2LT5vdmVybGF5cyk7 CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGNvbnN0IHN0cnVjdCBvZl9kZXZpY2VfaWQgYmNt NjM2OF9waW5jdHJsX21hdGNoW10gPSB7CisJeyAuY29tcGF0aWJsZSA9ICJicmNtLGJjbTYzNjgt cGluY3RybCIsIH0sCisJeyAvKiBzZW50aW5lbCAqLyB9Cit9OworCitzdGF0aWMgc3RydWN0IHBs YXRmb3JtX2RyaXZlciBiY202MzY4X3BpbmN0cmxfZHJpdmVyID0geworCS5wcm9iZSA9IGJjbTYz NjhfcGluY3RybF9wcm9iZSwKKwkuZHJpdmVyID0geworCQkubmFtZSA9ICJiY202MzY4LXBpbmN0 cmwiLAorCQkub2ZfbWF0Y2hfdGFibGUgPSBiY202MzY4X3BpbmN0cmxfbWF0Y2gsCisJfSwKK307 CisKK2J1aWx0aW5fcGxhdGZvcm1fZHJpdmVyKGJjbTYzNjhfcGluY3RybF9kcml2ZXIpOwotLSAK Mi4yMC4xCgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18K bGludXgtYXJtLWtlcm5lbCBtYWlsaW5nIGxpc3QKbGludXgtYXJtLWtlcm5lbEBsaXN0cy5pbmZy YWRlYWQub3JnCmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vbGlu dXgtYXJtLWtlcm5lbAo=