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 C5D7EC41518 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 A5B8A65030 for ; Sat, 6 Mar 2021 15:58:21 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231267AbhCFP5z (ORCPT ); Sat, 6 Mar 2021 10:57:55 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:50966 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231147AbhCFP51 (ORCPT ); Sat, 6 Mar 2021 10:57:27 -0500 Received: from mail-wm1-x32a.google.com (mail-wm1-x32a.google.com [IPv6:2a00:1450:4864:20::32a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 331B4C061761; Sat, 6 Mar 2021 07:57:27 -0800 (PST) Received: by mail-wm1-x32a.google.com with SMTP id r10-20020a05600c35cab029010c946c95easo1124695wmq.4; Sat, 06 Mar 2021 07:57:27 -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=4pjgGbqKDjNg2FmQ5/CldxJAcMZhOx+mxLsPTFNPLi4=; b=OGNiJxg2/qluxW1WH86Z0U2dlbMq0eaheVz+snhv8qQchVv2IBWqyNDCuLbgeeQyyv pwICJqfUe/BCCRuWLo5VcCJcqH4NxITzo0gEKJ8pxSMMHUKLNZeKVRpilySc3y4BT3PW xDuKMtNShnADNmmPhHMmgF52WwMxbfRMhBDC1Lk4kOGIHNc8ocdUZxMgqbrXZhSDvgYL qDgBPbf/1E4w0gZhc6xw1tKCaWADORtvdFuwKlovGFAv4j1h39BQLwRx1QcYKejtS9LN RpZW4xPbZJFffOmaz9l7APENTTAPROhkFAnnysVD7pJCGaF0Fr0fUitAVP6k+Bgov/sA oMTA== 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=4pjgGbqKDjNg2FmQ5/CldxJAcMZhOx+mxLsPTFNPLi4=; b=dANb5XDsMwwaQLT7p9QvlvkrxNvnacL9Eb97fLGDX+mkklqgBqoMVDbjDyxixS387v upoGzuqmwOwjWaKCmPqHNt43OwYpwrvM0F8r+rGTHy5PuKQ3pIg8kjvz/addWR5A31GZ NphaVlM8a/RRunbQFIXl6gdp1nKFRWOYa7luiAhPtpQimnioYcvvgfultdhA81m0sVcG d9F5Sqkmj5jYpCKXfm4eWkTFZhE3bjRhjZNdK8SVawn4RsVHBRh0HFfOTaTPchndXuDg 90JzfuzonCZrxF4e+49n47oU3LQ+SWRwWVXwGxf/PFRFOP/yweVPkeJ5lLzk3uEByS2k i+cg== X-Gm-Message-State: AOAM532PgUXTLVmb6fvg6+I6EpZNkrfz41lKhlqsSfL+59WhxdIqeqf+ 9sJj/HUrcoXY0h0vhFCnPMg= X-Google-Smtp-Source: ABdhPJzXq63VH/XI2h1ddfxDinjTJWjGh4unvkvLxkE9QtP3Rqt14OLYdPN190xRhsl1z8BGjfi5Dg== X-Received: by 2002:a1c:e388:: with SMTP id a130mr14299188wmh.187.1615046245708; Sat, 06 Mar 2021 07:57:25 -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.24 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 06 Mar 2021 07:57:25 -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 15/15] pinctrl: add a pincontrol driver for BCM6318 Date: Sat, 6 Mar 2021 16:57:12 +0100 Message-Id: <20210306155712.4298-16-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 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. 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-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 EDFD0C433DB for ; Sat, 6 Mar 2021 16:01:48 +0000 (UTC) Received: from desiato.infradead.org (desiato.infradead.org [90.155.92.199]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 4694964FF0 for ; Sat, 6 Mar 2021 16:01:48 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 4694964FF0 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=g2hfRUwSlncOjScgMHb2x2+KgOjw7ZfFAmu9KeyB9ag=; b=BDofcM9kjcWsJ4k5ErIP7Cy8n ZOCZxV7Jj2fLAKmARLlv13N2gpDL8X2QOsxAiRbC8IgsU/w8aWGUbm70xUjnBI1cWJM7Kl7FXZVCS HzdtIRPazM0xgtAchJssI3OElmvulQj0A8+ZRVtQjEJ/nX/cYbRpn8WYqViucAp618ZBPWRagGbb2 v3YkdH+q7tl7CitqA88Y9frvgeDZgXFEVVNsG1uvWjbTG2Po16l/yiBEf4GKAHEJfeymv7nslIdlP 7ufJiydNhJwLTvHyjd7qtdgrxPH8h01qsagC2u7snWQpUEKcKUvwWYJb9bD8fjk+f5Ug0UQ20FXKs AVTiDdmOg==; Received: from localhost ([::1] helo=desiato.infradead.org) by desiato.infradead.org with esmtp (Exim 4.94 #2 (Red Hat Linux)) id 1lIZLi-003WGo-Rv; Sat, 06 Mar 2021 16:00:16 +0000 Received: from mail-wm1-x32a.google.com ([2a00:1450:4864:20::32a]) by desiato.infradead.org with esmtps (Exim 4.94 #2 (Red Hat Linux)) id 1lIZJ0-003Uvd-52 for linux-arm-kernel@lists.infradead.org; Sat, 06 Mar 2021 15:57:28 +0000 Received: by mail-wm1-x32a.google.com with SMTP id i9so3450288wml.0 for ; Sat, 06 Mar 2021 07:57:26 -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=4pjgGbqKDjNg2FmQ5/CldxJAcMZhOx+mxLsPTFNPLi4=; b=OGNiJxg2/qluxW1WH86Z0U2dlbMq0eaheVz+snhv8qQchVv2IBWqyNDCuLbgeeQyyv pwICJqfUe/BCCRuWLo5VcCJcqH4NxITzo0gEKJ8pxSMMHUKLNZeKVRpilySc3y4BT3PW xDuKMtNShnADNmmPhHMmgF52WwMxbfRMhBDC1Lk4kOGIHNc8ocdUZxMgqbrXZhSDvgYL qDgBPbf/1E4w0gZhc6xw1tKCaWADORtvdFuwKlovGFAv4j1h39BQLwRx1QcYKejtS9LN RpZW4xPbZJFffOmaz9l7APENTTAPROhkFAnnysVD7pJCGaF0Fr0fUitAVP6k+Bgov/sA oMTA== 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=4pjgGbqKDjNg2FmQ5/CldxJAcMZhOx+mxLsPTFNPLi4=; b=bnjeybnfD7D4ZjhLLXF2KkmkSuTSeMQ3Q/XpztDkbMfuEPP3Y1rHOn13/PA9HsLVuC atqkEzC1ZKf3mfIK5gfbXxlWqTeW/CgciKDO+oy7z4PECf1RvIxYXXqIlJxFdT9q7Vkk jmD1tLZZNhzTluLwvdPUzyt/+IXGGorTYceULBWTmh7pEqph3pSUiw4ndiREIYpzqQcr wfX/YSIWbSOa10FYtQkqstxK5jl6N/sZSNEDNRgOudeLTDBnFpQZCYgu5dagjPTtuFr3 2IYVDO7vAWHzOjgdhgtvU1NuG3m+bjEvpshWjtoR0FZx5PYVOwMNzrHPzEdq3u35Zyx1 vZzQ== X-Gm-Message-State: AOAM5303IGkJTliHpjBdVT8FOu2nNmIJRr7ZoI/YSpvHxhvUJjrwRY8n kDfLf91yulLGkHSsVCqgYa4= X-Google-Smtp-Source: ABdhPJzXq63VH/XI2h1ddfxDinjTJWjGh4unvkvLxkE9QtP3Rqt14OLYdPN190xRhsl1z8BGjfi5Dg== X-Received: by 2002:a1c:e388:: with SMTP id a130mr14299188wmh.187.1615046245708; Sat, 06 Mar 2021 07:57:25 -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.24 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 06 Mar 2021 07:57:25 -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 15/15] pinctrl: add a pincontrol driver for BCM6318 Date: Sat, 6 Mar 2021 16:57:12 +0100 Message-Id: <20210306155712.4298-16-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_155726_441622_58CF280E X-CRM114-Status: GOOD ( 18.70 ) 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 bnVtYmVyLgoKU2lnbmVkLW9mZi1ieTogSm9uYXMgR29yc2tpIDxqb25hcy5nb3Jza2lAZ21haWwu Y29tPgpDby1kZXZlbG9wZWQtYnk6IEpvbmFzIEdvcnNraSA8am9uYXMuZ29yc2tpQGdtYWlsLmNv bT4KU2lnbmVkLW9mZi1ieTogw4FsdmFybyBGZXJuw6FuZGV6IFJvamFzIDxub2x0YXJpQGdtYWls LmNvbT4KLS0tCiB2NTogYWRkIGNoYW5nZXMgc3VnZ2VzdGVkIGJ5IEFuZHkgU2hldmNoZW5rbwog djQ6IG5vIGNoYW5nZXMKIHYzOiB1c2UgbmV3IHNoYXJlZCBjb2RlCiB2Mjogc3dpdGNoIHRvIEdQ SU9fUkVHTUFQCgogZHJpdmVycy9waW5jdHJsL2JjbS9LY29uZmlnICAgICAgICAgICB8ICAgOCAr CiBkcml2ZXJzL3BpbmN0cmwvYmNtL01ha2VmaWxlICAgICAgICAgIHwgICAxICsKIGRyaXZlcnMv cGluY3RybC9iY20vcGluY3RybC1iY202MzE4LmMgfCA0OTggKysrKysrKysrKysrKysrKysrKysr KysrKysKIDMgZmlsZXMgY2hhbmdlZCwgNTA3IGluc2VydGlvbnMoKykKIGNyZWF0ZSBtb2RlIDEw MDY0NCBkcml2ZXJzL3BpbmN0cmwvYmNtL3BpbmN0cmwtYmNtNjMxOC5jCgpkaWZmIC0tZ2l0IGEv ZHJpdmVycy9waW5jdHJsL2JjbS9LY29uZmlnIGIvZHJpdmVycy9waW5jdHJsL2JjbS9LY29uZmln CmluZGV4IDE4Njk4NTg0NjEyMC4uMzM2NjBlOGZlYzA1IDEwMDY0NAotLS0gYS9kcml2ZXJzL3Bp bmN0cmwvYmNtL0tjb25maWcKKysrIGIvZHJpdmVycy9waW5jdHJsL2JjbS9LY29uZmlnCkBAIC0z Niw2ICszNiwxNCBAQCBjb25maWcgUElOQ1RSTF9CQ002M1hYCiAJc2VsZWN0IFBJTkNPTkYKIAlz ZWxlY3QgUElOTVVYCiAKK2NvbmZpZyBQSU5DVFJMX0JDTTYzMTgKKwlib29sICJCcm9hZGNvbSBC Q002MzE4IEdQSU8gZHJpdmVyIgorCWRlcGVuZHMgb24gKEJNSVBTX0dFTkVSSUMgfHwgQ09NUElM RV9URVNUKQorCXNlbGVjdCBQSU5DVFJMX0JDTTYzWFgKKwlkZWZhdWx0IEJNSVBTX0dFTkVSSUMK KwloZWxwCisJICAgU2F5IFkgaGVyZSB0byBlbmFibGUgdGhlIEJyb2FkY29tIEJDTTYzMTggR1BJ TyBkcml2ZXIuCisKIGNvbmZpZyBQSU5DVFJMX0JDTTYzMjgKIAlib29sICJCcm9hZGNvbSBCQ002 MzI4IEdQSU8gZHJpdmVyIgogCWRlcGVuZHMgb24gKEJNSVBTX0dFTkVSSUMgfHwgQ09NUElMRV9U RVNUKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9waW5jdHJsL2JjbS9NYWtlZmlsZSBiL2RyaXZlcnMv cGluY3RybC9iY20vTWFrZWZpbGUKaW5kZXggNDExNzg0N2ZkMjc5Li4wMGM3Yjc3NzVlNjMgMTAw NjQ0Ci0tLSBhL2RyaXZlcnMvcGluY3RybC9iY20vTWFrZWZpbGUKKysrIGIvZHJpdmVycy9waW5j dHJsL2JjbS9NYWtlZmlsZQpAQCAtNCw2ICs0LDcgQEAKIG9iai0kKENPTkZJR19QSU5DVFJMX0JD TTI4MVhYKQkJKz0gcGluY3RybC1iY20yODF4eC5vCiBvYmotJChDT05GSUdfUElOQ1RSTF9CQ00y ODM1KQkJKz0gcGluY3RybC1iY20yODM1Lm8KIG9iai0kKENPTkZJR19QSU5DVFJMX0JDTTYzWFgp CQkrPSBwaW5jdHJsLWJjbTYzeHgubworb2JqLSQoQ09ORklHX1BJTkNUUkxfQkNNNjMxOCkJCSs9 IHBpbmN0cmwtYmNtNjMxOC5vCiBvYmotJChDT05GSUdfUElOQ1RSTF9CQ002MzI4KQkJKz0gcGlu Y3RybC1iY202MzI4Lm8KIG9iai0kKENPTkZJR19QSU5DVFJMX0JDTTYzNTgpCQkrPSBwaW5jdHJs LWJjbTYzNTgubwogb2JqLSQoQ09ORklHX1BJTkNUUkxfQkNNNjM2MikJCSs9IHBpbmN0cmwtYmNt NjM2Mi5vCmRpZmYgLS1naXQgYS9kcml2ZXJzL3BpbmN0cmwvYmNtL3BpbmN0cmwtYmNtNjMxOC5j IGIvZHJpdmVycy9waW5jdHJsL2JjbS9waW5jdHJsLWJjbTYzMTguYwpuZXcgZmlsZSBtb2RlIDEw MDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLjc3ZmQ5YjU4MDY3ZAotLS0gL2Rldi9udWxsCisrKyBi L2RyaXZlcnMvcGluY3RybC9iY20vcGluY3RybC1iY202MzE4LmMKQEAgLTAsMCArMSw0OTggQEAK Ky8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wKworLyoKKyAqIERyaXZlciBmb3Ig QkNNNjMxOCBHUElPIHVuaXQgKHBpbmN0cmwgKyBHUElPKQorICoKKyAqIENvcHlyaWdodCAoQykg MjAyMSDDgWx2YXJvIEZlcm7DoW5kZXogUm9qYXMgPG5vbHRhcmlAZ21haWwuY29tPgorICogQ29w eXJpZ2h0IChDKSAyMDE2IEpvbmFzIEdvcnNraSA8am9uYXMuZ29yc2tpQGdtYWlsLmNvbT4KKyAq LworCisjaW5jbHVkZSA8bGludXgvYml0cy5oPgorI2luY2x1ZGUgPGxpbnV4L2dwaW8vZHJpdmVy Lmg+CisjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgvb2YuaD4KKyNp bmNsdWRlIDxsaW51eC9waW5jdHJsL3Bpbm11eC5oPgorI2luY2x1ZGUgPGxpbnV4L3BsYXRmb3Jt X2RldmljZS5oPgorI2luY2x1ZGUgPGxpbnV4L3JlZ21hcC5oPgorCisjaW5jbHVkZSAiLi4vcGlu Y3RybC11dGlscy5oIgorCisjaW5jbHVkZSAicGluY3RybC1iY202M3h4LmgiCisKKyNkZWZpbmUg QkNNNjMxOF9OVU1fR1BJT1MJNTAKKyNkZWZpbmUgQkNNNjMxOF9OVU1fTVVYCQk0OAorCisjZGVm aW5lIEJDTTYzMThfTU9ERV9SRUcJMHgxOAorI2RlZmluZSBCQ002MzE4X01VWF9SRUcJCTB4MWMK KyNkZWZpbmUgIEJDTTYzMjhfTVVYX01BU0sJR0VOTUFTSygxLCAwKQorI2RlZmluZSBCQ002MzE4 X1BBRF9SRUcJCTB4NTQKKyNkZWZpbmUgIEJDTTYzMjhfUEFEX01BU0sJR0VOTUFTSygzLCAwKQor CitzdHJ1Y3QgYmNtNjMxOF9waW5ncm91cCB7CisJY29uc3QgY2hhciAqbmFtZTsKKwljb25zdCB1 bnNpZ25lZCAqIGNvbnN0IHBpbnM7CisJY29uc3QgdW5zaWduZWQgbnVtX3BpbnM7Cit9OworCitz dHJ1Y3QgYmNtNjMxOF9mdW5jdGlvbiB7CisJY29uc3QgY2hhciAqbmFtZTsKKwljb25zdCBjaGFy ICogY29uc3QgKmdyb3VwczsKKwljb25zdCB1bnNpZ25lZCBudW1fZ3JvdXBzOworCisJdW5zaWdu ZWQgbW9kZV92YWw6MTsKKwl1bnNpZ25lZCBtdXhfdmFsOjI7Cit9OworCitzdGF0aWMgY29uc3Qg c3RydWN0IHBpbmN0cmxfcGluX2Rlc2MgYmNtNjMxOF9waW5zW10gPSB7CisJUElOQ1RSTF9QSU4o MCwgImdwaW8wIiksCisJUElOQ1RSTF9QSU4oMSwgImdwaW8xIiksCisJUElOQ1RSTF9QSU4oMiwg ImdwaW8yIiksCisJUElOQ1RSTF9QSU4oMywgImdwaW8zIiksCisJUElOQ1RSTF9QSU4oNCwgImdw aW80IiksCisJUElOQ1RSTF9QSU4oNSwgImdwaW81IiksCisJUElOQ1RSTF9QSU4oNiwgImdwaW82 IiksCisJUElOQ1RSTF9QSU4oNywgImdwaW83IiksCisJUElOQ1RSTF9QSU4oOCwgImdwaW84Iiks CisJUElOQ1RSTF9QSU4oOSwgImdwaW85IiksCisJUElOQ1RSTF9QSU4oMTAsICJncGlvMTAiKSwK KwlQSU5DVFJMX1BJTigxMSwgImdwaW8xMSIpLAorCVBJTkNUUkxfUElOKDEyLCAiZ3BpbzEyIiks CisJUElOQ1RSTF9QSU4oMTMsICJncGlvMTMiKSwKKwlQSU5DVFJMX1BJTigxNCwgImdwaW8xNCIp LAorCVBJTkNUUkxfUElOKDE1LCAiZ3BpbzE1IiksCisJUElOQ1RSTF9QSU4oMTYsICJncGlvMTYi KSwKKwlQSU5DVFJMX1BJTigxNywgImdwaW8xNyIpLAorCVBJTkNUUkxfUElOKDE4LCAiZ3BpbzE4 IiksCisJUElOQ1RSTF9QSU4oMTksICJncGlvMTkiKSwKKwlQSU5DVFJMX1BJTigyMCwgImdwaW8y MCIpLAorCVBJTkNUUkxfUElOKDIxLCAiZ3BpbzIxIiksCisJUElOQ1RSTF9QSU4oMjIsICJncGlv MjIiKSwKKwlQSU5DVFJMX1BJTigyMywgImdwaW8yMyIpLAorCVBJTkNUUkxfUElOKDI0LCAiZ3Bp bzI0IiksCisJUElOQ1RSTF9QSU4oMjUsICJncGlvMjUiKSwKKwlQSU5DVFJMX1BJTigyNiwgImdw aW8yNiIpLAorCVBJTkNUUkxfUElOKDI3LCAiZ3BpbzI3IiksCisJUElOQ1RSTF9QSU4oMjgsICJn cGlvMjgiKSwKKwlQSU5DVFJMX1BJTigyOSwgImdwaW8yOSIpLAorCVBJTkNUUkxfUElOKDMwLCAi Z3BpbzMwIiksCisJUElOQ1RSTF9QSU4oMzEsICJncGlvMzEiKSwKKwlQSU5DVFJMX1BJTigzMiwg ImdwaW8zMiIpLAorCVBJTkNUUkxfUElOKDMzLCAiZ3BpbzMzIiksCisJUElOQ1RSTF9QSU4oMzQs ICJncGlvMzQiKSwKKwlQSU5DVFJMX1BJTigzNSwgImdwaW8zNSIpLAorCVBJTkNUUkxfUElOKDM2 LCAiZ3BpbzM2IiksCisJUElOQ1RSTF9QSU4oMzcsICJncGlvMzciKSwKKwlQSU5DVFJMX1BJTigz OCwgImdwaW8zOCIpLAorCVBJTkNUUkxfUElOKDM5LCAiZ3BpbzM5IiksCisJUElOQ1RSTF9QSU4o NDAsICJncGlvNDAiKSwKKwlQSU5DVFJMX1BJTig0MSwgImdwaW80MSIpLAorCVBJTkNUUkxfUElO KDQyLCAiZ3BpbzQyIiksCisJUElOQ1RSTF9QSU4oNDMsICJncGlvNDMiKSwKKwlQSU5DVFJMX1BJ Tig0NCwgImdwaW80NCIpLAorCVBJTkNUUkxfUElOKDQ1LCAiZ3BpbzQ1IiksCisJUElOQ1RSTF9Q SU4oNDYsICJncGlvNDYiKSwKKwlQSU5DVFJMX1BJTig0NywgImdwaW80NyIpLAorCVBJTkNUUkxf UElOKDQ4LCAiZ3BpbzQ4IiksCisJUElOQ1RSTF9QSU4oNDksICJncGlvNDkiKSwKK307CisKK3N0 YXRpYyB1bnNpZ25lZCBncGlvMF9waW5zW10gPSB7IDAgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlv MV9waW5zW10gPSB7IDEgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMl9waW5zW10gPSB7IDIgfTsK K3N0YXRpYyB1bnNpZ25lZCBncGlvM19waW5zW10gPSB7IDMgfTsKK3N0YXRpYyB1bnNpZ25lZCBn cGlvNF9waW5zW10gPSB7IDQgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvNV9waW5zW10gPSB7IDUg fTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvNl9waW5zW10gPSB7IDYgfTsKK3N0YXRpYyB1bnNpZ25l ZCBncGlvN19waW5zW10gPSB7IDcgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvOF9waW5zW10gPSB7 IDggfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvOV9waW5zW10gPSB7IDkgfTsKK3N0YXRpYyB1bnNp Z25lZCBncGlvMTBfcGluc1tdID0geyAxMCB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8xMV9waW5z W10gPSB7IDExIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzEyX3BpbnNbXSA9IHsgMTIgfTsKK3N0 YXRpYyB1bnNpZ25lZCBncGlvMTNfcGluc1tdID0geyAxMyB9Oworc3RhdGljIHVuc2lnbmVkIGdw aW8xNF9waW5zW10gPSB7IDE0IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzE1X3BpbnNbXSA9IHsg MTUgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMTZfcGluc1tdID0geyAxNiB9Oworc3RhdGljIHVu c2lnbmVkIGdwaW8xN19waW5zW10gPSB7IDE3IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzE4X3Bp bnNbXSA9IHsgMTggfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMTlfcGluc1tdID0geyAxOSB9Owor c3RhdGljIHVuc2lnbmVkIGdwaW8yMF9waW5zW10gPSB7IDIwIH07CitzdGF0aWMgdW5zaWduZWQg Z3BpbzIxX3BpbnNbXSA9IHsgMjEgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMjJfcGluc1tdID0g eyAyMiB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8yM19waW5zW10gPSB7IDIzIH07CitzdGF0aWMg dW5zaWduZWQgZ3BpbzI0X3BpbnNbXSA9IHsgMjQgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMjVf cGluc1tdID0geyAyNSB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8yNl9waW5zW10gPSB7IDI2IH07 CitzdGF0aWMgdW5zaWduZWQgZ3BpbzI3X3BpbnNbXSA9IHsgMjcgfTsKK3N0YXRpYyB1bnNpZ25l ZCBncGlvMjhfcGluc1tdID0geyAyOCB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8yOV9waW5zW10g PSB7IDI5IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzMwX3BpbnNbXSA9IHsgMzAgfTsKK3N0YXRp YyB1bnNpZ25lZCBncGlvMzFfcGluc1tdID0geyAzMSB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW8z Ml9waW5zW10gPSB7IDMyIH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzMzX3BpbnNbXSA9IHsgMzMg fTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMzRfcGluc1tdID0geyAzNCB9Oworc3RhdGljIHVuc2ln bmVkIGdwaW8zNV9waW5zW10gPSB7IDM1IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzM2X3BpbnNb XSA9IHsgMzYgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvMzdfcGluc1tdID0geyAzNyB9Oworc3Rh dGljIHVuc2lnbmVkIGdwaW8zOF9waW5zW10gPSB7IDM4IH07CitzdGF0aWMgdW5zaWduZWQgZ3Bp bzM5X3BpbnNbXSA9IHsgMzkgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvNDBfcGluc1tdID0geyA0 MCB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW80MV9waW5zW10gPSB7IDQxIH07CitzdGF0aWMgdW5z aWduZWQgZ3BpbzQyX3BpbnNbXSA9IHsgNDIgfTsKK3N0YXRpYyB1bnNpZ25lZCBncGlvNDNfcGlu c1tdID0geyA0MyB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW80NF9waW5zW10gPSB7IDQ0IH07Citz dGF0aWMgdW5zaWduZWQgZ3BpbzQ1X3BpbnNbXSA9IHsgNDUgfTsKK3N0YXRpYyB1bnNpZ25lZCBn cGlvNDZfcGluc1tdID0geyA0NiB9Oworc3RhdGljIHVuc2lnbmVkIGdwaW80N19waW5zW10gPSB7 IDQ3IH07CitzdGF0aWMgdW5zaWduZWQgZ3BpbzQ4X3BpbnNbXSA9IHsgNDggfTsKK3N0YXRpYyB1 bnNpZ25lZCBncGlvNDlfcGluc1tdID0geyA0OSB9OworCisjZGVmaW5lIEJDTTYzMThfR1JPVVAo bikJCQkJCVwKKwl7CQkJCQkJCVwKKwkJLm5hbWUgPSAjbiwJCQkJCVwKKwkJLnBpbnMgPSBuIyNf cGlucywJCQkJXAorCQkubnVtX3BpbnMgPSBBUlJBWV9TSVpFKG4jI19waW5zKSwJCVwKKwl9CisK K3N0YXRpYyBzdHJ1Y3QgYmNtNjMxOF9waW5ncm91cCBiY202MzE4X2dyb3Vwc1tdID0geworCUJD TTYzMThfR1JPVVAoZ3BpbzApLAorCUJDTTYzMThfR1JPVVAoZ3BpbzEpLAorCUJDTTYzMThfR1JP VVAoZ3BpbzIpLAorCUJDTTYzMThfR1JPVVAoZ3BpbzMpLAorCUJDTTYzMThfR1JPVVAoZ3BpbzQp LAorCUJDTTYzMThfR1JPVVAoZ3BpbzUpLAorCUJDTTYzMThfR1JPVVAoZ3BpbzYpLAorCUJDTTYz MThfR1JPVVAoZ3BpbzcpLAorCUJDTTYzMThfR1JPVVAoZ3BpbzgpLAorCUJDTTYzMThfR1JPVVAo Z3BpbzkpLAorCUJDTTYzMThfR1JPVVAoZ3BpbzEwKSwKKwlCQ002MzE4X0dST1VQKGdwaW8xMSks CisJQkNNNjMxOF9HUk9VUChncGlvMTIpLAorCUJDTTYzMThfR1JPVVAoZ3BpbzEzKSwKKwlCQ002 MzE4X0dST1VQKGdwaW8xNCksCisJQkNNNjMxOF9HUk9VUChncGlvMTUpLAorCUJDTTYzMThfR1JP VVAoZ3BpbzE2KSwKKwlCQ002MzE4X0dST1VQKGdwaW8xNyksCisJQkNNNjMxOF9HUk9VUChncGlv MTgpLAorCUJDTTYzMThfR1JPVVAoZ3BpbzE5KSwKKwlCQ002MzE4X0dST1VQKGdwaW8yMCksCisJ QkNNNjMxOF9HUk9VUChncGlvMjEpLAorCUJDTTYzMThfR1JPVVAoZ3BpbzIyKSwKKwlCQ002MzE4 X0dST1VQKGdwaW8yMyksCisJQkNNNjMxOF9HUk9VUChncGlvMjQpLAorCUJDTTYzMThfR1JPVVAo Z3BpbzI1KSwKKwlCQ002MzE4X0dST1VQKGdwaW8yNiksCisJQkNNNjMxOF9HUk9VUChncGlvMjcp LAorCUJDTTYzMThfR1JPVVAoZ3BpbzI4KSwKKwlCQ002MzE4X0dST1VQKGdwaW8yOSksCisJQkNN NjMxOF9HUk9VUChncGlvMzApLAorCUJDTTYzMThfR1JPVVAoZ3BpbzMxKSwKKwlCQ002MzE4X0dS T1VQKGdwaW8zMiksCisJQkNNNjMxOF9HUk9VUChncGlvMzMpLAorCUJDTTYzMThfR1JPVVAoZ3Bp bzM0KSwKKwlCQ002MzE4X0dST1VQKGdwaW8zNSksCisJQkNNNjMxOF9HUk9VUChncGlvMzYpLAor CUJDTTYzMThfR1JPVVAoZ3BpbzM3KSwKKwlCQ002MzE4X0dST1VQKGdwaW8zOCksCisJQkNNNjMx OF9HUk9VUChncGlvMzkpLAorCUJDTTYzMThfR1JPVVAoZ3BpbzQwKSwKKwlCQ002MzE4X0dST1VQ KGdwaW80MSksCisJQkNNNjMxOF9HUk9VUChncGlvNDIpLAorCUJDTTYzMThfR1JPVVAoZ3BpbzQz KSwKKwlCQ002MzE4X0dST1VQKGdwaW80NCksCisJQkNNNjMxOF9HUk9VUChncGlvNDUpLAorCUJD TTYzMThfR1JPVVAoZ3BpbzQ2KSwKKwlCQ002MzE4X0dST1VQKGdwaW80NyksCisJQkNNNjMxOF9H Uk9VUChncGlvNDgpLAorCUJDTTYzMThfR1JPVVAoZ3BpbzQ5KSwKK307CisKKy8qIEdQSU9fTU9E RSAqLworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBsZWRfZ3JvdXBzW10gPSB7CisJImdwaW8w IiwKKwkiZ3BpbzEiLAorCSJncGlvMiIsCisJImdwaW8zIiwKKwkiZ3BpbzQiLAorCSJncGlvNSIs CisJImdwaW82IiwKKwkiZ3BpbzciLAorCSJncGlvOCIsCisJImdwaW85IiwKKwkiZ3BpbzEwIiwK KwkiZ3BpbzExIiwKKwkiZ3BpbzEyIiwKKwkiZ3BpbzEzIiwKKwkiZ3BpbzE0IiwKKwkiZ3BpbzE1 IiwKKwkiZ3BpbzE2IiwKKwkiZ3BpbzE3IiwKKwkiZ3BpbzE4IiwKKwkiZ3BpbzE5IiwKKwkiZ3Bp bzIwIiwKKwkiZ3BpbzIxIiwKKwkiZ3BpbzIyIiwKKwkiZ3BpbzIzIiwKK307CisKKy8qIFBJTk1V WF9TRUwgKi8KK3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgZXBoeTBfc3BkX2xlZF9ncm91cHNb XSA9IHsKKwkiZ3BpbzAiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBlcGh5MV9z cGRfbGVkX2dyb3Vwc1tdID0geworCSJncGlvMSIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAq IGNvbnN0IGVwaHkyX3NwZF9sZWRfZ3JvdXBzW10gPSB7CisJImdwaW8yIiwKK307CisKK3N0YXRp YyBjb25zdCBjaGFyICogY29uc3QgZXBoeTNfc3BkX2xlZF9ncm91cHNbXSA9IHsKKwkiZ3BpbzMi LAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBlcGh5MF9hY3RfbGVkX2dyb3Vwc1td ID0geworCSJncGlvNCIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IGVwaHkxX2Fj dF9sZWRfZ3JvdXBzW10gPSB7CisJImdwaW81IiwKK307CisKK3N0YXRpYyBjb25zdCBjaGFyICog Y29uc3QgZXBoeTJfYWN0X2xlZF9ncm91cHNbXSA9IHsKKwkiZ3BpbzYiLAorfTsKKworc3RhdGlj IGNvbnN0IGNoYXIgKiBjb25zdCBlcGh5M19hY3RfbGVkX2dyb3Vwc1tdID0geworCSJncGlvNyIs Cit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHNlcmlhbF9sZWRfZGF0YV9ncm91cHNb XSA9IHsKKwkiZ3BpbzYiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBzZXJpYWxf bGVkX2Nsa19ncm91cHNbXSA9IHsKKwkiZ3BpbzciLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIg KiBjb25zdCBpbmV0X2FjdF9sZWRfZ3JvdXBzW10gPSB7CisJImdwaW84IiwKK307CisKK3N0YXRp YyBjb25zdCBjaGFyICogY29uc3QgaW5ldF9mYWlsX2xlZF9ncm91cHNbXSA9IHsKKwkiZ3Bpbzki LAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBkc2xfbGVkX2dyb3Vwc1tdID0gewor CSJncGlvMTAiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBwb3N0X2ZhaWxfbGVk X2dyb3Vwc1tdID0geworCSJncGlvMTEiLAorfTsKKworc3RhdGljIGNvbnN0IGNoYXIgKiBjb25z dCB3bGFuX3dwc19sZWRfZ3JvdXBzW10gPSB7CisJImdwaW8xMiIsCit9OworCitzdGF0aWMgY29u c3QgY2hhciAqIGNvbnN0IHVzYl9wd3Jvbl9ncm91cHNbXSA9IHsKKwkiZ3BpbzEzIiwKK307CisK K3N0YXRpYyBjb25zdCBjaGFyICogY29uc3QgdXNiX2RldmljZV9sZWRfZ3JvdXBzW10gPSB7CisJ ImdwaW8xMyIsCit9OworCitzdGF0aWMgY29uc3QgY2hhciAqIGNvbnN0IHVzYl9hY3RpdmVfZ3Jv dXBzW10gPSB7CisJImdwaW80MCIsCit9OworCisjZGVmaW5lIEJDTTYzMThfTU9ERV9GVU4obikJ CQkJXAorCXsJCQkJCQlcCisJCS5uYW1lID0gI24sCQkJCVwKKwkJLmdyb3VwcyA9IG4jI19ncm91 cHMsCQkJXAorCQkubnVtX2dyb3VwcyA9IEFSUkFZX1NJWkUobiMjX2dyb3VwcyksCVwKKwkJLm1v ZGVfdmFsID0gMSwJCQkJXAorCX0KKworI2RlZmluZSBCQ002MzE4X01VWF9GVU4obiwgbXV4KQkJ CQlcCisJewkJCQkJCVwKKwkJLm5hbWUgPSAjbiwJCQkJXAorCQkuZ3JvdXBzID0gbiMjX2dyb3Vw cywJCQlcCisJCS5udW1fZ3JvdXBzID0gQVJSQVlfU0laRShuIyNfZ3JvdXBzKSwJXAorCQkubXV4 X3ZhbCA9IG11eCwJCQkJXAorCX0KKworc3RhdGljIGNvbnN0IHN0cnVjdCBiY202MzE4X2Z1bmN0 aW9uIGJjbTYzMThfZnVuY3NbXSA9IHsKKwlCQ002MzE4X01PREVfRlVOKGxlZCksCisJQkNNNjMx OF9NVVhfRlVOKGVwaHkwX3NwZF9sZWQsIDEpLAorCUJDTTYzMThfTVVYX0ZVTihlcGh5MV9zcGRf bGVkLCAxKSwKKwlCQ002MzE4X01VWF9GVU4oZXBoeTJfc3BkX2xlZCwgMSksCisJQkNNNjMxOF9N VVhfRlVOKGVwaHkzX3NwZF9sZWQsIDEpLAorCUJDTTYzMThfTVVYX0ZVTihlcGh5MF9hY3RfbGVk LCAxKSwKKwlCQ002MzE4X01VWF9GVU4oZXBoeTFfYWN0X2xlZCwgMSksCisJQkNNNjMxOF9NVVhf RlVOKGVwaHkyX2FjdF9sZWQsIDEpLAorCUJDTTYzMThfTVVYX0ZVTihlcGh5M19hY3RfbGVkLCAx KSwKKwlCQ002MzE4X01VWF9GVU4oc2VyaWFsX2xlZF9kYXRhLCAzKSwKKwlCQ002MzE4X01VWF9G VU4oc2VyaWFsX2xlZF9jbGssIDMpLAorCUJDTTYzMThfTVVYX0ZVTihpbmV0X2FjdF9sZWQsIDEp LAorCUJDTTYzMThfTVVYX0ZVTihpbmV0X2ZhaWxfbGVkLCAxKSwKKwlCQ002MzE4X01VWF9GVU4o ZHNsX2xlZCwgMSksCisJQkNNNjMxOF9NVVhfRlVOKHBvc3RfZmFpbF9sZWQsIDEpLAorCUJDTTYz MThfTVVYX0ZVTih3bGFuX3dwc19sZWQsIDEpLAorCUJDTTYzMThfTVVYX0ZVTih1c2JfcHdyb24s IDEpLAorCUJDTTYzMThfTVVYX0ZVTih1c2JfZGV2aWNlX2xlZCwgMiksCisJQkNNNjMxOF9NVVhf RlVOKHVzYl9hY3RpdmUsIDIpLAorfTsKKworc3RhdGljIGlubGluZSB1bnNpZ25lZCBpbnQgYmNt NjMxOF9tdXhfb2ZmKHVuc2lnbmVkIGludCBwaW4pCit7CisJcmV0dXJuIEJDTTYzMThfTVVYX1JF RyArIChwaW4gLyAxNikgKiA0OworfQorCitzdGF0aWMgaW5saW5lIHVuc2lnbmVkIGludCBiY202 MzE4X3BhZF9vZmYodW5zaWduZWQgaW50IHBpbikKK3sKKwlyZXR1cm4gQkNNNjMxOF9QQURfUkVH ICsgKHBpbiAvIDgpICogNDsKK30KKworc3RhdGljIGludCBiY202MzE4X3BpbmN0cmxfZ2V0X2dy b3VwX2NvdW50KHN0cnVjdCBwaW5jdHJsX2RldiAqcGN0bGRldikKK3sKKwlyZXR1cm4gQVJSQVlf U0laRShiY202MzE4X2dyb3Vwcyk7Cit9CisKK3N0YXRpYyBjb25zdCBjaGFyICpiY202MzE4X3Bp bmN0cmxfZ2V0X2dyb3VwX25hbWUoc3RydWN0IHBpbmN0cmxfZGV2ICpwY3RsZGV2LAorCQkJCQkJ ICB1bnNpZ25lZCBncm91cCkKK3sKKwlyZXR1cm4gYmNtNjMxOF9ncm91cHNbZ3JvdXBdLm5hbWU7 Cit9CisKK3N0YXRpYyBpbnQgYmNtNjMxOF9waW5jdHJsX2dldF9ncm91cF9waW5zKHN0cnVjdCBw aW5jdHJsX2RldiAqcGN0bGRldiwKKwkJCQkJICB1bnNpZ25lZCBncm91cCwgY29uc3QgdW5zaWdu ZWQgKipwaW5zLAorCQkJCQkgIHVuc2lnbmVkICpudW1fcGlucykKK3sKKwkqcGlucyA9IGJjbTYz MThfZ3JvdXBzW2dyb3VwXS5waW5zOworCSpudW1fcGlucyA9IGJjbTYzMThfZ3JvdXBzW2dyb3Vw XS5udW1fcGluczsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IGJjbTYzMThfcGluY3Ry bF9nZXRfZnVuY19jb3VudChzdHJ1Y3QgcGluY3RybF9kZXYgKnBjdGxkZXYpCit7CisJcmV0dXJu IEFSUkFZX1NJWkUoYmNtNjMxOF9mdW5jcyk7Cit9CisKK3N0YXRpYyBjb25zdCBjaGFyICpiY202 MzE4X3BpbmN0cmxfZ2V0X2Z1bmNfbmFtZShzdHJ1Y3QgcGluY3RybF9kZXYgKnBjdGxkZXYsCisJ CQkJCQkgdW5zaWduZWQgc2VsZWN0b3IpCit7CisJcmV0dXJuIGJjbTYzMThfZnVuY3Nbc2VsZWN0 b3JdLm5hbWU7Cit9CisKK3N0YXRpYyBpbnQgYmNtNjMxOF9waW5jdHJsX2dldF9ncm91cHMoc3Ry dWN0IHBpbmN0cmxfZGV2ICpwY3RsZGV2LAorCQkJCSAgICAgIHVuc2lnbmVkIHNlbGVjdG9yLAor CQkJCSAgICAgIGNvbnN0IGNoYXIgKiBjb25zdCAqKmdyb3VwcywKKwkJCQkgICAgICB1bnNpZ25l ZCAqIGNvbnN0IG51bV9ncm91cHMpCit7CisJKmdyb3VwcyA9IGJjbTYzMThfZnVuY3Nbc2VsZWN0 b3JdLmdyb3VwczsKKwkqbnVtX2dyb3VwcyA9IGJjbTYzMThfZnVuY3Nbc2VsZWN0b3JdLm51bV9n cm91cHM7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGlubGluZSB2b2lkIGJjbTYzMThfcm13 X211eChzdHJ1Y3QgYmNtNjN4eF9waW5jdHJsICpwYywgdW5zaWduZWQgcGluLAorCQkJCSAgIHVu c2lnbmVkIGludCBtb2RlLCB1bnNpZ25lZCBpbnQgbXV4KQoreworCWlmIChwaW4gPCBCQ002M1hY X0JBTktfR1BJT1MpCisJCXJlZ21hcF91cGRhdGVfYml0cyhwYy0+cmVncywgQkNNNjMxOF9NT0RF X1JFRywgQklUKHBpbiksCisJCQkJICAgbW9kZSA/IEJJVChwaW4pIDogMCk7CisKKwlpZiAocGlu IDwgQkNNNjMxOF9OVU1fTVVYKQorCQlyZWdtYXBfdXBkYXRlX2JpdHMocGMtPnJlZ3MsCisJCQkJ ICAgYmNtNjMxOF9tdXhfb2ZmKHBpbiksCisJCQkJICAgQkNNNjMyOF9NVVhfTUFTSyA8PCAoKHBp biAlIDE2KSAqIDIpLAorCQkJCSAgIG11eCA8PCAoKHBpbiAlIDE2KSAqIDIpKTsKK30KKworc3Rh dGljIGlubGluZSB2b2lkIGJjbTYzMThfc2V0X3BhZChzdHJ1Y3QgYmNtNjN4eF9waW5jdHJsICpw YywgdW5zaWduZWQgcGluLAorCQkJCSAgIHVpbnQ4X3QgdmFsKQoreworCXJlZ21hcF91cGRhdGVf Yml0cyhwYy0+cmVncywgYmNtNjMxOF9wYWRfb2ZmKHBpbiksCisJCQkgICBCQ002MzI4X1BBRF9N QVNLIDw8ICgocGluICUgOCkgKiA0KSwKKwkJCSAgIHZhbCA8PCAoKHBpbiAlIDgpICogNCkpOwor fQorCitzdGF0aWMgaW50IGJjbTYzMThfcGluY3RybF9zZXRfbXV4KHN0cnVjdCBwaW5jdHJsX2Rl diAqcGN0bGRldiwKKwkJCQkgICB1bnNpZ25lZCBzZWxlY3RvciwgdW5zaWduZWQgZ3JvdXApCit7 CisJc3RydWN0IGJjbTYzeHhfcGluY3RybCAqcGMgPSBwaW5jdHJsX2Rldl9nZXRfZHJ2ZGF0YShw Y3RsZGV2KTsKKwljb25zdCBzdHJ1Y3QgYmNtNjMxOF9waW5ncm91cCAqcGcgPSAmYmNtNjMxOF9n cm91cHNbZ3JvdXBdOworCWNvbnN0IHN0cnVjdCBiY202MzE4X2Z1bmN0aW9uICpmID0gJmJjbTYz MThfZnVuY3Nbc2VsZWN0b3JdOworCisJYmNtNjMxOF9ybXdfbXV4KHBjLCBwZy0+cGluc1swXSwg Zi0+bW9kZV92YWwsIGYtPm11eF92YWwpOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQg YmNtNjMxOF9ncGlvX3JlcXVlc3RfZW5hYmxlKHN0cnVjdCBwaW5jdHJsX2RldiAqcGN0bGRldiwK KwkJCQkgICAgICAgc3RydWN0IHBpbmN0cmxfZ3Bpb19yYW5nZSAqcmFuZ2UsCisJCQkJICAgICAg IHVuc2lnbmVkIG9mZnNldCkKK3sKKwlzdHJ1Y3QgYmNtNjN4eF9waW5jdHJsICpwYyA9IHBpbmN0 cmxfZGV2X2dldF9kcnZkYXRhKHBjdGxkZXYpOworCisJLyogZGlzYWJsZSBhbGwgZnVuY3Rpb25z IHVzaW5nIHRoaXMgcGluICovCisJaWYgKG9mZnNldCA8IDEzKSB7CisJCS8qIEdQSU9zIDAtMTIg dXNlIG11eCAwIGFzIEdQSU8gZnVuY3Rpb24gKi8KKwkJYmNtNjMxOF9ybXdfbXV4KHBjLCBvZmZz ZXQsIDAsIDApOworCX0gZWxzZSBpZiAob2Zmc2V0IDwgNDIpIHsKKwkJLyogR1BJT3MgMTMtNDEg dXNlIG11eCAzIGFzIEdQSU8gZnVuY3Rpb24gKi8KKwkJYmNtNjMxOF9ybXdfbXV4KHBjLCBvZmZz ZXQsIDAsIDMpOworCisJCWJjbTYzMThfc2V0X3BhZChwYywgb2Zmc2V0LCAwKTsKKwl9CisKKwly ZXR1cm4gMDsKK30KKworc3RhdGljIHN0cnVjdCBwaW5jdHJsX29wcyBiY202MzE4X3BjdGxfb3Bz ID0geworCS5kdF9mcmVlX21hcCA9IHBpbmN0cmxfdXRpbHNfZnJlZV9tYXAsCisJLmR0X25vZGVf dG9fbWFwID0gcGluY29uZl9nZW5lcmljX2R0X25vZGVfdG9fbWFwX3BpbiwKKwkuZ2V0X2dyb3Vw X25hbWUgPSBiY202MzE4X3BpbmN0cmxfZ2V0X2dyb3VwX25hbWUsCisJLmdldF9ncm91cF9waW5z ID0gYmNtNjMxOF9waW5jdHJsX2dldF9ncm91cF9waW5zLAorCS5nZXRfZ3JvdXBzX2NvdW50ID0g YmNtNjMxOF9waW5jdHJsX2dldF9ncm91cF9jb3VudCwKK307CisKK3N0YXRpYyBzdHJ1Y3QgcGlu bXV4X29wcyBiY202MzE4X3BteF9vcHMgPSB7CisJLmdldF9mdW5jdGlvbl9ncm91cHMgPSBiY202 MzE4X3BpbmN0cmxfZ2V0X2dyb3VwcywKKwkuZ2V0X2Z1bmN0aW9uX25hbWUgPSBiY202MzE4X3Bp bmN0cmxfZ2V0X2Z1bmNfbmFtZSwKKwkuZ2V0X2Z1bmN0aW9uc19jb3VudCA9IGJjbTYzMThfcGlu Y3RybF9nZXRfZnVuY19jb3VudCwKKwkuZ3Bpb19yZXF1ZXN0X2VuYWJsZSA9IGJjbTYzMThfZ3Bp b19yZXF1ZXN0X2VuYWJsZSwKKwkuc2V0X211eCA9IGJjbTYzMThfcGluY3RybF9zZXRfbXV4LAor CS5zdHJpY3QgPSB0cnVlLAorfTsKKworc3RhdGljIGNvbnN0IHN0cnVjdCBiY202M3h4X3BpbmN0 cmxfc29jIGJjbTYzMThfc29jID0geworCS5uZ3Bpb3MgPSBCQ002MzE4X05VTV9HUElPUywKKwku bnBpbnMgPSBBUlJBWV9TSVpFKGJjbTYzMThfcGlucyksCisJLnBjdGxfb3BzID0gJmJjbTYzMThf cGN0bF9vcHMsCisJLnBpbnMgPSBiY202MzE4X3BpbnMsCisJLnBteF9vcHMgPSAmYmNtNjMxOF9w bXhfb3BzLAorfTsKKworc3RhdGljIGludCBiY202MzE4X3BpbmN0cmxfcHJvYmUoc3RydWN0IHBs YXRmb3JtX2RldmljZSAqcGRldikKK3sKKwlyZXR1cm4gYmNtNjN4eF9waW5jdHJsX3Byb2JlKHBk ZXYsICZiY202MzE4X3NvYywgTlVMTCk7Cit9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgb2ZfZGV2 aWNlX2lkIGJjbTYzMThfcGluY3RybF9tYXRjaFtdID0geworCXsgLmNvbXBhdGlibGUgPSAiYnJj bSxiY202MzE4LXBpbmN0cmwiLCB9LAorCXsgLyogc2VudGluZWwgKi8gfQorfTsKKworc3RhdGlj IHN0cnVjdCBwbGF0Zm9ybV9kcml2ZXIgYmNtNjMxOF9waW5jdHJsX2RyaXZlciA9IHsKKwkucHJv YmUgPSBiY202MzE4X3BpbmN0cmxfcHJvYmUsCisJLmRyaXZlciA9IHsKKwkJLm5hbWUgPSAiYmNt NjMxOC1waW5jdHJsIiwKKwkJLm9mX21hdGNoX3RhYmxlID0gYmNtNjMxOF9waW5jdHJsX21hdGNo LAorCX0sCit9OworCitidWlsdGluX3BsYXRmb3JtX2RyaXZlcihiY202MzE4X3BpbmN0cmxfZHJp dmVyKTsKLS0gCjIuMjAuMQoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fCmxpbnV4LWFybS1rZXJuZWwgbWFpbGluZyBsaXN0CmxpbnV4LWFybS1rZXJuZWxA bGlzdHMuaW5mcmFkZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xp c3RpbmZvL2xpbnV4LWFybS1rZXJuZWwK