From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id E79DE3F7A80; Thu, 26 Mar 2026 11:58:53 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1774526334; cv=none; b=W6Qz+g4hGtuE1AddvLz9m/sQMEnr4vTs3FiVDsMUUtCSA5QggCujetFSdwCFBSXXXWgl8iqBuvEUIGN72s2DABy+W3TwkhAKhPiKpJGSt+Ha5rEhfoIFtg+4vJ1F4wiUbxiU0hgMOM85jWmG9MF8uaknz8OjTV3d+t4wbPLqjvw= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1774526334; c=relaxed/simple; bh=aJGxEH6abHvJG1/YDdFthINX7UFKbe9YYLe2cTfN8JY=; h=Date:From:To:Cc:Subject:Message-ID:References:MIME-Version: Content-Type:Content-Disposition:In-Reply-To; b=GPVN0IVrTE+u0Ipj5zNvmFy7lRO5yUgMewKR6kYDq/rA+zk/sKvMAX86ueNXYZMENn9u+imAMGlroYiOGYyBsDqvGyG59V9HTZub5W4mvwqnHM8/9Qalh6Ny5CEJWwU1ItH7oKfc/uLEO9YqjOlH0QqMfMD8UJol+ZzsFfrSgNo= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=M9C2ASmk; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="M9C2ASmk" Received: by smtp.kernel.org (Postfix) with ESMTPSA id E35DDC2BC87; Thu, 26 Mar 2026 11:58:50 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1774526333; bh=aJGxEH6abHvJG1/YDdFthINX7UFKbe9YYLe2cTfN8JY=; h=Date:From:To:Cc:Subject:References:In-Reply-To:From; b=M9C2ASmkZQq9/XXTxASyRFE2mDv8+QRWNRzMnAxtFGkmxxmXOG715QRrpk7d5LWxa rEwXdG2HIq9A6WJhnkFUIP5XyFxn1M9NnDAGI64PZSAZ8LTDOeFCe5ngVISffDQqC3 QaIarLkfwyKLHu925Gp0U25INxQXe6DhyFfWSPr307g0L/NTtbzYcWonkVzyS6YFRH jLfwGaba45JnpYQWAl1aDqdOdNoub28c979w9F09Tb8mWSwisMo27EYZht5ZXOictm bW0uTgP1Fgdmi92+wVK+t8y772/64rw2uOxwCYPgj0bQdkUWRDzKsrTCepNNcYCCZg 0QcoLRTXjpAUA== Date: Thu, 26 Mar 2026 11:58:48 +0000 From: Lee Jones To: Lakshay Piplani Cc: linux-kernel@vger.kernel.org, linux-i3c@lists.infradead.org, alexandre.belloni@bootlin.com, krzk+dt@kernel.org, robh@kernel.org, conor+dt@kernel.org, devicetree@vger.kernel.org, broonie@kernel.org, Frank.Li@nxp.com, lgirdwood@gmail.com, vikash.bansal@nxp.com, priyanka.jain@nxp.com, aman.kumarpandey@nxp.com Subject: Re: [PATCH v7 4/7] mfd: p3h2x4x: Add driver for NXP P3H2x4x i3c hub and on-die regulator Message-ID: <20260326115848.GL1141718@google.com> References: <20260319112441.3888957-1-lakshay.piplani@nxp.com> <20260319112441.3888957-5-lakshay.piplani@nxp.com> Precedence: bulk X-Mailing-List: devicetree@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <20260319112441.3888957-5-lakshay.piplani@nxp.com> On Thu, 19 Mar 2026, Lakshay Piplani wrote: > From: Aman Kumar Pandey > > Add core MFD support for the NXP P3H2x4x (P3H2440/P3H2441/P3H2840/P3H2841) > family of multiport I3C hub devices. These devices connect to a host via > I3C/I2C/SMBus and expose multiple downstream target ports. > > Signed-off-by: Aman Kumar Pandey > Signed-off-by: Vikash Bansal > > --- > Changes in v7: > - Use new config I3C_OR_I2C > > Changes in v6: > - No change > > Changes in v5: > - Corrected the ordering in the Makefile and Kconfig for MFD_P3H2X4X > - Updated dev_err_probe() for regmap_init failure. > - Updated module description > > Changes in v4: > - Split the driver into three separate patches(mfd, regulator and I3C hub) > - Added support for NXP P3H2x4x MFD functionality > --- > --- One is enough. > MAINTAINERS | 2 + > drivers/mfd/Kconfig | 13 ++++ > drivers/mfd/Makefile | 1 + > drivers/mfd/p3h2840.c | 125 ++++++++++++++++++++++++++++++++++++ > include/linux/mfd/p3h2840.h | 27 ++++++++ > 5 files changed, 168 insertions(+) > create mode 100644 drivers/mfd/p3h2840.c > create mode 100644 include/linux/mfd/p3h2840.h > > diff --git a/MAINTAINERS b/MAINTAINERS > index c72976dbdf31..4f67fe64c833 100644 > --- a/MAINTAINERS > +++ b/MAINTAINERS > @@ -19101,6 +19101,8 @@ L: linux-kernel@vger.kernel.org > L: linux-i3c-owner@lists.infradead.org > S: Maintained > F: Documentation/devicetree/bindings/i3c/nxp,p3h2840.yaml > +F: drivers/mfd/p3h2840.c > +F: include/linux/mfd/p3h2840.h > > NXP PF5300/PF5301/PF5302 PMIC REGULATOR DEVICE DRIVER > M: Woodrow Douglass > diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig > index 7192c9d1d268..14f4736683a1 100644 > --- a/drivers/mfd/Kconfig > +++ b/drivers/mfd/Kconfig > @@ -617,6 +617,19 @@ config MFD_MX25_TSADC > i.MX25 processors. They consist of a conversion queue for general > purpose ADC and a queue for Touchscreens. > > +config MFD_P3H2X4X MFD_NXP_P3H2X4X > + tristate "NXP P3H2X4X I3C Hub Device" > + depends on I3C_OR_I2C > + select MFD_CORE > + select REGMAP_I3C > + select REGMAP_I2C > + help > + Enable Support for NXP P3H244x/P3H284x I3C HUB device using I3C/I2C > + communication interface. > + > + This driver provides support for I3C hub and regulator, each subdriver > + can be enabled independently depending on the required functionality. > + > config MFD_PF1550 > tristate "NXP PF1550 PMIC Support" > depends on I2C=y && OF > diff --git a/drivers/mfd/Makefile b/drivers/mfd/Makefile > index e75e8045c28a..aaadf50fedf4 100644 > --- a/drivers/mfd/Makefile > +++ b/drivers/mfd/Makefile > @@ -122,6 +122,7 @@ obj-$(CONFIG_MFD_MC13XXX) += mc13xxx-core.o > obj-$(CONFIG_MFD_MC13XXX_SPI) += mc13xxx-spi.o > obj-$(CONFIG_MFD_MC13XXX_I2C) += mc13xxx-i2c.o > > +obj-$(CONFIG_MFD_P3H2X4X) += p3h2840.o There is a mismatch in the naming here. Are we expressing the family or the specific device? > obj-$(CONFIG_MFD_PF1550) += pf1550.o > > obj-$(CONFIG_MFD_NCT6694) += nct6694.o > diff --git a/drivers/mfd/p3h2840.c b/drivers/mfd/p3h2840.c > new file mode 100644 > index 000000000000..65090a09f7c6 > --- /dev/null > +++ b/drivers/mfd/p3h2840.c > @@ -0,0 +1,125 @@ > +// SPDX-License-Identifier: GPL-2.0 > +/* > + * Copyright 2025 NXP Needs updating. Author(s)? > + * P3H2x4x i3c hub and regulator device. > + */ Could this comment be a little more descriptive? Something like: "Core driver for the NXP P3H2x4x family of I3C hubs." Drop the regular part. > +#include > +#include > +#include > +#include > +#include Please sort your `#include` directives alphabetically. > +static const struct mfd_cell p3h2x4x_devs[] = { > + { > + .name = "p3h2x4x-regulator", > + }, > + { > + .name = "p3h2x4x-i3c-hub", > + }, > +}; MFD_CELL_NAME() > +static const struct regmap_config p3h2x4x_regmap_config = { > + .reg_bits = P3H2x4x_REG_BITS, > + .val_bits = P3H2x4x_VAL_BITS, > + .max_register = 0xFF, > +}; > + > +static int p3h2x4x_device_probe_i3c(struct i3c_device *i3cdev) > +{ > + struct p3h2x4x_dev *p3h2x4x; > + int ret; > + > + p3h2x4x = devm_kzalloc(&i3cdev->dev, sizeof(*p3h2x4x), GFP_KERNEL); > + if (!p3h2x4x) > + return -ENOMEM; > + > + i3cdev_set_drvdata(i3cdev, p3h2x4x); No point in setting this until after its populated. > + p3h2x4x->regmap = devm_regmap_init_i3c(i3cdev, &p3h2x4x_regmap_config); > + if (IS_ERR(p3h2x4x->regmap)) > + return dev_err_probe(&i3cdev->dev, PTR_ERR(p3h2x4x->regmap), > + "Failed to register I3C HUB regmap\n"); This error message appears to be a copy-paste from the I2C probe function. Perhaps a more generic message like "Failed to initialise regmap" would be more appropriate for both contexts. > + > + p3h2x4x->is_p3h2x4x_in_i3c = true; This is superfluous. Just check `p3h2x4x->i3cdev`. > + p3h2x4x->i3cdev = i3cdev; > + > + ret = devm_mfd_add_devices(&i3cdev->dev, PLATFORM_DEVID_NONE, > + p3h2x4x_devs, ARRAY_SIZE(p3h2x4x_devs), > + NULL, 0, NULL); > + if (ret) > + return dev_err_probe(&i3cdev->dev, ret, "Failed to add sub devices\n"); > + > + return 0; > +} > + > +static int p3h2x4x_device_probe_i2c(struct i2c_client *client) > +{ > + struct p3h2x4x_dev *p3h2x4x; > + int ret; > + > + p3h2x4x = devm_kzalloc(&client->dev, sizeof(*p3h2x4x), GFP_KERNEL); > + if (!p3h2x4x) > + return -ENOMEM; > + > + i2c_set_clientdata(client, p3h2x4x); As above. > + p3h2x4x->regmap = devm_regmap_init_i2c(client, &p3h2x4x_regmap_config); > + if (IS_ERR(p3h2x4x->regmap)) > + return dev_err_probe(&client->dev, PTR_ERR(p3h2x4x->regmap), > + "Failed to register I3C HUB regmap\n"); I2C > + > + p3h2x4x->is_p3h2x4x_in_i3c = false; As above. > + ret = devm_mfd_add_devices(&client->dev, PLATFORM_DEVID_NONE, > + p3h2x4x_devs, ARRAY_SIZE(p3h2x4x_devs), > + NULL, 0, NULL); > + if (ret) > + return dev_err_probe(&client->dev, ret, "Failed to add sub devices\n"); > + > + return 0; > +} These two probe functions, `p3h2x4x_device_probe_i3c` and `p3h2x4x_device_probe_i2c`, are almost identical. Could they be refactored into a single common probe function to reduce code duplication? The bus-specific wrappers could handle the regmap initialisation and then call a shared `p3h2x4x_probe(struct device *dev, struct regmap *regmap)` function. > + > +/* p3h2x4x ids (i3c) */ > +static const struct i3c_device_id p3h2x4x_i3c_ids[] = { > + I3C_CLASS(I3C_DCR_HUB, NULL), > + { /* sentinel */ }, > +}; > +MODULE_DEVICE_TABLE(i3c, p3h2x4x_i3c_ids); > + > +/* p3h2x4x ids (i2c) */ > +static const struct i2c_device_id p3h2x4x_i2c_id_table[] = { > + { "nxp-i3c-hub" }, This is an MFD core driver, not just a hub driver. Perhaps a more suitable name would be "p3h2x4x"? > + { /* sentinel */ } > +}; > +MODULE_DEVICE_TABLE(i2c, p3h2x4x_i2c_id_table); > + > +static const struct of_device_id p3h2x4x_i2c_of_match[] = { > + { .compatible = "nxp,p3h2840", }, > + { /* sentinel */ } > +}; > + > +MODULE_DEVICE_TABLE(of, p3h2x4x_i2c_of_match); This should be adjacent to the struct above. > +static struct i3c_driver p3h2x4x_i3c = { > + .driver = { > + .name = "p3h2x4x_i3c_drv", "_drv" should be removed. > + }, > + .probe = p3h2x4x_device_probe_i3c, > + .id_table = p3h2x4x_i3c_ids, > +}; > + > +static struct i2c_driver p3h2x4x_i2c = { > + .driver = { > + .name = "p3h2x4x_i2c_drv", As above. > + .of_match_table = p3h2x4x_i2c_of_match, > + }, > + .probe = p3h2x4x_device_probe_i2c, > + .id_table = p3h2x4x_i2c_id_table, > +}; > + > +module_i3c_i2c_driver(p3h2x4x_i3c, &p3h2x4x_i2c); > + > +MODULE_AUTHOR("Aman Kumar Pandey "); > +MODULE_AUTHOR("Vikash Bansal "); Stick to having one of these and put two in the header comment. > +MODULE_DESCRIPTION("P3H2x4x I3C HUB multi function driver"); This could be more precise. How about: "NXP P3H2x4x I3C Hub core driver" Drop all mentions of MFD. It's not a real thing. > +MODULE_LICENSE("GPL"); > diff --git a/include/linux/mfd/p3h2840.h b/include/linux/mfd/p3h2840.h > new file mode 100644 > index 000000000000..cba6fa516d1e > --- /dev/null > +++ b/include/linux/mfd/p3h2840.h > @@ -0,0 +1,27 @@ > +/* SPDX-License-Identifier: GPL-2.0 */ > +/* > + * Copyright 2025 NXP > + * This header file contain private Reg address and its bit mapping etc. > + */ The comment is not a complete sentence and states the obvious. Please consider something more descriptive, for example: "Register definitions for the NXP P3H2x4x I3C Hub." > + > +#ifndef _LINUX_MFD_P3H2840_H > +#define _LINUX_MFD_P3H2840_H If the filenames are changed to `p3h2x4x.h` as suggested earlier, this header guard will need to be updated to `_LINUX_MFD_P3H2X4X_H`. > + > +#include > + > +/* Device Configuration Registers */ > +#define P3H2x4x_DEV_REG_PROTECTION_CODE 0x10 > +#define P3H2x4x_REGISTERS_LOCK_CODE 0x00 > +#define P3H2x4x_REGISTERS_UNLOCK_CODE 0x69 > +#define P3H2x4x_CP1_REGISTERS_UNLOCK_CODE 0x6a > + > +/* Reg config for Regmap */ > +#define P3H2x4x_REG_BITS 8 > +#define P3H2x4x_VAL_BITS 8 > + > +struct p3h2x4x_dev { > + struct i3c_device *i3cdev; > + struct regmap *regmap; > + bool is_p3h2x4x_in_i3c; > +}; Why are we storing i3c_device, but not i2c_device_id? -- Lee Jones [李琼斯] 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 2F89E10A3D7F for ; Thu, 26 Mar 2026 11:58:58 +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:In-Reply-To:MIME-Version:References: Message-ID:Subject:Cc:To:From:Date:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=Qwsm7wVSyCfxQykQ4+9AijkIey4g+7CxOg2I/O9BwWQ=; b=sztY6qsFBJscSB syF6XB2NunEG1uCMvr2C3a0HIWAKwMiw44+JkLqZazlhsx8c4PIZETUKpO1dfBqaBbi+2k8+B6Kpe HpkpoKuUSwDLslYk5jGgbHba755TqQjrlR6l8V3jrOqnw4HDzqAp5GzkePUhUy3yX3u6Y0qLrkjxK GuEG8fR4/j36C/XvD1myT6fMkvICe3s7CUrZZFMsUctEleVXJrZruF82WFFGypxPK2smB9bEgB7dT zVPU11YQr3VzXGSbcVQimLSdY0RCue8XSN+IUZrSd1ZmWeRen0snkdtaPzxrpA/xTDJ/1RuiGIln3 QGBa3J8YFA5170iztSUg==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.98.2 #2 (Red Hat Linux)) id 1w5jMX-00000005OOd-3rvZ; Thu, 26 Mar 2026 11:58:57 +0000 Received: from sea.source.kernel.org ([2600:3c0a:e001:78e:0:1991:8:25]) by bombadil.infradead.org with esmtps (Exim 4.98.2 #2 (Red Hat Linux)) id 1w5jMV-00000005OOC-0aEs for linux-i3c@lists.infradead.org; Thu, 26 Mar 2026 11:58:56 +0000 Received: from smtp.kernel.org (transwarp.subspace.kernel.org [100.75.92.58]) by sea.source.kernel.org (Postfix) with ESMTP id BF47B439BB; Thu, 26 Mar 2026 11:58:53 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id E35DDC2BC87; Thu, 26 Mar 2026 11:58:50 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1774526333; bh=aJGxEH6abHvJG1/YDdFthINX7UFKbe9YYLe2cTfN8JY=; h=Date:From:To:Cc:Subject:References:In-Reply-To:From; b=M9C2ASmkZQq9/XXTxASyRFE2mDv8+QRWNRzMnAxtFGkmxxmXOG715QRrpk7d5LWxa rEwXdG2HIq9A6WJhnkFUIP5XyFxn1M9NnDAGI64PZSAZ8LTDOeFCe5ngVISffDQqC3 QaIarLkfwyKLHu925Gp0U25INxQXe6DhyFfWSPr307g0L/NTtbzYcWonkVzyS6YFRH jLfwGaba45JnpYQWAl1aDqdOdNoub28c979w9F09Tb8mWSwisMo27EYZht5ZXOictm bW0uTgP1Fgdmi92+wVK+t8y772/64rw2uOxwCYPgj0bQdkUWRDzKsrTCepNNcYCCZg 0QcoLRTXjpAUA== Date: Thu, 26 Mar 2026 11:58:48 +0000 From: Lee Jones To: Lakshay Piplani Cc: linux-kernel@vger.kernel.org, linux-i3c@lists.infradead.org, alexandre.belloni@bootlin.com, krzk+dt@kernel.org, robh@kernel.org, conor+dt@kernel.org, devicetree@vger.kernel.org, broonie@kernel.org, Frank.Li@nxp.com, lgirdwood@gmail.com, vikash.bansal@nxp.com, priyanka.jain@nxp.com, aman.kumarpandey@nxp.com Subject: Re: [PATCH v7 4/7] mfd: p3h2x4x: Add driver for NXP P3H2x4x i3c hub and on-die regulator Message-ID: <20260326115848.GL1141718@google.com> References: <20260319112441.3888957-1-lakshay.piplani@nxp.com> <20260319112441.3888957-5-lakshay.piplani@nxp.com> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: <20260319112441.3888957-5-lakshay.piplani@nxp.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20260326_045855_225111_69ED2D71 X-CRM114-Status: GOOD ( 35.74 ) X-BeenThere: linux-i3c@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-i3c" Errors-To: linux-i3c-bounces+linux-i3c=archiver.kernel.org@lists.infradead.org T24gVGh1LCAxOSBNYXIgMjAyNiwgTGFrc2hheSBQaXBsYW5pIHdyb3RlOgoKPiBGcm9tOiBBbWFu IEt1bWFyIFBhbmRleSA8YW1hbi5rdW1hcnBhbmRleUBueHAuY29tPgo+IAo+IEFkZCBjb3JlIE1G RCBzdXBwb3J0IGZvciB0aGUgTlhQIFAzSDJ4NHggKFAzSDI0NDAvUDNIMjQ0MS9QM0gyODQwL1Az SDI4NDEpCj4gZmFtaWx5IG9mIG11bHRpcG9ydCBJM0MgaHViIGRldmljZXMuIFRoZXNlIGRldmlj ZXMgY29ubmVjdCB0byBhIGhvc3QgdmlhCj4gSTNDL0kyQy9TTUJ1cyBhbmQgZXhwb3NlIG11bHRp cGxlIGRvd25zdHJlYW0gdGFyZ2V0IHBvcnRzLgo+IAo+IFNpZ25lZC1vZmYtYnk6IEFtYW4gS3Vt YXIgUGFuZGV5IDxhbWFuLmt1bWFycGFuZGV5QG54cC5jb20+Cj4gU2lnbmVkLW9mZi1ieTogVmlr YXNoIEJhbnNhbCA8dmlrYXNoLmJhbnNhbEBueHAuY29tPgo+IAo+IC0tLQo+IENoYW5nZXMgaW4g djc6Cj4gIC0gVXNlIG5ldyBjb25maWcgSTNDX09SX0kyQwo+IAo+IENoYW5nZXMgaW4gdjY6Cj4g IC0gTm8gY2hhbmdlCj4gCj4gQ2hhbmdlcyBpbiB2NToKPiAgLSBDb3JyZWN0ZWQgdGhlIG9yZGVy aW5nIGluIHRoZSBNYWtlZmlsZSBhbmQgS2NvbmZpZyBmb3IgTUZEX1AzSDJYNFgKPiAgLSBVcGRh dGVkIGRldl9lcnJfcHJvYmUoKSBmb3IgcmVnbWFwX2luaXQgZmFpbHVyZS4KPiAgLSBVcGRhdGVk IG1vZHVsZSBkZXNjcmlwdGlvbgo+IAo+IENoYW5nZXMgaW4gdjQ6Cj4gIC0gU3BsaXQgdGhlIGRy aXZlciBpbnRvIHRocmVlIHNlcGFyYXRlIHBhdGNoZXMobWZkLCByZWd1bGF0b3IgYW5kIEkzQyBo dWIpCj4gIC0gQWRkZWQgc3VwcG9ydCBmb3IgTlhQIFAzSDJ4NHggTUZEIGZ1bmN0aW9uYWxpdHkK PiAtLS0KPiAtLS0KCk9uZSBpcyBlbm91Z2guCgo+ICBNQUlOVEFJTkVSUyAgICAgICAgICAgICAg ICAgfCAgIDIgKwo+ICBkcml2ZXJzL21mZC9LY29uZmlnICAgICAgICAgfCAgMTMgKysrKwo+ICBk cml2ZXJzL21mZC9NYWtlZmlsZSAgICAgICAgfCAgIDEgKwo+ICBkcml2ZXJzL21mZC9wM2gyODQw LmMgICAgICAgfCAxMjUgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCj4gIGlu Y2x1ZGUvbGludXgvbWZkL3AzaDI4NDAuaCB8ICAyNyArKysrKysrKwo+ICA1IGZpbGVzIGNoYW5n ZWQsIDE2OCBpbnNlcnRpb25zKCspCj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL21mZC9w M2gyODQwLmMKPiAgY3JlYXRlIG1vZGUgMTAwNjQ0IGluY2x1ZGUvbGludXgvbWZkL3AzaDI4NDAu aAo+IAo+IGRpZmYgLS1naXQgYS9NQUlOVEFJTkVSUyBiL01BSU5UQUlORVJTCj4gaW5kZXggYzcy OTc2ZGJkZjMxLi40ZjY3ZmU2NGM4MzMgMTAwNjQ0Cj4gLS0tIGEvTUFJTlRBSU5FUlMKPiArKysg Yi9NQUlOVEFJTkVSUwo+IEBAIC0xOTEwMSw2ICsxOTEwMSw4IEBAIEw6CWxpbnV4LWtlcm5lbEB2 Z2VyLmtlcm5lbC5vcmcKPiAgTDoJbGludXgtaTNjLW93bmVyQGxpc3RzLmluZnJhZGVhZC5vcmcK PiAgUzoJTWFpbnRhaW5lZAo+ICBGOglEb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmluZGluZ3Mv aTNjL254cCxwM2gyODQwLnlhbWwKPiArRjoJZHJpdmVycy9tZmQvcDNoMjg0MC5jCj4gK0Y6CWlu Y2x1ZGUvbGludXgvbWZkL3AzaDI4NDAuaAo+ICAKPiAgTlhQIFBGNTMwMC9QRjUzMDEvUEY1MzAy IFBNSUMgUkVHVUxBVE9SIERFVklDRSBEUklWRVIKPiAgTToJV29vZHJvdyBEb3VnbGFzcyA8d2Rv dWdsYXNzQGNhcm5lZ2llcm9ib3RpY3MuY29tPgo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL21mZC9L Y29uZmlnIGIvZHJpdmVycy9tZmQvS2NvbmZpZwo+IGluZGV4IDcxOTJjOWQxZDI2OC4uMTRmNDcz NjY4M2ExIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvbWZkL0tjb25maWcKPiArKysgYi9kcml2ZXJz L21mZC9LY29uZmlnCj4gQEAgLTYxNyw2ICs2MTcsMTkgQEAgY29uZmlnIE1GRF9NWDI1X1RTQURD Cj4gIAkgIGkuTVgyNSBwcm9jZXNzb3JzLiBUaGV5IGNvbnNpc3Qgb2YgYSBjb252ZXJzaW9uIHF1 ZXVlIGZvciBnZW5lcmFsCj4gIAkgIHB1cnBvc2UgQURDIGFuZCBhIHF1ZXVlIGZvciBUb3VjaHNj cmVlbnMuCj4gIAo+ICtjb25maWcgTUZEX1AzSDJYNFgKCk1GRF9OWFBfUDNIMlg0WAoKPiArICAg ICAgIHRyaXN0YXRlICJOWFAgUDNIMlg0WCBJM0MgSHViIERldmljZSIKPiArICAgICAgIGRlcGVu ZHMgb24gSTNDX09SX0kyQwo+ICsgICAgICAgc2VsZWN0IE1GRF9DT1JFCj4gKyAgICAgICBzZWxl Y3QgUkVHTUFQX0kzQwo+ICsgICAgICAgc2VsZWN0IFJFR01BUF9JMkMKPiArICAgICAgIGhlbHAK PiArICAgICAgICAgRW5hYmxlIFN1cHBvcnQgZm9yIE5YUCBQM0gyNDR4L1AzSDI4NHggSTNDIEhV QiBkZXZpY2UgdXNpbmcgSTNDL0kyQwo+ICsgICAgICAgICBjb21tdW5pY2F0aW9uIGludGVyZmFj ZS4KPiArCj4gKyAgICAgICAgIFRoaXMgZHJpdmVyIHByb3ZpZGVzIHN1cHBvcnQgZm9yIEkzQyBo dWIgYW5kIHJlZ3VsYXRvciwgZWFjaCBzdWJkcml2ZXIKPiArICAgICAgICAgY2FuIGJlIGVuYWJs ZWQgaW5kZXBlbmRlbnRseSBkZXBlbmRpbmcgb24gdGhlIHJlcXVpcmVkIGZ1bmN0aW9uYWxpdHku Cj4gKwo+ICBjb25maWcgTUZEX1BGMTU1MAo+ICAJdHJpc3RhdGUgIk5YUCBQRjE1NTAgUE1JQyBT dXBwb3J0Igo+ICAJZGVwZW5kcyBvbiBJMkM9eSAmJiBPRgo+IGRpZmYgLS1naXQgYS9kcml2ZXJz L21mZC9NYWtlZmlsZSBiL2RyaXZlcnMvbWZkL01ha2VmaWxlCj4gaW5kZXggZTc1ZTgwNDVjMjhh Li5hYWFkZjUwZmVkZjQgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9tZmQvTWFrZWZpbGUKPiArKysg Yi9kcml2ZXJzL21mZC9NYWtlZmlsZQo+IEBAIC0xMjIsNiArMTIyLDcgQEAgb2JqLSQoQ09ORklH X01GRF9NQzEzWFhYKQkrPSBtYzEzeHh4LWNvcmUubwo+ICBvYmotJChDT05GSUdfTUZEX01DMTNY WFhfU1BJKQkrPSBtYzEzeHh4LXNwaS5vCj4gIG9iai0kKENPTkZJR19NRkRfTUMxM1hYWF9JMkMp CSs9IG1jMTN4eHgtaTJjLm8KPiAgCj4gK29iai0kKENPTkZJR19NRkRfUDNIMlg0WCkgIAkrPSBw M2gyODQwLm8KClRoZXJlIGlzIGEgbWlzbWF0Y2ggaW4gdGhlIG5hbWluZyBoZXJlLgoKQXJlIHdl IGV4cHJlc3NpbmcgdGhlIGZhbWlseSBvciB0aGUgc3BlY2lmaWMgZGV2aWNlPwoKPiAgb2JqLSQo Q09ORklHX01GRF9QRjE1NTApCSs9IHBmMTU1MC5vCj4gIAo+ICBvYmotJChDT05GSUdfTUZEX05D VDY2OTQpCSs9IG5jdDY2OTQubwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL21mZC9wM2gyODQwLmMg Yi9kcml2ZXJzL21mZC9wM2gyODQwLmMKPiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+IGluZGV4IDAw MDAwMDAwMDAwMC4uNjUwOTBhMDlmN2M2Cj4gLS0tIC9kZXYvbnVsbAo+ICsrKyBiL2RyaXZlcnMv bWZkL3AzaDI4NDAuYwo+IEBAIC0wLDAgKzEsMTI1IEBACj4gKy8vIFNQRFgtTGljZW5zZS1JZGVu dGlmaWVyOiBHUEwtMi4wCj4gKy8qCj4gKyAqIENvcHlyaWdodCAyMDI1IE5YUAoKTmVlZHMgdXBk YXRpbmcuCgpBdXRob3Iocyk/Cgo+ICsgKiBQM0gyeDR4IGkzYyBodWIgYW5kIHJlZ3VsYXRvciBk ZXZpY2UuCj4gKyAqLwoKQ291bGQgdGhpcyBjb21tZW50IGJlIGEgbGl0dGxlIG1vcmUgZGVzY3Jp cHRpdmU/IFNvbWV0aGluZyBsaWtlOgoKIkNvcmUgZHJpdmVyIGZvciB0aGUgTlhQIFAzSDJ4NHgg ZmFtaWx5IG9mIEkzQyBodWJzLiIKCkRyb3AgdGhlIHJlZ3VsYXIgcGFydC4KCj4gKyNpbmNsdWRl IDxsaW51eC9pM2MvbWFzdGVyLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9pMmMuaD4KPiArI2luY2x1 ZGUgPGxpbnV4L21mZC9jb3JlLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9tZmQvcDNoMjg0MC5oPgo+ ICsjaW5jbHVkZSA8bGludXgvcmVnbWFwLmg+CgpQbGVhc2Ugc29ydCB5b3VyIGAjaW5jbHVkZWAg ZGlyZWN0aXZlcyBhbHBoYWJldGljYWxseS4KCj4gK3N0YXRpYyBjb25zdCBzdHJ1Y3QgbWZkX2Nl bGwgcDNoMng0eF9kZXZzW10gPSB7Cj4gKwl7Cj4gKwkJLm5hbWUgPSAicDNoMng0eC1yZWd1bGF0 b3IiLAo+ICsJfSwKPiArCXsKPiArCQkubmFtZSA9ICJwM2gyeDR4LWkzYy1odWIiLAo+ICsJfSwK PiArfTsKCk1GRF9DRUxMX05BTUUoKQoKPiArc3RhdGljIGNvbnN0IHN0cnVjdCByZWdtYXBfY29u ZmlnIHAzaDJ4NHhfcmVnbWFwX2NvbmZpZyA9IHsKPiArCS5yZWdfYml0cyA9IFAzSDJ4NHhfUkVH X0JJVFMsCj4gKwkudmFsX2JpdHMgPSBQM0gyeDR4X1ZBTF9CSVRTLAo+ICsJLm1heF9yZWdpc3Rl ciA9IDB4RkYsCj4gK307Cj4gKwo+ICtzdGF0aWMgaW50IHAzaDJ4NHhfZGV2aWNlX3Byb2JlX2kz YyhzdHJ1Y3QgaTNjX2RldmljZSAqaTNjZGV2KQo+ICt7Cj4gKwlzdHJ1Y3QgcDNoMng0eF9kZXYg KnAzaDJ4NHg7Cj4gKwlpbnQgcmV0Owo+ICsKPiArCXAzaDJ4NHggPSBkZXZtX2t6YWxsb2MoJmkz Y2Rldi0+ZGV2LCBzaXplb2YoKnAzaDJ4NHgpLCBHRlBfS0VSTkVMKTsKPiArCWlmICghcDNoMng0 eCkKPiArCQlyZXR1cm4gLUVOT01FTTsKPiArCj4gKwlpM2NkZXZfc2V0X2RydmRhdGEoaTNjZGV2 LCBwM2gyeDR4KTsKCk5vIHBvaW50IGluIHNldHRpbmcgdGhpcyB1bnRpbCBhZnRlciBpdHMgcG9w dWxhdGVkLgoKPiArCXAzaDJ4NHgtPnJlZ21hcCA9IGRldm1fcmVnbWFwX2luaXRfaTNjKGkzY2Rl diwgJnAzaDJ4NHhfcmVnbWFwX2NvbmZpZyk7Cj4gKwlpZiAoSVNfRVJSKHAzaDJ4NHgtPnJlZ21h cCkpCj4gKwkJcmV0dXJuIGRldl9lcnJfcHJvYmUoJmkzY2Rldi0+ZGV2LCBQVFJfRVJSKHAzaDJ4 NHgtPnJlZ21hcCksCj4gKwkJCQkgICAgICJGYWlsZWQgdG8gcmVnaXN0ZXIgSTNDIEhVQiByZWdt YXBcbiIpOwoKVGhpcyBlcnJvciBtZXNzYWdlIGFwcGVhcnMgdG8gYmUgYSBjb3B5LXBhc3RlIGZy b20gdGhlIEkyQyBwcm9iZSBmdW5jdGlvbi4KUGVyaGFwcyBhIG1vcmUgZ2VuZXJpYyBtZXNzYWdl IGxpa2UgIkZhaWxlZCB0byBpbml0aWFsaXNlIHJlZ21hcCIgd291bGQgYmUKbW9yZSBhcHByb3By aWF0ZSBmb3IgYm90aCBjb250ZXh0cy4KCj4gKwo+ICsJcDNoMng0eC0+aXNfcDNoMng0eF9pbl9p M2MgPSB0cnVlOwoKVGhpcyBpcyBzdXBlcmZsdW91cy4gIEp1c3QgY2hlY2sgYHAzaDJ4NHgtPmkz Y2RldmAuCgo+ICsJcDNoMng0eC0+aTNjZGV2ID0gaTNjZGV2Owo+ICsKPiArCXJldCA9IGRldm1f bWZkX2FkZF9kZXZpY2VzKCZpM2NkZXYtPmRldiwgUExBVEZPUk1fREVWSURfTk9ORSwKPiArCQkJ CSAgIHAzaDJ4NHhfZGV2cywgQVJSQVlfU0laRShwM2gyeDR4X2RldnMpLAo+ICsJCQkJICAgTlVM TCwgMCwgTlVMTCk7Cj4gKwlpZiAocmV0KQo+ICsJCXJldHVybiBkZXZfZXJyX3Byb2JlKCZpM2Nk ZXYtPmRldiwgcmV0LCAiRmFpbGVkIHRvIGFkZCBzdWIgZGV2aWNlc1xuIik7Cj4gKwo+ICsJcmV0 dXJuIDA7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgcDNoMng0eF9kZXZpY2VfcHJvYmVfaTJjKHN0 cnVjdCBpMmNfY2xpZW50ICpjbGllbnQpCj4gK3sKPiArCXN0cnVjdCBwM2gyeDR4X2RldiAqcDNo Mng0eDsKPiArCWludCByZXQ7Cj4gKwo+ICsJcDNoMng0eCA9IGRldm1fa3phbGxvYygmY2xpZW50 LT5kZXYsIHNpemVvZigqcDNoMng0eCksIEdGUF9LRVJORUwpOwo+ICsJaWYgKCFwM2gyeDR4KQo+ ICsJCXJldHVybiAtRU5PTUVNOwo+ICsKPiArCWkyY19zZXRfY2xpZW50ZGF0YShjbGllbnQsIHAz aDJ4NHgpOwoKQXMgYWJvdmUuCgo+ICsJcDNoMng0eC0+cmVnbWFwID0gZGV2bV9yZWdtYXBfaW5p dF9pMmMoY2xpZW50LCAmcDNoMng0eF9yZWdtYXBfY29uZmlnKTsKPiArCWlmIChJU19FUlIocDNo Mng0eC0+cmVnbWFwKSkKPiArCQlyZXR1cm4gZGV2X2Vycl9wcm9iZSgmY2xpZW50LT5kZXYsIFBU Ul9FUlIocDNoMng0eC0+cmVnbWFwKSwKPiArCQkJCSAgICAgIkZhaWxlZCB0byByZWdpc3RlciBJ M0MgSFVCIHJlZ21hcFxuIik7CgpJMkMKCj4gKwo+ICsJcDNoMng0eC0+aXNfcDNoMng0eF9pbl9p M2MgPSBmYWxzZTsKCkFzIGFib3ZlLgoKPiArCXJldCA9IGRldm1fbWZkX2FkZF9kZXZpY2VzKCZj bGllbnQtPmRldiwgUExBVEZPUk1fREVWSURfTk9ORSwKPiArCQkJCSAgIHAzaDJ4NHhfZGV2cywg QVJSQVlfU0laRShwM2gyeDR4X2RldnMpLAo+ICsJCQkJICAgTlVMTCwgMCwgTlVMTCk7Cj4gKwlp ZiAocmV0KQo+ICsJCXJldHVybiBkZXZfZXJyX3Byb2JlKCZjbGllbnQtPmRldiwgcmV0LCAiRmFp bGVkIHRvIGFkZCBzdWIgZGV2aWNlc1xuIik7Cj4gKwo+ICsJcmV0dXJuIDA7Cj4gK30KClRoZXNl IHR3byBwcm9iZSBmdW5jdGlvbnMsIGBwM2gyeDR4X2RldmljZV9wcm9iZV9pM2NgIGFuZApgcDNo Mng0eF9kZXZpY2VfcHJvYmVfaTJjYCwgYXJlIGFsbW9zdCBpZGVudGljYWwuIENvdWxkIHRoZXkg YmUgcmVmYWN0b3JlZAppbnRvIGEgc2luZ2xlIGNvbW1vbiBwcm9iZSBmdW5jdGlvbiB0byByZWR1 Y2UgY29kZSBkdXBsaWNhdGlvbj8KClRoZSBidXMtc3BlY2lmaWMgd3JhcHBlcnMgY291bGQgaGFu ZGxlIHRoZSByZWdtYXAgaW5pdGlhbGlzYXRpb24gYW5kIHRoZW4KY2FsbCBhIHNoYXJlZCBgcDNo Mng0eF9wcm9iZShzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCByZWdtYXAgKnJlZ21hcClgCmZ1 bmN0aW9uLgoKPiArCj4gKy8qIHAzaDJ4NHggaWRzIChpM2MpICovCj4gK3N0YXRpYyBjb25zdCBz dHJ1Y3QgaTNjX2RldmljZV9pZCBwM2gyeDR4X2kzY19pZHNbXSA9IHsKPiArCUkzQ19DTEFTUyhJ M0NfRENSX0hVQiwgTlVMTCksCj4gKwl7IC8qIHNlbnRpbmVsICovIH0sCj4gK307Cj4gK01PRFVM RV9ERVZJQ0VfVEFCTEUoaTNjLCBwM2gyeDR4X2kzY19pZHMpOwo+ICsKPiArLyogcDNoMng0eCBp ZHMgKGkyYykgKi8KPiArc3RhdGljIGNvbnN0IHN0cnVjdCBpMmNfZGV2aWNlX2lkIHAzaDJ4NHhf aTJjX2lkX3RhYmxlW10gPSB7Cj4gKwl7ICJueHAtaTNjLWh1YiIgfSwKClRoaXMgaXMgYW4gTUZE IGNvcmUgZHJpdmVyLCBub3QganVzdCBhIGh1YiBkcml2ZXIuIFBlcmhhcHMgYSBtb3JlIHN1aXRh YmxlCm5hbWUgd291bGQgYmUgInAzaDJ4NHgiPwoKPiArCXsgLyogc2VudGluZWwgKi8gfQo+ICt9 Owo+ICtNT0RVTEVfREVWSUNFX1RBQkxFKGkyYywgcDNoMng0eF9pMmNfaWRfdGFibGUpOwo+ICsK PiArc3RhdGljIGNvbnN0IHN0cnVjdCBvZl9kZXZpY2VfaWQgIHAzaDJ4NHhfaTJjX29mX21hdGNo W10gPSB7Cj4gKwl7IC5jb21wYXRpYmxlID0gIm54cCxwM2gyODQwIiwgfSwKPiArCXsgLyogc2Vu dGluZWwgKi8gfQo+ICt9Owo+ICsKPiArTU9EVUxFX0RFVklDRV9UQUJMRShvZiwgcDNoMng0eF9p MmNfb2ZfbWF0Y2gpOwoKVGhpcyBzaG91bGQgYmUgYWRqYWNlbnQgdG8gdGhlIHN0cnVjdCBhYm92 ZS4KCj4gK3N0YXRpYyBzdHJ1Y3QgaTNjX2RyaXZlciBwM2gyeDR4X2kzYyA9IHsKPiArCS5kcml2 ZXIgPSB7Cj4gKwkJLm5hbWUgPSAicDNoMng0eF9pM2NfZHJ2IiwKCiJfZHJ2IiBzaG91bGQgYmUg cmVtb3ZlZC4KCj4gKwl9LAo+ICsJLnByb2JlID0gcDNoMng0eF9kZXZpY2VfcHJvYmVfaTNjLAo+ ICsJLmlkX3RhYmxlID0gcDNoMng0eF9pM2NfaWRzLAo+ICt9Owo+ICsKPiArc3RhdGljIHN0cnVj dCBpMmNfZHJpdmVyIHAzaDJ4NHhfaTJjID0gewo+ICsJLmRyaXZlciA9IHsKPiArCQkubmFtZSA9 ICJwM2gyeDR4X2kyY19kcnYiLAoKQXMgYWJvdmUuCgo+ICsJCS5vZl9tYXRjaF90YWJsZSA9IHAz aDJ4NHhfaTJjX29mX21hdGNoLAo+ICsJfSwKPiArCS5wcm9iZSA9ICBwM2gyeDR4X2RldmljZV9w cm9iZV9pMmMsCj4gKwkuaWRfdGFibGUgPSBwM2gyeDR4X2kyY19pZF90YWJsZSwKPiArfTsKPiAr Cj4gK21vZHVsZV9pM2NfaTJjX2RyaXZlcihwM2gyeDR4X2kzYywgJnAzaDJ4NHhfaTJjKTsKPiAr Cj4gK01PRFVMRV9BVVRIT1IoIkFtYW4gS3VtYXIgUGFuZGV5IDxhbWFuLmt1bWFycGFuZGV5QG54 cC5jb20+Iik7Cj4gK01PRFVMRV9BVVRIT1IoIlZpa2FzaCBCYW5zYWwgPHZpa2FzaC5iYW5zYWxA bnhwLmNvbT4iKTsKClN0aWNrIHRvIGhhdmluZyBvbmUgb2YgdGhlc2UgYW5kIHB1dCB0d28gaW4g dGhlIGhlYWRlciBjb21tZW50LgoKPiArTU9EVUxFX0RFU0NSSVBUSU9OKCJQM0gyeDR4IEkzQyBI VUIgbXVsdGkgZnVuY3Rpb24gZHJpdmVyIik7CgpUaGlzIGNvdWxkIGJlIG1vcmUgcHJlY2lzZS4g SG93IGFib3V0OgoKIk5YUCBQM0gyeDR4IEkzQyBIdWIgY29yZSBkcml2ZXIiCgpEcm9wIGFsbCBt ZW50aW9ucyBvZiBNRkQuICBJdCdzIG5vdCBhIHJlYWwgdGhpbmcuCgo+ICtNT0RVTEVfTElDRU5T RSgiR1BMIik7Cj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvbWZkL3AzaDI4NDAuaCBiL2lu Y2x1ZGUvbGludXgvbWZkL3AzaDI4NDAuaAo+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4gaW5kZXgg MDAwMDAwMDAwMDAwLi5jYmE2ZmE1MTZkMWUKPiAtLS0gL2Rldi9udWxsCj4gKysrIGIvaW5jbHVk ZS9saW51eC9tZmQvcDNoMjg0MC5oCj4gQEAgLTAsMCArMSwyNyBAQAo+ICsvKiBTUERYLUxpY2Vu c2UtSWRlbnRpZmllcjogR1BMLTIuMCAqLwo+ICsvKgo+ICsgKiBDb3B5cmlnaHQgMjAyNSBOWFAK PiArICogVGhpcyBoZWFkZXIgZmlsZSBjb250YWluIHByaXZhdGUgUmVnIGFkZHJlc3MgYW5kIGl0 cyBiaXQgbWFwcGluZyBldGMuCj4gKyAqLwoKVGhlIGNvbW1lbnQgaXMgbm90IGEgY29tcGxldGUg c2VudGVuY2UgYW5kIHN0YXRlcyB0aGUgb2J2aW91cy4gUGxlYXNlIGNvbnNpZGVyCnNvbWV0aGlu ZyBtb3JlIGRlc2NyaXB0aXZlLCBmb3IgZXhhbXBsZToKCiJSZWdpc3RlciBkZWZpbml0aW9ucyBm b3IgdGhlIE5YUCBQM0gyeDR4IEkzQyBIdWIuIgoKPiArCj4gKyNpZm5kZWYgX0xJTlVYX01GRF9Q M0gyODQwX0gKPiArI2RlZmluZSBfTElOVVhfTUZEX1AzSDI4NDBfSAoKSWYgdGhlIGZpbGVuYW1l cyBhcmUgY2hhbmdlZCB0byBgcDNoMng0eC5oYCBhcyBzdWdnZXN0ZWQgZWFybGllciwgdGhpcwpo ZWFkZXIgZ3VhcmQgd2lsbCBuZWVkIHRvIGJlIHVwZGF0ZWQgdG8gYF9MSU5VWF9NRkRfUDNIMlg0 WF9IYC4KCj4gKwo+ICsjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KPiArCj4gKy8qIERldmljZSBD b25maWd1cmF0aW9uIFJlZ2lzdGVycyAqLwo+ICsjZGVmaW5lIFAzSDJ4NHhfREVWX1JFR19QUk9U RUNUSU9OX0NPREUJCQkJMHgxMAo+ICsjZGVmaW5lIFAzSDJ4NHhfUkVHSVNURVJTX0xPQ0tfQ09E RQkJCQkweDAwCj4gKyNkZWZpbmUgUDNIMng0eF9SRUdJU1RFUlNfVU5MT0NLX0NPREUJCQkJMHg2 OQo+ICsjZGVmaW5lIFAzSDJ4NHhfQ1AxX1JFR0lTVEVSU19VTkxPQ0tfQ09ERQkJCTB4NmEKPiAr Cj4gKy8qIFJlZyBjb25maWcgZm9yIFJlZ21hcCAqLwo+ICsjZGVmaW5lIFAzSDJ4NHhfUkVHX0JJ VFMJCQkJCTgKPiArI2RlZmluZSBQM0gyeDR4X1ZBTF9CSVRTCQkJCQk4Cj4gKwo+ICtzdHJ1Y3Qg cDNoMng0eF9kZXYgewo+ICsJc3RydWN0IGkzY19kZXZpY2UgKmkzY2RldjsKPiArCXN0cnVjdCBy ZWdtYXAgKnJlZ21hcDsKPiArCWJvb2wgaXNfcDNoMng0eF9pbl9pM2M7Cj4gK307CgpXaHkgYXJl IHdlIHN0b3JpbmcgaTNjX2RldmljZSwgYnV0IG5vdCBpMmNfZGV2aWNlX2lkPwoKLS0gCkxlZSBK b25lcyBb5p2O55C85pavXQoKLS0gCmxpbnV4LWkzYyBtYWlsaW5nIGxpc3QKbGludXgtaTNjQGxp c3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0 aW5mby9saW51eC1pM2MK