From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from relay9-d.mail.gandi.net (relay9-d.mail.gandi.net [217.70.183.199]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 68D0F145FE2; Thu, 16 May 2024 12:56:53 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=217.70.183.199 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1715864217; cv=none; b=dnTgSI8beP+CM5OQWROrsgNt1pU96f9ucZvM0Rkuwn0trpjog5ENxmF/IFqNGRtbJOuBzrFnq67wf8RrZUlSSgXfhbUkN4IZKBZ/2OO7ilj8gm39T7ES9YyJEHxsbAzgoPhSZ7EUKkWV2nCSWT5YSu2kl1L9q750F055GNyIWeI= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1715864217; c=relaxed/simple; bh=dpVa7G479zxsvMr8u2zWcCsIj7wH+o97XdcxaHwbASo=; h=Date:From:To:Cc:Subject:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=LZCactLskIw6AZNGTVwCcESgLYlOzh3U1nKLAdVGfSefKw+vDGWxxGj+ny5O15xPFbgpGs1KICyEFH+bpJ13yyIShm3n4RRVoJj6k9Im9tWk6zNAqv/zdLrYvnTFPjmwrBuvuqdLYRLVjp3UY1hrAXhbZe0mbod3YsUpk8v4uRs= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=bootlin.com; spf=pass smtp.mailfrom=bootlin.com; dkim=pass (2048-bit key) header.d=bootlin.com header.i=@bootlin.com header.b=QAOn2Mmo; arc=none smtp.client-ip=217.70.183.199 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=bootlin.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=bootlin.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=bootlin.com header.i=@bootlin.com header.b="QAOn2Mmo" Received: by mail.gandi.net (Postfix) with ESMTPSA id A6BAAFF804; Thu, 16 May 2024 12:56:43 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bootlin.com; s=gm1; t=1715864205; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=8Z2vq8zelYK0GvD16zOjZ/AuXmOgHF5RsOMoLyDARYQ=; b=QAOn2Mmo7PWCvAXA/J6U2vsbOs7+WF0cMtVQKyJ3d4HToLFW3Zlujpb/biOv5GJITAoI5z IaE8W2M6g9fZxOu8cWiY1QHWXmq5g8IPZqTUAjS7uH8MWaBLPbhQYajEglVsP5pdBUnC2y cdyG89ud+/zD9GT/mFzu/9LbJoagCgEtFsS+n2taOHEqV/joxujGCS2e98wXAq6B31XPBe s56VppiAhNvQRYXAHX0AkNO5cnJauekFn9DTDdnbuDvtwFFWUp9XxiOmJ1yybVoojedcti l29u7UAW7h4a6xb85GeS37i/pX7JXeD9klAGU20mQu78O70jShUA2mj4V+4RDw== Date: Thu, 16 May 2024 14:56:42 +0200 From: Miquel Raynal To: Md Sadre Alam Cc: broonie@kernel.org, robh@kernel.org, krzk+dt@kernel.org, conor+dt@kernel.org, andersson@kernel.org, konrad.dybcio@linaro.org, richard@nod.at, vigneshr@ti.com, manivannan.sadhasivam@linaro.org, linux-arm-msm@vger.kernel.org, linux-spi@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-mtd@lists.infradead.org, quic_srichara@quicinc.com, quic_varada@quicinc.com, Alexandru Gagniuc Subject: Re: [PATCH v5 5/7] spi: spi-qpic: add driver for QCOM SPI NAND flash Interface Message-ID: <20240516145642.644a7f1c@xps-13> In-Reply-To: <20240508083637.3744003-6-quic_mdalam@quicinc.com> References: <20240508083637.3744003-1-quic_mdalam@quicinc.com> <20240508083637.3744003-6-quic_mdalam@quicinc.com> Organization: Bootlin X-Mailer: Claws Mail 4.1.1 (GTK 3.24.38; x86_64-pc-linux-gnu) Precedence: bulk X-Mailing-List: linux-arm-msm@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: quoted-printable X-GND-Sasl: miquel.raynal@bootlin.com Hi, > --- /dev/null > +++ b/drivers/spi/spi-qpic-snand.c > @@ -0,0 +1,1423 @@ > +/* > + * SPDX-License-Identifier: GPL-2.0 > + * > + * Copyright (c) 2023, Qualcomm Innovation Center, Inc. All rights reser= ved. > + * > + * Authors: > + * Md Sadre Alam > + * Sricharan R > + * Varadarajan Narayanan > + */ > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include Not sure why partitions.h is needed here? > +#include No raw NAND include. > +#include > +#include > +#include > +#include > +#include ... > +static int qcom_spi_ecc_init_ctx_pipelined(struct nand_device *nand) > +{ > + struct qcom_nand_controller *snandc =3D nand_to_qcom_snand(nand); > + struct nand_ecc_props *conf =3D &nand->ecc.ctx.conf; > + struct nand_ecc_props *reqs =3D &nand->ecc.requirements; > + struct nand_ecc_props *user =3D &nand->ecc.user_conf; > + struct mtd_info *mtd =3D nanddev_to_mtd(nand); > + int step_size =3D 0, strength =3D 0, steps; > + int cwperpage, bad_block_byte; > + struct qpic_ecc *ecc_cfg; > + > + cwperpage =3D mtd->writesize / NANDC_STEP_SIZE; > + snandc->num_cw =3D cwperpage; > + > + ecc_cfg =3D kzalloc(sizeof(*ecc_cfg), GFP_KERNEL); > + if (!ecc_cfg) > + return -ENOMEM; > + > + nand->ecc.ctx.priv =3D ecc_cfg; > + > + if (user->step_size && user->strength) { > + step_size =3D user->step_size; > + strength =3D user->strength; > + } else if (reqs->step_size && reqs->strength) { > + step_size =3D reqs->step_size; > + strength =3D reqs->strength; > + } > + > + if (step_size && strength) > + steps =3D mtd->writesize / step_size; > + > + ecc_cfg->ecc_bytes_hw =3D 7; > + ecc_cfg->spare_bytes =3D 4; > + ecc_cfg->bbm_size =3D 1; > + ecc_cfg->bch_enabled =3D true; > + ecc_cfg->bytes =3D ecc_cfg->ecc_bytes_hw + ecc_cfg->spare_bytes + ecc_c= fg->bbm_size; > + > + ecc_cfg->steps =3D 4; > + ecc_cfg->strength =3D 4; > + ecc_cfg->step_size =3D 512; > + > + mtd_set_ooblayout(mtd, &qcom_spi_ooblayout); > + > + ecc_cfg->cw_data =3D 516; > + ecc_cfg->cw_size =3D ecc_cfg->cw_data + ecc_cfg->bytes; > + bad_block_byte =3D mtd->writesize - ecc_cfg->cw_size * (cwperpage - 1) = + 1; > + > + ecc_cfg->cfg0 =3D (cwperpage - 1) << CW_PER_PAGE > + | ecc_cfg->cw_data << UD_SIZE_BYTES > + | 1 << DISABLE_STATUS_AFTER_WRITE > + | 3 << NUM_ADDR_CYCLES > + | ecc_cfg->ecc_bytes_hw << ECC_PARITY_SIZE_BYTES_RS > + | 0 << STATUS_BFR_READ > + | 1 << SET_RD_MODE_AFTER_STATUS > + | ecc_cfg->spare_bytes << SPARE_SIZE_BYTES; Can we please use FIELD_GET/FIELD_SET? Also I think the coding style proposes: val =3D foo | bar; instead of val =3D foo | bar; ... > +static int qcom_spi_write_page_cache(struct qcom_nand_controller *snandc, > + const struct spi_mem_op *op) > +{ > + struct qpic_snand_op s_op =3D {}; > + u32 cmd; > + > + cmd =3D qcom_spi_cmd_mapping(snandc, op->cmd.opcode); > + s_op.cmd_reg =3D cmd; > + > + if (op->cmd.opcode =3D=3D SPINAND_PROGRAM_LOAD) { > + if (snandc->page_rw) > + snandc->data_buf =3D (u8 *)op->data.buf.out; > + if (snandc->oob_rw) > + snandc->oob_buf =3D (u8 *)op->data.buf.out; Quick comment: looks wrong, no? > + } > + > + return 0; > +} > + > +static int qcom_spi_send_cmdaddr(struct qcom_nand_controller *snandc, > + const struct spi_mem_op *op) > +{ > + struct qpic_snand_op s_op =3D {}; > + u32 cmd; > + int ret, opcode; > + > + cmd =3D qcom_spi_cmd_mapping(snandc, op->cmd.opcode); > + > + s_op.cmd_reg =3D cmd; > + s_op.addr1_reg =3D op->addr.val; > + s_op.addr2_reg =3D 0; > + > + opcode =3D op->cmd.opcode; > + > + switch (opcode) { > + case SPINAND_WRITE_EN: > + return 0; > + case SPINAND_PROGRAM_EXECUTE: > + s_op.addr1_reg =3D op->addr.val << 16; > + s_op.addr2_reg =3D op->addr.val >> 16 & 0xff; > + snandc->addr1 =3D s_op.addr1_reg; > + snandc->addr2 =3D s_op.addr2_reg; > + snandc->cmd =3D cmd; > + return qcom_spi_program_execute(snandc, op); > + case SPINAND_READ: > + s_op.addr1_reg =3D (op->addr.val << 16); > + s_op.addr2_reg =3D op->addr.val >> 16 & 0xff; > + snandc->addr1 =3D s_op.addr1_reg; > + snandc->addr2 =3D s_op.addr2_reg; > + snandc->cmd =3D cmd; > + return 0; > + case SPINAND_ERASE: > + s_op.addr2_reg =3D (op->addr.val >> 16) & 0xffff; > + s_op.addr1_reg =3D op->addr.val; > + snandc->addr1 =3D s_op.addr1_reg; > + snandc->addr1 <<=3D 16; Feels wrong as well > + snandc->addr2 =3D s_op.addr2_reg; > + snandc->cmd =3D cmd; > + qcom_spi_block_erase(snandc); > + return 0; > + default: > + break; > + } > + > + snandc->buf_count =3D 0; > + snandc->buf_start =3D 0; > + qcom_clear_read_regs(snandc); > + qcom_clear_bam_transaction(snandc); > + > + snandc->regs->cmd =3D s_op.cmd_reg; > + snandc->regs->exec =3D 1; > + snandc->regs->addr0 =3D s_op.addr1_reg; > + snandc->regs->addr1 =3D s_op.addr2_reg; > + > + qcom_write_reg_dma(snandc, &snandc->regs->cmd, NAND_FLASH_CMD, 3, NAND_= BAM_NEXT_SGL); > + qcom_write_reg_dma(snandc, &snandc->regs->exec, NAND_EXEC_CMD, 1, NAND_= BAM_NEXT_SGL); > + > + ret =3D qcom_submit_descs(snandc); > + if (ret) > + dev_err(snandc->dev, "failure in sbumitting cmd descriptor\n"); > + > + return ret; > +} > + > +static int qcom_spi_io_op(struct qcom_nand_controller *snandc, const str= uct spi_mem_op *op) > +{ > + int ret, val, opcode; > + bool copy =3D false, copy_ftr =3D false; > + > + ret =3D qcom_spi_send_cmdaddr(snandc, op); > + if (ret) > + return ret; > + > + snandc->buf_count =3D 0; > + snandc->buf_start =3D 0; > + qcom_clear_read_regs(snandc); > + qcom_clear_bam_transaction(snandc); > + opcode =3D op->cmd.opcode; > + > + switch (opcode) { > + case SPINAND_READID: > + snandc->buf_count =3D 4; > + qcom_read_reg_dma(snandc, NAND_READ_ID, 1, NAND_BAM_NEXT_SGL); > + copy =3D true; > + break; > + case SPINAND_GET_FEATURE: > + snandc->buf_count =3D 4; > + qcom_read_reg_dma(snandc, NAND_FLASH_FEATURES, 1, NAND_BAM_NEXT_SGL); > + copy_ftr =3D true; > + break; > + case SPINAND_SET_FEATURE: > + snandc->regs->flash_feature =3D *(u32 *)op->data.buf.out; > + qcom_write_reg_dma(snandc, &snandc->regs->flash_feature, > + NAND_FLASH_FEATURES, 1, NAND_BAM_NEXT_SGL); > + break; > + default: > + return 0; No error state? > + } > + > + ret =3D qcom_submit_descs(snandc); > + if (ret) > + dev_err(snandc->dev, "failure in submitting descriptor for:%d\n", opco= de); > + > + if (copy) { > + qcom_nandc_dev_to_mem(snandc, true); > + memcpy(op->data.buf.in, snandc->reg_read_buf, snandc->buf_count); > + } > + > + if (copy_ftr) { > + qcom_nandc_dev_to_mem(snandc, true); > + val =3D le32_to_cpu(*(__le32 *)snandc->reg_read_buf); > + val >>=3D 8; > + memcpy(op->data.buf.in, &val, snandc->buf_count); > + } > + > + return ret; > +} > + > +static bool qcom_spi_is_page_op(const struct spi_mem_op *op) > +{ > + if (op->addr.buswidth !=3D 1 && op->addr.buswidth !=3D 2 && op->addr.bu= swidth !=3D 4) > + return false; > + > + if (op->data.dir =3D=3D SPI_MEM_DATA_IN) { > + if (op->addr.buswidth =3D=3D 4 && op->data.buswidth =3D=3D 4) > + return true; > + > + if (op->addr.nbytes =3D=3D 2 && op->addr.buswidth =3D=3D 1) > + return true; > + > + } else if (op->data.dir =3D=3D SPI_MEM_DATA_OUT) { > + if (op->data.buswidth =3D=3D 4) > + return true; > + if (op->addr.nbytes =3D=3D 2 && op->addr.buswidth =3D=3D 1) > + return true; > + } > + > + return false; > +} > + > +static bool qcom_spi_supports_op(struct spi_mem *mem, const struct spi_m= em_op *op) > +{ > + if (!spi_mem_default_supports_op(mem, op)) > + return false; > + > + if (op->cmd.nbytes !=3D 1 || op->cmd.buswidth !=3D 1) > + return false; > + > + if (qcom_spi_is_page_op(op)) > + return true; > + > + return ((!op->addr.nbytes || op->addr.buswidth =3D=3D 1) && > + (!op->dummy.nbytes || op->dummy.buswidth =3D=3D 1) && > + (!op->data.nbytes || op->data.buswidth =3D=3D 1)); > +} > + > +static int qcom_spi_exec_op(struct spi_mem *mem, const struct spi_mem_op= *op) > +{ > + struct qcom_nand_controller *snandc =3D spi_controller_get_devdata(mem-= >spi->controller); > + > + dev_dbg(snandc->dev, "OP %02x ADDR %08llX@%d:%u DATA %d:%u", op->cmd.op= code, > + op->addr.val, op->addr.buswidth, op->addr.nbytes, > + op->data.buswidth, op->data.nbytes); > + > + if (qcom_spi_is_page_op(op)) { > + if (op->data.dir =3D=3D SPI_MEM_DATA_IN) > + return qcom_spi_read_page_cache(snandc, op); > + if (op->data.dir =3D=3D SPI_MEM_DATA_OUT) > + return qcom_spi_write_page_cache(snandc, op); > + } else { > + return qcom_spi_io_op(snandc, op); > + } > + > + return 0; > +} > + > +static const struct spi_controller_mem_ops qcom_spi_mem_ops =3D { > + .supports_op =3D qcom_spi_supports_op, > + .exec_op =3D qcom_spi_exec_op, > +}; > + > +static const struct spi_controller_mem_caps qcom_spi_mem_caps =3D { > + .ecc =3D true, > +}; > + > +static int qcom_spi_probe(struct platform_device *pdev) > +{ > + struct device *dev =3D &pdev->dev; > + struct spi_controller *ctlr; > + struct qcom_nand_controller *snandc; > + struct resource *res; > + const void *dev_data; > + struct qpic_ecc *ecc; > + int ret; > + > + ecc =3D devm_kzalloc(dev, sizeof(*ecc), GFP_KERNEL); > + if (!ecc) > + return -ENOMEM; > + > + ctlr =3D __devm_spi_alloc_controller(dev, sizeof(*snandc), false); > + if (!ctlr) > + return -ENOMEM; > + > + platform_set_drvdata(pdev, ctlr); > + > + snandc =3D spi_controller_get_devdata(ctlr); > + > + snandc->ctlr =3D ctlr; > + snandc->dev =3D dev; > + snandc->ecc =3D ecc; > + > + snandc->oob_buf =3D devm_kzalloc(dev, OOB_BUF_SIZE, GFP_KERNEL); > + if (!snandc->oob_buf) > + return -ENOMEM; > + > + dev_data =3D of_device_get_match_data(dev); > + if (!dev_data) { > + dev_err(&pdev->dev, "failed to get device data\n"); > + return -ENODEV; > + } > + > + snandc->props =3D dev_data; > + snandc->dev =3D &pdev->dev; > + > + snandc->core_clk =3D devm_clk_get(dev, "core"); > + if (IS_ERR(snandc->core_clk)) > + return PTR_ERR(snandc->core_clk); > + > + snandc->aon_clk =3D devm_clk_get(dev, "aon"); > + if (IS_ERR(snandc->aon_clk)) > + return PTR_ERR(snandc->aon_clk); > + > + snandc->iomacro_clk =3D devm_clk_get(dev, "iom"); > + if (IS_ERR(snandc->iomacro_clk)) > + return PTR_ERR(snandc->iomacro_clk); > + > + snandc->base =3D devm_platform_get_and_ioremap_resource(pdev, 0, &res); > + if (IS_ERR(snandc->base)) > + return PTR_ERR(snandc->base); > + > + snandc->base_phys =3D res->start; > + snandc->base_dma =3D dma_map_resource(dev, res->start, resource_size(re= s), > + DMA_BIDIRECTIONAL, 0); > + if (dma_mapping_error(dev, snandc->base_dma)) > + return -ENXIO; > + > + ret =3D clk_prepare_enable(snandc->core_clk); > + if (ret) > + goto err_core_clk; error labels should point at the next freeing instruction, they should not be named against where they are called. Same below. > + > + ret =3D clk_prepare_enable(snandc->aon_clk); > + if (ret) > + goto err_aon_clk; > + > + ret =3D clk_prepare_enable(snandc->iomacro_clk); > + if (ret) > + goto err_snandc_alloc; This label is really badly named > + > + ret =3D qcom_nandc_alloc(snandc); > + if (ret) > + goto err_iom_clk; goto err_dis_iom_clk; ? > + > + ret =3D qcom_spi_init(snandc); > + if (ret) > + goto err_init; > + > + /* setup ECC engine */ > + snandc->ecc_eng.dev =3D &pdev->dev; > + snandc->ecc_eng.integration =3D NAND_ECC_ENGINE_INTEGRATION_PIPELINED; > + snandc->ecc_eng.ops =3D &qcom_spi_ecc_engine_ops_pipelined; > + snandc->ecc_eng.priv =3D snandc; > + > + ret =3D nand_ecc_register_on_host_hw_engine(&snandc->ecc_eng); > + if (ret) { > + dev_err(&pdev->dev, "failed to register ecc engine.\n"); Maybe you can print the error if we want the dev_err() call to be useful? > + goto err_init; > + } > + > + ctlr->num_chipselect =3D QPIC_QSPI_NUM_CS; > + ctlr->mem_ops =3D &qcom_spi_mem_ops; > + ctlr->mem_caps =3D &qcom_spi_mem_caps; > + ctlr->dev.of_node =3D pdev->dev.of_node; > + ctlr->mode_bits =3D SPI_TX_DUAL | SPI_RX_DUAL | > + SPI_TX_QUAD | SPI_RX_QUAD; > + > + ret =3D spi_register_controller(ctlr); > + if (ret) { > + dev_err(&pdev->dev, "spi_register_controller failed.\n"); > + goto err_init; > + } > + > + return 0; > + > +err_init: > + qcom_nandc_unalloc(snandc); > +err_iom_clk: > + clk_disable_unprepare(snandc->iomacro_clk); > +err_snandc_alloc: > + clk_disable_unprepare(snandc->aon_clk); > +err_aon_clk: > + clk_disable_unprepare(snandc->core_clk); > +err_core_clk: > + dma_unmap_resource(dev, res->start, resource_size(res), > + DMA_BIDIRECTIONAL, 0); > + return ret; > +} > + > +static int qcom_spi_remove(struct platform_device *pdev) > +{ > + struct spi_controller *ctlr =3D platform_get_drvdata(pdev); > + struct qcom_nand_controller *snandc =3D spi_controller_get_devdata(ctlr= ); > + struct resource *res =3D platform_get_resource(pdev, IORESOURCE_MEM, 0); > + > + spi_unregister_controller(ctlr); > + > + clk_disable_unprepare(snandc->aon_clk); > + clk_disable_unprepare(snandc->core_clk); > + clk_disable_unprepare(snandc->iomacro_clk); > + > + dma_unmap_resource(&pdev->dev, snandc->base_dma, resource_size(res), > + DMA_BIDIRECTIONAL, 0); No unalloc? BTW unalloc is a bit weird. "free" or "cleanup" might be better. > + return 0; > +} > + > +static const struct qcom_nandc_props ipq9574_snandc_props =3D { > + .dev_cmd_reg_start =3D 0x7000, > + .supports_bam =3D true, > +}; > + > +static const struct of_device_id qcom_snandc_of_match[] =3D { > + { > + .compatible =3D "qcom,spi-qpic-snand", > + .data =3D &ipq9574_snandc_props, > + }, > + {} > +} > +MODULE_DEVICE_TABLE(of, qcom_snandc_of_match); > + > +static struct platform_driver qcom_spi_driver =3D { > + .driver =3D { > + .name =3D "qcom_snand", > + .of_match_table =3D qcom_snandc_of_match, > + }, > + .probe =3D qcom_spi_probe, > + .remove =3D qcom_spi_remove, > +}; > +module_platform_driver(qcom_spi_driver); > + > +MODULE_DESCRIPTION("SPI driver for QPIC QSPI cores"); > +MODULE_AUTHOR("Md Sadre Alam "); > +MODULE_LICENSE("GPL"); > diff --git a/include/linux/mtd/nand-qpic-common.h b/include/linux/mtd/nan= d-qpic-common.h > index 096c15d3be76..dd2b56125bc1 100644 > --- a/include/linux/mtd/nand-qpic-common.h > +++ b/include/linux/mtd/nand-qpic-common.h > @@ -315,11 +315,56 @@ struct nandc_regs { > __le32 read_location_last1; > __le32 read_location_last2; > __le32 read_location_last3; > + __le32 spi_cfg; > + __le32 num_addr_cycle; > + __le32 busy_wait_cnt; > + __le32 flash_feature; > =20 > __le32 erased_cw_detect_cfg_clr; > __le32 erased_cw_detect_cfg_set; > }; > =20 > +/* > + * ECC state struct > + * @corrected: ECC corrected > + * @bitflips: Max bit flip > + * @failed: ECC failed > + */ > +struct qcom_ecc_stats { > + u32 corrected; > + u32 bitflips; > + u32 failed; > +}; > + > +struct qpic_ecc { > + struct device *dev; > + const struct qpic_ecc_caps *caps; > + struct completion done; > + u32 sectors; > + u8 *eccdata; > + bool use_ecc; > + u32 ecc_modes; > + int ecc_bytes_hw; > + int spare_bytes; > + int bbm_size; > + int ecc_mode; > + int bytes; > + int steps; > + int step_size; > + int strength; > + int cw_size; > + int cw_data; > + u32 cfg0, cfg1; > + u32 cfg0_raw, cfg1_raw; > + u32 ecc_buf_cfg; > + u32 ecc_bch_cfg; > + u32 clrflashstatus; > + u32 clrreadstatus; > + bool bch_enabled; > +}; > + > +struct qpic_ecc; > + > /* > * NAND controller data struct > * > @@ -329,6 +374,7 @@ struct nandc_regs { > * > * @core_clk: controller clock > * @aon_clk: another controller clock > + * @iomacro_clk: io macro clock > * > * @regs: a contiguous chunk of memory for DMA register > * writes. contains the register values to be > @@ -338,6 +384,7 @@ struct nandc_regs { > * initialized via DT match data > * > * @controller: base controller structure > + * @ctlr: spi controller structure > * @host_list: list containing all the chips attached to the > * controller > * > @@ -375,6 +422,7 @@ struct qcom_nand_controller { > =20 > struct clk *core_clk; > struct clk *aon_clk; > + struct clk *iomacro_clk; > =20 > struct nandc_regs *regs; > struct bam_transaction *bam_txn; > @@ -382,6 +430,7 @@ struct qcom_nand_controller { > const struct qcom_nandc_props *props; > =20 > struct nand_controller controller; > + struct spi_controller *ctlr; > struct list_head host_list; > =20 > union { > @@ -418,6 +467,21 @@ struct qcom_nand_controller { > =20 > u32 cmd1, vld; > bool exec_opwrite; > + struct qpic_ecc *ecc; > + struct qcom_ecc_stats ecc_stats; > + struct nand_ecc_engine ecc_eng; > + u8 *data_buf; > + u8 *oob_buf; > + u32 wlen; > + u32 addr1; > + u32 addr2; > + u32 cmd; > + u32 num_cw; > + u32 pagesize; > + bool oob_rw; > + bool page_rw; > + bool raw_rw; > + bool read_last_cw; > }; If all these definitions are only used by the spi controller, I don't see why you want to put them in the common file. Thanks, Miqu=C3=A8l 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 EF17EC25B74 for ; Thu, 16 May 2024 12:57:03 +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:MIME-Version:References:In-Reply-To: Message-ID:Subject:Cc:To:From:Date:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=dcheJBrz2C6J4ecG3ESY7ZI3Mt4f9LFrpRc+DIfMLYc=; b=2oVnW7LhMrNEef vkSjTjkf3U/MCpzuZiVgJ6LKR/tFGJyVqLBb++0C32NyCqUodhGWB98AY8tmgMzNVv6kiUZoHggG2 k7kBlr+1ScTIxotOadVBUfrJIf6m0xrfvtvZ9VCLcR1AjRewWSjKNHsfcNI5rDuVuPwx6+NbUN1Jb 302sEp9fsC6CLWrHGDHOiM+1SyWkg76OUP18k0xtrK8MxBi1h6EoXhhIAt2gIBG434+9ogPSljBZ9 iiE2uLdsJVz7uGdzA+J4L2mFu0tQknVli+WmUpzkdVB/YKqt36oohNguKFUtlpaC+sGu5McXTvRmD 16J+KXW6cUE6jt6bWY8g==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.97.1 #2 (Red Hat Linux)) id 1s7afM-00000004trv-3loR; Thu, 16 May 2024 12:57:00 +0000 Received: from relay9-d.mail.gandi.net ([2001:4b98:dc4:8::229]) by bombadil.infradead.org with esmtps (Exim 4.97.1 #2 (Red Hat Linux)) id 1s7afI-00000004tqY-1Saj for linux-mtd@lists.infradead.org; Thu, 16 May 2024 12:56:58 +0000 Received: by mail.gandi.net (Postfix) with ESMTPSA id A6BAAFF804; Thu, 16 May 2024 12:56:43 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bootlin.com; s=gm1; t=1715864205; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=8Z2vq8zelYK0GvD16zOjZ/AuXmOgHF5RsOMoLyDARYQ=; b=QAOn2Mmo7PWCvAXA/J6U2vsbOs7+WF0cMtVQKyJ3d4HToLFW3Zlujpb/biOv5GJITAoI5z IaE8W2M6g9fZxOu8cWiY1QHWXmq5g8IPZqTUAjS7uH8MWaBLPbhQYajEglVsP5pdBUnC2y cdyG89ud+/zD9GT/mFzu/9LbJoagCgEtFsS+n2taOHEqV/joxujGCS2e98wXAq6B31XPBe s56VppiAhNvQRYXAHX0AkNO5cnJauekFn9DTDdnbuDvtwFFWUp9XxiOmJ1yybVoojedcti l29u7UAW7h4a6xb85GeS37i/pX7JXeD9klAGU20mQu78O70jShUA2mj4V+4RDw== Date: Thu, 16 May 2024 14:56:42 +0200 From: Miquel Raynal To: Md Sadre Alam Cc: broonie@kernel.org, robh@kernel.org, krzk+dt@kernel.org, conor+dt@kernel.org, andersson@kernel.org, konrad.dybcio@linaro.org, richard@nod.at, vigneshr@ti.com, manivannan.sadhasivam@linaro.org, linux-arm-msm@vger.kernel.org, linux-spi@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, linux-mtd@lists.infradead.org, quic_srichara@quicinc.com, quic_varada@quicinc.com, Alexandru Gagniuc Subject: Re: [PATCH v5 5/7] spi: spi-qpic: add driver for QCOM SPI NAND flash Interface Message-ID: <20240516145642.644a7f1c@xps-13> In-Reply-To: <20240508083637.3744003-6-quic_mdalam@quicinc.com> References: <20240508083637.3744003-1-quic_mdalam@quicinc.com> <20240508083637.3744003-6-quic_mdalam@quicinc.com> Organization: Bootlin X-Mailer: Claws Mail 4.1.1 (GTK 3.24.38; x86_64-pc-linux-gnu) MIME-Version: 1.0 X-GND-Sasl: miquel.raynal@bootlin.com X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20240516_055656_710558_2D6E0A17 X-CRM114-Status: GOOD ( 23.11 ) 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 SGksCgo+IC0tLSAvZGV2L251bGwKPiArKysgYi9kcml2ZXJzL3NwaS9zcGktcXBpYy1zbmFuZC5j Cj4gQEAgLTAsMCArMSwxNDIzIEBACj4gKy8qCj4gKyAqIFNQRFgtTGljZW5zZS1JZGVudGlmaWVy OiBHUEwtMi4wCj4gKyAqCj4gKyAqIENvcHlyaWdodCAoYykgMjAyMywgUXVhbGNvbW0gSW5ub3Zh dGlvbiBDZW50ZXIsIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KPiArICoKPiArICogQXV0aG9y czoKPiArICoJTWQgU2FkcmUgQWxhbSA8cXVpY19tZGFsYW1AcXVpY2luYy5jb20+Cj4gKyAqCVNy aWNoYXJhbiBSIDxxdWljX3NyaWNoYXJhQHF1aWNpbmMuY29tPgo+ICsgKglWYXJhZGFyYWphbiBO YXJheWFuYW4gPHF1aWNfdmFyYWRhQHF1aWNpbmMuY29tPgo+ICsgKi8KPiArI2luY2x1ZGUgPGxp bnV4L2JpdG9wcy5oPgo+ICsjaW5jbHVkZSA8bGludXgvY2xrLmg+Cj4gKyNpbmNsdWRlIDxsaW51 eC9kZWxheS5oPgo+ICsjaW5jbHVkZSA8bGludXgvZG1hZW5naW5lLmg+Cj4gKyNpbmNsdWRlIDxs aW51eC9kbWEtbWFwcGluZy5oPgo+ICsjaW5jbHVkZSA8bGludXgvZG1hL3Fjb21fYWRtLmg+Cj4g KyNpbmNsdWRlIDxsaW51eC9kbWEvcWNvbV9iYW1fZG1hLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9t b2R1bGUuaD4KPiArI2luY2x1ZGUgPGxpbnV4L210ZC9wYXJ0aXRpb25zLmg+CgpOb3Qgc3VyZSB3 aHkgcGFydGl0aW9ucy5oIGlzIG5lZWRlZCBoZXJlPwoKPiArI2luY2x1ZGUgPGxpbnV4L210ZC9y YXduYW5kLmg+CgpObyByYXcgTkFORCBpbmNsdWRlLgoKPiArI2luY2x1ZGUgPGxpbnV4L29mLmg+ Cj4gKyNpbmNsdWRlIDxsaW51eC9wbGF0Zm9ybV9kZXZpY2UuaD4KPiArI2luY2x1ZGUgPGxpbnV4 L3NsYWIuaD4KPiArI2luY2x1ZGUgPGxpbnV4L210ZC9uYW5kLXFwaWMtY29tbW9uLmg+Cj4gKyNp bmNsdWRlIDxsaW51eC9tdGQvc3BpbmFuZC5oPgoKLi4uCgo+ICtzdGF0aWMgaW50IHFjb21fc3Bp X2VjY19pbml0X2N0eF9waXBlbGluZWQoc3RydWN0IG5hbmRfZGV2aWNlICpuYW5kKQo+ICt7Cj4g KwlzdHJ1Y3QgcWNvbV9uYW5kX2NvbnRyb2xsZXIgKnNuYW5kYyA9IG5hbmRfdG9fcWNvbV9zbmFu ZChuYW5kKTsKPiArCXN0cnVjdCBuYW5kX2VjY19wcm9wcyAqY29uZiA9ICZuYW5kLT5lY2MuY3R4 LmNvbmY7Cj4gKwlzdHJ1Y3QgbmFuZF9lY2NfcHJvcHMgKnJlcXMgPSAmbmFuZC0+ZWNjLnJlcXVp cmVtZW50czsKPiArCXN0cnVjdCBuYW5kX2VjY19wcm9wcyAqdXNlciA9ICZuYW5kLT5lY2MudXNl cl9jb25mOwo+ICsJc3RydWN0IG10ZF9pbmZvICptdGQgPSBuYW5kZGV2X3RvX210ZChuYW5kKTsK PiArCWludCBzdGVwX3NpemUgPSAwLCBzdHJlbmd0aCA9IDAsIHN0ZXBzOwo+ICsJaW50IGN3cGVy cGFnZSwgYmFkX2Jsb2NrX2J5dGU7Cj4gKwlzdHJ1Y3QgcXBpY19lY2MgKmVjY19jZmc7Cj4gKwo+ ICsJY3dwZXJwYWdlID0gbXRkLT53cml0ZXNpemUgLyBOQU5EQ19TVEVQX1NJWkU7Cj4gKwlzbmFu ZGMtPm51bV9jdyA9IGN3cGVycGFnZTsKPiArCj4gKwllY2NfY2ZnID0ga3phbGxvYyhzaXplb2Yo KmVjY19jZmcpLCBHRlBfS0VSTkVMKTsKPiArCWlmICghZWNjX2NmZykKPiArCQlyZXR1cm4gLUVO T01FTTsKPiArCj4gKwluYW5kLT5lY2MuY3R4LnByaXYgPSBlY2NfY2ZnOwo+ICsKPiArCWlmICh1 c2VyLT5zdGVwX3NpemUgJiYgdXNlci0+c3RyZW5ndGgpIHsKPiArCQlzdGVwX3NpemUgPSB1c2Vy LT5zdGVwX3NpemU7Cj4gKwkJc3RyZW5ndGggPSB1c2VyLT5zdHJlbmd0aDsKPiArCX0gZWxzZSBp ZiAocmVxcy0+c3RlcF9zaXplICYmIHJlcXMtPnN0cmVuZ3RoKSB7Cj4gKwkJc3RlcF9zaXplID0g cmVxcy0+c3RlcF9zaXplOwo+ICsJCXN0cmVuZ3RoID0gcmVxcy0+c3RyZW5ndGg7Cj4gKwl9Cj4g Kwo+ICsJaWYgKHN0ZXBfc2l6ZSAmJiBzdHJlbmd0aCkKPiArCQlzdGVwcyA9IG10ZC0+d3JpdGVz aXplIC8gc3RlcF9zaXplOwo+ICsKPiArCWVjY19jZmctPmVjY19ieXRlc19odyA9IDc7Cj4gKwll Y2NfY2ZnLT5zcGFyZV9ieXRlcyA9IDQ7Cj4gKwllY2NfY2ZnLT5iYm1fc2l6ZSA9IDE7Cj4gKwll Y2NfY2ZnLT5iY2hfZW5hYmxlZCA9IHRydWU7Cj4gKwllY2NfY2ZnLT5ieXRlcyA9IGVjY19jZmct PmVjY19ieXRlc19odyArIGVjY19jZmctPnNwYXJlX2J5dGVzICsgZWNjX2NmZy0+YmJtX3NpemU7 Cj4gKwo+ICsJZWNjX2NmZy0+c3RlcHMgPSA0Owo+ICsJZWNjX2NmZy0+c3RyZW5ndGggPSA0Owo+ ICsJZWNjX2NmZy0+c3RlcF9zaXplID0gNTEyOwo+ICsKPiArCW10ZF9zZXRfb29ibGF5b3V0KG10 ZCwgJnFjb21fc3BpX29vYmxheW91dCk7Cj4gKwo+ICsJZWNjX2NmZy0+Y3dfZGF0YSA9IDUxNjsK PiArCWVjY19jZmctPmN3X3NpemUgPSBlY2NfY2ZnLT5jd19kYXRhICsgZWNjX2NmZy0+Ynl0ZXM7 Cj4gKwliYWRfYmxvY2tfYnl0ZSA9IG10ZC0+d3JpdGVzaXplIC0gZWNjX2NmZy0+Y3dfc2l6ZSAq IChjd3BlcnBhZ2UgLSAxKSArIDE7Cj4gKwo+ICsJZWNjX2NmZy0+Y2ZnMCA9IChjd3BlcnBhZ2Ug LSAxKSA8PCBDV19QRVJfUEFHRQo+ICsJCQkJfCBlY2NfY2ZnLT5jd19kYXRhIDw8IFVEX1NJWkVf QllURVMKPiArCQkJCXwgMSA8PCBESVNBQkxFX1NUQVRVU19BRlRFUl9XUklURQo+ICsJCQkJfCAz IDw8IE5VTV9BRERSX0NZQ0xFUwo+ICsJCQkJfCBlY2NfY2ZnLT5lY2NfYnl0ZXNfaHcgPDwgRUND X1BBUklUWV9TSVpFX0JZVEVTX1JTCj4gKwkJCQl8IDAgPDwgU1RBVFVTX0JGUl9SRUFECj4gKwkJ CQl8IDEgPDwgU0VUX1JEX01PREVfQUZURVJfU1RBVFVTCj4gKwkJCQl8IGVjY19jZmctPnNwYXJl X2J5dGVzIDw8IFNQQVJFX1NJWkVfQllURVM7CgpDYW4gd2UgcGxlYXNlIHVzZSBGSUVMRF9HRVQv RklFTERfU0VUPwoKQWxzbyBJIHRoaW5rIHRoZSBjb2Rpbmcgc3R5bGUgcHJvcG9zZXM6CgoJdmFs ID0gZm9vIHwKCSAgICAgIGJhcjsKCmluc3RlYWQgb2YKCgl2YWwgPSBmb28KCSAJfCBiYXI7CgoK Li4uCgo+ICtzdGF0aWMgaW50IHFjb21fc3BpX3dyaXRlX3BhZ2VfY2FjaGUoc3RydWN0IHFjb21f bmFuZF9jb250cm9sbGVyICpzbmFuZGMsCj4gKwkJCQkgICAgIGNvbnN0IHN0cnVjdCBzcGlfbWVt X29wICpvcCkKPiArewo+ICsJc3RydWN0IHFwaWNfc25hbmRfb3Agc19vcCA9IHt9Owo+ICsJdTMy IGNtZDsKPiArCj4gKwljbWQgPSBxY29tX3NwaV9jbWRfbWFwcGluZyhzbmFuZGMsIG9wLT5jbWQu b3Bjb2RlKTsKPiArCXNfb3AuY21kX3JlZyA9IGNtZDsKPiArCj4gKwlpZiAob3AtPmNtZC5vcGNv ZGUgPT0gU1BJTkFORF9QUk9HUkFNX0xPQUQpIHsKPiArCQlpZiAoc25hbmRjLT5wYWdlX3J3KQo+ ICsJCQlzbmFuZGMtPmRhdGFfYnVmID0gKHU4ICopb3AtPmRhdGEuYnVmLm91dDsKPiArCQlpZiAo c25hbmRjLT5vb2JfcncpCj4gKwkJCXNuYW5kYy0+b29iX2J1ZiA9ICh1OCAqKW9wLT5kYXRhLmJ1 Zi5vdXQ7CgpRdWljayBjb21tZW50OiBsb29rcyB3cm9uZywgbm8/Cgo+ICsJfQo+ICsKPiArCXJl dHVybiAwOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IHFjb21fc3BpX3NlbmRfY21kYWRkcihzdHJ1 Y3QgcWNvbV9uYW5kX2NvbnRyb2xsZXIgKnNuYW5kYywKPiArCQkJCSBjb25zdCBzdHJ1Y3Qgc3Bp X21lbV9vcCAqb3ApCj4gK3sKPiArCXN0cnVjdCBxcGljX3NuYW5kX29wIHNfb3AgPSB7fTsKPiAr CXUzMiBjbWQ7Cj4gKwlpbnQgcmV0LCBvcGNvZGU7Cj4gKwo+ICsJY21kID0gcWNvbV9zcGlfY21k X21hcHBpbmcoc25hbmRjLCBvcC0+Y21kLm9wY29kZSk7Cj4gKwo+ICsJc19vcC5jbWRfcmVnID0g Y21kOwo+ICsJc19vcC5hZGRyMV9yZWcgPSBvcC0+YWRkci52YWw7Cj4gKwlzX29wLmFkZHIyX3Jl ZyA9IDA7Cj4gKwo+ICsJb3Bjb2RlID0gb3AtPmNtZC5vcGNvZGU7Cj4gKwo+ICsJc3dpdGNoIChv cGNvZGUpIHsKPiArCWNhc2UgU1BJTkFORF9XUklURV9FTjoKPiArCQlyZXR1cm4gMDsKPiArCWNh c2UgU1BJTkFORF9QUk9HUkFNX0VYRUNVVEU6Cj4gKwkJc19vcC5hZGRyMV9yZWcgPSBvcC0+YWRk ci52YWwgPDwgMTY7Cj4gKwkJc19vcC5hZGRyMl9yZWcgPSBvcC0+YWRkci52YWwgPj4gMTYgJiAw eGZmOwo+ICsJCXNuYW5kYy0+YWRkcjEgPSBzX29wLmFkZHIxX3JlZzsKPiArCQlzbmFuZGMtPmFk ZHIyID0gc19vcC5hZGRyMl9yZWc7Cj4gKwkJc25hbmRjLT5jbWQgPSBjbWQ7Cj4gKwkJcmV0dXJu IHFjb21fc3BpX3Byb2dyYW1fZXhlY3V0ZShzbmFuZGMsIG9wKTsKPiArCWNhc2UgU1BJTkFORF9S RUFEOgo+ICsJCXNfb3AuYWRkcjFfcmVnID0gKG9wLT5hZGRyLnZhbCA8PCAxNik7Cj4gKwkJc19v cC5hZGRyMl9yZWcgPSBvcC0+YWRkci52YWwgPj4gMTYgJiAweGZmOwo+ICsJCXNuYW5kYy0+YWRk cjEgPSBzX29wLmFkZHIxX3JlZzsKPiArCQlzbmFuZGMtPmFkZHIyID0gc19vcC5hZGRyMl9yZWc7 Cj4gKwkJc25hbmRjLT5jbWQgPSBjbWQ7Cj4gKwkJcmV0dXJuIDA7Cj4gKwljYXNlIFNQSU5BTkRf RVJBU0U6Cj4gKwkJc19vcC5hZGRyMl9yZWcgPSAob3AtPmFkZHIudmFsID4+IDE2KSAmIDB4ZmZm ZjsKPiArCQlzX29wLmFkZHIxX3JlZyA9IG9wLT5hZGRyLnZhbDsKPiArCQlzbmFuZGMtPmFkZHIx ID0gc19vcC5hZGRyMV9yZWc7Cj4gKwkJc25hbmRjLT5hZGRyMSA8PD0gMTY7CgpGZWVscyB3cm9u ZyBhcyB3ZWxsCgo+ICsJCXNuYW5kYy0+YWRkcjIgPSBzX29wLmFkZHIyX3JlZzsKPiArCQlzbmFu ZGMtPmNtZCA9IGNtZDsKPiArCQlxY29tX3NwaV9ibG9ja19lcmFzZShzbmFuZGMpOwo+ICsJCXJl dHVybiAwOwo+ICsJZGVmYXVsdDoKPiArCQlicmVhazsKPiArCX0KPiArCj4gKwlzbmFuZGMtPmJ1 Zl9jb3VudCA9IDA7Cj4gKwlzbmFuZGMtPmJ1Zl9zdGFydCA9IDA7Cj4gKwlxY29tX2NsZWFyX3Jl YWRfcmVncyhzbmFuZGMpOwo+ICsJcWNvbV9jbGVhcl9iYW1fdHJhbnNhY3Rpb24oc25hbmRjKTsK PiArCj4gKwlzbmFuZGMtPnJlZ3MtPmNtZCA9IHNfb3AuY21kX3JlZzsKPiArCXNuYW5kYy0+cmVn cy0+ZXhlYyA9IDE7Cj4gKwlzbmFuZGMtPnJlZ3MtPmFkZHIwID0gc19vcC5hZGRyMV9yZWc7Cj4g KwlzbmFuZGMtPnJlZ3MtPmFkZHIxID0gc19vcC5hZGRyMl9yZWc7Cj4gKwo+ICsJcWNvbV93cml0 ZV9yZWdfZG1hKHNuYW5kYywgJnNuYW5kYy0+cmVncy0+Y21kLCBOQU5EX0ZMQVNIX0NNRCwgMywg TkFORF9CQU1fTkVYVF9TR0wpOwo+ICsJcWNvbV93cml0ZV9yZWdfZG1hKHNuYW5kYywgJnNuYW5k Yy0+cmVncy0+ZXhlYywgTkFORF9FWEVDX0NNRCwgMSwgTkFORF9CQU1fTkVYVF9TR0wpOwo+ICsK PiArCXJldCA9IHFjb21fc3VibWl0X2Rlc2NzKHNuYW5kYyk7Cj4gKwlpZiAocmV0KQo+ICsJCWRl dl9lcnIoc25hbmRjLT5kZXYsICJmYWlsdXJlIGluIHNidW1pdHRpbmcgY21kIGRlc2NyaXB0b3Jc biIpOwo+ICsKPiArCXJldHVybiByZXQ7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgcWNvbV9zcGlf aW9fb3Aoc3RydWN0IHFjb21fbmFuZF9jb250cm9sbGVyICpzbmFuZGMsIGNvbnN0IHN0cnVjdCBz cGlfbWVtX29wICpvcCkKPiArewo+ICsJaW50IHJldCwgdmFsLCBvcGNvZGU7Cj4gKwlib29sIGNv cHkgPSBmYWxzZSwgY29weV9mdHIgPSBmYWxzZTsKPiArCj4gKwlyZXQgPSBxY29tX3NwaV9zZW5k X2NtZGFkZHIoc25hbmRjLCBvcCk7Cj4gKwlpZiAocmV0KQo+ICsJCXJldHVybiByZXQ7Cj4gKwo+ ICsJc25hbmRjLT5idWZfY291bnQgPSAwOwo+ICsJc25hbmRjLT5idWZfc3RhcnQgPSAwOwo+ICsJ cWNvbV9jbGVhcl9yZWFkX3JlZ3Moc25hbmRjKTsKPiArCXFjb21fY2xlYXJfYmFtX3RyYW5zYWN0 aW9uKHNuYW5kYyk7Cj4gKwlvcGNvZGUgPSBvcC0+Y21kLm9wY29kZTsKPiArCj4gKwlzd2l0Y2gg KG9wY29kZSkgewo+ICsJY2FzZSBTUElOQU5EX1JFQURJRDoKPiArCQlzbmFuZGMtPmJ1Zl9jb3Vu dCA9IDQ7Cj4gKwkJcWNvbV9yZWFkX3JlZ19kbWEoc25hbmRjLCBOQU5EX1JFQURfSUQsIDEsIE5B TkRfQkFNX05FWFRfU0dMKTsKPiArCQljb3B5ID0gdHJ1ZTsKPiArCQlicmVhazsKPiArCWNhc2Ug U1BJTkFORF9HRVRfRkVBVFVSRToKPiArCQlzbmFuZGMtPmJ1Zl9jb3VudCA9IDQ7Cj4gKwkJcWNv bV9yZWFkX3JlZ19kbWEoc25hbmRjLCBOQU5EX0ZMQVNIX0ZFQVRVUkVTLCAxLCBOQU5EX0JBTV9O RVhUX1NHTCk7Cj4gKwkJY29weV9mdHIgPSB0cnVlOwo+ICsJCWJyZWFrOwo+ICsJY2FzZSBTUElO QU5EX1NFVF9GRUFUVVJFOgo+ICsJCXNuYW5kYy0+cmVncy0+Zmxhc2hfZmVhdHVyZSA9ICoodTMy ICopb3AtPmRhdGEuYnVmLm91dDsKPiArCQlxY29tX3dyaXRlX3JlZ19kbWEoc25hbmRjLCAmc25h bmRjLT5yZWdzLT5mbGFzaF9mZWF0dXJlLAo+ICsJCQkJICAgTkFORF9GTEFTSF9GRUFUVVJFUywg MSwgTkFORF9CQU1fTkVYVF9TR0wpOwo+ICsJCWJyZWFrOwo+ICsJZGVmYXVsdDoKPiArCQlyZXR1 cm4gMDsKCk5vIGVycm9yIHN0YXRlPwoKPiArCX0KPiArCj4gKwlyZXQgPSBxY29tX3N1Ym1pdF9k ZXNjcyhzbmFuZGMpOwo+ICsJaWYgKHJldCkKPiArCQlkZXZfZXJyKHNuYW5kYy0+ZGV2LCAiZmFp bHVyZSBpbiBzdWJtaXR0aW5nIGRlc2NyaXB0b3IgZm9yOiVkXG4iLCBvcGNvZGUpOwo+ICsKPiAr CWlmIChjb3B5KSB7Cj4gKwkJcWNvbV9uYW5kY19kZXZfdG9fbWVtKHNuYW5kYywgdHJ1ZSk7Cj4g KwkJbWVtY3B5KG9wLT5kYXRhLmJ1Zi5pbiwgc25hbmRjLT5yZWdfcmVhZF9idWYsIHNuYW5kYy0+ YnVmX2NvdW50KTsKPiArCX0KPiArCj4gKwlpZiAoY29weV9mdHIpIHsKPiArCQlxY29tX25hbmRj X2Rldl90b19tZW0oc25hbmRjLCB0cnVlKTsKPiArCQl2YWwgPSBsZTMyX3RvX2NwdSgqKF9fbGUz MiAqKXNuYW5kYy0+cmVnX3JlYWRfYnVmKTsKPiArCQl2YWwgPj49IDg7Cj4gKwkJbWVtY3B5KG9w LT5kYXRhLmJ1Zi5pbiwgJnZhbCwgc25hbmRjLT5idWZfY291bnQpOwo+ICsJfQo+ICsKPiArCXJl dHVybiByZXQ7Cj4gK30KPiArCj4gK3N0YXRpYyBib29sIHFjb21fc3BpX2lzX3BhZ2Vfb3AoY29u c3Qgc3RydWN0IHNwaV9tZW1fb3AgKm9wKQo+ICt7Cj4gKwlpZiAob3AtPmFkZHIuYnVzd2lkdGgg IT0gMSAmJiBvcC0+YWRkci5idXN3aWR0aCAhPSAyICYmIG9wLT5hZGRyLmJ1c3dpZHRoICE9IDQp Cj4gKwkJcmV0dXJuIGZhbHNlOwo+ICsKPiArCWlmIChvcC0+ZGF0YS5kaXIgPT0gU1BJX01FTV9E QVRBX0lOKSB7Cj4gKwkJaWYgKG9wLT5hZGRyLmJ1c3dpZHRoID09IDQgJiYgb3AtPmRhdGEuYnVz d2lkdGggPT0gNCkKPiArCQkJcmV0dXJuIHRydWU7Cj4gKwo+ICsJCWlmIChvcC0+YWRkci5uYnl0 ZXMgPT0gMiAmJiBvcC0+YWRkci5idXN3aWR0aCA9PSAxKQo+ICsJCQlyZXR1cm4gdHJ1ZTsKPiAr Cj4gKwl9IGVsc2UgaWYgKG9wLT5kYXRhLmRpciA9PSBTUElfTUVNX0RBVEFfT1VUKSB7Cj4gKwkJ aWYgKG9wLT5kYXRhLmJ1c3dpZHRoID09IDQpCj4gKwkJCXJldHVybiB0cnVlOwo+ICsJCWlmIChv cC0+YWRkci5uYnl0ZXMgPT0gMiAmJiBvcC0+YWRkci5idXN3aWR0aCA9PSAxKQo+ICsJCQlyZXR1 cm4gdHJ1ZTsKPiArCX0KPiArCj4gKwlyZXR1cm4gZmFsc2U7Cj4gK30KPiArCj4gK3N0YXRpYyBi b29sIHFjb21fc3BpX3N1cHBvcnRzX29wKHN0cnVjdCBzcGlfbWVtICptZW0sIGNvbnN0IHN0cnVj dCBzcGlfbWVtX29wICpvcCkKPiArewo+ICsJaWYgKCFzcGlfbWVtX2RlZmF1bHRfc3VwcG9ydHNf b3AobWVtLCBvcCkpCj4gKwkJcmV0dXJuIGZhbHNlOwo+ICsKPiArCWlmIChvcC0+Y21kLm5ieXRl cyAhPSAxIHx8IG9wLT5jbWQuYnVzd2lkdGggIT0gMSkKPiArCQlyZXR1cm4gZmFsc2U7Cj4gKwo+ ICsJaWYgKHFjb21fc3BpX2lzX3BhZ2Vfb3Aob3ApKQo+ICsJCXJldHVybiB0cnVlOwo+ICsKPiAr CXJldHVybiAoKCFvcC0+YWRkci5uYnl0ZXMgfHwgb3AtPmFkZHIuYnVzd2lkdGggPT0gMSkgJiYK PiArCQkoIW9wLT5kdW1teS5uYnl0ZXMgfHwgb3AtPmR1bW15LmJ1c3dpZHRoID09IDEpICYmCj4g KwkJKCFvcC0+ZGF0YS5uYnl0ZXMgfHwgb3AtPmRhdGEuYnVzd2lkdGggPT0gMSkpOwo+ICt9Cj4g Kwo+ICtzdGF0aWMgaW50IHFjb21fc3BpX2V4ZWNfb3Aoc3RydWN0IHNwaV9tZW0gKm1lbSwgY29u c3Qgc3RydWN0IHNwaV9tZW1fb3AgKm9wKQo+ICt7Cj4gKwlzdHJ1Y3QgcWNvbV9uYW5kX2NvbnRy b2xsZXIgKnNuYW5kYyA9IHNwaV9jb250cm9sbGVyX2dldF9kZXZkYXRhKG1lbS0+c3BpLT5jb250 cm9sbGVyKTsKPiArCj4gKwlkZXZfZGJnKHNuYW5kYy0+ZGV2LCAiT1AgJTAyeCBBRERSICUwOGxs WEAlZDoldSBEQVRBICVkOiV1Iiwgb3AtPmNtZC5vcGNvZGUsCj4gKwkJb3AtPmFkZHIudmFsLCBv cC0+YWRkci5idXN3aWR0aCwgb3AtPmFkZHIubmJ5dGVzLAo+ICsJCW9wLT5kYXRhLmJ1c3dpZHRo LCBvcC0+ZGF0YS5uYnl0ZXMpOwo+ICsKPiArCWlmIChxY29tX3NwaV9pc19wYWdlX29wKG9wKSkg ewo+ICsJCWlmIChvcC0+ZGF0YS5kaXIgPT0gU1BJX01FTV9EQVRBX0lOKQo+ICsJCQlyZXR1cm4g cWNvbV9zcGlfcmVhZF9wYWdlX2NhY2hlKHNuYW5kYywgb3ApOwo+ICsJCWlmIChvcC0+ZGF0YS5k aXIgPT0gU1BJX01FTV9EQVRBX09VVCkKPiArCQkJcmV0dXJuIHFjb21fc3BpX3dyaXRlX3BhZ2Vf Y2FjaGUoc25hbmRjLCBvcCk7Cj4gKwl9IGVsc2Ugewo+ICsJCXJldHVybiBxY29tX3NwaV9pb19v cChzbmFuZGMsIG9wKTsKPiArCX0KPiArCj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiArc3RhdGlj IGNvbnN0IHN0cnVjdCBzcGlfY29udHJvbGxlcl9tZW1fb3BzIHFjb21fc3BpX21lbV9vcHMgPSB7 Cj4gKwkuc3VwcG9ydHNfb3AgPSBxY29tX3NwaV9zdXBwb3J0c19vcCwKPiArCS5leGVjX29wID0g cWNvbV9zcGlfZXhlY19vcCwKPiArfTsKPiArCj4gK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgc3BpX2Nv bnRyb2xsZXJfbWVtX2NhcHMgcWNvbV9zcGlfbWVtX2NhcHMgPSB7Cj4gKwkuZWNjID0gdHJ1ZSwK PiArfTsKPiArCj4gK3N0YXRpYyBpbnQgcWNvbV9zcGlfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2Rl dmljZSAqcGRldikKPiArewo+ICsJc3RydWN0IGRldmljZSAqZGV2ID0gJnBkZXYtPmRldjsKPiAr CXN0cnVjdCBzcGlfY29udHJvbGxlciAqY3RscjsKPiArCXN0cnVjdCBxY29tX25hbmRfY29udHJv bGxlciAqc25hbmRjOwo+ICsJc3RydWN0IHJlc291cmNlICpyZXM7Cj4gKwljb25zdCB2b2lkICpk ZXZfZGF0YTsKPiArCXN0cnVjdCBxcGljX2VjYyAqZWNjOwo+ICsJaW50IHJldDsKPiArCj4gKwll Y2MgPSBkZXZtX2t6YWxsb2MoZGV2LCBzaXplb2YoKmVjYyksIEdGUF9LRVJORUwpOwo+ICsJaWYg KCFlY2MpCj4gKwkJcmV0dXJuIC1FTk9NRU07Cj4gKwo+ICsJY3RsciA9IF9fZGV2bV9zcGlfYWxs b2NfY29udHJvbGxlcihkZXYsIHNpemVvZigqc25hbmRjKSwgZmFsc2UpOwo+ICsJaWYgKCFjdGxy KQo+ICsJCXJldHVybiAtRU5PTUVNOwo+ICsKPiArCXBsYXRmb3JtX3NldF9kcnZkYXRhKHBkZXYs IGN0bHIpOwo+ICsKPiArCXNuYW5kYyA9IHNwaV9jb250cm9sbGVyX2dldF9kZXZkYXRhKGN0bHIp Owo+ICsKPiArCXNuYW5kYy0+Y3RsciA9IGN0bHI7Cj4gKwlzbmFuZGMtPmRldiA9IGRldjsKPiAr CXNuYW5kYy0+ZWNjID0gZWNjOwo+ICsKPiArCXNuYW5kYy0+b29iX2J1ZiA9IGRldm1fa3phbGxv YyhkZXYsIE9PQl9CVUZfU0laRSwgR0ZQX0tFUk5FTCk7Cj4gKwlpZiAoIXNuYW5kYy0+b29iX2J1 ZikKPiArCQlyZXR1cm4gLUVOT01FTTsKPiArCj4gKwlkZXZfZGF0YSA9IG9mX2RldmljZV9nZXRf bWF0Y2hfZGF0YShkZXYpOwo+ICsJaWYgKCFkZXZfZGF0YSkgewo+ICsJCWRldl9lcnIoJnBkZXYt PmRldiwgImZhaWxlZCB0byBnZXQgZGV2aWNlIGRhdGFcbiIpOwo+ICsJCXJldHVybiAtRU5PREVW Owo+ICsJfQo+ICsKPiArCXNuYW5kYy0+cHJvcHMgPSBkZXZfZGF0YTsKPiArCXNuYW5kYy0+ZGV2 ID0gJnBkZXYtPmRldjsKPiArCj4gKwlzbmFuZGMtPmNvcmVfY2xrID0gZGV2bV9jbGtfZ2V0KGRl diwgImNvcmUiKTsKPiArCWlmIChJU19FUlIoc25hbmRjLT5jb3JlX2NsaykpCj4gKwkJcmV0dXJu IFBUUl9FUlIoc25hbmRjLT5jb3JlX2Nsayk7Cj4gKwo+ICsJc25hbmRjLT5hb25fY2xrID0gZGV2 bV9jbGtfZ2V0KGRldiwgImFvbiIpOwo+ICsJaWYgKElTX0VSUihzbmFuZGMtPmFvbl9jbGspKQo+ ICsJCXJldHVybiBQVFJfRVJSKHNuYW5kYy0+YW9uX2Nsayk7Cj4gKwo+ICsJc25hbmRjLT5pb21h Y3JvX2NsayA9IGRldm1fY2xrX2dldChkZXYsICJpb20iKTsKPiArCWlmIChJU19FUlIoc25hbmRj LT5pb21hY3JvX2NsaykpCj4gKwkJcmV0dXJuIFBUUl9FUlIoc25hbmRjLT5pb21hY3JvX2Nsayk7 Cj4gKwo+ICsJc25hbmRjLT5iYXNlID0gZGV2bV9wbGF0Zm9ybV9nZXRfYW5kX2lvcmVtYXBfcmVz b3VyY2UocGRldiwgMCwgJnJlcyk7Cj4gKwlpZiAoSVNfRVJSKHNuYW5kYy0+YmFzZSkpCj4gKwkJ cmV0dXJuIFBUUl9FUlIoc25hbmRjLT5iYXNlKTsKPiArCj4gKwlzbmFuZGMtPmJhc2VfcGh5cyA9 IHJlcy0+c3RhcnQ7Cj4gKwlzbmFuZGMtPmJhc2VfZG1hID0gZG1hX21hcF9yZXNvdXJjZShkZXYs IHJlcy0+c3RhcnQsIHJlc291cmNlX3NpemUocmVzKSwKPiArCQkJCQkgICAgRE1BX0JJRElSRUNU SU9OQUwsIDApOwo+ICsJaWYgKGRtYV9tYXBwaW5nX2Vycm9yKGRldiwgc25hbmRjLT5iYXNlX2Rt YSkpCj4gKwkJcmV0dXJuIC1FTlhJTzsKPiArCj4gKwlyZXQgPSBjbGtfcHJlcGFyZV9lbmFibGUo c25hbmRjLT5jb3JlX2Nsayk7Cj4gKwlpZiAocmV0KQo+ICsJCWdvdG8gZXJyX2NvcmVfY2xrOwoK ZXJyb3IgbGFiZWxzIHNob3VsZCBwb2ludCBhdCB0aGUgbmV4dCBmcmVlaW5nIGluc3RydWN0aW9u LCB0aGV5IHNob3VsZApub3QgYmUgbmFtZWQgYWdhaW5zdCB3aGVyZSB0aGV5IGFyZSBjYWxsZWQu CgpTYW1lIGJlbG93LgoKPiArCj4gKwlyZXQgPSBjbGtfcHJlcGFyZV9lbmFibGUoc25hbmRjLT5h b25fY2xrKTsKPiArCWlmIChyZXQpCj4gKwkJZ290byBlcnJfYW9uX2NsazsKPiArCj4gKwlyZXQg PSBjbGtfcHJlcGFyZV9lbmFibGUoc25hbmRjLT5pb21hY3JvX2Nsayk7Cj4gKwlpZiAocmV0KQo+ ICsJCWdvdG8gZXJyX3NuYW5kY19hbGxvYzsKClRoaXMgbGFiZWwgaXMgcmVhbGx5IGJhZGx5IG5h bWVkCgo+ICsKPiArCXJldCA9IHFjb21fbmFuZGNfYWxsb2Moc25hbmRjKTsKPiArCWlmIChyZXQp Cj4gKwkJZ290byBlcnJfaW9tX2NsazsKCgkJZ290byBlcnJfZGlzX2lvbV9jbGs7ID8KCj4gKwo+ ICsJcmV0ID0gcWNvbV9zcGlfaW5pdChzbmFuZGMpOwo+ICsJaWYgKHJldCkKPiArCQlnb3RvIGVy cl9pbml0Owo+ICsKPiArCS8qIHNldHVwIEVDQyBlbmdpbmUgKi8KPiArCXNuYW5kYy0+ZWNjX2Vu Zy5kZXYgPSAmcGRldi0+ZGV2Owo+ICsJc25hbmRjLT5lY2NfZW5nLmludGVncmF0aW9uID0gTkFO RF9FQ0NfRU5HSU5FX0lOVEVHUkFUSU9OX1BJUEVMSU5FRDsKPiArCXNuYW5kYy0+ZWNjX2VuZy5v cHMgPSAmcWNvbV9zcGlfZWNjX2VuZ2luZV9vcHNfcGlwZWxpbmVkOwo+ICsJc25hbmRjLT5lY2Nf ZW5nLnByaXYgPSBzbmFuZGM7Cj4gKwo+ICsJcmV0ID0gbmFuZF9lY2NfcmVnaXN0ZXJfb25faG9z dF9od19lbmdpbmUoJnNuYW5kYy0+ZWNjX2VuZyk7Cj4gKwlpZiAocmV0KSB7Cj4gKwkJZGV2X2Vy cigmcGRldi0+ZGV2LCAiZmFpbGVkIHRvIHJlZ2lzdGVyIGVjYyBlbmdpbmUuXG4iKTsKCk1heWJl IHlvdSBjYW4gcHJpbnQgdGhlIGVycm9yIGlmIHdlIHdhbnQgdGhlIGRldl9lcnIoKSBjYWxsIHRv IGJlCnVzZWZ1bD8KCj4gKwkJZ290byBlcnJfaW5pdDsKPiArCX0KPiArCj4gKwljdGxyLT5udW1f Y2hpcHNlbGVjdCA9IFFQSUNfUVNQSV9OVU1fQ1M7Cj4gKwljdGxyLT5tZW1fb3BzID0gJnFjb21f c3BpX21lbV9vcHM7Cj4gKwljdGxyLT5tZW1fY2FwcyA9ICZxY29tX3NwaV9tZW1fY2FwczsKPiAr CWN0bHItPmRldi5vZl9ub2RlID0gcGRldi0+ZGV2Lm9mX25vZGU7Cj4gKwljdGxyLT5tb2RlX2Jp dHMgPSBTUElfVFhfRFVBTCB8IFNQSV9SWF9EVUFMIHwKPiArCQkJICAgIFNQSV9UWF9RVUFEIHwg U1BJX1JYX1FVQUQ7Cj4gKwo+ICsJcmV0ID0gc3BpX3JlZ2lzdGVyX2NvbnRyb2xsZXIoY3Rscik7 Cj4gKwlpZiAocmV0KSB7Cj4gKwkJZGV2X2VycigmcGRldi0+ZGV2LCAic3BpX3JlZ2lzdGVyX2Nv bnRyb2xsZXIgZmFpbGVkLlxuIik7Cj4gKwkJZ290byBlcnJfaW5pdDsKPiArCX0KPiArCj4gKwly ZXR1cm4gMDsKPiArCj4gK2Vycl9pbml0Ogo+ICsJcWNvbV9uYW5kY191bmFsbG9jKHNuYW5kYyk7 Cj4gK2Vycl9pb21fY2xrOgo+ICsJY2xrX2Rpc2FibGVfdW5wcmVwYXJlKHNuYW5kYy0+aW9tYWNy b19jbGspOwo+ICtlcnJfc25hbmRjX2FsbG9jOgo+ICsJY2xrX2Rpc2FibGVfdW5wcmVwYXJlKHNu YW5kYy0+YW9uX2Nsayk7Cj4gK2Vycl9hb25fY2xrOgo+ICsJY2xrX2Rpc2FibGVfdW5wcmVwYXJl KHNuYW5kYy0+Y29yZV9jbGspOwo+ICtlcnJfY29yZV9jbGs6Cj4gKwlkbWFfdW5tYXBfcmVzb3Vy Y2UoZGV2LCByZXMtPnN0YXJ0LCByZXNvdXJjZV9zaXplKHJlcyksCj4gKwkJCSAgIERNQV9CSURJ UkVDVElPTkFMLCAwKTsKPiArCXJldHVybiByZXQ7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgcWNv bV9zcGlfcmVtb3ZlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCj4gK3sKPiArCXN0cnVj dCBzcGlfY29udHJvbGxlciAqY3RsciA9IHBsYXRmb3JtX2dldF9kcnZkYXRhKHBkZXYpOwo+ICsJ c3RydWN0IHFjb21fbmFuZF9jb250cm9sbGVyICpzbmFuZGMgPSBzcGlfY29udHJvbGxlcl9nZXRf ZGV2ZGF0YShjdGxyKTsKPiArCXN0cnVjdCByZXNvdXJjZSAqcmVzID0gcGxhdGZvcm1fZ2V0X3Jl c291cmNlKHBkZXYsIElPUkVTT1VSQ0VfTUVNLCAwKTsKPiArCj4gKwlzcGlfdW5yZWdpc3Rlcl9j b250cm9sbGVyKGN0bHIpOwo+ICsKPiArCWNsa19kaXNhYmxlX3VucHJlcGFyZShzbmFuZGMtPmFv bl9jbGspOwo+ICsJY2xrX2Rpc2FibGVfdW5wcmVwYXJlKHNuYW5kYy0+Y29yZV9jbGspOwo+ICsJ Y2xrX2Rpc2FibGVfdW5wcmVwYXJlKHNuYW5kYy0+aW9tYWNyb19jbGspOwo+ICsKPiArCWRtYV91 bm1hcF9yZXNvdXJjZSgmcGRldi0+ZGV2LCBzbmFuZGMtPmJhc2VfZG1hLCByZXNvdXJjZV9zaXpl KHJlcyksCj4gKwkJCSAgIERNQV9CSURJUkVDVElPTkFMLCAwKTsKCk5vIHVuYWxsb2M/CgpCVFcg dW5hbGxvYyBpcyBhIGJpdCB3ZWlyZC4gImZyZWUiIG9yICJjbGVhbnVwIiBtaWdodCBiZSBiZXR0 ZXIuCgo+ICsJcmV0dXJuIDA7Cj4gK30KPiArCj4gK3N0YXRpYyBjb25zdCBzdHJ1Y3QgcWNvbV9u YW5kY19wcm9wcyBpcHE5NTc0X3NuYW5kY19wcm9wcyA9IHsKPiArCS5kZXZfY21kX3JlZ19zdGFy dCA9IDB4NzAwMCwKPiArCS5zdXBwb3J0c19iYW0gPSB0cnVlLAo+ICt9Owo+ICsKPiArc3RhdGlj IGNvbnN0IHN0cnVjdCBvZl9kZXZpY2VfaWQgcWNvbV9zbmFuZGNfb2ZfbWF0Y2hbXSA9IHsKPiAr CXsKPiArCQkuY29tcGF0aWJsZSA9ICJxY29tLHNwaS1xcGljLXNuYW5kIiwKPiArCQkuZGF0YSA9 ICZpcHE5NTc0X3NuYW5kY19wcm9wcywKPiArCX0sCj4gKwl7fQo+ICt9Cj4gK01PRFVMRV9ERVZJ Q0VfVEFCTEUob2YsIHFjb21fc25hbmRjX29mX21hdGNoKTsKPiArCj4gK3N0YXRpYyBzdHJ1Y3Qg cGxhdGZvcm1fZHJpdmVyIHFjb21fc3BpX2RyaXZlciA9IHsKPiArCS5kcml2ZXIgPSB7Cj4gKwkJ Lm5hbWUJCT0gInFjb21fc25hbmQiLAo+ICsJCS5vZl9tYXRjaF90YWJsZSA9IHFjb21fc25hbmRj X29mX21hdGNoLAo+ICsJfSwKPiArCS5wcm9iZSA9IHFjb21fc3BpX3Byb2JlLAo+ICsJLnJlbW92 ZSA9IHFjb21fc3BpX3JlbW92ZSwKPiArfTsKPiArbW9kdWxlX3BsYXRmb3JtX2RyaXZlcihxY29t X3NwaV9kcml2ZXIpOwo+ICsKPiArTU9EVUxFX0RFU0NSSVBUSU9OKCJTUEkgZHJpdmVyIGZvciBR UElDIFFTUEkgY29yZXMiKTsKPiArTU9EVUxFX0FVVEhPUigiTWQgU2FkcmUgQWxhbSA8cXVpY19t ZGFsYW1AcXVpY2luYy5jb20+Iik7Cj4gK01PRFVMRV9MSUNFTlNFKCJHUEwiKTsKPiBkaWZmIC0t Z2l0IGEvaW5jbHVkZS9saW51eC9tdGQvbmFuZC1xcGljLWNvbW1vbi5oIGIvaW5jbHVkZS9saW51 eC9tdGQvbmFuZC1xcGljLWNvbW1vbi5oCj4gaW5kZXggMDk2YzE1ZDNiZTc2Li5kZDJiNTYxMjVi YzEgMTAwNjQ0Cj4gLS0tIGEvaW5jbHVkZS9saW51eC9tdGQvbmFuZC1xcGljLWNvbW1vbi5oCj4g KysrIGIvaW5jbHVkZS9saW51eC9tdGQvbmFuZC1xcGljLWNvbW1vbi5oCj4gQEAgLTMxNSwxMSAr MzE1LDU2IEBAIHN0cnVjdCBuYW5kY19yZWdzIHsKPiAgCV9fbGUzMiByZWFkX2xvY2F0aW9uX2xh c3QxOwo+ICAJX19sZTMyIHJlYWRfbG9jYXRpb25fbGFzdDI7Cj4gIAlfX2xlMzIgcmVhZF9sb2Nh dGlvbl9sYXN0MzsKPiArCV9fbGUzMiBzcGlfY2ZnOwo+ICsJX19sZTMyIG51bV9hZGRyX2N5Y2xl Owo+ICsJX19sZTMyIGJ1c3lfd2FpdF9jbnQ7Cj4gKwlfX2xlMzIgZmxhc2hfZmVhdHVyZTsKPiAg Cj4gIAlfX2xlMzIgZXJhc2VkX2N3X2RldGVjdF9jZmdfY2xyOwo+ICAJX19sZTMyIGVyYXNlZF9j d19kZXRlY3RfY2ZnX3NldDsKPiAgfTsKPiAgCj4gKy8qCj4gKyAqIEVDQyBzdGF0ZSBzdHJ1Y3QK PiArICogQGNvcnJlY3RlZDoJCUVDQyBjb3JyZWN0ZWQKPiArICogQGJpdGZsaXBzOgkJTWF4IGJp dCBmbGlwCj4gKyAqIEBmYWlsZWQ6CQlFQ0MgZmFpbGVkCj4gKyAqLwo+ICtzdHJ1Y3QgcWNvbV9l Y2Nfc3RhdHMgewo+ICsJdTMyIGNvcnJlY3RlZDsKPiArCXUzMiBiaXRmbGlwczsKPiArCXUzMiBm YWlsZWQ7Cj4gK307Cj4gKwo+ICtzdHJ1Y3QgcXBpY19lY2Mgewo+ICsJc3RydWN0IGRldmljZSAq ZGV2Owo+ICsJY29uc3Qgc3RydWN0IHFwaWNfZWNjX2NhcHMgKmNhcHM7Cj4gKwlzdHJ1Y3QgY29t cGxldGlvbiBkb25lOwo+ICsJdTMyIHNlY3RvcnM7Cj4gKwl1OCAqZWNjZGF0YTsKPiArCWJvb2wg dXNlX2VjYzsKPiArCXUzMiBlY2NfbW9kZXM7Cj4gKwlpbnQgZWNjX2J5dGVzX2h3Owo+ICsJaW50 IHNwYXJlX2J5dGVzOwo+ICsJaW50IGJibV9zaXplOwo+ICsJaW50IGVjY19tb2RlOwo+ICsJaW50 IGJ5dGVzOwo+ICsJaW50IHN0ZXBzOwo+ICsJaW50IHN0ZXBfc2l6ZTsKPiArCWludCBzdHJlbmd0 aDsKPiArCWludCBjd19zaXplOwo+ICsJaW50IGN3X2RhdGE7Cj4gKwl1MzIgY2ZnMCwgY2ZnMTsK PiArCXUzMiBjZmcwX3JhdywgY2ZnMV9yYXc7Cj4gKwl1MzIgZWNjX2J1Zl9jZmc7Cj4gKwl1MzIg ZWNjX2JjaF9jZmc7Cj4gKwl1MzIgY2xyZmxhc2hzdGF0dXM7Cj4gKwl1MzIgY2xycmVhZHN0YXR1 czsKPiArCWJvb2wgYmNoX2VuYWJsZWQ7Cj4gK307Cj4gKwo+ICtzdHJ1Y3QgcXBpY19lY2M7Cj4g Kwo+ICAvKgo+ICAgKiBOQU5EIGNvbnRyb2xsZXIgZGF0YSBzdHJ1Y3QKPiAgICoKPiBAQCAtMzI5 LDYgKzM3NCw3IEBAIHN0cnVjdCBuYW5kY19yZWdzIHsKPiAgICoKPiAgICogQGNvcmVfY2xrOgkJ CWNvbnRyb2xsZXIgY2xvY2sKPiAgICogQGFvbl9jbGs6CQkJYW5vdGhlciBjb250cm9sbGVyIGNs b2NrCj4gKyAqIEBpb21hY3JvX2NsazoJCWlvIG1hY3JvIGNsb2NrCj4gICAqCj4gICAqIEByZWdz OgkJCWEgY29udGlndW91cyBjaHVuayBvZiBtZW1vcnkgZm9yIERNQSByZWdpc3Rlcgo+ICAgKgkJ CQl3cml0ZXMuIGNvbnRhaW5zIHRoZSByZWdpc3RlciB2YWx1ZXMgdG8gYmUKPiBAQCAtMzM4LDYg KzM4NCw3IEBAIHN0cnVjdCBuYW5kY19yZWdzIHsKPiAgICoJCQkJaW5pdGlhbGl6ZWQgdmlhIERU IG1hdGNoIGRhdGEKPiAgICoKPiAgICogQGNvbnRyb2xsZXI6CQkJYmFzZSBjb250cm9sbGVyIHN0 cnVjdHVyZQo+ICsgKiBAY3RscjoJCQlzcGkgY29udHJvbGxlciBzdHJ1Y3R1cmUKPiAgICogQGhv c3RfbGlzdDoJCQlsaXN0IGNvbnRhaW5pbmcgYWxsIHRoZSBjaGlwcyBhdHRhY2hlZCB0byB0aGUK PiAgICoJCQkJY29udHJvbGxlcgo+ICAgKgo+IEBAIC0zNzUsNiArNDIyLDcgQEAgc3RydWN0IHFj b21fbmFuZF9jb250cm9sbGVyIHsKPiAgCj4gIAlzdHJ1Y3QgY2xrICpjb3JlX2NsazsKPiAgCXN0 cnVjdCBjbGsgKmFvbl9jbGs7Cj4gKwlzdHJ1Y3QgY2xrICppb21hY3JvX2NsazsKPiAgCj4gIAlz dHJ1Y3QgbmFuZGNfcmVncyAqcmVnczsKPiAgCXN0cnVjdCBiYW1fdHJhbnNhY3Rpb24gKmJhbV90 eG47Cj4gQEAgLTM4Miw2ICs0MzAsNyBAQCBzdHJ1Y3QgcWNvbV9uYW5kX2NvbnRyb2xsZXIgewo+ ICAJY29uc3Qgc3RydWN0IHFjb21fbmFuZGNfcHJvcHMgKnByb3BzOwo+ICAKPiAgCXN0cnVjdCBu YW5kX2NvbnRyb2xsZXIgY29udHJvbGxlcjsKPiArCXN0cnVjdCBzcGlfY29udHJvbGxlciAqY3Rs cjsKPiAgCXN0cnVjdCBsaXN0X2hlYWQgaG9zdF9saXN0Owo+ICAKPiAgCXVuaW9uIHsKPiBAQCAt NDE4LDYgKzQ2NywyMSBAQCBzdHJ1Y3QgcWNvbV9uYW5kX2NvbnRyb2xsZXIgewo+ICAKPiAgCXUz MiBjbWQxLCB2bGQ7Cj4gIAlib29sIGV4ZWNfb3B3cml0ZTsKPiArCXN0cnVjdCBxcGljX2VjYyAq ZWNjOwo+ICsJc3RydWN0IHFjb21fZWNjX3N0YXRzIGVjY19zdGF0czsKPiArCXN0cnVjdCBuYW5k X2VjY19lbmdpbmUgZWNjX2VuZzsKPiArCXU4ICpkYXRhX2J1ZjsKPiArCXU4ICpvb2JfYnVmOwo+ ICsJdTMyIHdsZW47Cj4gKwl1MzIgYWRkcjE7Cj4gKwl1MzIgYWRkcjI7Cj4gKwl1MzIgY21kOwo+ ICsJdTMyIG51bV9jdzsKPiArCXUzMiBwYWdlc2l6ZTsKPiArCWJvb2wgb29iX3J3Owo+ICsJYm9v bCBwYWdlX3J3Owo+ICsJYm9vbCByYXdfcnc7Cj4gKwlib29sIHJlYWRfbGFzdF9jdzsKPiAgfTsK CklmIGFsbCB0aGVzZSBkZWZpbml0aW9ucyBhcmUgb25seSB1c2VkIGJ5IHRoZSBzcGkgY29udHJv bGxlciwgSSBkb24ndApzZWUgd2h5IHlvdSB3YW50IHRvIHB1dCB0aGVtIGluIHRoZSBjb21tb24g ZmlsZS4KClRoYW5rcywKTWlxdcOobAoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fCkxpbnV4IE1URCBkaXNjdXNzaW9uIG1haWxpbmcgbGlzdApo dHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LW10ZC8K