From mboxrd@z Thu Jan 1 00:00:00 1970 From: vnkgutta@codeaurora.org Subject: Re: [PATCH v2 3/4] drivers: edac: Add EDAC driver support for QCOM SoCs Date: Fri, 24 Aug 2018 12:47:27 -0700 Message-ID: <87d9cab4aec979e375950ba4b4d1e91a@codeaurora.org> References: <1534550915-18230-1-git-send-email-vnkgutta@codeaurora.org> <1534550915-18230-4-git-send-email-vnkgutta@codeaurora.org> <153512710906.28926.10438185172171294721@swboyd.mtv.corp.google.com> Mime-Version: 1.0 Content-Type: text/plain; charset=US-ASCII; format=flowed Content-Transfer-Encoding: 7bit Return-path: In-Reply-To: <153512710906.28926.10438185172171294721@swboyd.mtv.corp.google.com> Sender: linux-kernel-owner@vger.kernel.org To: Stephen Boyd Cc: Andy Gross , David Brown , bp@alien8.de, ckadabi@codeaurora.org, devicetree@vger.kernel.org, evgreen@chromium.org, linux-arm-msm@vger.kernel.org, linux-edac@vger.kernel.org, linux-kernel@vger.kernel.org, linux-soc@vger.kernel.org, mark.rutland@arm.com, mchehab@kernel.org, rishabhb@codeaurora.org, robh+dt@kernel.org, robh@kernel.org, tsoni@codeaurora.org List-Id: linux-arm-msm@vger.kernel.org On 2018-08-24 09:11, Stephen Boyd wrote: > Quoting Venkata Narendra Kumar Gutta (2018-08-17 17:08:34) >> diff --git a/drivers/edac/Kconfig b/drivers/edac/Kconfig >> index 57304b2..da8f150 100644 >> --- a/drivers/edac/Kconfig >> +++ b/drivers/edac/Kconfig >> @@ -460,4 +460,32 @@ config EDAC_TI >> Support for error detection and correction on the >> TI SoCs. >> >> +config EDAC_QCOM >> + tristate "QCOM EDAC Controller" >> + depends on EDAC >> + help >> + Support for error detection and correction on the >> + QCOM SoCs. >> + >> +config EDAC_QCOM_LLCC >> + tristate "QCOM EDAC Controller for LLCC Cache" >> + depends on EDAC_QCOM && QCOM_LLCC >> + help >> + Support for error detection and correction on the >> + QCOM LLCC cache. Report errors caught by LLCC ECC >> + mechanism. >> + >> + For debugging issues having to do with stability and overall >> system >> + health, you should probably say 'Y' here. >> + >> +config EDAC_QCOM_LLCC_PANIC_ON_UE >> + bool "Panic on uncorrectable errors - qcom llcc" > > Why isn't this a generic option for all EDAC? I'm not sure, I'll get back to you on this. > >> + depends on EDAC_QCOM_LLCC >> + help >> + Forcibly cause a kernel panic if an uncorrectable error (UE) >> is >> + detected. This can reduce debugging times on hardware which >> may be >> + operating at voltages or frequencies outside normal >> specification. >> + >> + For production builds, you should probably say 'N' here. >> + >> endif # EDAC >> diff --git a/drivers/edac/Makefile b/drivers/edac/Makefile >> index 02b43a7..716096d 100644 >> --- a/drivers/edac/Makefile >> +++ b/drivers/edac/Makefile >> @@ -77,3 +77,4 @@ obj-$(CONFIG_EDAC_ALTERA) += >> altera_edac.o >> obj-$(CONFIG_EDAC_SYNOPSYS) += synopsys_edac.o >> obj-$(CONFIG_EDAC_XGENE) += xgene_edac.o >> obj-$(CONFIG_EDAC_TI) += ti_edac.o >> +obj-$(CONFIG_EDAC_QCOM) += qcom_edac.o > > Maybe put this in sort of alphabetical order so conflicts don't happen. None of them are in alphabetical order, so I'm not sure where to start! what do you suggest? > >> diff --git a/drivers/edac/qcom_edac.c b/drivers/edac/qcom_edac.c >> new file mode 100644 >> index 0000000..9a8c670 >> --- /dev/null >> +++ b/drivers/edac/qcom_edac.c >> @@ -0,0 +1,446 @@ >> +// SPDX-License-Identifier: GPL-2.0 >> +/* >> + * Copyright (c) 2018, The Linux Foundation. All rights reserved. >> + */ >> + >> +#include >> +#include >> +#include >> +#include > > Used? Maybe it should just be linux/of.h Ok, I'll check and update. > >> +#include >> +#include >> +#include > > Why? I'll check if this is being used, otherwise, I'll remove it. > >> +#include >> + >> +#include "edac_mc.h" >> +#include "edac_device.h" >> + >> +#ifdef CONFIG_EDAC_QCOM_LLCC_PANIC_ON_UE >> +#define LLCC_ERP_PANIC_ON_UE 1 >> +#else >> +#define LLCC_ERP_PANIC_ON_UE 0 >> +#endif >> + >> +#define EDAC_LLCC "qcom_llcc" >> + >> +#define TRP_SYN_REG_CNT 6 >> + >> +#define DRP_SYN_REG_CNT 8 >> + >> +#define LLCC_COMMON_STATUS0 0x0003000C >> +#define LLCC_LB_CNT_MASK GENMASK(31, 28) >> +#define LLCC_LB_CNT_SHIFT 28 >> + >> +/* single & Double Bit syndrome register offsets */ >> +#define TRP_ECC_SB_ERR_SYN0 0x0002304C >> +#define TRP_ECC_DB_ERR_SYN0 0x00020370 >> +#define DRP_ECC_SB_ERR_SYN0 0x0004204C >> +#define DRP_ECC_DB_ERR_SYN0 0x00042070 >> + >> +/* Error register offsets */ >> +#define TRP_ECC_ERROR_STATUS1 0x00020348 >> +#define TRP_ECC_ERROR_STATUS0 0x00020344 >> +#define DRP_ECC_ERROR_STATUS1 0x00042048 >> +#define DRP_ECC_ERROR_STATUS0 0x00042044 >> + >> +/* TRP, DRP interrupt register offsets */ >> +#define DRP_INTERRUPT_STATUS 0x00041000 >> +#define TRP_INTERRUPT_0_STATUS 0x00020480 >> +#define DRP_INTERRUPT_CLEAR 0x00041008 >> +#define DRP_ECC_ERROR_CNTR_CLEAR 0x00040004 >> +#define TRP_INTERRUPT_0_CLEAR 0x00020484 >> +#define TRP_ECC_ERROR_CNTR_CLEAR 0x00020440 >> + >> +/* Mask and shift macros */ >> +#define ECC_DB_ERR_COUNT_MASK GENMASK(4, 0) >> +#define ECC_DB_ERR_WAYS_MASK GENMASK(31, 16) >> +#define ECC_DB_ERR_WAYS_SHIFT BIT(4) >> + >> +#define ECC_SB_ERR_COUNT_MASK GENMASK(23, 16) >> +#define ECC_SB_ERR_COUNT_SHIFT BIT(4) >> +#define ECC_SB_ERR_WAYS_MASK GENMASK(15, 0) >> + >> +#define SB_ECC_ERROR BIT(0) >> +#define DB_ECC_ERROR BIT(1) >> + >> +#define DRP_TRP_INT_CLEAR GENMASK(1, 0) >> +#define DRP_TRP_CNT_CLEAR GENMASK(1, 0) >> + >> +/* Config registers offsets*/ >> +#define DRP_ECC_ERROR_CFG 0x00040000 >> + >> +/* TRP, DRP interrupt register offsets */ >> +#define CMN_INTERRUPT_0_ENABLE 0x0003001C >> +#define CMN_INTERRUPT_2_ENABLE 0x0003003C >> +#define TRP_INTERRUPT_0_ENABLE 0x00020488 >> +#define DRP_INTERRUPT_ENABLE 0x0004100C >> + >> +#define SB_ERROR_THRESHOLD 0x1 >> +#define SB_ERROR_THRESHOLD_SHIFT 24 >> +#define SB_DB_TRP_INTERRUPT_ENABLE 0x3 >> +#define TRP0_INTERRUPT_ENABLE 0x1 >> +#define DRP0_INTERRUPT_ENABLE BIT(6) >> +#define SB_DB_DRP_INTERRUPT_ENABLE 0x3 >> + >> +enum { >> + LLCC_DRAM_CE = 0, >> + LLCC_DRAM_UE, >> + LLCC_TRAM_CE, >> + LLCC_TRAM_UE, >> + LLCC_ERR_TYPE_MAX = LLCC_TRAM_UE + 1, > > What's the point? I was using this to have a sentinel value for this enum, which can be used initially to allocate the memory and later for any kind of error checks. I'll remove this as we are anyway getting rid of this allocation and I'm not doing any error checks for now. > >> +}; >> + >> +static int qcom_llcc_core_setup(struct regmap *llcc_bcast_regmap) >> +{ >> + u32 sb_err_threshold; >> + int ret; >> + >> + /* Enable TRP in instance 2 of common interrupt enable >> register */ > > What is TRP? This is in reference to Tag Ram, I'll expand this one. > >> + ret = regmap_update_bits(llcc_bcast_regmap, >> CMN_INTERRUPT_2_ENABLE, >> + TRP0_INTERRUPT_ENABLE, >> + TRP0_INTERRUPT_ENABLE); >> + if (ret) >> + return ret; >> + >> + /* Enable ECC interrupts on Tag Ram */ >> + ret = regmap_update_bits(llcc_bcast_regmap, >> TRP_INTERRUPT_0_ENABLE, >> + SB_DB_TRP_INTERRUPT_ENABLE, >> + SB_DB_TRP_INTERRUPT_ENABLE); >> + if (ret) >> + return ret; >> + >> + /* Enable SB error for Data RAM */ > > SB is single bit? Yes, Single bit, I'll expand this one. > >> + sb_err_threshold = (SB_ERROR_THRESHOLD << >> SB_ERROR_THRESHOLD_SHIFT); >> + ret = regmap_write(llcc_bcast_regmap, DRP_ECC_ERROR_CFG, >> + sb_err_threshold); >> + if (ret) >> + return ret; >> + >> + /* Enable DRP in instance 2 of common interrupt enable >> register */ > > DRP is double bit? No, This is in reference to Data Ram, May be I should expand this one too. > >> + ret = regmap_update_bits(llcc_bcast_regmap, >> CMN_INTERRUPT_2_ENABLE, >> + DRP0_INTERRUPT_ENABLE, >> + DRP0_INTERRUPT_ENABLE); >> + if (ret) >> + return ret; >> + >> + /* Enable ECC interrupts on Data Ram */ >> + ret = regmap_write(llcc_bcast_regmap, DRP_INTERRUPT_ENABLE, >> + SB_DB_DRP_INTERRUPT_ENABLE); >> + return ret; >> +} >> + >> +/* Clear the error interrupt and counter registers */ >> +static int >> +qcom_llcc_clear_errors_status(int err_type, struct llcc_drv_data >> *drv) >> +{ >> + int ret = 0; >> + >> + switch (err_type) { >> + case LLCC_DRAM_CE: >> + case LLCC_DRAM_UE: >> + /* Clear the interrupt */ >> + ret = regmap_write(drv->bcast_regmap, >> DRP_INTERRUPT_CLEAR, >> + DRP_TRP_INT_CLEAR); >> + if (ret) >> + return ret; >> + >> + /* Clear the counters */ > > A lot of these comments are just saying what the register write is > doing > which is fairly obvious from the register names. Can you remove these > obvious comments? Ok, Done. I'll update this in the next patchset. > >> + ret = regmap_write(drv->bcast_regmap, >> DRP_ECC_ERROR_CNTR_CLEAR, >> + DRP_TRP_CNT_CLEAR); >> + if (ret) >> + return ret; >> + break; >> + case LLCC_TRAM_CE: >> + case LLCC_TRAM_UE: >> + ret = regmap_write(drv->bcast_regmap, >> TRP_INTERRUPT_0_CLEAR, >> + DRP_TRP_INT_CLEAR); >> + if (ret) >> + return ret; >> + >> + ret = regmap_write(drv->bcast_regmap, >> TRP_ECC_ERROR_CNTR_CLEAR, >> + DRP_TRP_CNT_CLEAR); >> + if (ret) >> + return ret; >> + break; >> + } >> + return ret; >> +} >> + >> +/* Dump Syndrome registers data for Tag RAM, Data RAM bit errors*/ >> +static int >> +dump_syn_reg_values(struct llcc_drv_data *drv, u32 bank, int >> err_type) >> +{ >> + struct llcc_edac_reg_data *reg_data = >> &(drv->edac_reg[err_type]); > > const? Also, drop the useless parenthesis. Ok, done. > >> + int err_cnt, err_ways, ret, i; >> + u32 synd_reg, synd_val; >> + >> + for (i = 0; i < reg_data->reg_cnt; i++) { >> + synd_reg = reg_data->synd_reg + (i * 4); >> + ret = regmap_read(drv->regmap, drv->offsets[bank] + >> synd_reg, >> + &synd_val); >> + if (ret) >> + goto clear; >> + edac_printk(KERN_CRIT, EDAC_LLCC, "%s: ECC_SYN%d: >> 0x%8x\n", >> + reg_data->err_name, i, synd_val); >> + } >> + >> + ret = regmap_read(drv->regmap, >> + drv->offsets[bank] + >> reg_data->err_status_reg, >> + &err_cnt); >> + if (ret) >> + goto clear; >> + >> + err_cnt &= reg_data->err_count_mask; >> + err_cnt >>= reg_data->err_count_shift; >> + edac_printk(KERN_CRIT, EDAC_LLCC, "%s: error count: 0x%4x\n", >> + reg_data->err_name, err_cnt); >> + >> + ret = regmap_read(drv->regmap, >> + drv->offsets[bank] + >> reg_data->err_ways_status, >> + &err_ways); >> + if (ret) >> + goto clear; >> + >> + err_ways &= reg_data->err_ways_mask; >> + err_ways >>= reg_data->err_ways_shift; >> + >> + edac_printk(KERN_CRIT, EDAC_LLCC, "%s: error ways: 0x%4x\n", >> + reg_data->err_name, err_ways); >> + >> +clear: >> + ret = qcom_llcc_clear_errors_status(err_type, drv); >> + return ret; > > Just 'return qcom_llcc_clear_errors_status(...)' Done. > >> +} >> + >> +static int >> +dump_syn_reg(struct edac_device_ctl_info *edev_ctl, int err_type, u32 >> bank) >> +{ >> + struct llcc_drv_data *drv = edev_ctl->pvt_info; >> + int ret = 0; > > Please don't assign local variables at the start of a function and then > reassign them again immediately after. It hides initialization > problems. I did this because the compiler was throwing some warnings, I'll try to get that and see if this is really needed. > >> + >> + ret = dump_syn_reg_values(drv, bank, err_type); >> + if (ret) >> + return ret; >> + >> + switch (err_type) { >> + case LLCC_DRAM_CE: >> + edac_device_handle_ce(edev_ctl, 0, bank, >> + "LLCC Data RAM correctable >> Error"); >> + break; >> + case LLCC_DRAM_UE: >> + edac_device_handle_ue(edev_ctl, 0, bank, >> + "LLCC Data RAM uncorrectable >> Error"); >> + break; >> + case LLCC_TRAM_CE: >> + edac_device_handle_ce(edev_ctl, 0, bank, >> + "LLCC Tag RAM correctable >> Error"); >> + break; >> + case LLCC_TRAM_UE: >> + edac_device_handle_ue(edev_ctl, 0, bank, >> + "LLCC Tag RAM uncorrectable >> Error"); >> + break; >> + } >> + >> + return ret; >> +} >> + >> +static irqreturn_t >> +llcc_ecc_irq_handler(int irq, void *edev_ctl) >> +{ >> + struct edac_device_ctl_info *edac_dev_ctl; >> + irqreturn_t irq_rc = IRQ_NONE; >> + u32 drp_error, trp_error, i; >> + struct llcc_drv_data *drv; >> + int ret; >> + >> + edac_dev_ctl = (struct edac_device_ctl_info *)edev_ctl; > > Remove useless cast please. Forgot to update this, I'll do it. > >> + drv = edac_dev_ctl->pvt_info; >> + >> + for (i = 0; i < drv->num_banks; i++) { >> + /* Look for Data RAM errors */ >> + ret = regmap_read(drv->regmap, >> + drv->offsets[i] + >> DRP_INTERRUPT_STATUS, >> + &drp_error); >> + if (ret) >> + return irq_rc; >> + >> + if (drp_error & SB_ECC_ERROR) { >> + edac_printk(KERN_CRIT, EDAC_LLCC, >> + "Single Bit Error detected in Data >> Ram\n"); >> + ret = dump_syn_reg(edev_ctl, LLCC_DRAM_CE, i); >> + if (!ret) >> + irq_rc = IRQ_HANDLED; > > Rename 'irq_rc' to 'handled' and make it a bool and then break from all > these 'return irq_rc' places and 'if (handled) return IRQ_HANDLED; > return IRQ_NONE;' at the end of this function so we have one exit point > from the irq handler. Ok, I'll try to optimize the logic here. > >> + } else if (drp_error & DB_ECC_ERROR) { >> + edac_printk(KERN_CRIT, EDAC_LLCC, >> + "Double Bit Error detected in Data >> Ram\n"); >> + ret = dump_syn_reg(edev_ctl, LLCC_DRAM_UE, i); >> + if (!ret) >> + irq_rc = IRQ_HANDLED; >> + } >> + >> + /* Look for Tag RAM errors */ >> + ret = regmap_read(drv->regmap, >> + drv->offsets[i] + >> TRP_INTERRUPT_0_STATUS, >> + &trp_error); >> + if (ret) >> + return irq_rc; >> + >> + if (trp_error & SB_ECC_ERROR) { >> + edac_printk(KERN_CRIT, EDAC_LLCC, >> + "Single Bit Error detected in Tag >> Ram\n"); >> + ret = dump_syn_reg(edev_ctl, LLCC_TRAM_CE, i); >> + if (!ret) >> + irq_rc = IRQ_HANDLED; >> + } else if (trp_error & DB_ECC_ERROR) { >> + edac_printk(KERN_CRIT, EDAC_LLCC, >> + "Double Bit Error detected in Tag >> Ram\n"); >> + ret = dump_syn_reg(edev_ctl, LLCC_TRAM_UE, i); >> + if (!ret) >> + irq_rc = IRQ_HANDLED; >> + } >> + } >> + >> + return irq_rc; >> +} >> + >> +static void llcc_edac_reg_data_init(struct llcc_edac_reg_data >> *edac_reg) >> +{ >> + >> + struct llcc_edac_reg_data *reg_data; >> + >> + /* Initialize register info for LLCC_DRAM_CE */ >> + reg_data = &edac_reg[LLCC_DRAM_CE]; >> + reg_data->err_name = "DRAM Single-bit"; >> + reg_data->reg_cnt = DRP_SYN_REG_CNT; >> + reg_data->synd_reg = DRP_ECC_SB_ERR_SYN0; >> + reg_data->err_status_reg = DRP_ECC_ERROR_STATUS1; >> + reg_data->err_count_mask = ECC_SB_ERR_COUNT_MASK; >> + reg_data->err_count_shift = ECC_SB_ERR_COUNT_SHIFT; >> + reg_data->err_ways_status = DRP_ECC_ERROR_STATUS0; >> + reg_data->err_ways_mask = ECC_SB_ERR_WAYS_MASK; >> + >> + /* Initialize register info for LLCC_DRAM_UE */ >> + reg_data = &edac_reg[LLCC_DRAM_UE]; >> + reg_data->err_name = "DRAM Double-bit"; >> + reg_data->reg_cnt = DRP_SYN_REG_CNT; >> + reg_data->synd_reg = DRP_ECC_DB_ERR_SYN0; >> + reg_data->err_status_reg = DRP_ECC_ERROR_STATUS1; >> + reg_data->err_count_mask = ECC_DB_ERR_COUNT_MASK; >> + reg_data->err_ways_status = DRP_ECC_ERROR_STATUS0; >> + reg_data->err_ways_mask = ECC_DB_ERR_WAYS_MASK; >> + reg_data->err_ways_shift = ECC_DB_ERR_WAYS_SHIFT; >> + >> + /* Initialize register info for LLCC_TRAM_CE */ >> + reg_data = &edac_reg[LLCC_TRAM_CE]; >> + reg_data->err_name = "TRAM Single-bit"; >> + reg_data->reg_cnt = TRP_SYN_REG_CNT; >> + reg_data->synd_reg = TRP_ECC_SB_ERR_SYN0; >> + reg_data->err_status_reg = TRP_ECC_ERROR_STATUS1; >> + reg_data->err_count_mask = ECC_SB_ERR_COUNT_MASK; >> + reg_data->err_count_shift = ECC_SB_ERR_COUNT_SHIFT; >> + reg_data->err_ways_status = TRP_ECC_ERROR_STATUS0; >> + reg_data->err_ways_mask = ECC_SB_ERR_WAYS_MASK; >> + >> + /* Initialize register info for LLCC_TRAM_UE */ >> + reg_data = &edac_reg[LLCC_TRAM_UE]; >> + reg_data->err_name = "TRAM Double-bit"; >> + reg_data->reg_cnt = TRP_SYN_REG_CNT; >> + reg_data->synd_reg = TRP_ECC_DB_ERR_SYN0; >> + reg_data->err_status_reg = TRP_ECC_ERROR_STATUS1; >> + reg_data->err_count_mask = ECC_DB_ERR_COUNT_MASK; >> + reg_data->err_ways_status = TRP_ECC_ERROR_STATUS0; >> + reg_data->err_ways_mask = ECC_DB_ERR_WAYS_MASK; >> + reg_data->err_ways_shift = ECC_DB_ERR_WAYS_SHIFT; > > Why can't these things be a static const array that the driver looks up > in? What's the point of it being per-device instance? Yeah, we don't need this struct to be populated per device. That makes sense. I'll make this initialization static. > >> +} >> + >> +static int qcom_llcc_edac_probe(struct platform_device *pdev) >> +{ >> + struct llcc_drv_data *llcc_driv_data = >> pdev->dev.platform_data; >> + struct edac_device_ctl_info *edev_ctl; >> + struct device *dev = &pdev->dev; >> + int ecc_irq; >> + int rc; >> + >> + /* Initialize register set for the error types*/ >> + llcc_driv_data->edac_reg = devm_kcalloc(dev, >> LLCC_ERR_TYPE_MAX, >> + sizeof(struct >> llcc_edac_reg_data), >> + GFP_KERNEL); >> + llcc_edac_reg_data_init(llcc_driv_data->edac_reg); >> + >> + rc = qcom_llcc_core_setup(llcc_driv_data->bcast_regmap); >> + if (rc) >> + return rc; >> + >> + /* Allocate edac control info */ >> + edev_ctl = edac_device_alloc_ctl_info(0, "qcom-llcc", 1, >> "bank", >> + >> llcc_driv_data->num_banks, 1, >> + NULL, 0, >> + >> edac_device_alloc_index()); >> + >> + if (!edev_ctl) >> + return -ENOMEM; >> + >> + edev_ctl->dev = dev; >> + edev_ctl->mod_name = dev_name(dev); >> + edev_ctl->dev_name = dev_name(dev); >> + edev_ctl->ctl_name = "llcc"; >> + edev_ctl->panic_on_ue = LLCC_ERP_PANIC_ON_UE; >> + edev_ctl->pvt_info = llcc_driv_data; >> + >> + rc = edac_device_add_device(edev_ctl); >> + if (rc) >> + goto out_mem; >> + >> + platform_set_drvdata(pdev, edev_ctl); >> + >> + /* Request for ecc irq */ >> + ecc_irq = llcc_driv_data->ecc_irq; >> + if (ecc_irq < 0) { >> + rc = -ENODEV; > > Return error code from platform_get_irq()? Oh, that's weird. Why is > some/ > other driver getting and storing the irq away? Hopefully it isn't a > shared IRQ. No, it isn't a shared irq. LLCC EDAC platform driver is registered from LLCC and the interrupt values are populated there. Check this patch [[PATCH v2 2/4] drivers: soc: Add support to register LLCC EDAC driver] > >> + goto out_dev; >> + } >> + rc = devm_request_irq(dev, ecc_irq, llcc_ecc_irq_handler, >> + IRQF_TRIGGER_HIGH, "llcc_ecc", >> edev_ctl); >> + if (rc) >> + goto out_dev; >> + >> + return rc; >> + >> +out_dev: >> + edac_device_del_device(edev_ctl->dev); >> +out_mem: >> + edac_device_free_ctl_info(edev_ctl); >> + >> + return rc; >> +} >> + >> +static int qcom_llcc_edac_remove(struct platform_device *pdev) >> +{ >> + struct edac_device_ctl_info *edev_ctl = >> dev_get_drvdata(&pdev->dev); >> + >> + edac_device_del_device(edev_ctl->dev); >> + edac_device_free_ctl_info(edev_ctl); >> + platform_set_drvdata(pdev, NULL); > > No need. Don't set platform data to NULL. Why? I was asked to set this explicitly. It'd be good to know why I don't need this. Is it taken care of by framework explicitly? > >> + >> + return 0; >> +} >> + >> +static const struct of_device_id qcom_llcc_edac_match_table[] = { >> +#ifdef EDAC_QCOM_LLCC > > Huh? Shouldn't this driver only be compiled when this config is > enabled? No this driver is a generic qcom edac driver, and the llcc-edac will come into picture only when this config is enabled. We updated this as per the initial comments on to maintain this driver generically > >> + { .compatible = "qcom,llcc-edac" }, >> +#endif >> + { }, >> +}; >> + >> +static struct platform_driver qcom_llcc_edac_driver = { >> + .probe = qcom_llcc_edac_probe, >> + .remove = qcom_llcc_edac_remove, >> + .driver = { >> + .name = "qcom_llcc_edac", >> + .of_match_table = qcom_llcc_edac_match_table, >> + }, >> +}; >> +module_platform_driver(qcom_llcc_edac_driver); >> + >> +MODULE_DESCRIPTION("QCOM EDAC driver"); >> +MODULE_LICENSE("GPL v2"); >> diff --git a/include/linux/soc/qcom/llcc-qcom.h >> b/include/linux/soc/qcom/llcc-qcom.h >> index 2e4b34d..25096e0 100644 >> --- a/include/linux/soc/qcom/llcc-qcom.h >> +++ b/include/linux/soc/qcom/llcc-qcom.h >> @@ -84,6 +84,7 @@ struct llcc_drv_data { >> struct regmap *regmap; >> struct regmap *bcast_regmap; >> const struct llcc_slice_config *cfg; >> + struct llcc_edac_reg_data *edac_reg; > > Why a pointer instead of an array of proper size? I wanted to have it dynamic, so that if you want to add more error types you don't need to update this one. Anyhow, I'm removing this one to make this struct initialization static. > >> struct mutex lock; >> u32 cfg_size; >> u32 max_slices; >> @@ -93,6 +94,30 @@ struct llcc_drv_data { >> int ecc_irq; >> }; >> >> +/** >> + * llcc_edac_reg_data - llcc edac registers data for each error type >> + * @err_name: name of the error >> + * @reg_cnt: number of registers >> + * @synd_reg: syndrome register address >> + * @err_status_reg: Status register address to read the error count >> + * @err_count_mask: Mask value to get the error count >> + * @err_count_shift: Shift value to get the error count >> + * @err_ways_status: Status register address to read error ways >> + * @err_ways_mask: Mask value to get the error ways >> + * @err_ways_shift: Shift value to get the error ways >> + */ >> +struct llcc_edac_reg_data { >> + char *err_name; > > Just name instead? I don't think "name" itself doesn't convey anything. I wanted to have better convention, hence this variable. > >> + int reg_cnt; >> + int synd_reg; >> + int err_status_reg; >> + int err_count_mask; >> + int err_count_shift; >> + int err_ways_status; >> + int err_ways_mask; >> + int err_ways_shift; > > Do any of these need to be signed types? Use u8 for register offsets > and > shifts, u32 for masks and unsigned ints for counts please. Sure, that makes sense, I'll update the data types. > >> +}; From mboxrd@z Thu Jan 1 00:00:00 1970 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: base64 Subject: [v2,3/4] drivers: edac: Add EDAC driver support for QCOM SoCs From: Venkata Narendra Kumar Gutta Message-Id: <87d9cab4aec979e375950ba4b4d1e91a@codeaurora.org> Date: Fri, 24 Aug 2018 12:47:27 -0700 To: Stephen Boyd Cc: Andy Gross , David Brown , bp@alien8.de, ckadabi@codeaurora.org, devicetree@vger.kernel.org, evgreen@chromium.org, linux-arm-msm@vger.kernel.org, linux-edac@vger.kernel.org, linux-kernel@vger.kernel.org, linux-soc@vger.kernel.org, mark.rutland@arm.com, mchehab@kernel.org, rishabhb@codeaurora.org, robh+dt@kernel.org, robh@kernel.org, tsoni@codeaurora.org List-ID: T24gMjAxOC0wOC0yNCAwOToxMSwgU3RlcGhlbiBCb3lkIHdyb3RlOgo+IFF1b3RpbmcgVmVua2F0 YSBOYXJlbmRyYSBLdW1hciBHdXR0YSAoMjAxOC0wOC0xNyAxNzowODozNCkKPj4gZGlmZiAtLWdp dCBhL2RyaXZlcnMvZWRhYy9LY29uZmlnIGIvZHJpdmVycy9lZGFjL0tjb25maWcKPj4gaW5kZXgg NTczMDRiMi4uZGE4ZjE1MCAxMDA2NDQKPj4gLS0tIGEvZHJpdmVycy9lZGFjL0tjb25maWcKPj4g KysrIGIvZHJpdmVycy9lZGFjL0tjb25maWcKPj4gQEAgLTQ2MCw0ICs0NjAsMzIgQEAgY29uZmln IEVEQUNfVEkKPj4gICAgICAgICAgIFN1cHBvcnQgZm9yIGVycm9yIGRldGVjdGlvbiBhbmQgY29y cmVjdGlvbiBvbiB0aGUKPj4gICAgICAgICAgICBUSSBTb0NzLgo+PiAKPj4gK2NvbmZpZyBFREFD X1FDT00KPj4gKyAgICAgICB0cmlzdGF0ZSAiUUNPTSBFREFDIENvbnRyb2xsZXIiCj4+ICsgICAg ICAgZGVwZW5kcyBvbiBFREFDCj4+ICsgICAgICAgaGVscAo+PiArICAgICAgICAgU3VwcG9ydCBm b3IgZXJyb3IgZGV0ZWN0aW9uIGFuZCBjb3JyZWN0aW9uIG9uIHRoZQo+PiArICAgICAgICAgUUNP TSBTb0NzLgo+PiArCj4+ICtjb25maWcgRURBQ19RQ09NX0xMQ0MKPj4gKyAgICAgICB0cmlzdGF0 ZSAiUUNPTSBFREFDIENvbnRyb2xsZXIgZm9yIExMQ0MgQ2FjaGUiCj4+ICsgICAgICAgZGVwZW5k cyBvbiBFREFDX1FDT00gJiYgUUNPTV9MTENDCj4+ICsgICAgICAgaGVscAo+PiArICAgICAgICAg U3VwcG9ydCBmb3IgZXJyb3IgZGV0ZWN0aW9uIGFuZCBjb3JyZWN0aW9uIG9uIHRoZQo+PiArICAg ICAgICAgUUNPTSBMTENDIGNhY2hlLiBSZXBvcnQgZXJyb3JzIGNhdWdodCBieSBMTENDIEVDQwo+ PiArICAgICAgICAgbWVjaGFuaXNtLgo+PiArCj4+ICsgICAgICAgICBGb3IgZGVidWdnaW5nIGlz c3VlcyBoYXZpbmcgdG8gZG8gd2l0aCBzdGFiaWxpdHkgYW5kIG92ZXJhbGwgCj4+IHN5c3RlbQo+ PiArICAgICAgICAgIGhlYWx0aCwgeW91IHNob3VsZCBwcm9iYWJseSBzYXkgJ1knIGhlcmUuCj4+ ICsKPj4gK2NvbmZpZyBFREFDX1FDT01fTExDQ19QQU5JQ19PTl9VRQo+PiArICAgICAgIGJvb2wg IlBhbmljIG9uIHVuY29ycmVjdGFibGUgZXJyb3JzIC0gcWNvbSBsbGNjIgo+IAo+IFdoeSBpc24n dCB0aGlzIGEgZ2VuZXJpYyBvcHRpb24gZm9yIGFsbCBFREFDPwoKSSdtIG5vdCBzdXJlLCBJJ2xs IGdldCBiYWNrIHRvIHlvdSBvbiB0aGlzLgoKPiAKPj4gKyAgICAgICBkZXBlbmRzIG9uIEVEQUNf UUNPTV9MTENDCj4+ICsgICAgICAgaGVscAo+PiArICAgICAgICAgRm9yY2libHkgY2F1c2UgYSBr ZXJuZWwgcGFuaWMgaWYgYW4gdW5jb3JyZWN0YWJsZSBlcnJvciAoVUUpIAo+PiBpcwo+PiArICAg ICAgICAgZGV0ZWN0ZWQuIFRoaXMgY2FuIHJlZHVjZSBkZWJ1Z2dpbmcgdGltZXMgb24gaGFyZHdh cmUgd2hpY2ggCj4+IG1heSBiZQo+PiArICAgICAgICAgb3BlcmF0aW5nIGF0IHZvbHRhZ2VzIG9y IGZyZXF1ZW5jaWVzIG91dHNpZGUgbm9ybWFsIAo+PiBzcGVjaWZpY2F0aW9uLgo+PiArCj4+ICsg ICAgICAgICBGb3IgcHJvZHVjdGlvbiBidWlsZHMsIHlvdSBzaG91bGQgcHJvYmFibHkgc2F5ICdO JyBoZXJlLgo+PiArCj4+ICBlbmRpZiAjIEVEQUMKPj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvZWRh Yy9NYWtlZmlsZSBiL2RyaXZlcnMvZWRhYy9NYWtlZmlsZQo+PiBpbmRleCAwMmI0M2E3Li43MTYw OTZkIDEwMDY0NAo+PiAtLS0gYS9kcml2ZXJzL2VkYWMvTWFrZWZpbGUKPj4gKysrIGIvZHJpdmVy cy9lZGFjL01ha2VmaWxlCj4+IEBAIC03NywzICs3Nyw0IEBAIG9iai0kKENPTkZJR19FREFDX0FM VEVSQSkgICAgICAgICAgICAgKz0gCj4+IGFsdGVyYV9lZGFjLm8KPj4gIG9iai0kKENPTkZJR19F REFDX1NZTk9QU1lTKSAgICAgICAgICAgICs9IHN5bm9wc3lzX2VkYWMubwo+PiAgb2JqLSQoQ09O RklHX0VEQUNfWEdFTkUpICAgICAgICAgICAgICAgKz0geGdlbmVfZWRhYy5vCj4+ICBvYmotJChD T05GSUdfRURBQ19USSkgICAgICAgICAgICAgICAgICArPSB0aV9lZGFjLm8KPj4gK29iai0kKENP TkZJR19FREFDX1FDT00pICAgICAgICAgICAgICAgICAgICAgICAgKz0gcWNvbV9lZGFjLm8KPiAK PiBNYXliZSBwdXQgdGhpcyBpbiBzb3J0IG9mIGFscGhhYmV0aWNhbCBvcmRlciBzbyBjb25mbGlj dHMgZG9uJ3QgaGFwcGVuLgoKTm9uZSBvZiB0aGVtIGFyZSBpbiBhbHBoYWJldGljYWwgb3JkZXIs IHNvIEknbSBub3Qgc3VyZSB3aGVyZSB0byBzdGFydCEgCndoYXQgZG8geW91IHN1Z2dlc3Q/Cgo+ IAo+PiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9lZGFjL3Fjb21fZWRhYy5jIGIvZHJpdmVycy9lZGFj L3Fjb21fZWRhYy5jCj4+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4+IGluZGV4IDAwMDAwMDAuLjlh OGM2NzAKPj4gLS0tIC9kZXYvbnVsbAo+PiArKysgYi9kcml2ZXJzL2VkYWMvcWNvbV9lZGFjLmMK Pj4gQEAgLTAsMCArMSw0NDYgQEAKPj4gKy8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwt Mi4wCj4+ICsvKgo+PiArICogQ29weXJpZ2h0IChjKSAyMDE4LCBUaGUgTGludXggRm91bmRhdGlv bi4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KPj4gKyAqLwo+PiArCj4+ICsjaW5jbHVkZSA8bGludXgv ZWRhYy5oPgo+PiArI2luY2x1ZGUgPGxpbnV4L2ludGVycnVwdC5oPgo+PiArI2luY2x1ZGUgPGxp bnV4L2tlcm5lbC5oPgo+PiArI2luY2x1ZGUgPGxpbnV4L29mX2RldmljZS5oPgo+IAo+IFVzZWQ/ IE1heWJlIGl0IHNob3VsZCBqdXN0IGJlIGxpbnV4L29mLmgKT2ssIEknbGwgY2hlY2sgYW5kIHVw ZGF0ZS4KCj4gCj4+ICsjaW5jbHVkZSA8bGludXgvcGxhdGZvcm1fZGV2aWNlLmg+Cj4+ICsjaW5j bHVkZSA8bGludXgvcmVnbWFwLmg+Cj4+ICsjaW5jbHVkZSA8bGludXgvc21wLmg+Cj4gCj4gV2h5 PwpJJ2xsIGNoZWNrIGlmIHRoaXMgaXMgYmVpbmcgdXNlZCwgb3RoZXJ3aXNlLCBJJ2xsIHJlbW92 ZSBpdC4KCj4gCj4+ICsjaW5jbHVkZSA8bGludXgvc29jL3Fjb20vbGxjYy1xY29tLmg+Cj4+ICsK Pj4gKyNpbmNsdWRlICJlZGFjX21jLmgiCj4+ICsjaW5jbHVkZSAiZWRhY19kZXZpY2UuaCIKPj4g Kwo+PiArI2lmZGVmIENPTkZJR19FREFDX1FDT01fTExDQ19QQU5JQ19PTl9VRQo+PiArI2RlZmlu ZSBMTENDX0VSUF9QQU5JQ19PTl9VRSAgICAgICAgICAgIDEKPj4gKyNlbHNlCj4+ICsjZGVmaW5l IExMQ0NfRVJQX1BBTklDX09OX1VFICAgICAgICAgICAgMAo+PiArI2VuZGlmCj4+ICsKPj4gKyNk ZWZpbmUgRURBQ19MTENDICAgICAgICAgICAgICAgICAgICAgICAicWNvbV9sbGNjIgo+PiArCj4+ ICsjZGVmaW5lIFRSUF9TWU5fUkVHX0NOVCAgICAgICAgICAgICAgICAgNgo+PiArCj4+ICsjZGVm aW5lIERSUF9TWU5fUkVHX0NOVCAgICAgICAgICAgICAgICAgOAo+PiArCj4+ICsjZGVmaW5lIExM Q0NfQ09NTU9OX1NUQVRVUzAgICAgICAgICAgICAgMHgwMDAzMDAwQwo+PiArI2RlZmluZSBMTEND X0xCX0NOVF9NQVNLICAgICAgICAgICAgICAgIEdFTk1BU0soMzEsIDI4KQo+PiArI2RlZmluZSBM TENDX0xCX0NOVF9TSElGVCAgICAgICAgICAgICAgIDI4Cj4+ICsKPj4gKy8qIHNpbmdsZSAmIERv dWJsZSBCaXQgc3luZHJvbWUgcmVnaXN0ZXIgb2Zmc2V0cyAqLwo+PiArI2RlZmluZSBUUlBfRUND X1NCX0VSUl9TWU4wICAgICAgICAgICAgIDB4MDAwMjMwNEMKPj4gKyNkZWZpbmUgVFJQX0VDQ19E Ql9FUlJfU1lOMCAgICAgICAgICAgICAweDAwMDIwMzcwCj4+ICsjZGVmaW5lIERSUF9FQ0NfU0Jf RVJSX1NZTjAgICAgICAgICAgICAgMHgwMDA0MjA0Qwo+PiArI2RlZmluZSBEUlBfRUNDX0RCX0VS Ul9TWU4wICAgICAgICAgICAgIDB4MDAwNDIwNzAKPj4gKwo+PiArLyogRXJyb3IgcmVnaXN0ZXIg b2Zmc2V0cyAqLwo+PiArI2RlZmluZSBUUlBfRUNDX0VSUk9SX1NUQVRVUzEgICAgICAgICAgIDB4 MDAwMjAzNDgKPj4gKyNkZWZpbmUgVFJQX0VDQ19FUlJPUl9TVEFUVVMwICAgICAgICAgICAweDAw MDIwMzQ0Cj4+ICsjZGVmaW5lIERSUF9FQ0NfRVJST1JfU1RBVFVTMSAgICAgICAgICAgMHgwMDA0 MjA0OAo+PiArI2RlZmluZSBEUlBfRUNDX0VSUk9SX1NUQVRVUzAgICAgICAgICAgIDB4MDAwNDIw NDQKPj4gKwo+PiArLyogVFJQLCBEUlAgaW50ZXJydXB0IHJlZ2lzdGVyIG9mZnNldHMgKi8KPj4g KyNkZWZpbmUgRFJQX0lOVEVSUlVQVF9TVEFUVVMgICAgICAgICAgICAweDAwMDQxMDAwCj4+ICsj ZGVmaW5lIFRSUF9JTlRFUlJVUFRfMF9TVEFUVVMgICAgICAgICAgMHgwMDAyMDQ4MAo+PiArI2Rl ZmluZSBEUlBfSU5URVJSVVBUX0NMRUFSICAgICAgICAgICAgIDB4MDAwNDEwMDgKPj4gKyNkZWZp bmUgRFJQX0VDQ19FUlJPUl9DTlRSX0NMRUFSICAgICAgICAweDAwMDQwMDA0Cj4+ICsjZGVmaW5l IFRSUF9JTlRFUlJVUFRfMF9DTEVBUiAgICAgICAgICAgMHgwMDAyMDQ4NAo+PiArI2RlZmluZSBU UlBfRUNDX0VSUk9SX0NOVFJfQ0xFQVIgICAgICAgIDB4MDAwMjA0NDAKPj4gKwo+PiArLyogTWFz ayBhbmQgc2hpZnQgbWFjcm9zICovCj4+ICsjZGVmaW5lIEVDQ19EQl9FUlJfQ09VTlRfTUFTSyAg ICAgICAgICAgR0VOTUFTSyg0LCAwKQo+PiArI2RlZmluZSBFQ0NfREJfRVJSX1dBWVNfTUFTSyAg ICAgICAgICAgIEdFTk1BU0soMzEsIDE2KQo+PiArI2RlZmluZSBFQ0NfREJfRVJSX1dBWVNfU0hJ RlQgICAgICAgICAgIEJJVCg0KQo+PiArCj4+ICsjZGVmaW5lIEVDQ19TQl9FUlJfQ09VTlRfTUFT SyAgICAgICAgICAgR0VOTUFTSygyMywgMTYpCj4+ICsjZGVmaW5lIEVDQ19TQl9FUlJfQ09VTlRf U0hJRlQgICAgICAgICAgQklUKDQpCj4+ICsjZGVmaW5lIEVDQ19TQl9FUlJfV0FZU19NQVNLICAg ICAgICAgICAgR0VOTUFTSygxNSwgMCkKPj4gKwo+PiArI2RlZmluZSBTQl9FQ0NfRVJST1IgICAg ICAgICAgICAgICAgICAgIEJJVCgwKQo+PiArI2RlZmluZSBEQl9FQ0NfRVJST1IgICAgICAgICAg ICAgICAgICAgIEJJVCgxKQo+PiArCj4+ICsjZGVmaW5lIERSUF9UUlBfSU5UX0NMRUFSICAgICAg ICAgICAgICAgR0VOTUFTSygxLCAwKQo+PiArI2RlZmluZSBEUlBfVFJQX0NOVF9DTEVBUiAgICAg ICAgICAgICAgIEdFTk1BU0soMSwgMCkKPj4gKwo+PiArLyogQ29uZmlnIHJlZ2lzdGVycyBvZmZz ZXRzKi8KPj4gKyNkZWZpbmUgRFJQX0VDQ19FUlJPUl9DRkcgICAgICAgICAgICAgICAweDAwMDQw MDAwCj4+ICsKPj4gKy8qIFRSUCwgRFJQIGludGVycnVwdCByZWdpc3RlciBvZmZzZXRzICovCj4+ ICsjZGVmaW5lIENNTl9JTlRFUlJVUFRfMF9FTkFCTEUgICAgICAgICAgMHgwMDAzMDAxQwo+PiAr I2RlZmluZSBDTU5fSU5URVJSVVBUXzJfRU5BQkxFICAgICAgICAgIDB4MDAwMzAwM0MKPj4gKyNk ZWZpbmUgVFJQX0lOVEVSUlVQVF8wX0VOQUJMRSAgICAgICAgICAweDAwMDIwNDg4Cj4+ICsjZGVm aW5lIERSUF9JTlRFUlJVUFRfRU5BQkxFICAgICAgICAgICAgMHgwMDA0MTAwQwo+PiArCj4+ICsj ZGVmaW5lIFNCX0VSUk9SX1RIUkVTSE9MRCAgICAgICAgICAgICAgMHgxCj4+ICsjZGVmaW5lIFNC X0VSUk9SX1RIUkVTSE9MRF9TSElGVCAgICAgICAgMjQKPj4gKyNkZWZpbmUgU0JfREJfVFJQX0lO VEVSUlVQVF9FTkFCTEUgICAgICAweDMKPj4gKyNkZWZpbmUgVFJQMF9JTlRFUlJVUFRfRU5BQkxF ICAgICAgICAgICAweDEKPj4gKyNkZWZpbmUgRFJQMF9JTlRFUlJVUFRfRU5BQkxFICAgICAgICAg ICBCSVQoNikKPj4gKyNkZWZpbmUgU0JfREJfRFJQX0lOVEVSUlVQVF9FTkFCTEUgICAgICAweDMK Pj4gKwo+PiArZW51bSB7Cj4+ICsgICAgICAgTExDQ19EUkFNX0NFID0gMCwKPj4gKyAgICAgICBM TENDX0RSQU1fVUUsCj4+ICsgICAgICAgTExDQ19UUkFNX0NFLAo+PiArICAgICAgIExMQ0NfVFJB TV9VRSwKPj4gKyAgICAgICBMTENDX0VSUl9UWVBFX01BWCA9IExMQ0NfVFJBTV9VRSArIDEsCj4g Cj4gV2hhdCdzIHRoZSBwb2ludD8KCkkgd2FzIHVzaW5nIHRoaXMgdG8gaGF2ZSBhIHNlbnRpbmVs IHZhbHVlIGZvciB0aGlzIGVudW0sIHdoaWNoIGNhbiBiZSAKdXNlZAppbml0aWFsbHkgdG8gYWxs b2NhdGUgdGhlIG1lbW9yeSBhbmQgbGF0ZXIgZm9yIGFueSBraW5kIG9mIGVycm9yIGNoZWNrcy4K CkknbGwgcmVtb3ZlIHRoaXMgYXMgd2UgYXJlIGFueXdheSBnZXR0aW5nIHJpZCBvZiB0aGlzIGFs bG9jYXRpb24gYW5kIEknbSAKbm90IGRvaW5nIGFueSBlcnJvciBjaGVja3MgZm9yIG5vdy4KCj4g Cj4+ICt9Owo+PiArCj4+ICtzdGF0aWMgaW50IHFjb21fbGxjY19jb3JlX3NldHVwKHN0cnVjdCBy ZWdtYXAgKmxsY2NfYmNhc3RfcmVnbWFwKQo+PiArewo+PiArICAgICAgIHUzMiBzYl9lcnJfdGhy ZXNob2xkOwo+PiArICAgICAgIGludCByZXQ7Cj4+ICsKPj4gKyAgICAgICAvKiBFbmFibGUgVFJQ IGluIGluc3RhbmNlIDIgb2YgY29tbW9uIGludGVycnVwdCBlbmFibGUgCj4+IHJlZ2lzdGVyICov Cj4gCj4gV2hhdCBpcyBUUlA/CgpUaGlzIGlzIGluIHJlZmVyZW5jZSB0byBUYWcgUmFtLCBJJ2xs IGV4cGFuZCB0aGlzIG9uZS4KCj4gCj4+ICsgICAgICAgcmV0ID0gcmVnbWFwX3VwZGF0ZV9iaXRz KGxsY2NfYmNhc3RfcmVnbWFwLCAKPj4gQ01OX0lOVEVSUlVQVF8yX0VOQUJMRSwKPj4gKyAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgVFJQMF9JTlRFUlJVUFRfRU5BQkxFLAo+PiArICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBUUlAwX0lOVEVSUlVQVF9FTkFCTEUpOwo+PiAr ICAgICAgIGlmIChyZXQpCj4+ICsgICAgICAgICAgICAgICByZXR1cm4gcmV0Owo+PiArCj4+ICsg ICAgICAgLyogRW5hYmxlIEVDQyBpbnRlcnJ1cHRzIG9uIFRhZyBSYW0gKi8KPj4gKyAgICAgICBy ZXQgPSByZWdtYXBfdXBkYXRlX2JpdHMobGxjY19iY2FzdF9yZWdtYXAsIAo+PiBUUlBfSU5URVJS VVBUXzBfRU5BQkxFLAo+PiArICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBTQl9EQl9U UlBfSU5URVJSVVBUX0VOQUJMRSwKPj4gKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg U0JfREJfVFJQX0lOVEVSUlVQVF9FTkFCTEUpOwo+PiArICAgICAgIGlmIChyZXQpCj4+ICsgICAg ICAgICAgICAgICByZXR1cm4gcmV0Owo+PiArCj4+ICsgICAgICAgLyogRW5hYmxlIFNCIGVycm9y IGZvciBEYXRhIFJBTSAqLwo+IAo+IFNCIGlzIHNpbmdsZSBiaXQ/CgpZZXMsIFNpbmdsZSBiaXQs IEknbGwgZXhwYW5kIHRoaXMgb25lLgoKPiAKPj4gKyAgICAgICBzYl9lcnJfdGhyZXNob2xkID0g KFNCX0VSUk9SX1RIUkVTSE9MRCA8PCAKPj4gU0JfRVJST1JfVEhSRVNIT0xEX1NISUZUKTsKPj4g KyAgICAgICByZXQgPSByZWdtYXBfd3JpdGUobGxjY19iY2FzdF9yZWdtYXAsIERSUF9FQ0NfRVJS T1JfQ0ZHLAo+PiArICAgICAgICAgICAgICAgICAgICAgICAgICBzYl9lcnJfdGhyZXNob2xkKTsK Pj4gKyAgICAgICBpZiAocmV0KQo+PiArICAgICAgICAgICAgICAgcmV0dXJuIHJldDsKPj4gKwo+ PiArICAgICAgIC8qIEVuYWJsZSBEUlAgaW4gaW5zdGFuY2UgMiBvZiBjb21tb24gaW50ZXJydXB0 IGVuYWJsZSAKPj4gcmVnaXN0ZXIgKi8KPiAKPiBEUlAgaXMgZG91YmxlIGJpdD8KCk5vLCBUaGlz IGlzIGluIHJlZmVyZW5jZSB0byBEYXRhIFJhbSwgTWF5IGJlIEkgc2hvdWxkIGV4cGFuZCB0aGlz IG9uZSAKdG9vLgoKPiAKPj4gKyAgICAgICByZXQgPSByZWdtYXBfdXBkYXRlX2JpdHMobGxjY19i Y2FzdF9yZWdtYXAsIAo+PiBDTU5fSU5URVJSVVBUXzJfRU5BQkxFLAo+PiArICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBEUlAwX0lOVEVSUlVQVF9FTkFCTEUsCj4+ICsgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIERSUDBfSU5URVJSVVBUX0VOQUJMRSk7Cj4+ICsgICAgICAg aWYgKHJldCkKPj4gKyAgICAgICAgICAgICAgIHJldHVybiByZXQ7Cj4+ICsKPj4gKyAgICAgICAv KiBFbmFibGUgRUNDIGludGVycnVwdHMgb24gRGF0YSBSYW0gKi8KPj4gKyAgICAgICByZXQgPSBy ZWdtYXBfd3JpdGUobGxjY19iY2FzdF9yZWdtYXAsIERSUF9JTlRFUlJVUFRfRU5BQkxFLAo+PiAr ICAgICAgICAgICAgICAgICAgICAgICAgICBTQl9EQl9EUlBfSU5URVJSVVBUX0VOQUJMRSk7Cj4+ ICsgICAgICAgcmV0dXJuIHJldDsKPj4gK30KPj4gKwo+PiArLyogQ2xlYXIgdGhlIGVycm9yIGlu dGVycnVwdCBhbmQgY291bnRlciByZWdpc3RlcnMgKi8KPj4gK3N0YXRpYyBpbnQKPj4gK3Fjb21f bGxjY19jbGVhcl9lcnJvcnNfc3RhdHVzKGludCBlcnJfdHlwZSwgc3RydWN0IGxsY2NfZHJ2X2Rh dGEgCj4+ICpkcnYpCj4+ICt7Cj4+ICsgICAgICAgaW50IHJldCA9IDA7Cj4+ICsKPj4gKyAgICAg ICBzd2l0Y2ggKGVycl90eXBlKSB7Cj4+ICsgICAgICAgY2FzZSBMTENDX0RSQU1fQ0U6Cj4+ICsg ICAgICAgY2FzZSBMTENDX0RSQU1fVUU6Cj4+ICsgICAgICAgICAgICAgICAvKiBDbGVhciB0aGUg aW50ZXJydXB0ICovCj4+ICsgICAgICAgICAgICAgICByZXQgPSByZWdtYXBfd3JpdGUoZHJ2LT5i Y2FzdF9yZWdtYXAsIAo+PiBEUlBfSU5URVJSVVBUX0NMRUFSLAo+PiArICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIERSUF9UUlBfSU5UX0NMRUFSKTsKPj4gKyAgICAgICAgICAgICAg IGlmIChyZXQpCj4+ICsgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiByZXQ7Cj4+ICsKPj4g KyAgICAgICAgICAgICAgIC8qIENsZWFyIHRoZSBjb3VudGVycyAqLwo+IAo+IEEgbG90IG9mIHRo ZXNlIGNvbW1lbnRzIGFyZSBqdXN0IHNheWluZyB3aGF0IHRoZSByZWdpc3RlciB3cml0ZSBpcyAK PiBkb2luZwo+IHdoaWNoIGlzIGZhaXJseSBvYnZpb3VzIGZyb20gdGhlIHJlZ2lzdGVyIG5hbWVz LiBDYW4geW91IHJlbW92ZSB0aGVzZQo+IG9idmlvdXMgY29tbWVudHM/CgpPaywgRG9uZS4gSSds bCB1cGRhdGUgdGhpcyBpbiB0aGUgbmV4dCBwYXRjaHNldC4KCj4gCj4+ICsgICAgICAgICAgICAg ICByZXQgPSByZWdtYXBfd3JpdGUoZHJ2LT5iY2FzdF9yZWdtYXAsIAo+PiBEUlBfRUNDX0VSUk9S X0NOVFJfQ0xFQVIsCj4+ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgRFJQX1RS UF9DTlRfQ0xFQVIpOwo+PiArICAgICAgICAgICAgICAgaWYgKHJldCkKPj4gKyAgICAgICAgICAg ICAgICAgICAgICAgcmV0dXJuIHJldDsKPj4gKyAgICAgICAgICAgICAgIGJyZWFrOwo+PiArICAg ICAgIGNhc2UgTExDQ19UUkFNX0NFOgo+PiArICAgICAgIGNhc2UgTExDQ19UUkFNX1VFOgo+PiAr ICAgICAgICAgICAgICAgcmV0ID0gcmVnbWFwX3dyaXRlKGRydi0+YmNhc3RfcmVnbWFwLCAKPj4g VFJQX0lOVEVSUlVQVF8wX0NMRUFSLAo+PiArICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIERSUF9UUlBfSU5UX0NMRUFSKTsKPj4gKyAgICAgICAgICAgICAgIGlmIChyZXQpCj4+ICsg ICAgICAgICAgICAgICAgICAgICAgIHJldHVybiByZXQ7Cj4+ICsKPj4gKyAgICAgICAgICAgICAg IHJldCA9IHJlZ21hcF93cml0ZShkcnYtPmJjYXN0X3JlZ21hcCwgCj4+IFRSUF9FQ0NfRVJST1Jf Q05UUl9DTEVBUiwKPj4gKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBEUlBfVFJQ X0NOVF9DTEVBUik7Cj4+ICsgICAgICAgICAgICAgICBpZiAocmV0KQo+PiArICAgICAgICAgICAg ICAgICAgICAgICByZXR1cm4gcmV0Owo+PiArICAgICAgICAgICAgICAgYnJlYWs7Cj4+ICsgICAg ICAgfQo+PiArICAgICAgIHJldHVybiByZXQ7Cj4+ICt9Cj4+ICsKPj4gKy8qIER1bXAgU3luZHJv bWUgcmVnaXN0ZXJzIGRhdGEgZm9yIFRhZyBSQU0sIERhdGEgUkFNIGJpdCBlcnJvcnMqLwo+PiAr c3RhdGljIGludAo+PiArZHVtcF9zeW5fcmVnX3ZhbHVlcyhzdHJ1Y3QgbGxjY19kcnZfZGF0YSAq ZHJ2LCB1MzIgYmFuaywgaW50IAo+PiBlcnJfdHlwZSkKPj4gK3sKPj4gKyAgICAgICBzdHJ1Y3Qg bGxjY19lZGFjX3JlZ19kYXRhICpyZWdfZGF0YSA9IAo+PiAmKGRydi0+ZWRhY19yZWdbZXJyX3R5 cGVdKTsKPiAKPiBjb25zdD8gQWxzbywgZHJvcCB0aGUgdXNlbGVzcyBwYXJlbnRoZXNpcy4KCk9r LCBkb25lLgoKPiAKPj4gKyAgICAgICBpbnQgZXJyX2NudCwgZXJyX3dheXMsIHJldCwgaTsKPj4g KyAgICAgICB1MzIgc3luZF9yZWcsIHN5bmRfdmFsOwo+PiArCj4+ICsgICAgICAgZm9yIChpID0g MDsgaSA8IHJlZ19kYXRhLT5yZWdfY250OyBpKyspIHsKPj4gKyAgICAgICAgICAgICAgIHN5bmRf cmVnID0gcmVnX2RhdGEtPnN5bmRfcmVnICsgKGkgKiA0KTsKPj4gKyAgICAgICAgICAgICAgIHJl dCA9IHJlZ21hcF9yZWFkKGRydi0+cmVnbWFwLCBkcnYtPm9mZnNldHNbYmFua10gKyAKPj4gc3lu ZF9yZWcsCj4+ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAmc3luZF92YWwpOwo+ PiArICAgICAgICAgICAgICAgaWYgKHJldCkKPj4gKyAgICAgICAgICAgICAgICAgICAgICAgZ290 byBjbGVhcjsKPj4gKyAgICAgICAgICAgICAgIGVkYWNfcHJpbnRrKEtFUk5fQ1JJVCwgRURBQ19M TENDLCAiJXM6IEVDQ19TWU4lZDogCj4+IDB4JTh4XG4iLAo+PiArICAgICAgICAgICAgICAgICAg ICAgICAgICAgcmVnX2RhdGEtPmVycl9uYW1lLCBpLCBzeW5kX3ZhbCk7Cj4+ICsgICAgICAgfQo+ PiArCj4+ICsgICAgICAgcmV0ID0gcmVnbWFwX3JlYWQoZHJ2LT5yZWdtYXAsCj4+ICsgICAgICAg ICAgICAgICAgICAgICAgICAgZHJ2LT5vZmZzZXRzW2JhbmtdICsgCj4+IHJlZ19kYXRhLT5lcnJf c3RhdHVzX3JlZywKPj4gKyAgICAgICAgICAgICAgICAgICAgICAgICAmZXJyX2NudCk7Cj4+ICsg ICAgICAgaWYgKHJldCkKPj4gKyAgICAgICAgICAgICAgIGdvdG8gY2xlYXI7Cj4+ICsKPj4gKyAg ICAgICBlcnJfY250ICY9IHJlZ19kYXRhLT5lcnJfY291bnRfbWFzazsKPj4gKyAgICAgICBlcnJf Y250ID4+PSByZWdfZGF0YS0+ZXJyX2NvdW50X3NoaWZ0Owo+PiArICAgICAgIGVkYWNfcHJpbnRr KEtFUk5fQ1JJVCwgRURBQ19MTENDLCAiJXM6IGVycm9yIGNvdW50OiAweCU0eFxuIiwKPj4gKyAg ICAgICAgICAgICAgICAgICByZWdfZGF0YS0+ZXJyX25hbWUsIGVycl9jbnQpOwo+PiArCj4+ICsg ICAgICAgcmV0ID0gcmVnbWFwX3JlYWQoZHJ2LT5yZWdtYXAsCj4+ICsgICAgICAgICAgICAgICAg ICAgICAgICAgZHJ2LT5vZmZzZXRzW2JhbmtdICsgCj4+IHJlZ19kYXRhLT5lcnJfd2F5c19zdGF0 dXMsCj4+ICsgICAgICAgICAgICAgICAgICAgICAgICAgJmVycl93YXlzKTsKPj4gKyAgICAgICBp ZiAocmV0KQo+PiArICAgICAgICAgICAgICAgZ290byBjbGVhcjsKPj4gKwo+PiArICAgICAgIGVy cl93YXlzICY9IHJlZ19kYXRhLT5lcnJfd2F5c19tYXNrOwo+PiArICAgICAgIGVycl93YXlzID4+ PSByZWdfZGF0YS0+ZXJyX3dheXNfc2hpZnQ7Cj4+ICsKPj4gKyAgICAgICBlZGFjX3ByaW50ayhL RVJOX0NSSVQsIEVEQUNfTExDQywgIiVzOiBlcnJvciB3YXlzOiAweCU0eFxuIiwKPj4gKyAgICAg ICAgICAgICAgICAgICByZWdfZGF0YS0+ZXJyX25hbWUsIGVycl93YXlzKTsKPj4gKwo+PiArY2xl YXI6Cj4+ICsgICAgICAgcmV0ID0gcWNvbV9sbGNjX2NsZWFyX2Vycm9yc19zdGF0dXMoZXJyX3R5 cGUsIGRydik7Cj4+ICsgICAgICAgcmV0dXJuIHJldDsKPiAKPiBKdXN0ICdyZXR1cm4gcWNvbV9s bGNjX2NsZWFyX2Vycm9yc19zdGF0dXMoLi4uKScKCkRvbmUuCgo+IAo+PiArfQo+PiArCj4+ICtz dGF0aWMgaW50Cj4+ICtkdW1wX3N5bl9yZWcoc3RydWN0IGVkYWNfZGV2aWNlX2N0bF9pbmZvICpl ZGV2X2N0bCwgaW50IGVycl90eXBlLCB1MzIgCj4+IGJhbmspCj4+ICt7Cj4+ICsgICAgICAgc3Ry dWN0IGxsY2NfZHJ2X2RhdGEgKmRydiA9IGVkZXZfY3RsLT5wdnRfaW5mbzsKPj4gKyAgICAgICBp bnQgcmV0ID0gMDsKPiAKPiBQbGVhc2UgZG9uJ3QgYXNzaWduIGxvY2FsIHZhcmlhYmxlcyBhdCB0 aGUgc3RhcnQgb2YgYSBmdW5jdGlvbiBhbmQgdGhlbgo+IHJlYXNzaWduIHRoZW0gYWdhaW4gaW1t ZWRpYXRlbHkgYWZ0ZXIuIEl0IGhpZGVzIGluaXRpYWxpemF0aW9uIAo+IHByb2JsZW1zLgoKSSBk aWQgdGhpcyBiZWNhdXNlIHRoZSBjb21waWxlciB3YXMgdGhyb3dpbmcgc29tZSB3YXJuaW5ncywg SSdsbCB0cnkgdG8gCmdldCB0aGF0CmFuZCBzZWUgaWYgdGhpcyBpcyByZWFsbHkgbmVlZGVkLgoK PiAKPj4gKwo+PiArICAgICAgIHJldCA9IGR1bXBfc3luX3JlZ192YWx1ZXMoZHJ2LCBiYW5rLCBl cnJfdHlwZSk7Cj4+ICsgICAgICAgaWYgKHJldCkKPj4gKyAgICAgICAgICAgICAgIHJldHVybiBy ZXQ7Cj4+ICsKPj4gKyAgICAgICBzd2l0Y2ggKGVycl90eXBlKSB7Cj4+ICsgICAgICAgY2FzZSBM TENDX0RSQU1fQ0U6Cj4+ICsgICAgICAgICAgICAgICBlZGFjX2RldmljZV9oYW5kbGVfY2UoZWRl dl9jdGwsIDAsIGJhbmssCj4+ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IkxMQ0MgRGF0YSBSQU0gY29ycmVjdGFibGUgCj4+IEVycm9yIik7Cj4+ICsgICAgICAgICAgICAg ICBicmVhazsKPj4gKyAgICAgICBjYXNlIExMQ0NfRFJBTV9VRToKPj4gKyAgICAgICAgICAgICAg IGVkYWNfZGV2aWNlX2hhbmRsZV91ZShlZGV2X2N0bCwgMCwgYmFuaywKPj4gKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAiTExDQyBEYXRhIFJBTSB1bmNvcnJlY3RhYmxlIAo+ PiBFcnJvciIpOwo+PiArICAgICAgICAgICAgICAgYnJlYWs7Cj4+ICsgICAgICAgY2FzZSBMTEND X1RSQU1fQ0U6Cj4+ICsgICAgICAgICAgICAgICBlZGFjX2RldmljZV9oYW5kbGVfY2UoZWRldl9j dGwsIDAsIGJhbmssCj4+ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIkxM Q0MgVGFnIFJBTSBjb3JyZWN0YWJsZSAKPj4gRXJyb3IiKTsKPj4gKyAgICAgICAgICAgICAgIGJy ZWFrOwo+PiArICAgICAgIGNhc2UgTExDQ19UUkFNX1VFOgo+PiArICAgICAgICAgICAgICAgZWRh Y19kZXZpY2VfaGFuZGxlX3VlKGVkZXZfY3RsLCAwLCBiYW5rLAo+PiArICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICJMTENDIFRhZyBSQU0gdW5jb3JyZWN0YWJsZSAKPj4gRXJy b3IiKTsKPj4gKyAgICAgICAgICAgICAgIGJyZWFrOwo+PiArICAgICAgIH0KPj4gKwo+PiArICAg ICAgIHJldHVybiByZXQ7Cj4+ICt9Cj4+ICsKPj4gK3N0YXRpYyBpcnFyZXR1cm5fdAo+PiArbGxj Y19lY2NfaXJxX2hhbmRsZXIoaW50IGlycSwgdm9pZCAqZWRldl9jdGwpCj4+ICt7Cj4+ICsgICAg ICAgc3RydWN0IGVkYWNfZGV2aWNlX2N0bF9pbmZvICplZGFjX2Rldl9jdGw7Cj4+ICsgICAgICAg aXJxcmV0dXJuX3QgaXJxX3JjID0gSVJRX05PTkU7Cj4+ICsgICAgICAgdTMyIGRycF9lcnJvciwg dHJwX2Vycm9yLCBpOwo+PiArICAgICAgIHN0cnVjdCBsbGNjX2Rydl9kYXRhICpkcnY7Cj4+ICsg ICAgICAgaW50IHJldDsKPj4gKwo+PiArICAgICAgIGVkYWNfZGV2X2N0bCA9IChzdHJ1Y3QgZWRh Y19kZXZpY2VfY3RsX2luZm8gKillZGV2X2N0bDsKPiAKPiBSZW1vdmUgdXNlbGVzcyBjYXN0IHBs ZWFzZS4KCkZvcmdvdCB0byB1cGRhdGUgdGhpcywgSSdsbCBkbyBpdC4KCj4gCj4+ICsgICAgICAg ZHJ2ID0gZWRhY19kZXZfY3RsLT5wdnRfaW5mbzsKPj4gKwo+PiArICAgICAgIGZvciAoaSA9IDA7 IGkgPCBkcnYtPm51bV9iYW5rczsgaSsrKSB7Cj4+ICsgICAgICAgICAgICAgICAvKiBMb29rIGZv ciBEYXRhIFJBTSBlcnJvcnMgKi8KPj4gKyAgICAgICAgICAgICAgIHJldCA9IHJlZ21hcF9yZWFk KGRydi0+cmVnbWFwLAo+PiArICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZHJ2LT5v ZmZzZXRzW2ldICsgCj4+IERSUF9JTlRFUlJVUFRfU1RBVFVTLAo+PiArICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgJmRycF9lcnJvcik7Cj4+ICsgICAgICAgICAgICAgICBpZiAocmV0 KQo+PiArICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gaXJxX3JjOwo+PiArCj4+ICsgICAg ICAgICAgICAgICBpZiAoZHJwX2Vycm9yICYgU0JfRUNDX0VSUk9SKSB7Cj4+ICsgICAgICAgICAg ICAgICAgICAgICAgIGVkYWNfcHJpbnRrKEtFUk5fQ1JJVCwgRURBQ19MTENDLAo+PiArICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAiU2luZ2xlIEJpdCBFcnJvciBkZXRlY3RlZCBp biBEYXRhIAo+PiBSYW1cbiIpOwo+PiArICAgICAgICAgICAgICAgICAgICAgICByZXQgPSBkdW1w X3N5bl9yZWcoZWRldl9jdGwsIExMQ0NfRFJBTV9DRSwgaSk7Cj4+ICsgICAgICAgICAgICAgICAg ICAgICAgIGlmICghcmV0KQo+PiArICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGlycV9y YyA9IElSUV9IQU5ETEVEOwo+IAo+IFJlbmFtZSAnaXJxX3JjJyB0byAnaGFuZGxlZCcgYW5kIG1h a2UgaXQgYSBib29sIGFuZCB0aGVuIGJyZWFrIGZyb20gYWxsCj4gdGhlc2UgJ3JldHVybiBpcnFf cmMnIHBsYWNlcyBhbmQgJ2lmIChoYW5kbGVkKSByZXR1cm4gSVJRX0hBTkRMRUQ7Cj4gcmV0dXJu IElSUV9OT05FOycgYXQgdGhlIGVuZCBvZiB0aGlzIGZ1bmN0aW9uIHNvIHdlIGhhdmUgb25lIGV4 aXQgcG9pbnQKPiBmcm9tIHRoZSBpcnEgaGFuZGxlci4KCk9rLCBJJ2xsIHRyeSB0byBvcHRpbWl6 ZSB0aGUgbG9naWMgaGVyZS4KCj4gCj4+ICsgICAgICAgICAgICAgICB9IGVsc2UgaWYgKGRycF9l cnJvciAmIERCX0VDQ19FUlJPUikgewo+PiArICAgICAgICAgICAgICAgICAgICAgICBlZGFjX3By aW50ayhLRVJOX0NSSVQsIEVEQUNfTExDQywKPj4gKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIkRvdWJsZSBCaXQgRXJyb3IgZGV0ZWN0ZWQgaW4gRGF0YSAKPj4gUmFtXG4iKTsK Pj4gKyAgICAgICAgICAgICAgICAgICAgICAgcmV0ID0gZHVtcF9zeW5fcmVnKGVkZXZfY3RsLCBM TENDX0RSQU1fVUUsIGkpOwo+PiArICAgICAgICAgICAgICAgICAgICAgICBpZiAoIXJldCkKPj4g KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBpcnFfcmMgPSBJUlFfSEFORExFRDsKPj4g KyAgICAgICAgICAgICAgIH0KPj4gKwo+PiArICAgICAgICAgICAgICAgLyogTG9vayBmb3IgVGFn IFJBTSBlcnJvcnMgKi8KPj4gKyAgICAgICAgICAgICAgIHJldCA9IHJlZ21hcF9yZWFkKGRydi0+ cmVnbWFwLAo+PiArICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZHJ2LT5vZmZzZXRz W2ldICsgCj4+IFRSUF9JTlRFUlJVUFRfMF9TVEFUVVMsCj4+ICsgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAmdHJwX2Vycm9yKTsKPj4gKyAgICAgICAgICAgICAgIGlmIChyZXQpCj4+ ICsgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBpcnFfcmM7Cj4+ICsKPj4gKyAgICAgICAg ICAgICAgIGlmICh0cnBfZXJyb3IgJiBTQl9FQ0NfRVJST1IpIHsKPj4gKyAgICAgICAgICAgICAg ICAgICAgICAgZWRhY19wcmludGsoS0VSTl9DUklULCBFREFDX0xMQ0MsCj4+ICsgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICJTaW5nbGUgQml0IEVycm9yIGRldGVjdGVkIGluIFRh ZyAKPj4gUmFtXG4iKTsKPj4gKyAgICAgICAgICAgICAgICAgICAgICAgcmV0ID0gZHVtcF9zeW5f cmVnKGVkZXZfY3RsLCBMTENDX1RSQU1fQ0UsIGkpOwo+PiArICAgICAgICAgICAgICAgICAgICAg ICBpZiAoIXJldCkKPj4gKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBpcnFfcmMgPSBJ UlFfSEFORExFRDsKPj4gKyAgICAgICAgICAgICAgIH0gZWxzZSBpZiAodHJwX2Vycm9yICYgREJf RUNDX0VSUk9SKSB7Cj4+ICsgICAgICAgICAgICAgICAgICAgICAgIGVkYWNfcHJpbnRrKEtFUk5f Q1JJVCwgRURBQ19MTENDLAo+PiArICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAi RG91YmxlIEJpdCBFcnJvciBkZXRlY3RlZCBpbiBUYWcgCj4+IFJhbVxuIik7Cj4+ICsgICAgICAg ICAgICAgICAgICAgICAgIHJldCA9IGR1bXBfc3luX3JlZyhlZGV2X2N0bCwgTExDQ19UUkFNX1VF LCBpKTsKPj4gKyAgICAgICAgICAgICAgICAgICAgICAgaWYgKCFyZXQpCj4+ICsgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgaXJxX3JjID0gSVJRX0hBTkRMRUQ7Cj4+ICsgICAgICAgICAg ICAgICB9Cj4+ICsgICAgICAgfQo+PiArCj4+ICsgICAgICAgcmV0dXJuIGlycV9yYzsKPj4gK30K Pj4gKwo+PiArc3RhdGljIHZvaWQgbGxjY19lZGFjX3JlZ19kYXRhX2luaXQoc3RydWN0IGxsY2Nf ZWRhY19yZWdfZGF0YSAKPj4gKmVkYWNfcmVnKQo+PiArewo+PiArCj4+ICsgICAgICAgc3RydWN0 IGxsY2NfZWRhY19yZWdfZGF0YSAqcmVnX2RhdGE7Cj4+ICsKPj4gKyAgICAgICAvKiBJbml0aWFs aXplIHJlZ2lzdGVyIGluZm8gZm9yIExMQ0NfRFJBTV9DRSAqLwo+PiArICAgICAgIHJlZ19kYXRh ID0gJmVkYWNfcmVnW0xMQ0NfRFJBTV9DRV07Cj4+ICsgICAgICAgcmVnX2RhdGEtPmVycl9uYW1l ID0gIkRSQU0gU2luZ2xlLWJpdCI7Cj4+ICsgICAgICAgcmVnX2RhdGEtPnJlZ19jbnQgPSBEUlBf U1lOX1JFR19DTlQ7Cj4+ICsgICAgICAgcmVnX2RhdGEtPnN5bmRfcmVnID0gRFJQX0VDQ19TQl9F UlJfU1lOMDsKPj4gKyAgICAgICByZWdfZGF0YS0+ZXJyX3N0YXR1c19yZWcgPSBEUlBfRUNDX0VS Uk9SX1NUQVRVUzE7Cj4+ICsgICAgICAgcmVnX2RhdGEtPmVycl9jb3VudF9tYXNrID0gRUNDX1NC X0VSUl9DT1VOVF9NQVNLOwo+PiArICAgICAgIHJlZ19kYXRhLT5lcnJfY291bnRfc2hpZnQgPSBF Q0NfU0JfRVJSX0NPVU5UX1NISUZUOwo+PiArICAgICAgIHJlZ19kYXRhLT5lcnJfd2F5c19zdGF0 dXMgPSBEUlBfRUNDX0VSUk9SX1NUQVRVUzA7Cj4+ICsgICAgICAgcmVnX2RhdGEtPmVycl93YXlz X21hc2sgPSBFQ0NfU0JfRVJSX1dBWVNfTUFTSzsKPj4gKwo+PiArICAgICAgIC8qIEluaXRpYWxp emUgcmVnaXN0ZXIgaW5mbyBmb3IgTExDQ19EUkFNX1VFICovCj4+ICsgICAgICAgcmVnX2RhdGEg PSAmZWRhY19yZWdbTExDQ19EUkFNX1VFXTsKPj4gKyAgICAgICByZWdfZGF0YS0+ZXJyX25hbWUg PSAiRFJBTSBEb3VibGUtYml0IjsKPj4gKyAgICAgICByZWdfZGF0YS0+cmVnX2NudCA9IERSUF9T WU5fUkVHX0NOVDsKPj4gKyAgICAgICByZWdfZGF0YS0+c3luZF9yZWcgPSBEUlBfRUNDX0RCX0VS Ul9TWU4wOwo+PiArICAgICAgIHJlZ19kYXRhLT5lcnJfc3RhdHVzX3JlZyA9IERSUF9FQ0NfRVJS T1JfU1RBVFVTMTsKPj4gKyAgICAgICByZWdfZGF0YS0+ZXJyX2NvdW50X21hc2sgPSBFQ0NfREJf RVJSX0NPVU5UX01BU0s7Cj4+ICsgICAgICAgcmVnX2RhdGEtPmVycl93YXlzX3N0YXR1cyA9IERS UF9FQ0NfRVJST1JfU1RBVFVTMDsKPj4gKyAgICAgICByZWdfZGF0YS0+ZXJyX3dheXNfbWFzayA9 IEVDQ19EQl9FUlJfV0FZU19NQVNLOwo+PiArICAgICAgIHJlZ19kYXRhLT5lcnJfd2F5c19zaGlm dCA9IEVDQ19EQl9FUlJfV0FZU19TSElGVDsKPj4gKwo+PiArICAgICAgIC8qIEluaXRpYWxpemUg cmVnaXN0ZXIgaW5mbyBmb3IgTExDQ19UUkFNX0NFICovCj4+ICsgICAgICAgcmVnX2RhdGEgPSAm ZWRhY19yZWdbTExDQ19UUkFNX0NFXTsKPj4gKyAgICAgICByZWdfZGF0YS0+ZXJyX25hbWUgPSAi VFJBTSBTaW5nbGUtYml0IjsKPj4gKyAgICAgICByZWdfZGF0YS0+cmVnX2NudCA9IFRSUF9TWU5f UkVHX0NOVDsKPj4gKyAgICAgICByZWdfZGF0YS0+c3luZF9yZWcgPSBUUlBfRUNDX1NCX0VSUl9T WU4wOwo+PiArICAgICAgIHJlZ19kYXRhLT5lcnJfc3RhdHVzX3JlZyA9IFRSUF9FQ0NfRVJST1Jf U1RBVFVTMTsKPj4gKyAgICAgICByZWdfZGF0YS0+ZXJyX2NvdW50X21hc2sgPSBFQ0NfU0JfRVJS X0NPVU5UX01BU0s7Cj4+ICsgICAgICAgcmVnX2RhdGEtPmVycl9jb3VudF9zaGlmdCA9IEVDQ19T Ql9FUlJfQ09VTlRfU0hJRlQ7Cj4+ICsgICAgICAgcmVnX2RhdGEtPmVycl93YXlzX3N0YXR1cyA9 IFRSUF9FQ0NfRVJST1JfU1RBVFVTMDsKPj4gKyAgICAgICByZWdfZGF0YS0+ZXJyX3dheXNfbWFz ayA9IEVDQ19TQl9FUlJfV0FZU19NQVNLOwo+PiArCj4+ICsgICAgICAgLyogSW5pdGlhbGl6ZSBy ZWdpc3RlciBpbmZvIGZvciBMTENDX1RSQU1fVUUgKi8KPj4gKyAgICAgICByZWdfZGF0YSA9ICZl ZGFjX3JlZ1tMTENDX1RSQU1fVUVdOwo+PiArICAgICAgIHJlZ19kYXRhLT5lcnJfbmFtZSA9ICJU UkFNIERvdWJsZS1iaXQiOwo+PiArICAgICAgIHJlZ19kYXRhLT5yZWdfY250ID0gVFJQX1NZTl9S RUdfQ05UOwo+PiArICAgICAgIHJlZ19kYXRhLT5zeW5kX3JlZyA9IFRSUF9FQ0NfREJfRVJSX1NZ TjA7Cj4+ICsgICAgICAgcmVnX2RhdGEtPmVycl9zdGF0dXNfcmVnID0gVFJQX0VDQ19FUlJPUl9T VEFUVVMxOwo+PiArICAgICAgIHJlZ19kYXRhLT5lcnJfY291bnRfbWFzayA9IEVDQ19EQl9FUlJf Q09VTlRfTUFTSzsKPj4gKyAgICAgICByZWdfZGF0YS0+ZXJyX3dheXNfc3RhdHVzID0gVFJQX0VD Q19FUlJPUl9TVEFUVVMwOwo+PiArICAgICAgIHJlZ19kYXRhLT5lcnJfd2F5c19tYXNrID0gRUND X0RCX0VSUl9XQVlTX01BU0s7Cj4+ICsgICAgICAgcmVnX2RhdGEtPmVycl93YXlzX3NoaWZ0ID0g RUNDX0RCX0VSUl9XQVlTX1NISUZUOwo+IAo+IFdoeSBjYW4ndCB0aGVzZSB0aGluZ3MgYmUgYSBz dGF0aWMgY29uc3QgYXJyYXkgdGhhdCB0aGUgZHJpdmVyIGxvb2tzIHVwCj4gaW4/IFdoYXQncyB0 aGUgcG9pbnQgb2YgaXQgYmVpbmcgcGVyLWRldmljZSBpbnN0YW5jZT8KClllYWgsIHdlIGRvbid0 IG5lZWQgdGhpcyBzdHJ1Y3QgdG8gYmUgcG9wdWxhdGVkIHBlciBkZXZpY2UuIFRoYXQgbWFrZXMg CnNlbnNlLgpJJ2xsIG1ha2UgdGhpcyBpbml0aWFsaXphdGlvbiBzdGF0aWMuCgo+IAo+PiArfQo+ PiArCj4+ICtzdGF0aWMgaW50IHFjb21fbGxjY19lZGFjX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9k ZXZpY2UgKnBkZXYpCj4+ICt7Cj4+ICsgICAgICAgc3RydWN0IGxsY2NfZHJ2X2RhdGEgKmxsY2Nf ZHJpdl9kYXRhID0gCj4+IHBkZXYtPmRldi5wbGF0Zm9ybV9kYXRhOwo+PiArICAgICAgIHN0cnVj dCBlZGFjX2RldmljZV9jdGxfaW5mbyAqZWRldl9jdGw7Cj4+ICsgICAgICAgc3RydWN0IGRldmlj ZSAqZGV2ID0gJnBkZXYtPmRldjsKPj4gKyAgICAgICBpbnQgZWNjX2lycTsKPj4gKyAgICAgICBp bnQgcmM7Cj4+ICsKPj4gKyAgICAgICAvKiBJbml0aWFsaXplIHJlZ2lzdGVyIHNldCBmb3IgdGhl IGVycm9yIHR5cGVzKi8KPj4gKyAgICAgICBsbGNjX2RyaXZfZGF0YS0+ZWRhY19yZWcgPSBkZXZt X2tjYWxsb2MoZGV2LCAKPj4gTExDQ19FUlJfVFlQRV9NQVgsCj4+ICsgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBzaXplb2Yoc3RydWN0IAo+PiBsbGNjX2VkYWNfcmVnX2Rh dGEpLAo+PiArICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgR0ZQX0tFUk5F TCk7Cj4+ICsgICAgICAgbGxjY19lZGFjX3JlZ19kYXRhX2luaXQobGxjY19kcml2X2RhdGEtPmVk YWNfcmVnKTsKPj4gKwo+PiArICAgICAgIHJjID0gcWNvbV9sbGNjX2NvcmVfc2V0dXAobGxjY19k cml2X2RhdGEtPmJjYXN0X3JlZ21hcCk7Cj4+ICsgICAgICAgaWYgKHJjKQo+PiArICAgICAgICAg ICAgICAgcmV0dXJuIHJjOwo+PiArCj4+ICsgICAgICAgLyogQWxsb2NhdGUgZWRhYyBjb250cm9s IGluZm8gKi8KPj4gKyAgICAgICBlZGV2X2N0bCA9IGVkYWNfZGV2aWNlX2FsbG9jX2N0bF9pbmZv KDAsICJxY29tLWxsY2MiLCAxLCAKPj4gImJhbmsiLAo+PiArICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgCj4+IGxsY2NfZHJpdl9kYXRhLT5udW1fYmFua3MsIDEs Cj4+ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBOVUxMLCAw LAo+PiArICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCj4+IGVk YWNfZGV2aWNlX2FsbG9jX2luZGV4KCkpOwo+PiArCj4+ICsgICAgICAgaWYgKCFlZGV2X2N0bCkK Pj4gKyAgICAgICAgICAgICAgIHJldHVybiAtRU5PTUVNOwo+PiArCj4+ICsgICAgICAgZWRldl9j dGwtPmRldiA9IGRldjsKPj4gKyAgICAgICBlZGV2X2N0bC0+bW9kX25hbWUgPSBkZXZfbmFtZShk ZXYpOwo+PiArICAgICAgIGVkZXZfY3RsLT5kZXZfbmFtZSA9IGRldl9uYW1lKGRldik7Cj4+ICsg ICAgICAgZWRldl9jdGwtPmN0bF9uYW1lID0gImxsY2MiOwo+PiArICAgICAgIGVkZXZfY3RsLT5w YW5pY19vbl91ZSA9IExMQ0NfRVJQX1BBTklDX09OX1VFOwo+PiArICAgICAgIGVkZXZfY3RsLT5w dnRfaW5mbyA9IGxsY2NfZHJpdl9kYXRhOwo+PiArCj4+ICsgICAgICAgcmMgPSBlZGFjX2Rldmlj ZV9hZGRfZGV2aWNlKGVkZXZfY3RsKTsKPj4gKyAgICAgICBpZiAocmMpCj4+ICsgICAgICAgICAg ICAgICBnb3RvIG91dF9tZW07Cj4+ICsKPj4gKyAgICAgICBwbGF0Zm9ybV9zZXRfZHJ2ZGF0YShw ZGV2LCBlZGV2X2N0bCk7Cj4+ICsKPj4gKyAgICAgICAvKiBSZXF1ZXN0IGZvciBlY2MgaXJxICov Cj4+ICsgICAgICAgZWNjX2lycSA9IGxsY2NfZHJpdl9kYXRhLT5lY2NfaXJxOwo+PiArICAgICAg IGlmIChlY2NfaXJxIDwgMCkgewo+PiArICAgICAgICAgICAgICAgcmMgPSAtRU5PREVWOwo+IAo+ IFJldHVybiBlcnJvciBjb2RlIGZyb20gcGxhdGZvcm1fZ2V0X2lycSgpPyBPaCwgdGhhdCdzIHdl aXJkLiBXaHkgaXMgCj4gc29tZS8KPiBvdGhlciBkcml2ZXIgZ2V0dGluZyBhbmQgc3RvcmluZyB0 aGUgaXJxIGF3YXk/IEhvcGVmdWxseSBpdCBpc24ndCBhCj4gc2hhcmVkIElSUS4KCk5vLCBpdCBp c24ndCBhIHNoYXJlZCBpcnEuIExMQ0MgRURBQyBwbGF0Zm9ybSBkcml2ZXIgaXMgcmVnaXN0ZXJl ZCBmcm9tIApMTENDCmFuZCB0aGUgaW50ZXJydXB0IHZhbHVlcyBhcmUgcG9wdWxhdGVkIHRoZXJl LgpDaGVjayB0aGlzIHBhdGNoICBbW1BBVENIIHYyIDIvNF0gZHJpdmVyczogc29jOiBBZGQgc3Vw cG9ydCB0byByZWdpc3RlciAKTExDQyBFREFDIGRyaXZlcl0KCgo+IAo+PiArICAgICAgICAgICAg ICAgZ290byBvdXRfZGV2Owo+PiArICAgICAgIH0KPj4gKyAgICAgICByYyA9IGRldm1fcmVxdWVz dF9pcnEoZGV2LCBlY2NfaXJxLCBsbGNjX2VjY19pcnFfaGFuZGxlciwKPj4gKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgSVJRRl9UUklHR0VSX0hJR0gsICJsbGNjX2VjYyIsIAo+PiBlZGV2 X2N0bCk7Cj4+ICsgICAgICAgaWYgKHJjKQo+PiArICAgICAgICAgICAgICAgZ290byBvdXRfZGV2 Owo+PiArCj4+ICsgICAgICAgcmV0dXJuIHJjOwo+PiArCj4+ICtvdXRfZGV2Ogo+PiArICAgICAg IGVkYWNfZGV2aWNlX2RlbF9kZXZpY2UoZWRldl9jdGwtPmRldik7Cj4+ICtvdXRfbWVtOgo+PiAr ICAgICAgIGVkYWNfZGV2aWNlX2ZyZWVfY3RsX2luZm8oZWRldl9jdGwpOwo+PiArCj4+ICsgICAg ICAgcmV0dXJuIHJjOwo+PiArfQo+PiArCj4+ICtzdGF0aWMgaW50IHFjb21fbGxjY19lZGFjX3Jl bW92ZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQo+PiArewo+PiArICAgICAgIHN0cnVj dCBlZGFjX2RldmljZV9jdGxfaW5mbyAqZWRldl9jdGwgPSAKPj4gZGV2X2dldF9kcnZkYXRhKCZw ZGV2LT5kZXYpOwo+PiArCj4+ICsgICAgICAgZWRhY19kZXZpY2VfZGVsX2RldmljZShlZGV2X2N0 bC0+ZGV2KTsKPj4gKyAgICAgICBlZGFjX2RldmljZV9mcmVlX2N0bF9pbmZvKGVkZXZfY3RsKTsK Pj4gKyAgICAgICBwbGF0Zm9ybV9zZXRfZHJ2ZGF0YShwZGV2LCBOVUxMKTsKPiAKPiBObyBuZWVk LiBEb24ndCBzZXQgcGxhdGZvcm0gZGF0YSB0byBOVUxMLgoKV2h5PyAgSSB3YXMgYXNrZWQgdG8g c2V0IHRoaXMgZXhwbGljaXRseS4KSXQnZCBiZSBnb29kIHRvIGtub3cgd2h5IEkgZG9uJ3QgbmVl ZCB0aGlzLiBJcyBpdCB0YWtlbiBjYXJlIG9mIGJ5IApmcmFtZXdvcmsgZXhwbGljaXRseT8KCj4g Cj4+ICsKPj4gKyAgICAgICByZXR1cm4gMDsKPj4gK30KPj4gKwo+PiArc3RhdGljIGNvbnN0IHN0 cnVjdCBvZl9kZXZpY2VfaWQgcWNvbV9sbGNjX2VkYWNfbWF0Y2hfdGFibGVbXSA9IHsKPj4gKyNp ZmRlZiBFREFDX1FDT01fTExDQwo+IAo+IEh1aD8gU2hvdWxkbid0IHRoaXMgZHJpdmVyIG9ubHkg YmUgY29tcGlsZWQgd2hlbiB0aGlzIGNvbmZpZyBpcyAKPiBlbmFibGVkPwoKTm8gdGhpcyBkcml2 ZXIgaXMgYSBnZW5lcmljIHFjb20gZWRhYyBkcml2ZXIsIGFuZCB0aGUgbGxjYy1lZGFjIHdpbGwg CmNvbWUgaW50bwpwaWN0dXJlIG9ubHkgd2hlbiB0aGlzIGNvbmZpZyBpcyBlbmFibGVkLgoKCldl IHVwZGF0ZWQgdGhpcyBhcyBwZXIgdGhlIGluaXRpYWwgY29tbWVudHMgb24gdG8gbWFpbnRhaW4g dGhpcyBkcml2ZXIgCmdlbmVyaWNhbGx5Cgo+IAo+PiArICAgICAgIHsgLmNvbXBhdGlibGUgPSAi cWNvbSxsbGNjLWVkYWMiIH0sCj4+ICsjZW5kaWYKPj4gKyAgICAgICB7IH0sCj4+ICt9Owo+PiAr Cj4+ICtzdGF0aWMgc3RydWN0IHBsYXRmb3JtX2RyaXZlciBxY29tX2xsY2NfZWRhY19kcml2ZXIg PSB7Cj4+ICsgICAgICAgLnByb2JlID0gcWNvbV9sbGNjX2VkYWNfcHJvYmUsCj4+ICsgICAgICAg LnJlbW92ZSA9IHFjb21fbGxjY19lZGFjX3JlbW92ZSwKPj4gKyAgICAgICAuZHJpdmVyID0gewo+ PiArICAgICAgICAgICAgICAgLm5hbWUgPSAicWNvbV9sbGNjX2VkYWMiLAo+PiArICAgICAgICAg ICAgICAgLm9mX21hdGNoX3RhYmxlID0gcWNvbV9sbGNjX2VkYWNfbWF0Y2hfdGFibGUsCj4+ICsg ICAgICAgfSwKPj4gK307Cj4+ICttb2R1bGVfcGxhdGZvcm1fZHJpdmVyKHFjb21fbGxjY19lZGFj X2RyaXZlcik7Cj4+ICsKPj4gK01PRFVMRV9ERVNDUklQVElPTigiUUNPTSBFREFDIGRyaXZlciIp Owo+PiArTU9EVUxFX0xJQ0VOU0UoIkdQTCB2MiIpOwo+PiBkaWZmIC0tZ2l0IGEvaW5jbHVkZS9s aW51eC9zb2MvcWNvbS9sbGNjLXFjb20uaCAKPj4gYi9pbmNsdWRlL2xpbnV4L3NvYy9xY29tL2xs Y2MtcWNvbS5oCj4+IGluZGV4IDJlNGIzNGQuLjI1MDk2ZTAgMTAwNjQ0Cj4+IC0tLSBhL2luY2x1 ZGUvbGludXgvc29jL3Fjb20vbGxjYy1xY29tLmgKPj4gKysrIGIvaW5jbHVkZS9saW51eC9zb2Mv cWNvbS9sbGNjLXFjb20uaAo+PiBAQCAtODQsNiArODQsNyBAQCBzdHJ1Y3QgbGxjY19kcnZfZGF0 YSB7Cj4+ICAgICAgICAgc3RydWN0IHJlZ21hcCAqcmVnbWFwOwo+PiAgICAgICAgIHN0cnVjdCBy ZWdtYXAgKmJjYXN0X3JlZ21hcDsKPj4gICAgICAgICBjb25zdCBzdHJ1Y3QgbGxjY19zbGljZV9j b25maWcgKmNmZzsKPj4gKyAgICAgICBzdHJ1Y3QgbGxjY19lZGFjX3JlZ19kYXRhICplZGFjX3Jl ZzsKPiAKPiBXaHkgYSBwb2ludGVyIGluc3RlYWQgb2YgYW4gYXJyYXkgb2YgcHJvcGVyIHNpemU/ CgpJIHdhbnRlZCB0byBoYXZlIGl0IGR5bmFtaWMsIHNvIHRoYXQgaWYgeW91IHdhbnQgdG8gYWRk IG1vcmUgZXJyb3IgdHlwZXMgCnlvdSBkb24ndCBuZWVkIHRvIHVwZGF0ZSB0aGlzIG9uZS4KCkFu eWhvdywgSSdtIHJlbW92aW5nIHRoaXMgb25lIHRvIG1ha2UgdGhpcyBzdHJ1Y3QgaW5pdGlhbGl6 YXRpb24gc3RhdGljLgoKPiAKPj4gICAgICAgICBzdHJ1Y3QgbXV0ZXggbG9jazsKPj4gICAgICAg ICB1MzIgY2ZnX3NpemU7Cj4+ICAgICAgICAgdTMyIG1heF9zbGljZXM7Cj4+IEBAIC05Myw2ICs5 NCwzMCBAQCBzdHJ1Y3QgbGxjY19kcnZfZGF0YSB7Cj4+ICAgICAgICAgaW50IGVjY19pcnE7Cj4+ ICB9Owo+PiAKPj4gKy8qKgo+PiArICogbGxjY19lZGFjX3JlZ19kYXRhIC0gbGxjYyBlZGFjIHJl Z2lzdGVycyBkYXRhIGZvciBlYWNoIGVycm9yIHR5cGUKPj4gKyAqIEBlcnJfbmFtZTogbmFtZSBv ZiB0aGUgZXJyb3IKPj4gKyAqIEByZWdfY250OiBudW1iZXIgb2YgcmVnaXN0ZXJzCj4+ICsgKiBA c3luZF9yZWc6IHN5bmRyb21lIHJlZ2lzdGVyIGFkZHJlc3MKPj4gKyAqIEBlcnJfc3RhdHVzX3Jl ZzogU3RhdHVzIHJlZ2lzdGVyIGFkZHJlc3MgdG8gcmVhZCB0aGUgZXJyb3IgY291bnQKPj4gKyAq IEBlcnJfY291bnRfbWFzazogTWFzayB2YWx1ZSB0byBnZXQgdGhlIGVycm9yIGNvdW50Cj4+ICsg KiBAZXJyX2NvdW50X3NoaWZ0OiBTaGlmdCB2YWx1ZSB0byBnZXQgdGhlIGVycm9yIGNvdW50Cj4+ ICsgKiBAZXJyX3dheXNfc3RhdHVzOiBTdGF0dXMgcmVnaXN0ZXIgYWRkcmVzcyB0byByZWFkIGVy cm9yIHdheXMKPj4gKyAqIEBlcnJfd2F5c19tYXNrOiBNYXNrIHZhbHVlIHRvIGdldCB0aGUgZXJy b3Igd2F5cwo+PiArICogQGVycl93YXlzX3NoaWZ0OiBTaGlmdCB2YWx1ZSB0byBnZXQgdGhlIGVy cm9yIHdheXMKPj4gKyAqLwo+PiArc3RydWN0IGxsY2NfZWRhY19yZWdfZGF0YSB7Cj4+ICsgICAg ICAgY2hhciAqZXJyX25hbWU7Cj4gCj4gSnVzdCBuYW1lIGluc3RlYWQ/CgpJIGRvbid0IHRoaW5r ICJuYW1lIiBpdHNlbGYgZG9lc24ndCBjb252ZXkgYW55dGhpbmcuIEkgd2FudGVkIHRvIGhhdmUg CmJldHRlciBjb252ZW50aW9uLCBoZW5jZSB0aGlzIHZhcmlhYmxlLgoKPiAKPj4gKyAgICAgICBp bnQgcmVnX2NudDsKPj4gKyAgICAgICBpbnQgc3luZF9yZWc7Cj4+ICsgICAgICAgaW50IGVycl9z dGF0dXNfcmVnOwo+PiArICAgICAgIGludCBlcnJfY291bnRfbWFzazsKPj4gKyAgICAgICBpbnQg ZXJyX2NvdW50X3NoaWZ0Owo+PiArICAgICAgIGludCBlcnJfd2F5c19zdGF0dXM7Cj4+ICsgICAg ICAgaW50IGVycl93YXlzX21hc2s7Cj4+ICsgICAgICAgaW50IGVycl93YXlzX3NoaWZ0Owo+IAo+ IERvIGFueSBvZiB0aGVzZSBuZWVkIHRvIGJlIHNpZ25lZCB0eXBlcz8gVXNlIHU4IGZvciByZWdp c3RlciBvZmZzZXRzIAo+IGFuZAo+IHNoaWZ0cywgdTMyIGZvciBtYXNrcyBhbmQgdW5zaWduZWQg aW50cyBmb3IgY291bnRzIHBsZWFzZS4KClN1cmUsIHRoYXQgbWFrZXMgc2Vuc2UsIEknbGwgdXBk YXRlIHRoZSBkYXRhIHR5cGVzLgoKPiAKPj4gK307Cg==