From mboxrd@z Thu Jan 1 00:00:00 1970 From: Venkata Narendra Kumar Gutta Subject: [PATCH v4 3/4] drivers: edac: Add EDAC driver support for QCOM SoCs Date: Tue, 4 Sep 2018 16:22:24 -0700 Message-ID: <1536103345-1919-4-git-send-email-vnkgutta@codeaurora.org> References: <1536103345-1919-1-git-send-email-vnkgutta@codeaurora.org> Return-path: In-Reply-To: <1536103345-1919-1-git-send-email-vnkgutta@codeaurora.org> Sender: linux-kernel-owner@vger.kernel.org To: Borislav Petkov , evgreen@chromium.org, robh@kernel.org, mchehab@kernel.org, linux-edac@vger.kernel.org, linux-kernel@vger.kernel.org, Andy Gross , David Brown , linux-arm-msm@vger.kernel.org, linux-soc@vger.kernel.org, robh+dt@kernel.org, mark.rutland@arm.com, devicetree@vger.kernel.org, tsoni@codeaurora.org, ckadabi@codeaurora.org, rishabhb@codeaurora.org, swboyd@chromium.org, bjorn.andersson@linaro.org Cc: Venkata Narendra Kumar Gutta List-Id: linux-arm-msm@vger.kernel.org From: Channagoud Kadabi Add error reporting driver for Single Bit Errors (SBEs) and Double Bit Errors (DBEs). As of now, this driver supports error reporting for Last Level Cache Controller (LLCC) of Tag RAM and Data RAM. Interrupts are triggered when the errors happen in the cache, the driver handles those interrupts and dumps the syndrome registers. Signed-off-by: Channagoud Kadabi Signed-off-by: Venkata Narendra Kumar Gutta Co-developed-by: Venkata Narendra Kumar Gutta --- MAINTAINERS | 8 + drivers/edac/Kconfig | 14 ++ drivers/edac/Makefile | 1 + drivers/edac/qcom_edac.c | 420 +++++++++++++++++++++++++++++++++++++ include/linux/soc/qcom/llcc-qcom.h | 24 +++ 5 files changed, 467 insertions(+) create mode 100644 drivers/edac/qcom_edac.c diff --git a/MAINTAINERS b/MAINTAINERS index 0a23427..0bff713 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -5227,6 +5227,14 @@ L: linux-edac@vger.kernel.org S: Maintained F: drivers/edac/ti_edac.c +EDAC-QUALCOMM +M: Channagoud Kadabi +M: Venkata Narendra Kumar Gutta +L: linux-arm-msm@vger.kernel.org +L: linux-edac@vger.kernel.org +S: Maintained +F: drivers/edac/qcom_edac.c + EDIROL UA-101/UA-1000 DRIVER M: Clemens Ladisch L: alsa-devel@alsa-project.org (moderated for non-subscribers) diff --git a/drivers/edac/Kconfig b/drivers/edac/Kconfig index 57304b2..c4e3472 100644 --- a/drivers/edac/Kconfig +++ b/drivers/edac/Kconfig @@ -460,4 +460,18 @@ config EDAC_TI Support for error detection and correction on the TI SoCs. +config EDAC_QCOM + tristate "QCOM EDAC Controller" + depends on ARCH_QCOM && QCOM_LLCC + help + Support for error detection and correction on the + QCOM SoCs. + + This driver reports Single Bit Errors (SBEs) and Double Bit Errors (DBEs). + As of now, it supports error reporting for Last Level Cache Controller (LLCC) + of Tag RAM and Data RAM. + + For debugging issues having to do with stability and overall system + health, you should probably say 'Y' 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 diff --git a/drivers/edac/qcom_edac.c b/drivers/edac/qcom_edac.c new file mode 100644 index 0000000..1773216 --- /dev/null +++ b/drivers/edac/qcom_edac.c @@ -0,0 +1,420 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (c) 2018, The Linux Foundation. All rights reserved. + */ + +#include +#include +#include +#include +#include +#include +#include + +#include "edac_mc.h" +#include "edac_device.h" + +#define EDAC_LLCC "qcom_llcc" + +#define LLCC_ERP_PANIC_ON_UE 1 + +#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 + +/* Tag RAM, Data RAM 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, +}; + +static const struct llcc_edac_reg_data edac_reg_data[] = { + [LLCC_DRAM_CE] = { + .name = "DRAM Single-bit", + .synd_reg = DRP_ECC_SB_ERR_SYN0, + .count_status_reg = DRP_ECC_ERROR_STATUS1, + .ways_status_reg = DRP_ECC_ERROR_STATUS0, + .reg_cnt = DRP_SYN_REG_CNT, + .count_mask = ECC_SB_ERR_COUNT_MASK, + .ways_mask = ECC_SB_ERR_WAYS_MASK, + .count_shift = ECC_SB_ERR_COUNT_SHIFT, + }, + [LLCC_DRAM_UE] = { + .name = "DRAM Double-bit", + .synd_reg = DRP_ECC_DB_ERR_SYN0, + .count_status_reg = DRP_ECC_ERROR_STATUS1, + .ways_status_reg = DRP_ECC_ERROR_STATUS0, + .reg_cnt = DRP_SYN_REG_CNT, + .count_mask = ECC_DB_ERR_COUNT_MASK, + .ways_mask = ECC_DB_ERR_WAYS_MASK, + .ways_shift = ECC_DB_ERR_WAYS_SHIFT, + }, + [LLCC_TRAM_CE] = { + .name = "TRAM Single-bit", + .synd_reg = TRP_ECC_SB_ERR_SYN0, + .count_status_reg = TRP_ECC_ERROR_STATUS1, + .ways_status_reg = TRP_ECC_ERROR_STATUS0, + .reg_cnt = TRP_SYN_REG_CNT, + .count_mask = ECC_SB_ERR_COUNT_MASK, + .ways_mask = ECC_SB_ERR_WAYS_MASK, + .count_shift = ECC_SB_ERR_COUNT_SHIFT, + }, + [LLCC_TRAM_UE] = { + .name = "TRAM Double-bit", + .synd_reg = TRP_ECC_DB_ERR_SYN0, + .count_status_reg = TRP_ECC_ERROR_STATUS1, + .ways_status_reg = TRP_ECC_ERROR_STATUS0, + .reg_cnt = TRP_SYN_REG_CNT, + .count_mask = ECC_DB_ERR_COUNT_MASK, + .ways_mask = ECC_DB_ERR_WAYS_MASK, + .ways_shift = ECC_DB_ERR_WAYS_SHIFT, + }, +}; + +static int qcom_llcc_core_setup(struct regmap *llcc_bcast_regmap) +{ + u32 sb_err_threshold; + int ret; + + /* + * Configure interrupt enable registers such that Tag, Data RAM related + * interrupts are propagated to interrupt controller for servicing + */ + ret = regmap_update_bits(llcc_bcast_regmap, CMN_INTERRUPT_2_ENABLE, + TRP0_INTERRUPT_ENABLE, + TRP0_INTERRUPT_ENABLE); + if (ret) + return ret; + + 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; + + 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; + + ret = regmap_update_bits(llcc_bcast_regmap, CMN_INTERRUPT_2_ENABLE, + DRP0_INTERRUPT_ENABLE, + DRP0_INTERRUPT_ENABLE); + if (ret) + return ret; + + 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_error_status(int err_type, struct llcc_drv_data *drv) +{ + int ret = 0; + + switch (err_type) { + case LLCC_DRAM_CE: + case LLCC_DRAM_UE: + ret = regmap_write(drv->bcast_regmap, DRP_INTERRUPT_CLEAR, + DRP_TRP_INT_CLEAR); + if (ret) + return ret; + + 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; + default: + ret = -EINVAL; + edac_printk(KERN_CRIT, EDAC_LLCC, "Unexpected error type: %d\n", + err_type); + } + 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 = edac_reg_data[err_type]; + 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.name, i, synd_val); + } + + ret = regmap_read(drv->regmap, + drv->offsets[bank] + reg_data.count_status_reg, + &err_cnt); + if (ret) + goto clear; + + err_cnt &= reg_data.count_mask; + err_cnt >>= reg_data.count_shift; + edac_printk(KERN_CRIT, EDAC_LLCC, "%s: Error count: 0x%4x\n", + reg_data.name, err_cnt); + + ret = regmap_read(drv->regmap, + drv->offsets[bank] + reg_data.ways_status_reg, + &err_ways); + if (ret) + goto clear; + + err_ways &= reg_data.ways_mask; + err_ways >>= reg_data.ways_shift; + + edac_printk(KERN_CRIT, EDAC_LLCC, "%s: Error ways: 0x%4x\n", + reg_data.name, err_ways); + +clear: + return qcom_llcc_clear_error_status(err_type, drv); +} + +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; + + 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; + default: + ret = -EINVAL; + edac_printk(KERN_CRIT, EDAC_LLCC, "Unexpected error type: %d\n", + err_type); + } + + return ret; +} + +static irqreturn_t +llcc_ecc_irq_handler(int irq, void *edev_ctl) +{ + struct edac_device_ctl_info *edac_dev_ctl = edev_ctl; + struct llcc_drv_data *drv = edac_dev_ctl->pvt_info; + irqreturn_t irq_rc = IRQ_NONE; + u32 drp_error, trp_error, i; + bool irq_handled; + int ret; + + /* Iterate over the banks and look for Tag RAM or Data RAM errors */ + for (i = 0; i < drv->num_banks; i++) { + ret = regmap_read(drv->regmap, + drv->offsets[i] + DRP_INTERRUPT_STATUS, + &drp_error); + + if (!ret && (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); + } else if (!ret && (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_handled = true; + + ret = regmap_read(drv->regmap, + drv->offsets[i] + TRP_INTERRUPT_0_STATUS, + &trp_error); + + if (!ret && (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); + } else if (!ret && (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_handled = true; + } + + if (irq_handled) + irq_rc = IRQ_HANDLED; + + return irq_rc; +} + +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; + + 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; + 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); + + return 0; +} + +static const struct of_device_id qcom_llcc_edac_match_table[] = { + { .compatible = "qcom,llcc-edac" }, + { }, +}; + +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..69c285b 100644 --- a/include/linux/soc/qcom/llcc-qcom.h +++ b/include/linux/soc/qcom/llcc-qcom.h @@ -93,6 +93,30 @@ struct llcc_drv_data { int ecc_irq; }; +/** + * llcc_edac_reg_data - llcc edac registers data for each error type + * @name: Name of the error + * @synd_reg: Syndrome register address + * @count_status_reg: Status register address to read the error count + * @ways_status_reg: Status register address to read the error ways + * @reg_cnt: Number of registers + * @count_mask: Mask value to get the error count + * @ways_mask: Mask value to get the error ways + * @count_shift: Shift value to get the error count + * @ways_shift: Shift value to get the error ways + */ +struct llcc_edac_reg_data { + char *name; + u64 synd_reg; + u64 count_status_reg; + u64 ways_status_reg; + u32 reg_cnt; + u32 count_mask; + u32 ways_mask; + u8 count_shift; + u8 ways_shift; +}; + #if IS_ENABLED(CONFIG_QCOM_LLCC) /** * llcc_slice_getd - get llcc slice descriptor -- The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum, a Linux Foundation Collaborative Project 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: [v4,3/4] drivers: edac: Add EDAC driver support for QCOM SoCs From: Venkata Narendra Kumar Gutta Message-Id: <1536103345-1919-4-git-send-email-vnkgutta@codeaurora.org> Date: Tue, 4 Sep 2018 16:22:24 -0700 To: Borislav Petkov , evgreen@chromium.org, robh@kernel.org, mchehab@kernel.org, linux-edac@vger.kernel.org, linux-kernel@vger.kernel.org, Andy Gross , David Brown , linux-arm-msm@vger.kernel.org, linux-soc@vger.kernel.org, robh+dt@kernel.org, mark.rutland@arm.com, devicetree@vger.kernel.org, tsoni@codeaurora.org, ckadabi@codeaurora.org, rishabhb@codeaurora.org, swboyd@chromium.org, bjorn.andersson@linaro.org Cc: Venkata Narendra Kumar Gutta List-ID: RnJvbTogQ2hhbm5hZ291ZCBLYWRhYmkgPGNrYWRhYmlAY29kZWF1cm9yYS5vcmc+CgpBZGQgZXJy b3IgcmVwb3J0aW5nIGRyaXZlciBmb3IgU2luZ2xlIEJpdCBFcnJvcnMgKFNCRXMpIGFuZCBEb3Vi bGUgQml0CkVycm9ycyAoREJFcykuIEFzIG9mIG5vdywgdGhpcyBkcml2ZXIgc3VwcG9ydHMgZXJy b3IgcmVwb3J0aW5nIGZvcgpMYXN0IExldmVsIENhY2hlIENvbnRyb2xsZXIgKExMQ0MpIG9mIFRh ZyBSQU0gYW5kIERhdGEgUkFNLiBJbnRlcnJ1cHRzCmFyZSB0cmlnZ2VyZWQgd2hlbiB0aGUgZXJy b3JzIGhhcHBlbiBpbiB0aGUgY2FjaGUsIHRoZSBkcml2ZXIgaGFuZGxlcwp0aG9zZSBpbnRlcnJ1 cHRzIGFuZCBkdW1wcyB0aGUgc3luZHJvbWUgcmVnaXN0ZXJzLgoKU2lnbmVkLW9mZi1ieTogQ2hh bm5hZ291ZCBLYWRhYmkgPGNrYWRhYmlAY29kZWF1cm9yYS5vcmc+ClNpZ25lZC1vZmYtYnk6IFZl bmthdGEgTmFyZW5kcmEgS3VtYXIgR3V0dGEgPHZua2d1dHRhQGNvZGVhdXJvcmEub3JnPgpDby1k ZXZlbG9wZWQtYnk6IFZlbmthdGEgTmFyZW5kcmEgS3VtYXIgR3V0dGEgPHZua2d1dHRhQGNvZGVh dXJvcmEub3JnPgotLS0KIE1BSU5UQUlORVJTICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDgg KwogZHJpdmVycy9lZGFjL0tjb25maWcgICAgICAgICAgICAgICB8ICAxNCArKwogZHJpdmVycy9l ZGFjL01ha2VmaWxlICAgICAgICAgICAgICB8ICAgMSArCiBkcml2ZXJzL2VkYWMvcWNvbV9lZGFj LmMgICAgICAgICAgIHwgNDIwICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysK IGluY2x1ZGUvbGludXgvc29jL3Fjb20vbGxjYy1xY29tLmggfCAgMjQgKysrCiA1IGZpbGVzIGNo YW5nZWQsIDQ2NyBpbnNlcnRpb25zKCspCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9lZGFj L3Fjb21fZWRhYy5jCgpkaWZmIC0tZ2l0IGEvTUFJTlRBSU5FUlMgYi9NQUlOVEFJTkVSUwppbmRl eCAwYTIzNDI3Li4wYmZmNzEzIDEwMDY0NAotLS0gYS9NQUlOVEFJTkVSUworKysgYi9NQUlOVEFJ TkVSUwpAQCAtNTIyNyw2ICs1MjI3LDE0IEBAIEw6CWxpbnV4LWVkYWNAdmdlci5rZXJuZWwub3Jn CiBTOglNYWludGFpbmVkCiBGOglkcml2ZXJzL2VkYWMvdGlfZWRhYy5jCiAKK0VEQUMtUVVBTENP TU0KK006CUNoYW5uYWdvdWQgS2FkYWJpIDxja2FkYWJpQGNvZGVhdXJvcmEub3JnPgorTToJVmVu a2F0YSBOYXJlbmRyYSBLdW1hciBHdXR0YSA8dm5rZ3V0dGFAY29kZWF1cm9yYS5vcmc+CitMOgls aW51eC1hcm0tbXNtQHZnZXIua2VybmVsLm9yZworTDoJbGludXgtZWRhY0B2Z2VyLmtlcm5lbC5v cmcKK1M6CU1haW50YWluZWQKK0Y6CWRyaXZlcnMvZWRhYy9xY29tX2VkYWMuYworCiBFRElST0wg VUEtMTAxL1VBLTEwMDAgRFJJVkVSCiBNOglDbGVtZW5zIExhZGlzY2ggPGNsZW1lbnNAbGFkaXNj aC5kZT4KIEw6CWFsc2EtZGV2ZWxAYWxzYS1wcm9qZWN0Lm9yZyAobW9kZXJhdGVkIGZvciBub24t c3Vic2NyaWJlcnMpCmRpZmYgLS1naXQgYS9kcml2ZXJzL2VkYWMvS2NvbmZpZyBiL2RyaXZlcnMv ZWRhYy9LY29uZmlnCmluZGV4IDU3MzA0YjIuLmM0ZTM0NzIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMv ZWRhYy9LY29uZmlnCisrKyBiL2RyaXZlcnMvZWRhYy9LY29uZmlnCkBAIC00NjAsNCArNDYwLDE4 IEBAIGNvbmZpZyBFREFDX1RJCiAJICBTdXBwb3J0IGZvciBlcnJvciBkZXRlY3Rpb24gYW5kIGNv cnJlY3Rpb24gb24gdGhlCiAgICAgICAgICAgVEkgU29Dcy4KIAorY29uZmlnIEVEQUNfUUNPTQor CXRyaXN0YXRlICJRQ09NIEVEQUMgQ29udHJvbGxlciIKKwlkZXBlbmRzIG9uIEFSQ0hfUUNPTSAm JiBRQ09NX0xMQ0MKKwloZWxwCisJICBTdXBwb3J0IGZvciBlcnJvciBkZXRlY3Rpb24gYW5kIGNv cnJlY3Rpb24gb24gdGhlCisJICBRQ09NIFNvQ3MuCisKKwkgIFRoaXMgZHJpdmVyIHJlcG9ydHMg U2luZ2xlIEJpdCBFcnJvcnMgKFNCRXMpIGFuZCBEb3VibGUgQml0IEVycm9ycyAoREJFcykuCisJ ICBBcyBvZiBub3csIGl0IHN1cHBvcnRzIGVycm9yIHJlcG9ydGluZyBmb3IgTGFzdCBMZXZlbCBD YWNoZSBDb250cm9sbGVyIChMTENDKQorCSAgb2YgVGFnIFJBTSBhbmQgRGF0YSBSQU0uCisKKwkg IEZvciBkZWJ1Z2dpbmcgaXNzdWVzIGhhdmluZyB0byBkbyB3aXRoIHN0YWJpbGl0eSBhbmQgb3Zl cmFsbCBzeXN0ZW0KKwkgIGhlYWx0aCwgeW91IHNob3VsZCBwcm9iYWJseSBzYXkgJ1knIGhlcmUu CisKIGVuZGlmICMgRURBQwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9lZGFjL01ha2VmaWxlIGIvZHJp dmVycy9lZGFjL01ha2VmaWxlCmluZGV4IDAyYjQzYTcuLjcxNjA5NmQgMTAwNjQ0Ci0tLSBhL2Ry aXZlcnMvZWRhYy9NYWtlZmlsZQorKysgYi9kcml2ZXJzL2VkYWMvTWFrZWZpbGUKQEAgLTc3LDMg Kzc3LDQgQEAgb2JqLSQoQ09ORklHX0VEQUNfQUxURVJBKQkJKz0gYWx0ZXJhX2VkYWMubwogb2Jq LSQoQ09ORklHX0VEQUNfU1lOT1BTWVMpCQkrPSBzeW5vcHN5c19lZGFjLm8KIG9iai0kKENPTkZJ R19FREFDX1hHRU5FKQkJKz0geGdlbmVfZWRhYy5vCiBvYmotJChDT05GSUdfRURBQ19USSkJCQkr PSB0aV9lZGFjLm8KK29iai0kKENPTkZJR19FREFDX1FDT00pCQkJKz0gcWNvbV9lZGFjLm8KZGlm ZiAtLWdpdCBhL2RyaXZlcnMvZWRhYy9xY29tX2VkYWMuYyBiL2RyaXZlcnMvZWRhYy9xY29tX2Vk YWMuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4xNzczMjE2Ci0tLSAvZGV2 L251bGwKKysrIGIvZHJpdmVycy9lZGFjL3Fjb21fZWRhYy5jCkBAIC0wLDAgKzEsNDIwIEBACisv LyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMAorLyoKKyAqIENvcHlyaWdodCAoYykg MjAxOCwgVGhlIExpbnV4IEZvdW5kYXRpb24uIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKi8KKwor I2luY2x1ZGUgPGxpbnV4L2VkYWMuaD4KKyNpbmNsdWRlIDxsaW51eC9pbnRlcnJ1cHQuaD4KKyNp bmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KKyNpbmNsdWRlIDxsaW51eC9vZi5oPgorI2luY2x1ZGUg PGxpbnV4L3BsYXRmb3JtX2RldmljZS5oPgorI2luY2x1ZGUgPGxpbnV4L3JlZ21hcC5oPgorI2lu Y2x1ZGUgPGxpbnV4L3NvYy9xY29tL2xsY2MtcWNvbS5oPgorCisjaW5jbHVkZSAiZWRhY19tYy5o IgorI2luY2x1ZGUgImVkYWNfZGV2aWNlLmgiCisKKyNkZWZpbmUgRURBQ19MTENDICAgICAgICAg ICAgICAgICAgICAgICAicWNvbV9sbGNjIgorCisjZGVmaW5lIExMQ0NfRVJQX1BBTklDX09OX1VF ICAgICAgICAgICAgMQorCisjZGVmaW5lIFRSUF9TWU5fUkVHX0NOVCAgICAgICAgICAgICAgICAg NgorI2RlZmluZSBEUlBfU1lOX1JFR19DTlQgICAgICAgICAgICAgICAgIDgKKworI2RlZmluZSBM TENDX0NPTU1PTl9TVEFUVVMwICAgICAgICAgICAgIDB4MDAwMzAwMGMKKyNkZWZpbmUgTExDQ19M Ql9DTlRfTUFTSyAgICAgICAgICAgICAgICBHRU5NQVNLKDMxLCAyOCkKKyNkZWZpbmUgTExDQ19M Ql9DTlRfU0hJRlQgICAgICAgICAgICAgICAyOAorCisvKiBTaW5nbGUgJiBkb3VibGUgYml0IHN5 bmRyb21lIHJlZ2lzdGVyIG9mZnNldHMgKi8KKyNkZWZpbmUgVFJQX0VDQ19TQl9FUlJfU1lOMCAg ICAgICAgICAgICAweDAwMDIzMDRjCisjZGVmaW5lIFRSUF9FQ0NfREJfRVJSX1NZTjAgICAgICAg ICAgICAgMHgwMDAyMDM3MAorI2RlZmluZSBEUlBfRUNDX1NCX0VSUl9TWU4wICAgICAgICAgICAg IDB4MDAwNDIwNGMKKyNkZWZpbmUgRFJQX0VDQ19EQl9FUlJfU1lOMCAgICAgICAgICAgICAweDAw MDQyMDcwCisKKy8qIEVycm9yIHJlZ2lzdGVyIG9mZnNldHMgKi8KKyNkZWZpbmUgVFJQX0VDQ19F UlJPUl9TVEFUVVMxICAgICAgICAgICAweDAwMDIwMzQ4CisjZGVmaW5lIFRSUF9FQ0NfRVJST1Jf U1RBVFVTMCAgICAgICAgICAgMHgwMDAyMDM0NAorI2RlZmluZSBEUlBfRUNDX0VSUk9SX1NUQVRV UzEgICAgICAgICAgIDB4MDAwNDIwNDgKKyNkZWZpbmUgRFJQX0VDQ19FUlJPUl9TVEFUVVMwICAg ICAgICAgICAweDAwMDQyMDQ0CisKKy8qIFRSUCwgRFJQIGludGVycnVwdCByZWdpc3RlciBvZmZz ZXRzICovCisjZGVmaW5lIERSUF9JTlRFUlJVUFRfU1RBVFVTICAgICAgICAgICAgMHgwMDA0MTAw MAorI2RlZmluZSBUUlBfSU5URVJSVVBUXzBfU1RBVFVTICAgICAgICAgIDB4MDAwMjA0ODAKKyNk ZWZpbmUgRFJQX0lOVEVSUlVQVF9DTEVBUiAgICAgICAgICAgICAweDAwMDQxMDA4CisjZGVmaW5l IERSUF9FQ0NfRVJST1JfQ05UUl9DTEVBUiAgICAgICAgMHgwMDA0MDAwNAorI2RlZmluZSBUUlBf SU5URVJSVVBUXzBfQ0xFQVIgICAgICAgICAgIDB4MDAwMjA0ODQKKyNkZWZpbmUgVFJQX0VDQ19F UlJPUl9DTlRSX0NMRUFSICAgICAgICAweDAwMDIwNDQwCisKKy8qIE1hc2sgYW5kIHNoaWZ0IG1h Y3JvcyAqLworI2RlZmluZSBFQ0NfREJfRVJSX0NPVU5UX01BU0sgICAgICAgICAgIEdFTk1BU0so NCwgMCkKKyNkZWZpbmUgRUNDX0RCX0VSUl9XQVlTX01BU0sgICAgICAgICAgICBHRU5NQVNLKDMx LCAxNikKKyNkZWZpbmUgRUNDX0RCX0VSUl9XQVlTX1NISUZUICAgICAgICAgICBCSVQoNCkKKwor I2RlZmluZSBFQ0NfU0JfRVJSX0NPVU5UX01BU0sgICAgICAgICAgIEdFTk1BU0soMjMsIDE2KQor I2RlZmluZSBFQ0NfU0JfRVJSX0NPVU5UX1NISUZUICAgICAgICAgIEJJVCg0KQorI2RlZmluZSBF Q0NfU0JfRVJSX1dBWVNfTUFTSyAgICAgICAgICAgIEdFTk1BU0soMTUsIDApCisKKyNkZWZpbmUg U0JfRUNDX0VSUk9SICAgICAgICAgICAgICAgICAgICBCSVQoMCkKKyNkZWZpbmUgREJfRUNDX0VS Uk9SICAgICAgICAgICAgICAgICAgICBCSVQoMSkKKworI2RlZmluZSBEUlBfVFJQX0lOVF9DTEVB UiAgICAgICAgICAgICAgIEdFTk1BU0soMSwgMCkKKyNkZWZpbmUgRFJQX1RSUF9DTlRfQ0xFQVIg ICAgICAgICAgICAgICBHRU5NQVNLKDEsIDApCisKKy8qIENvbmZpZyByZWdpc3RlcnMgb2Zmc2V0 cyovCisjZGVmaW5lIERSUF9FQ0NfRVJST1JfQ0ZHICAgICAgICAgICAgICAgMHgwMDA0MDAwMAor CisvKiBUYWcgUkFNLCBEYXRhIFJBTSBpbnRlcnJ1cHQgcmVnaXN0ZXIgb2Zmc2V0cyAqLworI2Rl ZmluZSBDTU5fSU5URVJSVVBUXzBfRU5BQkxFICAgICAgICAgIDB4MDAwMzAwMWMKKyNkZWZpbmUg Q01OX0lOVEVSUlVQVF8yX0VOQUJMRSAgICAgICAgICAweDAwMDMwMDNjCisjZGVmaW5lIFRSUF9J TlRFUlJVUFRfMF9FTkFCTEUgICAgICAgICAgMHgwMDAyMDQ4OAorI2RlZmluZSBEUlBfSU5URVJS VVBUX0VOQUJMRSAgICAgICAgICAgIDB4MDAwNDEwMGMKKworI2RlZmluZSBTQl9FUlJPUl9USFJF U0hPTEQgICAgICAgICAgICAgIDB4MQorI2RlZmluZSBTQl9FUlJPUl9USFJFU0hPTERfU0hJRlQg ICAgICAgIDI0CisjZGVmaW5lIFNCX0RCX1RSUF9JTlRFUlJVUFRfRU5BQkxFICAgICAgMHgzCisj ZGVmaW5lIFRSUDBfSU5URVJSVVBUX0VOQUJMRSAgICAgICAgICAgMHgxCisjZGVmaW5lIERSUDBf SU5URVJSVVBUX0VOQUJMRSAgICAgICAgICAgQklUKDYpCisjZGVmaW5lIFNCX0RCX0RSUF9JTlRF UlJVUFRfRU5BQkxFICAgICAgMHgzCisKK2VudW0geworCUxMQ0NfRFJBTV9DRSA9IDAsCisJTExD Q19EUkFNX1VFLAorCUxMQ0NfVFJBTV9DRSwKKwlMTENDX1RSQU1fVUUsCit9OworCitzdGF0aWMg Y29uc3Qgc3RydWN0IGxsY2NfZWRhY19yZWdfZGF0YSBlZGFjX3JlZ19kYXRhW10gPSB7CisJW0xM Q0NfRFJBTV9DRV0gPSB7CisJCS5uYW1lID0gIkRSQU0gU2luZ2xlLWJpdCIsCisJCS5zeW5kX3Jl ZyA9IERSUF9FQ0NfU0JfRVJSX1NZTjAsCisJCS5jb3VudF9zdGF0dXNfcmVnID0gRFJQX0VDQ19F UlJPUl9TVEFUVVMxLAorCQkud2F5c19zdGF0dXNfcmVnID0gRFJQX0VDQ19FUlJPUl9TVEFUVVMw LAorCQkucmVnX2NudCA9IERSUF9TWU5fUkVHX0NOVCwKKwkJLmNvdW50X21hc2sgPSBFQ0NfU0Jf RVJSX0NPVU5UX01BU0ssCisJCS53YXlzX21hc2sgPSBFQ0NfU0JfRVJSX1dBWVNfTUFTSywKKwkJ LmNvdW50X3NoaWZ0ID0gRUNDX1NCX0VSUl9DT1VOVF9TSElGVCwKKwl9LAorCVtMTENDX0RSQU1f VUVdID0geworCQkubmFtZSA9ICJEUkFNIERvdWJsZS1iaXQiLAorCQkuc3luZF9yZWcgPSBEUlBf RUNDX0RCX0VSUl9TWU4wLAorCQkuY291bnRfc3RhdHVzX3JlZyA9IERSUF9FQ0NfRVJST1JfU1RB VFVTMSwKKwkJLndheXNfc3RhdHVzX3JlZyA9IERSUF9FQ0NfRVJST1JfU1RBVFVTMCwKKwkJLnJl Z19jbnQgPSBEUlBfU1lOX1JFR19DTlQsCisJCS5jb3VudF9tYXNrID0gRUNDX0RCX0VSUl9DT1VO VF9NQVNLLAorCQkud2F5c19tYXNrID0gRUNDX0RCX0VSUl9XQVlTX01BU0ssCisJCS53YXlzX3No aWZ0ID0gRUNDX0RCX0VSUl9XQVlTX1NISUZULAorCX0sCisJW0xMQ0NfVFJBTV9DRV0gPSB7CisJ CS5uYW1lID0gIlRSQU0gU2luZ2xlLWJpdCIsCisJCS5zeW5kX3JlZyA9IFRSUF9FQ0NfU0JfRVJS X1NZTjAsCisJCS5jb3VudF9zdGF0dXNfcmVnID0gVFJQX0VDQ19FUlJPUl9TVEFUVVMxLAorCQku d2F5c19zdGF0dXNfcmVnID0gVFJQX0VDQ19FUlJPUl9TVEFUVVMwLAorCQkucmVnX2NudCA9IFRS UF9TWU5fUkVHX0NOVCwKKwkJLmNvdW50X21hc2sgPSBFQ0NfU0JfRVJSX0NPVU5UX01BU0ssCisJ CS53YXlzX21hc2sgPSBFQ0NfU0JfRVJSX1dBWVNfTUFTSywKKwkJLmNvdW50X3NoaWZ0ID0gRUND X1NCX0VSUl9DT1VOVF9TSElGVCwKKwl9LAorCVtMTENDX1RSQU1fVUVdID0geworCQkubmFtZSA9 ICJUUkFNIERvdWJsZS1iaXQiLAorCQkuc3luZF9yZWcgPSBUUlBfRUNDX0RCX0VSUl9TWU4wLAor CQkuY291bnRfc3RhdHVzX3JlZyA9IFRSUF9FQ0NfRVJST1JfU1RBVFVTMSwKKwkJLndheXNfc3Rh dHVzX3JlZyA9IFRSUF9FQ0NfRVJST1JfU1RBVFVTMCwKKwkJLnJlZ19jbnQgPSBUUlBfU1lOX1JF R19DTlQsCisJCS5jb3VudF9tYXNrID0gRUNDX0RCX0VSUl9DT1VOVF9NQVNLLAorCQkud2F5c19t YXNrID0gRUNDX0RCX0VSUl9XQVlTX01BU0ssCisJCS53YXlzX3NoaWZ0ID0gRUNDX0RCX0VSUl9X QVlTX1NISUZULAorCX0sCit9OworCitzdGF0aWMgaW50IHFjb21fbGxjY19jb3JlX3NldHVwKHN0 cnVjdCByZWdtYXAgKmxsY2NfYmNhc3RfcmVnbWFwKQoreworCXUzMiBzYl9lcnJfdGhyZXNob2xk OworCWludCByZXQ7CisKKwkvKgorCSAqIENvbmZpZ3VyZSBpbnRlcnJ1cHQgZW5hYmxlIHJlZ2lz dGVycyBzdWNoIHRoYXQgVGFnLCBEYXRhIFJBTSByZWxhdGVkCisJICogaW50ZXJydXB0cyBhcmUg cHJvcGFnYXRlZCB0byBpbnRlcnJ1cHQgY29udHJvbGxlciBmb3Igc2VydmljaW5nCisJICovCisJ cmV0ID0gcmVnbWFwX3VwZGF0ZV9iaXRzKGxsY2NfYmNhc3RfcmVnbWFwLCBDTU5fSU5URVJSVVBU XzJfRU5BQkxFLAorCQkJCSBUUlAwX0lOVEVSUlVQVF9FTkFCTEUsCisJCQkJIFRSUDBfSU5URVJS VVBUX0VOQUJMRSk7CisJaWYgKHJldCkKKwkJcmV0dXJuIHJldDsKKworCXJldCA9IHJlZ21hcF91 cGRhdGVfYml0cyhsbGNjX2JjYXN0X3JlZ21hcCwgVFJQX0lOVEVSUlVQVF8wX0VOQUJMRSwKKwkJ CQkgU0JfREJfVFJQX0lOVEVSUlVQVF9FTkFCTEUsCisJCQkJIFNCX0RCX1RSUF9JTlRFUlJVUFRf RU5BQkxFKTsKKwlpZiAocmV0KQorCQlyZXR1cm4gcmV0OworCisJc2JfZXJyX3RocmVzaG9sZCA9 IChTQl9FUlJPUl9USFJFU0hPTEQgPDwgU0JfRVJST1JfVEhSRVNIT0xEX1NISUZUKTsKKwlyZXQg PSByZWdtYXBfd3JpdGUobGxjY19iY2FzdF9yZWdtYXAsIERSUF9FQ0NfRVJST1JfQ0ZHLAorCQkJ ICAgc2JfZXJyX3RocmVzaG9sZCk7CisJaWYgKHJldCkKKwkJcmV0dXJuIHJldDsKKworCXJldCA9 IHJlZ21hcF91cGRhdGVfYml0cyhsbGNjX2JjYXN0X3JlZ21hcCwgQ01OX0lOVEVSUlVQVF8yX0VO QUJMRSwKKwkJCQkgRFJQMF9JTlRFUlJVUFRfRU5BQkxFLAorCQkJCSBEUlAwX0lOVEVSUlVQVF9F TkFCTEUpOworCWlmIChyZXQpCisJCXJldHVybiByZXQ7CisKKwlyZXQgPSByZWdtYXBfd3JpdGUo bGxjY19iY2FzdF9yZWdtYXAsIERSUF9JTlRFUlJVUFRfRU5BQkxFLAorCQkJICAgU0JfREJfRFJQ X0lOVEVSUlVQVF9FTkFCTEUpOworCXJldHVybiByZXQ7Cit9CisKKy8qIENsZWFyIHRoZSBlcnJv ciBpbnRlcnJ1cHQgYW5kIGNvdW50ZXIgcmVnaXN0ZXJzICovCitzdGF0aWMgaW50CitxY29tX2xs Y2NfY2xlYXJfZXJyb3Jfc3RhdHVzKGludCBlcnJfdHlwZSwgc3RydWN0IGxsY2NfZHJ2X2RhdGEg KmRydikKK3sKKwlpbnQgcmV0ID0gMDsKKworCXN3aXRjaCAoZXJyX3R5cGUpIHsKKwljYXNlIExM Q0NfRFJBTV9DRToKKwljYXNlIExMQ0NfRFJBTV9VRToKKwkJcmV0ID0gcmVnbWFwX3dyaXRlKGRy di0+YmNhc3RfcmVnbWFwLCBEUlBfSU5URVJSVVBUX0NMRUFSLAorCQkJCSAgIERSUF9UUlBfSU5U X0NMRUFSKTsKKwkJaWYgKHJldCkKKwkJCXJldHVybiByZXQ7CisKKwkJcmV0ID0gcmVnbWFwX3dy aXRlKGRydi0+YmNhc3RfcmVnbWFwLCBEUlBfRUNDX0VSUk9SX0NOVFJfQ0xFQVIsCisJCQkJICAg RFJQX1RSUF9DTlRfQ0xFQVIpOworCQlpZiAocmV0KQorCQkJcmV0dXJuIHJldDsKKwkJYnJlYWs7 CisJY2FzZSBMTENDX1RSQU1fQ0U6CisJY2FzZSBMTENDX1RSQU1fVUU6CisJCXJldCA9IHJlZ21h cF93cml0ZShkcnYtPmJjYXN0X3JlZ21hcCwgVFJQX0lOVEVSUlVQVF8wX0NMRUFSLAorCQkJCSAg IERSUF9UUlBfSU5UX0NMRUFSKTsKKwkJaWYgKHJldCkKKwkJCXJldHVybiByZXQ7CisKKwkJcmV0 ID0gcmVnbWFwX3dyaXRlKGRydi0+YmNhc3RfcmVnbWFwLCBUUlBfRUNDX0VSUk9SX0NOVFJfQ0xF QVIsCisJCQkJICAgRFJQX1RSUF9DTlRfQ0xFQVIpOworCQlpZiAocmV0KQorCQkJcmV0dXJuIHJl dDsKKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJcmV0ID0gLUVJTlZBTDsKKwkJZWRhY19wcmludGso S0VSTl9DUklULCBFREFDX0xMQ0MsICJVbmV4cGVjdGVkIGVycm9yIHR5cGU6ICVkXG4iLAorCQkJ ICAgIGVycl90eXBlKTsKKwl9CisJcmV0dXJuIHJldDsKK30KKworLyogRHVtcCBTeW5kcm9tZSBy ZWdpc3RlcnMgZGF0YSBmb3IgVGFnIFJBTSwgRGF0YSBSQU0gYml0IGVycm9ycyovCitzdGF0aWMg aW50CitkdW1wX3N5bl9yZWdfdmFsdWVzKHN0cnVjdCBsbGNjX2Rydl9kYXRhICpkcnYsIHUzMiBi YW5rLCBpbnQgZXJyX3R5cGUpCit7CisJc3RydWN0IGxsY2NfZWRhY19yZWdfZGF0YSByZWdfZGF0 YSA9IGVkYWNfcmVnX2RhdGFbZXJyX3R5cGVdOworCWludCBlcnJfY250LCBlcnJfd2F5cywgcmV0 LCBpOworCXUzMiBzeW5kX3JlZywgc3luZF92YWw7CisKKwlmb3IgKGkgPSAwOyBpIDwgcmVnX2Rh dGEucmVnX2NudDsgaSsrKSB7CisJCXN5bmRfcmVnID0gcmVnX2RhdGEuc3luZF9yZWcgKyAoaSAq IDQpOworCQlyZXQgPSByZWdtYXBfcmVhZChkcnYtPnJlZ21hcCwgZHJ2LT5vZmZzZXRzW2Jhbmtd ICsgc3luZF9yZWcsCisJCQkJICAmc3luZF92YWwpOworCQlpZiAocmV0KQorCQkJZ290byBjbGVh cjsKKworCQllZGFjX3ByaW50ayhLRVJOX0NSSVQsIEVEQUNfTExDQywgIiVzOiBFQ0NfU1lOJWQ6 IDB4JTh4XG4iLAorCQkJICAgIHJlZ19kYXRhLm5hbWUsIGksIHN5bmRfdmFsKTsKKwl9CisKKwly ZXQgPSByZWdtYXBfcmVhZChkcnYtPnJlZ21hcCwKKwkJCSAgZHJ2LT5vZmZzZXRzW2JhbmtdICsg cmVnX2RhdGEuY291bnRfc3RhdHVzX3JlZywKKwkJCSAgJmVycl9jbnQpOworCWlmIChyZXQpCisJ CWdvdG8gY2xlYXI7CisKKwllcnJfY250ICY9IHJlZ19kYXRhLmNvdW50X21hc2s7CisJZXJyX2Nu dCA+Pj0gcmVnX2RhdGEuY291bnRfc2hpZnQ7CisJZWRhY19wcmludGsoS0VSTl9DUklULCBFREFD X0xMQ0MsICIlczogRXJyb3IgY291bnQ6IDB4JTR4XG4iLAorCQkgICAgcmVnX2RhdGEubmFtZSwg ZXJyX2NudCk7CisKKwlyZXQgPSByZWdtYXBfcmVhZChkcnYtPnJlZ21hcCwKKwkJCSAgZHJ2LT5v ZmZzZXRzW2JhbmtdICsgcmVnX2RhdGEud2F5c19zdGF0dXNfcmVnLAorCQkJICAmZXJyX3dheXMp OworCWlmIChyZXQpCisJCWdvdG8gY2xlYXI7CisKKwllcnJfd2F5cyAmPSByZWdfZGF0YS53YXlz X21hc2s7CisJZXJyX3dheXMgPj49IHJlZ19kYXRhLndheXNfc2hpZnQ7CisKKwllZGFjX3ByaW50 ayhLRVJOX0NSSVQsIEVEQUNfTExDQywgIiVzOiBFcnJvciB3YXlzOiAweCU0eFxuIiwKKwkJICAg IHJlZ19kYXRhLm5hbWUsIGVycl93YXlzKTsKKworY2xlYXI6CisJcmV0dXJuIHFjb21fbGxjY19j bGVhcl9lcnJvcl9zdGF0dXMoZXJyX3R5cGUsIGRydik7Cit9CisKK3N0YXRpYyBpbnQKK2R1bXBf c3luX3JlZyhzdHJ1Y3QgZWRhY19kZXZpY2VfY3RsX2luZm8gKmVkZXZfY3RsLCBpbnQgZXJyX3R5 cGUsIHUzMiBiYW5rKQoreworCXN0cnVjdCBsbGNjX2Rydl9kYXRhICpkcnYgPSBlZGV2X2N0bC0+ cHZ0X2luZm87CisJaW50IHJldDsKKworCXJldCA9IGR1bXBfc3luX3JlZ192YWx1ZXMoZHJ2LCBi YW5rLCBlcnJfdHlwZSk7CisJaWYgKHJldCkKKwkJcmV0dXJuIHJldDsKKworCXN3aXRjaCAoZXJy X3R5cGUpIHsKKwljYXNlIExMQ0NfRFJBTV9DRToKKwkJZWRhY19kZXZpY2VfaGFuZGxlX2NlKGVk ZXZfY3RsLCAwLCBiYW5rLAorCQkJCSAgICAgICJMTENDIERhdGEgUkFNIGNvcnJlY3RhYmxlIEVy cm9yIik7CisJCWJyZWFrOworCWNhc2UgTExDQ19EUkFNX1VFOgorCQllZGFjX2RldmljZV9oYW5k bGVfdWUoZWRldl9jdGwsIDAsIGJhbmssCisJCQkJICAgICAgIkxMQ0MgRGF0YSBSQU0gdW5jb3Jy ZWN0YWJsZSBFcnJvciIpOworCQlicmVhazsKKwljYXNlIExMQ0NfVFJBTV9DRToKKwkJZWRhY19k ZXZpY2VfaGFuZGxlX2NlKGVkZXZfY3RsLCAwLCBiYW5rLAorCQkJCSAgICAgICJMTENDIFRhZyBS QU0gY29ycmVjdGFibGUgRXJyb3IiKTsKKwkJYnJlYWs7CisJY2FzZSBMTENDX1RSQU1fVUU6CisJ CWVkYWNfZGV2aWNlX2hhbmRsZV91ZShlZGV2X2N0bCwgMCwgYmFuaywKKwkJCQkgICAgICAiTExD QyBUYWcgUkFNIHVuY29ycmVjdGFibGUgRXJyb3IiKTsKKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJ cmV0ID0gLUVJTlZBTDsKKwkJZWRhY19wcmludGsoS0VSTl9DUklULCBFREFDX0xMQ0MsICJVbmV4 cGVjdGVkIGVycm9yIHR5cGU6ICVkXG4iLAorCQkJICAgIGVycl90eXBlKTsKKwl9CisKKwlyZXR1 cm4gcmV0OworfQorCitzdGF0aWMgaXJxcmV0dXJuX3QKK2xsY2NfZWNjX2lycV9oYW5kbGVyKGlu dCBpcnEsIHZvaWQgKmVkZXZfY3RsKQoreworCXN0cnVjdCBlZGFjX2RldmljZV9jdGxfaW5mbyAq ZWRhY19kZXZfY3RsID0gZWRldl9jdGw7CisJc3RydWN0IGxsY2NfZHJ2X2RhdGEgKmRydiA9IGVk YWNfZGV2X2N0bC0+cHZ0X2luZm87CisJaXJxcmV0dXJuX3QgaXJxX3JjID0gSVJRX05PTkU7CisJ dTMyIGRycF9lcnJvciwgdHJwX2Vycm9yLCBpOworCWJvb2wgaXJxX2hhbmRsZWQ7CisJaW50IHJl dDsKKworCS8qIEl0ZXJhdGUgb3ZlciB0aGUgYmFua3MgYW5kIGxvb2sgZm9yIFRhZyBSQU0gb3Ig RGF0YSBSQU0gZXJyb3JzICovCisJZm9yIChpID0gMDsgaSA8IGRydi0+bnVtX2JhbmtzOyBpKysp IHsKKwkJcmV0ID0gcmVnbWFwX3JlYWQoZHJ2LT5yZWdtYXAsCisJCQkJICBkcnYtPm9mZnNldHNb aV0gKyBEUlBfSU5URVJSVVBUX1NUQVRVUywKKwkJCQkgICZkcnBfZXJyb3IpOworCisJCWlmICgh cmV0ICYmIChkcnBfZXJyb3IgJiBTQl9FQ0NfRVJST1IpKSB7CisJCQllZGFjX3ByaW50ayhLRVJO X0NSSVQsIEVEQUNfTExDQywKKwkJCQkgICAgIlNpbmdsZSBCaXQgRXJyb3IgZGV0ZWN0ZWQgaW4g RGF0YSBSQU1cbiIpOworCQkJcmV0ID0gZHVtcF9zeW5fcmVnKGVkZXZfY3RsLCBMTENDX0RSQU1f Q0UsIGkpOworCQl9IGVsc2UgaWYgKCFyZXQgJiYgKGRycF9lcnJvciAmIERCX0VDQ19FUlJPUikp IHsKKwkJCWVkYWNfcHJpbnRrKEtFUk5fQ1JJVCwgRURBQ19MTENDLAorCQkJCSAgICAiRG91Ymxl IEJpdCBFcnJvciBkZXRlY3RlZCBpbiBEYXRhIFJBTVxuIik7CisJCQlyZXQgPSBkdW1wX3N5bl9y ZWcoZWRldl9jdGwsIExMQ0NfRFJBTV9VRSwgaSk7CisJCX0KKwkJaWYgKCFyZXQpCisJCQlpcnFf aGFuZGxlZCA9IHRydWU7CisKKwkJcmV0ID0gcmVnbWFwX3JlYWQoZHJ2LT5yZWdtYXAsCisJCQkJ ICBkcnYtPm9mZnNldHNbaV0gKyBUUlBfSU5URVJSVVBUXzBfU1RBVFVTLAorCQkJCSAgJnRycF9l cnJvcik7CisKKwkJaWYgKCFyZXQgJiYgKHRycF9lcnJvciAmIFNCX0VDQ19FUlJPUikpIHsKKwkJ CWVkYWNfcHJpbnRrKEtFUk5fQ1JJVCwgRURBQ19MTENDLAorCQkJCSAgICAiU2luZ2xlIEJpdCBF cnJvciBkZXRlY3RlZCBpbiBUYWcgUkFNXG4iKTsKKwkJCXJldCA9IGR1bXBfc3luX3JlZyhlZGV2 X2N0bCwgTExDQ19UUkFNX0NFLCBpKTsKKwkJfSBlbHNlIGlmICghcmV0ICYmICh0cnBfZXJyb3Ig JiBEQl9FQ0NfRVJST1IpKSB7CisJCQllZGFjX3ByaW50ayhLRVJOX0NSSVQsIEVEQUNfTExDQywK KwkJCQkgICAgIkRvdWJsZSBCaXQgRXJyb3IgZGV0ZWN0ZWQgaW4gVGFnIFJBTVxuIik7CisJCQly ZXQgPSBkdW1wX3N5bl9yZWcoZWRldl9jdGwsIExMQ0NfVFJBTV9VRSwgaSk7CisJCX0KKwkJaWYg KCFyZXQpCisJCQlpcnFfaGFuZGxlZCA9IHRydWU7CisJfQorCisJaWYgKGlycV9oYW5kbGVkKQor CQlpcnFfcmMgPSBJUlFfSEFORExFRDsKKworCXJldHVybiBpcnFfcmM7Cit9CisKK3N0YXRpYyBp bnQgcWNvbV9sbGNjX2VkYWNfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKK3sK KwlzdHJ1Y3QgbGxjY19kcnZfZGF0YSAqbGxjY19kcml2X2RhdGEgPSBwZGV2LT5kZXYucGxhdGZv cm1fZGF0YTsKKwlzdHJ1Y3QgZWRhY19kZXZpY2VfY3RsX2luZm8gKmVkZXZfY3RsOworCXN0cnVj dCBkZXZpY2UgKmRldiA9ICZwZGV2LT5kZXY7CisJaW50IGVjY19pcnE7CisJaW50IHJjOworCisJ cmMgPSBxY29tX2xsY2NfY29yZV9zZXR1cChsbGNjX2RyaXZfZGF0YS0+YmNhc3RfcmVnbWFwKTsK KwlpZiAocmMpCisJCXJldHVybiByYzsKKworCS8qIEFsbG9jYXRlIGVkYWMgY29udHJvbCBpbmZv ICovCisJZWRldl9jdGwgPSBlZGFjX2RldmljZV9hbGxvY19jdGxfaW5mbygwLCAicWNvbS1sbGNj IiwgMSwgImJhbmsiLAorCQkJCQkgICAgICBsbGNjX2RyaXZfZGF0YS0+bnVtX2JhbmtzLCAxLAor CQkJCQkgICAgICBOVUxMLCAwLAorCQkJCQkgICAgICBlZGFjX2RldmljZV9hbGxvY19pbmRleCgp KTsKKworCWlmICghZWRldl9jdGwpCisJCXJldHVybiAtRU5PTUVNOworCisJZWRldl9jdGwtPmRl diA9IGRldjsKKwllZGV2X2N0bC0+bW9kX25hbWUgPSBkZXZfbmFtZShkZXYpOworCWVkZXZfY3Rs LT5kZXZfbmFtZSA9IGRldl9uYW1lKGRldik7CisJZWRldl9jdGwtPmN0bF9uYW1lID0gImxsY2Mi OworCWVkZXZfY3RsLT5wYW5pY19vbl91ZSA9IExMQ0NfRVJQX1BBTklDX09OX1VFOworCWVkZXZf Y3RsLT5wdnRfaW5mbyA9IGxsY2NfZHJpdl9kYXRhOworCisJcmMgPSBlZGFjX2RldmljZV9hZGRf ZGV2aWNlKGVkZXZfY3RsKTsKKwlpZiAocmMpCisJCWdvdG8gb3V0X21lbTsKKworCXBsYXRmb3Jt X3NldF9kcnZkYXRhKHBkZXYsIGVkZXZfY3RsKTsKKworCS8qIFJlcXVlc3QgZm9yIGVjYyBpcnEg Ki8KKwllY2NfaXJxID0gbGxjY19kcml2X2RhdGEtPmVjY19pcnE7CisJaWYgKGVjY19pcnEgPCAw KSB7CisJCXJjID0gLUVOT0RFVjsKKwkJZ290byBvdXRfZGV2OworCX0KKwlyYyA9IGRldm1fcmVx dWVzdF9pcnEoZGV2LCBlY2NfaXJxLCBsbGNjX2VjY19pcnFfaGFuZGxlciwKKwkJCSAgICAgIElS UUZfVFJJR0dFUl9ISUdILCAibGxjY19lY2MiLCBlZGV2X2N0bCk7CisJaWYgKHJjKQorCQlnb3Rv IG91dF9kZXY7CisKKwlyZXR1cm4gcmM7CisKK291dF9kZXY6CisJZWRhY19kZXZpY2VfZGVsX2Rl dmljZShlZGV2X2N0bC0+ZGV2KTsKK291dF9tZW06CisJZWRhY19kZXZpY2VfZnJlZV9jdGxfaW5m byhlZGV2X2N0bCk7CisKKwlyZXR1cm4gcmM7Cit9CisKK3N0YXRpYyBpbnQgcWNvbV9sbGNjX2Vk YWNfcmVtb3ZlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCit7CisJc3RydWN0IGVkYWNf ZGV2aWNlX2N0bF9pbmZvICplZGV2X2N0bCA9IGRldl9nZXRfZHJ2ZGF0YSgmcGRldi0+ZGV2KTsK KworCWVkYWNfZGV2aWNlX2RlbF9kZXZpY2UoZWRldl9jdGwtPmRldik7CisJZWRhY19kZXZpY2Vf ZnJlZV9jdGxfaW5mbyhlZGV2X2N0bCk7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGNvbnN0 IHN0cnVjdCBvZl9kZXZpY2VfaWQgcWNvbV9sbGNjX2VkYWNfbWF0Y2hfdGFibGVbXSA9IHsKKwl7 IC5jb21wYXRpYmxlID0gInFjb20sbGxjYy1lZGFjIiB9LAorCXsgfSwKK307CisKK3N0YXRpYyBz dHJ1Y3QgcGxhdGZvcm1fZHJpdmVyIHFjb21fbGxjY19lZGFjX2RyaXZlciA9IHsKKwkucHJvYmUg PSBxY29tX2xsY2NfZWRhY19wcm9iZSwKKwkucmVtb3ZlID0gcWNvbV9sbGNjX2VkYWNfcmVtb3Zl LAorCS5kcml2ZXIgPSB7CisJCS5uYW1lID0gInFjb21fbGxjY19lZGFjIiwKKwkJLm9mX21hdGNo X3RhYmxlID0gcWNvbV9sbGNjX2VkYWNfbWF0Y2hfdGFibGUsCisJfSwKK307Cittb2R1bGVfcGxh dGZvcm1fZHJpdmVyKHFjb21fbGxjY19lZGFjX2RyaXZlcik7CisKK01PRFVMRV9ERVNDUklQVElP TigiUUNPTSBFREFDIGRyaXZlciIpOworTU9EVUxFX0xJQ0VOU0UoIkdQTCB2MiIpOwpkaWZmIC0t Z2l0IGEvaW5jbHVkZS9saW51eC9zb2MvcWNvbS9sbGNjLXFjb20uaCBiL2luY2x1ZGUvbGludXgv c29jL3Fjb20vbGxjYy1xY29tLmgKaW5kZXggMmU0YjM0ZC4uNjljMjg1YiAxMDA2NDQKLS0tIGEv aW5jbHVkZS9saW51eC9zb2MvcWNvbS9sbGNjLXFjb20uaAorKysgYi9pbmNsdWRlL2xpbnV4L3Nv Yy9xY29tL2xsY2MtcWNvbS5oCkBAIC05Myw2ICs5MywzMCBAQCBzdHJ1Y3QgbGxjY19kcnZfZGF0 YSB7CiAJaW50IGVjY19pcnE7CiB9OwogCisvKioKKyAqIGxsY2NfZWRhY19yZWdfZGF0YSAtIGxs Y2MgZWRhYyByZWdpc3RlcnMgZGF0YSBmb3IgZWFjaCBlcnJvciB0eXBlCisgKiBAbmFtZTogTmFt ZSBvZiB0aGUgZXJyb3IKKyAqIEBzeW5kX3JlZzogU3luZHJvbWUgcmVnaXN0ZXIgYWRkcmVzcwor ICogQGNvdW50X3N0YXR1c19yZWc6IFN0YXR1cyByZWdpc3RlciBhZGRyZXNzIHRvIHJlYWQgdGhl IGVycm9yIGNvdW50CisgKiBAd2F5c19zdGF0dXNfcmVnOiBTdGF0dXMgcmVnaXN0ZXIgYWRkcmVz cyB0byByZWFkIHRoZSBlcnJvciB3YXlzCisgKiBAcmVnX2NudDogTnVtYmVyIG9mIHJlZ2lzdGVy cworICogQGNvdW50X21hc2s6IE1hc2sgdmFsdWUgdG8gZ2V0IHRoZSBlcnJvciBjb3VudAorICog QHdheXNfbWFzazogTWFzayB2YWx1ZSB0byBnZXQgdGhlIGVycm9yIHdheXMKKyAqIEBjb3VudF9z aGlmdDogU2hpZnQgdmFsdWUgdG8gZ2V0IHRoZSBlcnJvciBjb3VudAorICogQHdheXNfc2hpZnQ6 IFNoaWZ0IHZhbHVlIHRvIGdldCB0aGUgZXJyb3Igd2F5cworICovCitzdHJ1Y3QgbGxjY19lZGFj X3JlZ19kYXRhIHsKKwljaGFyICpuYW1lOworCXU2NCBzeW5kX3JlZzsKKwl1NjQgY291bnRfc3Rh dHVzX3JlZzsKKwl1NjQgd2F5c19zdGF0dXNfcmVnOworCXUzMiByZWdfY250OworCXUzMiBjb3Vu dF9tYXNrOworCXUzMiB3YXlzX21hc2s7CisJdTggIGNvdW50X3NoaWZ0OworCXU4ICB3YXlzX3No aWZ0OworfTsKKwogI2lmIElTX0VOQUJMRUQoQ09ORklHX1FDT01fTExDQykKIC8qKgogICogbGxj Y19zbGljZV9nZXRkIC0gZ2V0IGxsY2Mgc2xpY2UgZGVzY3JpcHRvcgo=