From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mail-wm2-f12.google.com (mail-wm2-f12.google.com [74.125.225.140]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id D5B143AB47A for ; Fri, 11 Sep 2026 22:15:14 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=74.125.225.140 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1789164917; cv=none; b=IN0QmZSyH03oHZdDj/COAyg7EoOohaACt9PMJ8JNNWFd7ljG1NX/ZWd6B2z4QDBNggxRTrTNfAXZh8GCBjrM1PJ7ryQ5NGoImnFDaxC20S886UO3QYXBdQzOZ91DCpMBD8NmY/8/zfz4Wuz/rbSzrEXQi6lXNMh2Z0JQ9Vv9PO8= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1789164917; c=relaxed/simple; bh=U38KIW8l3Mu//XwcIMEecEk/1YyGnT9t7x5OqfJMhJs=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=NinzLZYkg4yo7dCvh5Jbj6GQsUFcHcGCXkS9r/eELwE/i2z9s1hnADWQcR4a6nJNt6u8pVfUws3lSma1sq1+ZDai/hMuKmXPFfuml/VymLZoFqvD+/4LjXy5N5exJMCMb24AT3GUCA7VSr4yphit+bubsglNI5RjMcSHNgJewsM= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=baylibre.com; spf=pass smtp.mailfrom=baylibre.com; dkim=pass (2048-bit key) header.d=baylibre.com header.i=@baylibre.com header.b=o1vh+fWa; arc=none smtp.client-ip=74.125.225.140 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=baylibre.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=baylibre.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=baylibre.com header.i=@baylibre.com header.b="o1vh+fWa" Received: by mail-wm2-f12.google.com with SMTP id 5b1f17b1804b1-49b912d37b6so1654595e9.0 for ; Fri, 11 Sep 2026 15:15:14 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=baylibre.com; s=google; t=1789164913; x=1789769713; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :content-type:mime-version:subject:date:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=EuapJCTCH4Mm1Cl2su8mwhuXka1tyaCJMFc8XSqcx9k=; b=o1vh+fWaQA0CnDOVV3d4t9bWJEieVp3qBNBSXanPuGcPn7xowE+7XBR1/UwZVcfFAZ xdLBf6IhsFRpFfUZMR72A84S9dJmOJBetEXllZTIaJmqv1aB0Fcy73aFdbP3GT0Py2kF nYiuWbolFMb3nWfhTQcDprBhBWMH7cFnYude9Kyhfe8xvk6MxUIdZlsj8Uhl80n2F/wR R06cnRKkuN78h2ikJuBvSwCq1D2jTHI91eUQudgT0ZpZy0hYUr/8JK6DW0osmNnoNvhC 5opF8HFFj3nkOoNG4jxfW0E1WVXxacCc+VFmoHTaQ8d/RS3sYPpFd7st0lDAYT1206DQ GWYA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1789164913; x=1789769713; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :content-type:mime-version:subject:date:from:x-gm-gg :x-gm-message-state:from:to:cc:subject:date:message-id:reply-to :content-type; bh=EuapJCTCH4Mm1Cl2su8mwhuXka1tyaCJMFc8XSqcx9k=; b=I0KKyR4h79z74/esXMBe4lhzOmcnHEZPsm/Q1C4eClFM3JFlbW6bNRumYfHFNdgV5k 5S9pv5L2OYaiV4yN8/1x0xEp+/dam6BkUhHisk/85tJ2POQMeno2O1xitkTfKFkrZ+eW rr+513coGQA82hQs3lBhKHpx+yrx39VdrgqmpL5j+R6BoAsmUyDAO/ELp8SYKOVita1A 0EZwCaia5w9u6cDmNceJiqcf8gv7St/OmB9h1htl53Y1TjXgpLMQ5O5QoF5DQ+N0ttRa iM9qzEBrnK/weOnybbq+JsGDEZX/7Ir2ru6xHGqbvwEiMWo0OrGkT1CkwkbI0oAxXn9l +qig== X-Gm-Message-State: AFuF++l0yqdV/SXxx1v3W+ngcSRoSRhxdnvIqh2KRuTJ3LoQddfrkydZ pj5+IlP4eta7jyjBER2Lo1oYH6P9AMblo0+puKEo3PFlxePOiDMvnzdV+FyrEbYhj78= X-Gm-Gg: AYBFou3ZZt6Lmvx3ZyunZun+XxQlQREmh7GmwFgxB3kOuAiPw6KB8aouD3h+6USzOK9 NetXyD0FNfJFmdcNYbVkFSbeOQ3fFxALEBQanYsAGxMj8/o8TuBAeEwem09TjG3bN8LE0XBGkUC KxhZhKcyRM/ersu1jH7defA1F9XKAL4uvvWb+MffTFyqEvnyro1sUBqjqmAFn2NOaUS/P1ml97k WK2RCpYNCDDwiiCJ639aYn7Ge6hlxpS8D2rOFv4m4FVWgJoeQAbd1mlexMDSWxXyDquN9P2kXSy q3NvBwJq1W5tDflsfCd7ojxWqIaWlPmfMFV4wtUccylJLz4LdkoXIU7xR7PX9+R1k99/72pdeOQ hWeFOoJTWEBV2eXh8onFzL9ebyGZ8TIe2bOpqKimgPT9uDBtxlZ5F4ok2zdhBwcE1T6cUww/pSd JdkE0amZVpKKPH5ZcfAVmMlAYLypX4H3lEbv0Gm+zHRRP6KNu5B9ypvmh/g5/yy0zHxQ== X-Received: by 2002:a05:600c:540e:b0:49e:6692:27fd with SMTP id 5b1f17b1804b1-49e66922810mr91970045e9.2.1789164913122; Fri, 11 Sep 2026 15:15:13 -0700 (PDT) Received: from [127.0.1.1] ([151.42.87.32]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-49d26c2a419sm202882745e9.7.2026.09.11.15.15.12 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 11 Sep 2026 15:15:12 -0700 (PDT) From: Valerio Setti Date: Sat, 12 Sep 2026 00:14:32 +0200 Subject: [PATCH 2/6] ASoC: meson: add audin main module and I2S formatter Precedence: bulk X-Mailing-List: linux-sound@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: 8bit Message-Id: <20260912-audin-v1-2-7fbefe928711@baylibre.com> References: <20260912-audin-v1-0-7fbefe928711@baylibre.com> In-Reply-To: <20260912-audin-v1-0-7fbefe928711@baylibre.com> To: Jerome Brunet , Liam Girdwood , Mark Brown , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Neil Armstrong , Kevin Hilman , Martin Blumenstingl , Jaroslav Kysela , Takashi Iwai Cc: linux-sound@vger.kernel.org, devicetree@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-amlogic@lists.infradead.org, linux-kernel@vger.kernel.org, Valerio Setti X-Mailer: b4 0.16.0 X-Developer-Signature: v=1; a=openpgp-sha256; l=12397; i=vsetti@baylibre.com; h=from:subject:message-id; bh=U38KIW8l3Mu//XwcIMEecEk/1YyGnT9t7x5OqfJMhJs=; b=owGbwMvMwCV2z3ty7kUrRgbG02pJDFlLanP94l+c3PBA9/DU6+57ct2rOvMaV3Qe2OyfpKHmz dLEULe+o5SFQYyLQVZMkYVl+r3fBaVqD40TThbAzGFlAhnCwMUpABP5f4jhf63FF8HcSQ/epJuf uGtT8jNz2k55Jr1jS9xdLD8krD7h+4fhf7m3ULHFoWIDC76Gxl8fv7GXLo91Xi68/NXPVa1edwP 3sQIA X-Developer-Key: i=vsetti@baylibre.com; a=openpgp; fpr=0497DEFB707526E13360C970DE4B936DD13A0100 Audin is the main component that provides audio input support to the Amlogic GX based platforms (GXBB/GXL). From a functional point of view it's pretty simple: - It provides input data formatters as sound widgets. Currently only I2S is supported, but other interfaces can be added in the future. - It enables the shared clock that's being used from all the components, i.e. formatters and FIFO. - It triggers the parsing of its DT child nodes that implement FIFOs. Note: the parent intentionally does not claim its register window so that the FIFO children can claim theirs. 'audin-formatter-i2s' is also added here implementing the functionalities required for the widget that's part of the audin audio component. The overall design is identical to what has been done for AIU module. Signed-off-by: Valerio Setti --- sound/soc/meson/Kconfig | 9 ++ sound/soc/meson/Makefile | 3 + sound/soc/meson/audin-formatter-i2s.c | 174 ++++++++++++++++++++++++++++++++++ sound/soc/meson/audin.c | 109 +++++++++++++++++++++ sound/soc/meson/audin.h | 14 +++ 5 files changed, 309 insertions(+) diff --git a/sound/soc/meson/Kconfig b/sound/soc/meson/Kconfig index d9a730994a2a..f6e54615fc73 100644 --- a/sound/soc/meson/Kconfig +++ b/sound/soc/meson/Kconfig @@ -12,6 +12,14 @@ config SND_MESON_AIU Select Y or M to add support for the Audio output subsystem found in the Amlogic Meson8, Meson8b and GX SoC families +config SND_MESON_AUDIN + tristate "Amlogic AUDIN" + select REGMAP_MMIO + select SND_MESON_AIU + help + Select Y or M to add support for the audio input subsystem found + in the Amlogic GX SoC family. Currently only I2S input is supported. + config SND_MESON_AXG_FIFO tristate select REGMAP_MMIO @@ -108,6 +116,7 @@ config SND_MESON_GX_SOUND_CARD tristate "Amlogic GX Sound Card Support" select SND_MESON_CARD_UTILS imply SND_MESON_AIU + imply SND_MESON_AUDIN help Select Y or M to add support for the GXBB/GXL SoC sound card diff --git a/sound/soc/meson/Makefile b/sound/soc/meson/Makefile index f9ec0ebb01f0..6a06a7b26e61 100644 --- a/sound/soc/meson/Makefile +++ b/sound/soc/meson/Makefile @@ -10,6 +10,8 @@ snd-soc-meson-aiu-y += aiu-encoder-spdif.o snd-soc-meson-aiu-y += aiu-fifo.o snd-soc-meson-aiu-y += aiu-fifo-i2s.o snd-soc-meson-aiu-y += aiu-fifo-spdif.o +snd-soc-meson-audin-y := audin.o +snd-soc-meson-audin-y += audin-formatter-i2s.o snd-soc-meson-axg-fifo-y := axg-fifo.o snd-soc-meson-axg-frddr-y := axg-frddr.o snd-soc-meson-axg-toddr-y := axg-toddr.o @@ -29,6 +31,7 @@ snd-soc-meson-g12a-tohdmitx-y := g12a-tohdmitx.o snd-soc-meson-t9015-y := t9015.o obj-$(CONFIG_SND_MESON_AIU) += snd-soc-meson-aiu.o +obj-$(CONFIG_SND_MESON_AUDIN) += snd-soc-meson-audin.o obj-$(CONFIG_SND_MESON_AXG_FIFO) += snd-soc-meson-axg-fifo.o obj-$(CONFIG_SND_MESON_AXG_FRDDR) += snd-soc-meson-axg-frddr.o obj-$(CONFIG_SND_MESON_AXG_TODDR) += snd-soc-meson-axg-toddr.o diff --git a/sound/soc/meson/audin-formatter-i2s.c b/sound/soc/meson/audin-formatter-i2s.c new file mode 100644 index 000000000000..8bbb5cdb52dc --- /dev/null +++ b/sound/soc/meson/audin-formatter-i2s.c @@ -0,0 +1,174 @@ +// SPDX-License-Identifier: GPL-2.0 +// +// Copyright (c) 2026 BayLibre, SAS. +// Author: Valerio Setti + +#include +#include +#include +#include + +#include "audin.h" +#include "gx-formatter.h" + +/* I2SIN_CTRL register and bits */ +#define AUDIN_I2SIN_CTRL 0x40 +#define AUDIN_I2SIN_CTRL_I2SIN_DIR BIT(0) +#define AUDIN_I2SIN_CTRL_I2SIN_CLK_SEL BIT(1) +#define AUDIN_I2SIN_CTRL_I2SIN_LRCLK_SEL BIT(2) +#define AUDIN_I2SIN_CTRL_I2SIN_BCLK_INV BIT(3) +#define AUDIN_I2SIN_CTRL_I2SIN_LRCLK_SKEW_MASK GENMASK(6, 4) +#define AUDIN_I2SIN_CTRL_I2SIN_LRCLK_INV BIT(7) +#define AUDIN_I2SIN_CTRL_I2SIN_SIZE_MASK GENMASK(9, 8) +#define AUDIN_I2SIN_CTRL_I2SIN_CHAN_EN_MASK GENMASK(13, 10) +#define AUDIN_I2SIN_CTRL_I2SIN_EN BIT(15) + +static struct snd_soc_dai * +audin_formatter_i2s_get_be(struct snd_soc_dapm_widget *w) +{ + struct snd_soc_dapm_path *p; + struct snd_soc_dai *be; + + snd_soc_dapm_widget_for_each_source_path(w, p) { + if (!p->connect) + continue; + + if (p->source->id == snd_soc_dapm_dai_out) + return (struct snd_soc_dai *)p->source->priv; + + be = audin_formatter_i2s_get_be(p->source); + if (be) + return be; + } + + return NULL; +} + +static struct gx_stream * +audin_formatter_i2s_get_stream(struct snd_soc_dapm_widget *w) +{ + struct snd_soc_dai *be = audin_formatter_i2s_get_be(w); + + if (!be) + return NULL; + + return snd_soc_dai_dma_data_get_capture(be); +} + +static void audin_formatter_i2s_enable(struct regmap *map) +{ + regmap_update_bits(map, AUDIN_I2SIN_CTRL, + AUDIN_I2SIN_CTRL_I2SIN_EN, + AUDIN_I2SIN_CTRL_I2SIN_EN); +} + +static void audin_formatter_i2s_disable(struct regmap *map) +{ + regmap_update_bits(map, AUDIN_I2SIN_CTRL, + AUDIN_I2SIN_CTRL_I2SIN_EN, 0); +} + +static int audin_formatter_i2s_prepare(struct regmap *map, + const struct gx_formatter_hw *quirks, + struct gx_stream *ts) +{ + unsigned int val; + int ret; + + /* + * I2S decoder always outputs 24 bits to the FIFO according to the + * manual. The only thing we can change through + * AUDIN_I2SIN_CTRL_I2SIN_SIZE_MASK is the following: + * - 0 -> output[23:0] = {original[23:8],8’d0} + * - 1 -> output[23:0] = {original[23:6],6’d0} + * - 2 -> output[23:0] = {original[23:4],4’d0} + * - 3 -> output[23:0] = {original[23:0]} + * + * We use 3 here and, in case of 16 bit format, we filter unnecessary + * bytes at FIFO stage. + * Note: data is left-justified, so in case of 16 bits samples, this + * means that the LSB is to be discarded at FIFO level and the + * relevant part is in bits [23:8]. + */ + val = FIELD_PREP(AUDIN_I2SIN_CTRL_I2SIN_SIZE_MASK, 3); + ret = regmap_update_bits(map, AUDIN_I2SIN_CTRL, + AUDIN_I2SIN_CTRL_I2SIN_SIZE_MASK, val); + if (ret) + return ret; + + /* + * The manual claims that this platform supports up to 4 streams + * (8 channels), but currently only 1 stream (2 channels) has been + * tested and it's supported. + */ + val = FIELD_PREP(AUDIN_I2SIN_CTRL_I2SIN_CHAN_EN_MASK, 1); + ret = regmap_update_bits(map, AUDIN_I2SIN_CTRL, + AUDIN_I2SIN_CTRL_I2SIN_CHAN_EN_MASK, val); + if (ret) + return ret; + + /* + * Use clocks from AIU and not from the pads since we only want to + * support master mode. + */ + val = AUDIN_I2SIN_CTRL_I2SIN_CLK_SEL | + AUDIN_I2SIN_CTRL_I2SIN_LRCLK_SEL | + AUDIN_I2SIN_CTRL_I2SIN_DIR; + ret = regmap_update_bits(map, AUDIN_I2SIN_CTRL, val, val); + if (ret) + return ret; + + switch (ts->iface->fmt & SND_SOC_DAIFMT_INV_MASK) { + case SND_SOC_DAIFMT_IB_NF: + val = AUDIN_I2SIN_CTRL_I2SIN_BCLK_INV; + break; + case SND_SOC_DAIFMT_NB_IF: + val = AUDIN_I2SIN_CTRL_I2SIN_LRCLK_INV; + break; + case SND_SOC_DAIFMT_IB_IF: + val = AUDIN_I2SIN_CTRL_I2SIN_BCLK_INV | AUDIN_I2SIN_CTRL_I2SIN_LRCLK_INV; + break; + case SND_SOC_DAIFMT_NB_NF: + val = 0; + break; + default: + return -EINVAL; + } + + ret = regmap_update_bits(map, AUDIN_I2SIN_CTRL, + AUDIN_I2SIN_CTRL_I2SIN_LRCLK_INV | + AUDIN_I2SIN_CTRL_I2SIN_BCLK_INV, val); + if (ret) + return ret; + + switch (ts->iface->fmt & SND_SOC_DAIFMT_FORMAT_MASK) { + case SND_SOC_DAIFMT_I2S: + val = 1; + break; + case SND_SOC_DAIFMT_LEFT_J: + val = 0; + break; + default: + return -EINVAL; + } + + val = FIELD_PREP(AUDIN_I2SIN_CTRL_I2SIN_LRCLK_SKEW_MASK, val); + ret = regmap_update_bits(map, AUDIN_I2SIN_CTRL, + AUDIN_I2SIN_CTRL_I2SIN_LRCLK_SKEW_MASK, + val); + if (ret) + return ret; + + return 0; +} + +static const struct gx_formatter_ops audin_formatter_i2s_ops = { + .get_stream = audin_formatter_i2s_get_stream, + .prepare = audin_formatter_i2s_prepare, + .enable = audin_formatter_i2s_enable, + .disable = audin_formatter_i2s_disable, +}; + +const struct gx_formatter_driver audin_formatter_i2s_drv = { + .ops = &audin_formatter_i2s_ops, +}; diff --git a/sound/soc/meson/audin.c b/sound/soc/meson/audin.c new file mode 100644 index 000000000000..e8071323432b --- /dev/null +++ b/sound/soc/meson/audin.c @@ -0,0 +1,109 @@ +// SPDX-License-Identifier: GPL-2.0 +// +// Copyright (c) 2026 BayLibre, SAS. +// Author: Valerio Setti + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "audin.h" +#include "gx-formatter.h" + +static struct snd_soc_dapm_widget audin_dapm_widgets[] = { + SND_SOC_DAPM_PGA_E("I2S Formatter", SND_SOC_NOPM, 0, 0, NULL, 0, + gx_formatter_event, + (SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_PRE_PMD)), +}; + +static const struct snd_soc_component_driver audin_component = { + .dapm_widgets = audin_dapm_widgets, + .num_dapm_widgets = ARRAY_SIZE(audin_dapm_widgets), +}; + +static const struct regmap_config audin_regmap_cfg = { + .reg_bits = 32, + .val_bits = 32, + .reg_stride = 4, + .max_register = 0x304, +}; + +static int meson_gx_audin_probe(struct platform_device *pdev) +{ + struct device *dev = &pdev->dev; + struct resource *res; + void __iomem *mmio; + struct regmap *regmap; + struct clk *clk; + int ret; + + ret = device_reset(dev); + if (ret) + return dev_err_probe(dev, ret, "Failed to reset device\n"); + + res = platform_get_resource(pdev, IORESOURCE_MEM, 0); + if (!res) + return dev_err_probe(dev, -EINVAL, "Failed to get memory resource\n"); + + /* + * Do not use devm_platform_ioremap_resource() here: it would claim the + * whole AUDIN window exclusively and the FIFO children would then fail + * to request their own sub-ranges. + */ + mmio = devm_ioremap(dev, res->start, resource_size(res)); + if (!mmio) + return dev_err_probe(dev, -ENOMEM, "Failed to remap memory\n"); + + regmap = devm_regmap_init_mmio(dev, mmio, &audin_regmap_cfg); + if (IS_ERR(regmap)) + return dev_err_probe(dev, PTR_ERR(regmap), "Failed to init regmap\n"); + + clk = devm_clk_get_enabled(dev, NULL); + if (IS_ERR(clk)) + return dev_err_probe(dev, PTR_ERR(clk), "Failed to get clock\n"); + + ret = gx_formatter_create(dev, &audin_dapm_widgets[0], &audin_formatter_i2s_drv, regmap); + if (ret) + return dev_err_probe(dev, ret, "Failed to allocate formatter\n"); + + ret = devm_snd_soc_register_component(dev, &audin_component, NULL, 0); + if (ret) + return dev_err_probe(dev, ret, "Failed to register component\n"); + + ret = devm_of_platform_populate(dev); + if (ret) + return dev_err_probe(dev, ret, "Failed to probe child nodes\n"); + + return 0; +} + +static void meson_gx_audin_remove(struct platform_device *pdev) +{ + gx_formatter_free(&audin_dapm_widgets[0]); +} + +static const struct of_device_id meson_gx_audin_of_match[] = { + { .compatible = "amlogic,meson-gxbb-audin" }, + { .compatible = "amlogic,meson-gxl-audin" }, + {} +}; +MODULE_DEVICE_TABLE(of, meson_gx_audin_of_match); + +static struct platform_driver meson_gx_audin_driver = { + .driver = { + .name = "meson-gx-audin", + .of_match_table = meson_gx_audin_of_match, + }, + .probe = meson_gx_audin_probe, + .remove = meson_gx_audin_remove, +}; +module_platform_driver(meson_gx_audin_driver); + +MODULE_DESCRIPTION("Meson GX AUDIN driver"); +MODULE_AUTHOR("Valerio Setti "); +MODULE_LICENSE("GPL"); diff --git a/sound/soc/meson/audin.h b/sound/soc/meson/audin.h new file mode 100644 index 000000000000..29961e18190f --- /dev/null +++ b/sound/soc/meson/audin.h @@ -0,0 +1,14 @@ +/* SPDX-License-Identifier: (GPL-2.0 OR MIT) */ +/* + * Copyright (c) 2026 BayLibre, SAS. + * Author: Valerio Setti + */ + +#ifndef _MESON_AUDIN_H +#define _MESON_AUDIN_H + +#include "gx-formatter.h" + +extern const struct gx_formatter_driver audin_formatter_i2s_drv; + +#endif -- 2.47.3 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 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 smtp.lore.kernel.org (Postfix) with ESMTPS id 6A9CDC88E50 for ; Fri, 11 Sep 2026 22:15:22 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:Cc:To:In-Reply-To:References:Message-Id :MIME-Version:Subject:Date:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=JZXngxEO081Xr7bimiP1zKyl2pMwBKkYvA4a/uQfaFA=; b=iSPstDn/mGyAwk 1JrX/JkeO9reCaQO5ehAE6uWVKCsOeAVOp+55nR4DuLX/KeqHNZAPSltWDsHBZxFwu/3pgN9eyZ9Z kDnNy2lFDPfU3dXvqdseeOiX49HdP+0z26UVFi0JB3uo84cgqTlvZVYbq1OzqHRgS5qUeIXTKc0YS 4eCNmWFmUWGYMjMIbxcMaxpfeiL/EjWH0oWUXDWsVuzxbyQi6p8JLGCfPI6b0diwiz1vv05Hixau5 RGQ64DuBo+KOI+OrIrGvyljD/1NiwJqGhqdkfEiSceyHtxq3wMQLNVaFfatH5v99LEZw1Ap6yKrHx i3hbclque+oI/PSUJCjA==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.99.1 #2 (Red Hat Linux)) id 1x59Wf-00000000FG4-2nJM; Fri, 11 Sep 2026 22:15:17 +0000 Received: from mail-wm2-x10.google.com ([2a00:1450:4864:31::10]) by bombadil.infradead.org with esmtps (Exim 4.99.1 #2 (Red Hat Linux)) id 1x59Wc-00000000FCf-2oJt for linux-amlogic@lists.infradead.org; Fri, 11 Sep 2026 22:15:16 +0000 Received: by mail-wm2-x10.google.com with SMTP id 5b1f17b1804b1-49b912d37b5so2233855e9.2 for ; Fri, 11 Sep 2026 15:15:14 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=baylibre.com; s=google; t=1789164913; x=1789769713; darn=lists.infradead.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :content-type:mime-version:subject:date:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=EuapJCTCH4Mm1Cl2su8mwhuXka1tyaCJMFc8XSqcx9k=; b=WsvI5zNVNRdOFxeuUW2vYjP1gL+Zgk4wL2J86f1o5sA8iylwJNtjsL48Hl1eLe3J+J IylDKAqUHF2FQnV6GLqybqmaZqEHNgSFv7ojbqEafqg9FSNrr71DlhwWTnjOtWCVUUHg y5biP6ArcJ+RSW+2ZLGx/5edqrPORy06euCRSkF9fivSauV4OhwXF3Rs2Hhny77Ww+By ttr2xiM9ONT6zOhQ2ZQkT1hCg82Z6RciPiJZT66FJk/ZdStkhZqmRdst5mESt5agzogh 4Or9rjVaTgBJc1cG/5Q05NO47ZB8FVsn/olW7JEMEbcjHLndRme2MCjKOvY51lmZu+Dw nupw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1789164913; x=1789769713; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :content-type:mime-version:subject:date:from:x-gm-gg :x-gm-message-state:from:to:cc:subject:date:message-id:reply-to :content-type; bh=EuapJCTCH4Mm1Cl2su8mwhuXka1tyaCJMFc8XSqcx9k=; b=AXfcWlibJtEsUAnahWUkO8Ei9PaLXJ80seu6oBG8NMhrmBuaSRt+erMVpL8fVsdMGC 85heDODmXyXy37zYx5HS64COdRC/urkANTHAvnTrKEfNJKquNxeFMkt8EhtWczJZU/49 0rPDh1BJ9eDUyBOsNQfQxXu+uz8Iys7h18pBl9N2m59ipOV4J4h7LrYMVazZLtJy1vX1 26KXw3cBs4Jcja3kL8INtcKFuazKiyYoNN9vAKS6Xr/n1tlb+0JHfcYP5w9VSMsQ8/Mf ia6sWy3dgUw/wCf9XGqKWQ4LMxzRbbE3mU4Re3tzxiBzaS28sinizytOiKxruoENRlYx rXjw== X-Forwarded-Encrypted: i=1; AKwUvBwE3OgnTWcayJI6s11vWpW4qB5gQ9ufi0AIvoJh0t1GR/x4nbeJg0FKWzVrw5mwF0c5finH7gJ5KJowq8rD@lists.infradead.org X-Gm-Message-State: AFuF++laQhlWxl/pG8bBfKEPrQqC+IZ0ceF4P7P9mAlBUrZJWZU7aXTc pvs73xZmlneVOHuv+lez3h4RCq5bDRRH4s8Wfo2JEW3VUorCp/1ZLOGr74MSH/tj+WY= X-Gm-Gg: AYBFou1LRLgbjok6ytj4XdCQboDJdAX8g9xTrgcH+s6+PeT4AebPqcPW8ZTgpTa2FK5 fI1M/NFnvDEp1GP7SOhQbkwSqvAl47lQH1hLZh1Esy5dkFruhCyulKGn+r7BmVEvOtOvxpWlOQl wym7WnLBKgCKfhtrEpmNnn5dgQzMM+IXqDf9lXLGMiUruoAu8VDObrf1H/FCM4wq2PW3N7nkljP y3fsERrdNSED3qaPmwSrV4ulFb08e2VIHtdyQhSQeGBez3MY7m7wMm2u70JNCx5DncHY3KH7rhR eoQvHF4Wxy7NKisA48m85XqKLK9cyIqSrYV2Fo8fgpbO01cSClB37FOHzXV4+Ns0CStz4tQ+G+a IYewWOf8LEZaJL3AEkgk4JhlAs4eVFKIeItd5nRNxAcBKiC9h+lzYGDnrCr4tjJl7vB+FJQor4a 9H0BTLr3HrP1XlbHZwYqmOBXYSms2+8tFvQbZj/J/23PXcSEg9s4iyXjiPfRCortI46w== X-Received: by 2002:a05:600c:540e:b0:49e:6692:27fd with SMTP id 5b1f17b1804b1-49e66922810mr91970045e9.2.1789164913122; Fri, 11 Sep 2026 15:15:13 -0700 (PDT) Received: from [127.0.1.1] ([151.42.87.32]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-49d26c2a419sm202882745e9.7.2026.09.11.15.15.12 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 11 Sep 2026 15:15:12 -0700 (PDT) From: Valerio Setti Date: Sat, 12 Sep 2026 00:14:32 +0200 Subject: [PATCH 2/6] ASoC: meson: add audin main module and I2S formatter MIME-Version: 1.0 Message-Id: <20260912-audin-v1-2-7fbefe928711@baylibre.com> References: <20260912-audin-v1-0-7fbefe928711@baylibre.com> In-Reply-To: <20260912-audin-v1-0-7fbefe928711@baylibre.com> To: Jerome Brunet , Liam Girdwood , Mark Brown , Rob Herring , Krzysztof Kozlowski , Conor Dooley , Neil Armstrong , Kevin Hilman , Martin Blumenstingl , Jaroslav Kysela , Takashi Iwai Cc: linux-sound@vger.kernel.org, devicetree@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-amlogic@lists.infradead.org, linux-kernel@vger.kernel.org, Valerio Setti X-Mailer: b4 0.16.0 X-Developer-Signature: v=1; a=openpgp-sha256; l=12397; i=vsetti@baylibre.com; h=from:subject:message-id; bh=U38KIW8l3Mu//XwcIMEecEk/1YyGnT9t7x5OqfJMhJs=; b=owGbwMvMwCV2z3ty7kUrRgbG02pJDFlLanP94l+c3PBA9/DU6+57ct2rOvMaV3Qe2OyfpKHmz dLEULe+o5SFQYyLQVZMkYVl+r3fBaVqD40TThbAzGFlAhnCwMUpABP5f4jhf63FF8HcSQ/epJuf uGtT8jNz2k55Jr1jS9xdLD8krD7h+4fhf7m3ULHFoWIDC76Gxl8fv7GXLo91Xi68/NXPVa1edwP 3sQIA X-Developer-Key: i=vsetti@baylibre.com; a=openpgp; fpr=0497DEFB707526E13360C970DE4B936DD13A0100 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.9.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20260911_151514_781600_31F2D91B X-CRM114-Status: GOOD ( 26.95 ) X-BeenThere: linux-amlogic@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-amlogic" Errors-To: linux-amlogic-bounces+linux-amlogic=archiver.kernel.org@lists.infradead.org QXVkaW4gaXMgdGhlIG1haW4gY29tcG9uZW50IHRoYXQgcHJvdmlkZXMgYXVkaW8gaW5wdXQgc3Vw cG9ydCB0byB0aGUgQW1sb2dpYwpHWCBiYXNlZCBwbGF0Zm9ybXMgKEdYQkIvR1hMKS4gRnJvbSBh IGZ1bmN0aW9uYWwgcG9pbnQgb2YgdmlldyBpdCdzIHByZXR0eQpzaW1wbGU6Ci0gSXQgcHJvdmlk ZXMgaW5wdXQgZGF0YSBmb3JtYXR0ZXJzIGFzIHNvdW5kIHdpZGdldHMuIEN1cnJlbnRseSBvbmx5 IEkyUwogIGlzIHN1cHBvcnRlZCwgYnV0IG90aGVyIGludGVyZmFjZXMgY2FuIGJlIGFkZGVkIGlu IHRoZSBmdXR1cmUuCi0gSXQgZW5hYmxlcyB0aGUgc2hhcmVkIGNsb2NrIHRoYXQncyBiZWluZyB1 c2VkIGZyb20gYWxsIHRoZSBjb21wb25lbnRzLAogIGkuZS4gZm9ybWF0dGVycyBhbmQgRklGTy4K LSBJdCB0cmlnZ2VycyB0aGUgcGFyc2luZyBvZiBpdHMgRFQgY2hpbGQgbm9kZXMgdGhhdCBpbXBs ZW1lbnQgRklGT3MuCiAgTm90ZTogdGhlIHBhcmVudCBpbnRlbnRpb25hbGx5IGRvZXMgbm90IGNs YWltIGl0cyByZWdpc3RlciB3aW5kb3cgc28KICB0aGF0IHRoZSBGSUZPIGNoaWxkcmVuIGNhbiBj bGFpbSB0aGVpcnMuCgonYXVkaW4tZm9ybWF0dGVyLWkycycgaXMgYWxzbyBhZGRlZCBoZXJlIGlt cGxlbWVudGluZyB0aGUgZnVuY3Rpb25hbGl0aWVzCnJlcXVpcmVkIGZvciB0aGUgd2lkZ2V0IHRo YXQncyBwYXJ0IG9mIHRoZSBhdWRpbiBhdWRpbyBjb21wb25lbnQuCgpUaGUgb3ZlcmFsbCBkZXNp Z24gaXMgaWRlbnRpY2FsIHRvIHdoYXQgaGFzIGJlZW4gZG9uZSBmb3IgQUlVIG1vZHVsZS4KClNp Z25lZC1vZmYtYnk6IFZhbGVyaW8gU2V0dGkgPHZzZXR0aUBiYXlsaWJyZS5jb20+Ci0tLQogc291 bmQvc29jL21lc29uL0tjb25maWcgICAgICAgICAgICAgICB8ICAgOSArKwogc291bmQvc29jL21l c29uL01ha2VmaWxlICAgICAgICAgICAgICB8ICAgMyArCiBzb3VuZC9zb2MvbWVzb24vYXVkaW4t Zm9ybWF0dGVyLWkycy5jIHwgMTc0ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysK IHNvdW5kL3NvYy9tZXNvbi9hdWRpbi5jICAgICAgICAgICAgICAgfCAxMDkgKysrKysrKysrKysr KysrKysrKysrCiBzb3VuZC9zb2MvbWVzb24vYXVkaW4uaCAgICAgICAgICAgICAgIHwgIDE0ICsr KwogNSBmaWxlcyBjaGFuZ2VkLCAzMDkgaW5zZXJ0aW9ucygrKQoKZGlmZiAtLWdpdCBhL3NvdW5k L3NvYy9tZXNvbi9LY29uZmlnIGIvc291bmQvc29jL21lc29uL0tjb25maWcKaW5kZXggZDlhNzMw OTk0YTJhLi5mNmU1NDYxNWZjNzMgMTAwNjQ0Ci0tLSBhL3NvdW5kL3NvYy9tZXNvbi9LY29uZmln CisrKyBiL3NvdW5kL3NvYy9tZXNvbi9LY29uZmlnCkBAIC0xMiw2ICsxMiwxNCBAQCBjb25maWcg U05EX01FU09OX0FJVQogCSAgU2VsZWN0IFkgb3IgTSB0byBhZGQgc3VwcG9ydCBmb3IgdGhlIEF1 ZGlvIG91dHB1dCBzdWJzeXN0ZW0gZm91bmQKIAkgIGluIHRoZSBBbWxvZ2ljIE1lc29uOCwgTWVz b244YiBhbmQgR1ggU29DIGZhbWlsaWVzCiAKK2NvbmZpZyBTTkRfTUVTT05fQVVESU4KKwl0cmlz dGF0ZSAiQW1sb2dpYyBBVURJTiIKKwlzZWxlY3QgUkVHTUFQX01NSU8KKwlzZWxlY3QgU05EX01F U09OX0FJVQorCWhlbHAKKwkgIFNlbGVjdCBZIG9yIE0gdG8gYWRkIHN1cHBvcnQgZm9yIHRoZSBh dWRpbyBpbnB1dCBzdWJzeXN0ZW0gZm91bmQKKwkgIGluIHRoZSBBbWxvZ2ljIEdYIFNvQyBmYW1p bHkuIEN1cnJlbnRseSBvbmx5IEkyUyBpbnB1dCBpcyBzdXBwb3J0ZWQuCisKIGNvbmZpZyBTTkRf TUVTT05fQVhHX0ZJRk8KIAl0cmlzdGF0ZQogCXNlbGVjdCBSRUdNQVBfTU1JTwpAQCAtMTA4LDYg KzExNiw3IEBAIGNvbmZpZyBTTkRfTUVTT05fR1hfU09VTkRfQ0FSRAogCXRyaXN0YXRlICJBbWxv Z2ljIEdYIFNvdW5kIENhcmQgU3VwcG9ydCIKIAlzZWxlY3QgU05EX01FU09OX0NBUkRfVVRJTFMK IAlpbXBseSBTTkRfTUVTT05fQUlVCisJaW1wbHkgU05EX01FU09OX0FVRElOCiAJaGVscAogCSAg U2VsZWN0IFkgb3IgTSB0byBhZGQgc3VwcG9ydCBmb3IgdGhlIEdYQkIvR1hMIFNvQyBzb3VuZCBj YXJkCiAKZGlmZiAtLWdpdCBhL3NvdW5kL3NvYy9tZXNvbi9NYWtlZmlsZSBiL3NvdW5kL3NvYy9t ZXNvbi9NYWtlZmlsZQppbmRleCBmOWVjMGViYjAxZjAuLjZhMDZhN2IyNmU2MSAxMDA2NDQKLS0t IGEvc291bmQvc29jL21lc29uL01ha2VmaWxlCisrKyBiL3NvdW5kL3NvYy9tZXNvbi9NYWtlZmls ZQpAQCAtMTAsNiArMTAsOCBAQCBzbmQtc29jLW1lc29uLWFpdS15ICs9IGFpdS1lbmNvZGVyLXNw ZGlmLm8KIHNuZC1zb2MtbWVzb24tYWl1LXkgKz0gYWl1LWZpZm8ubwogc25kLXNvYy1tZXNvbi1h aXUteSArPSBhaXUtZmlmby1pMnMubwogc25kLXNvYy1tZXNvbi1haXUteSArPSBhaXUtZmlmby1z cGRpZi5vCitzbmQtc29jLW1lc29uLWF1ZGluLXkgOj0gYXVkaW4ubworc25kLXNvYy1tZXNvbi1h dWRpbi15ICs9IGF1ZGluLWZvcm1hdHRlci1pMnMubwogc25kLXNvYy1tZXNvbi1heGctZmlmby15 IDo9IGF4Zy1maWZvLm8KIHNuZC1zb2MtbWVzb24tYXhnLWZyZGRyLXkgOj0gYXhnLWZyZGRyLm8K IHNuZC1zb2MtbWVzb24tYXhnLXRvZGRyLXkgOj0gYXhnLXRvZGRyLm8KQEAgLTI5LDYgKzMxLDcg QEAgc25kLXNvYy1tZXNvbi1nMTJhLXRvaGRtaXR4LXkgOj0gZzEyYS10b2hkbWl0eC5vCiBzbmQt c29jLW1lc29uLXQ5MDE1LXkgOj0gdDkwMTUubwogCiBvYmotJChDT05GSUdfU05EX01FU09OX0FJ VSkgKz0gc25kLXNvYy1tZXNvbi1haXUubworb2JqLSQoQ09ORklHX1NORF9NRVNPTl9BVURJTikg Kz0gc25kLXNvYy1tZXNvbi1hdWRpbi5vCiBvYmotJChDT05GSUdfU05EX01FU09OX0FYR19GSUZP KSArPSBzbmQtc29jLW1lc29uLWF4Zy1maWZvLm8KIG9iai0kKENPTkZJR19TTkRfTUVTT05fQVhH X0ZSRERSKSArPSBzbmQtc29jLW1lc29uLWF4Zy1mcmRkci5vCiBvYmotJChDT05GSUdfU05EX01F U09OX0FYR19UT0REUikgKz0gc25kLXNvYy1tZXNvbi1heGctdG9kZHIubwpkaWZmIC0tZ2l0IGEv c291bmQvc29jL21lc29uL2F1ZGluLWZvcm1hdHRlci1pMnMuYyBiL3NvdW5kL3NvYy9tZXNvbi9h dWRpbi1mb3JtYXR0ZXItaTJzLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAw MDAwLi44YmJiNWNkYjUyZGMKLS0tIC9kZXYvbnVsbAorKysgYi9zb3VuZC9zb2MvbWVzb24vYXVk aW4tZm9ybWF0dGVyLWkycy5jCkBAIC0wLDAgKzEsMTc0IEBACisvLyBTUERYLUxpY2Vuc2UtSWRl bnRpZmllcjogR1BMLTIuMAorLy8KKy8vIENvcHlyaWdodCAoYykgMjAyNiBCYXlMaWJyZSwgU0FT LgorLy8gQXV0aG9yOiBWYWxlcmlvIFNldHRpIDx2c2V0dGlAYmF5bGlicmUuY29tPgorCisjaW5j bHVkZSA8bGludXgvYml0ZmllbGQuaD4KKyNpbmNsdWRlIDxsaW51eC9yZWdtYXAuaD4KKyNpbmNs dWRlIDxzb3VuZC9zb2MuaD4KKyNpbmNsdWRlIDxzb3VuZC9zb2MtZGFpLmg+CisKKyNpbmNsdWRl ICJhdWRpbi5oIgorI2luY2x1ZGUgImd4LWZvcm1hdHRlci5oIgorCisvKiBJMlNJTl9DVFJMIHJl Z2lzdGVyIGFuZCBiaXRzICovCisjZGVmaW5lIEFVRElOX0kyU0lOX0NUUkwJCQkweDQwCisjZGVm aW5lICBBVURJTl9JMlNJTl9DVFJMX0kyU0lOX0RJUgkJQklUKDApCisjZGVmaW5lICBBVURJTl9J MlNJTl9DVFJMX0kyU0lOX0NMS19TRUwJCUJJVCgxKQorI2RlZmluZSAgQVVESU5fSTJTSU5fQ1RS TF9JMlNJTl9MUkNMS19TRUwJQklUKDIpCisjZGVmaW5lICBBVURJTl9JMlNJTl9DVFJMX0kyU0lO X0JDTEtfSU5WCUJJVCgzKQorI2RlZmluZSAgQVVESU5fSTJTSU5fQ1RSTF9JMlNJTl9MUkNMS19T S0VXX01BU0sJR0VOTUFTSyg2LCA0KQorI2RlZmluZSAgQVVESU5fSTJTSU5fQ1RSTF9JMlNJTl9M UkNMS19JTlYJQklUKDcpCisjZGVmaW5lICBBVURJTl9JMlNJTl9DVFJMX0kyU0lOX1NJWkVfTUFT SwlHRU5NQVNLKDksIDgpCisjZGVmaW5lICBBVURJTl9JMlNJTl9DVFJMX0kyU0lOX0NIQU5fRU5f TUFTSwlHRU5NQVNLKDEzLCAxMCkKKyNkZWZpbmUgIEFVRElOX0kyU0lOX0NUUkxfSTJTSU5fRU4J CUJJVCgxNSkKKworc3RhdGljIHN0cnVjdCBzbmRfc29jX2RhaSAqCithdWRpbl9mb3JtYXR0ZXJf aTJzX2dldF9iZShzdHJ1Y3Qgc25kX3NvY19kYXBtX3dpZGdldCAqdykKK3sKKwlzdHJ1Y3Qgc25k X3NvY19kYXBtX3BhdGggKnA7CisJc3RydWN0IHNuZF9zb2NfZGFpICpiZTsKKworCXNuZF9zb2Nf ZGFwbV93aWRnZXRfZm9yX2VhY2hfc291cmNlX3BhdGgodywgcCkgeworCQlpZiAoIXAtPmNvbm5l Y3QpCisJCQljb250aW51ZTsKKworCQlpZiAocC0+c291cmNlLT5pZCA9PSBzbmRfc29jX2RhcG1f ZGFpX291dCkKKwkJCXJldHVybiAoc3RydWN0IHNuZF9zb2NfZGFpICopcC0+c291cmNlLT5wcml2 OworCisJCWJlID0gYXVkaW5fZm9ybWF0dGVyX2kyc19nZXRfYmUocC0+c291cmNlKTsKKwkJaWYg KGJlKQorCQkJcmV0dXJuIGJlOworCX0KKworCXJldHVybiBOVUxMOworfQorCitzdGF0aWMgc3Ry dWN0IGd4X3N0cmVhbSAqCithdWRpbl9mb3JtYXR0ZXJfaTJzX2dldF9zdHJlYW0oc3RydWN0IHNu ZF9zb2NfZGFwbV93aWRnZXQgKncpCit7CisJc3RydWN0IHNuZF9zb2NfZGFpICpiZSA9IGF1ZGlu X2Zvcm1hdHRlcl9pMnNfZ2V0X2JlKHcpOworCisJaWYgKCFiZSkKKwkJcmV0dXJuIE5VTEw7CisK KwlyZXR1cm4gc25kX3NvY19kYWlfZG1hX2RhdGFfZ2V0X2NhcHR1cmUoYmUpOworfQorCitzdGF0 aWMgdm9pZCBhdWRpbl9mb3JtYXR0ZXJfaTJzX2VuYWJsZShzdHJ1Y3QgcmVnbWFwICptYXApCit7 CisJcmVnbWFwX3VwZGF0ZV9iaXRzKG1hcCwgQVVESU5fSTJTSU5fQ1RSTCwKKwkJCSAgIEFVRElO X0kyU0lOX0NUUkxfSTJTSU5fRU4sCisJCQkgICBBVURJTl9JMlNJTl9DVFJMX0kyU0lOX0VOKTsK K30KKworc3RhdGljIHZvaWQgYXVkaW5fZm9ybWF0dGVyX2kyc19kaXNhYmxlKHN0cnVjdCByZWdt YXAgKm1hcCkKK3sKKwlyZWdtYXBfdXBkYXRlX2JpdHMobWFwLCBBVURJTl9JMlNJTl9DVFJMLAor CQkJICAgQVVESU5fSTJTSU5fQ1RSTF9JMlNJTl9FTiwgMCk7Cit9CisKK3N0YXRpYyBpbnQgYXVk aW5fZm9ybWF0dGVyX2kyc19wcmVwYXJlKHN0cnVjdCByZWdtYXAgKm1hcCwKKwkJCQkgICAgICAg Y29uc3Qgc3RydWN0IGd4X2Zvcm1hdHRlcl9odyAqcXVpcmtzLAorCQkJCSAgICAgICBzdHJ1Y3Qg Z3hfc3RyZWFtICp0cykKK3sKKwl1bnNpZ25lZCBpbnQgdmFsOworCWludCByZXQ7CisKKwkvKgor CSAqIEkyUyBkZWNvZGVyIGFsd2F5cyBvdXRwdXRzIDI0IGJpdHMgdG8gdGhlIEZJRk8gYWNjb3Jk aW5nIHRvIHRoZQorCSAqIG1hbnVhbC4gVGhlIG9ubHkgdGhpbmcgd2UgY2FuIGNoYW5nZSB0aHJv dWdoCisJICogQVVESU5fSTJTSU5fQ1RSTF9JMlNJTl9TSVpFX01BU0sgaXMgdGhlIGZvbGxvd2lu ZzoKKwkgKiAtIDAgLT4gb3V0cHV0WzIzOjBdID0ge29yaWdpbmFsWzIzOjhdLDjigJlkMH0KKwkg KiAtIDEgLT4gb3V0cHV0WzIzOjBdID0ge29yaWdpbmFsWzIzOjZdLDbigJlkMH0KKwkgKiAtIDIg LT4gb3V0cHV0WzIzOjBdID0ge29yaWdpbmFsWzIzOjRdLDTigJlkMH0KKwkgKiAtIDMgLT4gb3V0 cHV0WzIzOjBdID0ge29yaWdpbmFsWzIzOjBdfQorCSAqCisJICogV2UgdXNlIDMgaGVyZSBhbmQs IGluIGNhc2Ugb2YgMTYgYml0IGZvcm1hdCwgd2UgZmlsdGVyIHVubmVjZXNzYXJ5CisJICogYnl0 ZXMgYXQgRklGTyBzdGFnZS4KKwkgKiBOb3RlOiBkYXRhIGlzIGxlZnQtanVzdGlmaWVkLCBzbyBp biBjYXNlIG9mIDE2IGJpdHMgc2FtcGxlcywgdGhpcworCSAqICAgICAgIG1lYW5zIHRoYXQgdGhl IExTQiBpcyB0byBiZSBkaXNjYXJkZWQgYXQgRklGTyBsZXZlbCBhbmQgdGhlCisJICogICAgICAg cmVsZXZhbnQgcGFydCBpcyBpbiBiaXRzIFsyMzo4XS4KKwkgKi8KKwl2YWwgPSBGSUVMRF9QUkVQ KEFVRElOX0kyU0lOX0NUUkxfSTJTSU5fU0laRV9NQVNLLCAzKTsKKwlyZXQgPSByZWdtYXBfdXBk YXRlX2JpdHMobWFwLCBBVURJTl9JMlNJTl9DVFJMLAorCQkJCSBBVURJTl9JMlNJTl9DVFJMX0ky U0lOX1NJWkVfTUFTSywgdmFsKTsKKwlpZiAocmV0KQorCQlyZXR1cm4gcmV0OworCisJLyoKKwkg KiBUaGUgbWFudWFsIGNsYWltcyB0aGF0IHRoaXMgcGxhdGZvcm0gc3VwcG9ydHMgdXAgdG8gNCBz dHJlYW1zCisJICogKDggY2hhbm5lbHMpLCBidXQgY3VycmVudGx5IG9ubHkgMSBzdHJlYW0gKDIg Y2hhbm5lbHMpIGhhcyBiZWVuCisJICogdGVzdGVkIGFuZCBpdCdzIHN1cHBvcnRlZC4KKwkgKi8K Kwl2YWwgPSBGSUVMRF9QUkVQKEFVRElOX0kyU0lOX0NUUkxfSTJTSU5fQ0hBTl9FTl9NQVNLLCAx KTsKKwlyZXQgPSByZWdtYXBfdXBkYXRlX2JpdHMobWFwLCBBVURJTl9JMlNJTl9DVFJMLAorCQkJ CSBBVURJTl9JMlNJTl9DVFJMX0kyU0lOX0NIQU5fRU5fTUFTSywgdmFsKTsKKwlpZiAocmV0KQor CQlyZXR1cm4gcmV0OworCisJLyoKKwkgKiBVc2UgY2xvY2tzIGZyb20gQUlVIGFuZCBub3QgZnJv bSB0aGUgcGFkcyBzaW5jZSB3ZSBvbmx5IHdhbnQgdG8KKwkgKiBzdXBwb3J0IG1hc3RlciBtb2Rl LgorCSAqLworCXZhbCA9IEFVRElOX0kyU0lOX0NUUkxfSTJTSU5fQ0xLX1NFTCB8CisJICAgICAg QVVESU5fSTJTSU5fQ1RSTF9JMlNJTl9MUkNMS19TRUwgfAorCSAgICAgIEFVRElOX0kyU0lOX0NU UkxfSTJTSU5fRElSOworCXJldCA9IHJlZ21hcF91cGRhdGVfYml0cyhtYXAsIEFVRElOX0kyU0lO X0NUUkwsIHZhbCwgdmFsKTsKKwlpZiAocmV0KQorCQlyZXR1cm4gcmV0OworCisJc3dpdGNoICh0 cy0+aWZhY2UtPmZtdCAmIFNORF9TT0NfREFJRk1UX0lOVl9NQVNLKSB7CisJY2FzZSBTTkRfU09D X0RBSUZNVF9JQl9ORjoKKwkJdmFsID0gQVVESU5fSTJTSU5fQ1RSTF9JMlNJTl9CQ0xLX0lOVjsK KwkJYnJlYWs7CisJY2FzZSBTTkRfU09DX0RBSUZNVF9OQl9JRjoKKwkJdmFsID0gQVVESU5fSTJT SU5fQ1RSTF9JMlNJTl9MUkNMS19JTlY7CisJCWJyZWFrOworCWNhc2UgU05EX1NPQ19EQUlGTVRf SUJfSUY6CisJCXZhbCA9IEFVRElOX0kyU0lOX0NUUkxfSTJTSU5fQkNMS19JTlYgfCBBVURJTl9J MlNJTl9DVFJMX0kyU0lOX0xSQ0xLX0lOVjsKKwkJYnJlYWs7CisJY2FzZSBTTkRfU09DX0RBSUZN VF9OQl9ORjoKKwkJdmFsID0gMDsKKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJcmV0dXJuIC1FSU5W QUw7CisJfQorCisJcmV0ID0gcmVnbWFwX3VwZGF0ZV9iaXRzKG1hcCwgQVVESU5fSTJTSU5fQ1RS TCwKKwkJCQkgQVVESU5fSTJTSU5fQ1RSTF9JMlNJTl9MUkNMS19JTlYgfAorCQkJCSBBVURJTl9J MlNJTl9DVFJMX0kyU0lOX0JDTEtfSU5WLCB2YWwpOworCWlmIChyZXQpCisJCXJldHVybiByZXQ7 CisKKwlzd2l0Y2ggKHRzLT5pZmFjZS0+Zm10ICYgU05EX1NPQ19EQUlGTVRfRk9STUFUX01BU0sp IHsKKwljYXNlIFNORF9TT0NfREFJRk1UX0kyUzoKKwkJdmFsID0gMTsKKwkJYnJlYWs7CisJY2Fz ZSBTTkRfU09DX0RBSUZNVF9MRUZUX0o6CisJCXZhbCA9IDA7CisJCWJyZWFrOworCWRlZmF1bHQ6 CisJCXJldHVybiAtRUlOVkFMOworCX0KKworCXZhbCA9IEZJRUxEX1BSRVAoQVVESU5fSTJTSU5f Q1RSTF9JMlNJTl9MUkNMS19TS0VXX01BU0ssIHZhbCk7CisJcmV0ID0gcmVnbWFwX3VwZGF0ZV9i aXRzKG1hcCwgQVVESU5fSTJTSU5fQ1RSTCwKKwkJCQkgQVVESU5fSTJTSU5fQ1RSTF9JMlNJTl9M UkNMS19TS0VXX01BU0ssCisJCQkJIHZhbCk7CisJaWYgKHJldCkKKwkJcmV0dXJuIHJldDsKKwor CXJldHVybiAwOworfQorCitzdGF0aWMgY29uc3Qgc3RydWN0IGd4X2Zvcm1hdHRlcl9vcHMgYXVk aW5fZm9ybWF0dGVyX2kyc19vcHMgPSB7CisJLmdldF9zdHJlYW0JPSBhdWRpbl9mb3JtYXR0ZXJf aTJzX2dldF9zdHJlYW0sCisJLnByZXBhcmUJPSBhdWRpbl9mb3JtYXR0ZXJfaTJzX3ByZXBhcmUs CisJLmVuYWJsZQkJPSBhdWRpbl9mb3JtYXR0ZXJfaTJzX2VuYWJsZSwKKwkuZGlzYWJsZQk9IGF1 ZGluX2Zvcm1hdHRlcl9pMnNfZGlzYWJsZSwKK307CisKK2NvbnN0IHN0cnVjdCBneF9mb3JtYXR0 ZXJfZHJpdmVyIGF1ZGluX2Zvcm1hdHRlcl9pMnNfZHJ2ID0geworCS5vcHMJCT0gJmF1ZGluX2Zv cm1hdHRlcl9pMnNfb3BzLAorfTsKZGlmZiAtLWdpdCBhL3NvdW5kL3NvYy9tZXNvbi9hdWRpbi5j IGIvc291bmQvc29jL21lc29uL2F1ZGluLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAw MDAwMDAwMDAwLi5lODA3MTMyMzQzMmIKLS0tIC9kZXYvbnVsbAorKysgYi9zb3VuZC9zb2MvbWVz b24vYXVkaW4uYwpAQCAtMCwwICsxLDEwOSBAQAorLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6 IEdQTC0yLjAKKy8vCisvLyBDb3B5cmlnaHQgKGMpIDIwMjYgQmF5TGlicmUsIFNBUy4KKy8vIEF1 dGhvcjogVmFsZXJpbyBTZXR0aSA8dnNldHRpQGJheWxpYnJlLmNvbT4KKworI2luY2x1ZGUgPGxp bnV4L2Nsay5oPgorI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgorI2luY2x1ZGUgPGxpbnV4L21v ZF9kZXZpY2V0YWJsZS5oPgorI2luY2x1ZGUgPGxpbnV4L29mX3BsYXRmb3JtLmg+CisjaW5jbHVk ZSA8bGludXgvcGxhdGZvcm1fZGV2aWNlLmg+CisjaW5jbHVkZSA8bGludXgvcmVnbWFwLmg+Cisj aW5jbHVkZSA8bGludXgvcmVzZXQuaD4KKyNpbmNsdWRlIDxzb3VuZC9zb2MuaD4KKworI2luY2x1 ZGUgImF1ZGluLmgiCisjaW5jbHVkZSAiZ3gtZm9ybWF0dGVyLmgiCisKK3N0YXRpYyBzdHJ1Y3Qg c25kX3NvY19kYXBtX3dpZGdldCBhdWRpbl9kYXBtX3dpZGdldHNbXSA9IHsKKwlTTkRfU09DX0RB UE1fUEdBX0UoIkkyUyBGb3JtYXR0ZXIiLCBTTkRfU09DX05PUE0sIDAsIDAsIE5VTEwsIDAsCisJ CQkgICBneF9mb3JtYXR0ZXJfZXZlbnQsCisJCQkgICAoU05EX1NPQ19EQVBNX1BSRV9QTVUgfCBT TkRfU09DX0RBUE1fUFJFX1BNRCkpLAorfTsKKworc3RhdGljIGNvbnN0IHN0cnVjdCBzbmRfc29j X2NvbXBvbmVudF9kcml2ZXIgYXVkaW5fY29tcG9uZW50ID0geworCS5kYXBtX3dpZGdldHMJCT0g YXVkaW5fZGFwbV93aWRnZXRzLAorCS5udW1fZGFwbV93aWRnZXRzCT0gQVJSQVlfU0laRShhdWRp bl9kYXBtX3dpZGdldHMpLAorfTsKKworc3RhdGljIGNvbnN0IHN0cnVjdCByZWdtYXBfY29uZmln IGF1ZGluX3JlZ21hcF9jZmcgPSB7CisJLnJlZ19iaXRzCT0gMzIsCisJLnZhbF9iaXRzCT0gMzIs CisJLnJlZ19zdHJpZGUJPSA0LAorCS5tYXhfcmVnaXN0ZXIJPSAweDMwNCwKK307CisKK3N0YXRp YyBpbnQgbWVzb25fZ3hfYXVkaW5fcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikK K3sKKwlzdHJ1Y3QgZGV2aWNlICpkZXYgPSAmcGRldi0+ZGV2OworCXN0cnVjdCByZXNvdXJjZSAq cmVzOworCXZvaWQgX19pb21lbSAqbW1pbzsKKwlzdHJ1Y3QgcmVnbWFwICpyZWdtYXA7CisJc3Ry dWN0IGNsayAqY2xrOworCWludCByZXQ7CisKKwlyZXQgPSBkZXZpY2VfcmVzZXQoZGV2KTsKKwlp ZiAocmV0KQorCQlyZXR1cm4gZGV2X2Vycl9wcm9iZShkZXYsIHJldCwgIkZhaWxlZCB0byByZXNl dCBkZXZpY2VcbiIpOworCisJcmVzID0gcGxhdGZvcm1fZ2V0X3Jlc291cmNlKHBkZXYsIElPUkVT T1VSQ0VfTUVNLCAwKTsKKwlpZiAoIXJlcykKKwkJcmV0dXJuIGRldl9lcnJfcHJvYmUoZGV2LCAt RUlOVkFMLCAiRmFpbGVkIHRvIGdldCBtZW1vcnkgcmVzb3VyY2VcbiIpOworCisJLyoKKwkgKiBE byBub3QgdXNlIGRldm1fcGxhdGZvcm1faW9yZW1hcF9yZXNvdXJjZSgpIGhlcmU6IGl0IHdvdWxk IGNsYWltIHRoZQorCSAqIHdob2xlIEFVRElOIHdpbmRvdyBleGNsdXNpdmVseSBhbmQgdGhlIEZJ Rk8gY2hpbGRyZW4gd291bGQgdGhlbiBmYWlsCisJICogdG8gcmVxdWVzdCB0aGVpciBvd24gc3Vi LXJhbmdlcy4KKwkgKi8KKwltbWlvID0gZGV2bV9pb3JlbWFwKGRldiwgcmVzLT5zdGFydCwgcmVz b3VyY2Vfc2l6ZShyZXMpKTsKKwlpZiAoIW1taW8pCisJCXJldHVybiBkZXZfZXJyX3Byb2JlKGRl diwgLUVOT01FTSwgIkZhaWxlZCB0byByZW1hcCBtZW1vcnlcbiIpOworCisJcmVnbWFwID0gZGV2 bV9yZWdtYXBfaW5pdF9tbWlvKGRldiwgbW1pbywgJmF1ZGluX3JlZ21hcF9jZmcpOworCWlmIChJ U19FUlIocmVnbWFwKSkKKwkJcmV0dXJuIGRldl9lcnJfcHJvYmUoZGV2LCBQVFJfRVJSKHJlZ21h cCksICJGYWlsZWQgdG8gaW5pdCByZWdtYXBcbiIpOworCisJY2xrID0gZGV2bV9jbGtfZ2V0X2Vu YWJsZWQoZGV2LCBOVUxMKTsKKwlpZiAoSVNfRVJSKGNsaykpCisJCXJldHVybiBkZXZfZXJyX3By b2JlKGRldiwgUFRSX0VSUihjbGspLCAiRmFpbGVkIHRvIGdldCBjbG9ja1xuIik7CisKKwlyZXQg PSBneF9mb3JtYXR0ZXJfY3JlYXRlKGRldiwgJmF1ZGluX2RhcG1fd2lkZ2V0c1swXSwgJmF1ZGlu X2Zvcm1hdHRlcl9pMnNfZHJ2LCByZWdtYXApOworCWlmIChyZXQpCisJCXJldHVybiBkZXZfZXJy X3Byb2JlKGRldiwgcmV0LCAiRmFpbGVkIHRvIGFsbG9jYXRlIGZvcm1hdHRlclxuIik7CisKKwly ZXQgPSBkZXZtX3NuZF9zb2NfcmVnaXN0ZXJfY29tcG9uZW50KGRldiwgJmF1ZGluX2NvbXBvbmVu dCwgTlVMTCwgMCk7CisJaWYgKHJldCkKKwkJcmV0dXJuIGRldl9lcnJfcHJvYmUoZGV2LCByZXQs ICJGYWlsZWQgdG8gcmVnaXN0ZXIgY29tcG9uZW50XG4iKTsKKworCXJldCA9IGRldm1fb2ZfcGxh dGZvcm1fcG9wdWxhdGUoZGV2KTsKKwlpZiAocmV0KQorCQlyZXR1cm4gZGV2X2Vycl9wcm9iZShk ZXYsIHJldCwgIkZhaWxlZCB0byBwcm9iZSBjaGlsZCBub2Rlc1xuIik7CisKKwlyZXR1cm4gMDsK K30KKworc3RhdGljIHZvaWQgbWVzb25fZ3hfYXVkaW5fcmVtb3ZlKHN0cnVjdCBwbGF0Zm9ybV9k ZXZpY2UgKnBkZXYpCit7CisJZ3hfZm9ybWF0dGVyX2ZyZWUoJmF1ZGluX2RhcG1fd2lkZ2V0c1sw XSk7Cit9CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgb2ZfZGV2aWNlX2lkIG1lc29uX2d4X2F1ZGlu X29mX21hdGNoW10gPSB7CisJeyAuY29tcGF0aWJsZSA9ICJhbWxvZ2ljLG1lc29uLWd4YmItYXVk aW4iIH0sCisJeyAuY29tcGF0aWJsZSA9ICJhbWxvZ2ljLG1lc29uLWd4bC1hdWRpbiIgfSwKKwl7 fQorfTsKK01PRFVMRV9ERVZJQ0VfVEFCTEUob2YsIG1lc29uX2d4X2F1ZGluX29mX21hdGNoKTsK Kworc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kcml2ZXIgbWVzb25fZ3hfYXVkaW5fZHJpdmVyID0g eworCS5kcml2ZXIgPSB7CisJCS5uYW1lID0gIm1lc29uLWd4LWF1ZGluIiwKKwkJLm9mX21hdGNo X3RhYmxlID0gbWVzb25fZ3hfYXVkaW5fb2ZfbWF0Y2gsCisJfSwKKwkucHJvYmUgPSBtZXNvbl9n eF9hdWRpbl9wcm9iZSwKKwkucmVtb3ZlID0gbWVzb25fZ3hfYXVkaW5fcmVtb3ZlLAorfTsKK21v ZHVsZV9wbGF0Zm9ybV9kcml2ZXIobWVzb25fZ3hfYXVkaW5fZHJpdmVyKTsKKworTU9EVUxFX0RF U0NSSVBUSU9OKCJNZXNvbiBHWCBBVURJTiBkcml2ZXIiKTsKK01PRFVMRV9BVVRIT1IoIlZhbGVy aW8gU2V0dGkgPHZzZXR0aUBiYXlsaWJyZS5jb20+Iik7CitNT0RVTEVfTElDRU5TRSgiR1BMIik7 CmRpZmYgLS1naXQgYS9zb3VuZC9zb2MvbWVzb24vYXVkaW4uaCBiL3NvdW5kL3NvYy9tZXNvbi9h dWRpbi5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uMjk5NjFlMTgx OTBmCi0tLSAvZGV2L251bGwKKysrIGIvc291bmQvc29jL21lc29uL2F1ZGluLmgKQEAgLTAsMCAr MSwxNCBAQAorLyogU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IChHUEwtMi4wIE9SIE1JVCkgKi8K Ky8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMjYgQmF5TGlicmUsIFNBUy4KKyAqIEF1dGhvcjogVmFs ZXJpbyBTZXR0aSA8dnNldHRpQGJheWxpYnJlLmNvbT4KKyAqLworCisjaWZuZGVmIF9NRVNPTl9B VURJTl9ICisjZGVmaW5lIF9NRVNPTl9BVURJTl9ICisKKyNpbmNsdWRlICJneC1mb3JtYXR0ZXIu aCIKKworZXh0ZXJuIGNvbnN0IHN0cnVjdCBneF9mb3JtYXR0ZXJfZHJpdmVyIGF1ZGluX2Zvcm1h dHRlcl9pMnNfZHJ2OworCisjZW5kaWYKCi0tIAoyLjQ3LjMKCgpfX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fXwpsaW51eC1hbWxvZ2ljIG1haWxpbmcgbGlzdAps aW51eC1hbWxvZ2ljQGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5v cmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1hbWxvZ2ljCg==