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,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 04E48C43381 for ; Tue, 2 Apr 2019 04:04:46 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 9EEF120857 for ; Tue, 2 Apr 2019 04:04:45 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=nifty.com header.i=@nifty.com header.b="2Qkul3Oo" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1728743AbfDBEEo (ORCPT ); Tue, 2 Apr 2019 00:04:44 -0400 Received: from conuserg-07.nifty.com ([210.131.2.74]:18625 "EHLO conuserg-07.nifty.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727156AbfDBEEj (ORCPT ); Tue, 2 Apr 2019 00:04:39 -0400 Received: from pug.e01.socionext.com (p14092-ipngnfx01kyoto.kyoto.ocn.ne.jp [153.142.97.92]) (authenticated) by conuserg-07.nifty.com with ESMTP id x3243Haa021871; Tue, 2 Apr 2019 13:03:24 +0900 DKIM-Filter: OpenDKIM Filter v2.10.3 conuserg-07.nifty.com x3243Haa021871 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nifty.com; s=dec2015msa; t=1554177805; bh=124eBJCr4qqB7iP4i51cXSSRik3d7kHbEGuewnEjsk0=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=2Qkul3OoJC3P5PlWh607ViG+OlQ+YTdVn8YTHw6+CS1jmfvuY1o3H+uW5tn4jZS8h FVoqIa1B1rXuPzG6jkf5DHUuFhw4+3nEHiVUWJSMP8BPitU48PkcgrnyaP5yNo4o4H QvE68WxsxglKK4Kmaa70F6pVacJcXT1izl5RlvK7GnaM2H1WchPCYMfrLRL/0bTB9h 7fy6LfvwrpAwLrg5ECTZGiJIDXcZeX2vTvGDAGfzNAmaIUe1+OMwzVuNn4DnxuZRRH CvUPGqNXCxdSEvFcVEXPaauJsjXwfaZ9HMHNATszsCr2Mmmd9fyuvLHWoQw8JDdyTM 5Pz0QHY42J6pA== 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 v5 7/9] mtd: rawnand: denali: decouple controller and NAND chips Date: Tue, 2 Apr 2019 13:03:07 +0900 Message-Id: <1554177789-15414-8-git-send-email-yamada.masahiro@socionext.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1554177789-15414-1-git-send-email-yamada.masahiro@socionext.com> References: <1554177789-15414-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 v5: None Changes in v4: None Changes in v3: - simplify mtd->name fallback - Add Rob's Ack Changes in v2: None .../devicetree/bindings/mtd/denali-nand.txt | 40 +- drivers/mtd/nand/raw/denali.c | 430 ++++++++++++--------- drivers/mtd/nand/raw/denali.h | 114 +++++- drivers/mtd/nand/raw/denali_dt.c | 98 ++++- drivers/mtd/nand/raw/denali_pci.c | 30 +- 5 files changed, 482 insertions(+), 230 deletions(-) diff --git a/Documentation/devicetree/bindings/mtd/denali-nand.txt b/Documentation/devicetree/bindings/mtd/denali-nand.txt index f33da87..b14b675 100644 --- a/Documentation/devicetree/bindings/mtd/denali-nand.txt +++ b/Documentation/devicetree/bindings/mtd/denali-nand.txt @@ -7,34 +7,48 @@ 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 a501d9e..8722762 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,9 +193,41 @@ 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_change_column(struct nand_chip *chip, unsigned int offset, @@ -226,7 +243,7 @@ static int denali_change_column(struct nand_chip *chip, unsigned int offset, static int denali_payload_xfer(struct nand_chip *chip, void *buf, bool write) { - 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; @@ -263,7 +280,7 @@ static int denali_payload_xfer(struct nand_chip *chip, void *buf, bool write) static int denali_oob_xfer(struct nand_chip *chip, void *buf, bool write) { - 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; @@ -393,7 +410,7 @@ static int denali_check_erased_page(struct nand_chip *chip, u8 *buf, unsigned long uncor_ecc_flags, unsigned int max_bitflips) { - struct denali_nand_info *denali = to_denali(chip); + struct denali_controller *denali = to_denali_controller(chip); struct mtd_ecc_stats *ecc_stats = &nand_to_mtd(chip)->ecc_stats; uint8_t *ecc_code = chip->oob_poi + denali->oob_skip_bytes; int ecc_steps = chip->ecc.steps; @@ -426,7 +443,7 @@ static int denali_check_erased_page(struct nand_chip *chip, u8 *buf, static int denali_hw_ecc_fixup(struct nand_chip *chip, unsigned long *uncor_ecc_flags) { - struct denali_nand_info *denali = to_denali(chip); + struct denali_controller *denali = to_denali_controller(chip); struct mtd_ecc_stats *ecc_stats = &nand_to_mtd(chip)->ecc_stats; int bank = denali->active_bank; uint32_t ecc_cor; @@ -461,7 +478,7 @@ static int denali_hw_ecc_fixup(struct nand_chip *chip, static int denali_sw_ecc_fixup(struct nand_chip *chip, unsigned long *uncor_ecc_flags, uint8_t *buf) { - struct denali_nand_info *denali = to_denali(chip); + struct denali_controller *denali = to_denali_controller(chip); struct mtd_ecc_stats *ecc_stats = &nand_to_mtd(chip)->ecc_stats; unsigned int ecc_size = chip->ecc.size; unsigned int bitflips = 0; @@ -532,7 +549,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; @@ -557,7 +574,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; @@ -581,7 +598,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; @@ -608,7 +625,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; @@ -628,7 +645,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) @@ -637,7 +654,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; @@ -697,7 +714,7 @@ static int denali_dma_xfer(struct denali_nand_info *denali, void *buf, static int denali_page_xfer(struct nand_chip *chip, void *buf, size_t size, int page, 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); @@ -710,8 +727,8 @@ static int denali_page_xfer(struct nand_chip *chip, void *buf, size_t size, 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; @@ -751,7 +768,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; @@ -780,6 +798,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); @@ -787,7 +807,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); @@ -796,7 +816,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); @@ -805,7 +825,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 @@ -819,7 +839,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 */ @@ -834,7 +854,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), @@ -844,7 +864,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); @@ -857,7 +877,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, @@ -868,40 +888,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(0, denali->reg + TRANSFER_SPARE_REG); - iowrite32(0x0F, denali->reg + RB_PIN_ENABLED); - iowrite32(CHIP_EN_DONT_CARE__FLAG, denali->reg + CHIP_ENABLE_DONT_CARE); - iowrite32(ECC_ENABLE__FLAG, denali->reg + ECC_ENABLE); - 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 */ @@ -912,10 +903,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; @@ -927,10 +918,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; @@ -946,7 +937,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); /* @@ -997,38 +988,10 @@ 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 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) { @@ -1040,33 +1003,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; @@ -1074,7 +1010,7 @@ static int denali_attach_chip(struct nand_chip *chip) return 0; } -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; @@ -1083,7 +1019,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; @@ -1097,7 +1033,7 @@ static void denali_exec_in16(struct denali_nand_info *denali, u32 type, } } -static void denali_exec_in(struct denali_nand_info *denali, u32 type, +static void denali_exec_in(struct denali_controller *denali, u32 type, u8 *buf, unsigned int len, bool width16) { if (width16) @@ -1106,7 +1042,7 @@ static void denali_exec_in(struct denali_nand_info *denali, u32 type, denali_exec_in8(denali, type, buf, len); } -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; @@ -1115,7 +1051,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; @@ -1125,7 +1061,7 @@ static void denali_exec_out16(struct denali_nand_info *denali, u32 type, buf[i + 1] << 16 | buf[i]); } -static void denali_exec_out(struct denali_nand_info *denali, u32 type, +static void denali_exec_out(struct denali_controller *denali, u32 type, const u8 *buf, unsigned int len, bool width16) { if (width16) @@ -1134,7 +1070,7 @@ static void denali_exec_out(struct denali_nand_info *denali, u32 type, denali_exec_out8(denali, type, buf, len); } -static int denali_exec_waitrdy(struct denali_nand_info *denali) +static int denali_exec_waitrdy(struct denali_controller *denali) { u32 irq_stat; @@ -1150,7 +1086,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); switch (instr->type) { case NAND_OP_CMD_INSTR: @@ -1200,7 +1136,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]); @@ -1217,53 +1153,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) { @@ -1271,20 +1234,111 @@ 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(0, denali->reg + TRANSFER_SPARE_REG); + iowrite32(GENMASK(denali->nbanks - 1, 0), denali->reg + RB_PIN_ENABLED); + iowrite32(CHIP_EN_DONT_CARE__FLAG, denali->reg + CHIP_ENABLE_DONT_CARE); + iowrite32(ECC_ENABLE__FLAG, denali->reg + ECC_ENABLE); + 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 d2603c6..e5cdcda 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,29 +291,98 @@ #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 + * @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; + 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; - 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); }; @@ -320,7 +390,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 E5747C43381 for ; Tue, 2 Apr 2019 04:05:26 +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 AB7082084C for ; Tue, 2 Apr 2019 04:05:26 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="Iqo4AsXD"; dkim=fail reason="signature verification failed" (2048-bit key) header.d=nifty.com header.i=@nifty.com header.b="2Qkul3Oo" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org AB7082084C 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=jo78Kr6ptfFp5ZVfijdo4AJ/MAmN7HfyWaB2M9TYknk=; b=Iqo4AsXD3ovX3v jZfILViz4TPeItAOg9y0j7dpUPllVGnpU/3JKEppfVE51TvKbAAd0RRRYNLziHNopqnZSZ9v4j3vO 9YjUc/SbRXZngxkE81U3PWNytpxQMcY62rmsm6kKMKh5kR1KZlN+ppGvb/H1SbDmmkTzrr+ZDwbqM Vqs6/Df6oab2CNf4LzVuSTNlvFhN8h3B/XkU97YqKuIAxc/4JE4A+pCpL+Ai/z9uLhs6d3BBScpNE M/g2+D9zrCisAoYdhfSzJitnF/KjND8VF9EKSxrQ0zx5l70D93mXpCCEMUemqMcAQy4sZde5ahcIV 6OUkicIIw4smPcsDY2NA==; 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 1hBAfq-0002yw-0R; Tue, 02 Apr 2019 04:05:22 +0000 Received: from conuserg-07.nifty.com ([210.131.2.74]) by bombadil.infradead.org with esmtps (Exim 4.90_1 #2 (Red Hat Linux)) id 1hBAeI-0008Ei-9W for linux-mtd@lists.infradead.org; Tue, 02 Apr 2019 04:03:57 +0000 Received: from pug.e01.socionext.com (p14092-ipngnfx01kyoto.kyoto.ocn.ne.jp [153.142.97.92]) (authenticated) by conuserg-07.nifty.com with ESMTP id x3243Haa021871; Tue, 2 Apr 2019 13:03:24 +0900 DKIM-Filter: OpenDKIM Filter v2.10.3 conuserg-07.nifty.com x3243Haa021871 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nifty.com; s=dec2015msa; t=1554177805; bh=124eBJCr4qqB7iP4i51cXSSRik3d7kHbEGuewnEjsk0=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=2Qkul3OoJC3P5PlWh607ViG+OlQ+YTdVn8YTHw6+CS1jmfvuY1o3H+uW5tn4jZS8h FVoqIa1B1rXuPzG6jkf5DHUuFhw4+3nEHiVUWJSMP8BPitU48PkcgrnyaP5yNo4o4H QvE68WxsxglKK4Kmaa70F6pVacJcXT1izl5RlvK7GnaM2H1WchPCYMfrLRL/0bTB9h 7fy6LfvwrpAwLrg5ECTZGiJIDXcZeX2vTvGDAGfzNAmaIUe1+OMwzVuNn4DnxuZRRH CvUPGqNXCxdSEvFcVEXPaauJsjXwfaZ9HMHNATszsCr2Mmmd9fyuvLHWoQw8JDdyTM 5Pz0QHY42J6pA== X-Nifty-SrcIP: [153.142.97.92] From: Masahiro Yamada To: linux-mtd@lists.infradead.org, Miquel Raynal Subject: [PATCH v5 7/9] mtd: rawnand: denali: decouple controller and NAND chips Date: Tue, 2 Apr 2019 13:03:07 +0900 Message-Id: <1554177789-15414-8-git-send-email-yamada.masahiro@socionext.com> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1554177789-15414-1-git-send-email-yamada.masahiro@socionext.com> References: <1554177789-15414-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-20190401_210346_687053_23D85CE3 X-CRM114-Status: GOOD ( 20.50 ) 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+Ci0tLQoKQ2hhbmdlcyBpbiB2NTogTm9uZQpDaGFuZ2VzIGluIHY0OiBOb25l CkNoYW5nZXMgaW4gdjM6CiAtIHNpbXBsaWZ5IG10ZC0+bmFtZSBmYWxsYmFjawogLSBBZGQgUm9i J3MgQWNrCgpDaGFuZ2VzIGluIHYyOiBOb25lCgogLi4uL2RldmljZXRyZWUvYmluZGluZ3MvbXRk L2RlbmFsaS1uYW5kLnR4dCAgICAgICAgfCAgNDAgKy0KIGRyaXZlcnMvbXRkL25hbmQvcmF3L2Rl bmFsaS5jICAgICAgICAgICAgICAgICAgICAgIHwgNDMwICsrKysrKysrKysrKy0tLS0tLS0tLQog ZHJpdmVycy9tdGQvbmFuZC9yYXcvZGVuYWxpLmggICAgICAgICAgICAgICAgICAgICAgfCAxMTQg KysrKystCiBkcml2ZXJzL210ZC9uYW5kL3Jhdy9kZW5hbGlfZHQuYyAgICAgICAgICAgICAgICAg ICB8ICA5OCArKysrLQogZHJpdmVycy9tdGQvbmFuZC9yYXcvZGVuYWxpX3BjaS5jICAgICAgICAg ICAgICAgICAgfCAgMzAgKy0KIDUgZmlsZXMgY2hhbmdlZCwgNDgyIGluc2VydGlvbnMoKyksIDIz MCBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2RldmljZXRyZWUvYmlu ZGluZ3MvbXRkL2RlbmFsaS1uYW5kLnR4dCBiL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5k aW5ncy9tdGQvZGVuYWxpLW5hbmQudHh0CmluZGV4IGYzM2RhODcuLmIxNGI2NzUgMTAwNjQ0Ci0t LSBhL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9tdGQvZGVuYWxpLW5hbmQudHh0 CisrKyBiL0RvY3VtZW50YXRpb24vZGV2aWNldHJlZS9iaW5kaW5ncy9tdGQvZGVuYWxpLW5hbmQu dHh0CkBAIC03LDM0ICs3LDQ4IEBAIFJlcXVpcmVkIHByb3BlcnRpZXM6CiAgICAgICAic29jaW9u ZXh0LHVuaXBoaWVyLWRlbmFsaS1uYW5kLXY1YiIgIC0gZm9yIFNvY2lvbmV4dCBVbmlQaGllciAo djViKQogICAtIHJlZyA6IHNob3VsZCBjb250YWluIHJlZ2lzdGVycyBsb2NhdGlvbiBhbmQgbGVu Z3RoIGZvciBkYXRhIGFuZCByZWcuCiAgIC0gcmVnLW5hbWVzOiBTaG91bGQgY29udGFpbiB0aGUg cmVnIG5hbWVzICJuYW5kX2RhdGEiIGFuZCAiZGVuYWxpX3JlZyIKKyAgLSAjYWRkcmVzcy1jZWxs czogc2hvdWxkIGJlIDEuIFRoZSBjZWxsIGVuY29kZXMgdGhlIGNoaXAgc2VsZWN0IGNvbm5lY3Rp b24uCisgIC0gI3NpemUtY2VsbHMgOiBzaG91bGQgYmUgMC4KICAgLSBpbnRlcnJ1cHRzIDogVGhl IGludGVycnVwdCBudW1iZXIuCiAgIC0gY2xvY2tzOiBzaG91bGQgY29udGFpbiBwaGFuZGxlIG9m IHRoZSBjb250cm9sbGVyIGNvcmUgY2xvY2ssIHRoZSBidXMKICAgICBpbnRlcmZhY2UgY2xvY2ss IGFuZCB0aGUgRUNDIGNpcmN1aXQgY2xvY2suCiAgIC0gY2xvY2stbmFtZXM6IHNob3VsZCBjb250 YWluICJuYW5kIiwgIm5hbmRfeCIsICJlY2MiCiAKLU9wdGlvbmFsIHByb3BlcnRpZXM6Ci0gIC0g bmFuZC1lY2Mtc3RlcC1zaXplOiBzZWUgbmFuZC50eHQgZm9yIGRldGFpbHMuICBJZiBwcmVzZW50 LCB0aGUgdmFsdWUgbXVzdCBiZQotICAgICAgNTEyICAgICAgICBmb3IgImFsdHIsc29jZnBnYS1k ZW5hbGktbmFuZCIKLSAgICAgIDEwMjQgICAgICAgZm9yICJzb2Npb25leHQsdW5pcGhpZXItZGVu YWxpLW5hbmQtdjVhIgotICAgICAgMTAyNCAgICAgICBmb3IgInNvY2lvbmV4dCx1bmlwaGllci1k ZW5hbGktbmFuZC12NWIiCi0gIC0gbmFuZC1lY2Mtc3RyZW5ndGg6IHNlZSBuYW5kLnR4dCBmb3Ig ZGV0YWlscy4gIFZhbGlkIHZhbHVlcyBhcmU6Ci0gICAgICA4LCAxNSAgICAgIGZvciAiYWx0cixz b2NmcGdhLWRlbmFsaS1uYW5kIgotICAgICAgOCwgMTYsIDI0ICBmb3IgInNvY2lvbmV4dCx1bmlw aGllci1kZW5hbGktbmFuZC12NWEiCi0gICAgICA4LCAxNiAgICAgIGZvciAic29jaW9uZXh0LHVu aXBoaWVyLWRlbmFsaS1uYW5kLXY1YiIKLSAgLSBuYW5kLWVjYy1tYXhpbWl6ZTogc2VlIG5hbmQu dHh0IGZvciBkZXRhaWxzCi0KLVRoZSBkZXZpY2UgdHJlZSBtYXkgb3B0aW9uYWxseSBjb250YWlu IHN1Yi1ub2RlcyBkZXNjcmliaW5nIHBhcnRpdGlvbnMgb2YgdGhlCitTdWItbm9kZXM6CisgIFN1 Yi1ub2RlcyByZXByZXNlbnQgYXZhaWxhYmxlIE5BTkQgY2hpcHMuCisKKyAgUmVxdWlyZWQgcHJv cGVydGllczoKKyAgICAtIHJlZzogc2hvdWxkIGNvbnRhaW4gdGhlIGJhbmsgSUQgb2YgdGhlIGNv bnRyb2xsZXIgdG8gd2hpY2ggZWFjaCBjaGlwCisgICAgICBzZWxlY3QgaXMgY29ubmVjdGVkLgor CisgIE9wdGlvbmFsIHByb3BlcnRpZXM6CisgICAgLSBuYW5kLWVjYy1zdGVwLXNpemU6IHNlZSBu YW5kLnR4dCBmb3IgZGV0YWlscy4KKyAgICAgIElmIHByZXNlbnQsIHRoZSB2YWx1ZSBtdXN0IGJl CisgICAgICAgIDUxMiAgICAgICAgZm9yICJhbHRyLHNvY2ZwZ2EtZGVuYWxpLW5hbmQiCisgICAg ICAgIDEwMjQgICAgICAgZm9yICJzb2Npb25leHQsdW5pcGhpZXItZGVuYWxpLW5hbmQtdjVhIgor ICAgICAgICAxMDI0ICAgICAgIGZvciAic29jaW9uZXh0LHVuaXBoaWVyLWRlbmFsaS1uYW5kLXY1 YiIKKyAgICAtIG5hbmQtZWNjLXN0cmVuZ3RoOiBzZWUgbmFuZC50eHQgZm9yIGRldGFpbHMuIFZh bGlkIHZhbHVlcyBhcmU6CisgICAgICAgIDgsIDE1ICAgICAgZm9yICJhbHRyLHNvY2ZwZ2EtZGVu YWxpLW5hbmQiCisgICAgICAgIDgsIDE2LCAyNCAgZm9yICJzb2Npb25leHQsdW5pcGhpZXItZGVu YWxpLW5hbmQtdjVhIgorICAgICAgICA4LCAxNiAgICAgIGZvciAic29jaW9uZXh0LHVuaXBoaWVy LWRlbmFsaS1uYW5kLXY1YiIKKyAgICAtIG5hbmQtZWNjLW1heGltaXplOiBzZWUgbmFuZC50eHQg Zm9yIGRldGFpbHMKKworVGhlIGNoaXAgbm9kZXMgbWF5IG9wdGlvbmFsbHkgY29udGFpbiBzdWIt bm9kZXMgZGVzY3JpYmluZyBwYXJ0aXRpb25zIG9mIHRoZQogYWRkcmVzcyBzcGFjZS4gU2VlIHBh cnRpdGlvbi50eHQgZm9yIG1vcmUgZGV0YWlsLgogCiBFeGFtcGxlczoKIAogbmFuZDogbmFuZEBm ZjkwMDAwMCB7CiAJI2FkZHJlc3MtY2VsbHMgPSA8MT47Ci0JI3NpemUtY2VsbHMgPSA8MT47CisJ I3NpemUtY2VsbHMgPSA8MD47CiAJY29tcGF0aWJsZSA9ICJhbHRyLHNvY2ZwZ2EtZGVuYWxpLW5h bmQiOwogCXJlZyA9IDwweGZmOTAwMDAwIDB4MjA+LCA8MHhmZmI4MDAwMCAweDEwMDA+OwogCXJl Zy1uYW1lcyA9ICJuYW5kX2RhdGEiLCAiZGVuYWxpX3JlZyI7CiAJY2xvY2tzID0gPCZuYW5kX2Ns az4sIDwmbmFuZF94X2Nsaz4sIDwmbmFuZF9lY2NfY2xrPjsKIAljbG9jay1uYW1lcyA9ICJuYW5k IiwgIm5hbmRfeCIsICJlY2MiOwogCWludGVycnVwdHMgPSA8MCAxNDQgND47CisKKwluYW5kQDAg eworCQlyZWcgPSA8MD47CisJfQogfTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbXRkL25hbmQvcmF3 L2RlbmFsaS5jIGIvZHJpdmVycy9tdGQvbmFuZC9yYXcvZGVuYWxpLmMKaW5kZXggYTUwMWQ5ZS4u ODcyMjc2MiAxMDA2NDQKLS0tIGEvZHJpdmVycy9tdGQvbmFuZC9yYXcvZGVuYWxpLmMKKysrIGIv ZHJpdmVycy9tdGQvbmFuZC9yYXcvZGVuYWxpLmMKQEAgLTMsNyArMyw3IEBACiAgKiBOQU5EIEZs YXNoIENvbnRyb2xsZXIgRGV2aWNlIERyaXZlcgogICogQ29weXJpZ2h0IMKpIDIwMDktMjAxMCwg SW50ZWwgQ29ycG9yYXRpb24gYW5kIGl0cyBzdXBwbGllcnMuCiAgKgotICogQ29weXJpZ2h0IChj KSAyMDE3IFNvY2lvbmV4dCBJbmMuCisgKiBDb3B5cmlnaHQgKGMpIDIwMTctMjAxOSBTb2Npb25l eHQgSW5jLgogICogICBSZXdvcmtlZCBieSBNYXNhaGlybyBZYW1hZGEgPHlhbWFkYS5tYXNhaGly b0Bzb2Npb25leHQuY29tPgogICovCiAKQEAgLTQyLDE0ICs0MiwxNSBAQAogI2RlZmluZSBERU5B TElfSU5WQUxJRF9CQU5LCS0xCiAjZGVmaW5lIERFTkFMSV9OUl9CQU5LUwkJNAogCi1zdGF0aWMg aW5saW5lIHN0cnVjdCBkZW5hbGlfbmFuZF9pbmZvICptdGRfdG9fZGVuYWxpKHN0cnVjdCBtdGRf aW5mbyAqbXRkKQorc3RhdGljIHN0cnVjdCBkZW5hbGlfY2hpcCAqdG9fZGVuYWxpX2NoaXAoc3Ry dWN0IG5hbmRfY2hpcCAqY2hpcCkKIHsKLQlyZXR1cm4gY29udGFpbmVyX29mKG10ZF90b19uYW5k KG10ZCksIHN0cnVjdCBkZW5hbGlfbmFuZF9pbmZvLCBuYW5kKTsKKwlyZXR1cm4gY29udGFpbmVy X29mKGNoaXAsIHN0cnVjdCBkZW5hbGlfY2hpcCwgY2hpcCk7CiB9CiAKLXN0YXRpYyBzdHJ1Y3Qg ZGVuYWxpX25hbmRfaW5mbyAqdG9fZGVuYWxpKHN0cnVjdCBuYW5kX2NoaXAgKmNoaXApCitzdGF0 aWMgc3RydWN0IGRlbmFsaV9jb250cm9sbGVyICp0b19kZW5hbGlfY29udHJvbGxlcihzdHJ1Y3Qg bmFuZF9jaGlwICpjaGlwKQogewotCXJldHVybiBjb250YWluZXJfb2YoY2hpcCwgc3RydWN0IGRl bmFsaV9uYW5kX2luZm8sIG5hbmQpOworCXJldHVybiBjb250YWluZXJfb2YoY2hpcC0+Y29udHJv bGxlciwgc3RydWN0IGRlbmFsaV9jb250cm9sbGVyLAorCQkJICAgIGNvbnRyb2xsZXIpOwogfQog CiAvKgpAQCAtNTcsMTIgKzU4LDEyIEBAIHN0YXRpYyBzdHJ1Y3QgZGVuYWxpX25hbmRfaW5mbyAq dG9fZGVuYWxpKHN0cnVjdCBuYW5kX2NoaXAgKmNoaXApCiAgKiB0eXBlLCBiYW5rLCBibG9jaywg YW5kIHBhZ2UgYWRkcmVzcykuICBUaGUgc2xhdmUgZGF0YSBpcyB0aGUgYWN0dWFsIGRhdGEgdG8K ICAqIGJlIHRyYW5zZmVycmVkLiAgVGhpcyBtb2RlIHJlcXVpcmVzIDI4IGJpdHMgb2YgYWRkcmVz cyByZWdpb24gYWxsb2NhdGVkLgogICovCi1zdGF0aWMgdTMyIGRlbmFsaV9kaXJlY3RfcmVhZChz dHJ1Y3QgZGVuYWxpX25hbmRfaW5mbyAqZGVuYWxpLCB1MzIgYWRkcikKK3N0YXRpYyB1MzIgZGVu YWxpX2RpcmVjdF9yZWFkKHN0cnVjdCBkZW5hbGlfY29udHJvbGxlciAqZGVuYWxpLCB1MzIgYWRk cikKIHsKIAlyZXR1cm4gaW9yZWFkMzIoZGVuYWxpLT5ob3N0ICsgYWRkcik7CiB9CiAKLXN0YXRp YyB2b2lkIGRlbmFsaV9kaXJlY3Rfd3JpdGUoc3RydWN0IGRlbmFsaV9uYW5kX2luZm8gKmRlbmFs aSwgdTMyIGFkZHIsCitzdGF0aWMgdm9pZCBkZW5hbGlfZGlyZWN0X3dyaXRlKHN0cnVjdCBkZW5h bGlfY29udHJvbGxlciAqZGVuYWxpLCB1MzIgYWRkciwKIAkJCQl1MzIgZGF0YSkKIHsKIAlpb3dy aXRlMzIoZGF0YSwgZGVuYWxpLT5ob3N0ICsgYWRkcik7CkBAIC03NCwzNSArNzUsMjAgQEAgc3Rh dGljIHZvaWQgZGVuYWxpX2RpcmVjdF93cml0ZShzdHJ1Y3QgZGVuYWxpX25hbmRfaW5mbyAqZGVu YWxpLCB1MzIgYWRkciwKICAqIGNvbnRyb2wgaW5mb3JtYXRpb24gYW5kIHRyYW5zZmVycmVkIGRh dGEgYXJlIGxhdGNoZWQgYnkgdGhlIHJlZ2lzdGVycyBpbgogICogdGhlIHRyYW5zbGF0aW9uIG1v ZHVsZS4KICAqLwotc3RhdGljIHUzMiBkZW5hbGlfaW5kZXhlZF9yZWFkKHN0cnVjdCBkZW5hbGlf bmFuZF9pbmZvICpkZW5hbGksIHUzMiBhZGRyKQorc3RhdGljIHUzMiBkZW5hbGlfaW5kZXhlZF9y ZWFkKHN0cnVjdCBkZW5hbGlfY29udHJvbGxlciAqZGVuYWxpLCB1MzIgYWRkcikKIHsKIAlpb3dy aXRlMzIoYWRkciwgZGVuYWxpLT5ob3N0ICsgREVOQUxJX0lOREVYRURfQ1RSTCk7CiAJcmV0dXJu IGlvcmVhZDMyKGRlbmFsaS0+aG9zdCArIERFTkFMSV9JTkRFWEVEX0RBVEEpOwogfQogCi1zdGF0 aWMgdm9pZCBkZW5hbGlfaW5kZXhlZF93cml0ZShzdHJ1Y3QgZGVuYWxpX25hbmRfaW5mbyAqZGVu YWxpLCB1MzIgYWRkciwKK3N0YXRpYyB2b2lkIGRlbmFsaV9pbmRleGVkX3dyaXRlKHN0cnVjdCBk ZW5hbGlfY29udHJvbGxlciAqZGVuYWxpLCB1MzIgYWRkciwKIAkJCQkgdTMyIGRhdGEpCiB7CiAJ aW93cml0ZTMyKGFkZHIsIGRlbmFsaS0+aG9zdCArIERFTkFMSV9JTkRFWEVEX0NUUkwpOwogCWlv d3JpdGUzMihkYXRhLCBkZW5hbGktPmhvc3QgKyBERU5BTElfSU5ERVhFRF9EQVRBKTsKIH0KIAot LyoKLSAqIFVzZSB0aGUgY29uZmlndXJhdGlvbiBmZWF0dXJlIHJlZ2lzdGVyIHRvIGRldGVybWlu ZSB0aGUgbWF4aW11bSBudW1iZXIgb2YKLSAqIGJhbmtzIHRoYXQgdGhlIGhhcmR3YXJlIHN1cHBv cnRzLgotICovCi1zdGF0aWMgdm9pZCBkZW5hbGlfZGV0ZWN0X21heF9iYW5rcyhzdHJ1Y3QgZGVu YWxpX25hbmRfaW5mbyAqZGVuYWxpKQotewotCXVpbnQzMl90IGZlYXR1cmVzID0gaW9yZWFkMzIo ZGVuYWxpLT5yZWcgKyBGRUFUVVJFUyk7Ci0KLQlkZW5hbGktPm1heF9iYW5rcyA9IDEgPDwgRklF TERfR0VUKEZFQVRVUkVTX19OX0JBTktTLCBmZWF0dXJlcyk7Ci0KLQkvKiB0aGUgZW5jb2Rpbmcg Y2hhbmdlZCBmcm9tIHJldiA1LjAgdG8gNS4xICovCi0JaWYgKGRlbmFsaS0+cmV2aXNpb24gPCAw eDA1MDEpCi0JCWRlbmFsaS0+bWF4X2JhbmtzIDw8PSAxOwotfQotCi1zdGF0aWMgdm9pZCBkZW5h bGlfZW5hYmxlX2lycShzdHJ1Y3QgZGVuYWxpX25hbmRfaW5mbyAqZGVuYWxpKQorc3RhdGljIHZv aWQgZGVuYWxpX2VuYWJsZV9pcnEoc3RydWN0IGRlbmFsaV9jb250cm9sbGVyICpkZW5hbGkpCiB7 CiAJaW50IGk7CiAKQEAgLTExMSw3ICs5Nyw3IEBAIHN0YXRpYyB2b2lkIGRlbmFsaV9lbmFibGVf aXJxKHN0cnVjdCBkZW5hbGlfbmFuZF9pbmZvICpkZW5hbGkpCiAJaW93cml0ZTMyKEdMT0JBTF9J TlRfRU5fRkxBRywgZGVuYWxpLT5yZWcgKyBHTE9CQUxfSU5UX0VOQUJMRSk7CiB9CiAKLXN0YXRp YyB2b2lkIGRlbmFsaV9kaXNhYmxlX2lycShzdHJ1Y3QgZGVuYWxpX25hbmRfaW5mbyAqZGVuYWxp KQorc3RhdGljIHZvaWQgZGVuYWxpX2Rpc2FibGVfaXJxKHN0cnVjdCBkZW5hbGlfY29udHJvbGxl ciAqZGVuYWxpKQogewogCWludCBpOwogCkBAIC0xMjAsMTQgKzEwNiwxNCBAQCBzdGF0aWMgdm9p ZCBkZW5hbGlfZGlzYWJsZV9pcnEoc3RydWN0IGRlbmFsaV9uYW5kX2luZm8gKmRlbmFsaSkKIAlp b3dyaXRlMzIoMCwgZGVuYWxpLT5yZWcgKyBHTE9CQUxfSU5UX0VOQUJMRSk7CiB9CiAKLXN0YXRp YyB2b2lkIGRlbmFsaV9jbGVhcl9pcnEoc3RydWN0IGRlbmFsaV9uYW5kX2luZm8gKmRlbmFsaSwK K3N0YXRpYyB2b2lkIGRlbmFsaV9jbGVhcl9pcnEoc3RydWN0IGRlbmFsaV9jb250cm9sbGVyICpk ZW5hbGksCiAJCQkgICAgIGludCBiYW5rLCB1aW50MzJfdCBpcnFfc3RhdHVzKQogewogCS8qIHdy aXRlIG9uZSB0byBjbGVhciBiaXRzICovCiAJaW93cml0ZTMyKGlycV9zdGF0dXMsIGRlbmFsaS0+ cmVnICsgSU5UUl9TVEFUVVMoYmFuaykpOwogfQogCi1zdGF0aWMgdm9pZCBkZW5hbGlfY2xlYXJf aXJxX2FsbChzdHJ1Y3QgZGVuYWxpX25hbmRfaW5mbyAqZGVuYWxpKQorc3RhdGljIHZvaWQgZGVu YWxpX2NsZWFyX2lycV9hbGwoc3RydWN0IGRlbmFsaV9jb250cm9sbGVyICpkZW5hbGkpCiB7CiAJ aW50IGk7CiAKQEAgLTEzNyw3ICsxMjMsNyBAQCBzdGF0aWMgdm9pZCBkZW5hbGlfY2xlYXJfaXJx X2FsbChzdHJ1Y3QgZGVuYWxpX25hbmRfaW5mbyAqZGVuYWxpKQogCiBzdGF0aWMgaXJxcmV0dXJu X3QgZGVuYWxpX2lzcihpbnQgaXJxLCB2b2lkICpkZXZfaWQpCiB7Ci0Jc3RydWN0IGRlbmFsaV9u YW5kX2luZm8gKmRlbmFsaSA9IGRldl9pZDsKKwlzdHJ1Y3QgZGVuYWxpX2NvbnRyb2xsZXIgKmRl bmFsaSA9IGRldl9pZDsKIAlpcnFyZXR1cm5fdCByZXQgPSBJUlFfTk9ORTsKIAl1aW50MzJfdCBp cnFfc3RhdHVzOwogCWludCBpOwpAQCAtMTY1LDcgKzE1MSw3IEBAIHN0YXRpYyBpcnFyZXR1cm5f dCBkZW5hbGlfaXNyKGludCBpcnEsIHZvaWQgKmRldl9pZCkKIAlyZXR1cm4gcmV0OwogfQogCi1z dGF0aWMgdm9pZCBkZW5hbGlfcmVzZXRfaXJxKHN0cnVjdCBkZW5hbGlfbmFuZF9pbmZvICpkZW5h bGkpCitzdGF0aWMgdm9pZCBkZW5hbGlfcmVzZXRfaXJxKHN0cnVjdCBkZW5hbGlfY29udHJvbGxl ciAqZGVuYWxpKQogewogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAKQEAgLTE3NSw4ICsxNjEsNyBA QCBzdGF0aWMgdm9pZCBkZW5hbGlfcmVzZXRfaXJxKHN0cnVjdCBkZW5hbGlfbmFuZF9pbmZvICpk ZW5hbGkpCiAJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZGVuYWxpLT5pcnFfbG9jaywgZmxhZ3Mp OwogfQogCi1zdGF0aWMgdWludDMyX3QgZGVuYWxpX3dhaXRfZm9yX2lycShzdHJ1Y3QgZGVuYWxp X25hbmRfaW5mbyAqZGVuYWxpLAotCQkJCSAgICB1aW50MzJfdCBpcnFfbWFzaykKK3N0YXRpYyB1 MzIgZGVuYWxpX3dhaXRfZm9yX2lycShzdHJ1Y3QgZGVuYWxpX2NvbnRyb2xsZXIgKmRlbmFsaSwg dTMyIGlycV9tYXNrKQogewogCXVuc2lnbmVkIGxvbmcgdGltZV9sZWZ0LCBmbGFnczsKIAl1aW50 MzJfdCBpcnFfc3RhdHVzOwpAQCAtMjA4LDkgKzE5Myw0MSBAQCBzdGF0aWMgdWludDMyX3QgZGVu YWxpX3dhaXRfZm9yX2lycShzdHJ1Y3QgZGVuYWxpX25hbmRfaW5mbyAqZGVuYWxpLAogCiBzdGF0 aWMgdm9pZCBkZW5hbGlfc2VsZWN0X3RhcmdldChzdHJ1Y3QgbmFuZF9jaGlwICpjaGlwLCBpbnQg Y3MpCiB7Ci0Jc3RydWN0IGRlbmFsaV9uYW5kX2luZm8gKmRlbmFsaSA9IHRvX2RlbmFsaShjaGlw KTsKKwlzdHJ1Y3QgZGVuYWxpX2NvbnRyb2xsZXIgKmRlbmFsaSA9IHRvX2RlbmFsaV9jb250cm9s bGVyKGNoaXApOworCXN0cnVjdCBkZW5hbGlfY2hpcF9zZWwgKnNlbCA9ICZ0b19kZW5hbGlfY2hp cChjaGlwKS0+c2Vsc1tjc107CisJc3RydWN0IG10ZF9pbmZvICptdGQgPSBuYW5kX3RvX210ZChj aGlwKTsKKworCWRlbmFsaS0+YWN0aXZlX2JhbmsgPSBzZWwtPmJhbms7CiAKLQlkZW5hbGktPmFj dGl2ZV9iYW5rID0gY3M7CisJaW93cml0ZTMyKDEgPDwgKGNoaXAtPnBoeXNfZXJhc2Vfc2hpZnQg LSBjaGlwLT5wYWdlX3NoaWZ0KSwKKwkJICBkZW5hbGktPnJlZyArIFBBR0VTX1BFUl9CTE9DSyk7 CisJaW93cml0ZTMyKGNoaXAtPm9wdGlvbnMgJiBOQU5EX0JVU1dJRFRIXzE2ID8gMSA6IDAsCisJ CSAgZGVuYWxpLT5yZWcgKyBERVZJQ0VfV0lEVEgpOworCWlvd3JpdGUzMihtdGQtPndyaXRlc2l6 ZSwgZGVuYWxpLT5yZWcgKyBERVZJQ0VfTUFJTl9BUkVBX1NJWkUpOworCWlvd3JpdGUzMihtdGQt Pm9vYnNpemUsIGRlbmFsaS0+cmVnICsgREVWSUNFX1NQQVJFX0FSRUFfU0laRSk7CisJaW93cml0 ZTMyKGNoaXAtPm9wdGlvbnMgJiBOQU5EX1JPV19BRERSXzMgPworCQkgIDAgOiBUV09fUk9XX0FE RFJfQ1lDTEVTX19GTEFHLAorCQkgIGRlbmFsaS0+cmVnICsgVFdPX1JPV19BRERSX0NZQ0xFUyk7 CisJaW93cml0ZTMyKEZJRUxEX1BSRVAoRUNDX0NPUlJFQ1RJT05fX0VSQVNFX1RIUkVTSE9MRCwg MSkgfAorCQkgIEZJRUxEX1BSRVAoRUNDX0NPUlJFQ1RJT05fX1ZBTFVFLCBjaGlwLT5lY2Muc3Ry ZW5ndGgpLAorCQkgIGRlbmFsaS0+cmVnICsgRUNDX0NPUlJFQ1RJT04pOworCWlvd3JpdGUzMihj aGlwLT5lY2Muc2l6ZSwgZGVuYWxpLT5yZWcgKyBDRkdfREFUQV9CTE9DS19TSVpFKTsKKwlpb3dy aXRlMzIoY2hpcC0+ZWNjLnNpemUsIGRlbmFsaS0+cmVnICsgQ0ZHX0xBU1RfREFUQV9CTE9DS19T SVpFKTsKKwlpb3dyaXRlMzIoY2hpcC0+ZWNjLnN0ZXBzLCBkZW5hbGktPnJlZyArIENGR19OVU1f REFUQV9CTE9DS1MpOworCisJaWYgKGNoaXAtPm9wdGlvbnMgJiBOQU5EX0tFRVBfVElNSU5HUykK KwkJcmV0dXJuOworCisJLyogdXBkYXRlIHRpbWluZyByZWdpc3RlcnMgdW5sZXNzIE5BTkRfS0VF UF9USU1JTkdTIGlzIHNldCAqLworCWlvd3JpdGUzMihzZWwtPmh3aHIyX2FuZF93ZV8yX3JlLCBk ZW5hbGktPnJlZyArIFRXSFIyX0FORF9XRV8yX1JFKTsKKwlpb3dyaXRlMzIoc2VsLT50Y3dhd19h bmRfYWRkcl8yX2RhdGEsCisJCSAgZGVuYWxpLT5yZWcgKyBUQ1dBV19BTkRfQUREUl8yX0RBVEEp OworCWlvd3JpdGUzMihzZWwtPnJlXzJfd2UsIGRlbmFsaS0+cmVnICsgUkVfMl9XRSk7CisJaW93 cml0ZTMyKHNlbC0+YWNjX2Nsa3MsIGRlbmFsaS0+cmVnICsgQUNDX0NMS1MpOworCWlvd3JpdGUz MihzZWwtPnJkd3JfZW5fbG9fY250LCBkZW5hbGktPnJlZyArIFJEV1JfRU5fTE9fQ05UKTsKKwlp b3dyaXRlMzIoc2VsLT5yZHdyX2VuX2hpX2NudCwgZGVuYWxpLT5yZWcgKyBSRFdSX0VOX0hJX0NO VCk7CisJaW93cml0ZTMyKHNlbC0+Y3Nfc2V0dXBfY250LCBkZW5hbGktPnJlZyArIENTX1NFVFVQ X0NOVCk7CisJaW93cml0ZTMyKHNlbC0+cmVfMl9yZSwgZGVuYWxpLT5yZWcgKyBSRV8yX1JFKTsK IH0KIAogc3RhdGljIGludCBkZW5hbGlfY2hhbmdlX2NvbHVtbihzdHJ1Y3QgbmFuZF9jaGlwICpj aGlwLCB1bnNpZ25lZCBpbnQgb2Zmc2V0LApAQCAtMjI2LDcgKzI0Myw3IEBAIHN0YXRpYyBpbnQg ZGVuYWxpX2NoYW5nZV9jb2x1bW4oc3RydWN0IG5hbmRfY2hpcCAqY2hpcCwgdW5zaWduZWQgaW50 IG9mZnNldCwKIAogc3RhdGljIGludCBkZW5hbGlfcGF5bG9hZF94ZmVyKHN0cnVjdCBuYW5kX2No aXAgKmNoaXAsIHZvaWQgKmJ1ZiwgYm9vbCB3cml0ZSkKIHsKLQlzdHJ1Y3QgZGVuYWxpX25hbmRf aW5mbyAqZGVuYWxpID0gdG9fZGVuYWxpKGNoaXApOworCXN0cnVjdCBkZW5hbGlfY29udHJvbGxl ciAqZGVuYWxpID0gdG9fZGVuYWxpX2NvbnRyb2xsZXIoY2hpcCk7CiAJc3RydWN0IG10ZF9pbmZv ICptdGQgPSBuYW5kX3RvX210ZChjaGlwKTsKIAlzdHJ1Y3QgbmFuZF9lY2NfY3RybCAqZWNjID0g JmNoaXAtPmVjYzsKIAlpbnQgd3JpdGVzaXplID0gbXRkLT53cml0ZXNpemU7CkBAIC0yNjMsNyAr MjgwLDcgQEAgc3RhdGljIGludCBkZW5hbGlfcGF5bG9hZF94ZmVyKHN0cnVjdCBuYW5kX2NoaXAg KmNoaXAsIHZvaWQgKmJ1ZiwgYm9vbCB3cml0ZSkKIAogc3RhdGljIGludCBkZW5hbGlfb29iX3hm ZXIoc3RydWN0IG5hbmRfY2hpcCAqY2hpcCwgdm9pZCAqYnVmLCBib29sIHdyaXRlKQogewotCXN0 cnVjdCBkZW5hbGlfbmFuZF9pbmZvICpkZW5hbGkgPSB0b19kZW5hbGkoY2hpcCk7CisJc3RydWN0 IGRlbmFsaV9jb250cm9sbGVyICpkZW5hbGkgPSB0b19kZW5hbGlfY29udHJvbGxlcihjaGlwKTsK IAlzdHJ1Y3QgbXRkX2luZm8gKm10ZCA9IG5hbmRfdG9fbXRkKGNoaXApOwogCXN0cnVjdCBuYW5k X2VjY19jdHJsICplY2MgPSAmY2hpcC0+ZWNjOwogCWludCB3cml0ZXNpemUgPSBtdGQtPndyaXRl c2l6ZTsKQEAgLTM5Myw3ICs0MTAsNyBAQCBzdGF0aWMgaW50IGRlbmFsaV9jaGVja19lcmFzZWRf cGFnZShzdHJ1Y3QgbmFuZF9jaGlwICpjaGlwLCB1OCAqYnVmLAogCQkJCSAgICB1bnNpZ25lZCBs b25nIHVuY29yX2VjY19mbGFncywKIAkJCQkgICAgdW5zaWduZWQgaW50IG1heF9iaXRmbGlwcykK IHsKLQlzdHJ1Y3QgZGVuYWxpX25hbmRfaW5mbyAqZGVuYWxpID0gdG9fZGVuYWxpKGNoaXApOwor CXN0cnVjdCBkZW5hbGlfY29udHJvbGxlciAqZGVuYWxpID0gdG9fZGVuYWxpX2NvbnRyb2xsZXIo Y2hpcCk7CiAJc3RydWN0IG10ZF9lY2Nfc3RhdHMgKmVjY19zdGF0cyA9ICZuYW5kX3RvX210ZChj aGlwKS0+ZWNjX3N0YXRzOwogCXVpbnQ4X3QgKmVjY19jb2RlID0gY2hpcC0+b29iX3BvaSArIGRl bmFsaS0+b29iX3NraXBfYnl0ZXM7CiAJaW50IGVjY19zdGVwcyA9IGNoaXAtPmVjYy5zdGVwczsK QEAgLTQyNiw3ICs0NDMsNyBAQCBzdGF0aWMgaW50IGRlbmFsaV9jaGVja19lcmFzZWRfcGFnZShz dHJ1Y3QgbmFuZF9jaGlwICpjaGlwLCB1OCAqYnVmLAogc3RhdGljIGludCBkZW5hbGlfaHdfZWNj X2ZpeHVwKHN0cnVjdCBuYW5kX2NoaXAgKmNoaXAsCiAJCQkgICAgICAgdW5zaWduZWQgbG9uZyAq dW5jb3JfZWNjX2ZsYWdzKQogewotCXN0cnVjdCBkZW5hbGlfbmFuZF9pbmZvICpkZW5hbGkgPSB0 b19kZW5hbGkoY2hpcCk7CisJc3RydWN0IGRlbmFsaV9jb250cm9sbGVyICpkZW5hbGkgPSB0b19k ZW5hbGlfY29udHJvbGxlcihjaGlwKTsKIAlzdHJ1Y3QgbXRkX2VjY19zdGF0cyAqZWNjX3N0YXRz ID0gJm5hbmRfdG9fbXRkKGNoaXApLT5lY2Nfc3RhdHM7CiAJaW50IGJhbmsgPSBkZW5hbGktPmFj dGl2ZV9iYW5rOwogCXVpbnQzMl90IGVjY19jb3I7CkBAIC00NjEsNyArNDc4LDcgQEAgc3RhdGlj IGludCBkZW5hbGlfaHdfZWNjX2ZpeHVwKHN0cnVjdCBuYW5kX2NoaXAgKmNoaXAsCiBzdGF0aWMg aW50IGRlbmFsaV9zd19lY2NfZml4dXAoc3RydWN0IG5hbmRfY2hpcCAqY2hpcCwKIAkJCSAgICAg ICB1bnNpZ25lZCBsb25nICp1bmNvcl9lY2NfZmxhZ3MsIHVpbnQ4X3QgKmJ1ZikKIHsKLQlzdHJ1 Y3QgZGVuYWxpX25hbmRfaW5mbyAqZGVuYWxpID0gdG9fZGVuYWxpKGNoaXApOworCXN0cnVjdCBk ZW5hbGlfY29udHJvbGxlciAqZGVuYWxpID0gdG9fZGVuYWxpX2NvbnRyb2xsZXIoY2hpcCk7CiAJ c3RydWN0IG10ZF9lY2Nfc3RhdHMgKmVjY19zdGF0cyA9ICZuYW5kX3RvX210ZChjaGlwKS0+ZWNj X3N0YXRzOwogCXVuc2lnbmVkIGludCBlY2Nfc2l6ZSA9IGNoaXAtPmVjYy5zaXplOwogCXVuc2ln bmVkIGludCBiaXRmbGlwcyA9IDA7CkBAIC01MzIsNyArNTQ5LDcgQEAgc3RhdGljIGludCBkZW5h bGlfc3dfZWNjX2ZpeHVwKHN0cnVjdCBuYW5kX2NoaXAgKmNoaXAsCiAJcmV0dXJuIG1heF9iaXRm bGlwczsKIH0KIAotc3RhdGljIHZvaWQgZGVuYWxpX3NldHVwX2RtYTY0KHN0cnVjdCBkZW5hbGlf bmFuZF9pbmZvICpkZW5hbGksCitzdGF0aWMgdm9pZCBkZW5hbGlfc2V0dXBfZG1hNjQoc3RydWN0 IGRlbmFsaV9jb250cm9sbGVyICpkZW5hbGksCiAJCQkgICAgICAgZG1hX2FkZHJfdCBkbWFfYWRk ciwgaW50IHBhZ2UsIGJvb2wgd3JpdGUpCiB7CiAJdWludDMyX3QgbW9kZTsKQEAgLTU1Nyw3ICs1 NzQsNyBAQCBzdGF0aWMgdm9pZCBkZW5hbGlfc2V0dXBfZG1hNjQoc3RydWN0IGRlbmFsaV9uYW5k X2luZm8gKmRlbmFsaSwKIAlkZW5hbGktPmhvc3Rfd3JpdGUoZGVuYWxpLCBtb2RlLCB1cHBlcl8z Ml9iaXRzKGRtYV9hZGRyKSk7CiB9CiAKLXN0YXRpYyB2b2lkIGRlbmFsaV9zZXR1cF9kbWEzMihz dHJ1Y3QgZGVuYWxpX25hbmRfaW5mbyAqZGVuYWxpLAorc3RhdGljIHZvaWQgZGVuYWxpX3NldHVw X2RtYTMyKHN0cnVjdCBkZW5hbGlfY29udHJvbGxlciAqZGVuYWxpLAogCQkJICAgICAgIGRtYV9h ZGRyX3QgZG1hX2FkZHIsIGludCBwYWdlLCBib29sIHdyaXRlKQogewogCXVpbnQzMl90IG1vZGU7 CkBAIC01ODEsNyArNTk4LDcgQEAgc3RhdGljIHZvaWQgZGVuYWxpX3NldHVwX2RtYTMyKHN0cnVj dCBkZW5hbGlfbmFuZF9pbmZvICpkZW5hbGksCiAJZGVuYWxpLT5ob3N0X3dyaXRlKGRlbmFsaSwg bW9kZSB8IDB4MTQwMDAsIDB4MjQwMCk7CiB9CiAKLXN0YXRpYyBpbnQgZGVuYWxpX3Bpb19yZWFk KHN0cnVjdCBkZW5hbGlfbmFuZF9pbmZvICpkZW5hbGksIHUzMiAqYnVmLAorc3RhdGljIGludCBk ZW5hbGlfcGlvX3JlYWQoc3RydWN0IGRlbmFsaV9jb250cm9sbGVyICpkZW5hbGksIHUzMiAqYnVm LAogCQkJICAgc2l6ZV90IHNpemUsIGludCBwYWdlKQogewogCXUzMiBhZGRyID0gREVOQUxJX01B UDAxIHwgREVOQUxJX0JBTksoZGVuYWxpKSB8IHBhZ2U7CkBAIC02MDgsNyArNjI1LDcgQEAgc3Rh dGljIGludCBkZW5hbGlfcGlvX3JlYWQoc3RydWN0IGRlbmFsaV9uYW5kX2luZm8gKmRlbmFsaSwg dTMyICpidWYsCiAJcmV0dXJuIGlycV9zdGF0dXMgJiBlY2NfZXJyX21hc2sgPyAtRUJBRE1TRyA6 IDA7CiB9CiAKLXN0YXRpYyBpbnQgZGVuYWxpX3Bpb193cml0ZShzdHJ1Y3QgZGVuYWxpX25hbmRf aW5mbyAqZGVuYWxpLCBjb25zdCB1MzIgKmJ1ZiwKK3N0YXRpYyBpbnQgZGVuYWxpX3Bpb193cml0 ZShzdHJ1Y3QgZGVuYWxpX2NvbnRyb2xsZXIgKmRlbmFsaSwgY29uc3QgdTMyICpidWYsCiAJCQkg ICAgc2l6ZV90IHNpemUsIGludCBwYWdlKQogewogCXUzMiBhZGRyID0gREVOQUxJX01BUDAxIHwg REVOQUxJX0JBTksoZGVuYWxpKSB8IHBhZ2U7CkBAIC02MjgsNyArNjQ1LDcgQEAgc3RhdGljIGlu dCBkZW5hbGlfcGlvX3dyaXRlKHN0cnVjdCBkZW5hbGlfbmFuZF9pbmZvICpkZW5hbGksIGNvbnN0 IHUzMiAqYnVmLAogCXJldHVybiAwOwogfQogCi1zdGF0aWMgaW50IGRlbmFsaV9waW9feGZlcihz dHJ1Y3QgZGVuYWxpX25hbmRfaW5mbyAqZGVuYWxpLCB2b2lkICpidWYsCitzdGF0aWMgaW50IGRl bmFsaV9waW9feGZlcihzdHJ1Y3QgZGVuYWxpX2NvbnRyb2xsZXIgKmRlbmFsaSwgdm9pZCAqYnVm LAogCQkJICAgc2l6ZV90IHNpemUsIGludCBwYWdlLCBib29sIHdyaXRlKQogewogCWlmICh3cml0 ZSkKQEAgLTYzNyw3ICs2NTQsNyBAQCBzdGF0aWMgaW50IGRlbmFsaV9waW9feGZlcihzdHJ1Y3Qg ZGVuYWxpX25hbmRfaW5mbyAqZGVuYWxpLCB2b2lkICpidWYsCiAJCXJldHVybiBkZW5hbGlfcGlv X3JlYWQoZGVuYWxpLCBidWYsIHNpemUsIHBhZ2UpOwogfQogCi1zdGF0aWMgaW50IGRlbmFsaV9k bWFfeGZlcihzdHJ1Y3QgZGVuYWxpX25hbmRfaW5mbyAqZGVuYWxpLCB2b2lkICpidWYsCitzdGF0 aWMgaW50IGRlbmFsaV9kbWFfeGZlcihzdHJ1Y3QgZGVuYWxpX2NvbnRyb2xsZXIgKmRlbmFsaSwg dm9pZCAqYnVmLAogCQkJICAgc2l6ZV90IHNpemUsIGludCBwYWdlLCBib29sIHdyaXRlKQogewog CWRtYV9hZGRyX3QgZG1hX2FkZHI7CkBAIC02OTcsNyArNzE0LDcgQEAgc3RhdGljIGludCBkZW5h bGlfZG1hX3hmZXIoc3RydWN0IGRlbmFsaV9uYW5kX2luZm8gKmRlbmFsaSwgdm9pZCAqYnVmLAog c3RhdGljIGludCBkZW5hbGlfcGFnZV94ZmVyKHN0cnVjdCBuYW5kX2NoaXAgKmNoaXAsIHZvaWQg KmJ1Ziwgc2l6ZV90IHNpemUsCiAJCQkgICAgaW50IHBhZ2UsIGJvb2wgd3JpdGUpCiB7Ci0Jc3Ry dWN0IGRlbmFsaV9uYW5kX2luZm8gKmRlbmFsaSA9IHRvX2RlbmFsaShjaGlwKTsKKwlzdHJ1Y3Qg ZGVuYWxpX2NvbnRyb2xsZXIgKmRlbmFsaSA9IHRvX2RlbmFsaV9jb250cm9sbGVyKGNoaXApOwog CiAJZGVuYWxpX3NlbGVjdF90YXJnZXQoY2hpcCwgY2hpcC0+Y3VyX2NzKTsKIApAQCAtNzEwLDgg KzcyNyw4IEBAIHN0YXRpYyBpbnQgZGVuYWxpX3BhZ2VfeGZlcihzdHJ1Y3QgbmFuZF9jaGlwICpj aGlwLCB2b2lkICpidWYsIHNpemVfdCBzaXplLAogc3RhdGljIGludCBkZW5hbGlfcmVhZF9wYWdl KHN0cnVjdCBuYW5kX2NoaXAgKmNoaXAsIHVpbnQ4X3QgKmJ1ZiwKIAkJCSAgICBpbnQgb29iX3Jl cXVpcmVkLCBpbnQgcGFnZSkKIHsKKwlzdHJ1Y3QgZGVuYWxpX2NvbnRyb2xsZXIgKmRlbmFsaSA9 IHRvX2RlbmFsaV9jb250cm9sbGVyKGNoaXApOwogCXN0cnVjdCBtdGRfaW5mbyAqbXRkID0gbmFu ZF90b19tdGQoY2hpcCk7Ci0Jc3RydWN0IGRlbmFsaV9uYW5kX2luZm8gKmRlbmFsaSA9IG10ZF90 b19kZW5hbGkobXRkKTsKIAl1bnNpZ25lZCBsb25nIHVuY29yX2VjY19mbGFncyA9IDA7CiAJaW50 IHN0YXQgPSAwOwogCWludCByZXQ7CkBAIC03NTEsNyArNzY4LDggQEAgc3RhdGljIGludCBkZW5h bGlfd3JpdGVfcGFnZShzdHJ1Y3QgbmFuZF9jaGlwICpjaGlwLCBjb25zdCB1aW50OF90ICpidWYs CiBzdGF0aWMgaW50IGRlbmFsaV9zZXR1cF9kYXRhX2ludGVyZmFjZShzdHJ1Y3QgbmFuZF9jaGlw ICpjaGlwLCBpbnQgY2hpcG5yLAogCQkJCSAgICAgICBjb25zdCBzdHJ1Y3QgbmFuZF9kYXRhX2lu dGVyZmFjZSAqY29uZikKIHsKLQlzdHJ1Y3QgZGVuYWxpX25hbmRfaW5mbyAqZGVuYWxpID0gbXRk X3RvX2RlbmFsaShuYW5kX3RvX210ZChjaGlwKSk7CisJc3RydWN0IGRlbmFsaV9jb250cm9sbGVy ICpkZW5hbGkgPSB0b19kZW5hbGlfY29udHJvbGxlcihjaGlwKTsKKwlzdHJ1Y3QgZGVuYWxpX2No aXBfc2VsICpzZWw7CiAJY29uc3Qgc3RydWN0IG5hbmRfc2RyX3RpbWluZ3MgKnRpbWluZ3M7CiAJ dW5zaWduZWQgbG9uZyB0X3gsIG11bHRfeDsKIAlpbnQgYWNjX2Nsa3MsIHJlXzJfd2UsIHJlXzJf cmUsIHdlXzJfcmUsIGFkZHJfMl9kYXRhOwpAQCAtNzgwLDYgKzc5OCw4IEBAIHN0YXRpYyBpbnQg ZGVuYWxpX3NldHVwX2RhdGFfaW50ZXJmYWNlKHN0cnVjdCBuYW5kX2NoaXAgKmNoaXAsIGludCBj aGlwbnIsCiAJaWYgKGNoaXBuciA9PSBOQU5EX0RBVEFfSUZBQ0VfQ0hFQ0tfT05MWSkKIAkJcmV0 dXJuIDA7CiAKKwlzZWwgPSAmdG9fZGVuYWxpX2NoaXAoY2hpcCktPnNlbHNbY2hpcG5yXTsKKwog CS8qIHRSRUEgLT4gQUNDX0NMS1MgKi8KIAlhY2NfY2xrcyA9IERJVl9ST1VORF9VUCh0aW1pbmdz LT50UkVBX21heCwgdF94KTsKIAlhY2NfY2xrcyA9IG1pbl90KGludCwgYWNjX2Nsa3MsIEFDQ19D TEtTX19WQUxVRSk7CkBAIC03ODcsNyArODA3LDcgQEAgc3RhdGljIGludCBkZW5hbGlfc2V0dXBf ZGF0YV9pbnRlcmZhY2Uoc3RydWN0IG5hbmRfY2hpcCAqY2hpcCwgaW50IGNoaXBuciwKIAl0bXAg PSBpb3JlYWQzMihkZW5hbGktPnJlZyArIEFDQ19DTEtTKTsKIAl0bXAgJj0gfkFDQ19DTEtTX19W QUxVRTsKIAl0bXAgfD0gRklFTERfUFJFUChBQ0NfQ0xLU19fVkFMVUUsIGFjY19jbGtzKTsKLQlp b3dyaXRlMzIodG1wLCBkZW5hbGktPnJlZyArIEFDQ19DTEtTKTsKKwlzZWwtPmFjY19jbGtzID0g dG1wOwogCiAJLyogdFJXSCAtPiBSRV8yX1dFICovCiAJcmVfMl93ZSA9IERJVl9ST1VORF9VUCh0 aW1pbmdzLT50UkhXX21pbiwgdF94KTsKQEAgLTc5Niw3ICs4MTYsNyBAQCBzdGF0aWMgaW50IGRl bmFsaV9zZXR1cF9kYXRhX2ludGVyZmFjZShzdHJ1Y3QgbmFuZF9jaGlwICpjaGlwLCBpbnQgY2hp cG5yLAogCXRtcCA9IGlvcmVhZDMyKGRlbmFsaS0+cmVnICsgUkVfMl9XRSk7CiAJdG1wICY9IH5S RV8yX1dFX19WQUxVRTsKIAl0bXAgfD0gRklFTERfUFJFUChSRV8yX1dFX19WQUxVRSwgcmVfMl93 ZSk7Ci0JaW93cml0ZTMyKHRtcCwgZGVuYWxpLT5yZWcgKyBSRV8yX1dFKTsKKwlzZWwtPnJlXzJf d2UgPSB0bXA7CiAKIAkvKiB0UkhaIC0+IFJFXzJfUkUgKi8KIAlyZV8yX3JlID0gRElWX1JPVU5E X1VQKHRpbWluZ3MtPnRSSFpfbWF4LCB0X3gpOwpAQCAtODA1LDcgKzgyNSw3IEBAIHN0YXRpYyBp bnQgZGVuYWxpX3NldHVwX2RhdGFfaW50ZXJmYWNlKHN0cnVjdCBuYW5kX2NoaXAgKmNoaXAsIGlu dCBjaGlwbnIsCiAJdG1wID0gaW9yZWFkMzIoZGVuYWxpLT5yZWcgKyBSRV8yX1JFKTsKIAl0bXAg Jj0gflJFXzJfUkVfX1ZBTFVFOwogCXRtcCB8PSBGSUVMRF9QUkVQKFJFXzJfUkVfX1ZBTFVFLCBy ZV8yX3JlKTsKLQlpb3dyaXRlMzIodG1wLCBkZW5hbGktPnJlZyArIFJFXzJfUkUpOworCXNlbC0+ cmVfMl9yZSA9IHRtcDsKIAogCS8qCiAJICogdENDUywgdFdIUiAtPiBXRV8yX1JFCkBAIC04MTks NyArODM5LDcgQEAgc3RhdGljIGludCBkZW5hbGlfc2V0dXBfZGF0YV9pbnRlcmZhY2Uoc3RydWN0 IG5hbmRfY2hpcCAqY2hpcCwgaW50IGNoaXBuciwKIAl0bXAgPSBpb3JlYWQzMihkZW5hbGktPnJl ZyArIFRXSFIyX0FORF9XRV8yX1JFKTsKIAl0bXAgJj0gflRXSFIyX0FORF9XRV8yX1JFX19XRV8y X1JFOwogCXRtcCB8PSBGSUVMRF9QUkVQKFRXSFIyX0FORF9XRV8yX1JFX19XRV8yX1JFLCB3ZV8y X3JlKTsKLQlpb3dyaXRlMzIodG1wLCBkZW5hbGktPnJlZyArIFRXSFIyX0FORF9XRV8yX1JFKTsK KwlzZWwtPmh3aHIyX2FuZF93ZV8yX3JlID0gdG1wOwogCiAJLyogdEFETCAtPiBBRERSXzJfREFU QSAqLwogCkBAIC04MzQsNyArODU0LDcgQEAgc3RhdGljIGludCBkZW5hbGlfc2V0dXBfZGF0YV9p bnRlcmZhY2Uoc3RydWN0IG5hbmRfY2hpcCAqY2hpcCwgaW50IGNoaXBuciwKIAl0bXAgPSBpb3Jl YWQzMihkZW5hbGktPnJlZyArIFRDV0FXX0FORF9BRERSXzJfREFUQSk7CiAJdG1wICY9IH5UQ1dB V19BTkRfQUREUl8yX0RBVEFfX0FERFJfMl9EQVRBOwogCXRtcCB8PSBGSUVMRF9QUkVQKFRDV0FX X0FORF9BRERSXzJfREFUQV9fQUREUl8yX0RBVEEsIGFkZHJfMl9kYXRhKTsKLQlpb3dyaXRlMzIo dG1wLCBkZW5hbGktPnJlZyArIFRDV0FXX0FORF9BRERSXzJfREFUQSk7CisJc2VsLT50Y3dhd19h bmRfYWRkcl8yX2RhdGEgPSB0bXA7CiAKIAkvKiB0UkVILCB0V0ggLT4gUkRXUl9FTl9ISV9DTlQg Ki8KIAlyZHdyX2VuX2hpID0gRElWX1JPVU5EX1VQKG1heCh0aW1pbmdzLT50UkVIX21pbiwgdGlt aW5ncy0+dFdIX21pbiksCkBAIC04NDQsNyArODY0LDcgQEAgc3RhdGljIGludCBkZW5hbGlfc2V0 dXBfZGF0YV9pbnRlcmZhY2Uoc3RydWN0IG5hbmRfY2hpcCAqY2hpcCwgaW50IGNoaXBuciwKIAl0 bXAgPSBpb3JlYWQzMihkZW5hbGktPnJlZyArIFJEV1JfRU5fSElfQ05UKTsKIAl0bXAgJj0gflJE V1JfRU5fSElfQ05UX19WQUxVRTsKIAl0bXAgfD0gRklFTERfUFJFUChSRFdSX0VOX0hJX0NOVF9f VkFMVUUsIHJkd3JfZW5faGkpOwotCWlvd3JpdGUzMih0bXAsIGRlbmFsaS0+cmVnICsgUkRXUl9F Tl9ISV9DTlQpOworCXNlbC0+cmR3cl9lbl9oaV9jbnQgPSB0bXA7CiAKIAkvKiB0UlAsIHRXUCAt PiBSRFdSX0VOX0xPX0NOVCAqLwogCXJkd3JfZW5fbG8gPSBESVZfUk9VTkRfVVAobWF4KHRpbWlu Z3MtPnRSUF9taW4sIHRpbWluZ3MtPnRXUF9taW4pLCB0X3gpOwpAQCAtODU3LDcgKzg3Nyw3IEBA IHN0YXRpYyBpbnQgZGVuYWxpX3NldHVwX2RhdGFfaW50ZXJmYWNlKHN0cnVjdCBuYW5kX2NoaXAg KmNoaXAsIGludCBjaGlwbnIsCiAJdG1wID0gaW9yZWFkMzIoZGVuYWxpLT5yZWcgKyBSRFdSX0VO X0xPX0NOVCk7CiAJdG1wICY9IH5SRFdSX0VOX0xPX0NOVF9fVkFMVUU7CiAJdG1wIHw9IEZJRUxE X1BSRVAoUkRXUl9FTl9MT19DTlRfX1ZBTFVFLCByZHdyX2VuX2xvKTsKLQlpb3dyaXRlMzIodG1w LCBkZW5hbGktPnJlZyArIFJEV1JfRU5fTE9fQ05UKTsKKwlzZWwtPnJkd3JfZW5fbG9fY250ID0g dG1wOwogCiAJLyogdENTLCB0Q0VBIC0+IENTX1NFVFVQX0NOVCAqLwogCWNzX3NldHVwID0gbWF4 MygoaW50KURJVl9ST1VORF9VUCh0aW1pbmdzLT50Q1NfbWluLCB0X3gpIC0gcmR3cl9lbl9sbywK QEAgLTg2OCw0MCArODg4LDExIEBAIHN0YXRpYyBpbnQgZGVuYWxpX3NldHVwX2RhdGFfaW50ZXJm YWNlKHN0cnVjdCBuYW5kX2NoaXAgKmNoaXAsIGludCBjaGlwbnIsCiAJdG1wID0gaW9yZWFkMzIo ZGVuYWxpLT5yZWcgKyBDU19TRVRVUF9DTlQpOwogCXRtcCAmPSB+Q1NfU0VUVVBfQ05UX19WQUxV RTsKIAl0bXAgfD0gRklFTERfUFJFUChDU19TRVRVUF9DTlRfX1ZBTFVFLCBjc19zZXR1cCk7Ci0J aW93cml0ZTMyKHRtcCwgZGVuYWxpLT5yZWcgKyBDU19TRVRVUF9DTlQpOworCXNlbC0+Y3Nfc2V0 dXBfY250ID0gdG1wOwogCiAJcmV0dXJuIDA7CiB9CiAKLXN0YXRpYyB2b2lkIGRlbmFsaV9od19p bml0KHN0cnVjdCBkZW5hbGlfbmFuZF9pbmZvICpkZW5hbGkpCi17Ci0JLyoKLQkgKiBUaGUgUkVW SVNJT04gcmVnaXN0ZXIgbWF5IG5vdCBiZSByZWxpYWJsZS4gIFBsYXRmb3JtcyBhcmUgYWxsb3dl ZCB0bwotCSAqIG92ZXJyaWRlIGl0LgotCSAqLwotCWlmICghZGVuYWxpLT5yZXZpc2lvbikKLQkJ ZGVuYWxpLT5yZXZpc2lvbiA9IHN3YWIxNihpb3JlYWQzMihkZW5hbGktPnJlZyArIFJFVklTSU9O KSk7Ci0KLQkvKgotCSAqIFNldCBob3cgbWFueSBieXRlcyBzaG91bGQgYmUgc2tpcHBlZCBiZWZv cmUgd3JpdGluZyBkYXRhIGluIE9PQi4KLQkgKiBJZiBhIG5vbi16ZXJvIHZhbHVlIGhhcyBhbHJl YWR5IGJlZW4gc2V0IChieSBmaXJtd2FyZSBvciBzb21ldGhpbmcpLAotCSAqIGp1c3QgdXNlIGl0 LiAgT3RoZXJ3aXNlLCBzZXQgdGhlIGRyaXZlciBkZWZhdWx0LgotCSAqLwotCWRlbmFsaS0+b29i X3NraXBfYnl0ZXMgPSBpb3JlYWQzMihkZW5hbGktPnJlZyArIFNQQVJFX0FSRUFfU0tJUF9CWVRF Uyk7Ci0JaWYgKCFkZW5hbGktPm9vYl9za2lwX2J5dGVzKSB7Ci0JCWRlbmFsaS0+b29iX3NraXBf Ynl0ZXMgPSBERU5BTElfREVGQVVMVF9PT0JfU0tJUF9CWVRFUzsKLQkJaW93cml0ZTMyKGRlbmFs aS0+b29iX3NraXBfYnl0ZXMsCi0JCQkgIGRlbmFsaS0+cmVnICsgU1BBUkVfQVJFQV9TS0lQX0JZ VEVTKTsKLQl9Ci0KLQlkZW5hbGlfZGV0ZWN0X21heF9iYW5rcyhkZW5hbGkpOwotCWlvd3JpdGUz MigwLCBkZW5hbGktPnJlZyArIFRSQU5TRkVSX1NQQVJFX1JFRyk7Ci0JaW93cml0ZTMyKDB4MEYs IGRlbmFsaS0+cmVnICsgUkJfUElOX0VOQUJMRUQpOwotCWlvd3JpdGUzMihDSElQX0VOX0RPTlRf Q0FSRV9fRkxBRywgZGVuYWxpLT5yZWcgKyBDSElQX0VOQUJMRV9ET05UX0NBUkUpOwotCWlvd3Jp dGUzMihFQ0NfRU5BQkxFX19GTEFHLCBkZW5hbGktPnJlZyArIEVDQ19FTkFCTEUpOwotCWlvd3Jp dGUzMigweGZmZmYsIGRlbmFsaS0+cmVnICsgU1BBUkVfQVJFQV9NQVJLRVIpOwotfQotCiBpbnQg ZGVuYWxpX2NhbGNfZWNjX2J5dGVzKGludCBzdGVwX3NpemUsIGludCBzdHJlbmd0aCkKIHsKIAkv KiBCQ0ggY29kZS4gIERlbmFsaSByZXF1aXJlcyBlY2MuYnl0ZXMgdG8gYmUgbXVsdGlwbGUgb2Yg MiAqLwpAQCAtOTEyLDEwICs5MDMsMTAgQEAgRVhQT1JUX1NZTUJPTChkZW5hbGlfY2FsY19lY2Nf Ynl0ZXMpOwogc3RhdGljIGludCBkZW5hbGlfb29ibGF5b3V0X2VjYyhzdHJ1Y3QgbXRkX2luZm8g Km10ZCwgaW50IHNlY3Rpb24sCiAJCQkJc3RydWN0IG10ZF9vb2JfcmVnaW9uICpvb2JyZWdpb24p CiB7Ci0Jc3RydWN0IGRlbmFsaV9uYW5kX2luZm8gKmRlbmFsaSA9IG10ZF90b19kZW5hbGkobXRk KTsKIAlzdHJ1Y3QgbmFuZF9jaGlwICpjaGlwID0gbXRkX3RvX25hbmQobXRkKTsKKwlzdHJ1Y3Qg ZGVuYWxpX2NvbnRyb2xsZXIgKmRlbmFsaSA9IHRvX2RlbmFsaV9jb250cm9sbGVyKGNoaXApOwog Ci0JaWYgKHNlY3Rpb24pCisJaWYgKHNlY3Rpb24gPiAwKQogCQlyZXR1cm4gLUVSQU5HRTsKIAog CW9vYnJlZ2lvbi0+b2Zmc2V0ID0gZGVuYWxpLT5vb2Jfc2tpcF9ieXRlczsKQEAgLTkyNywxMCAr OTE4LDEwIEBAIHN0YXRpYyBpbnQgZGVuYWxpX29vYmxheW91dF9lY2Moc3RydWN0IG10ZF9pbmZv ICptdGQsIGludCBzZWN0aW9uLAogc3RhdGljIGludCBkZW5hbGlfb29ibGF5b3V0X2ZyZWUoc3Ry dWN0IG10ZF9pbmZvICptdGQsIGludCBzZWN0aW9uLAogCQkJCSBzdHJ1Y3QgbXRkX29vYl9yZWdp b24gKm9vYnJlZ2lvbikKIHsKLQlzdHJ1Y3QgZGVuYWxpX25hbmRfaW5mbyAqZGVuYWxpID0gbXRk X3RvX2RlbmFsaShtdGQpOwogCXN0cnVjdCBuYW5kX2NoaXAgKmNoaXAgPSBtdGRfdG9fbmFuZCht dGQpOworCXN0cnVjdCBkZW5hbGlfY29udHJvbGxlciAqZGVuYWxpID0gdG9fZGVuYWxpX2NvbnRy b2xsZXIoY2hpcCk7CiAKLQlpZiAoc2VjdGlvbikKKwlpZiAoc2VjdGlvbiA+IDApCiAJCXJldHVy biAtRVJBTkdFOwogCiAJb29icmVnaW9uLT5vZmZzZXQgPSBjaGlwLT5lY2MudG90YWwgKyBkZW5h bGktPm9vYl9za2lwX2J5dGVzOwpAQCAtOTQ2LDcgKzkzNyw3IEBAIHN0YXRpYyBjb25zdCBzdHJ1 Y3QgbXRkX29vYmxheW91dF9vcHMgZGVuYWxpX29vYmxheW91dF9vcHMgPSB7CiAKIHN0YXRpYyBp bnQgZGVuYWxpX211bHRpZGV2X2ZpeHVwKHN0cnVjdCBuYW5kX2NoaXAgKmNoaXApCiB7Ci0Jc3Ry dWN0IGRlbmFsaV9uYW5kX2luZm8gKmRlbmFsaSA9IHRvX2RlbmFsaShjaGlwKTsKKwlzdHJ1Y3Qg ZGVuYWxpX2NvbnRyb2xsZXIgKmRlbmFsaSA9IHRvX2RlbmFsaV9jb250cm9sbGVyKGNoaXApOwog CXN0cnVjdCBtdGRfaW5mbyAqbXRkID0gbmFuZF90b19tdGQoY2hpcCk7CiAKIAkvKgpAQCAtOTk3 LDM4ICs5ODgsMTAgQEAgc3RhdGljIGludCBkZW5hbGlfbXVsdGlkZXZfZml4dXAoc3RydWN0IG5h bmRfY2hpcCAqY2hpcCkKIAogc3RhdGljIGludCBkZW5hbGlfYXR0YWNoX2NoaXAoc3RydWN0IG5h bmRfY2hpcCAqY2hpcCkKIHsKKwlzdHJ1Y3QgZGVuYWxpX2NvbnRyb2xsZXIgKmRlbmFsaSA9IHRv X2RlbmFsaV9jb250cm9sbGVyKGNoaXApOwogCXN0cnVjdCBtdGRfaW5mbyAqbXRkID0gbmFuZF90 b19tdGQoY2hpcCk7Ci0Jc3RydWN0IGRlbmFsaV9uYW5kX2luZm8gKmRlbmFsaSA9IG10ZF90b19k ZW5hbGkobXRkKTsKIAlpbnQgcmV0OwogCi0JaWYgKGlvcmVhZDMyKGRlbmFsaS0+cmVnICsgRkVB VFVSRVMpICYgRkVBVFVSRVNfX0RNQSkKLQkJZGVuYWxpLT5kbWFfYXZhaWwgPSB0cnVlOwotCi0J aWYgKGRlbmFsaS0+ZG1hX2F2YWlsKSB7Ci0JCWludCBkbWFfYml0ID0gZGVuYWxpLT5jYXBzICYg REVOQUxJX0NBUF9ETUFfNjRCSVQgPyA2NCA6IDMyOwotCi0JCXJldCA9IGRtYV9zZXRfbWFzayhk ZW5hbGktPmRldiwgRE1BX0JJVF9NQVNLKGRtYV9iaXQpKTsKLQkJaWYgKHJldCkgewotCQkJZGV2 X2luZm8oZGVuYWxpLT5kZXYsCi0JCQkJICJGYWlsZWQgdG8gc2V0IERNQSBtYXNrLiBEaXNhYmxp bmcgRE1BLlxuIik7Ci0JCQlkZW5hbGktPmRtYV9hdmFpbCA9IGZhbHNlOwotCQl9Ci0JfQotCi0J aWYgKGRlbmFsaS0+ZG1hX2F2YWlsKSB7Ci0JCWNoaXAtPm9wdGlvbnMgfD0gTkFORF9VU0VfQk9V TkNFX0JVRkZFUjsKLQkJY2hpcC0+YnVmX2FsaWduID0gMTY7Ci0JCWlmIChkZW5hbGktPmNhcHMg JiBERU5BTElfQ0FQX0RNQV82NEJJVCkKLQkJCWRlbmFsaS0+c2V0dXBfZG1hID0gZGVuYWxpX3Nl dHVwX2RtYTY0OwotCQllbHNlCi0JCQlkZW5hbGktPnNldHVwX2RtYSA9IGRlbmFsaV9zZXR1cF9k bWEzMjsKLQl9Ci0KLQljaGlwLT5iYnRfb3B0aW9ucyB8PSBOQU5EX0JCVF9VU0VfRkxBU0g7Ci0J Y2hpcC0+YmJ0X29wdGlvbnMgfD0gTkFORF9CQlRfTk9fT09COwotCWNoaXAtPmVjYy5tb2RlID0g TkFORF9FQ0NfSFdfU1lORFJPTUU7Ci0JY2hpcC0+b3B0aW9ucyB8PSBOQU5EX05PX1NVQlBBR0Vf V1JJVEU7Ci0KIAlyZXQgPSBuYW5kX2VjY19jaG9vc2VfY29uZihjaGlwLCBkZW5hbGktPmVjY19j YXBzLAogCQkJCSAgIG10ZC0+b29ic2l6ZSAtIGRlbmFsaS0+b29iX3NraXBfYnl0ZXMpOwogCWlm IChyZXQpIHsKQEAgLTEwNDAsMzMgKzEwMDMsNiBAQCBzdGF0aWMgaW50IGRlbmFsaV9hdHRhY2hf Y2hpcChzdHJ1Y3QgbmFuZF9jaGlwICpjaGlwKQogCQkiY2hvc2VuIEVDQyBzZXR0aW5nczogc3Rl cD0lZCwgc3RyZW5ndGg9JWQsIGJ5dGVzPSVkXG4iLAogCQljaGlwLT5lY2Muc2l6ZSwgY2hpcC0+ ZWNjLnN0cmVuZ3RoLCBjaGlwLT5lY2MuYnl0ZXMpOwogCi0JaW93cml0ZTMyKEZJRUxEX1BSRVAo RUNDX0NPUlJFQ1RJT05fX0VSQVNFX1RIUkVTSE9MRCwgMSkgfAotCQkgIEZJRUxEX1BSRVAoRUND X0NPUlJFQ1RJT05fX1ZBTFVFLCBjaGlwLT5lY2Muc3RyZW5ndGgpLAotCQkgIGRlbmFsaS0+cmVn ICsgRUNDX0NPUlJFQ1RJT04pOwotCWlvd3JpdGUzMihtdGQtPmVyYXNlc2l6ZSAvIG10ZC0+d3Jp dGVzaXplLAotCQkgIGRlbmFsaS0+cmVnICsgUEFHRVNfUEVSX0JMT0NLKTsKLQlpb3dyaXRlMzIo Y2hpcC0+b3B0aW9ucyAmIE5BTkRfQlVTV0lEVEhfMTYgPyAxIDogMCwKLQkJICBkZW5hbGktPnJl ZyArIERFVklDRV9XSURUSCk7Ci0JaW93cml0ZTMyKGNoaXAtPm9wdGlvbnMgJiBOQU5EX1JPV19B RERSXzMgPyAwIDogVFdPX1JPV19BRERSX0NZQ0xFU19fRkxBRywKLQkJICBkZW5hbGktPnJlZyAr IFRXT19ST1dfQUREUl9DWUNMRVMpOwotCWlvd3JpdGUzMihtdGQtPndyaXRlc2l6ZSwgZGVuYWxp LT5yZWcgKyBERVZJQ0VfTUFJTl9BUkVBX1NJWkUpOwotCWlvd3JpdGUzMihtdGQtPm9vYnNpemUs IGRlbmFsaS0+cmVnICsgREVWSUNFX1NQQVJFX0FSRUFfU0laRSk7Ci0KLQlpb3dyaXRlMzIoY2hp cC0+ZWNjLnNpemUsIGRlbmFsaS0+cmVnICsgQ0ZHX0RBVEFfQkxPQ0tfU0laRSk7Ci0JaW93cml0 ZTMyKGNoaXAtPmVjYy5zaXplLCBkZW5hbGktPnJlZyArIENGR19MQVNUX0RBVEFfQkxPQ0tfU0la RSk7Ci0JLyogY2hpcC0+ZWNjLnN0ZXBzIGlzIHNldCBieSBuYW5kX3NjYW5fdGFpbCgpOyBub3Qg YXZhaWxhYmxlIGhlcmUgKi8KLQlpb3dyaXRlMzIobXRkLT53cml0ZXNpemUgLyBjaGlwLT5lY2Mu c2l6ZSwKLQkJICBkZW5hbGktPnJlZyArIENGR19OVU1fREFUQV9CTE9DS1MpOwotCi0JbXRkX3Nl dF9vb2JsYXlvdXQobXRkLCAmZGVuYWxpX29vYmxheW91dF9vcHMpOwotCi0JY2hpcC0+ZWNjLnJl YWRfcGFnZSA9IGRlbmFsaV9yZWFkX3BhZ2U7Ci0JY2hpcC0+ZWNjLnJlYWRfcGFnZV9yYXcgPSBk ZW5hbGlfcmVhZF9wYWdlX3JhdzsKLQljaGlwLT5lY2Mud3JpdGVfcGFnZSA9IGRlbmFsaV93cml0 ZV9wYWdlOwotCWNoaXAtPmVjYy53cml0ZV9wYWdlX3JhdyA9IGRlbmFsaV93cml0ZV9wYWdlX3Jh dzsKLQljaGlwLT5lY2MucmVhZF9vb2IgPSBkZW5hbGlfcmVhZF9vb2I7Ci0JY2hpcC0+ZWNjLndy aXRlX29vYiA9IGRlbmFsaV93cml0ZV9vb2I7Ci0KIAlyZXQgPSBkZW5hbGlfbXVsdGlkZXZfZml4 dXAoY2hpcCk7CiAJaWYgKHJldCkKIAkJcmV0dXJuIHJldDsKQEAgLTEwNzQsNyArMTAxMCw3IEBA IHN0YXRpYyBpbnQgZGVuYWxpX2F0dGFjaF9jaGlwKHN0cnVjdCBuYW5kX2NoaXAgKmNoaXApCiAJ cmV0dXJuIDA7CiB9CiAKLXN0YXRpYyB2b2lkIGRlbmFsaV9leGVjX2luOChzdHJ1Y3QgZGVuYWxp X25hbmRfaW5mbyAqZGVuYWxpLCB1MzIgdHlwZSwKK3N0YXRpYyB2b2lkIGRlbmFsaV9leGVjX2lu OChzdHJ1Y3QgZGVuYWxpX2NvbnRyb2xsZXIgKmRlbmFsaSwgdTMyIHR5cGUsCiAJCQkgICAgdTgg KmJ1ZiwgdW5zaWduZWQgaW50IGxlbikKIHsKIAlpbnQgaTsKQEAgLTEwODMsNyArMTAxOSw3IEBA IHN0YXRpYyB2b2lkIGRlbmFsaV9leGVjX2luOChzdHJ1Y3QgZGVuYWxpX25hbmRfaW5mbyAqZGVu YWxpLCB1MzIgdHlwZSwKIAkJYnVmW2ldID0gZGVuYWxpLT5ob3N0X3JlYWQoZGVuYWxpLCB0eXBl IHwgREVOQUxJX0JBTksoZGVuYWxpKSk7CiB9CiAKLXN0YXRpYyB2b2lkIGRlbmFsaV9leGVjX2lu MTYoc3RydWN0IGRlbmFsaV9uYW5kX2luZm8gKmRlbmFsaSwgdTMyIHR5cGUsCitzdGF0aWMgdm9p ZCBkZW5hbGlfZXhlY19pbjE2KHN0cnVjdCBkZW5hbGlfY29udHJvbGxlciAqZGVuYWxpLCB1MzIg dHlwZSwKIAkJCSAgICAgdTggKmJ1ZiwgdW5zaWduZWQgaW50IGxlbikKIHsKIAl1MzIgZGF0YTsK QEAgLTEwOTcsNyArMTAzMyw3IEBAIHN0YXRpYyB2b2lkIGRlbmFsaV9leGVjX2luMTYoc3RydWN0 IGRlbmFsaV9uYW5kX2luZm8gKmRlbmFsaSwgdTMyIHR5cGUsCiAJfQogfQogCi1zdGF0aWMgdm9p ZCBkZW5hbGlfZXhlY19pbihzdHJ1Y3QgZGVuYWxpX25hbmRfaW5mbyAqZGVuYWxpLCB1MzIgdHlw ZSwKK3N0YXRpYyB2b2lkIGRlbmFsaV9leGVjX2luKHN0cnVjdCBkZW5hbGlfY29udHJvbGxlciAq ZGVuYWxpLCB1MzIgdHlwZSwKIAkJCSAgIHU4ICpidWYsIHVuc2lnbmVkIGludCBsZW4sIGJvb2wg d2lkdGgxNikKIHsKIAlpZiAod2lkdGgxNikKQEAgLTExMDYsNyArMTA0Miw3IEBAIHN0YXRpYyB2 b2lkIGRlbmFsaV9leGVjX2luKHN0cnVjdCBkZW5hbGlfbmFuZF9pbmZvICpkZW5hbGksIHUzMiB0 eXBlLAogCQlkZW5hbGlfZXhlY19pbjgoZGVuYWxpLCB0eXBlLCBidWYsIGxlbik7CiB9CiAKLXN0 YXRpYyB2b2lkIGRlbmFsaV9leGVjX291dDgoc3RydWN0IGRlbmFsaV9uYW5kX2luZm8gKmRlbmFs aSwgdTMyIHR5cGUsCitzdGF0aWMgdm9pZCBkZW5hbGlfZXhlY19vdXQ4KHN0cnVjdCBkZW5hbGlf Y29udHJvbGxlciAqZGVuYWxpLCB1MzIgdHlwZSwKIAkJCSAgICAgY29uc3QgdTggKmJ1ZiwgdW5z aWduZWQgaW50IGxlbikKIHsKIAlpbnQgaTsKQEAgLTExMTUsNyArMTA1MSw3IEBAIHN0YXRpYyB2 b2lkIGRlbmFsaV9leGVjX291dDgoc3RydWN0IGRlbmFsaV9uYW5kX2luZm8gKmRlbmFsaSwgdTMy IHR5cGUsCiAJCWRlbmFsaS0+aG9zdF93cml0ZShkZW5hbGksIHR5cGUgfCBERU5BTElfQkFOSyhk ZW5hbGkpLCBidWZbaV0pOwogfQogCi1zdGF0aWMgdm9pZCBkZW5hbGlfZXhlY19vdXQxNihzdHJ1 Y3QgZGVuYWxpX25hbmRfaW5mbyAqZGVuYWxpLCB1MzIgdHlwZSwKK3N0YXRpYyB2b2lkIGRlbmFs aV9leGVjX291dDE2KHN0cnVjdCBkZW5hbGlfY29udHJvbGxlciAqZGVuYWxpLCB1MzIgdHlwZSwK IAkJCSAgICAgIGNvbnN0IHU4ICpidWYsIHVuc2lnbmVkIGludCBsZW4pCiB7CiAJaW50IGk7CkBA IC0xMTI1LDcgKzEwNjEsNyBAQCBzdGF0aWMgdm9pZCBkZW5hbGlfZXhlY19vdXQxNihzdHJ1Y3Qg ZGVuYWxpX25hbmRfaW5mbyAqZGVuYWxpLCB1MzIgdHlwZSwKIAkJCQkgICBidWZbaSArIDFdIDw8 IDE2IHwgYnVmW2ldKTsKIH0KIAotc3RhdGljIHZvaWQgZGVuYWxpX2V4ZWNfb3V0KHN0cnVjdCBk ZW5hbGlfbmFuZF9pbmZvICpkZW5hbGksIHUzMiB0eXBlLAorc3RhdGljIHZvaWQgZGVuYWxpX2V4 ZWNfb3V0KHN0cnVjdCBkZW5hbGlfY29udHJvbGxlciAqZGVuYWxpLCB1MzIgdHlwZSwKIAkJCSAg ICBjb25zdCB1OCAqYnVmLCB1bnNpZ25lZCBpbnQgbGVuLCBib29sIHdpZHRoMTYpCiB7CiAJaWYg KHdpZHRoMTYpCkBAIC0xMTM0LDcgKzEwNzAsNyBAQCBzdGF0aWMgdm9pZCBkZW5hbGlfZXhlY19v dXQoc3RydWN0IGRlbmFsaV9uYW5kX2luZm8gKmRlbmFsaSwgdTMyIHR5cGUsCiAJCWRlbmFsaV9l eGVjX291dDgoZGVuYWxpLCB0eXBlLCBidWYsIGxlbik7CiB9CiAKLXN0YXRpYyBpbnQgZGVuYWxp X2V4ZWNfd2FpdHJkeShzdHJ1Y3QgZGVuYWxpX25hbmRfaW5mbyAqZGVuYWxpKQorc3RhdGljIGlu dCBkZW5hbGlfZXhlY193YWl0cmR5KHN0cnVjdCBkZW5hbGlfY29udHJvbGxlciAqZGVuYWxpKQog ewogCXUzMiBpcnFfc3RhdDsKIApAQCAtMTE1MCw3ICsxMDg2LDcgQEAgc3RhdGljIGludCBkZW5h bGlfZXhlY193YWl0cmR5KHN0cnVjdCBkZW5hbGlfbmFuZF9pbmZvICpkZW5hbGkpCiBzdGF0aWMg aW50IGRlbmFsaV9leGVjX2luc3RyKHN0cnVjdCBuYW5kX2NoaXAgKmNoaXAsCiAJCQkgICAgIGNv bnN0IHN0cnVjdCBuYW5kX29wX2luc3RyICppbnN0cikKIHsKLQlzdHJ1Y3QgZGVuYWxpX25hbmRf aW5mbyAqZGVuYWxpID0gdG9fZGVuYWxpKGNoaXApOworCXN0cnVjdCBkZW5hbGlfY29udHJvbGxl ciAqZGVuYWxpID0gdG9fZGVuYWxpX2NvbnRyb2xsZXIoY2hpcCk7CiAKIAlzd2l0Y2ggKGluc3Ry LT50eXBlKSB7CiAJY2FzZSBOQU5EX09QX0NNRF9JTlNUUjoKQEAgLTEyMDAsNyArMTEzNiw3IEBA IHN0YXRpYyBpbnQgZGVuYWxpX2V4ZWNfb3Aoc3RydWN0IG5hbmRfY2hpcCAqY2hpcCwKIAkgKiBT b21lIGNvbW1hbmRzIGNvbnRhaW4gTkFORF9PUF9XQUlUUkRZX0lOU1RSLgogCSAqIGlycSBtdXN0 IGJlIGNsZWFyZWQgaGVyZSB0byBjYXRjaCB0aGUgUi9CIyBpbnRlcnJ1cHQgdGhlcmUuCiAJICov Ci0JZGVuYWxpX3Jlc2V0X2lycSh0b19kZW5hbGkoY2hpcCkpOworCWRlbmFsaV9yZXNldF9pcnEo dG9fZGVuYWxpX2NvbnRyb2xsZXIoY2hpcCkpOwogCiAJZm9yIChpID0gMDsgaSA8IG9wLT5uaW5z dHJzOyBpKyspIHsKIAkJcmV0ID0gZGVuYWxpX2V4ZWNfaW5zdHIoY2hpcCwgJm9wLT5pbnN0cnNb aV0pOwpAQCAtMTIxNyw1MyArMTE1Myw4MCBAQCBzdGF0aWMgY29uc3Qgc3RydWN0IG5hbmRfY29u dHJvbGxlcl9vcHMgZGVuYWxpX2NvbnRyb2xsZXJfb3BzID0gewogCS5zZXR1cF9kYXRhX2ludGVy ZmFjZSA9IGRlbmFsaV9zZXR1cF9kYXRhX2ludGVyZmFjZSwKIH07CiAKLWludCBkZW5hbGlfaW5p dChzdHJ1Y3QgZGVuYWxpX25hbmRfaW5mbyAqZGVuYWxpKQoraW50IGRlbmFsaV9jaGlwX2luaXQo c3RydWN0IGRlbmFsaV9jb250cm9sbGVyICpkZW5hbGksCisJCSAgICAgc3RydWN0IGRlbmFsaV9j aGlwICpkY2hpcCkKIHsKLQlzdHJ1Y3QgbmFuZF9jaGlwICpjaGlwID0gJmRlbmFsaS0+bmFuZDsK KwlzdHJ1Y3QgbmFuZF9jaGlwICpjaGlwID0gJmRjaGlwLT5jaGlwOwogCXN0cnVjdCBtdGRfaW5m byAqbXRkID0gbmFuZF90b19tdGQoY2hpcCk7Ci0JdTMyIGZlYXR1cmVzID0gaW9yZWFkMzIoZGVu YWxpLT5yZWcgKyBGRUFUVVJFUyk7Ci0JaW50IHJldDsKKwlzdHJ1Y3QgZGVuYWxpX2NoaXAgKmRj aGlwMjsKKwlpbnQgaSwgaiwgcmV0OwogCi0JbXRkLT5kZXYucGFyZW50ID0gZGVuYWxpLT5kZXY7 Ci0JZGVuYWxpX2h3X2luaXQoZGVuYWxpKTsKKwljaGlwLT5jb250cm9sbGVyID0gJmRlbmFsaS0+ Y29udHJvbGxlcjsKIAotCWluaXRfY29tcGxldGlvbigmZGVuYWxpLT5jb21wbGV0ZSk7Ci0Jc3Bp bl9sb2NrX2luaXQoJmRlbmFsaS0+aXJxX2xvY2spOworCS8qIHNhbml0eSBjaGVja3MgZm9yIGJh bmsgbnVtYmVycyAqLworCWZvciAoaSA9IDA7IGkgPCBkY2hpcC0+bnNlbHM7IGkrKykgeworCQl1 bnNpZ25lZCBpbnQgYmFuayA9IGRjaGlwLT5zZWxzW2ldLmJhbms7CiAKLQlkZW5hbGlfY2xlYXJf aXJxX2FsbChkZW5hbGkpOworCQlpZiAoYmFuayA+PSBkZW5hbGktPm5iYW5rcykgeworCQkJZGV2 X2VycihkZW5hbGktPmRldiwgInVuc3VwcG9ydGVkIGJhbmsgJWRcbiIsIGJhbmspOworCQkJcmV0 dXJuIC1FSU5WQUw7CisJCX0KIAotCXJldCA9IGRldm1fcmVxdWVzdF9pcnEoZGVuYWxpLT5kZXYs IGRlbmFsaS0+aXJxLCBkZW5hbGlfaXNyLAotCQkJICAgICAgIElSUUZfU0hBUkVELCBERU5BTElf TkFORF9OQU1FLCBkZW5hbGkpOwotCWlmIChyZXQpIHsKLQkJZGV2X2VycihkZW5hbGktPmRldiwg IlVuYWJsZSB0byByZXF1ZXN0IElSUVxuIik7Ci0JCXJldHVybiByZXQ7Ci0JfQorCQlmb3IgKGog PSAwOyBqIDwgaTsgaisrKSB7CisJCQlpZiAoYmFuayA9PSBkY2hpcC0+c2Vsc1tqXS5iYW5rKSB7 CisJCQkJZGV2X2VycihkZW5hbGktPmRldiwKKwkJCQkJImJhbmsgJWQgaXMgYXNzaWduZWQgdHdp Y2UgaW4gdGhlIHNhbWUgY2hpcFxuIiwKKwkJCQkJYmFuayk7CisJCQkJcmV0dXJuIC1FSU5WQUw7 CisJCQl9CisJCX0KIAotCWRlbmFsaV9lbmFibGVfaXJxKGRlbmFsaSk7CisJCWxpc3RfZm9yX2Vh Y2hfZW50cnkoZGNoaXAyLCAmZGVuYWxpLT5jaGlwcywgbm9kZSkgeworCQkJZm9yIChqID0gMDsg aiA8IGRjaGlwMi0+bnNlbHM7IGorKykgeworCQkJCWlmIChiYW5rID09IGRjaGlwMi0+c2Vsc1tq XS5iYW5rKSB7CisJCQkJCWRldl9lcnIoZGVuYWxpLT5kZXYsCisJCQkJCQkiYmFuayAlZCBpcyBh bHJlYWR5IHVzZWRcbiIsCisJCQkJCQliYW5rKTsKKwkJCQkJcmV0dXJuIC1FSU5WQUw7CisJCQkJ fQorCQkJfQorCQl9CisJfQogCi0JZGVuYWxpLT5hY3RpdmVfYmFuayA9IERFTkFMSV9JTlZBTElE X0JBTks7CisJbXRkLT5kZXYucGFyZW50ID0gZGVuYWxpLT5kZXY7CiAKLQluYW5kX3NldF9mbGFz aF9ub2RlKGNoaXAsIGRlbmFsaS0+ZGV2LT5vZl9ub2RlKTsKLQkvKiBGYWxsYmFjayB0byB0aGUg ZGVmYXVsdCBuYW1lIGlmIERUIGRpZCBub3QgZ2l2ZSAibGFiZWwiIHByb3BlcnR5ICovCi0JaWYg KCFtdGQtPm5hbWUpCisJLyoKKwkgKiBGYWxsYmFjayB0byB0aGUgZGVmYXVsdCBuYW1lIGlmIERU IGRpZCBub3QgZ2l2ZSAibGFiZWwiIHByb3BlcnR5LgorCSAqIFVzZSAibGFiZWwiIHByb3BlcnR5 IGlmIG11bHRpcGxlIGNoaXBzIGFyZSBjb25uZWN0ZWQuCisJICovCisJaWYgKCFtdGQtPm5hbWUg JiYgbGlzdF9lbXB0eSgmZGVuYWxpLT5jaGlwcykpCiAJCW10ZC0+bmFtZSA9ICJkZW5hbGktbmFu ZCI7CiAKLQlpZiAoZmVhdHVyZXMgJiBGRUFUVVJFU19fSU5ERVhfQUREUikgewotCQlkZW5hbGkt Pmhvc3RfcmVhZCA9IGRlbmFsaV9pbmRleGVkX3JlYWQ7Ci0JCWRlbmFsaS0+aG9zdF93cml0ZSA9 IGRlbmFsaV9pbmRleGVkX3dyaXRlOwotCX0gZWxzZSB7Ci0JCWRlbmFsaS0+aG9zdF9yZWFkID0g ZGVuYWxpX2RpcmVjdF9yZWFkOwotCQlkZW5hbGktPmhvc3Rfd3JpdGUgPSBkZW5hbGlfZGlyZWN0 X3dyaXRlOworCWlmIChkZW5hbGktPmRtYV9hdmFpbCkgeworCQljaGlwLT5vcHRpb25zIHw9IE5B TkRfVVNFX0JPVU5DRV9CVUZGRVI7CisJCWNoaXAtPmJ1Zl9hbGlnbiA9IDE2OwogCX0KIAogCS8q IGNsayByYXRlIGluZm8gaXMgbmVlZGVkIGZvciBzZXR1cF9kYXRhX2ludGVyZmFjZSAqLwogCWlm ICghZGVuYWxpLT5jbGtfcmF0ZSB8fCAhZGVuYWxpLT5jbGtfeF9yYXRlKQogCQljaGlwLT5vcHRp b25zIHw9IE5BTkRfS0VFUF9USU1JTkdTOwogCi0JY2hpcC0+bGVnYWN5LmR1bW15X2NvbnRyb2xs ZXIub3BzID0gJmRlbmFsaV9jb250cm9sbGVyX29wczsKLQlyZXQgPSBuYW5kX3NjYW4oY2hpcCwg ZGVuYWxpLT5tYXhfYmFua3MpOworCWNoaXAtPmJidF9vcHRpb25zIHw9IE5BTkRfQkJUX1VTRV9G TEFTSDsKKwljaGlwLT5iYnRfb3B0aW9ucyB8PSBOQU5EX0JCVF9OT19PT0I7CisJY2hpcC0+b3B0 aW9ucyB8PSBOQU5EX05PX1NVQlBBR0VfV1JJVEU7CisJY2hpcC0+ZWNjLm1vZGUgPSBOQU5EX0VD Q19IV19TWU5EUk9NRTsKKwljaGlwLT5lY2MucmVhZF9wYWdlID0gZGVuYWxpX3JlYWRfcGFnZTsK KwljaGlwLT5lY2Mud3JpdGVfcGFnZSA9IGRlbmFsaV93cml0ZV9wYWdlOworCWNoaXAtPmVjYy5y ZWFkX3BhZ2VfcmF3ID0gZGVuYWxpX3JlYWRfcGFnZV9yYXc7CisJY2hpcC0+ZWNjLndyaXRlX3Bh Z2VfcmF3ID0gZGVuYWxpX3dyaXRlX3BhZ2VfcmF3OworCWNoaXAtPmVjYy5yZWFkX29vYiA9IGRl bmFsaV9yZWFkX29vYjsKKwljaGlwLT5lY2Mud3JpdGVfb29iID0gZGVuYWxpX3dyaXRlX29vYjsK KworCW10ZF9zZXRfb29ibGF5b3V0KG10ZCwgJmRlbmFsaV9vb2JsYXlvdXRfb3BzKTsKKworCXJl dCA9IG5hbmRfc2NhbihjaGlwLCBkY2hpcC0+bnNlbHMpOwogCWlmIChyZXQpCi0JCWdvdG8gZGlz YWJsZV9pcnE7CisJCXJldHVybiByZXQ7CiAKIAlyZXQgPSBtdGRfZGV2aWNlX3JlZ2lzdGVyKG10 ZCwgTlVMTCwgMCk7CiAJaWYgKHJldCkgewpAQCAtMTI3MSwyMCArMTIzNCwxMTEgQEAgaW50IGRl bmFsaV9pbml0KHN0cnVjdCBkZW5hbGlfbmFuZF9pbmZvICpkZW5hbGkpCiAJCWdvdG8gY2xlYW51 cF9uYW5kOwogCX0KIAorCWxpc3RfYWRkX3RhaWwoJmRjaGlwLT5ub2RlLCAmZGVuYWxpLT5jaGlw cyk7CisKIAlyZXR1cm4gMDsKIAogY2xlYW51cF9uYW5kOgogCW5hbmRfY2xlYW51cChjaGlwKTsK LWRpc2FibGVfaXJxOgotCWRlbmFsaV9kaXNhYmxlX2lycShkZW5hbGkpOwogCiAJcmV0dXJuIHJl dDsKIH0KK0VYUE9SVF9TWU1CT0xfR1BMKGRlbmFsaV9jaGlwX2luaXQpOworCitpbnQgZGVuYWxp X2luaXQoc3RydWN0IGRlbmFsaV9jb250cm9sbGVyICpkZW5hbGkpCit7CisJdTMyIGZlYXR1cmVz ID0gaW9yZWFkMzIoZGVuYWxpLT5yZWcgKyBGRUFUVVJFUyk7CisJaW50IHJldDsKKworCW5hbmRf Y29udHJvbGxlcl9pbml0KCZkZW5hbGktPmNvbnRyb2xsZXIpOworCWRlbmFsaS0+Y29udHJvbGxl ci5vcHMgPSAmZGVuYWxpX2NvbnRyb2xsZXJfb3BzOworCWluaXRfY29tcGxldGlvbigmZGVuYWxp LT5jb21wbGV0ZSk7CisJc3Bpbl9sb2NrX2luaXQoJmRlbmFsaS0+aXJxX2xvY2spOworCUlOSVRf TElTVF9IRUFEKCZkZW5hbGktPmNoaXBzKTsKKwlkZW5hbGktPmFjdGl2ZV9iYW5rID0gREVOQUxJ X0lOVkFMSURfQkFOSzsKKworCS8qCisJICogVGhlIFJFVklTSU9OIHJlZ2lzdGVyIG1heSBub3Qg YmUgcmVsaWFibGUuIFBsYXRmb3JtcyBhcmUgYWxsb3dlZCB0bworCSAqIG92ZXJyaWRlIGl0Lgor CSAqLworCWlmICghZGVuYWxpLT5yZXZpc2lvbikKKwkJZGVuYWxpLT5yZXZpc2lvbiA9IHN3YWIx Nihpb3JlYWQzMihkZW5hbGktPnJlZyArIFJFVklTSU9OKSk7CisKKwlkZW5hbGktPm5iYW5rcyA9 IDEgPDwgRklFTERfR0VUKEZFQVRVUkVTX19OX0JBTktTLCBmZWF0dXJlcyk7CisKKwkvKiB0aGUg ZW5jb2RpbmcgY2hhbmdlZCBmcm9tIHJldiA1LjAgdG8gNS4xICovCisJaWYgKGRlbmFsaS0+cmV2 aXNpb24gPCAweDA1MDEpCisJCWRlbmFsaS0+bmJhbmtzIDw8PSAxOworCisJaWYgKGZlYXR1cmVz ICYgRkVBVFVSRVNfX0RNQSkKKwkJZGVuYWxpLT5kbWFfYXZhaWwgPSB0cnVlOworCisJaWYgKGRl bmFsaS0+ZG1hX2F2YWlsKSB7CisJCWludCBkbWFfYml0ID0gZGVuYWxpLT5jYXBzICYgREVOQUxJ X0NBUF9ETUFfNjRCSVQgPyA2NCA6IDMyOworCisJCXJldCA9IGRtYV9zZXRfbWFzayhkZW5hbGkt PmRldiwgRE1BX0JJVF9NQVNLKGRtYV9iaXQpKTsKKwkJaWYgKHJldCkgeworCQkJZGV2X2luZm8o ZGVuYWxpLT5kZXYsCisJCQkJICJGYWlsZWQgdG8gc2V0IERNQSBtYXNrLiBEaXNhYmxpbmcgRE1B LlxuIik7CisJCQlkZW5hbGktPmRtYV9hdmFpbCA9IGZhbHNlOworCQl9CisJfQorCisJaWYgKGRl bmFsaS0+ZG1hX2F2YWlsKSB7CisJCWlmIChkZW5hbGktPmNhcHMgJiBERU5BTElfQ0FQX0RNQV82 NEJJVCkKKwkJCWRlbmFsaS0+c2V0dXBfZG1hID0gZGVuYWxpX3NldHVwX2RtYTY0OworCQllbHNl CisJCQlkZW5hbGktPnNldHVwX2RtYSA9IGRlbmFsaV9zZXR1cF9kbWEzMjsKKwl9CisKKwlpZiAo ZmVhdHVyZXMgJiBGRUFUVVJFU19fSU5ERVhfQUREUikgeworCQlkZW5hbGktPmhvc3RfcmVhZCA9 IGRlbmFsaV9pbmRleGVkX3JlYWQ7CisJCWRlbmFsaS0+aG9zdF93cml0ZSA9IGRlbmFsaV9pbmRl eGVkX3dyaXRlOworCX0gZWxzZSB7CisJCWRlbmFsaS0+aG9zdF9yZWFkID0gZGVuYWxpX2RpcmVj dF9yZWFkOworCQlkZW5hbGktPmhvc3Rfd3JpdGUgPSBkZW5hbGlfZGlyZWN0X3dyaXRlOworCX0K KworCS8qCisJICogU2V0IGhvdyBtYW55IGJ5dGVzIHNob3VsZCBiZSBza2lwcGVkIGJlZm9yZSB3 cml0aW5nIGRhdGEgaW4gT09CLgorCSAqIElmIGEgbm9uLXplcm8gdmFsdWUgaGFzIGFscmVhZHkg YmVlbiBzZXQgKGJ5IGZpcm13YXJlIG9yIHNvbWV0aGluZyksCisJICoganVzdCB1c2UgaXQuIE90 aGVyd2lzZSwgc2V0IHRoZSBkcml2ZXIncyBkZWZhdWx0LgorCSAqLworCWRlbmFsaS0+b29iX3Nr aXBfYnl0ZXMgPSBpb3JlYWQzMihkZW5hbGktPnJlZyArIFNQQVJFX0FSRUFfU0tJUF9CWVRFUyk7 CisJaWYgKCFkZW5hbGktPm9vYl9za2lwX2J5dGVzKSB7CisJCWRlbmFsaS0+b29iX3NraXBfYnl0 ZXMgPSBERU5BTElfREVGQVVMVF9PT0JfU0tJUF9CWVRFUzsKKwkJaW93cml0ZTMyKGRlbmFsaS0+ b29iX3NraXBfYnl0ZXMsCisJCQkgIGRlbmFsaS0+cmVnICsgU1BBUkVfQVJFQV9TS0lQX0JZVEVT KTsKKwl9CisKKwlpb3dyaXRlMzIoMCwgZGVuYWxpLT5yZWcgKyBUUkFOU0ZFUl9TUEFSRV9SRUcp OworCWlvd3JpdGUzMihHRU5NQVNLKGRlbmFsaS0+bmJhbmtzIC0gMSwgMCksIGRlbmFsaS0+cmVn ICsgUkJfUElOX0VOQUJMRUQpOworCWlvd3JpdGUzMihDSElQX0VOX0RPTlRfQ0FSRV9fRkxBRywg ZGVuYWxpLT5yZWcgKyBDSElQX0VOQUJMRV9ET05UX0NBUkUpOworCWlvd3JpdGUzMihFQ0NfRU5B QkxFX19GTEFHLCBkZW5hbGktPnJlZyArIEVDQ19FTkFCTEUpOworCWlvd3JpdGUzMigweGZmZmYs IGRlbmFsaS0+cmVnICsgU1BBUkVfQVJFQV9NQVJLRVIpOworCisJZGVuYWxpX2NsZWFyX2lycV9h bGwoZGVuYWxpKTsKKworCXJldCA9IGRldm1fcmVxdWVzdF9pcnEoZGVuYWxpLT5kZXYsIGRlbmFs aS0+aXJxLCBkZW5hbGlfaXNyLAorCQkJICAgICAgIElSUUZfU0hBUkVELCBERU5BTElfTkFORF9O QU1FLCBkZW5hbGkpOworCWlmIChyZXQpIHsKKwkJZGV2X2VycihkZW5hbGktPmRldiwgIlVuYWJs ZSB0byByZXF1ZXN0IElSUVxuIik7CisJCXJldHVybiByZXQ7CisJfQorCisJZGVuYWxpX2VuYWJs ZV9pcnEoZGVuYWxpKTsKKworCXJldHVybiAwOworfQogRVhQT1JUX1NZTUJPTChkZW5hbGlfaW5p dCk7CiAKLXZvaWQgZGVuYWxpX3JlbW92ZShzdHJ1Y3QgZGVuYWxpX25hbmRfaW5mbyAqZGVuYWxp KQordm9pZCBkZW5hbGlfcmVtb3ZlKHN0cnVjdCBkZW5hbGlfY29udHJvbGxlciAqZGVuYWxpKQog ewotCW5hbmRfcmVsZWFzZSgmZGVuYWxpLT5uYW5kKTsKKwlzdHJ1Y3QgZGVuYWxpX2NoaXAgKmRj aGlwOworCisJbGlzdF9mb3JfZWFjaF9lbnRyeShkY2hpcCwgJmRlbmFsaS0+Y2hpcHMsIG5vZGUp CisJCW5hbmRfcmVsZWFzZSgmZGNoaXAtPmNoaXApOworCiAJZGVuYWxpX2Rpc2FibGVfaXJxKGRl bmFsaSk7CiB9CiBFWFBPUlRfU1lNQk9MKGRlbmFsaV9yZW1vdmUpOwpkaWZmIC0tZ2l0IGEvZHJp dmVycy9tdGQvbmFuZC9yYXcvZGVuYWxpLmggYi9kcml2ZXJzL210ZC9uYW5kL3Jhdy9kZW5hbGku aAppbmRleCBkMjYwM2M2Li5lNWNkY2RhIDEwMDY0NAotLS0gYS9kcml2ZXJzL210ZC9uYW5kL3Jh dy9kZW5hbGkuaAorKysgYi9kcml2ZXJzL210ZC9uYW5kL3Jhdy9kZW5hbGkuaApAQCAtOSw2ICs5 LDcgQEAKIAogI2luY2x1ZGUgPGxpbnV4L2JpdHMuaD4KICNpbmNsdWRlIDxsaW51eC9jb21wbGV0 aW9uLmg+CisjaW5jbHVkZSA8bGludXgvbGlzdC5oPgogI2luY2x1ZGUgPGxpbnV4L210ZC9yYXdu YW5kLmg+CiAjaW5jbHVkZSA8bGludXgvc3BpbmxvY2tfdHlwZXMuaD4KICNpbmNsdWRlIDxsaW51 eC90eXBlcy5oPgpAQCAtMjkwLDI5ICsyOTEsOTggQEAKICNkZWZpbmUgICAgIENITkxfQUNUSVZF X19DSEFOTkVMMgkJCUJJVCgyKQogI2RlZmluZSAgICAgQ0hOTF9BQ1RJVkVfX0NIQU5ORUwzCQkJ QklUKDMpCiAKLXN0cnVjdCBkZW5hbGlfbmFuZF9pbmZvIHsKLQlzdHJ1Y3QgbmFuZF9jaGlwIG5h bmQ7Ci0JdW5zaWduZWQgbG9uZyBjbGtfcmF0ZTsJCS8qIGNvcmUgY2xvY2sgcmF0ZSAqLwotCXVu c2lnbmVkIGxvbmcgY2xrX3hfcmF0ZTsJLyogYnVzIGludGVyZmFjZSBjbG9jayByYXRlICovCi0J aW50IGFjdGl2ZV9iYW5rOwkJLyogY3VycmVudGx5IHNlbGVjdGVkIGJhbmsgKi8KKy8qKgorICog c3RydWN0IGRlbmFsaV9jaGlwX3NlbCAtIHBlci1DUyBkYXRhIG9mIERlbmFsaSBOQU5ECisgKgor ICogQGJhbms6ICAgICAgICAgICAgICAgICAgYmFuayBpZCBvZiB0aGUgY29udHJvbGxlciB0aGlz IENTIGlzIGNvbm5lY3RlZCB0bworICogQGh3aHIyX2FuZF93ZV8yX3JlOiAgICAgdmFsdWUgb2Yg dGltaW5nIHJlZ2lzdGVyIEhXSFIyX0FORF9XRV8yX1JFCisgKiBAdGN3YXdfYW5kX2FkZHJfMl9k YXRhOiB2YWx1ZSBvZiB0aW1pbmcgcmVnaXN0ZXIgVENXQVdfQU5EX0FERFJfMl9EQVRBCisgKiBA cmVfMl93ZTogICAgICAgICAgICAgICB2YWx1ZSBvZiB0aW1pbmcgcmVnaXN0ZXIgUkVfMl9XRQor ICogQGFjY19jbGtzOiAgICAgICAgICAgICAgdmFsdWUgb2YgdGltaW5nIHJlZ2lzdGVyIEFDQ19D TEtTCisgKiBAcmR3cl9lbl9sb19jbnQ6ICAgICAgICB2YWx1ZSBvZiB0aW1pbmcgcmVnaXN0ZXIg UkRXUl9FTl9MT19DTlQKKyAqIEByZHdyX2VuX2hpX2NudDogICAgICAgIHZhbHVlIG9mIHRpbWlu ZyByZWdpc3RlciBSRFdSX0VOX0hJX0NOVAorICogQGNzX3NldHVwX2NudDogICAgICAgICAgdmFs dWUgb2YgdGltaW5nIHJlZ2lzdGVyIENTX1NFVFVQX0NOVAorICogQHJlXzJfcmU6ICAgICAgICAg ICAgICAgdmFsdWUgb2YgdGltaW5nIHJlZ2lzdGVyIFJFXzJfUkUKKyAqLworc3RydWN0IGRlbmFs aV9jaGlwX3NlbCB7CisJaW50IGJhbms7CisJdTMyIGh3aHIyX2FuZF93ZV8yX3JlOworCXUzMiB0 Y3dhd19hbmRfYWRkcl8yX2RhdGE7CisJdTMyIHJlXzJfd2U7CisJdTMyIGFjY19jbGtzOworCXUz MiByZHdyX2VuX2xvX2NudDsKKwl1MzIgcmR3cl9lbl9oaV9jbnQ7CisJdTMyIGNzX3NldHVwX2Nu dDsKKwl1MzIgcmVfMl9yZTsKK307CisKKy8qKgorICogc3RydWN0IGRlbmFsaV9jaGlwIC0gcGVy LWNoaXAgZGF0YSBvZiBEZW5hbGkgTkFORAorICoKKyAqIEBjaGlwOiAgYmFzZSBOQU5EIGNoaXAg c3RydWN0dXJlCisgKiBAbm9kZTogIG5vZGUgdG8gYmUgdXNlZCB0byBhc3NvY2lhdGUgdGhpcyBj aGlwIHdpdGggdGhlIGNvbnRyb2xsZXIKKyAqIEBuc2VsczogdGhlIG51bWJlciBvZiBDUyBsaW5l cyBvZiB0aGlzIGNoaXAKKyAqIEBzZWxzOiAgdGhlIGFycmF5IG9mIHBlci1jcyBkYXRhCisgKi8K K3N0cnVjdCBkZW5hbGlfY2hpcCB7CisJc3RydWN0IG5hbmRfY2hpcCBjaGlwOworCXN0cnVjdCBs aXN0X2hlYWQgbm9kZTsKKwl1bnNpZ25lZCBpbnQgbnNlbHM7CisJc3RydWN0IGRlbmFsaV9jaGlw X3NlbCBzZWxzWzBdOworfTsKKworLyoqCisgKiBzdHJ1Y3QgZGVuYWxpX2NvbnRyb2xsZXIgLSBE ZW5hbGkgTkFORCBjb250cm9sbGVyIGRhdGEKKyAqCisgKiBAY29udHJvbGxlcjogICAgIGJhc2Ug TkFORCBjb250cm9sbGVyIHN0cnVjdHVyZQorICogQGRldjogICAgICAgICAgICBkZXZpY2UKKyAq IEBjaGlwczogICAgICAgICAgdGhlIGxpc3Qgb2YgY2hpcHMgYXR0YWNoZWQgdG8gdGhpcyBjb250 cm9sbGVyCisgKiBAY2xrX3JhdGU6ICAgICAgIGZyZXF1ZW5jeSBvZiBjb3JlIGNsb2NrCisgKiBA Y2xrX3hfcmF0ZTogICAgIGZyZXF1ZW5jeSBvZiBidXMgaW50ZXJmYWNlIGNsb2NrCisgKiBAcmVn OiAgICAgICAgICAgIGJhc2Ugb2YgUmVnaXN0ZXIgSW50ZXJmYWNlCisgKiBAaG9zdDogICAgICAg ICAgIGJhc2Ugb2YgSG9zdCBEYXRhL0NvbW1hbmQgaW50ZXJmYWNlCisgKiBAY29tcGxldGU6ICAg ICAgIGNvbXBsZXRpb24gdXNlZCB0byB3YWl0IGZvciBpbnRlcnJ1cHRzCisgKiBAaXJxOiAgICAg ICAgICAgIGludGVycnVwdCBudW1iZXIKKyAqIEBpcnFfbWFzazogICAgICAgaW50ZXJydXB0IGJp dHMgdGhlIGNvbnRyb2xsZXIgaXMgd2FpdGluZyBmb3IKKyAqIEBpcnFfc3RhdHVzOiAgICAgaW50 ZXJydXB0IGJpdHMgb2YgZXZlbnRzIHRoYXQgaGF2ZSBoYXBwZW5lZAorICogQGlycV9sb2NrOiAg ICAgICBsb2NrIHRvIHByb3RlY3QgQGlycV9tYXNrIGFuZCBAaXJxX3N0YXR1cworICogQGRtYV9h dmFpbDogICAgICBzZXQgaWYgRE1BIGVuZ2luZSBpcyBhdmFpbGFibGUKKyAqIEBkZXZzX3Blcl9j czogICAgbnVtYmVyIG9mIGRldmljZXMgY29ubmVjdGVkIGluIHBhcmFsbGVsCisgKiBAb29iX3Nr aXBfYnl0ZXM6IG51bWJlciBvZiBieXRlcyBpbiBPT0Igc2tpcHBlZCBieSB0aGUgRUNDIGVuZ2lu ZQorICogQGFjdGl2ZV9iYW5rOiAgICBhY3RpdmUgYmFuayBpZAorICogQG5iYW5rczogICAgICAg ICB0aGUgbnVtYmVyIG9mIGJhbmtzIHN1cHBvcnRlZCBieSB0aGlzIGNvbnRyb2xsZXIKKyAqIEBy ZXZpc2lvbjogICAgICAgSVAgcmV2aXNpb24KKyAqIEBjYXBzOiAgICAgICAgICAgY29udHJvbGxl ciBjYXBhYmlsaXRpZXMgdGhhdCBjYW5ub3QgYmUgZGV0ZWN0ZWQgcnVuLXRpbWUKKyAqIEBlY2Nf Y2FwczogICAgICAgRUNDIGVuZ2luZSBjYXBhYmlsaXRpZXMKKyAqIEBob3N0X3JlYWQ6ICAgICAg Y2FsbGJhY2sgZm9yIHJlYWQgYWNjZXNzIG9mIEhvc3QgRGF0YS9Db21tYW5kIEludGVyZmFjZQor ICogQGhvc3Rfd3JpdGU6ICAgICBjYWxsYmFjayBmb3Igd3JpdGUgYWNjZXNzIG9mIEhvc3QgRGF0 YS9Db21tYW5kIEludGVyZmFjZQorICogQHNldHVwX2RtYTogICAgICBjYWxsYmFjayBmb3Igc2V0 dXAgb2YgdGhlIERhdGEgRE1BCisgKi8KK3N0cnVjdCBkZW5hbGlfY29udHJvbGxlciB7CisJc3Ry dWN0IG5hbmRfY29udHJvbGxlciBjb250cm9sbGVyOwogCXN0cnVjdCBkZXZpY2UgKmRldjsKLQl2 b2lkIF9faW9tZW0gKnJlZzsJCS8qIFJlZ2lzdGVyIEludGVyZmFjZSAqLwotCXZvaWQgX19pb21l bSAqaG9zdDsJCS8qIEhvc3QgRGF0YS9Db21tYW5kIEludGVyZmFjZSAqLworCXN0cnVjdCBsaXN0 X2hlYWQgY2hpcHM7CisJdW5zaWduZWQgbG9uZyBjbGtfcmF0ZTsKKwl1bnNpZ25lZCBsb25nIGNs a194X3JhdGU7CisJdm9pZCBfX2lvbWVtICpyZWc7CisJdm9pZCBfX2lvbWVtICpob3N0OwogCXN0 cnVjdCBjb21wbGV0aW9uIGNvbXBsZXRlOwotCXNwaW5sb2NrX3QgaXJxX2xvY2s7CQkvKiBwcm90 ZWN0IGlycV9tYXNrIGFuZCBpcnFfc3RhdHVzICovCi0JdTMyIGlycV9tYXNrOwkJCS8qIGludGVy cnVwdHMgd2UgYXJlIHdhaXRpbmcgZm9yICovCi0JdTMyIGlycV9zdGF0dXM7CQkJLyogaW50ZXJy dXB0cyB0aGF0IGhhdmUgaGFwcGVuZWQgKi8KIAlpbnQgaXJxOwotCWJvb2wgZG1hX2F2YWlsOwkJ CS8qIGNhbiBzdXBwb3J0IERNQT8gKi8KLQlpbnQgZGV2c19wZXJfY3M7CQkvKiBkZXZpY2VzIGNv bm5lY3RlZCBpbiBwYXJhbGxlbCAqLwotCWludCBvb2Jfc2tpcF9ieXRlczsJCS8qIG51bWJlciBv ZiBieXRlcyByZXNlcnZlZCBmb3IgQkJNICovCi0JaW50IG1heF9iYW5rczsKLQl1bnNpZ25lZCBp bnQgcmV2aXNpb247CQkvKiBJUCByZXZpc2lvbiAqLwotCXVuc2lnbmVkIGludCBjYXBzOwkJLyog SVAgY2FwYWJpbGl0eSAob3IgcXVpcmspICovCisJdTMyIGlycV9tYXNrOworCXUzMiBpcnFfc3Rh dHVzOworCXNwaW5sb2NrX3QgaXJxX2xvY2s7CisJYm9vbCBkbWFfYXZhaWw7CisJaW50IGRldnNf cGVyX2NzOworCWludCBvb2Jfc2tpcF9ieXRlczsKKwlpbnQgYWN0aXZlX2Jhbms7CisJaW50IG5i YW5rczsKKwl1bnNpZ25lZCBpbnQgcmV2aXNpb247CisJdW5zaWduZWQgaW50IGNhcHM7CiAJY29u c3Qgc3RydWN0IG5hbmRfZWNjX2NhcHMgKmVjY19jYXBzOwotCXUzMiAoKmhvc3RfcmVhZCkoc3Ry dWN0IGRlbmFsaV9uYW5kX2luZm8gKmRlbmFsaSwgdTMyIGFkZHIpOwotCXZvaWQgKCpob3N0X3dy aXRlKShzdHJ1Y3QgZGVuYWxpX25hbmRfaW5mbyAqZGVuYWxpLCB1MzIgYWRkciwgdTMyIGRhdGEp OwotCXZvaWQgKCpzZXR1cF9kbWEpKHN0cnVjdCBkZW5hbGlfbmFuZF9pbmZvICpkZW5hbGksIGRt YV9hZGRyX3QgZG1hX2FkZHIsCisJdTMyICgqaG9zdF9yZWFkKShzdHJ1Y3QgZGVuYWxpX2NvbnRy b2xsZXIgKmRlbmFsaSwgdTMyIGFkZHIpOworCXZvaWQgKCpob3N0X3dyaXRlKShzdHJ1Y3QgZGVu YWxpX2NvbnRyb2xsZXIgKmRlbmFsaSwgdTMyIGFkZHIsCisJCQkgICB1MzIgZGF0YSk7CisJdm9p ZCAoKnNldHVwX2RtYSkoc3RydWN0IGRlbmFsaV9jb250cm9sbGVyICpkZW5hbGksIGRtYV9hZGRy X3QgZG1hX2FkZHIsCiAJCQkgIGludCBwYWdlLCBib29sIHdyaXRlKTsKIH07CiAKQEAgLTMyMCw3 ICszOTAsOSBAQCBzdHJ1Y3QgZGVuYWxpX25hbmRfaW5mbyB7CiAjZGVmaW5lIERFTkFMSV9DQVBf RE1BXzY0QklUCQkJQklUKDEpCiAKIGludCBkZW5hbGlfY2FsY19lY2NfYnl0ZXMoaW50IHN0ZXBf c2l6ZSwgaW50IHN0cmVuZ3RoKTsKLWludCBkZW5hbGlfaW5pdChzdHJ1Y3QgZGVuYWxpX25hbmRf aW5mbyAqZGVuYWxpKTsKLXZvaWQgZGVuYWxpX3JlbW92ZShzdHJ1Y3QgZGVuYWxpX25hbmRfaW5m byAqZGVuYWxpKTsKK2ludCBkZW5hbGlfY2hpcF9pbml0KHN0cnVjdCBkZW5hbGlfY29udHJvbGxl ciAqZGVuYWxpLAorCQkgICAgIHN0cnVjdCBkZW5hbGlfY2hpcCAqZGNoaXApOworaW50IGRlbmFs aV9pbml0KHN0cnVjdCBkZW5hbGlfY29udHJvbGxlciAqZGVuYWxpKTsKK3ZvaWQgZGVuYWxpX3Jl bW92ZShzdHJ1Y3QgZGVuYWxpX2NvbnRyb2xsZXIgKmRlbmFsaSk7CiAKICNlbmRpZiAvKiBfX0RF TkFMSV9IX18gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbXRkL25hbmQvcmF3L2RlbmFsaV9kdC5j IGIvZHJpdmVycy9tdGQvbmFuZC9yYXcvZGVuYWxpX2R0LmMKaW5kZXggMGI1YWUyNC4uNWUxNDgz NiAxMDA2NDQKLS0tIGEvZHJpdmVycy9tdGQvbmFuZC9yYXcvZGVuYWxpX2R0LmMKKysrIGIvZHJp dmVycy9tdGQvbmFuZC9yYXcvZGVuYWxpX2R0LmMKQEAgLTE4LDcgKzE4LDcgQEAKICNpbmNsdWRl ICJkZW5hbGkuaCIKIAogc3RydWN0IGRlbmFsaV9kdCB7Ci0Jc3RydWN0IGRlbmFsaV9uYW5kX2lu Zm8JZGVuYWxpOworCXN0cnVjdCBkZW5hbGlfY29udHJvbGxlciBjb250cm9sbGVyOwogCXN0cnVj dCBjbGsgKmNsazsJLyogY29yZSBjbG9jayAqLwogCXN0cnVjdCBjbGsgKmNsa194OwkvKiBidXMg aW50ZXJmYWNlIGNsb2NrICovCiAJc3RydWN0IGNsayAqY2xrX2VjYzsJLyogRUNDIGNpcmN1aXQg Y2xvY2sgKi8KQEAgLTcxLDE5ICs3MSw5MiBAQCBzdGF0aWMgY29uc3Qgc3RydWN0IG9mX2Rldmlj ZV9pZCBkZW5hbGlfbmFuZF9kdF9pZHNbXSA9IHsKIH07CiBNT0RVTEVfREVWSUNFX1RBQkxFKG9m LCBkZW5hbGlfbmFuZF9kdF9pZHMpOwogCitzdGF0aWMgaW50IGRlbmFsaV9kdF9jaGlwX2luaXQo c3RydWN0IGRlbmFsaV9jb250cm9sbGVyICpkZW5hbGksCisJCQkgICAgICAgc3RydWN0IGRldmlj ZV9ub2RlICpjaGlwX25wKQoreworCXN0cnVjdCBkZW5hbGlfY2hpcCAqZGNoaXA7CisJdTMyIGJh bms7CisJaW50IG5zZWxzLCBpLCByZXQ7CisKKwluc2VscyA9IG9mX3Byb3BlcnR5X2NvdW50X3Uz Ml9lbGVtcyhjaGlwX25wLCAicmVnIik7CisJaWYgKG5zZWxzIDwgMCkKKwkJcmV0dXJuIG5zZWxz OworCisJZGNoaXAgPSBkZXZtX2t6YWxsb2MoZGVuYWxpLT5kZXYsIHN0cnVjdF9zaXplKGRjaGlw LCBzZWxzLCBuc2VscyksCisJCQkgICAgIEdGUF9LRVJORUwpOworCWlmICghZGNoaXApCisJCXJl dHVybiAtRU5PTUVNOworCisJZGNoaXAtPm5zZWxzID0gbnNlbHM7CisKKwlmb3IgKGkgPSAwOyBp IDwgbnNlbHM7IGkrKykgeworCQlyZXQgPSBvZl9wcm9wZXJ0eV9yZWFkX3UzMl9pbmRleChjaGlw X25wLCAicmVnIiwgaSwgJmJhbmspOworCQlpZiAocmV0KQorCQkJcmV0dXJuIHJldDsKKworCQlk Y2hpcC0+c2Vsc1tpXS5iYW5rID0gYmFuazsKKworCQluYW5kX3NldF9mbGFzaF9ub2RlKCZkY2hp cC0+Y2hpcCwgY2hpcF9ucCk7CisJfQorCisJcmV0dXJuIGRlbmFsaV9jaGlwX2luaXQoZGVuYWxp LCBkY2hpcCk7Cit9CisKKy8qIEJhY2t3YXJkIGNvbXBhdGliaWxpdHkgZm9yIG9sZCBwbGF0Zm9y bXMgKi8KK3N0YXRpYyBpbnQgZGVuYWxpX2R0X2xlZ2FjeV9jaGlwX2luaXQoc3RydWN0IGRlbmFs aV9jb250cm9sbGVyICpkZW5hbGkpCit7CisJc3RydWN0IGRlbmFsaV9jaGlwICpkY2hpcDsKKwlp bnQgbnNlbHMsIGk7CisKKwluc2VscyA9IGRlbmFsaS0+bmJhbmtzOworCisJZGNoaXAgPSBkZXZt X2t6YWxsb2MoZGVuYWxpLT5kZXYsIHN0cnVjdF9zaXplKGRjaGlwLCBzZWxzLCBuc2VscyksCisJ CQkgICAgIEdGUF9LRVJORUwpOworCWlmICghZGNoaXApCisJCXJldHVybiAtRU5PTUVNOworCisJ ZGNoaXAtPm5zZWxzID0gbnNlbHM7CisKKwlmb3IgKGkgPSAwOyBpIDwgbnNlbHM7IGkrKykKKwkJ ZGNoaXAtPnNlbHNbaV0uYmFuayA9IGk7CisKKwluYW5kX3NldF9mbGFzaF9ub2RlKCZkY2hpcC0+ Y2hpcCwgZGVuYWxpLT5kZXYtPm9mX25vZGUpOworCisJcmV0dXJuIGRlbmFsaV9jaGlwX2luaXQo ZGVuYWxpLCBkY2hpcCk7Cit9CisKKy8qCisgKiBDaGVjayB0aGUgRFQgYmluZGluZy4KKyAqIFRo ZSBuZXcgYmluZGluZyBleHBlY3RzIGNoaXAgc3Vibm9kZXMgaW4gdGhlIGNvbnRyb2xsZXIgbm9k ZS4KKyAqIFNvLCAjYWRkcmVzcy1jZWxscyA9IDwxPjsgI3NpemUtY2VsbHMgPSA8MD47IGFyZSBy ZXF1aXJlZC4KKyAqIENoZWNrIHRoZSAjc2l6ZS1jZWxscyB0byBkaXN0aW5ndWlzaCB0aGUgYmlu ZGluZy4KKyAqLworc3RhdGljIGJvb2wgZGVuYWxpX2R0X2lzX2xlZ2FjeV9iaW5kaW5nKHN0cnVj dCBkZXZpY2Vfbm9kZSAqbnApCit7CisJdTMyIGNlbGxzOworCWludCByZXQ7CisKKwlyZXQgPSBv Zl9wcm9wZXJ0eV9yZWFkX3UzMihucCwgIiNzaXplLWNlbGxzIiwgJmNlbGxzKTsKKwlpZiAocmV0 KQorCQlyZXR1cm4gdHJ1ZTsKKworCXJldHVybiBjZWxscyAhPSAwOworfQorCiBzdGF0aWMgaW50 IGRlbmFsaV9kdF9wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQogewogCXN0cnVj dCBkZXZpY2UgKmRldiA9ICZwZGV2LT5kZXY7CiAJc3RydWN0IHJlc291cmNlICpyZXM7CiAJc3Ry dWN0IGRlbmFsaV9kdCAqZHQ7CiAJY29uc3Qgc3RydWN0IGRlbmFsaV9kdF9kYXRhICpkYXRhOwot CXN0cnVjdCBkZW5hbGlfbmFuZF9pbmZvICpkZW5hbGk7CisJc3RydWN0IGRlbmFsaV9jb250cm9s bGVyICpkZW5hbGk7CisJc3RydWN0IGRldmljZV9ub2RlICpucDsKIAlpbnQgcmV0OwogCiAJZHQg PSBkZXZtX2t6YWxsb2MoZGV2LCBzaXplb2YoKmR0KSwgR0ZQX0tFUk5FTCk7CiAJaWYgKCFkdCkK IAkJcmV0dXJuIC1FTk9NRU07Ci0JZGVuYWxpID0gJmR0LT5kZW5hbGk7CisJZGVuYWxpID0gJmR0 LT5jb250cm9sbGVyOwogCiAJZGF0YSA9IG9mX2RldmljZV9nZXRfbWF0Y2hfZGF0YShkZXYpOwog CWlmIChkYXRhKSB7CkBAIC0xNDAsOSArMjEzLDI2IEBAIHN0YXRpYyBpbnQgZGVuYWxpX2R0X3By b2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCiAJaWYgKHJldCkKIAkJZ290byBvdXRf ZGlzYWJsZV9jbGtfZWNjOwogCisJaWYgKGRlbmFsaV9kdF9pc19sZWdhY3lfYmluZGluZyhkZXYt Pm9mX25vZGUpKSB7CisJCXJldCA9IGRlbmFsaV9kdF9sZWdhY3lfY2hpcF9pbml0KGRlbmFsaSk7 CisJCWlmIChyZXQpCisJCQlnb3RvIG91dF9yZW1vdmVfZGVuYWxpOworCX0gZWxzZSB7CisJCWZv cl9lYWNoX2NoaWxkX29mX25vZGUoZGV2LT5vZl9ub2RlLCBucCkgeworCQkJcmV0ID0gZGVuYWxp X2R0X2NoaXBfaW5pdChkZW5hbGksIG5wKTsKKwkJCWlmIChyZXQpIHsKKwkJCQlvZl9ub2RlX3B1 dChucCk7CisJCQkJZ290byBvdXRfcmVtb3ZlX2RlbmFsaTsKKwkJCX0KKwkJfQorCX0KKwogCXBs YXRmb3JtX3NldF9kcnZkYXRhKHBkZXYsIGR0KTsKKwogCXJldHVybiAwOwogCitvdXRfcmVtb3Zl X2RlbmFsaToKKwlkZW5hbGlfcmVtb3ZlKGRlbmFsaSk7CiBvdXRfZGlzYWJsZV9jbGtfZWNjOgog CWNsa19kaXNhYmxlX3VucHJlcGFyZShkdC0+Y2xrX2VjYyk7CiBvdXRfZGlzYWJsZV9jbGtfeDoK QEAgLTE1Nyw3ICsyNDcsNyBAQCBzdGF0aWMgaW50IGRlbmFsaV9kdF9yZW1vdmUoc3RydWN0IHBs YXRmb3JtX2RldmljZSAqcGRldikKIHsKIAlzdHJ1Y3QgZGVuYWxpX2R0ICpkdCA9IHBsYXRmb3Jt X2dldF9kcnZkYXRhKHBkZXYpOwogCi0JZGVuYWxpX3JlbW92ZSgmZHQtPmRlbmFsaSk7CisJZGVu YWxpX3JlbW92ZSgmZHQtPmNvbnRyb2xsZXIpOwogCWNsa19kaXNhYmxlX3VucHJlcGFyZShkdC0+ Y2xrX2VjYyk7CiAJY2xrX2Rpc2FibGVfdW5wcmVwYXJlKGR0LT5jbGtfeCk7CiAJY2xrX2Rpc2Fi bGVfdW5wcmVwYXJlKGR0LT5jbGspOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tdGQvbmFuZC9yYXcv ZGVuYWxpX3BjaS5jIGIvZHJpdmVycy9tdGQvbmFuZC9yYXcvZGVuYWxpX3BjaS5jCmluZGV4IDAy ZWI1OTkuLmQ2MmFhNTIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbXRkL25hbmQvcmF3L2RlbmFsaV9w Y2kuYworKysgYi9kcml2ZXJzL210ZC9uYW5kL3Jhdy9kZW5hbGlfcGNpLmMKQEAgLTI5LDEwICsy OSwxMSBAQCBOQU5EX0VDQ19DQVBTX1NJTkdMRShkZW5hbGlfcGNpX2VjY19jYXBzLCBkZW5hbGlf Y2FsY19lY2NfYnl0ZXMsIDUxMiwgOCwgMTUpOwogCiBzdGF0aWMgaW50IGRlbmFsaV9wY2lfcHJv YmUoc3RydWN0IHBjaV9kZXYgKmRldiwgY29uc3Qgc3RydWN0IHBjaV9kZXZpY2VfaWQgKmlkKQog ewotCWludCByZXQ7CiAJcmVzb3VyY2Vfc2l6ZV90IGNzcl9iYXNlLCBtZW1fYmFzZTsKIAl1bnNp Z25lZCBsb25nIGNzcl9sZW4sIG1lbV9sZW47Ci0Jc3RydWN0IGRlbmFsaV9uYW5kX2luZm8gKmRl bmFsaTsKKwlzdHJ1Y3QgZGVuYWxpX2NvbnRyb2xsZXIgKmRlbmFsaTsKKwlzdHJ1Y3QgZGVuYWxp X2NoaXAgKmRjaGlwOworCWludCBuc2VscywgcmV0LCBpOwogCiAJZGVuYWxpID0gZGV2bV9remFs bG9jKCZkZXYtPmRldiwgc2l6ZW9mKCpkZW5hbGkpLCBHRlBfS0VSTkVMKTsKIAlpZiAoIWRlbmFs aSkKQEAgLTY0LDcgKzY1LDYgQEAgc3RhdGljIGludCBkZW5hbGlfcGNpX3Byb2JlKHN0cnVjdCBw Y2lfZGV2ICpkZXYsIGNvbnN0IHN0cnVjdCBwY2lfZGV2aWNlX2lkICppZCkKIAlkZW5hbGktPmRl diA9ICZkZXYtPmRldjsKIAlkZW5hbGktPmlycSA9IGRldi0+aXJxOwogCWRlbmFsaS0+ZWNjX2Nh cHMgPSAmZGVuYWxpX3BjaV9lY2NfY2FwczsKLQlkZW5hbGktPm5hbmQuZWNjLm9wdGlvbnMgfD0g TkFORF9FQ0NfTUFYSU1JWkU7CiAJZGVuYWxpLT5jbGtfcmF0ZSA9IDUwMDAwMDAwOwkJLyogNTAg TUh6ICovCiAJZGVuYWxpLT5jbGtfeF9yYXRlID0gMjAwMDAwMDAwOwkJLyogMjAwIE1IeiAqLwog CkBAIC05MSwxMCArOTEsMzIgQEAgc3RhdGljIGludCBkZW5hbGlfcGNpX3Byb2JlKHN0cnVjdCBw Y2lfZGV2ICpkZXYsIGNvbnN0IHN0cnVjdCBwY2lfZGV2aWNlX2lkICppZCkKIAlpZiAocmV0KQog CQlnb3RvIG91dF91bm1hcF9ob3N0OwogCisJbnNlbHMgPSBkZW5hbGktPm5iYW5rczsKKworCWRj aGlwID0gZGV2bV9remFsbG9jKGRlbmFsaS0+ZGV2LCBzdHJ1Y3Rfc2l6ZShkY2hpcCwgc2Vscywg bnNlbHMpLAorCQkJICAgICBHRlBfS0VSTkVMKTsKKwlpZiAoIWRjaGlwKSB7CisJCXJldCA9IC1F Tk9NRU07CisJCWdvdG8gb3V0X3JlbW92ZV9kZW5hbGk7CisJfQorCisJZGNoaXAtPmNoaXAuZWNj Lm9wdGlvbnMgfD0gTkFORF9FQ0NfTUFYSU1JWkU7CisKKwlkY2hpcC0+bnNlbHMgPSBuc2VsczsK KworCWZvciAoaSA9IDA7IGkgPCBuc2VsczsgaSsrKQorCQlkY2hpcC0+c2Vsc1tpXS5iYW5rID0g aTsKKworCXJldCA9IGRlbmFsaV9jaGlwX2luaXQoZGVuYWxpLCBkY2hpcCk7CisJaWYgKHJldCkK KwkJZ290byBvdXRfcmVtb3ZlX2RlbmFsaTsKKwogCXBjaV9zZXRfZHJ2ZGF0YShkZXYsIGRlbmFs aSk7CiAKIAlyZXR1cm4gMDsKIAorb3V0X3JlbW92ZV9kZW5hbGk6CisJZGVuYWxpX3JlbW92ZShk ZW5hbGkpOwogb3V0X3VubWFwX2hvc3Q6CiAJaW91bm1hcChkZW5hbGktPmhvc3QpOwogb3V0X3Vu bWFwX3JlZzoKQEAgLTEwNCw3ICsxMjYsNyBAQCBzdGF0aWMgaW50IGRlbmFsaV9wY2lfcHJvYmUo c3RydWN0IHBjaV9kZXYgKmRldiwgY29uc3Qgc3RydWN0IHBjaV9kZXZpY2VfaWQgKmlkKQogCiBz dGF0aWMgdm9pZCBkZW5hbGlfcGNpX3JlbW92ZShzdHJ1Y3QgcGNpX2RldiAqZGV2KQogewotCXN0 cnVjdCBkZW5hbGlfbmFuZF9pbmZvICpkZW5hbGkgPSBwY2lfZ2V0X2RydmRhdGEoZGV2KTsKKwlz dHJ1Y3QgZGVuYWxpX2NvbnRyb2xsZXIgKmRlbmFsaSA9IHBjaV9nZXRfZHJ2ZGF0YShkZXYpOwog CiAJZGVuYWxpX3JlbW92ZShkZW5hbGkpOwogCWlvdW5tYXAoZGVuYWxpLT5yZWcpOwotLSAKMi43 LjQKCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X18KTGludXggTVREIGRpc2N1c3Npb24gbWFpbGluZyBsaXN0Cmh0dHA6Ly9saXN0cy5pbmZyYWRl YWQub3JnL21haWxtYW4vbGlzdGluZm8vbGludXgtbXRkLwo=