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 9D919ECAAD3 for ; Thu, 1 Sep 2022 11:07:34 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S234456AbiIALHc (ORCPT ); Thu, 1 Sep 2022 07:07:32 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:50916 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233930AbiIALHN (ORCPT ); Thu, 1 Sep 2022 07:07:13 -0400 Received: from smtp-out2.suse.de (smtp-out2.suse.de [195.135.220.29]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 494CD1321E8; Thu, 1 Sep 2022 04:07:11 -0700 (PDT) Received: from relay2.suse.de (relay2.suse.de [149.44.160.134]) by smtp-out2.suse.de (Postfix) with ESMTP id CB7D61FF4B; Thu, 1 Sep 2022 11:07:09 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=suse.cz; s=susede2_rsa; t=1662030429; h=from:from:reply-to:date:date:message-id:message-id:to:to:cc:cc: mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=TR522oSc/XjpQrSgmlSIskBoUD5syTk9/HGQdD+o0EU=; b=Kj7Fcq8MxlElz3VODQ5zo0Kag+gsc3vIsKQD3k8IBCBVwh23zBJNfmHXXtuQzcNcDg9mTE pJt6Z9bg6U8taR1KPVjeZ6ie8kyPDgCPef9F14S6Mlc762cQJmo/GMLahVPCvnWe+HO0S9 2aWzJeD2HaBAaIBbwheFBnNDxF0Q2Ho= DKIM-Signature: v=1; a=ed25519-sha256; c=relaxed/relaxed; d=suse.cz; s=susede2_ed25519; t=1662030429; h=from:from:reply-to:date:date:message-id:message-id:to:to:cc:cc: mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=TR522oSc/XjpQrSgmlSIskBoUD5syTk9/HGQdD+o0EU=; b=D8MTX+4alvundHuvcXlwd2iIMKgjesM6x1qH9a3dEFd8pXynFkpwwNIj7GF8Ug2e9sRQI8 78fjPvMa7bhCrqDQ== Received: from localhost.localdomain (unknown [10.100.208.98]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by relay2.suse.de (Postfix) with ESMTPS id 5284D2C142; Thu, 1 Sep 2022 11:07:08 +0000 (UTC) From: Jiri Slaby To: gregkh@linuxfoundation.org Cc: =?UTF-8?q?Ilpo=20J=C3=A4rvinen?= , linux-serial@vger.kernel.org, linux-kernel@vger.kernel.org, Jiri Slaby , Russell King , Florian Fainelli , bcm-kernel-feedback-list@broadcom.com, =?UTF-8?q?Pali=20Roh=C3=A1r?= , Kevin Cernekee , Palmer Dabbelt , Paul Walmsley , Orson Zhai , Baolin Wang , Chunyan Zhang , Patrice Chotard , linux-riscv@lists.infradead.org Subject: [PATCH v2 3/3] tty: serial: use DEFINE_UART_PORT_TX_HELPER_LIMITED() Date: Thu, 1 Sep 2022 13:06:57 +0200 Message-Id: <20220901110657.3305-4-jslaby@suse.cz> X-Mailer: git-send-email 2.37.2 In-Reply-To: <20220901110657.3305-1-jslaby@suse.cz> References: <20220901110657.3305-1-jslaby@suse.cz> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org DEFINE_UART_PORT_TX_HELPER_LIMITED() is a new helper to send characters to the device. Use it in these drivers. mux.c also needs to define tx_done(). But I'm not sure if the driver really wants to wait for all the characters to dismiss from the HW fifo at this code point. Hence I marked this as FIXME. Signed-off-by: Jiri Slaby Cc: Russell King Cc: Florian Fainelli Cc: bcm-kernel-feedback-list@broadcom.com Cc: "Pali Rohár" Cc: Kevin Cernekee Cc: Palmer Dabbelt Cc: Paul Walmsley Cc: Orson Zhai Cc: Baolin Wang Cc: Chunyan Zhang Cc: Patrice Chotard Cc: linux-riscv@lists.infradead.org --- drivers/tty/serial/21285.c | 33 ++++-------------- drivers/tty/serial/altera_jtaguart.c | 42 ++++++----------------- drivers/tty/serial/amba-pl010.c | 37 +++----------------- drivers/tty/serial/apbuart.c | 36 ++++---------------- drivers/tty/serial/bcm63xx_uart.c | 47 +++++--------------------- drivers/tty/serial/mux.c | 46 ++++++++----------------- drivers/tty/serial/mvebu-uart.c | 40 ++++------------------ drivers/tty/serial/omap-serial.c | 47 +++++++------------------- drivers/tty/serial/pxa.c | 39 +++++----------------- drivers/tty/serial/rp2.c | 36 ++++---------------- drivers/tty/serial/serial_txx9.c | 37 +++----------------- drivers/tty/serial/sifive.c | 45 +++---------------------- drivers/tty/serial/sprd_serial.c | 38 +++------------------ drivers/tty/serial/st-asc.c | 50 ++++------------------------ 14 files changed, 103 insertions(+), 470 deletions(-) diff --git a/drivers/tty/serial/21285.c b/drivers/tty/serial/21285.c index 7520cc02fd4d..a23401aa0847 100644 --- a/drivers/tty/serial/21285.c +++ b/drivers/tty/serial/21285.c @@ -151,38 +151,17 @@ static irqreturn_t serial21285_rx_chars(int irq, void *dev_id) return IRQ_HANDLED; } +static DEFINE_UART_PORT_TX_HELPER_LIMITED(serial21285_do_tx_chars, port, ch, + !(*CSR_UARTFLG & 0x20), + *CSR_UARTDR = ch, + ({})); + static irqreturn_t serial21285_tx_chars(int irq, void *dev_id) { struct uart_port *port = dev_id; - struct circ_buf *xmit = &port->state->xmit; - int count = 256; - - if (port->x_char) { - *CSR_UARTDR = port->x_char; - port->icount.tx++; - port->x_char = 0; - goto out; - } - if (uart_circ_empty(xmit) || uart_tx_stopped(port)) { - serial21285_stop_tx(port); - goto out; - } - - do { - *CSR_UARTDR = xmit->buf[xmit->tail]; - xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1); - port->icount.tx++; - if (uart_circ_empty(xmit)) - break; - } while (--count > 0 && !(*CSR_UARTFLG & 0x20)); - - if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS) - uart_write_wakeup(port); - if (uart_circ_empty(xmit)) - serial21285_stop_tx(port); + serial21285_do_tx_chars(port, 256); - out: return IRQ_HANDLED; } diff --git a/drivers/tty/serial/altera_jtaguart.c b/drivers/tty/serial/altera_jtaguart.c index cb791c5149a3..928ed419e969 100644 --- a/drivers/tty/serial/altera_jtaguart.c +++ b/drivers/tty/serial/altera_jtaguart.c @@ -134,42 +134,20 @@ static void altera_jtaguart_rx_chars(struct altera_jtaguart *pp) tty_flip_buffer_push(&port->state->port); } +static DEFINE_UART_PORT_TX_HELPER_LIMITED(altera_jtaguart_do_tx_chars, port, ch, + true, + writel(ch, port->membase + ALTERA_JTAGUART_DATA_REG), + ({})); + static void altera_jtaguart_tx_chars(struct altera_jtaguart *pp) { struct uart_port *port = &pp->port; - struct circ_buf *xmit = &port->state->xmit; - unsigned int pending, count; - - if (port->x_char) { - /* Send special char - probably flow control */ - writel(port->x_char, port->membase + ALTERA_JTAGUART_DATA_REG); - port->x_char = 0; - port->icount.tx++; - return; - } - - pending = uart_circ_chars_pending(xmit); - if (pending > 0) { - count = (readl(port->membase + ALTERA_JTAGUART_CONTROL_REG) & - ALTERA_JTAGUART_CONTROL_WSPACE_MSK) >> - ALTERA_JTAGUART_CONTROL_WSPACE_OFF; - if (count > pending) - count = pending; - if (count > 0) { - pending -= count; - while (count--) { - writel(xmit->buf[xmit->tail], - port->membase + ALTERA_JTAGUART_DATA_REG); - xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1); - port->icount.tx++; - } - if (pending < WAKEUP_CHARS) - uart_write_wakeup(port); - } - } + unsigned int space; - if (pending == 0) - altera_jtaguart_stop_tx(port); + space = (readl(port->membase + ALTERA_JTAGUART_CONTROL_REG) & + ALTERA_JTAGUART_CONTROL_WSPACE_MSK) >> + ALTERA_JTAGUART_CONTROL_WSPACE_OFF; + altera_jtaguart_do_tx_chars(port, space); } static irqreturn_t altera_jtaguart_interrupt(int irq, void *data) diff --git a/drivers/tty/serial/amba-pl010.c b/drivers/tty/serial/amba-pl010.c index fae0b581ff42..cc95e5546b79 100644 --- a/drivers/tty/serial/amba-pl010.c +++ b/drivers/tty/serial/amba-pl010.c @@ -162,37 +162,10 @@ static void pl010_rx_chars(struct uart_port *port) tty_flip_buffer_push(&port->state->port); } -static void pl010_tx_chars(struct uart_port *port) -{ - struct circ_buf *xmit = &port->state->xmit; - int count; - - if (port->x_char) { - writel(port->x_char, port->membase + UART01x_DR); - port->icount.tx++; - port->x_char = 0; - return; - } - if (uart_circ_empty(xmit) || uart_tx_stopped(port)) { - pl010_stop_tx(port); - return; - } - - count = port->fifosize >> 1; - do { - writel(xmit->buf[xmit->tail], port->membase + UART01x_DR); - xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1); - port->icount.tx++; - if (uart_circ_empty(xmit)) - break; - } while (--count > 0); - - if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS) - uart_write_wakeup(port); - - if (uart_circ_empty(xmit)) - pl010_stop_tx(port); -} +static DEFINE_UART_PORT_TX_HELPER_LIMITED(pl010_tx_chars, port, ch, + true, + writel(ch, port->membase + UART01x_DR), + ({})); static void pl010_modem_status(struct uart_amba_port *uap) { @@ -238,7 +211,7 @@ static irqreturn_t pl010_int(int irq, void *dev_id) if (status & UART010_IIR_MIS) pl010_modem_status(uap); if (status & UART010_IIR_TIS) - pl010_tx_chars(port); + pl010_tx_chars(port, port->fifosize >> 1); if (pass_counter-- == 0) break; diff --git a/drivers/tty/serial/apbuart.c b/drivers/tty/serial/apbuart.c index 9ef82d870ff2..06c880ed7036 100644 --- a/drivers/tty/serial/apbuart.c +++ b/drivers/tty/serial/apbuart.c @@ -120,38 +120,14 @@ static void apbuart_rx_chars(struct uart_port *port) tty_flip_buffer_push(&port->state->port); } +static DEFINE_UART_PORT_TX_HELPER_LIMITED(apbuart_do_tx_chars, port, ch, + true, + UART_PUT_CHAR(port, ch), + ({})); + static void apbuart_tx_chars(struct uart_port *port) { - struct circ_buf *xmit = &port->state->xmit; - int count; - - if (port->x_char) { - UART_PUT_CHAR(port, port->x_char); - port->icount.tx++; - port->x_char = 0; - return; - } - - if (uart_circ_empty(xmit) || uart_tx_stopped(port)) { - apbuart_stop_tx(port); - return; - } - - /* amba: fill FIFO */ - count = port->fifosize >> 1; - do { - UART_PUT_CHAR(port, xmit->buf[xmit->tail]); - xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1); - port->icount.tx++; - if (uart_circ_empty(xmit)) - break; - } while (--count > 0); - - if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS) - uart_write_wakeup(port); - - if (uart_circ_empty(xmit)) - apbuart_stop_tx(port); + apbuart_do_tx_chars(port, port->fifosize >> 1); } static irqreturn_t apbuart_int(int irq, void *dev_id) diff --git a/drivers/tty/serial/bcm63xx_uart.c b/drivers/tty/serial/bcm63xx_uart.c index 53b43174aa40..1b9f0cec3aa1 100644 --- a/drivers/tty/serial/bcm63xx_uart.c +++ b/drivers/tty/serial/bcm63xx_uart.c @@ -297,59 +297,30 @@ static void bcm_uart_do_rx(struct uart_port *port) tty_flip_buffer_push(tty_port); } +static DEFINE_UART_PORT_TX_HELPER_LIMITED(bcm_uart_tx, port, ch, + true, + bcm_uart_writel(port, ch, UART_FIFO_REG), + ({})); + /* * fill tx fifo with chars to send, stop when fifo is about to be full * or when all chars have been sent. */ static void bcm_uart_do_tx(struct uart_port *port) { - struct circ_buf *xmit; - unsigned int val, max_count; - - if (port->x_char) { - bcm_uart_writel(port, port->x_char, UART_FIFO_REG); - port->icount.tx++; - port->x_char = 0; - return; - } - - if (uart_tx_stopped(port)) { - bcm_uart_stop_tx(port); - return; - } - - xmit = &port->state->xmit; - if (uart_circ_empty(xmit)) - goto txq_empty; + unsigned int val, pending; val = bcm_uart_readl(port, UART_MCTL_REG); val = (val & UART_MCTL_TXFIFOFILL_MASK) >> UART_MCTL_TXFIFOFILL_SHIFT; - max_count = port->fifosize - val; - - while (max_count--) { - unsigned int c; - c = xmit->buf[xmit->tail]; - bcm_uart_writel(port, c, UART_FIFO_REG); - xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1); - port->icount.tx++; - if (uart_circ_empty(xmit)) - break; - } - - if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS) - uart_write_wakeup(port); - - if (uart_circ_empty(xmit)) - goto txq_empty; - return; + pending = bcm_uart_tx(port, port->fifosize - val); + if (pending) + return; -txq_empty: /* nothing to send, disable transmit interrupt */ val = bcm_uart_readl(port, UART_IR_REG); val &= ~UART_TX_INT_MASK; bcm_uart_writel(port, val, UART_IR_REG); - return; } /* diff --git a/drivers/tty/serial/mux.c b/drivers/tty/serial/mux.c index 0ba0f4d9459d..f65f694fdecd 100644 --- a/drivers/tty/serial/mux.c +++ b/drivers/tty/serial/mux.c @@ -171,6 +171,18 @@ static void mux_break_ctl(struct uart_port *port, int break_state) { } +static void mux_tx_done(struct uart_port *port) +{ + /* FIXME js: really needs to wait? */ + while (UART_GET_FIFO_CNT(port)) + udelay(1); +} + +static DEFINE_UART_PORT_TX_HELPER_LIMITED(mux_transmit, port, ch, + true, + UART_PUT_CHAR(port, ch), + mux_tx_done(port)); + /** * mux_write - Write chars to the mux fifo. * @port: Ptr to the uart_port. @@ -180,39 +192,7 @@ static void mux_break_ctl(struct uart_port *port, int break_state) */ static void mux_write(struct uart_port *port) { - int count; - struct circ_buf *xmit = &port->state->xmit; - - if(port->x_char) { - UART_PUT_CHAR(port, port->x_char); - port->icount.tx++; - port->x_char = 0; - return; - } - - if(uart_circ_empty(xmit) || uart_tx_stopped(port)) { - mux_stop_tx(port); - return; - } - - count = (port->fifosize) - UART_GET_FIFO_CNT(port); - do { - UART_PUT_CHAR(port, xmit->buf[xmit->tail]); - xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1); - port->icount.tx++; - if(uart_circ_empty(xmit)) - break; - - } while(--count > 0); - - while(UART_GET_FIFO_CNT(port)) - udelay(1); - - if(uart_circ_chars_pending(xmit) < WAKEUP_CHARS) - uart_write_wakeup(port); - - if (uart_circ_empty(xmit)) - mux_stop_tx(port); + mux_transmit(port, port->fifosize - UART_GET_FIFO_CNT(port)); } /** diff --git a/drivers/tty/serial/mvebu-uart.c b/drivers/tty/serial/mvebu-uart.c index 65eaecd10b7c..1dc0d9bcf797 100644 --- a/drivers/tty/serial/mvebu-uart.c +++ b/drivers/tty/serial/mvebu-uart.c @@ -333,42 +333,14 @@ static void mvebu_uart_rx_chars(struct uart_port *port, unsigned int status) tty_flip_buffer_push(tport); } +static DEFINE_UART_PORT_TX_HELPER_LIMITED(mvebu_uart_do_tx_chars, port, ch, + !(readl(port->membase + UART_STAT) & STAT_TX_FIFO_FUL), + writel(ch, port->membase + UART_TSH(port)), + ({})); + static void mvebu_uart_tx_chars(struct uart_port *port, unsigned int status) { - struct circ_buf *xmit = &port->state->xmit; - unsigned int count; - unsigned int st; - - if (port->x_char) { - writel(port->x_char, port->membase + UART_TSH(port)); - port->icount.tx++; - port->x_char = 0; - return; - } - - if (uart_circ_empty(xmit) || uart_tx_stopped(port)) { - mvebu_uart_stop_tx(port); - return; - } - - for (count = 0; count < port->fifosize; count++) { - writel(xmit->buf[xmit->tail], port->membase + UART_TSH(port)); - xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1); - port->icount.tx++; - - if (uart_circ_empty(xmit)) - break; - - st = readl(port->membase + UART_STAT); - if (st & STAT_TX_FIFO_FUL) - break; - } - - if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS) - uart_write_wakeup(port); - - if (uart_circ_empty(xmit)) - mvebu_uart_stop_tx(port); + mvebu_uart_do_tx_chars(port, port->fifosize); } static irqreturn_t mvebu_uart_isr(int irq, void *dev_id) diff --git a/drivers/tty/serial/omap-serial.c b/drivers/tty/serial/omap-serial.c index 0aa666e247d5..a0ccde3b33e3 100644 --- a/drivers/tty/serial/omap-serial.c +++ b/drivers/tty/serial/omap-serial.c @@ -337,45 +337,22 @@ static void serial_omap_stop_rx(struct uart_port *port) serial_out(up, UART_IER, up->ier); } -static void transmit_chars(struct uart_omap_port *up, unsigned int lsr) +static void serial_omap_put_char(struct uart_port *port, unsigned char ch) { - struct circ_buf *xmit = &up->port.state->xmit; - int count; - - if (up->port.x_char) { - serial_out(up, UART_TX, up->port.x_char); - up->port.icount.tx++; - up->port.x_char = 0; - if ((up->port.rs485.flags & SER_RS485_ENABLED) && - !(up->port.rs485.flags & SER_RS485_RX_DURING_TX)) - up->rs485_tx_filter_count++; - - return; - } - if (uart_circ_empty(xmit) || uart_tx_stopped(&up->port)) { - serial_omap_stop_tx(&up->port); - return; - } - count = up->port.fifosize / 4; - do { - serial_out(up, UART_TX, xmit->buf[xmit->tail]); - xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1); - up->port.icount.tx++; - if ((up->port.rs485.flags & SER_RS485_ENABLED) && - !(up->port.rs485.flags & SER_RS485_RX_DURING_TX)) - up->rs485_tx_filter_count++; - - if (uart_circ_empty(xmit)) - break; - } while (--count > 0); + struct uart_omap_port *up = to_uart_omap_port(port); - if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS) - uart_write_wakeup(&up->port); + serial_out(up, UART_TX, ch); - if (uart_circ_empty(xmit)) - serial_omap_stop_tx(&up->port); + if ((up->port.rs485.flags & SER_RS485_ENABLED) && + !(up->port.rs485.flags & SER_RS485_RX_DURING_TX)) + up->rs485_tx_filter_count++; } +static DEFINE_UART_PORT_TX_HELPER_LIMITED(transmit_chars, port, ch, + true, + serial_omap_put_char(port, ch), + ({})); + static inline void serial_omap_enable_ier_thri(struct uart_omap_port *up) { if (!(up->ier & UART_IER_THRI)) { @@ -573,7 +550,7 @@ static irqreturn_t serial_omap_irq(int irq, void *dev_id) check_modem_status(up); break; case UART_IIR_THRI: - transmit_chars(up, lsr); + transmit_chars(&up->port, up->port.fifosize / 4); break; case UART_IIR_RX_TIMEOUT: case UART_IIR_RDI: diff --git a/drivers/tty/serial/pxa.c b/drivers/tty/serial/pxa.c index 9309ffd87c8e..c1376e8adbf4 100644 --- a/drivers/tty/serial/pxa.c +++ b/drivers/tty/serial/pxa.c @@ -172,39 +172,18 @@ static inline void receive_chars(struct uart_pxa_port *up, int *status) serial_out(up, UART_IER, up->ier); } -static void transmit_chars(struct uart_pxa_port *up) +static void serial_pxa_put_char(struct uart_port *port, u8 ch) { - struct circ_buf *xmit = &up->port.state->xmit; - int count; - - if (up->port.x_char) { - serial_out(up, UART_TX, up->port.x_char); - up->port.icount.tx++; - up->port.x_char = 0; - return; - } - if (uart_circ_empty(xmit) || uart_tx_stopped(&up->port)) { - serial_pxa_stop_tx(&up->port); - return; - } - - count = up->port.fifosize / 2; - do { - serial_out(up, UART_TX, xmit->buf[xmit->tail]); - xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1); - up->port.icount.tx++; - if (uart_circ_empty(xmit)) - break; - } while (--count > 0); - - if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS) - uart_write_wakeup(&up->port); - + struct uart_pxa_port *up = (struct uart_pxa_port *)port; - if (uart_circ_empty(xmit)) - serial_pxa_stop_tx(&up->port); + serial_out(up, UART_TX, ch); } +static DEFINE_UART_PORT_TX_HELPER_LIMITED(transmit_chars, port, ch, + true, + serial_pxa_put_char(port, ch), + ({})); + static void serial_pxa_start_tx(struct uart_port *port) { struct uart_pxa_port *up = (struct uart_pxa_port *)port; @@ -254,7 +233,7 @@ static inline irqreturn_t serial_pxa_irq(int irq, void *dev_id) receive_chars(up, &lsr); check_modem_status(up); if (lsr & UART_LSR_THRE) - transmit_chars(up); + transmit_chars(&up->port, up->port.fifosize / 2); spin_unlock(&up->port.lock); return IRQ_HANDLED; } diff --git a/drivers/tty/serial/rp2.c b/drivers/tty/serial/rp2.c index 6689d8add8f7..8719022b189d 100644 --- a/drivers/tty/serial/rp2.c +++ b/drivers/tty/serial/rp2.c @@ -426,35 +426,10 @@ static void rp2_rx_chars(struct rp2_uart_port *up) tty_flip_buffer_push(port); } -static void rp2_tx_chars(struct rp2_uart_port *up) -{ - u16 max_tx = FIFO_SIZE - readw(up->base + RP2_TX_FIFO_COUNT); - struct circ_buf *xmit = &up->port.state->xmit; - - if (uart_tx_stopped(&up->port)) { - rp2_uart_stop_tx(&up->port); - return; - } - - for (; max_tx != 0; max_tx--) { - if (up->port.x_char) { - writeb(up->port.x_char, up->base + RP2_DATA_BYTE); - up->port.x_char = 0; - up->port.icount.tx++; - continue; - } - if (uart_circ_empty(xmit)) { - rp2_uart_stop_tx(&up->port); - break; - } - writeb(xmit->buf[xmit->tail], up->base + RP2_DATA_BYTE); - xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1); - up->port.icount.tx++; - } - - if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS) - uart_write_wakeup(&up->port); -} +static DEFINE_UART_PORT_TX_HELPER_LIMITED(rp2_tx_chars, port, ch, + true, + writeb(ch, port_to_up(port)->base + RP2_DATA_BYTE), + ({})); static void rp2_ch_interrupt(struct rp2_uart_port *up) { @@ -472,7 +447,8 @@ static void rp2_ch_interrupt(struct rp2_uart_port *up) if (status & RP2_CHAN_STAT_RXDATA_m) rp2_rx_chars(up); if (status & RP2_CHAN_STAT_TXEMPTY_m) - rp2_tx_chars(up); + rp2_tx_chars(&up->port, + FIFO_SIZE - readw(up->base + RP2_TX_FIFO_COUNT)); if (status & RP2_CHAN_STAT_MS_CHANGED_MASK) wake_up_interruptible(&up->port.state->port.delta_msr_wait); diff --git a/drivers/tty/serial/serial_txx9.c b/drivers/tty/serial/serial_txx9.c index 228e380db080..855ad3b457f7 100644 --- a/drivers/tty/serial/serial_txx9.c +++ b/drivers/tty/serial/serial_txx9.c @@ -319,37 +319,10 @@ receive_chars(struct uart_port *up, unsigned int *status) *status = disr; } -static inline void transmit_chars(struct uart_port *up) -{ - struct circ_buf *xmit = &up->state->xmit; - int count; - - if (up->x_char) { - sio_out(up, TXX9_SITFIFO, up->x_char); - up->icount.tx++; - up->x_char = 0; - return; - } - if (uart_circ_empty(xmit) || uart_tx_stopped(up)) { - serial_txx9_stop_tx(up); - return; - } - - count = TXX9_SIO_TX_FIFO; - do { - sio_out(up, TXX9_SITFIFO, xmit->buf[xmit->tail]); - xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1); - up->icount.tx++; - if (uart_circ_empty(xmit)) - break; - } while (--count > 0); - - if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS) - uart_write_wakeup(up); - - if (uart_circ_empty(xmit)) - serial_txx9_stop_tx(up); -} +static DEFINE_UART_PORT_TX_HELPER_LIMITED(transmit_chars, port, ch, + true, + sio_out(port, TXX9_SITFIFO, ch), + ({})); static irqreturn_t serial_txx9_interrupt(int irq, void *dev_id) { @@ -371,7 +344,7 @@ static irqreturn_t serial_txx9_interrupt(int irq, void *dev_id) if (status & TXX9_SIDISR_RDIS) receive_chars(up, &status); if (status & TXX9_SIDISR_TDIS) - transmit_chars(up); + transmit_chars(up, TXX9_SIO_TX_FIFO); /* Clear TX/RX Int. Status */ sio_mask(up, TXX9_SIDISR, TXX9_SIDISR_TDIS | TXX9_SIDISR_RDIS | diff --git a/drivers/tty/serial/sifive.c b/drivers/tty/serial/sifive.c index 5c3a07546a58..78180f936bf3 100644 --- a/drivers/tty/serial/sifive.c +++ b/drivers/tty/serial/sifive.c @@ -277,45 +277,10 @@ static void __ssp_transmit_char(struct sifive_serial_port *ssp, int ch) __ssp_writel(ch, SIFIVE_SERIAL_TXDATA_OFFS, ssp); } -/** - * __ssp_transmit_chars() - enqueue multiple bytes onto the TX FIFO - * @ssp: pointer to a struct sifive_serial_port - * - * Transfer up to a TX FIFO size's worth of characters from the Linux serial - * transmit buffer to the SiFive UART TX FIFO. - * - * Context: Any context. Expects @ssp->port.lock to be held by caller. - */ -static void __ssp_transmit_chars(struct sifive_serial_port *ssp) -{ - struct circ_buf *xmit = &ssp->port.state->xmit; - int count; - - if (ssp->port.x_char) { - __ssp_transmit_char(ssp, ssp->port.x_char); - ssp->port.icount.tx++; - ssp->port.x_char = 0; - return; - } - if (uart_circ_empty(xmit) || uart_tx_stopped(&ssp->port)) { - sifive_serial_stop_tx(&ssp->port); - return; - } - count = SIFIVE_TX_FIFO_DEPTH; - do { - __ssp_transmit_char(ssp, xmit->buf[xmit->tail]); - xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1); - ssp->port.icount.tx++; - if (uart_circ_empty(xmit)) - break; - } while (--count > 0); - - if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS) - uart_write_wakeup(&ssp->port); - - if (uart_circ_empty(xmit)) - sifive_serial_stop_tx(&ssp->port); -} +static DEFINE_UART_PORT_TX_HELPER_LIMITED(__ssp_transmit_chars, port, ch, + true, + __ssp_transmit_char(port_to_sifive_serial_port(port), ch), + ({})); /** * __ssp_enable_txwm() - enable transmit watermark interrupts @@ -553,7 +518,7 @@ static irqreturn_t sifive_serial_irq(int irq, void *dev_id) if (ip & SIFIVE_SERIAL_IP_RXWM_MASK) __ssp_receive_chars(ssp); if (ip & SIFIVE_SERIAL_IP_TXWM_MASK) - __ssp_transmit_chars(ssp); + __ssp_transmit_chars(&ssp->port, SIFIVE_TX_FIFO_DEPTH); spin_unlock(&ssp->port.lock); diff --git a/drivers/tty/serial/sprd_serial.c b/drivers/tty/serial/sprd_serial.c index 4329b9c9cbf0..e217b7ab69af 100644 --- a/drivers/tty/serial/sprd_serial.c +++ b/drivers/tty/serial/sprd_serial.c @@ -624,38 +624,10 @@ static inline void sprd_rx(struct uart_port *port) tty_flip_buffer_push(tty); } -static inline void sprd_tx(struct uart_port *port) -{ - struct circ_buf *xmit = &port->state->xmit; - int count; - - if (port->x_char) { - serial_out(port, SPRD_TXD, port->x_char); - port->icount.tx++; - port->x_char = 0; - return; - } - - if (uart_circ_empty(xmit) || uart_tx_stopped(port)) { - sprd_stop_tx(port); - return; - } - - count = THLD_TX_EMPTY; - do { - serial_out(port, SPRD_TXD, xmit->buf[xmit->tail]); - xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1); - port->icount.tx++; - if (uart_circ_empty(xmit)) - break; - } while (--count > 0); - - if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS) - uart_write_wakeup(port); - - if (uart_circ_empty(xmit)) - sprd_stop_tx(port); -} +static DEFINE_UART_PORT_TX_HELPER_LIMITED(sprd_tx, port, ch, + true, + serial_out(port, SPRD_TXD, ch), + ({})); /* this handles the interrupt from one port */ static irqreturn_t sprd_handle_irq(int irq, void *dev_id) @@ -683,7 +655,7 @@ static irqreturn_t sprd_handle_irq(int irq, void *dev_id) sprd_rx(port); if (ims & SPRD_IMSR_TX_FIFO_EMPTY) - sprd_tx(port); + sprd_tx(port, THLD_TX_EMPTY); spin_unlock(&port->lock); diff --git a/drivers/tty/serial/st-asc.c b/drivers/tty/serial/st-asc.c index cce42f4c9bc2..f5dd3fa4bf26 100644 --- a/drivers/tty/serial/st-asc.c +++ b/drivers/tty/serial/st-asc.c @@ -230,6 +230,11 @@ static inline unsigned asc_hw_txroom(struct uart_port *port) return 0; } +static DEFINE_UART_PORT_TX_HELPER_LIMITED(asc_do_transmit_chars, port, ch, + true, + asc_out(port, ASC_TXBUF, ch), + ({})); + /* * Start transmitting chars. * This is called from both interrupt and task level. @@ -237,50 +242,7 @@ static inline unsigned asc_hw_txroom(struct uart_port *port) */ static void asc_transmit_chars(struct uart_port *port) { - struct circ_buf *xmit = &port->state->xmit; - int txroom; - unsigned char c; - - txroom = asc_hw_txroom(port); - - if ((txroom != 0) && port->x_char) { - c = port->x_char; - port->x_char = 0; - asc_out(port, ASC_TXBUF, c); - port->icount.tx++; - txroom = asc_hw_txroom(port); - } - - if (uart_tx_stopped(port)) { - /* - * We should try and stop the hardware here, but I - * don't think the ASC has any way to do that. - */ - asc_disable_tx_interrupts(port); - return; - } - - if (uart_circ_empty(xmit)) { - asc_disable_tx_interrupts(port); - return; - } - - if (txroom == 0) - return; - - do { - c = xmit->buf[xmit->tail]; - xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1); - asc_out(port, ASC_TXBUF, c); - port->icount.tx++; - txroom--; - } while ((txroom > 0) && (!uart_circ_empty(xmit))); - - if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS) - uart_write_wakeup(port); - - if (uart_circ_empty(xmit)) - asc_disable_tx_interrupts(port); + asc_do_transmit_chars(port, asc_hw_txroom(port)); } static void asc_receive_chars(struct uart_port *port) -- 2.37.2 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 B920CECAAD3 for ; Thu, 1 Sep 2022 11:07:29 +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=l1orlbLz1qUoWIZaXFyYTfiP9Nxcgq40Zc2cRRfWpAI=; b=qidZw+OMgfVlY+ DFqz8op63QQ+dBB7WSpV4nrJxqZOg+K4RIhzcdNzHI4Dabc9GijFiTyzUT4nQLF+xHedw+F9O30cX Lnjes/+MLSsa/h80wRRiR9pR05Zy4FM9TDuaZv5fyZafo4oftGCJC/Vc9XXo2vShpdza5Bf9AzLh7 5sBy/IowR1PI+EyR8gkhXOV/YEv+LorzxQkD2Z5nz+mVPRIBvAeAPPON8pqIxEJ24I40jovBE68k8 mqR/xDW5FkNWYHesETZayNdPEYZXn9plsRnvO+cO72c/rR0HRWU4UBZSQnUz19xarNi6xvGUQNFuk 1qxRbyOJW459JPjl/J2g==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1oTi2X-00BFrh-L6; Thu, 01 Sep 2022 11:07:17 +0000 Received: from smtp-out2.suse.de ([2001:67c:2178:6::1d]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1oTi2T-00BFnX-UF for linux-riscv@lists.infradead.org; Thu, 01 Sep 2022 11:07:17 +0000 Received: from relay2.suse.de (relay2.suse.de [149.44.160.134]) by smtp-out2.suse.de (Postfix) with ESMTP id CB7D61FF4B; Thu, 1 Sep 2022 11:07:09 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=suse.cz; s=susede2_rsa; t=1662030429; h=from:from:reply-to:date:date:message-id:message-id:to:to:cc:cc: mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=TR522oSc/XjpQrSgmlSIskBoUD5syTk9/HGQdD+o0EU=; b=Kj7Fcq8MxlElz3VODQ5zo0Kag+gsc3vIsKQD3k8IBCBVwh23zBJNfmHXXtuQzcNcDg9mTE pJt6Z9bg6U8taR1KPVjeZ6ie8kyPDgCPef9F14S6Mlc762cQJmo/GMLahVPCvnWe+HO0S9 2aWzJeD2HaBAaIBbwheFBnNDxF0Q2Ho= DKIM-Signature: v=1; a=ed25519-sha256; c=relaxed/relaxed; d=suse.cz; s=susede2_ed25519; t=1662030429; h=from:from:reply-to:date:date:message-id:message-id:to:to:cc:cc: mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=TR522oSc/XjpQrSgmlSIskBoUD5syTk9/HGQdD+o0EU=; b=D8MTX+4alvundHuvcXlwd2iIMKgjesM6x1qH9a3dEFd8pXynFkpwwNIj7GF8Ug2e9sRQI8 78fjPvMa7bhCrqDQ== Received: from localhost.localdomain (unknown [10.100.208.98]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by relay2.suse.de (Postfix) with ESMTPS id 5284D2C142; Thu, 1 Sep 2022 11:07:08 +0000 (UTC) From: Jiri Slaby To: gregkh@linuxfoundation.org Cc: =?UTF-8?q?Ilpo=20J=C3=A4rvinen?= , linux-serial@vger.kernel.org, linux-kernel@vger.kernel.org, Jiri Slaby , Russell King , Florian Fainelli , bcm-kernel-feedback-list@broadcom.com, =?UTF-8?q?Pali=20Roh=C3=A1r?= , Kevin Cernekee , Palmer Dabbelt , Paul Walmsley , Orson Zhai , Baolin Wang , Chunyan Zhang , Patrice Chotard , linux-riscv@lists.infradead.org Subject: [PATCH v2 3/3] tty: serial: use DEFINE_UART_PORT_TX_HELPER_LIMITED() Date: Thu, 1 Sep 2022 13:06:57 +0200 Message-Id: <20220901110657.3305-4-jslaby@suse.cz> X-Mailer: git-send-email 2.37.2 In-Reply-To: <20220901110657.3305-1-jslaby@suse.cz> References: <20220901110657.3305-1-jslaby@suse.cz> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20220901_040714_312432_68100583 X-CRM114-Status: GOOD ( 22.13 ) X-BeenThere: linux-riscv@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-riscv" Errors-To: linux-riscv-bounces+linux-riscv=archiver.kernel.org@lists.infradead.org REVGSU5FX1VBUlRfUE9SVF9UWF9IRUxQRVJfTElNSVRFRCgpIGlzIGEgbmV3IGhlbHBlciB0byBz ZW5kIGNoYXJhY3RlcnMKdG8gdGhlIGRldmljZS4gVXNlIGl0IGluIHRoZXNlIGRyaXZlcnMuCgpt dXguYyBhbHNvIG5lZWRzIHRvIGRlZmluZSB0eF9kb25lKCkuIEJ1dCBJJ20gbm90IHN1cmUgaWYg dGhlIGRyaXZlcgpyZWFsbHkgd2FudHMgdG8gd2FpdCBmb3IgYWxsIHRoZSBjaGFyYWN0ZXJzIHRv IGRpc21pc3MgZnJvbSB0aGUgSFcgZmlmbwphdCB0aGlzIGNvZGUgcG9pbnQuIEhlbmNlIEkgbWFy a2VkIHRoaXMgYXMgRklYTUUuCgpTaWduZWQtb2ZmLWJ5OiBKaXJpIFNsYWJ5IDxqc2xhYnlAc3Vz ZS5jej4KQ2M6IFJ1c3NlbGwgS2luZyA8bGludXhAYXJtbGludXgub3JnLnVrPgpDYzogRmxvcmlh biBGYWluZWxsaSA8Zi5mYWluZWxsaUBnbWFpbC5jb20+CkNjOiBiY20ta2VybmVsLWZlZWRiYWNr LWxpc3RAYnJvYWRjb20uY29tCkNjOiAiUGFsaSBSb2jDoXIiIDxwYWxpQGtlcm5lbC5vcmc+CkNj OiBLZXZpbiBDZXJuZWtlZSA8Y2VybmVrZWVAZ21haWwuY29tPgpDYzogUGFsbWVyIERhYmJlbHQg PHBhbG1lckBkYWJiZWx0LmNvbT4KQ2M6IFBhdWwgV2FsbXNsZXkgPHBhdWwud2FsbXNsZXlAc2lm aXZlLmNvbT4KQ2M6IE9yc29uIFpoYWkgPG9yc29uemhhaUBnbWFpbC5jb20+CkNjOiBCYW9saW4g V2FuZyA8YmFvbGluLndhbmc3QGdtYWlsLmNvbT4KQ2M6IENodW55YW4gWmhhbmcgPHpoYW5nLmx5 cmFAZ21haWwuY29tPgpDYzogUGF0cmljZSBDaG90YXJkIDxwYXRyaWNlLmNob3RhcmRAZm9zcy5z dC5jb20+CkNjOiBsaW51eC1yaXNjdkBsaXN0cy5pbmZyYWRlYWQub3JnCi0tLQogZHJpdmVycy90 dHkvc2VyaWFsLzIxMjg1LmMgICAgICAgICAgIHwgMzMgKysrKy0tLS0tLS0tLS0tLS0tCiBkcml2 ZXJzL3R0eS9zZXJpYWwvYWx0ZXJhX2p0YWd1YXJ0LmMgfCA0MiArKysrKystLS0tLS0tLS0tLS0t LS0tLQogZHJpdmVycy90dHkvc2VyaWFsL2FtYmEtcGwwMTAuYyAgICAgIHwgMzcgKysrLS0tLS0t LS0tLS0tLS0tLS0KIGRyaXZlcnMvdHR5L3NlcmlhbC9hcGJ1YXJ0LmMgICAgICAgICB8IDM2ICsr KystLS0tLS0tLS0tLS0tLS0tCiBkcml2ZXJzL3R0eS9zZXJpYWwvYmNtNjN4eF91YXJ0LmMgICAg fCA0NyArKysrKy0tLS0tLS0tLS0tLS0tLS0tLS0tLQogZHJpdmVycy90dHkvc2VyaWFsL211eC5j ICAgICAgICAgICAgIHwgNDYgKysrKysrKystLS0tLS0tLS0tLS0tLS0tLQogZHJpdmVycy90dHkv c2VyaWFsL212ZWJ1LXVhcnQuYyAgICAgIHwgNDAgKysrKy0tLS0tLS0tLS0tLS0tLS0tLQogZHJp dmVycy90dHkvc2VyaWFsL29tYXAtc2VyaWFsLmMgICAgIHwgNDcgKysrKysrKy0tLS0tLS0tLS0t LS0tLS0tLS0KIGRyaXZlcnMvdHR5L3NlcmlhbC9weGEuYyAgICAgICAgICAgICB8IDM5ICsrKysr LS0tLS0tLS0tLS0tLS0tLS0KIGRyaXZlcnMvdHR5L3NlcmlhbC9ycDIuYyAgICAgICAgICAgICB8 IDM2ICsrKystLS0tLS0tLS0tLS0tLS0tCiBkcml2ZXJzL3R0eS9zZXJpYWwvc2VyaWFsX3R4eDku YyAgICAgfCAzNyArKystLS0tLS0tLS0tLS0tLS0tLQogZHJpdmVycy90dHkvc2VyaWFsL3NpZml2 ZS5jICAgICAgICAgIHwgNDUgKysrLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogZHJpdmVycy90dHkv c2VyaWFsL3NwcmRfc2VyaWFsLmMgICAgIHwgMzggKysrLS0tLS0tLS0tLS0tLS0tLS0tCiBkcml2 ZXJzL3R0eS9zZXJpYWwvc3QtYXNjLmMgICAgICAgICAgfCA1MCArKysrLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tCiAxNCBmaWxlcyBjaGFuZ2VkLCAxMDMgaW5zZXJ0aW9ucygrKSwgNDcwIGRlbGV0 aW9ucygtKQoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdHR5L3NlcmlhbC8yMTI4NS5jIGIvZHJpdmVy cy90dHkvc2VyaWFsLzIxMjg1LmMKaW5kZXggNzUyMGNjMDJmZDRkLi5hMjM0MDFhYTA4NDcgMTAw NjQ0Ci0tLSBhL2RyaXZlcnMvdHR5L3NlcmlhbC8yMTI4NS5jCisrKyBiL2RyaXZlcnMvdHR5L3Nl cmlhbC8yMTI4NS5jCkBAIC0xNTEsMzggKzE1MSwxNyBAQCBzdGF0aWMgaXJxcmV0dXJuX3Qgc2Vy aWFsMjEyODVfcnhfY2hhcnMoaW50IGlycSwgdm9pZCAqZGV2X2lkKQogCXJldHVybiBJUlFfSEFO RExFRDsKIH0KIAorc3RhdGljIERFRklORV9VQVJUX1BPUlRfVFhfSEVMUEVSX0xJTUlURUQoc2Vy aWFsMjEyODVfZG9fdHhfY2hhcnMsIHBvcnQsIGNoLAorCQkhKCpDU1JfVUFSVEZMRyAmIDB4MjAp LAorCQkqQ1NSX1VBUlREUiA9IGNoLAorCQkoe30pKTsKKwogc3RhdGljIGlycXJldHVybl90IHNl cmlhbDIxMjg1X3R4X2NoYXJzKGludCBpcnEsIHZvaWQgKmRldl9pZCkKIHsKIAlzdHJ1Y3QgdWFy dF9wb3J0ICpwb3J0ID0gZGV2X2lkOwotCXN0cnVjdCBjaXJjX2J1ZiAqeG1pdCA9ICZwb3J0LT5z dGF0ZS0+eG1pdDsKLQlpbnQgY291bnQgPSAyNTY7Ci0KLQlpZiAocG9ydC0+eF9jaGFyKSB7Ci0J CSpDU1JfVUFSVERSID0gcG9ydC0+eF9jaGFyOwotCQlwb3J0LT5pY291bnQudHgrKzsKLQkJcG9y dC0+eF9jaGFyID0gMDsKLQkJZ290byBvdXQ7Ci0JfQotCWlmICh1YXJ0X2NpcmNfZW1wdHkoeG1p dCkgfHwgdWFydF90eF9zdG9wcGVkKHBvcnQpKSB7Ci0JCXNlcmlhbDIxMjg1X3N0b3BfdHgocG9y dCk7Ci0JCWdvdG8gb3V0OwotCX0KLQotCWRvIHsKLQkJKkNTUl9VQVJURFIgPSB4bWl0LT5idWZb eG1pdC0+dGFpbF07Ci0JCXhtaXQtPnRhaWwgPSAoeG1pdC0+dGFpbCArIDEpICYgKFVBUlRfWE1J VF9TSVpFIC0gMSk7Ci0JCXBvcnQtPmljb3VudC50eCsrOwotCQlpZiAodWFydF9jaXJjX2VtcHR5 KHhtaXQpKQotCQkJYnJlYWs7Ci0JfSB3aGlsZSAoLS1jb3VudCA+IDAgJiYgISgqQ1NSX1VBUlRG TEcgJiAweDIwKSk7Ci0KLQlpZiAodWFydF9jaXJjX2NoYXJzX3BlbmRpbmcoeG1pdCkgPCBXQUtF VVBfQ0hBUlMpCi0JCXVhcnRfd3JpdGVfd2FrZXVwKHBvcnQpOwogCi0JaWYgKHVhcnRfY2lyY19l bXB0eSh4bWl0KSkKLQkJc2VyaWFsMjEyODVfc3RvcF90eChwb3J0KTsKKwlzZXJpYWwyMTI4NV9k b190eF9jaGFycyhwb3J0LCAyNTYpOwogCi0gb3V0OgogCXJldHVybiBJUlFfSEFORExFRDsKIH0K IApkaWZmIC0tZ2l0IGEvZHJpdmVycy90dHkvc2VyaWFsL2FsdGVyYV9qdGFndWFydC5jIGIvZHJp dmVycy90dHkvc2VyaWFsL2FsdGVyYV9qdGFndWFydC5jCmluZGV4IGNiNzkxYzUxNDlhMy4uOTI4 ZWQ0MTllOTY5IDEwMDY0NAotLS0gYS9kcml2ZXJzL3R0eS9zZXJpYWwvYWx0ZXJhX2p0YWd1YXJ0 LmMKKysrIGIvZHJpdmVycy90dHkvc2VyaWFsL2FsdGVyYV9qdGFndWFydC5jCkBAIC0xMzQsNDIg KzEzNCwyMCBAQCBzdGF0aWMgdm9pZCBhbHRlcmFfanRhZ3VhcnRfcnhfY2hhcnMoc3RydWN0IGFs dGVyYV9qdGFndWFydCAqcHApCiAJdHR5X2ZsaXBfYnVmZmVyX3B1c2goJnBvcnQtPnN0YXRlLT5w b3J0KTsKIH0KIAorc3RhdGljIERFRklORV9VQVJUX1BPUlRfVFhfSEVMUEVSX0xJTUlURUQoYWx0 ZXJhX2p0YWd1YXJ0X2RvX3R4X2NoYXJzLCBwb3J0LCBjaCwKKwkJdHJ1ZSwKKwkJd3JpdGVsKGNo LCBwb3J0LT5tZW1iYXNlICsgQUxURVJBX0pUQUdVQVJUX0RBVEFfUkVHKSwKKwkJKHt9KSk7CisK IHN0YXRpYyB2b2lkIGFsdGVyYV9qdGFndWFydF90eF9jaGFycyhzdHJ1Y3QgYWx0ZXJhX2p0YWd1 YXJ0ICpwcCkKIHsKIAlzdHJ1Y3QgdWFydF9wb3J0ICpwb3J0ID0gJnBwLT5wb3J0OwotCXN0cnVj dCBjaXJjX2J1ZiAqeG1pdCA9ICZwb3J0LT5zdGF0ZS0+eG1pdDsKLQl1bnNpZ25lZCBpbnQgcGVu ZGluZywgY291bnQ7Ci0KLQlpZiAocG9ydC0+eF9jaGFyKSB7Ci0JCS8qIFNlbmQgc3BlY2lhbCBj aGFyIC0gcHJvYmFibHkgZmxvdyBjb250cm9sICovCi0JCXdyaXRlbChwb3J0LT54X2NoYXIsIHBv cnQtPm1lbWJhc2UgKyBBTFRFUkFfSlRBR1VBUlRfREFUQV9SRUcpOwotCQlwb3J0LT54X2NoYXIg PSAwOwotCQlwb3J0LT5pY291bnQudHgrKzsKLQkJcmV0dXJuOwotCX0KLQotCXBlbmRpbmcgPSB1 YXJ0X2NpcmNfY2hhcnNfcGVuZGluZyh4bWl0KTsKLQlpZiAocGVuZGluZyA+IDApIHsKLQkJY291 bnQgPSAocmVhZGwocG9ydC0+bWVtYmFzZSArIEFMVEVSQV9KVEFHVUFSVF9DT05UUk9MX1JFRykg JgotCQkJCUFMVEVSQV9KVEFHVUFSVF9DT05UUk9MX1dTUEFDRV9NU0spID4+Ci0JCQlBTFRFUkFf SlRBR1VBUlRfQ09OVFJPTF9XU1BBQ0VfT0ZGOwotCQlpZiAoY291bnQgPiBwZW5kaW5nKQotCQkJ Y291bnQgPSBwZW5kaW5nOwotCQlpZiAoY291bnQgPiAwKSB7Ci0JCQlwZW5kaW5nIC09IGNvdW50 OwotCQkJd2hpbGUgKGNvdW50LS0pIHsKLQkJCQl3cml0ZWwoeG1pdC0+YnVmW3htaXQtPnRhaWxd LAotCQkJCSAgICAgICBwb3J0LT5tZW1iYXNlICsgQUxURVJBX0pUQUdVQVJUX0RBVEFfUkVHKTsK LQkJCQl4bWl0LT50YWlsID0gKHhtaXQtPnRhaWwgKyAxKSAmIChVQVJUX1hNSVRfU0laRSAtIDEp OwotCQkJCXBvcnQtPmljb3VudC50eCsrOwotCQkJfQotCQkJaWYgKHBlbmRpbmcgPCBXQUtFVVBf Q0hBUlMpCi0JCQkJdWFydF93cml0ZV93YWtldXAocG9ydCk7Ci0JCX0KLQl9CisJdW5zaWduZWQg aW50IHNwYWNlOwogCi0JaWYgKHBlbmRpbmcgPT0gMCkKLQkJYWx0ZXJhX2p0YWd1YXJ0X3N0b3Bf dHgocG9ydCk7CisJc3BhY2UgPSAocmVhZGwocG9ydC0+bWVtYmFzZSArIEFMVEVSQV9KVEFHVUFS VF9DT05UUk9MX1JFRykgJgorCQkJQUxURVJBX0pUQUdVQVJUX0NPTlRST0xfV1NQQUNFX01TSykg Pj4KKwkJQUxURVJBX0pUQUdVQVJUX0NPTlRST0xfV1NQQUNFX09GRjsKKwlhbHRlcmFfanRhZ3Vh cnRfZG9fdHhfY2hhcnMocG9ydCwgc3BhY2UpOwogfQogCiBzdGF0aWMgaXJxcmV0dXJuX3QgYWx0 ZXJhX2p0YWd1YXJ0X2ludGVycnVwdChpbnQgaXJxLCB2b2lkICpkYXRhKQpkaWZmIC0tZ2l0IGEv ZHJpdmVycy90dHkvc2VyaWFsL2FtYmEtcGwwMTAuYyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9hbWJh LXBsMDEwLmMKaW5kZXggZmFlMGI1ODFmZjQyLi5jYzk1ZTU1NDZiNzkgMTAwNjQ0Ci0tLSBhL2Ry aXZlcnMvdHR5L3NlcmlhbC9hbWJhLXBsMDEwLmMKKysrIGIvZHJpdmVycy90dHkvc2VyaWFsL2Ft YmEtcGwwMTAuYwpAQCAtMTYyLDM3ICsxNjIsMTAgQEAgc3RhdGljIHZvaWQgcGwwMTBfcnhfY2hh cnMoc3RydWN0IHVhcnRfcG9ydCAqcG9ydCkKIAl0dHlfZmxpcF9idWZmZXJfcHVzaCgmcG9ydC0+ c3RhdGUtPnBvcnQpOwogfQogCi1zdGF0aWMgdm9pZCBwbDAxMF90eF9jaGFycyhzdHJ1Y3QgdWFy dF9wb3J0ICpwb3J0KQotewotCXN0cnVjdCBjaXJjX2J1ZiAqeG1pdCA9ICZwb3J0LT5zdGF0ZS0+ eG1pdDsKLQlpbnQgY291bnQ7Ci0KLQlpZiAocG9ydC0+eF9jaGFyKSB7Ci0JCXdyaXRlbChwb3J0 LT54X2NoYXIsIHBvcnQtPm1lbWJhc2UgKyBVQVJUMDF4X0RSKTsKLQkJcG9ydC0+aWNvdW50LnR4 Kys7Ci0JCXBvcnQtPnhfY2hhciA9IDA7Ci0JCXJldHVybjsKLQl9Ci0JaWYgKHVhcnRfY2lyY19l bXB0eSh4bWl0KSB8fCB1YXJ0X3R4X3N0b3BwZWQocG9ydCkpIHsKLQkJcGwwMTBfc3RvcF90eChw b3J0KTsKLQkJcmV0dXJuOwotCX0KLQotCWNvdW50ID0gcG9ydC0+Zmlmb3NpemUgPj4gMTsKLQlk byB7Ci0JCXdyaXRlbCh4bWl0LT5idWZbeG1pdC0+dGFpbF0sIHBvcnQtPm1lbWJhc2UgKyBVQVJU MDF4X0RSKTsKLQkJeG1pdC0+dGFpbCA9ICh4bWl0LT50YWlsICsgMSkgJiAoVUFSVF9YTUlUX1NJ WkUgLSAxKTsKLQkJcG9ydC0+aWNvdW50LnR4Kys7Ci0JCWlmICh1YXJ0X2NpcmNfZW1wdHkoeG1p dCkpCi0JCQlicmVhazsKLQl9IHdoaWxlICgtLWNvdW50ID4gMCk7Ci0KLQlpZiAodWFydF9jaXJj X2NoYXJzX3BlbmRpbmcoeG1pdCkgPCBXQUtFVVBfQ0hBUlMpCi0JCXVhcnRfd3JpdGVfd2FrZXVw KHBvcnQpOwotCi0JaWYgKHVhcnRfY2lyY19lbXB0eSh4bWl0KSkKLQkJcGwwMTBfc3RvcF90eChw b3J0KTsKLX0KK3N0YXRpYyBERUZJTkVfVUFSVF9QT1JUX1RYX0hFTFBFUl9MSU1JVEVEKHBsMDEw X3R4X2NoYXJzLCBwb3J0LCBjaCwKKwkJdHJ1ZSwKKwkJd3JpdGVsKGNoLCBwb3J0LT5tZW1iYXNl ICsgVUFSVDAxeF9EUiksCisJCSh7fSkpOwogCiBzdGF0aWMgdm9pZCBwbDAxMF9tb2RlbV9zdGF0 dXMoc3RydWN0IHVhcnRfYW1iYV9wb3J0ICp1YXApCiB7CkBAIC0yMzgsNyArMjExLDcgQEAgc3Rh dGljIGlycXJldHVybl90IHBsMDEwX2ludChpbnQgaXJxLCB2b2lkICpkZXZfaWQpCiAJCQlpZiAo c3RhdHVzICYgVUFSVDAxMF9JSVJfTUlTKQogCQkJCXBsMDEwX21vZGVtX3N0YXR1cyh1YXApOwog CQkJaWYgKHN0YXR1cyAmIFVBUlQwMTBfSUlSX1RJUykKLQkJCQlwbDAxMF90eF9jaGFycyhwb3J0 KTsKKwkJCQlwbDAxMF90eF9jaGFycyhwb3J0LCBwb3J0LT5maWZvc2l6ZSA+PiAxKTsKIAogCQkJ aWYgKHBhc3NfY291bnRlci0tID09IDApCiAJCQkJYnJlYWs7CmRpZmYgLS1naXQgYS9kcml2ZXJz L3R0eS9zZXJpYWwvYXBidWFydC5jIGIvZHJpdmVycy90dHkvc2VyaWFsL2FwYnVhcnQuYwppbmRl eCA5ZWY4MmQ4NzBmZjIuLjA2Yzg4MGVkNzAzNiAxMDA2NDQKLS0tIGEvZHJpdmVycy90dHkvc2Vy aWFsL2FwYnVhcnQuYworKysgYi9kcml2ZXJzL3R0eS9zZXJpYWwvYXBidWFydC5jCkBAIC0xMjAs MzggKzEyMCwxNCBAQCBzdGF0aWMgdm9pZCBhcGJ1YXJ0X3J4X2NoYXJzKHN0cnVjdCB1YXJ0X3Bv cnQgKnBvcnQpCiAJdHR5X2ZsaXBfYnVmZmVyX3B1c2goJnBvcnQtPnN0YXRlLT5wb3J0KTsKIH0K IAorc3RhdGljIERFRklORV9VQVJUX1BPUlRfVFhfSEVMUEVSX0xJTUlURUQoYXBidWFydF9kb190 eF9jaGFycywgcG9ydCwgY2gsCisJCXRydWUsCisJCVVBUlRfUFVUX0NIQVIocG9ydCwgY2gpLAor CQkoe30pKTsKKwogc3RhdGljIHZvaWQgYXBidWFydF90eF9jaGFycyhzdHJ1Y3QgdWFydF9wb3J0 ICpwb3J0KQogewotCXN0cnVjdCBjaXJjX2J1ZiAqeG1pdCA9ICZwb3J0LT5zdGF0ZS0+eG1pdDsK LQlpbnQgY291bnQ7Ci0KLQlpZiAocG9ydC0+eF9jaGFyKSB7Ci0JCVVBUlRfUFVUX0NIQVIocG9y dCwgcG9ydC0+eF9jaGFyKTsKLQkJcG9ydC0+aWNvdW50LnR4Kys7Ci0JCXBvcnQtPnhfY2hhciA9 IDA7Ci0JCXJldHVybjsKLQl9Ci0KLQlpZiAodWFydF9jaXJjX2VtcHR5KHhtaXQpIHx8IHVhcnRf dHhfc3RvcHBlZChwb3J0KSkgewotCQlhcGJ1YXJ0X3N0b3BfdHgocG9ydCk7Ci0JCXJldHVybjsK LQl9Ci0KLQkvKiBhbWJhOiBmaWxsIEZJRk8gKi8KLQljb3VudCA9IHBvcnQtPmZpZm9zaXplID4+ IDE7Ci0JZG8gewotCQlVQVJUX1BVVF9DSEFSKHBvcnQsIHhtaXQtPmJ1Zlt4bWl0LT50YWlsXSk7 Ci0JCXhtaXQtPnRhaWwgPSAoeG1pdC0+dGFpbCArIDEpICYgKFVBUlRfWE1JVF9TSVpFIC0gMSk7 Ci0JCXBvcnQtPmljb3VudC50eCsrOwotCQlpZiAodWFydF9jaXJjX2VtcHR5KHhtaXQpKQotCQkJ YnJlYWs7Ci0JfSB3aGlsZSAoLS1jb3VudCA+IDApOwotCi0JaWYgKHVhcnRfY2lyY19jaGFyc19w ZW5kaW5nKHhtaXQpIDwgV0FLRVVQX0NIQVJTKQotCQl1YXJ0X3dyaXRlX3dha2V1cChwb3J0KTsK LQotCWlmICh1YXJ0X2NpcmNfZW1wdHkoeG1pdCkpCi0JCWFwYnVhcnRfc3RvcF90eChwb3J0KTsK KwlhcGJ1YXJ0X2RvX3R4X2NoYXJzKHBvcnQsIHBvcnQtPmZpZm9zaXplID4+IDEpOwogfQogCiBz dGF0aWMgaXJxcmV0dXJuX3QgYXBidWFydF9pbnQoaW50IGlycSwgdm9pZCAqZGV2X2lkKQpkaWZm IC0tZ2l0IGEvZHJpdmVycy90dHkvc2VyaWFsL2JjbTYzeHhfdWFydC5jIGIvZHJpdmVycy90dHkv c2VyaWFsL2JjbTYzeHhfdWFydC5jCmluZGV4IDUzYjQzMTc0YWE0MC4uMWI5ZjBjZWMzYWExIDEw MDY0NAotLS0gYS9kcml2ZXJzL3R0eS9zZXJpYWwvYmNtNjN4eF91YXJ0LmMKKysrIGIvZHJpdmVy cy90dHkvc2VyaWFsL2JjbTYzeHhfdWFydC5jCkBAIC0yOTcsNTkgKzI5NywzMCBAQCBzdGF0aWMg dm9pZCBiY21fdWFydF9kb19yeChzdHJ1Y3QgdWFydF9wb3J0ICpwb3J0KQogCXR0eV9mbGlwX2J1 ZmZlcl9wdXNoKHR0eV9wb3J0KTsKIH0KIAorc3RhdGljIERFRklORV9VQVJUX1BPUlRfVFhfSEVM UEVSX0xJTUlURUQoYmNtX3VhcnRfdHgsIHBvcnQsIGNoLAorCQl0cnVlLAorCQliY21fdWFydF93 cml0ZWwocG9ydCwgY2gsIFVBUlRfRklGT19SRUcpLAorCQkoe30pKTsKKwogLyoKICAqIGZpbGwg dHggZmlmbyB3aXRoIGNoYXJzIHRvIHNlbmQsIHN0b3Agd2hlbiBmaWZvIGlzIGFib3V0IHRvIGJl IGZ1bGwKICAqIG9yIHdoZW4gYWxsIGNoYXJzIGhhdmUgYmVlbiBzZW50LgogICovCiBzdGF0aWMg dm9pZCBiY21fdWFydF9kb190eChzdHJ1Y3QgdWFydF9wb3J0ICpwb3J0KQogewotCXN0cnVjdCBj aXJjX2J1ZiAqeG1pdDsKLQl1bnNpZ25lZCBpbnQgdmFsLCBtYXhfY291bnQ7Ci0KLQlpZiAocG9y dC0+eF9jaGFyKSB7Ci0JCWJjbV91YXJ0X3dyaXRlbChwb3J0LCBwb3J0LT54X2NoYXIsIFVBUlRf RklGT19SRUcpOwotCQlwb3J0LT5pY291bnQudHgrKzsKLQkJcG9ydC0+eF9jaGFyID0gMDsKLQkJ cmV0dXJuOwotCX0KLQotCWlmICh1YXJ0X3R4X3N0b3BwZWQocG9ydCkpIHsKLQkJYmNtX3VhcnRf c3RvcF90eChwb3J0KTsKLQkJcmV0dXJuOwotCX0KLQotCXhtaXQgPSAmcG9ydC0+c3RhdGUtPnht aXQ7Ci0JaWYgKHVhcnRfY2lyY19lbXB0eSh4bWl0KSkKLQkJZ290byB0eHFfZW1wdHk7CisJdW5z aWduZWQgaW50IHZhbCwgcGVuZGluZzsKIAogCXZhbCA9IGJjbV91YXJ0X3JlYWRsKHBvcnQsIFVB UlRfTUNUTF9SRUcpOwogCXZhbCA9ICh2YWwgJiBVQVJUX01DVExfVFhGSUZPRklMTF9NQVNLKSA+ PiBVQVJUX01DVExfVFhGSUZPRklMTF9TSElGVDsKLQltYXhfY291bnQgPSBwb3J0LT5maWZvc2l6 ZSAtIHZhbDsKLQotCXdoaWxlIChtYXhfY291bnQtLSkgewotCQl1bnNpZ25lZCBpbnQgYzsKIAot CQljID0geG1pdC0+YnVmW3htaXQtPnRhaWxdOwotCQliY21fdWFydF93cml0ZWwocG9ydCwgYywg VUFSVF9GSUZPX1JFRyk7Ci0JCXhtaXQtPnRhaWwgPSAoeG1pdC0+dGFpbCArIDEpICYgKFVBUlRf WE1JVF9TSVpFIC0gMSk7Ci0JCXBvcnQtPmljb3VudC50eCsrOwotCQlpZiAodWFydF9jaXJjX2Vt cHR5KHhtaXQpKQotCQkJYnJlYWs7Ci0JfQotCi0JaWYgKHVhcnRfY2lyY19jaGFyc19wZW5kaW5n KHhtaXQpIDwgV0FLRVVQX0NIQVJTKQotCQl1YXJ0X3dyaXRlX3dha2V1cChwb3J0KTsKLQotCWlm ICh1YXJ0X2NpcmNfZW1wdHkoeG1pdCkpCi0JCWdvdG8gdHhxX2VtcHR5OwotCXJldHVybjsKKwlw ZW5kaW5nID0gYmNtX3VhcnRfdHgocG9ydCwgcG9ydC0+Zmlmb3NpemUgLSB2YWwpOworCWlmIChw ZW5kaW5nKQorCQlyZXR1cm47CiAKLXR4cV9lbXB0eToKIAkvKiBub3RoaW5nIHRvIHNlbmQsIGRp c2FibGUgdHJhbnNtaXQgaW50ZXJydXB0ICovCiAJdmFsID0gYmNtX3VhcnRfcmVhZGwocG9ydCwg VUFSVF9JUl9SRUcpOwogCXZhbCAmPSB+VUFSVF9UWF9JTlRfTUFTSzsKIAliY21fdWFydF93cml0 ZWwocG9ydCwgdmFsLCBVQVJUX0lSX1JFRyk7Ci0JcmV0dXJuOwogfQogCiAvKgpkaWZmIC0tZ2l0 IGEvZHJpdmVycy90dHkvc2VyaWFsL211eC5jIGIvZHJpdmVycy90dHkvc2VyaWFsL211eC5jCmlu ZGV4IDBiYTBmNGQ5NDU5ZC4uZjY1ZjY5NGZkZWNkIDEwMDY0NAotLS0gYS9kcml2ZXJzL3R0eS9z ZXJpYWwvbXV4LmMKKysrIGIvZHJpdmVycy90dHkvc2VyaWFsL211eC5jCkBAIC0xNzEsNiArMTcx LDE4IEBAIHN0YXRpYyB2b2lkIG11eF9icmVha19jdGwoc3RydWN0IHVhcnRfcG9ydCAqcG9ydCwg aW50IGJyZWFrX3N0YXRlKQogewogfQogCitzdGF0aWMgdm9pZCBtdXhfdHhfZG9uZShzdHJ1Y3Qg dWFydF9wb3J0ICpwb3J0KQoreworCS8qIEZJWE1FIGpzOiByZWFsbHkgbmVlZHMgdG8gd2FpdD8g Ki8KKwl3aGlsZSAoVUFSVF9HRVRfRklGT19DTlQocG9ydCkpCisJCXVkZWxheSgxKTsKK30KKwor c3RhdGljIERFRklORV9VQVJUX1BPUlRfVFhfSEVMUEVSX0xJTUlURUQobXV4X3RyYW5zbWl0LCBw b3J0LCBjaCwKKwkJdHJ1ZSwKKwkJVUFSVF9QVVRfQ0hBUihwb3J0LCBjaCksCisJCW11eF90eF9k b25lKHBvcnQpKTsKKwogLyoqCiAgKiBtdXhfd3JpdGUgLSBXcml0ZSBjaGFycyB0byB0aGUgbXV4 IGZpZm8uCiAgKiBAcG9ydDogUHRyIHRvIHRoZSB1YXJ0X3BvcnQuCkBAIC0xODAsMzkgKzE5Miw3 IEBAIHN0YXRpYyB2b2lkIG11eF9icmVha19jdGwoc3RydWN0IHVhcnRfcG9ydCAqcG9ydCwgaW50 IGJyZWFrX3N0YXRlKQogICovCiBzdGF0aWMgdm9pZCBtdXhfd3JpdGUoc3RydWN0IHVhcnRfcG9y dCAqcG9ydCkKIHsKLQlpbnQgY291bnQ7Ci0Jc3RydWN0IGNpcmNfYnVmICp4bWl0ID0gJnBvcnQt PnN0YXRlLT54bWl0OwotCi0JaWYocG9ydC0+eF9jaGFyKSB7Ci0JCVVBUlRfUFVUX0NIQVIocG9y dCwgcG9ydC0+eF9jaGFyKTsKLQkJcG9ydC0+aWNvdW50LnR4Kys7Ci0JCXBvcnQtPnhfY2hhciA9 IDA7Ci0JCXJldHVybjsKLQl9Ci0KLQlpZih1YXJ0X2NpcmNfZW1wdHkoeG1pdCkgfHwgdWFydF90 eF9zdG9wcGVkKHBvcnQpKSB7Ci0JCW11eF9zdG9wX3R4KHBvcnQpOwotCQlyZXR1cm47Ci0JfQot Ci0JY291bnQgPSAocG9ydC0+Zmlmb3NpemUpIC0gVUFSVF9HRVRfRklGT19DTlQocG9ydCk7Ci0J ZG8gewotCQlVQVJUX1BVVF9DSEFSKHBvcnQsIHhtaXQtPmJ1Zlt4bWl0LT50YWlsXSk7Ci0JCXht aXQtPnRhaWwgPSAoeG1pdC0+dGFpbCArIDEpICYgKFVBUlRfWE1JVF9TSVpFIC0gMSk7Ci0JCXBv cnQtPmljb3VudC50eCsrOwotCQlpZih1YXJ0X2NpcmNfZW1wdHkoeG1pdCkpCi0JCQlicmVhazsK LQotCX0gd2hpbGUoLS1jb3VudCA+IDApOwotCi0Jd2hpbGUoVUFSVF9HRVRfRklGT19DTlQocG9y dCkpIAotCQl1ZGVsYXkoMSk7Ci0KLQlpZih1YXJ0X2NpcmNfY2hhcnNfcGVuZGluZyh4bWl0KSA8 IFdBS0VVUF9DSEFSUykKLQkJdWFydF93cml0ZV93YWtldXAocG9ydCk7Ci0KLQlpZiAodWFydF9j aXJjX2VtcHR5KHhtaXQpKQotCQltdXhfc3RvcF90eChwb3J0KTsKKwltdXhfdHJhbnNtaXQocG9y dCwgcG9ydC0+Zmlmb3NpemUgLSBVQVJUX0dFVF9GSUZPX0NOVChwb3J0KSk7CiB9CiAKIC8qKgpk aWZmIC0tZ2l0IGEvZHJpdmVycy90dHkvc2VyaWFsL212ZWJ1LXVhcnQuYyBiL2RyaXZlcnMvdHR5 L3NlcmlhbC9tdmVidS11YXJ0LmMKaW5kZXggNjVlYWVjZDEwYjdjLi4xZGMwZDliY2Y3OTcgMTAw NjQ0Ci0tLSBhL2RyaXZlcnMvdHR5L3NlcmlhbC9tdmVidS11YXJ0LmMKKysrIGIvZHJpdmVycy90 dHkvc2VyaWFsL212ZWJ1LXVhcnQuYwpAQCAtMzMzLDQyICszMzMsMTQgQEAgc3RhdGljIHZvaWQg bXZlYnVfdWFydF9yeF9jaGFycyhzdHJ1Y3QgdWFydF9wb3J0ICpwb3J0LCB1bnNpZ25lZCBpbnQg c3RhdHVzKQogCXR0eV9mbGlwX2J1ZmZlcl9wdXNoKHRwb3J0KTsKIH0KIAorc3RhdGljIERFRklO RV9VQVJUX1BPUlRfVFhfSEVMUEVSX0xJTUlURUQobXZlYnVfdWFydF9kb190eF9jaGFycywgcG9y dCwgY2gsCisJCSEocmVhZGwocG9ydC0+bWVtYmFzZSArIFVBUlRfU1RBVCkgJiBTVEFUX1RYX0ZJ Rk9fRlVMKSwKKwkJd3JpdGVsKGNoLCBwb3J0LT5tZW1iYXNlICsgVUFSVF9UU0gocG9ydCkpLAor CQkoe30pKTsKKwogc3RhdGljIHZvaWQgbXZlYnVfdWFydF90eF9jaGFycyhzdHJ1Y3QgdWFydF9w b3J0ICpwb3J0LCB1bnNpZ25lZCBpbnQgc3RhdHVzKQogewotCXN0cnVjdCBjaXJjX2J1ZiAqeG1p dCA9ICZwb3J0LT5zdGF0ZS0+eG1pdDsKLQl1bnNpZ25lZCBpbnQgY291bnQ7Ci0JdW5zaWduZWQg aW50IHN0OwotCi0JaWYgKHBvcnQtPnhfY2hhcikgewotCQl3cml0ZWwocG9ydC0+eF9jaGFyLCBw b3J0LT5tZW1iYXNlICsgVUFSVF9UU0gocG9ydCkpOwotCQlwb3J0LT5pY291bnQudHgrKzsKLQkJ cG9ydC0+eF9jaGFyID0gMDsKLQkJcmV0dXJuOwotCX0KLQotCWlmICh1YXJ0X2NpcmNfZW1wdHko eG1pdCkgfHwgdWFydF90eF9zdG9wcGVkKHBvcnQpKSB7Ci0JCW12ZWJ1X3VhcnRfc3RvcF90eChw b3J0KTsKLQkJcmV0dXJuOwotCX0KLQotCWZvciAoY291bnQgPSAwOyBjb3VudCA8IHBvcnQtPmZp Zm9zaXplOyBjb3VudCsrKSB7Ci0JCXdyaXRlbCh4bWl0LT5idWZbeG1pdC0+dGFpbF0sIHBvcnQt Pm1lbWJhc2UgKyBVQVJUX1RTSChwb3J0KSk7Ci0JCXhtaXQtPnRhaWwgPSAoeG1pdC0+dGFpbCAr IDEpICYgKFVBUlRfWE1JVF9TSVpFIC0gMSk7Ci0JCXBvcnQtPmljb3VudC50eCsrOwotCi0JCWlm ICh1YXJ0X2NpcmNfZW1wdHkoeG1pdCkpCi0JCQlicmVhazsKLQotCQlzdCA9IHJlYWRsKHBvcnQt Pm1lbWJhc2UgKyBVQVJUX1NUQVQpOwotCQlpZiAoc3QgJiBTVEFUX1RYX0ZJRk9fRlVMKQotCQkJ YnJlYWs7Ci0JfQotCi0JaWYgKHVhcnRfY2lyY19jaGFyc19wZW5kaW5nKHhtaXQpIDwgV0FLRVVQ X0NIQVJTKQotCQl1YXJ0X3dyaXRlX3dha2V1cChwb3J0KTsKLQotCWlmICh1YXJ0X2NpcmNfZW1w dHkoeG1pdCkpCi0JCW12ZWJ1X3VhcnRfc3RvcF90eChwb3J0KTsKKwltdmVidV91YXJ0X2RvX3R4 X2NoYXJzKHBvcnQsIHBvcnQtPmZpZm9zaXplKTsKIH0KIAogc3RhdGljIGlycXJldHVybl90IG12 ZWJ1X3VhcnRfaXNyKGludCBpcnEsIHZvaWQgKmRldl9pZCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMv dHR5L3NlcmlhbC9vbWFwLXNlcmlhbC5jIGIvZHJpdmVycy90dHkvc2VyaWFsL29tYXAtc2VyaWFs LmMKaW5kZXggMGFhNjY2ZTI0N2Q1Li5hMGNjZGUzYjMzZTMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMv dHR5L3NlcmlhbC9vbWFwLXNlcmlhbC5jCisrKyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9vbWFwLXNl cmlhbC5jCkBAIC0zMzcsNDUgKzMzNywyMiBAQCBzdGF0aWMgdm9pZCBzZXJpYWxfb21hcF9zdG9w X3J4KHN0cnVjdCB1YXJ0X3BvcnQgKnBvcnQpCiAJc2VyaWFsX291dCh1cCwgVUFSVF9JRVIsIHVw LT5pZXIpOwogfQogCi1zdGF0aWMgdm9pZCB0cmFuc21pdF9jaGFycyhzdHJ1Y3QgdWFydF9vbWFw X3BvcnQgKnVwLCB1bnNpZ25lZCBpbnQgbHNyKQorc3RhdGljIHZvaWQgc2VyaWFsX29tYXBfcHV0 X2NoYXIoc3RydWN0IHVhcnRfcG9ydCAqcG9ydCwgdW5zaWduZWQgY2hhciBjaCkKIHsKLQlzdHJ1 Y3QgY2lyY19idWYgKnhtaXQgPSAmdXAtPnBvcnQuc3RhdGUtPnhtaXQ7Ci0JaW50IGNvdW50Owot Ci0JaWYgKHVwLT5wb3J0LnhfY2hhcikgewotCQlzZXJpYWxfb3V0KHVwLCBVQVJUX1RYLCB1cC0+ cG9ydC54X2NoYXIpOwotCQl1cC0+cG9ydC5pY291bnQudHgrKzsKLQkJdXAtPnBvcnQueF9jaGFy ID0gMDsKLQkJaWYgKCh1cC0+cG9ydC5yczQ4NS5mbGFncyAmIFNFUl9SUzQ4NV9FTkFCTEVEKSAm JgotCQkgICAgISh1cC0+cG9ydC5yczQ4NS5mbGFncyAmIFNFUl9SUzQ4NV9SWF9EVVJJTkdfVFgp KQotCQkJdXAtPnJzNDg1X3R4X2ZpbHRlcl9jb3VudCsrOwotCi0JCXJldHVybjsKLQl9Ci0JaWYg KHVhcnRfY2lyY19lbXB0eSh4bWl0KSB8fCB1YXJ0X3R4X3N0b3BwZWQoJnVwLT5wb3J0KSkgewot CQlzZXJpYWxfb21hcF9zdG9wX3R4KCZ1cC0+cG9ydCk7Ci0JCXJldHVybjsKLQl9Ci0JY291bnQg PSB1cC0+cG9ydC5maWZvc2l6ZSAvIDQ7Ci0JZG8gewotCQlzZXJpYWxfb3V0KHVwLCBVQVJUX1RY LCB4bWl0LT5idWZbeG1pdC0+dGFpbF0pOwotCQl4bWl0LT50YWlsID0gKHhtaXQtPnRhaWwgKyAx KSAmIChVQVJUX1hNSVRfU0laRSAtIDEpOwotCQl1cC0+cG9ydC5pY291bnQudHgrKzsKLQkJaWYg KCh1cC0+cG9ydC5yczQ4NS5mbGFncyAmIFNFUl9SUzQ4NV9FTkFCTEVEKSAmJgotCQkgICAgISh1 cC0+cG9ydC5yczQ4NS5mbGFncyAmIFNFUl9SUzQ4NV9SWF9EVVJJTkdfVFgpKQotCQkJdXAtPnJz NDg1X3R4X2ZpbHRlcl9jb3VudCsrOwotCi0JCWlmICh1YXJ0X2NpcmNfZW1wdHkoeG1pdCkpCi0J CQlicmVhazsKLQl9IHdoaWxlICgtLWNvdW50ID4gMCk7CisJc3RydWN0IHVhcnRfb21hcF9wb3J0 ICp1cCA9IHRvX3VhcnRfb21hcF9wb3J0KHBvcnQpOwogCi0JaWYgKHVhcnRfY2lyY19jaGFyc19w ZW5kaW5nKHhtaXQpIDwgV0FLRVVQX0NIQVJTKQotCQl1YXJ0X3dyaXRlX3dha2V1cCgmdXAtPnBv cnQpOworCXNlcmlhbF9vdXQodXAsIFVBUlRfVFgsIGNoKTsKIAotCWlmICh1YXJ0X2NpcmNfZW1w dHkoeG1pdCkpCi0JCXNlcmlhbF9vbWFwX3N0b3BfdHgoJnVwLT5wb3J0KTsKKwlpZiAoKHVwLT5w b3J0LnJzNDg1LmZsYWdzICYgU0VSX1JTNDg1X0VOQUJMRUQpICYmCisJICAgICEodXAtPnBvcnQu cnM0ODUuZmxhZ3MgJiBTRVJfUlM0ODVfUlhfRFVSSU5HX1RYKSkKKwkJdXAtPnJzNDg1X3R4X2Zp bHRlcl9jb3VudCsrOwogfQogCitzdGF0aWMgREVGSU5FX1VBUlRfUE9SVF9UWF9IRUxQRVJfTElN SVRFRCh0cmFuc21pdF9jaGFycywgcG9ydCwgY2gsCisJCXRydWUsCisJCXNlcmlhbF9vbWFwX3B1 dF9jaGFyKHBvcnQsIGNoKSwKKwkJKHt9KSk7CisKIHN0YXRpYyBpbmxpbmUgdm9pZCBzZXJpYWxf b21hcF9lbmFibGVfaWVyX3Rocmkoc3RydWN0IHVhcnRfb21hcF9wb3J0ICp1cCkKIHsKIAlpZiAo ISh1cC0+aWVyICYgVUFSVF9JRVJfVEhSSSkpIHsKQEAgLTU3Myw3ICs1NTAsNyBAQCBzdGF0aWMg aXJxcmV0dXJuX3Qgc2VyaWFsX29tYXBfaXJxKGludCBpcnEsIHZvaWQgKmRldl9pZCkKIAkJCWNo ZWNrX21vZGVtX3N0YXR1cyh1cCk7CiAJCQlicmVhazsKIAkJY2FzZSBVQVJUX0lJUl9USFJJOgot CQkJdHJhbnNtaXRfY2hhcnModXAsIGxzcik7CisJCQl0cmFuc21pdF9jaGFycygmdXAtPnBvcnQs IHVwLT5wb3J0LmZpZm9zaXplIC8gNCk7CiAJCQlicmVhazsKIAkJY2FzZSBVQVJUX0lJUl9SWF9U SU1FT1VUOgogCQljYXNlIFVBUlRfSUlSX1JESToKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdHR5L3Nl cmlhbC9weGEuYyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9weGEuYwppbmRleCA5MzA5ZmZkODdjOGUu LmMxMzc2ZThhZGJmNCAxMDA2NDQKLS0tIGEvZHJpdmVycy90dHkvc2VyaWFsL3B4YS5jCisrKyBi L2RyaXZlcnMvdHR5L3NlcmlhbC9weGEuYwpAQCAtMTcyLDM5ICsxNzIsMTggQEAgc3RhdGljIGlu bGluZSB2b2lkIHJlY2VpdmVfY2hhcnMoc3RydWN0IHVhcnRfcHhhX3BvcnQgKnVwLCBpbnQgKnN0 YXR1cykKIAlzZXJpYWxfb3V0KHVwLCBVQVJUX0lFUiwgdXAtPmllcik7CiB9CiAKLXN0YXRpYyB2 b2lkIHRyYW5zbWl0X2NoYXJzKHN0cnVjdCB1YXJ0X3B4YV9wb3J0ICp1cCkKK3N0YXRpYyB2b2lk IHNlcmlhbF9weGFfcHV0X2NoYXIoc3RydWN0IHVhcnRfcG9ydCAqcG9ydCwgdTggY2gpCiB7Ci0J c3RydWN0IGNpcmNfYnVmICp4bWl0ID0gJnVwLT5wb3J0LnN0YXRlLT54bWl0OwotCWludCBjb3Vu dDsKLQotCWlmICh1cC0+cG9ydC54X2NoYXIpIHsKLQkJc2VyaWFsX291dCh1cCwgVUFSVF9UWCwg dXAtPnBvcnQueF9jaGFyKTsKLQkJdXAtPnBvcnQuaWNvdW50LnR4Kys7Ci0JCXVwLT5wb3J0Lnhf Y2hhciA9IDA7Ci0JCXJldHVybjsKLQl9Ci0JaWYgKHVhcnRfY2lyY19lbXB0eSh4bWl0KSB8fCB1 YXJ0X3R4X3N0b3BwZWQoJnVwLT5wb3J0KSkgewotCQlzZXJpYWxfcHhhX3N0b3BfdHgoJnVwLT5w b3J0KTsKLQkJcmV0dXJuOwotCX0KLQotCWNvdW50ID0gdXAtPnBvcnQuZmlmb3NpemUgLyAyOwot CWRvIHsKLQkJc2VyaWFsX291dCh1cCwgVUFSVF9UWCwgeG1pdC0+YnVmW3htaXQtPnRhaWxdKTsK LQkJeG1pdC0+dGFpbCA9ICh4bWl0LT50YWlsICsgMSkgJiAoVUFSVF9YTUlUX1NJWkUgLSAxKTsK LQkJdXAtPnBvcnQuaWNvdW50LnR4Kys7Ci0JCWlmICh1YXJ0X2NpcmNfZW1wdHkoeG1pdCkpCi0J CQlicmVhazsKLQl9IHdoaWxlICgtLWNvdW50ID4gMCk7Ci0KLQlpZiAodWFydF9jaXJjX2NoYXJz X3BlbmRpbmcoeG1pdCkgPCBXQUtFVVBfQ0hBUlMpCi0JCXVhcnRfd3JpdGVfd2FrZXVwKCZ1cC0+ cG9ydCk7Ci0KKwlzdHJ1Y3QgdWFydF9weGFfcG9ydCAqdXAgPSAoc3RydWN0IHVhcnRfcHhhX3Bv cnQgKilwb3J0OwogCi0JaWYgKHVhcnRfY2lyY19lbXB0eSh4bWl0KSkKLQkJc2VyaWFsX3B4YV9z dG9wX3R4KCZ1cC0+cG9ydCk7CisJc2VyaWFsX291dCh1cCwgVUFSVF9UWCwgY2gpOwogfQogCitz dGF0aWMgREVGSU5FX1VBUlRfUE9SVF9UWF9IRUxQRVJfTElNSVRFRCh0cmFuc21pdF9jaGFycywg cG9ydCwgY2gsCisJCXRydWUsCisJCXNlcmlhbF9weGFfcHV0X2NoYXIocG9ydCwgY2gpLAorCQko e30pKTsKKwogc3RhdGljIHZvaWQgc2VyaWFsX3B4YV9zdGFydF90eChzdHJ1Y3QgdWFydF9wb3J0 ICpwb3J0KQogewogCXN0cnVjdCB1YXJ0X3B4YV9wb3J0ICp1cCA9IChzdHJ1Y3QgdWFydF9weGFf cG9ydCAqKXBvcnQ7CkBAIC0yNTQsNyArMjMzLDcgQEAgc3RhdGljIGlubGluZSBpcnFyZXR1cm5f dCBzZXJpYWxfcHhhX2lycShpbnQgaXJxLCB2b2lkICpkZXZfaWQpCiAJCXJlY2VpdmVfY2hhcnMo dXAsICZsc3IpOwogCWNoZWNrX21vZGVtX3N0YXR1cyh1cCk7CiAJaWYgKGxzciAmIFVBUlRfTFNS X1RIUkUpCi0JCXRyYW5zbWl0X2NoYXJzKHVwKTsKKwkJdHJhbnNtaXRfY2hhcnMoJnVwLT5wb3J0 LCB1cC0+cG9ydC5maWZvc2l6ZSAvIDIpOwogCXNwaW5fdW5sb2NrKCZ1cC0+cG9ydC5sb2NrKTsK IAlyZXR1cm4gSVJRX0hBTkRMRUQ7CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL3R0eS9zZXJpYWwv cnAyLmMgYi9kcml2ZXJzL3R0eS9zZXJpYWwvcnAyLmMKaW5kZXggNjY4OWQ4YWRkOGY3Li44NzE5 MDIyYjE4OWQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdHR5L3NlcmlhbC9ycDIuYworKysgYi9kcml2 ZXJzL3R0eS9zZXJpYWwvcnAyLmMKQEAgLTQyNiwzNSArNDI2LDEwIEBAIHN0YXRpYyB2b2lkIHJw Ml9yeF9jaGFycyhzdHJ1Y3QgcnAyX3VhcnRfcG9ydCAqdXApCiAJdHR5X2ZsaXBfYnVmZmVyX3B1 c2gocG9ydCk7CiB9CiAKLXN0YXRpYyB2b2lkIHJwMl90eF9jaGFycyhzdHJ1Y3QgcnAyX3VhcnRf cG9ydCAqdXApCi17Ci0JdTE2IG1heF90eCA9IEZJRk9fU0laRSAtIHJlYWR3KHVwLT5iYXNlICsg UlAyX1RYX0ZJRk9fQ09VTlQpOwotCXN0cnVjdCBjaXJjX2J1ZiAqeG1pdCA9ICZ1cC0+cG9ydC5z dGF0ZS0+eG1pdDsKLQotCWlmICh1YXJ0X3R4X3N0b3BwZWQoJnVwLT5wb3J0KSkgewotCQlycDJf dWFydF9zdG9wX3R4KCZ1cC0+cG9ydCk7Ci0JCXJldHVybjsKLQl9Ci0KLQlmb3IgKDsgbWF4X3R4 ICE9IDA7IG1heF90eC0tKSB7Ci0JCWlmICh1cC0+cG9ydC54X2NoYXIpIHsKLQkJCXdyaXRlYih1 cC0+cG9ydC54X2NoYXIsIHVwLT5iYXNlICsgUlAyX0RBVEFfQllURSk7Ci0JCQl1cC0+cG9ydC54 X2NoYXIgPSAwOwotCQkJdXAtPnBvcnQuaWNvdW50LnR4Kys7Ci0JCQljb250aW51ZTsKLQkJfQot CQlpZiAodWFydF9jaXJjX2VtcHR5KHhtaXQpKSB7Ci0JCQlycDJfdWFydF9zdG9wX3R4KCZ1cC0+ cG9ydCk7Ci0JCQlicmVhazsKLQkJfQotCQl3cml0ZWIoeG1pdC0+YnVmW3htaXQtPnRhaWxdLCB1 cC0+YmFzZSArIFJQMl9EQVRBX0JZVEUpOwotCQl4bWl0LT50YWlsID0gKHhtaXQtPnRhaWwgKyAx KSAmIChVQVJUX1hNSVRfU0laRSAtIDEpOwotCQl1cC0+cG9ydC5pY291bnQudHgrKzsKLQl9Ci0K LQlpZiAodWFydF9jaXJjX2NoYXJzX3BlbmRpbmcoeG1pdCkgPCBXQUtFVVBfQ0hBUlMpCi0JCXVh cnRfd3JpdGVfd2FrZXVwKCZ1cC0+cG9ydCk7Ci19CitzdGF0aWMgREVGSU5FX1VBUlRfUE9SVF9U WF9IRUxQRVJfTElNSVRFRChycDJfdHhfY2hhcnMsIHBvcnQsIGNoLAorCQl0cnVlLAorCQl3cml0 ZWIoY2gsIHBvcnRfdG9fdXAocG9ydCktPmJhc2UgKyBSUDJfREFUQV9CWVRFKSwKKwkJKHt9KSk7 CiAKIHN0YXRpYyB2b2lkIHJwMl9jaF9pbnRlcnJ1cHQoc3RydWN0IHJwMl91YXJ0X3BvcnQgKnVw KQogewpAQCAtNDcyLDcgKzQ0Nyw4IEBAIHN0YXRpYyB2b2lkIHJwMl9jaF9pbnRlcnJ1cHQoc3Ry dWN0IHJwMl91YXJ0X3BvcnQgKnVwKQogCWlmIChzdGF0dXMgJiBSUDJfQ0hBTl9TVEFUX1JYREFU QV9tKQogCQlycDJfcnhfY2hhcnModXApOwogCWlmIChzdGF0dXMgJiBSUDJfQ0hBTl9TVEFUX1RY RU1QVFlfbSkKLQkJcnAyX3R4X2NoYXJzKHVwKTsKKwkJcnAyX3R4X2NoYXJzKCZ1cC0+cG9ydCwK KwkJCUZJRk9fU0laRSAtIHJlYWR3KHVwLT5iYXNlICsgUlAyX1RYX0ZJRk9fQ09VTlQpKTsKIAlp ZiAoc3RhdHVzICYgUlAyX0NIQU5fU1RBVF9NU19DSEFOR0VEX01BU0spCiAJCXdha2VfdXBfaW50 ZXJydXB0aWJsZSgmdXAtPnBvcnQuc3RhdGUtPnBvcnQuZGVsdGFfbXNyX3dhaXQpOwogCmRpZmYg LS1naXQgYS9kcml2ZXJzL3R0eS9zZXJpYWwvc2VyaWFsX3R4eDkuYyBiL2RyaXZlcnMvdHR5L3Nl cmlhbC9zZXJpYWxfdHh4OS5jCmluZGV4IDIyOGUzODBkYjA4MC4uODU1YWQzYjQ1N2Y3IDEwMDY0 NAotLS0gYS9kcml2ZXJzL3R0eS9zZXJpYWwvc2VyaWFsX3R4eDkuYworKysgYi9kcml2ZXJzL3R0 eS9zZXJpYWwvc2VyaWFsX3R4eDkuYwpAQCAtMzE5LDM3ICszMTksMTAgQEAgcmVjZWl2ZV9jaGFy cyhzdHJ1Y3QgdWFydF9wb3J0ICp1cCwgdW5zaWduZWQgaW50ICpzdGF0dXMpCiAJKnN0YXR1cyA9 IGRpc3I7CiB9CiAKLXN0YXRpYyBpbmxpbmUgdm9pZCB0cmFuc21pdF9jaGFycyhzdHJ1Y3QgdWFy dF9wb3J0ICp1cCkKLXsKLQlzdHJ1Y3QgY2lyY19idWYgKnhtaXQgPSAmdXAtPnN0YXRlLT54bWl0 OwotCWludCBjb3VudDsKLQotCWlmICh1cC0+eF9jaGFyKSB7Ci0JCXNpb19vdXQodXAsIFRYWDlf U0lURklGTywgdXAtPnhfY2hhcik7Ci0JCXVwLT5pY291bnQudHgrKzsKLQkJdXAtPnhfY2hhciA9 IDA7Ci0JCXJldHVybjsKLQl9Ci0JaWYgKHVhcnRfY2lyY19lbXB0eSh4bWl0KSB8fCB1YXJ0X3R4 X3N0b3BwZWQodXApKSB7Ci0JCXNlcmlhbF90eHg5X3N0b3BfdHgodXApOwotCQlyZXR1cm47Ci0J fQotCi0JY291bnQgPSBUWFg5X1NJT19UWF9GSUZPOwotCWRvIHsKLQkJc2lvX291dCh1cCwgVFhY OV9TSVRGSUZPLCB4bWl0LT5idWZbeG1pdC0+dGFpbF0pOwotCQl4bWl0LT50YWlsID0gKHhtaXQt PnRhaWwgKyAxKSAmIChVQVJUX1hNSVRfU0laRSAtIDEpOwotCQl1cC0+aWNvdW50LnR4Kys7Ci0J CWlmICh1YXJ0X2NpcmNfZW1wdHkoeG1pdCkpCi0JCQlicmVhazsKLQl9IHdoaWxlICgtLWNvdW50 ID4gMCk7Ci0KLQlpZiAodWFydF9jaXJjX2NoYXJzX3BlbmRpbmcoeG1pdCkgPCBXQUtFVVBfQ0hB UlMpCi0JCXVhcnRfd3JpdGVfd2FrZXVwKHVwKTsKLQotCWlmICh1YXJ0X2NpcmNfZW1wdHkoeG1p dCkpCi0JCXNlcmlhbF90eHg5X3N0b3BfdHgodXApOwotfQorc3RhdGljIERFRklORV9VQVJUX1BP UlRfVFhfSEVMUEVSX0xJTUlURUQodHJhbnNtaXRfY2hhcnMsIHBvcnQsIGNoLAorCQl0cnVlLAor CQlzaW9fb3V0KHBvcnQsIFRYWDlfU0lURklGTywgY2gpLAorCQkoe30pKTsKIAogc3RhdGljIGly cXJldHVybl90IHNlcmlhbF90eHg5X2ludGVycnVwdChpbnQgaXJxLCB2b2lkICpkZXZfaWQpCiB7 CkBAIC0zNzEsNyArMzQ0LDcgQEAgc3RhdGljIGlycXJldHVybl90IHNlcmlhbF90eHg5X2ludGVy cnVwdChpbnQgaXJxLCB2b2lkICpkZXZfaWQpCiAJCWlmIChzdGF0dXMgJiBUWFg5X1NJRElTUl9S RElTKQogCQkJcmVjZWl2ZV9jaGFycyh1cCwgJnN0YXR1cyk7CiAJCWlmIChzdGF0dXMgJiBUWFg5 X1NJRElTUl9URElTKQotCQkJdHJhbnNtaXRfY2hhcnModXApOworCQkJdHJhbnNtaXRfY2hhcnMo dXAsIFRYWDlfU0lPX1RYX0ZJRk8pOwogCQkvKiBDbGVhciBUWC9SWCBJbnQuIFN0YXR1cyAqLwog CQlzaW9fbWFzayh1cCwgVFhYOV9TSURJU1IsCiAJCQkgVFhYOV9TSURJU1JfVERJUyB8IFRYWDlf U0lESVNSX1JESVMgfApkaWZmIC0tZ2l0IGEvZHJpdmVycy90dHkvc2VyaWFsL3NpZml2ZS5jIGIv ZHJpdmVycy90dHkvc2VyaWFsL3NpZml2ZS5jCmluZGV4IDVjM2EwNzU0NmE1OC4uNzgxODBmOTM2 YmYzIDEwMDY0NAotLS0gYS9kcml2ZXJzL3R0eS9zZXJpYWwvc2lmaXZlLmMKKysrIGIvZHJpdmVy cy90dHkvc2VyaWFsL3NpZml2ZS5jCkBAIC0yNzcsNDUgKzI3NywxMCBAQCBzdGF0aWMgdm9pZCBf X3NzcF90cmFuc21pdF9jaGFyKHN0cnVjdCBzaWZpdmVfc2VyaWFsX3BvcnQgKnNzcCwgaW50IGNo KQogCV9fc3NwX3dyaXRlbChjaCwgU0lGSVZFX1NFUklBTF9UWERBVEFfT0ZGUywgc3NwKTsKIH0K IAotLyoqCi0gKiBfX3NzcF90cmFuc21pdF9jaGFycygpIC0gZW5xdWV1ZSBtdWx0aXBsZSBieXRl cyBvbnRvIHRoZSBUWCBGSUZPCi0gKiBAc3NwOiBwb2ludGVyIHRvIGEgc3RydWN0IHNpZml2ZV9z ZXJpYWxfcG9ydAotICoKLSAqIFRyYW5zZmVyIHVwIHRvIGEgVFggRklGTyBzaXplJ3Mgd29ydGgg b2YgY2hhcmFjdGVycyBmcm9tIHRoZSBMaW51eCBzZXJpYWwKLSAqIHRyYW5zbWl0IGJ1ZmZlciB0 byB0aGUgU2lGaXZlIFVBUlQgVFggRklGTy4KLSAqCi0gKiBDb250ZXh0OiBBbnkgY29udGV4dC4g IEV4cGVjdHMgQHNzcC0+cG9ydC5sb2NrIHRvIGJlIGhlbGQgYnkgY2FsbGVyLgotICovCi1zdGF0 aWMgdm9pZCBfX3NzcF90cmFuc21pdF9jaGFycyhzdHJ1Y3Qgc2lmaXZlX3NlcmlhbF9wb3J0ICpz c3ApCi17Ci0Jc3RydWN0IGNpcmNfYnVmICp4bWl0ID0gJnNzcC0+cG9ydC5zdGF0ZS0+eG1pdDsK LQlpbnQgY291bnQ7Ci0KLQlpZiAoc3NwLT5wb3J0LnhfY2hhcikgewotCQlfX3NzcF90cmFuc21p dF9jaGFyKHNzcCwgc3NwLT5wb3J0LnhfY2hhcik7Ci0JCXNzcC0+cG9ydC5pY291bnQudHgrKzsK LQkJc3NwLT5wb3J0LnhfY2hhciA9IDA7Ci0JCXJldHVybjsKLQl9Ci0JaWYgKHVhcnRfY2lyY19l bXB0eSh4bWl0KSB8fCB1YXJ0X3R4X3N0b3BwZWQoJnNzcC0+cG9ydCkpIHsKLQkJc2lmaXZlX3Nl cmlhbF9zdG9wX3R4KCZzc3AtPnBvcnQpOwotCQlyZXR1cm47Ci0JfQotCWNvdW50ID0gU0lGSVZF X1RYX0ZJRk9fREVQVEg7Ci0JZG8gewotCQlfX3NzcF90cmFuc21pdF9jaGFyKHNzcCwgeG1pdC0+ YnVmW3htaXQtPnRhaWxdKTsKLQkJeG1pdC0+dGFpbCA9ICh4bWl0LT50YWlsICsgMSkgJiAoVUFS VF9YTUlUX1NJWkUgLSAxKTsKLQkJc3NwLT5wb3J0Lmljb3VudC50eCsrOwotCQlpZiAodWFydF9j aXJjX2VtcHR5KHhtaXQpKQotCQkJYnJlYWs7Ci0JfSB3aGlsZSAoLS1jb3VudCA+IDApOwotCi0J aWYgKHVhcnRfY2lyY19jaGFyc19wZW5kaW5nKHhtaXQpIDwgV0FLRVVQX0NIQVJTKQotCQl1YXJ0 X3dyaXRlX3dha2V1cCgmc3NwLT5wb3J0KTsKLQotCWlmICh1YXJ0X2NpcmNfZW1wdHkoeG1pdCkp Ci0JCXNpZml2ZV9zZXJpYWxfc3RvcF90eCgmc3NwLT5wb3J0KTsKLX0KK3N0YXRpYyBERUZJTkVf VUFSVF9QT1JUX1RYX0hFTFBFUl9MSU1JVEVEKF9fc3NwX3RyYW5zbWl0X2NoYXJzLCBwb3J0LCBj aCwKKwkJdHJ1ZSwKKwkJX19zc3BfdHJhbnNtaXRfY2hhcihwb3J0X3RvX3NpZml2ZV9zZXJpYWxf cG9ydChwb3J0KSwgY2gpLAorCQkoe30pKTsKIAogLyoqCiAgKiBfX3NzcF9lbmFibGVfdHh3bSgp IC0gZW5hYmxlIHRyYW5zbWl0IHdhdGVybWFyayBpbnRlcnJ1cHRzCkBAIC01NTMsNyArNTE4LDcg QEAgc3RhdGljIGlycXJldHVybl90IHNpZml2ZV9zZXJpYWxfaXJxKGludCBpcnEsIHZvaWQgKmRl dl9pZCkKIAlpZiAoaXAgJiBTSUZJVkVfU0VSSUFMX0lQX1JYV01fTUFTSykKIAkJX19zc3BfcmVj ZWl2ZV9jaGFycyhzc3ApOwogCWlmIChpcCAmIFNJRklWRV9TRVJJQUxfSVBfVFhXTV9NQVNLKQot CQlfX3NzcF90cmFuc21pdF9jaGFycyhzc3ApOworCQlfX3NzcF90cmFuc21pdF9jaGFycygmc3Nw LT5wb3J0LCBTSUZJVkVfVFhfRklGT19ERVBUSCk7CiAKIAlzcGluX3VubG9jaygmc3NwLT5wb3J0 LmxvY2spOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3R0eS9zZXJpYWwvc3ByZF9zZXJpYWwuYyBi L2RyaXZlcnMvdHR5L3NlcmlhbC9zcHJkX3NlcmlhbC5jCmluZGV4IDQzMjliOWM5Y2JmMC4uZTIx N2I3YWI2OWFmIDEwMDY0NAotLS0gYS9kcml2ZXJzL3R0eS9zZXJpYWwvc3ByZF9zZXJpYWwuYwor KysgYi9kcml2ZXJzL3R0eS9zZXJpYWwvc3ByZF9zZXJpYWwuYwpAQCAtNjI0LDM4ICs2MjQsMTAg QEAgc3RhdGljIGlubGluZSB2b2lkIHNwcmRfcngoc3RydWN0IHVhcnRfcG9ydCAqcG9ydCkKIAl0 dHlfZmxpcF9idWZmZXJfcHVzaCh0dHkpOwogfQogCi1zdGF0aWMgaW5saW5lIHZvaWQgc3ByZF90 eChzdHJ1Y3QgdWFydF9wb3J0ICpwb3J0KQotewotCXN0cnVjdCBjaXJjX2J1ZiAqeG1pdCA9ICZw b3J0LT5zdGF0ZS0+eG1pdDsKLQlpbnQgY291bnQ7Ci0KLQlpZiAocG9ydC0+eF9jaGFyKSB7Ci0J CXNlcmlhbF9vdXQocG9ydCwgU1BSRF9UWEQsIHBvcnQtPnhfY2hhcik7Ci0JCXBvcnQtPmljb3Vu dC50eCsrOwotCQlwb3J0LT54X2NoYXIgPSAwOwotCQlyZXR1cm47Ci0JfQotCi0JaWYgKHVhcnRf Y2lyY19lbXB0eSh4bWl0KSB8fCB1YXJ0X3R4X3N0b3BwZWQocG9ydCkpIHsKLQkJc3ByZF9zdG9w X3R4KHBvcnQpOwotCQlyZXR1cm47Ci0JfQotCi0JY291bnQgPSBUSExEX1RYX0VNUFRZOwotCWRv IHsKLQkJc2VyaWFsX291dChwb3J0LCBTUFJEX1RYRCwgeG1pdC0+YnVmW3htaXQtPnRhaWxdKTsK LQkJeG1pdC0+dGFpbCA9ICh4bWl0LT50YWlsICsgMSkgJiAoVUFSVF9YTUlUX1NJWkUgLSAxKTsK LQkJcG9ydC0+aWNvdW50LnR4Kys7Ci0JCWlmICh1YXJ0X2NpcmNfZW1wdHkoeG1pdCkpCi0JCQli cmVhazsKLQl9IHdoaWxlICgtLWNvdW50ID4gMCk7Ci0KLQlpZiAodWFydF9jaXJjX2NoYXJzX3Bl bmRpbmcoeG1pdCkgPCBXQUtFVVBfQ0hBUlMpCi0JCXVhcnRfd3JpdGVfd2FrZXVwKHBvcnQpOwot Ci0JaWYgKHVhcnRfY2lyY19lbXB0eSh4bWl0KSkKLQkJc3ByZF9zdG9wX3R4KHBvcnQpOwotfQor c3RhdGljIERFRklORV9VQVJUX1BPUlRfVFhfSEVMUEVSX0xJTUlURUQoc3ByZF90eCwgcG9ydCwg Y2gsCisJCXRydWUsCisJCXNlcmlhbF9vdXQocG9ydCwgU1BSRF9UWEQsIGNoKSwKKwkJKHt9KSk7 CiAKIC8qIHRoaXMgaGFuZGxlcyB0aGUgaW50ZXJydXB0IGZyb20gb25lIHBvcnQgKi8KIHN0YXRp YyBpcnFyZXR1cm5fdCBzcHJkX2hhbmRsZV9pcnEoaW50IGlycSwgdm9pZCAqZGV2X2lkKQpAQCAt NjgzLDcgKzY1NSw3IEBAIHN0YXRpYyBpcnFyZXR1cm5fdCBzcHJkX2hhbmRsZV9pcnEoaW50IGly cSwgdm9pZCAqZGV2X2lkKQogCQlzcHJkX3J4KHBvcnQpOwogCiAJaWYgKGltcyAmIFNQUkRfSU1T Ul9UWF9GSUZPX0VNUFRZKQotCQlzcHJkX3R4KHBvcnQpOworCQlzcHJkX3R4KHBvcnQsIFRITERf VFhfRU1QVFkpOwogCiAJc3Bpbl91bmxvY2soJnBvcnQtPmxvY2spOwogCmRpZmYgLS1naXQgYS9k cml2ZXJzL3R0eS9zZXJpYWwvc3QtYXNjLmMgYi9kcml2ZXJzL3R0eS9zZXJpYWwvc3QtYXNjLmMK aW5kZXggY2NlNDJmNGM5YmMyLi5mNWRkM2ZhNGJmMjYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdHR5 L3NlcmlhbC9zdC1hc2MuYworKysgYi9kcml2ZXJzL3R0eS9zZXJpYWwvc3QtYXNjLmMKQEAgLTIz MCw2ICsyMzAsMTEgQEAgc3RhdGljIGlubGluZSB1bnNpZ25lZCBhc2NfaHdfdHhyb29tKHN0cnVj dCB1YXJ0X3BvcnQgKnBvcnQpCiAJcmV0dXJuIDA7CiB9CiAKK3N0YXRpYyBERUZJTkVfVUFSVF9Q T1JUX1RYX0hFTFBFUl9MSU1JVEVEKGFzY19kb190cmFuc21pdF9jaGFycywgcG9ydCwgY2gsCisJ CXRydWUsCisJCWFzY19vdXQocG9ydCwgQVNDX1RYQlVGLCBjaCksCisJCSh7fSkpOworCiAvKgog ICogU3RhcnQgdHJhbnNtaXR0aW5nIGNoYXJzLgogICogVGhpcyBpcyBjYWxsZWQgZnJvbSBib3Ro IGludGVycnVwdCBhbmQgdGFzayBsZXZlbC4KQEAgLTIzNyw1MCArMjQyLDcgQEAgc3RhdGljIGlu bGluZSB1bnNpZ25lZCBhc2NfaHdfdHhyb29tKHN0cnVjdCB1YXJ0X3BvcnQgKnBvcnQpCiAgKi8K IHN0YXRpYyB2b2lkIGFzY190cmFuc21pdF9jaGFycyhzdHJ1Y3QgdWFydF9wb3J0ICpwb3J0KQog ewotCXN0cnVjdCBjaXJjX2J1ZiAqeG1pdCA9ICZwb3J0LT5zdGF0ZS0+eG1pdDsKLQlpbnQgdHhy b29tOwotCXVuc2lnbmVkIGNoYXIgYzsKLQotCXR4cm9vbSA9IGFzY19od190eHJvb20ocG9ydCk7 Ci0KLQlpZiAoKHR4cm9vbSAhPSAwKSAmJiBwb3J0LT54X2NoYXIpIHsKLQkJYyA9IHBvcnQtPnhf Y2hhcjsKLQkJcG9ydC0+eF9jaGFyID0gMDsKLQkJYXNjX291dChwb3J0LCBBU0NfVFhCVUYsIGMp OwotCQlwb3J0LT5pY291bnQudHgrKzsKLQkJdHhyb29tID0gYXNjX2h3X3R4cm9vbShwb3J0KTsK LQl9Ci0KLQlpZiAodWFydF90eF9zdG9wcGVkKHBvcnQpKSB7Ci0JCS8qCi0JCSAqIFdlIHNob3Vs ZCB0cnkgYW5kIHN0b3AgdGhlIGhhcmR3YXJlIGhlcmUsIGJ1dCBJCi0JCSAqIGRvbid0IHRoaW5r IHRoZSBBU0MgaGFzIGFueSB3YXkgdG8gZG8gdGhhdC4KLQkJICovCi0JCWFzY19kaXNhYmxlX3R4 X2ludGVycnVwdHMocG9ydCk7Ci0JCXJldHVybjsKLQl9Ci0KLQlpZiAodWFydF9jaXJjX2VtcHR5 KHhtaXQpKSB7Ci0JCWFzY19kaXNhYmxlX3R4X2ludGVycnVwdHMocG9ydCk7Ci0JCXJldHVybjsK LQl9Ci0KLQlpZiAodHhyb29tID09IDApCi0JCXJldHVybjsKLQotCWRvIHsKLQkJYyA9IHhtaXQt PmJ1Zlt4bWl0LT50YWlsXTsKLQkJeG1pdC0+dGFpbCA9ICh4bWl0LT50YWlsICsgMSkgJiAoVUFS VF9YTUlUX1NJWkUgLSAxKTsKLQkJYXNjX291dChwb3J0LCBBU0NfVFhCVUYsIGMpOwotCQlwb3J0 LT5pY291bnQudHgrKzsKLQkJdHhyb29tLS07Ci0JfSB3aGlsZSAoKHR4cm9vbSA+IDApICYmICgh dWFydF9jaXJjX2VtcHR5KHhtaXQpKSk7Ci0KLQlpZiAodWFydF9jaXJjX2NoYXJzX3BlbmRpbmco eG1pdCkgPCBXQUtFVVBfQ0hBUlMpCi0JCXVhcnRfd3JpdGVfd2FrZXVwKHBvcnQpOwotCi0JaWYg KHVhcnRfY2lyY19lbXB0eSh4bWl0KSkKLQkJYXNjX2Rpc2FibGVfdHhfaW50ZXJydXB0cyhwb3J0 KTsKKwlhc2NfZG9fdHJhbnNtaXRfY2hhcnMocG9ydCwgYXNjX2h3X3R4cm9vbShwb3J0KSk7CiB9 CiAKIHN0YXRpYyB2b2lkIGFzY19yZWNlaXZlX2NoYXJzKHN0cnVjdCB1YXJ0X3BvcnQgKnBvcnQp Ci0tIAoyLjM3LjIKCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fXwpsaW51eC1yaXNjdiBtYWlsaW5nIGxpc3QKbGludXgtcmlzY3ZAbGlzdHMuaW5mcmFkZWFk Lm9yZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LXJp c2N2Cg==