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=-9.6 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, 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 46418C433E1 for ; Tue, 9 Jun 2020 10:53:02 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 199A62078D for ; Tue, 9 Jun 2020 10:53:02 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="pURvbwHJ" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726918AbgFIKxA (ORCPT ); Tue, 9 Jun 2020 06:53:00 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:33364 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727777AbgFIKwv (ORCPT ); Tue, 9 Jun 2020 06:52:51 -0400 Received: from mail-wr1-x442.google.com (mail-wr1-x442.google.com [IPv6:2a00:1450:4864:20::442]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 17A45C08C5C2; Tue, 9 Jun 2020 03:52:50 -0700 (PDT) Received: by mail-wr1-x442.google.com with SMTP id r7so20793359wro.1; Tue, 09 Jun 2020 03:52:50 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=qdOuIEoqs/+VDBW0OKFccriMXr4tmsLSpKU4xXreWrI=; b=pURvbwHJ0Q3YJ8g99HOsbCYQc+cYayvcMnQnatAXEU/KG76IQo8BsRyJiP1xKy+I2o 3EeLXDXloJLbigMVWbi3dMBLWhZuqiX6bUnwGWQAXpAX5OlE7umr5OXKBmLgpE8r5aic jfIlPpghtCNN4SwxeLCmiRgHTr8uQ0Pm/ZFiwL5/j+mw2CPoJw0NFpFo8Ees9B9uJX8u ctT586qoUaxWonJ9ApUWMtypLsdvjSPJ3wBoKckN3ZCdfQ4vNyU6QEMugdkrmp5w5YBX hXgD2Dk1wC7Lg/oaBAo0aPx9Ur9t5Cf27L+fNDvIymxVjMzy/1qvQ1VzQf/c0BakVFGT gkqg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=qdOuIEoqs/+VDBW0OKFccriMXr4tmsLSpKU4xXreWrI=; b=k2NEH/IKcWnqRvXaJVVOrgg2evxj65wKeyFPPtfX537FO06RKskyjIJDlcr4I9cjlA QlUsyItRbp/Lg51DNZvGsSBgh/CNgbKpjpBLHpx6gXqvRTFHJu5c51gj+fOZhVWkhI58 k4XSmk27Q1hTEFOWJfhxQFytWp/0K/6y33IV9uxfRLx+o8JNLFmYLS4YpJFyVBcbbUXr Gmi3ego5C9m3njo5dH5wzNOYL77XqZC6hAVAoR/DsUY6zC0Ph6twhRm5ciPoWhGyBCsO y5mZbeeOkmVkycm8GB4KebgVI6ZtgBUzMNybUPdW1NjfKrNydtftE8aJwfmMOCo4KPNr OaAg== X-Gm-Message-State: AOAM532deQhEwlbHV9CWL7OlEFvxSPmVrhEuwtLoz4Wf9QGIcHgYO2Cw 1QFPyWPBPsMRcCTewl6OxRhAHfiJFf4dlA== X-Google-Smtp-Source: ABdhPJzacyMzl5AcSYWGgfLsv0Eu2pANVtVHHoPdnZapMYpFzRu0zmU0d52povmbP5Di5kGTlWzOUw== X-Received: by 2002:adf:e387:: with SMTP id e7mr3752845wrm.70.1591699968682; Tue, 09 Jun 2020 03:52:48 -0700 (PDT) Received: from skynet.lan (28.red-83-49-61.dynamicip.rima-tde.net. [83.49.61.28]) by smtp.gmail.com with ESMTPSA id h5sm2949931wrw.85.2020.06.09.03.52.47 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 09 Jun 2020 03:52:48 -0700 (PDT) From: =?UTF-8?q?=C3=81lvaro=20Fern=C3=A1ndez=20Rojas?= To: hauke@hauke-m.de, zajec5@gmail.com, tsbogend@alpha.franken.de, robh+dt@kernel.org, f.fainelli@gmail.com, jonas.gorski@gmail.com, bcm-kernel-feedback-list@broadcom.com, linux-mips@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Cc: =?UTF-8?q?=C3=81lvaro=20Fern=C3=A1ndez=20Rojas?= Subject: [PATCH 2/4] soc: bcm: add BCM63xx power domain driver Date: Tue, 9 Jun 2020 12:52:42 +0200 Message-Id: <20200609105244.4014823-3-noltari@gmail.com> X-Mailer: git-send-email 2.26.2 In-Reply-To: <20200609105244.4014823-1-noltari@gmail.com> References: <20200609105244.4014823-1-noltari@gmail.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sender: linux-mips-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-mips@vger.kernel.org BCM6318, BCM6328, BCM6362 and BCM63268 SoCs have a power domain controller to enable/disable certain components in order to save power. Signed-off-by: Álvaro Fernández Rojas --- drivers/soc/bcm/Kconfig | 8 + drivers/soc/bcm/Makefile | 1 + drivers/soc/bcm/bcm63xx-power.c | 374 ++++++++++++++++++++++++++++++++ 3 files changed, 383 insertions(+) create mode 100644 drivers/soc/bcm/bcm63xx-power.c diff --git a/drivers/soc/bcm/Kconfig b/drivers/soc/bcm/Kconfig index 648e32693b7e..a2e60d28370b 100644 --- a/drivers/soc/bcm/Kconfig +++ b/drivers/soc/bcm/Kconfig @@ -13,6 +13,14 @@ config BCM2835_POWER firmware means that Linux usage of the same power domain must be accessed using the RASPBERRYPI_POWER driver +config BCM63XX_POWER + bool "BCM63xx power domain driver" + depends on BMIPS_GENERIC || (COMPILE_TEST && OF) + select PM_GENERIC_DOMAINS if PM + help + This enables support for the BCM63xx power domains controller on + BCM6318, BCM6328, BCM6362 and BCM63268 SoCs. + config RASPBERRYPI_POWER bool "Raspberry Pi power domain driver" depends on ARCH_BCM2835 || (COMPILE_TEST && OF) diff --git a/drivers/soc/bcm/Makefile b/drivers/soc/bcm/Makefile index d92268a829a9..e6c3d04a4a83 100644 --- a/drivers/soc/bcm/Makefile +++ b/drivers/soc/bcm/Makefile @@ -1,4 +1,5 @@ # SPDX-License-Identifier: GPL-2.0-only obj-$(CONFIG_BCM2835_POWER) += bcm2835-power.o +obj-$(CONFIG_BCM63XX_POWER) += bcm63xx-power.o obj-$(CONFIG_RASPBERRYPI_POWER) += raspberrypi-power.o obj-$(CONFIG_SOC_BRCMSTB) += brcmstb/ diff --git a/drivers/soc/bcm/bcm63xx-power.c b/drivers/soc/bcm/bcm63xx-power.c new file mode 100644 index 000000000000..b6e51b721f09 --- /dev/null +++ b/drivers/soc/bcm/bcm63xx-power.c @@ -0,0 +1,374 @@ +// SPDX-License-Identifier: GPL-2.0-or-later +/* + * BCM63xx Power Domain Controller Driver + * + * Copyright (C) 2020 Álvaro Fernández Rojas + */ + +#include +#include +#include +#include +#include +#include + +struct bcm63xx_power_dev { + struct generic_pm_domain genpd; + struct bcm63xx_power *power; + uint32_t mask; +}; + +struct bcm63xx_power { + void __iomem *base; + spinlock_t lock; + struct bcm63xx_power_dev *dev; + struct genpd_onecell_data genpd_data; + struct generic_pm_domain **genpd; +}; + +struct bcm63xx_power_data { + const char * const name; + uint8_t bit; + unsigned int flags; +}; + +static int bcm63xx_power_get_state(struct bcm63xx_power_dev *pmd, bool *is_on) +{ + struct bcm63xx_power *power = pmd->power; + + if (!pmd->mask) { + *is_on = false; + return -EINVAL; + } + + *is_on = !(__raw_readl(power->base) & pmd->mask); + + return 0; +} + +static int bcm63xx_power_set_state(struct bcm63xx_power_dev *pmd, bool on) +{ + struct bcm63xx_power *power = pmd->power; + unsigned long flags; + uint32_t val; + + if (!pmd->mask) + return -EINVAL; + + spin_lock_irqsave(&power->lock, flags); + val = __raw_readl(power->base); + if (on) + val &= ~pmd->mask; + else + val |= pmd->mask; + __raw_writel(val, power->base); + spin_unlock_irqrestore(&power->lock, flags); + + return 0; +} + +static int bcm63xx_power_on(struct generic_pm_domain *genpd) +{ + struct bcm63xx_power_dev *pmd = container_of(genpd, + struct bcm63xx_power_dev, genpd); + + return bcm63xx_power_set_state(pmd, true); +} + +static int bcm63xx_power_off(struct generic_pm_domain *genpd) +{ + struct bcm63xx_power_dev *pmd = container_of(genpd, + struct bcm63xx_power_dev, genpd); + + return bcm63xx_power_set_state(pmd, false); +} + +static int bcm63xx_power_probe(struct platform_device *pdev) +{ + struct device *dev = &pdev->dev; + struct device_node *np = dev->of_node; + struct resource *res; + const struct bcm63xx_power_data *entry, *table; + struct bcm63xx_power *power; + unsigned int ndom; + uint8_t max_bit = 0; + int ret; + + power = devm_kzalloc(dev, sizeof(*power), GFP_KERNEL); + if (!power) + return -ENOMEM; + + res = platform_get_resource(pdev, IORESOURCE_MEM, 0); + power->base = devm_ioremap_resource(&pdev->dev, res); + if (IS_ERR(power->base)) + return PTR_ERR(power->base); + + table = of_device_get_match_data(dev); + if (!table) + return -EINVAL; + + power->genpd_data.num_domains = 0; + ndom = 0; + for (entry = table; entry->name; entry++) { + max_bit = max(max_bit, entry->bit); + ndom++; + } + + if (!ndom) + return -ENODEV; + + power->genpd_data.num_domains = max_bit + 1; + + power->dev = devm_kcalloc(dev, power->genpd_data.num_domains, + sizeof(struct bcm63xx_power_dev), + GFP_KERNEL); + if (!power->dev) + return -ENOMEM; + + power->genpd = devm_kcalloc(dev, power->genpd_data.num_domains, + sizeof(struct generic_pm_domain *), + GFP_KERNEL); + if (!power->genpd) + return -ENOMEM; + + power->genpd_data.domains = power->genpd; + + ndom = 0; + for (entry = table; entry->name; entry++) { + struct bcm63xx_power_dev *pmd = &power->dev[ndom]; + bool is_on; + + pmd->power = power; + pmd->mask = BIT(entry->bit); + pmd->genpd.name = entry->name; + pmd->genpd.flags = entry->flags; + + ret = bcm63xx_power_get_state(pmd, &is_on); + if (ret) + dev_warn(dev, "unable to get current state for %s\n", + pmd->genpd.name); + + pmd->genpd.power_on = bcm63xx_power_on; + pmd->genpd.power_off = bcm63xx_power_off; + + pm_genpd_init(&pmd->genpd, NULL, !is_on); + power->genpd[entry->bit] = &pmd->genpd; + + ndom++; + } + + spin_lock_init(&power->lock); + + ret = of_genpd_add_provider_onecell(np, &power->genpd_data); + if (ret) { + dev_err(dev, "failed to register genpd driver: %d\n", ret); + return ret; + } + + dev_info(dev, "registered %u power domains\n", ndom); + + return 0; +} + +static const struct bcm63xx_power_data bcm6318_power_domains[] = { + { + .name = "pcie", + .bit = 0, + }, { + .name = "usb", + .bit = 1, + }, { + .name = "ephy0", + .bit = 2, + }, { + .name = "ephy1", + .bit = 3, + }, { + .name = "ephy2", + .bit = 4, + }, { + .name = "ephy3", + .bit = 5, + }, { + .name = "ldo2p5", + .bit = 6, + .flags = GENPD_FLAG_ALWAYS_ON, + }, { + .name = "ldo2p9", + .bit = 7, + .flags = GENPD_FLAG_ALWAYS_ON, + }, { + .name = "sw1p0", + .bit = 8, + .flags = GENPD_FLAG_ALWAYS_ON, + }, { + .name = "pad", + .bit = 9, + .flags = GENPD_FLAG_ALWAYS_ON, + }, { + /* sentinel */ + }, +}; + +static const struct bcm63xx_power_data bcm6328_power_domains[] = { + { + .name = "adsl2-mips", + .bit = 0, + }, { + .name = "adsl2-phy", + .bit = 1, + }, { + .name = "adsl2-afe", + .bit = 2, + }, { + .name = "sar", + .bit = 3, + }, { + .name = "pcm", + .bit = 4, + }, { + .name = "usbd", + .bit = 5, + }, { + .name = "usbh", + .bit = 6, + }, { + .name = "pcie", + .bit = 7, + }, { + .name = "robosw", + .bit = 8, + }, { + .name = "ephy", + .bit = 9, + }, { + /* sentinel */ + }, +}; + +static const struct bcm63xx_power_data bcm6362_power_domains[] = { + { + .name = "sar", + .bit = 0, + }, { + .name = "ipsec", + .bit = 1, + }, { + .name = "mips", + .bit = 2, + .flags = GENPD_FLAG_ALWAYS_ON, + }, { + .name = "dect", + .bit = 3, + }, { + .name = "usbh", + .bit = 4, + }, { + .name = "usbd", + .bit = 5, + }, { + .name = "robosw", + .bit = 6, + }, { + .name = "pcm", + .bit = 7, + }, { + .name = "periph", + .bit = 8, + .flags = GENPD_FLAG_ALWAYS_ON, + }, { + .name = "adsl-phy", + .bit = 9, + }, { + .name = "gmii-pads", + .bit = 10, + }, { + .name = "fap", + .bit = 11, + }, { + .name = "pcie", + .bit = 12, + }, { + .name = "wlan-pads", + .bit = 13, + }, { + /* sentinel */ + }, +}; + +static const struct bcm63xx_power_data bcm63268_power_domains[] = { + { + .name = "sar", + .bit = 0, + }, { + .name = "ipsec", + .bit = 1, + }, { + .name = "mips", + .bit = 2, + .flags = GENPD_FLAG_ALWAYS_ON, + }, { + .name = "dect", + .bit = 3, + }, { + .name = "usbh", + .bit = 4, + }, { + .name = "usbd", + .bit = 5, + }, { + .name = "robosw", + .bit = 6, + }, { + .name = "pcm", + .bit = 7, + }, { + .name = "periph", + .bit = 8, + .flags = GENPD_FLAG_ALWAYS_ON, + }, { + .name = "vdsl-phy", + .bit = 9, + }, { + .name = "vdsl-mips", + .bit = 10, + }, { + .name = "fap", + .bit = 11, + }, { + .name = "pcie", + .bit = 12, + }, { + .name = "wlan-pads", + .bit = 13, + }, { + /* sentinel */ + }, +}; + +static const struct of_device_id bcm63xx_power_of_match[] = { + { + .compatible = "brcm,bcm6318-power-controller", + .data = &bcm6318_power_domains, + }, { + .compatible = "brcm,bcm6328-power-controller", + .data = &bcm6328_power_domains, + }, { + .compatible = "brcm,bcm6362-power-controller", + .data = &bcm6362_power_domains, + }, { + .compatible = "brcm,bcm63268-power-controller", + .data = &bcm63268_power_domains, + }, { + /* sentinel */ + } +}; + +static struct platform_driver bcm63xx_power_driver = { + .driver = { + .name = "bcm63xx-power-controller", + .of_match_table = bcm63xx_power_of_match, + }, + .probe = bcm63xx_power_probe, +}; +builtin_platform_driver(bcm63xx_power_driver); -- 2.26.2 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=-9.5 required=3.0 tests=DKIM_ADSP_CUSTOM_MED, DKIM_SIGNED,DKIM_VALID,FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, 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 2142BC433E0 for ; Tue, 9 Jun 2020 10:53:39 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (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 CEA5A2078D for ; Tue, 9 Jun 2020 10:53:38 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="DUJ7UMmP"; dkim=fail reason="signature verification failed" (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="pURvbwHJ" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org CEA5A2078D 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+infradead-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=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:Cc: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:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=hNzZnp0kIrtii2NQeSsuuPGounJtmqX1AU7UjvwexvY=; b=DUJ7UMmP3Sqrv1 p0XT/55xKWs7wfjkR9TW2kV0U32LCVSNFmUOgyoqdE9CFuxECQS8m7uRnOty9bAFNeu2183scxNm/ D6AG/5vRM+fSc8/wqpS3abIC9yvaVkSXbyrTIFMhBvMCqq3V4VeZ1e8Tqutd8JuhIEX/Mnv2CNlny IecVfgxNuMwq4xzOp7ZjPp9ErsnAWe9MxQJNWEbMhIRa3vpELhPmxE3nqFj19uWgPVBPk0a5IoQtQ r6v2H+8uBxCqPkRZfAnvkJRLkhCVA9DANztdWmev8nyzp7NGZ3eCEj4g5SC9RCi6HFV+pnviLI4E+ 8Cyl7Euc+EqcFuNPpbVA==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1jibsp-0006sk-Vh; Tue, 09 Jun 2020 10:53:32 +0000 Received: from mail-wr1-x442.google.com ([2a00:1450:4864:20::442]) by bombadil.infradead.org with esmtps (Exim 4.92.3 #3 (Red Hat Linux)) id 1jibs9-0006G2-VQ for linux-arm-kernel@lists.infradead.org; Tue, 09 Jun 2020 10:52:52 +0000 Received: by mail-wr1-x442.google.com with SMTP id x6so20705139wrm.13 for ; Tue, 09 Jun 2020 03:52:49 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=qdOuIEoqs/+VDBW0OKFccriMXr4tmsLSpKU4xXreWrI=; b=pURvbwHJ0Q3YJ8g99HOsbCYQc+cYayvcMnQnatAXEU/KG76IQo8BsRyJiP1xKy+I2o 3EeLXDXloJLbigMVWbi3dMBLWhZuqiX6bUnwGWQAXpAX5OlE7umr5OXKBmLgpE8r5aic jfIlPpghtCNN4SwxeLCmiRgHTr8uQ0Pm/ZFiwL5/j+mw2CPoJw0NFpFo8Ees9B9uJX8u ctT586qoUaxWonJ9ApUWMtypLsdvjSPJ3wBoKckN3ZCdfQ4vNyU6QEMugdkrmp5w5YBX hXgD2Dk1wC7Lg/oaBAo0aPx9Ur9t5Cf27L+fNDvIymxVjMzy/1qvQ1VzQf/c0BakVFGT gkqg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=qdOuIEoqs/+VDBW0OKFccriMXr4tmsLSpKU4xXreWrI=; b=pz06bI2lDa8N2ld2R627PVvMZOCc/LM7iMRK5MQU5dBvhJiTjgWDk0AeE58wYABNJj IcYhvde0eatusicilCo85nCe8qGue/jt9nCIdmomUUQMZ5/AlW2z3EGGv5q1fuhozL0F qGwLMRNInNZjm/PQ8XaHqZKAtSlgmTZtndRKWkXOGqkDuj6lZaVpVK7itZW9uWYIhIKT +2NZqmynWOSW3fyEi4CBMDx+guV0daj8HQGEfz1ACHaLrkW667mHOqd+aTItNVIwp0dl /OcnHqyfG0DFj1J4ku5pf8Z0L7BnqoqSMQ6CXDNvMMiDXRTlgZB6TsJT6oVKge8cTZjp REvw== X-Gm-Message-State: AOAM532xjOAeIXIn+o/D2MOyAc+/SckVXNahP5lGgFESu1c/Ds3CaJYX jrW8hMvfEpBehSvww6HyvrQ= X-Google-Smtp-Source: ABdhPJzacyMzl5AcSYWGgfLsv0Eu2pANVtVHHoPdnZapMYpFzRu0zmU0d52povmbP5Di5kGTlWzOUw== X-Received: by 2002:adf:e387:: with SMTP id e7mr3752845wrm.70.1591699968682; Tue, 09 Jun 2020 03:52:48 -0700 (PDT) Received: from skynet.lan (28.red-83-49-61.dynamicip.rima-tde.net. [83.49.61.28]) by smtp.gmail.com with ESMTPSA id h5sm2949931wrw.85.2020.06.09.03.52.47 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 09 Jun 2020 03:52:48 -0700 (PDT) From: =?UTF-8?q?=C3=81lvaro=20Fern=C3=A1ndez=20Rojas?= To: hauke@hauke-m.de, zajec5@gmail.com, tsbogend@alpha.franken.de, robh+dt@kernel.org, f.fainelli@gmail.com, jonas.gorski@gmail.com, bcm-kernel-feedback-list@broadcom.com, linux-mips@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [PATCH 2/4] soc: bcm: add BCM63xx power domain driver Date: Tue, 9 Jun 2020 12:52:42 +0200 Message-Id: <20200609105244.4014823-3-noltari@gmail.com> X-Mailer: git-send-email 2.26.2 In-Reply-To: <20200609105244.4014823-1-noltari@gmail.com> References: <20200609105244.4014823-1-noltari@gmail.com> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20200609_035250_045507_21F25A2C X-CRM114-Status: GOOD ( 16.24 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: =?UTF-8?q?=C3=81lvaro=20Fern=C3=A1ndez=20Rojas?= Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+infradead-linux-arm-kernel=archiver.kernel.org@lists.infradead.org QkNNNjMxOCwgQkNNNjMyOCwgQkNNNjM2MiBhbmQgQkNNNjMyNjggU29DcyBoYXZlIGEgcG93ZXIg ZG9tYWluIGNvbnRyb2xsZXIKdG8gZW5hYmxlL2Rpc2FibGUgY2VydGFpbiBjb21wb25lbnRzIGlu IG9yZGVyIHRvIHNhdmUgcG93ZXIuCgpTaWduZWQtb2ZmLWJ5OiDDgWx2YXJvIEZlcm7DoW5kZXog Um9qYXMgPG5vbHRhcmlAZ21haWwuY29tPgotLS0KIGRyaXZlcnMvc29jL2JjbS9LY29uZmlnICAg ICAgICAgfCAgIDggKwogZHJpdmVycy9zb2MvYmNtL01ha2VmaWxlICAgICAgICB8ICAgMSArCiBk cml2ZXJzL3NvYy9iY20vYmNtNjN4eC1wb3dlci5jIHwgMzc0ICsrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrCiAzIGZpbGVzIGNoYW5nZWQsIDM4MyBpbnNlcnRpb25zKCspCiBjcmVhdGUg bW9kZSAxMDA2NDQgZHJpdmVycy9zb2MvYmNtL2JjbTYzeHgtcG93ZXIuYwoKZGlmZiAtLWdpdCBh L2RyaXZlcnMvc29jL2JjbS9LY29uZmlnIGIvZHJpdmVycy9zb2MvYmNtL0tjb25maWcKaW5kZXgg NjQ4ZTMyNjkzYjdlLi5hMmU2MGQyODM3MGIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc29jL2JjbS9L Y29uZmlnCisrKyBiL2RyaXZlcnMvc29jL2JjbS9LY29uZmlnCkBAIC0xMyw2ICsxMywxNCBAQCBj b25maWcgQkNNMjgzNV9QT1dFUgogCSAgZmlybXdhcmUgbWVhbnMgdGhhdCBMaW51eCB1c2FnZSBv ZiB0aGUgc2FtZSBwb3dlciBkb21haW4KIAkgIG11c3QgYmUgYWNjZXNzZWQgdXNpbmcgdGhlIFJB U1BCRVJSWVBJX1BPV0VSIGRyaXZlcgogCitjb25maWcgQkNNNjNYWF9QT1dFUgorCWJvb2wgIkJD TTYzeHggcG93ZXIgZG9tYWluIGRyaXZlciIKKwlkZXBlbmRzIG9uIEJNSVBTX0dFTkVSSUMgfHwg KENPTVBJTEVfVEVTVCAmJiBPRikKKwlzZWxlY3QgUE1fR0VORVJJQ19ET01BSU5TIGlmIFBNCisJ aGVscAorCSAgVGhpcyBlbmFibGVzIHN1cHBvcnQgZm9yIHRoZSBCQ002M3h4IHBvd2VyIGRvbWFp bnMgY29udHJvbGxlciBvbgorCSAgQkNNNjMxOCwgQkNNNjMyOCwgQkNNNjM2MiBhbmQgQkNNNjMy NjggU29Dcy4KKwogY29uZmlnIFJBU1BCRVJSWVBJX1BPV0VSCiAJYm9vbCAiUmFzcGJlcnJ5IFBp IHBvd2VyIGRvbWFpbiBkcml2ZXIiCiAJZGVwZW5kcyBvbiBBUkNIX0JDTTI4MzUgfHwgKENPTVBJ TEVfVEVTVCAmJiBPRikKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc29jL2JjbS9NYWtlZmlsZSBiL2Ry aXZlcnMvc29jL2JjbS9NYWtlZmlsZQppbmRleCBkOTIyNjhhODI5YTkuLmU2YzNkMDRhNGE4MyAx MDA2NDQKLS0tIGEvZHJpdmVycy9zb2MvYmNtL01ha2VmaWxlCisrKyBiL2RyaXZlcnMvc29jL2Jj bS9NYWtlZmlsZQpAQCAtMSw0ICsxLDUgQEAKICMgU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQ TC0yLjAtb25seQogb2JqLSQoQ09ORklHX0JDTTI4MzVfUE9XRVIpCSs9IGJjbTI4MzUtcG93ZXIu bworb2JqLSQoQ09ORklHX0JDTTYzWFhfUE9XRVIpCSs9IGJjbTYzeHgtcG93ZXIubwogb2JqLSQo Q09ORklHX1JBU1BCRVJSWVBJX1BPV0VSKQkrPSByYXNwYmVycnlwaS1wb3dlci5vCiBvYmotJChD T05GSUdfU09DX0JSQ01TVEIpCSs9IGJyY21zdGIvCmRpZmYgLS1naXQgYS9kcml2ZXJzL3NvYy9i Y20vYmNtNjN4eC1wb3dlci5jIGIvZHJpdmVycy9zb2MvYmNtL2JjbTYzeHgtcG93ZXIuYwpuZXcg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLmI2ZTUxYjcyMWYwOQotLS0gL2Rl di9udWxsCisrKyBiL2RyaXZlcnMvc29jL2JjbS9iY202M3h4LXBvd2VyLmMKQEAgLTAsMCArMSwz NzQgQEAKKy8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wLW9yLWxhdGVyCisvKgor ICogQkNNNjN4eCBQb3dlciBEb21haW4gQ29udHJvbGxlciBEcml2ZXIKKyAqCisgKiBDb3B5cmln aHQgKEMpIDIwMjAgw4FsdmFybyBGZXJuw6FuZGV6IFJvamFzIDxub2x0YXJpQGdtYWlsLmNvbT4K KyAqLworCisjaW5jbHVkZSA8bGludXgvaW8uaD4KKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4K KyNpbmNsdWRlIDxsaW51eC9wbGF0Zm9ybV9kZXZpY2UuaD4KKyNpbmNsdWRlIDxsaW51eC9wbV9k b21haW4uaD4KKyNpbmNsdWRlIDxsaW51eC9vZi5oPgorI2luY2x1ZGUgPGxpbnV4L29mX2Rldmlj ZS5oPgorCitzdHJ1Y3QgYmNtNjN4eF9wb3dlcl9kZXYgeworCXN0cnVjdCBnZW5lcmljX3BtX2Rv bWFpbiBnZW5wZDsKKwlzdHJ1Y3QgYmNtNjN4eF9wb3dlciAqcG93ZXI7CisJdWludDMyX3QgbWFz azsKK307CisKK3N0cnVjdCBiY202M3h4X3Bvd2VyIHsKKwl2b2lkIF9faW9tZW0gKmJhc2U7CisJ c3BpbmxvY2tfdCBsb2NrOworCXN0cnVjdCBiY202M3h4X3Bvd2VyX2RldiAqZGV2OworCXN0cnVj dCBnZW5wZF9vbmVjZWxsX2RhdGEgZ2VucGRfZGF0YTsKKwlzdHJ1Y3QgZ2VuZXJpY19wbV9kb21h aW4gKipnZW5wZDsKK307CisKK3N0cnVjdCBiY202M3h4X3Bvd2VyX2RhdGEgeworCWNvbnN0IGNo YXIgKiBjb25zdCBuYW1lOworCXVpbnQ4X3QgYml0OworCXVuc2lnbmVkIGludCBmbGFnczsKK307 CisKK3N0YXRpYyBpbnQgYmNtNjN4eF9wb3dlcl9nZXRfc3RhdGUoc3RydWN0IGJjbTYzeHhfcG93 ZXJfZGV2ICpwbWQsIGJvb2wgKmlzX29uKQoreworCXN0cnVjdCBiY202M3h4X3Bvd2VyICpwb3dl ciA9IHBtZC0+cG93ZXI7CisKKwlpZiAoIXBtZC0+bWFzaykgeworCQkqaXNfb24gPSBmYWxzZTsK KwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCisJKmlzX29uID0gIShfX3Jhd19yZWFkbChwb3dlci0+ YmFzZSkgJiBwbWQtPm1hc2spOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgYmNtNjN4 eF9wb3dlcl9zZXRfc3RhdGUoc3RydWN0IGJjbTYzeHhfcG93ZXJfZGV2ICpwbWQsIGJvb2wgb24p Cit7CisJc3RydWN0IGJjbTYzeHhfcG93ZXIgKnBvd2VyID0gcG1kLT5wb3dlcjsKKwl1bnNpZ25l ZCBsb25nIGZsYWdzOworCXVpbnQzMl90IHZhbDsKKworCWlmICghcG1kLT5tYXNrKQorCQlyZXR1 cm4gLUVJTlZBTDsKKworCXNwaW5fbG9ja19pcnFzYXZlKCZwb3dlci0+bG9jaywgZmxhZ3MpOwor CXZhbCA9IF9fcmF3X3JlYWRsKHBvd2VyLT5iYXNlKTsKKwlpZiAob24pCisJCXZhbCAmPSB+cG1k LT5tYXNrOworCWVsc2UKKwkJdmFsIHw9IHBtZC0+bWFzazsKKwlfX3Jhd193cml0ZWwodmFsLCBw b3dlci0+YmFzZSk7CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcG93ZXItPmxvY2ssIGZsYWdz KTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IGJjbTYzeHhfcG93ZXJfb24oc3RydWN0 IGdlbmVyaWNfcG1fZG9tYWluICpnZW5wZCkKK3sKKwlzdHJ1Y3QgYmNtNjN4eF9wb3dlcl9kZXYg KnBtZCA9IGNvbnRhaW5lcl9vZihnZW5wZCwKKwkJc3RydWN0IGJjbTYzeHhfcG93ZXJfZGV2LCBn ZW5wZCk7CisKKwlyZXR1cm4gYmNtNjN4eF9wb3dlcl9zZXRfc3RhdGUocG1kLCB0cnVlKTsKK30K Kworc3RhdGljIGludCBiY202M3h4X3Bvd2VyX29mZihzdHJ1Y3QgZ2VuZXJpY19wbV9kb21haW4g KmdlbnBkKQoreworCXN0cnVjdCBiY202M3h4X3Bvd2VyX2RldiAqcG1kID0gY29udGFpbmVyX29m KGdlbnBkLAorCQlzdHJ1Y3QgYmNtNjN4eF9wb3dlcl9kZXYsIGdlbnBkKTsKKworCXJldHVybiBi Y202M3h4X3Bvd2VyX3NldF9zdGF0ZShwbWQsIGZhbHNlKTsKK30KKworc3RhdGljIGludCBiY202 M3h4X3Bvd2VyX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCit7CisJc3RydWN0 IGRldmljZSAqZGV2ID0gJnBkZXYtPmRldjsKKwlzdHJ1Y3QgZGV2aWNlX25vZGUgKm5wID0gZGV2 LT5vZl9ub2RlOworCXN0cnVjdCByZXNvdXJjZSAqcmVzOworCWNvbnN0IHN0cnVjdCBiY202M3h4 X3Bvd2VyX2RhdGEgKmVudHJ5LCAqdGFibGU7CisJc3RydWN0IGJjbTYzeHhfcG93ZXIgKnBvd2Vy OworCXVuc2lnbmVkIGludCBuZG9tOworCXVpbnQ4X3QgbWF4X2JpdCA9IDA7CisJaW50IHJldDsK KworCXBvd2VyID0gZGV2bV9remFsbG9jKGRldiwgc2l6ZW9mKCpwb3dlciksIEdGUF9LRVJORUwp OworCWlmICghcG93ZXIpCisJCXJldHVybiAtRU5PTUVNOworCisJcmVzID0gcGxhdGZvcm1fZ2V0 X3Jlc291cmNlKHBkZXYsIElPUkVTT1VSQ0VfTUVNLCAwKTsKKwlwb3dlci0+YmFzZSA9IGRldm1f aW9yZW1hcF9yZXNvdXJjZSgmcGRldi0+ZGV2LCByZXMpOworCWlmIChJU19FUlIocG93ZXItPmJh c2UpKQorCQlyZXR1cm4gUFRSX0VSUihwb3dlci0+YmFzZSk7CisKKwl0YWJsZSA9IG9mX2Rldmlj ZV9nZXRfbWF0Y2hfZGF0YShkZXYpOworCWlmICghdGFibGUpCisJCXJldHVybiAtRUlOVkFMOwor CisJcG93ZXItPmdlbnBkX2RhdGEubnVtX2RvbWFpbnMgPSAwOworCW5kb20gPSAwOworCWZvciAo ZW50cnkgPSB0YWJsZTsgZW50cnktPm5hbWU7IGVudHJ5KyspIHsKKwkJbWF4X2JpdCA9IG1heCht YXhfYml0LCBlbnRyeS0+Yml0KTsKKwkJbmRvbSsrOworCX0KKworCWlmICghbmRvbSkKKwkJcmV0 dXJuIC1FTk9ERVY7CisKKwlwb3dlci0+Z2VucGRfZGF0YS5udW1fZG9tYWlucyA9IG1heF9iaXQg KyAxOworCisJcG93ZXItPmRldiA9IGRldm1fa2NhbGxvYyhkZXYsIHBvd2VyLT5nZW5wZF9kYXRh Lm51bV9kb21haW5zLAorCQkJCSAgc2l6ZW9mKHN0cnVjdCBiY202M3h4X3Bvd2VyX2RldiksCisJ CQkJICBHRlBfS0VSTkVMKTsKKwlpZiAoIXBvd2VyLT5kZXYpCisJCXJldHVybiAtRU5PTUVNOwor CisJcG93ZXItPmdlbnBkID0gZGV2bV9rY2FsbG9jKGRldiwgcG93ZXItPmdlbnBkX2RhdGEubnVt X2RvbWFpbnMsCisJCQkJICAgIHNpemVvZihzdHJ1Y3QgZ2VuZXJpY19wbV9kb21haW4gKiksCisJ CQkJICAgIEdGUF9LRVJORUwpOworCWlmICghcG93ZXItPmdlbnBkKQorCQlyZXR1cm4gLUVOT01F TTsKKworCXBvd2VyLT5nZW5wZF9kYXRhLmRvbWFpbnMgPSBwb3dlci0+Z2VucGQ7CisKKwluZG9t ID0gMDsKKwlmb3IgKGVudHJ5ID0gdGFibGU7IGVudHJ5LT5uYW1lOyBlbnRyeSsrKSB7CisJCXN0 cnVjdCBiY202M3h4X3Bvd2VyX2RldiAqcG1kID0gJnBvd2VyLT5kZXZbbmRvbV07CisJCWJvb2wg aXNfb247CisKKwkJcG1kLT5wb3dlciA9IHBvd2VyOworCQlwbWQtPm1hc2sgPSBCSVQoZW50cnkt PmJpdCk7CisJCXBtZC0+Z2VucGQubmFtZSA9IGVudHJ5LT5uYW1lOworCQlwbWQtPmdlbnBkLmZs YWdzID0gZW50cnktPmZsYWdzOworCisJCXJldCA9IGJjbTYzeHhfcG93ZXJfZ2V0X3N0YXRlKHBt ZCwgJmlzX29uKTsKKwkJaWYgKHJldCkKKwkJCWRldl93YXJuKGRldiwgInVuYWJsZSB0byBnZXQg Y3VycmVudCBzdGF0ZSBmb3IgJXNcbiIsCisJCQkJIHBtZC0+Z2VucGQubmFtZSk7CisKKwkJcG1k LT5nZW5wZC5wb3dlcl9vbiA9IGJjbTYzeHhfcG93ZXJfb247CisJCXBtZC0+Z2VucGQucG93ZXJf b2ZmID0gYmNtNjN4eF9wb3dlcl9vZmY7CisKKwkJcG1fZ2VucGRfaW5pdCgmcG1kLT5nZW5wZCwg TlVMTCwgIWlzX29uKTsKKwkJcG93ZXItPmdlbnBkW2VudHJ5LT5iaXRdID0gJnBtZC0+Z2VucGQ7 CisKKwkJbmRvbSsrOworCX0KKworCXNwaW5fbG9ja19pbml0KCZwb3dlci0+bG9jayk7CisKKwly ZXQgPSBvZl9nZW5wZF9hZGRfcHJvdmlkZXJfb25lY2VsbChucCwgJnBvd2VyLT5nZW5wZF9kYXRh KTsKKwlpZiAocmV0KSB7CisJCWRldl9lcnIoZGV2LCAiZmFpbGVkIHRvIHJlZ2lzdGVyIGdlbnBk IGRyaXZlcjogJWRcbiIsIHJldCk7CisJCXJldHVybiByZXQ7CisJfQorCisJZGV2X2luZm8oZGV2 LCAicmVnaXN0ZXJlZCAldSBwb3dlciBkb21haW5zXG4iLCBuZG9tKTsKKworCXJldHVybiAwOwor fQorCitzdGF0aWMgY29uc3Qgc3RydWN0IGJjbTYzeHhfcG93ZXJfZGF0YSBiY202MzE4X3Bvd2Vy X2RvbWFpbnNbXSA9IHsKKwl7CisJCS5uYW1lID0gInBjaWUiLAorCQkuYml0ID0gMCwKKwl9LCB7 CisJCS5uYW1lID0gInVzYiIsCisJCS5iaXQgPSAxLAorCX0sIHsKKwkJLm5hbWUgPSAiZXBoeTAi LAorCQkuYml0ID0gMiwKKwl9LCB7CisJCS5uYW1lID0gImVwaHkxIiwKKwkJLmJpdCA9IDMsCisJ fSwgeworCQkubmFtZSA9ICJlcGh5MiIsCisJCS5iaXQgPSA0LAorCX0sIHsKKwkJLm5hbWUgPSAi ZXBoeTMiLAorCQkuYml0ID0gNSwKKwl9LCB7CisJCS5uYW1lID0gImxkbzJwNSIsCisJCS5iaXQg PSA2LAorCQkuZmxhZ3MgPSBHRU5QRF9GTEFHX0FMV0FZU19PTiwKKwl9LCB7CisJCS5uYW1lID0g ImxkbzJwOSIsCisJCS5iaXQgPSA3LAorCQkuZmxhZ3MgPSBHRU5QRF9GTEFHX0FMV0FZU19PTiwK Kwl9LCB7CisJCS5uYW1lID0gInN3MXAwIiwKKwkJLmJpdCA9IDgsCisJCS5mbGFncyA9IEdFTlBE X0ZMQUdfQUxXQVlTX09OLAorCX0sIHsKKwkJLm5hbWUgPSAicGFkIiwKKwkJLmJpdCA9IDksCisJ CS5mbGFncyA9IEdFTlBEX0ZMQUdfQUxXQVlTX09OLAorCX0sIHsKKwkJLyogc2VudGluZWwgKi8K Kwl9LAorfTsKKworc3RhdGljIGNvbnN0IHN0cnVjdCBiY202M3h4X3Bvd2VyX2RhdGEgYmNtNjMy OF9wb3dlcl9kb21haW5zW10gPSB7CisJeworCQkubmFtZSA9ICJhZHNsMi1taXBzIiwKKwkJLmJp dCA9IDAsCisJfSwgeworCQkubmFtZSA9ICJhZHNsMi1waHkiLAorCQkuYml0ID0gMSwKKwl9LCB7 CisJCS5uYW1lID0gImFkc2wyLWFmZSIsCisJCS5iaXQgPSAyLAorCX0sIHsKKwkJLm5hbWUgPSAi c2FyIiwKKwkJLmJpdCA9IDMsCisJfSwgeworCQkubmFtZSA9ICJwY20iLAorCQkuYml0ID0gNCwK Kwl9LCB7CisJCS5uYW1lID0gInVzYmQiLAorCQkuYml0ID0gNSwKKwl9LCB7CisJCS5uYW1lID0g InVzYmgiLAorCQkuYml0ID0gNiwKKwl9LCB7CisJCS5uYW1lID0gInBjaWUiLAorCQkuYml0ID0g NywKKwl9LCB7CisJCS5uYW1lID0gInJvYm9zdyIsCisJCS5iaXQgPSA4LAorCX0sIHsKKwkJLm5h bWUgPSAiZXBoeSIsCisJCS5iaXQgPSA5LAorCX0sIHsKKwkJLyogc2VudGluZWwgKi8KKwl9LAor fTsKKworc3RhdGljIGNvbnN0IHN0cnVjdCBiY202M3h4X3Bvd2VyX2RhdGEgYmNtNjM2Ml9wb3dl cl9kb21haW5zW10gPSB7CisJeworCQkubmFtZSA9ICJzYXIiLAorCQkuYml0ID0gMCwKKwl9LCB7 CisJCS5uYW1lID0gImlwc2VjIiwKKwkJLmJpdCA9IDEsCisJfSwgeworCQkubmFtZSA9ICJtaXBz IiwKKwkJLmJpdCA9IDIsCisJCS5mbGFncyA9IEdFTlBEX0ZMQUdfQUxXQVlTX09OLAorCX0sIHsK KwkJLm5hbWUgPSAiZGVjdCIsCisJCS5iaXQgPSAzLAorCX0sIHsKKwkJLm5hbWUgPSAidXNiaCIs CisJCS5iaXQgPSA0LAorCX0sIHsKKwkJLm5hbWUgPSAidXNiZCIsCisJCS5iaXQgPSA1LAorCX0s IHsKKwkJLm5hbWUgPSAicm9ib3N3IiwKKwkJLmJpdCA9IDYsCisJfSwgeworCQkubmFtZSA9ICJw Y20iLAorCQkuYml0ID0gNywKKwl9LCB7CisJCS5uYW1lID0gInBlcmlwaCIsCisJCS5iaXQgPSA4 LAorCQkuZmxhZ3MgPSBHRU5QRF9GTEFHX0FMV0FZU19PTiwKKwl9LCB7CisJCS5uYW1lID0gImFk c2wtcGh5IiwKKwkJLmJpdCA9IDksCisJfSwgeworCQkubmFtZSA9ICJnbWlpLXBhZHMiLAorCQku Yml0ID0gMTAsCisJfSwgeworCQkubmFtZSA9ICJmYXAiLAorCQkuYml0ID0gMTEsCisJfSwgewor CQkubmFtZSA9ICJwY2llIiwKKwkJLmJpdCA9IDEyLAorCX0sIHsKKwkJLm5hbWUgPSAid2xhbi1w YWRzIiwKKwkJLmJpdCA9IDEzLAorCX0sIHsKKwkJLyogc2VudGluZWwgKi8KKwl9LAorfTsKKwor c3RhdGljIGNvbnN0IHN0cnVjdCBiY202M3h4X3Bvd2VyX2RhdGEgYmNtNjMyNjhfcG93ZXJfZG9t YWluc1tdID0geworCXsKKwkJLm5hbWUgPSAic2FyIiwKKwkJLmJpdCA9IDAsCisJfSwgeworCQku bmFtZSA9ICJpcHNlYyIsCisJCS5iaXQgPSAxLAorCX0sIHsKKwkJLm5hbWUgPSAibWlwcyIsCisJ CS5iaXQgPSAyLAorCQkuZmxhZ3MgPSBHRU5QRF9GTEFHX0FMV0FZU19PTiwKKwl9LCB7CisJCS5u YW1lID0gImRlY3QiLAorCQkuYml0ID0gMywKKwl9LCB7CisJCS5uYW1lID0gInVzYmgiLAorCQku Yml0ID0gNCwKKwl9LCB7CisJCS5uYW1lID0gInVzYmQiLAorCQkuYml0ID0gNSwKKwl9LCB7CisJ CS5uYW1lID0gInJvYm9zdyIsCisJCS5iaXQgPSA2LAorCX0sIHsKKwkJLm5hbWUgPSAicGNtIiwK KwkJLmJpdCA9IDcsCisJfSwgeworCQkubmFtZSA9ICJwZXJpcGgiLAorCQkuYml0ID0gOCwKKwkJ LmZsYWdzID0gR0VOUERfRkxBR19BTFdBWVNfT04sCisJfSwgeworCQkubmFtZSA9ICJ2ZHNsLXBo eSIsCisJCS5iaXQgPSA5LAorCX0sIHsKKwkJLm5hbWUgPSAidmRzbC1taXBzIiwKKwkJLmJpdCA9 IDEwLAorCX0sIHsKKwkJLm5hbWUgPSAiZmFwIiwKKwkJLmJpdCA9IDExLAorCX0sIHsKKwkJLm5h bWUgPSAicGNpZSIsCisJCS5iaXQgPSAxMiwKKwl9LCB7CisJCS5uYW1lID0gIndsYW4tcGFkcyIs CisJCS5iaXQgPSAxMywKKwl9LCB7CisJCS8qIHNlbnRpbmVsICovCisJfSwKK307CisKK3N0YXRp YyBjb25zdCBzdHJ1Y3Qgb2ZfZGV2aWNlX2lkIGJjbTYzeHhfcG93ZXJfb2ZfbWF0Y2hbXSA9IHsK Kwl7CisJCS5jb21wYXRpYmxlID0gImJyY20sYmNtNjMxOC1wb3dlci1jb250cm9sbGVyIiwKKwkJ LmRhdGEgPSAmYmNtNjMxOF9wb3dlcl9kb21haW5zLAorCX0sIHsKKwkJLmNvbXBhdGlibGUgPSAi YnJjbSxiY202MzI4LXBvd2VyLWNvbnRyb2xsZXIiLAorCQkuZGF0YSA9ICZiY202MzI4X3Bvd2Vy X2RvbWFpbnMsCisJfSwgeworCQkuY29tcGF0aWJsZSA9ICJicmNtLGJjbTYzNjItcG93ZXItY29u dHJvbGxlciIsCisJCS5kYXRhID0gJmJjbTYzNjJfcG93ZXJfZG9tYWlucywKKwl9LCB7CisJCS5j b21wYXRpYmxlID0gImJyY20sYmNtNjMyNjgtcG93ZXItY29udHJvbGxlciIsCisJCS5kYXRhID0g JmJjbTYzMjY4X3Bvd2VyX2RvbWFpbnMsCisJfSwgeworCQkvKiBzZW50aW5lbCAqLworCX0KK307 CisKK3N0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZHJpdmVyIGJjbTYzeHhfcG93ZXJfZHJpdmVyID0g eworCS5kcml2ZXIgPSB7CisJCS5uYW1lID0gImJjbTYzeHgtcG93ZXItY29udHJvbGxlciIsCisJ CS5vZl9tYXRjaF90YWJsZSA9IGJjbTYzeHhfcG93ZXJfb2ZfbWF0Y2gsCisJfSwKKwkucHJvYmUg ID0gYmNtNjN4eF9wb3dlcl9wcm9iZSwKK307CitidWlsdGluX3BsYXRmb3JtX2RyaXZlcihiY202 M3h4X3Bvd2VyX2RyaXZlcik7Ci0tIAoyLjI2LjIKCgpfX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fXwpsaW51eC1hcm0ta2VybmVsIG1haWxpbmcgbGlzdApsaW51 eC1hcm0ta2VybmVsQGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5v cmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1hcm0ta2VybmVsCg==