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=-8.3 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_SANE_1 autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 6AB77CA9EAF for ; Mon, 21 Oct 2019 10:46:20 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 209C02084C for ; Mon, 21 Oct 2019 10:46:20 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=linaro.org header.i=@linaro.org header.b="X877r9tJ" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727517AbfJUKqT (ORCPT ); Mon, 21 Oct 2019 06:46:19 -0400 Received: from mail-wr1-f68.google.com ([209.85.221.68]:32795 "EHLO mail-wr1-f68.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727993AbfJUKqS (ORCPT ); Mon, 21 Oct 2019 06:46:18 -0400 Received: by mail-wr1-f68.google.com with SMTP id s1so4611822wro.0 for ; Mon, 21 Oct 2019 03:46:14 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=date:from:to:cc:subject:message-id:references:mime-version :content-disposition:content-transfer-encoding:in-reply-to :user-agent; bh=fBo1+HCeMV1YXAlWKCtAuQFnV7KnLzFAUah7I6NP9lI=; b=X877r9tJBpulXjd4ktLhwl3lgE+BHcQFJoX/zaeJGl53XFB7ys0/5SZzeBv1WLz/kk wfmVd7XBAqpm4ZGH71JFH9+eWjn63aTzwdNFON+hT/smzkQYuQDt413QhuAXMrN+mPlC sQswBLFHG4R01NOX9lQVLajWNmksRnLrIFgYteF6bThUh5Kb9nId5tTPoLsHoXd+tQG2 EDL3C8e6jfsSTefzQO9Z5OA20tpWVp1DYILwQT5XZ6eB+4GTRAVN9O1eTkaFr94nK1wU FO1aVckezY76jqQ/2psPnxKBS/V0oIKsLPS5uBxrEeUC5qcXJti4/9cKEkiJI0xbZAuR uWKA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:date:from:to:cc:subject:message-id:references :mime-version:content-disposition:content-transfer-encoding :in-reply-to:user-agent; bh=fBo1+HCeMV1YXAlWKCtAuQFnV7KnLzFAUah7I6NP9lI=; b=T+63xFIg7SpYQF6ekJ1cDubrQKJAn6fuc5hXTavaVFXO7g1NcDWTE0Csj6e+/WLELH KHsHSQRZS6cEI4njDpTKPZH2hnY0a3kVxiFTMndS7CXhJbP9DzqmlrrFtkPreSy+lcKm 8ej7t0eSunroPdy6y0J9ZPGL96VOeSQdLklFvPaokh1LB5TB3VnR9GT/7Ss9CEMfgEXq totYEnphwu+AgKPJuPdzv2RAuTjK+aeC2eQRAjvaxiGyzrPD5nf9jj7GIJgKFR4dA0Dl CdiAjBYAR9z2LSgN1JwKOTLhcq0n8X2KAj7flnDtZSae3gO1DBzMg50Sb67gUUJ6I8GH 5ojw== X-Gm-Message-State: APjAAAUOqrSTC3lrY3NUgGrs5fON282OSi0FrBST1TM5KjoS2CvvGJI8 of+BomStwO/YSZQOcQpWZuwsHA== X-Google-Smtp-Source: APXvYqwHQtEoMhkDuStyIn5FzNV1scIY8dvmt4vwCkW7NxJmrLBCpkLhCF0I5EkhKaCpTKqr/kMH0Q== X-Received: by 2002:adf:db04:: with SMTP id s4mr16868612wri.12.1571654773647; Mon, 21 Oct 2019 03:46:13 -0700 (PDT) Received: from dell ([95.149.164.99]) by smtp.gmail.com with ESMTPSA id s12sm15264345wra.82.2019.10.21.03.46.12 (version=TLS1_2 cipher=ECDHE-RSA-CHACHA20-POLY1305 bits=256/256); Mon, 21 Oct 2019 03:46:13 -0700 (PDT) Date: Mon, 21 Oct 2019 11:46:11 +0100 From: Lee Jones To: Srinivas Kandagatla Cc: robh@kernel.org, broonie@kernel.org, linus.walleij@linaro.org, vinod.koul@linaro.org, alsa-devel@alsa-project.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, spapothi@codeaurora.org, bgoswami@codeaurora.org, linux-gpio@vger.kernel.org Subject: Re: [PATCH v2 02/11] mfd: wcd934x: add support to wcd9340/wcd9341 codec Message-ID: <20191021104611.GZ4365@dell> References: <20191018001849.27205-1-srinivas.kandagatla@linaro.org> <20191018001849.27205-3-srinivas.kandagatla@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <20191018001849.27205-3-srinivas.kandagatla@linaro.org> User-Agent: Mutt/1.9.4 (2018-02-28) Sender: linux-gpio-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-gpio@vger.kernel.org On Fri, 18 Oct 2019, Srinivas Kandagatla wrote: > Qualcomm WCD9340/WCD9341 Codec is a standalone Hi-Fi audio codec IC. > > This codec has integrated SoundWire controller, pin controller and > interrupt controller. > > Signed-off-by: Srinivas Kandagatla > --- > drivers/mfd/Kconfig | 8 + > drivers/mfd/Makefile | 1 + > drivers/mfd/wcd934x.c | 330 ++++++++++++++++ > include/linux/mfd/wcd934x/registers.h | 529 ++++++++++++++++++++++++++ > include/linux/mfd/wcd934x/wcd934x.h | 24 ++ > 5 files changed, 892 insertions(+) > create mode 100644 drivers/mfd/wcd934x.c > create mode 100644 include/linux/mfd/wcd934x/registers.h > create mode 100644 include/linux/mfd/wcd934x/wcd934x.h > > diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig > index ae24d3ea68ea..ab09862b5996 100644 > --- a/drivers/mfd/Kconfig > +++ b/drivers/mfd/Kconfig > @@ -1967,6 +1967,14 @@ config MFD_STMFX > additional drivers must be enabled in order to use the functionality > of the device. > > +config MFD_WCD934X > + tristate "Support for WCD9340/WCD9341 Codec" > + depends on SLIMBUS > + select REGMAP > + select REGMAP_SLIMBUS > + select REGMAP_IRQ > + select MFD_CORE > + No help? > menu "Multimedia Capabilities Port drivers" > depends on ARCH_SA1100 > > diff --git a/drivers/mfd/Makefile b/drivers/mfd/Makefile > index c1067ea46204..8059a9c36188 100644 > --- a/drivers/mfd/Makefile > +++ b/drivers/mfd/Makefile > @@ -58,6 +58,7 @@ endif > ifeq ($(CONFIG_MFD_CS47L24),y) > obj-$(CONFIG_MFD_ARIZONA) += cs47l24-tables.o > endif > +obj-$(CONFIG_MFD_WCD934X) += wcd934x.o > obj-$(CONFIG_MFD_WM8400) += wm8400-core.o > wm831x-objs := wm831x-core.o wm831x-irq.o wm831x-otp.o > wm831x-objs += wm831x-auxadc.o > diff --git a/drivers/mfd/wcd934x.c b/drivers/mfd/wcd934x.c > new file mode 100644 > index 000000000000..bb4d2a6c89bc > --- /dev/null > +++ b/drivers/mfd/wcd934x.c > @@ -0,0 +1,330 @@ > +// SPDX-License-Identifier: GPL-2.0 > +// Copyright (c) 2019, Linaro Limited > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > + > +static const struct mfd_cell wcd934x_devices[] = { > + { /* Audio Codec */ These comments aren't required. The .names are good enough. > + .name = "wcd934x-codec", > + }, { /* Pin controller */ > + .name = "wcd934x-pinctrl", > + .of_compatible = "qcom,wcd9340-pinctrl", > + }, { /* Soundwire Controller */ > + .name = "wcd934x-soundwire", > + .of_compatible = "qcom,soundwire-v1.3.0", > + }, > +}; > + > +static const struct regmap_irq wcd934x_irqs[] = { > + /* INTR_REG 0 */ Again, doesn't really add or explain anything additional. > + [WCD934X_IRQ_SLIMBUS] = { > + .reg_offset = 0, > + .mask = BIT(0), > + .type = { > + .type_reg_offset = 0, > + .types_supported = IRQ_TYPE_EDGE_BOTH, > + .type_reg_mask = BIT(0), > + .type_level_low_val = BIT(0), > + .type_level_high_val = BIT(0), > + .type_falling_val = 0, > + .type_rising_val = 0, > + }, > + }, > + [WCD934X_IRQ_SOUNDWIRE] = { > + .reg_offset = 2, > + .mask = BIT(4), > + .type = { > + .type_reg_offset = 2, > + .types_supported = IRQ_TYPE_EDGE_BOTH, > + .type_reg_mask = BIT(4), > + .type_level_low_val = BIT(4), > + .type_level_high_val = BIT(4), > + .type_falling_val = 0, > + .type_rising_val = 0, > + }, > + }, > +}; > + > +static const struct regmap_irq_chip wcd934x_regmap_irq_chip = { > + .name = "wcd934x_irq", > + .status_base = WCD934X_INTR_PIN1_STATUS0, > + .mask_base = WCD934X_INTR_PIN1_MASK0, > + .ack_base = WCD934X_INTR_PIN1_CLEAR0, > + .type_base = WCD934X_INTR_LEVEL0, > + .num_type_reg = 4, > + .type_in_mask = false, > + .num_regs = 4, > + .irqs = wcd934x_irqs, > + .num_irqs = ARRAY_SIZE(wcd934x_irqs), > +}; > + > +static bool wcd934x_is_volatile_register(struct device *dev, unsigned int reg) > +{ > + switch (reg) { > + case WCD934X_INTR_PIN1_STATUS0...WCD934X_INTR_PIN2_CLEAR3: > + case WCD934X_SWR_AHB_BRIDGE_RD_DATA_0: > + case WCD934X_SWR_AHB_BRIDGE_RD_DATA_1: > + case WCD934X_SWR_AHB_BRIDGE_RD_DATA_2: > + case WCD934X_SWR_AHB_BRIDGE_RD_DATA_3: > + case WCD934X_SWR_AHB_BRIDGE_ACCESS_STATUS: > + case WCD934X_ANA_MBHC_RESULT_3: > + case WCD934X_ANA_MBHC_RESULT_2: > + case WCD934X_ANA_MBHC_RESULT_1: > + case WCD934X_ANA_MBHC_MECH: > + case WCD934X_ANA_MBHC_ELECT: > + case WCD934X_ANA_MBHC_ZDET: > + case WCD934X_ANA_MICB2: > + case WCD934X_ANA_RCO: > + case WCD934X_ANA_BIAS: > + return true; > + default: > + return false; > + } > + > +}; > + > +static const struct regmap_range_cfg wcd934x_ranges[] = { > + { .name = "WCD934X", > + .range_min = 0x0, > + .range_max = WCD934X_MAX_REGISTER, > + .selector_reg = WCD934X_SEL_REGISTER, > + .selector_mask = WCD934X_SEL_MASK, > + .selector_shift = WCD934X_SEL_SHIFT, > + .window_start = WCD934X_WINDOW_START, > + .window_len = WCD934X_WINDOW_LENGTH, > + }, > +}; > + > +static struct regmap_config wcd934x_regmap_config = { > + .reg_bits = 16, > + .val_bits = 8, > + .cache_type = REGCACHE_RBTREE, > + .max_register = 0xffff, > + .can_multi_write = true, > + .ranges = wcd934x_ranges, > + .num_ranges = ARRAY_SIZE(wcd934x_ranges), > + .volatile_reg = wcd934x_is_volatile_register, > +}; > + > +static int wcd934x_parse_resources(struct wcd934x_data *wcd) > +{ > + struct device *dev = wcd->dev; Since most things stem from the device, it's more common to pass that instead. You can then use dev_get_drvdata() to obtain the device data. > + struct device_node *np = dev->of_node; > + int ret; > + > + wcd->irq = of_irq_get(wcd->dev->of_node, 0); > + if (wcd->irq < 0) { > + if (wcd->irq != -EPROBE_DEFER) > + dev_err(wcd->dev, "Failed to get IRQ: err = %d\n", > + wcd->irq); > + return wcd->irq; > + } > + > + wcd->reset_gpio = of_get_named_gpio(np, "reset-gpios", 0); > + if (wcd->reset_gpio < 0) { > + dev_err(dev, "Failed to get reset gpio: err = %d\n", > + wcd->reset_gpio); > + return wcd->reset_gpio; > + } > + > + wcd->extclk = devm_clk_get(dev, "extclk"); > + if (IS_ERR(wcd->extclk)) { > + dev_err(dev, "Failed to get extclk"); > + return PTR_ERR(wcd->extclk); > + } > + > + wcd->supplies[0].supply = "vdd-buck"; > + wcd->supplies[1].supply = "vdd-buck-sido"; > + wcd->supplies[2].supply = "vdd-tx"; > + wcd->supplies[3].supply = "vdd-rx"; > + wcd->supplies[4].supply = "vdd-io"; > + > + ret = regulator_bulk_get(dev, WCD934X_MAX_SUPPLY, wcd->supplies); > + if (ret != 0) { > + dev_err(dev, "Failed to get supplies: err = %d\n", ret); > + return ret; > + } More of a nit-pick really, but I don't see any reason for all of this not to be in probe. > + return 0; > +} > + > +static int wcd934x_power_on_reset(struct wcd934x_data *wcd) > +{ > + int ret; > + > + ret = regulator_bulk_enable(WCD934X_MAX_SUPPLY, wcd->supplies); > + if (ret != 0) { > + dev_err(wcd->dev, "Failed to get supplies: err = %d\n", ret); > + return ret; > + } By doing regulator_bulk_{get,enable}() in separate functions, you put an unnecessary burden on 'struct wcd934x_data'. Unless of course you're using 'supplies' to disable and put as well. Where does that happen? Surely you should do that in .remove()? > + /* > + * For WCD934X, it takes about 600us for the Vout_A and > + * Vout_D to be ready after BUCK_SIDO is powered up. > + * SYS_RST_N shouldn't be pulled high during this time > + */ > + usleep_range(600, 650); > + gpio_direction_output(wcd->reset_gpio, 0); > + msleep(20); > + gpio_set_value(wcd->reset_gpio, 1); > + msleep(20); > + > + return 0; > +} > + > +static int wcd934x_slim_probe(struct slim_device *sdev) I'd expect to find the .probe() closer to the bottom of the file. > +{ > + struct device *dev = &sdev->dev; > + struct wcd934x_data *wcd; This is actually "ddata". It's more common to do: struct wcd934x_ddata *ddata; > + int ret = 0; Why does this need pre-initialisation? > + wcd = devm_kzalloc(dev, sizeof(*wcd), GFP_KERNEL); > + if (!wcd) > + return -ENOMEM; > + > + wcd->dev = dev; '\n' here. > + ret = wcd934x_parse_resources(wcd); > + if (ret) { > + dev_err(dev, "Error parsing DT: err = %d\n", ret); You've already printed an error at this point. No need for another. > + return ret; > + } > + > + ret = wcd934x_power_on_reset(wcd); > + if (ret) { > + dev_err(dev, "Error Power resetting device: err = %d\n", ret); You've already printed an error at this point. No need for another. > + return ret; > + } > + > + wcd->sdev = sdev; > + dev_set_drvdata(dev, wcd); Do this first, then you can use dev_get_drvdata() above. > + return 0; > +} > + > +static int wcd934x_bring_up(struct wcd934x_data *wcd) > +{ > + struct regmap *rm = wcd->regmap; It's much more common to use 'regmap' or 'map'. > + u16 id_minor, id_major; > + int ret; > + > + ret = regmap_bulk_read(rm, WCD934X_CHIP_TIER_CTRL_CHIP_ID_BYTE0, > + (u8 *)&id_minor, sizeof(u16)); > + if (ret) > + return -EINVAL; > + > + ret = regmap_bulk_read(rm, WCD934X_CHIP_TIER_CTRL_CHIP_ID_BYTE2, > + (u8 *)&id_major, sizeof(u16)); > + if (ret) > + return -EINVAL; > + > + dev_info(wcd->dev, "wcd934x chip id major 0x%x, minor 0x%x\n", > + id_major, id_minor); > + > + regmap_write(rm, WCD934X_CODEC_RPM_RST_CTL, 0x01); > + regmap_write(rm, WCD934X_SIDO_NEW_VOUT_A_STARTUP, 0x19); > + regmap_write(rm, WCD934X_SIDO_NEW_VOUT_D_STARTUP, 0x15); > + /* Add 1msec delay for VOUT to settle */ > + usleep_range(1000, 1100); > + regmap_write(rm, WCD934X_CODEC_RPM_PWR_CDC_DIG_HM_CTL, 0x5); > + regmap_write(rm, WCD934X_CODEC_RPM_PWR_CDC_DIG_HM_CTL, 0x7); > + regmap_write(rm, WCD934X_CODEC_RPM_RST_CTL, 0x3); > + regmap_write(rm, WCD934X_CODEC_RPM_RST_CTL, 0x7); > + regmap_write(rm, WCD934X_CODEC_RPM_PWR_CDC_DIG_HM_CTL, 0x3); > + > + return 0; > + Superfluous '\n'. > +} > + > +static int wcd934x_slim_status(struct slim_device *sdev, > + enum slim_device_status status) > +{ > + struct device *dev = &sdev->dev; > + struct wcd934x_data *wcd; > + int ret; This is semantically odd! Why are you doing most of the initialisation and bring-up in 'status' and not 'probe'. Seems broken to me. > + wcd = dev_get_drvdata(dev); > + > + switch (status) { > + case SLIM_DEVICE_STATUS_UP: > + wcd->regmap = regmap_init_slimbus(sdev, &wcd934x_regmap_config); > + if (IS_ERR(wcd->regmap)) { > + dev_err(dev, "Error allocating slim regmap\n"); > + return PTR_ERR(wcd->regmap); > + } > + > + ret = wcd934x_bring_up(wcd); > + if (ret) { > + dev_err(dev, "Error WCD934X bringup: err = %d\n", ret); Please use well formed English. "Failed to bring up WCD934X". > + return ret; > + } > + > + ret = devm_regmap_add_irq_chip(wcd->dev, wcd->regmap, wcd->irq, > + IRQF_TRIGGER_HIGH, 0, > + &wcd934x_regmap_irq_chip, > + &wcd->irq_data); > + if (ret) { > + dev_err(wcd->dev, "Error adding irq_chip: err = %d\n", "Failed to add IRQ chip". > + ret); > + return ret; > + } > + > + ret = mfd_add_devices(wcd->dev, 0, wcd934x_devices, What do you mean by 0 here? > + ARRAY_SIZE(wcd934x_devices), > + NULL, 0, NULL); > + if (ret) { > + dev_err(wcd->dev, "Error add mfd devices: err = %d\n", "Failed to add child devices". > + ret); > + return ret; > + } > + break; > + case SLIM_DEVICE_STATUS_DOWN: > + mfd_remove_devices(wcd->dev); > + break; > + default: > + return -EINVAL; > + } > + > + return 0; > +} > + > +static void wcd934x_slim_remove(struct slim_device *sdev) > +{ > + struct wcd934x_data *wcd = dev_get_drvdata(&sdev->dev); No more clean-up? Aren't the regulators still enabled? > + mfd_remove_devices(&sdev->dev); > + kfree(wcd); > +} > + > +static const struct slim_device_id wcd934x_slim_id[] = { > + {SLIM_MANF_ID_QCOM, SLIM_PROD_CODE_WCD9340, 0x1, 0x0}, ' 's before and after first and last chars please. > + {} > +}; > + > +static struct slim_driver wcd934x_slim_driver = { > + .driver = { > + .name = "wcd934x-slim", > + }, > + .probe = wcd934x_slim_probe, > + .remove = wcd934x_slim_remove, > + .device_status = wcd934x_slim_status, > + .id_table = wcd934x_slim_id, > +}; > + > +module_slim_driver(wcd934x_slim_driver); > +MODULE_DESCRIPTION("WCD934X slim driver"); > +MODULE_LICENSE("GPL v2"); > +MODULE_ALIAS("slim:217:250:*"); MODULE_AUTHOR? [...] > +#endif > diff --git a/include/linux/mfd/wcd934x/wcd934x.h b/include/linux/mfd/wcd934x/wcd934x.h > new file mode 100644 > index 000000000000..d102e211948c > --- /dev/null > +++ b/include/linux/mfd/wcd934x/wcd934x.h > @@ -0,0 +1,24 @@ > +/* SPDX-License-Identifier: GPL-2.0 */ > + > +#ifndef __WCD934X_H__ > +#define __WCD934X_H__ > +#include > +#include > +#include > +#include > + > +#define WCD934X_MAX_SUPPLY 5 Kernel doc? > +struct wcd934x_data { > + int reset_gpio; > + int irq; I'd prefer to see the more complex 'struct's at the top. > + struct device *dev; > + struct clk *extclk; > + struct regmap *regmap; > + struct slim_device *sdev; You don't need 'sdev' and 'dev'. > + struct regmap_irq_chip_data *irq_data; > + struct regulator_bulk_data supplies[WCD934X_MAX_SUPPLY]; > +}; > + > +#endif /* __WCD934X_H__ */ > + -- Lee Jones [李琼斯] Linaro Services Technical Lead Linaro.org │ Open source software for ARM SoCs Follow Linaro: Facebook | Twitter | Blog 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=-8.3 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_HELO_NONE,SPF_PASS,USER_AGENT_SANE_1 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 D9FC2CA9EB0 for ; Mon, 21 Oct 2019 10:47:16 +0000 (UTC) Received: from alsa0.perex.cz (alsa0.perex.cz [77.48.224.243]) (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 5F93520882 for ; Mon, 21 Oct 2019 10:47:16 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=alsa-project.org header.i=@alsa-project.org header.b="pXY8LI9z"; dkim=fail reason="signature verification failed" (2048-bit key) header.d=linaro.org header.i=@linaro.org header.b="X877r9tJ" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 5F93520882 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=linaro.org Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=alsa-devel-bounces@alsa-project.org Received: from alsa1.perex.cz (alsa1.perex.cz [207.180.221.201]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by alsa0.perex.cz (Postfix) with ESMTPS id 8B3D5165E; Mon, 21 Oct 2019 12:46:24 +0200 (CEST) DKIM-Filter: OpenDKIM Filter v2.11.0 alsa0.perex.cz 8B3D5165E DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=alsa-project.org; s=default; t=1571654834; bh=SA112sQ0RgalQtkkNlEe+CD4IZKklpcUyH5HrZfxcyQ=; h=Date:From:To:References:In-Reply-To:Cc:Subject:List-Id: List-Unsubscribe:List-Archive:List-Post:List-Help:List-Subscribe: From; b=pXY8LI9zojtjpSP+GkvlKAKHIwZ/TcOqeECDcI68UYFUH0ItGLu8kN6z6XBfxLAuq xf/eA/FyujAfPD2rcHiruIjBylm4waoJeev9LakRtEVQdrslf3NmA3ic0aDnXx2exm qH7Dwah/xikbjWacjH9YSOfTL8mS/sXTFqCOFAyE= Received: from alsa1.perex.cz (localhost.localdomain [127.0.0.1]) by alsa1.perex.cz (Postfix) with ESMTP id 3B4A2F80368; Mon, 21 Oct 2019 12:46:19 +0200 (CEST) Received: by alsa1.perex.cz (Postfix, from userid 50401) id C0E05F803D7; Mon, 21 Oct 2019 12:46:17 +0200 (CEST) Received: from mail-wr1-x444.google.com (mail-wr1-x444.google.com [IPv6:2a00:1450:4864:20::444]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by alsa1.perex.cz (Postfix) with ESMTPS id DFA35F80112 for ; Mon, 21 Oct 2019 12:46:14 +0200 (CEST) DKIM-Filter: OpenDKIM Filter v2.11.0 alsa1.perex.cz DFA35F80112 Authentication-Results: alsa1.perex.cz; dkim=pass (2048-bit key) header.d=linaro.org header.i=@linaro.org header.b="X877r9tJ" Received: by mail-wr1-x444.google.com with SMTP id c2so8131868wrr.10 for ; Mon, 21 Oct 2019 03:46:14 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=date:from:to:cc:subject:message-id:references:mime-version :content-disposition:content-transfer-encoding:in-reply-to :user-agent; bh=fBo1+HCeMV1YXAlWKCtAuQFnV7KnLzFAUah7I6NP9lI=; b=X877r9tJBpulXjd4ktLhwl3lgE+BHcQFJoX/zaeJGl53XFB7ys0/5SZzeBv1WLz/kk wfmVd7XBAqpm4ZGH71JFH9+eWjn63aTzwdNFON+hT/smzkQYuQDt413QhuAXMrN+mPlC sQswBLFHG4R01NOX9lQVLajWNmksRnLrIFgYteF6bThUh5Kb9nId5tTPoLsHoXd+tQG2 EDL3C8e6jfsSTefzQO9Z5OA20tpWVp1DYILwQT5XZ6eB+4GTRAVN9O1eTkaFr94nK1wU FO1aVckezY76jqQ/2psPnxKBS/V0oIKsLPS5uBxrEeUC5qcXJti4/9cKEkiJI0xbZAuR uWKA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:date:from:to:cc:subject:message-id:references :mime-version:content-disposition:content-transfer-encoding :in-reply-to:user-agent; bh=fBo1+HCeMV1YXAlWKCtAuQFnV7KnLzFAUah7I6NP9lI=; b=Nr12ZvZC8e9O+N6VuN9JGuQxDgJMnpYcyDCc+r9muC+nH9cEFqeRBck+h63O9vpwFd eP0uStpdr5CwORRpDC8AT74IzD71TB+uTX7b6fg6AHgC9YIvPVCfUc32zzEnUXnZqEmm nTS2dI4wPjsFaQ0WGS3EsTrKsAQQtUFpx6/MbuS29Jg8O9alJzDNg23+erNqZED1lZ/E eFcgMmM14IKYFl5Qb7Vbj9f3i6Y0cgap1q05p2OMYi1yZ0lcAtjxjY93qu9ElmaDTNra KkIXiA4oV5nB1EtH6oTbef4LLOJTKIcj12EbhrxOSEWR5fBnMAp9gCoZFqRSih9vyZok 1pNw== X-Gm-Message-State: APjAAAWJk9YShhiAWK2DZ5I1nPWzk1Ls1rGYchEje6IMsXxGcXTOtR8m P+kcT2TGNdAivs2Hxx2BchAxFA== X-Google-Smtp-Source: APXvYqwHQtEoMhkDuStyIn5FzNV1scIY8dvmt4vwCkW7NxJmrLBCpkLhCF0I5EkhKaCpTKqr/kMH0Q== X-Received: by 2002:adf:db04:: with SMTP id s4mr16868612wri.12.1571654773647; Mon, 21 Oct 2019 03:46:13 -0700 (PDT) Received: from dell ([95.149.164.99]) by smtp.gmail.com with ESMTPSA id s12sm15264345wra.82.2019.10.21.03.46.12 (version=TLS1_2 cipher=ECDHE-RSA-CHACHA20-POLY1305 bits=256/256); Mon, 21 Oct 2019 03:46:13 -0700 (PDT) Date: Mon, 21 Oct 2019 11:46:11 +0100 From: Lee Jones To: Srinivas Kandagatla Message-ID: <20191021104611.GZ4365@dell> References: <20191018001849.27205-1-srinivas.kandagatla@linaro.org> <20191018001849.27205-3-srinivas.kandagatla@linaro.org> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: <20191018001849.27205-3-srinivas.kandagatla@linaro.org> User-Agent: Mutt/1.9.4 (2018-02-28) Cc: robh@kernel.org, alsa-devel@alsa-project.org, bgoswami@codeaurora.org, vinod.koul@linaro.org, devicetree@vger.kernel.org, linus.walleij@linaro.org, linux-kernel@vger.kernel.org, linux-gpio@vger.kernel.org, broonie@kernel.org, spapothi@codeaurora.org Subject: Re: [alsa-devel] [PATCH v2 02/11] mfd: wcd934x: add support to wcd9340/wcd9341 codec X-BeenThere: alsa-devel@alsa-project.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: "Alsa-devel mailing list for ALSA developers - http://www.alsa-project.org" List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: alsa-devel-bounces@alsa-project.org Sender: "Alsa-devel" T24gRnJpLCAxOCBPY3QgMjAxOSwgU3Jpbml2YXMgS2FuZGFnYXRsYSB3cm90ZToKCj4gUXVhbGNv bW0gV0NEOTM0MC9XQ0Q5MzQxIENvZGVjIGlzIGEgc3RhbmRhbG9uZSBIaS1GaSBhdWRpbyBjb2Rl YyBJQy4KPiAKPiBUaGlzIGNvZGVjIGhhcyBpbnRlZ3JhdGVkIFNvdW5kV2lyZSBjb250cm9sbGVy LCBwaW4gY29udHJvbGxlciBhbmQKPiBpbnRlcnJ1cHQgY29udHJvbGxlci4KPiAKPiBTaWduZWQt b2ZmLWJ5OiBTcmluaXZhcyBLYW5kYWdhdGxhIDxzcmluaXZhcy5rYW5kYWdhdGxhQGxpbmFyby5v cmc+Cj4gLS0tCj4gIGRyaXZlcnMvbWZkL0tjb25maWcgICAgICAgICAgICAgICAgICAgfCAgIDgg Kwo+ICBkcml2ZXJzL21mZC9NYWtlZmlsZSAgICAgICAgICAgICAgICAgIHwgICAxICsKPiAgZHJp dmVycy9tZmQvd2NkOTM0eC5jICAgICAgICAgICAgICAgICB8IDMzMCArKysrKysrKysrKysrKysr Cj4gIGluY2x1ZGUvbGludXgvbWZkL3djZDkzNHgvcmVnaXN0ZXJzLmggfCA1MjkgKysrKysrKysr KysrKysrKysrKysrKysrKysKPiAgaW5jbHVkZS9saW51eC9tZmQvd2NkOTM0eC93Y2Q5MzR4Lmgg ICB8ICAyNCArKwo+ICA1IGZpbGVzIGNoYW5nZWQsIDg5MiBpbnNlcnRpb25zKCspCj4gIGNyZWF0 ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL21mZC93Y2Q5MzR4LmMKPiAgY3JlYXRlIG1vZGUgMTAwNjQ0 IGluY2x1ZGUvbGludXgvbWZkL3djZDkzNHgvcmVnaXN0ZXJzLmgKPiAgY3JlYXRlIG1vZGUgMTAw NjQ0IGluY2x1ZGUvbGludXgvbWZkL3djZDkzNHgvd2NkOTM0eC5oCj4gCj4gZGlmZiAtLWdpdCBh L2RyaXZlcnMvbWZkL0tjb25maWcgYi9kcml2ZXJzL21mZC9LY29uZmlnCj4gaW5kZXggYWUyNGQz ZWE2OGVhLi5hYjA5ODYyYjU5OTYgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9tZmQvS2NvbmZpZwo+ ICsrKyBiL2RyaXZlcnMvbWZkL0tjb25maWcKPiBAQCAtMTk2Nyw2ICsxOTY3LDE0IEBAIGNvbmZp ZyBNRkRfU1RNRlgKPiAgCSAgYWRkaXRpb25hbCBkcml2ZXJzIG11c3QgYmUgZW5hYmxlZCBpbiBv cmRlciB0byB1c2UgdGhlIGZ1bmN0aW9uYWxpdHkKPiAgCSAgb2YgdGhlIGRldmljZS4KPiAgCj4g K2NvbmZpZyBNRkRfV0NEOTM0WAo+ICsJdHJpc3RhdGUgIlN1cHBvcnQgZm9yIFdDRDkzNDAvV0NE OTM0MSBDb2RlYyIKPiArCWRlcGVuZHMgb24gU0xJTUJVUwo+ICsJc2VsZWN0IFJFR01BUAo+ICsJ c2VsZWN0IFJFR01BUF9TTElNQlVTCj4gKwlzZWxlY3QgUkVHTUFQX0lSUQo+ICsJc2VsZWN0IE1G RF9DT1JFCj4gKwoKTm8gaGVscD8KCj4gIG1lbnUgIk11bHRpbWVkaWEgQ2FwYWJpbGl0aWVzIFBv cnQgZHJpdmVycyIKPiAgCWRlcGVuZHMgb24gQVJDSF9TQTExMDAKPiAgCj4gZGlmZiAtLWdpdCBh L2RyaXZlcnMvbWZkL01ha2VmaWxlIGIvZHJpdmVycy9tZmQvTWFrZWZpbGUKPiBpbmRleCBjMTA2 N2VhNDYyMDQuLjgwNTlhOWMzNjE4OCAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL21mZC9NYWtlZmls ZQo+ICsrKyBiL2RyaXZlcnMvbWZkL01ha2VmaWxlCj4gQEAgLTU4LDYgKzU4LDcgQEAgZW5kaWYK PiAgaWZlcSAoJChDT05GSUdfTUZEX0NTNDdMMjQpLHkpCj4gIG9iai0kKENPTkZJR19NRkRfQVJJ Wk9OQSkJKz0gY3M0N2wyNC10YWJsZXMubwo+ICBlbmRpZgo+ICtvYmotJChDT05GSUdfTUZEX1dD RDkzNFgpCSs9IHdjZDkzNHgubwo+ICBvYmotJChDT05GSUdfTUZEX1dNODQwMCkJKz0gd204NDAw LWNvcmUubwo+ICB3bTgzMXgtb2JqcwkJCTo9IHdtODMxeC1jb3JlLm8gd204MzF4LWlycS5vIHdt ODMxeC1vdHAubwo+ICB3bTgzMXgtb2JqcwkJCSs9IHdtODMxeC1hdXhhZGMubwo+IGRpZmYgLS1n aXQgYS9kcml2ZXJzL21mZC93Y2Q5MzR4LmMgYi9kcml2ZXJzL21mZC93Y2Q5MzR4LmMKPiBuZXcg ZmlsZSBtb2RlIDEwMDY0NAo+IGluZGV4IDAwMDAwMDAwMDAwMC4uYmI0ZDJhNmM4OWJjCj4gLS0t IC9kZXYvbnVsbAo+ICsrKyBiL2RyaXZlcnMvbWZkL3djZDkzNHguYwo+IEBAIC0wLDAgKzEsMzMw IEBACj4gKy8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wCj4gKy8vIENvcHlyaWdo dCAoYykgMjAxOSwgTGluYXJvIExpbWl0ZWQKPiArCj4gKyNpbmNsdWRlIDxsaW51eC9jbGsuaD4K PiArI2luY2x1ZGUgPGxpbnV4L2dwaW8uaD4KPiArI2luY2x1ZGUgPGxpbnV4L2ludGVycnVwdC5o Pgo+ICsjaW5jbHVkZSA8bGludXgva2VybmVsLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9tZmQvY29y ZS5oPgo+ICsjaW5jbHVkZSA8bGludXgvbWZkL3djZDkzNHgvcmVnaXN0ZXJzLmg+Cj4gKyNpbmNs dWRlIDxsaW51eC9tZmQvd2NkOTM0eC93Y2Q5MzR4Lmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9tb2R1 bGUuaD4KPiArI2luY2x1ZGUgPGxpbnV4L29mX2dwaW8uaD4KPiArI2luY2x1ZGUgPGxpbnV4L29m Lmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9vZl9pcnEuaD4KPiArI2luY2x1ZGUgPGxpbnV4L3BsYXRm b3JtX2RldmljZS5oPgo+ICsjaW5jbHVkZSA8bGludXgvcmVnbWFwLmg+Cj4gKyNpbmNsdWRlIDxs aW51eC9yZWd1bGF0b3IvY29uc3VtZXIuaD4KPiArI2luY2x1ZGUgPGxpbnV4L3NsaW1idXMuaD4K PiArCj4gK3N0YXRpYyBjb25zdCBzdHJ1Y3QgbWZkX2NlbGwgd2NkOTM0eF9kZXZpY2VzW10gPSB7 Cj4gKwl7IC8qIEF1ZGlvIENvZGVjICovCgpUaGVzZSBjb21tZW50cyBhcmVuJ3QgcmVxdWlyZWQu ICBUaGUgLm5hbWVzIGFyZSBnb29kIGVub3VnaC4KCj4gKwkJLm5hbWUgPSAid2NkOTM0eC1jb2Rl YyIsCj4gKwl9LCB7IC8qIFBpbiBjb250cm9sbGVyICovCj4gKwkJLm5hbWUgPSAid2NkOTM0eC1w aW5jdHJsIiwKPiArCQkub2ZfY29tcGF0aWJsZSA9ICJxY29tLHdjZDkzNDAtcGluY3RybCIsCj4g Kwl9LCB7IC8qIFNvdW5kd2lyZSBDb250cm9sbGVyICovCj4gKwkJLm5hbWUgPSAid2NkOTM0eC1z b3VuZHdpcmUiLAo+ICsJCS5vZl9jb21wYXRpYmxlID0gInFjb20sc291bmR3aXJlLXYxLjMuMCIs Cj4gKwl9LAo+ICt9Owo+ICsKPiArc3RhdGljIGNvbnN0IHN0cnVjdCByZWdtYXBfaXJxIHdjZDkz NHhfaXJxc1tdID0gewo+ICsJLyogSU5UUl9SRUcgMCAqLwoKQWdhaW4sIGRvZXNuJ3QgcmVhbGx5 IGFkZCBvciBleHBsYWluIGFueXRoaW5nIGFkZGl0aW9uYWwuCgo+ICsJW1dDRDkzNFhfSVJRX1NM SU1CVVNdID0gewo+ICsJCS5yZWdfb2Zmc2V0ID0gMCwKPiArCQkubWFzayA9IEJJVCgwKSwKPiAr CQkudHlwZSA9IHsKPiArCQkJLnR5cGVfcmVnX29mZnNldCA9IDAsCj4gKwkJCS50eXBlc19zdXBw b3J0ZWQgPSBJUlFfVFlQRV9FREdFX0JPVEgsCj4gKwkJCS50eXBlX3JlZ19tYXNrICA9IEJJVCgw KSwKPiArCQkJLnR5cGVfbGV2ZWxfbG93X3ZhbCA9IEJJVCgwKSwKPiArCQkJLnR5cGVfbGV2ZWxf aGlnaF92YWwgPSBCSVQoMCksCj4gKwkJCS50eXBlX2ZhbGxpbmdfdmFsID0gMCwKPiArCQkJLnR5 cGVfcmlzaW5nX3ZhbCA9IDAsCj4gKwkJfSwKPiArCX0sCj4gKwlbV0NEOTM0WF9JUlFfU09VTkRX SVJFXSA9IHsKPiArCQkucmVnX29mZnNldCA9IDIsCj4gKwkJLm1hc2sgPSBCSVQoNCksCj4gKwkJ LnR5cGUgPSB7Cj4gKwkJCS50eXBlX3JlZ19vZmZzZXQgPSAyLAo+ICsJCQkudHlwZXNfc3VwcG9y dGVkID0gSVJRX1RZUEVfRURHRV9CT1RILAo+ICsJCQkudHlwZV9yZWdfbWFzayAgPSBCSVQoNCks Cj4gKwkJCS50eXBlX2xldmVsX2xvd192YWwgPSBCSVQoNCksCj4gKwkJCS50eXBlX2xldmVsX2hp Z2hfdmFsID0gQklUKDQpLAo+ICsJCQkudHlwZV9mYWxsaW5nX3ZhbCA9IDAsCj4gKwkJCS50eXBl X3Jpc2luZ192YWwgPSAwLAo+ICsJCX0sCj4gKwl9LAo+ICt9Owo+ICsKPiArc3RhdGljIGNvbnN0 IHN0cnVjdCByZWdtYXBfaXJxX2NoaXAgd2NkOTM0eF9yZWdtYXBfaXJxX2NoaXAgPSB7Cj4gKwku bmFtZSA9ICJ3Y2Q5MzR4X2lycSIsCj4gKwkuc3RhdHVzX2Jhc2UgPSBXQ0Q5MzRYX0lOVFJfUElO MV9TVEFUVVMwLAo+ICsJLm1hc2tfYmFzZSA9IFdDRDkzNFhfSU5UUl9QSU4xX01BU0swLAo+ICsJ LmFja19iYXNlID0gV0NEOTM0WF9JTlRSX1BJTjFfQ0xFQVIwLAo+ICsJLnR5cGVfYmFzZSA9IFdD RDkzNFhfSU5UUl9MRVZFTDAsCj4gKwkubnVtX3R5cGVfcmVnID0gNCwKPiArCS50eXBlX2luX21h c2sgPSBmYWxzZSwKPiArCS5udW1fcmVncyA9IDQsCj4gKwkuaXJxcyA9IHdjZDkzNHhfaXJxcywK PiArCS5udW1faXJxcyA9IEFSUkFZX1NJWkUod2NkOTM0eF9pcnFzKSwKPiArfTsKPiArCj4gK3N0 YXRpYyBib29sIHdjZDkzNHhfaXNfdm9sYXRpbGVfcmVnaXN0ZXIoc3RydWN0IGRldmljZSAqZGV2 LCB1bnNpZ25lZCBpbnQgcmVnKQo+ICt7Cj4gKwlzd2l0Y2ggKHJlZykgewo+ICsJY2FzZSBXQ0Q5 MzRYX0lOVFJfUElOMV9TVEFUVVMwLi4uV0NEOTM0WF9JTlRSX1BJTjJfQ0xFQVIzOgo+ICsJY2Fz ZSBXQ0Q5MzRYX1NXUl9BSEJfQlJJREdFX1JEX0RBVEFfMDoKPiArCWNhc2UgV0NEOTM0WF9TV1Jf QUhCX0JSSURHRV9SRF9EQVRBXzE6Cj4gKwljYXNlIFdDRDkzNFhfU1dSX0FIQl9CUklER0VfUkRf REFUQV8yOgo+ICsJY2FzZSBXQ0Q5MzRYX1NXUl9BSEJfQlJJREdFX1JEX0RBVEFfMzoKPiArCWNh c2UgV0NEOTM0WF9TV1JfQUhCX0JSSURHRV9BQ0NFU1NfU1RBVFVTOgo+ICsJY2FzZSBXQ0Q5MzRY X0FOQV9NQkhDX1JFU1VMVF8zOgo+ICsJY2FzZSBXQ0Q5MzRYX0FOQV9NQkhDX1JFU1VMVF8yOgo+ ICsJY2FzZSBXQ0Q5MzRYX0FOQV9NQkhDX1JFU1VMVF8xOgo+ICsJY2FzZSBXQ0Q5MzRYX0FOQV9N QkhDX01FQ0g6Cj4gKwljYXNlIFdDRDkzNFhfQU5BX01CSENfRUxFQ1Q6Cj4gKwljYXNlIFdDRDkz NFhfQU5BX01CSENfWkRFVDoKPiArCWNhc2UgV0NEOTM0WF9BTkFfTUlDQjI6Cj4gKwljYXNlIFdD RDkzNFhfQU5BX1JDTzoKPiArCWNhc2UgV0NEOTM0WF9BTkFfQklBUzoKPiArCQlyZXR1cm4gdHJ1 ZTsKPiArCWRlZmF1bHQ6Cj4gKwkJcmV0dXJuIGZhbHNlOwo+ICsJfQo+ICsKPiArfTsKPiArCj4g K3N0YXRpYyBjb25zdCBzdHJ1Y3QgcmVnbWFwX3JhbmdlX2NmZyB3Y2Q5MzR4X3Jhbmdlc1tdID0g ewo+ICsJewkubmFtZSA9ICJXQ0Q5MzRYIiwKPiArCQkucmFuZ2VfbWluID0gIDB4MCwKPiArCQku cmFuZ2VfbWF4ID0gIFdDRDkzNFhfTUFYX1JFR0lTVEVSLAo+ICsJCS5zZWxlY3Rvcl9yZWcgPSBX Q0Q5MzRYX1NFTF9SRUdJU1RFUiwKPiArCQkuc2VsZWN0b3JfbWFzayA9IFdDRDkzNFhfU0VMX01B U0ssCj4gKwkJLnNlbGVjdG9yX3NoaWZ0ID0gV0NEOTM0WF9TRUxfU0hJRlQsCj4gKwkJLndpbmRv d19zdGFydCA9IFdDRDkzNFhfV0lORE9XX1NUQVJULAo+ICsJCS53aW5kb3dfbGVuID0gV0NEOTM0 WF9XSU5ET1dfTEVOR1RILAo+ICsJfSwKPiArfTsKPiArCj4gK3N0YXRpYyBzdHJ1Y3QgcmVnbWFw X2NvbmZpZyB3Y2Q5MzR4X3JlZ21hcF9jb25maWcgPSB7Cj4gKwkucmVnX2JpdHMgPSAxNiwKPiAr CS52YWxfYml0cyA9IDgsCj4gKwkuY2FjaGVfdHlwZSA9IFJFR0NBQ0hFX1JCVFJFRSwKPiArCS5t YXhfcmVnaXN0ZXIgPSAweGZmZmYsCj4gKwkuY2FuX211bHRpX3dyaXRlID0gdHJ1ZSwKPiArCS5y YW5nZXMgPSB3Y2Q5MzR4X3JhbmdlcywKPiArCS5udW1fcmFuZ2VzID0gQVJSQVlfU0laRSh3Y2Q5 MzR4X3JhbmdlcyksCj4gKwkudm9sYXRpbGVfcmVnID0gd2NkOTM0eF9pc192b2xhdGlsZV9yZWdp c3RlciwKPiArfTsKPiArCj4gK3N0YXRpYyBpbnQgd2NkOTM0eF9wYXJzZV9yZXNvdXJjZXMoc3Ry dWN0IHdjZDkzNHhfZGF0YSAqd2NkKQo+ICt7Cj4gKwlzdHJ1Y3QgZGV2aWNlICpkZXYgPSB3Y2Qt PmRldjsKClNpbmNlIG1vc3QgdGhpbmdzIHN0ZW0gZnJvbSB0aGUgZGV2aWNlLCBpdCdzIG1vcmUg Y29tbW9uIHRvIHBhc3MgdGhhdAppbnN0ZWFkLiAgWW91IGNhbiB0aGVuIHVzZSBkZXZfZ2V0X2Ry dmRhdGEoKSB0byBvYnRhaW4gdGhlIGRldmljZQpkYXRhLgoKPiArCXN0cnVjdCBkZXZpY2Vfbm9k ZSAqbnAgPSBkZXYtPm9mX25vZGU7Cj4gKwlpbnQgcmV0Owo+ICsKPiArCXdjZC0+aXJxID0gb2Zf aXJxX2dldCh3Y2QtPmRldi0+b2Zfbm9kZSwgMCk7Cj4gKwlpZiAod2NkLT5pcnEgPCAwKSB7Cj4g KwkJaWYgKHdjZC0+aXJxICE9IC1FUFJPQkVfREVGRVIpCj4gKwkJCWRldl9lcnIod2NkLT5kZXYs ICJGYWlsZWQgdG8gZ2V0IElSUTogZXJyID0gJWRcbiIsCj4gKwkJCQl3Y2QtPmlycSk7Cj4gKwkJ cmV0dXJuIHdjZC0+aXJxOwo+ICsJfQo+ICsKPiArCXdjZC0+cmVzZXRfZ3BpbyA9IG9mX2dldF9u YW1lZF9ncGlvKG5wLAkicmVzZXQtZ3Bpb3MiLCAwKTsKPiArCWlmICh3Y2QtPnJlc2V0X2dwaW8g PCAwKSB7Cj4gKwkJZGV2X2VycihkZXYsICJGYWlsZWQgdG8gZ2V0IHJlc2V0IGdwaW86IGVyciA9 ICVkXG4iLAo+ICsJCQl3Y2QtPnJlc2V0X2dwaW8pOwo+ICsJCXJldHVybiB3Y2QtPnJlc2V0X2dw aW87Cj4gKwl9Cj4gKwo+ICsJd2NkLT5leHRjbGsgPSBkZXZtX2Nsa19nZXQoZGV2LCAiZXh0Y2xr Iik7Cj4gKwlpZiAoSVNfRVJSKHdjZC0+ZXh0Y2xrKSkgewo+ICsJCWRldl9lcnIoZGV2LCAiRmFp bGVkIHRvIGdldCBleHRjbGsiKTsKPiArCQlyZXR1cm4gUFRSX0VSUih3Y2QtPmV4dGNsayk7Cj4g Kwl9Cj4gKwo+ICsJd2NkLT5zdXBwbGllc1swXS5zdXBwbHkgPSAidmRkLWJ1Y2siOwo+ICsJd2Nk LT5zdXBwbGllc1sxXS5zdXBwbHkgPSAidmRkLWJ1Y2stc2lkbyI7Cj4gKwl3Y2QtPnN1cHBsaWVz WzJdLnN1cHBseSA9ICJ2ZGQtdHgiOwo+ICsJd2NkLT5zdXBwbGllc1szXS5zdXBwbHkgPSAidmRk LXJ4IjsKPiArCXdjZC0+c3VwcGxpZXNbNF0uc3VwcGx5ID0gInZkZC1pbyI7Cj4gKwo+ICsJcmV0 ID0gcmVndWxhdG9yX2J1bGtfZ2V0KGRldiwgV0NEOTM0WF9NQVhfU1VQUExZLCB3Y2QtPnN1cHBs aWVzKTsKPiArCWlmIChyZXQgIT0gMCkgewo+ICsJCWRldl9lcnIoZGV2LCAiRmFpbGVkIHRvIGdl dCBzdXBwbGllczogZXJyID0gJWRcbiIsIHJldCk7Cj4gKwkJcmV0dXJuIHJldDsKPiArCX0KCk1v cmUgb2YgYSBuaXQtcGljayByZWFsbHksIGJ1dCBJIGRvbid0IHNlZSBhbnkgcmVhc29uIGZvciBh bGwgb2YgdGhpcwpub3QgdG8gYmUgaW4gcHJvYmUuCgo+ICsJcmV0dXJuIDA7Cj4gK30KPiArCj4g K3N0YXRpYyBpbnQgd2NkOTM0eF9wb3dlcl9vbl9yZXNldChzdHJ1Y3Qgd2NkOTM0eF9kYXRhICp3 Y2QpCj4gK3sKPiArCWludCByZXQ7Cj4gKwo+ICsJcmV0ID0gcmVndWxhdG9yX2J1bGtfZW5hYmxl KFdDRDkzNFhfTUFYX1NVUFBMWSwgd2NkLT5zdXBwbGllcyk7Cj4gKwlpZiAocmV0ICE9IDApIHsK PiArCQlkZXZfZXJyKHdjZC0+ZGV2LCAiRmFpbGVkIHRvIGdldCBzdXBwbGllczogZXJyID0gJWRc biIsIHJldCk7Cj4gKwkJcmV0dXJuIHJldDsKPiArCX0KCkJ5IGRvaW5nIHJlZ3VsYXRvcl9idWxr X3tnZXQsZW5hYmxlfSgpIGluIHNlcGFyYXRlIGZ1bmN0aW9ucywgeW91IHB1dAphbiB1bm5lY2Vz c2FyeSBidXJkZW4gb24gJ3N0cnVjdCB3Y2Q5MzR4X2RhdGEnLiAgVW5sZXNzIG9mIGNvdXJzZQp5 b3UncmUgdXNpbmcgJ3N1cHBsaWVzJyB0byBkaXNhYmxlIGFuZCBwdXQgYXMgd2VsbC4gIFdoZXJl IGRvZXMgdGhhdApoYXBwZW4/ICBTdXJlbHkgeW91IHNob3VsZCBkbyB0aGF0IGluIC5yZW1vdmUo KT8KCj4gKwkvKgo+ICsJICogRm9yIFdDRDkzNFgsIGl0IHRha2VzIGFib3V0IDYwMHVzIGZvciB0 aGUgVm91dF9BIGFuZAo+ICsJICogVm91dF9EIHRvIGJlIHJlYWR5IGFmdGVyIEJVQ0tfU0lETyBp cyBwb3dlcmVkIHVwLgo+ICsJICogU1lTX1JTVF9OIHNob3VsZG4ndCBiZSBwdWxsZWQgaGlnaCBk dXJpbmcgdGhpcyB0aW1lCj4gKwkgKi8KPiArCXVzbGVlcF9yYW5nZSg2MDAsIDY1MCk7Cj4gKwln cGlvX2RpcmVjdGlvbl9vdXRwdXQod2NkLT5yZXNldF9ncGlvLCAwKTsKPiArCW1zbGVlcCgyMCk7 Cj4gKwlncGlvX3NldF92YWx1ZSh3Y2QtPnJlc2V0X2dwaW8sIDEpOwo+ICsJbXNsZWVwKDIwKTsK PiArCj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiArc3RhdGljIGludCB3Y2Q5MzR4X3NsaW1fcHJv YmUoc3RydWN0IHNsaW1fZGV2aWNlICpzZGV2KQoKSSdkIGV4cGVjdCB0byBmaW5kIHRoZSAucHJv YmUoKSBjbG9zZXIgdG8gdGhlIGJvdHRvbSBvZiB0aGUgZmlsZS4KCj4gK3sKPiArCXN0cnVjdCBk ZXZpY2UgKmRldiA9ICZzZGV2LT5kZXY7Cj4gKwlzdHJ1Y3Qgd2NkOTM0eF9kYXRhICp3Y2Q7CgpU aGlzIGlzIGFjdHVhbGx5ICJkZGF0YSIuICBJdCdzIG1vcmUgY29tbW9uIHRvIGRvOgoKICAgICAg IHN0cnVjdCB3Y2Q5MzR4X2RkYXRhICpkZGF0YTsKCj4gKwlpbnQgcmV0ID0gMDsKCldoeSBkb2Vz IHRoaXMgbmVlZCBwcmUtaW5pdGlhbGlzYXRpb24/Cgo+ICsJd2NkID0gZGV2bV9remFsbG9jKGRl diwgc2l6ZW9mKCp3Y2QpLCBHRlBfS0VSTkVMKTsKPiArCWlmICghd2NkKQo+ICsJCXJldHVybgkt RU5PTUVNOwo+ICsKPiArCXdjZC0+ZGV2ID0gZGV2OwoKJ1xuJyBoZXJlLgoKPiArCXJldCA9IHdj ZDkzNHhfcGFyc2VfcmVzb3VyY2VzKHdjZCk7Cj4gKwlpZiAocmV0KSB7Cj4gKwkJZGV2X2Vycihk ZXYsICJFcnJvciBwYXJzaW5nIERUOiBlcnIgPSAlZFxuIiwgcmV0KTsKCllvdSd2ZSBhbHJlYWR5 IHByaW50ZWQgYW4gZXJyb3IgYXQgdGhpcyBwb2ludC4gIE5vIG5lZWQgZm9yIGFub3RoZXIuCgo+ ICsJCXJldHVybiByZXQ7Cj4gKwl9Cj4gKwo+ICsJcmV0ID0gd2NkOTM0eF9wb3dlcl9vbl9yZXNl dCh3Y2QpOwo+ICsJaWYgKHJldCkgewo+ICsJCWRldl9lcnIoZGV2LCAiRXJyb3IgUG93ZXIgcmVz ZXR0aW5nIGRldmljZTogZXJyID0gJWRcbiIsIHJldCk7CgpZb3UndmUgYWxyZWFkeSBwcmludGVk IGFuIGVycm9yIGF0IHRoaXMgcG9pbnQuICBObyBuZWVkIGZvciBhbm90aGVyLgoKPiArCQlyZXR1 cm4gcmV0Owo+ICsJfQo+ICsKPiArCXdjZC0+c2RldiA9IHNkZXY7Cj4gKwlkZXZfc2V0X2RydmRh dGEoZGV2LCB3Y2QpOwoKRG8gdGhpcyBmaXJzdCwgdGhlbiB5b3UgY2FuIHVzZSBkZXZfZ2V0X2Ry dmRhdGEoKSBhYm92ZS4KCj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiArc3RhdGljIGludCB3Y2Q5 MzR4X2JyaW5nX3VwKHN0cnVjdCB3Y2Q5MzR4X2RhdGEgKndjZCkKPiArewo+ICsJc3RydWN0IHJl Z21hcCAqcm0gPSB3Y2QtPnJlZ21hcDsKCkl0J3MgbXVjaCBtb3JlIGNvbW1vbiB0byB1c2UgJ3Jl Z21hcCcgb3IgJ21hcCcuCgo+ICsJdTE2IGlkX21pbm9yLCBpZF9tYWpvcjsKPiArCWludCByZXQ7 Cj4gKwo+ICsJcmV0ID0gcmVnbWFwX2J1bGtfcmVhZChybSwgV0NEOTM0WF9DSElQX1RJRVJfQ1RS TF9DSElQX0lEX0JZVEUwLAo+ICsJCQkgICAgICAgKHU4ICopJmlkX21pbm9yLCBzaXplb2YodTE2 KSk7Cj4gKwlpZiAocmV0KQo+ICsJCXJldHVybiAtRUlOVkFMOwo+ICsKPiArCXJldCA9IHJlZ21h cF9idWxrX3JlYWQocm0sIFdDRDkzNFhfQ0hJUF9USUVSX0NUUkxfQ0hJUF9JRF9CWVRFMiwKPiAr CQkJICAgICAgICh1OCAqKSZpZF9tYWpvciwgc2l6ZW9mKHUxNikpOwo+ICsJaWYgKHJldCkKPiAr CQlyZXR1cm4gLUVJTlZBTDsKPiArCj4gKwlkZXZfaW5mbyh3Y2QtPmRldiwgIndjZDkzNHggY2hp cCBpZCBtYWpvciAweCV4LCBtaW5vciAweCV4XG4iLAo+ICsJCSBpZF9tYWpvciwgaWRfbWlub3Ip Owo+ICsKPiArCXJlZ21hcF93cml0ZShybSwgV0NEOTM0WF9DT0RFQ19SUE1fUlNUX0NUTCwgMHgw MSk7Cj4gKwlyZWdtYXBfd3JpdGUocm0sIFdDRDkzNFhfU0lET19ORVdfVk9VVF9BX1NUQVJUVVAs IDB4MTkpOwo+ICsJcmVnbWFwX3dyaXRlKHJtLCBXQ0Q5MzRYX1NJRE9fTkVXX1ZPVVRfRF9TVEFS VFVQLCAweDE1KTsKPiArCS8qIEFkZCAxbXNlYyBkZWxheSBmb3IgVk9VVCB0byBzZXR0bGUgKi8K PiArCXVzbGVlcF9yYW5nZSgxMDAwLCAxMTAwKTsKPiArCXJlZ21hcF93cml0ZShybSwgV0NEOTM0 WF9DT0RFQ19SUE1fUFdSX0NEQ19ESUdfSE1fQ1RMLCAweDUpOwo+ICsJcmVnbWFwX3dyaXRlKHJt LCBXQ0Q5MzRYX0NPREVDX1JQTV9QV1JfQ0RDX0RJR19ITV9DVEwsIDB4Nyk7Cj4gKwlyZWdtYXBf d3JpdGUocm0sIFdDRDkzNFhfQ09ERUNfUlBNX1JTVF9DVEwsIDB4Myk7Cj4gKwlyZWdtYXBfd3Jp dGUocm0sIFdDRDkzNFhfQ09ERUNfUlBNX1JTVF9DVEwsIDB4Nyk7Cj4gKwlyZWdtYXBfd3JpdGUo cm0sIFdDRDkzNFhfQ09ERUNfUlBNX1BXUl9DRENfRElHX0hNX0NUTCwgMHgzKTsKPiArCj4gKwly ZXR1cm4gMDsKPiArCgpTdXBlcmZsdW91cyAnXG4nLgoKPiArfQo+ICsKPiArc3RhdGljIGludCB3 Y2Q5MzR4X3NsaW1fc3RhdHVzKHN0cnVjdCBzbGltX2RldmljZSAqc2RldiwKPiArCQkJICAgICAg IGVudW0gc2xpbV9kZXZpY2Vfc3RhdHVzIHN0YXR1cykKPiArewo+ICsJc3RydWN0IGRldmljZSAq ZGV2ID0gJnNkZXYtPmRldjsKPiArCXN0cnVjdCB3Y2Q5MzR4X2RhdGEgKndjZDsKPiArCWludCBy ZXQ7CgpUaGlzIGlzIHNlbWFudGljYWxseSBvZGQhICBXaHkgYXJlIHlvdSBkb2luZyBtb3N0IG9m IHRoZQppbml0aWFsaXNhdGlvbiBhbmQgYnJpbmctdXAgaW4gJ3N0YXR1cycgYW5kIG5vdCAncHJv YmUnLiAgU2VlbXMKYnJva2VuIHRvIG1lLgoKPiArCXdjZCA9IGRldl9nZXRfZHJ2ZGF0YShkZXYp Owo+ICsKPiArCXN3aXRjaCAoc3RhdHVzKSB7Cj4gKwljYXNlIFNMSU1fREVWSUNFX1NUQVRVU19V UDoKPiArCQl3Y2QtPnJlZ21hcCA9IHJlZ21hcF9pbml0X3NsaW1idXMoc2RldiwgJndjZDkzNHhf cmVnbWFwX2NvbmZpZyk7Cj4gKwkJaWYgKElTX0VSUih3Y2QtPnJlZ21hcCkpIHsKPiArCQkJZGV2 X2VycihkZXYsICJFcnJvciBhbGxvY2F0aW5nIHNsaW0gcmVnbWFwXG4iKTsKPiArCQkJcmV0dXJu IFBUUl9FUlIod2NkLT5yZWdtYXApOwo+ICsJCX0KPiArCj4gKwkJcmV0ID0gd2NkOTM0eF9icmlu Z191cCh3Y2QpOwo+ICsJCWlmIChyZXQpIHsKPiArCQkJZGV2X2VycihkZXYsICJFcnJvciBXQ0Q5 MzRYIGJyaW5ndXA6IGVyciA9ICVkXG4iLCByZXQpOwoKUGxlYXNlIHVzZSB3ZWxsIGZvcm1lZCBF bmdsaXNoLgoKIkZhaWxlZCB0byBicmluZyB1cCBXQ0Q5MzRYIi4KCj4gKwkJCXJldHVybiByZXQ7 Cj4gKwkJfQo+ICsKPiArCQlyZXQgPSBkZXZtX3JlZ21hcF9hZGRfaXJxX2NoaXAod2NkLT5kZXYs IHdjZC0+cmVnbWFwLCB3Y2QtPmlycSwKPiArCQkJCQkgICAgICAgSVJRRl9UUklHR0VSX0hJR0gs IDAsCj4gKwkJCQkJICAgICAgICZ3Y2Q5MzR4X3JlZ21hcF9pcnFfY2hpcCwKPiArCQkJCQkgICAg ICAgJndjZC0+aXJxX2RhdGEpOwo+ICsJCWlmIChyZXQpIHsKPiArCQkJZGV2X2Vycih3Y2QtPmRl diwgIkVycm9yIGFkZGluZyBpcnFfY2hpcDogZXJyID0gJWRcbiIsCgoiRmFpbGVkIHRvIGFkZCBJ UlEgY2hpcCIuCgo+ICsJCQkJcmV0KTsKPiArCQkJcmV0dXJuIHJldDsKPiArCQl9Cj4gKwo+ICsJ CXJldCA9IG1mZF9hZGRfZGV2aWNlcyh3Y2QtPmRldiwgMCwgd2NkOTM0eF9kZXZpY2VzLAoKV2hh dCBkbyB5b3UgbWVhbiBieSAwIGhlcmU/Cgo+ICsJCQkJICAgICAgQVJSQVlfU0laRSh3Y2Q5MzR4 X2RldmljZXMpLAo+ICsJCQkJICAgICAgTlVMTCwgMCwgTlVMTCk7Cj4gKwkJaWYgKHJldCkgewo+ ICsJCQlkZXZfZXJyKHdjZC0+ZGV2LCAiRXJyb3IgYWRkIG1mZCBkZXZpY2VzOiBlcnIgPSAlZFxu IiwKCiJGYWlsZWQgdG8gYWRkIGNoaWxkIGRldmljZXMiLgoKPiArCQkJCXJldCk7Cj4gKwkJCXJl dHVybiByZXQ7Cj4gKwkJfQo+ICsJCWJyZWFrOwo+ICsJY2FzZSBTTElNX0RFVklDRV9TVEFUVVNf RE9XTjoKPiArCQltZmRfcmVtb3ZlX2RldmljZXMod2NkLT5kZXYpOwo+ICsJCWJyZWFrOwo+ICsJ ZGVmYXVsdDoKPiArCQlyZXR1cm4gLUVJTlZBTDsKPiArCX0KPiArCj4gKwlyZXR1cm4gMDsKPiAr fQo+ICsKPiArc3RhdGljIHZvaWQgd2NkOTM0eF9zbGltX3JlbW92ZShzdHJ1Y3Qgc2xpbV9kZXZp Y2UgKnNkZXYpCj4gK3sKPiArCXN0cnVjdCB3Y2Q5MzR4X2RhdGEgKndjZCA9IGRldl9nZXRfZHJ2 ZGF0YSgmc2Rldi0+ZGV2KTsKCk5vIG1vcmUgY2xlYW4tdXA/ICBBcmVuJ3QgdGhlIHJlZ3VsYXRv cnMgc3RpbGwgZW5hYmxlZD8KCj4gKwltZmRfcmVtb3ZlX2RldmljZXMoJnNkZXYtPmRldik7Cj4g KwlrZnJlZSh3Y2QpOwo+ICt9Cj4gKwo+ICtzdGF0aWMgY29uc3Qgc3RydWN0IHNsaW1fZGV2aWNl X2lkIHdjZDkzNHhfc2xpbV9pZFtdID0gewo+ICsJe1NMSU1fTUFORl9JRF9RQ09NLCBTTElNX1BS T0RfQ09ERV9XQ0Q5MzQwLCAweDEsIDB4MH0sCgonICdzIGJlZm9yZSBhbmQgYWZ0ZXIgZmlyc3Qg YW5kIGxhc3QgY2hhcnMgcGxlYXNlLgoKPiArCXt9Cj4gK307Cj4gKwo+ICtzdGF0aWMgc3RydWN0 IHNsaW1fZHJpdmVyIHdjZDkzNHhfc2xpbV9kcml2ZXIgPSB7Cj4gKwkuZHJpdmVyID0gewo+ICsJ CS5uYW1lID0gIndjZDkzNHgtc2xpbSIsCj4gKwl9LAo+ICsJLnByb2JlID0gd2NkOTM0eF9zbGlt X3Byb2JlLAo+ICsJLnJlbW92ZSA9IHdjZDkzNHhfc2xpbV9yZW1vdmUsCj4gKwkuZGV2aWNlX3N0 YXR1cyA9IHdjZDkzNHhfc2xpbV9zdGF0dXMsCj4gKwkuaWRfdGFibGUgPSB3Y2Q5MzR4X3NsaW1f aWQsCj4gK307Cj4gKwo+ICttb2R1bGVfc2xpbV9kcml2ZXIod2NkOTM0eF9zbGltX2RyaXZlcik7 Cj4gK01PRFVMRV9ERVNDUklQVElPTigiV0NEOTM0WCBzbGltIGRyaXZlciIpOwo+ICtNT0RVTEVf TElDRU5TRSgiR1BMIHYyIik7Cj4gK01PRFVMRV9BTElBUygic2xpbToyMTc6MjUwOioiKTsKCk1P RFVMRV9BVVRIT1I/CgpbLi4uXQoKPiArI2VuZGlmCj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGlu dXgvbWZkL3djZDkzNHgvd2NkOTM0eC5oIGIvaW5jbHVkZS9saW51eC9tZmQvd2NkOTM0eC93Y2Q5 MzR4LmgKPiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+IGluZGV4IDAwMDAwMDAwMDAwMC4uZDEwMmUy MTE5NDhjCj4gLS0tIC9kZXYvbnVsbAo+ICsrKyBiL2luY2x1ZGUvbGludXgvbWZkL3djZDkzNHgv d2NkOTM0eC5oCj4gQEAgLTAsMCArMSwyNCBAQAo+ICsvKiBTUERYLUxpY2Vuc2UtSWRlbnRpZmll cjogR1BMLTIuMCAqLwo+ICsKPiArI2lmbmRlZiBfX1dDRDkzNFhfSF9fCj4gKyNkZWZpbmUgX19X Q0Q5MzRYX0hfXwo+ICsjaW5jbHVkZSA8bGludXgvY2xrLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9y ZWd1bGF0b3IvY29uc3VtZXIuaD4KPiArI2luY2x1ZGUgPGxpbnV4L3JlZ21hcC5oPgo+ICsjaW5j bHVkZSA8bGludXgvc2xpbWJ1cy5oPgo+ICsKPiArI2RlZmluZSBXQ0Q5MzRYX01BWF9TVVBQTFkJ NQoKS2VybmVsIGRvYz8KCj4gK3N0cnVjdCB3Y2Q5MzR4X2RhdGEgewo+ICsJaW50IHJlc2V0X2dw aW87Cj4gKwlpbnQgaXJxOwoKSSdkIHByZWZlciB0byBzZWUgdGhlIG1vcmUgY29tcGxleCAnc3Ry dWN0J3MgYXQgdGhlIHRvcC4KCj4gKwlzdHJ1Y3QgZGV2aWNlICpkZXY7Cj4gKwlzdHJ1Y3QgY2xr ICpleHRjbGs7Cj4gKwlzdHJ1Y3QgcmVnbWFwICpyZWdtYXA7Cj4gKwlzdHJ1Y3Qgc2xpbV9kZXZp Y2UgKnNkZXY7CgpZb3UgZG9uJ3QgbmVlZCAnc2RldicgYW5kICdkZXYnLgoKPiArCXN0cnVjdCBy ZWdtYXBfaXJxX2NoaXBfZGF0YSAqaXJxX2RhdGE7Cj4gKwlzdHJ1Y3QgcmVndWxhdG9yX2J1bGtf ZGF0YSBzdXBwbGllc1tXQ0Q5MzRYX01BWF9TVVBQTFldOwo+ICt9Owo+ICsKPiArI2VuZGlmIC8q IF9fV0NEOTM0WF9IX18gKi8KPiArCgotLSAKTGVlIEpvbmVzIFvmnY7nkLzmlq9dCkxpbmFybyBT ZXJ2aWNlcyBUZWNobmljYWwgTGVhZApMaW5hcm8ub3JnIOKUgiBPcGVuIHNvdXJjZSBzb2Z0d2Fy ZSBmb3IgQVJNIFNvQ3MKRm9sbG93IExpbmFybzogRmFjZWJvb2sgfCBUd2l0dGVyIHwgQmxvZwpf X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpBbHNhLWRldmVs IG1haWxpbmcgbGlzdApBbHNhLWRldmVsQGFsc2EtcHJvamVjdC5vcmcKaHR0cHM6Ly9tYWlsbWFu LmFsc2EtcHJvamVjdC5vcmcvbWFpbG1hbi9saXN0aW5mby9hbHNhLWRldmVsCg==