From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 4B4B8C433F5 for ; Tue, 19 Apr 2022 01:28:43 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S240337AbiDSBbV (ORCPT ); Mon, 18 Apr 2022 21:31:21 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:40148 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S240317AbiDSBbU (ORCPT ); Mon, 18 Apr 2022 21:31:20 -0400 Received: from mail-io1-xd31.google.com (mail-io1-xd31.google.com [IPv6:2607:f8b0:4864:20::d31]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 8E3E725294; Mon, 18 Apr 2022 18:28:38 -0700 (PDT) Received: by mail-io1-xd31.google.com with SMTP id e194so11648764iof.11; Mon, 18 Apr 2022 18:28:38 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=Md+qfUiaZJYVHRis0KLvsKhzCYXdod5jz3J0IJoHXZY=; b=HYnFlf9M+npwYUoPm69LAGL5EK49HrfH2rkoVsVMY1LBufds0ELeBSdlUGicUmUhmA +hK1yAfy3AszXcJ6Cdb2rDziwFXTO0h5X2kxUmepa2hPL1AzaVK3J+pPTQbT4GJEcBSN cMkXrOH86bkknv2Pz7LyBxQYH1mwbumdrLEZOnSxKf3Au6pZDGfmLtu4kVomlhywlKz3 kIglr2ed8CgJF7y09ZdupNFSdpDfMU3+TkMKhH4kCJ3p3Bk+2owVqOLW+OM/e5/hAmXP O8tRIrAf1NQesUidQgfmf5H9bJpYYOuRyZiliPb3lNsGTBHjTTGHC7nEGxLaxMi8+t8X JyVw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=Md+qfUiaZJYVHRis0KLvsKhzCYXdod5jz3J0IJoHXZY=; b=Jt9cj3wGUkrNR3NZIzgqiKVq798SXx4oGMl1WUUAXjkONgNfkDqkypm7hMBJs1SRlx xeLXj/R79UGf/+9tR1ZPRu3hJ4LNgG4PZaxAWrjxH6qp/F5uACXcXzDS4/psfWwq+6+n tmPp9it0fdi88KXr4/mjWE1aSpY8/NUx//JUsUEfm6a+ZNZJ00Kvj6ytEZV6Up161tmw khEkJOtOZsJcW3BW5mPgLyUjve5COJmXDdF8BbAVi5ePZk0go58G1SM6OJMaWtEYfq9W mS16qloAiFDlO201hREwySx4lg1wOZTlG2ajp/xoVNjYTGRLDydu5D1/0UzxLQ09iImG ZK4g== X-Gm-Message-State: AOAM533T+7S4nHmQWWdjLn4frUzWQTwKSutDC6V88pWoR1QNl9T73yQg be88Wi/cw5wxqxiotH0PsMQ= X-Google-Smtp-Source: ABdhPJxG4PATS5sMOw/iYcLAG3J7gn1YIRpUb2lKDF1dEw44GupFwRpLcHCuAnWc3n702Kj4EWUL0g== X-Received: by 2002:a6b:5a10:0:b0:653:9007:d163 with SMTP id o16-20020a6b5a10000000b006539007d163mr5832310iob.43.1650331717620; Mon, 18 Apr 2022 18:28:37 -0700 (PDT) Received: from localhost (ec2-13-59-0-164.us-east-2.compute.amazonaws.com. [13.59.0.164]) by smtp.gmail.com with UTF8SMTPSA id i11-20020a056e020d8b00b002c79690d56esm8015513ilj.10.2022.04.18.18.28.33 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Mon, 18 Apr 2022 18:28:37 -0700 (PDT) From: Schspa Shi To: brgl@bgdev.pl, andy.shevchenko@gmail.com, linus.walleij@linaro.org Cc: f.fainelli@gmail.com, fancer.lancer@gmail.com, hoan@os.amperecomputing.com, linux-arm-kernel@lists.infradead.org, linux-gpio@vger.kernel.org, linux-kernel@vger.kernel.org, opendmb@gmail.com, schspa@gmail.com Subject: [PATCH v3] gpio: use raw spinlock for gpio chip shadowed data Date: Tue, 19 Apr 2022 09:28:10 +0800 Message-Id: <20220419012810.88417-1-schspa@gmail.com> X-Mailer: git-send-email 2.24.3 (Apple Git-128) In-Reply-To: References: MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-gpio@vger.kernel.org In case of PREEMPT_RT, there is a raw_spinlock -> spinlock dependency as the lockdep report shows. __irq_set_handler irq_get_desc_buslock __irq_get_desc_lock raw_spin_lock_irqsave(&desc->lock, *flags); // raw spinlock get here __irq_do_set_handler mask_ack_irq dwapb_irq_ack spin_lock_irqsave(&gc->bgpio_lock, flags); // sleep able spinlock irq_put_desc_busunlock Replace with a raw lock to avoid BUGs. This lock is only used to access registers, and It's safe to replace with the raw lock without bad influence. [ 15.090359][ T1] ============================= [ 15.090365][ T1] [ BUG: Invalid wait context ] [ 15.090373][ T1] 5.10.59-rt52-00983-g186a6841c682-dirty #3 Not tainted [ 15.090386][ T1] ----------------------------- [ 15.090392][ T1] swapper/0/1 is trying to lock: [ 15.090402][ T1] 70ff00018507c188 (&gc->bgpio_lock){....}-{3:3}, at: _raw_spin_lock_irqsave+0x1c/0x28 [ 15.090470][ T1] other info that might help us debug this: [ 15.090477][ T1] context-{5:5} [ 15.090485][ T1] 3 locks held by swapper/0/1: [ 15.090497][ T1] #0: c2ff0001816de1a0 (&dev->mutex){....}-{4:4}, at: __device_driver_lock+0x98/0x104 [ 15.090553][ T1] #1: ffff90001485b4b8 (irq_domain_mutex){+.+.}-{4:4}, at: irq_domain_associate+0xbc/0x6d4 [ 15.090606][ T1] #2: 4bff000185d7a8e0 (lock_class){....}-{2:2}, at: _raw_spin_lock_irqsave+0x1c/0x28 [ 15.090654][ T1] stack backtrace: [ 15.090661][ T1] CPU: 4 PID: 1 Comm: swapper/0 Not tainted 5.10.59-rt52-00983-g186a6841c682-dirty #3 [ 15.090682][ T1] Hardware name: Horizon Robotics Journey 5 DVB (DT) [ 15.090692][ T1] Call trace: ...... [ 15.090811][ T1] _raw_spin_lock_irqsave+0x1c/0x28 [ 15.090828][ T1] dwapb_irq_ack+0xb4/0x300 [ 15.090846][ T1] __irq_do_set_handler+0x494/0xb2c [ 15.090864][ T1] __irq_set_handler+0x74/0x114 [ 15.090881][ T1] irq_set_chip_and_handler_name+0x44/0x58 [ 15.090900][ T1] gpiochip_irq_map+0x210/0x644 Signed-off-by: Schspa Shi --- Changelog: v1 -> v2: - Reduce the useless stacktrace. - Split to series of patches v2 -> v3: - Restore to a single patch as Andy and Bartosz's suggest - add cutter ‘--- ‘ line for Change log --- drivers/gpio/gpio-amdpt.c | 10 +++---- drivers/gpio/gpio-brcmstb.c | 12 ++++---- drivers/gpio/gpio-cadence.c | 12 ++++---- drivers/gpio/gpio-dwapb.c | 36 +++++++++++------------ drivers/gpio/gpio-grgpio.c | 30 +++++++++---------- drivers/gpio/gpio-hlwd.c | 18 ++++++------ drivers/gpio/gpio-idt3243x.c | 12 ++++---- drivers/gpio/gpio-ixp4xx.c | 4 +-- drivers/gpio/gpio-loongson1.c | 8 ++--- drivers/gpio/gpio-menz127.c | 8 ++--- drivers/gpio/gpio-mlxbf2.c | 18 ++++++------ drivers/gpio/gpio-mmio.c | 22 +++++++------- drivers/gpio/gpio-sifive.c | 12 ++++---- drivers/gpio/gpio-tb10x.c | 4 +-- drivers/pinctrl/nuvoton/pinctrl-npcm7xx.c | 8 ++--- include/linux/gpio/driver.h | 2 +- 16 files changed, 108 insertions(+), 108 deletions(-) diff --git a/drivers/gpio/gpio-amdpt.c b/drivers/gpio/gpio-amdpt.c index 8cfb353c3abb..07c6d090058d 100644 --- a/drivers/gpio/gpio-amdpt.c +++ b/drivers/gpio/gpio-amdpt.c @@ -36,19 +36,19 @@ static int pt_gpio_request(struct gpio_chip *gc, unsigned offset) dev_dbg(gc->parent, "pt_gpio_request offset=%x\n", offset); - spin_lock_irqsave(&gc->bgpio_lock, flags); + raw_spin_lock_irqsave(&gc->bgpio_lock, flags); using_pins = readl(pt_gpio->reg_base + PT_SYNC_REG); if (using_pins & BIT(offset)) { dev_warn(gc->parent, "PT GPIO pin %x reconfigured\n", offset); - spin_unlock_irqrestore(&gc->bgpio_lock, flags); + raw_spin_unlock_irqrestore(&gc->bgpio_lock, flags); return -EINVAL; } writel(using_pins | BIT(offset), pt_gpio->reg_base + PT_SYNC_REG); - spin_unlock_irqrestore(&gc->bgpio_lock, flags); + raw_spin_unlock_irqrestore(&gc->bgpio_lock, flags); return 0; } @@ -59,13 +59,13 @@ static void pt_gpio_free(struct gpio_chip *gc, unsigned offset) unsigned long flags; u32 using_pins; - spin_lock_irqsave(&gc->bgpio_lock, flags); + raw_spin_lock_irqsave(&gc->bgpio_lock, flags); using_pins = readl(pt_gpio->reg_base + PT_SYNC_REG); using_pins &= ~BIT(offset); writel(using_pins, pt_gpio->reg_base + PT_SYNC_REG); - spin_unlock_irqrestore(&gc->bgpio_lock, flags); + raw_spin_unlock_irqrestore(&gc->bgpio_lock, flags); dev_dbg(gc->parent, "pt_gpio_free offset=%x\n", offset); } diff --git a/drivers/gpio/gpio-brcmstb.c b/drivers/gpio/gpio-brcmstb.c index 74ef89248867..6b7439b44690 100644 --- a/drivers/gpio/gpio-brcmstb.c +++ b/drivers/gpio/gpio-brcmstb.c @@ -92,9 +92,9 @@ brcmstb_gpio_get_active_irqs(struct brcmstb_gpio_bank *bank) unsigned long status; unsigned long flags; - spin_lock_irqsave(&bank->gc.bgpio_lock, flags); + raw_spin_lock_irqsave(&bank->gc.bgpio_lock, flags); status = __brcmstb_gpio_get_active_irqs(bank); - spin_unlock_irqrestore(&bank->gc.bgpio_lock, flags); + raw_spin_unlock_irqrestore(&bank->gc.bgpio_lock, flags); return status; } @@ -114,14 +114,14 @@ static void brcmstb_gpio_set_imask(struct brcmstb_gpio_bank *bank, u32 imask; unsigned long flags; - spin_lock_irqsave(&gc->bgpio_lock, flags); + raw_spin_lock_irqsave(&gc->bgpio_lock, flags); imask = gc->read_reg(priv->reg_base + GIO_MASK(bank->id)); if (enable) imask |= mask; else imask &= ~mask; gc->write_reg(priv->reg_base + GIO_MASK(bank->id), imask); - spin_unlock_irqrestore(&gc->bgpio_lock, flags); + raw_spin_unlock_irqrestore(&gc->bgpio_lock, flags); } static int brcmstb_gpio_to_irq(struct gpio_chip *gc, unsigned offset) @@ -204,7 +204,7 @@ static int brcmstb_gpio_irq_set_type(struct irq_data *d, unsigned int type) return -EINVAL; } - spin_lock_irqsave(&bank->gc.bgpio_lock, flags); + raw_spin_lock_irqsave(&bank->gc.bgpio_lock, flags); iedge_config = bank->gc.read_reg(priv->reg_base + GIO_EC(bank->id)) & ~mask; @@ -220,7 +220,7 @@ static int brcmstb_gpio_irq_set_type(struct irq_data *d, unsigned int type) bank->gc.write_reg(priv->reg_base + GIO_LEVEL(bank->id), ilevel | level); - spin_unlock_irqrestore(&bank->gc.bgpio_lock, flags); + raw_spin_unlock_irqrestore(&bank->gc.bgpio_lock, flags); return 0; } diff --git a/drivers/gpio/gpio-cadence.c b/drivers/gpio/gpio-cadence.c index 562f8f7e7d1f..137aea49ba02 100644 --- a/drivers/gpio/gpio-cadence.c +++ b/drivers/gpio/gpio-cadence.c @@ -41,12 +41,12 @@ static int cdns_gpio_request(struct gpio_chip *chip, unsigned int offset) struct cdns_gpio_chip *cgpio = gpiochip_get_data(chip); unsigned long flags; - spin_lock_irqsave(&chip->bgpio_lock, flags); + raw_spin_lock_irqsave(&chip->bgpio_lock, flags); iowrite32(ioread32(cgpio->regs + CDNS_GPIO_BYPASS_MODE) & ~BIT(offset), cgpio->regs + CDNS_GPIO_BYPASS_MODE); - spin_unlock_irqrestore(&chip->bgpio_lock, flags); + raw_spin_unlock_irqrestore(&chip->bgpio_lock, flags); return 0; } @@ -55,13 +55,13 @@ static void cdns_gpio_free(struct gpio_chip *chip, unsigned int offset) struct cdns_gpio_chip *cgpio = gpiochip_get_data(chip); unsigned long flags; - spin_lock_irqsave(&chip->bgpio_lock, flags); + raw_spin_lock_irqsave(&chip->bgpio_lock, flags); iowrite32(ioread32(cgpio->regs + CDNS_GPIO_BYPASS_MODE) | (BIT(offset) & cgpio->bypass_orig), cgpio->regs + CDNS_GPIO_BYPASS_MODE); - spin_unlock_irqrestore(&chip->bgpio_lock, flags); + raw_spin_unlock_irqrestore(&chip->bgpio_lock, flags); } static void cdns_gpio_irq_mask(struct irq_data *d) @@ -90,7 +90,7 @@ static int cdns_gpio_irq_set_type(struct irq_data *d, unsigned int type) u32 mask = BIT(d->hwirq); int ret = 0; - spin_lock_irqsave(&chip->bgpio_lock, flags); + raw_spin_lock_irqsave(&chip->bgpio_lock, flags); int_value = ioread32(cgpio->regs + CDNS_GPIO_IRQ_VALUE) & ~mask; int_type = ioread32(cgpio->regs + CDNS_GPIO_IRQ_TYPE) & ~mask; @@ -115,7 +115,7 @@ static int cdns_gpio_irq_set_type(struct irq_data *d, unsigned int type) iowrite32(int_type, cgpio->regs + CDNS_GPIO_IRQ_TYPE); err_irq_type: - spin_unlock_irqrestore(&chip->bgpio_lock, flags); + raw_spin_unlock_irqrestore(&chip->bgpio_lock, flags); return ret; } diff --git a/drivers/gpio/gpio-dwapb.c b/drivers/gpio/gpio-dwapb.c index b0f3aca61974..7130195da48d 100644 --- a/drivers/gpio/gpio-dwapb.c +++ b/drivers/gpio/gpio-dwapb.c @@ -243,9 +243,9 @@ static void dwapb_irq_ack(struct irq_data *d) u32 val = BIT(irqd_to_hwirq(d)); unsigned long flags; - spin_lock_irqsave(&gc->bgpio_lock, flags); + raw_spin_lock_irqsave(&gc->bgpio_lock, flags); dwapb_write(gpio, GPIO_PORTA_EOI, val); - spin_unlock_irqrestore(&gc->bgpio_lock, flags); + raw_spin_unlock_irqrestore(&gc->bgpio_lock, flags); } static void dwapb_irq_mask(struct irq_data *d) @@ -255,10 +255,10 @@ static void dwapb_irq_mask(struct irq_data *d) unsigned long flags; u32 val; - spin_lock_irqsave(&gc->bgpio_lock, flags); + raw_spin_lock_irqsave(&gc->bgpio_lock, flags); val = dwapb_read(gpio, GPIO_INTMASK) | BIT(irqd_to_hwirq(d)); dwapb_write(gpio, GPIO_INTMASK, val); - spin_unlock_irqrestore(&gc->bgpio_lock, flags); + raw_spin_unlock_irqrestore(&gc->bgpio_lock, flags); } static void dwapb_irq_unmask(struct irq_data *d) @@ -268,10 +268,10 @@ static void dwapb_irq_unmask(struct irq_data *d) unsigned long flags; u32 val; - spin_lock_irqsave(&gc->bgpio_lock, flags); + raw_spin_lock_irqsave(&gc->bgpio_lock, flags); val = dwapb_read(gpio, GPIO_INTMASK) & ~BIT(irqd_to_hwirq(d)); dwapb_write(gpio, GPIO_INTMASK, val); - spin_unlock_irqrestore(&gc->bgpio_lock, flags); + raw_spin_unlock_irqrestore(&gc->bgpio_lock, flags); } static void dwapb_irq_enable(struct irq_data *d) @@ -281,11 +281,11 @@ static void dwapb_irq_enable(struct irq_data *d) unsigned long flags; u32 val; - spin_lock_irqsave(&gc->bgpio_lock, flags); + raw_spin_lock_irqsave(&gc->bgpio_lock, flags); val = dwapb_read(gpio, GPIO_INTEN); val |= BIT(irqd_to_hwirq(d)); dwapb_write(gpio, GPIO_INTEN, val); - spin_unlock_irqrestore(&gc->bgpio_lock, flags); + raw_spin_unlock_irqrestore(&gc->bgpio_lock, flags); } static void dwapb_irq_disable(struct irq_data *d) @@ -295,11 +295,11 @@ static void dwapb_irq_disable(struct irq_data *d) unsigned long flags; u32 val; - spin_lock_irqsave(&gc->bgpio_lock, flags); + raw_spin_lock_irqsave(&gc->bgpio_lock, flags); val = dwapb_read(gpio, GPIO_INTEN); val &= ~BIT(irqd_to_hwirq(d)); dwapb_write(gpio, GPIO_INTEN, val); - spin_unlock_irqrestore(&gc->bgpio_lock, flags); + raw_spin_unlock_irqrestore(&gc->bgpio_lock, flags); } static int dwapb_irq_set_type(struct irq_data *d, u32 type) @@ -309,7 +309,7 @@ static int dwapb_irq_set_type(struct irq_data *d, u32 type) irq_hw_number_t bit = irqd_to_hwirq(d); unsigned long level, polarity, flags; - spin_lock_irqsave(&gc->bgpio_lock, flags); + raw_spin_lock_irqsave(&gc->bgpio_lock, flags); level = dwapb_read(gpio, GPIO_INTTYPE_LEVEL); polarity = dwapb_read(gpio, GPIO_INT_POLARITY); @@ -344,7 +344,7 @@ static int dwapb_irq_set_type(struct irq_data *d, u32 type) dwapb_write(gpio, GPIO_INTTYPE_LEVEL, level); if (type != IRQ_TYPE_EDGE_BOTH) dwapb_write(gpio, GPIO_INT_POLARITY, polarity); - spin_unlock_irqrestore(&gc->bgpio_lock, flags); + raw_spin_unlock_irqrestore(&gc->bgpio_lock, flags); return 0; } @@ -374,7 +374,7 @@ static int dwapb_gpio_set_debounce(struct gpio_chip *gc, unsigned long flags, val_deb; unsigned long mask = BIT(offset); - spin_lock_irqsave(&gc->bgpio_lock, flags); + raw_spin_lock_irqsave(&gc->bgpio_lock, flags); val_deb = dwapb_read(gpio, GPIO_PORTA_DEBOUNCE); if (debounce) @@ -383,7 +383,7 @@ static int dwapb_gpio_set_debounce(struct gpio_chip *gc, val_deb &= ~mask; dwapb_write(gpio, GPIO_PORTA_DEBOUNCE, val_deb); - spin_unlock_irqrestore(&gc->bgpio_lock, flags); + raw_spin_unlock_irqrestore(&gc->bgpio_lock, flags); return 0; } @@ -738,7 +738,7 @@ static int dwapb_gpio_suspend(struct device *dev) unsigned long flags; int i; - spin_lock_irqsave(&gc->bgpio_lock, flags); + raw_spin_lock_irqsave(&gc->bgpio_lock, flags); for (i = 0; i < gpio->nr_ports; i++) { unsigned int offset; unsigned int idx = gpio->ports[i].idx; @@ -765,7 +765,7 @@ static int dwapb_gpio_suspend(struct device *dev) dwapb_write(gpio, GPIO_INTMASK, ~ctx->wake_en); } } - spin_unlock_irqrestore(&gc->bgpio_lock, flags); + raw_spin_unlock_irqrestore(&gc->bgpio_lock, flags); clk_bulk_disable_unprepare(DWAPB_NR_CLOCKS, gpio->clks); @@ -785,7 +785,7 @@ static int dwapb_gpio_resume(struct device *dev) return err; } - spin_lock_irqsave(&gc->bgpio_lock, flags); + raw_spin_lock_irqsave(&gc->bgpio_lock, flags); for (i = 0; i < gpio->nr_ports; i++) { unsigned int offset; unsigned int idx = gpio->ports[i].idx; @@ -812,7 +812,7 @@ static int dwapb_gpio_resume(struct device *dev) dwapb_write(gpio, GPIO_PORTA_EOI, 0xffffffff); } } - spin_unlock_irqrestore(&gc->bgpio_lock, flags); + raw_spin_unlock_irqrestore(&gc->bgpio_lock, flags); return 0; } diff --git a/drivers/gpio/gpio-grgpio.c b/drivers/gpio/gpio-grgpio.c index 23d447e17a67..df563616f943 100644 --- a/drivers/gpio/gpio-grgpio.c +++ b/drivers/gpio/gpio-grgpio.c @@ -145,7 +145,7 @@ static int grgpio_irq_set_type(struct irq_data *d, unsigned int type) return -EINVAL; } - spin_lock_irqsave(&priv->gc.bgpio_lock, flags); + raw_spin_lock_irqsave(&priv->gc.bgpio_lock, flags); ipol = priv->gc.read_reg(priv->regs + GRGPIO_IPOL) & ~mask; iedge = priv->gc.read_reg(priv->regs + GRGPIO_IEDGE) & ~mask; @@ -153,7 +153,7 @@ static int grgpio_irq_set_type(struct irq_data *d, unsigned int type) priv->gc.write_reg(priv->regs + GRGPIO_IPOL, ipol | pol); priv->gc.write_reg(priv->regs + GRGPIO_IEDGE, iedge | edge); - spin_unlock_irqrestore(&priv->gc.bgpio_lock, flags); + raw_spin_unlock_irqrestore(&priv->gc.bgpio_lock, flags); return 0; } @@ -164,11 +164,11 @@ static void grgpio_irq_mask(struct irq_data *d) int offset = d->hwirq; unsigned long flags; - spin_lock_irqsave(&priv->gc.bgpio_lock, flags); + raw_spin_lock_irqsave(&priv->gc.bgpio_lock, flags); grgpio_set_imask(priv, offset, 0); - spin_unlock_irqrestore(&priv->gc.bgpio_lock, flags); + raw_spin_unlock_irqrestore(&priv->gc.bgpio_lock, flags); } static void grgpio_irq_unmask(struct irq_data *d) @@ -177,11 +177,11 @@ static void grgpio_irq_unmask(struct irq_data *d) int offset = d->hwirq; unsigned long flags; - spin_lock_irqsave(&priv->gc.bgpio_lock, flags); + raw_spin_lock_irqsave(&priv->gc.bgpio_lock, flags); grgpio_set_imask(priv, offset, 1); - spin_unlock_irqrestore(&priv->gc.bgpio_lock, flags); + raw_spin_unlock_irqrestore(&priv->gc.bgpio_lock, flags); } static struct irq_chip grgpio_irq_chip = { @@ -199,7 +199,7 @@ static irqreturn_t grgpio_irq_handler(int irq, void *dev) int i; int match = 0; - spin_lock_irqsave(&priv->gc.bgpio_lock, flags); + raw_spin_lock_irqsave(&priv->gc.bgpio_lock, flags); /* * For each gpio line, call its interrupt handler if it its underlying @@ -215,7 +215,7 @@ static irqreturn_t grgpio_irq_handler(int irq, void *dev) } } - spin_unlock_irqrestore(&priv->gc.bgpio_lock, flags); + raw_spin_unlock_irqrestore(&priv->gc.bgpio_lock, flags); if (!match) dev_warn(priv->dev, "No gpio line matched irq %d\n", irq); @@ -247,13 +247,13 @@ static int grgpio_irq_map(struct irq_domain *d, unsigned int irq, dev_dbg(priv->dev, "Mapping irq %d for gpio line %d\n", irq, offset); - spin_lock_irqsave(&priv->gc.bgpio_lock, flags); + raw_spin_lock_irqsave(&priv->gc.bgpio_lock, flags); /* Request underlying irq if not already requested */ lirq->irq = irq; uirq = &priv->uirqs[lirq->index]; if (uirq->refcnt == 0) { - spin_unlock_irqrestore(&priv->gc.bgpio_lock, flags); + raw_spin_unlock_irqrestore(&priv->gc.bgpio_lock, flags); ret = request_irq(uirq->uirq, grgpio_irq_handler, 0, dev_name(priv->dev), priv); if (ret) { @@ -262,11 +262,11 @@ static int grgpio_irq_map(struct irq_domain *d, unsigned int irq, uirq->uirq); return ret; } - spin_lock_irqsave(&priv->gc.bgpio_lock, flags); + raw_spin_lock_irqsave(&priv->gc.bgpio_lock, flags); } uirq->refcnt++; - spin_unlock_irqrestore(&priv->gc.bgpio_lock, flags); + raw_spin_unlock_irqrestore(&priv->gc.bgpio_lock, flags); /* Setup irq */ irq_set_chip_data(irq, priv); @@ -290,7 +290,7 @@ static void grgpio_irq_unmap(struct irq_domain *d, unsigned int irq) irq_set_chip_and_handler(irq, NULL, NULL); irq_set_chip_data(irq, NULL); - spin_lock_irqsave(&priv->gc.bgpio_lock, flags); + raw_spin_lock_irqsave(&priv->gc.bgpio_lock, flags); /* Free underlying irq if last user unmapped */ index = -1; @@ -309,13 +309,13 @@ static void grgpio_irq_unmap(struct irq_domain *d, unsigned int irq) uirq = &priv->uirqs[lirq->index]; uirq->refcnt--; if (uirq->refcnt == 0) { - spin_unlock_irqrestore(&priv->gc.bgpio_lock, flags); + raw_spin_unlock_irqrestore(&priv->gc.bgpio_lock, flags); free_irq(uirq->uirq, priv); return; } } - spin_unlock_irqrestore(&priv->gc.bgpio_lock, flags); + raw_spin_unlock_irqrestore(&priv->gc.bgpio_lock, flags); } static const struct irq_domain_ops grgpio_irq_domain_ops = { diff --git a/drivers/gpio/gpio-hlwd.c b/drivers/gpio/gpio-hlwd.c index 641719a96a1a..4e13e937f832 100644 --- a/drivers/gpio/gpio-hlwd.c +++ b/drivers/gpio/gpio-hlwd.c @@ -65,7 +65,7 @@ static void hlwd_gpio_irqhandler(struct irq_desc *desc) int hwirq; u32 emulated_pending; - spin_lock_irqsave(&hlwd->gpioc.bgpio_lock, flags); + raw_spin_lock_irqsave(&hlwd->gpioc.bgpio_lock, flags); pending = ioread32be(hlwd->regs + HW_GPIOB_INTFLAG); pending &= ioread32be(hlwd->regs + HW_GPIOB_INTMASK); @@ -93,7 +93,7 @@ static void hlwd_gpio_irqhandler(struct irq_desc *desc) /* Mark emulated interrupts as pending */ pending |= rising | falling; } - spin_unlock_irqrestore(&hlwd->gpioc.bgpio_lock, flags); + raw_spin_unlock_irqrestore(&hlwd->gpioc.bgpio_lock, flags); chained_irq_enter(chip, desc); @@ -118,11 +118,11 @@ static void hlwd_gpio_irq_mask(struct irq_data *data) unsigned long flags; u32 mask; - spin_lock_irqsave(&hlwd->gpioc.bgpio_lock, flags); + raw_spin_lock_irqsave(&hlwd->gpioc.bgpio_lock, flags); mask = ioread32be(hlwd->regs + HW_GPIOB_INTMASK); mask &= ~BIT(data->hwirq); iowrite32be(mask, hlwd->regs + HW_GPIOB_INTMASK); - spin_unlock_irqrestore(&hlwd->gpioc.bgpio_lock, flags); + raw_spin_unlock_irqrestore(&hlwd->gpioc.bgpio_lock, flags); } static void hlwd_gpio_irq_unmask(struct irq_data *data) @@ -132,11 +132,11 @@ static void hlwd_gpio_irq_unmask(struct irq_data *data) unsigned long flags; u32 mask; - spin_lock_irqsave(&hlwd->gpioc.bgpio_lock, flags); + raw_spin_lock_irqsave(&hlwd->gpioc.bgpio_lock, flags); mask = ioread32be(hlwd->regs + HW_GPIOB_INTMASK); mask |= BIT(data->hwirq); iowrite32be(mask, hlwd->regs + HW_GPIOB_INTMASK); - spin_unlock_irqrestore(&hlwd->gpioc.bgpio_lock, flags); + raw_spin_unlock_irqrestore(&hlwd->gpioc.bgpio_lock, flags); } static void hlwd_gpio_irq_enable(struct irq_data *data) @@ -173,7 +173,7 @@ static int hlwd_gpio_irq_set_type(struct irq_data *data, unsigned int flow_type) unsigned long flags; u32 level; - spin_lock_irqsave(&hlwd->gpioc.bgpio_lock, flags); + raw_spin_lock_irqsave(&hlwd->gpioc.bgpio_lock, flags); hlwd->edge_emulation &= ~BIT(data->hwirq); @@ -194,11 +194,11 @@ static int hlwd_gpio_irq_set_type(struct irq_data *data, unsigned int flow_type) hlwd_gpio_irq_setup_emulation(hlwd, data->hwirq, flow_type); break; default: - spin_unlock_irqrestore(&hlwd->gpioc.bgpio_lock, flags); + raw_spin_unlock_irqrestore(&hlwd->gpioc.bgpio_lock, flags); return -EINVAL; } - spin_unlock_irqrestore(&hlwd->gpioc.bgpio_lock, flags); + raw_spin_unlock_irqrestore(&hlwd->gpioc.bgpio_lock, flags); return 0; } diff --git a/drivers/gpio/gpio-idt3243x.c b/drivers/gpio/gpio-idt3243x.c index 52b8b72ded77..1cafdf46f875 100644 --- a/drivers/gpio/gpio-idt3243x.c +++ b/drivers/gpio/gpio-idt3243x.c @@ -57,7 +57,7 @@ static int idt_gpio_irq_set_type(struct irq_data *d, unsigned int flow_type) if (sense == IRQ_TYPE_NONE || (sense & IRQ_TYPE_EDGE_BOTH)) return -EINVAL; - spin_lock_irqsave(&gc->bgpio_lock, flags); + raw_spin_lock_irqsave(&gc->bgpio_lock, flags); ilevel = readl(ctrl->gpio + IDT_GPIO_ILEVEL); if (sense & IRQ_TYPE_LEVEL_HIGH) @@ -68,7 +68,7 @@ static int idt_gpio_irq_set_type(struct irq_data *d, unsigned int flow_type) writel(ilevel, ctrl->gpio + IDT_GPIO_ILEVEL); irq_set_handler_locked(d, handle_level_irq); - spin_unlock_irqrestore(&gc->bgpio_lock, flags); + raw_spin_unlock_irqrestore(&gc->bgpio_lock, flags); return 0; } @@ -86,12 +86,12 @@ static void idt_gpio_mask(struct irq_data *d) struct idt_gpio_ctrl *ctrl = gpiochip_get_data(gc); unsigned long flags; - spin_lock_irqsave(&gc->bgpio_lock, flags); + raw_spin_lock_irqsave(&gc->bgpio_lock, flags); ctrl->mask_cache |= BIT(d->hwirq); writel(ctrl->mask_cache, ctrl->pic + IDT_PIC_IRQ_MASK); - spin_unlock_irqrestore(&gc->bgpio_lock, flags); + raw_spin_unlock_irqrestore(&gc->bgpio_lock, flags); } static void idt_gpio_unmask(struct irq_data *d) @@ -100,12 +100,12 @@ static void idt_gpio_unmask(struct irq_data *d) struct idt_gpio_ctrl *ctrl = gpiochip_get_data(gc); unsigned long flags; - spin_lock_irqsave(&gc->bgpio_lock, flags); + raw_spin_lock_irqsave(&gc->bgpio_lock, flags); ctrl->mask_cache &= ~BIT(d->hwirq); writel(ctrl->mask_cache, ctrl->pic + IDT_PIC_IRQ_MASK); - spin_unlock_irqrestore(&gc->bgpio_lock, flags); + raw_spin_unlock_irqrestore(&gc->bgpio_lock, flags); } static int idt_gpio_irq_init_hw(struct gpio_chip *gc) diff --git a/drivers/gpio/gpio-ixp4xx.c b/drivers/gpio/gpio-ixp4xx.c index b3b050604e0b..6b184502fa3f 100644 --- a/drivers/gpio/gpio-ixp4xx.c +++ b/drivers/gpio/gpio-ixp4xx.c @@ -128,7 +128,7 @@ static int ixp4xx_gpio_irq_set_type(struct irq_data *d, unsigned int type) int_reg = IXP4XX_REG_GPIT1; } - spin_lock_irqsave(&g->gc.bgpio_lock, flags); + raw_spin_lock_irqsave(&g->gc.bgpio_lock, flags); /* Clear the style for the appropriate pin */ val = __raw_readl(g->base + int_reg); @@ -147,7 +147,7 @@ static int ixp4xx_gpio_irq_set_type(struct irq_data *d, unsigned int type) val |= BIT(d->hwirq); __raw_writel(val, g->base + IXP4XX_REG_GPOE); - spin_unlock_irqrestore(&g->gc.bgpio_lock, flags); + raw_spin_unlock_irqrestore(&g->gc.bgpio_lock, flags); /* This parent only accept level high (asserted) */ return irq_chip_set_type_parent(d, IRQ_TYPE_LEVEL_HIGH); diff --git a/drivers/gpio/gpio-loongson1.c b/drivers/gpio/gpio-loongson1.c index 1b1ee94eeab4..5d90b3bc5a25 100644 --- a/drivers/gpio/gpio-loongson1.c +++ b/drivers/gpio/gpio-loongson1.c @@ -25,10 +25,10 @@ static int ls1x_gpio_request(struct gpio_chip *gc, unsigned int offset) { unsigned long flags; - spin_lock_irqsave(&gc->bgpio_lock, flags); + raw_spin_lock_irqsave(&gc->bgpio_lock, flags); __raw_writel(__raw_readl(gpio_reg_base + GPIO_CFG) | BIT(offset), gpio_reg_base + GPIO_CFG); - spin_unlock_irqrestore(&gc->bgpio_lock, flags); + raw_spin_unlock_irqrestore(&gc->bgpio_lock, flags); return 0; } @@ -37,10 +37,10 @@ static void ls1x_gpio_free(struct gpio_chip *gc, unsigned int offset) { unsigned long flags; - spin_lock_irqsave(&gc->bgpio_lock, flags); + raw_spin_lock_irqsave(&gc->bgpio_lock, flags); __raw_writel(__raw_readl(gpio_reg_base + GPIO_CFG) & ~BIT(offset), gpio_reg_base + GPIO_CFG); - spin_unlock_irqrestore(&gc->bgpio_lock, flags); + raw_spin_unlock_irqrestore(&gc->bgpio_lock, flags); } static int ls1x_gpio_probe(struct platform_device *pdev) diff --git a/drivers/gpio/gpio-menz127.c b/drivers/gpio/gpio-menz127.c index 1e21c661d79d..a035a9bcb57c 100644 --- a/drivers/gpio/gpio-menz127.c +++ b/drivers/gpio/gpio-menz127.c @@ -64,7 +64,7 @@ static int men_z127_debounce(struct gpio_chip *gc, unsigned gpio, debounce /= 50; } - spin_lock(&gc->bgpio_lock); + raw_spin_lock(&gc->bgpio_lock); db_en = readl(priv->reg_base + MEN_Z127_DBER); @@ -79,7 +79,7 @@ static int men_z127_debounce(struct gpio_chip *gc, unsigned gpio, writel(db_en, priv->reg_base + MEN_Z127_DBER); writel(db_cnt, priv->reg_base + GPIO_TO_DBCNT_REG(gpio)); - spin_unlock(&gc->bgpio_lock); + raw_spin_unlock(&gc->bgpio_lock); return 0; } @@ -91,7 +91,7 @@ static int men_z127_set_single_ended(struct gpio_chip *gc, struct men_z127_gpio *priv = gpiochip_get_data(gc); u32 od_en; - spin_lock(&gc->bgpio_lock); + raw_spin_lock(&gc->bgpio_lock); od_en = readl(priv->reg_base + MEN_Z127_ODER); if (param == PIN_CONFIG_DRIVE_OPEN_DRAIN) @@ -101,7 +101,7 @@ static int men_z127_set_single_ended(struct gpio_chip *gc, od_en &= ~BIT(offset); writel(od_en, priv->reg_base + MEN_Z127_ODER); - spin_unlock(&gc->bgpio_lock); + raw_spin_unlock(&gc->bgpio_lock); return 0; } diff --git a/drivers/gpio/gpio-mlxbf2.c b/drivers/gpio/gpio-mlxbf2.c index 3d89912a05b8..64cb060d9d75 100644 --- a/drivers/gpio/gpio-mlxbf2.c +++ b/drivers/gpio/gpio-mlxbf2.c @@ -131,7 +131,7 @@ static int mlxbf2_gpio_lock_acquire(struct mlxbf2_gpio_context *gs) u32 arm_gpio_lock_val; mutex_lock(yu_arm_gpio_lock_param.lock); - spin_lock(&gs->gc.bgpio_lock); + raw_spin_lock(&gs->gc.bgpio_lock); arm_gpio_lock_val = readl(yu_arm_gpio_lock_param.io); @@ -139,7 +139,7 @@ static int mlxbf2_gpio_lock_acquire(struct mlxbf2_gpio_context *gs) * When lock active bit[31] is set, ModeX is write enabled */ if (YU_LOCK_ACTIVE_BIT(arm_gpio_lock_val)) { - spin_unlock(&gs->gc.bgpio_lock); + raw_spin_unlock(&gs->gc.bgpio_lock); mutex_unlock(yu_arm_gpio_lock_param.lock); return -EINVAL; } @@ -157,7 +157,7 @@ static void mlxbf2_gpio_lock_release(struct mlxbf2_gpio_context *gs) __releases(yu_arm_gpio_lock_param.lock) { writel(YU_ARM_GPIO_LOCK_RELEASE, yu_arm_gpio_lock_param.io); - spin_unlock(&gs->gc.bgpio_lock); + raw_spin_unlock(&gs->gc.bgpio_lock); mutex_unlock(yu_arm_gpio_lock_param.lock); } @@ -237,7 +237,7 @@ static void mlxbf2_gpio_irq_enable(struct irq_data *irqd) unsigned long flags; u32 val; - spin_lock_irqsave(&gs->gc.bgpio_lock, flags); + raw_spin_lock_irqsave(&gs->gc.bgpio_lock, flags); val = readl(gs->gpio_io + YU_GPIO_CAUSE_OR_CLRCAUSE); val |= BIT(offset); writel(val, gs->gpio_io + YU_GPIO_CAUSE_OR_CLRCAUSE); @@ -245,7 +245,7 @@ static void mlxbf2_gpio_irq_enable(struct irq_data *irqd) val = readl(gs->gpio_io + YU_GPIO_CAUSE_OR_EVTEN0); val |= BIT(offset); writel(val, gs->gpio_io + YU_GPIO_CAUSE_OR_EVTEN0); - spin_unlock_irqrestore(&gs->gc.bgpio_lock, flags); + raw_spin_unlock_irqrestore(&gs->gc.bgpio_lock, flags); } static void mlxbf2_gpio_irq_disable(struct irq_data *irqd) @@ -256,11 +256,11 @@ static void mlxbf2_gpio_irq_disable(struct irq_data *irqd) unsigned long flags; u32 val; - spin_lock_irqsave(&gs->gc.bgpio_lock, flags); + raw_spin_lock_irqsave(&gs->gc.bgpio_lock, flags); val = readl(gs->gpio_io + YU_GPIO_CAUSE_OR_EVTEN0); val &= ~BIT(offset); writel(val, gs->gpio_io + YU_GPIO_CAUSE_OR_EVTEN0); - spin_unlock_irqrestore(&gs->gc.bgpio_lock, flags); + raw_spin_unlock_irqrestore(&gs->gc.bgpio_lock, flags); } static irqreturn_t mlxbf2_gpio_irq_handler(int irq, void *ptr) @@ -307,7 +307,7 @@ mlxbf2_gpio_irq_set_type(struct irq_data *irqd, unsigned int type) return -EINVAL; } - spin_lock_irqsave(&gs->gc.bgpio_lock, flags); + raw_spin_lock_irqsave(&gs->gc.bgpio_lock, flags); if (fall) { val = readl(gs->gpio_io + YU_GPIO_CAUSE_FALL_EN); val |= BIT(offset); @@ -319,7 +319,7 @@ mlxbf2_gpio_irq_set_type(struct irq_data *irqd, unsigned int type) val |= BIT(offset); writel(val, gs->gpio_io + YU_GPIO_CAUSE_RISE_EN); } - spin_unlock_irqrestore(&gs->gc.bgpio_lock, flags); + raw_spin_unlock_irqrestore(&gs->gc.bgpio_lock, flags); return 0; } diff --git a/drivers/gpio/gpio-mmio.c b/drivers/gpio/gpio-mmio.c index c335a0309ba3..d9dff3dc92ae 100644 --- a/drivers/gpio/gpio-mmio.c +++ b/drivers/gpio/gpio-mmio.c @@ -220,7 +220,7 @@ static void bgpio_set(struct gpio_chip *gc, unsigned int gpio, int val) unsigned long mask = bgpio_line2mask(gc, gpio); unsigned long flags; - spin_lock_irqsave(&gc->bgpio_lock, flags); + raw_spin_lock_irqsave(&gc->bgpio_lock, flags); if (val) gc->bgpio_data |= mask; @@ -229,7 +229,7 @@ static void bgpio_set(struct gpio_chip *gc, unsigned int gpio, int val) gc->write_reg(gc->reg_dat, gc->bgpio_data); - spin_unlock_irqrestore(&gc->bgpio_lock, flags); + raw_spin_unlock_irqrestore(&gc->bgpio_lock, flags); } static void bgpio_set_with_clear(struct gpio_chip *gc, unsigned int gpio, @@ -248,7 +248,7 @@ static void bgpio_set_set(struct gpio_chip *gc, unsigned int gpio, int val) unsigned long mask = bgpio_line2mask(gc, gpio); unsigned long flags; - spin_lock_irqsave(&gc->bgpio_lock, flags); + raw_spin_lock_irqsave(&gc->bgpio_lock, flags); if (val) gc->bgpio_data |= mask; @@ -257,7 +257,7 @@ static void bgpio_set_set(struct gpio_chip *gc, unsigned int gpio, int val) gc->write_reg(gc->reg_set, gc->bgpio_data); - spin_unlock_irqrestore(&gc->bgpio_lock, flags); + raw_spin_unlock_irqrestore(&gc->bgpio_lock, flags); } static void bgpio_multiple_get_masks(struct gpio_chip *gc, @@ -286,7 +286,7 @@ static void bgpio_set_multiple_single_reg(struct gpio_chip *gc, unsigned long flags; unsigned long set_mask, clear_mask; - spin_lock_irqsave(&gc->bgpio_lock, flags); + raw_spin_lock_irqsave(&gc->bgpio_lock, flags); bgpio_multiple_get_masks(gc, mask, bits, &set_mask, &clear_mask); @@ -295,7 +295,7 @@ static void bgpio_set_multiple_single_reg(struct gpio_chip *gc, gc->write_reg(reg, gc->bgpio_data); - spin_unlock_irqrestore(&gc->bgpio_lock, flags); + raw_spin_unlock_irqrestore(&gc->bgpio_lock, flags); } static void bgpio_set_multiple(struct gpio_chip *gc, unsigned long *mask, @@ -347,7 +347,7 @@ static int bgpio_dir_in(struct gpio_chip *gc, unsigned int gpio) { unsigned long flags; - spin_lock_irqsave(&gc->bgpio_lock, flags); + raw_spin_lock_irqsave(&gc->bgpio_lock, flags); gc->bgpio_dir &= ~bgpio_line2mask(gc, gpio); @@ -356,7 +356,7 @@ static int bgpio_dir_in(struct gpio_chip *gc, unsigned int gpio) if (gc->reg_dir_out) gc->write_reg(gc->reg_dir_out, gc->bgpio_dir); - spin_unlock_irqrestore(&gc->bgpio_lock, flags); + raw_spin_unlock_irqrestore(&gc->bgpio_lock, flags); return 0; } @@ -387,7 +387,7 @@ static void bgpio_dir_out(struct gpio_chip *gc, unsigned int gpio, int val) { unsigned long flags; - spin_lock_irqsave(&gc->bgpio_lock, flags); + raw_spin_lock_irqsave(&gc->bgpio_lock, flags); gc->bgpio_dir |= bgpio_line2mask(gc, gpio); @@ -396,7 +396,7 @@ static void bgpio_dir_out(struct gpio_chip *gc, unsigned int gpio, int val) if (gc->reg_dir_out) gc->write_reg(gc->reg_dir_out, gc->bgpio_dir); - spin_unlock_irqrestore(&gc->bgpio_lock, flags); + raw_spin_unlock_irqrestore(&gc->bgpio_lock, flags); } static int bgpio_dir_out_dir_first(struct gpio_chip *gc, unsigned int gpio, @@ -610,7 +610,7 @@ int bgpio_init(struct gpio_chip *gc, struct device *dev, if (gc->bgpio_bits > BITS_PER_LONG) return -EINVAL; - spin_lock_init(&gc->bgpio_lock); + raw_spin_lock_init(&gc->bgpio_lock); gc->parent = dev; gc->label = dev_name(dev); gc->base = -1; diff --git a/drivers/gpio/gpio-sifive.c b/drivers/gpio/gpio-sifive.c index 7d82388b4ab7..03b8c4de2e91 100644 --- a/drivers/gpio/gpio-sifive.c +++ b/drivers/gpio/gpio-sifive.c @@ -44,7 +44,7 @@ static void sifive_gpio_set_ie(struct sifive_gpio *chip, unsigned int offset) unsigned long flags; unsigned int trigger; - spin_lock_irqsave(&chip->gc.bgpio_lock, flags); + raw_spin_lock_irqsave(&chip->gc.bgpio_lock, flags); trigger = (chip->irq_state & BIT(offset)) ? chip->trigger[offset] : 0; regmap_update_bits(chip->regs, SIFIVE_GPIO_RISE_IE, BIT(offset), (trigger & IRQ_TYPE_EDGE_RISING) ? BIT(offset) : 0); @@ -54,7 +54,7 @@ static void sifive_gpio_set_ie(struct sifive_gpio *chip, unsigned int offset) (trigger & IRQ_TYPE_LEVEL_HIGH) ? BIT(offset) : 0); regmap_update_bits(chip->regs, SIFIVE_GPIO_LOW_IE, BIT(offset), (trigger & IRQ_TYPE_LEVEL_LOW) ? BIT(offset) : 0); - spin_unlock_irqrestore(&chip->gc.bgpio_lock, flags); + raw_spin_unlock_irqrestore(&chip->gc.bgpio_lock, flags); } static int sifive_gpio_irq_set_type(struct irq_data *d, unsigned int trigger) @@ -84,13 +84,13 @@ static void sifive_gpio_irq_enable(struct irq_data *d) /* Switch to input */ gc->direction_input(gc, offset); - spin_lock_irqsave(&gc->bgpio_lock, flags); + raw_spin_lock_irqsave(&gc->bgpio_lock, flags); /* Clear any sticky pending interrupts */ regmap_write(chip->regs, SIFIVE_GPIO_RISE_IP, bit); regmap_write(chip->regs, SIFIVE_GPIO_FALL_IP, bit); regmap_write(chip->regs, SIFIVE_GPIO_HIGH_IP, bit); regmap_write(chip->regs, SIFIVE_GPIO_LOW_IP, bit); - spin_unlock_irqrestore(&gc->bgpio_lock, flags); + raw_spin_unlock_irqrestore(&gc->bgpio_lock, flags); /* Enable interrupts */ assign_bit(offset, &chip->irq_state, 1); @@ -116,13 +116,13 @@ static void sifive_gpio_irq_eoi(struct irq_data *d) u32 bit = BIT(offset); unsigned long flags; - spin_lock_irqsave(&gc->bgpio_lock, flags); + raw_spin_lock_irqsave(&gc->bgpio_lock, flags); /* Clear all pending interrupts */ regmap_write(chip->regs, SIFIVE_GPIO_RISE_IP, bit); regmap_write(chip->regs, SIFIVE_GPIO_FALL_IP, bit); regmap_write(chip->regs, SIFIVE_GPIO_HIGH_IP, bit); regmap_write(chip->regs, SIFIVE_GPIO_LOW_IP, bit); - spin_unlock_irqrestore(&gc->bgpio_lock, flags); + raw_spin_unlock_irqrestore(&gc->bgpio_lock, flags); irq_chip_eoi_parent(d); } diff --git a/drivers/gpio/gpio-tb10x.c b/drivers/gpio/gpio-tb10x.c index 718a508d3b2f..de6afa3f9716 100644 --- a/drivers/gpio/gpio-tb10x.c +++ b/drivers/gpio/gpio-tb10x.c @@ -62,14 +62,14 @@ static inline void tb10x_set_bits(struct tb10x_gpio *gpio, unsigned int offs, u32 r; unsigned long flags; - spin_lock_irqsave(&gpio->gc.bgpio_lock, flags); + raw_spin_lock_irqsave(&gpio->gc.bgpio_lock, flags); r = tb10x_reg_read(gpio, offs); r = (r & ~mask) | (val & mask); tb10x_reg_write(gpio, offs, r); - spin_unlock_irqrestore(&gpio->gc.bgpio_lock, flags); + raw_spin_unlock_irqrestore(&gpio->gc.bgpio_lock, flags); } static int tb10x_gpio_to_irq(struct gpio_chip *chip, unsigned offset) diff --git a/drivers/pinctrl/nuvoton/pinctrl-npcm7xx.c b/drivers/pinctrl/nuvoton/pinctrl-npcm7xx.c index 9557fac5d11c..b2a0f11a658b 100644 --- a/drivers/pinctrl/nuvoton/pinctrl-npcm7xx.c +++ b/drivers/pinctrl/nuvoton/pinctrl-npcm7xx.c @@ -104,12 +104,12 @@ static void npcm_gpio_set(struct gpio_chip *gc, void __iomem *reg, unsigned long flags; unsigned long val; - spin_lock_irqsave(&gc->bgpio_lock, flags); + raw_spin_lock_irqsave(&gc->bgpio_lock, flags); val = ioread32(reg) | pinmask; iowrite32(val, reg); - spin_unlock_irqrestore(&gc->bgpio_lock, flags); + raw_spin_unlock_irqrestore(&gc->bgpio_lock, flags); } static void npcm_gpio_clr(struct gpio_chip *gc, void __iomem *reg, @@ -118,12 +118,12 @@ static void npcm_gpio_clr(struct gpio_chip *gc, void __iomem *reg, unsigned long flags; unsigned long val; - spin_lock_irqsave(&gc->bgpio_lock, flags); + raw_spin_lock_irqsave(&gc->bgpio_lock, flags); val = ioread32(reg) & ~pinmask; iowrite32(val, reg); - spin_unlock_irqrestore(&gc->bgpio_lock, flags); + raw_spin_unlock_irqrestore(&gc->bgpio_lock, flags); } static void npcmgpio_dbg_show(struct seq_file *s, struct gpio_chip *chip) diff --git a/include/linux/gpio/driver.h b/include/linux/gpio/driver.h index 874aabd270c9..ff8247a19f57 100644 --- a/include/linux/gpio/driver.h +++ b/include/linux/gpio/driver.h @@ -445,7 +445,7 @@ struct gpio_chip { void __iomem *reg_dir_in; bool bgpio_dir_unreadable; int bgpio_bits; - spinlock_t bgpio_lock; + raw_spinlock_t bgpio_lock; unsigned long bgpio_data; unsigned long bgpio_dir; #endif /* CONFIG_GPIO_GENERIC */ -- 2.24.3 (Apple Git-128) From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id A1ACEC433EF for ; Tue, 19 Apr 2022 01:30:43 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Message-Id:Date:Subject:Cc:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=sK/iF/MH5fxCKJ7OVvBLxhfLNyTKiXWDLB+FXz/aw20=; b=Zd6DFtWm377mMg Agy/GiNl0eyExfhSx9Ul0nsiqWiWXCAqNH+9PJdRmndQp0jHqJlWAJj2f6EI8+rFTl7wXapHW5VbW jmYFCoJHYD4NDCbPX6/35Z+jpImGOB90Nqzj+u7XG7VzgYoxdNKTIA4vNh7LuPSQp55tjiY9/6KgH urI+dX6VmkNTqVTJGKpmoWK9h/ZtlK1JDibAt5w/OYoGB3oGqrQkrcB/p2yE48B0haRr2VpeG2qS+ gct3lzg5B8gEHti5l7mnsuy34RmsJ+vOXBn483ftuCDKQKg5XuUQBTtUTx+JedduYfKEftSw8m2qz TRrATFv9PloLKKSnJC6Q==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1ngcfe-0013WF-RX; Tue, 19 Apr 2022 01:28:46 +0000 Received: from mail-io1-xd34.google.com ([2607:f8b0:4864:20::d34]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1ngcfY-0013VV-LZ for linux-arm-kernel@lists.infradead.org; Tue, 19 Apr 2022 01:28:44 +0000 Received: by mail-io1-xd34.google.com with SMTP id p62so3561630iod.0 for ; Mon, 18 Apr 2022 18:28:38 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=Md+qfUiaZJYVHRis0KLvsKhzCYXdod5jz3J0IJoHXZY=; b=HYnFlf9M+npwYUoPm69LAGL5EK49HrfH2rkoVsVMY1LBufds0ELeBSdlUGicUmUhmA +hK1yAfy3AszXcJ6Cdb2rDziwFXTO0h5X2kxUmepa2hPL1AzaVK3J+pPTQbT4GJEcBSN cMkXrOH86bkknv2Pz7LyBxQYH1mwbumdrLEZOnSxKf3Au6pZDGfmLtu4kVomlhywlKz3 kIglr2ed8CgJF7y09ZdupNFSdpDfMU3+TkMKhH4kCJ3p3Bk+2owVqOLW+OM/e5/hAmXP O8tRIrAf1NQesUidQgfmf5H9bJpYYOuRyZiliPb3lNsGTBHjTTGHC7nEGxLaxMi8+t8X JyVw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=Md+qfUiaZJYVHRis0KLvsKhzCYXdod5jz3J0IJoHXZY=; b=EdAzTEJ/2InMN85LiYws/Dp64YxzIStfH3ikn8cfLJsRkqabatd5KguZ+d5R/VOExh HyQJh2zCp4peLxwCqrWBOB0z9C+54jtLyIBZ8rX9I3xxP/gLl82JdewniG6xoAvtDhHj a1YVN7aSYvsSnsLWC5M/EWW8YKsz7Rg9aloERy7HWH4ZziEaFA+g+o5HnmFJRCNe68Re JDTVE5G6Y89lObdF2KSVITtcjxExpThO97NYj2zfgituC/qp6E07Sq+FcqN7sbp3QFok kFR8hZVKchhSCRB0LNw+/2/EyHz/V0cvpfV2VOwbWaIXFKBprzwulDwhgeWFJ1SBMU/L Yrgw== X-Gm-Message-State: AOAM530hhuvEJpZG3gn0z1spucCTbpJFZtmwwvtU3ClnnH67LdimMp7G F/DYwDPP7xxdZvym30CO4tI= X-Google-Smtp-Source: ABdhPJxG4PATS5sMOw/iYcLAG3J7gn1YIRpUb2lKDF1dEw44GupFwRpLcHCuAnWc3n702Kj4EWUL0g== X-Received: by 2002:a6b:5a10:0:b0:653:9007:d163 with SMTP id o16-20020a6b5a10000000b006539007d163mr5832310iob.43.1650331717620; Mon, 18 Apr 2022 18:28:37 -0700 (PDT) Received: from localhost (ec2-13-59-0-164.us-east-2.compute.amazonaws.com. [13.59.0.164]) by smtp.gmail.com with UTF8SMTPSA id i11-20020a056e020d8b00b002c79690d56esm8015513ilj.10.2022.04.18.18.28.33 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Mon, 18 Apr 2022 18:28:37 -0700 (PDT) From: Schspa Shi To: brgl@bgdev.pl, andy.shevchenko@gmail.com, linus.walleij@linaro.org Cc: f.fainelli@gmail.com, fancer.lancer@gmail.com, hoan@os.amperecomputing.com, linux-arm-kernel@lists.infradead.org, linux-gpio@vger.kernel.org, linux-kernel@vger.kernel.org, opendmb@gmail.com, schspa@gmail.com Subject: [PATCH v3] gpio: use raw spinlock for gpio chip shadowed data Date: Tue, 19 Apr 2022 09:28:10 +0800 Message-Id: <20220419012810.88417-1-schspa@gmail.com> X-Mailer: git-send-email 2.24.3 (Apple Git-128) In-Reply-To: References: MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20220418_182840_773508_AEA416F1 X-CRM114-Status: GOOD ( 16.83 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org SW4gY2FzZSBvZiBQUkVFTVBUX1JULCB0aGVyZSBpcyBhIHJhd19zcGlubG9jayAtPiBzcGlubG9j ayBkZXBlbmRlbmN5CmFzIHRoZSBsb2NrZGVwIHJlcG9ydCBzaG93cy4KCl9faXJxX3NldF9oYW5k bGVyCiAgaXJxX2dldF9kZXNjX2J1c2xvY2sKICAgIF9faXJxX2dldF9kZXNjX2xvY2sKICAgICAg cmF3X3NwaW5fbG9ja19pcnFzYXZlKCZkZXNjLT5sb2NrLCAqZmxhZ3MpOyAgLy8gcmF3IHNwaW5s b2NrIGdldCBoZXJlCiAgX19pcnFfZG9fc2V0X2hhbmRsZXIKICAgIG1hc2tfYWNrX2lycQogICAg ICBkd2FwYl9pcnFfYWNrCiAgICAgICAgc3Bpbl9sb2NrX2lycXNhdmUoJmdjLT5iZ3Bpb19sb2Nr LCBmbGFncyk7IC8vIHNsZWVwIGFibGUgc3BpbmxvY2sKICBpcnFfcHV0X2Rlc2NfYnVzdW5sb2Nr CgpSZXBsYWNlIHdpdGggYSByYXcgbG9jayB0byBhdm9pZCBCVUdzLiBUaGlzIGxvY2sgaXMgb25s eSB1c2VkIHRvIGFjY2VzcwpyZWdpc3RlcnMsIGFuZCBJdCdzIHNhZmUgdG8gcmVwbGFjZSB3aXRo IHRoZSByYXcgbG9jayB3aXRob3V0IGJhZAppbmZsdWVuY2UuCgpbICAgMTUuMDkwMzU5XVsgICAg VDFdID09PT09PT09PT09PT09PT09PT09PT09PT09PT09ClsgICAxNS4wOTAzNjVdWyAgICBUMV0g WyBCVUc6IEludmFsaWQgd2FpdCBjb250ZXh0IF0KWyAgIDE1LjA5MDM3M11bICAgIFQxXSA1LjEw LjU5LXJ0NTItMDA5ODMtZzE4NmE2ODQxYzY4Mi1kaXJ0eSAjMyBOb3QgdGFpbnRlZApbICAgMTUu MDkwMzg2XVsgICAgVDFdIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tClsgICAxNS4wOTAz OTJdWyAgICBUMV0gc3dhcHBlci8wLzEgaXMgdHJ5aW5nIHRvIGxvY2s6ClsgICAxNS4wOTA0MDJd WyAgICBUMV0gNzBmZjAwMDE4NTA3YzE4OCAoJmdjLT5iZ3Bpb19sb2NrKXsuLi4ufS17MzozfSwg YXQ6IF9yYXdfc3Bpbl9sb2NrX2lycXNhdmUrMHgxYy8weDI4ClsgICAxNS4wOTA0NzBdWyAgICBU MV0gb3RoZXIgaW5mbyB0aGF0IG1pZ2h0IGhlbHAgdXMgZGVidWcgdGhpczoKWyAgIDE1LjA5MDQ3 N11bICAgIFQxXSBjb250ZXh0LXs1OjV9ClsgICAxNS4wOTA0ODVdWyAgICBUMV0gMyBsb2NrcyBo ZWxkIGJ5IHN3YXBwZXIvMC8xOgpbICAgMTUuMDkwNDk3XVsgICAgVDFdICAjMDogYzJmZjAwMDE4 MTZkZTFhMCAoJmRldi0+bXV0ZXgpey4uLi59LXs0OjR9LCBhdDogX19kZXZpY2VfZHJpdmVyX2xv Y2srMHg5OC8weDEwNApbICAgMTUuMDkwNTUzXVsgICAgVDFdICAjMTogZmZmZjkwMDAxNDg1YjRi OCAoaXJxX2RvbWFpbl9tdXRleCl7Ky4rLn0tezQ6NH0sIGF0OiBpcnFfZG9tYWluX2Fzc29jaWF0 ZSsweGJjLzB4NmQ0ClsgICAxNS4wOTA2MDZdWyAgICBUMV0gICMyOiA0YmZmMDAwMTg1ZDdhOGUw IChsb2NrX2NsYXNzKXsuLi4ufS17MjoyfSwgYXQ6IF9yYXdfc3Bpbl9sb2NrX2lycXNhdmUrMHgx Yy8weDI4ClsgICAxNS4wOTA2NTRdWyAgICBUMV0gc3RhY2sgYmFja3RyYWNlOgpbICAgMTUuMDkw NjYxXVsgICAgVDFdIENQVTogNCBQSUQ6IDEgQ29tbTogc3dhcHBlci8wIE5vdCB0YWludGVkIDUu MTAuNTktcnQ1Mi0wMDk4My1nMTg2YTY4NDFjNjgyLWRpcnR5ICMzClsgICAxNS4wOTA2ODJdWyAg ICBUMV0gSGFyZHdhcmUgbmFtZTogSG9yaXpvbiBSb2JvdGljcyBKb3VybmV5IDUgRFZCIChEVCkK WyAgIDE1LjA5MDY5Ml1bICAgIFQxXSBDYWxsIHRyYWNlOgouLi4uLi4KWyAgIDE1LjA5MDgxMV1b ICAgIFQxXSAgX3Jhd19zcGluX2xvY2tfaXJxc2F2ZSsweDFjLzB4MjgKWyAgIDE1LjA5MDgyOF1b ICAgIFQxXSAgZHdhcGJfaXJxX2FjaysweGI0LzB4MzAwClsgICAxNS4wOTA4NDZdWyAgICBUMV0g IF9faXJxX2RvX3NldF9oYW5kbGVyKzB4NDk0LzB4YjJjClsgICAxNS4wOTA4NjRdWyAgICBUMV0g IF9faXJxX3NldF9oYW5kbGVyKzB4NzQvMHgxMTQKWyAgIDE1LjA5MDg4MV1bICAgIFQxXSAgaXJx X3NldF9jaGlwX2FuZF9oYW5kbGVyX25hbWUrMHg0NC8weDU4ClsgICAxNS4wOTA5MDBdWyAgICBU MV0gIGdwaW9jaGlwX2lycV9tYXArMHgyMTAvMHg2NDQKClNpZ25lZC1vZmYtYnk6IFNjaHNwYSBT aGkgPHNjaHNwYUBnbWFpbC5jb20+CgotLS0KCkNoYW5nZWxvZzoKdjEgLT4gdjI6CiAgICAgICAg LSBSZWR1Y2UgdGhlIHVzZWxlc3Mgc3RhY2t0cmFjZS4KICAgICAgICAtIFNwbGl0IHRvIHNlcmll cyBvZiBwYXRjaGVzCnYyIC0+IHYzOgogICAgICAgIC0gUmVzdG9yZSB0byBhIHNpbmdsZSBwYXRj aCBhcyBBbmR5IGFuZCBCYXJ0b3N6J3Mgc3VnZ2VzdAogICAgICAgIC0gYWRkIGN1dHRlciDigJgt LS0g4oCYIGxpbmUgZm9yIENoYW5nZSBsb2cKLS0tCiBkcml2ZXJzL2dwaW8vZ3Bpby1hbWRwdC5j ICAgICAgICAgICAgICAgICB8IDEwICsrKy0tLS0KIGRyaXZlcnMvZ3Bpby9ncGlvLWJyY21zdGIu YyAgICAgICAgICAgICAgIHwgMTIgKysrKy0tLS0KIGRyaXZlcnMvZ3Bpby9ncGlvLWNhZGVuY2Uu YyAgICAgICAgICAgICAgIHwgMTIgKysrKy0tLS0KIGRyaXZlcnMvZ3Bpby9ncGlvLWR3YXBiLmMg ICAgICAgICAgICAgICAgIHwgMzYgKysrKysrKysrKystLS0tLS0tLS0tLS0KIGRyaXZlcnMvZ3Bp by9ncGlvLWdyZ3Bpby5jICAgICAgICAgICAgICAgIHwgMzAgKysrKysrKysrLS0tLS0tLS0tLQog ZHJpdmVycy9ncGlvL2dwaW8taGx3ZC5jICAgICAgICAgICAgICAgICAgfCAxOCArKysrKystLS0t LS0KIGRyaXZlcnMvZ3Bpby9ncGlvLWlkdDMyNDN4LmMgICAgICAgICAgICAgIHwgMTIgKysrKy0t LS0KIGRyaXZlcnMvZ3Bpby9ncGlvLWl4cDR4eC5jICAgICAgICAgICAgICAgIHwgIDQgKy0tCiBk cml2ZXJzL2dwaW8vZ3Bpby1sb29uZ3NvbjEuYyAgICAgICAgICAgICB8ICA4ICsrLS0tCiBkcml2 ZXJzL2dwaW8vZ3Bpby1tZW56MTI3LmMgICAgICAgICAgICAgICB8ICA4ICsrLS0tCiBkcml2ZXJz L2dwaW8vZ3Bpby1tbHhiZjIuYyAgICAgICAgICAgICAgICB8IDE4ICsrKysrKy0tLS0tLQogZHJp dmVycy9ncGlvL2dwaW8tbW1pby5jICAgICAgICAgICAgICAgICAgfCAyMiArKysrKysrLS0tLS0t LQogZHJpdmVycy9ncGlvL2dwaW8tc2lmaXZlLmMgICAgICAgICAgICAgICAgfCAxMiArKysrLS0t LQogZHJpdmVycy9ncGlvL2dwaW8tdGIxMHguYyAgICAgICAgICAgICAgICAgfCAgNCArLS0KIGRy aXZlcnMvcGluY3RybC9udXZvdG9uL3BpbmN0cmwtbnBjbTd4eC5jIHwgIDggKystLS0KIGluY2x1 ZGUvbGludXgvZ3Bpby9kcml2ZXIuaCAgICAgICAgICAgICAgIHwgIDIgKy0KIDE2IGZpbGVzIGNo YW5nZWQsIDEwOCBpbnNlcnRpb25zKCspLCAxMDggZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEv ZHJpdmVycy9ncGlvL2dwaW8tYW1kcHQuYyBiL2RyaXZlcnMvZ3Bpby9ncGlvLWFtZHB0LmMKaW5k ZXggOGNmYjM1M2MzYWJiLi4wN2M2ZDA5MDA1OGQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3Bpby9n cGlvLWFtZHB0LmMKKysrIGIvZHJpdmVycy9ncGlvL2dwaW8tYW1kcHQuYwpAQCAtMzYsMTkgKzM2 LDE5IEBAIHN0YXRpYyBpbnQgcHRfZ3Bpb19yZXF1ZXN0KHN0cnVjdCBncGlvX2NoaXAgKmdjLCB1 bnNpZ25lZCBvZmZzZXQpCiAKIAlkZXZfZGJnKGdjLT5wYXJlbnQsICJwdF9ncGlvX3JlcXVlc3Qg b2Zmc2V0PSV4XG4iLCBvZmZzZXQpOwogCi0Jc3Bpbl9sb2NrX2lycXNhdmUoJmdjLT5iZ3Bpb19s b2NrLCBmbGFncyk7CisJcmF3X3NwaW5fbG9ja19pcnFzYXZlKCZnYy0+YmdwaW9fbG9jaywgZmxh Z3MpOwogCiAJdXNpbmdfcGlucyA9IHJlYWRsKHB0X2dwaW8tPnJlZ19iYXNlICsgUFRfU1lOQ19S RUcpOwogCWlmICh1c2luZ19waW5zICYgQklUKG9mZnNldCkpIHsKIAkJZGV2X3dhcm4oZ2MtPnBh cmVudCwgIlBUIEdQSU8gcGluICV4IHJlY29uZmlndXJlZFxuIiwKIAkJCSBvZmZzZXQpOwotCQlz cGluX3VubG9ja19pcnFyZXN0b3JlKCZnYy0+YmdwaW9fbG9jaywgZmxhZ3MpOworCQlyYXdfc3Bp bl91bmxvY2tfaXJxcmVzdG9yZSgmZ2MtPmJncGlvX2xvY2ssIGZsYWdzKTsKIAkJcmV0dXJuIC1F SU5WQUw7CiAJfQogCiAJd3JpdGVsKHVzaW5nX3BpbnMgfCBCSVQob2Zmc2V0KSwgcHRfZ3Bpby0+ cmVnX2Jhc2UgKyBQVF9TWU5DX1JFRyk7CiAKLQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZnYy0+ YmdwaW9fbG9jaywgZmxhZ3MpOworCXJhd19zcGluX3VubG9ja19pcnFyZXN0b3JlKCZnYy0+Ymdw aW9fbG9jaywgZmxhZ3MpOwogCiAJcmV0dXJuIDA7CiB9CkBAIC01OSwxMyArNTksMTMgQEAgc3Rh dGljIHZvaWQgcHRfZ3Bpb19mcmVlKHN0cnVjdCBncGlvX2NoaXAgKmdjLCB1bnNpZ25lZCBvZmZz ZXQpCiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIAl1MzIgdXNpbmdfcGluczsKIAotCXNwaW5fbG9j a19pcnFzYXZlKCZnYy0+YmdwaW9fbG9jaywgZmxhZ3MpOworCXJhd19zcGluX2xvY2tfaXJxc2F2 ZSgmZ2MtPmJncGlvX2xvY2ssIGZsYWdzKTsKIAogCXVzaW5nX3BpbnMgPSByZWFkbChwdF9ncGlv LT5yZWdfYmFzZSArIFBUX1NZTkNfUkVHKTsKIAl1c2luZ19waW5zICY9IH5CSVQob2Zmc2V0KTsK IAl3cml0ZWwodXNpbmdfcGlucywgcHRfZ3Bpby0+cmVnX2Jhc2UgKyBQVF9TWU5DX1JFRyk7CiAK LQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZnYy0+YmdwaW9fbG9jaywgZmxhZ3MpOworCXJhd19z cGluX3VubG9ja19pcnFyZXN0b3JlKCZnYy0+YmdwaW9fbG9jaywgZmxhZ3MpOwogCiAJZGV2X2Ri ZyhnYy0+cGFyZW50LCAicHRfZ3Bpb19mcmVlIG9mZnNldD0leFxuIiwgb2Zmc2V0KTsKIH0KZGlm ZiAtLWdpdCBhL2RyaXZlcnMvZ3Bpby9ncGlvLWJyY21zdGIuYyBiL2RyaXZlcnMvZ3Bpby9ncGlv LWJyY21zdGIuYwppbmRleCA3NGVmODkyNDg4NjcuLjZiNzQzOWI0NDY5MCAxMDA2NDQKLS0tIGEv ZHJpdmVycy9ncGlvL2dwaW8tYnJjbXN0Yi5jCisrKyBiL2RyaXZlcnMvZ3Bpby9ncGlvLWJyY21z dGIuYwpAQCAtOTIsOSArOTIsOSBAQCBicmNtc3RiX2dwaW9fZ2V0X2FjdGl2ZV9pcnFzKHN0cnVj dCBicmNtc3RiX2dwaW9fYmFuayAqYmFuaykKIAl1bnNpZ25lZCBsb25nIHN0YXR1czsKIAl1bnNp Z25lZCBsb25nIGZsYWdzOwogCi0Jc3Bpbl9sb2NrX2lycXNhdmUoJmJhbmstPmdjLmJncGlvX2xv Y2ssIGZsYWdzKTsKKwlyYXdfc3Bpbl9sb2NrX2lycXNhdmUoJmJhbmstPmdjLmJncGlvX2xvY2ss IGZsYWdzKTsKIAlzdGF0dXMgPSBfX2JyY21zdGJfZ3Bpb19nZXRfYWN0aXZlX2lycXMoYmFuayk7 Ci0Jc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmYmFuay0+Z2MuYmdwaW9fbG9jaywgZmxhZ3MpOwor CXJhd19zcGluX3VubG9ja19pcnFyZXN0b3JlKCZiYW5rLT5nYy5iZ3Bpb19sb2NrLCBmbGFncyk7 CiAKIAlyZXR1cm4gc3RhdHVzOwogfQpAQCAtMTE0LDE0ICsxMTQsMTQgQEAgc3RhdGljIHZvaWQg YnJjbXN0Yl9ncGlvX3NldF9pbWFzayhzdHJ1Y3QgYnJjbXN0Yl9ncGlvX2JhbmsgKmJhbmssCiAJ dTMyIGltYXNrOwogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAKLQlzcGluX2xvY2tfaXJxc2F2ZSgm Z2MtPmJncGlvX2xvY2ssIGZsYWdzKTsKKwlyYXdfc3Bpbl9sb2NrX2lycXNhdmUoJmdjLT5iZ3Bp b19sb2NrLCBmbGFncyk7CiAJaW1hc2sgPSBnYy0+cmVhZF9yZWcocHJpdi0+cmVnX2Jhc2UgKyBH SU9fTUFTSyhiYW5rLT5pZCkpOwogCWlmIChlbmFibGUpCiAJCWltYXNrIHw9IG1hc2s7CiAJZWxz ZQogCQlpbWFzayAmPSB+bWFzazsKIAlnYy0+d3JpdGVfcmVnKHByaXYtPnJlZ19iYXNlICsgR0lP X01BU0soYmFuay0+aWQpLCBpbWFzayk7Ci0Jc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZ2MtPmJn cGlvX2xvY2ssIGZsYWdzKTsKKwlyYXdfc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZ2MtPmJncGlv X2xvY2ssIGZsYWdzKTsKIH0KIAogc3RhdGljIGludCBicmNtc3RiX2dwaW9fdG9faXJxKHN0cnVj dCBncGlvX2NoaXAgKmdjLCB1bnNpZ25lZCBvZmZzZXQpCkBAIC0yMDQsNyArMjA0LDcgQEAgc3Rh dGljIGludCBicmNtc3RiX2dwaW9faXJxX3NldF90eXBlKHN0cnVjdCBpcnFfZGF0YSAqZCwgdW5z aWduZWQgaW50IHR5cGUpCiAJCXJldHVybiAtRUlOVkFMOwogCX0KIAotCXNwaW5fbG9ja19pcnFz YXZlKCZiYW5rLT5nYy5iZ3Bpb19sb2NrLCBmbGFncyk7CisJcmF3X3NwaW5fbG9ja19pcnFzYXZl KCZiYW5rLT5nYy5iZ3Bpb19sb2NrLCBmbGFncyk7CiAKIAlpZWRnZV9jb25maWcgPSBiYW5rLT5n Yy5yZWFkX3JlZyhwcml2LT5yZWdfYmFzZSArCiAJCQlHSU9fRUMoYmFuay0+aWQpKSAmIH5tYXNr OwpAQCAtMjIwLDcgKzIyMCw3IEBAIHN0YXRpYyBpbnQgYnJjbXN0Yl9ncGlvX2lycV9zZXRfdHlw ZShzdHJ1Y3QgaXJxX2RhdGEgKmQsIHVuc2lnbmVkIGludCB0eXBlKQogCWJhbmstPmdjLndyaXRl X3JlZyhwcml2LT5yZWdfYmFzZSArIEdJT19MRVZFTChiYW5rLT5pZCksCiAJCQlpbGV2ZWwgfCBs ZXZlbCk7CiAKLQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZiYW5rLT5nYy5iZ3Bpb19sb2NrLCBm bGFncyk7CisJcmF3X3NwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmJhbmstPmdjLmJncGlvX2xvY2ss IGZsYWdzKTsKIAlyZXR1cm4gMDsKIH0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncGlvL2dwaW8t Y2FkZW5jZS5jIGIvZHJpdmVycy9ncGlvL2dwaW8tY2FkZW5jZS5jCmluZGV4IDU2MmY4ZjdlN2Qx Zi4uMTM3YWVhNDliYTAyIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwaW8vZ3Bpby1jYWRlbmNlLmMK KysrIGIvZHJpdmVycy9ncGlvL2dwaW8tY2FkZW5jZS5jCkBAIC00MSwxMiArNDEsMTIgQEAgc3Rh dGljIGludCBjZG5zX2dwaW9fcmVxdWVzdChzdHJ1Y3QgZ3Bpb19jaGlwICpjaGlwLCB1bnNpZ25l ZCBpbnQgb2Zmc2V0KQogCXN0cnVjdCBjZG5zX2dwaW9fY2hpcCAqY2dwaW8gPSBncGlvY2hpcF9n ZXRfZGF0YShjaGlwKTsKIAl1bnNpZ25lZCBsb25nIGZsYWdzOwogCi0Jc3Bpbl9sb2NrX2lycXNh dmUoJmNoaXAtPmJncGlvX2xvY2ssIGZsYWdzKTsKKwlyYXdfc3Bpbl9sb2NrX2lycXNhdmUoJmNo aXAtPmJncGlvX2xvY2ssIGZsYWdzKTsKIAogCWlvd3JpdGUzMihpb3JlYWQzMihjZ3Bpby0+cmVn cyArIENETlNfR1BJT19CWVBBU1NfTU9ERSkgJiB+QklUKG9mZnNldCksCiAJCSAgY2dwaW8tPnJl Z3MgKyBDRE5TX0dQSU9fQllQQVNTX01PREUpOwogCi0Jc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgm Y2hpcC0+YmdwaW9fbG9jaywgZmxhZ3MpOworCXJhd19zcGluX3VubG9ja19pcnFyZXN0b3JlKCZj aGlwLT5iZ3Bpb19sb2NrLCBmbGFncyk7CiAJcmV0dXJuIDA7CiB9CiAKQEAgLTU1LDEzICs1NSwx MyBAQCBzdGF0aWMgdm9pZCBjZG5zX2dwaW9fZnJlZShzdHJ1Y3QgZ3Bpb19jaGlwICpjaGlwLCB1 bnNpZ25lZCBpbnQgb2Zmc2V0KQogCXN0cnVjdCBjZG5zX2dwaW9fY2hpcCAqY2dwaW8gPSBncGlv Y2hpcF9nZXRfZGF0YShjaGlwKTsKIAl1bnNpZ25lZCBsb25nIGZsYWdzOwogCi0Jc3Bpbl9sb2Nr X2lycXNhdmUoJmNoaXAtPmJncGlvX2xvY2ssIGZsYWdzKTsKKwlyYXdfc3Bpbl9sb2NrX2lycXNh dmUoJmNoaXAtPmJncGlvX2xvY2ssIGZsYWdzKTsKIAogCWlvd3JpdGUzMihpb3JlYWQzMihjZ3Bp by0+cmVncyArIENETlNfR1BJT19CWVBBU1NfTU9ERSkgfAogCQkgIChCSVQob2Zmc2V0KSAmIGNn cGlvLT5ieXBhc3Nfb3JpZyksCiAJCSAgY2dwaW8tPnJlZ3MgKyBDRE5TX0dQSU9fQllQQVNTX01P REUpOwogCi0Jc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmY2hpcC0+YmdwaW9fbG9jaywgZmxhZ3Mp OworCXJhd19zcGluX3VubG9ja19pcnFyZXN0b3JlKCZjaGlwLT5iZ3Bpb19sb2NrLCBmbGFncyk7 CiB9CiAKIHN0YXRpYyB2b2lkIGNkbnNfZ3Bpb19pcnFfbWFzayhzdHJ1Y3QgaXJxX2RhdGEgKmQp CkBAIC05MCw3ICs5MCw3IEBAIHN0YXRpYyBpbnQgY2Ruc19ncGlvX2lycV9zZXRfdHlwZShzdHJ1 Y3QgaXJxX2RhdGEgKmQsIHVuc2lnbmVkIGludCB0eXBlKQogCXUzMiBtYXNrID0gQklUKGQtPmh3 aXJxKTsKIAlpbnQgcmV0ID0gMDsKIAotCXNwaW5fbG9ja19pcnFzYXZlKCZjaGlwLT5iZ3Bpb19s b2NrLCBmbGFncyk7CisJcmF3X3NwaW5fbG9ja19pcnFzYXZlKCZjaGlwLT5iZ3Bpb19sb2NrLCBm bGFncyk7CiAKIAlpbnRfdmFsdWUgPSBpb3JlYWQzMihjZ3Bpby0+cmVncyArIENETlNfR1BJT19J UlFfVkFMVUUpICYgfm1hc2s7CiAJaW50X3R5cGUgPSBpb3JlYWQzMihjZ3Bpby0+cmVncyArIENE TlNfR1BJT19JUlFfVFlQRSkgJiB+bWFzazsKQEAgLTExNSw3ICsxMTUsNyBAQCBzdGF0aWMgaW50 IGNkbnNfZ3Bpb19pcnFfc2V0X3R5cGUoc3RydWN0IGlycV9kYXRhICpkLCB1bnNpZ25lZCBpbnQg dHlwZSkKIAlpb3dyaXRlMzIoaW50X3R5cGUsIGNncGlvLT5yZWdzICsgQ0ROU19HUElPX0lSUV9U WVBFKTsKIAogZXJyX2lycV90eXBlOgotCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmNoaXAtPmJn cGlvX2xvY2ssIGZsYWdzKTsKKwlyYXdfc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmY2hpcC0+Ymdw aW9fbG9jaywgZmxhZ3MpOwogCXJldHVybiByZXQ7CiB9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMv Z3Bpby9ncGlvLWR3YXBiLmMgYi9kcml2ZXJzL2dwaW8vZ3Bpby1kd2FwYi5jCmluZGV4IGIwZjNh Y2E2MTk3NC4uNzEzMDE5NWRhNDhkIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwaW8vZ3Bpby1kd2Fw Yi5jCisrKyBiL2RyaXZlcnMvZ3Bpby9ncGlvLWR3YXBiLmMKQEAgLTI0Myw5ICsyNDMsOSBAQCBz dGF0aWMgdm9pZCBkd2FwYl9pcnFfYWNrKHN0cnVjdCBpcnFfZGF0YSAqZCkKIAl1MzIgdmFsID0g QklUKGlycWRfdG9faHdpcnEoZCkpOwogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAKLQlzcGluX2xv Y2tfaXJxc2F2ZSgmZ2MtPmJncGlvX2xvY2ssIGZsYWdzKTsKKwlyYXdfc3Bpbl9sb2NrX2lycXNh dmUoJmdjLT5iZ3Bpb19sb2NrLCBmbGFncyk7CiAJZHdhcGJfd3JpdGUoZ3BpbywgR1BJT19QT1JU QV9FT0ksIHZhbCk7Ci0Jc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZ2MtPmJncGlvX2xvY2ssIGZs YWdzKTsKKwlyYXdfc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZ2MtPmJncGlvX2xvY2ssIGZsYWdz KTsKIH0KIAogc3RhdGljIHZvaWQgZHdhcGJfaXJxX21hc2soc3RydWN0IGlycV9kYXRhICpkKQpA QCAtMjU1LDEwICsyNTUsMTAgQEAgc3RhdGljIHZvaWQgZHdhcGJfaXJxX21hc2soc3RydWN0IGly cV9kYXRhICpkKQogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAJdTMyIHZhbDsKIAotCXNwaW5fbG9j a19pcnFzYXZlKCZnYy0+YmdwaW9fbG9jaywgZmxhZ3MpOworCXJhd19zcGluX2xvY2tfaXJxc2F2 ZSgmZ2MtPmJncGlvX2xvY2ssIGZsYWdzKTsKIAl2YWwgPSBkd2FwYl9yZWFkKGdwaW8sIEdQSU9f SU5UTUFTSykgfCBCSVQoaXJxZF90b19od2lycShkKSk7CiAJZHdhcGJfd3JpdGUoZ3BpbywgR1BJ T19JTlRNQVNLLCB2YWwpOwotCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmdjLT5iZ3Bpb19sb2Nr LCBmbGFncyk7CisJcmF3X3NwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmdjLT5iZ3Bpb19sb2NrLCBm bGFncyk7CiB9CiAKIHN0YXRpYyB2b2lkIGR3YXBiX2lycV91bm1hc2soc3RydWN0IGlycV9kYXRh ICpkKQpAQCAtMjY4LDEwICsyNjgsMTAgQEAgc3RhdGljIHZvaWQgZHdhcGJfaXJxX3VubWFzayhz dHJ1Y3QgaXJxX2RhdGEgKmQpCiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIAl1MzIgdmFsOwogCi0J c3Bpbl9sb2NrX2lycXNhdmUoJmdjLT5iZ3Bpb19sb2NrLCBmbGFncyk7CisJcmF3X3NwaW5fbG9j a19pcnFzYXZlKCZnYy0+YmdwaW9fbG9jaywgZmxhZ3MpOwogCXZhbCA9IGR3YXBiX3JlYWQoZ3Bp bywgR1BJT19JTlRNQVNLKSAmIH5CSVQoaXJxZF90b19od2lycShkKSk7CiAJZHdhcGJfd3JpdGUo Z3BpbywgR1BJT19JTlRNQVNLLCB2YWwpOwotCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmdjLT5i Z3Bpb19sb2NrLCBmbGFncyk7CisJcmF3X3NwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmdjLT5iZ3Bp b19sb2NrLCBmbGFncyk7CiB9CiAKIHN0YXRpYyB2b2lkIGR3YXBiX2lycV9lbmFibGUoc3RydWN0 IGlycV9kYXRhICpkKQpAQCAtMjgxLDExICsyODEsMTEgQEAgc3RhdGljIHZvaWQgZHdhcGJfaXJx X2VuYWJsZShzdHJ1Y3QgaXJxX2RhdGEgKmQpCiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIAl1MzIg dmFsOwogCi0Jc3Bpbl9sb2NrX2lycXNhdmUoJmdjLT5iZ3Bpb19sb2NrLCBmbGFncyk7CisJcmF3 X3NwaW5fbG9ja19pcnFzYXZlKCZnYy0+YmdwaW9fbG9jaywgZmxhZ3MpOwogCXZhbCA9IGR3YXBi X3JlYWQoZ3BpbywgR1BJT19JTlRFTik7CiAJdmFsIHw9IEJJVChpcnFkX3RvX2h3aXJxKGQpKTsK IAlkd2FwYl93cml0ZShncGlvLCBHUElPX0lOVEVOLCB2YWwpOwotCXNwaW5fdW5sb2NrX2lycXJl c3RvcmUoJmdjLT5iZ3Bpb19sb2NrLCBmbGFncyk7CisJcmF3X3NwaW5fdW5sb2NrX2lycXJlc3Rv cmUoJmdjLT5iZ3Bpb19sb2NrLCBmbGFncyk7CiB9CiAKIHN0YXRpYyB2b2lkIGR3YXBiX2lycV9k aXNhYmxlKHN0cnVjdCBpcnFfZGF0YSAqZCkKQEAgLTI5NSwxMSArMjk1LDExIEBAIHN0YXRpYyB2 b2lkIGR3YXBiX2lycV9kaXNhYmxlKHN0cnVjdCBpcnFfZGF0YSAqZCkKIAl1bnNpZ25lZCBsb25n IGZsYWdzOwogCXUzMiB2YWw7CiAKLQlzcGluX2xvY2tfaXJxc2F2ZSgmZ2MtPmJncGlvX2xvY2ss IGZsYWdzKTsKKwlyYXdfc3Bpbl9sb2NrX2lycXNhdmUoJmdjLT5iZ3Bpb19sb2NrLCBmbGFncyk7 CiAJdmFsID0gZHdhcGJfcmVhZChncGlvLCBHUElPX0lOVEVOKTsKIAl2YWwgJj0gfkJJVChpcnFk X3RvX2h3aXJxKGQpKTsKIAlkd2FwYl93cml0ZShncGlvLCBHUElPX0lOVEVOLCB2YWwpOwotCXNw aW5fdW5sb2NrX2lycXJlc3RvcmUoJmdjLT5iZ3Bpb19sb2NrLCBmbGFncyk7CisJcmF3X3NwaW5f dW5sb2NrX2lycXJlc3RvcmUoJmdjLT5iZ3Bpb19sb2NrLCBmbGFncyk7CiB9CiAKIHN0YXRpYyBp bnQgZHdhcGJfaXJxX3NldF90eXBlKHN0cnVjdCBpcnFfZGF0YSAqZCwgdTMyIHR5cGUpCkBAIC0z MDksNyArMzA5LDcgQEAgc3RhdGljIGludCBkd2FwYl9pcnFfc2V0X3R5cGUoc3RydWN0IGlycV9k YXRhICpkLCB1MzIgdHlwZSkKIAlpcnFfaHdfbnVtYmVyX3QgYml0ID0gaXJxZF90b19od2lycShk KTsKIAl1bnNpZ25lZCBsb25nIGxldmVsLCBwb2xhcml0eSwgZmxhZ3M7CiAKLQlzcGluX2xvY2tf aXJxc2F2ZSgmZ2MtPmJncGlvX2xvY2ssIGZsYWdzKTsKKwlyYXdfc3Bpbl9sb2NrX2lycXNhdmUo JmdjLT5iZ3Bpb19sb2NrLCBmbGFncyk7CiAJbGV2ZWwgPSBkd2FwYl9yZWFkKGdwaW8sIEdQSU9f SU5UVFlQRV9MRVZFTCk7CiAJcG9sYXJpdHkgPSBkd2FwYl9yZWFkKGdwaW8sIEdQSU9fSU5UX1BP TEFSSVRZKTsKIApAQCAtMzQ0LDcgKzM0NCw3IEBAIHN0YXRpYyBpbnQgZHdhcGJfaXJxX3NldF90 eXBlKHN0cnVjdCBpcnFfZGF0YSAqZCwgdTMyIHR5cGUpCiAJZHdhcGJfd3JpdGUoZ3BpbywgR1BJ T19JTlRUWVBFX0xFVkVMLCBsZXZlbCk7CiAJaWYgKHR5cGUgIT0gSVJRX1RZUEVfRURHRV9CT1RI KQogCQlkd2FwYl93cml0ZShncGlvLCBHUElPX0lOVF9QT0xBUklUWSwgcG9sYXJpdHkpOwotCXNw aW5fdW5sb2NrX2lycXJlc3RvcmUoJmdjLT5iZ3Bpb19sb2NrLCBmbGFncyk7CisJcmF3X3NwaW5f dW5sb2NrX2lycXJlc3RvcmUoJmdjLT5iZ3Bpb19sb2NrLCBmbGFncyk7CiAKIAlyZXR1cm4gMDsK IH0KQEAgLTM3NCw3ICszNzQsNyBAQCBzdGF0aWMgaW50IGR3YXBiX2dwaW9fc2V0X2RlYm91bmNl KHN0cnVjdCBncGlvX2NoaXAgKmdjLAogCXVuc2lnbmVkIGxvbmcgZmxhZ3MsIHZhbF9kZWI7CiAJ dW5zaWduZWQgbG9uZyBtYXNrID0gQklUKG9mZnNldCk7CiAKLQlzcGluX2xvY2tfaXJxc2F2ZSgm Z2MtPmJncGlvX2xvY2ssIGZsYWdzKTsKKwlyYXdfc3Bpbl9sb2NrX2lycXNhdmUoJmdjLT5iZ3Bp b19sb2NrLCBmbGFncyk7CiAKIAl2YWxfZGViID0gZHdhcGJfcmVhZChncGlvLCBHUElPX1BPUlRB X0RFQk9VTkNFKTsKIAlpZiAoZGVib3VuY2UpCkBAIC0zODMsNyArMzgzLDcgQEAgc3RhdGljIGlu dCBkd2FwYl9ncGlvX3NldF9kZWJvdW5jZShzdHJ1Y3QgZ3Bpb19jaGlwICpnYywKIAkJdmFsX2Rl YiAmPSB+bWFzazsKIAlkd2FwYl93cml0ZShncGlvLCBHUElPX1BPUlRBX0RFQk9VTkNFLCB2YWxf ZGViKTsKIAotCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmdjLT5iZ3Bpb19sb2NrLCBmbGFncyk7 CisJcmF3X3NwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmdjLT5iZ3Bpb19sb2NrLCBmbGFncyk7CiAK IAlyZXR1cm4gMDsKIH0KQEAgLTczOCw3ICs3MzgsNyBAQCBzdGF0aWMgaW50IGR3YXBiX2dwaW9f c3VzcGVuZChzdHJ1Y3QgZGV2aWNlICpkZXYpCiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIAlpbnQg aTsKIAotCXNwaW5fbG9ja19pcnFzYXZlKCZnYy0+YmdwaW9fbG9jaywgZmxhZ3MpOworCXJhd19z cGluX2xvY2tfaXJxc2F2ZSgmZ2MtPmJncGlvX2xvY2ssIGZsYWdzKTsKIAlmb3IgKGkgPSAwOyBp IDwgZ3Bpby0+bnJfcG9ydHM7IGkrKykgewogCQl1bnNpZ25lZCBpbnQgb2Zmc2V0OwogCQl1bnNp Z25lZCBpbnQgaWR4ID0gZ3Bpby0+cG9ydHNbaV0uaWR4OwpAQCAtNzY1LDcgKzc2NSw3IEBAIHN0 YXRpYyBpbnQgZHdhcGJfZ3Bpb19zdXNwZW5kKHN0cnVjdCBkZXZpY2UgKmRldikKIAkJCWR3YXBi X3dyaXRlKGdwaW8sIEdQSU9fSU5UTUFTSywgfmN0eC0+d2FrZV9lbik7CiAJCX0KIAl9Ci0Jc3Bp bl91bmxvY2tfaXJxcmVzdG9yZSgmZ2MtPmJncGlvX2xvY2ssIGZsYWdzKTsKKwlyYXdfc3Bpbl91 bmxvY2tfaXJxcmVzdG9yZSgmZ2MtPmJncGlvX2xvY2ssIGZsYWdzKTsKIAogCWNsa19idWxrX2Rp c2FibGVfdW5wcmVwYXJlKERXQVBCX05SX0NMT0NLUywgZ3Bpby0+Y2xrcyk7CiAKQEAgLTc4NSw3 ICs3ODUsNyBAQCBzdGF0aWMgaW50IGR3YXBiX2dwaW9fcmVzdW1lKHN0cnVjdCBkZXZpY2UgKmRl dikKIAkJcmV0dXJuIGVycjsKIAl9CiAKLQlzcGluX2xvY2tfaXJxc2F2ZSgmZ2MtPmJncGlvX2xv Y2ssIGZsYWdzKTsKKwlyYXdfc3Bpbl9sb2NrX2lycXNhdmUoJmdjLT5iZ3Bpb19sb2NrLCBmbGFn cyk7CiAJZm9yIChpID0gMDsgaSA8IGdwaW8tPm5yX3BvcnRzOyBpKyspIHsKIAkJdW5zaWduZWQg aW50IG9mZnNldDsKIAkJdW5zaWduZWQgaW50IGlkeCA9IGdwaW8tPnBvcnRzW2ldLmlkeDsKQEAg LTgxMiw3ICs4MTIsNyBAQCBzdGF0aWMgaW50IGR3YXBiX2dwaW9fcmVzdW1lKHN0cnVjdCBkZXZp Y2UgKmRldikKIAkJCWR3YXBiX3dyaXRlKGdwaW8sIEdQSU9fUE9SVEFfRU9JLCAweGZmZmZmZmZm KTsKIAkJfQogCX0KLQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZnYy0+YmdwaW9fbG9jaywgZmxh Z3MpOworCXJhd19zcGluX3VubG9ja19pcnFyZXN0b3JlKCZnYy0+YmdwaW9fbG9jaywgZmxhZ3Mp OwogCiAJcmV0dXJuIDA7CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwaW8vZ3Bpby1ncmdwaW8u YyBiL2RyaXZlcnMvZ3Bpby9ncGlvLWdyZ3Bpby5jCmluZGV4IDIzZDQ0N2UxN2E2Ny4uZGY1NjM2 MTZmOTQzIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwaW8vZ3Bpby1ncmdwaW8uYworKysgYi9kcml2 ZXJzL2dwaW8vZ3Bpby1ncmdwaW8uYwpAQCAtMTQ1LDcgKzE0NSw3IEBAIHN0YXRpYyBpbnQgZ3Jn cGlvX2lycV9zZXRfdHlwZShzdHJ1Y3QgaXJxX2RhdGEgKmQsIHVuc2lnbmVkIGludCB0eXBlKQog CQlyZXR1cm4gLUVJTlZBTDsKIAl9CiAKLQlzcGluX2xvY2tfaXJxc2F2ZSgmcHJpdi0+Z2MuYmdw aW9fbG9jaywgZmxhZ3MpOworCXJhd19zcGluX2xvY2tfaXJxc2F2ZSgmcHJpdi0+Z2MuYmdwaW9f bG9jaywgZmxhZ3MpOwogCiAJaXBvbCA9IHByaXYtPmdjLnJlYWRfcmVnKHByaXYtPnJlZ3MgKyBH UkdQSU9fSVBPTCkgJiB+bWFzazsKIAlpZWRnZSA9IHByaXYtPmdjLnJlYWRfcmVnKHByaXYtPnJl Z3MgKyBHUkdQSU9fSUVER0UpICYgfm1hc2s7CkBAIC0xNTMsNyArMTUzLDcgQEAgc3RhdGljIGlu dCBncmdwaW9faXJxX3NldF90eXBlKHN0cnVjdCBpcnFfZGF0YSAqZCwgdW5zaWduZWQgaW50IHR5 cGUpCiAJcHJpdi0+Z2Mud3JpdGVfcmVnKHByaXYtPnJlZ3MgKyBHUkdQSU9fSVBPTCwgaXBvbCB8 IHBvbCk7CiAJcHJpdi0+Z2Mud3JpdGVfcmVnKHByaXYtPnJlZ3MgKyBHUkdQSU9fSUVER0UsIGll ZGdlIHwgZWRnZSk7CiAKLQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwcml2LT5nYy5iZ3Bpb19s b2NrLCBmbGFncyk7CisJcmF3X3NwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnByaXYtPmdjLmJncGlv X2xvY2ssIGZsYWdzKTsKIAogCXJldHVybiAwOwogfQpAQCAtMTY0LDExICsxNjQsMTEgQEAgc3Rh dGljIHZvaWQgZ3JncGlvX2lycV9tYXNrKHN0cnVjdCBpcnFfZGF0YSAqZCkKIAlpbnQgb2Zmc2V0 ID0gZC0+aHdpcnE7CiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIAotCXNwaW5fbG9ja19pcnFzYXZl KCZwcml2LT5nYy5iZ3Bpb19sb2NrLCBmbGFncyk7CisJcmF3X3NwaW5fbG9ja19pcnFzYXZlKCZw cml2LT5nYy5iZ3Bpb19sb2NrLCBmbGFncyk7CiAKIAlncmdwaW9fc2V0X2ltYXNrKHByaXYsIG9m ZnNldCwgMCk7CiAKLQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwcml2LT5nYy5iZ3Bpb19sb2Nr LCBmbGFncyk7CisJcmF3X3NwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnByaXYtPmdjLmJncGlvX2xv Y2ssIGZsYWdzKTsKIH0KIAogc3RhdGljIHZvaWQgZ3JncGlvX2lycV91bm1hc2soc3RydWN0IGly cV9kYXRhICpkKQpAQCAtMTc3LDExICsxNzcsMTEgQEAgc3RhdGljIHZvaWQgZ3JncGlvX2lycV91 bm1hc2soc3RydWN0IGlycV9kYXRhICpkKQogCWludCBvZmZzZXQgPSBkLT5od2lycTsKIAl1bnNp Z25lZCBsb25nIGZsYWdzOwogCi0Jc3Bpbl9sb2NrX2lycXNhdmUoJnByaXYtPmdjLmJncGlvX2xv Y2ssIGZsYWdzKTsKKwlyYXdfc3Bpbl9sb2NrX2lycXNhdmUoJnByaXYtPmdjLmJncGlvX2xvY2ss IGZsYWdzKTsKIAogCWdyZ3Bpb19zZXRfaW1hc2socHJpdiwgb2Zmc2V0LCAxKTsKIAotCXNwaW5f dW5sb2NrX2lycXJlc3RvcmUoJnByaXYtPmdjLmJncGlvX2xvY2ssIGZsYWdzKTsKKwlyYXdfc3Bp bl91bmxvY2tfaXJxcmVzdG9yZSgmcHJpdi0+Z2MuYmdwaW9fbG9jaywgZmxhZ3MpOwogfQogCiBz dGF0aWMgc3RydWN0IGlycV9jaGlwIGdyZ3Bpb19pcnFfY2hpcCA9IHsKQEAgLTE5OSw3ICsxOTks NyBAQCBzdGF0aWMgaXJxcmV0dXJuX3QgZ3JncGlvX2lycV9oYW5kbGVyKGludCBpcnEsIHZvaWQg KmRldikKIAlpbnQgaTsKIAlpbnQgbWF0Y2ggPSAwOwogCi0Jc3Bpbl9sb2NrX2lycXNhdmUoJnBy aXYtPmdjLmJncGlvX2xvY2ssIGZsYWdzKTsKKwlyYXdfc3Bpbl9sb2NrX2lycXNhdmUoJnByaXYt PmdjLmJncGlvX2xvY2ssIGZsYWdzKTsKIAogCS8qCiAJICogRm9yIGVhY2ggZ3BpbyBsaW5lLCBj YWxsIGl0cyBpbnRlcnJ1cHQgaGFuZGxlciBpZiBpdCBpdHMgdW5kZXJseWluZwpAQCAtMjE1LDcg KzIxNSw3IEBAIHN0YXRpYyBpcnFyZXR1cm5fdCBncmdwaW9faXJxX2hhbmRsZXIoaW50IGlycSwg dm9pZCAqZGV2KQogCQl9CiAJfQogCi0Jc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcHJpdi0+Z2Mu YmdwaW9fbG9jaywgZmxhZ3MpOworCXJhd19zcGluX3VubG9ja19pcnFyZXN0b3JlKCZwcml2LT5n Yy5iZ3Bpb19sb2NrLCBmbGFncyk7CiAKIAlpZiAoIW1hdGNoKQogCQlkZXZfd2Fybihwcml2LT5k ZXYsICJObyBncGlvIGxpbmUgbWF0Y2hlZCBpcnEgJWRcbiIsIGlycSk7CkBAIC0yNDcsMTMgKzI0 NywxMyBAQCBzdGF0aWMgaW50IGdyZ3Bpb19pcnFfbWFwKHN0cnVjdCBpcnFfZG9tYWluICpkLCB1 bnNpZ25lZCBpbnQgaXJxLAogCWRldl9kYmcocHJpdi0+ZGV2LCAiTWFwcGluZyBpcnEgJWQgZm9y IGdwaW8gbGluZSAlZFxuIiwKIAkJaXJxLCBvZmZzZXQpOwogCi0Jc3Bpbl9sb2NrX2lycXNhdmUo JnByaXYtPmdjLmJncGlvX2xvY2ssIGZsYWdzKTsKKwlyYXdfc3Bpbl9sb2NrX2lycXNhdmUoJnBy aXYtPmdjLmJncGlvX2xvY2ssIGZsYWdzKTsKIAogCS8qIFJlcXVlc3QgdW5kZXJseWluZyBpcnEg aWYgbm90IGFscmVhZHkgcmVxdWVzdGVkICovCiAJbGlycS0+aXJxID0gaXJxOwogCXVpcnEgPSAm cHJpdi0+dWlycXNbbGlycS0+aW5kZXhdOwogCWlmICh1aXJxLT5yZWZjbnQgPT0gMCkgewotCQlz cGluX3VubG9ja19pcnFyZXN0b3JlKCZwcml2LT5nYy5iZ3Bpb19sb2NrLCBmbGFncyk7CisJCXJh d19zcGluX3VubG9ja19pcnFyZXN0b3JlKCZwcml2LT5nYy5iZ3Bpb19sb2NrLCBmbGFncyk7CiAJ CXJldCA9IHJlcXVlc3RfaXJxKHVpcnEtPnVpcnEsIGdyZ3Bpb19pcnFfaGFuZGxlciwgMCwKIAkJ CQkgIGRldl9uYW1lKHByaXYtPmRldiksIHByaXYpOwogCQlpZiAocmV0KSB7CkBAIC0yNjIsMTEg KzI2MiwxMSBAQCBzdGF0aWMgaW50IGdyZ3Bpb19pcnFfbWFwKHN0cnVjdCBpcnFfZG9tYWluICpk LCB1bnNpZ25lZCBpbnQgaXJxLAogCQkJCXVpcnEtPnVpcnEpOwogCQkJcmV0dXJuIHJldDsKIAkJ fQotCQlzcGluX2xvY2tfaXJxc2F2ZSgmcHJpdi0+Z2MuYmdwaW9fbG9jaywgZmxhZ3MpOworCQly YXdfc3Bpbl9sb2NrX2lycXNhdmUoJnByaXYtPmdjLmJncGlvX2xvY2ssIGZsYWdzKTsKIAl9CiAJ dWlycS0+cmVmY250Kys7CiAKLQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwcml2LT5nYy5iZ3Bp b19sb2NrLCBmbGFncyk7CisJcmF3X3NwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnByaXYtPmdjLmJn cGlvX2xvY2ssIGZsYWdzKTsKIAogCS8qIFNldHVwIGlycSAgKi8KIAlpcnFfc2V0X2NoaXBfZGF0 YShpcnEsIHByaXYpOwpAQCAtMjkwLDcgKzI5MCw3IEBAIHN0YXRpYyB2b2lkIGdyZ3Bpb19pcnFf dW5tYXAoc3RydWN0IGlycV9kb21haW4gKmQsIHVuc2lnbmVkIGludCBpcnEpCiAJaXJxX3NldF9j aGlwX2FuZF9oYW5kbGVyKGlycSwgTlVMTCwgTlVMTCk7CiAJaXJxX3NldF9jaGlwX2RhdGEoaXJx LCBOVUxMKTsKIAotCXNwaW5fbG9ja19pcnFzYXZlKCZwcml2LT5nYy5iZ3Bpb19sb2NrLCBmbGFn cyk7CisJcmF3X3NwaW5fbG9ja19pcnFzYXZlKCZwcml2LT5nYy5iZ3Bpb19sb2NrLCBmbGFncyk7 CiAKIAkvKiBGcmVlIHVuZGVybHlpbmcgaXJxIGlmIGxhc3QgdXNlciB1bm1hcHBlZCAqLwogCWlu ZGV4ID0gLTE7CkBAIC0zMDksMTMgKzMwOSwxMyBAQCBzdGF0aWMgdm9pZCBncmdwaW9faXJxX3Vu bWFwKHN0cnVjdCBpcnFfZG9tYWluICpkLCB1bnNpZ25lZCBpbnQgaXJxKQogCQl1aXJxID0gJnBy aXYtPnVpcnFzW2xpcnEtPmluZGV4XTsKIAkJdWlycS0+cmVmY250LS07CiAJCWlmICh1aXJxLT5y ZWZjbnQgPT0gMCkgewotCQkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcHJpdi0+Z2MuYmdwaW9f bG9jaywgZmxhZ3MpOworCQkJcmF3X3NwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnByaXYtPmdjLmJn cGlvX2xvY2ssIGZsYWdzKTsKIAkJCWZyZWVfaXJxKHVpcnEtPnVpcnEsIHByaXYpOwogCQkJcmV0 dXJuOwogCQl9CiAJfQogCi0Jc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcHJpdi0+Z2MuYmdwaW9f bG9jaywgZmxhZ3MpOworCXJhd19zcGluX3VubG9ja19pcnFyZXN0b3JlKCZwcml2LT5nYy5iZ3Bp b19sb2NrLCBmbGFncyk7CiB9CiAKIHN0YXRpYyBjb25zdCBzdHJ1Y3QgaXJxX2RvbWFpbl9vcHMg Z3JncGlvX2lycV9kb21haW5fb3BzID0gewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncGlvL2dwaW8t aGx3ZC5jIGIvZHJpdmVycy9ncGlvL2dwaW8taGx3ZC5jCmluZGV4IDY0MTcxOWE5NmExYS4uNGUx M2U5MzdmODMyIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwaW8vZ3Bpby1obHdkLmMKKysrIGIvZHJp dmVycy9ncGlvL2dwaW8taGx3ZC5jCkBAIC02NSw3ICs2NSw3IEBAIHN0YXRpYyB2b2lkIGhsd2Rf Z3Bpb19pcnFoYW5kbGVyKHN0cnVjdCBpcnFfZGVzYyAqZGVzYykKIAlpbnQgaHdpcnE7CiAJdTMy IGVtdWxhdGVkX3BlbmRpbmc7CiAKLQlzcGluX2xvY2tfaXJxc2F2ZSgmaGx3ZC0+Z3Bpb2MuYmdw aW9fbG9jaywgZmxhZ3MpOworCXJhd19zcGluX2xvY2tfaXJxc2F2ZSgmaGx3ZC0+Z3Bpb2MuYmdw aW9fbG9jaywgZmxhZ3MpOwogCXBlbmRpbmcgPSBpb3JlYWQzMmJlKGhsd2QtPnJlZ3MgKyBIV19H UElPQl9JTlRGTEFHKTsKIAlwZW5kaW5nICY9IGlvcmVhZDMyYmUoaGx3ZC0+cmVncyArIEhXX0dQ SU9CX0lOVE1BU0spOwogCkBAIC05Myw3ICs5Myw3IEBAIHN0YXRpYyB2b2lkIGhsd2RfZ3Bpb19p cnFoYW5kbGVyKHN0cnVjdCBpcnFfZGVzYyAqZGVzYykKIAkJLyogTWFyayBlbXVsYXRlZCBpbnRl cnJ1cHRzIGFzIHBlbmRpbmcgKi8KIAkJcGVuZGluZyB8PSByaXNpbmcgfCBmYWxsaW5nOwogCX0K LQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZobHdkLT5ncGlvYy5iZ3Bpb19sb2NrLCBmbGFncyk7 CisJcmF3X3NwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmhsd2QtPmdwaW9jLmJncGlvX2xvY2ssIGZs YWdzKTsKIAogCWNoYWluZWRfaXJxX2VudGVyKGNoaXAsIGRlc2MpOwogCkBAIC0xMTgsMTEgKzEx OCwxMSBAQCBzdGF0aWMgdm9pZCBobHdkX2dwaW9faXJxX21hc2soc3RydWN0IGlycV9kYXRhICpk YXRhKQogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAJdTMyIG1hc2s7CiAKLQlzcGluX2xvY2tfaXJx c2F2ZSgmaGx3ZC0+Z3Bpb2MuYmdwaW9fbG9jaywgZmxhZ3MpOworCXJhd19zcGluX2xvY2tfaXJx c2F2ZSgmaGx3ZC0+Z3Bpb2MuYmdwaW9fbG9jaywgZmxhZ3MpOwogCW1hc2sgPSBpb3JlYWQzMmJl KGhsd2QtPnJlZ3MgKyBIV19HUElPQl9JTlRNQVNLKTsKIAltYXNrICY9IH5CSVQoZGF0YS0+aHdp cnEpOwogCWlvd3JpdGUzMmJlKG1hc2ssIGhsd2QtPnJlZ3MgKyBIV19HUElPQl9JTlRNQVNLKTsK LQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZobHdkLT5ncGlvYy5iZ3Bpb19sb2NrLCBmbGFncyk7 CisJcmF3X3NwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmhsd2QtPmdwaW9jLmJncGlvX2xvY2ssIGZs YWdzKTsKIH0KIAogc3RhdGljIHZvaWQgaGx3ZF9ncGlvX2lycV91bm1hc2soc3RydWN0IGlycV9k YXRhICpkYXRhKQpAQCAtMTMyLDExICsxMzIsMTEgQEAgc3RhdGljIHZvaWQgaGx3ZF9ncGlvX2ly cV91bm1hc2soc3RydWN0IGlycV9kYXRhICpkYXRhKQogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAJ dTMyIG1hc2s7CiAKLQlzcGluX2xvY2tfaXJxc2F2ZSgmaGx3ZC0+Z3Bpb2MuYmdwaW9fbG9jaywg ZmxhZ3MpOworCXJhd19zcGluX2xvY2tfaXJxc2F2ZSgmaGx3ZC0+Z3Bpb2MuYmdwaW9fbG9jaywg ZmxhZ3MpOwogCW1hc2sgPSBpb3JlYWQzMmJlKGhsd2QtPnJlZ3MgKyBIV19HUElPQl9JTlRNQVNL KTsKIAltYXNrIHw9IEJJVChkYXRhLT5od2lycSk7CiAJaW93cml0ZTMyYmUobWFzaywgaGx3ZC0+ cmVncyArIEhXX0dQSU9CX0lOVE1BU0spOwotCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmhsd2Qt PmdwaW9jLmJncGlvX2xvY2ssIGZsYWdzKTsKKwlyYXdfc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgm aGx3ZC0+Z3Bpb2MuYmdwaW9fbG9jaywgZmxhZ3MpOwogfQogCiBzdGF0aWMgdm9pZCBobHdkX2dw aW9faXJxX2VuYWJsZShzdHJ1Y3QgaXJxX2RhdGEgKmRhdGEpCkBAIC0xNzMsNyArMTczLDcgQEAg c3RhdGljIGludCBobHdkX2dwaW9faXJxX3NldF90eXBlKHN0cnVjdCBpcnFfZGF0YSAqZGF0YSwg dW5zaWduZWQgaW50IGZsb3dfdHlwZSkKIAl1bnNpZ25lZCBsb25nIGZsYWdzOwogCXUzMiBsZXZl bDsKIAotCXNwaW5fbG9ja19pcnFzYXZlKCZobHdkLT5ncGlvYy5iZ3Bpb19sb2NrLCBmbGFncyk7 CisJcmF3X3NwaW5fbG9ja19pcnFzYXZlKCZobHdkLT5ncGlvYy5iZ3Bpb19sb2NrLCBmbGFncyk7 CiAKIAlobHdkLT5lZGdlX2VtdWxhdGlvbiAmPSB+QklUKGRhdGEtPmh3aXJxKTsKIApAQCAtMTk0 LDExICsxOTQsMTEgQEAgc3RhdGljIGludCBobHdkX2dwaW9faXJxX3NldF90eXBlKHN0cnVjdCBp cnFfZGF0YSAqZGF0YSwgdW5zaWduZWQgaW50IGZsb3dfdHlwZSkKIAkJaGx3ZF9ncGlvX2lycV9z ZXR1cF9lbXVsYXRpb24oaGx3ZCwgZGF0YS0+aHdpcnEsIGZsb3dfdHlwZSk7CiAJCWJyZWFrOwog CWRlZmF1bHQ6Ci0JCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmhsd2QtPmdwaW9jLmJncGlvX2xv Y2ssIGZsYWdzKTsKKwkJcmF3X3NwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmhsd2QtPmdwaW9jLmJn cGlvX2xvY2ssIGZsYWdzKTsKIAkJcmV0dXJuIC1FSU5WQUw7CiAJfQogCi0Jc3Bpbl91bmxvY2tf aXJxcmVzdG9yZSgmaGx3ZC0+Z3Bpb2MuYmdwaW9fbG9jaywgZmxhZ3MpOworCXJhd19zcGluX3Vu bG9ja19pcnFyZXN0b3JlKCZobHdkLT5ncGlvYy5iZ3Bpb19sb2NrLCBmbGFncyk7CiAJcmV0dXJu IDA7CiB9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3Bpby9ncGlvLWlkdDMyNDN4LmMgYi9kcml2 ZXJzL2dwaW8vZ3Bpby1pZHQzMjQzeC5jCmluZGV4IDUyYjhiNzJkZWQ3Ny4uMWNhZmRmNDZmODc1 IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwaW8vZ3Bpby1pZHQzMjQzeC5jCisrKyBiL2RyaXZlcnMv Z3Bpby9ncGlvLWlkdDMyNDN4LmMKQEAgLTU3LDcgKzU3LDcgQEAgc3RhdGljIGludCBpZHRfZ3Bp b19pcnFfc2V0X3R5cGUoc3RydWN0IGlycV9kYXRhICpkLCB1bnNpZ25lZCBpbnQgZmxvd190eXBl KQogCWlmIChzZW5zZSA9PSBJUlFfVFlQRV9OT05FIHx8IChzZW5zZSAmIElSUV9UWVBFX0VER0Vf Qk9USCkpCiAJCXJldHVybiAtRUlOVkFMOwogCi0Jc3Bpbl9sb2NrX2lycXNhdmUoJmdjLT5iZ3Bp b19sb2NrLCBmbGFncyk7CisJcmF3X3NwaW5fbG9ja19pcnFzYXZlKCZnYy0+YmdwaW9fbG9jaywg ZmxhZ3MpOwogCiAJaWxldmVsID0gcmVhZGwoY3RybC0+Z3BpbyArIElEVF9HUElPX0lMRVZFTCk7 CiAJaWYgKHNlbnNlICYgSVJRX1RZUEVfTEVWRUxfSElHSCkKQEAgLTY4LDcgKzY4LDcgQEAgc3Rh dGljIGludCBpZHRfZ3Bpb19pcnFfc2V0X3R5cGUoc3RydWN0IGlycV9kYXRhICpkLCB1bnNpZ25l ZCBpbnQgZmxvd190eXBlKQogCXdyaXRlbChpbGV2ZWwsIGN0cmwtPmdwaW8gKyBJRFRfR1BJT19J TEVWRUwpOwogCWlycV9zZXRfaGFuZGxlcl9sb2NrZWQoZCwgaGFuZGxlX2xldmVsX2lycSk7CiAK LQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZnYy0+YmdwaW9fbG9jaywgZmxhZ3MpOworCXJhd19z cGluX3VubG9ja19pcnFyZXN0b3JlKCZnYy0+YmdwaW9fbG9jaywgZmxhZ3MpOwogCXJldHVybiAw OwogfQogCkBAIC04NiwxMiArODYsMTIgQEAgc3RhdGljIHZvaWQgaWR0X2dwaW9fbWFzayhzdHJ1 Y3QgaXJxX2RhdGEgKmQpCiAJc3RydWN0IGlkdF9ncGlvX2N0cmwgKmN0cmwgPSBncGlvY2hpcF9n ZXRfZGF0YShnYyk7CiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIAotCXNwaW5fbG9ja19pcnFzYXZl KCZnYy0+YmdwaW9fbG9jaywgZmxhZ3MpOworCXJhd19zcGluX2xvY2tfaXJxc2F2ZSgmZ2MtPmJn cGlvX2xvY2ssIGZsYWdzKTsKIAogCWN0cmwtPm1hc2tfY2FjaGUgfD0gQklUKGQtPmh3aXJxKTsK IAl3cml0ZWwoY3RybC0+bWFza19jYWNoZSwgY3RybC0+cGljICsgSURUX1BJQ19JUlFfTUFTSyk7 CiAKLQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZnYy0+YmdwaW9fbG9jaywgZmxhZ3MpOworCXJh d19zcGluX3VubG9ja19pcnFyZXN0b3JlKCZnYy0+YmdwaW9fbG9jaywgZmxhZ3MpOwogfQogCiBz dGF0aWMgdm9pZCBpZHRfZ3Bpb191bm1hc2soc3RydWN0IGlycV9kYXRhICpkKQpAQCAtMTAwLDEy ICsxMDAsMTIgQEAgc3RhdGljIHZvaWQgaWR0X2dwaW9fdW5tYXNrKHN0cnVjdCBpcnFfZGF0YSAq ZCkKIAlzdHJ1Y3QgaWR0X2dwaW9fY3RybCAqY3RybCA9IGdwaW9jaGlwX2dldF9kYXRhKGdjKTsK IAl1bnNpZ25lZCBsb25nIGZsYWdzOwogCi0Jc3Bpbl9sb2NrX2lycXNhdmUoJmdjLT5iZ3Bpb19s b2NrLCBmbGFncyk7CisJcmF3X3NwaW5fbG9ja19pcnFzYXZlKCZnYy0+YmdwaW9fbG9jaywgZmxh Z3MpOwogCiAJY3RybC0+bWFza19jYWNoZSAmPSB+QklUKGQtPmh3aXJxKTsKIAl3cml0ZWwoY3Ry bC0+bWFza19jYWNoZSwgY3RybC0+cGljICsgSURUX1BJQ19JUlFfTUFTSyk7CiAKLQlzcGluX3Vu bG9ja19pcnFyZXN0b3JlKCZnYy0+YmdwaW9fbG9jaywgZmxhZ3MpOworCXJhd19zcGluX3VubG9j a19pcnFyZXN0b3JlKCZnYy0+YmdwaW9fbG9jaywgZmxhZ3MpOwogfQogCiBzdGF0aWMgaW50IGlk dF9ncGlvX2lycV9pbml0X2h3KHN0cnVjdCBncGlvX2NoaXAgKmdjKQpkaWZmIC0tZ2l0IGEvZHJp dmVycy9ncGlvL2dwaW8taXhwNHh4LmMgYi9kcml2ZXJzL2dwaW8vZ3Bpby1peHA0eHguYwppbmRl eCBiM2IwNTA2MDRlMGIuLjZiMTg0NTAyZmEzZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncGlvL2dw aW8taXhwNHh4LmMKKysrIGIvZHJpdmVycy9ncGlvL2dwaW8taXhwNHh4LmMKQEAgLTEyOCw3ICsx MjgsNyBAQCBzdGF0aWMgaW50IGl4cDR4eF9ncGlvX2lycV9zZXRfdHlwZShzdHJ1Y3QgaXJxX2Rh dGEgKmQsIHVuc2lnbmVkIGludCB0eXBlKQogCQlpbnRfcmVnID0gSVhQNFhYX1JFR19HUElUMTsK IAl9CiAKLQlzcGluX2xvY2tfaXJxc2F2ZSgmZy0+Z2MuYmdwaW9fbG9jaywgZmxhZ3MpOworCXJh d19zcGluX2xvY2tfaXJxc2F2ZSgmZy0+Z2MuYmdwaW9fbG9jaywgZmxhZ3MpOwogCiAJLyogQ2xl YXIgdGhlIHN0eWxlIGZvciB0aGUgYXBwcm9wcmlhdGUgcGluICovCiAJdmFsID0gX19yYXdfcmVh ZGwoZy0+YmFzZSArIGludF9yZWcpOwpAQCAtMTQ3LDcgKzE0Nyw3IEBAIHN0YXRpYyBpbnQgaXhw NHh4X2dwaW9faXJxX3NldF90eXBlKHN0cnVjdCBpcnFfZGF0YSAqZCwgdW5zaWduZWQgaW50IHR5 cGUpCiAJdmFsIHw9IEJJVChkLT5od2lycSk7CiAJX19yYXdfd3JpdGVsKHZhbCwgZy0+YmFzZSAr IElYUDRYWF9SRUdfR1BPRSk7CiAKLQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZnLT5nYy5iZ3Bp b19sb2NrLCBmbGFncyk7CisJcmF3X3NwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmctPmdjLmJncGlv X2xvY2ssIGZsYWdzKTsKIAogCS8qIFRoaXMgcGFyZW50IG9ubHkgYWNjZXB0IGxldmVsIGhpZ2gg KGFzc2VydGVkKSAqLwogCXJldHVybiBpcnFfY2hpcF9zZXRfdHlwZV9wYXJlbnQoZCwgSVJRX1RZ UEVfTEVWRUxfSElHSCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwaW8vZ3Bpby1sb29uZ3NvbjEu YyBiL2RyaXZlcnMvZ3Bpby9ncGlvLWxvb25nc29uMS5jCmluZGV4IDFiMWVlOTRlZWFiNC4uNWQ5 MGIzYmM1YTI1IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwaW8vZ3Bpby1sb29uZ3NvbjEuYworKysg Yi9kcml2ZXJzL2dwaW8vZ3Bpby1sb29uZ3NvbjEuYwpAQCAtMjUsMTAgKzI1LDEwIEBAIHN0YXRp YyBpbnQgbHMxeF9ncGlvX3JlcXVlc3Qoc3RydWN0IGdwaW9fY2hpcCAqZ2MsIHVuc2lnbmVkIGlu dCBvZmZzZXQpCiB7CiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIAotCXNwaW5fbG9ja19pcnFzYXZl KCZnYy0+YmdwaW9fbG9jaywgZmxhZ3MpOworCXJhd19zcGluX2xvY2tfaXJxc2F2ZSgmZ2MtPmJn cGlvX2xvY2ssIGZsYWdzKTsKIAlfX3Jhd193cml0ZWwoX19yYXdfcmVhZGwoZ3Bpb19yZWdfYmFz ZSArIEdQSU9fQ0ZHKSB8IEJJVChvZmZzZXQpLAogCQkgICAgIGdwaW9fcmVnX2Jhc2UgKyBHUElP X0NGRyk7Ci0Jc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZ2MtPmJncGlvX2xvY2ssIGZsYWdzKTsK KwlyYXdfc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZ2MtPmJncGlvX2xvY2ssIGZsYWdzKTsKIAog CXJldHVybiAwOwogfQpAQCAtMzcsMTAgKzM3LDEwIEBAIHN0YXRpYyB2b2lkIGxzMXhfZ3Bpb19m cmVlKHN0cnVjdCBncGlvX2NoaXAgKmdjLCB1bnNpZ25lZCBpbnQgb2Zmc2V0KQogewogCXVuc2ln bmVkIGxvbmcgZmxhZ3M7CiAKLQlzcGluX2xvY2tfaXJxc2F2ZSgmZ2MtPmJncGlvX2xvY2ssIGZs YWdzKTsKKwlyYXdfc3Bpbl9sb2NrX2lycXNhdmUoJmdjLT5iZ3Bpb19sb2NrLCBmbGFncyk7CiAJ X19yYXdfd3JpdGVsKF9fcmF3X3JlYWRsKGdwaW9fcmVnX2Jhc2UgKyBHUElPX0NGRykgJiB+QklU KG9mZnNldCksCiAJCSAgICAgZ3Bpb19yZWdfYmFzZSArIEdQSU9fQ0ZHKTsKLQlzcGluX3VubG9j a19pcnFyZXN0b3JlKCZnYy0+YmdwaW9fbG9jaywgZmxhZ3MpOworCXJhd19zcGluX3VubG9ja19p cnFyZXN0b3JlKCZnYy0+YmdwaW9fbG9jaywgZmxhZ3MpOwogfQogCiBzdGF0aWMgaW50IGxzMXhf Z3Bpb19wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQpkaWZmIC0tZ2l0IGEvZHJp dmVycy9ncGlvL2dwaW8tbWVuejEyNy5jIGIvZHJpdmVycy9ncGlvL2dwaW8tbWVuejEyNy5jCmlu ZGV4IDFlMjFjNjYxZDc5ZC4uYTAzNWE5YmNiNTdjIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwaW8v Z3Bpby1tZW56MTI3LmMKKysrIGIvZHJpdmVycy9ncGlvL2dwaW8tbWVuejEyNy5jCkBAIC02NCw3 ICs2NCw3IEBAIHN0YXRpYyBpbnQgbWVuX3oxMjdfZGVib3VuY2Uoc3RydWN0IGdwaW9fY2hpcCAq Z2MsIHVuc2lnbmVkIGdwaW8sCiAJCWRlYm91bmNlIC89IDUwOwogCX0KIAotCXNwaW5fbG9jaygm Z2MtPmJncGlvX2xvY2spOworCXJhd19zcGluX2xvY2soJmdjLT5iZ3Bpb19sb2NrKTsKIAogCWRi X2VuID0gcmVhZGwocHJpdi0+cmVnX2Jhc2UgKyBNRU5fWjEyN19EQkVSKTsKIApAQCAtNzksNyAr NzksNyBAQCBzdGF0aWMgaW50IG1lbl96MTI3X2RlYm91bmNlKHN0cnVjdCBncGlvX2NoaXAgKmdj LCB1bnNpZ25lZCBncGlvLAogCXdyaXRlbChkYl9lbiwgcHJpdi0+cmVnX2Jhc2UgKyBNRU5fWjEy N19EQkVSKTsKIAl3cml0ZWwoZGJfY250LCBwcml2LT5yZWdfYmFzZSArIEdQSU9fVE9fREJDTlRf UkVHKGdwaW8pKTsKIAotCXNwaW5fdW5sb2NrKCZnYy0+YmdwaW9fbG9jayk7CisJcmF3X3NwaW5f dW5sb2NrKCZnYy0+YmdwaW9fbG9jayk7CiAKIAlyZXR1cm4gMDsKIH0KQEAgLTkxLDcgKzkxLDcg QEAgc3RhdGljIGludCBtZW5fejEyN19zZXRfc2luZ2xlX2VuZGVkKHN0cnVjdCBncGlvX2NoaXAg KmdjLAogCXN0cnVjdCBtZW5fejEyN19ncGlvICpwcml2ID0gZ3Bpb2NoaXBfZ2V0X2RhdGEoZ2Mp OwogCXUzMiBvZF9lbjsKIAotCXNwaW5fbG9jaygmZ2MtPmJncGlvX2xvY2spOworCXJhd19zcGlu X2xvY2soJmdjLT5iZ3Bpb19sb2NrKTsKIAlvZF9lbiA9IHJlYWRsKHByaXYtPnJlZ19iYXNlICsg TUVOX1oxMjdfT0RFUik7CiAKIAlpZiAocGFyYW0gPT0gUElOX0NPTkZJR19EUklWRV9PUEVOX0RS QUlOKQpAQCAtMTAxLDcgKzEwMSw3IEBAIHN0YXRpYyBpbnQgbWVuX3oxMjdfc2V0X3NpbmdsZV9l bmRlZChzdHJ1Y3QgZ3Bpb19jaGlwICpnYywKIAkJb2RfZW4gJj0gfkJJVChvZmZzZXQpOwogCiAJ d3JpdGVsKG9kX2VuLCBwcml2LT5yZWdfYmFzZSArIE1FTl9aMTI3X09ERVIpOwotCXNwaW5fdW5s b2NrKCZnYy0+YmdwaW9fbG9jayk7CisJcmF3X3NwaW5fdW5sb2NrKCZnYy0+YmdwaW9fbG9jayk7 CiAKIAlyZXR1cm4gMDsKIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3Bpby9ncGlvLW1seGJmMi5j IGIvZHJpdmVycy9ncGlvL2dwaW8tbWx4YmYyLmMKaW5kZXggM2Q4OTkxMmEwNWI4Li42NGNiMDYw ZDlkNzUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3Bpby9ncGlvLW1seGJmMi5jCisrKyBiL2RyaXZl cnMvZ3Bpby9ncGlvLW1seGJmMi5jCkBAIC0xMzEsNyArMTMxLDcgQEAgc3RhdGljIGludCBtbHhi ZjJfZ3Bpb19sb2NrX2FjcXVpcmUoc3RydWN0IG1seGJmMl9ncGlvX2NvbnRleHQgKmdzKQogCXUz MiBhcm1fZ3Bpb19sb2NrX3ZhbDsKIAogCW11dGV4X2xvY2soeXVfYXJtX2dwaW9fbG9ja19wYXJh bS5sb2NrKTsKLQlzcGluX2xvY2soJmdzLT5nYy5iZ3Bpb19sb2NrKTsKKwlyYXdfc3Bpbl9sb2Nr KCZncy0+Z2MuYmdwaW9fbG9jayk7CiAKIAlhcm1fZ3Bpb19sb2NrX3ZhbCA9IHJlYWRsKHl1X2Fy bV9ncGlvX2xvY2tfcGFyYW0uaW8pOwogCkBAIC0xMzksNyArMTM5LDcgQEAgc3RhdGljIGludCBt bHhiZjJfZ3Bpb19sb2NrX2FjcXVpcmUoc3RydWN0IG1seGJmMl9ncGlvX2NvbnRleHQgKmdzKQog CSAqIFdoZW4gbG9jayBhY3RpdmUgYml0WzMxXSBpcyBzZXQsIE1vZGVYIGlzIHdyaXRlIGVuYWJs ZWQKIAkgKi8KIAlpZiAoWVVfTE9DS19BQ1RJVkVfQklUKGFybV9ncGlvX2xvY2tfdmFsKSkgewot CQlzcGluX3VubG9jaygmZ3MtPmdjLmJncGlvX2xvY2spOworCQlyYXdfc3Bpbl91bmxvY2soJmdz LT5nYy5iZ3Bpb19sb2NrKTsKIAkJbXV0ZXhfdW5sb2NrKHl1X2FybV9ncGlvX2xvY2tfcGFyYW0u bG9jayk7CiAJCXJldHVybiAtRUlOVkFMOwogCX0KQEAgLTE1Nyw3ICsxNTcsNyBAQCBzdGF0aWMg dm9pZCBtbHhiZjJfZ3Bpb19sb2NrX3JlbGVhc2Uoc3RydWN0IG1seGJmMl9ncGlvX2NvbnRleHQg KmdzKQogCV9fcmVsZWFzZXMoeXVfYXJtX2dwaW9fbG9ja19wYXJhbS5sb2NrKQogewogCXdyaXRl bChZVV9BUk1fR1BJT19MT0NLX1JFTEVBU0UsIHl1X2FybV9ncGlvX2xvY2tfcGFyYW0uaW8pOwot CXNwaW5fdW5sb2NrKCZncy0+Z2MuYmdwaW9fbG9jayk7CisJcmF3X3NwaW5fdW5sb2NrKCZncy0+ Z2MuYmdwaW9fbG9jayk7CiAJbXV0ZXhfdW5sb2NrKHl1X2FybV9ncGlvX2xvY2tfcGFyYW0ubG9j ayk7CiB9CiAKQEAgLTIzNyw3ICsyMzcsNyBAQCBzdGF0aWMgdm9pZCBtbHhiZjJfZ3Bpb19pcnFf ZW5hYmxlKHN0cnVjdCBpcnFfZGF0YSAqaXJxZCkKIAl1bnNpZ25lZCBsb25nIGZsYWdzOwogCXUz MiB2YWw7CiAKLQlzcGluX2xvY2tfaXJxc2F2ZSgmZ3MtPmdjLmJncGlvX2xvY2ssIGZsYWdzKTsK KwlyYXdfc3Bpbl9sb2NrX2lycXNhdmUoJmdzLT5nYy5iZ3Bpb19sb2NrLCBmbGFncyk7CiAJdmFs ID0gcmVhZGwoZ3MtPmdwaW9faW8gKyBZVV9HUElPX0NBVVNFX09SX0NMUkNBVVNFKTsKIAl2YWwg fD0gQklUKG9mZnNldCk7CiAJd3JpdGVsKHZhbCwgZ3MtPmdwaW9faW8gKyBZVV9HUElPX0NBVVNF X09SX0NMUkNBVVNFKTsKQEAgLTI0NSw3ICsyNDUsNyBAQCBzdGF0aWMgdm9pZCBtbHhiZjJfZ3Bp b19pcnFfZW5hYmxlKHN0cnVjdCBpcnFfZGF0YSAqaXJxZCkKIAl2YWwgPSByZWFkbChncy0+Z3Bp b19pbyArIFlVX0dQSU9fQ0FVU0VfT1JfRVZURU4wKTsKIAl2YWwgfD0gQklUKG9mZnNldCk7CiAJ d3JpdGVsKHZhbCwgZ3MtPmdwaW9faW8gKyBZVV9HUElPX0NBVVNFX09SX0VWVEVOMCk7Ci0Jc3Bp bl91bmxvY2tfaXJxcmVzdG9yZSgmZ3MtPmdjLmJncGlvX2xvY2ssIGZsYWdzKTsKKwlyYXdfc3Bp bl91bmxvY2tfaXJxcmVzdG9yZSgmZ3MtPmdjLmJncGlvX2xvY2ssIGZsYWdzKTsKIH0KIAogc3Rh dGljIHZvaWQgbWx4YmYyX2dwaW9faXJxX2Rpc2FibGUoc3RydWN0IGlycV9kYXRhICppcnFkKQpA QCAtMjU2LDExICsyNTYsMTEgQEAgc3RhdGljIHZvaWQgbWx4YmYyX2dwaW9faXJxX2Rpc2FibGUo c3RydWN0IGlycV9kYXRhICppcnFkKQogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAJdTMyIHZhbDsK IAotCXNwaW5fbG9ja19pcnFzYXZlKCZncy0+Z2MuYmdwaW9fbG9jaywgZmxhZ3MpOworCXJhd19z cGluX2xvY2tfaXJxc2F2ZSgmZ3MtPmdjLmJncGlvX2xvY2ssIGZsYWdzKTsKIAl2YWwgPSByZWFk bChncy0+Z3Bpb19pbyArIFlVX0dQSU9fQ0FVU0VfT1JfRVZURU4wKTsKIAl2YWwgJj0gfkJJVChv ZmZzZXQpOwogCXdyaXRlbCh2YWwsIGdzLT5ncGlvX2lvICsgWVVfR1BJT19DQVVTRV9PUl9FVlRF TjApOwotCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmdzLT5nYy5iZ3Bpb19sb2NrLCBmbGFncyk7 CisJcmF3X3NwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmdzLT5nYy5iZ3Bpb19sb2NrLCBmbGFncyk7 CiB9CiAKIHN0YXRpYyBpcnFyZXR1cm5fdCBtbHhiZjJfZ3Bpb19pcnFfaGFuZGxlcihpbnQgaXJx LCB2b2lkICpwdHIpCkBAIC0zMDcsNyArMzA3LDcgQEAgbWx4YmYyX2dwaW9faXJxX3NldF90eXBl KHN0cnVjdCBpcnFfZGF0YSAqaXJxZCwgdW5zaWduZWQgaW50IHR5cGUpCiAJCXJldHVybiAtRUlO VkFMOwogCX0KIAotCXNwaW5fbG9ja19pcnFzYXZlKCZncy0+Z2MuYmdwaW9fbG9jaywgZmxhZ3Mp OworCXJhd19zcGluX2xvY2tfaXJxc2F2ZSgmZ3MtPmdjLmJncGlvX2xvY2ssIGZsYWdzKTsKIAlp ZiAoZmFsbCkgewogCQl2YWwgPSByZWFkbChncy0+Z3Bpb19pbyArIFlVX0dQSU9fQ0FVU0VfRkFM TF9FTik7CiAJCXZhbCB8PSBCSVQob2Zmc2V0KTsKQEAgLTMxOSw3ICszMTksNyBAQCBtbHhiZjJf Z3Bpb19pcnFfc2V0X3R5cGUoc3RydWN0IGlycV9kYXRhICppcnFkLCB1bnNpZ25lZCBpbnQgdHlw ZSkKIAkJdmFsIHw9IEJJVChvZmZzZXQpOwogCQl3cml0ZWwodmFsLCBncy0+Z3Bpb19pbyArIFlV X0dQSU9fQ0FVU0VfUklTRV9FTik7CiAJfQotCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmdzLT5n Yy5iZ3Bpb19sb2NrLCBmbGFncyk7CisJcmF3X3NwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmdzLT5n Yy5iZ3Bpb19sb2NrLCBmbGFncyk7CiAKIAlyZXR1cm4gMDsKIH0KZGlmZiAtLWdpdCBhL2RyaXZl cnMvZ3Bpby9ncGlvLW1taW8uYyBiL2RyaXZlcnMvZ3Bpby9ncGlvLW1taW8uYwppbmRleCBjMzM1 YTAzMDliYTMuLmQ5ZGZmM2RjOTJhZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncGlvL2dwaW8tbW1p by5jCisrKyBiL2RyaXZlcnMvZ3Bpby9ncGlvLW1taW8uYwpAQCAtMjIwLDcgKzIyMCw3IEBAIHN0 YXRpYyB2b2lkIGJncGlvX3NldChzdHJ1Y3QgZ3Bpb19jaGlwICpnYywgdW5zaWduZWQgaW50IGdw aW8sIGludCB2YWwpCiAJdW5zaWduZWQgbG9uZyBtYXNrID0gYmdwaW9fbGluZTJtYXNrKGdjLCBn cGlvKTsKIAl1bnNpZ25lZCBsb25nIGZsYWdzOwogCi0Jc3Bpbl9sb2NrX2lycXNhdmUoJmdjLT5i Z3Bpb19sb2NrLCBmbGFncyk7CisJcmF3X3NwaW5fbG9ja19pcnFzYXZlKCZnYy0+YmdwaW9fbG9j aywgZmxhZ3MpOwogCiAJaWYgKHZhbCkKIAkJZ2MtPmJncGlvX2RhdGEgfD0gbWFzazsKQEAgLTIy OSw3ICsyMjksNyBAQCBzdGF0aWMgdm9pZCBiZ3Bpb19zZXQoc3RydWN0IGdwaW9fY2hpcCAqZ2Ms IHVuc2lnbmVkIGludCBncGlvLCBpbnQgdmFsKQogCiAJZ2MtPndyaXRlX3JlZyhnYy0+cmVnX2Rh dCwgZ2MtPmJncGlvX2RhdGEpOwogCi0Jc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZ2MtPmJncGlv X2xvY2ssIGZsYWdzKTsKKwlyYXdfc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZ2MtPmJncGlvX2xv Y2ssIGZsYWdzKTsKIH0KIAogc3RhdGljIHZvaWQgYmdwaW9fc2V0X3dpdGhfY2xlYXIoc3RydWN0 IGdwaW9fY2hpcCAqZ2MsIHVuc2lnbmVkIGludCBncGlvLApAQCAtMjQ4LDcgKzI0OCw3IEBAIHN0 YXRpYyB2b2lkIGJncGlvX3NldF9zZXQoc3RydWN0IGdwaW9fY2hpcCAqZ2MsIHVuc2lnbmVkIGlu dCBncGlvLCBpbnQgdmFsKQogCXVuc2lnbmVkIGxvbmcgbWFzayA9IGJncGlvX2xpbmUybWFzayhn YywgZ3Bpbyk7CiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIAotCXNwaW5fbG9ja19pcnFzYXZlKCZn Yy0+YmdwaW9fbG9jaywgZmxhZ3MpOworCXJhd19zcGluX2xvY2tfaXJxc2F2ZSgmZ2MtPmJncGlv X2xvY2ssIGZsYWdzKTsKIAogCWlmICh2YWwpCiAJCWdjLT5iZ3Bpb19kYXRhIHw9IG1hc2s7CkBA IC0yNTcsNyArMjU3LDcgQEAgc3RhdGljIHZvaWQgYmdwaW9fc2V0X3NldChzdHJ1Y3QgZ3Bpb19j aGlwICpnYywgdW5zaWduZWQgaW50IGdwaW8sIGludCB2YWwpCiAKIAlnYy0+d3JpdGVfcmVnKGdj LT5yZWdfc2V0LCBnYy0+YmdwaW9fZGF0YSk7CiAKLQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZn Yy0+YmdwaW9fbG9jaywgZmxhZ3MpOworCXJhd19zcGluX3VubG9ja19pcnFyZXN0b3JlKCZnYy0+ YmdwaW9fbG9jaywgZmxhZ3MpOwogfQogCiBzdGF0aWMgdm9pZCBiZ3Bpb19tdWx0aXBsZV9nZXRf bWFza3Moc3RydWN0IGdwaW9fY2hpcCAqZ2MsCkBAIC0yODYsNyArMjg2LDcgQEAgc3RhdGljIHZv aWQgYmdwaW9fc2V0X211bHRpcGxlX3NpbmdsZV9yZWcoc3RydWN0IGdwaW9fY2hpcCAqZ2MsCiAJ dW5zaWduZWQgbG9uZyBmbGFnczsKIAl1bnNpZ25lZCBsb25nIHNldF9tYXNrLCBjbGVhcl9tYXNr OwogCi0Jc3Bpbl9sb2NrX2lycXNhdmUoJmdjLT5iZ3Bpb19sb2NrLCBmbGFncyk7CisJcmF3X3Nw aW5fbG9ja19pcnFzYXZlKCZnYy0+YmdwaW9fbG9jaywgZmxhZ3MpOwogCiAJYmdwaW9fbXVsdGlw bGVfZ2V0X21hc2tzKGdjLCBtYXNrLCBiaXRzLCAmc2V0X21hc2ssICZjbGVhcl9tYXNrKTsKIApA QCAtMjk1LDcgKzI5NSw3IEBAIHN0YXRpYyB2b2lkIGJncGlvX3NldF9tdWx0aXBsZV9zaW5nbGVf cmVnKHN0cnVjdCBncGlvX2NoaXAgKmdjLAogCiAJZ2MtPndyaXRlX3JlZyhyZWcsIGdjLT5iZ3Bp b19kYXRhKTsKIAotCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmdjLT5iZ3Bpb19sb2NrLCBmbGFn cyk7CisJcmF3X3NwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmdjLT5iZ3Bpb19sb2NrLCBmbGFncyk7 CiB9CiAKIHN0YXRpYyB2b2lkIGJncGlvX3NldF9tdWx0aXBsZShzdHJ1Y3QgZ3Bpb19jaGlwICpn YywgdW5zaWduZWQgbG9uZyAqbWFzaywKQEAgLTM0Nyw3ICszNDcsNyBAQCBzdGF0aWMgaW50IGJn cGlvX2Rpcl9pbihzdHJ1Y3QgZ3Bpb19jaGlwICpnYywgdW5zaWduZWQgaW50IGdwaW8pCiB7CiAJ dW5zaWduZWQgbG9uZyBmbGFnczsKIAotCXNwaW5fbG9ja19pcnFzYXZlKCZnYy0+YmdwaW9fbG9j aywgZmxhZ3MpOworCXJhd19zcGluX2xvY2tfaXJxc2F2ZSgmZ2MtPmJncGlvX2xvY2ssIGZsYWdz KTsKIAogCWdjLT5iZ3Bpb19kaXIgJj0gfmJncGlvX2xpbmUybWFzayhnYywgZ3Bpbyk7CiAKQEAg LTM1Niw3ICszNTYsNyBAQCBzdGF0aWMgaW50IGJncGlvX2Rpcl9pbihzdHJ1Y3QgZ3Bpb19jaGlw ICpnYywgdW5zaWduZWQgaW50IGdwaW8pCiAJaWYgKGdjLT5yZWdfZGlyX291dCkKIAkJZ2MtPndy aXRlX3JlZyhnYy0+cmVnX2Rpcl9vdXQsIGdjLT5iZ3Bpb19kaXIpOwogCi0Jc3Bpbl91bmxvY2tf aXJxcmVzdG9yZSgmZ2MtPmJncGlvX2xvY2ssIGZsYWdzKTsKKwlyYXdfc3Bpbl91bmxvY2tfaXJx cmVzdG9yZSgmZ2MtPmJncGlvX2xvY2ssIGZsYWdzKTsKIAogCXJldHVybiAwOwogfQpAQCAtMzg3 LDcgKzM4Nyw3IEBAIHN0YXRpYyB2b2lkIGJncGlvX2Rpcl9vdXQoc3RydWN0IGdwaW9fY2hpcCAq Z2MsIHVuc2lnbmVkIGludCBncGlvLCBpbnQgdmFsKQogewogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7 CiAKLQlzcGluX2xvY2tfaXJxc2F2ZSgmZ2MtPmJncGlvX2xvY2ssIGZsYWdzKTsKKwlyYXdfc3Bp bl9sb2NrX2lycXNhdmUoJmdjLT5iZ3Bpb19sb2NrLCBmbGFncyk7CiAKIAlnYy0+YmdwaW9fZGly IHw9IGJncGlvX2xpbmUybWFzayhnYywgZ3Bpbyk7CiAKQEAgLTM5Niw3ICszOTYsNyBAQCBzdGF0 aWMgdm9pZCBiZ3Bpb19kaXJfb3V0KHN0cnVjdCBncGlvX2NoaXAgKmdjLCB1bnNpZ25lZCBpbnQg Z3BpbywgaW50IHZhbCkKIAlpZiAoZ2MtPnJlZ19kaXJfb3V0KQogCQlnYy0+d3JpdGVfcmVnKGdj LT5yZWdfZGlyX291dCwgZ2MtPmJncGlvX2Rpcik7CiAKLQlzcGluX3VubG9ja19pcnFyZXN0b3Jl KCZnYy0+YmdwaW9fbG9jaywgZmxhZ3MpOworCXJhd19zcGluX3VubG9ja19pcnFyZXN0b3JlKCZn Yy0+YmdwaW9fbG9jaywgZmxhZ3MpOwogfQogCiBzdGF0aWMgaW50IGJncGlvX2Rpcl9vdXRfZGly X2ZpcnN0KHN0cnVjdCBncGlvX2NoaXAgKmdjLCB1bnNpZ25lZCBpbnQgZ3BpbywKQEAgLTYxMCw3 ICs2MTAsNyBAQCBpbnQgYmdwaW9faW5pdChzdHJ1Y3QgZ3Bpb19jaGlwICpnYywgc3RydWN0IGRl dmljZSAqZGV2LAogCWlmIChnYy0+YmdwaW9fYml0cyA+IEJJVFNfUEVSX0xPTkcpCiAJCXJldHVy biAtRUlOVkFMOwogCi0Jc3Bpbl9sb2NrX2luaXQoJmdjLT5iZ3Bpb19sb2NrKTsKKwlyYXdfc3Bp bl9sb2NrX2luaXQoJmdjLT5iZ3Bpb19sb2NrKTsKIAlnYy0+cGFyZW50ID0gZGV2OwogCWdjLT5s YWJlbCA9IGRldl9uYW1lKGRldik7CiAJZ2MtPmJhc2UgPSAtMTsKZGlmZiAtLWdpdCBhL2RyaXZl cnMvZ3Bpby9ncGlvLXNpZml2ZS5jIGIvZHJpdmVycy9ncGlvL2dwaW8tc2lmaXZlLmMKaW5kZXgg N2Q4MjM4OGI0YWI3Li4wM2I4YzRkZTJlOTEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3Bpby9ncGlv LXNpZml2ZS5jCisrKyBiL2RyaXZlcnMvZ3Bpby9ncGlvLXNpZml2ZS5jCkBAIC00NCw3ICs0NCw3 IEBAIHN0YXRpYyB2b2lkIHNpZml2ZV9ncGlvX3NldF9pZShzdHJ1Y3Qgc2lmaXZlX2dwaW8gKmNo aXAsIHVuc2lnbmVkIGludCBvZmZzZXQpCiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIAl1bnNpZ25l ZCBpbnQgdHJpZ2dlcjsKIAotCXNwaW5fbG9ja19pcnFzYXZlKCZjaGlwLT5nYy5iZ3Bpb19sb2Nr LCBmbGFncyk7CisJcmF3X3NwaW5fbG9ja19pcnFzYXZlKCZjaGlwLT5nYy5iZ3Bpb19sb2NrLCBm bGFncyk7CiAJdHJpZ2dlciA9IChjaGlwLT5pcnFfc3RhdGUgJiBCSVQob2Zmc2V0KSkgPyBjaGlw LT50cmlnZ2VyW29mZnNldF0gOiAwOwogCXJlZ21hcF91cGRhdGVfYml0cyhjaGlwLT5yZWdzLCBT SUZJVkVfR1BJT19SSVNFX0lFLCBCSVQob2Zmc2V0KSwKIAkJCSAgICh0cmlnZ2VyICYgSVJRX1RZ UEVfRURHRV9SSVNJTkcpID8gQklUKG9mZnNldCkgOiAwKTsKQEAgLTU0LDcgKzU0LDcgQEAgc3Rh dGljIHZvaWQgc2lmaXZlX2dwaW9fc2V0X2llKHN0cnVjdCBzaWZpdmVfZ3BpbyAqY2hpcCwgdW5z aWduZWQgaW50IG9mZnNldCkKIAkJCSAgICh0cmlnZ2VyICYgSVJRX1RZUEVfTEVWRUxfSElHSCkg PyBCSVQob2Zmc2V0KSA6IDApOwogCXJlZ21hcF91cGRhdGVfYml0cyhjaGlwLT5yZWdzLCBTSUZJ VkVfR1BJT19MT1dfSUUsIEJJVChvZmZzZXQpLAogCQkJICAgKHRyaWdnZXIgJiBJUlFfVFlQRV9M RVZFTF9MT1cpID8gQklUKG9mZnNldCkgOiAwKTsKLQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZj aGlwLT5nYy5iZ3Bpb19sb2NrLCBmbGFncyk7CisJcmF3X3NwaW5fdW5sb2NrX2lycXJlc3RvcmUo JmNoaXAtPmdjLmJncGlvX2xvY2ssIGZsYWdzKTsKIH0KIAogc3RhdGljIGludCBzaWZpdmVfZ3Bp b19pcnFfc2V0X3R5cGUoc3RydWN0IGlycV9kYXRhICpkLCB1bnNpZ25lZCBpbnQgdHJpZ2dlcikK QEAgLTg0LDEzICs4NCwxMyBAQCBzdGF0aWMgdm9pZCBzaWZpdmVfZ3Bpb19pcnFfZW5hYmxlKHN0 cnVjdCBpcnFfZGF0YSAqZCkKIAkvKiBTd2l0Y2ggdG8gaW5wdXQgKi8KIAlnYy0+ZGlyZWN0aW9u X2lucHV0KGdjLCBvZmZzZXQpOwogCi0Jc3Bpbl9sb2NrX2lycXNhdmUoJmdjLT5iZ3Bpb19sb2Nr LCBmbGFncyk7CisJcmF3X3NwaW5fbG9ja19pcnFzYXZlKCZnYy0+YmdwaW9fbG9jaywgZmxhZ3Mp OwogCS8qIENsZWFyIGFueSBzdGlja3kgcGVuZGluZyBpbnRlcnJ1cHRzICovCiAJcmVnbWFwX3dy aXRlKGNoaXAtPnJlZ3MsIFNJRklWRV9HUElPX1JJU0VfSVAsIGJpdCk7CiAJcmVnbWFwX3dyaXRl KGNoaXAtPnJlZ3MsIFNJRklWRV9HUElPX0ZBTExfSVAsIGJpdCk7CiAJcmVnbWFwX3dyaXRlKGNo aXAtPnJlZ3MsIFNJRklWRV9HUElPX0hJR0hfSVAsIGJpdCk7CiAJcmVnbWFwX3dyaXRlKGNoaXAt PnJlZ3MsIFNJRklWRV9HUElPX0xPV19JUCwgYml0KTsKLQlzcGluX3VubG9ja19pcnFyZXN0b3Jl KCZnYy0+YmdwaW9fbG9jaywgZmxhZ3MpOworCXJhd19zcGluX3VubG9ja19pcnFyZXN0b3JlKCZn Yy0+YmdwaW9fbG9jaywgZmxhZ3MpOwogCiAJLyogRW5hYmxlIGludGVycnVwdHMgKi8KIAlhc3Np Z25fYml0KG9mZnNldCwgJmNoaXAtPmlycV9zdGF0ZSwgMSk7CkBAIC0xMTYsMTMgKzExNiwxMyBA QCBzdGF0aWMgdm9pZCBzaWZpdmVfZ3Bpb19pcnFfZW9pKHN0cnVjdCBpcnFfZGF0YSAqZCkKIAl1 MzIgYml0ID0gQklUKG9mZnNldCk7CiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIAotCXNwaW5fbG9j a19pcnFzYXZlKCZnYy0+YmdwaW9fbG9jaywgZmxhZ3MpOworCXJhd19zcGluX2xvY2tfaXJxc2F2 ZSgmZ2MtPmJncGlvX2xvY2ssIGZsYWdzKTsKIAkvKiBDbGVhciBhbGwgcGVuZGluZyBpbnRlcnJ1 cHRzICovCiAJcmVnbWFwX3dyaXRlKGNoaXAtPnJlZ3MsIFNJRklWRV9HUElPX1JJU0VfSVAsIGJp dCk7CiAJcmVnbWFwX3dyaXRlKGNoaXAtPnJlZ3MsIFNJRklWRV9HUElPX0ZBTExfSVAsIGJpdCk7 CiAJcmVnbWFwX3dyaXRlKGNoaXAtPnJlZ3MsIFNJRklWRV9HUElPX0hJR0hfSVAsIGJpdCk7CiAJ cmVnbWFwX3dyaXRlKGNoaXAtPnJlZ3MsIFNJRklWRV9HUElPX0xPV19JUCwgYml0KTsKLQlzcGlu X3VubG9ja19pcnFyZXN0b3JlKCZnYy0+YmdwaW9fbG9jaywgZmxhZ3MpOworCXJhd19zcGluX3Vu bG9ja19pcnFyZXN0b3JlKCZnYy0+YmdwaW9fbG9jaywgZmxhZ3MpOwogCiAJaXJxX2NoaXBfZW9p X3BhcmVudChkKTsKIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3Bpby9ncGlvLXRiMTB4LmMgYi9k cml2ZXJzL2dwaW8vZ3Bpby10YjEweC5jCmluZGV4IDcxOGE1MDhkM2IyZi4uZGU2YWZhM2Y5NzE2 IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwaW8vZ3Bpby10YjEweC5jCisrKyBiL2RyaXZlcnMvZ3Bp by9ncGlvLXRiMTB4LmMKQEAgLTYyLDE0ICs2MiwxNCBAQCBzdGF0aWMgaW5saW5lIHZvaWQgdGIx MHhfc2V0X2JpdHMoc3RydWN0IHRiMTB4X2dwaW8gKmdwaW8sIHVuc2lnbmVkIGludCBvZmZzLAog CXUzMiByOwogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAKLQlzcGluX2xvY2tfaXJxc2F2ZSgmZ3Bp by0+Z2MuYmdwaW9fbG9jaywgZmxhZ3MpOworCXJhd19zcGluX2xvY2tfaXJxc2F2ZSgmZ3Bpby0+ Z2MuYmdwaW9fbG9jaywgZmxhZ3MpOwogCiAJciA9IHRiMTB4X3JlZ19yZWFkKGdwaW8sIG9mZnMp OwogCXIgPSAociAmIH5tYXNrKSB8ICh2YWwgJiBtYXNrKTsKIAogCXRiMTB4X3JlZ193cml0ZShn cGlvLCBvZmZzLCByKTsKIAotCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmdwaW8tPmdjLmJncGlv X2xvY2ssIGZsYWdzKTsKKwlyYXdfc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZ3Bpby0+Z2MuYmdw aW9fbG9jaywgZmxhZ3MpOwogfQogCiBzdGF0aWMgaW50IHRiMTB4X2dwaW9fdG9faXJxKHN0cnVj dCBncGlvX2NoaXAgKmNoaXAsIHVuc2lnbmVkIG9mZnNldCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMv cGluY3RybC9udXZvdG9uL3BpbmN0cmwtbnBjbTd4eC5jIGIvZHJpdmVycy9waW5jdHJsL251dm90 b24vcGluY3RybC1ucGNtN3h4LmMKaW5kZXggOTU1N2ZhYzVkMTFjLi5iMmEwZjExYTY1OGIgMTAw NjQ0Ci0tLSBhL2RyaXZlcnMvcGluY3RybC9udXZvdG9uL3BpbmN0cmwtbnBjbTd4eC5jCisrKyBi L2RyaXZlcnMvcGluY3RybC9udXZvdG9uL3BpbmN0cmwtbnBjbTd4eC5jCkBAIC0xMDQsMTIgKzEw NCwxMiBAQCBzdGF0aWMgdm9pZCBucGNtX2dwaW9fc2V0KHN0cnVjdCBncGlvX2NoaXAgKmdjLCB2 b2lkIF9faW9tZW0gKnJlZywKIAl1bnNpZ25lZCBsb25nIGZsYWdzOwogCXVuc2lnbmVkIGxvbmcg dmFsOwogCi0Jc3Bpbl9sb2NrX2lycXNhdmUoJmdjLT5iZ3Bpb19sb2NrLCBmbGFncyk7CisJcmF3 X3NwaW5fbG9ja19pcnFzYXZlKCZnYy0+YmdwaW9fbG9jaywgZmxhZ3MpOwogCiAJdmFsID0gaW9y ZWFkMzIocmVnKSB8IHBpbm1hc2s7CiAJaW93cml0ZTMyKHZhbCwgcmVnKTsKIAotCXNwaW5fdW5s b2NrX2lycXJlc3RvcmUoJmdjLT5iZ3Bpb19sb2NrLCBmbGFncyk7CisJcmF3X3NwaW5fdW5sb2Nr X2lycXJlc3RvcmUoJmdjLT5iZ3Bpb19sb2NrLCBmbGFncyk7CiB9CiAKIHN0YXRpYyB2b2lkIG5w Y21fZ3Bpb19jbHIoc3RydWN0IGdwaW9fY2hpcCAqZ2MsIHZvaWQgX19pb21lbSAqcmVnLApAQCAt MTE4LDEyICsxMTgsMTIgQEAgc3RhdGljIHZvaWQgbnBjbV9ncGlvX2NscihzdHJ1Y3QgZ3Bpb19j aGlwICpnYywgdm9pZCBfX2lvbWVtICpyZWcsCiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIAl1bnNp Z25lZCBsb25nIHZhbDsKIAotCXNwaW5fbG9ja19pcnFzYXZlKCZnYy0+YmdwaW9fbG9jaywgZmxh Z3MpOworCXJhd19zcGluX2xvY2tfaXJxc2F2ZSgmZ2MtPmJncGlvX2xvY2ssIGZsYWdzKTsKIAog CXZhbCA9IGlvcmVhZDMyKHJlZykgJiB+cGlubWFzazsKIAlpb3dyaXRlMzIodmFsLCByZWcpOwog Ci0Jc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZ2MtPmJncGlvX2xvY2ssIGZsYWdzKTsKKwlyYXdf c3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZ2MtPmJncGlvX2xvY2ssIGZsYWdzKTsKIH0KIAogc3Rh dGljIHZvaWQgbnBjbWdwaW9fZGJnX3Nob3coc3RydWN0IHNlcV9maWxlICpzLCBzdHJ1Y3QgZ3Bp b19jaGlwICpjaGlwKQpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9ncGlvL2RyaXZlci5oIGIv aW5jbHVkZS9saW51eC9ncGlvL2RyaXZlci5oCmluZGV4IDg3NGFhYmQyNzBjOS4uZmY4MjQ3YTE5 ZjU3IDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L2dwaW8vZHJpdmVyLmgKKysrIGIvaW5jbHVk ZS9saW51eC9ncGlvL2RyaXZlci5oCkBAIC00NDUsNyArNDQ1LDcgQEAgc3RydWN0IGdwaW9fY2hp cCB7CiAJdm9pZCBfX2lvbWVtICpyZWdfZGlyX2luOwogCWJvb2wgYmdwaW9fZGlyX3VucmVhZGFi bGU7CiAJaW50IGJncGlvX2JpdHM7Ci0Jc3BpbmxvY2tfdCBiZ3Bpb19sb2NrOworCXJhd19zcGlu bG9ja190IGJncGlvX2xvY2s7CiAJdW5zaWduZWQgbG9uZyBiZ3Bpb19kYXRhOwogCXVuc2lnbmVk IGxvbmcgYmdwaW9fZGlyOwogI2VuZGlmIC8qIENPTkZJR19HUElPX0dFTkVSSUMgKi8KLS0gCjIu MjQuMyAoQXBwbGUgR2l0LTEyOCkKCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fXwpsaW51eC1hcm0ta2VybmVsIG1haWxpbmcgbGlzdApsaW51eC1hcm0ta2Vy bmVsQGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1h bi9saXN0aW5mby9saW51eC1hcm0ta2VybmVsCg==