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 vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 95074C04A95 for ; Wed, 28 Sep 2022 14:14:09 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S234245AbiI1OOH (ORCPT ); Wed, 28 Sep 2022 10:14:07 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:41624 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234228AbiI1OOD (ORCPT ); Wed, 28 Sep 2022 10:14:03 -0400 Received: from dfw.source.kernel.org (dfw.source.kernel.org [IPv6:2604:1380:4641:c500::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 7E3139E894; Wed, 28 Sep 2022 07:14:01 -0700 (PDT) Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by dfw.source.kernel.org (Postfix) with ESMTPS id 0A9A161E91; Wed, 28 Sep 2022 14:14:01 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 12782C433D6; Wed, 28 Sep 2022 14:13:56 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1664374440; bh=qokI1UHZPf3czrAYVK1Fpc1za1XINMSz4Cp8uETUY7c=; h=Date:From:To:Cc:Subject:References:In-Reply-To:From; b=SMncpH3AwZsU2W3PF5ZxTqV1djC0AovIXvUwtZcMqQyHNunK7fBMb3D2ySnKXDHqo X0KShVR63uK0Zyvd6L170FSeG6eDtrTlS4r5/grJOlK7ClTSjtR1jXPhcx45lqSaZz mV357TvUcUBhMhCkJF1BbFyJX51bKJlGDUnLUblk+Z5LTzteSBhn1VkUqXtc9Emgpe It3eQU6OlEQb74OKpb/M8GkgZN0AIyztMj6vIiTyrO4qh4tUk1g7xxNSU5BSQ1wBa5 DTHVI8ixW2I0o3wdzPPXCyKAne12SrGV+iduhLyyw4UFme/vfwCxHM6Z7hHYBeAIio Ju0+bCyI8Vf9w== Date: Wed, 28 Sep 2022 15:13:53 +0100 From: Lee Jones To: Sebastian Reichel Cc: Heiko Stuebner , Rob Herring , Krzysztof Kozlowski , Michael Turquette , Stephen Boyd , Linus Walleij , Mark Brown , Liam Girdwood , Alexandre Belloni , Alessandro Zummo , linux-rockchip@lists.infradead.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, kernel@collabora.com Subject: Re: [PATCHv3 07/14] mfd: rk808: split into core and i2c Message-ID: References: <20220909175522.179175-1-sebastian.reichel@collabora.com> <20220909175522.179175-8-sebastian.reichel@collabora.com> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <20220909175522.179175-8-sebastian.reichel@collabora.com> Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Fri, 09 Sep 2022, Sebastian Reichel wrote: > Split rk808 into a core and an i2c part in preperation for > SPI support. > > Signed-off-by: Sebastian Reichel > --- > drivers/mfd/Kconfig | 5 + > drivers/mfd/Makefile | 3 +- > drivers/mfd/{rk808.c => rk8xx-core.c} | 200 +++++-------------------- > drivers/mfd/rk8xx-i2c.c | 203 ++++++++++++++++++++++++++ > include/linux/mfd/rk808.h | 6 + > 5 files changed, 249 insertions(+), 168 deletions(-) > rename drivers/mfd/{rk808.c => rk8xx-core.c} (76%) > create mode 100644 drivers/mfd/rk8xx-i2c.c > > diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig > index abb58ab1a1a4..acb7133d6db6 100644 > --- a/drivers/mfd/Kconfig > +++ b/drivers/mfd/Kconfig > @@ -1143,11 +1143,16 @@ config MFD_RC5T583 > different functionality of the device. > > config MFD_RK808 > + bool > + select MFD_CORE > + > +config MFD_RK8XX_I2C > tristate "Rockchip RK805/RK808/RK809/RK817/RK818 Power Management Chip" > depends on I2C && OF > select MFD_CORE > select REGMAP_I2C > select REGMAP_IRQ > + select MFD_RK808 > help > If you say yes here you get support for the RK805, RK808, RK809, > RK817 and RK818 Power Management chips. > diff --git a/drivers/mfd/Makefile b/drivers/mfd/Makefile > index 858cacf659d6..25ac617a5e6b 100644 > --- a/drivers/mfd/Makefile > +++ b/drivers/mfd/Makefile > @@ -215,7 +215,8 @@ obj-$(CONFIG_MFD_PALMAS) += palmas.o > obj-$(CONFIG_MFD_VIPERBOARD) += viperboard.o > obj-$(CONFIG_MFD_NTXEC) += ntxec.o > obj-$(CONFIG_MFD_RC5T583) += rc5t583.o rc5t583-irq.o > -obj-$(CONFIG_MFD_RK808) += rk808.o > +obj-$(CONFIG_MFD_RK808) += rk8xx-core.o > +obj-$(CONFIG_MFD_RK8XX_I2C) += rk8xx-i2c.o > obj-$(CONFIG_MFD_RN5T618) += rn5t618.o > obj-$(CONFIG_MFD_SEC_CORE) += sec-core.o sec-irq.o > obj-$(CONFIG_MFD_SYSCON) += syscon.o > diff --git a/drivers/mfd/rk808.c b/drivers/mfd/rk8xx-core.c > similarity index 76% > rename from drivers/mfd/rk808.c > rename to drivers/mfd/rk8xx-core.c > index 518c6deec4b1..d0ce17d98fdc 100644 > --- a/drivers/mfd/rk808.c > +++ b/drivers/mfd/rk8xx-core.c > @@ -12,7 +12,6 @@ > * Author: Wadim Egorov > */ > > -#include > #include > #include > #include > @@ -27,88 +26,6 @@ struct rk808_reg_data { > int value; > }; > > -static bool rk808_is_volatile_reg(struct device *dev, unsigned int reg) > -{ > - /* > - * Notes: > - * - Technically the ROUND_30s bit makes RTC_CTRL_REG volatile, but > - * we don't use that feature. It's better to cache. > - * - It's unlikely we care that RK808_DEVCTRL_REG is volatile since > - * bits are cleared in case when we shutoff anyway, but better safe. > - */ > - > - switch (reg) { > - case RK808_SECONDS_REG ... RK808_WEEKS_REG: > - case RK808_RTC_STATUS_REG: > - case RK808_VB_MON_REG: > - case RK808_THERMAL_REG: > - case RK808_DCDC_UV_STS_REG: > - case RK808_LDO_UV_STS_REG: > - case RK808_DCDC_PG_REG: > - case RK808_LDO_PG_REG: > - case RK808_DEVCTRL_REG: > - case RK808_INT_STS_REG1: > - case RK808_INT_STS_REG2: > - return true; > - } > - > - return false; > -} > - > -static bool rk817_is_volatile_reg(struct device *dev, unsigned int reg) > -{ > - /* > - * Notes: > - * - Technically the ROUND_30s bit makes RTC_CTRL_REG volatile, but > - * we don't use that feature. It's better to cache. > - */ > - > - switch (reg) { > - case RK817_SECONDS_REG ... RK817_WEEKS_REG: > - case RK817_RTC_STATUS_REG: > - case RK817_CODEC_DTOP_LPT_SRST: > - case RK817_INT_STS_REG0: > - case RK817_INT_STS_REG1: > - case RK817_INT_STS_REG2: > - case RK817_SYS_STS: > - return true; > - } > - > - return true; > -} > - > -static const struct regmap_config rk818_regmap_config = { > - .reg_bits = 8, > - .val_bits = 8, > - .max_register = RK818_USB_CTRL_REG, > - .cache_type = REGCACHE_RBTREE, > - .volatile_reg = rk808_is_volatile_reg, > -}; > - > -static const struct regmap_config rk805_regmap_config = { > - .reg_bits = 8, > - .val_bits = 8, > - .max_register = RK805_OFF_SOURCE_REG, > - .cache_type = REGCACHE_RBTREE, > - .volatile_reg = rk808_is_volatile_reg, > -}; > - > -static const struct regmap_config rk808_regmap_config = { > - .reg_bits = 8, > - .val_bits = 8, > - .max_register = RK808_IO_POL_REG, > - .cache_type = REGCACHE_RBTREE, > - .volatile_reg = rk808_is_volatile_reg, > -}; > - > -static const struct regmap_config rk817_regmap_config = { > - .reg_bits = 8, > - .val_bits = 8, > - .max_register = RK817_GPIO_INT_CFG, > - .cache_type = REGCACHE_NONE, > - .volatile_reg = rk817_is_volatile_reg, > -}; > - > static const struct resource rtc_resources[] = { > DEFINE_RES_IRQ(RK808_IRQ_RTC_ALARM), > }; > @@ -584,9 +501,9 @@ static int rk808_restart(struct sys_off_data *data) > return NOTIFY_DONE; > } > > -static void rk8xx_shutdown(struct i2c_client *client) > +void rk8xx_shutdown(struct device *dev) > { > - struct rk808 *rk808 = i2c_get_clientdata(client); > + struct rk808 *rk808 = dev_get_drvdata(dev); > int ret; > > switch (rk808->variant) { > @@ -607,62 +524,31 @@ static void rk8xx_shutdown(struct i2c_client *client) > return; > } > if (ret) > - dev_warn(&client->dev, > + dev_warn(dev, > "Cannot switch to power down function\n"); > } > +EXPORT_SYMBOL_GPL(rk8xx_shutdown); > > -static const struct of_device_id rk808_of_match[] = { > - { .compatible = "rockchip,rk805" }, > - { .compatible = "rockchip,rk808" }, > - { .compatible = "rockchip,rk809" }, > - { .compatible = "rockchip,rk817" }, > - { .compatible = "rockchip,rk818" }, > - { }, > -}; > -MODULE_DEVICE_TABLE(of, rk808_of_match); > - > -static int rk808_probe(struct i2c_client *client, > - const struct i2c_device_id *id) > +int rk8xx_probe(struct device *dev, int variant, unsigned int irq, struct regmap *regmap) > { > - struct device_node *np = client->dev.of_node; > struct rk808 *rk808; > const struct rk808_reg_data *pre_init_reg; > const struct mfd_cell *cells; > int nr_pre_init_regs; > int nr_cells; > - int msb, lsb; > - unsigned char pmic_id_msb, pmic_id_lsb; > int ret; > int i; > > - rk808 = devm_kzalloc(&client->dev, sizeof(*rk808), GFP_KERNEL); > + rk808 = devm_kzalloc(dev, sizeof(*rk808), GFP_KERNEL); > if (!rk808) > return -ENOMEM; > - > - if (of_device_is_compatible(np, "rockchip,rk817") || > - of_device_is_compatible(np, "rockchip,rk809")) { > - pmic_id_msb = RK817_ID_MSB; > - pmic_id_lsb = RK817_ID_LSB; > - } else { > - pmic_id_msb = RK808_ID_MSB; > - pmic_id_lsb = RK808_ID_LSB; > - } > - > - /* Read chip variant */ > - msb = i2c_smbus_read_byte_data(client, pmic_id_msb); > - if (msb < 0) > - return dev_err_probe(&client->dev, msb, "failed to read the chip id MSB\n"); > - > - lsb = i2c_smbus_read_byte_data(client, pmic_id_lsb); > - if (lsb < 0) > - return dev_err_probe(&client->dev, lsb, "failed to read the chip id LSB\n"); > - > - rk808->variant = ((msb << 8) | lsb) & RK8XX_ID_MSK; > - dev_info(&client->dev, "chip id: 0x%x\n", (unsigned int)rk808->variant); > + rk808->dev = dev; > + rk808->variant = variant; > + rk808->regmap = regmap; > + dev_set_drvdata(dev, rk808); > > switch (rk808->variant) { > case RK805_ID: > - rk808->regmap_cfg = &rk805_regmap_config; > rk808->regmap_irq_chip = &rk805_irq_chip; > pre_init_reg = rk805_pre_init_reg; > nr_pre_init_regs = ARRAY_SIZE(rk805_pre_init_reg); > @@ -670,7 +556,6 @@ static int rk808_probe(struct i2c_client *client, > nr_cells = ARRAY_SIZE(rk805s); > break; > case RK808_ID: > - rk808->regmap_cfg = &rk808_regmap_config; > rk808->regmap_irq_chip = &rk808_irq_chip; > pre_init_reg = rk808_pre_init_reg; > nr_pre_init_regs = ARRAY_SIZE(rk808_pre_init_reg); > @@ -678,7 +563,6 @@ static int rk808_probe(struct i2c_client *client, > nr_cells = ARRAY_SIZE(rk808s); > break; > case RK818_ID: > - rk808->regmap_cfg = &rk818_regmap_config; > rk808->regmap_irq_chip = &rk818_irq_chip; > pre_init_reg = rk818_pre_init_reg; > nr_pre_init_regs = ARRAY_SIZE(rk818_pre_init_reg); > @@ -687,7 +571,6 @@ static int rk808_probe(struct i2c_client *client, > break; > case RK809_ID: > case RK817_ID: > - rk808->regmap_cfg = &rk817_regmap_config; > rk808->regmap_irq_chip = &rk817_irq_chip; > pre_init_reg = rk817_pre_init_reg; > nr_pre_init_regs = ARRAY_SIZE(rk817_pre_init_reg); > @@ -695,27 +578,20 @@ static int rk808_probe(struct i2c_client *client, > nr_cells = ARRAY_SIZE(rk817s); > break; > default: > - dev_err(&client->dev, "Unsupported RK8XX ID %lu\n", > - rk808->variant); > + dev_err(dev, "Unsupported RK8XX ID %lu\n", rk808->variant); > return -EINVAL; > } > > - rk808->dev = &client->dev; > - i2c_set_clientdata(client, rk808); > + dev_info(dev, "chip id: 0x%x\n", (unsigned int)rk808->variant); > > - rk808->regmap = devm_regmap_init_i2c(client, rk808->regmap_cfg); > - if (IS_ERR(rk808->regmap)) > - return dev_err_probe(&client->dev, PTR_ERR(rk808->regmap), > - "regmap initialization failed\n"); > + if (!irq) > + return dev_err_probe(dev, -EINVAL, "No interrupt support, no core IRQ\n"); > > - if (!client->irq) > - return dev_err_probe(&client->dev, -EINVAL, "No interrupt support, no core IRQ\n"); > - > - ret = devm_regmap_add_irq_chip(&client->dev, rk808->regmap, client->irq, > + ret = devm_regmap_add_irq_chip(dev, rk808->regmap, irq, > IRQF_ONESHOT, -1, > rk808->regmap_irq_chip, &rk808->irq_data); > if (ret) > - return dev_err_probe(&client->dev, ret, "Failed to add irq_chip\n"); > + return dev_err_probe(dev, ret, "Failed to add irq_chip\n"); > > for (i = 0; i < nr_pre_init_regs; i++) { > ret = regmap_update_bits(rk808->regmap, > @@ -723,45 +599,46 @@ static int rk808_probe(struct i2c_client *client, > pre_init_reg[i].mask, > pre_init_reg[i].value); > if (ret) > - return dev_err_probe(&client->dev, ret, "0x%x write err\n", > + return dev_err_probe(dev, ret, "0x%x write err\n", > pre_init_reg[i].addr); > } > > - ret = devm_mfd_add_devices(&client->dev, PLATFORM_DEVID_NONE, > + ret = devm_mfd_add_devices(dev, PLATFORM_DEVID_NONE, > cells, nr_cells, NULL, 0, > regmap_irq_get_domain(rk808->irq_data)); > if (ret) > - return dev_err_probe(&client->dev, ret, "failed to add MFD devices\n"); > + return dev_err_probe(dev, ret, "failed to add MFD devices\n"); > > - if (of_property_read_bool(np, "rockchip,system-power-controller")) { > - ret = devm_register_sys_off_handler(&client->dev, > + if (device_property_read_bool(dev, "rockchip,system-power-controller")) { > + ret = devm_register_sys_off_handler(dev, > SYS_OFF_MODE_POWER_OFF_PREPARE, SYS_OFF_PRIO_HIGH, > &rk808_power_off, rk808); > if (ret) > - return dev_err_probe(&client->dev, ret, > + return dev_err_probe(dev, ret, > "failed to register poweroff handler\n"); > > switch (rk808->variant) { > case RK809_ID: > case RK817_ID: > - ret = devm_register_sys_off_handler(&client->dev, > + ret = devm_register_sys_off_handler(dev, > SYS_OFF_MODE_RESTART, SYS_OFF_PRIO_HIGH, > &rk808_restart, rk808); > if (ret) > - dev_warn(&client->dev, "failed to register rst handler, %d\n", ret); > + dev_warn(dev, "failed to register rst handler, %d\n", ret); > break; > default: > - dev_dbg(&client->dev, "pmic controlled board reset not supported\n"); > + dev_dbg(dev, "pmic controlled board reset not supported\n"); > break; > } > } > > return 0; > } > +EXPORT_SYMBOL_GPL(rk8xx_probe); > > -static int __maybe_unused rk8xx_suspend(struct device *dev) > +int rk8xx_suspend(struct device *dev) > { > - struct rk808 *rk808 = i2c_get_clientdata(to_i2c_client(dev)); > + struct rk808 *rk808 = dev_get_drvdata(dev); > int ret = 0; > > switch (rk808->variant) { > @@ -784,10 +661,11 @@ static int __maybe_unused rk8xx_suspend(struct device *dev) > > return ret; > } > +EXPORT_SYMBOL_GPL(rk8xx_suspend); > > -static int __maybe_unused rk8xx_resume(struct device *dev) > +int rk8xx_resume(struct device *dev) > { > - struct rk808 *rk808 = i2c_get_clientdata(to_i2c_client(dev)); > + struct rk808 *rk808 = dev_get_drvdata(dev); > int ret = 0; > > switch (rk808->variant) { > @@ -804,22 +682,10 @@ static int __maybe_unused rk8xx_resume(struct device *dev) > > return ret; > } > -static SIMPLE_DEV_PM_OPS(rk8xx_pm_ops, rk8xx_suspend, rk8xx_resume); > - > -static struct i2c_driver rk808_i2c_driver = { > - .driver = { > - .name = "rk808", > - .of_match_table = rk808_of_match, > - .pm = &rk8xx_pm_ops, > - }, > - .probe = rk808_probe, > - .shutdown = rk8xx_shutdown, > -}; > - > -module_i2c_driver(rk808_i2c_driver); > +EXPORT_SYMBOL_GPL(rk8xx_resume); > > MODULE_LICENSE("GPL"); > MODULE_AUTHOR("Chris Zhong "); > MODULE_AUTHOR("Zhang Qing "); > MODULE_AUTHOR("Wadim Egorov "); > -MODULE_DESCRIPTION("RK808/RK818 PMIC driver"); > +MODULE_DESCRIPTION("RK8xx PMIC core"); > diff --git a/drivers/mfd/rk8xx-i2c.c b/drivers/mfd/rk8xx-i2c.c > new file mode 100644 > index 000000000000..325d0e519325 > --- /dev/null > +++ b/drivers/mfd/rk8xx-i2c.c > @@ -0,0 +1,203 @@ > +// SPDX-License-Identifier: GPL-2.0-only > +/* > + * MFD i2c driver for Rockchip RK808/RK818 Please drop the "MFD" here, so: Rockchip RK808/RK818 Core (I2C) driver > + * Copyright (c) 2014, Fuzhou Rockchip Electronics Co., Ltd > + * > + * Author: Chris Zhong > + * Author: Zhang Qing > + * > + * Copyright (C) 2016 PHYTEC Messtechnik GmbH > + * > + * Author: Wadim Egorov > + */ This is a new file, right? So this might need updating. > +#include > +#include You're missing includes here. > +static bool rk808_is_volatile_reg(struct device *dev, unsigned int reg) #include > +{ > + /* > + * Notes: > + * - Technically the ROUND_30s bit makes RTC_CTRL_REG volatile, but > + * we don't use that feature. It's better to cache. > + * - It's unlikely we care that RK808_DEVCTRL_REG is volatile since > + * bits are cleared in case when we shutoff anyway, but better safe. > + */ > + > + switch (reg) { > + case RK808_SECONDS_REG ... RK808_WEEKS_REG: > + case RK808_RTC_STATUS_REG: > + case RK808_VB_MON_REG: > + case RK808_THERMAL_REG: > + case RK808_DCDC_UV_STS_REG: > + case RK808_LDO_UV_STS_REG: > + case RK808_DCDC_PG_REG: > + case RK808_LDO_PG_REG: > + case RK808_DEVCTRL_REG: > + case RK808_INT_STS_REG1: > + case RK808_INT_STS_REG2: > + return true; > + } > + > + return false; > +} > + > +static bool rk817_is_volatile_reg(struct device *dev, unsigned int reg) > +{ > + /* > + * Notes: > + * - Technically the ROUND_30s bit makes RTC_CTRL_REG volatile, but > + * we don't use that feature. It's better to cache. > + */ > + > + switch (reg) { > + case RK817_SECONDS_REG ... RK817_WEEKS_REG: > + case RK817_RTC_STATUS_REG: > + case RK817_CODEC_DTOP_LPT_SRST: > + case RK817_INT_STS_REG0: > + case RK817_INT_STS_REG1: > + case RK817_INT_STS_REG2: > + case RK817_SYS_STS: > + return true; > + } > + > + return true; > +} > + > +static const struct regmap_config rk818_regmap_config = { #include etc - please look for others. > + .reg_bits = 8, > + .val_bits = 8, > + .max_register = RK818_USB_CTRL_REG, > + .cache_type = REGCACHE_RBTREE, > + .volatile_reg = rk808_is_volatile_reg, > +}; > + > +static const struct regmap_config rk805_regmap_config = { > + .reg_bits = 8, > + .val_bits = 8, > + .max_register = RK805_OFF_SOURCE_REG, > + .cache_type = REGCACHE_RBTREE, > + .volatile_reg = rk808_is_volatile_reg, > +}; > + > +static const struct regmap_config rk808_regmap_config = { > + .reg_bits = 8, > + .val_bits = 8, > + .max_register = RK808_IO_POL_REG, > + .cache_type = REGCACHE_RBTREE, > + .volatile_reg = rk808_is_volatile_reg, > +}; > + > +static const struct regmap_config rk817_regmap_config = { > + .reg_bits = 8, > + .val_bits = 8, > + .max_register = RK817_GPIO_INT_CFG, > + .cache_type = REGCACHE_NONE, > + .volatile_reg = rk817_is_volatile_reg, > +}; > + > +static int rk8xx_i2c_get_variant(struct i2c_client *client) > +{ > + u8 pmic_id_msb, pmic_id_lsb; > + int msb, lsb; > + > + if (of_device_is_compatible(client->dev.of_node, "rockchip,rk817") || > + of_device_is_compatible(client->dev.of_node, "rockchip,rk809")) { > + pmic_id_msb = RK817_ID_MSB; > + pmic_id_lsb = RK817_ID_LSB; > + } else { > + pmic_id_msb = RK808_ID_MSB; > + pmic_id_lsb = RK808_ID_LSB; > + } > + > + /* Read chip variant */ > + msb = i2c_smbus_read_byte_data(client, pmic_id_msb); > + if (msb < 0) > + return dev_err_probe(&client->dev, msb, "failed to read the chip id MSB\n"); > + > + lsb = i2c_smbus_read_byte_data(client, pmic_id_lsb); > + if (lsb < 0) > + return dev_err_probe(&client->dev, lsb, "failed to read the chip id LSB\n"); > + > + return ((msb << 8) | lsb) & RK8XX_ID_MSK; > +} > + > +static int rk8xx_i2c_probe(struct i2c_client *client) > +{ > + const struct regmap_config *regmap_cfg; > + struct regmap *regmap; > + int variant; > + > + variant = rk8xx_i2c_get_variant(client); > + if (variant < 0) > + return variant; > + > + switch (variant) { > + case RK805_ID: > + regmap_cfg = &rk805_regmap_config; > + break; > + case RK808_ID: > + regmap_cfg = &rk808_regmap_config; > + break; > + case RK818_ID: > + regmap_cfg = &rk818_regmap_config; > + break; > + case RK809_ID: > + case RK817_ID: > + regmap_cfg = &rk817_regmap_config; > + break; > + default: > + return dev_err_probe(&client->dev, -EINVAL, "Unsupported RK8XX ID %x\n", variant); > + } > + > + regmap = devm_regmap_init_i2c(client, regmap_cfg); > + if (IS_ERR(regmap)) > + return dev_err_probe(&client->dev, PTR_ERR(regmap), > + "regmap initialization failed\n"); > + > + return rk8xx_probe(&client->dev, variant, client->irq, regmap); > +} > + > +static void rk8xx_i2c_shutdown(struct i2c_client *client) > +{ > + rk8xx_shutdown(&client->dev); > +} > + > +static int __maybe_unused rk8xx_i2c_suspend(struct device *dev) > +{ > + return rk8xx_suspend(dev); > +} > + > +static int __maybe_unused rk8xx_i2c_resume(struct device *dev) > +{ > + return rk8xx_resume(dev); > +} > +static SIMPLE_DEV_PM_OPS(rk8xx_i2c_pm_ops, rk8xx_i2c_suspend, rk8xx_i2c_resume); > + > +static const struct of_device_id rk8xx_i2c_of_match[] = { > + { .compatible = "rockchip,rk805" }, > + { .compatible = "rockchip,rk808" }, > + { .compatible = "rockchip,rk809" }, > + { .compatible = "rockchip,rk817" }, > + { .compatible = "rockchip,rk818" }, > + { }, > +}; > +MODULE_DEVICE_TABLE(of, rk8xx_i2c_of_match); > + > +static struct i2c_driver rk8xx_i2c_driver = { > + .driver = { > + .name = "rk8xx-i2c", > + .of_match_table = rk8xx_i2c_of_match, > + .pm = &rk8xx_i2c_pm_ops, > + }, > + .probe_new = rk8xx_i2c_probe, > + .shutdown = rk8xx_i2c_shutdown, > +}; > +module_i2c_driver(rk8xx_i2c_driver); > + > +MODULE_LICENSE("GPL"); > +MODULE_AUTHOR("Chris Zhong "); > +MODULE_AUTHOR("Zhang Qing "); > +MODULE_AUTHOR("Wadim Egorov "); Not mentioned in the header? > +MODULE_DESCRIPTION("RK8xx I2C PMIC driver"); > diff --git a/include/linux/mfd/rk808.h b/include/linux/mfd/rk808.h > index 9937b068fa82..c5ddfb0e5353 100644 > --- a/include/linux/mfd/rk808.h > +++ b/include/linux/mfd/rk808.h > @@ -703,4 +703,10 @@ struct rk808 { > const struct regmap_config *regmap_cfg; > const struct regmap_irq_chip *regmap_irq_chip; > }; > + > +void rk8xx_shutdown(struct device *dev); > +int rk8xx_probe(struct device *dev, int variant, unsigned int irq, struct regmap *regmap); > +int rk8xx_suspend(struct device *dev); > +int rk8xx_resume(struct device *dev); > + > #endif /* __LINUX_REGULATOR_RK808_H */ -- 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 EFD64C04A95 for ; Wed, 28 Sep 2022 14:14: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: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=YMN+RPo51n3wvmx4aMllsswmw2zSz5AvlkC3+xlo2fk=; b=HgRka+H+ohvDfA /o13N7s7vw4U7qqZobhRKzQQG5r/+n2GAblDGnP/2g8V9l4Fg76o3tLsIIcCUAPuJ0mDlEJZdsm+/ AoUQeut9qeu83Ibgl0cU2qsqIXOF1Jqd4L69lvefAO5J/FdxUS1oY0/IFM1KsH9ntZ2G6qBaHXNlF vo/SbRseOk/LrVjzzWS7oUtZE9lCCLef+OTOW46XlRZ7Bpg56UL+eqddaj389YCn/X2lzaOituIq8 PfFlqwhBXHGxC8hVw0DVhVpLthhIUEfa7CeXDudfaJ1KFbd/1juUPS40OOB0mHYmMv8taT6wKBxBR 9oawt+g8hVYYsFqdJbtA==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1odXpB-00Gdp2-70; Wed, 28 Sep 2022 14:14:09 +0000 Received: from ams.source.kernel.org ([145.40.68.75]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1odXp7-00Gdo4-Ld for linux-rockchip@lists.infradead.org; Wed, 28 Sep 2022 14:14:08 +0000 Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ams.source.kernel.org (Postfix) with ESMTPS id BECA8B820E8; Wed, 28 Sep 2022 14:14:01 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 12782C433D6; Wed, 28 Sep 2022 14:13:56 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1664374440; bh=qokI1UHZPf3czrAYVK1Fpc1za1XINMSz4Cp8uETUY7c=; h=Date:From:To:Cc:Subject:References:In-Reply-To:From; b=SMncpH3AwZsU2W3PF5ZxTqV1djC0AovIXvUwtZcMqQyHNunK7fBMb3D2ySnKXDHqo X0KShVR63uK0Zyvd6L170FSeG6eDtrTlS4r5/grJOlK7ClTSjtR1jXPhcx45lqSaZz mV357TvUcUBhMhCkJF1BbFyJX51bKJlGDUnLUblk+Z5LTzteSBhn1VkUqXtc9Emgpe It3eQU6OlEQb74OKpb/M8GkgZN0AIyztMj6vIiTyrO4qh4tUk1g7xxNSU5BSQ1wBa5 DTHVI8ixW2I0o3wdzPPXCyKAne12SrGV+iduhLyyw4UFme/vfwCxHM6Z7hHYBeAIio Ju0+bCyI8Vf9w== Date: Wed, 28 Sep 2022 15:13:53 +0100 From: Lee Jones To: Sebastian Reichel Cc: Heiko Stuebner , Rob Herring , Krzysztof Kozlowski , Michael Turquette , Stephen Boyd , Linus Walleij , Mark Brown , Liam Girdwood , Alexandre Belloni , Alessandro Zummo , linux-rockchip@lists.infradead.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, kernel@collabora.com Subject: Re: [PATCHv3 07/14] mfd: rk808: split into core and i2c Message-ID: References: <20220909175522.179175-1-sebastian.reichel@collabora.com> <20220909175522.179175-8-sebastian.reichel@collabora.com> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: <20220909175522.179175-8-sebastian.reichel@collabora.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20220928_071406_027137_C60E0124 X-CRM114-Status: GOOD ( 34.35 ) X-BeenThere: linux-rockchip@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: Upstream kernel work for Rockchip platforms List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "Linux-rockchip" Errors-To: linux-rockchip-bounces+linux-rockchip=archiver.kernel.org@lists.infradead.org T24gRnJpLCAwOSBTZXAgMjAyMiwgU2ViYXN0aWFuIFJlaWNoZWwgd3JvdGU6Cgo+IFNwbGl0IHJr ODA4IGludG8gYSBjb3JlIGFuZCBhbiBpMmMgcGFydCBpbiBwcmVwZXJhdGlvbiBmb3IKPiBTUEkg c3VwcG9ydC4KPiAKPiBTaWduZWQtb2ZmLWJ5OiBTZWJhc3RpYW4gUmVpY2hlbCA8c2ViYXN0aWFu LnJlaWNoZWxAY29sbGFib3JhLmNvbT4KPiAtLS0KPiAgZHJpdmVycy9tZmQvS2NvbmZpZyAgICAg ICAgICAgICAgICAgICB8ICAgNSArCj4gIGRyaXZlcnMvbWZkL01ha2VmaWxlICAgICAgICAgICAg ICAgICAgfCAgIDMgKy0KPiAgZHJpdmVycy9tZmQve3JrODA4LmMgPT4gcms4eHgtY29yZS5jfSB8 IDIwMCArKysrKy0tLS0tLS0tLS0tLS0tLS0tLS0tCj4gIGRyaXZlcnMvbWZkL3JrOHh4LWkyYy5j ICAgICAgICAgICAgICAgfCAyMDMgKysrKysrKysrKysrKysrKysrKysrKysrKysKPiAgaW5jbHVk ZS9saW51eC9tZmQvcms4MDguaCAgICAgICAgICAgICB8ICAgNiArCj4gIDUgZmlsZXMgY2hhbmdl ZCwgMjQ5IGluc2VydGlvbnMoKyksIDE2OCBkZWxldGlvbnMoLSkKPiAgcmVuYW1lIGRyaXZlcnMv bWZkL3tyazgwOC5jID0+IHJrOHh4LWNvcmUuY30gKDc2JSkKPiAgY3JlYXRlIG1vZGUgMTAwNjQ0 IGRyaXZlcnMvbWZkL3JrOHh4LWkyYy5jCj4gCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWZkL0tj b25maWcgYi9kcml2ZXJzL21mZC9LY29uZmlnCj4gaW5kZXggYWJiNThhYjFhMWE0Li5hY2I3MTMz ZDZkYjYgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9tZmQvS2NvbmZpZwo+ICsrKyBiL2RyaXZlcnMv bWZkL0tjb25maWcKPiBAQCAtMTE0MywxMSArMTE0MywxNiBAQCBjb25maWcgTUZEX1JDNVQ1ODMK PiAgCSAgZGlmZmVyZW50IGZ1bmN0aW9uYWxpdHkgb2YgdGhlIGRldmljZS4KPiAgCj4gIGNvbmZp ZyBNRkRfUks4MDgKPiArCWJvb2wKPiArCXNlbGVjdCBNRkRfQ09SRQo+ICsKPiArY29uZmlnIE1G RF9SSzhYWF9JMkMKPiAgCXRyaXN0YXRlICJSb2NrY2hpcCBSSzgwNS9SSzgwOC9SSzgwOS9SSzgx Ny9SSzgxOCBQb3dlciBNYW5hZ2VtZW50IENoaXAiCj4gIAlkZXBlbmRzIG9uIEkyQyAmJiBPRgo+ ICAJc2VsZWN0IE1GRF9DT1JFCj4gIAlzZWxlY3QgUkVHTUFQX0kyQwo+ICAJc2VsZWN0IFJFR01B UF9JUlEKPiArCXNlbGVjdCBNRkRfUks4MDgKPiAgCWhlbHAKPiAgCSAgSWYgeW91IHNheSB5ZXMg aGVyZSB5b3UgZ2V0IHN1cHBvcnQgZm9yIHRoZSBSSzgwNSwgUks4MDgsIFJLODA5LAo+ICAJICBS SzgxNyBhbmQgUks4MTggUG93ZXIgTWFuYWdlbWVudCBjaGlwcy4KPiBkaWZmIC0tZ2l0IGEvZHJp dmVycy9tZmQvTWFrZWZpbGUgYi9kcml2ZXJzL21mZC9NYWtlZmlsZQo+IGluZGV4IDg1OGNhY2Y2 NTlkNi4uMjVhYzYxN2E1ZTZiIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvbWZkL01ha2VmaWxlCj4g KysrIGIvZHJpdmVycy9tZmQvTWFrZWZpbGUKPiBAQCAtMjE1LDcgKzIxNSw4IEBAIG9iai0kKENP TkZJR19NRkRfUEFMTUFTKQkrPSBwYWxtYXMubwo+ICBvYmotJChDT05GSUdfTUZEX1ZJUEVSQk9B UkQpICAgICs9IHZpcGVyYm9hcmQubwo+ICBvYmotJChDT05GSUdfTUZEX05UWEVDKQkJKz0gbnR4 ZWMubwo+ICBvYmotJChDT05GSUdfTUZEX1JDNVQ1ODMpCSs9IHJjNXQ1ODMubyByYzV0NTgzLWly cS5vCj4gLW9iai0kKENPTkZJR19NRkRfUks4MDgpCQkrPSByazgwOC5vCj4gK29iai0kKENPTkZJ R19NRkRfUks4MDgpCQkrPSByazh4eC1jb3JlLm8KPiArb2JqLSQoQ09ORklHX01GRF9SSzhYWF9J MkMpCSs9IHJrOHh4LWkyYy5vCj4gIG9iai0kKENPTkZJR19NRkRfUk41VDYxOCkJKz0gcm41dDYx OC5vCj4gIG9iai0kKENPTkZJR19NRkRfU0VDX0NPUkUpCSs9IHNlYy1jb3JlLm8gc2VjLWlycS5v Cj4gIG9iai0kKENPTkZJR19NRkRfU1lTQ09OKQkrPSBzeXNjb24ubwo+IGRpZmYgLS1naXQgYS9k cml2ZXJzL21mZC9yazgwOC5jIGIvZHJpdmVycy9tZmQvcms4eHgtY29yZS5jCj4gc2ltaWxhcml0 eSBpbmRleCA3NiUKPiByZW5hbWUgZnJvbSBkcml2ZXJzL21mZC9yazgwOC5jCj4gcmVuYW1lIHRv IGRyaXZlcnMvbWZkL3JrOHh4LWNvcmUuYwo+IGluZGV4IDUxOGM2ZGVlYzRiMS4uZDBjZTE3ZDk4 ZmRjIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvbWZkL3JrODA4LmMKPiArKysgYi9kcml2ZXJzL21m ZC9yazh4eC1jb3JlLmMKPiBAQCAtMTIsNyArMTIsNiBAQAo+ICAgKiBBdXRob3I6IFdhZGltIEVn b3JvdiA8dy5lZ29yb3ZAcGh5dGVjLmRlPgo+ICAgKi8KPiAgCj4gLSNpbmNsdWRlIDxsaW51eC9p MmMuaD4KPiAgI2luY2x1ZGUgPGxpbnV4L2ludGVycnVwdC5oPgo+ICAjaW5jbHVkZSA8bGludXgv bWZkL3JrODA4Lmg+Cj4gICNpbmNsdWRlIDxsaW51eC9tZmQvY29yZS5oPgo+IEBAIC0yNyw4OCAr MjYsNiBAQCBzdHJ1Y3Qgcms4MDhfcmVnX2RhdGEgewo+ICAJaW50IHZhbHVlOwo+ICB9Owo+ICAK PiAtc3RhdGljIGJvb2wgcms4MDhfaXNfdm9sYXRpbGVfcmVnKHN0cnVjdCBkZXZpY2UgKmRldiwg dW5zaWduZWQgaW50IHJlZykKPiAtewo+IC0JLyoKPiAtCSAqIE5vdGVzOgo+IC0JICogLSBUZWNo bmljYWxseSB0aGUgUk9VTkRfMzBzIGJpdCBtYWtlcyBSVENfQ1RSTF9SRUcgdm9sYXRpbGUsIGJ1 dAo+IC0JICogICB3ZSBkb24ndCB1c2UgdGhhdCBmZWF0dXJlLiAgSXQncyBiZXR0ZXIgdG8gY2Fj aGUuCj4gLQkgKiAtIEl0J3MgdW5saWtlbHkgd2UgY2FyZSB0aGF0IFJLODA4X0RFVkNUUkxfUkVH IGlzIHZvbGF0aWxlIHNpbmNlCj4gLQkgKiAgIGJpdHMgYXJlIGNsZWFyZWQgaW4gY2FzZSB3aGVu IHdlIHNodXRvZmYgYW55d2F5LCBidXQgYmV0dGVyIHNhZmUuCj4gLQkgKi8KPiAtCj4gLQlzd2l0 Y2ggKHJlZykgewo+IC0JY2FzZSBSSzgwOF9TRUNPTkRTX1JFRyAuLi4gUks4MDhfV0VFS1NfUkVH Ogo+IC0JY2FzZSBSSzgwOF9SVENfU1RBVFVTX1JFRzoKPiAtCWNhc2UgUks4MDhfVkJfTU9OX1JF RzoKPiAtCWNhc2UgUks4MDhfVEhFUk1BTF9SRUc6Cj4gLQljYXNlIFJLODA4X0RDRENfVVZfU1RT X1JFRzoKPiAtCWNhc2UgUks4MDhfTERPX1VWX1NUU19SRUc6Cj4gLQljYXNlIFJLODA4X0RDRENf UEdfUkVHOgo+IC0JY2FzZSBSSzgwOF9MRE9fUEdfUkVHOgo+IC0JY2FzZSBSSzgwOF9ERVZDVFJM X1JFRzoKPiAtCWNhc2UgUks4MDhfSU5UX1NUU19SRUcxOgo+IC0JY2FzZSBSSzgwOF9JTlRfU1RT X1JFRzI6Cj4gLQkJcmV0dXJuIHRydWU7Cj4gLQl9Cj4gLQo+IC0JcmV0dXJuIGZhbHNlOwo+IC19 Cj4gLQo+IC1zdGF0aWMgYm9vbCByazgxN19pc192b2xhdGlsZV9yZWcoc3RydWN0IGRldmljZSAq ZGV2LCB1bnNpZ25lZCBpbnQgcmVnKQo+IC17Cj4gLQkvKgo+IC0JICogTm90ZXM6Cj4gLQkgKiAt IFRlY2huaWNhbGx5IHRoZSBST1VORF8zMHMgYml0IG1ha2VzIFJUQ19DVFJMX1JFRyB2b2xhdGls ZSwgYnV0Cj4gLQkgKiAgIHdlIGRvbid0IHVzZSB0aGF0IGZlYXR1cmUuICBJdCdzIGJldHRlciB0 byBjYWNoZS4KPiAtCSAqLwo+IC0KPiAtCXN3aXRjaCAocmVnKSB7Cj4gLQljYXNlIFJLODE3X1NF Q09ORFNfUkVHIC4uLiBSSzgxN19XRUVLU19SRUc6Cj4gLQljYXNlIFJLODE3X1JUQ19TVEFUVVNf UkVHOgo+IC0JY2FzZSBSSzgxN19DT0RFQ19EVE9QX0xQVF9TUlNUOgo+IC0JY2FzZSBSSzgxN19J TlRfU1RTX1JFRzA6Cj4gLQljYXNlIFJLODE3X0lOVF9TVFNfUkVHMToKPiAtCWNhc2UgUks4MTdf SU5UX1NUU19SRUcyOgo+IC0JY2FzZSBSSzgxN19TWVNfU1RTOgo+IC0JCXJldHVybiB0cnVlOwo+ IC0JfQo+IC0KPiAtCXJldHVybiB0cnVlOwo+IC19Cj4gLQo+IC1zdGF0aWMgY29uc3Qgc3RydWN0 IHJlZ21hcF9jb25maWcgcms4MThfcmVnbWFwX2NvbmZpZyA9IHsKPiAtCS5yZWdfYml0cyA9IDgs Cj4gLQkudmFsX2JpdHMgPSA4LAo+IC0JLm1heF9yZWdpc3RlciA9IFJLODE4X1VTQl9DVFJMX1JF RywKPiAtCS5jYWNoZV90eXBlID0gUkVHQ0FDSEVfUkJUUkVFLAo+IC0JLnZvbGF0aWxlX3JlZyA9 IHJrODA4X2lzX3ZvbGF0aWxlX3JlZywKPiAtfTsKPiAtCj4gLXN0YXRpYyBjb25zdCBzdHJ1Y3Qg cmVnbWFwX2NvbmZpZyByazgwNV9yZWdtYXBfY29uZmlnID0gewo+IC0JLnJlZ19iaXRzID0gOCwK PiAtCS52YWxfYml0cyA9IDgsCj4gLQkubWF4X3JlZ2lzdGVyID0gUks4MDVfT0ZGX1NPVVJDRV9S RUcsCj4gLQkuY2FjaGVfdHlwZSA9IFJFR0NBQ0hFX1JCVFJFRSwKPiAtCS52b2xhdGlsZV9yZWcg PSByazgwOF9pc192b2xhdGlsZV9yZWcsCj4gLX07Cj4gLQo+IC1zdGF0aWMgY29uc3Qgc3RydWN0 IHJlZ21hcF9jb25maWcgcms4MDhfcmVnbWFwX2NvbmZpZyA9IHsKPiAtCS5yZWdfYml0cyA9IDgs Cj4gLQkudmFsX2JpdHMgPSA4LAo+IC0JLm1heF9yZWdpc3RlciA9IFJLODA4X0lPX1BPTF9SRUcs Cj4gLQkuY2FjaGVfdHlwZSA9IFJFR0NBQ0hFX1JCVFJFRSwKPiAtCS52b2xhdGlsZV9yZWcgPSBy azgwOF9pc192b2xhdGlsZV9yZWcsCj4gLX07Cj4gLQo+IC1zdGF0aWMgY29uc3Qgc3RydWN0IHJl Z21hcF9jb25maWcgcms4MTdfcmVnbWFwX2NvbmZpZyA9IHsKPiAtCS5yZWdfYml0cyA9IDgsCj4g LQkudmFsX2JpdHMgPSA4LAo+IC0JLm1heF9yZWdpc3RlciA9IFJLODE3X0dQSU9fSU5UX0NGRywK PiAtCS5jYWNoZV90eXBlID0gUkVHQ0FDSEVfTk9ORSwKPiAtCS52b2xhdGlsZV9yZWcgPSByazgx N19pc192b2xhdGlsZV9yZWcsCj4gLX07Cj4gLQo+ICBzdGF0aWMgY29uc3Qgc3RydWN0IHJlc291 cmNlIHJ0Y19yZXNvdXJjZXNbXSA9IHsKPiAgCURFRklORV9SRVNfSVJRKFJLODA4X0lSUV9SVENf QUxBUk0pLAo+ICB9Owo+IEBAIC01ODQsOSArNTAxLDkgQEAgc3RhdGljIGludCByazgwOF9yZXN0 YXJ0KHN0cnVjdCBzeXNfb2ZmX2RhdGEgKmRhdGEpCj4gIAlyZXR1cm4gTk9USUZZX0RPTkU7Cj4g IH0KPiAgCj4gLXN0YXRpYyB2b2lkIHJrOHh4X3NodXRkb3duKHN0cnVjdCBpMmNfY2xpZW50ICpj bGllbnQpCj4gK3ZvaWQgcms4eHhfc2h1dGRvd24oc3RydWN0IGRldmljZSAqZGV2KQo+ICB7Cj4g LQlzdHJ1Y3Qgcms4MDggKnJrODA4ID0gaTJjX2dldF9jbGllbnRkYXRhKGNsaWVudCk7Cj4gKwlz dHJ1Y3Qgcms4MDggKnJrODA4ID0gZGV2X2dldF9kcnZkYXRhKGRldik7Cj4gIAlpbnQgcmV0Owo+ ICAKPiAgCXN3aXRjaCAocms4MDgtPnZhcmlhbnQpIHsKPiBAQCAtNjA3LDYyICs1MjQsMzEgQEAg c3RhdGljIHZvaWQgcms4eHhfc2h1dGRvd24oc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCkKPiAg CQlyZXR1cm47Cj4gIAl9Cj4gIAlpZiAocmV0KQo+IC0JCWRldl93YXJuKCZjbGllbnQtPmRldiwK PiArCQlkZXZfd2FybihkZXYsCj4gIAkJCSAiQ2Fubm90IHN3aXRjaCB0byBwb3dlciBkb3duIGZ1 bmN0aW9uXG4iKTsKPiAgfQo+ICtFWFBPUlRfU1lNQk9MX0dQTChyazh4eF9zaHV0ZG93bik7Cj4g IAo+IC1zdGF0aWMgY29uc3Qgc3RydWN0IG9mX2RldmljZV9pZCByazgwOF9vZl9tYXRjaFtdID0g ewo+IC0JeyAuY29tcGF0aWJsZSA9ICJyb2NrY2hpcCxyazgwNSIgfSwKPiAtCXsgLmNvbXBhdGli bGUgPSAicm9ja2NoaXAscms4MDgiIH0sCj4gLQl7IC5jb21wYXRpYmxlID0gInJvY2tjaGlwLHJr ODA5IiB9LAo+IC0JeyAuY29tcGF0aWJsZSA9ICJyb2NrY2hpcCxyazgxNyIgfSwKPiAtCXsgLmNv bXBhdGlibGUgPSAicm9ja2NoaXAscms4MTgiIH0sCj4gLQl7IH0sCj4gLX07Cj4gLU1PRFVMRV9E RVZJQ0VfVEFCTEUob2YsIHJrODA4X29mX21hdGNoKTsKPiAtCj4gLXN0YXRpYyBpbnQgcms4MDhf cHJvYmUoc3RydWN0IGkyY19jbGllbnQgKmNsaWVudCwKPiAtCQkgICAgICAgY29uc3Qgc3RydWN0 IGkyY19kZXZpY2VfaWQgKmlkKQo+ICtpbnQgcms4eHhfcHJvYmUoc3RydWN0IGRldmljZSAqZGV2 LCBpbnQgdmFyaWFudCwgdW5zaWduZWQgaW50IGlycSwgc3RydWN0IHJlZ21hcCAqcmVnbWFwKQo+ ICB7Cj4gLQlzdHJ1Y3QgZGV2aWNlX25vZGUgKm5wID0gY2xpZW50LT5kZXYub2Zfbm9kZTsKPiAg CXN0cnVjdCByazgwOCAqcms4MDg7Cj4gIAljb25zdCBzdHJ1Y3Qgcms4MDhfcmVnX2RhdGEgKnBy ZV9pbml0X3JlZzsKPiAgCWNvbnN0IHN0cnVjdCBtZmRfY2VsbCAqY2VsbHM7Cj4gIAlpbnQgbnJf cHJlX2luaXRfcmVnczsKPiAgCWludCBucl9jZWxsczsKPiAtCWludCBtc2IsIGxzYjsKPiAtCXVu c2lnbmVkIGNoYXIgcG1pY19pZF9tc2IsIHBtaWNfaWRfbHNiOwo+ICAJaW50IHJldDsKPiAgCWlu dCBpOwo+ICAKPiAtCXJrODA4ID0gZGV2bV9remFsbG9jKCZjbGllbnQtPmRldiwgc2l6ZW9mKCpy azgwOCksIEdGUF9LRVJORUwpOwo+ICsJcms4MDggPSBkZXZtX2t6YWxsb2MoZGV2LCBzaXplb2Yo KnJrODA4KSwgR0ZQX0tFUk5FTCk7Cj4gIAlpZiAoIXJrODA4KQo+ICAJCXJldHVybiAtRU5PTUVN Owo+IC0KPiAtCWlmIChvZl9kZXZpY2VfaXNfY29tcGF0aWJsZShucCwgInJvY2tjaGlwLHJrODE3 IikgfHwKPiAtCSAgICBvZl9kZXZpY2VfaXNfY29tcGF0aWJsZShucCwgInJvY2tjaGlwLHJrODA5 IikpIHsKPiAtCQlwbWljX2lkX21zYiA9IFJLODE3X0lEX01TQjsKPiAtCQlwbWljX2lkX2xzYiA9 IFJLODE3X0lEX0xTQjsKPiAtCX0gZWxzZSB7Cj4gLQkJcG1pY19pZF9tc2IgPSBSSzgwOF9JRF9N U0I7Cj4gLQkJcG1pY19pZF9sc2IgPSBSSzgwOF9JRF9MU0I7Cj4gLQl9Cj4gLQo+IC0JLyogUmVh ZCBjaGlwIHZhcmlhbnQgKi8KPiAtCW1zYiA9IGkyY19zbWJ1c19yZWFkX2J5dGVfZGF0YShjbGll bnQsIHBtaWNfaWRfbXNiKTsKPiAtCWlmIChtc2IgPCAwKQo+IC0JCXJldHVybiBkZXZfZXJyX3By b2JlKCZjbGllbnQtPmRldiwgbXNiLCAiZmFpbGVkIHRvIHJlYWQgdGhlIGNoaXAgaWQgTVNCXG4i KTsKPiAtCj4gLQlsc2IgPSBpMmNfc21idXNfcmVhZF9ieXRlX2RhdGEoY2xpZW50LCBwbWljX2lk X2xzYik7Cj4gLQlpZiAobHNiIDwgMCkKPiAtCQlyZXR1cm4gZGV2X2Vycl9wcm9iZSgmY2xpZW50 LT5kZXYsIGxzYiwgImZhaWxlZCB0byByZWFkIHRoZSBjaGlwIGlkIExTQlxuIik7Cj4gLQo+IC0J cms4MDgtPnZhcmlhbnQgPSAoKG1zYiA8PCA4KSB8IGxzYikgJiBSSzhYWF9JRF9NU0s7Cj4gLQlk ZXZfaW5mbygmY2xpZW50LT5kZXYsICJjaGlwIGlkOiAweCV4XG4iLCAodW5zaWduZWQgaW50KXJr ODA4LT52YXJpYW50KTsKPiArCXJrODA4LT5kZXYgPSBkZXY7Cj4gKwlyazgwOC0+dmFyaWFudCA9 IHZhcmlhbnQ7Cj4gKwlyazgwOC0+cmVnbWFwID0gcmVnbWFwOwo+ICsJZGV2X3NldF9kcnZkYXRh KGRldiwgcms4MDgpOwo+ICAKPiAgCXN3aXRjaCAocms4MDgtPnZhcmlhbnQpIHsKPiAgCWNhc2Ug Uks4MDVfSUQ6Cj4gLQkJcms4MDgtPnJlZ21hcF9jZmcgPSAmcms4MDVfcmVnbWFwX2NvbmZpZzsK PiAgCQlyazgwOC0+cmVnbWFwX2lycV9jaGlwID0gJnJrODA1X2lycV9jaGlwOwo+ICAJCXByZV9p bml0X3JlZyA9IHJrODA1X3ByZV9pbml0X3JlZzsKPiAgCQlucl9wcmVfaW5pdF9yZWdzID0gQVJS QVlfU0laRShyazgwNV9wcmVfaW5pdF9yZWcpOwo+IEBAIC02NzAsNyArNTU2LDYgQEAgc3RhdGlj IGludCByazgwOF9wcm9iZShzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50LAo+ICAJCW5yX2NlbGxz ID0gQVJSQVlfU0laRShyazgwNXMpOwo+ICAJCWJyZWFrOwo+ICAJY2FzZSBSSzgwOF9JRDoKPiAt CQlyazgwOC0+cmVnbWFwX2NmZyA9ICZyazgwOF9yZWdtYXBfY29uZmlnOwo+ICAJCXJrODA4LT5y ZWdtYXBfaXJxX2NoaXAgPSAmcms4MDhfaXJxX2NoaXA7Cj4gIAkJcHJlX2luaXRfcmVnID0gcms4 MDhfcHJlX2luaXRfcmVnOwo+ICAJCW5yX3ByZV9pbml0X3JlZ3MgPSBBUlJBWV9TSVpFKHJrODA4 X3ByZV9pbml0X3JlZyk7Cj4gQEAgLTY3OCw3ICs1NjMsNiBAQCBzdGF0aWMgaW50IHJrODA4X3By b2JlKHN0cnVjdCBpMmNfY2xpZW50ICpjbGllbnQsCj4gIAkJbnJfY2VsbHMgPSBBUlJBWV9TSVpF KHJrODA4cyk7Cj4gIAkJYnJlYWs7Cj4gIAljYXNlIFJLODE4X0lEOgo+IC0JCXJrODA4LT5yZWdt YXBfY2ZnID0gJnJrODE4X3JlZ21hcF9jb25maWc7Cj4gIAkJcms4MDgtPnJlZ21hcF9pcnFfY2hp cCA9ICZyazgxOF9pcnFfY2hpcDsKPiAgCQlwcmVfaW5pdF9yZWcgPSByazgxOF9wcmVfaW5pdF9y ZWc7Cj4gIAkJbnJfcHJlX2luaXRfcmVncyA9IEFSUkFZX1NJWkUocms4MThfcHJlX2luaXRfcmVn KTsKPiBAQCAtNjg3LDcgKzU3MSw2IEBAIHN0YXRpYyBpbnQgcms4MDhfcHJvYmUoc3RydWN0IGky Y19jbGllbnQgKmNsaWVudCwKPiAgCQlicmVhazsKPiAgCWNhc2UgUks4MDlfSUQ6Cj4gIAljYXNl IFJLODE3X0lEOgo+IC0JCXJrODA4LT5yZWdtYXBfY2ZnID0gJnJrODE3X3JlZ21hcF9jb25maWc7 Cj4gIAkJcms4MDgtPnJlZ21hcF9pcnFfY2hpcCA9ICZyazgxN19pcnFfY2hpcDsKPiAgCQlwcmVf aW5pdF9yZWcgPSByazgxN19wcmVfaW5pdF9yZWc7Cj4gIAkJbnJfcHJlX2luaXRfcmVncyA9IEFS UkFZX1NJWkUocms4MTdfcHJlX2luaXRfcmVnKTsKPiBAQCAtNjk1LDI3ICs1NzgsMjAgQEAgc3Rh dGljIGludCByazgwOF9wcm9iZShzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50LAo+ICAJCW5yX2Nl bGxzID0gQVJSQVlfU0laRShyazgxN3MpOwo+ICAJCWJyZWFrOwo+ICAJZGVmYXVsdDoKPiAtCQlk ZXZfZXJyKCZjbGllbnQtPmRldiwgIlVuc3VwcG9ydGVkIFJLOFhYIElEICVsdVxuIiwKPiAtCQkJ cms4MDgtPnZhcmlhbnQpOwo+ICsJCWRldl9lcnIoZGV2LCAiVW5zdXBwb3J0ZWQgUks4WFggSUQg JWx1XG4iLCByazgwOC0+dmFyaWFudCk7Cj4gIAkJcmV0dXJuIC1FSU5WQUw7Cj4gIAl9Cj4gIAo+ IC0Jcms4MDgtPmRldiA9ICZjbGllbnQtPmRldjsKPiAtCWkyY19zZXRfY2xpZW50ZGF0YShjbGll bnQsIHJrODA4KTsKPiArCWRldl9pbmZvKGRldiwgImNoaXAgaWQ6IDB4JXhcbiIsICh1bnNpZ25l ZCBpbnQpcms4MDgtPnZhcmlhbnQpOwo+ICAKPiAtCXJrODA4LT5yZWdtYXAgPSBkZXZtX3JlZ21h cF9pbml0X2kyYyhjbGllbnQsIHJrODA4LT5yZWdtYXBfY2ZnKTsKPiAtCWlmIChJU19FUlIocms4 MDgtPnJlZ21hcCkpCj4gLQkJcmV0dXJuIGRldl9lcnJfcHJvYmUoJmNsaWVudC0+ZGV2LCBQVFJf RVJSKHJrODA4LT5yZWdtYXApLAo+IC0JCQkJICAgICAicmVnbWFwIGluaXRpYWxpemF0aW9uIGZh aWxlZFxuIik7Cj4gKwlpZiAoIWlycSkKPiArCQlyZXR1cm4gZGV2X2Vycl9wcm9iZShkZXYsIC1F SU5WQUwsICJObyBpbnRlcnJ1cHQgc3VwcG9ydCwgbm8gY29yZSBJUlFcbiIpOwo+ICAKPiAtCWlm ICghY2xpZW50LT5pcnEpCj4gLQkJcmV0dXJuIGRldl9lcnJfcHJvYmUoJmNsaWVudC0+ZGV2LCAt RUlOVkFMLCAiTm8gaW50ZXJydXB0IHN1cHBvcnQsIG5vIGNvcmUgSVJRXG4iKTsKPiAtCj4gLQly ZXQgPSBkZXZtX3JlZ21hcF9hZGRfaXJxX2NoaXAoJmNsaWVudC0+ZGV2LCByazgwOC0+cmVnbWFw LCBjbGllbnQtPmlycSwKPiArCXJldCA9IGRldm1fcmVnbWFwX2FkZF9pcnFfY2hpcChkZXYsIHJr ODA4LT5yZWdtYXAsIGlycSwKPiAgCQkJCSAgICAgICBJUlFGX09ORVNIT1QsIC0xLAo+ICAJCQkJ ICAgICAgIHJrODA4LT5yZWdtYXBfaXJxX2NoaXAsICZyazgwOC0+aXJxX2RhdGEpOwo+ICAJaWYg KHJldCkKPiAtCQlyZXR1cm4gZGV2X2Vycl9wcm9iZSgmY2xpZW50LT5kZXYsIHJldCwgIkZhaWxl ZCB0byBhZGQgaXJxX2NoaXBcbiIpOwo+ICsJCXJldHVybiBkZXZfZXJyX3Byb2JlKGRldiwgcmV0 LCAiRmFpbGVkIHRvIGFkZCBpcnFfY2hpcFxuIik7Cj4gIAo+ICAJZm9yIChpID0gMDsgaSA8IG5y X3ByZV9pbml0X3JlZ3M7IGkrKykgewo+ICAJCXJldCA9IHJlZ21hcF91cGRhdGVfYml0cyhyazgw OC0+cmVnbWFwLAo+IEBAIC03MjMsNDUgKzU5OSw0NiBAQCBzdGF0aWMgaW50IHJrODA4X3Byb2Jl KHN0cnVjdCBpMmNfY2xpZW50ICpjbGllbnQsCj4gIAkJCQkJcHJlX2luaXRfcmVnW2ldLm1hc2ss Cj4gIAkJCQkJcHJlX2luaXRfcmVnW2ldLnZhbHVlKTsKPiAgCQlpZiAocmV0KQo+IC0JCQlyZXR1 cm4gZGV2X2Vycl9wcm9iZSgmY2xpZW50LT5kZXYsIHJldCwgIjB4JXggd3JpdGUgZXJyXG4iLAo+ ICsJCQlyZXR1cm4gZGV2X2Vycl9wcm9iZShkZXYsIHJldCwgIjB4JXggd3JpdGUgZXJyXG4iLAo+ ICAJCQkJCSAgICAgcHJlX2luaXRfcmVnW2ldLmFkZHIpOwo+ICAJfQo+ICAKPiAtCXJldCA9IGRl dm1fbWZkX2FkZF9kZXZpY2VzKCZjbGllbnQtPmRldiwgUExBVEZPUk1fREVWSURfTk9ORSwKPiAr CXJldCA9IGRldm1fbWZkX2FkZF9kZXZpY2VzKGRldiwgUExBVEZPUk1fREVWSURfTk9ORSwKPiAg CQkJICAgICAgY2VsbHMsIG5yX2NlbGxzLCBOVUxMLCAwLAo+ICAJCQkgICAgICByZWdtYXBfaXJx X2dldF9kb21haW4ocms4MDgtPmlycV9kYXRhKSk7Cj4gIAlpZiAocmV0KQo+IC0JCXJldHVybiBk ZXZfZXJyX3Byb2JlKCZjbGllbnQtPmRldiwgcmV0LCAiZmFpbGVkIHRvIGFkZCBNRkQgZGV2aWNl c1xuIik7Cj4gKwkJcmV0dXJuIGRldl9lcnJfcHJvYmUoZGV2LCByZXQsICJmYWlsZWQgdG8gYWRk IE1GRCBkZXZpY2VzXG4iKTsKPiAgCj4gLQlpZiAob2ZfcHJvcGVydHlfcmVhZF9ib29sKG5wLCAi cm9ja2NoaXAsc3lzdGVtLXBvd2VyLWNvbnRyb2xsZXIiKSkgewo+IC0JCXJldCA9IGRldm1fcmVn aXN0ZXJfc3lzX29mZl9oYW5kbGVyKCZjbGllbnQtPmRldiwKPiArCWlmIChkZXZpY2VfcHJvcGVy dHlfcmVhZF9ib29sKGRldiwgInJvY2tjaGlwLHN5c3RlbS1wb3dlci1jb250cm9sbGVyIikpIHsK PiArCQlyZXQgPSBkZXZtX3JlZ2lzdGVyX3N5c19vZmZfaGFuZGxlcihkZXYsCj4gIAkJCQkgICAg U1lTX09GRl9NT0RFX1BPV0VSX09GRl9QUkVQQVJFLCBTWVNfT0ZGX1BSSU9fSElHSCwKPiAgCQkJ CSAgICAmcms4MDhfcG93ZXJfb2ZmLCByazgwOCk7Cj4gIAkJaWYgKHJldCkKPiAtCQkJcmV0dXJu IGRldl9lcnJfcHJvYmUoJmNsaWVudC0+ZGV2LCByZXQsCj4gKwkJCXJldHVybiBkZXZfZXJyX3By b2JlKGRldiwgcmV0LAo+ICAJCQkJCSAgICAgImZhaWxlZCB0byByZWdpc3RlciBwb3dlcm9mZiBo YW5kbGVyXG4iKTsKPiAgCj4gIAkJc3dpdGNoIChyazgwOC0+dmFyaWFudCkgewo+ICAJCWNhc2Ug Uks4MDlfSUQ6Cj4gIAkJY2FzZSBSSzgxN19JRDoKPiAtCQkJcmV0ID0gZGV2bV9yZWdpc3Rlcl9z eXNfb2ZmX2hhbmRsZXIoJmNsaWVudC0+ZGV2LAo+ICsJCQlyZXQgPSBkZXZtX3JlZ2lzdGVyX3N5 c19vZmZfaGFuZGxlcihkZXYsCj4gIAkJCQkJCQkgICAgU1lTX09GRl9NT0RFX1JFU1RBUlQsIFNZ U19PRkZfUFJJT19ISUdILAo+ICAJCQkJCQkJICAgICZyazgwOF9yZXN0YXJ0LCByazgwOCk7Cj4g IAkJCWlmIChyZXQpCj4gLQkJCQlkZXZfd2FybigmY2xpZW50LT5kZXYsICJmYWlsZWQgdG8gcmVn aXN0ZXIgcnN0IGhhbmRsZXIsICVkXG4iLCByZXQpOwo+ICsJCQkJZGV2X3dhcm4oZGV2LCAiZmFp bGVkIHRvIHJlZ2lzdGVyIHJzdCBoYW5kbGVyLCAlZFxuIiwgcmV0KTsKPiAgCQkJYnJlYWs7Cj4g IAkJZGVmYXVsdDoKPiAtCQkJZGV2X2RiZygmY2xpZW50LT5kZXYsICJwbWljIGNvbnRyb2xsZWQg Ym9hcmQgcmVzZXQgbm90IHN1cHBvcnRlZFxuIik7Cj4gKwkJCWRldl9kYmcoZGV2LCAicG1pYyBj b250cm9sbGVkIGJvYXJkIHJlc2V0IG5vdCBzdXBwb3J0ZWRcbiIpOwo+ICAJCQlicmVhazsKPiAg CQl9Cj4gIAl9Cj4gIAo+ICAJcmV0dXJuIDA7Cj4gIH0KPiArRVhQT1JUX1NZTUJPTF9HUEwocms4 eHhfcHJvYmUpOwo+ICAKPiAtc3RhdGljIGludCBfX21heWJlX3VudXNlZCByazh4eF9zdXNwZW5k KHN0cnVjdCBkZXZpY2UgKmRldikKPiAraW50IHJrOHh4X3N1c3BlbmQoc3RydWN0IGRldmljZSAq ZGV2KQo+ICB7Cj4gLQlzdHJ1Y3Qgcms4MDggKnJrODA4ID0gaTJjX2dldF9jbGllbnRkYXRhKHRv X2kyY19jbGllbnQoZGV2KSk7Cj4gKwlzdHJ1Y3Qgcms4MDggKnJrODA4ID0gZGV2X2dldF9kcnZk YXRhKGRldik7Cj4gIAlpbnQgcmV0ID0gMDsKPiAgCj4gIAlzd2l0Y2ggKHJrODA4LT52YXJpYW50 KSB7Cj4gQEAgLTc4NCwxMCArNjYxLDExIEBAIHN0YXRpYyBpbnQgX19tYXliZV91bnVzZWQgcms4 eHhfc3VzcGVuZChzdHJ1Y3QgZGV2aWNlICpkZXYpCj4gIAo+ICAJcmV0dXJuIHJldDsKPiAgfQo+ ICtFWFBPUlRfU1lNQk9MX0dQTChyazh4eF9zdXNwZW5kKTsKPiAgCj4gLXN0YXRpYyBpbnQgX19t YXliZV91bnVzZWQgcms4eHhfcmVzdW1lKHN0cnVjdCBkZXZpY2UgKmRldikKPiAraW50IHJrOHh4 X3Jlc3VtZShzdHJ1Y3QgZGV2aWNlICpkZXYpCj4gIHsKPiAtCXN0cnVjdCByazgwOCAqcms4MDgg PSBpMmNfZ2V0X2NsaWVudGRhdGEodG9faTJjX2NsaWVudChkZXYpKTsKPiArCXN0cnVjdCByazgw OCAqcms4MDggPSBkZXZfZ2V0X2RydmRhdGEoZGV2KTsKPiAgCWludCByZXQgPSAwOwo+ICAKPiAg CXN3aXRjaCAocms4MDgtPnZhcmlhbnQpIHsKPiBAQCAtODA0LDIyICs2ODIsMTAgQEAgc3RhdGlj IGludCBfX21heWJlX3VudXNlZCByazh4eF9yZXN1bWUoc3RydWN0IGRldmljZSAqZGV2KQo+ICAK PiAgCXJldHVybiByZXQ7Cj4gIH0KPiAtc3RhdGljIFNJTVBMRV9ERVZfUE1fT1BTKHJrOHh4X3Bt X29wcywgcms4eHhfc3VzcGVuZCwgcms4eHhfcmVzdW1lKTsKPiAtCj4gLXN0YXRpYyBzdHJ1Y3Qg aTJjX2RyaXZlciByazgwOF9pMmNfZHJpdmVyID0gewo+IC0JLmRyaXZlciA9IHsKPiAtCQkubmFt ZSA9ICJyazgwOCIsCj4gLQkJLm9mX21hdGNoX3RhYmxlID0gcms4MDhfb2ZfbWF0Y2gsCj4gLQkJ LnBtID0gJnJrOHh4X3BtX29wcywKPiAtCX0sCj4gLQkucHJvYmUgICAgPSByazgwOF9wcm9iZSwK PiAtCS5zaHV0ZG93biA9IHJrOHh4X3NodXRkb3duLAo+IC19Owo+IC0KPiAtbW9kdWxlX2kyY19k cml2ZXIocms4MDhfaTJjX2RyaXZlcik7Cj4gK0VYUE9SVF9TWU1CT0xfR1BMKHJrOHh4X3Jlc3Vt ZSk7Cj4gIAo+ICBNT0RVTEVfTElDRU5TRSgiR1BMIik7Cj4gIE1PRFVMRV9BVVRIT1IoIkNocmlz IFpob25nIDx6eXdAcm9jay1jaGlwcy5jb20+Iik7Cj4gIE1PRFVMRV9BVVRIT1IoIlpoYW5nIFFp bmcgPHpoYW5ncWluZ0Byb2NrLWNoaXBzLmNvbT4iKTsKPiAgTU9EVUxFX0FVVEhPUigiV2FkaW0g RWdvcm92IDx3LmVnb3JvdkBwaHl0ZWMuZGU+Iik7Cj4gLU1PRFVMRV9ERVNDUklQVElPTigiUks4 MDgvUks4MTggUE1JQyBkcml2ZXIiKTsKPiArTU9EVUxFX0RFU0NSSVBUSU9OKCJSSzh4eCBQTUlD IGNvcmUiKTsKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZmQvcms4eHgtaTJjLmMgYi9kcml2ZXJz L21mZC9yazh4eC1pMmMuYwo+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4gaW5kZXggMDAwMDAwMDAw MDAwLi4zMjVkMGU1MTkzMjUKPiAtLS0gL2Rldi9udWxsCj4gKysrIGIvZHJpdmVycy9tZmQvcms4 eHgtaTJjLmMKPiBAQCAtMCwwICsxLDIwMyBAQAo+ICsvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmll cjogR1BMLTIuMC1vbmx5Cj4gKy8qCj4gKyAqIE1GRCBpMmMgZHJpdmVyIGZvciBSb2NrY2hpcCBS SzgwOC9SSzgxOAoKUGxlYXNlIGRyb3AgdGhlICJNRkQiIGhlcmUsIHNvOgoKICBSb2NrY2hpcCBS SzgwOC9SSzgxOCBDb3JlIChJMkMpIGRyaXZlcgogIAo+ICsgKiBDb3B5cmlnaHQgKGMpIDIwMTQs IEZ1emhvdSBSb2NrY2hpcCBFbGVjdHJvbmljcyBDby4sIEx0ZAo+ICsgKgo+ICsgKiBBdXRob3I6 IENocmlzIFpob25nIDx6eXdAcm9jay1jaGlwcy5jb20+Cj4gKyAqIEF1dGhvcjogWmhhbmcgUWlu ZyA8emhhbmdxaW5nQHJvY2stY2hpcHMuY29tPgo+ICsgKgo+ICsgKiBDb3B5cmlnaHQgKEMpIDIw MTYgUEhZVEVDIE1lc3N0ZWNobmlrIEdtYkgKPiArICoKPiArICogQXV0aG9yOiBXYWRpbSBFZ29y b3YgPHcuZWdvcm92QHBoeXRlYy5kZT4KPiArICovCgpUaGlzIGlzIGEgbmV3IGZpbGUsIHJpZ2h0 PyAgU28gdGhpcyBtaWdodCBuZWVkIHVwZGF0aW5nLgoKPiArI2luY2x1ZGUgPGxpbnV4L2kyYy5o Pgo+ICsjaW5jbHVkZSA8bGludXgvbWZkL3JrODA4Lmg+CgpZb3UncmUgbWlzc2luZyBpbmNsdWRl cyBoZXJlLgoKPiArc3RhdGljIGJvb2wgcms4MDhfaXNfdm9sYXRpbGVfcmVnKHN0cnVjdCBkZXZp Y2UgKmRldiwgdW5zaWduZWQgaW50IHJlZykKCiNpbmNsdWRlIDxsaW51eC9kZXZpY2UuaD4KCj4g K3sKPiArCS8qCj4gKwkgKiBOb3RlczoKPiArCSAqIC0gVGVjaG5pY2FsbHkgdGhlIFJPVU5EXzMw cyBiaXQgbWFrZXMgUlRDX0NUUkxfUkVHIHZvbGF0aWxlLCBidXQKPiArCSAqICAgd2UgZG9uJ3Qg dXNlIHRoYXQgZmVhdHVyZS4gIEl0J3MgYmV0dGVyIHRvIGNhY2hlLgo+ICsJICogLSBJdCdzIHVu bGlrZWx5IHdlIGNhcmUgdGhhdCBSSzgwOF9ERVZDVFJMX1JFRyBpcyB2b2xhdGlsZSBzaW5jZQo+ ICsJICogICBiaXRzIGFyZSBjbGVhcmVkIGluIGNhc2Ugd2hlbiB3ZSBzaHV0b2ZmIGFueXdheSwg YnV0IGJldHRlciBzYWZlLgo+ICsJICovCj4gKwo+ICsJc3dpdGNoIChyZWcpIHsKPiArCWNhc2Ug Uks4MDhfU0VDT05EU19SRUcgLi4uIFJLODA4X1dFRUtTX1JFRzoKPiArCWNhc2UgUks4MDhfUlRD X1NUQVRVU19SRUc6Cj4gKwljYXNlIFJLODA4X1ZCX01PTl9SRUc6Cj4gKwljYXNlIFJLODA4X1RI RVJNQUxfUkVHOgo+ICsJY2FzZSBSSzgwOF9EQ0RDX1VWX1NUU19SRUc6Cj4gKwljYXNlIFJLODA4 X0xET19VVl9TVFNfUkVHOgo+ICsJY2FzZSBSSzgwOF9EQ0RDX1BHX1JFRzoKPiArCWNhc2UgUks4 MDhfTERPX1BHX1JFRzoKPiArCWNhc2UgUks4MDhfREVWQ1RSTF9SRUc6Cj4gKwljYXNlIFJLODA4 X0lOVF9TVFNfUkVHMToKPiArCWNhc2UgUks4MDhfSU5UX1NUU19SRUcyOgo+ICsJCXJldHVybiB0 cnVlOwo+ICsJfQo+ICsKPiArCXJldHVybiBmYWxzZTsKPiArfQo+ICsKPiArc3RhdGljIGJvb2wg cms4MTdfaXNfdm9sYXRpbGVfcmVnKHN0cnVjdCBkZXZpY2UgKmRldiwgdW5zaWduZWQgaW50IHJl ZykKPiArewo+ICsJLyoKPiArCSAqIE5vdGVzOgo+ICsJICogLSBUZWNobmljYWxseSB0aGUgUk9V TkRfMzBzIGJpdCBtYWtlcyBSVENfQ1RSTF9SRUcgdm9sYXRpbGUsIGJ1dAo+ICsJICogICB3ZSBk b24ndCB1c2UgdGhhdCBmZWF0dXJlLiAgSXQncyBiZXR0ZXIgdG8gY2FjaGUuCj4gKwkgKi8KPiAr Cj4gKwlzd2l0Y2ggKHJlZykgewo+ICsJY2FzZSBSSzgxN19TRUNPTkRTX1JFRyAuLi4gUks4MTdf V0VFS1NfUkVHOgo+ICsJY2FzZSBSSzgxN19SVENfU1RBVFVTX1JFRzoKPiArCWNhc2UgUks4MTdf Q09ERUNfRFRPUF9MUFRfU1JTVDoKPiArCWNhc2UgUks4MTdfSU5UX1NUU19SRUcwOgo+ICsJY2Fz ZSBSSzgxN19JTlRfU1RTX1JFRzE6Cj4gKwljYXNlIFJLODE3X0lOVF9TVFNfUkVHMjoKPiArCWNh c2UgUks4MTdfU1lTX1NUUzoKPiArCQlyZXR1cm4gdHJ1ZTsKPiArCX0KPiArCj4gKwlyZXR1cm4g dHJ1ZTsKPiArfQo+ICsKPiArc3RhdGljIGNvbnN0IHN0cnVjdCByZWdtYXBfY29uZmlnIHJrODE4 X3JlZ21hcF9jb25maWcgPSB7CgojaW5jbHVkZSA8bGludXgvcmVnbWFwLmg+IGV0YyAtIHBsZWFz ZSBsb29rIGZvciBvdGhlcnMuCgo+ICsJLnJlZ19iaXRzID0gOCwKPiArCS52YWxfYml0cyA9IDgs Cj4gKwkubWF4X3JlZ2lzdGVyID0gUks4MThfVVNCX0NUUkxfUkVHLAo+ICsJLmNhY2hlX3R5cGUg PSBSRUdDQUNIRV9SQlRSRUUsCj4gKwkudm9sYXRpbGVfcmVnID0gcms4MDhfaXNfdm9sYXRpbGVf cmVnLAo+ICt9Owo+ICsKPiArc3RhdGljIGNvbnN0IHN0cnVjdCByZWdtYXBfY29uZmlnIHJrODA1 X3JlZ21hcF9jb25maWcgPSB7Cj4gKwkucmVnX2JpdHMgPSA4LAo+ICsJLnZhbF9iaXRzID0gOCwK PiArCS5tYXhfcmVnaXN0ZXIgPSBSSzgwNV9PRkZfU09VUkNFX1JFRywKPiArCS5jYWNoZV90eXBl ID0gUkVHQ0FDSEVfUkJUUkVFLAo+ICsJLnZvbGF0aWxlX3JlZyA9IHJrODA4X2lzX3ZvbGF0aWxl X3JlZywKPiArfTsKPiArCj4gK3N0YXRpYyBjb25zdCBzdHJ1Y3QgcmVnbWFwX2NvbmZpZyByazgw OF9yZWdtYXBfY29uZmlnID0gewo+ICsJLnJlZ19iaXRzID0gOCwKPiArCS52YWxfYml0cyA9IDgs Cj4gKwkubWF4X3JlZ2lzdGVyID0gUks4MDhfSU9fUE9MX1JFRywKPiArCS5jYWNoZV90eXBlID0g UkVHQ0FDSEVfUkJUUkVFLAo+ICsJLnZvbGF0aWxlX3JlZyA9IHJrODA4X2lzX3ZvbGF0aWxlX3Jl ZywKPiArfTsKPiArCj4gK3N0YXRpYyBjb25zdCBzdHJ1Y3QgcmVnbWFwX2NvbmZpZyByazgxN19y ZWdtYXBfY29uZmlnID0gewo+ICsJLnJlZ19iaXRzID0gOCwKPiArCS52YWxfYml0cyA9IDgsCj4g KwkubWF4X3JlZ2lzdGVyID0gUks4MTdfR1BJT19JTlRfQ0ZHLAo+ICsJLmNhY2hlX3R5cGUgPSBS RUdDQUNIRV9OT05FLAo+ICsJLnZvbGF0aWxlX3JlZyA9IHJrODE3X2lzX3ZvbGF0aWxlX3JlZywK PiArfTsKPiArCj4gK3N0YXRpYyBpbnQgcms4eHhfaTJjX2dldF92YXJpYW50KHN0cnVjdCBpMmNf Y2xpZW50ICpjbGllbnQpCj4gK3sKPiArCXU4IHBtaWNfaWRfbXNiLCBwbWljX2lkX2xzYjsKPiAr CWludCBtc2IsIGxzYjsKPiArCj4gKwlpZiAob2ZfZGV2aWNlX2lzX2NvbXBhdGlibGUoY2xpZW50 LT5kZXYub2Zfbm9kZSwgInJvY2tjaGlwLHJrODE3IikgfHwKPiArCSAgICBvZl9kZXZpY2VfaXNf Y29tcGF0aWJsZShjbGllbnQtPmRldi5vZl9ub2RlLCAicm9ja2NoaXAscms4MDkiKSkgewo+ICsJ CXBtaWNfaWRfbXNiID0gUks4MTdfSURfTVNCOwo+ICsJCXBtaWNfaWRfbHNiID0gUks4MTdfSURf TFNCOwo+ICsJfSBlbHNlIHsKPiArCQlwbWljX2lkX21zYiA9IFJLODA4X0lEX01TQjsKPiArCQlw bWljX2lkX2xzYiA9IFJLODA4X0lEX0xTQjsKPiArCX0KPiArCj4gKwkvKiBSZWFkIGNoaXAgdmFy aWFudCAqLwo+ICsJbXNiID0gaTJjX3NtYnVzX3JlYWRfYnl0ZV9kYXRhKGNsaWVudCwgcG1pY19p ZF9tc2IpOwo+ICsJaWYgKG1zYiA8IDApCj4gKwkJcmV0dXJuIGRldl9lcnJfcHJvYmUoJmNsaWVu dC0+ZGV2LCBtc2IsICJmYWlsZWQgdG8gcmVhZCB0aGUgY2hpcCBpZCBNU0JcbiIpOwo+ICsKPiAr CWxzYiA9IGkyY19zbWJ1c19yZWFkX2J5dGVfZGF0YShjbGllbnQsIHBtaWNfaWRfbHNiKTsKPiAr CWlmIChsc2IgPCAwKQo+ICsJCXJldHVybiBkZXZfZXJyX3Byb2JlKCZjbGllbnQtPmRldiwgbHNi LCAiZmFpbGVkIHRvIHJlYWQgdGhlIGNoaXAgaWQgTFNCXG4iKTsKPiArCj4gKwlyZXR1cm4gKCht c2IgPDwgOCkgfCBsc2IpICYgUks4WFhfSURfTVNLOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IHJr OHh4X2kyY19wcm9iZShzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50KQo+ICt7Cj4gKwljb25zdCBz dHJ1Y3QgcmVnbWFwX2NvbmZpZyAqcmVnbWFwX2NmZzsKPiArCXN0cnVjdCByZWdtYXAgKnJlZ21h cDsKPiArCWludCB2YXJpYW50Owo+ICsKPiArCXZhcmlhbnQgPSByazh4eF9pMmNfZ2V0X3Zhcmlh bnQoY2xpZW50KTsKPiArCWlmICh2YXJpYW50IDwgMCkKPiArCQlyZXR1cm4gdmFyaWFudDsKPiAr Cj4gKwlzd2l0Y2ggKHZhcmlhbnQpIHsKPiArCWNhc2UgUks4MDVfSUQ6Cj4gKwkJcmVnbWFwX2Nm ZyA9ICZyazgwNV9yZWdtYXBfY29uZmlnOwo+ICsJCWJyZWFrOwo+ICsJY2FzZSBSSzgwOF9JRDoK PiArCQlyZWdtYXBfY2ZnID0gJnJrODA4X3JlZ21hcF9jb25maWc7Cj4gKwkJYnJlYWs7Cj4gKwlj YXNlIFJLODE4X0lEOgo+ICsJCXJlZ21hcF9jZmcgPSAmcms4MThfcmVnbWFwX2NvbmZpZzsKPiAr CQlicmVhazsKPiArCWNhc2UgUks4MDlfSUQ6Cj4gKwljYXNlIFJLODE3X0lEOgo+ICsJCXJlZ21h cF9jZmcgPSAmcms4MTdfcmVnbWFwX2NvbmZpZzsKPiArCQlicmVhazsKPiArCWRlZmF1bHQ6Cj4g KwkJcmV0dXJuIGRldl9lcnJfcHJvYmUoJmNsaWVudC0+ZGV2LCAtRUlOVkFMLCAiVW5zdXBwb3J0 ZWQgUks4WFggSUQgJXhcbiIsIHZhcmlhbnQpOwo+ICsJfQo+ICsKPiArCXJlZ21hcCA9IGRldm1f cmVnbWFwX2luaXRfaTJjKGNsaWVudCwgcmVnbWFwX2NmZyk7Cj4gKwlpZiAoSVNfRVJSKHJlZ21h cCkpCj4gKwkJcmV0dXJuIGRldl9lcnJfcHJvYmUoJmNsaWVudC0+ZGV2LCBQVFJfRVJSKHJlZ21h cCksCj4gKwkJCQkgICAgICJyZWdtYXAgaW5pdGlhbGl6YXRpb24gZmFpbGVkXG4iKTsKPiArCj4g KwlyZXR1cm4gcms4eHhfcHJvYmUoJmNsaWVudC0+ZGV2LCB2YXJpYW50LCBjbGllbnQtPmlycSwg cmVnbWFwKTsKPiArfQo+ICsKPiArc3RhdGljIHZvaWQgcms4eHhfaTJjX3NodXRkb3duKHN0cnVj dCBpMmNfY2xpZW50ICpjbGllbnQpCj4gK3sKPiArCXJrOHh4X3NodXRkb3duKCZjbGllbnQtPmRl dik7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgX19tYXliZV91bnVzZWQgcms4eHhfaTJjX3N1c3Bl bmQoc3RydWN0IGRldmljZSAqZGV2KQo+ICt7Cj4gKwlyZXR1cm4gcms4eHhfc3VzcGVuZChkZXYp Owo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IF9fbWF5YmVfdW51c2VkIHJrOHh4X2kyY19yZXN1bWUo c3RydWN0IGRldmljZSAqZGV2KQo+ICt7Cj4gKwlyZXR1cm4gcms4eHhfcmVzdW1lKGRldik7Cj4g K30KPiArc3RhdGljIFNJTVBMRV9ERVZfUE1fT1BTKHJrOHh4X2kyY19wbV9vcHMsIHJrOHh4X2ky Y19zdXNwZW5kLCByazh4eF9pMmNfcmVzdW1lKTsKPiArCj4gK3N0YXRpYyBjb25zdCBzdHJ1Y3Qg b2ZfZGV2aWNlX2lkIHJrOHh4X2kyY19vZl9tYXRjaFtdID0gewo+ICsJeyAuY29tcGF0aWJsZSA9 ICJyb2NrY2hpcCxyazgwNSIgfSwKPiArCXsgLmNvbXBhdGlibGUgPSAicm9ja2NoaXAscms4MDgi IH0sCj4gKwl7IC5jb21wYXRpYmxlID0gInJvY2tjaGlwLHJrODA5IiB9LAo+ICsJeyAuY29tcGF0 aWJsZSA9ICJyb2NrY2hpcCxyazgxNyIgfSwKPiArCXsgLmNvbXBhdGlibGUgPSAicm9ja2NoaXAs cms4MTgiIH0sCj4gKwl7IH0sCj4gK307Cj4gK01PRFVMRV9ERVZJQ0VfVEFCTEUob2YsIHJrOHh4 X2kyY19vZl9tYXRjaCk7Cj4gKwo+ICtzdGF0aWMgc3RydWN0IGkyY19kcml2ZXIgcms4eHhfaTJj X2RyaXZlciA9IHsKPiArCS5kcml2ZXIgPSB7Cj4gKwkJLm5hbWUgPSAicms4eHgtaTJjIiwKPiAr CQkub2ZfbWF0Y2hfdGFibGUgPSByazh4eF9pMmNfb2ZfbWF0Y2gsCj4gKwkJLnBtID0gJnJrOHh4 X2kyY19wbV9vcHMsCj4gKwl9LAo+ICsJLnByb2JlX25ldyA9IHJrOHh4X2kyY19wcm9iZSwKPiAr CS5zaHV0ZG93biAgPSByazh4eF9pMmNfc2h1dGRvd24sCj4gK307Cj4gK21vZHVsZV9pMmNfZHJp dmVyKHJrOHh4X2kyY19kcml2ZXIpOwo+ICsKPiArTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOwo+ICtN T0RVTEVfQVVUSE9SKCJDaHJpcyBaaG9uZyA8enl3QHJvY2stY2hpcHMuY29tPiIpOwo+ICtNT0RV TEVfQVVUSE9SKCJaaGFuZyBRaW5nIDx6aGFuZ3FpbmdAcm9jay1jaGlwcy5jb20+Iik7Cj4gK01P RFVMRV9BVVRIT1IoIldhZGltIEVnb3JvdiA8dy5lZ29yb3ZAcGh5dGVjLmRlPiIpOwoKTm90IG1l bnRpb25lZCBpbiB0aGUgaGVhZGVyPwoKPiArTU9EVUxFX0RFU0NSSVBUSU9OKCJSSzh4eCBJMkMg UE1JQyBkcml2ZXIiKTsKPiBkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9tZmQvcms4MDguaCBi L2luY2x1ZGUvbGludXgvbWZkL3JrODA4LmgKPiBpbmRleCA5OTM3YjA2OGZhODIuLmM1ZGRmYjBl NTM1MyAxMDA2NDQKPiAtLS0gYS9pbmNsdWRlL2xpbnV4L21mZC9yazgwOC5oCj4gKysrIGIvaW5j bHVkZS9saW51eC9tZmQvcms4MDguaAo+IEBAIC03MDMsNCArNzAzLDEwIEBAIHN0cnVjdCByazgw OCB7Cj4gIAljb25zdCBzdHJ1Y3QgcmVnbWFwX2NvbmZpZwkqcmVnbWFwX2NmZzsKPiAgCWNvbnN0 IHN0cnVjdCByZWdtYXBfaXJxX2NoaXAJKnJlZ21hcF9pcnFfY2hpcDsKPiAgfTsKPiArCj4gK3Zv aWQgcms4eHhfc2h1dGRvd24oc3RydWN0IGRldmljZSAqZGV2KTsKPiAraW50IHJrOHh4X3Byb2Jl KHN0cnVjdCBkZXZpY2UgKmRldiwgaW50IHZhcmlhbnQsIHVuc2lnbmVkIGludCBpcnEsIHN0cnVj dCByZWdtYXAgKnJlZ21hcCk7Cj4gK2ludCByazh4eF9zdXNwZW5kKHN0cnVjdCBkZXZpY2UgKmRl dik7Cj4gK2ludCByazh4eF9yZXN1bWUoc3RydWN0IGRldmljZSAqZGV2KTsKPiArCj4gICNlbmRp ZiAvKiBfX0xJTlVYX1JFR1VMQVRPUl9SSzgwOF9IICovCgotLSAKTGVlIEpvbmVzIFvmnY7nkLzm lq9dCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpMaW51 eC1yb2NrY2hpcCBtYWlsaW5nIGxpc3QKTGludXgtcm9ja2NoaXBAbGlzdHMuaW5mcmFkZWFkLm9y ZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LXJvY2tj aGlwCg==