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 X-Spam-Level: X-Spam-Status: No, score=-9.0 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 5CF41C43381 for ; Tue, 12 Mar 2019 08:47:11 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 029B7214AE for ; Tue, 12 Mar 2019 08:47:11 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=nifty.com header.i=@nifty.com header.b="LoYzANey" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727682AbfCLIrJ (ORCPT ); Tue, 12 Mar 2019 04:47:09 -0400 Received: from conuserg-09.nifty.com ([210.131.2.76]:38193 "EHLO conuserg-09.nifty.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726672AbfCLIrF (ORCPT ); Tue, 12 Mar 2019 04:47:05 -0400 Received: from pug.e01.socionext.com (p14092-ipngnfx01kyoto.kyoto.ocn.ne.jp [153.142.97.92]) (authenticated) by conuserg-09.nifty.com with ESMTP id x2C8j6Zh004092; Tue, 12 Mar 2019 17:45:21 +0900 DKIM-Filter: OpenDKIM Filter v2.10.3 conuserg-09.nifty.com x2C8j6Zh004092 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nifty.com; s=dec2015msa; t=1552380322; bh=+Bp3rUGsngEs4ZclauVLRfxngtYHpkGOee/XpTMXonw=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=LoYzANeydVKqR3fX9kiDC4zTAfYvBCK74CS/bgDXcRJmM/MvHR+GAhx5riysWnh34 ec/n6+CVewNSb3bhfWfyzwCNxww2QM9qAR1/ln62DNK+cNpFJifhf0XQml0W/kZxWY aZJGN/+Ff4yxHiFVv/N+U0MjkLha54eKzENOeEIVrGrvQ55Hg23TNJob5GsQKQi9B5 0sk0yg7OXcV3TFdRIZMBmX7Zzf9sazsZ4lTRZ6wHMpdTgBUXg0kMncNhufLOjpHKyE T+e3b6zg8qp6/WHTNvhmNdDN0tCcTfF4jOcyacJbmjkm451VbfdUveIu+L//4pFTNZ pMqb43MkNX+eA== X-Nifty-SrcIP: [153.142.97.92] From: Masahiro Yamada To: linux-mtd@lists.infradead.org, Miquel Raynal Cc: Boris Brezillon , Masahiro Yamada , devicetree@vger.kernel.org, Brian Norris , linux-kernel@vger.kernel.org, Marek Vasut , Richard Weinberger , David Woodhouse , Rob Herring , Mark Rutland Subject: [PATCH v3 7/9] mtd: rawnand: denali: decouple controller and NAND chips Date: Tue, 12 Mar 2019 17:44:48 +0900 Message-Id: <1552380290-19951-8-git-send-email-yamada.masahiro@socionext.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1552380290-19951-1-git-send-email-yamada.masahiro@socionext.com> References: <1552380290-19951-1-git-send-email-yamada.masahiro@socionext.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Currently, this driver sticks to the legacy NAND model because it was upstreamed before commit 2d472aba15ff ("mtd: nand: document the NAND controller/NAND chip DT representation"). However, relying on the dummy_controller is already deprecated. Switch over to the new controller/chip representation. The struct denali_nand_info has been split into denali_controller and denali_chip, to contain the controller data, per-chip data, respectively. One problem is, this commit changes the DT binding. So, as always, the backward compatibility must be taken into consideration. In the new binding, the controller node expects #address-cells = <1>; #size-cells = <0>; ... since the child nodes represent NAND chips. In the old binding, the controller node may have subnodes, but they are MTD partitions. The denali_dt_is_legacy_binding() exploits it to distinguish old/new platforms. Going forward, the old binding is only allowed for existing DT files. I updated the binding document. Signed-off-by: Masahiro Yamada Acked-by: Rob Herring --- Changes in v3: - simplify mtd->name fallback - Add Rob's Ack Changes in v2: None .../devicetree/bindings/mtd/denali-nand.txt | 39 +- drivers/mtd/nand/raw/denali.c | 441 ++++++++++++--------- drivers/mtd/nand/raw/denali.h | 117 +++++- drivers/mtd/nand/raw/denali_dt.c | 98 ++++- drivers/mtd/nand/raw/denali_pci.c | 30 +- 5 files changed, 488 insertions(+), 237 deletions(-) diff --git a/Documentation/devicetree/bindings/mtd/denali-nand.txt b/Documentation/devicetree/bindings/mtd/denali-nand.txt index f33da87..de4ddff 100644 --- a/Documentation/devicetree/bindings/mtd/denali-nand.txt +++ b/Documentation/devicetree/bindings/mtd/denali-nand.txt @@ -7,34 +7,47 @@ Required properties: "socionext,uniphier-denali-nand-v5b" - for Socionext UniPhier (v5b) - reg : should contain registers location and length for data and reg. - reg-names: Should contain the reg names "nand_data" and "denali_reg" + - #address-cells: should be 1. The cell encodes the chip select connection. + - #size-cells : should be 0. - interrupts : The interrupt number. - clocks: should contain phandle of the controller core clock, the bus interface clock, and the ECC circuit clock. - clock-names: should contain "nand", "nand_x", "ecc" -Optional properties: - - nand-ecc-step-size: see nand.txt for details. If present, the value must be - 512 for "altr,socfpga-denali-nand" - 1024 for "socionext,uniphier-denali-nand-v5a" - 1024 for "socionext,uniphier-denali-nand-v5b" - - nand-ecc-strength: see nand.txt for details. Valid values are: - 8, 15 for "altr,socfpga-denali-nand" - 8, 16, 24 for "socionext,uniphier-denali-nand-v5a" - 8, 16 for "socionext,uniphier-denali-nand-v5b" - - nand-ecc-maximize: see nand.txt for details - -The device tree may optionally contain sub-nodes describing partitions of the +Sub-nodes: + Sub-nodes represent available NAND chips. + + Required properties: + - reg: should contain the bank ID of the controller to which each chip + select is connected. + + Optional properties: + - nand-ecc-step-size: see nand.txt for details. If present, the value must be + 512 for "altr,socfpga-denali-nand" + 1024 for "socionext,uniphier-denali-nand-v5a" + 1024 for "socionext,uniphier-denali-nand-v5b" + - nand-ecc-strength: see nand.txt for details. Valid values are: + 8, 15 for "altr,socfpga-denali-nand" + 8, 16, 24 for "socionext,uniphier-denali-nand-v5a" + 8, 16 for "socionext,uniphier-denali-nand-v5b" + - nand-ecc-maximize: see nand.txt for details + +The chip nodes may optionally contain sub-nodes describing partitions of the address space. See partition.txt for more detail. Examples: nand: nand@ff900000 { #address-cells = <1>; - #size-cells = <1>; + #size-cells = <0>; compatible = "altr,socfpga-denali-nand"; reg = <0xff900000 0x20>, <0xffb80000 0x1000>; reg-names = "nand_data", "denali_reg"; clocks = <&nand_clk>, <&nand_x_clk>, <&nand_ecc_clk>; clock-names = "nand", "nand_x", "ecc"; interrupts = <0 144 4>; + + nand@0 { + reg = <0>; + } }; diff --git a/drivers/mtd/nand/raw/denali.c b/drivers/mtd/nand/raw/denali.c index 05fbe8f..0c47c56 100644 --- a/drivers/mtd/nand/raw/denali.c +++ b/drivers/mtd/nand/raw/denali.c @@ -3,7 +3,7 @@ * NAND Flash Controller Device Driver * Copyright © 2009-2010, Intel Corporation and its suppliers. * - * Copyright (c) 2017 Socionext Inc. + * Copyright (c) 2017-2019 Socionext Inc. * Reworked by Masahiro Yamada */ @@ -42,14 +42,15 @@ #define DENALI_INVALID_BANK -1 #define DENALI_NR_BANKS 4 -static inline struct denali_nand_info *mtd_to_denali(struct mtd_info *mtd) +static struct denali_chip *to_denali_chip(struct nand_chip *chip) { - return container_of(mtd_to_nand(mtd), struct denali_nand_info, nand); + return container_of(chip, struct denali_chip, chip); } -static struct denali_nand_info *to_denali(struct nand_chip *chip) +static struct denali_controller *to_denali_controller(struct nand_chip *chip) { - return container_of(chip, struct denali_nand_info, nand); + return container_of(chip->controller, struct denali_controller, + controller); } /* @@ -57,12 +58,12 @@ static struct denali_nand_info *to_denali(struct nand_chip *chip) * type, bank, block, and page address). The slave data is the actual data to * be transferred. This mode requires 28 bits of address region allocated. */ -static u32 denali_direct_read(struct denali_nand_info *denali, u32 addr) +static u32 denali_direct_read(struct denali_controller *denali, u32 addr) { return ioread32(denali->host + addr); } -static void denali_direct_write(struct denali_nand_info *denali, u32 addr, +static void denali_direct_write(struct denali_controller *denali, u32 addr, u32 data) { iowrite32(data, denali->host + addr); @@ -74,35 +75,20 @@ static void denali_direct_write(struct denali_nand_info *denali, u32 addr, * control information and transferred data are latched by the registers in * the translation module. */ -static u32 denali_indexed_read(struct denali_nand_info *denali, u32 addr) +static u32 denali_indexed_read(struct denali_controller *denali, u32 addr) { iowrite32(addr, denali->host + DENALI_INDEXED_CTRL); return ioread32(denali->host + DENALI_INDEXED_DATA); } -static void denali_indexed_write(struct denali_nand_info *denali, u32 addr, +static void denali_indexed_write(struct denali_controller *denali, u32 addr, u32 data) { iowrite32(addr, denali->host + DENALI_INDEXED_CTRL); iowrite32(data, denali->host + DENALI_INDEXED_DATA); } -/* - * Use the configuration feature register to determine the maximum number of - * banks that the hardware supports. - */ -static void denali_detect_max_banks(struct denali_nand_info *denali) -{ - uint32_t features = ioread32(denali->reg + FEATURES); - - denali->max_banks = 1 << FIELD_GET(FEATURES__N_BANKS, features); - - /* the encoding changed from rev 5.0 to 5.1 */ - if (denali->revision < 0x0501) - denali->max_banks <<= 1; -} - -static void denali_enable_irq(struct denali_nand_info *denali) +static void denali_enable_irq(struct denali_controller *denali) { int i; @@ -111,7 +97,7 @@ static void denali_enable_irq(struct denali_nand_info *denali) iowrite32(GLOBAL_INT_EN_FLAG, denali->reg + GLOBAL_INT_ENABLE); } -static void denali_disable_irq(struct denali_nand_info *denali) +static void denali_disable_irq(struct denali_controller *denali) { int i; @@ -120,14 +106,14 @@ static void denali_disable_irq(struct denali_nand_info *denali) iowrite32(0, denali->reg + GLOBAL_INT_ENABLE); } -static void denali_clear_irq(struct denali_nand_info *denali, +static void denali_clear_irq(struct denali_controller *denali, int bank, uint32_t irq_status) { /* write one to clear bits */ iowrite32(irq_status, denali->reg + INTR_STATUS(bank)); } -static void denali_clear_irq_all(struct denali_nand_info *denali) +static void denali_clear_irq_all(struct denali_controller *denali) { int i; @@ -137,7 +123,7 @@ static void denali_clear_irq_all(struct denali_nand_info *denali) static irqreturn_t denali_isr(int irq, void *dev_id) { - struct denali_nand_info *denali = dev_id; + struct denali_controller *denali = dev_id; irqreturn_t ret = IRQ_NONE; uint32_t irq_status; int i; @@ -165,7 +151,7 @@ static irqreturn_t denali_isr(int irq, void *dev_id) return ret; } -static void denali_reset_irq(struct denali_nand_info *denali) +static void denali_reset_irq(struct denali_controller *denali) { unsigned long flags; @@ -175,8 +161,7 @@ static void denali_reset_irq(struct denali_nand_info *denali) spin_unlock_irqrestore(&denali->irq_lock, flags); } -static uint32_t denali_wait_for_irq(struct denali_nand_info *denali, - uint32_t irq_mask) +static u32 denali_wait_for_irq(struct denali_controller *denali, u32 irq_mask) { unsigned long time_left, flags; uint32_t irq_status; @@ -208,13 +193,45 @@ static uint32_t denali_wait_for_irq(struct denali_nand_info *denali, static void denali_select_target(struct nand_chip *chip, int cs) { - struct denali_nand_info *denali = to_denali(chip); + struct denali_controller *denali = to_denali_controller(chip); + struct denali_chip_sel *sel = &to_denali_chip(chip)->sels[cs]; + struct mtd_info *mtd = nand_to_mtd(chip); + + denali->active_bank = sel->bank; - denali->active_bank = cs; + iowrite32(1 << (chip->phys_erase_shift - chip->page_shift), + denali->reg + PAGES_PER_BLOCK); + iowrite32(chip->options & NAND_BUSWIDTH_16 ? 1 : 0, + denali->reg + DEVICE_WIDTH); + iowrite32(mtd->writesize, denali->reg + DEVICE_MAIN_AREA_SIZE); + iowrite32(mtd->oobsize, denali->reg + DEVICE_SPARE_AREA_SIZE); + iowrite32(chip->options & NAND_ROW_ADDR_3 ? + 0 : TWO_ROW_ADDR_CYCLES__FLAG, + denali->reg + TWO_ROW_ADDR_CYCLES); + iowrite32(FIELD_PREP(ECC_CORRECTION__ERASE_THRESHOLD, 1) | + FIELD_PREP(ECC_CORRECTION__VALUE, chip->ecc.strength), + denali->reg + ECC_CORRECTION); + iowrite32(chip->ecc.size, denali->reg + CFG_DATA_BLOCK_SIZE); + iowrite32(chip->ecc.size, denali->reg + CFG_LAST_DATA_BLOCK_SIZE); + iowrite32(chip->ecc.steps, denali->reg + CFG_NUM_DATA_BLOCKS); + + if (chip->options & NAND_KEEP_TIMINGS) + return; + + /* update timing registers unless NAND_KEEP_TIMINGS is set */ + iowrite32(sel->hwhr2_and_we_2_re, denali->reg + TWHR2_AND_WE_2_RE); + iowrite32(sel->tcwaw_and_addr_2_data, + denali->reg + TCWAW_AND_ADDR_2_DATA); + iowrite32(sel->re_2_we, denali->reg + RE_2_WE); + iowrite32(sel->acc_clks, denali->reg + ACC_CLKS); + iowrite32(sel->rdwr_en_lo_cnt, denali->reg + RDWR_EN_LO_CNT); + iowrite32(sel->rdwr_en_hi_cnt, denali->reg + RDWR_EN_HI_CNT); + iowrite32(sel->cs_setup_cnt, denali->reg + CS_SETUP_CNT); + iowrite32(sel->re_2_re, denali->reg + RE_2_RE); } static int denali_check_erased_page(struct nand_chip *chip, - struct denali_nand_info *denali, u8 *buf, + struct denali_controller *denali, u8 *buf, unsigned long uncor_ecc_flags, unsigned int max_bitflips) { @@ -248,7 +265,7 @@ static int denali_check_erased_page(struct nand_chip *chip, } static int denali_hw_ecc_fixup(struct nand_chip *chip, - struct denali_nand_info *denali, + struct denali_controller *denali, unsigned long *uncor_ecc_flags) { struct mtd_ecc_stats *ecc_stats = &nand_to_mtd(chip)->ecc_stats; @@ -283,7 +300,7 @@ static int denali_hw_ecc_fixup(struct nand_chip *chip, } static int denali_sw_ecc_fixup(struct nand_chip *chip, - struct denali_nand_info *denali, + struct denali_controller *denali, unsigned long *uncor_ecc_flags, uint8_t *buf) { struct mtd_ecc_stats *ecc_stats = &nand_to_mtd(chip)->ecc_stats; @@ -356,7 +373,7 @@ static int denali_sw_ecc_fixup(struct nand_chip *chip, return max_bitflips; } -static void denali_setup_dma64(struct denali_nand_info *denali, +static void denali_setup_dma64(struct denali_controller *denali, dma_addr_t dma_addr, int page, bool write) { uint32_t mode; @@ -381,7 +398,7 @@ static void denali_setup_dma64(struct denali_nand_info *denali, denali->host_write(denali, mode, upper_32_bits(dma_addr)); } -static void denali_setup_dma32(struct denali_nand_info *denali, +static void denali_setup_dma32(struct denali_controller *denali, dma_addr_t dma_addr, int page, bool write) { uint32_t mode; @@ -405,7 +422,7 @@ static void denali_setup_dma32(struct denali_nand_info *denali, denali->host_write(denali, mode | 0x14000, 0x2400); } -static int denali_pio_read(struct denali_nand_info *denali, u32 *buf, +static int denali_pio_read(struct denali_controller *denali, u32 *buf, size_t size, int page) { u32 addr = DENALI_MAP01 | DENALI_BANK(denali) | page; @@ -432,7 +449,7 @@ static int denali_pio_read(struct denali_nand_info *denali, u32 *buf, return irq_status & ecc_err_mask ? -EBADMSG : 0; } -static int denali_pio_write(struct denali_nand_info *denali, const u32 *buf, +static int denali_pio_write(struct denali_controller *denali, const u32 *buf, size_t size, int page) { u32 addr = DENALI_MAP01 | DENALI_BANK(denali) | page; @@ -452,7 +469,7 @@ static int denali_pio_write(struct denali_nand_info *denali, const u32 *buf, return 0; } -static int denali_pio_xfer(struct denali_nand_info *denali, void *buf, +static int denali_pio_xfer(struct denali_controller *denali, void *buf, size_t size, int page, bool write) { if (write) @@ -461,7 +478,7 @@ static int denali_pio_xfer(struct denali_nand_info *denali, void *buf, return denali_pio_read(denali, buf, size, page); } -static int denali_dma_xfer(struct denali_nand_info *denali, void *buf, +static int denali_dma_xfer(struct denali_controller *denali, void *buf, size_t size, int page, bool write) { dma_addr_t dma_addr; @@ -521,7 +538,7 @@ static int denali_dma_xfer(struct denali_nand_info *denali, void *buf, static int denali_data_xfer(struct nand_chip *chip, void *buf, size_t size, int page, bool raw, bool write) { - struct denali_nand_info *denali = to_denali(chip); + struct denali_controller *denali = to_denali_controller(chip); denali_select_target(chip, chip->cur_cs); @@ -554,7 +571,7 @@ typedef int denali_change_column_callback(void *buf, unsigned int offset, static int denali_raw_payload_op(struct nand_chip *chip, void *buf, denali_change_column_callback *cb, void *priv) { - struct denali_nand_info *denali = to_denali(chip); + struct denali_controller *denali = to_denali_controller(chip); struct mtd_info *mtd = nand_to_mtd(chip); struct nand_ecc_ctrl *ecc = &chip->ecc; int writesize = mtd->writesize; @@ -604,7 +621,7 @@ static int denali_raw_payload_op(struct nand_chip *chip, void *buf, static int denali_raw_oob_op(struct nand_chip *chip, void *buf, denali_change_column_callback *cb, void *priv) { - struct denali_nand_info *denali = to_denali(chip); + struct denali_controller *denali = to_denali_controller(chip); struct mtd_info *mtd = nand_to_mtd(chip); struct nand_ecc_ctrl *ecc = &chip->ecc; int writesize = mtd->writesize; @@ -661,9 +678,9 @@ static int denali_memcpy_in(void *buf, unsigned int offset, unsigned int len, static int denali_read_page_raw(struct nand_chip *chip, uint8_t *buf, int oob_required, int page) { - struct denali_nand_info *denali = to_denali(chip); + struct denali_chip *dchip = to_denali_chip(chip); struct mtd_info *mtd = nand_to_mtd(chip); - void *tmp_buf = denali->buf; + void *tmp_buf = dchip->buf; size_t size = mtd->writesize + mtd->oobsize; int ret; @@ -698,9 +715,9 @@ static int denali_memcpy_out(void *buf, unsigned int offset, unsigned int len, static int denali_write_page_raw(struct nand_chip *chip, const uint8_t *buf, int oob_required, int page) { - struct denali_nand_info *denali = to_denali(chip); + struct denali_chip *dchip = to_denali_chip(chip); struct mtd_info *mtd = nand_to_mtd(chip); - void *tmp_buf = denali->buf; + void *tmp_buf = dchip->buf; size_t size = mtd->writesize + mtd->oobsize; int ret; @@ -772,8 +789,8 @@ static int denali_write_oob(struct nand_chip *chip, int page) static int denali_read_page(struct nand_chip *chip, uint8_t *buf, int oob_required, int page) { + struct denali_controller *denali = to_denali_controller(chip); struct mtd_info *mtd = nand_to_mtd(chip); - struct denali_nand_info *denali = mtd_to_denali(mtd); unsigned long uncor_ecc_flags = 0; int stat = 0; int ret; @@ -814,7 +831,8 @@ static int denali_write_page(struct nand_chip *chip, const uint8_t *buf, static int denali_setup_data_interface(struct nand_chip *chip, int chipnr, const struct nand_data_interface *conf) { - struct denali_nand_info *denali = mtd_to_denali(nand_to_mtd(chip)); + struct denali_controller *denali = to_denali_controller(chip); + struct denali_chip_sel *sel; const struct nand_sdr_timings *timings; unsigned long t_x, mult_x; int acc_clks, re_2_we, re_2_re, we_2_re, addr_2_data; @@ -843,6 +861,8 @@ static int denali_setup_data_interface(struct nand_chip *chip, int chipnr, if (chipnr == NAND_DATA_IFACE_CHECK_ONLY) return 0; + sel = &to_denali_chip(chip)->sels[chipnr]; + /* tREA -> ACC_CLKS */ acc_clks = DIV_ROUND_UP(timings->tREA_max, t_x); acc_clks = min_t(int, acc_clks, ACC_CLKS__VALUE); @@ -850,7 +870,7 @@ static int denali_setup_data_interface(struct nand_chip *chip, int chipnr, tmp = ioread32(denali->reg + ACC_CLKS); tmp &= ~ACC_CLKS__VALUE; tmp |= FIELD_PREP(ACC_CLKS__VALUE, acc_clks); - iowrite32(tmp, denali->reg + ACC_CLKS); + sel->acc_clks = tmp; /* tRWH -> RE_2_WE */ re_2_we = DIV_ROUND_UP(timings->tRHW_min, t_x); @@ -859,7 +879,7 @@ static int denali_setup_data_interface(struct nand_chip *chip, int chipnr, tmp = ioread32(denali->reg + RE_2_WE); tmp &= ~RE_2_WE__VALUE; tmp |= FIELD_PREP(RE_2_WE__VALUE, re_2_we); - iowrite32(tmp, denali->reg + RE_2_WE); + sel->re_2_we = tmp; /* tRHZ -> RE_2_RE */ re_2_re = DIV_ROUND_UP(timings->tRHZ_max, t_x); @@ -868,7 +888,7 @@ static int denali_setup_data_interface(struct nand_chip *chip, int chipnr, tmp = ioread32(denali->reg + RE_2_RE); tmp &= ~RE_2_RE__VALUE; tmp |= FIELD_PREP(RE_2_RE__VALUE, re_2_re); - iowrite32(tmp, denali->reg + RE_2_RE); + sel->re_2_re = tmp; /* * tCCS, tWHR -> WE_2_RE @@ -882,7 +902,7 @@ static int denali_setup_data_interface(struct nand_chip *chip, int chipnr, tmp = ioread32(denali->reg + TWHR2_AND_WE_2_RE); tmp &= ~TWHR2_AND_WE_2_RE__WE_2_RE; tmp |= FIELD_PREP(TWHR2_AND_WE_2_RE__WE_2_RE, we_2_re); - iowrite32(tmp, denali->reg + TWHR2_AND_WE_2_RE); + sel->hwhr2_and_we_2_re = tmp; /* tADL -> ADDR_2_DATA */ @@ -897,7 +917,7 @@ static int denali_setup_data_interface(struct nand_chip *chip, int chipnr, tmp = ioread32(denali->reg + TCWAW_AND_ADDR_2_DATA); tmp &= ~TCWAW_AND_ADDR_2_DATA__ADDR_2_DATA; tmp |= FIELD_PREP(TCWAW_AND_ADDR_2_DATA__ADDR_2_DATA, addr_2_data); - iowrite32(tmp, denali->reg + TCWAW_AND_ADDR_2_DATA); + sel->tcwaw_and_addr_2_data = tmp; /* tREH, tWH -> RDWR_EN_HI_CNT */ rdwr_en_hi = DIV_ROUND_UP(max(timings->tREH_min, timings->tWH_min), @@ -907,7 +927,7 @@ static int denali_setup_data_interface(struct nand_chip *chip, int chipnr, tmp = ioread32(denali->reg + RDWR_EN_HI_CNT); tmp &= ~RDWR_EN_HI_CNT__VALUE; tmp |= FIELD_PREP(RDWR_EN_HI_CNT__VALUE, rdwr_en_hi); - iowrite32(tmp, denali->reg + RDWR_EN_HI_CNT); + sel->rdwr_en_hi_cnt = tmp; /* tRP, tWP -> RDWR_EN_LO_CNT */ rdwr_en_lo = DIV_ROUND_UP(max(timings->tRP_min, timings->tWP_min), t_x); @@ -920,7 +940,7 @@ static int denali_setup_data_interface(struct nand_chip *chip, int chipnr, tmp = ioread32(denali->reg + RDWR_EN_LO_CNT); tmp &= ~RDWR_EN_LO_CNT__VALUE; tmp |= FIELD_PREP(RDWR_EN_LO_CNT__VALUE, rdwr_en_lo); - iowrite32(tmp, denali->reg + RDWR_EN_LO_CNT); + sel->rdwr_en_lo_cnt = tmp; /* tCS, tCEA -> CS_SETUP_CNT */ cs_setup = max3((int)DIV_ROUND_UP(timings->tCS_min, t_x) - rdwr_en_lo, @@ -931,39 +951,11 @@ static int denali_setup_data_interface(struct nand_chip *chip, int chipnr, tmp = ioread32(denali->reg + CS_SETUP_CNT); tmp &= ~CS_SETUP_CNT__VALUE; tmp |= FIELD_PREP(CS_SETUP_CNT__VALUE, cs_setup); - iowrite32(tmp, denali->reg + CS_SETUP_CNT); + sel->cs_setup_cnt = tmp; return 0; } -static void denali_hw_init(struct denali_nand_info *denali) -{ - /* - * The REVISION register may not be reliable. Platforms are allowed to - * override it. - */ - if (!denali->revision) - denali->revision = swab16(ioread32(denali->reg + REVISION)); - - /* - * Set how many bytes should be skipped before writing data in OOB. - * If a non-zero value has already been set (by firmware or something), - * just use it. Otherwise, set the driver default. - */ - denali->oob_skip_bytes = ioread32(denali->reg + SPARE_AREA_SKIP_BYTES); - if (!denali->oob_skip_bytes) { - denali->oob_skip_bytes = DENALI_DEFAULT_OOB_SKIP_BYTES; - iowrite32(denali->oob_skip_bytes, - denali->reg + SPARE_AREA_SKIP_BYTES); - } - - denali_detect_max_banks(denali); - iowrite32(0x0F, denali->reg + RB_PIN_ENABLED); - iowrite32(CHIP_EN_DONT_CARE__FLAG, denali->reg + CHIP_ENABLE_DONT_CARE); - - iowrite32(0xffff, denali->reg + SPARE_AREA_MARKER); -} - int denali_calc_ecc_bytes(int step_size, int strength) { /* BCH code. Denali requires ecc.bytes to be multiple of 2 */ @@ -974,10 +966,10 @@ EXPORT_SYMBOL(denali_calc_ecc_bytes); static int denali_ooblayout_ecc(struct mtd_info *mtd, int section, struct mtd_oob_region *oobregion) { - struct denali_nand_info *denali = mtd_to_denali(mtd); struct nand_chip *chip = mtd_to_nand(mtd); + struct denali_controller *denali = to_denali_controller(chip); - if (section) + if (section > 0) return -ERANGE; oobregion->offset = denali->oob_skip_bytes; @@ -989,10 +981,10 @@ static int denali_ooblayout_ecc(struct mtd_info *mtd, int section, static int denali_ooblayout_free(struct mtd_info *mtd, int section, struct mtd_oob_region *oobregion) { - struct denali_nand_info *denali = mtd_to_denali(mtd); struct nand_chip *chip = mtd_to_nand(mtd); + struct denali_controller *denali = to_denali_controller(chip); - if (section) + if (section > 0) return -ERANGE; oobregion->offset = chip->ecc.total + denali->oob_skip_bytes; @@ -1008,7 +1000,7 @@ static const struct mtd_ooblayout_ops denali_ooblayout_ops = { static int denali_multidev_fixup(struct nand_chip *chip) { - struct denali_nand_info *denali = to_denali(chip); + struct denali_controller *denali = to_denali_controller(chip); struct mtd_info *mtd = nand_to_mtd(chip); /* @@ -1059,38 +1051,11 @@ static int denali_multidev_fixup(struct nand_chip *chip) static int denali_attach_chip(struct nand_chip *chip) { + struct denali_controller *denali = to_denali_controller(chip); + struct denali_chip *dchip = to_denali_chip(chip); struct mtd_info *mtd = nand_to_mtd(chip); - struct denali_nand_info *denali = mtd_to_denali(mtd); int ret; - if (ioread32(denali->reg + FEATURES) & FEATURES__DMA) - denali->dma_avail = true; - - if (denali->dma_avail) { - int dma_bit = denali->caps & DENALI_CAP_DMA_64BIT ? 64 : 32; - - ret = dma_set_mask(denali->dev, DMA_BIT_MASK(dma_bit)); - if (ret) { - dev_info(denali->dev, - "Failed to set DMA mask. Disabling DMA.\n"); - denali->dma_avail = false; - } - } - - if (denali->dma_avail) { - chip->options |= NAND_USE_BOUNCE_BUFFER; - chip->buf_align = 16; - if (denali->caps & DENALI_CAP_DMA_64BIT) - denali->setup_dma = denali_setup_dma64; - else - denali->setup_dma = denali_setup_dma32; - } - - chip->bbt_options |= NAND_BBT_USE_FLASH; - chip->bbt_options |= NAND_BBT_NO_OOB; - chip->ecc.mode = NAND_ECC_HW_SYNDROME; - chip->options |= NAND_NO_SUBPAGE_WRITE; - ret = nand_ecc_choose_conf(chip, denali->ecc_caps, mtd->oobsize - denali->oob_skip_bytes); if (ret) { @@ -1102,33 +1067,6 @@ static int denali_attach_chip(struct nand_chip *chip) "chosen ECC settings: step=%d, strength=%d, bytes=%d\n", chip->ecc.size, chip->ecc.strength, chip->ecc.bytes); - iowrite32(FIELD_PREP(ECC_CORRECTION__ERASE_THRESHOLD, 1) | - FIELD_PREP(ECC_CORRECTION__VALUE, chip->ecc.strength), - denali->reg + ECC_CORRECTION); - iowrite32(mtd->erasesize / mtd->writesize, - denali->reg + PAGES_PER_BLOCK); - iowrite32(chip->options & NAND_BUSWIDTH_16 ? 1 : 0, - denali->reg + DEVICE_WIDTH); - iowrite32(chip->options & NAND_ROW_ADDR_3 ? 0 : TWO_ROW_ADDR_CYCLES__FLAG, - denali->reg + TWO_ROW_ADDR_CYCLES); - iowrite32(mtd->writesize, denali->reg + DEVICE_MAIN_AREA_SIZE); - iowrite32(mtd->oobsize, denali->reg + DEVICE_SPARE_AREA_SIZE); - - iowrite32(chip->ecc.size, denali->reg + CFG_DATA_BLOCK_SIZE); - iowrite32(chip->ecc.size, denali->reg + CFG_LAST_DATA_BLOCK_SIZE); - /* chip->ecc.steps is set by nand_scan_tail(); not available here */ - iowrite32(mtd->writesize / chip->ecc.size, - denali->reg + CFG_NUM_DATA_BLOCKS); - - mtd_set_ooblayout(mtd, &denali_ooblayout_ops); - - chip->ecc.read_page = denali_read_page; - chip->ecc.read_page_raw = denali_read_page_raw; - chip->ecc.write_page = denali_write_page; - chip->ecc.write_page_raw = denali_write_page_raw; - chip->ecc.read_oob = denali_read_oob; - chip->ecc.write_oob = denali_write_oob; - ret = denali_multidev_fixup(chip); if (ret) return ret; @@ -1138,8 +1076,8 @@ static int denali_attach_chip(struct nand_chip *chip) * use devm_kmalloc() because the memory allocated by devm_ does not * guarantee DMA-safe alignment. */ - denali->buf = kmalloc(mtd->writesize + mtd->oobsize, GFP_KERNEL); - if (!denali->buf) + dchip->buf = kmalloc(mtd->writesize + mtd->oobsize, GFP_KERNEL); + if (!dchip->buf) return -ENOMEM; return 0; @@ -1147,13 +1085,12 @@ static int denali_attach_chip(struct nand_chip *chip) static void denali_detach_chip(struct nand_chip *chip) { - struct mtd_info *mtd = nand_to_mtd(chip); - struct denali_nand_info *denali = mtd_to_denali(mtd); + struct denali_chip *dchip = to_denali_chip(chip); - kfree(denali->buf); + kfree(dchip->buf); } -static void denali_exec_in8(struct denali_nand_info *denali, u32 type, +static void denali_exec_in8(struct denali_controller *denali, u32 type, u8 *buf, unsigned int len) { int i; @@ -1162,7 +1099,7 @@ static void denali_exec_in8(struct denali_nand_info *denali, u32 type, buf[i] = denali->host_read(denali, type | DENALI_BANK(denali)); } -static void denali_exec_in16(struct denali_nand_info *denali, u32 type, +static void denali_exec_in16(struct denali_controller *denali, u32 type, u8 *buf, unsigned int len) { u32 data; @@ -1176,7 +1113,7 @@ static void denali_exec_in16(struct denali_nand_info *denali, u32 type, } } -static void denali_exec_out8(struct denali_nand_info *denali, u32 type, +static void denali_exec_out8(struct denali_controller *denali, u32 type, const u8 *buf, unsigned int len) { int i; @@ -1185,7 +1122,7 @@ static void denali_exec_out8(struct denali_nand_info *denali, u32 type, denali->host_write(denali, type | DENALI_BANK(denali), buf[i]); } -static void denali_exec_out16(struct denali_nand_info *denali, u32 type, +static void denali_exec_out16(struct denali_controller *denali, u32 type, const u8 *buf, unsigned int len) { int i; @@ -1195,7 +1132,7 @@ static void denali_exec_out16(struct denali_nand_info *denali, u32 type, buf[i + 1] << 16 | buf[i]); } -static int denali_exec_waitrdy(struct denali_nand_info *denali) +static int denali_exec_waitrdy(struct denali_controller *denali) { u32 irq_stat; @@ -1211,7 +1148,7 @@ static int denali_exec_waitrdy(struct denali_nand_info *denali) static int denali_exec_instr(struct nand_chip *chip, const struct nand_op_instr *instr) { - struct denali_nand_info *denali = to_denali(chip); + struct denali_controller *denali = to_denali_controller(chip); bool width16 = chip->options & NAND_BUSWIDTH_16; switch (instr->type) { @@ -1262,7 +1199,7 @@ static int denali_exec_op(struct nand_chip *chip, * Some commands contain NAND_OP_WAITRDY_INSTR. * irq must be cleared here to catch the R/B# interrupt there. */ - denali_reset_irq(to_denali(chip)); + denali_reset_irq(to_denali_controller(chip)); for (i = 0; i < op->ninstrs; i++) { ret = denali_exec_instr(chip, &op->instrs[i]); @@ -1280,53 +1217,80 @@ static const struct nand_controller_ops denali_controller_ops = { .setup_data_interface = denali_setup_data_interface, }; -int denali_init(struct denali_nand_info *denali) +int denali_chip_init(struct denali_controller *denali, + struct denali_chip *dchip) { - struct nand_chip *chip = &denali->nand; + struct nand_chip *chip = &dchip->chip; struct mtd_info *mtd = nand_to_mtd(chip); - u32 features = ioread32(denali->reg + FEATURES); - int ret; + struct denali_chip *dchip2; + int i, j, ret; - mtd->dev.parent = denali->dev; - denali_hw_init(denali); + chip->controller = &denali->controller; - init_completion(&denali->complete); - spin_lock_init(&denali->irq_lock); + /* sanity checks for bank numbers */ + for (i = 0; i < dchip->nsels; i++) { + unsigned int bank = dchip->sels[i].bank; - denali_clear_irq_all(denali); + if (bank >= denali->nbanks) { + dev_err(denali->dev, "unsupported bank %d\n", bank); + return -EINVAL; + } - ret = devm_request_irq(denali->dev, denali->irq, denali_isr, - IRQF_SHARED, DENALI_NAND_NAME, denali); - if (ret) { - dev_err(denali->dev, "Unable to request IRQ\n"); - return ret; - } + for (j = 0; j < i; j++) { + if (bank == dchip->sels[j].bank) { + dev_err(denali->dev, + "bank %d is assigned twice in the same chip\n", + bank); + return -EINVAL; + } + } - denali_enable_irq(denali); + list_for_each_entry(dchip2, &denali->chips, node) { + for (j = 0; j < dchip2->nsels; j++) { + if (bank == dchip2->sels[j].bank) { + dev_err(denali->dev, + "bank %d is already used\n", + bank); + return -EINVAL; + } + } + } + } - denali->active_bank = DENALI_INVALID_BANK; + mtd->dev.parent = denali->dev; - nand_set_flash_node(chip, denali->dev->of_node); - /* Fallback to the default name if DT did not give "label" property */ - if (!mtd->name) + /* + * Fallback to the default name if DT did not give "label" property. + * Use "label" property if multiple chips are connected. + */ + if (!mtd->name && list_empty(&denali->chips)) mtd->name = "denali-nand"; - if (features & FEATURES__INDEX_ADDR) { - denali->host_read = denali_indexed_read; - denali->host_write = denali_indexed_write; - } else { - denali->host_read = denali_direct_read; - denali->host_write = denali_direct_write; + if (denali->dma_avail) { + chip->options |= NAND_USE_BOUNCE_BUFFER; + chip->buf_align = 16; } /* clk rate info is needed for setup_data_interface */ if (!denali->clk_rate || !denali->clk_x_rate) chip->options |= NAND_KEEP_TIMINGS; - chip->legacy.dummy_controller.ops = &denali_controller_ops; - ret = nand_scan(chip, denali->max_banks); + chip->bbt_options |= NAND_BBT_USE_FLASH; + chip->bbt_options |= NAND_BBT_NO_OOB; + chip->options |= NAND_NO_SUBPAGE_WRITE; + chip->ecc.mode = NAND_ECC_HW_SYNDROME; + chip->ecc.read_page = denali_read_page; + chip->ecc.write_page = denali_write_page; + chip->ecc.read_page_raw = denali_read_page_raw; + chip->ecc.write_page_raw = denali_write_page_raw; + chip->ecc.read_oob = denali_read_oob; + chip->ecc.write_oob = denali_write_oob; + + mtd_set_ooblayout(mtd, &denali_ooblayout_ops); + + ret = nand_scan(chip, dchip->nsels); if (ret) - goto disable_irq; + return ret; ret = mtd_device_register(mtd, NULL, 0); if (ret) { @@ -1334,20 +1298,109 @@ int denali_init(struct denali_nand_info *denali) goto cleanup_nand; } + list_add_tail(&dchip->node, &denali->chips); + return 0; cleanup_nand: nand_cleanup(chip); -disable_irq: - denali_disable_irq(denali); return ret; } +EXPORT_SYMBOL_GPL(denali_chip_init); + +int denali_init(struct denali_controller *denali) +{ + u32 features = ioread32(denali->reg + FEATURES); + int ret; + + nand_controller_init(&denali->controller); + denali->controller.ops = &denali_controller_ops; + init_completion(&denali->complete); + spin_lock_init(&denali->irq_lock); + INIT_LIST_HEAD(&denali->chips); + denali->active_bank = DENALI_INVALID_BANK; + + /* + * The REVISION register may not be reliable. Platforms are allowed to + * override it. + */ + if (!denali->revision) + denali->revision = swab16(ioread32(denali->reg + REVISION)); + + denali->nbanks = 1 << FIELD_GET(FEATURES__N_BANKS, features); + + /* the encoding changed from rev 5.0 to 5.1 */ + if (denali->revision < 0x0501) + denali->nbanks <<= 1; + + if (features & FEATURES__DMA) + denali->dma_avail = true; + + if (denali->dma_avail) { + int dma_bit = denali->caps & DENALI_CAP_DMA_64BIT ? 64 : 32; + + ret = dma_set_mask(denali->dev, DMA_BIT_MASK(dma_bit)); + if (ret) { + dev_info(denali->dev, + "Failed to set DMA mask. Disabling DMA.\n"); + denali->dma_avail = false; + } + } + + if (denali->dma_avail) { + if (denali->caps & DENALI_CAP_DMA_64BIT) + denali->setup_dma = denali_setup_dma64; + else + denali->setup_dma = denali_setup_dma32; + } + + if (features & FEATURES__INDEX_ADDR) { + denali->host_read = denali_indexed_read; + denali->host_write = denali_indexed_write; + } else { + denali->host_read = denali_direct_read; + denali->host_write = denali_direct_write; + } + + /* + * Set how many bytes should be skipped before writing data in OOB. + * If a non-zero value has already been set (by firmware or something), + * just use it. Otherwise, set the driver's default. + */ + denali->oob_skip_bytes = ioread32(denali->reg + SPARE_AREA_SKIP_BYTES); + if (!denali->oob_skip_bytes) { + denali->oob_skip_bytes = DENALI_DEFAULT_OOB_SKIP_BYTES; + iowrite32(denali->oob_skip_bytes, + denali->reg + SPARE_AREA_SKIP_BYTES); + } + + iowrite32(GENMASK(denali->nbanks - 1, 0), denali->reg + RB_PIN_ENABLED); + iowrite32(CHIP_EN_DONT_CARE__FLAG, denali->reg + CHIP_ENABLE_DONT_CARE); + iowrite32(0xffff, denali->reg + SPARE_AREA_MARKER); + + denali_clear_irq_all(denali); + + ret = devm_request_irq(denali->dev, denali->irq, denali_isr, + IRQF_SHARED, DENALI_NAND_NAME, denali); + if (ret) { + dev_err(denali->dev, "Unable to request IRQ\n"); + return ret; + } + + denali_enable_irq(denali); + + return 0; +} EXPORT_SYMBOL(denali_init); -void denali_remove(struct denali_nand_info *denali) +void denali_remove(struct denali_controller *denali) { - nand_release(&denali->nand); + struct denali_chip *dchip; + + list_for_each_entry(dchip, &denali->chips, node) + nand_release(&dchip->chip); + denali_disable_irq(denali); } EXPORT_SYMBOL(denali_remove); diff --git a/drivers/mtd/nand/raw/denali.h b/drivers/mtd/nand/raw/denali.h index 8552b3f..138b239 100644 --- a/drivers/mtd/nand/raw/denali.h +++ b/drivers/mtd/nand/raw/denali.h @@ -9,6 +9,7 @@ #include #include +#include #include #include #include @@ -290,30 +291,100 @@ #define CHNL_ACTIVE__CHANNEL2 BIT(2) #define CHNL_ACTIVE__CHANNEL3 BIT(3) -struct denali_nand_info { - struct nand_chip nand; - unsigned long clk_rate; /* core clock rate */ - unsigned long clk_x_rate; /* bus interface clock rate */ - int active_bank; /* currently selected bank */ +/** + * struct denali_chip_sel - per-CS data of Denali NAND + * + * @bank: bank id of the controller this CS is connected to + * @hwhr2_and_we_2_re: value of timing register HWHR2_AND_WE_2_RE + * @tcwaw_and_addr_2_data: value of timing register TCWAW_AND_ADDR_2_DATA + * @re_2_we: value of timing register RE_2_WE + * @acc_clks: value of timing register ACC_CLKS + * @rdwr_en_lo_cnt: value of timing register RDWR_EN_LO_CNT + * @rdwr_en_hi_cnt: value of timing register RDWR_EN_HI_CNT + * @cs_setup_cnt: value of timing register CS_SETUP_CNT + * @re_2_re: value of timing register RE_2_RE + */ +struct denali_chip_sel { + int bank; + u32 hwhr2_and_we_2_re; + u32 tcwaw_and_addr_2_data; + u32 re_2_we; + u32 acc_clks; + u32 rdwr_en_lo_cnt; + u32 rdwr_en_hi_cnt; + u32 cs_setup_cnt; + u32 re_2_re; +}; + +/** + * struct denali_chip - per-chip data of Denali NAND + * + * @chip: base NAND chip structure + * @buf: internal buffer for syndrome layout conversion + * @node: node to be used to associate this chip with the controller + * @nsels: the number of CS lines of this chip + * @sels: the array of per-cs data + */ +struct denali_chip { + struct nand_chip chip; + void *buf; + struct list_head node; + unsigned int nsels; + struct denali_chip_sel sels[0]; +}; + +/** + * struct denali_controller - Denali NAND controller data + * + * @controller: base NAND controller structure + * @dev: device + * @chips: the list of chips attached to this controller + * @clk_rate: frequency of core clock + * @clk_x_rate: frequency of bus interface clock + * @reg: base of Register Interface + * @host: base of Host Data/Command interface + * @complete: completion used to wait for interrupts + * @irq: interrupt number + * @irq_mask: interrupt bits the controller is waiting for + * @irq_status: interrupt bits of events that have happened + * @irq_lock: lock to protect @irq_mask and @irq_status + * @dma_avail: set if DMA engine is available + * @devs_per_cs: number of devices connected in parallel + * @oob_skip_bytes: number of bytes in OOB skipped by the ECC engine + * @active_bank: active bank id + * @nbanks: the number of banks supported by this controller + * @revision: IP revision + * @caps: controller capabilities that cannot be detected run-time + * @ecc_caps: ECC engine capabilities + * @host_read: callback for read access of Host Data/Command Interface + * @host_write: callback for write access of Host Data/Command Interface + * @setup_dma: callback for setup of the Data DMA + */ +struct denali_controller { + struct nand_controller controller; struct device *dev; - void __iomem *reg; /* Register Interface */ - void __iomem *host; /* Host Data/Command Interface */ + struct list_head chips; + unsigned long clk_rate; + unsigned long clk_x_rate; + void __iomem *reg; + void __iomem *host; struct completion complete; - spinlock_t irq_lock; /* protect irq_mask and irq_status */ - u32 irq_mask; /* interrupts we are waiting for */ - u32 irq_status; /* interrupts that have happened */ int irq; - void *buf; /* for syndrome layout conversion */ - bool dma_avail; /* can support DMA? */ - int devs_per_cs; /* devices connected in parallel */ - int oob_skip_bytes; /* number of bytes reserved for BBM */ - int max_banks; - unsigned int revision; /* IP revision */ - unsigned int caps; /* IP capability (or quirk) */ + u32 irq_mask; + u32 irq_status; + spinlock_t irq_lock; + bool dma_avail; + int devs_per_cs; + int oob_skip_bytes; + int active_bank; + int nbanks; + unsigned int revision; + unsigned int caps; const struct nand_ecc_caps *ecc_caps; - u32 (*host_read)(struct denali_nand_info *denali, u32 addr); - void (*host_write)(struct denali_nand_info *denali, u32 addr, u32 data); - void (*setup_dma)(struct denali_nand_info *denali, dma_addr_t dma_addr, + u32 (*host_read)(struct denali_controller *denali, u32 addr); + void (*host_write)(struct denali_controller *denali, u32 addr, + u32 data); + void (*setup_dma)(struct denali_controller *denali, dma_addr_t dma_addr, int page, bool write); }; @@ -321,7 +392,9 @@ struct denali_nand_info { #define DENALI_CAP_DMA_64BIT BIT(1) int denali_calc_ecc_bytes(int step_size, int strength); -int denali_init(struct denali_nand_info *denali); -void denali_remove(struct denali_nand_info *denali); +int denali_chip_init(struct denali_controller *denali, + struct denali_chip *dchip); +int denali_init(struct denali_controller *denali); +void denali_remove(struct denali_controller *denali); #endif /* __DENALI_H__ */ diff --git a/drivers/mtd/nand/raw/denali_dt.c b/drivers/mtd/nand/raw/denali_dt.c index 0b5ae24..5e14836 100644 --- a/drivers/mtd/nand/raw/denali_dt.c +++ b/drivers/mtd/nand/raw/denali_dt.c @@ -18,7 +18,7 @@ #include "denali.h" struct denali_dt { - struct denali_nand_info denali; + struct denali_controller controller; struct clk *clk; /* core clock */ struct clk *clk_x; /* bus interface clock */ struct clk *clk_ecc; /* ECC circuit clock */ @@ -71,19 +71,92 @@ static const struct of_device_id denali_nand_dt_ids[] = { }; MODULE_DEVICE_TABLE(of, denali_nand_dt_ids); +static int denali_dt_chip_init(struct denali_controller *denali, + struct device_node *chip_np) +{ + struct denali_chip *dchip; + u32 bank; + int nsels, i, ret; + + nsels = of_property_count_u32_elems(chip_np, "reg"); + if (nsels < 0) + return nsels; + + dchip = devm_kzalloc(denali->dev, struct_size(dchip, sels, nsels), + GFP_KERNEL); + if (!dchip) + return -ENOMEM; + + dchip->nsels = nsels; + + for (i = 0; i < nsels; i++) { + ret = of_property_read_u32_index(chip_np, "reg", i, &bank); + if (ret) + return ret; + + dchip->sels[i].bank = bank; + + nand_set_flash_node(&dchip->chip, chip_np); + } + + return denali_chip_init(denali, dchip); +} + +/* Backward compatibility for old platforms */ +static int denali_dt_legacy_chip_init(struct denali_controller *denali) +{ + struct denali_chip *dchip; + int nsels, i; + + nsels = denali->nbanks; + + dchip = devm_kzalloc(denali->dev, struct_size(dchip, sels, nsels), + GFP_KERNEL); + if (!dchip) + return -ENOMEM; + + dchip->nsels = nsels; + + for (i = 0; i < nsels; i++) + dchip->sels[i].bank = i; + + nand_set_flash_node(&dchip->chip, denali->dev->of_node); + + return denali_chip_init(denali, dchip); +} + +/* + * Check the DT binding. + * The new binding expects chip subnodes in the controller node. + * So, #address-cells = <1>; #size-cells = <0>; are required. + * Check the #size-cells to distinguish the binding. + */ +static bool denali_dt_is_legacy_binding(struct device_node *np) +{ + u32 cells; + int ret; + + ret = of_property_read_u32(np, "#size-cells", &cells); + if (ret) + return true; + + return cells != 0; +} + static int denali_dt_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct resource *res; struct denali_dt *dt; const struct denali_dt_data *data; - struct denali_nand_info *denali; + struct denali_controller *denali; + struct device_node *np; int ret; dt = devm_kzalloc(dev, sizeof(*dt), GFP_KERNEL); if (!dt) return -ENOMEM; - denali = &dt->denali; + denali = &dt->controller; data = of_device_get_match_data(dev); if (data) { @@ -140,9 +213,26 @@ static int denali_dt_probe(struct platform_device *pdev) if (ret) goto out_disable_clk_ecc; + if (denali_dt_is_legacy_binding(dev->of_node)) { + ret = denali_dt_legacy_chip_init(denali); + if (ret) + goto out_remove_denali; + } else { + for_each_child_of_node(dev->of_node, np) { + ret = denali_dt_chip_init(denali, np); + if (ret) { + of_node_put(np); + goto out_remove_denali; + } + } + } + platform_set_drvdata(pdev, dt); + return 0; +out_remove_denali: + denali_remove(denali); out_disable_clk_ecc: clk_disable_unprepare(dt->clk_ecc); out_disable_clk_x: @@ -157,7 +247,7 @@ static int denali_dt_remove(struct platform_device *pdev) { struct denali_dt *dt = platform_get_drvdata(pdev); - denali_remove(&dt->denali); + denali_remove(&dt->controller); clk_disable_unprepare(dt->clk_ecc); clk_disable_unprepare(dt->clk_x); clk_disable_unprepare(dt->clk); diff --git a/drivers/mtd/nand/raw/denali_pci.c b/drivers/mtd/nand/raw/denali_pci.c index 02eb599..d62aa52 100644 --- a/drivers/mtd/nand/raw/denali_pci.c +++ b/drivers/mtd/nand/raw/denali_pci.c @@ -29,10 +29,11 @@ NAND_ECC_CAPS_SINGLE(denali_pci_ecc_caps, denali_calc_ecc_bytes, 512, 8, 15); static int denali_pci_probe(struct pci_dev *dev, const struct pci_device_id *id) { - int ret; resource_size_t csr_base, mem_base; unsigned long csr_len, mem_len; - struct denali_nand_info *denali; + struct denali_controller *denali; + struct denali_chip *dchip; + int nsels, ret, i; denali = devm_kzalloc(&dev->dev, sizeof(*denali), GFP_KERNEL); if (!denali) @@ -64,7 +65,6 @@ static int denali_pci_probe(struct pci_dev *dev, const struct pci_device_id *id) denali->dev = &dev->dev; denali->irq = dev->irq; denali->ecc_caps = &denali_pci_ecc_caps; - denali->nand.ecc.options |= NAND_ECC_MAXIMIZE; denali->clk_rate = 50000000; /* 50 MHz */ denali->clk_x_rate = 200000000; /* 200 MHz */ @@ -91,10 +91,32 @@ static int denali_pci_probe(struct pci_dev *dev, const struct pci_device_id *id) if (ret) goto out_unmap_host; + nsels = denali->nbanks; + + dchip = devm_kzalloc(denali->dev, struct_size(dchip, sels, nsels), + GFP_KERNEL); + if (!dchip) { + ret = -ENOMEM; + goto out_remove_denali; + } + + dchip->chip.ecc.options |= NAND_ECC_MAXIMIZE; + + dchip->nsels = nsels; + + for (i = 0; i < nsels; i++) + dchip->sels[i].bank = i; + + ret = denali_chip_init(denali, dchip); + if (ret) + goto out_remove_denali; + pci_set_drvdata(dev, denali); return 0; +out_remove_denali: + denali_remove(denali); out_unmap_host: iounmap(denali->host); out_unmap_reg: @@ -104,7 +126,7 @@ static int denali_pci_probe(struct pci_dev *dev, const struct pci_device_id *id) static void denali_pci_remove(struct pci_dev *dev) { - struct denali_nand_info *denali = pci_get_drvdata(dev); + struct denali_controller *denali = pci_get_drvdata(dev); denali_remove(denali); iounmap(denali->reg); -- 2.7.4 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 X-Spam-Level: X-Spam-Status: No, score=-9.0 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id DECDDC43381 for ; Tue, 12 Mar 2019 08:47:15 +0000 (UTC) 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 mail.kernel.org (Postfix) with ESMTPS id AA267214AE for ; Tue, 12 Mar 2019 08:47:15 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="W7nibjMS"; dkim=fail reason="signature verification failed" (2048-bit key) header.d=nifty.com header.i=@nifty.com header.b="LoYzANey" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org AA267214AE Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=socionext.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-mtd-bounces+linux-mtd=archiver.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:Cc:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Message-Id:Date:Subject:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=43nVZQ6NMvVx/QFwhvMKn6j3g3+dCCHHYIyuQmZD1XI=; b=W7nibjMSSUzEVB BD9nooNnpx6ZKuHt2oGkYo4Ytouqg4zCIaBnfDeOAONQZ8Gqbe8sEcXMFRBPLdKLJRDllj0bap/Wo MEDsrp+tFWVx38QqvyhrEo7pdwubLSDEyQ4ujKJAAOOofpSO4jfrBv2WMalwuorn95JYSTTcLdq/a Fl1xWpT4qF4kRsFbNYHhLt3yVYcuNXIzndPjdX0UNMh1uWUFHaOrjKRPe1QNkjOxTV4qUOiPBX3CV xIxCX8jcCmf20eb59ByS1JKdzRsW1kD3T46uMb0XaI7mht/dMQxXmXloBAsqijjpmqUN4uwxZOFd/ Bzr+S8FpOMTHYpA5ch5w==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.90_1 #2 (Red Hat Linux)) id 1h3d43-00026G-Kp; Tue, 12 Mar 2019 08:47:11 +0000 Received: from conuserg-09.nifty.com ([210.131.2.76]) by bombadil.infradead.org with esmtps (Exim 4.90_1 #2 (Red Hat Linux)) id 1h3d2h-00009F-Bg for linux-mtd@lists.infradead.org; Tue, 12 Mar 2019 08:46:07 +0000 Received: from pug.e01.socionext.com (p14092-ipngnfx01kyoto.kyoto.ocn.ne.jp [153.142.97.92]) (authenticated) by conuserg-09.nifty.com with ESMTP id x2C8j6Zh004092; Tue, 12 Mar 2019 17:45:21 +0900 DKIM-Filter: OpenDKIM Filter v2.10.3 conuserg-09.nifty.com x2C8j6Zh004092 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nifty.com; s=dec2015msa; t=1552380322; bh=+Bp3rUGsngEs4ZclauVLRfxngtYHpkGOee/XpTMXonw=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=LoYzANeydVKqR3fX9kiDC4zTAfYvBCK74CS/bgDXcRJmM/MvHR+GAhx5riysWnh34 ec/n6+CVewNSb3bhfWfyzwCNxww2QM9qAR1/ln62DNK+cNpFJifhf0XQml0W/kZxWY aZJGN/+Ff4yxHiFVv/N+U0MjkLha54eKzENOeEIVrGrvQ55Hg23TNJob5GsQKQi9B5 0sk0yg7OXcV3TFdRIZMBmX7Zzf9sazsZ4lTRZ6wHMpdTgBUXg0kMncNhufLOjpHKyE T+e3b6zg8qp6/WHTNvhmNdDN0tCcTfF4jOcyacJbmjkm451VbfdUveIu+L//4pFTNZ pMqb43MkNX+eA== X-Nifty-SrcIP: [153.142.97.92] From: Masahiro Yamada To: linux-mtd@lists.infradead.org, Miquel Raynal Subject: [PATCH v3 7/9] mtd: rawnand: denali: decouple controller and NAND chips Date: Tue, 12 Mar 2019 17:44:48 +0900 Message-Id: <1552380290-19951-8-git-send-email-yamada.masahiro@socionext.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1552380290-19951-1-git-send-email-yamada.masahiro@socionext.com> References: <1552380290-19951-1-git-send-email-yamada.masahiro@socionext.com> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20190312_014547_758563_EF913CA4 X-CRM114-Status: GOOD ( 20.75 ) X-BeenThere: linux-mtd@lists.infradead.org X-Mailman-Version: 2.1.21 Precedence: list List-Id: Linux MTD discussion mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Mark Rutland , devicetree@vger.kernel.org, Masahiro Yamada , Richard Weinberger , Boris Brezillon , linux-kernel@vger.kernel.org, Marek Vasut , Rob Herring , Brian Norris , David Woodhouse 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 Q3VycmVudGx5LCB0aGlzIGRyaXZlciBzdGlja3MgdG8gdGhlIGxlZ2FjeSBOQU5EIG1vZGVsIGJl Y2F1c2UgaXQgd2FzCnVwc3RyZWFtZWQgYmVmb3JlIGNvbW1pdCAyZDQ3MmFiYTE1ZmYgKCJtdGQ6 IG5hbmQ6IGRvY3VtZW50IHRoZSBOQU5ECmNvbnRyb2xsZXIvTkFORCBjaGlwIERUIHJlcHJlc2Vu dGF0aW9uIikuIEhvd2V2ZXIsIHJlbHlpbmcgb24gdGhlCmR1bW15X2NvbnRyb2xsZXIgaXMgYWxy ZWFkeSBkZXByZWNhdGVkLgoKU3dpdGNoIG92ZXIgdG8gdGhlIG5ldyBjb250cm9sbGVyL2NoaXAg cmVwcmVzZW50YXRpb24uCgpUaGUgc3RydWN0IGRlbmFsaV9uYW5kX2luZm8gaGFzIGJlZW4gc3Bs aXQgaW50byBkZW5hbGlfY29udHJvbGxlcgphbmQgZGVuYWxpX2NoaXAsIHRvIGNvbnRhaW4gdGhl IGNvbnRyb2xsZXIgZGF0YSwgcGVyLWNoaXAgZGF0YSwKcmVzcGVjdGl2ZWx5LgoKT25lIHByb2Js ZW0gaXMsIHRoaXMgY29tbWl0IGNoYW5nZXMgdGhlIERUIGJpbmRpbmcuIFNvLCBhcyBhbHdheXMs CnRoZSBiYWNrd2FyZCBjb21wYXRpYmlsaXR5IG11c3QgYmUgdGFrZW4gaW50byBjb25zaWRlcmF0 aW9uLgoKSW4gdGhlIG5ldyBiaW5kaW5nLCB0aGUgY29udHJvbGxlciBub2RlIGV4cGVjdHMKCiAg I2FkZHJlc3MtY2VsbHMgPSA8MT47CiAgI3NpemUtY2VsbHMgPSA8MD47CgouLi4gc2luY2UgdGhl IGNoaWxkIG5vZGVzIHJlcHJlc2VudCBOQU5EIGNoaXBzLgoKSW4gdGhlIG9sZCBiaW5kaW5nLCB0 aGUgY29udHJvbGxlciBub2RlIG1heSBoYXZlIHN1Ym5vZGVzLCBidXQgdGhleQphcmUgTVREIHBh cnRpdGlvbnMuCgpUaGUgZGVuYWxpX2R0X2lzX2xlZ2FjeV9iaW5kaW5nKCkgZXhwbG9pdHMgaXQg dG8gZGlzdGluZ3Vpc2ggb2xkL25ldwpwbGF0Zm9ybXMuCgpHb2luZyBmb3J3YXJkLCB0aGUgb2xk IGJpbmRpbmcgaXMgb25seSBhbGxvd2VkIGZvciBleGlzdGluZyBEVCBmaWxlcy4KSSB1cGRhdGVk IHRoZSBiaW5kaW5nIGRvY3VtZW50LgoKU2lnbmVkLW9mZi1ieTogTWFzYWhpcm8gWWFtYWRhIDx5 YW1hZGEubWFzYWhpcm9Ac29jaW9uZXh0LmNvbT4KQWNrZWQtYnk6IFJvYiBIZXJyaW5nIDxyb2Jo QGtlcm5lbC5vcmc+Ci0tLQoKQ2hhbmdlcyBpbiB2MzoKIC0gc2ltcGxpZnkgbXRkLT5uYW1lIGZh bGxiYWNrCiAtIEFkZCBSb2IncyBBY2sKCkNoYW5nZXMgaW4gdjI6IE5vbmUKCiAuLi4vZGV2aWNl dHJlZS9iaW5kaW5ncy9tdGQvZGVuYWxpLW5hbmQudHh0ICAgICAgICB8ICAzOSArLQogZHJpdmVy cy9tdGQvbmFuZC9yYXcvZGVuYWxpLmMgICAgICAgICAgICAgICAgICAgICAgfCA0NDEgKysrKysr KysrKysrLS0tLS0tLS0tCiBkcml2ZXJzL210ZC9uYW5kL3Jhdy9kZW5hbGkuaCAgICAgICAgICAg ICAgICAgICAgICB8IDExNyArKysrKy0KIGRyaXZlcnMvbXRkL25hbmQvcmF3L2RlbmFsaV9kdC5j ICAgICAgICAgICAgICAgICAgIHwgIDk4ICsrKystCiBkcml2ZXJzL210ZC9uYW5kL3Jhdy9kZW5h bGlfcGNpLmMgICAgICAgICAgICAgICAgICB8ICAzMCArLQogNSBmaWxlcyBjaGFuZ2VkLCA0ODgg aW5zZXJ0aW9ucygrKSwgMjM3IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRp b24vZGV2aWNldHJlZS9iaW5kaW5ncy9tdGQvZGVuYWxpLW5hbmQudHh0IGIvRG9jdW1lbnRhdGlv bi9kZXZpY2V0cmVlL2JpbmRpbmdzL210ZC9kZW5hbGktbmFuZC50eHQKaW5kZXggZjMzZGE4Ny4u ZGU0ZGRmZiAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdzL210 ZC9kZW5hbGktbmFuZC50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9kZXZpY2V0cmVlL2JpbmRpbmdz L210ZC9kZW5hbGktbmFuZC50eHQKQEAgLTcsMzQgKzcsNDcgQEAgUmVxdWlyZWQgcHJvcGVydGll czoKICAgICAgICJzb2Npb25leHQsdW5pcGhpZXItZGVuYWxpLW5hbmQtdjViIiAgLSBmb3IgU29j aW9uZXh0IFVuaVBoaWVyICh2NWIpCiAgIC0gcmVnIDogc2hvdWxkIGNvbnRhaW4gcmVnaXN0ZXJz IGxvY2F0aW9uIGFuZCBsZW5ndGggZm9yIGRhdGEgYW5kIHJlZy4KICAgLSByZWctbmFtZXM6IFNo b3VsZCBjb250YWluIHRoZSByZWcgbmFtZXMgIm5hbmRfZGF0YSIgYW5kICJkZW5hbGlfcmVnIgor ICAtICNhZGRyZXNzLWNlbGxzOiBzaG91bGQgYmUgMS4gVGhlIGNlbGwgZW5jb2RlcyB0aGUgY2hp cCBzZWxlY3QgY29ubmVjdGlvbi4KKyAgLSAjc2l6ZS1jZWxscyA6IHNob3VsZCBiZSAwLgogICAt IGludGVycnVwdHMgOiBUaGUgaW50ZXJydXB0IG51bWJlci4KICAgLSBjbG9ja3M6IHNob3VsZCBj b250YWluIHBoYW5kbGUgb2YgdGhlIGNvbnRyb2xsZXIgY29yZSBjbG9jaywgdGhlIGJ1cwogICAg IGludGVyZmFjZSBjbG9jaywgYW5kIHRoZSBFQ0MgY2lyY3VpdCBjbG9jay4KICAgLSBjbG9jay1u YW1lczogc2hvdWxkIGNvbnRhaW4gIm5hbmQiLCAibmFuZF94IiwgImVjYyIKIAotT3B0aW9uYWwg cHJvcGVydGllczoKLSAgLSBuYW5kLWVjYy1zdGVwLXNpemU6IHNlZSBuYW5kLnR4dCBmb3IgZGV0 YWlscy4gIElmIHByZXNlbnQsIHRoZSB2YWx1ZSBtdXN0IGJlCi0gICAgICA1MTIgICAgICAgIGZv ciAiYWx0cixzb2NmcGdhLWRlbmFsaS1uYW5kIgotICAgICAgMTAyNCAgICAgICBmb3IgInNvY2lv bmV4dCx1bmlwaGllci1kZW5hbGktbmFuZC12NWEiCi0gICAgICAxMDI0ICAgICAgIGZvciAic29j aW9uZXh0LHVuaXBoaWVyLWRlbmFsaS1uYW5kLXY1YiIKLSAgLSBuYW5kLWVjYy1zdHJlbmd0aDog c2VlIG5hbmQudHh0IGZvciBkZXRhaWxzLiAgVmFsaWQgdmFsdWVzIGFyZToKLSAgICAgIDgsIDE1 ICAgICAgZm9yICJhbHRyLHNvY2ZwZ2EtZGVuYWxpLW5hbmQiCi0gICAgICA4LCAxNiwgMjQgIGZv ciAic29jaW9uZXh0LHVuaXBoaWVyLWRlbmFsaS1uYW5kLXY1YSIKLSAgICAgIDgsIDE2ICAgICAg Zm9yICJzb2Npb25leHQsdW5pcGhpZXItZGVuYWxpLW5hbmQtdjViIgotICAtIG5hbmQtZWNjLW1h eGltaXplOiBzZWUgbmFuZC50eHQgZm9yIGRldGFpbHMKLQotVGhlIGRldmljZSB0cmVlIG1heSBv cHRpb25hbGx5IGNvbnRhaW4gc3ViLW5vZGVzIGRlc2NyaWJpbmcgcGFydGl0aW9ucyBvZiB0aGUK K1N1Yi1ub2RlczoKKyAgU3ViLW5vZGVzIHJlcHJlc2VudCBhdmFpbGFibGUgTkFORCBjaGlwcy4K KworICBSZXF1aXJlZCBwcm9wZXJ0aWVzOgorICAgIC0gcmVnOiBzaG91bGQgY29udGFpbiB0aGUg YmFuayBJRCBvZiB0aGUgY29udHJvbGxlciB0byB3aGljaCBlYWNoIGNoaXAKKyAgICAgIHNlbGVj dCBpcyBjb25uZWN0ZWQuCisKKyAgT3B0aW9uYWwgcHJvcGVydGllczoKKyAgICAtIG5hbmQtZWNj LXN0ZXAtc2l6ZTogc2VlIG5hbmQudHh0IGZvciBkZXRhaWxzLiAgSWYgcHJlc2VudCwgdGhlIHZh bHVlIG11c3QgYmUKKyAgICAgICAgNTEyICAgICAgICBmb3IgImFsdHIsc29jZnBnYS1kZW5hbGkt bmFuZCIKKyAgICAgICAgMTAyNCAgICAgICBmb3IgInNvY2lvbmV4dCx1bmlwaGllci1kZW5hbGkt bmFuZC12NWEiCisgICAgICAgIDEwMjQgICAgICAgZm9yICJzb2Npb25leHQsdW5pcGhpZXItZGVu YWxpLW5hbmQtdjViIgorICAgIC0gbmFuZC1lY2Mtc3RyZW5ndGg6IHNlZSBuYW5kLnR4dCBmb3Ig ZGV0YWlscy4gIFZhbGlkIHZhbHVlcyBhcmU6CisgICAgICAgIDgsIDE1ICAgICAgZm9yICJhbHRy LHNvY2ZwZ2EtZGVuYWxpLW5hbmQiCisgICAgICAgIDgsIDE2LCAyNCAgZm9yICJzb2Npb25leHQs dW5pcGhpZXItZGVuYWxpLW5hbmQtdjVhIgorICAgICAgICA4LCAxNiAgICAgIGZvciAic29jaW9u ZXh0LHVuaXBoaWVyLWRlbmFsaS1uYW5kLXY1YiIKKyAgICAtIG5hbmQtZWNjLW1heGltaXplOiBz ZWUgbmFuZC50eHQgZm9yIGRldGFpbHMKKworVGhlIGNoaXAgbm9kZXMgbWF5IG9wdGlvbmFsbHkg Y29udGFpbiBzdWItbm9kZXMgZGVzY3JpYmluZyBwYXJ0aXRpb25zIG9mIHRoZQogYWRkcmVzcyBz cGFjZS4gU2VlIHBhcnRpdGlvbi50eHQgZm9yIG1vcmUgZGV0YWlsLgogCiBFeGFtcGxlczoKIAog bmFuZDogbmFuZEBmZjkwMDAwMCB7CiAJI2FkZHJlc3MtY2VsbHMgPSA8MT47Ci0JI3NpemUtY2Vs bHMgPSA8MT47CisJI3NpemUtY2VsbHMgPSA8MD47CiAJY29tcGF0aWJsZSA9ICJhbHRyLHNvY2Zw Z2EtZGVuYWxpLW5hbmQiOwogCXJlZyA9IDwweGZmOTAwMDAwIDB4MjA+LCA8MHhmZmI4MDAwMCAw eDEwMDA+OwogCXJlZy1uYW1lcyA9ICJuYW5kX2RhdGEiLCAiZGVuYWxpX3JlZyI7CiAJY2xvY2tz ID0gPCZuYW5kX2Nsaz4sIDwmbmFuZF94X2Nsaz4sIDwmbmFuZF9lY2NfY2xrPjsKIAljbG9jay1u YW1lcyA9ICJuYW5kIiwgIm5hbmRfeCIsICJlY2MiOwogCWludGVycnVwdHMgPSA8MCAxNDQgND47 CisKKwluYW5kQDAgeworCQlyZWcgPSA8MD47CisJfQogfTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMv bXRkL25hbmQvcmF3L2RlbmFsaS5jIGIvZHJpdmVycy9tdGQvbmFuZC9yYXcvZGVuYWxpLmMKaW5k ZXggMDVmYmU4Zi4uMGM0N2M1NiAxMDA2NDQKLS0tIGEvZHJpdmVycy9tdGQvbmFuZC9yYXcvZGVu YWxpLmMKKysrIGIvZHJpdmVycy9tdGQvbmFuZC9yYXcvZGVuYWxpLmMKQEAgLTMsNyArMyw3IEBA CiAgKiBOQU5EIEZsYXNoIENvbnRyb2xsZXIgRGV2aWNlIERyaXZlcgogICogQ29weXJpZ2h0IMKp IDIwMDktMjAxMCwgSW50ZWwgQ29ycG9yYXRpb24gYW5kIGl0cyBzdXBwbGllcnMuCiAgKgotICog Q29weXJpZ2h0IChjKSAyMDE3IFNvY2lvbmV4dCBJbmMuCisgKiBDb3B5cmlnaHQgKGMpIDIwMTct MjAxOSBTb2Npb25leHQgSW5jLgogICogICBSZXdvcmtlZCBieSBNYXNhaGlybyBZYW1hZGEgPHlh bWFkYS5tYXNhaGlyb0Bzb2Npb25leHQuY29tPgogICovCiAKQEAgLTQyLDE0ICs0MiwxNSBAQAog I2RlZmluZSBERU5BTElfSU5WQUxJRF9CQU5LCS0xCiAjZGVmaW5lIERFTkFMSV9OUl9CQU5LUwkJ NAogCi1zdGF0aWMgaW5saW5lIHN0cnVjdCBkZW5hbGlfbmFuZF9pbmZvICptdGRfdG9fZGVuYWxp KHN0cnVjdCBtdGRfaW5mbyAqbXRkKQorc3RhdGljIHN0cnVjdCBkZW5hbGlfY2hpcCAqdG9fZGVu YWxpX2NoaXAoc3RydWN0IG5hbmRfY2hpcCAqY2hpcCkKIHsKLQlyZXR1cm4gY29udGFpbmVyX29m KG10ZF90b19uYW5kKG10ZCksIHN0cnVjdCBkZW5hbGlfbmFuZF9pbmZvLCBuYW5kKTsKKwlyZXR1 cm4gY29udGFpbmVyX29mKGNoaXAsIHN0cnVjdCBkZW5hbGlfY2hpcCwgY2hpcCk7CiB9CiAKLXN0 YXRpYyBzdHJ1Y3QgZGVuYWxpX25hbmRfaW5mbyAqdG9fZGVuYWxpKHN0cnVjdCBuYW5kX2NoaXAg KmNoaXApCitzdGF0aWMgc3RydWN0IGRlbmFsaV9jb250cm9sbGVyICp0b19kZW5hbGlfY29udHJv bGxlcihzdHJ1Y3QgbmFuZF9jaGlwICpjaGlwKQogewotCXJldHVybiBjb250YWluZXJfb2YoY2hp cCwgc3RydWN0IGRlbmFsaV9uYW5kX2luZm8sIG5hbmQpOworCXJldHVybiBjb250YWluZXJfb2Yo Y2hpcC0+Y29udHJvbGxlciwgc3RydWN0IGRlbmFsaV9jb250cm9sbGVyLAorCQkJICAgIGNvbnRy b2xsZXIpOwogfQogCiAvKgpAQCAtNTcsMTIgKzU4LDEyIEBAIHN0YXRpYyBzdHJ1Y3QgZGVuYWxp X25hbmRfaW5mbyAqdG9fZGVuYWxpKHN0cnVjdCBuYW5kX2NoaXAgKmNoaXApCiAgKiB0eXBlLCBi YW5rLCBibG9jaywgYW5kIHBhZ2UgYWRkcmVzcykuICBUaGUgc2xhdmUgZGF0YSBpcyB0aGUgYWN0 dWFsIGRhdGEgdG8KICAqIGJlIHRyYW5zZmVycmVkLiAgVGhpcyBtb2RlIHJlcXVpcmVzIDI4IGJp dHMgb2YgYWRkcmVzcyByZWdpb24gYWxsb2NhdGVkLgogICovCi1zdGF0aWMgdTMyIGRlbmFsaV9k aXJlY3RfcmVhZChzdHJ1Y3QgZGVuYWxpX25hbmRfaW5mbyAqZGVuYWxpLCB1MzIgYWRkcikKK3N0 YXRpYyB1MzIgZGVuYWxpX2RpcmVjdF9yZWFkKHN0cnVjdCBkZW5hbGlfY29udHJvbGxlciAqZGVu YWxpLCB1MzIgYWRkcikKIHsKIAlyZXR1cm4gaW9yZWFkMzIoZGVuYWxpLT5ob3N0ICsgYWRkcik7 CiB9CiAKLXN0YXRpYyB2b2lkIGRlbmFsaV9kaXJlY3Rfd3JpdGUoc3RydWN0IGRlbmFsaV9uYW5k X2luZm8gKmRlbmFsaSwgdTMyIGFkZHIsCitzdGF0aWMgdm9pZCBkZW5hbGlfZGlyZWN0X3dyaXRl KHN0cnVjdCBkZW5hbGlfY29udHJvbGxlciAqZGVuYWxpLCB1MzIgYWRkciwKIAkJCQl1MzIgZGF0 YSkKIHsKIAlpb3dyaXRlMzIoZGF0YSwgZGVuYWxpLT5ob3N0ICsgYWRkcik7CkBAIC03NCwzNSAr NzUsMjAgQEAgc3RhdGljIHZvaWQgZGVuYWxpX2RpcmVjdF93cml0ZShzdHJ1Y3QgZGVuYWxpX25h bmRfaW5mbyAqZGVuYWxpLCB1MzIgYWRkciwKICAqIGNvbnRyb2wgaW5mb3JtYXRpb24gYW5kIHRy YW5zZmVycmVkIGRhdGEgYXJlIGxhdGNoZWQgYnkgdGhlIHJlZ2lzdGVycyBpbgogICogdGhlIHRy YW5zbGF0aW9uIG1vZHVsZS4KICAqLwotc3RhdGljIHUzMiBkZW5hbGlfaW5kZXhlZF9yZWFkKHN0 cnVjdCBkZW5hbGlfbmFuZF9pbmZvICpkZW5hbGksIHUzMiBhZGRyKQorc3RhdGljIHUzMiBkZW5h bGlfaW5kZXhlZF9yZWFkKHN0cnVjdCBkZW5hbGlfY29udHJvbGxlciAqZGVuYWxpLCB1MzIgYWRk cikKIHsKIAlpb3dyaXRlMzIoYWRkciwgZGVuYWxpLT5ob3N0ICsgREVOQUxJX0lOREVYRURfQ1RS TCk7CiAJcmV0dXJuIGlvcmVhZDMyKGRlbmFsaS0+aG9zdCArIERFTkFMSV9JTkRFWEVEX0RBVEEp OwogfQogCi1zdGF0aWMgdm9pZCBkZW5hbGlfaW5kZXhlZF93cml0ZShzdHJ1Y3QgZGVuYWxpX25h bmRfaW5mbyAqZGVuYWxpLCB1MzIgYWRkciwKK3N0YXRpYyB2b2lkIGRlbmFsaV9pbmRleGVkX3dy aXRlKHN0cnVjdCBkZW5hbGlfY29udHJvbGxlciAqZGVuYWxpLCB1MzIgYWRkciwKIAkJCQkgdTMy IGRhdGEpCiB7CiAJaW93cml0ZTMyKGFkZHIsIGRlbmFsaS0+aG9zdCArIERFTkFMSV9JTkRFWEVE X0NUUkwpOwogCWlvd3JpdGUzMihkYXRhLCBkZW5hbGktPmhvc3QgKyBERU5BTElfSU5ERVhFRF9E QVRBKTsKIH0KIAotLyoKLSAqIFVzZSB0aGUgY29uZmlndXJhdGlvbiBmZWF0dXJlIHJlZ2lzdGVy IHRvIGRldGVybWluZSB0aGUgbWF4aW11bSBudW1iZXIgb2YKLSAqIGJhbmtzIHRoYXQgdGhlIGhh cmR3YXJlIHN1cHBvcnRzLgotICovCi1zdGF0aWMgdm9pZCBkZW5hbGlfZGV0ZWN0X21heF9iYW5r cyhzdHJ1Y3QgZGVuYWxpX25hbmRfaW5mbyAqZGVuYWxpKQotewotCXVpbnQzMl90IGZlYXR1cmVz ID0gaW9yZWFkMzIoZGVuYWxpLT5yZWcgKyBGRUFUVVJFUyk7Ci0KLQlkZW5hbGktPm1heF9iYW5r cyA9IDEgPDwgRklFTERfR0VUKEZFQVRVUkVTX19OX0JBTktTLCBmZWF0dXJlcyk7Ci0KLQkvKiB0 aGUgZW5jb2RpbmcgY2hhbmdlZCBmcm9tIHJldiA1LjAgdG8gNS4xICovCi0JaWYgKGRlbmFsaS0+ cmV2aXNpb24gPCAweDA1MDEpCi0JCWRlbmFsaS0+bWF4X2JhbmtzIDw8PSAxOwotfQotCi1zdGF0 aWMgdm9pZCBkZW5hbGlfZW5hYmxlX2lycShzdHJ1Y3QgZGVuYWxpX25hbmRfaW5mbyAqZGVuYWxp KQorc3RhdGljIHZvaWQgZGVuYWxpX2VuYWJsZV9pcnEoc3RydWN0IGRlbmFsaV9jb250cm9sbGVy ICpkZW5hbGkpCiB7CiAJaW50IGk7CiAKQEAgLTExMSw3ICs5Nyw3IEBAIHN0YXRpYyB2b2lkIGRl bmFsaV9lbmFibGVfaXJxKHN0cnVjdCBkZW5hbGlfbmFuZF9pbmZvICpkZW5hbGkpCiAJaW93cml0 ZTMyKEdMT0JBTF9JTlRfRU5fRkxBRywgZGVuYWxpLT5yZWcgKyBHTE9CQUxfSU5UX0VOQUJMRSk7 CiB9CiAKLXN0YXRpYyB2b2lkIGRlbmFsaV9kaXNhYmxlX2lycShzdHJ1Y3QgZGVuYWxpX25hbmRf aW5mbyAqZGVuYWxpKQorc3RhdGljIHZvaWQgZGVuYWxpX2Rpc2FibGVfaXJxKHN0cnVjdCBkZW5h bGlfY29udHJvbGxlciAqZGVuYWxpKQogewogCWludCBpOwogCkBAIC0xMjAsMTQgKzEwNiwxNCBA QCBzdGF0aWMgdm9pZCBkZW5hbGlfZGlzYWJsZV9pcnEoc3RydWN0IGRlbmFsaV9uYW5kX2luZm8g KmRlbmFsaSkKIAlpb3dyaXRlMzIoMCwgZGVuYWxpLT5yZWcgKyBHTE9CQUxfSU5UX0VOQUJMRSk7 CiB9CiAKLXN0YXRpYyB2b2lkIGRlbmFsaV9jbGVhcl9pcnEoc3RydWN0IGRlbmFsaV9uYW5kX2lu Zm8gKmRlbmFsaSwKK3N0YXRpYyB2b2lkIGRlbmFsaV9jbGVhcl9pcnEoc3RydWN0IGRlbmFsaV9j b250cm9sbGVyICpkZW5hbGksCiAJCQkgICAgIGludCBiYW5rLCB1aW50MzJfdCBpcnFfc3RhdHVz KQogewogCS8qIHdyaXRlIG9uZSB0byBjbGVhciBiaXRzICovCiAJaW93cml0ZTMyKGlycV9zdGF0 dXMsIGRlbmFsaS0+cmVnICsgSU5UUl9TVEFUVVMoYmFuaykpOwogfQogCi1zdGF0aWMgdm9pZCBk ZW5hbGlfY2xlYXJfaXJxX2FsbChzdHJ1Y3QgZGVuYWxpX25hbmRfaW5mbyAqZGVuYWxpKQorc3Rh dGljIHZvaWQgZGVuYWxpX2NsZWFyX2lycV9hbGwoc3RydWN0IGRlbmFsaV9jb250cm9sbGVyICpk ZW5hbGkpCiB7CiAJaW50IGk7CiAKQEAgLTEzNyw3ICsxMjMsNyBAQCBzdGF0aWMgdm9pZCBkZW5h bGlfY2xlYXJfaXJxX2FsbChzdHJ1Y3QgZGVuYWxpX25hbmRfaW5mbyAqZGVuYWxpKQogCiBzdGF0 aWMgaXJxcmV0dXJuX3QgZGVuYWxpX2lzcihpbnQgaXJxLCB2b2lkICpkZXZfaWQpCiB7Ci0Jc3Ry dWN0IGRlbmFsaV9uYW5kX2luZm8gKmRlbmFsaSA9IGRldl9pZDsKKwlzdHJ1Y3QgZGVuYWxpX2Nv bnRyb2xsZXIgKmRlbmFsaSA9IGRldl9pZDsKIAlpcnFyZXR1cm5fdCByZXQgPSBJUlFfTk9ORTsK IAl1aW50MzJfdCBpcnFfc3RhdHVzOwogCWludCBpOwpAQCAtMTY1LDcgKzE1MSw3IEBAIHN0YXRp YyBpcnFyZXR1cm5fdCBkZW5hbGlfaXNyKGludCBpcnEsIHZvaWQgKmRldl9pZCkKIAlyZXR1cm4g cmV0OwogfQogCi1zdGF0aWMgdm9pZCBkZW5hbGlfcmVzZXRfaXJxKHN0cnVjdCBkZW5hbGlfbmFu ZF9pbmZvICpkZW5hbGkpCitzdGF0aWMgdm9pZCBkZW5hbGlfcmVzZXRfaXJxKHN0cnVjdCBkZW5h bGlfY29udHJvbGxlciAqZGVuYWxpKQogewogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAKQEAgLTE3 NSw4ICsxNjEsNyBAQCBzdGF0aWMgdm9pZCBkZW5hbGlfcmVzZXRfaXJxKHN0cnVjdCBkZW5hbGlf bmFuZF9pbmZvICpkZW5hbGkpCiAJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZGVuYWxpLT5pcnFf bG9jaywgZmxhZ3MpOwogfQogCi1zdGF0aWMgdWludDMyX3QgZGVuYWxpX3dhaXRfZm9yX2lycShz dHJ1Y3QgZGVuYWxpX25hbmRfaW5mbyAqZGVuYWxpLAotCQkJCSAgICB1aW50MzJfdCBpcnFfbWFz aykKK3N0YXRpYyB1MzIgZGVuYWxpX3dhaXRfZm9yX2lycShzdHJ1Y3QgZGVuYWxpX2NvbnRyb2xs ZXIgKmRlbmFsaSwgdTMyIGlycV9tYXNrKQogewogCXVuc2lnbmVkIGxvbmcgdGltZV9sZWZ0LCBm bGFnczsKIAl1aW50MzJfdCBpcnFfc3RhdHVzOwpAQCAtMjA4LDEzICsxOTMsNDUgQEAgc3RhdGlj IHVpbnQzMl90IGRlbmFsaV93YWl0X2Zvcl9pcnEoc3RydWN0IGRlbmFsaV9uYW5kX2luZm8gKmRl bmFsaSwKIAogc3RhdGljIHZvaWQgZGVuYWxpX3NlbGVjdF90YXJnZXQoc3RydWN0IG5hbmRfY2hp cCAqY2hpcCwgaW50IGNzKQogewotCXN0cnVjdCBkZW5hbGlfbmFuZF9pbmZvICpkZW5hbGkgPSB0 b19kZW5hbGkoY2hpcCk7CisJc3RydWN0IGRlbmFsaV9jb250cm9sbGVyICpkZW5hbGkgPSB0b19k ZW5hbGlfY29udHJvbGxlcihjaGlwKTsKKwlzdHJ1Y3QgZGVuYWxpX2NoaXBfc2VsICpzZWwgPSAm dG9fZGVuYWxpX2NoaXAoY2hpcCktPnNlbHNbY3NdOworCXN0cnVjdCBtdGRfaW5mbyAqbXRkID0g bmFuZF90b19tdGQoY2hpcCk7CisKKwlkZW5hbGktPmFjdGl2ZV9iYW5rID0gc2VsLT5iYW5rOwog Ci0JZGVuYWxpLT5hY3RpdmVfYmFuayA9IGNzOworCWlvd3JpdGUzMigxIDw8IChjaGlwLT5waHlz X2VyYXNlX3NoaWZ0IC0gY2hpcC0+cGFnZV9zaGlmdCksCisJCSAgZGVuYWxpLT5yZWcgKyBQQUdF U19QRVJfQkxPQ0spOworCWlvd3JpdGUzMihjaGlwLT5vcHRpb25zICYgTkFORF9CVVNXSURUSF8x NiA/IDEgOiAwLAorCQkgIGRlbmFsaS0+cmVnICsgREVWSUNFX1dJRFRIKTsKKwlpb3dyaXRlMzIo bXRkLT53cml0ZXNpemUsIGRlbmFsaS0+cmVnICsgREVWSUNFX01BSU5fQVJFQV9TSVpFKTsKKwlp b3dyaXRlMzIobXRkLT5vb2JzaXplLCBkZW5hbGktPnJlZyArIERFVklDRV9TUEFSRV9BUkVBX1NJ WkUpOworCWlvd3JpdGUzMihjaGlwLT5vcHRpb25zICYgTkFORF9ST1dfQUREUl8zID8KKwkJICAw IDogVFdPX1JPV19BRERSX0NZQ0xFU19fRkxBRywKKwkJICBkZW5hbGktPnJlZyArIFRXT19ST1df QUREUl9DWUNMRVMpOworCWlvd3JpdGUzMihGSUVMRF9QUkVQKEVDQ19DT1JSRUNUSU9OX19FUkFT RV9USFJFU0hPTEQsIDEpIHwKKwkJICBGSUVMRF9QUkVQKEVDQ19DT1JSRUNUSU9OX19WQUxVRSwg Y2hpcC0+ZWNjLnN0cmVuZ3RoKSwKKwkJICBkZW5hbGktPnJlZyArIEVDQ19DT1JSRUNUSU9OKTsK Kwlpb3dyaXRlMzIoY2hpcC0+ZWNjLnNpemUsIGRlbmFsaS0+cmVnICsgQ0ZHX0RBVEFfQkxPQ0tf U0laRSk7CisJaW93cml0ZTMyKGNoaXAtPmVjYy5zaXplLCBkZW5hbGktPnJlZyArIENGR19MQVNU X0RBVEFfQkxPQ0tfU0laRSk7CisJaW93cml0ZTMyKGNoaXAtPmVjYy5zdGVwcywgZGVuYWxpLT5y ZWcgKyBDRkdfTlVNX0RBVEFfQkxPQ0tTKTsKKworCWlmIChjaGlwLT5vcHRpb25zICYgTkFORF9L RUVQX1RJTUlOR1MpCisJCXJldHVybjsKKworCS8qIHVwZGF0ZSB0aW1pbmcgcmVnaXN0ZXJzIHVu bGVzcyBOQU5EX0tFRVBfVElNSU5HUyBpcyBzZXQgKi8KKwlpb3dyaXRlMzIoc2VsLT5od2hyMl9h bmRfd2VfMl9yZSwgZGVuYWxpLT5yZWcgKyBUV0hSMl9BTkRfV0VfMl9SRSk7CisJaW93cml0ZTMy KHNlbC0+dGN3YXdfYW5kX2FkZHJfMl9kYXRhLAorCQkgIGRlbmFsaS0+cmVnICsgVENXQVdfQU5E X0FERFJfMl9EQVRBKTsKKwlpb3dyaXRlMzIoc2VsLT5yZV8yX3dlLCBkZW5hbGktPnJlZyArIFJF XzJfV0UpOworCWlvd3JpdGUzMihzZWwtPmFjY19jbGtzLCBkZW5hbGktPnJlZyArIEFDQ19DTEtT KTsKKwlpb3dyaXRlMzIoc2VsLT5yZHdyX2VuX2xvX2NudCwgZGVuYWxpLT5yZWcgKyBSRFdSX0VO X0xPX0NOVCk7CisJaW93cml0ZTMyKHNlbC0+cmR3cl9lbl9oaV9jbnQsIGRlbmFsaS0+cmVnICsg UkRXUl9FTl9ISV9DTlQpOworCWlvd3JpdGUzMihzZWwtPmNzX3NldHVwX2NudCwgZGVuYWxpLT5y ZWcgKyBDU19TRVRVUF9DTlQpOworCWlvd3JpdGUzMihzZWwtPnJlXzJfcmUsIGRlbmFsaS0+cmVn ICsgUkVfMl9SRSk7CiB9CiAKIHN0YXRpYyBpbnQgZGVuYWxpX2NoZWNrX2VyYXNlZF9wYWdlKHN0 cnVjdCBuYW5kX2NoaXAgKmNoaXAsCi0JCQkJICAgIHN0cnVjdCBkZW5hbGlfbmFuZF9pbmZvICpk ZW5hbGksIHU4ICpidWYsCisJCQkJICAgIHN0cnVjdCBkZW5hbGlfY29udHJvbGxlciAqZGVuYWxp LCB1OCAqYnVmLAogCQkJCSAgICB1bnNpZ25lZCBsb25nIHVuY29yX2VjY19mbGFncywKIAkJCQkg ICAgdW5zaWduZWQgaW50IG1heF9iaXRmbGlwcykKIHsKQEAgLTI0OCw3ICsyNjUsNyBAQCBzdGF0 aWMgaW50IGRlbmFsaV9jaGVja19lcmFzZWRfcGFnZShzdHJ1Y3QgbmFuZF9jaGlwICpjaGlwLAog fQogCiBzdGF0aWMgaW50IGRlbmFsaV9od19lY2NfZml4dXAoc3RydWN0IG5hbmRfY2hpcCAqY2hp cCwKLQkJCSAgICAgICBzdHJ1Y3QgZGVuYWxpX25hbmRfaW5mbyAqZGVuYWxpLAorCQkJICAgICAg IHN0cnVjdCBkZW5hbGlfY29udHJvbGxlciAqZGVuYWxpLAogCQkJICAgICAgIHVuc2lnbmVkIGxv bmcgKnVuY29yX2VjY19mbGFncykKIHsKIAlzdHJ1Y3QgbXRkX2VjY19zdGF0cyAqZWNjX3N0YXRz ID0gJm5hbmRfdG9fbXRkKGNoaXApLT5lY2Nfc3RhdHM7CkBAIC0yODMsNyArMzAwLDcgQEAgc3Rh dGljIGludCBkZW5hbGlfaHdfZWNjX2ZpeHVwKHN0cnVjdCBuYW5kX2NoaXAgKmNoaXAsCiB9CiAK IHN0YXRpYyBpbnQgZGVuYWxpX3N3X2VjY19maXh1cChzdHJ1Y3QgbmFuZF9jaGlwICpjaGlwLAot CQkJICAgICAgIHN0cnVjdCBkZW5hbGlfbmFuZF9pbmZvICpkZW5hbGksCisJCQkgICAgICAgc3Ry dWN0IGRlbmFsaV9jb250cm9sbGVyICpkZW5hbGksCiAJCQkgICAgICAgdW5zaWduZWQgbG9uZyAq dW5jb3JfZWNjX2ZsYWdzLCB1aW50OF90ICpidWYpCiB7CiAJc3RydWN0IG10ZF9lY2Nfc3RhdHMg KmVjY19zdGF0cyA9ICZuYW5kX3RvX210ZChjaGlwKS0+ZWNjX3N0YXRzOwpAQCAtMzU2LDcgKzM3 Myw3IEBAIHN0YXRpYyBpbnQgZGVuYWxpX3N3X2VjY19maXh1cChzdHJ1Y3QgbmFuZF9jaGlwICpj aGlwLAogCXJldHVybiBtYXhfYml0ZmxpcHM7CiB9CiAKLXN0YXRpYyB2b2lkIGRlbmFsaV9zZXR1 cF9kbWE2NChzdHJ1Y3QgZGVuYWxpX25hbmRfaW5mbyAqZGVuYWxpLAorc3RhdGljIHZvaWQgZGVu YWxpX3NldHVwX2RtYTY0KHN0cnVjdCBkZW5hbGlfY29udHJvbGxlciAqZGVuYWxpLAogCQkJICAg ICAgIGRtYV9hZGRyX3QgZG1hX2FkZHIsIGludCBwYWdlLCBib29sIHdyaXRlKQogewogCXVpbnQz Ml90IG1vZGU7CkBAIC0zODEsNyArMzk4LDcgQEAgc3RhdGljIHZvaWQgZGVuYWxpX3NldHVwX2Rt YTY0KHN0cnVjdCBkZW5hbGlfbmFuZF9pbmZvICpkZW5hbGksCiAJZGVuYWxpLT5ob3N0X3dyaXRl KGRlbmFsaSwgbW9kZSwgdXBwZXJfMzJfYml0cyhkbWFfYWRkcikpOwogfQogCi1zdGF0aWMgdm9p ZCBkZW5hbGlfc2V0dXBfZG1hMzIoc3RydWN0IGRlbmFsaV9uYW5kX2luZm8gKmRlbmFsaSwKK3N0 YXRpYyB2b2lkIGRlbmFsaV9zZXR1cF9kbWEzMihzdHJ1Y3QgZGVuYWxpX2NvbnRyb2xsZXIgKmRl bmFsaSwKIAkJCSAgICAgICBkbWFfYWRkcl90IGRtYV9hZGRyLCBpbnQgcGFnZSwgYm9vbCB3cml0 ZSkKIHsKIAl1aW50MzJfdCBtb2RlOwpAQCAtNDA1LDcgKzQyMiw3IEBAIHN0YXRpYyB2b2lkIGRl bmFsaV9zZXR1cF9kbWEzMihzdHJ1Y3QgZGVuYWxpX25hbmRfaW5mbyAqZGVuYWxpLAogCWRlbmFs aS0+aG9zdF93cml0ZShkZW5hbGksIG1vZGUgfCAweDE0MDAwLCAweDI0MDApOwogfQogCi1zdGF0 aWMgaW50IGRlbmFsaV9waW9fcmVhZChzdHJ1Y3QgZGVuYWxpX25hbmRfaW5mbyAqZGVuYWxpLCB1 MzIgKmJ1ZiwKK3N0YXRpYyBpbnQgZGVuYWxpX3Bpb19yZWFkKHN0cnVjdCBkZW5hbGlfY29udHJv bGxlciAqZGVuYWxpLCB1MzIgKmJ1ZiwKIAkJCSAgIHNpemVfdCBzaXplLCBpbnQgcGFnZSkKIHsK IAl1MzIgYWRkciA9IERFTkFMSV9NQVAwMSB8IERFTkFMSV9CQU5LKGRlbmFsaSkgfCBwYWdlOwpA QCAtNDMyLDcgKzQ0OSw3IEBAIHN0YXRpYyBpbnQgZGVuYWxpX3Bpb19yZWFkKHN0cnVjdCBkZW5h bGlfbmFuZF9pbmZvICpkZW5hbGksIHUzMiAqYnVmLAogCXJldHVybiBpcnFfc3RhdHVzICYgZWNj X2Vycl9tYXNrID8gLUVCQURNU0cgOiAwOwogfQogCi1zdGF0aWMgaW50IGRlbmFsaV9waW9fd3Jp dGUoc3RydWN0IGRlbmFsaV9uYW5kX2luZm8gKmRlbmFsaSwgY29uc3QgdTMyICpidWYsCitzdGF0 aWMgaW50IGRlbmFsaV9waW9fd3JpdGUoc3RydWN0IGRlbmFsaV9jb250cm9sbGVyICpkZW5hbGks IGNvbnN0IHUzMiAqYnVmLAogCQkJICAgIHNpemVfdCBzaXplLCBpbnQgcGFnZSkKIHsKIAl1MzIg YWRkciA9IERFTkFMSV9NQVAwMSB8IERFTkFMSV9CQU5LKGRlbmFsaSkgfCBwYWdlOwpAQCAtNDUy LDcgKzQ2OSw3IEBAIHN0YXRpYyBpbnQgZGVuYWxpX3Bpb193cml0ZShzdHJ1Y3QgZGVuYWxpX25h bmRfaW5mbyAqZGVuYWxpLCBjb25zdCB1MzIgKmJ1ZiwKIAlyZXR1cm4gMDsKIH0KIAotc3RhdGlj IGludCBkZW5hbGlfcGlvX3hmZXIoc3RydWN0IGRlbmFsaV9uYW5kX2luZm8gKmRlbmFsaSwgdm9p ZCAqYnVmLAorc3RhdGljIGludCBkZW5hbGlfcGlvX3hmZXIoc3RydWN0IGRlbmFsaV9jb250cm9s bGVyICpkZW5hbGksIHZvaWQgKmJ1ZiwKIAkJCSAgIHNpemVfdCBzaXplLCBpbnQgcGFnZSwgYm9v bCB3cml0ZSkKIHsKIAlpZiAod3JpdGUpCkBAIC00NjEsNyArNDc4LDcgQEAgc3RhdGljIGludCBk ZW5hbGlfcGlvX3hmZXIoc3RydWN0IGRlbmFsaV9uYW5kX2luZm8gKmRlbmFsaSwgdm9pZCAqYnVm LAogCQlyZXR1cm4gZGVuYWxpX3Bpb19yZWFkKGRlbmFsaSwgYnVmLCBzaXplLCBwYWdlKTsKIH0K IAotc3RhdGljIGludCBkZW5hbGlfZG1hX3hmZXIoc3RydWN0IGRlbmFsaV9uYW5kX2luZm8gKmRl bmFsaSwgdm9pZCAqYnVmLAorc3RhdGljIGludCBkZW5hbGlfZG1hX3hmZXIoc3RydWN0IGRlbmFs aV9jb250cm9sbGVyICpkZW5hbGksIHZvaWQgKmJ1ZiwKIAkJCSAgIHNpemVfdCBzaXplLCBpbnQg cGFnZSwgYm9vbCB3cml0ZSkKIHsKIAlkbWFfYWRkcl90IGRtYV9hZGRyOwpAQCAtNTIxLDcgKzUz OCw3IEBAIHN0YXRpYyBpbnQgZGVuYWxpX2RtYV94ZmVyKHN0cnVjdCBkZW5hbGlfbmFuZF9pbmZv ICpkZW5hbGksIHZvaWQgKmJ1ZiwKIHN0YXRpYyBpbnQgZGVuYWxpX2RhdGFfeGZlcihzdHJ1Y3Qg bmFuZF9jaGlwICpjaGlwLCB2b2lkICpidWYsIHNpemVfdCBzaXplLAogCQkJICAgIGludCBwYWdl LCBib29sIHJhdywgYm9vbCB3cml0ZSkKIHsKLQlzdHJ1Y3QgZGVuYWxpX25hbmRfaW5mbyAqZGVu YWxpID0gdG9fZGVuYWxpKGNoaXApOworCXN0cnVjdCBkZW5hbGlfY29udHJvbGxlciAqZGVuYWxp ID0gdG9fZGVuYWxpX2NvbnRyb2xsZXIoY2hpcCk7CiAKIAlkZW5hbGlfc2VsZWN0X3RhcmdldChj aGlwLCBjaGlwLT5jdXJfY3MpOwogCkBAIC01NTQsNyArNTcxLDcgQEAgdHlwZWRlZiBpbnQgZGVu YWxpX2NoYW5nZV9jb2x1bW5fY2FsbGJhY2sodm9pZCAqYnVmLCB1bnNpZ25lZCBpbnQgb2Zmc2V0 LAogc3RhdGljIGludCBkZW5hbGlfcmF3X3BheWxvYWRfb3Aoc3RydWN0IG5hbmRfY2hpcCAqY2hp cCwgdm9pZCAqYnVmLAogCQkJCSBkZW5hbGlfY2hhbmdlX2NvbHVtbl9jYWxsYmFjayAqY2IsIHZv aWQgKnByaXYpCiB7Ci0Jc3RydWN0IGRlbmFsaV9uYW5kX2luZm8gKmRlbmFsaSA9IHRvX2RlbmFs aShjaGlwKTsKKwlzdHJ1Y3QgZGVuYWxpX2NvbnRyb2xsZXIgKmRlbmFsaSA9IHRvX2RlbmFsaV9j b250cm9sbGVyKGNoaXApOwogCXN0cnVjdCBtdGRfaW5mbyAqbXRkID0gbmFuZF90b19tdGQoY2hp cCk7CiAJc3RydWN0IG5hbmRfZWNjX2N0cmwgKmVjYyA9ICZjaGlwLT5lY2M7CiAJaW50IHdyaXRl c2l6ZSA9IG10ZC0+d3JpdGVzaXplOwpAQCAtNjA0LDcgKzYyMSw3IEBAIHN0YXRpYyBpbnQgZGVu YWxpX3Jhd19wYXlsb2FkX29wKHN0cnVjdCBuYW5kX2NoaXAgKmNoaXAsIHZvaWQgKmJ1ZiwKIHN0 YXRpYyBpbnQgZGVuYWxpX3Jhd19vb2Jfb3Aoc3RydWN0IG5hbmRfY2hpcCAqY2hpcCwgdm9pZCAq YnVmLAogCQkJICAgICBkZW5hbGlfY2hhbmdlX2NvbHVtbl9jYWxsYmFjayAqY2IsIHZvaWQgKnBy aXYpCiB7Ci0Jc3RydWN0IGRlbmFsaV9uYW5kX2luZm8gKmRlbmFsaSA9IHRvX2RlbmFsaShjaGlw KTsKKwlzdHJ1Y3QgZGVuYWxpX2NvbnRyb2xsZXIgKmRlbmFsaSA9IHRvX2RlbmFsaV9jb250cm9s bGVyKGNoaXApOwogCXN0cnVjdCBtdGRfaW5mbyAqbXRkID0gbmFuZF90b19tdGQoY2hpcCk7CiAJ c3RydWN0IG5hbmRfZWNjX2N0cmwgKmVjYyA9ICZjaGlwLT5lY2M7CiAJaW50IHdyaXRlc2l6ZSA9 IG10ZC0+d3JpdGVzaXplOwpAQCAtNjYxLDkgKzY3OCw5IEBAIHN0YXRpYyBpbnQgZGVuYWxpX21l bWNweV9pbih2b2lkICpidWYsIHVuc2lnbmVkIGludCBvZmZzZXQsIHVuc2lnbmVkIGludCBsZW4s CiBzdGF0aWMgaW50IGRlbmFsaV9yZWFkX3BhZ2VfcmF3KHN0cnVjdCBuYW5kX2NoaXAgKmNoaXAs IHVpbnQ4X3QgKmJ1ZiwKIAkJCQlpbnQgb29iX3JlcXVpcmVkLCBpbnQgcGFnZSkKIHsKLQlzdHJ1 Y3QgZGVuYWxpX25hbmRfaW5mbyAqZGVuYWxpID0gdG9fZGVuYWxpKGNoaXApOworCXN0cnVjdCBk ZW5hbGlfY2hpcCAqZGNoaXAgPSB0b19kZW5hbGlfY2hpcChjaGlwKTsKIAlzdHJ1Y3QgbXRkX2lu Zm8gKm10ZCA9IG5hbmRfdG9fbXRkKGNoaXApOwotCXZvaWQgKnRtcF9idWYgPSBkZW5hbGktPmJ1 ZjsKKwl2b2lkICp0bXBfYnVmID0gZGNoaXAtPmJ1ZjsKIAlzaXplX3Qgc2l6ZSA9IG10ZC0+d3Jp dGVzaXplICsgbXRkLT5vb2JzaXplOwogCWludCByZXQ7CiAKQEAgLTY5OCw5ICs3MTUsOSBAQCBz dGF0aWMgaW50IGRlbmFsaV9tZW1jcHlfb3V0KHZvaWQgKmJ1ZiwgdW5zaWduZWQgaW50IG9mZnNl dCwgdW5zaWduZWQgaW50IGxlbiwKIHN0YXRpYyBpbnQgZGVuYWxpX3dyaXRlX3BhZ2VfcmF3KHN0 cnVjdCBuYW5kX2NoaXAgKmNoaXAsIGNvbnN0IHVpbnQ4X3QgKmJ1ZiwKIAkJCQkgaW50IG9vYl9y ZXF1aXJlZCwgaW50IHBhZ2UpCiB7Ci0Jc3RydWN0IGRlbmFsaV9uYW5kX2luZm8gKmRlbmFsaSA9 IHRvX2RlbmFsaShjaGlwKTsKKwlzdHJ1Y3QgZGVuYWxpX2NoaXAgKmRjaGlwID0gdG9fZGVuYWxp X2NoaXAoY2hpcCk7CiAJc3RydWN0IG10ZF9pbmZvICptdGQgPSBuYW5kX3RvX210ZChjaGlwKTsK LQl2b2lkICp0bXBfYnVmID0gZGVuYWxpLT5idWY7CisJdm9pZCAqdG1wX2J1ZiA9IGRjaGlwLT5i dWY7CiAJc2l6ZV90IHNpemUgPSBtdGQtPndyaXRlc2l6ZSArIG10ZC0+b29ic2l6ZTsKIAlpbnQg cmV0OwogCkBAIC03NzIsOCArNzg5LDggQEAgc3RhdGljIGludCBkZW5hbGlfd3JpdGVfb29iKHN0 cnVjdCBuYW5kX2NoaXAgKmNoaXAsIGludCBwYWdlKQogc3RhdGljIGludCBkZW5hbGlfcmVhZF9w YWdlKHN0cnVjdCBuYW5kX2NoaXAgKmNoaXAsIHVpbnQ4X3QgKmJ1ZiwKIAkJCSAgICBpbnQgb29i X3JlcXVpcmVkLCBpbnQgcGFnZSkKIHsKKwlzdHJ1Y3QgZGVuYWxpX2NvbnRyb2xsZXIgKmRlbmFs aSA9IHRvX2RlbmFsaV9jb250cm9sbGVyKGNoaXApOwogCXN0cnVjdCBtdGRfaW5mbyAqbXRkID0g bmFuZF90b19tdGQoY2hpcCk7Ci0Jc3RydWN0IGRlbmFsaV9uYW5kX2luZm8gKmRlbmFsaSA9IG10 ZF90b19kZW5hbGkobXRkKTsKIAl1bnNpZ25lZCBsb25nIHVuY29yX2VjY19mbGFncyA9IDA7CiAJ aW50IHN0YXQgPSAwOwogCWludCByZXQ7CkBAIC04MTQsNyArODMxLDggQEAgc3RhdGljIGludCBk ZW5hbGlfd3JpdGVfcGFnZShzdHJ1Y3QgbmFuZF9jaGlwICpjaGlwLCBjb25zdCB1aW50OF90ICpi dWYsCiBzdGF0aWMgaW50IGRlbmFsaV9zZXR1cF9kYXRhX2ludGVyZmFjZShzdHJ1Y3QgbmFuZF9j aGlwICpjaGlwLCBpbnQgY2hpcG5yLAogCQkJCSAgICAgICBjb25zdCBzdHJ1Y3QgbmFuZF9kYXRh X2ludGVyZmFjZSAqY29uZikKIHsKLQlzdHJ1Y3QgZGVuYWxpX25hbmRfaW5mbyAqZGVuYWxpID0g bXRkX3RvX2RlbmFsaShuYW5kX3RvX210ZChjaGlwKSk7CisJc3RydWN0IGRlbmFsaV9jb250cm9s bGVyICpkZW5hbGkgPSB0b19kZW5hbGlfY29udHJvbGxlcihjaGlwKTsKKwlzdHJ1Y3QgZGVuYWxp X2NoaXBfc2VsICpzZWw7CiAJY29uc3Qgc3RydWN0IG5hbmRfc2RyX3RpbWluZ3MgKnRpbWluZ3M7 CiAJdW5zaWduZWQgbG9uZyB0X3gsIG11bHRfeDsKIAlpbnQgYWNjX2Nsa3MsIHJlXzJfd2UsIHJl XzJfcmUsIHdlXzJfcmUsIGFkZHJfMl9kYXRhOwpAQCAtODQzLDYgKzg2MSw4IEBAIHN0YXRpYyBp bnQgZGVuYWxpX3NldHVwX2RhdGFfaW50ZXJmYWNlKHN0cnVjdCBuYW5kX2NoaXAgKmNoaXAsIGlu dCBjaGlwbnIsCiAJaWYgKGNoaXBuciA9PSBOQU5EX0RBVEFfSUZBQ0VfQ0hFQ0tfT05MWSkKIAkJ cmV0dXJuIDA7CiAKKwlzZWwgPSAmdG9fZGVuYWxpX2NoaXAoY2hpcCktPnNlbHNbY2hpcG5yXTsK KwogCS8qIHRSRUEgLT4gQUNDX0NMS1MgKi8KIAlhY2NfY2xrcyA9IERJVl9ST1VORF9VUCh0aW1p bmdzLT50UkVBX21heCwgdF94KTsKIAlhY2NfY2xrcyA9IG1pbl90KGludCwgYWNjX2Nsa3MsIEFD Q19DTEtTX19WQUxVRSk7CkBAIC04NTAsNyArODcwLDcgQEAgc3RhdGljIGludCBkZW5hbGlfc2V0 dXBfZGF0YV9pbnRlcmZhY2Uoc3RydWN0IG5hbmRfY2hpcCAqY2hpcCwgaW50IGNoaXBuciwKIAl0 bXAgPSBpb3JlYWQzMihkZW5hbGktPnJlZyArIEFDQ19DTEtTKTsKIAl0bXAgJj0gfkFDQ19DTEtT X19WQUxVRTsKIAl0bXAgfD0gRklFTERfUFJFUChBQ0NfQ0xLU19fVkFMVUUsIGFjY19jbGtzKTsK LQlpb3dyaXRlMzIodG1wLCBkZW5hbGktPnJlZyArIEFDQ19DTEtTKTsKKwlzZWwtPmFjY19jbGtz ID0gdG1wOwogCiAJLyogdFJXSCAtPiBSRV8yX1dFICovCiAJcmVfMl93ZSA9IERJVl9ST1VORF9V UCh0aW1pbmdzLT50UkhXX21pbiwgdF94KTsKQEAgLTg1OSw3ICs4NzksNyBAQCBzdGF0aWMgaW50 IGRlbmFsaV9zZXR1cF9kYXRhX2ludGVyZmFjZShzdHJ1Y3QgbmFuZF9jaGlwICpjaGlwLCBpbnQg Y2hpcG5yLAogCXRtcCA9IGlvcmVhZDMyKGRlbmFsaS0+cmVnICsgUkVfMl9XRSk7CiAJdG1wICY9 IH5SRV8yX1dFX19WQUxVRTsKIAl0bXAgfD0gRklFTERfUFJFUChSRV8yX1dFX19WQUxVRSwgcmVf Ml93ZSk7Ci0JaW93cml0ZTMyKHRtcCwgZGVuYWxpLT5yZWcgKyBSRV8yX1dFKTsKKwlzZWwtPnJl XzJfd2UgPSB0bXA7CiAKIAkvKiB0UkhaIC0+IFJFXzJfUkUgKi8KIAlyZV8yX3JlID0gRElWX1JP VU5EX1VQKHRpbWluZ3MtPnRSSFpfbWF4LCB0X3gpOwpAQCAtODY4LDcgKzg4OCw3IEBAIHN0YXRp YyBpbnQgZGVuYWxpX3NldHVwX2RhdGFfaW50ZXJmYWNlKHN0cnVjdCBuYW5kX2NoaXAgKmNoaXAs IGludCBjaGlwbnIsCiAJdG1wID0gaW9yZWFkMzIoZGVuYWxpLT5yZWcgKyBSRV8yX1JFKTsKIAl0 bXAgJj0gflJFXzJfUkVfX1ZBTFVFOwogCXRtcCB8PSBGSUVMRF9QUkVQKFJFXzJfUkVfX1ZBTFVF LCByZV8yX3JlKTsKLQlpb3dyaXRlMzIodG1wLCBkZW5hbGktPnJlZyArIFJFXzJfUkUpOworCXNl bC0+cmVfMl9yZSA9IHRtcDsKIAogCS8qCiAJICogdENDUywgdFdIUiAtPiBXRV8yX1JFCkBAIC04 ODIsNyArOTAyLDcgQEAgc3RhdGljIGludCBkZW5hbGlfc2V0dXBfZGF0YV9pbnRlcmZhY2Uoc3Ry dWN0IG5hbmRfY2hpcCAqY2hpcCwgaW50IGNoaXBuciwKIAl0bXAgPSBpb3JlYWQzMihkZW5hbGkt PnJlZyArIFRXSFIyX0FORF9XRV8yX1JFKTsKIAl0bXAgJj0gflRXSFIyX0FORF9XRV8yX1JFX19X RV8yX1JFOwogCXRtcCB8PSBGSUVMRF9QUkVQKFRXSFIyX0FORF9XRV8yX1JFX19XRV8yX1JFLCB3 ZV8yX3JlKTsKLQlpb3dyaXRlMzIodG1wLCBkZW5hbGktPnJlZyArIFRXSFIyX0FORF9XRV8yX1JF KTsKKwlzZWwtPmh3aHIyX2FuZF93ZV8yX3JlID0gdG1wOwogCiAJLyogdEFETCAtPiBBRERSXzJf REFUQSAqLwogCkBAIC04OTcsNyArOTE3LDcgQEAgc3RhdGljIGludCBkZW5hbGlfc2V0dXBfZGF0 YV9pbnRlcmZhY2Uoc3RydWN0IG5hbmRfY2hpcCAqY2hpcCwgaW50IGNoaXBuciwKIAl0bXAgPSBp b3JlYWQzMihkZW5hbGktPnJlZyArIFRDV0FXX0FORF9BRERSXzJfREFUQSk7CiAJdG1wICY9IH5U Q1dBV19BTkRfQUREUl8yX0RBVEFfX0FERFJfMl9EQVRBOwogCXRtcCB8PSBGSUVMRF9QUkVQKFRD V0FXX0FORF9BRERSXzJfREFUQV9fQUREUl8yX0RBVEEsIGFkZHJfMl9kYXRhKTsKLQlpb3dyaXRl MzIodG1wLCBkZW5hbGktPnJlZyArIFRDV0FXX0FORF9BRERSXzJfREFUQSk7CisJc2VsLT50Y3dh d19hbmRfYWRkcl8yX2RhdGEgPSB0bXA7CiAKIAkvKiB0UkVILCB0V0ggLT4gUkRXUl9FTl9ISV9D TlQgKi8KIAlyZHdyX2VuX2hpID0gRElWX1JPVU5EX1VQKG1heCh0aW1pbmdzLT50UkVIX21pbiwg dGltaW5ncy0+dFdIX21pbiksCkBAIC05MDcsNyArOTI3LDcgQEAgc3RhdGljIGludCBkZW5hbGlf c2V0dXBfZGF0YV9pbnRlcmZhY2Uoc3RydWN0IG5hbmRfY2hpcCAqY2hpcCwgaW50IGNoaXBuciwK IAl0bXAgPSBpb3JlYWQzMihkZW5hbGktPnJlZyArIFJEV1JfRU5fSElfQ05UKTsKIAl0bXAgJj0g flJEV1JfRU5fSElfQ05UX19WQUxVRTsKIAl0bXAgfD0gRklFTERfUFJFUChSRFdSX0VOX0hJX0NO VF9fVkFMVUUsIHJkd3JfZW5faGkpOwotCWlvd3JpdGUzMih0bXAsIGRlbmFsaS0+cmVnICsgUkRX Ul9FTl9ISV9DTlQpOworCXNlbC0+cmR3cl9lbl9oaV9jbnQgPSB0bXA7CiAKIAkvKiB0UlAsIHRX UCAtPiBSRFdSX0VOX0xPX0NOVCAqLwogCXJkd3JfZW5fbG8gPSBESVZfUk9VTkRfVVAobWF4KHRp bWluZ3MtPnRSUF9taW4sIHRpbWluZ3MtPnRXUF9taW4pLCB0X3gpOwpAQCAtOTIwLDcgKzk0MCw3 IEBAIHN0YXRpYyBpbnQgZGVuYWxpX3NldHVwX2RhdGFfaW50ZXJmYWNlKHN0cnVjdCBuYW5kX2No aXAgKmNoaXAsIGludCBjaGlwbnIsCiAJdG1wID0gaW9yZWFkMzIoZGVuYWxpLT5yZWcgKyBSRFdS X0VOX0xPX0NOVCk7CiAJdG1wICY9IH5SRFdSX0VOX0xPX0NOVF9fVkFMVUU7CiAJdG1wIHw9IEZJ RUxEX1BSRVAoUkRXUl9FTl9MT19DTlRfX1ZBTFVFLCByZHdyX2VuX2xvKTsKLQlpb3dyaXRlMzIo dG1wLCBkZW5hbGktPnJlZyArIFJEV1JfRU5fTE9fQ05UKTsKKwlzZWwtPnJkd3JfZW5fbG9fY250 ID0gdG1wOwogCiAJLyogdENTLCB0Q0VBIC0+IENTX1NFVFVQX0NOVCAqLwogCWNzX3NldHVwID0g bWF4MygoaW50KURJVl9ST1VORF9VUCh0aW1pbmdzLT50Q1NfbWluLCB0X3gpIC0gcmR3cl9lbl9s bywKQEAgLTkzMSwzOSArOTUxLDExIEBAIHN0YXRpYyBpbnQgZGVuYWxpX3NldHVwX2RhdGFfaW50 ZXJmYWNlKHN0cnVjdCBuYW5kX2NoaXAgKmNoaXAsIGludCBjaGlwbnIsCiAJdG1wID0gaW9yZWFk MzIoZGVuYWxpLT5yZWcgKyBDU19TRVRVUF9DTlQpOwogCXRtcCAmPSB+Q1NfU0VUVVBfQ05UX19W QUxVRTsKIAl0bXAgfD0gRklFTERfUFJFUChDU19TRVRVUF9DTlRfX1ZBTFVFLCBjc19zZXR1cCk7 Ci0JaW93cml0ZTMyKHRtcCwgZGVuYWxpLT5yZWcgKyBDU19TRVRVUF9DTlQpOworCXNlbC0+Y3Nf c2V0dXBfY250ID0gdG1wOwogCiAJcmV0dXJuIDA7CiB9CiAKLXN0YXRpYyB2b2lkIGRlbmFsaV9o d19pbml0KHN0cnVjdCBkZW5hbGlfbmFuZF9pbmZvICpkZW5hbGkpCi17Ci0JLyoKLQkgKiBUaGUg UkVWSVNJT04gcmVnaXN0ZXIgbWF5IG5vdCBiZSByZWxpYWJsZS4gIFBsYXRmb3JtcyBhcmUgYWxs b3dlZCB0bwotCSAqIG92ZXJyaWRlIGl0LgotCSAqLwotCWlmICghZGVuYWxpLT5yZXZpc2lvbikK LQkJZGVuYWxpLT5yZXZpc2lvbiA9IHN3YWIxNihpb3JlYWQzMihkZW5hbGktPnJlZyArIFJFVklT SU9OKSk7Ci0KLQkvKgotCSAqIFNldCBob3cgbWFueSBieXRlcyBzaG91bGQgYmUgc2tpcHBlZCBi ZWZvcmUgd3JpdGluZyBkYXRhIGluIE9PQi4KLQkgKiBJZiBhIG5vbi16ZXJvIHZhbHVlIGhhcyBh bHJlYWR5IGJlZW4gc2V0IChieSBmaXJtd2FyZSBvciBzb21ldGhpbmcpLAotCSAqIGp1c3QgdXNl IGl0LiAgT3RoZXJ3aXNlLCBzZXQgdGhlIGRyaXZlciBkZWZhdWx0LgotCSAqLwotCWRlbmFsaS0+ b29iX3NraXBfYnl0ZXMgPSBpb3JlYWQzMihkZW5hbGktPnJlZyArIFNQQVJFX0FSRUFfU0tJUF9C WVRFUyk7Ci0JaWYgKCFkZW5hbGktPm9vYl9za2lwX2J5dGVzKSB7Ci0JCWRlbmFsaS0+b29iX3Nr aXBfYnl0ZXMgPSBERU5BTElfREVGQVVMVF9PT0JfU0tJUF9CWVRFUzsKLQkJaW93cml0ZTMyKGRl bmFsaS0+b29iX3NraXBfYnl0ZXMsCi0JCQkgIGRlbmFsaS0+cmVnICsgU1BBUkVfQVJFQV9TS0lQ X0JZVEVTKTsKLQl9Ci0KLQlkZW5hbGlfZGV0ZWN0X21heF9iYW5rcyhkZW5hbGkpOwotCWlvd3Jp dGUzMigweDBGLCBkZW5hbGktPnJlZyArIFJCX1BJTl9FTkFCTEVEKTsKLQlpb3dyaXRlMzIoQ0hJ UF9FTl9ET05UX0NBUkVfX0ZMQUcsIGRlbmFsaS0+cmVnICsgQ0hJUF9FTkFCTEVfRE9OVF9DQVJF KTsKLQotCWlvd3JpdGUzMigweGZmZmYsIGRlbmFsaS0+cmVnICsgU1BBUkVfQVJFQV9NQVJLRVIp OwotfQotCiBpbnQgZGVuYWxpX2NhbGNfZWNjX2J5dGVzKGludCBzdGVwX3NpemUsIGludCBzdHJl bmd0aCkKIHsKIAkvKiBCQ0ggY29kZS4gIERlbmFsaSByZXF1aXJlcyBlY2MuYnl0ZXMgdG8gYmUg bXVsdGlwbGUgb2YgMiAqLwpAQCAtOTc0LDEwICs5NjYsMTAgQEAgRVhQT1JUX1NZTUJPTChkZW5h bGlfY2FsY19lY2NfYnl0ZXMpOwogc3RhdGljIGludCBkZW5hbGlfb29ibGF5b3V0X2VjYyhzdHJ1 Y3QgbXRkX2luZm8gKm10ZCwgaW50IHNlY3Rpb24sCiAJCQkJc3RydWN0IG10ZF9vb2JfcmVnaW9u ICpvb2JyZWdpb24pCiB7Ci0Jc3RydWN0IGRlbmFsaV9uYW5kX2luZm8gKmRlbmFsaSA9IG10ZF90 b19kZW5hbGkobXRkKTsKIAlzdHJ1Y3QgbmFuZF9jaGlwICpjaGlwID0gbXRkX3RvX25hbmQobXRk KTsKKwlzdHJ1Y3QgZGVuYWxpX2NvbnRyb2xsZXIgKmRlbmFsaSA9IHRvX2RlbmFsaV9jb250cm9s bGVyKGNoaXApOwogCi0JaWYgKHNlY3Rpb24pCisJaWYgKHNlY3Rpb24gPiAwKQogCQlyZXR1cm4g LUVSQU5HRTsKIAogCW9vYnJlZ2lvbi0+b2Zmc2V0ID0gZGVuYWxpLT5vb2Jfc2tpcF9ieXRlczsK QEAgLTk4OSwxMCArOTgxLDEwIEBAIHN0YXRpYyBpbnQgZGVuYWxpX29vYmxheW91dF9lY2Moc3Ry dWN0IG10ZF9pbmZvICptdGQsIGludCBzZWN0aW9uLAogc3RhdGljIGludCBkZW5hbGlfb29ibGF5 b3V0X2ZyZWUoc3RydWN0IG10ZF9pbmZvICptdGQsIGludCBzZWN0aW9uLAogCQkJCSBzdHJ1Y3Qg bXRkX29vYl9yZWdpb24gKm9vYnJlZ2lvbikKIHsKLQlzdHJ1Y3QgZGVuYWxpX25hbmRfaW5mbyAq ZGVuYWxpID0gbXRkX3RvX2RlbmFsaShtdGQpOwogCXN0cnVjdCBuYW5kX2NoaXAgKmNoaXAgPSBt dGRfdG9fbmFuZChtdGQpOworCXN0cnVjdCBkZW5hbGlfY29udHJvbGxlciAqZGVuYWxpID0gdG9f ZGVuYWxpX2NvbnRyb2xsZXIoY2hpcCk7CiAKLQlpZiAoc2VjdGlvbikKKwlpZiAoc2VjdGlvbiA+ IDApCiAJCXJldHVybiAtRVJBTkdFOwogCiAJb29icmVnaW9uLT5vZmZzZXQgPSBjaGlwLT5lY2Mu dG90YWwgKyBkZW5hbGktPm9vYl9za2lwX2J5dGVzOwpAQCAtMTAwOCw3ICsxMDAwLDcgQEAgc3Rh dGljIGNvbnN0IHN0cnVjdCBtdGRfb29ibGF5b3V0X29wcyBkZW5hbGlfb29ibGF5b3V0X29wcyA9 IHsKIAogc3RhdGljIGludCBkZW5hbGlfbXVsdGlkZXZfZml4dXAoc3RydWN0IG5hbmRfY2hpcCAq Y2hpcCkKIHsKLQlzdHJ1Y3QgZGVuYWxpX25hbmRfaW5mbyAqZGVuYWxpID0gdG9fZGVuYWxpKGNo aXApOworCXN0cnVjdCBkZW5hbGlfY29udHJvbGxlciAqZGVuYWxpID0gdG9fZGVuYWxpX2NvbnRy b2xsZXIoY2hpcCk7CiAJc3RydWN0IG10ZF9pbmZvICptdGQgPSBuYW5kX3RvX210ZChjaGlwKTsK IAogCS8qCkBAIC0xMDU5LDM4ICsxMDUxLDExIEBAIHN0YXRpYyBpbnQgZGVuYWxpX211bHRpZGV2 X2ZpeHVwKHN0cnVjdCBuYW5kX2NoaXAgKmNoaXApCiAKIHN0YXRpYyBpbnQgZGVuYWxpX2F0dGFj aF9jaGlwKHN0cnVjdCBuYW5kX2NoaXAgKmNoaXApCiB7CisJc3RydWN0IGRlbmFsaV9jb250cm9s bGVyICpkZW5hbGkgPSB0b19kZW5hbGlfY29udHJvbGxlcihjaGlwKTsKKwlzdHJ1Y3QgZGVuYWxp X2NoaXAgKmRjaGlwID0gdG9fZGVuYWxpX2NoaXAoY2hpcCk7CiAJc3RydWN0IG10ZF9pbmZvICpt dGQgPSBuYW5kX3RvX210ZChjaGlwKTsKLQlzdHJ1Y3QgZGVuYWxpX25hbmRfaW5mbyAqZGVuYWxp ID0gbXRkX3RvX2RlbmFsaShtdGQpOwogCWludCByZXQ7CiAKLQlpZiAoaW9yZWFkMzIoZGVuYWxp LT5yZWcgKyBGRUFUVVJFUykgJiBGRUFUVVJFU19fRE1BKQotCQlkZW5hbGktPmRtYV9hdmFpbCA9 IHRydWU7Ci0KLQlpZiAoZGVuYWxpLT5kbWFfYXZhaWwpIHsKLQkJaW50IGRtYV9iaXQgPSBkZW5h bGktPmNhcHMgJiBERU5BTElfQ0FQX0RNQV82NEJJVCA/IDY0IDogMzI7Ci0KLQkJcmV0ID0gZG1h X3NldF9tYXNrKGRlbmFsaS0+ZGV2LCBETUFfQklUX01BU0soZG1hX2JpdCkpOwotCQlpZiAocmV0 KSB7Ci0JCQlkZXZfaW5mbyhkZW5hbGktPmRldiwKLQkJCQkgIkZhaWxlZCB0byBzZXQgRE1BIG1h c2suIERpc2FibGluZyBETUEuXG4iKTsKLQkJCWRlbmFsaS0+ZG1hX2F2YWlsID0gZmFsc2U7Ci0J CX0KLQl9Ci0KLQlpZiAoZGVuYWxpLT5kbWFfYXZhaWwpIHsKLQkJY2hpcC0+b3B0aW9ucyB8PSBO QU5EX1VTRV9CT1VOQ0VfQlVGRkVSOwotCQljaGlwLT5idWZfYWxpZ24gPSAxNjsKLQkJaWYgKGRl bmFsaS0+Y2FwcyAmIERFTkFMSV9DQVBfRE1BXzY0QklUKQotCQkJZGVuYWxpLT5zZXR1cF9kbWEg PSBkZW5hbGlfc2V0dXBfZG1hNjQ7Ci0JCWVsc2UKLQkJCWRlbmFsaS0+c2V0dXBfZG1hID0gZGVu YWxpX3NldHVwX2RtYTMyOwotCX0KLQotCWNoaXAtPmJidF9vcHRpb25zIHw9IE5BTkRfQkJUX1VT RV9GTEFTSDsKLQljaGlwLT5iYnRfb3B0aW9ucyB8PSBOQU5EX0JCVF9OT19PT0I7Ci0JY2hpcC0+ ZWNjLm1vZGUgPSBOQU5EX0VDQ19IV19TWU5EUk9NRTsKLQljaGlwLT5vcHRpb25zIHw9IE5BTkRf Tk9fU1VCUEFHRV9XUklURTsKLQogCXJldCA9IG5hbmRfZWNjX2Nob29zZV9jb25mKGNoaXAsIGRl bmFsaS0+ZWNjX2NhcHMsCiAJCQkJICAgbXRkLT5vb2JzaXplIC0gZGVuYWxpLT5vb2Jfc2tpcF9i eXRlcyk7CiAJaWYgKHJldCkgewpAQCAtMTEwMiwzMyArMTA2Nyw2IEBAIHN0YXRpYyBpbnQgZGVu YWxpX2F0dGFjaF9jaGlwKHN0cnVjdCBuYW5kX2NoaXAgKmNoaXApCiAJCSJjaG9zZW4gRUNDIHNl dHRpbmdzOiBzdGVwPSVkLCBzdHJlbmd0aD0lZCwgYnl0ZXM9JWRcbiIsCiAJCWNoaXAtPmVjYy5z aXplLCBjaGlwLT5lY2Muc3RyZW5ndGgsIGNoaXAtPmVjYy5ieXRlcyk7CiAKLQlpb3dyaXRlMzIo RklFTERfUFJFUChFQ0NfQ09SUkVDVElPTl9fRVJBU0VfVEhSRVNIT0xELCAxKSB8Ci0JCSAgRklF TERfUFJFUChFQ0NfQ09SUkVDVElPTl9fVkFMVUUsIGNoaXAtPmVjYy5zdHJlbmd0aCksCi0JCSAg ZGVuYWxpLT5yZWcgKyBFQ0NfQ09SUkVDVElPTik7Ci0JaW93cml0ZTMyKG10ZC0+ZXJhc2VzaXpl IC8gbXRkLT53cml0ZXNpemUsCi0JCSAgZGVuYWxpLT5yZWcgKyBQQUdFU19QRVJfQkxPQ0spOwot CWlvd3JpdGUzMihjaGlwLT5vcHRpb25zICYgTkFORF9CVVNXSURUSF8xNiA/IDEgOiAwLAotCQkg IGRlbmFsaS0+cmVnICsgREVWSUNFX1dJRFRIKTsKLQlpb3dyaXRlMzIoY2hpcC0+b3B0aW9ucyAm IE5BTkRfUk9XX0FERFJfMyA/IDAgOiBUV09fUk9XX0FERFJfQ1lDTEVTX19GTEFHLAotCQkgIGRl bmFsaS0+cmVnICsgVFdPX1JPV19BRERSX0NZQ0xFUyk7Ci0JaW93cml0ZTMyKG10ZC0+d3JpdGVz aXplLCBkZW5hbGktPnJlZyArIERFVklDRV9NQUlOX0FSRUFfU0laRSk7Ci0JaW93cml0ZTMyKG10 ZC0+b29ic2l6ZSwgZGVuYWxpLT5yZWcgKyBERVZJQ0VfU1BBUkVfQVJFQV9TSVpFKTsKLQotCWlv d3JpdGUzMihjaGlwLT5lY2Muc2l6ZSwgZGVuYWxpLT5yZWcgKyBDRkdfREFUQV9CTE9DS19TSVpF KTsKLQlpb3dyaXRlMzIoY2hpcC0+ZWNjLnNpemUsIGRlbmFsaS0+cmVnICsgQ0ZHX0xBU1RfREFU QV9CTE9DS19TSVpFKTsKLQkvKiBjaGlwLT5lY2Muc3RlcHMgaXMgc2V0IGJ5IG5hbmRfc2Nhbl90 YWlsKCk7IG5vdCBhdmFpbGFibGUgaGVyZSAqLwotCWlvd3JpdGUzMihtdGQtPndyaXRlc2l6ZSAv IGNoaXAtPmVjYy5zaXplLAotCQkgIGRlbmFsaS0+cmVnICsgQ0ZHX05VTV9EQVRBX0JMT0NLUyk7 Ci0KLQltdGRfc2V0X29vYmxheW91dChtdGQsICZkZW5hbGlfb29ibGF5b3V0X29wcyk7Ci0KLQlj aGlwLT5lY2MucmVhZF9wYWdlID0gZGVuYWxpX3JlYWRfcGFnZTsKLQljaGlwLT5lY2MucmVhZF9w YWdlX3JhdyA9IGRlbmFsaV9yZWFkX3BhZ2VfcmF3OwotCWNoaXAtPmVjYy53cml0ZV9wYWdlID0g ZGVuYWxpX3dyaXRlX3BhZ2U7Ci0JY2hpcC0+ZWNjLndyaXRlX3BhZ2VfcmF3ID0gZGVuYWxpX3dy aXRlX3BhZ2VfcmF3OwotCWNoaXAtPmVjYy5yZWFkX29vYiA9IGRlbmFsaV9yZWFkX29vYjsKLQlj aGlwLT5lY2Mud3JpdGVfb29iID0gZGVuYWxpX3dyaXRlX29vYjsKLQogCXJldCA9IGRlbmFsaV9t dWx0aWRldl9maXh1cChjaGlwKTsKIAlpZiAocmV0KQogCQlyZXR1cm4gcmV0OwpAQCAtMTEzOCw4 ICsxMDc2LDggQEAgc3RhdGljIGludCBkZW5hbGlfYXR0YWNoX2NoaXAoc3RydWN0IG5hbmRfY2hp cCAqY2hpcCkKIAkgKiB1c2UgZGV2bV9rbWFsbG9jKCkgYmVjYXVzZSB0aGUgbWVtb3J5IGFsbG9j YXRlZCBieSBkZXZtXyBkb2VzIG5vdAogCSAqIGd1YXJhbnRlZSBETUEtc2FmZSBhbGlnbm1lbnQu CiAJICovCi0JZGVuYWxpLT5idWYgPSBrbWFsbG9jKG10ZC0+d3JpdGVzaXplICsgbXRkLT5vb2Jz aXplLCBHRlBfS0VSTkVMKTsKLQlpZiAoIWRlbmFsaS0+YnVmKQorCWRjaGlwLT5idWYgPSBrbWFs bG9jKG10ZC0+d3JpdGVzaXplICsgbXRkLT5vb2JzaXplLCBHRlBfS0VSTkVMKTsKKwlpZiAoIWRj aGlwLT5idWYpCiAJCXJldHVybiAtRU5PTUVNOwogCiAJcmV0dXJuIDA7CkBAIC0xMTQ3LDEzICsx MDg1LDEyIEBAIHN0YXRpYyBpbnQgZGVuYWxpX2F0dGFjaF9jaGlwKHN0cnVjdCBuYW5kX2NoaXAg KmNoaXApCiAKIHN0YXRpYyB2b2lkIGRlbmFsaV9kZXRhY2hfY2hpcChzdHJ1Y3QgbmFuZF9jaGlw ICpjaGlwKQogewotCXN0cnVjdCBtdGRfaW5mbyAqbXRkID0gbmFuZF90b19tdGQoY2hpcCk7Ci0J c3RydWN0IGRlbmFsaV9uYW5kX2luZm8gKmRlbmFsaSA9IG10ZF90b19kZW5hbGkobXRkKTsKKwlz dHJ1Y3QgZGVuYWxpX2NoaXAgKmRjaGlwID0gdG9fZGVuYWxpX2NoaXAoY2hpcCk7CiAKLQlrZnJl ZShkZW5hbGktPmJ1Zik7CisJa2ZyZWUoZGNoaXAtPmJ1Zik7CiB9CiAKLXN0YXRpYyB2b2lkIGRl bmFsaV9leGVjX2luOChzdHJ1Y3QgZGVuYWxpX25hbmRfaW5mbyAqZGVuYWxpLCB1MzIgdHlwZSwK K3N0YXRpYyB2b2lkIGRlbmFsaV9leGVjX2luOChzdHJ1Y3QgZGVuYWxpX2NvbnRyb2xsZXIgKmRl bmFsaSwgdTMyIHR5cGUsCiAJCQkgICAgdTggKmJ1ZiwgdW5zaWduZWQgaW50IGxlbikKIHsKIAlp bnQgaTsKQEAgLTExNjIsNyArMTA5OSw3IEBAIHN0YXRpYyB2b2lkIGRlbmFsaV9leGVjX2luOChz dHJ1Y3QgZGVuYWxpX25hbmRfaW5mbyAqZGVuYWxpLCB1MzIgdHlwZSwKIAkJYnVmW2ldID0gZGVu YWxpLT5ob3N0X3JlYWQoZGVuYWxpLCB0eXBlIHwgREVOQUxJX0JBTksoZGVuYWxpKSk7CiB9CiAK LXN0YXRpYyB2b2lkIGRlbmFsaV9leGVjX2luMTYoc3RydWN0IGRlbmFsaV9uYW5kX2luZm8gKmRl bmFsaSwgdTMyIHR5cGUsCitzdGF0aWMgdm9pZCBkZW5hbGlfZXhlY19pbjE2KHN0cnVjdCBkZW5h bGlfY29udHJvbGxlciAqZGVuYWxpLCB1MzIgdHlwZSwKIAkJCSAgICAgdTggKmJ1ZiwgdW5zaWdu ZWQgaW50IGxlbikKIHsKIAl1MzIgZGF0YTsKQEAgLTExNzYsNyArMTExMyw3IEBAIHN0YXRpYyB2 b2lkIGRlbmFsaV9leGVjX2luMTYoc3RydWN0IGRlbmFsaV9uYW5kX2luZm8gKmRlbmFsaSwgdTMy IHR5cGUsCiAJfQogfQogCi1zdGF0aWMgdm9pZCBkZW5hbGlfZXhlY19vdXQ4KHN0cnVjdCBkZW5h bGlfbmFuZF9pbmZvICpkZW5hbGksIHUzMiB0eXBlLAorc3RhdGljIHZvaWQgZGVuYWxpX2V4ZWNf b3V0OChzdHJ1Y3QgZGVuYWxpX2NvbnRyb2xsZXIgKmRlbmFsaSwgdTMyIHR5cGUsCiAJCQkgICAg IGNvbnN0IHU4ICpidWYsIHVuc2lnbmVkIGludCBsZW4pCiB7CiAJaW50IGk7CkBAIC0xMTg1LDcg KzExMjIsNyBAQCBzdGF0aWMgdm9pZCBkZW5hbGlfZXhlY19vdXQ4KHN0cnVjdCBkZW5hbGlfbmFu ZF9pbmZvICpkZW5hbGksIHUzMiB0eXBlLAogCQlkZW5hbGktPmhvc3Rfd3JpdGUoZGVuYWxpLCB0 eXBlIHwgREVOQUxJX0JBTksoZGVuYWxpKSwgYnVmW2ldKTsKIH0KIAotc3RhdGljIHZvaWQgZGVu YWxpX2V4ZWNfb3V0MTYoc3RydWN0IGRlbmFsaV9uYW5kX2luZm8gKmRlbmFsaSwgdTMyIHR5cGUs CitzdGF0aWMgdm9pZCBkZW5hbGlfZXhlY19vdXQxNihzdHJ1Y3QgZGVuYWxpX2NvbnRyb2xsZXIg KmRlbmFsaSwgdTMyIHR5cGUsCiAJCQkgICAgICBjb25zdCB1OCAqYnVmLCB1bnNpZ25lZCBpbnQg bGVuKQogewogCWludCBpOwpAQCAtMTE5NSw3ICsxMTMyLDcgQEAgc3RhdGljIHZvaWQgZGVuYWxp X2V4ZWNfb3V0MTYoc3RydWN0IGRlbmFsaV9uYW5kX2luZm8gKmRlbmFsaSwgdTMyIHR5cGUsCiAJ CQkJICAgYnVmW2kgKyAxXSA8PCAxNiB8IGJ1ZltpXSk7CiB9CiAKLXN0YXRpYyBpbnQgZGVuYWxp X2V4ZWNfd2FpdHJkeShzdHJ1Y3QgZGVuYWxpX25hbmRfaW5mbyAqZGVuYWxpKQorc3RhdGljIGlu dCBkZW5hbGlfZXhlY193YWl0cmR5KHN0cnVjdCBkZW5hbGlfY29udHJvbGxlciAqZGVuYWxpKQog ewogCXUzMiBpcnFfc3RhdDsKIApAQCAtMTIxMSw3ICsxMTQ4LDcgQEAgc3RhdGljIGludCBkZW5h bGlfZXhlY193YWl0cmR5KHN0cnVjdCBkZW5hbGlfbmFuZF9pbmZvICpkZW5hbGkpCiBzdGF0aWMg aW50IGRlbmFsaV9leGVjX2luc3RyKHN0cnVjdCBuYW5kX2NoaXAgKmNoaXAsCiAJCQkgICAgIGNv bnN0IHN0cnVjdCBuYW5kX29wX2luc3RyICppbnN0cikKIHsKLQlzdHJ1Y3QgZGVuYWxpX25hbmRf aW5mbyAqZGVuYWxpID0gdG9fZGVuYWxpKGNoaXApOworCXN0cnVjdCBkZW5hbGlfY29udHJvbGxl ciAqZGVuYWxpID0gdG9fZGVuYWxpX2NvbnRyb2xsZXIoY2hpcCk7CiAJYm9vbCB3aWR0aDE2ID0g Y2hpcC0+b3B0aW9ucyAmIE5BTkRfQlVTV0lEVEhfMTY7CiAKIAlzd2l0Y2ggKGluc3RyLT50eXBl KSB7CkBAIC0xMjYyLDcgKzExOTksNyBAQCBzdGF0aWMgaW50IGRlbmFsaV9leGVjX29wKHN0cnVj dCBuYW5kX2NoaXAgKmNoaXAsCiAJICogU29tZSBjb21tYW5kcyBjb250YWluIE5BTkRfT1BfV0FJ VFJEWV9JTlNUUi4KIAkgKiBpcnEgbXVzdCBiZSBjbGVhcmVkIGhlcmUgdG8gY2F0Y2ggdGhlIFIv QiMgaW50ZXJydXB0IHRoZXJlLgogCSAqLwotCWRlbmFsaV9yZXNldF9pcnEodG9fZGVuYWxpKGNo aXApKTsKKwlkZW5hbGlfcmVzZXRfaXJxKHRvX2RlbmFsaV9jb250cm9sbGVyKGNoaXApKTsKIAog CWZvciAoaSA9IDA7IGkgPCBvcC0+bmluc3RyczsgaSsrKSB7CiAJCXJldCA9IGRlbmFsaV9leGVj X2luc3RyKGNoaXAsICZvcC0+aW5zdHJzW2ldKTsKQEAgLTEyODAsNTMgKzEyMTcsODAgQEAgc3Rh dGljIGNvbnN0IHN0cnVjdCBuYW5kX2NvbnRyb2xsZXJfb3BzIGRlbmFsaV9jb250cm9sbGVyX29w cyA9IHsKIAkuc2V0dXBfZGF0YV9pbnRlcmZhY2UgPSBkZW5hbGlfc2V0dXBfZGF0YV9pbnRlcmZh Y2UsCiB9OwogCi1pbnQgZGVuYWxpX2luaXQoc3RydWN0IGRlbmFsaV9uYW5kX2luZm8gKmRlbmFs aSkKK2ludCBkZW5hbGlfY2hpcF9pbml0KHN0cnVjdCBkZW5hbGlfY29udHJvbGxlciAqZGVuYWxp LAorCQkgICAgIHN0cnVjdCBkZW5hbGlfY2hpcCAqZGNoaXApCiB7Ci0Jc3RydWN0IG5hbmRfY2hp cCAqY2hpcCA9ICZkZW5hbGktPm5hbmQ7CisJc3RydWN0IG5hbmRfY2hpcCAqY2hpcCA9ICZkY2hp cC0+Y2hpcDsKIAlzdHJ1Y3QgbXRkX2luZm8gKm10ZCA9IG5hbmRfdG9fbXRkKGNoaXApOwotCXUz MiBmZWF0dXJlcyA9IGlvcmVhZDMyKGRlbmFsaS0+cmVnICsgRkVBVFVSRVMpOwotCWludCByZXQ7 CisJc3RydWN0IGRlbmFsaV9jaGlwICpkY2hpcDI7CisJaW50IGksIGosIHJldDsKIAotCW10ZC0+ ZGV2LnBhcmVudCA9IGRlbmFsaS0+ZGV2OwotCWRlbmFsaV9od19pbml0KGRlbmFsaSk7CisJY2hp cC0+Y29udHJvbGxlciA9ICZkZW5hbGktPmNvbnRyb2xsZXI7CiAKLQlpbml0X2NvbXBsZXRpb24o JmRlbmFsaS0+Y29tcGxldGUpOwotCXNwaW5fbG9ja19pbml0KCZkZW5hbGktPmlycV9sb2NrKTsK KwkvKiBzYW5pdHkgY2hlY2tzIGZvciBiYW5rIG51bWJlcnMgKi8KKwlmb3IgKGkgPSAwOyBpIDwg ZGNoaXAtPm5zZWxzOyBpKyspIHsKKwkJdW5zaWduZWQgaW50IGJhbmsgPSBkY2hpcC0+c2Vsc1tp XS5iYW5rOwogCi0JZGVuYWxpX2NsZWFyX2lycV9hbGwoZGVuYWxpKTsKKwkJaWYgKGJhbmsgPj0g ZGVuYWxpLT5uYmFua3MpIHsKKwkJCWRldl9lcnIoZGVuYWxpLT5kZXYsICJ1bnN1cHBvcnRlZCBi YW5rICVkXG4iLCBiYW5rKTsKKwkJCXJldHVybiAtRUlOVkFMOworCQl9CiAKLQlyZXQgPSBkZXZt X3JlcXVlc3RfaXJxKGRlbmFsaS0+ZGV2LCBkZW5hbGktPmlycSwgZGVuYWxpX2lzciwKLQkJCSAg ICAgICBJUlFGX1NIQVJFRCwgREVOQUxJX05BTkRfTkFNRSwgZGVuYWxpKTsKLQlpZiAocmV0KSB7 Ci0JCWRldl9lcnIoZGVuYWxpLT5kZXYsICJVbmFibGUgdG8gcmVxdWVzdCBJUlFcbiIpOwotCQly ZXR1cm4gcmV0OwotCX0KKwkJZm9yIChqID0gMDsgaiA8IGk7IGorKykgeworCQkJaWYgKGJhbmsg PT0gZGNoaXAtPnNlbHNbal0uYmFuaykgeworCQkJCWRldl9lcnIoZGVuYWxpLT5kZXYsCisJCQkJ CSJiYW5rICVkIGlzIGFzc2lnbmVkIHR3aWNlIGluIHRoZSBzYW1lIGNoaXBcbiIsCisJCQkJCWJh bmspOworCQkJCXJldHVybiAtRUlOVkFMOworCQkJfQorCQl9CiAKLQlkZW5hbGlfZW5hYmxlX2ly cShkZW5hbGkpOworCQlsaXN0X2Zvcl9lYWNoX2VudHJ5KGRjaGlwMiwgJmRlbmFsaS0+Y2hpcHMs IG5vZGUpIHsKKwkJCWZvciAoaiA9IDA7IGogPCBkY2hpcDItPm5zZWxzOyBqKyspIHsKKwkJCQlp ZiAoYmFuayA9PSBkY2hpcDItPnNlbHNbal0uYmFuaykgeworCQkJCQlkZXZfZXJyKGRlbmFsaS0+ ZGV2LAorCQkJCQkJImJhbmsgJWQgaXMgYWxyZWFkeSB1c2VkXG4iLAorCQkJCQkJYmFuayk7CisJ CQkJCXJldHVybiAtRUlOVkFMOworCQkJCX0KKwkJCX0KKwkJfQorCX0KIAotCWRlbmFsaS0+YWN0 aXZlX2JhbmsgPSBERU5BTElfSU5WQUxJRF9CQU5LOworCW10ZC0+ZGV2LnBhcmVudCA9IGRlbmFs aS0+ZGV2OwogCi0JbmFuZF9zZXRfZmxhc2hfbm9kZShjaGlwLCBkZW5hbGktPmRldi0+b2Zfbm9k ZSk7Ci0JLyogRmFsbGJhY2sgdG8gdGhlIGRlZmF1bHQgbmFtZSBpZiBEVCBkaWQgbm90IGdpdmUg ImxhYmVsIiBwcm9wZXJ0eSAqLwotCWlmICghbXRkLT5uYW1lKQorCS8qCisJICogRmFsbGJhY2sg dG8gdGhlIGRlZmF1bHQgbmFtZSBpZiBEVCBkaWQgbm90IGdpdmUgImxhYmVsIiBwcm9wZXJ0eS4K KwkgKiBVc2UgImxhYmVsIiBwcm9wZXJ0eSBpZiBtdWx0aXBsZSBjaGlwcyBhcmUgY29ubmVjdGVk LgorCSAqLworCWlmICghbXRkLT5uYW1lICYmIGxpc3RfZW1wdHkoJmRlbmFsaS0+Y2hpcHMpKQog CQltdGQtPm5hbWUgPSAiZGVuYWxpLW5hbmQiOwogCi0JaWYgKGZlYXR1cmVzICYgRkVBVFVSRVNf X0lOREVYX0FERFIpIHsKLQkJZGVuYWxpLT5ob3N0X3JlYWQgPSBkZW5hbGlfaW5kZXhlZF9yZWFk OwotCQlkZW5hbGktPmhvc3Rfd3JpdGUgPSBkZW5hbGlfaW5kZXhlZF93cml0ZTsKLQl9IGVsc2Ug ewotCQlkZW5hbGktPmhvc3RfcmVhZCA9IGRlbmFsaV9kaXJlY3RfcmVhZDsKLQkJZGVuYWxpLT5o b3N0X3dyaXRlID0gZGVuYWxpX2RpcmVjdF93cml0ZTsKKwlpZiAoZGVuYWxpLT5kbWFfYXZhaWwp IHsKKwkJY2hpcC0+b3B0aW9ucyB8PSBOQU5EX1VTRV9CT1VOQ0VfQlVGRkVSOworCQljaGlwLT5i dWZfYWxpZ24gPSAxNjsKIAl9CiAKIAkvKiBjbGsgcmF0ZSBpbmZvIGlzIG5lZWRlZCBmb3Igc2V0 dXBfZGF0YV9pbnRlcmZhY2UgKi8KIAlpZiAoIWRlbmFsaS0+Y2xrX3JhdGUgfHwgIWRlbmFsaS0+ Y2xrX3hfcmF0ZSkKIAkJY2hpcC0+b3B0aW9ucyB8PSBOQU5EX0tFRVBfVElNSU5HUzsKIAotCWNo aXAtPmxlZ2FjeS5kdW1teV9jb250cm9sbGVyLm9wcyA9ICZkZW5hbGlfY29udHJvbGxlcl9vcHM7 Ci0JcmV0ID0gbmFuZF9zY2FuKGNoaXAsIGRlbmFsaS0+bWF4X2JhbmtzKTsKKwljaGlwLT5iYnRf b3B0aW9ucyB8PSBOQU5EX0JCVF9VU0VfRkxBU0g7CisJY2hpcC0+YmJ0X29wdGlvbnMgfD0gTkFO RF9CQlRfTk9fT09COworCWNoaXAtPm9wdGlvbnMgfD0gTkFORF9OT19TVUJQQUdFX1dSSVRFOwor CWNoaXAtPmVjYy5tb2RlID0gTkFORF9FQ0NfSFdfU1lORFJPTUU7CisJY2hpcC0+ZWNjLnJlYWRf cGFnZSA9IGRlbmFsaV9yZWFkX3BhZ2U7CisJY2hpcC0+ZWNjLndyaXRlX3BhZ2UgPSBkZW5hbGlf d3JpdGVfcGFnZTsKKwljaGlwLT5lY2MucmVhZF9wYWdlX3JhdyA9IGRlbmFsaV9yZWFkX3BhZ2Vf cmF3OworCWNoaXAtPmVjYy53cml0ZV9wYWdlX3JhdyA9IGRlbmFsaV93cml0ZV9wYWdlX3JhdzsK KwljaGlwLT5lY2MucmVhZF9vb2IgPSBkZW5hbGlfcmVhZF9vb2I7CisJY2hpcC0+ZWNjLndyaXRl X29vYiA9IGRlbmFsaV93cml0ZV9vb2I7CisKKwltdGRfc2V0X29vYmxheW91dChtdGQsICZkZW5h bGlfb29ibGF5b3V0X29wcyk7CisKKwlyZXQgPSBuYW5kX3NjYW4oY2hpcCwgZGNoaXAtPm5zZWxz KTsKIAlpZiAocmV0KQotCQlnb3RvIGRpc2FibGVfaXJxOworCQlyZXR1cm4gcmV0OwogCiAJcmV0 ID0gbXRkX2RldmljZV9yZWdpc3RlcihtdGQsIE5VTEwsIDApOwogCWlmIChyZXQpIHsKQEAgLTEz MzQsMjAgKzEyOTgsMTA5IEBAIGludCBkZW5hbGlfaW5pdChzdHJ1Y3QgZGVuYWxpX25hbmRfaW5m byAqZGVuYWxpKQogCQlnb3RvIGNsZWFudXBfbmFuZDsKIAl9CiAKKwlsaXN0X2FkZF90YWlsKCZk Y2hpcC0+bm9kZSwgJmRlbmFsaS0+Y2hpcHMpOworCiAJcmV0dXJuIDA7CiAKIGNsZWFudXBfbmFu ZDoKIAluYW5kX2NsZWFudXAoY2hpcCk7Ci1kaXNhYmxlX2lycToKLQlkZW5hbGlfZGlzYWJsZV9p cnEoZGVuYWxpKTsKIAogCXJldHVybiByZXQ7CiB9CitFWFBPUlRfU1lNQk9MX0dQTChkZW5hbGlf Y2hpcF9pbml0KTsKKworaW50IGRlbmFsaV9pbml0KHN0cnVjdCBkZW5hbGlfY29udHJvbGxlciAq ZGVuYWxpKQoreworCXUzMiBmZWF0dXJlcyA9IGlvcmVhZDMyKGRlbmFsaS0+cmVnICsgRkVBVFVS RVMpOworCWludCByZXQ7CisKKwluYW5kX2NvbnRyb2xsZXJfaW5pdCgmZGVuYWxpLT5jb250cm9s bGVyKTsKKwlkZW5hbGktPmNvbnRyb2xsZXIub3BzID0gJmRlbmFsaV9jb250cm9sbGVyX29wczsK Kwlpbml0X2NvbXBsZXRpb24oJmRlbmFsaS0+Y29tcGxldGUpOworCXNwaW5fbG9ja19pbml0KCZk ZW5hbGktPmlycV9sb2NrKTsKKwlJTklUX0xJU1RfSEVBRCgmZGVuYWxpLT5jaGlwcyk7CisJZGVu YWxpLT5hY3RpdmVfYmFuayA9IERFTkFMSV9JTlZBTElEX0JBTks7CisKKwkvKgorCSAqIFRoZSBS RVZJU0lPTiByZWdpc3RlciBtYXkgbm90IGJlIHJlbGlhYmxlLiBQbGF0Zm9ybXMgYXJlIGFsbG93 ZWQgdG8KKwkgKiBvdmVycmlkZSBpdC4KKwkgKi8KKwlpZiAoIWRlbmFsaS0+cmV2aXNpb24pCisJ CWRlbmFsaS0+cmV2aXNpb24gPSBzd2FiMTYoaW9yZWFkMzIoZGVuYWxpLT5yZWcgKyBSRVZJU0lP TikpOworCisJZGVuYWxpLT5uYmFua3MgPSAxIDw8IEZJRUxEX0dFVChGRUFUVVJFU19fTl9CQU5L UywgZmVhdHVyZXMpOworCisJLyogdGhlIGVuY29kaW5nIGNoYW5nZWQgZnJvbSByZXYgNS4wIHRv IDUuMSAqLworCWlmIChkZW5hbGktPnJldmlzaW9uIDwgMHgwNTAxKQorCQlkZW5hbGktPm5iYW5r cyA8PD0gMTsKKworCWlmIChmZWF0dXJlcyAmIEZFQVRVUkVTX19ETUEpCisJCWRlbmFsaS0+ZG1h X2F2YWlsID0gdHJ1ZTsKKworCWlmIChkZW5hbGktPmRtYV9hdmFpbCkgeworCQlpbnQgZG1hX2Jp dCA9IGRlbmFsaS0+Y2FwcyAmIERFTkFMSV9DQVBfRE1BXzY0QklUID8gNjQgOiAzMjsKKworCQly ZXQgPSBkbWFfc2V0X21hc2soZGVuYWxpLT5kZXYsIERNQV9CSVRfTUFTSyhkbWFfYml0KSk7CisJ CWlmIChyZXQpIHsKKwkJCWRldl9pbmZvKGRlbmFsaS0+ZGV2LAorCQkJCSAiRmFpbGVkIHRvIHNl dCBETUEgbWFzay4gRGlzYWJsaW5nIERNQS5cbiIpOworCQkJZGVuYWxpLT5kbWFfYXZhaWwgPSBm YWxzZTsKKwkJfQorCX0KKworCWlmIChkZW5hbGktPmRtYV9hdmFpbCkgeworCQlpZiAoZGVuYWxp LT5jYXBzICYgREVOQUxJX0NBUF9ETUFfNjRCSVQpCisJCQlkZW5hbGktPnNldHVwX2RtYSA9IGRl bmFsaV9zZXR1cF9kbWE2NDsKKwkJZWxzZQorCQkJZGVuYWxpLT5zZXR1cF9kbWEgPSBkZW5hbGlf c2V0dXBfZG1hMzI7CisJfQorCisJaWYgKGZlYXR1cmVzICYgRkVBVFVSRVNfX0lOREVYX0FERFIp IHsKKwkJZGVuYWxpLT5ob3N0X3JlYWQgPSBkZW5hbGlfaW5kZXhlZF9yZWFkOworCQlkZW5hbGkt Pmhvc3Rfd3JpdGUgPSBkZW5hbGlfaW5kZXhlZF93cml0ZTsKKwl9IGVsc2UgeworCQlkZW5hbGkt Pmhvc3RfcmVhZCA9IGRlbmFsaV9kaXJlY3RfcmVhZDsKKwkJZGVuYWxpLT5ob3N0X3dyaXRlID0g ZGVuYWxpX2RpcmVjdF93cml0ZTsKKwl9CisKKwkvKgorCSAqIFNldCBob3cgbWFueSBieXRlcyBz aG91bGQgYmUgc2tpcHBlZCBiZWZvcmUgd3JpdGluZyBkYXRhIGluIE9PQi4KKwkgKiBJZiBhIG5v bi16ZXJvIHZhbHVlIGhhcyBhbHJlYWR5IGJlZW4gc2V0IChieSBmaXJtd2FyZSBvciBzb21ldGhp bmcpLAorCSAqIGp1c3QgdXNlIGl0LiBPdGhlcndpc2UsIHNldCB0aGUgZHJpdmVyJ3MgZGVmYXVs dC4KKwkgKi8KKwlkZW5hbGktPm9vYl9za2lwX2J5dGVzID0gaW9yZWFkMzIoZGVuYWxpLT5yZWcg KyBTUEFSRV9BUkVBX1NLSVBfQllURVMpOworCWlmICghZGVuYWxpLT5vb2Jfc2tpcF9ieXRlcykg eworCQlkZW5hbGktPm9vYl9za2lwX2J5dGVzID0gREVOQUxJX0RFRkFVTFRfT09CX1NLSVBfQllU RVM7CisJCWlvd3JpdGUzMihkZW5hbGktPm9vYl9za2lwX2J5dGVzLAorCQkJICBkZW5hbGktPnJl ZyArIFNQQVJFX0FSRUFfU0tJUF9CWVRFUyk7CisJfQorCisJaW93cml0ZTMyKEdFTk1BU0soZGVu YWxpLT5uYmFua3MgLSAxLCAwKSwgZGVuYWxpLT5yZWcgKyBSQl9QSU5fRU5BQkxFRCk7CisJaW93 cml0ZTMyKENISVBfRU5fRE9OVF9DQVJFX19GTEFHLCBkZW5hbGktPnJlZyArIENISVBfRU5BQkxF X0RPTlRfQ0FSRSk7CisJaW93cml0ZTMyKDB4ZmZmZiwgZGVuYWxpLT5yZWcgKyBTUEFSRV9BUkVB X01BUktFUik7CisKKwlkZW5hbGlfY2xlYXJfaXJxX2FsbChkZW5hbGkpOworCisJcmV0ID0gZGV2 bV9yZXF1ZXN0X2lycShkZW5hbGktPmRldiwgZGVuYWxpLT5pcnEsIGRlbmFsaV9pc3IsCisJCQkg ICAgICAgSVJRRl9TSEFSRUQsIERFTkFMSV9OQU5EX05BTUUsIGRlbmFsaSk7CisJaWYgKHJldCkg eworCQlkZXZfZXJyKGRlbmFsaS0+ZGV2LCAiVW5hYmxlIHRvIHJlcXVlc3QgSVJRXG4iKTsKKwkJ cmV0dXJuIHJldDsKKwl9CisKKwlkZW5hbGlfZW5hYmxlX2lycShkZW5hbGkpOworCisJcmV0dXJu IDA7Cit9CiBFWFBPUlRfU1lNQk9MKGRlbmFsaV9pbml0KTsKIAotdm9pZCBkZW5hbGlfcmVtb3Zl KHN0cnVjdCBkZW5hbGlfbmFuZF9pbmZvICpkZW5hbGkpCit2b2lkIGRlbmFsaV9yZW1vdmUoc3Ry dWN0IGRlbmFsaV9jb250cm9sbGVyICpkZW5hbGkpCiB7Ci0JbmFuZF9yZWxlYXNlKCZkZW5hbGkt Pm5hbmQpOworCXN0cnVjdCBkZW5hbGlfY2hpcCAqZGNoaXA7CisKKwlsaXN0X2Zvcl9lYWNoX2Vu dHJ5KGRjaGlwLCAmZGVuYWxpLT5jaGlwcywgbm9kZSkKKwkJbmFuZF9yZWxlYXNlKCZkY2hpcC0+ Y2hpcCk7CisKIAlkZW5hbGlfZGlzYWJsZV9pcnEoZGVuYWxpKTsKIH0KIEVYUE9SVF9TWU1CT0wo ZGVuYWxpX3JlbW92ZSk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL210ZC9uYW5kL3Jhdy9kZW5hbGku aCBiL2RyaXZlcnMvbXRkL25hbmQvcmF3L2RlbmFsaS5oCmluZGV4IDg1NTJiM2YuLjEzOGIyMzkg MTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbXRkL25hbmQvcmF3L2RlbmFsaS5oCisrKyBiL2RyaXZlcnMv bXRkL25hbmQvcmF3L2RlbmFsaS5oCkBAIC05LDYgKzksNyBAQAogCiAjaW5jbHVkZSA8bGludXgv Yml0cy5oPgogI2luY2x1ZGUgPGxpbnV4L2NvbXBsZXRpb24uaD4KKyNpbmNsdWRlIDxsaW51eC9s aXN0Lmg+CiAjaW5jbHVkZSA8bGludXgvbXRkL3Jhd25hbmQuaD4KICNpbmNsdWRlIDxsaW51eC9z cGlubG9ja190eXBlcy5oPgogI2luY2x1ZGUgPGxpbnV4L3R5cGVzLmg+CkBAIC0yOTAsMzAgKzI5 MSwxMDAgQEAKICNkZWZpbmUgICAgIENITkxfQUNUSVZFX19DSEFOTkVMMgkJCUJJVCgyKQogI2Rl ZmluZSAgICAgQ0hOTF9BQ1RJVkVfX0NIQU5ORUwzCQkJQklUKDMpCiAKLXN0cnVjdCBkZW5hbGlf bmFuZF9pbmZvIHsKLQlzdHJ1Y3QgbmFuZF9jaGlwIG5hbmQ7Ci0JdW5zaWduZWQgbG9uZyBjbGtf cmF0ZTsJCS8qIGNvcmUgY2xvY2sgcmF0ZSAqLwotCXVuc2lnbmVkIGxvbmcgY2xrX3hfcmF0ZTsJ LyogYnVzIGludGVyZmFjZSBjbG9jayByYXRlICovCi0JaW50IGFjdGl2ZV9iYW5rOwkJLyogY3Vy cmVudGx5IHNlbGVjdGVkIGJhbmsgKi8KKy8qKgorICogc3RydWN0IGRlbmFsaV9jaGlwX3NlbCAt IHBlci1DUyBkYXRhIG9mIERlbmFsaSBOQU5ECisgKgorICogQGJhbms6ICAgICAgICAgICAgICAg ICAgYmFuayBpZCBvZiB0aGUgY29udHJvbGxlciB0aGlzIENTIGlzIGNvbm5lY3RlZCB0bworICog QGh3aHIyX2FuZF93ZV8yX3JlOiAgICAgdmFsdWUgb2YgdGltaW5nIHJlZ2lzdGVyIEhXSFIyX0FO RF9XRV8yX1JFCisgKiBAdGN3YXdfYW5kX2FkZHJfMl9kYXRhOiB2YWx1ZSBvZiB0aW1pbmcgcmVn aXN0ZXIgVENXQVdfQU5EX0FERFJfMl9EQVRBCisgKiBAcmVfMl93ZTogICAgICAgICAgICAgICB2 YWx1ZSBvZiB0aW1pbmcgcmVnaXN0ZXIgUkVfMl9XRQorICogQGFjY19jbGtzOiAgICAgICAgICAg ICAgdmFsdWUgb2YgdGltaW5nIHJlZ2lzdGVyIEFDQ19DTEtTCisgKiBAcmR3cl9lbl9sb19jbnQ6 ICAgICAgICB2YWx1ZSBvZiB0aW1pbmcgcmVnaXN0ZXIgUkRXUl9FTl9MT19DTlQKKyAqIEByZHdy X2VuX2hpX2NudDogICAgICAgIHZhbHVlIG9mIHRpbWluZyByZWdpc3RlciBSRFdSX0VOX0hJX0NO VAorICogQGNzX3NldHVwX2NudDogICAgICAgICAgdmFsdWUgb2YgdGltaW5nIHJlZ2lzdGVyIENT X1NFVFVQX0NOVAorICogQHJlXzJfcmU6ICAgICAgICAgICAgICAgdmFsdWUgb2YgdGltaW5nIHJl Z2lzdGVyIFJFXzJfUkUKKyAqLworc3RydWN0IGRlbmFsaV9jaGlwX3NlbCB7CisJaW50IGJhbms7 CisJdTMyIGh3aHIyX2FuZF93ZV8yX3JlOworCXUzMiB0Y3dhd19hbmRfYWRkcl8yX2RhdGE7CisJ dTMyIHJlXzJfd2U7CisJdTMyIGFjY19jbGtzOworCXUzMiByZHdyX2VuX2xvX2NudDsKKwl1MzIg cmR3cl9lbl9oaV9jbnQ7CisJdTMyIGNzX3NldHVwX2NudDsKKwl1MzIgcmVfMl9yZTsKK307CisK Ky8qKgorICogc3RydWN0IGRlbmFsaV9jaGlwIC0gcGVyLWNoaXAgZGF0YSBvZiBEZW5hbGkgTkFO RAorICoKKyAqIEBjaGlwOiAgYmFzZSBOQU5EIGNoaXAgc3RydWN0dXJlCisgKiBAYnVmOiAgIGlu dGVybmFsIGJ1ZmZlciBmb3Igc3luZHJvbWUgbGF5b3V0IGNvbnZlcnNpb24KKyAqIEBub2RlOiAg bm9kZSB0byBiZSB1c2VkIHRvIGFzc29jaWF0ZSB0aGlzIGNoaXAgd2l0aCB0aGUgY29udHJvbGxl cgorICogQG5zZWxzOiB0aGUgbnVtYmVyIG9mIENTIGxpbmVzIG9mIHRoaXMgY2hpcAorICogQHNl bHM6ICB0aGUgYXJyYXkgb2YgcGVyLWNzIGRhdGEKKyAqLworc3RydWN0IGRlbmFsaV9jaGlwIHsK KwlzdHJ1Y3QgbmFuZF9jaGlwIGNoaXA7CisJdm9pZCAqYnVmOworCXN0cnVjdCBsaXN0X2hlYWQg bm9kZTsKKwl1bnNpZ25lZCBpbnQgbnNlbHM7CisJc3RydWN0IGRlbmFsaV9jaGlwX3NlbCBzZWxz WzBdOworfTsKKworLyoqCisgKiBzdHJ1Y3QgZGVuYWxpX2NvbnRyb2xsZXIgLSBEZW5hbGkgTkFO RCBjb250cm9sbGVyIGRhdGEKKyAqCisgKiBAY29udHJvbGxlcjogICAgIGJhc2UgTkFORCBjb250 cm9sbGVyIHN0cnVjdHVyZQorICogQGRldjogICAgICAgICAgICBkZXZpY2UKKyAqIEBjaGlwczog ICAgICAgICAgdGhlIGxpc3Qgb2YgY2hpcHMgYXR0YWNoZWQgdG8gdGhpcyBjb250cm9sbGVyCisg KiBAY2xrX3JhdGU6ICAgICAgIGZyZXF1ZW5jeSBvZiBjb3JlIGNsb2NrCisgKiBAY2xrX3hfcmF0 ZTogICAgIGZyZXF1ZW5jeSBvZiBidXMgaW50ZXJmYWNlIGNsb2NrCisgKiBAcmVnOiAgICAgICAg ICAgIGJhc2Ugb2YgUmVnaXN0ZXIgSW50ZXJmYWNlCisgKiBAaG9zdDogICAgICAgICAgIGJhc2Ug b2YgSG9zdCBEYXRhL0NvbW1hbmQgaW50ZXJmYWNlCisgKiBAY29tcGxldGU6ICAgICAgIGNvbXBs ZXRpb24gdXNlZCB0byB3YWl0IGZvciBpbnRlcnJ1cHRzCisgKiBAaXJxOiAgICAgICAgICAgIGlu dGVycnVwdCBudW1iZXIKKyAqIEBpcnFfbWFzazogICAgICAgaW50ZXJydXB0IGJpdHMgdGhlIGNv bnRyb2xsZXIgaXMgd2FpdGluZyBmb3IKKyAqIEBpcnFfc3RhdHVzOiAgICAgaW50ZXJydXB0IGJp dHMgb2YgZXZlbnRzIHRoYXQgaGF2ZSBoYXBwZW5lZAorICogQGlycV9sb2NrOiAgICAgICBsb2Nr IHRvIHByb3RlY3QgQGlycV9tYXNrIGFuZCBAaXJxX3N0YXR1cworICogQGRtYV9hdmFpbDogICAg ICBzZXQgaWYgRE1BIGVuZ2luZSBpcyBhdmFpbGFibGUKKyAqIEBkZXZzX3Blcl9jczogICAgbnVt YmVyIG9mIGRldmljZXMgY29ubmVjdGVkIGluIHBhcmFsbGVsCisgKiBAb29iX3NraXBfYnl0ZXM6 IG51bWJlciBvZiBieXRlcyBpbiBPT0Igc2tpcHBlZCBieSB0aGUgRUNDIGVuZ2luZQorICogQGFj dGl2ZV9iYW5rOiAgICBhY3RpdmUgYmFuayBpZAorICogQG5iYW5rczogICAgICAgICB0aGUgbnVt YmVyIG9mIGJhbmtzIHN1cHBvcnRlZCBieSB0aGlzIGNvbnRyb2xsZXIKKyAqIEByZXZpc2lvbjog ICAgICAgSVAgcmV2aXNpb24KKyAqIEBjYXBzOiAgICAgICAgICAgY29udHJvbGxlciBjYXBhYmls aXRpZXMgdGhhdCBjYW5ub3QgYmUgZGV0ZWN0ZWQgcnVuLXRpbWUKKyAqIEBlY2NfY2FwczogICAg ICAgRUNDIGVuZ2luZSBjYXBhYmlsaXRpZXMKKyAqIEBob3N0X3JlYWQ6ICAgICAgY2FsbGJhY2sg Zm9yIHJlYWQgYWNjZXNzIG9mIEhvc3QgRGF0YS9Db21tYW5kIEludGVyZmFjZQorICogQGhvc3Rf d3JpdGU6ICAgICBjYWxsYmFjayBmb3Igd3JpdGUgYWNjZXNzIG9mIEhvc3QgRGF0YS9Db21tYW5k IEludGVyZmFjZQorICogQHNldHVwX2RtYTogICAgICBjYWxsYmFjayBmb3Igc2V0dXAgb2YgdGhl IERhdGEgRE1BCisgKi8KK3N0cnVjdCBkZW5hbGlfY29udHJvbGxlciB7CisJc3RydWN0IG5hbmRf Y29udHJvbGxlciBjb250cm9sbGVyOwogCXN0cnVjdCBkZXZpY2UgKmRldjsKLQl2b2lkIF9faW9t ZW0gKnJlZzsJCS8qIFJlZ2lzdGVyIEludGVyZmFjZSAqLwotCXZvaWQgX19pb21lbSAqaG9zdDsJ CS8qIEhvc3QgRGF0YS9Db21tYW5kIEludGVyZmFjZSAqLworCXN0cnVjdCBsaXN0X2hlYWQgY2hp cHM7CisJdW5zaWduZWQgbG9uZyBjbGtfcmF0ZTsKKwl1bnNpZ25lZCBsb25nIGNsa194X3JhdGU7 CisJdm9pZCBfX2lvbWVtICpyZWc7CisJdm9pZCBfX2lvbWVtICpob3N0OwogCXN0cnVjdCBjb21w bGV0aW9uIGNvbXBsZXRlOwotCXNwaW5sb2NrX3QgaXJxX2xvY2s7CQkvKiBwcm90ZWN0IGlycV9t YXNrIGFuZCBpcnFfc3RhdHVzICovCi0JdTMyIGlycV9tYXNrOwkJCS8qIGludGVycnVwdHMgd2Ug YXJlIHdhaXRpbmcgZm9yICovCi0JdTMyIGlycV9zdGF0dXM7CQkJLyogaW50ZXJydXB0cyB0aGF0 IGhhdmUgaGFwcGVuZWQgKi8KIAlpbnQgaXJxOwotCXZvaWQgKmJ1ZjsJCQkvKiBmb3Igc3luZHJv bWUgbGF5b3V0IGNvbnZlcnNpb24gKi8KLQlib29sIGRtYV9hdmFpbDsJCQkvKiBjYW4gc3VwcG9y dCBETUE/ICovCi0JaW50IGRldnNfcGVyX2NzOwkJLyogZGV2aWNlcyBjb25uZWN0ZWQgaW4gcGFy YWxsZWwgKi8KLQlpbnQgb29iX3NraXBfYnl0ZXM7CQkvKiBudW1iZXIgb2YgYnl0ZXMgcmVzZXJ2 ZWQgZm9yIEJCTSAqLwotCWludCBtYXhfYmFua3M7Ci0JdW5zaWduZWQgaW50IHJldmlzaW9uOwkJ LyogSVAgcmV2aXNpb24gKi8KLQl1bnNpZ25lZCBpbnQgY2FwczsJCS8qIElQIGNhcGFiaWxpdHkg KG9yIHF1aXJrKSAqLworCXUzMiBpcnFfbWFzazsKKwl1MzIgaXJxX3N0YXR1czsKKwlzcGlubG9j a190IGlycV9sb2NrOworCWJvb2wgZG1hX2F2YWlsOworCWludCBkZXZzX3Blcl9jczsKKwlpbnQg b29iX3NraXBfYnl0ZXM7CisJaW50IGFjdGl2ZV9iYW5rOworCWludCBuYmFua3M7CisJdW5zaWdu ZWQgaW50IHJldmlzaW9uOworCXVuc2lnbmVkIGludCBjYXBzOwogCWNvbnN0IHN0cnVjdCBuYW5k X2VjY19jYXBzICplY2NfY2FwczsKLQl1MzIgKCpob3N0X3JlYWQpKHN0cnVjdCBkZW5hbGlfbmFu ZF9pbmZvICpkZW5hbGksIHUzMiBhZGRyKTsKLQl2b2lkICgqaG9zdF93cml0ZSkoc3RydWN0IGRl bmFsaV9uYW5kX2luZm8gKmRlbmFsaSwgdTMyIGFkZHIsIHUzMiBkYXRhKTsKLQl2b2lkICgqc2V0 dXBfZG1hKShzdHJ1Y3QgZGVuYWxpX25hbmRfaW5mbyAqZGVuYWxpLCBkbWFfYWRkcl90IGRtYV9h ZGRyLAorCXUzMiAoKmhvc3RfcmVhZCkoc3RydWN0IGRlbmFsaV9jb250cm9sbGVyICpkZW5hbGks IHUzMiBhZGRyKTsKKwl2b2lkICgqaG9zdF93cml0ZSkoc3RydWN0IGRlbmFsaV9jb250cm9sbGVy ICpkZW5hbGksIHUzMiBhZGRyLAorCQkJICAgdTMyIGRhdGEpOworCXZvaWQgKCpzZXR1cF9kbWEp KHN0cnVjdCBkZW5hbGlfY29udHJvbGxlciAqZGVuYWxpLCBkbWFfYWRkcl90IGRtYV9hZGRyLAog CQkJICBpbnQgcGFnZSwgYm9vbCB3cml0ZSk7CiB9OwogCkBAIC0zMjEsNyArMzkyLDkgQEAgc3Ry dWN0IGRlbmFsaV9uYW5kX2luZm8gewogI2RlZmluZSBERU5BTElfQ0FQX0RNQV82NEJJVAkJCUJJ VCgxKQogCiBpbnQgZGVuYWxpX2NhbGNfZWNjX2J5dGVzKGludCBzdGVwX3NpemUsIGludCBzdHJl bmd0aCk7Ci1pbnQgZGVuYWxpX2luaXQoc3RydWN0IGRlbmFsaV9uYW5kX2luZm8gKmRlbmFsaSk7 Ci12b2lkIGRlbmFsaV9yZW1vdmUoc3RydWN0IGRlbmFsaV9uYW5kX2luZm8gKmRlbmFsaSk7Citp bnQgZGVuYWxpX2NoaXBfaW5pdChzdHJ1Y3QgZGVuYWxpX2NvbnRyb2xsZXIgKmRlbmFsaSwKKwkJ ICAgICBzdHJ1Y3QgZGVuYWxpX2NoaXAgKmRjaGlwKTsKK2ludCBkZW5hbGlfaW5pdChzdHJ1Y3Qg ZGVuYWxpX2NvbnRyb2xsZXIgKmRlbmFsaSk7Cit2b2lkIGRlbmFsaV9yZW1vdmUoc3RydWN0IGRl bmFsaV9jb250cm9sbGVyICpkZW5hbGkpOwogCiAjZW5kaWYgLyogX19ERU5BTElfSF9fICovCmRp ZmYgLS1naXQgYS9kcml2ZXJzL210ZC9uYW5kL3Jhdy9kZW5hbGlfZHQuYyBiL2RyaXZlcnMvbXRk L25hbmQvcmF3L2RlbmFsaV9kdC5jCmluZGV4IDBiNWFlMjQuLjVlMTQ4MzYgMTAwNjQ0Ci0tLSBh L2RyaXZlcnMvbXRkL25hbmQvcmF3L2RlbmFsaV9kdC5jCisrKyBiL2RyaXZlcnMvbXRkL25hbmQv cmF3L2RlbmFsaV9kdC5jCkBAIC0xOCw3ICsxOCw3IEBACiAjaW5jbHVkZSAiZGVuYWxpLmgiCiAK IHN0cnVjdCBkZW5hbGlfZHQgewotCXN0cnVjdCBkZW5hbGlfbmFuZF9pbmZvCWRlbmFsaTsKKwlz dHJ1Y3QgZGVuYWxpX2NvbnRyb2xsZXIgY29udHJvbGxlcjsKIAlzdHJ1Y3QgY2xrICpjbGs7CS8q IGNvcmUgY2xvY2sgKi8KIAlzdHJ1Y3QgY2xrICpjbGtfeDsJLyogYnVzIGludGVyZmFjZSBjbG9j ayAqLwogCXN0cnVjdCBjbGsgKmNsa19lY2M7CS8qIEVDQyBjaXJjdWl0IGNsb2NrICovCkBAIC03 MSwxOSArNzEsOTIgQEAgc3RhdGljIGNvbnN0IHN0cnVjdCBvZl9kZXZpY2VfaWQgZGVuYWxpX25h bmRfZHRfaWRzW10gPSB7CiB9OwogTU9EVUxFX0RFVklDRV9UQUJMRShvZiwgZGVuYWxpX25hbmRf ZHRfaWRzKTsKIAorc3RhdGljIGludCBkZW5hbGlfZHRfY2hpcF9pbml0KHN0cnVjdCBkZW5hbGlf Y29udHJvbGxlciAqZGVuYWxpLAorCQkJICAgICAgIHN0cnVjdCBkZXZpY2Vfbm9kZSAqY2hpcF9u cCkKK3sKKwlzdHJ1Y3QgZGVuYWxpX2NoaXAgKmRjaGlwOworCXUzMiBiYW5rOworCWludCBuc2Vs cywgaSwgcmV0OworCisJbnNlbHMgPSBvZl9wcm9wZXJ0eV9jb3VudF91MzJfZWxlbXMoY2hpcF9u cCwgInJlZyIpOworCWlmIChuc2VscyA8IDApCisJCXJldHVybiBuc2VsczsKKworCWRjaGlwID0g ZGV2bV9remFsbG9jKGRlbmFsaS0+ZGV2LCBzdHJ1Y3Rfc2l6ZShkY2hpcCwgc2VscywgbnNlbHMp LAorCQkJICAgICBHRlBfS0VSTkVMKTsKKwlpZiAoIWRjaGlwKQorCQlyZXR1cm4gLUVOT01FTTsK KworCWRjaGlwLT5uc2VscyA9IG5zZWxzOworCisJZm9yIChpID0gMDsgaSA8IG5zZWxzOyBpKysp IHsKKwkJcmV0ID0gb2ZfcHJvcGVydHlfcmVhZF91MzJfaW5kZXgoY2hpcF9ucCwgInJlZyIsIGks ICZiYW5rKTsKKwkJaWYgKHJldCkKKwkJCXJldHVybiByZXQ7CisKKwkJZGNoaXAtPnNlbHNbaV0u YmFuayA9IGJhbms7CisKKwkJbmFuZF9zZXRfZmxhc2hfbm9kZSgmZGNoaXAtPmNoaXAsIGNoaXBf bnApOworCX0KKworCXJldHVybiBkZW5hbGlfY2hpcF9pbml0KGRlbmFsaSwgZGNoaXApOworfQor CisvKiBCYWNrd2FyZCBjb21wYXRpYmlsaXR5IGZvciBvbGQgcGxhdGZvcm1zICovCitzdGF0aWMg aW50IGRlbmFsaV9kdF9sZWdhY3lfY2hpcF9pbml0KHN0cnVjdCBkZW5hbGlfY29udHJvbGxlciAq ZGVuYWxpKQoreworCXN0cnVjdCBkZW5hbGlfY2hpcCAqZGNoaXA7CisJaW50IG5zZWxzLCBpOwor CisJbnNlbHMgPSBkZW5hbGktPm5iYW5rczsKKworCWRjaGlwID0gZGV2bV9remFsbG9jKGRlbmFs aS0+ZGV2LCBzdHJ1Y3Rfc2l6ZShkY2hpcCwgc2VscywgbnNlbHMpLAorCQkJICAgICBHRlBfS0VS TkVMKTsKKwlpZiAoIWRjaGlwKQorCQlyZXR1cm4gLUVOT01FTTsKKworCWRjaGlwLT5uc2VscyA9 IG5zZWxzOworCisJZm9yIChpID0gMDsgaSA8IG5zZWxzOyBpKyspCisJCWRjaGlwLT5zZWxzW2ld LmJhbmsgPSBpOworCisJbmFuZF9zZXRfZmxhc2hfbm9kZSgmZGNoaXAtPmNoaXAsIGRlbmFsaS0+ ZGV2LT5vZl9ub2RlKTsKKworCXJldHVybiBkZW5hbGlfY2hpcF9pbml0KGRlbmFsaSwgZGNoaXAp OworfQorCisvKgorICogQ2hlY2sgdGhlIERUIGJpbmRpbmcuCisgKiBUaGUgbmV3IGJpbmRpbmcg ZXhwZWN0cyBjaGlwIHN1Ym5vZGVzIGluIHRoZSBjb250cm9sbGVyIG5vZGUuCisgKiBTbywgI2Fk ZHJlc3MtY2VsbHMgPSA8MT47ICNzaXplLWNlbGxzID0gPDA+OyBhcmUgcmVxdWlyZWQuCisgKiBD aGVjayB0aGUgI3NpemUtY2VsbHMgdG8gZGlzdGluZ3Vpc2ggdGhlIGJpbmRpbmcuCisgKi8KK3N0 YXRpYyBib29sIGRlbmFsaV9kdF9pc19sZWdhY3lfYmluZGluZyhzdHJ1Y3QgZGV2aWNlX25vZGUg Km5wKQoreworCXUzMiBjZWxsczsKKwlpbnQgcmV0OworCisJcmV0ID0gb2ZfcHJvcGVydHlfcmVh ZF91MzIobnAsICIjc2l6ZS1jZWxscyIsICZjZWxscyk7CisJaWYgKHJldCkKKwkJcmV0dXJuIHRy dWU7CisKKwlyZXR1cm4gY2VsbHMgIT0gMDsKK30KKwogc3RhdGljIGludCBkZW5hbGlfZHRfcHJv YmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKIHsKIAlzdHJ1Y3QgZGV2aWNlICpkZXYg PSAmcGRldi0+ZGV2OwogCXN0cnVjdCByZXNvdXJjZSAqcmVzOwogCXN0cnVjdCBkZW5hbGlfZHQg KmR0OwogCWNvbnN0IHN0cnVjdCBkZW5hbGlfZHRfZGF0YSAqZGF0YTsKLQlzdHJ1Y3QgZGVuYWxp X25hbmRfaW5mbyAqZGVuYWxpOworCXN0cnVjdCBkZW5hbGlfY29udHJvbGxlciAqZGVuYWxpOwor CXN0cnVjdCBkZXZpY2Vfbm9kZSAqbnA7CiAJaW50IHJldDsKIAogCWR0ID0gZGV2bV9remFsbG9j KGRldiwgc2l6ZW9mKCpkdCksIEdGUF9LRVJORUwpOwogCWlmICghZHQpCiAJCXJldHVybiAtRU5P TUVNOwotCWRlbmFsaSA9ICZkdC0+ZGVuYWxpOworCWRlbmFsaSA9ICZkdC0+Y29udHJvbGxlcjsK IAogCWRhdGEgPSBvZl9kZXZpY2VfZ2V0X21hdGNoX2RhdGEoZGV2KTsKIAlpZiAoZGF0YSkgewpA QCAtMTQwLDkgKzIxMywyNiBAQCBzdGF0aWMgaW50IGRlbmFsaV9kdF9wcm9iZShzdHJ1Y3QgcGxh dGZvcm1fZGV2aWNlICpwZGV2KQogCWlmIChyZXQpCiAJCWdvdG8gb3V0X2Rpc2FibGVfY2xrX2Vj YzsKIAorCWlmIChkZW5hbGlfZHRfaXNfbGVnYWN5X2JpbmRpbmcoZGV2LT5vZl9ub2RlKSkgewor CQlyZXQgPSBkZW5hbGlfZHRfbGVnYWN5X2NoaXBfaW5pdChkZW5hbGkpOworCQlpZiAocmV0KQor CQkJZ290byBvdXRfcmVtb3ZlX2RlbmFsaTsKKwl9IGVsc2UgeworCQlmb3JfZWFjaF9jaGlsZF9v Zl9ub2RlKGRldi0+b2Zfbm9kZSwgbnApIHsKKwkJCXJldCA9IGRlbmFsaV9kdF9jaGlwX2luaXQo ZGVuYWxpLCBucCk7CisJCQlpZiAocmV0KSB7CisJCQkJb2Zfbm9kZV9wdXQobnApOworCQkJCWdv dG8gb3V0X3JlbW92ZV9kZW5hbGk7CisJCQl9CisJCX0KKwl9CisKIAlwbGF0Zm9ybV9zZXRfZHJ2 ZGF0YShwZGV2LCBkdCk7CisKIAlyZXR1cm4gMDsKIAorb3V0X3JlbW92ZV9kZW5hbGk6CisJZGVu YWxpX3JlbW92ZShkZW5hbGkpOwogb3V0X2Rpc2FibGVfY2xrX2VjYzoKIAljbGtfZGlzYWJsZV91 bnByZXBhcmUoZHQtPmNsa19lY2MpOwogb3V0X2Rpc2FibGVfY2xrX3g6CkBAIC0xNTcsNyArMjQ3 LDcgQEAgc3RhdGljIGludCBkZW5hbGlfZHRfcmVtb3ZlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2Ug KnBkZXYpCiB7CiAJc3RydWN0IGRlbmFsaV9kdCAqZHQgPSBwbGF0Zm9ybV9nZXRfZHJ2ZGF0YShw ZGV2KTsKIAotCWRlbmFsaV9yZW1vdmUoJmR0LT5kZW5hbGkpOworCWRlbmFsaV9yZW1vdmUoJmR0 LT5jb250cm9sbGVyKTsKIAljbGtfZGlzYWJsZV91bnByZXBhcmUoZHQtPmNsa19lY2MpOwogCWNs a19kaXNhYmxlX3VucHJlcGFyZShkdC0+Y2xrX3gpOwogCWNsa19kaXNhYmxlX3VucHJlcGFyZShk dC0+Y2xrKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbXRkL25hbmQvcmF3L2RlbmFsaV9wY2kuYyBi L2RyaXZlcnMvbXRkL25hbmQvcmF3L2RlbmFsaV9wY2kuYwppbmRleCAwMmViNTk5Li5kNjJhYTUy IDEwMDY0NAotLS0gYS9kcml2ZXJzL210ZC9uYW5kL3Jhdy9kZW5hbGlfcGNpLmMKKysrIGIvZHJp dmVycy9tdGQvbmFuZC9yYXcvZGVuYWxpX3BjaS5jCkBAIC0yOSwxMCArMjksMTEgQEAgTkFORF9F Q0NfQ0FQU19TSU5HTEUoZGVuYWxpX3BjaV9lY2NfY2FwcywgZGVuYWxpX2NhbGNfZWNjX2J5dGVz LCA1MTIsIDgsIDE1KTsKIAogc3RhdGljIGludCBkZW5hbGlfcGNpX3Byb2JlKHN0cnVjdCBwY2lf ZGV2ICpkZXYsIGNvbnN0IHN0cnVjdCBwY2lfZGV2aWNlX2lkICppZCkKIHsKLQlpbnQgcmV0Owog CXJlc291cmNlX3NpemVfdCBjc3JfYmFzZSwgbWVtX2Jhc2U7CiAJdW5zaWduZWQgbG9uZyBjc3Jf bGVuLCBtZW1fbGVuOwotCXN0cnVjdCBkZW5hbGlfbmFuZF9pbmZvICpkZW5hbGk7CisJc3RydWN0 IGRlbmFsaV9jb250cm9sbGVyICpkZW5hbGk7CisJc3RydWN0IGRlbmFsaV9jaGlwICpkY2hpcDsK KwlpbnQgbnNlbHMsIHJldCwgaTsKIAogCWRlbmFsaSA9IGRldm1fa3phbGxvYygmZGV2LT5kZXYs IHNpemVvZigqZGVuYWxpKSwgR0ZQX0tFUk5FTCk7CiAJaWYgKCFkZW5hbGkpCkBAIC02NCw3ICs2 NSw2IEBAIHN0YXRpYyBpbnQgZGVuYWxpX3BjaV9wcm9iZShzdHJ1Y3QgcGNpX2RldiAqZGV2LCBj b25zdCBzdHJ1Y3QgcGNpX2RldmljZV9pZCAqaWQpCiAJZGVuYWxpLT5kZXYgPSAmZGV2LT5kZXY7 CiAJZGVuYWxpLT5pcnEgPSBkZXYtPmlycTsKIAlkZW5hbGktPmVjY19jYXBzID0gJmRlbmFsaV9w Y2lfZWNjX2NhcHM7Ci0JZGVuYWxpLT5uYW5kLmVjYy5vcHRpb25zIHw9IE5BTkRfRUNDX01BWElN SVpFOwogCWRlbmFsaS0+Y2xrX3JhdGUgPSA1MDAwMDAwMDsJCS8qIDUwIE1IeiAqLwogCWRlbmFs aS0+Y2xrX3hfcmF0ZSA9IDIwMDAwMDAwMDsJCS8qIDIwMCBNSHogKi8KIApAQCAtOTEsMTAgKzkx LDMyIEBAIHN0YXRpYyBpbnQgZGVuYWxpX3BjaV9wcm9iZShzdHJ1Y3QgcGNpX2RldiAqZGV2LCBj b25zdCBzdHJ1Y3QgcGNpX2RldmljZV9pZCAqaWQpCiAJaWYgKHJldCkKIAkJZ290byBvdXRfdW5t YXBfaG9zdDsKIAorCW5zZWxzID0gZGVuYWxpLT5uYmFua3M7CisKKwlkY2hpcCA9IGRldm1fa3ph bGxvYyhkZW5hbGktPmRldiwgc3RydWN0X3NpemUoZGNoaXAsIHNlbHMsIG5zZWxzKSwKKwkJCSAg ICAgR0ZQX0tFUk5FTCk7CisJaWYgKCFkY2hpcCkgeworCQlyZXQgPSAtRU5PTUVNOworCQlnb3Rv IG91dF9yZW1vdmVfZGVuYWxpOworCX0KKworCWRjaGlwLT5jaGlwLmVjYy5vcHRpb25zIHw9IE5B TkRfRUNDX01BWElNSVpFOworCisJZGNoaXAtPm5zZWxzID0gbnNlbHM7CisKKwlmb3IgKGkgPSAw OyBpIDwgbnNlbHM7IGkrKykKKwkJZGNoaXAtPnNlbHNbaV0uYmFuayA9IGk7CisKKwlyZXQgPSBk ZW5hbGlfY2hpcF9pbml0KGRlbmFsaSwgZGNoaXApOworCWlmIChyZXQpCisJCWdvdG8gb3V0X3Jl bW92ZV9kZW5hbGk7CisKIAlwY2lfc2V0X2RydmRhdGEoZGV2LCBkZW5hbGkpOwogCiAJcmV0dXJu IDA7CiAKK291dF9yZW1vdmVfZGVuYWxpOgorCWRlbmFsaV9yZW1vdmUoZGVuYWxpKTsKIG91dF91 bm1hcF9ob3N0OgogCWlvdW5tYXAoZGVuYWxpLT5ob3N0KTsKIG91dF91bm1hcF9yZWc6CkBAIC0x MDQsNyArMTI2LDcgQEAgc3RhdGljIGludCBkZW5hbGlfcGNpX3Byb2JlKHN0cnVjdCBwY2lfZGV2 ICpkZXYsIGNvbnN0IHN0cnVjdCBwY2lfZGV2aWNlX2lkICppZCkKIAogc3RhdGljIHZvaWQgZGVu YWxpX3BjaV9yZW1vdmUoc3RydWN0IHBjaV9kZXYgKmRldikKIHsKLQlzdHJ1Y3QgZGVuYWxpX25h bmRfaW5mbyAqZGVuYWxpID0gcGNpX2dldF9kcnZkYXRhKGRldik7CisJc3RydWN0IGRlbmFsaV9j b250cm9sbGVyICpkZW5hbGkgPSBwY2lfZ2V0X2RydmRhdGEoZGV2KTsKIAogCWRlbmFsaV9yZW1v dmUoZGVuYWxpKTsKIAlpb3VubWFwKGRlbmFsaS0+cmVnKTsKLS0gCjIuNy40CgoKX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCkxpbnV4IE1URCBk aXNjdXNzaW9uIG1haWxpbmcgbGlzdApodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFu L2xpc3RpbmZvL2xpbnV4LW10ZC8K