From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id E3FD8C43334 for ; Thu, 9 Jun 2022 10:24:33 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S234156AbiFIKYc (ORCPT ); Thu, 9 Jun 2022 06:24:32 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:38482 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232988AbiFIKYb (ORCPT ); Thu, 9 Jun 2022 06:24:31 -0400 Received: from mail-ej1-x629.google.com (mail-ej1-x629.google.com [IPv6:2a00:1450:4864:20::629]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 05D4B4B84C; Thu, 9 Jun 2022 03:24:29 -0700 (PDT) Received: by mail-ej1-x629.google.com with SMTP id m20so46460703ejj.10; Thu, 09 Jun 2022 03:24:28 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=message-id:date:from:to:cc:subject:references:mime-version :content-disposition:content-transfer-encoding:in-reply-to; bh=AHXRznNMpT1hcD9zigcRN0b5yLbWWRhNFM/wcISeAfc=; b=jgA9ZNWQMZGD4nEXn5XfUZF9ebuu94ebRP+l0xXpH8nQ0qyJCNHGACZsOJnXLZCOUg esYd7wm8pNUd9w2oc6LiOlr1RfC0iYIpJ0TY9+fGFoLLzEeFbEc45jPGawL+iO01EGpy D+O6OnkHO8dg6wZkMWg8rpT1IxsBgOLVdo7mY7Q8TMfNdrQrr6/YJCdNU3L7aXpgyrmL qVQTLivv/TfZ9qlMXRsAEAc/DKrX/5fUshVvYuHQ8+Spo5PdPljRH9YM6H1slH+Yyy27 /GrvHQmn8pp/MoQRPLuH1F7+dIxKEzTuOrk8YprD3+ZBRhmhJcCPV0pTyJNdR0fWMgzY Yd/w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:message-id:date:from:to:cc:subject:references :mime-version:content-disposition:content-transfer-encoding :in-reply-to; bh=AHXRznNMpT1hcD9zigcRN0b5yLbWWRhNFM/wcISeAfc=; b=XgH7jhwvvIrZ9SmLqEB05OpIPvUThKPJOrPZHWli6KBo8z4/UyXvs6L3OZpL9dr2Cu 4cLfQNxgzvPtATYaW4GQfexbG6c1K1JffC8GiPXdb5PI4ayvM17qIhEgeoOcOhNG/+JW BlRu3OCwj5M5WNGKmp4oUqUdo3mf6fBQZ1xojbrISXj+0RIuOlLo7P3/HxyEylohI4pN K1+LG0VRf+AM4WqJcE+dfRTVmCV/KCAApQ6hiQdDpoOZYJ/VmmnV45fHM0UXG1glRqmm gm4JcyQjNwYo1wJ1XEtPKPmZ4CCJGnDtLLg0U7nxGmW4soeCFsPUoXiQgm+ja3PF0PmE fg/A== X-Gm-Message-State: AOAM533myXV9kkaZOdFdBoGgiM14bO3qooKk0aaaLMjz+4hLaTCrxg8H ZS4zGLMrdMbnBc3yYhFSM3g= X-Google-Smtp-Source: ABdhPJz0Ce61R94Dt8Fks4jL1576/U3TAGD94V2FwP7+5QIFRnNyBU5YZjRVDFuacf/jBmxtXQNXvQ== X-Received: by 2002:a17:906:b048:b0:6fe:be4a:3ecf with SMTP id bj8-20020a170906b04800b006febe4a3ecfmr35598657ejb.104.1654770267147; Thu, 09 Jun 2022 03:24:27 -0700 (PDT) Received: from Ansuel-xps. (93-42-70-190.ip85.fastwebnet.it. [93.42.70.190]) by smtp.gmail.com with ESMTPSA id u15-20020a05640207cf00b0042dd60352d1sm14151130edy.35.2022.06.09.03.24.25 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 09 Jun 2022 03:24:26 -0700 (PDT) Message-ID: <62a1ca5a.1c69fb81.d403.b325@mx.google.com> X-Google-Original-Message-ID: Date: Thu, 9 Jun 2022 12:24:22 +0200 From: Ansuel Smith To: Manivannan Sadhasivam Cc: Andy Gross , Bjorn Andersson , Miquel Raynal , Richard Weinberger , Vignesh Raghavendra , Rob Herring , Krzysztof Kozlowski , linux-mtd@lists.infradead.org, linux-arm-msm@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org Subject: Re: [PATCH v5 1/3] mtd: nand: raw: qcom_nandc: add support for unprotected spare data pages References: <20220608001030.18813-1-ansuelsmth@gmail.com> <20220608001030.18813-2-ansuelsmth@gmail.com> <20220609075254.GC2758@thinkpad> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <20220609075254.GC2758@thinkpad> Precedence: bulk List-ID: X-Mailing-List: linux-arm-msm@vger.kernel.org On Thu, Jun 09, 2022 at 01:22:54PM +0530, Manivannan Sadhasivam wrote: > On Wed, Jun 08, 2022 at 02:10:28AM +0200, Ansuel Smith wrote: > > IPQ8064 nand have special pages where a different layout scheme is used. > > These special page are used by boot partition and on reading them > > lots of warning are reported about wrong ECC data and if written to > > results in broken data and not bootable device. > > > > The layout scheme used by these special page consist in using 512 bytes > > as the codeword size (even for the last codeword) while writing to CFG0 > > register. This forces the NAND controller to unprotect the 4 bytes of > > spare data. > > > > Since the kernel is unaware of this different layout for these special > > page, it does try to protect the spare data too during read/write and > > warn about CRC errors. > > > > Add support for this by permitting the user to declare these special > > pages in dts by declaring offset and size of the partition. The driver > > internally will convert these value to nand pages. > > > > On user read/write the page is checked and if it's a boot page the > > correct layout is used. > > > > Signed-off-by: Ansuel Smith > > --- > > drivers/mtd/nand/raw/qcom_nandc.c | 174 +++++++++++++++++++++++++++++- > > 1 file changed, 169 insertions(+), 5 deletions(-) > > > > diff --git a/drivers/mtd/nand/raw/qcom_nandc.c b/drivers/mtd/nand/raw/qcom_nandc.c > > index 1a77542c6d67..06ee9a836a3b 100644 > > --- a/drivers/mtd/nand/raw/qcom_nandc.c > > +++ b/drivers/mtd/nand/raw/qcom_nandc.c > > @@ -80,8 +80,10 @@ > > #define DISABLE_STATUS_AFTER_WRITE 4 > > #define CW_PER_PAGE 6 > > #define UD_SIZE_BYTES 9 > > +#define UD_SIZE_BYTES_MASK GENMASK(18, 9) > > #define ECC_PARITY_SIZE_BYTES_RS 19 > > #define SPARE_SIZE_BYTES 23 > > +#define SPARE_SIZE_BYTES_MASK GENMASK(26, 23) > > #define NUM_ADDR_CYCLES 27 > > #define STATUS_BFR_READ 30 > > #define SET_RD_MODE_AFTER_STATUS 31 > > @@ -102,6 +104,7 @@ > > #define ECC_MODE 4 > > #define ECC_PARITY_SIZE_BYTES_BCH 8 > > #define ECC_NUM_DATA_BYTES 16 > > +#define ECC_NUM_DATA_BYTES_MASK GENMASK(25, 16) > > #define ECC_FORCE_CLK_OPEN 30 > > > > /* NAND_DEV_CMD1 bits */ > > @@ -418,6 +421,19 @@ struct qcom_nand_controller { > > const struct qcom_nandc_props *props; > > }; > > > > +/* > > + * NAND special boot partitions > > + * > > + * @page_offset: offset of the partition where spare data is not protected > > + * by ECC (value in pages) > > s/page_offset/offset > Mhhh i changed this to page_offset since the struct is called boot_partition and it can be confusing since internally the values is in pages. Someone can think that the real partition offset/size is used instead of the value converted in pages. > > + * @page_offset: size of the partition where spare data is not protected > > + * by ECC (value in pages) > > s/page_offset/size > > > + */ > > +struct qcom_nand_boot_partition { > > + u32 page_offset; > > + u32 page_size; > > same here > > > +}; > > + > > /* > > * NAND chip structure > > * > > @@ -444,6 +460,13 @@ struct qcom_nand_controller { > > * @cfg0, cfg1, cfg0_raw..: NANDc register configurations needed for > > * ecc/non-ecc mode for the current nand flash > > * device > > + * > > + * @codeword_fixup: keep track of the current layout used by > > + * the driver for read/write operation. > > + * @nr_boot_partitions: count of the boot partitions where spare data is not > > + * protected by ECC > > Align the Kdoc comments w.r.t other members. > > > + * @boot_pages: array of boot partitions where offset and size of the > > + * boot partitions are stored > > s/boot_pages/boot_partitions > Sorry. > > */ > > struct qcom_nand_host { > > struct nand_chip chip; > > @@ -466,6 +489,10 @@ struct qcom_nand_host { > > u32 ecc_bch_cfg; > > u32 clrflashstatus; > > u32 clrreadstatus; > > + > > + bool codeword_fixup; > > + int nr_boot_partitions; > > + struct qcom_nand_boot_partition *boot_partitions; > > }; > > > > /* > > @@ -475,6 +502,7 @@ struct qcom_nand_host { > > * @is_bam - whether NAND controller is using BAM > > * @is_qpic - whether NAND CTRL is part of qpic IP > > * @qpic_v2 - flag to indicate QPIC IP version 2 > > + * @use_codeword_fixup - whether NAND has different layout for boot partitions > > * @dev_cmd_reg_start - NAND_DEV_CMD_* registers starting offset > > */ > > struct qcom_nandc_props { > > @@ -482,6 +510,7 @@ struct qcom_nandc_props { > > bool is_bam; > > bool is_qpic; > > bool qpic_v2; > > + bool use_codeword_fixup; > > u32 dev_cmd_reg_start; > > }; > > > > @@ -1701,7 +1730,7 @@ qcom_nandc_read_cw_raw(struct mtd_info *mtd, struct nand_chip *chip, > > data_size1 = mtd->writesize - host->cw_size * (ecc->steps - 1); > > oob_size1 = host->bbm_size; > > > > - if (qcom_nandc_is_last_cw(ecc, cw)) { > > + if (qcom_nandc_is_last_cw(ecc, cw) && !host->codeword_fixup) { > > data_size2 = ecc->size - data_size1 - > > ((ecc->steps - 1) * 4); > > oob_size2 = (ecc->steps * 4) + host->ecc_bytes_hw + > > @@ -1782,7 +1811,7 @@ check_for_erased_page(struct qcom_nand_host *host, u8 *data_buf, > > } > > > > for_each_set_bit(cw, &uncorrectable_cws, ecc->steps) { > > - if (qcom_nandc_is_last_cw(ecc, cw)) { > > + if (qcom_nandc_is_last_cw(ecc, cw) && !host->codeword_fixup) { > > data_size = ecc->size - ((ecc->steps - 1) * 4); > > oob_size = (ecc->steps * 4) + host->ecc_bytes_hw; > > } else { > > @@ -1940,7 +1969,7 @@ static int read_page_ecc(struct qcom_nand_host *host, u8 *data_buf, > > for (i = 0; i < ecc->steps; i++) { > > int data_size, oob_size; > > > > - if (qcom_nandc_is_last_cw(ecc, i)) { > > + if (qcom_nandc_is_last_cw(ecc, i) && !host->codeword_fixup) { > > data_size = ecc->size - ((ecc->steps - 1) << 2); > > oob_size = (ecc->steps << 2) + host->ecc_bytes_hw + > > host->spare_bytes; > > @@ -2037,6 +2066,55 @@ static int copy_last_cw(struct qcom_nand_host *host, int page) > > return ret; > > } > > > > +static bool > > +qcom_nandc_is_boot_page(struct qcom_nand_host *host, int page) > > Move function name to previous line. If it exceeds 100 lines then wrap > arguments. > > s/qcom_nandc_is_boot_page/qcom_nandc_is_boot_partition > Again considering the check is done on the page and not on the partition, wonder what is correct. > > +{ > > + struct qcom_nand_boot_partition *boot_partition; > > + u32 start, end; > > + int i; > > + > > + for (i = 0; i < host->nr_boot_partitions; i++) { > > + boot_partition = &host->boot_partitions[i]; > > + start = boot_partition->page_offset; > > + end = start + boot_partition->page_size; > > + > > + /* Boot pages are normally at the start of > > Block comments should start with: > > /* > * ... > > Also, are you sure that only few pages in the partitions have different layout > and not all pages? If not, then this comment needs to be reworded. > I probably worderd this bad... Each page of the boot partitions require the codeword fix. But other may have the normal codeword For example this is from a Netgear router: mtd0: 00c80000 00020000 "qcadata" (require codeword fix) mtd1: 00500000 00020000 "APPSBL" (require codeword fix) mtd2: 00080000 00020000 "APPSBLENV" (doesn't require codeword fix) mtd3: 00140000 00020000 "art" (doesn't) mtd4: 00140000 00020000 "artbak" (doesn't) mtd5: 00400000 00020000 "kernel" (doesn't) mtd6: 06080000 00020000 "ubi" (doesn't) mtd7: 00700000 00020000 "reserve" (doesn't) This is part of the case tho as there are some partition table with something like mtd0: 00c80000 00020000 "qcadata" (require codeword fix) mtd1: 00500000 00020000 "APPSBL" (require codeword fix) mtd2: 00080000 00020000 "APPSBLENV" (doesn't require codeword fix) mtd3: 00140000 00020000 "APPSBL2" (require codeword fix) [...] In all case 99% of the time in a normal system what you commonly write are the rootfs partition that are AFTER the boot partition so checking if the page is after such partition should speed up the check. Now that I think about it, a good idea is also start checking the boot_partition table from the end to improve the checking even more. So tell me if the comments is wronlgy worded. > > + * the nand in various partition. > > + * Check the page from the boot page end first > > + * to save one extra check and optimize this > > + * in case real no-boot partition are used. > > + */ > > + if (page < end && page >= start) > > + return true; > > + } > > + > > + return false; > > +} > > + > > +static void > > +qcom_nandc_codeword_fixup(struct qcom_nand_host *host, int page) > > +{ > > + bool codeword_fixup = qcom_nandc_is_boot_page(host, page); > > + > > + /* Skip conf write if we are already in the correct mode */ > > + if (codeword_fixup == host->codeword_fixup) > > + return; > > + > > + host->codeword_fixup = codeword_fixup; > > + > > + host->cw_data = codeword_fixup ? 512 : 516; > > + host->spare_bytes = host->cw_size - host->ecc_bytes_hw - > > + host->bbm_size - host->cw_data; > > + > > + host->cfg0 &= ~(SPARE_SIZE_BYTES_MASK | UD_SIZE_BYTES_MASK); > > + host->cfg0 |= host->spare_bytes << SPARE_SIZE_BYTES | > > + host->cw_data << UD_SIZE_BYTES; > > + > > + host->ecc_bch_cfg &= ~ECC_NUM_DATA_BYTES_MASK; > > + host->ecc_bch_cfg |= host->cw_data << ECC_NUM_DATA_BYTES; > > + host->ecc_buf_cfg = (codeword_fixup ? 0x1ff : 0x203) << NUM_STEPS; > > s/1ff/(512 - 1) > s/203/(516 - 1) > ok. I wonder if this can just be reduced to (host->cw_data - 1) and skipping the check entirely. > > +} > > + > > /* implements ecc->read_page() */ > > static int qcom_nandc_read_page(struct nand_chip *chip, uint8_t *buf, > > int oob_required, int page) > > @@ -2045,6 +2123,9 @@ static int qcom_nandc_read_page(struct nand_chip *chip, uint8_t *buf, > > struct qcom_nand_controller *nandc = get_qcom_nand_controller(chip); > > u8 *data_buf, *oob_buf = NULL; > > > > + if (host->nr_boot_partitions) > > + qcom_nandc_codeword_fixup(host, page); > > + > > nand_read_page_op(chip, page, 0, NULL, 0); > > data_buf = buf; > > oob_buf = oob_required ? chip->oob_poi : NULL; > > @@ -2064,6 +2145,9 @@ static int qcom_nandc_read_page_raw(struct nand_chip *chip, uint8_t *buf, > > int cw, ret; > > u8 *data_buf = buf, *oob_buf = chip->oob_poi; > > > > + if (host->nr_boot_partitions) > > + qcom_nandc_codeword_fixup(host, page); > > + > > for (cw = 0; cw < ecc->steps; cw++) { > > ret = qcom_nandc_read_cw_raw(mtd, chip, data_buf, oob_buf, > > page, cw); > > @@ -2084,6 +2168,9 @@ static int qcom_nandc_read_oob(struct nand_chip *chip, int page) > > struct qcom_nand_controller *nandc = get_qcom_nand_controller(chip); > > struct nand_ecc_ctrl *ecc = &chip->ecc; > > > > + if (host->nr_boot_partitions) > > + qcom_nandc_codeword_fixup(host, page); > > + > > clear_read_regs(nandc); > > clear_bam_transaction(nandc); > > > > @@ -2104,6 +2191,9 @@ static int qcom_nandc_write_page(struct nand_chip *chip, const uint8_t *buf, > > u8 *data_buf, *oob_buf; > > int i, ret; > > > > + if (host->nr_boot_partitions) > > + qcom_nandc_codeword_fixup(host, page); > > + > > nand_prog_page_begin_op(chip, page, 0, NULL, 0); > > > > clear_read_regs(nandc); > > @@ -2119,7 +2209,7 @@ static int qcom_nandc_write_page(struct nand_chip *chip, const uint8_t *buf, > > for (i = 0; i < ecc->steps; i++) { > > int data_size, oob_size; > > > > - if (qcom_nandc_is_last_cw(ecc, i)) { > > + if (qcom_nandc_is_last_cw(ecc, i) && !host->codeword_fixup) { > > data_size = ecc->size - ((ecc->steps - 1) << 2); > > oob_size = (ecc->steps << 2) + host->ecc_bytes_hw + > > host->spare_bytes; > > @@ -2176,6 +2266,9 @@ static int qcom_nandc_write_page_raw(struct nand_chip *chip, > > u8 *data_buf, *oob_buf; > > int i, ret; > > > > + if (host->nr_boot_partitions) > > + qcom_nandc_codeword_fixup(host, page); > > + > > nand_prog_page_begin_op(chip, page, 0, NULL, 0); > > clear_read_regs(nandc); > > clear_bam_transaction(nandc); > > @@ -2194,7 +2287,7 @@ static int qcom_nandc_write_page_raw(struct nand_chip *chip, > > data_size1 = mtd->writesize - host->cw_size * (ecc->steps - 1); > > oob_size1 = host->bbm_size; > > > > - if (qcom_nandc_is_last_cw(ecc, i)) { > > + if (qcom_nandc_is_last_cw(ecc, i) && !host->codeword_fixup) { > > data_size2 = ecc->size - data_size1 - > > ((ecc->steps - 1) << 2); > > oob_size2 = (ecc->steps << 2) + host->ecc_bytes_hw + > > @@ -2254,6 +2347,9 @@ static int qcom_nandc_write_oob(struct nand_chip *chip, int page) > > int data_size, oob_size; > > int ret; > > > > + if (host->nr_boot_partitions) > > + qcom_nandc_codeword_fixup(host, page); > > + > > host->use_ecc = true; > > clear_bam_transaction(nandc); > > > > @@ -2902,6 +2998,71 @@ static int qcom_nandc_setup(struct qcom_nand_controller *nandc) > > > > static const char * const probes[] = { "cmdlinepart", "ofpart", "qcomsmem", NULL }; > > > > +static int qcom_nand_host_parse_boot_partitions(struct qcom_nand_controller *nandc, > > + struct qcom_nand_host *host, > > + struct device_node *dn) > > +{ > > + struct nand_chip *chip = &host->chip; > > + struct mtd_info *mtd = nand_to_mtd(chip); > > + struct qcom_nand_boot_partition *boot_partition; > > + struct device *dev = nandc->dev; > > + int partitions_count, i, j, ret; > > + > > + if (!nandc->props->use_codeword_fixup) > > + return 0; > > Move this check to caller as I suggested previously. > Sorry I missed that. > > + > > + if (!of_find_property(dn, "qcom,boot-partitions", NULL)) > > + return 0; > > + > > + partitions_count = of_property_count_u32_elems(dn, "qcom,boot-partitions"); > > + if (partitions_count < 0) { > > partitions_count <= 0 > > > + dev_err(dev, "Error parsing boot partition."); > > Add newline at the end of error message > > > + return ret; > > + } > > + > > + host->nr_boot_partitions = partitions_count / 2; > > + host->boot_partitions = devm_kcalloc(dev, host->nr_boot_partitions, > > + sizeof(*host->boot_partitions), GFP_KERNEL); > > + if (!host->boot_partitions) > > host->nr_boot_partitions = 0; > > > + return -ENOMEM; > > + > > + for (i = 0, j = 0; i < host->nr_boot_partitions; i++, j += 2) { > > + boot_partition = &host->boot_partitions[i]; > > + > > + ret = of_property_read_u32_index(dn, "qcom,boot-partitions", j, > > + &boot_partition->page_offset); > > + if (ret) { > > + dev_err(dev, "Error parsing boot partition offset at index %d", i); > > Add newline at the end of error message. Do the same for all error prints. > > > + return ret; > > + } > > + > > + if (boot_partition->page_offset % mtd->writesize) { > > + dev_err(dev, "Boot partition offset not multiple of writesize at index %i", > > + i); > > + return -EINVAL; > > + } > > + /* Convert offset to nand pages */ > > s/pages/partitions > > > + boot_partition->page_offset /= mtd->writesize; > > s/page_offset/offset > > > + > > + ret = of_property_read_u32_index(dn, "qcom,boot-partitions", j + 1, > > + &boot_partition->page_size); > > + if (ret) { > > + dev_err(dev, "Error parsing boot partition size at index %d", i); > > + return ret; > > + } > > + > > + if (boot_partition->page_size % mtd->writesize) { > > s/page_size/size here and below > > > + dev_err(dev, "Boot partition size not multiple of writesize at index %i", > > + i); > > + return -EINVAL; > > + } > > + /* Convert size to nand pages */ > > s/pages/partitions > > Thanks, > Mani > > > + boot_partition->page_size /= mtd->writesize; > > + } > > + > > + return 0; > > +} > > + > > static int qcom_nand_host_init_and_register(struct qcom_nand_controller *nandc, > > struct qcom_nand_host *host, > > struct device_node *dn) > > @@ -2970,6 +3131,8 @@ static int qcom_nand_host_init_and_register(struct qcom_nand_controller *nandc, > > if (ret) > > nand_cleanup(chip); > > > > + qcom_nand_host_parse_boot_partitions(nandc, host, dn); > > + > > return ret; > > } > > > > @@ -3135,6 +3298,7 @@ static int qcom_nandc_remove(struct platform_device *pdev) > > static const struct qcom_nandc_props ipq806x_nandc_props = { > > .ecc_modes = (ECC_RS_4BIT | ECC_BCH_8BIT), > > .is_bam = false, > > + .use_codeword_fixup = true, > > .dev_cmd_reg_start = 0x0, > > }; > > > > -- > > 2.36.1 > > > > -- > மணிவண்ணன் சதாசிவம் -- Ansuel From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 08F8DC433EF for ; Thu, 9 Jun 2022 10:25:05 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:In-Reply-To:MIME-Version:References: Subject:Cc:To:From:Date:Message-ID:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=vaVL/9iaf2x2QSWViYl6XVp0cILLae/yvdWXuklH0xA=; b=z7MJwiRIe6a6mO Z5xU+/qPOZkNiaeteF1FzQHPRrq7oLOczg5P364yyfCPZWc2o5vEVxO3cjIQ5QaJDMRF+oTCUAaBh Cc9Mskfz4+lJejMKJ+itItIr6FdYUcK1dv+2gnyL1leFwgBw1U+hI+gGOcAu67mqldZ/JNVoy/vwe gJ1BJVy5vwsCabjnyMgn2sd5N87ET+X05sRRIl3F4k2FFeLG9l4YntY62EcmzUP9hZ8bNiFM8BIcF FG2bdk8mY90jz1EEYbb38+ZWueY2wsZWRhErpVzZVhNBE2+Xv71liCFikjbMknJ3LUkeorVO9UMyw Zm1PIPkI6zZf7am+yZKA==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1nzFL9-000xvB-0v; Thu, 09 Jun 2022 10:24:35 +0000 Received: from mail-ej1-x634.google.com ([2a00:1450:4864:20::634]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1nzFL5-000xtp-7V for linux-mtd@lists.infradead.org; Thu, 09 Jun 2022 10:24:33 +0000 Received: by mail-ej1-x634.google.com with SMTP id u12so46549038eja.8 for ; Thu, 09 Jun 2022 03:24:28 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=message-id:date:from:to:cc:subject:references:mime-version :content-disposition:content-transfer-encoding:in-reply-to; bh=AHXRznNMpT1hcD9zigcRN0b5yLbWWRhNFM/wcISeAfc=; b=jgA9ZNWQMZGD4nEXn5XfUZF9ebuu94ebRP+l0xXpH8nQ0qyJCNHGACZsOJnXLZCOUg esYd7wm8pNUd9w2oc6LiOlr1RfC0iYIpJ0TY9+fGFoLLzEeFbEc45jPGawL+iO01EGpy D+O6OnkHO8dg6wZkMWg8rpT1IxsBgOLVdo7mY7Q8TMfNdrQrr6/YJCdNU3L7aXpgyrmL qVQTLivv/TfZ9qlMXRsAEAc/DKrX/5fUshVvYuHQ8+Spo5PdPljRH9YM6H1slH+Yyy27 /GrvHQmn8pp/MoQRPLuH1F7+dIxKEzTuOrk8YprD3+ZBRhmhJcCPV0pTyJNdR0fWMgzY Yd/w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:message-id:date:from:to:cc:subject:references :mime-version:content-disposition:content-transfer-encoding :in-reply-to; bh=AHXRznNMpT1hcD9zigcRN0b5yLbWWRhNFM/wcISeAfc=; b=HpngumYb+jozTNPZwk1YEvDsD3Z0+6euof2eTzXd/6/UoqmoC+NJBTLGxYmo50E4ke Lt9XluwEGYolYo6WioHHJPH2h/vi58DkAp8X48occVAl0zuDFCz6bXUK1+EnNRUX9/xK HuIc8jrKVxckrMDg0cObNGyq46qJhC88UvWQQ3RJ+bpnU2kTRm24+aVSOpWHzrP3kvXA LfT8+smOMndH76XAeO8mBfX+WuImtHDiTsY3SlFGxp4Qt6gs5rsQxXvssE+zu0uvdeVZ 89cJgtsDt4eCg6QX4oeAypKJilRD1Fsf3Xy5hMi8yAW1bNFhjEVcrIo9XJaKcYmK56k1 7hlQ== X-Gm-Message-State: AOAM533pejUwgSqZUyk+YGL9eVwNZcU7eTKdrAtGAkCjf3CLyFD6I3ab piC0SpODkQZbFgWLy9H1cKw= X-Google-Smtp-Source: ABdhPJz0Ce61R94Dt8Fks4jL1576/U3TAGD94V2FwP7+5QIFRnNyBU5YZjRVDFuacf/jBmxtXQNXvQ== X-Received: by 2002:a17:906:b048:b0:6fe:be4a:3ecf with SMTP id bj8-20020a170906b04800b006febe4a3ecfmr35598657ejb.104.1654770267147; Thu, 09 Jun 2022 03:24:27 -0700 (PDT) Received: from Ansuel-xps. (93-42-70-190.ip85.fastwebnet.it. [93.42.70.190]) by smtp.gmail.com with ESMTPSA id u15-20020a05640207cf00b0042dd60352d1sm14151130edy.35.2022.06.09.03.24.25 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 09 Jun 2022 03:24:26 -0700 (PDT) Message-ID: <62a1ca5a.1c69fb81.d403.b325@mx.google.com> X-Google-Original-Message-ID: Date: Thu, 9 Jun 2022 12:24:22 +0200 From: Ansuel Smith To: Manivannan Sadhasivam Cc: Andy Gross , Bjorn Andersson , Miquel Raynal , Richard Weinberger , Vignesh Raghavendra , Rob Herring , Krzysztof Kozlowski , linux-mtd@lists.infradead.org, linux-arm-msm@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org Subject: Re: [PATCH v5 1/3] mtd: nand: raw: qcom_nandc: add support for unprotected spare data pages References: <20220608001030.18813-1-ansuelsmth@gmail.com> <20220608001030.18813-2-ansuelsmth@gmail.com> <20220609075254.GC2758@thinkpad> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: <20220609075254.GC2758@thinkpad> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20220609_032431_323959_284C863B X-CRM114-Status: GOOD ( 59.35 ) X-BeenThere: linux-mtd@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: Linux MTD discussion mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-mtd" Errors-To: linux-mtd-bounces+linux-mtd=archiver.kernel.org@lists.infradead.org T24gVGh1LCBKdW4gMDksIDIwMjIgYXQgMDE6MjI6NTRQTSArMDUzMCwgTWFuaXZhbm5hbiBTYWRo YXNpdmFtIHdyb3RlOgo+IE9uIFdlZCwgSnVuIDA4LCAyMDIyIGF0IDAyOjEwOjI4QU0gKzAyMDAs IEFuc3VlbCBTbWl0aCB3cm90ZToKPiA+IElQUTgwNjQgbmFuZCBoYXZlIHNwZWNpYWwgcGFnZXMg d2hlcmUgYSBkaWZmZXJlbnQgbGF5b3V0IHNjaGVtZSBpcyB1c2VkLgo+ID4gVGhlc2Ugc3BlY2lh bCBwYWdlIGFyZSB1c2VkIGJ5IGJvb3QgcGFydGl0aW9uIGFuZCBvbiByZWFkaW5nIHRoZW0KPiA+ IGxvdHMgb2Ygd2FybmluZyBhcmUgcmVwb3J0ZWQgYWJvdXQgd3JvbmcgRUNDIGRhdGEgYW5kIGlm IHdyaXR0ZW4gdG8KPiA+IHJlc3VsdHMgaW4gYnJva2VuIGRhdGEgYW5kIG5vdCBib290YWJsZSBk ZXZpY2UuCj4gPiAKPiA+IFRoZSBsYXlvdXQgc2NoZW1lIHVzZWQgYnkgdGhlc2Ugc3BlY2lhbCBw YWdlIGNvbnNpc3QgaW4gdXNpbmcgNTEyIGJ5dGVzCj4gPiBhcyB0aGUgY29kZXdvcmQgc2l6ZSAo ZXZlbiBmb3IgdGhlIGxhc3QgY29kZXdvcmQpIHdoaWxlIHdyaXRpbmcgdG8gQ0ZHMAo+ID4gcmVn aXN0ZXIuIFRoaXMgZm9yY2VzIHRoZSBOQU5EIGNvbnRyb2xsZXIgdG8gdW5wcm90ZWN0IHRoZSA0 IGJ5dGVzIG9mCj4gPiBzcGFyZSBkYXRhLgo+ID4gCj4gPiBTaW5jZSB0aGUga2VybmVsIGlzIHVu YXdhcmUgb2YgdGhpcyBkaWZmZXJlbnQgbGF5b3V0IGZvciB0aGVzZSBzcGVjaWFsCj4gPiBwYWdl LCBpdCBkb2VzIHRyeSB0byBwcm90ZWN0IHRoZSBzcGFyZSBkYXRhIHRvbyBkdXJpbmcgcmVhZC93 cml0ZSBhbmQKPiA+IHdhcm4gYWJvdXQgQ1JDIGVycm9ycy4KPiA+IAo+ID4gQWRkIHN1cHBvcnQg Zm9yIHRoaXMgYnkgcGVybWl0dGluZyB0aGUgdXNlciB0byBkZWNsYXJlIHRoZXNlIHNwZWNpYWwK PiA+IHBhZ2VzIGluIGR0cyBieSBkZWNsYXJpbmcgb2Zmc2V0IGFuZCBzaXplIG9mIHRoZSBwYXJ0 aXRpb24uIFRoZSBkcml2ZXIKPiA+IGludGVybmFsbHkgd2lsbCBjb252ZXJ0IHRoZXNlIHZhbHVl IHRvIG5hbmQgcGFnZXMuCj4gPiAKPiA+IE9uIHVzZXIgcmVhZC93cml0ZSB0aGUgcGFnZSBpcyBj aGVja2VkIGFuZCBpZiBpdCdzIGEgYm9vdCBwYWdlIHRoZQo+ID4gY29ycmVjdCBsYXlvdXQgaXMg dXNlZC4KPiA+IAo+ID4gU2lnbmVkLW9mZi1ieTogQW5zdWVsIFNtaXRoIDxhbnN1ZWxzbXRoQGdt YWlsLmNvbT4KPiA+IC0tLQo+ID4gIGRyaXZlcnMvbXRkL25hbmQvcmF3L3Fjb21fbmFuZGMuYyB8 IDE3NCArKysrKysrKysrKysrKysrKysrKysrKysrKysrKy0KPiA+ICAxIGZpbGUgY2hhbmdlZCwg MTY5IGluc2VydGlvbnMoKyksIDUgZGVsZXRpb25zKC0pCj4gPiAKPiA+IGRpZmYgLS1naXQgYS9k cml2ZXJzL210ZC9uYW5kL3Jhdy9xY29tX25hbmRjLmMgYi9kcml2ZXJzL210ZC9uYW5kL3Jhdy9x Y29tX25hbmRjLmMKPiA+IGluZGV4IDFhNzc1NDJjNmQ2Ny4uMDZlZTlhODM2YTNiIDEwMDY0NAo+ ID4gLS0tIGEvZHJpdmVycy9tdGQvbmFuZC9yYXcvcWNvbV9uYW5kYy5jCj4gPiArKysgYi9kcml2 ZXJzL210ZC9uYW5kL3Jhdy9xY29tX25hbmRjLmMKPiA+IEBAIC04MCw4ICs4MCwxMCBAQAo+ID4g ICNkZWZpbmUJRElTQUJMRV9TVEFUVVNfQUZURVJfV1JJVEUJNAo+ID4gICNkZWZpbmUJQ1dfUEVS X1BBR0UJCQk2Cj4gPiAgI2RlZmluZQlVRF9TSVpFX0JZVEVTCQkJOQo+ID4gKyNkZWZpbmUJVURf U0laRV9CWVRFU19NQVNLCQlHRU5NQVNLKDE4LCA5KQo+ID4gICNkZWZpbmUJRUNDX1BBUklUWV9T SVpFX0JZVEVTX1JTCTE5Cj4gPiAgI2RlZmluZQlTUEFSRV9TSVpFX0JZVEVTCQkyMwo+ID4gKyNk ZWZpbmUJU1BBUkVfU0laRV9CWVRFU19NQVNLCQlHRU5NQVNLKDI2LCAyMykKPiA+ICAjZGVmaW5l CU5VTV9BRERSX0NZQ0xFUwkJCTI3Cj4gPiAgI2RlZmluZQlTVEFUVVNfQkZSX1JFQUQJCQkzMAo+ ID4gICNkZWZpbmUJU0VUX1JEX01PREVfQUZURVJfU1RBVFVTCTMxCj4gPiBAQCAtMTAyLDYgKzEw NCw3IEBACj4gPiAgI2RlZmluZQlFQ0NfTU9ERQkJCTQKPiA+ICAjZGVmaW5lCUVDQ19QQVJJVFlf U0laRV9CWVRFU19CQ0gJOAo+ID4gICNkZWZpbmUJRUNDX05VTV9EQVRBX0JZVEVTCQkxNgo+ID4g KyNkZWZpbmUJRUNDX05VTV9EQVRBX0JZVEVTX01BU0sJCUdFTk1BU0soMjUsIDE2KQo+ID4gICNk ZWZpbmUJRUNDX0ZPUkNFX0NMS19PUEVOCQkzMAo+ID4gIAo+ID4gIC8qIE5BTkRfREVWX0NNRDEg Yml0cyAqLwo+ID4gQEAgLTQxOCw2ICs0MjEsMTkgQEAgc3RydWN0IHFjb21fbmFuZF9jb250cm9s bGVyIHsKPiA+ICAJY29uc3Qgc3RydWN0IHFjb21fbmFuZGNfcHJvcHMgKnByb3BzOwo+ID4gIH07 Cj4gPiAgCj4gPiArLyoKPiA+ICsgKiBOQU5EIHNwZWNpYWwgYm9vdCBwYXJ0aXRpb25zCj4gPiAr ICoKPiA+ICsgKiBAcGFnZV9vZmZzZXQ6CQlvZmZzZXQgb2YgdGhlIHBhcnRpdGlvbiB3aGVyZSBz cGFyZSBkYXRhIGlzIG5vdCBwcm90ZWN0ZWQKPiA+ICsgKgkJCQlieSBFQ0MgKHZhbHVlIGluIHBh Z2VzKQo+IAo+IHMvcGFnZV9vZmZzZXQvb2Zmc2V0Cj4KCk1oaGggaSBjaGFuZ2VkIHRoaXMgdG8g cGFnZV9vZmZzZXQgc2luY2UgdGhlIHN0cnVjdCBpcyBjYWxsZWQKYm9vdF9wYXJ0aXRpb24gYW5k IGl0IGNhbiBiZSBjb25mdXNpbmcgc2luY2UgaW50ZXJuYWxseSB0aGUgdmFsdWVzIGlzIGluCnBh Z2VzLiBTb21lb25lIGNhbiB0aGluayB0aGF0IHRoZSByZWFsIHBhcnRpdGlvbiBvZmZzZXQvc2l6 ZSBpcyB1c2VkCmluc3RlYWQgb2YgdGhlIHZhbHVlIGNvbnZlcnRlZCBpbiBwYWdlcy4KCj4gPiAr ICogQHBhZ2Vfb2Zmc2V0OgkJc2l6ZSBvZiB0aGUgcGFydGl0aW9uIHdoZXJlIHNwYXJlIGRhdGEg aXMgbm90IHByb3RlY3RlZAo+ID4gKyAqCQkJCWJ5IEVDQyAodmFsdWUgaW4gcGFnZXMpCj4gCj4g cy9wYWdlX29mZnNldC9zaXplCj4gCj4gPiArICovCj4gPiArc3RydWN0IHFjb21fbmFuZF9ib290 X3BhcnRpdGlvbiB7Cj4gPiArCXUzMiBwYWdlX29mZnNldDsKPiA+ICsJdTMyIHBhZ2Vfc2l6ZTsK PiAKPiBzYW1lIGhlcmUKPiAKPiA+ICt9Owo+ID4gKwo+ID4gIC8qCj4gPiAgICogTkFORCBjaGlw IHN0cnVjdHVyZQo+ID4gICAqCj4gPiBAQCAtNDQ0LDYgKzQ2MCwxMyBAQCBzdHJ1Y3QgcWNvbV9u YW5kX2NvbnRyb2xsZXIgewo+ID4gICAqIEBjZmcwLCBjZmcxLCBjZmcwX3Jhdy4uOglOQU5EYyBy ZWdpc3RlciBjb25maWd1cmF0aW9ucyBuZWVkZWQgZm9yCj4gPiAgICoJCQkJZWNjL25vbi1lY2Mg bW9kZSBmb3IgdGhlIGN1cnJlbnQgbmFuZCBmbGFzaAo+ID4gICAqCQkJCWRldmljZQo+ID4gKyAq Cj4gPiArICogQGNvZGV3b3JkX2ZpeHVwOgkJa2VlcCB0cmFjayBvZiB0aGUgY3VycmVudCBsYXlv dXQgdXNlZCBieQo+ID4gKyAqCQkJCXRoZSBkcml2ZXIgZm9yIHJlYWQvd3JpdGUgb3BlcmF0aW9u Lgo+ID4gKyAqIEBucl9ib290X3BhcnRpdGlvbnM6CQljb3VudCBvZiB0aGUgYm9vdCBwYXJ0aXRp b25zIHdoZXJlIHNwYXJlIGRhdGEgaXMgbm90Cj4gPiArICoJCQkJcHJvdGVjdGVkIGJ5IEVDQwo+ IAo+IEFsaWduIHRoZSBLZG9jIGNvbW1lbnRzIHcuci50IG90aGVyIG1lbWJlcnMuCj4gCj4gPiAr ICogQGJvb3RfcGFnZXM6CQkJYXJyYXkgb2YgYm9vdCBwYXJ0aXRpb25zIHdoZXJlIG9mZnNldCBh bmQgc2l6ZSBvZiB0aGUKPiA+ICsgKgkJCQlib290IHBhcnRpdGlvbnMgYXJlIHN0b3JlZAo+IAo+ IHMvYm9vdF9wYWdlcy9ib290X3BhcnRpdGlvbnMKPiAKClNvcnJ5LgoKPiA+ICAgKi8KPiA+ICBz dHJ1Y3QgcWNvbV9uYW5kX2hvc3Qgewo+ID4gIAlzdHJ1Y3QgbmFuZF9jaGlwIGNoaXA7Cj4gPiBA QCAtNDY2LDYgKzQ4OSwxMCBAQCBzdHJ1Y3QgcWNvbV9uYW5kX2hvc3Qgewo+ID4gIAl1MzIgZWNj X2JjaF9jZmc7Cj4gPiAgCXUzMiBjbHJmbGFzaHN0YXR1czsKPiA+ICAJdTMyIGNscnJlYWRzdGF0 dXM7Cj4gPiArCj4gPiArCWJvb2wgY29kZXdvcmRfZml4dXA7Cj4gPiArCWludCBucl9ib290X3Bh cnRpdGlvbnM7Cj4gPiArCXN0cnVjdCBxY29tX25hbmRfYm9vdF9wYXJ0aXRpb24gKmJvb3RfcGFy dGl0aW9uczsKPiA+ICB9Owo+ID4gIAo+ID4gIC8qCj4gPiBAQCAtNDc1LDYgKzUwMiw3IEBAIHN0 cnVjdCBxY29tX25hbmRfaG9zdCB7Cj4gPiAgICogQGlzX2JhbSAtIHdoZXRoZXIgTkFORCBjb250 cm9sbGVyIGlzIHVzaW5nIEJBTQo+ID4gICAqIEBpc19xcGljIC0gd2hldGhlciBOQU5EIENUUkwg aXMgcGFydCBvZiBxcGljIElQCj4gPiAgICogQHFwaWNfdjIgLSBmbGFnIHRvIGluZGljYXRlIFFQ SUMgSVAgdmVyc2lvbiAyCj4gPiArICogQHVzZV9jb2Rld29yZF9maXh1cCAtIHdoZXRoZXIgTkFO RCBoYXMgZGlmZmVyZW50IGxheW91dCBmb3IgYm9vdCBwYXJ0aXRpb25zCj4gPiAgICogQGRldl9j bWRfcmVnX3N0YXJ0IC0gTkFORF9ERVZfQ01EXyogcmVnaXN0ZXJzIHN0YXJ0aW5nIG9mZnNldAo+ ID4gICAqLwo+ID4gIHN0cnVjdCBxY29tX25hbmRjX3Byb3BzIHsKPiA+IEBAIC00ODIsNiArNTEw LDcgQEAgc3RydWN0IHFjb21fbmFuZGNfcHJvcHMgewo+ID4gIAlib29sIGlzX2JhbTsKPiA+ICAJ Ym9vbCBpc19xcGljOwo+ID4gIAlib29sIHFwaWNfdjI7Cj4gPiArCWJvb2wgdXNlX2NvZGV3b3Jk X2ZpeHVwOwo+ID4gIAl1MzIgZGV2X2NtZF9yZWdfc3RhcnQ7Cj4gPiAgfTsKPiA+ICAKPiA+IEBA IC0xNzAxLDcgKzE3MzAsNyBAQCBxY29tX25hbmRjX3JlYWRfY3dfcmF3KHN0cnVjdCBtdGRfaW5m byAqbXRkLCBzdHJ1Y3QgbmFuZF9jaGlwICpjaGlwLAo+ID4gIAlkYXRhX3NpemUxID0gbXRkLT53 cml0ZXNpemUgLSBob3N0LT5jd19zaXplICogKGVjYy0+c3RlcHMgLSAxKTsKPiA+ICAJb29iX3Np emUxID0gaG9zdC0+YmJtX3NpemU7Cj4gPiAgCj4gPiAtCWlmIChxY29tX25hbmRjX2lzX2xhc3Rf Y3coZWNjLCBjdykpIHsKPiA+ICsJaWYgKHFjb21fbmFuZGNfaXNfbGFzdF9jdyhlY2MsIGN3KSAm JiAhaG9zdC0+Y29kZXdvcmRfZml4dXApIHsKPiA+ICAJCWRhdGFfc2l6ZTIgPSBlY2MtPnNpemUg LSBkYXRhX3NpemUxIC0KPiA+ICAJCQkgICAgICgoZWNjLT5zdGVwcyAtIDEpICogNCk7Cj4gPiAg CQlvb2Jfc2l6ZTIgPSAoZWNjLT5zdGVwcyAqIDQpICsgaG9zdC0+ZWNjX2J5dGVzX2h3ICsKPiA+ IEBAIC0xNzgyLDcgKzE4MTEsNyBAQCBjaGVja19mb3JfZXJhc2VkX3BhZ2Uoc3RydWN0IHFjb21f bmFuZF9ob3N0ICpob3N0LCB1OCAqZGF0YV9idWYsCj4gPiAgCX0KPiA+ICAKPiA+ICAJZm9yX2Vh Y2hfc2V0X2JpdChjdywgJnVuY29ycmVjdGFibGVfY3dzLCBlY2MtPnN0ZXBzKSB7Cj4gPiAtCQlp ZiAocWNvbV9uYW5kY19pc19sYXN0X2N3KGVjYywgY3cpKSB7Cj4gPiArCQlpZiAocWNvbV9uYW5k Y19pc19sYXN0X2N3KGVjYywgY3cpICYmICFob3N0LT5jb2Rld29yZF9maXh1cCkgewo+ID4gIAkJ CWRhdGFfc2l6ZSA9IGVjYy0+c2l6ZSAtICgoZWNjLT5zdGVwcyAtIDEpICogNCk7Cj4gPiAgCQkJ b29iX3NpemUgPSAoZWNjLT5zdGVwcyAqIDQpICsgaG9zdC0+ZWNjX2J5dGVzX2h3Owo+ID4gIAkJ fSBlbHNlIHsKPiA+IEBAIC0xOTQwLDcgKzE5NjksNyBAQCBzdGF0aWMgaW50IHJlYWRfcGFnZV9l Y2Moc3RydWN0IHFjb21fbmFuZF9ob3N0ICpob3N0LCB1OCAqZGF0YV9idWYsCj4gPiAgCWZvciAo aSA9IDA7IGkgPCBlY2MtPnN0ZXBzOyBpKyspIHsKPiA+ICAJCWludCBkYXRhX3NpemUsIG9vYl9z aXplOwo+ID4gIAo+ID4gLQkJaWYgKHFjb21fbmFuZGNfaXNfbGFzdF9jdyhlY2MsIGkpKSB7Cj4g PiArCQlpZiAocWNvbV9uYW5kY19pc19sYXN0X2N3KGVjYywgaSkgJiYgIWhvc3QtPmNvZGV3b3Jk X2ZpeHVwKSB7Cj4gPiAgCQkJZGF0YV9zaXplID0gZWNjLT5zaXplIC0gKChlY2MtPnN0ZXBzIC0g MSkgPDwgMik7Cj4gPiAgCQkJb29iX3NpemUgPSAoZWNjLT5zdGVwcyA8PCAyKSArIGhvc3QtPmVj Y19ieXRlc19odyArCj4gPiAgCQkJCSAgIGhvc3QtPnNwYXJlX2J5dGVzOwo+ID4gQEAgLTIwMzcs NiArMjA2Niw1NSBAQCBzdGF0aWMgaW50IGNvcHlfbGFzdF9jdyhzdHJ1Y3QgcWNvbV9uYW5kX2hv c3QgKmhvc3QsIGludCBwYWdlKQo+ID4gIAlyZXR1cm4gcmV0Owo+ID4gIH0KPiA+ICAKPiA+ICtz dGF0aWMgYm9vbAo+ID4gK3Fjb21fbmFuZGNfaXNfYm9vdF9wYWdlKHN0cnVjdCBxY29tX25hbmRf aG9zdCAqaG9zdCwgaW50IHBhZ2UpCj4gCj4gTW92ZSBmdW5jdGlvbiBuYW1lIHRvIHByZXZpb3Vz IGxpbmUuIElmIGl0IGV4Y2VlZHMgMTAwIGxpbmVzIHRoZW4gd3JhcAo+IGFyZ3VtZW50cy4KPiAK PiBzL3Fjb21fbmFuZGNfaXNfYm9vdF9wYWdlL3Fjb21fbmFuZGNfaXNfYm9vdF9wYXJ0aXRpb24K PiAKCkFnYWluIGNvbnNpZGVyaW5nIHRoZSBjaGVjayBpcyBkb25lIG9uIHRoZSBwYWdlIGFuZCBu b3Qgb24gdGhlCnBhcnRpdGlvbiwgd29uZGVyIHdoYXQgaXMgY29ycmVjdC4KCj4gPiArewo+ID4g KwlzdHJ1Y3QgcWNvbV9uYW5kX2Jvb3RfcGFydGl0aW9uICpib290X3BhcnRpdGlvbjsKPiA+ICsJ dTMyIHN0YXJ0LCBlbmQ7Cj4gPiArCWludCBpOwo+ID4gKwo+ID4gKwlmb3IgKGkgPSAwOyBpIDwg aG9zdC0+bnJfYm9vdF9wYXJ0aXRpb25zOyBpKyspIHsKPiA+ICsJCWJvb3RfcGFydGl0aW9uID0g Jmhvc3QtPmJvb3RfcGFydGl0aW9uc1tpXTsKPiA+ICsJCXN0YXJ0ID0gYm9vdF9wYXJ0aXRpb24t PnBhZ2Vfb2Zmc2V0Owo+ID4gKwkJZW5kID0gc3RhcnQgKyBib290X3BhcnRpdGlvbi0+cGFnZV9z aXplOwo+ID4gKwo+ID4gKwkJLyogQm9vdCBwYWdlcyBhcmUgbm9ybWFsbHkgYXQgdGhlIHN0YXJ0 IG9mCj4gCj4gQmxvY2sgY29tbWVudHMgc2hvdWxkIHN0YXJ0IHdpdGg6Cj4gCj4gCS8qCj4gCSAq IC4uLgo+IAo+IEFsc28sIGFyZSB5b3Ugc3VyZSB0aGF0IG9ubHkgZmV3IHBhZ2VzIGluIHRoZSBw YXJ0aXRpb25zIGhhdmUgZGlmZmVyZW50IGxheW91dAo+IGFuZCBub3QgYWxsIHBhZ2VzPyBJZiBu b3QsIHRoZW4gdGhpcyBjb21tZW50IG5lZWRzIHRvIGJlIHJld29yZGVkLgo+IAoKSSBwcm9iYWJs eSB3b3JkZXJkIHRoaXMgYmFkLi4uCkVhY2ggcGFnZSBvZiB0aGUgYm9vdCBwYXJ0aXRpb25zIHJl cXVpcmUgdGhlIGNvZGV3b3JkIGZpeC4KQnV0IG90aGVyIG1heSBoYXZlIHRoZSBub3JtYWwgY29k ZXdvcmQKRm9yIGV4YW1wbGUgdGhpcyBpcyBmcm9tIGEgTmV0Z2VhciByb3V0ZXI6Cm10ZDA6IDAw YzgwMDAwIDAwMDIwMDAwICJxY2FkYXRhIiAocmVxdWlyZSBjb2Rld29yZCBmaXgpCm10ZDE6IDAw NTAwMDAwIDAwMDIwMDAwICJBUFBTQkwiICAocmVxdWlyZSBjb2Rld29yZCBmaXgpCm10ZDI6IDAw MDgwMDAwIDAwMDIwMDAwICJBUFBTQkxFTlYiIChkb2Vzbid0IHJlcXVpcmUgY29kZXdvcmQgZml4 KQptdGQzOiAwMDE0MDAwMCAwMDAyMDAwMCAiYXJ0IiAgICAgICAoZG9lc24ndCkKbXRkNDogMDAx NDAwMDAgMDAwMjAwMDAgImFydGJhayIgICAgKGRvZXNuJ3QpCm10ZDU6IDAwNDAwMDAwIDAwMDIw MDAwICJrZXJuZWwiICAgIChkb2Vzbid0KQptdGQ2OiAwNjA4MDAwMCAwMDAyMDAwMCAidWJpIiAg ICAgICAoZG9lc24ndCkKbXRkNzogMDA3MDAwMDAgMDAwMjAwMDAgInJlc2VydmUiICAgKGRvZXNu J3QpCgpUaGlzIGlzIHBhcnQgb2YgdGhlIGNhc2UgdGhvIGFzIHRoZXJlIGFyZSBzb21lIHBhcnRp dGlvbiB0YWJsZSB3aXRoCnNvbWV0aGluZyBsaWtlCgptdGQwOiAwMGM4MDAwMCAwMDAyMDAwMCAi cWNhZGF0YSIgKHJlcXVpcmUgY29kZXdvcmQgZml4KQptdGQxOiAwMDUwMDAwMCAwMDAyMDAwMCAi QVBQU0JMIiAgKHJlcXVpcmUgY29kZXdvcmQgZml4KQptdGQyOiAwMDA4MDAwMCAwMDAyMDAwMCAi QVBQU0JMRU5WIiAoZG9lc24ndCByZXF1aXJlIGNvZGV3b3JkIGZpeCkKbXRkMzogMDAxNDAwMDAg MDAwMjAwMDAgIkFQUFNCTDIiICAocmVxdWlyZSBjb2Rld29yZCBmaXgpClsuLi5dCgpJbiBhbGwg Y2FzZSA5OSUgb2YgdGhlIHRpbWUgaW4gYSBub3JtYWwgc3lzdGVtIHdoYXQgeW91IGNvbW1vbmx5 IHdyaXRlCmFyZSB0aGUgcm9vdGZzIHBhcnRpdGlvbiB0aGF0IGFyZSBBRlRFUiB0aGUgYm9vdCBw YXJ0aXRpb24gc28gY2hlY2tpbmcKaWYgdGhlIHBhZ2UgaXMgYWZ0ZXIgc3VjaCBwYXJ0aXRpb24g c2hvdWxkIHNwZWVkIHVwIHRoZSBjaGVjay4KTm93IHRoYXQgSSB0aGluayBhYm91dCBpdCwgYSBn b29kIGlkZWEgaXMgYWxzbyBzdGFydCBjaGVja2luZyB0aGUKYm9vdF9wYXJ0aXRpb24gdGFibGUg ZnJvbSB0aGUgZW5kIHRvIGltcHJvdmUgdGhlIGNoZWNraW5nIGV2ZW4gbW9yZS4KClNvIHRlbGwg bWUgaWYgdGhlIGNvbW1lbnRzIGlzIHdyb25sZ3kgd29yZGVkLgoKPiA+ICsJCSAqIHRoZSBuYW5k IGluIHZhcmlvdXMgcGFydGl0aW9uLgo+ID4gKwkJICogQ2hlY2sgdGhlIHBhZ2UgZnJvbSB0aGUg Ym9vdCBwYWdlIGVuZCBmaXJzdAo+ID4gKwkJICogdG8gc2F2ZSBvbmUgZXh0cmEgY2hlY2sgYW5k IG9wdGltaXplIHRoaXMKPiA+ICsJCSAqIGluIGNhc2UgcmVhbCBuby1ib290IHBhcnRpdGlvbiBh cmUgdXNlZC4KPiA+ICsJCSAqLwo+ID4gKwkJaWYgKHBhZ2UgPCBlbmQgJiYgcGFnZSA+PSBzdGFy dCkKPiA+ICsJCQlyZXR1cm4gdHJ1ZTsKPiA+ICsJfQo+ID4gKwo+ID4gKwlyZXR1cm4gZmFsc2U7 Cj4gPiArfQo+ID4gKwo+ID4gK3N0YXRpYyB2b2lkCj4gPiArcWNvbV9uYW5kY19jb2Rld29yZF9m aXh1cChzdHJ1Y3QgcWNvbV9uYW5kX2hvc3QgKmhvc3QsIGludCBwYWdlKQo+ID4gK3sKPiA+ICsJ Ym9vbCBjb2Rld29yZF9maXh1cCA9IHFjb21fbmFuZGNfaXNfYm9vdF9wYWdlKGhvc3QsIHBhZ2Up Owo+ID4gKwo+ID4gKwkvKiBTa2lwIGNvbmYgd3JpdGUgaWYgd2UgYXJlIGFscmVhZHkgaW4gdGhl IGNvcnJlY3QgbW9kZSAqLwo+ID4gKwlpZiAoY29kZXdvcmRfZml4dXAgPT0gaG9zdC0+Y29kZXdv cmRfZml4dXApCj4gPiArCQlyZXR1cm47Cj4gPiArCj4gPiArCWhvc3QtPmNvZGV3b3JkX2ZpeHVw ID0gY29kZXdvcmRfZml4dXA7Cj4gPiArCj4gPiArCWhvc3QtPmN3X2RhdGEgPSBjb2Rld29yZF9m aXh1cCA/IDUxMiA6IDUxNjsKPiA+ICsJaG9zdC0+c3BhcmVfYnl0ZXMgPSBob3N0LT5jd19zaXpl IC0gaG9zdC0+ZWNjX2J5dGVzX2h3IC0KPiA+ICsJCQkgICAgaG9zdC0+YmJtX3NpemUgLSBob3N0 LT5jd19kYXRhOwo+ID4gKwo+ID4gKwlob3N0LT5jZmcwICY9IH4oU1BBUkVfU0laRV9CWVRFU19N QVNLIHwgVURfU0laRV9CWVRFU19NQVNLKTsKPiA+ICsJaG9zdC0+Y2ZnMCB8PSBob3N0LT5zcGFy ZV9ieXRlcyA8PCBTUEFSRV9TSVpFX0JZVEVTIHwKPiA+ICsJCSAgICAgIGhvc3QtPmN3X2RhdGEg PDwgVURfU0laRV9CWVRFUzsKPiA+ICsKPiA+ICsJaG9zdC0+ZWNjX2JjaF9jZmcgJj0gfkVDQ19O VU1fREFUQV9CWVRFU19NQVNLOwo+ID4gKwlob3N0LT5lY2NfYmNoX2NmZyB8PSBob3N0LT5jd19k YXRhIDw8IEVDQ19OVU1fREFUQV9CWVRFUzsKPiA+ICsJaG9zdC0+ZWNjX2J1Zl9jZmcgPSAoY29k ZXdvcmRfZml4dXAgPyAweDFmZiA6IDB4MjAzKSA8PCBOVU1fU1RFUFM7Cj4gCj4gcy8xZmYvKDUx MiAtIDEpCj4gcy8yMDMvKDUxNiAtIDEpCj4gCgpvay4gSSB3b25kZXIgaWYgdGhpcyBjYW4ganVz dCBiZSByZWR1Y2VkIHRvIChob3N0LT5jd19kYXRhIC0gMSkgYW5kCnNraXBwaW5nIHRoZSBjaGVj ayBlbnRpcmVseS4KCj4gPiArfQo+ID4gKwo+ID4gIC8qIGltcGxlbWVudHMgZWNjLT5yZWFkX3Bh Z2UoKSAqLwo+ID4gIHN0YXRpYyBpbnQgcWNvbV9uYW5kY19yZWFkX3BhZ2Uoc3RydWN0IG5hbmRf Y2hpcCAqY2hpcCwgdWludDhfdCAqYnVmLAo+ID4gIAkJCQlpbnQgb29iX3JlcXVpcmVkLCBpbnQg cGFnZSkKPiA+IEBAIC0yMDQ1LDYgKzIxMjMsOSBAQCBzdGF0aWMgaW50IHFjb21fbmFuZGNfcmVh ZF9wYWdlKHN0cnVjdCBuYW5kX2NoaXAgKmNoaXAsIHVpbnQ4X3QgKmJ1ZiwKPiA+ICAJc3RydWN0 IHFjb21fbmFuZF9jb250cm9sbGVyICpuYW5kYyA9IGdldF9xY29tX25hbmRfY29udHJvbGxlcihj aGlwKTsKPiA+ICAJdTggKmRhdGFfYnVmLCAqb29iX2J1ZiA9IE5VTEw7Cj4gPiAgCj4gPiArCWlm IChob3N0LT5ucl9ib290X3BhcnRpdGlvbnMpCj4gPiArCQlxY29tX25hbmRjX2NvZGV3b3JkX2Zp eHVwKGhvc3QsIHBhZ2UpOwo+ID4gKwo+ID4gIAluYW5kX3JlYWRfcGFnZV9vcChjaGlwLCBwYWdl LCAwLCBOVUxMLCAwKTsKPiA+ICAJZGF0YV9idWYgPSBidWY7Cj4gPiAgCW9vYl9idWYgPSBvb2Jf cmVxdWlyZWQgPyBjaGlwLT5vb2JfcG9pIDogTlVMTDsKPiA+IEBAIC0yMDY0LDYgKzIxNDUsOSBA QCBzdGF0aWMgaW50IHFjb21fbmFuZGNfcmVhZF9wYWdlX3JhdyhzdHJ1Y3QgbmFuZF9jaGlwICpj aGlwLCB1aW50OF90ICpidWYsCj4gPiAgCWludCBjdywgcmV0Owo+ID4gIAl1OCAqZGF0YV9idWYg PSBidWYsICpvb2JfYnVmID0gY2hpcC0+b29iX3BvaTsKPiA+ICAKPiA+ICsJaWYgKGhvc3QtPm5y X2Jvb3RfcGFydGl0aW9ucykKPiA+ICsJCXFjb21fbmFuZGNfY29kZXdvcmRfZml4dXAoaG9zdCwg cGFnZSk7Cj4gPiArCj4gPiAgCWZvciAoY3cgPSAwOyBjdyA8IGVjYy0+c3RlcHM7IGN3KyspIHsK PiA+ICAJCXJldCA9IHFjb21fbmFuZGNfcmVhZF9jd19yYXcobXRkLCBjaGlwLCBkYXRhX2J1Ziwg b29iX2J1ZiwKPiA+ICAJCQkJCSAgICAgcGFnZSwgY3cpOwo+ID4gQEAgLTIwODQsNiArMjE2OCw5 IEBAIHN0YXRpYyBpbnQgcWNvbV9uYW5kY19yZWFkX29vYihzdHJ1Y3QgbmFuZF9jaGlwICpjaGlw LCBpbnQgcGFnZSkKPiA+ICAJc3RydWN0IHFjb21fbmFuZF9jb250cm9sbGVyICpuYW5kYyA9IGdl dF9xY29tX25hbmRfY29udHJvbGxlcihjaGlwKTsKPiA+ICAJc3RydWN0IG5hbmRfZWNjX2N0cmwg KmVjYyA9ICZjaGlwLT5lY2M7Cj4gPiAgCj4gPiArCWlmIChob3N0LT5ucl9ib290X3BhcnRpdGlv bnMpCj4gPiArCQlxY29tX25hbmRjX2NvZGV3b3JkX2ZpeHVwKGhvc3QsIHBhZ2UpOwo+ID4gKwo+ ID4gIAljbGVhcl9yZWFkX3JlZ3MobmFuZGMpOwo+ID4gIAljbGVhcl9iYW1fdHJhbnNhY3Rpb24o bmFuZGMpOwo+ID4gIAo+ID4gQEAgLTIxMDQsNiArMjE5MSw5IEBAIHN0YXRpYyBpbnQgcWNvbV9u YW5kY193cml0ZV9wYWdlKHN0cnVjdCBuYW5kX2NoaXAgKmNoaXAsIGNvbnN0IHVpbnQ4X3QgKmJ1 ZiwKPiA+ICAJdTggKmRhdGFfYnVmLCAqb29iX2J1ZjsKPiA+ICAJaW50IGksIHJldDsKPiA+ICAK PiA+ICsJaWYgKGhvc3QtPm5yX2Jvb3RfcGFydGl0aW9ucykKPiA+ICsJCXFjb21fbmFuZGNfY29k ZXdvcmRfZml4dXAoaG9zdCwgcGFnZSk7Cj4gPiArCj4gPiAgCW5hbmRfcHJvZ19wYWdlX2JlZ2lu X29wKGNoaXAsIHBhZ2UsIDAsIE5VTEwsIDApOwo+ID4gIAo+ID4gIAljbGVhcl9yZWFkX3JlZ3Mo bmFuZGMpOwo+ID4gQEAgLTIxMTksNyArMjIwOSw3IEBAIHN0YXRpYyBpbnQgcWNvbV9uYW5kY193 cml0ZV9wYWdlKHN0cnVjdCBuYW5kX2NoaXAgKmNoaXAsIGNvbnN0IHVpbnQ4X3QgKmJ1ZiwKPiA+ ICAJZm9yIChpID0gMDsgaSA8IGVjYy0+c3RlcHM7IGkrKykgewo+ID4gIAkJaW50IGRhdGFfc2l6 ZSwgb29iX3NpemU7Cj4gPiAgCj4gPiAtCQlpZiAocWNvbV9uYW5kY19pc19sYXN0X2N3KGVjYywg aSkpIHsKPiA+ICsJCWlmIChxY29tX25hbmRjX2lzX2xhc3RfY3coZWNjLCBpKSAmJiAhaG9zdC0+ Y29kZXdvcmRfZml4dXApIHsKPiA+ICAJCQlkYXRhX3NpemUgPSBlY2MtPnNpemUgLSAoKGVjYy0+ c3RlcHMgLSAxKSA8PCAyKTsKPiA+ICAJCQlvb2Jfc2l6ZSA9IChlY2MtPnN0ZXBzIDw8IDIpICsg aG9zdC0+ZWNjX2J5dGVzX2h3ICsKPiA+ICAJCQkJICAgaG9zdC0+c3BhcmVfYnl0ZXM7Cj4gPiBA QCAtMjE3Niw2ICsyMjY2LDkgQEAgc3RhdGljIGludCBxY29tX25hbmRjX3dyaXRlX3BhZ2VfcmF3 KHN0cnVjdCBuYW5kX2NoaXAgKmNoaXAsCj4gPiAgCXU4ICpkYXRhX2J1ZiwgKm9vYl9idWY7Cj4g PiAgCWludCBpLCByZXQ7Cj4gPiAgCj4gPiArCWlmIChob3N0LT5ucl9ib290X3BhcnRpdGlvbnMp Cj4gPiArCQlxY29tX25hbmRjX2NvZGV3b3JkX2ZpeHVwKGhvc3QsIHBhZ2UpOwo+ID4gKwo+ID4g IAluYW5kX3Byb2dfcGFnZV9iZWdpbl9vcChjaGlwLCBwYWdlLCAwLCBOVUxMLCAwKTsKPiA+ICAJ Y2xlYXJfcmVhZF9yZWdzKG5hbmRjKTsKPiA+ICAJY2xlYXJfYmFtX3RyYW5zYWN0aW9uKG5hbmRj KTsKPiA+IEBAIC0yMTk0LDcgKzIyODcsNyBAQCBzdGF0aWMgaW50IHFjb21fbmFuZGNfd3JpdGVf cGFnZV9yYXcoc3RydWN0IG5hbmRfY2hpcCAqY2hpcCwKPiA+ICAJCWRhdGFfc2l6ZTEgPSBtdGQt PndyaXRlc2l6ZSAtIGhvc3QtPmN3X3NpemUgKiAoZWNjLT5zdGVwcyAtIDEpOwo+ID4gIAkJb29i X3NpemUxID0gaG9zdC0+YmJtX3NpemU7Cj4gPiAgCj4gPiAtCQlpZiAocWNvbV9uYW5kY19pc19s YXN0X2N3KGVjYywgaSkpIHsKPiA+ICsJCWlmIChxY29tX25hbmRjX2lzX2xhc3RfY3coZWNjLCBp KSAmJiAhaG9zdC0+Y29kZXdvcmRfZml4dXApIHsKPiA+ICAJCQlkYXRhX3NpemUyID0gZWNjLT5z aXplIC0gZGF0YV9zaXplMSAtCj4gPiAgCQkJCSAgICAgKChlY2MtPnN0ZXBzIC0gMSkgPDwgMik7 Cj4gPiAgCQkJb29iX3NpemUyID0gKGVjYy0+c3RlcHMgPDwgMikgKyBob3N0LT5lY2NfYnl0ZXNf aHcgKwo+ID4gQEAgLTIyNTQsNiArMjM0Nyw5IEBAIHN0YXRpYyBpbnQgcWNvbV9uYW5kY193cml0 ZV9vb2Ioc3RydWN0IG5hbmRfY2hpcCAqY2hpcCwgaW50IHBhZ2UpCj4gPiAgCWludCBkYXRhX3Np emUsIG9vYl9zaXplOwo+ID4gIAlpbnQgcmV0Owo+ID4gIAo+ID4gKwlpZiAoaG9zdC0+bnJfYm9v dF9wYXJ0aXRpb25zKQo+ID4gKwkJcWNvbV9uYW5kY19jb2Rld29yZF9maXh1cChob3N0LCBwYWdl KTsKPiA+ICsKPiA+ICAJaG9zdC0+dXNlX2VjYyA9IHRydWU7Cj4gPiAgCWNsZWFyX2JhbV90cmFu c2FjdGlvbihuYW5kYyk7Cj4gPiAgCj4gPiBAQCAtMjkwMiw2ICsyOTk4LDcxIEBAIHN0YXRpYyBp bnQgcWNvbV9uYW5kY19zZXR1cChzdHJ1Y3QgcWNvbV9uYW5kX2NvbnRyb2xsZXIgKm5hbmRjKQo+ ID4gIAo+ID4gIHN0YXRpYyBjb25zdCBjaGFyICogY29uc3QgcHJvYmVzW10gPSB7ICJjbWRsaW5l cGFydCIsICJvZnBhcnQiLCAicWNvbXNtZW0iLCBOVUxMIH07Cj4gPiAgCj4gPiArc3RhdGljIGlu dCBxY29tX25hbmRfaG9zdF9wYXJzZV9ib290X3BhcnRpdGlvbnMoc3RydWN0IHFjb21fbmFuZF9j b250cm9sbGVyICpuYW5kYywKPiA+ICsJCQkJCQlzdHJ1Y3QgcWNvbV9uYW5kX2hvc3QgKmhvc3Qs Cj4gPiArCQkJCQkJc3RydWN0IGRldmljZV9ub2RlICpkbikKPiA+ICt7Cj4gPiArCXN0cnVjdCBu YW5kX2NoaXAgKmNoaXAgPSAmaG9zdC0+Y2hpcDsKPiA+ICsJc3RydWN0IG10ZF9pbmZvICptdGQg PSBuYW5kX3RvX210ZChjaGlwKTsKPiA+ICsJc3RydWN0IHFjb21fbmFuZF9ib290X3BhcnRpdGlv biAqYm9vdF9wYXJ0aXRpb247Cj4gPiArCXN0cnVjdCBkZXZpY2UgKmRldiA9IG5hbmRjLT5kZXY7 Cj4gPiArCWludCBwYXJ0aXRpb25zX2NvdW50LCBpLCBqLCByZXQ7Cj4gPiArCj4gPiArCWlmICgh bmFuZGMtPnByb3BzLT51c2VfY29kZXdvcmRfZml4dXApCj4gPiArCQlyZXR1cm4gMDsKPiAKPiBN b3ZlIHRoaXMgY2hlY2sgdG8gY2FsbGVyIGFzIEkgc3VnZ2VzdGVkIHByZXZpb3VzbHkuCj4gCgpT b3JyeSBJIG1pc3NlZCB0aGF0LgoKPiA+ICsKPiA+ICsJaWYgKCFvZl9maW5kX3Byb3BlcnR5KGRu LCAicWNvbSxib290LXBhcnRpdGlvbnMiLCBOVUxMKSkKPiA+ICsJCXJldHVybiAwOwo+ID4gKwo+ ID4gKwlwYXJ0aXRpb25zX2NvdW50ID0gb2ZfcHJvcGVydHlfY291bnRfdTMyX2VsZW1zKGRuLCAi cWNvbSxib290LXBhcnRpdGlvbnMiKTsKPiA+ICsJaWYgKHBhcnRpdGlvbnNfY291bnQgPCAwKSB7 Cj4gCj4gcGFydGl0aW9uc19jb3VudCA8PSAwCj4gCj4gPiArCQlkZXZfZXJyKGRldiwgIkVycm9y IHBhcnNpbmcgYm9vdCBwYXJ0aXRpb24uIik7Cj4gCj4gQWRkIG5ld2xpbmUgYXQgdGhlIGVuZCBv ZiBlcnJvciBtZXNzYWdlCj4gCj4gPiArCQlyZXR1cm4gcmV0Owo+ID4gKwl9Cj4gPiArCj4gPiAr CWhvc3QtPm5yX2Jvb3RfcGFydGl0aW9ucyA9IHBhcnRpdGlvbnNfY291bnQgLyAyOwo+ID4gKwlo b3N0LT5ib290X3BhcnRpdGlvbnMgPSBkZXZtX2tjYWxsb2MoZGV2LCBob3N0LT5ucl9ib290X3Bh cnRpdGlvbnMsCj4gPiArCQkJCQkgICAgIHNpemVvZigqaG9zdC0+Ym9vdF9wYXJ0aXRpb25zKSwg R0ZQX0tFUk5FTCk7Cj4gPiArCWlmICghaG9zdC0+Ym9vdF9wYXJ0aXRpb25zKQo+IAo+IGhvc3Qt Pm5yX2Jvb3RfcGFydGl0aW9ucyA9IDA7Cj4gCj4gPiArCQlyZXR1cm4gLUVOT01FTTsKPiA+ICsK PiA+ICsJZm9yIChpID0gMCwgaiA9IDA7IGkgPCBob3N0LT5ucl9ib290X3BhcnRpdGlvbnM7IGkr KywgaiArPSAyKSB7Cj4gPiArCQlib290X3BhcnRpdGlvbiA9ICZob3N0LT5ib290X3BhcnRpdGlv bnNbaV07Cj4gPiArCj4gPiArCQlyZXQgPSBvZl9wcm9wZXJ0eV9yZWFkX3UzMl9pbmRleChkbiwg InFjb20sYm9vdC1wYXJ0aXRpb25zIiwgaiwKPiA+ICsJCQkJCQkgJmJvb3RfcGFydGl0aW9uLT5w YWdlX29mZnNldCk7Cj4gPiArCQlpZiAocmV0KSB7Cj4gPiArCQkJZGV2X2VycihkZXYsICJFcnJv ciBwYXJzaW5nIGJvb3QgcGFydGl0aW9uIG9mZnNldCBhdCBpbmRleCAlZCIsIGkpOwo+IAo+IEFk ZCBuZXdsaW5lIGF0IHRoZSBlbmQgb2YgZXJyb3IgbWVzc2FnZS4gRG8gdGhlIHNhbWUgZm9yIGFs bCBlcnJvciBwcmludHMuCj4gCj4gPiArCQkJcmV0dXJuIHJldDsKPiA+ICsJCX0KPiA+ICsKPiA+ ICsJCWlmIChib290X3BhcnRpdGlvbi0+cGFnZV9vZmZzZXQgJSBtdGQtPndyaXRlc2l6ZSkgewo+ ID4gKwkJCWRldl9lcnIoZGV2LCAiQm9vdCBwYXJ0aXRpb24gb2Zmc2V0IG5vdCBtdWx0aXBsZSBv ZiB3cml0ZXNpemUgYXQgaW5kZXggJWkiLAo+ID4gKwkJCQlpKTsKPiA+ICsJCQlyZXR1cm4gLUVJ TlZBTDsKPiA+ICsJCX0KPiA+ICsJCS8qIENvbnZlcnQgb2Zmc2V0IHRvIG5hbmQgcGFnZXMgKi8K PiAKPiBzL3BhZ2VzL3BhcnRpdGlvbnMKPiAKPiA+ICsJCWJvb3RfcGFydGl0aW9uLT5wYWdlX29m ZnNldCAvPSBtdGQtPndyaXRlc2l6ZTsKPiAKPiBzL3BhZ2Vfb2Zmc2V0L29mZnNldAo+IAo+ID4g Kwo+ID4gKwkJcmV0ID0gb2ZfcHJvcGVydHlfcmVhZF91MzJfaW5kZXgoZG4sICJxY29tLGJvb3Qt cGFydGl0aW9ucyIsIGogKyAxLAo+ID4gKwkJCQkJCSAmYm9vdF9wYXJ0aXRpb24tPnBhZ2Vfc2l6 ZSk7Cj4gPiArCQlpZiAocmV0KSB7Cj4gPiArCQkJZGV2X2VycihkZXYsICJFcnJvciBwYXJzaW5n IGJvb3QgcGFydGl0aW9uIHNpemUgYXQgaW5kZXggJWQiLCBpKTsKPiA+ICsJCQlyZXR1cm4gcmV0 Owo+ID4gKwkJfQo+ID4gKwo+ID4gKwkJaWYgKGJvb3RfcGFydGl0aW9uLT5wYWdlX3NpemUgJSBt dGQtPndyaXRlc2l6ZSkgewo+IAo+IHMvcGFnZV9zaXplL3NpemUgaGVyZSBhbmQgYmVsb3cKPiAK PiA+ICsJCQlkZXZfZXJyKGRldiwgIkJvb3QgcGFydGl0aW9uIHNpemUgbm90IG11bHRpcGxlIG9m IHdyaXRlc2l6ZSBhdCBpbmRleCAlaSIsCj4gPiArCQkJCWkpOwo+ID4gKwkJCXJldHVybiAtRUlO VkFMOwo+ID4gKwkJfQo+ID4gKwkJLyogQ29udmVydCBzaXplIHRvIG5hbmQgcGFnZXMgKi8KPiAK PiBzL3BhZ2VzL3BhcnRpdGlvbnMKPiAKPiBUaGFua3MsCj4gTWFuaQo+IAo+ID4gKwkJYm9vdF9w YXJ0aXRpb24tPnBhZ2Vfc2l6ZSAvPSBtdGQtPndyaXRlc2l6ZTsKPiA+ICsJfQo+ID4gKwo+ID4g KwlyZXR1cm4gMDsKPiA+ICt9Cj4gPiArCj4gPiAgc3RhdGljIGludCBxY29tX25hbmRfaG9zdF9p bml0X2FuZF9yZWdpc3RlcihzdHJ1Y3QgcWNvbV9uYW5kX2NvbnRyb2xsZXIgKm5hbmRjLAo+ID4g IAkJCQkJICAgIHN0cnVjdCBxY29tX25hbmRfaG9zdCAqaG9zdCwKPiA+ICAJCQkJCSAgICBzdHJ1 Y3QgZGV2aWNlX25vZGUgKmRuKQo+ID4gQEAgLTI5NzAsNiArMzEzMSw4IEBAIHN0YXRpYyBpbnQg cWNvbV9uYW5kX2hvc3RfaW5pdF9hbmRfcmVnaXN0ZXIoc3RydWN0IHFjb21fbmFuZF9jb250cm9s bGVyICpuYW5kYywKPiA+ICAJaWYgKHJldCkKPiA+ICAJCW5hbmRfY2xlYW51cChjaGlwKTsKPiA+ ICAKPiA+ICsJcWNvbV9uYW5kX2hvc3RfcGFyc2VfYm9vdF9wYXJ0aXRpb25zKG5hbmRjLCBob3N0 LCBkbik7Cj4gPiArCj4gPiAgCXJldHVybiByZXQ7Cj4gPiAgfQo+ID4gIAo+ID4gQEAgLTMxMzUs NiArMzI5OCw3IEBAIHN0YXRpYyBpbnQgcWNvbV9uYW5kY19yZW1vdmUoc3RydWN0IHBsYXRmb3Jt X2RldmljZSAqcGRldikKPiA+ICBzdGF0aWMgY29uc3Qgc3RydWN0IHFjb21fbmFuZGNfcHJvcHMg aXBxODA2eF9uYW5kY19wcm9wcyA9IHsKPiA+ICAJLmVjY19tb2RlcyA9IChFQ0NfUlNfNEJJVCB8 IEVDQ19CQ0hfOEJJVCksCj4gPiAgCS5pc19iYW0gPSBmYWxzZSwKPiA+ICsJLnVzZV9jb2Rld29y ZF9maXh1cCA9IHRydWUsCj4gPiAgCS5kZXZfY21kX3JlZ19zdGFydCA9IDB4MCwKPiA+ICB9Owo+ ID4gIAo+ID4gLS0gCj4gPiAyLjM2LjEKPiA+IAo+IAo+IC0tIAo+IOCuruCuo+Cuv+CuteCuo+Cv jeCuo+CuqeCvjSDgrprgrqTgrr7grprgrr/grrXgrq7gr40KCi0tIAoJQW5zdWVsCgpfX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KTGludXggTVRE IGRpc2N1c3Npb24gbWFpbGluZyBsaXN0Cmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxt YW4vbGlzdGluZm8vbGludXgtbXRkLwo=