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 CAB11ECAAD8 for ; Tue, 20 Sep 2022 07:59:06 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S229828AbiITH7D (ORCPT ); Tue, 20 Sep 2022 03:59:03 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:53990 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230344AbiITH6t (ORCPT ); Tue, 20 Sep 2022 03:58:49 -0400 Received: from smtp-out2.suse.de (smtp-out2.suse.de [IPv6:2001:67c:2178:6::1d]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 292782DFA; Tue, 20 Sep 2022 00:58:47 -0700 (PDT) Received: from relay2.suse.de (relay2.suse.de [149.44.160.134]) by smtp-out2.suse.de (Postfix) with ESMTP id B7AA71F85D; Tue, 20 Sep 2022 07:58:45 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=suse.cz; s=susede2_rsa; t=1663660725; 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=Sc1kkFYXOjlKs/IqOME2hwVVovuP1iWXSlhqWySE1dI=; b=K3bKSByLZfltwYwa1MHv0UuwlpmYaSomu9PMzUgfipqm7oVLmpopbVEStFKgmhASMwHJZP 6oSVloCvAts6DLUsp6q6zgDBxYJ3CCHjHoGnxHinjT5GgAmSuGzJzlS7xf6sXbByTk2u3+ hLVEpk5JuSm2gWsNsoJ6j410bfMUugw= DKIM-Signature: v=1; a=ed25519-sha256; c=relaxed/relaxed; d=suse.cz; s=susede2_ed25519; t=1663660725; 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=Sc1kkFYXOjlKs/IqOME2hwVVovuP1iWXSlhqWySE1dI=; b=SdnPN/5ZxIMnj8kD0Hzvg9q0+lez3VQHohKzZdecCgeddeHdfuEe3yYV1zCpmGJ+6GW+do HuJLSgdr2p7+Z7Dw== Received: from localhost.localdomain (unknown [10.100.201.122]) (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 1FCBD2C141; Tue, 20 Sep 2022 07:58:45 +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 v4 10/10] tty: serial: use uart_port_tx_limited() Date: Tue, 20 Sep 2022 09:58:44 +0200 Message-Id: <20220920075844.29360-1-jslaby@suse.cz> X-Mailer: git-send-email 2.37.3 In-Reply-To: <20220920052049.20507-1-jslaby@suse.cz> References: <20220920052049.20507-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 uart_port_tx_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 --- Notes: [v4] switch from DEFINE_UART_PORT_TX_HELPER_LIMITED() (helper generator) to uart_port_tx_limited() (akin to wait_event()) drivers/tty/serial/21285.c | 32 +++---------------- drivers/tty/serial/altera_jtaguart.c | 40 ++++++----------------- drivers/tty/serial/amba-pl010.c | 32 +++---------------- drivers/tty/serial/apbuart.c | 34 +++----------------- drivers/tty/serial/bcm63xx_uart.c | 47 ++++++--------------------- drivers/tty/serial/mux.c | 45 ++++++++------------------ drivers/tty/serial/mvebu-uart.c | 38 +++------------------- drivers/tty/serial/omap-serial.c | 32 +++---------------- drivers/tty/serial/pxa.c | 33 +++---------------- drivers/tty/serial/rp2.c | 31 ++++-------------- drivers/tty/serial/serial_txx9.c | 32 +++---------------- drivers/tty/serial/sifive.c | 31 +++--------------- drivers/tty/serial/sprd_serial.c | 33 +++---------------- drivers/tty/serial/st-asc.c | 48 +++------------------------- 14 files changed, 87 insertions(+), 421 deletions(-) diff --git a/drivers/tty/serial/21285.c b/drivers/tty/serial/21285.c index 2f17bf4b221e..84c1e3e365c8 100644 --- a/drivers/tty/serial/21285.c +++ b/drivers/tty/serial/21285.c @@ -154,35 +154,13 @@ static irqreturn_t serial21285_rx_chars(int irq, void *dev_id) 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); + u8 ch; - if (uart_circ_empty(xmit)) - serial21285_stop_tx(port); + uart_port_tx_limited(port, ch, 256, + !(*CSR_UARTFLG & 0x20), + *CSR_UARTDR = ch, + ({})); - out: return IRQ_HANDLED; } diff --git a/drivers/tty/serial/altera_jtaguart.c b/drivers/tty/serial/altera_jtaguart.c index 23f339757894..f224f5141726 100644 --- a/drivers/tty/serial/altera_jtaguart.c +++ b/drivers/tty/serial/altera_jtaguart.c @@ -137,39 +137,17 @@ static void altera_jtaguart_rx_chars(struct altera_jtaguart *pp) 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; - } + unsigned int space; + u8 ch; - 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); - } - } + space = readl(port->membase + ALTERA_JTAGUART_CONTROL_REG); + space &= ALTERA_JTAGUART_CONTROL_WSPACE_MSK; + space >>= ALTERA_JTAGUART_CONTROL_WSPACE_OFF; - if (pending == 0) - altera_jtaguart_stop_tx(port); + uart_port_tx_limited(port, ch, space, + true, + writel(ch, port->membase + ALTERA_JTAGUART_DATA_REG), + ({})); } 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 af27fb8ec145..a98fae2ca422 100644 --- a/drivers/tty/serial/amba-pl010.c +++ b/drivers/tty/serial/amba-pl010.c @@ -164,34 +164,12 @@ static void pl010_rx_chars(struct uart_port *port) static void pl010_tx_chars(struct uart_port *port) { - struct circ_buf *xmit = &port->state->xmit; - int count; + u8 ch; - 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); + uart_port_tx_limited(port, ch, port->fifosize >> 1, + true, + writel(ch, port->membase + UART01x_DR), + ({})); } static void pl010_modem_status(struct uart_amba_port *uap) diff --git a/drivers/tty/serial/apbuart.c b/drivers/tty/serial/apbuart.c index 450f4edfda0f..915ee4b0d594 100644 --- a/drivers/tty/serial/apbuart.c +++ b/drivers/tty/serial/apbuart.c @@ -122,36 +122,12 @@ static void apbuart_rx_chars(struct uart_port *port) 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); + u8 ch; - if (uart_circ_empty(xmit)) - apbuart_stop_tx(port); + uart_port_tx_limited(port, ch, port->fifosize >> 1, + true, + UART_PUT_CHAR(port, ch), + ({})); } 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 5d9737c2d1f2..62bc7244dc67 100644 --- a/drivers/tty/serial/bcm63xx_uart.c +++ b/drivers/tty/serial/bcm63xx_uart.c @@ -303,53 +303,24 @@ static void bcm_uart_do_rx(struct uart_port *port) */ 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; + bool pending; + u8 ch; 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 = uart_port_tx_limited(port, ch, port->fifosize - val, + true, + bcm_uart_writel(port, ch, UART_FIFO_REG), + ({})); + 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 ed0e763f622a..85ce1e9af44a 100644 --- a/drivers/tty/serial/mux.c +++ b/drivers/tty/serial/mux.c @@ -171,6 +171,13 @@ 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); +} + /** * mux_write - Write chars to the mux fifo. * @port: Ptr to the uart_port. @@ -180,39 +187,13 @@ 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); + u8 ch; - if (uart_circ_empty(xmit)) - mux_stop_tx(port); + uart_port_tx_limited(port, ch, + port->fifosize - UART_GET_FIFO_CNT(port), + true, + UART_PUT_CHAR(port, ch), + mux_tx_done(port)); } /** diff --git a/drivers/tty/serial/mvebu-uart.c b/drivers/tty/serial/mvebu-uart.c index ba16e1da6bd3..7b566404cb33 100644 --- a/drivers/tty/serial/mvebu-uart.c +++ b/drivers/tty/serial/mvebu-uart.c @@ -335,40 +335,12 @@ static void mvebu_uart_rx_chars(struct uart_port *port, unsigned int status) 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); + u8 ch; - if (uart_circ_empty(xmit)) - mvebu_uart_stop_tx(port); + uart_port_tx_limited(port, ch, port->fifosize, + !(readl(port->membase + UART_STAT) & STAT_TX_FIFO_FUL), + writel(ch, port->membase + UART_TSH(port)), + ({})); } 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 b7b76e49115e..ccea746e1214 100644 --- a/drivers/tty/serial/omap-serial.c +++ b/drivers/tty/serial/omap-serial.c @@ -348,34 +348,12 @@ static void serial_omap_put_char(struct uart_omap_port *up, unsigned char ch) static void transmit_chars(struct uart_omap_port *up, unsigned int lsr) { - struct circ_buf *xmit = &up->port.state->xmit; - int count; + u8 ch; - if (up->port.x_char) { - serial_omap_put_char(up, 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_omap_stop_tx(&up->port); - return; - } - count = up->port.fifosize / 4; - do { - serial_omap_put_char(up, 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); - - if (uart_circ_empty(xmit)) - serial_omap_stop_tx(&up->port); + uart_port_tx_limited(&up->port, ch, up->port.fifosize / 4, + true, + serial_omap_put_char(up, ch), + ({})); } static inline void serial_omap_enable_ier_thri(struct uart_omap_port *up) diff --git a/drivers/tty/serial/pxa.c b/drivers/tty/serial/pxa.c index 2d25231fad84..444fa4b654ac 100644 --- a/drivers/tty/serial/pxa.c +++ b/drivers/tty/serial/pxa.c @@ -174,35 +174,12 @@ static inline void receive_chars(struct uart_pxa_port *up, int *status) static void transmit_chars(struct uart_pxa_port *up) { - struct circ_buf *xmit = &up->port.state->xmit; - int count; + u8 ch; - 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); - - - if (uart_circ_empty(xmit)) - serial_pxa_stop_tx(&up->port); + uart_port_tx_limited(&up->port, ch, up->port.fifosize / 2, + true, + serial_out(up, UART_TX, ch), + ({})); } static void serial_pxa_start_tx(struct uart_port *port) diff --git a/drivers/tty/serial/rp2.c b/drivers/tty/serial/rp2.c index b81afb06f1f4..749b873a5d99 100644 --- a/drivers/tty/serial/rp2.c +++ b/drivers/tty/serial/rp2.c @@ -427,32 +427,13 @@ static void rp2_rx_chars(struct rp2_uart_port *up) 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; + u8 ch; - 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); + uart_port_tx_limited(&up->port, ch, + FIFO_SIZE - readw(up->base + RP2_TX_FIFO_COUNT), + true, + writeb(ch, up->base + RP2_DATA_BYTE), + ({})); } static void rp2_ch_interrupt(struct rp2_uart_port *up) diff --git a/drivers/tty/serial/serial_txx9.c b/drivers/tty/serial/serial_txx9.c index e12f1dc18c38..eab387b01e36 100644 --- a/drivers/tty/serial/serial_txx9.c +++ b/drivers/tty/serial/serial_txx9.c @@ -321,34 +321,12 @@ receive_chars(struct uart_port *up, unsigned int *status) static inline void transmit_chars(struct uart_port *up) { - struct circ_buf *xmit = &up->state->xmit; - int count; + u8 ch; - 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); + uart_port_tx_limited(up, ch, TXX9_SIO_TX_FIFO, + true, + sio_out(up, TXX9_SITFIFO, ch), + ({})); } static irqreturn_t serial_txx9_interrupt(int irq, void *dev_id) diff --git a/drivers/tty/serial/sifive.c b/drivers/tty/serial/sifive.c index 4761f172103a..64cfd455f556 100644 --- a/drivers/tty/serial/sifive.c +++ b/drivers/tty/serial/sifive.c @@ -288,33 +288,12 @@ static void __ssp_transmit_char(struct sifive_serial_port *ssp, int ch) */ 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); + u8 ch; - if (uart_circ_empty(xmit)) - sifive_serial_stop_tx(&ssp->port); + uart_port_tx_limited(&ssp->port, ch, SIFIVE_TX_FIFO_DEPTH, + true, + __ssp_transmit_char(ssp, ch), + ({})); } /** diff --git a/drivers/tty/serial/sprd_serial.c b/drivers/tty/serial/sprd_serial.c index 342a87967631..3f34f7bb7700 100644 --- a/drivers/tty/serial/sprd_serial.c +++ b/drivers/tty/serial/sprd_serial.c @@ -626,35 +626,12 @@ static inline void sprd_rx(struct uart_port *port) 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); + u8 ch; - if (uart_circ_empty(xmit)) - sprd_stop_tx(port); + uart_port_tx_limited(port, ch, THLD_TX_EMPTY, + true, + serial_out(port, SPRD_TXD, ch), + ({})); } /* this handles the interrupt from one port */ diff --git a/drivers/tty/serial/st-asc.c b/drivers/tty/serial/st-asc.c index fcecea689a0d..5215e6910f68 100644 --- a/drivers/tty/serial/st-asc.c +++ b/drivers/tty/serial/st-asc.c @@ -237,50 +237,12 @@ 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); + u8 ch; - if (uart_circ_empty(xmit)) - asc_disable_tx_interrupts(port); + uart_port_tx_limited(port, ch, asc_hw_txroom(port), + true, + asc_out(port, ASC_TXBUF, ch), + ({})); } static void asc_receive_chars(struct uart_port *port) -- 2.37.3 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 EA8FDC54EE9 for ; Tue, 20 Sep 2022 07:59:05 +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=+D24WlRraqKPC0n4IlhuhYUt8i67xxrgriQaSztk328=; b=dojK3W9Kf9IAgT /I3pYYUmOqdxIPyt0k7RD32m4ggdtil0PAUTXtm4shElSHKDuwPIUzd6zoBqBeX7cClWH8gJKI1hO mQG7+pZsXaddoU09KkBjNoAr2Gb0YlANiSnkAs4UTVSp7Q7L9p5JRV/J8b+AaKEOYlrryeZWtjgfp iKTeEz39EYHhkX9meIvILYRmzjGeq6BBnHQ0GO8A5TnzFCkdi1ZNVgU9YkuQz9Bby21gK3jVCjZg1 7jwFyAdgIskU99MrWm/7nc6UWCJRXFhDU9Yw4WHQeg1eO3P9z1/h6eUK0IMeDH0oCkxm03CCK68GG 4VrVzbw5zgOgLrsVl5vw==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1oaY9e-001XtT-NT; Tue, 20 Sep 2022 07:58:54 +0000 Received: from smtp-out2.suse.de ([195.135.220.29]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1oaY9Z-001XrV-HB for linux-riscv@lists.infradead.org; Tue, 20 Sep 2022 07:58:52 +0000 Received: from relay2.suse.de (relay2.suse.de [149.44.160.134]) by smtp-out2.suse.de (Postfix) with ESMTP id B7AA71F85D; Tue, 20 Sep 2022 07:58:45 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=suse.cz; s=susede2_rsa; t=1663660725; 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=Sc1kkFYXOjlKs/IqOME2hwVVovuP1iWXSlhqWySE1dI=; b=K3bKSByLZfltwYwa1MHv0UuwlpmYaSomu9PMzUgfipqm7oVLmpopbVEStFKgmhASMwHJZP 6oSVloCvAts6DLUsp6q6zgDBxYJ3CCHjHoGnxHinjT5GgAmSuGzJzlS7xf6sXbByTk2u3+ hLVEpk5JuSm2gWsNsoJ6j410bfMUugw= DKIM-Signature: v=1; a=ed25519-sha256; c=relaxed/relaxed; d=suse.cz; s=susede2_ed25519; t=1663660725; 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=Sc1kkFYXOjlKs/IqOME2hwVVovuP1iWXSlhqWySE1dI=; b=SdnPN/5ZxIMnj8kD0Hzvg9q0+lez3VQHohKzZdecCgeddeHdfuEe3yYV1zCpmGJ+6GW+do HuJLSgdr2p7+Z7Dw== Received: from localhost.localdomain (unknown [10.100.201.122]) (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 1FCBD2C141; Tue, 20 Sep 2022 07:58:45 +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 v4 10/10] tty: serial: use uart_port_tx_limited() Date: Tue, 20 Sep 2022 09:58:44 +0200 Message-Id: <20220920075844.29360-1-jslaby@suse.cz> X-Mailer: git-send-email 2.37.3 In-Reply-To: <20220920052049.20507-1-jslaby@suse.cz> References: <20220920052049.20507-1-jslaby@suse.cz> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20220920_005850_076226_30E61DD1 X-CRM114-Status: GOOD ( 21.35 ) 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 dWFydF9wb3J0X3R4X2xpbWl0ZWQoKSBpcyBhIG5ldyBoZWxwZXIgdG8gc2VuZCBjaGFyYWN0ZXJz IHRvIHRoZSBkZXZpY2UuClVzZSBpdCBpbiB0aGVzZSBkcml2ZXJzLgoKbXV4LmMgYWxzbyBuZWVk cyB0byBkZWZpbmUgdHhfZG9uZSgpLiBCdXQgSSdtIG5vdCBzdXJlIGlmIHRoZSBkcml2ZXIKcmVh bGx5IHdhbnRzIHRvIHdhaXQgZm9yIGFsbCB0aGUgY2hhcmFjdGVycyB0byBkaXNtaXNzIGZyb20g dGhlIEhXIGZpZm8KYXQgdGhpcyBjb2RlIHBvaW50LiBIZW5jZSBJIG1hcmtlZCB0aGlzIGFzIEZJ WE1FLgoKU2lnbmVkLW9mZi1ieTogSmlyaSBTbGFieSA8anNsYWJ5QHN1c2UuY3o+CkNjOiBSdXNz ZWxsIEtpbmcgPGxpbnV4QGFybWxpbnV4Lm9yZy51az4KQ2M6IEZsb3JpYW4gRmFpbmVsbGkgPGYu ZmFpbmVsbGlAZ21haWwuY29tPgpDYzogYmNtLWtlcm5lbC1mZWVkYmFjay1saXN0QGJyb2FkY29t LmNvbQpDYzogIlBhbGkgUm9ow6FyIiA8cGFsaUBrZXJuZWwub3JnPgpDYzogS2V2aW4gQ2VybmVr ZWUgPGNlcm5la2VlQGdtYWlsLmNvbT4KQ2M6IFBhbG1lciBEYWJiZWx0IDxwYWxtZXJAZGFiYmVs dC5jb20+CkNjOiBQYXVsIFdhbG1zbGV5IDxwYXVsLndhbG1zbGV5QHNpZml2ZS5jb20+CkNjOiBP cnNvbiBaaGFpIDxvcnNvbnpoYWlAZ21haWwuY29tPgpDYzogQmFvbGluIFdhbmcgPGJhb2xpbi53 YW5nN0BnbWFpbC5jb20+CkNjOiBDaHVueWFuIFpoYW5nIDx6aGFuZy5seXJhQGdtYWlsLmNvbT4K Q2M6IFBhdHJpY2UgQ2hvdGFyZCA8cGF0cmljZS5jaG90YXJkQGZvc3Muc3QuY29tPgpDYzogbGlu dXgtcmlzY3ZAbGlzdHMuaW5mcmFkZWFkLm9yZwotLS0KCk5vdGVzOgogICAgW3Y0XSBzd2l0Y2gg ZnJvbSBERUZJTkVfVUFSVF9QT1JUX1RYX0hFTFBFUl9MSU1JVEVEKCkgKGhlbHBlciBnZW5lcmF0 b3IpCiAgICAgICAgIHRvIHVhcnRfcG9ydF90eF9saW1pdGVkKCkgKGFraW4gdG8gd2FpdF9ldmVu dCgpKQoKIGRyaXZlcnMvdHR5L3NlcmlhbC8yMTI4NS5jICAgICAgICAgICB8IDMyICsrKy0tLS0t LS0tLS0tLS0tLS0KIGRyaXZlcnMvdHR5L3NlcmlhbC9hbHRlcmFfanRhZ3VhcnQuYyB8IDQwICsr KysrKy0tLS0tLS0tLS0tLS0tLS0tCiBkcml2ZXJzL3R0eS9zZXJpYWwvYW1iYS1wbDAxMC5jICAg ICAgfCAzMiArKystLS0tLS0tLS0tLS0tLS0tCiBkcml2ZXJzL3R0eS9zZXJpYWwvYXBidWFydC5j ICAgICAgICAgfCAzNCArKystLS0tLS0tLS0tLS0tLS0tLQogZHJpdmVycy90dHkvc2VyaWFsL2Jj bTYzeHhfdWFydC5jICAgIHwgNDcgKysrKysrLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiBkcml2ZXJz L3R0eS9zZXJpYWwvbXV4LmMgICAgICAgICAgICAgfCA0NSArKysrKysrKy0tLS0tLS0tLS0tLS0t LS0tLQogZHJpdmVycy90dHkvc2VyaWFsL212ZWJ1LXVhcnQuYyAgICAgIHwgMzggKysrLS0tLS0t LS0tLS0tLS0tLS0tLQogZHJpdmVycy90dHkvc2VyaWFsL29tYXAtc2VyaWFsLmMgICAgIHwgMzIg KysrLS0tLS0tLS0tLS0tLS0tLQogZHJpdmVycy90dHkvc2VyaWFsL3B4YS5jICAgICAgICAgICAg IHwgMzMgKysrLS0tLS0tLS0tLS0tLS0tLQogZHJpdmVycy90dHkvc2VyaWFsL3JwMi5jICAgICAg ICAgICAgIHwgMzEgKysrKy0tLS0tLS0tLS0tLS0tCiBkcml2ZXJzL3R0eS9zZXJpYWwvc2VyaWFs X3R4eDkuYyAgICAgfCAzMiArKystLS0tLS0tLS0tLS0tLS0tCiBkcml2ZXJzL3R0eS9zZXJpYWwv c2lmaXZlLmMgICAgICAgICAgfCAzMSArKystLS0tLS0tLS0tLS0tLS0KIGRyaXZlcnMvdHR5L3Nl cmlhbC9zcHJkX3NlcmlhbC5jICAgICB8IDMzICsrKy0tLS0tLS0tLS0tLS0tLS0KIGRyaXZlcnMv dHR5L3NlcmlhbC9zdC1hc2MuYyAgICAgICAgICB8IDQ4ICsrKy0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0KIDE0IGZpbGVzIGNoYW5nZWQsIDg3IGluc2VydGlvbnMoKyksIDQyMSBkZWxldGlvbnMo LSkKCmRpZmYgLS1naXQgYS9kcml2ZXJzL3R0eS9zZXJpYWwvMjEyODUuYyBiL2RyaXZlcnMvdHR5 L3NlcmlhbC8yMTI4NS5jCmluZGV4IDJmMTdiZjRiMjIxZS4uODRjMWUzZTM2NWM4IDEwMDY0NAot LS0gYS9kcml2ZXJzL3R0eS9zZXJpYWwvMjEyODUuYworKysgYi9kcml2ZXJzL3R0eS9zZXJpYWwv MjEyODUuYwpAQCAtMTU0LDM1ICsxNTQsMTMgQEAgc3RhdGljIGlycXJldHVybl90IHNlcmlhbDIx Mjg1X3J4X2NoYXJzKGludCBpcnEsIHZvaWQgKmRldl9pZCkKIHN0YXRpYyBpcnFyZXR1cm5fdCBz ZXJpYWwyMTI4NV90eF9jaGFycyhpbnQgaXJxLCB2b2lkICpkZXZfaWQpCiB7CiAJc3RydWN0IHVh cnRfcG9ydCAqcG9ydCA9IGRldl9pZDsKLQlzdHJ1Y3QgY2lyY19idWYgKnhtaXQgPSAmcG9ydC0+ c3RhdGUtPnhtaXQ7Ci0JaW50IGNvdW50ID0gMjU2OwotCi0JaWYgKHBvcnQtPnhfY2hhcikgewot CQkqQ1NSX1VBUlREUiA9IHBvcnQtPnhfY2hhcjsKLQkJcG9ydC0+aWNvdW50LnR4Kys7Ci0JCXBv cnQtPnhfY2hhciA9IDA7Ci0JCWdvdG8gb3V0OwotCX0KLQlpZiAodWFydF9jaXJjX2VtcHR5KHht aXQpIHx8IHVhcnRfdHhfc3RvcHBlZChwb3J0KSkgewotCQlzZXJpYWwyMTI4NV9zdG9wX3R4KHBv cnQpOwotCQlnb3RvIG91dDsKLQl9Ci0KLQlkbyB7Ci0JCSpDU1JfVUFSVERSID0geG1pdC0+YnVm W3htaXQtPnRhaWxdOwotCQl4bWl0LT50YWlsID0gKHhtaXQtPnRhaWwgKyAxKSAmIChVQVJUX1hN SVRfU0laRSAtIDEpOwotCQlwb3J0LT5pY291bnQudHgrKzsKLQkJaWYgKHVhcnRfY2lyY19lbXB0 eSh4bWl0KSkKLQkJCWJyZWFrOwotCX0gd2hpbGUgKC0tY291bnQgPiAwICYmICEoKkNTUl9VQVJU RkxHICYgMHgyMCkpOwotCi0JaWYgKHVhcnRfY2lyY19jaGFyc19wZW5kaW5nKHhtaXQpIDwgV0FL RVVQX0NIQVJTKQotCQl1YXJ0X3dyaXRlX3dha2V1cChwb3J0KTsKKwl1OCBjaDsKIAotCWlmICh1 YXJ0X2NpcmNfZW1wdHkoeG1pdCkpCi0JCXNlcmlhbDIxMjg1X3N0b3BfdHgocG9ydCk7CisJdWFy dF9wb3J0X3R4X2xpbWl0ZWQocG9ydCwgY2gsIDI1NiwKKwkJISgqQ1NSX1VBUlRGTEcgJiAweDIw KSwKKwkJKkNTUl9VQVJURFIgPSBjaCwKKwkJKHt9KSk7CiAKLSBvdXQ6CiAJcmV0dXJuIElSUV9I QU5ETEVEOwogfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3R0eS9zZXJpYWwvYWx0ZXJhX2p0YWd1 YXJ0LmMgYi9kcml2ZXJzL3R0eS9zZXJpYWwvYWx0ZXJhX2p0YWd1YXJ0LmMKaW5kZXggMjNmMzM5 NzU3ODk0Li5mMjI0ZjUxNDE3MjYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdHR5L3NlcmlhbC9hbHRl cmFfanRhZ3VhcnQuYworKysgYi9kcml2ZXJzL3R0eS9zZXJpYWwvYWx0ZXJhX2p0YWd1YXJ0LmMK QEAgLTEzNywzOSArMTM3LDE3IEBAIHN0YXRpYyB2b2lkIGFsdGVyYV9qdGFndWFydF9yeF9jaGFy cyhzdHJ1Y3QgYWx0ZXJhX2p0YWd1YXJ0ICpwcCkKIHN0YXRpYyB2b2lkIGFsdGVyYV9qdGFndWFy dF90eF9jaGFycyhzdHJ1Y3QgYWx0ZXJhX2p0YWd1YXJ0ICpwcCkKIHsKIAlzdHJ1Y3QgdWFydF9w b3J0ICpwb3J0ID0gJnBwLT5wb3J0OwotCXN0cnVjdCBjaXJjX2J1ZiAqeG1pdCA9ICZwb3J0LT5z dGF0ZS0+eG1pdDsKLQl1bnNpZ25lZCBpbnQgcGVuZGluZywgY291bnQ7Ci0KLQlpZiAocG9ydC0+ eF9jaGFyKSB7Ci0JCS8qIFNlbmQgc3BlY2lhbCBjaGFyIC0gcHJvYmFibHkgZmxvdyBjb250cm9s ICovCi0JCXdyaXRlbChwb3J0LT54X2NoYXIsIHBvcnQtPm1lbWJhc2UgKyBBTFRFUkFfSlRBR1VB UlRfREFUQV9SRUcpOwotCQlwb3J0LT54X2NoYXIgPSAwOwotCQlwb3J0LT5pY291bnQudHgrKzsK LQkJcmV0dXJuOwotCX0KKwl1bnNpZ25lZCBpbnQgc3BhY2U7CisJdTggY2g7CiAKLQlwZW5kaW5n ID0gdWFydF9jaXJjX2NoYXJzX3BlbmRpbmcoeG1pdCk7Ci0JaWYgKHBlbmRpbmcgPiAwKSB7Ci0J CWNvdW50ID0gKHJlYWRsKHBvcnQtPm1lbWJhc2UgKyBBTFRFUkFfSlRBR1VBUlRfQ09OVFJPTF9S RUcpICYKLQkJCQlBTFRFUkFfSlRBR1VBUlRfQ09OVFJPTF9XU1BBQ0VfTVNLKSA+PgotCQkJQUxU RVJBX0pUQUdVQVJUX0NPTlRST0xfV1NQQUNFX09GRjsKLQkJaWYgKGNvdW50ID4gcGVuZGluZykK LQkJCWNvdW50ID0gcGVuZGluZzsKLQkJaWYgKGNvdW50ID4gMCkgewotCQkJcGVuZGluZyAtPSBj b3VudDsKLQkJCXdoaWxlIChjb3VudC0tKSB7Ci0JCQkJd3JpdGVsKHhtaXQtPmJ1Zlt4bWl0LT50 YWlsXSwKLQkJCQkgICAgICAgcG9ydC0+bWVtYmFzZSArIEFMVEVSQV9KVEFHVUFSVF9EQVRBX1JF Ryk7Ci0JCQkJeG1pdC0+dGFpbCA9ICh4bWl0LT50YWlsICsgMSkgJiAoVUFSVF9YTUlUX1NJWkUg LSAxKTsKLQkJCQlwb3J0LT5pY291bnQudHgrKzsKLQkJCX0KLQkJCWlmIChwZW5kaW5nIDwgV0FL RVVQX0NIQVJTKQotCQkJCXVhcnRfd3JpdGVfd2FrZXVwKHBvcnQpOwotCQl9Ci0JfQorCXNwYWNl ID0gcmVhZGwocG9ydC0+bWVtYmFzZSArIEFMVEVSQV9KVEFHVUFSVF9DT05UUk9MX1JFRyk7CisJ c3BhY2UgJj0gQUxURVJBX0pUQUdVQVJUX0NPTlRST0xfV1NQQUNFX01TSzsKKwlzcGFjZSA+Pj0g QUxURVJBX0pUQUdVQVJUX0NPTlRST0xfV1NQQUNFX09GRjsKIAotCWlmIChwZW5kaW5nID09IDAp Ci0JCWFsdGVyYV9qdGFndWFydF9zdG9wX3R4KHBvcnQpOworCXVhcnRfcG9ydF90eF9saW1pdGVk KHBvcnQsIGNoLCBzcGFjZSwKKwkJdHJ1ZSwKKwkJd3JpdGVsKGNoLCBwb3J0LT5tZW1iYXNlICsg QUxURVJBX0pUQUdVQVJUX0RBVEFfUkVHKSwKKwkJKHt9KSk7CiB9CiAKIHN0YXRpYyBpcnFyZXR1 cm5fdCBhbHRlcmFfanRhZ3VhcnRfaW50ZXJydXB0KGludCBpcnEsIHZvaWQgKmRhdGEpCmRpZmYg LS1naXQgYS9kcml2ZXJzL3R0eS9zZXJpYWwvYW1iYS1wbDAxMC5jIGIvZHJpdmVycy90dHkvc2Vy aWFsL2FtYmEtcGwwMTAuYwppbmRleCBhZjI3ZmI4ZWMxNDUuLmE5OGZhZTJjYTQyMiAxMDA2NDQK LS0tIGEvZHJpdmVycy90dHkvc2VyaWFsL2FtYmEtcGwwMTAuYworKysgYi9kcml2ZXJzL3R0eS9z ZXJpYWwvYW1iYS1wbDAxMC5jCkBAIC0xNjQsMzQgKzE2NCwxMiBAQCBzdGF0aWMgdm9pZCBwbDAx MF9yeF9jaGFycyhzdHJ1Y3QgdWFydF9wb3J0ICpwb3J0KQogCiBzdGF0aWMgdm9pZCBwbDAxMF90 eF9jaGFycyhzdHJ1Y3QgdWFydF9wb3J0ICpwb3J0KQogewotCXN0cnVjdCBjaXJjX2J1ZiAqeG1p dCA9ICZwb3J0LT5zdGF0ZS0+eG1pdDsKLQlpbnQgY291bnQ7CisJdTggY2g7CiAKLQlpZiAocG9y dC0+eF9jaGFyKSB7Ci0JCXdyaXRlbChwb3J0LT54X2NoYXIsIHBvcnQtPm1lbWJhc2UgKyBVQVJU MDF4X0RSKTsKLQkJcG9ydC0+aWNvdW50LnR4Kys7Ci0JCXBvcnQtPnhfY2hhciA9IDA7Ci0JCXJl dHVybjsKLQl9Ci0JaWYgKHVhcnRfY2lyY19lbXB0eSh4bWl0KSB8fCB1YXJ0X3R4X3N0b3BwZWQo cG9ydCkpIHsKLQkJcGwwMTBfc3RvcF90eChwb3J0KTsKLQkJcmV0dXJuOwotCX0KLQotCWNvdW50 ID0gcG9ydC0+Zmlmb3NpemUgPj4gMTsKLQlkbyB7Ci0JCXdyaXRlbCh4bWl0LT5idWZbeG1pdC0+ dGFpbF0sIHBvcnQtPm1lbWJhc2UgKyBVQVJUMDF4X0RSKTsKLQkJeG1pdC0+dGFpbCA9ICh4bWl0 LT50YWlsICsgMSkgJiAoVUFSVF9YTUlUX1NJWkUgLSAxKTsKLQkJcG9ydC0+aWNvdW50LnR4Kys7 Ci0JCWlmICh1YXJ0X2NpcmNfZW1wdHkoeG1pdCkpCi0JCQlicmVhazsKLQl9IHdoaWxlICgtLWNv dW50ID4gMCk7Ci0KLQlpZiAodWFydF9jaXJjX2NoYXJzX3BlbmRpbmcoeG1pdCkgPCBXQUtFVVBf Q0hBUlMpCi0JCXVhcnRfd3JpdGVfd2FrZXVwKHBvcnQpOwotCi0JaWYgKHVhcnRfY2lyY19lbXB0 eSh4bWl0KSkKLQkJcGwwMTBfc3RvcF90eChwb3J0KTsKKwl1YXJ0X3BvcnRfdHhfbGltaXRlZChw b3J0LCBjaCwgcG9ydC0+Zmlmb3NpemUgPj4gMSwKKwkJdHJ1ZSwKKwkJd3JpdGVsKGNoLCBwb3J0 LT5tZW1iYXNlICsgVUFSVDAxeF9EUiksCisJCSh7fSkpOwogfQogCiBzdGF0aWMgdm9pZCBwbDAx MF9tb2RlbV9zdGF0dXMoc3RydWN0IHVhcnRfYW1iYV9wb3J0ICp1YXApCmRpZmYgLS1naXQgYS9k cml2ZXJzL3R0eS9zZXJpYWwvYXBidWFydC5jIGIvZHJpdmVycy90dHkvc2VyaWFsL2FwYnVhcnQu YwppbmRleCA0NTBmNGVkZmRhMGYuLjkxNWVlNGIwZDU5NCAxMDA2NDQKLS0tIGEvZHJpdmVycy90 dHkvc2VyaWFsL2FwYnVhcnQuYworKysgYi9kcml2ZXJzL3R0eS9zZXJpYWwvYXBidWFydC5jCkBA IC0xMjIsMzYgKzEyMiwxMiBAQCBzdGF0aWMgdm9pZCBhcGJ1YXJ0X3J4X2NoYXJzKHN0cnVjdCB1 YXJ0X3BvcnQgKnBvcnQpCiAKIHN0YXRpYyB2b2lkIGFwYnVhcnRfdHhfY2hhcnMoc3RydWN0IHVh cnRfcG9ydCAqcG9ydCkKIHsKLQlzdHJ1Y3QgY2lyY19idWYgKnhtaXQgPSAmcG9ydC0+c3RhdGUt PnhtaXQ7Ci0JaW50IGNvdW50OwotCi0JaWYgKHBvcnQtPnhfY2hhcikgewotCQlVQVJUX1BVVF9D SEFSKHBvcnQsIHBvcnQtPnhfY2hhcik7Ci0JCXBvcnQtPmljb3VudC50eCsrOwotCQlwb3J0LT54 X2NoYXIgPSAwOwotCQlyZXR1cm47Ci0JfQotCi0JaWYgKHVhcnRfY2lyY19lbXB0eSh4bWl0KSB8 fCB1YXJ0X3R4X3N0b3BwZWQocG9ydCkpIHsKLQkJYXBidWFydF9zdG9wX3R4KHBvcnQpOwotCQly ZXR1cm47Ci0JfQotCi0JLyogYW1iYTogZmlsbCBGSUZPICovCi0JY291bnQgPSBwb3J0LT5maWZv c2l6ZSA+PiAxOwotCWRvIHsKLQkJVUFSVF9QVVRfQ0hBUihwb3J0LCB4bWl0LT5idWZbeG1pdC0+ dGFpbF0pOwotCQl4bWl0LT50YWlsID0gKHhtaXQtPnRhaWwgKyAxKSAmIChVQVJUX1hNSVRfU0la RSAtIDEpOwotCQlwb3J0LT5pY291bnQudHgrKzsKLQkJaWYgKHVhcnRfY2lyY19lbXB0eSh4bWl0 KSkKLQkJCWJyZWFrOwotCX0gd2hpbGUgKC0tY291bnQgPiAwKTsKLQotCWlmICh1YXJ0X2NpcmNf Y2hhcnNfcGVuZGluZyh4bWl0KSA8IFdBS0VVUF9DSEFSUykKLQkJdWFydF93cml0ZV93YWtldXAo cG9ydCk7CisJdTggY2g7CiAKLQlpZiAodWFydF9jaXJjX2VtcHR5KHhtaXQpKQotCQlhcGJ1YXJ0 X3N0b3BfdHgocG9ydCk7CisJdWFydF9wb3J0X3R4X2xpbWl0ZWQocG9ydCwgY2gsIHBvcnQtPmZp Zm9zaXplID4+IDEsCisJCXRydWUsCisJCVVBUlRfUFVUX0NIQVIocG9ydCwgY2gpLAorCQkoe30p KTsKIH0KIAogc3RhdGljIGlycXJldHVybl90IGFwYnVhcnRfaW50KGludCBpcnEsIHZvaWQgKmRl dl9pZCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdHR5L3NlcmlhbC9iY202M3h4X3VhcnQuYyBiL2Ry aXZlcnMvdHR5L3NlcmlhbC9iY202M3h4X3VhcnQuYwppbmRleCA1ZDk3MzdjMmQxZjIuLjYyYmM3 MjQ0ZGM2NyAxMDA2NDQKLS0tIGEvZHJpdmVycy90dHkvc2VyaWFsL2JjbTYzeHhfdWFydC5jCisr KyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9iY202M3h4X3VhcnQuYwpAQCAtMzAzLDUzICszMDMsMjQg QEAgc3RhdGljIHZvaWQgYmNtX3VhcnRfZG9fcngoc3RydWN0IHVhcnRfcG9ydCAqcG9ydCkKICAq Lwogc3RhdGljIHZvaWQgYmNtX3VhcnRfZG9fdHgoc3RydWN0IHVhcnRfcG9ydCAqcG9ydCkKIHsK LQlzdHJ1Y3QgY2lyY19idWYgKnhtaXQ7Ci0JdW5zaWduZWQgaW50IHZhbCwgbWF4X2NvdW50Owot Ci0JaWYgKHBvcnQtPnhfY2hhcikgewotCQliY21fdWFydF93cml0ZWwocG9ydCwgcG9ydC0+eF9j aGFyLCBVQVJUX0ZJRk9fUkVHKTsKLQkJcG9ydC0+aWNvdW50LnR4Kys7Ci0JCXBvcnQtPnhfY2hh ciA9IDA7Ci0JCXJldHVybjsKLQl9Ci0KLQlpZiAodWFydF90eF9zdG9wcGVkKHBvcnQpKSB7Ci0J CWJjbV91YXJ0X3N0b3BfdHgocG9ydCk7Ci0JCXJldHVybjsKLQl9Ci0KLQl4bWl0ID0gJnBvcnQt PnN0YXRlLT54bWl0OwotCWlmICh1YXJ0X2NpcmNfZW1wdHkoeG1pdCkpCi0JCWdvdG8gdHhxX2Vt cHR5OworCXVuc2lnbmVkIGludCB2YWw7CisJYm9vbCBwZW5kaW5nOworCXU4IGNoOwogCiAJdmFs ID0gYmNtX3VhcnRfcmVhZGwocG9ydCwgVUFSVF9NQ1RMX1JFRyk7CiAJdmFsID0gKHZhbCAmIFVB UlRfTUNUTF9UWEZJRk9GSUxMX01BU0spID4+IFVBUlRfTUNUTF9UWEZJRk9GSUxMX1NISUZUOwot CW1heF9jb3VudCA9IHBvcnQtPmZpZm9zaXplIC0gdmFsOwotCi0Jd2hpbGUgKG1heF9jb3VudC0t KSB7Ci0JCXVuc2lnbmVkIGludCBjOwogCi0JCWMgPSB4bWl0LT5idWZbeG1pdC0+dGFpbF07Ci0J CWJjbV91YXJ0X3dyaXRlbChwb3J0LCBjLCBVQVJUX0ZJRk9fUkVHKTsKLQkJeG1pdC0+dGFpbCA9 ICh4bWl0LT50YWlsICsgMSkgJiAoVUFSVF9YTUlUX1NJWkUgLSAxKTsKLQkJcG9ydC0+aWNvdW50 LnR4Kys7Ci0JCWlmICh1YXJ0X2NpcmNfZW1wdHkoeG1pdCkpCi0JCQlicmVhazsKLQl9Ci0KLQlp ZiAodWFydF9jaXJjX2NoYXJzX3BlbmRpbmcoeG1pdCkgPCBXQUtFVVBfQ0hBUlMpCi0JCXVhcnRf d3JpdGVfd2FrZXVwKHBvcnQpOwotCi0JaWYgKHVhcnRfY2lyY19lbXB0eSh4bWl0KSkKLQkJZ290 byB0eHFfZW1wdHk7Ci0JcmV0dXJuOworCXBlbmRpbmcgPSB1YXJ0X3BvcnRfdHhfbGltaXRlZChw b3J0LCBjaCwgcG9ydC0+Zmlmb3NpemUgLSB2YWwsCisJCXRydWUsCisJCWJjbV91YXJ0X3dyaXRl bChwb3J0LCBjaCwgVUFSVF9GSUZPX1JFRyksCisJCSh7fSkpOworCWlmIChwZW5kaW5nKQorCQly ZXR1cm47CiAKLXR4cV9lbXB0eToKIAkvKiBub3RoaW5nIHRvIHNlbmQsIGRpc2FibGUgdHJhbnNt aXQgaW50ZXJydXB0ICovCiAJdmFsID0gYmNtX3VhcnRfcmVhZGwocG9ydCwgVUFSVF9JUl9SRUcp OwogCXZhbCAmPSB+VUFSVF9UWF9JTlRfTUFTSzsKIAliY21fdWFydF93cml0ZWwocG9ydCwgdmFs LCBVQVJUX0lSX1JFRyk7Ci0JcmV0dXJuOwogfQogCiAvKgpkaWZmIC0tZ2l0IGEvZHJpdmVycy90 dHkvc2VyaWFsL211eC5jIGIvZHJpdmVycy90dHkvc2VyaWFsL211eC5jCmluZGV4IGVkMGU3NjNm NjIyYS4uODVjZTFlOWFmNDRhIDEwMDY0NAotLS0gYS9kcml2ZXJzL3R0eS9zZXJpYWwvbXV4LmMK KysrIGIvZHJpdmVycy90dHkvc2VyaWFsL211eC5jCkBAIC0xNzEsNiArMTcxLDEzIEBAIHN0YXRp YyB2b2lkIG11eF9icmVha19jdGwoc3RydWN0IHVhcnRfcG9ydCAqcG9ydCwgaW50IGJyZWFrX3N0 YXRlKQogewogfQogCitzdGF0aWMgdm9pZCBtdXhfdHhfZG9uZShzdHJ1Y3QgdWFydF9wb3J0ICpw b3J0KQoreworCS8qIEZJWE1FIGpzOiByZWFsbHkgbmVlZHMgdG8gd2FpdD8gKi8KKwl3aGlsZSAo VUFSVF9HRVRfRklGT19DTlQocG9ydCkpCisJCXVkZWxheSgxKTsKK30KKwogLyoqCiAgKiBtdXhf d3JpdGUgLSBXcml0ZSBjaGFycyB0byB0aGUgbXV4IGZpZm8uCiAgKiBAcG9ydDogUHRyIHRvIHRo ZSB1YXJ0X3BvcnQuCkBAIC0xODAsMzkgKzE4NywxMyBAQCBzdGF0aWMgdm9pZCBtdXhfYnJlYWtf Y3RsKHN0cnVjdCB1YXJ0X3BvcnQgKnBvcnQsIGludCBicmVha19zdGF0ZSkKICAqLwogc3RhdGlj IHZvaWQgbXV4X3dyaXRlKHN0cnVjdCB1YXJ0X3BvcnQgKnBvcnQpCiB7Ci0JaW50IGNvdW50Owot CXN0cnVjdCBjaXJjX2J1ZiAqeG1pdCA9ICZwb3J0LT5zdGF0ZS0+eG1pdDsKLQotCWlmKHBvcnQt PnhfY2hhcikgewotCQlVQVJUX1BVVF9DSEFSKHBvcnQsIHBvcnQtPnhfY2hhcik7Ci0JCXBvcnQt Pmljb3VudC50eCsrOwotCQlwb3J0LT54X2NoYXIgPSAwOwotCQlyZXR1cm47Ci0JfQotCi0JaWYo dWFydF9jaXJjX2VtcHR5KHhtaXQpIHx8IHVhcnRfdHhfc3RvcHBlZChwb3J0KSkgewotCQltdXhf c3RvcF90eChwb3J0KTsKLQkJcmV0dXJuOwotCX0KLQotCWNvdW50ID0gKHBvcnQtPmZpZm9zaXpl KSAtIFVBUlRfR0VUX0ZJRk9fQ05UKHBvcnQpOwotCWRvIHsKLQkJVUFSVF9QVVRfQ0hBUihwb3J0 LCB4bWl0LT5idWZbeG1pdC0+dGFpbF0pOwotCQl4bWl0LT50YWlsID0gKHhtaXQtPnRhaWwgKyAx KSAmIChVQVJUX1hNSVRfU0laRSAtIDEpOwotCQlwb3J0LT5pY291bnQudHgrKzsKLQkJaWYodWFy dF9jaXJjX2VtcHR5KHhtaXQpKQotCQkJYnJlYWs7Ci0KLQl9IHdoaWxlKC0tY291bnQgPiAwKTsK LQotCXdoaWxlKFVBUlRfR0VUX0ZJRk9fQ05UKHBvcnQpKSAKLQkJdWRlbGF5KDEpOwotCi0JaWYo dWFydF9jaXJjX2NoYXJzX3BlbmRpbmcoeG1pdCkgPCBXQUtFVVBfQ0hBUlMpCi0JCXVhcnRfd3Jp dGVfd2FrZXVwKHBvcnQpOworCXU4IGNoOwogCi0JaWYgKHVhcnRfY2lyY19lbXB0eSh4bWl0KSkK LQkJbXV4X3N0b3BfdHgocG9ydCk7CisJdWFydF9wb3J0X3R4X2xpbWl0ZWQocG9ydCwgY2gsCisJ CXBvcnQtPmZpZm9zaXplIC0gVUFSVF9HRVRfRklGT19DTlQocG9ydCksCisJCXRydWUsCisJCVVB UlRfUFVUX0NIQVIocG9ydCwgY2gpLAorCQltdXhfdHhfZG9uZShwb3J0KSk7CiB9CiAKIC8qKgpk aWZmIC0tZ2l0IGEvZHJpdmVycy90dHkvc2VyaWFsL212ZWJ1LXVhcnQuYyBiL2RyaXZlcnMvdHR5 L3NlcmlhbC9tdmVidS11YXJ0LmMKaW5kZXggYmExNmUxZGE2YmQzLi43YjU2NjQwNGNiMzMgMTAw NjQ0Ci0tLSBhL2RyaXZlcnMvdHR5L3NlcmlhbC9tdmVidS11YXJ0LmMKKysrIGIvZHJpdmVycy90 dHkvc2VyaWFsL212ZWJ1LXVhcnQuYwpAQCAtMzM1LDQwICszMzUsMTIgQEAgc3RhdGljIHZvaWQg bXZlYnVfdWFydF9yeF9jaGFycyhzdHJ1Y3QgdWFydF9wb3J0ICpwb3J0LCB1bnNpZ25lZCBpbnQg c3RhdHVzKQogCiBzdGF0aWMgdm9pZCBtdmVidV91YXJ0X3R4X2NoYXJzKHN0cnVjdCB1YXJ0X3Bv cnQgKnBvcnQsIHVuc2lnbmVkIGludCBzdGF0dXMpCiB7Ci0Jc3RydWN0IGNpcmNfYnVmICp4bWl0 ID0gJnBvcnQtPnN0YXRlLT54bWl0OwotCXVuc2lnbmVkIGludCBjb3VudDsKLQl1bnNpZ25lZCBp bnQgc3Q7Ci0KLQlpZiAocG9ydC0+eF9jaGFyKSB7Ci0JCXdyaXRlbChwb3J0LT54X2NoYXIsIHBv cnQtPm1lbWJhc2UgKyBVQVJUX1RTSChwb3J0KSk7Ci0JCXBvcnQtPmljb3VudC50eCsrOwotCQlw b3J0LT54X2NoYXIgPSAwOwotCQlyZXR1cm47Ci0JfQotCi0JaWYgKHVhcnRfY2lyY19lbXB0eSh4 bWl0KSB8fCB1YXJ0X3R4X3N0b3BwZWQocG9ydCkpIHsKLQkJbXZlYnVfdWFydF9zdG9wX3R4KHBv cnQpOwotCQlyZXR1cm47Ci0JfQotCi0JZm9yIChjb3VudCA9IDA7IGNvdW50IDwgcG9ydC0+Zmlm b3NpemU7IGNvdW50KyspIHsKLQkJd3JpdGVsKHhtaXQtPmJ1Zlt4bWl0LT50YWlsXSwgcG9ydC0+ bWVtYmFzZSArIFVBUlRfVFNIKHBvcnQpKTsKLQkJeG1pdC0+dGFpbCA9ICh4bWl0LT50YWlsICsg MSkgJiAoVUFSVF9YTUlUX1NJWkUgLSAxKTsKLQkJcG9ydC0+aWNvdW50LnR4Kys7Ci0KLQkJaWYg KHVhcnRfY2lyY19lbXB0eSh4bWl0KSkKLQkJCWJyZWFrOwotCi0JCXN0ID0gcmVhZGwocG9ydC0+ bWVtYmFzZSArIFVBUlRfU1RBVCk7Ci0JCWlmIChzdCAmIFNUQVRfVFhfRklGT19GVUwpCi0JCQli cmVhazsKLQl9Ci0KLQlpZiAodWFydF9jaXJjX2NoYXJzX3BlbmRpbmcoeG1pdCkgPCBXQUtFVVBf Q0hBUlMpCi0JCXVhcnRfd3JpdGVfd2FrZXVwKHBvcnQpOworCXU4IGNoOwogCi0JaWYgKHVhcnRf Y2lyY19lbXB0eSh4bWl0KSkKLQkJbXZlYnVfdWFydF9zdG9wX3R4KHBvcnQpOworCXVhcnRfcG9y dF90eF9saW1pdGVkKHBvcnQsIGNoLCBwb3J0LT5maWZvc2l6ZSwKKwkJIShyZWFkbChwb3J0LT5t ZW1iYXNlICsgVUFSVF9TVEFUKSAmIFNUQVRfVFhfRklGT19GVUwpLAorCQl3cml0ZWwoY2gsIHBv cnQtPm1lbWJhc2UgKyBVQVJUX1RTSChwb3J0KSksCisJCSh7fSkpOwogfQogCiBzdGF0aWMgaXJx cmV0dXJuX3QgbXZlYnVfdWFydF9pc3IoaW50IGlycSwgdm9pZCAqZGV2X2lkKQpkaWZmIC0tZ2l0 IGEvZHJpdmVycy90dHkvc2VyaWFsL29tYXAtc2VyaWFsLmMgYi9kcml2ZXJzL3R0eS9zZXJpYWwv b21hcC1zZXJpYWwuYwppbmRleCBiN2I3NmU0OTExNWUuLmNjZWE3NDZlMTIxNCAxMDA2NDQKLS0t IGEvZHJpdmVycy90dHkvc2VyaWFsL29tYXAtc2VyaWFsLmMKKysrIGIvZHJpdmVycy90dHkvc2Vy aWFsL29tYXAtc2VyaWFsLmMKQEAgLTM0OCwzNCArMzQ4LDEyIEBAIHN0YXRpYyB2b2lkIHNlcmlh bF9vbWFwX3B1dF9jaGFyKHN0cnVjdCB1YXJ0X29tYXBfcG9ydCAqdXAsIHVuc2lnbmVkIGNoYXIg Y2gpCiAKIHN0YXRpYyB2b2lkIHRyYW5zbWl0X2NoYXJzKHN0cnVjdCB1YXJ0X29tYXBfcG9ydCAq dXAsIHVuc2lnbmVkIGludCBsc3IpCiB7Ci0Jc3RydWN0IGNpcmNfYnVmICp4bWl0ID0gJnVwLT5w b3J0LnN0YXRlLT54bWl0OwotCWludCBjb3VudDsKKwl1OCBjaDsKIAotCWlmICh1cC0+cG9ydC54 X2NoYXIpIHsKLQkJc2VyaWFsX29tYXBfcHV0X2NoYXIodXAsIHVwLT5wb3J0LnhfY2hhcik7Ci0J CXVwLT5wb3J0Lmljb3VudC50eCsrOwotCQl1cC0+cG9ydC54X2NoYXIgPSAwOwotCQlyZXR1cm47 Ci0JfQotCWlmICh1YXJ0X2NpcmNfZW1wdHkoeG1pdCkgfHwgdWFydF90eF9zdG9wcGVkKCZ1cC0+ cG9ydCkpIHsKLQkJc2VyaWFsX29tYXBfc3RvcF90eCgmdXAtPnBvcnQpOwotCQlyZXR1cm47Ci0J fQotCWNvdW50ID0gdXAtPnBvcnQuZmlmb3NpemUgLyA0OwotCWRvIHsKLQkJc2VyaWFsX29tYXBf cHV0X2NoYXIodXAsIHhtaXQtPmJ1Zlt4bWl0LT50YWlsXSk7Ci0JCXhtaXQtPnRhaWwgPSAoeG1p dC0+dGFpbCArIDEpICYgKFVBUlRfWE1JVF9TSVpFIC0gMSk7Ci0JCXVwLT5wb3J0Lmljb3VudC50 eCsrOwotCi0JCWlmICh1YXJ0X2NpcmNfZW1wdHkoeG1pdCkpCi0JCQlicmVhazsKLQl9IHdoaWxl ICgtLWNvdW50ID4gMCk7Ci0KLQlpZiAodWFydF9jaXJjX2NoYXJzX3BlbmRpbmcoeG1pdCkgPCBX QUtFVVBfQ0hBUlMpCi0JCXVhcnRfd3JpdGVfd2FrZXVwKCZ1cC0+cG9ydCk7Ci0KLQlpZiAodWFy dF9jaXJjX2VtcHR5KHhtaXQpKQotCQlzZXJpYWxfb21hcF9zdG9wX3R4KCZ1cC0+cG9ydCk7CisJ dWFydF9wb3J0X3R4X2xpbWl0ZWQoJnVwLT5wb3J0LCBjaCwgdXAtPnBvcnQuZmlmb3NpemUgLyA0 LAorCQl0cnVlLAorCQlzZXJpYWxfb21hcF9wdXRfY2hhcih1cCwgY2gpLAorCQkoe30pKTsKIH0K IAogc3RhdGljIGlubGluZSB2b2lkIHNlcmlhbF9vbWFwX2VuYWJsZV9pZXJfdGhyaShzdHJ1Y3Qg dWFydF9vbWFwX3BvcnQgKnVwKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy90dHkvc2VyaWFsL3B4YS5j IGIvZHJpdmVycy90dHkvc2VyaWFsL3B4YS5jCmluZGV4IDJkMjUyMzFmYWQ4NC4uNDQ0ZmE0YjY1 NGFjIDEwMDY0NAotLS0gYS9kcml2ZXJzL3R0eS9zZXJpYWwvcHhhLmMKKysrIGIvZHJpdmVycy90 dHkvc2VyaWFsL3B4YS5jCkBAIC0xNzQsMzUgKzE3NCwxMiBAQCBzdGF0aWMgaW5saW5lIHZvaWQg cmVjZWl2ZV9jaGFycyhzdHJ1Y3QgdWFydF9weGFfcG9ydCAqdXAsIGludCAqc3RhdHVzKQogCiBz dGF0aWMgdm9pZCB0cmFuc21pdF9jaGFycyhzdHJ1Y3QgdWFydF9weGFfcG9ydCAqdXApCiB7Ci0J c3RydWN0IGNpcmNfYnVmICp4bWl0ID0gJnVwLT5wb3J0LnN0YXRlLT54bWl0OwotCWludCBjb3Vu dDsKKwl1OCBjaDsKIAotCWlmICh1cC0+cG9ydC54X2NoYXIpIHsKLQkJc2VyaWFsX291dCh1cCwg VUFSVF9UWCwgdXAtPnBvcnQueF9jaGFyKTsKLQkJdXAtPnBvcnQuaWNvdW50LnR4Kys7Ci0JCXVw LT5wb3J0LnhfY2hhciA9IDA7Ci0JCXJldHVybjsKLQl9Ci0JaWYgKHVhcnRfY2lyY19lbXB0eSh4 bWl0KSB8fCB1YXJ0X3R4X3N0b3BwZWQoJnVwLT5wb3J0KSkgewotCQlzZXJpYWxfcHhhX3N0b3Bf dHgoJnVwLT5wb3J0KTsKLQkJcmV0dXJuOwotCX0KLQotCWNvdW50ID0gdXAtPnBvcnQuZmlmb3Np emUgLyAyOwotCWRvIHsKLQkJc2VyaWFsX291dCh1cCwgVUFSVF9UWCwgeG1pdC0+YnVmW3htaXQt PnRhaWxdKTsKLQkJeG1pdC0+dGFpbCA9ICh4bWl0LT50YWlsICsgMSkgJiAoVUFSVF9YTUlUX1NJ WkUgLSAxKTsKLQkJdXAtPnBvcnQuaWNvdW50LnR4Kys7Ci0JCWlmICh1YXJ0X2NpcmNfZW1wdHko eG1pdCkpCi0JCQlicmVhazsKLQl9IHdoaWxlICgtLWNvdW50ID4gMCk7Ci0KLQlpZiAodWFydF9j aXJjX2NoYXJzX3BlbmRpbmcoeG1pdCkgPCBXQUtFVVBfQ0hBUlMpCi0JCXVhcnRfd3JpdGVfd2Fr ZXVwKCZ1cC0+cG9ydCk7Ci0KLQotCWlmICh1YXJ0X2NpcmNfZW1wdHkoeG1pdCkpCi0JCXNlcmlh bF9weGFfc3RvcF90eCgmdXAtPnBvcnQpOworCXVhcnRfcG9ydF90eF9saW1pdGVkKCZ1cC0+cG9y dCwgY2gsIHVwLT5wb3J0LmZpZm9zaXplIC8gMiwKKwkJdHJ1ZSwKKwkJc2VyaWFsX291dCh1cCwg VUFSVF9UWCwgY2gpLAorCQkoe30pKTsKIH0KIAogc3RhdGljIHZvaWQgc2VyaWFsX3B4YV9zdGFy dF90eChzdHJ1Y3QgdWFydF9wb3J0ICpwb3J0KQpkaWZmIC0tZ2l0IGEvZHJpdmVycy90dHkvc2Vy aWFsL3JwMi5jIGIvZHJpdmVycy90dHkvc2VyaWFsL3JwMi5jCmluZGV4IGI4MWFmYjA2ZjFmNC4u NzQ5Yjg3M2E1ZDk5IDEwMDY0NAotLS0gYS9kcml2ZXJzL3R0eS9zZXJpYWwvcnAyLmMKKysrIGIv ZHJpdmVycy90dHkvc2VyaWFsL3JwMi5jCkBAIC00MjcsMzIgKzQyNywxMyBAQCBzdGF0aWMgdm9p ZCBycDJfcnhfY2hhcnMoc3RydWN0IHJwMl91YXJ0X3BvcnQgKnVwKQogCiBzdGF0aWMgdm9pZCBy cDJfdHhfY2hhcnMoc3RydWN0IHJwMl91YXJ0X3BvcnQgKnVwKQogewotCXUxNiBtYXhfdHggPSBG SUZPX1NJWkUgLSByZWFkdyh1cC0+YmFzZSArIFJQMl9UWF9GSUZPX0NPVU5UKTsKLQlzdHJ1Y3Qg Y2lyY19idWYgKnhtaXQgPSAmdXAtPnBvcnQuc3RhdGUtPnhtaXQ7CisJdTggY2g7CiAKLQlpZiAo dWFydF90eF9zdG9wcGVkKCZ1cC0+cG9ydCkpIHsKLQkJcnAyX3VhcnRfc3RvcF90eCgmdXAtPnBv cnQpOwotCQlyZXR1cm47Ci0JfQotCi0JZm9yICg7IG1heF90eCAhPSAwOyBtYXhfdHgtLSkgewot CQlpZiAodXAtPnBvcnQueF9jaGFyKSB7Ci0JCQl3cml0ZWIodXAtPnBvcnQueF9jaGFyLCB1cC0+ YmFzZSArIFJQMl9EQVRBX0JZVEUpOwotCQkJdXAtPnBvcnQueF9jaGFyID0gMDsKLQkJCXVwLT5w b3J0Lmljb3VudC50eCsrOwotCQkJY29udGludWU7Ci0JCX0KLQkJaWYgKHVhcnRfY2lyY19lbXB0 eSh4bWl0KSkgewotCQkJcnAyX3VhcnRfc3RvcF90eCgmdXAtPnBvcnQpOwotCQkJYnJlYWs7Ci0J CX0KLQkJd3JpdGViKHhtaXQtPmJ1Zlt4bWl0LT50YWlsXSwgdXAtPmJhc2UgKyBSUDJfREFUQV9C WVRFKTsKLQkJeG1pdC0+dGFpbCA9ICh4bWl0LT50YWlsICsgMSkgJiAoVUFSVF9YTUlUX1NJWkUg LSAxKTsKLQkJdXAtPnBvcnQuaWNvdW50LnR4Kys7Ci0JfQotCi0JaWYgKHVhcnRfY2lyY19jaGFy c19wZW5kaW5nKHhtaXQpIDwgV0FLRVVQX0NIQVJTKQotCQl1YXJ0X3dyaXRlX3dha2V1cCgmdXAt PnBvcnQpOworCXVhcnRfcG9ydF90eF9saW1pdGVkKCZ1cC0+cG9ydCwgY2gsCisJCUZJRk9fU0la RSAtIHJlYWR3KHVwLT5iYXNlICsgUlAyX1RYX0ZJRk9fQ09VTlQpLAorCQl0cnVlLAorCQl3cml0 ZWIoY2gsIHVwLT5iYXNlICsgUlAyX0RBVEFfQllURSksCisJCSh7fSkpOwogfQogCiBzdGF0aWMg dm9pZCBycDJfY2hfaW50ZXJydXB0KHN0cnVjdCBycDJfdWFydF9wb3J0ICp1cCkKZGlmZiAtLWdp dCBhL2RyaXZlcnMvdHR5L3NlcmlhbC9zZXJpYWxfdHh4OS5jIGIvZHJpdmVycy90dHkvc2VyaWFs L3NlcmlhbF90eHg5LmMKaW5kZXggZTEyZjFkYzE4YzM4Li5lYWIzODdiMDFlMzYgMTAwNjQ0Ci0t LSBhL2RyaXZlcnMvdHR5L3NlcmlhbC9zZXJpYWxfdHh4OS5jCisrKyBiL2RyaXZlcnMvdHR5L3Nl cmlhbC9zZXJpYWxfdHh4OS5jCkBAIC0zMjEsMzQgKzMyMSwxMiBAQCByZWNlaXZlX2NoYXJzKHN0 cnVjdCB1YXJ0X3BvcnQgKnVwLCB1bnNpZ25lZCBpbnQgKnN0YXR1cykKIAogc3RhdGljIGlubGlu ZSB2b2lkIHRyYW5zbWl0X2NoYXJzKHN0cnVjdCB1YXJ0X3BvcnQgKnVwKQogewotCXN0cnVjdCBj aXJjX2J1ZiAqeG1pdCA9ICZ1cC0+c3RhdGUtPnhtaXQ7Ci0JaW50IGNvdW50OworCXU4IGNoOwog Ci0JaWYgKHVwLT54X2NoYXIpIHsKLQkJc2lvX291dCh1cCwgVFhYOV9TSVRGSUZPLCB1cC0+eF9j aGFyKTsKLQkJdXAtPmljb3VudC50eCsrOwotCQl1cC0+eF9jaGFyID0gMDsKLQkJcmV0dXJuOwot CX0KLQlpZiAodWFydF9jaXJjX2VtcHR5KHhtaXQpIHx8IHVhcnRfdHhfc3RvcHBlZCh1cCkpIHsK LQkJc2VyaWFsX3R4eDlfc3RvcF90eCh1cCk7Ci0JCXJldHVybjsKLQl9Ci0KLQljb3VudCA9IFRY WDlfU0lPX1RYX0ZJRk87Ci0JZG8gewotCQlzaW9fb3V0KHVwLCBUWFg5X1NJVEZJRk8sIHhtaXQt PmJ1Zlt4bWl0LT50YWlsXSk7Ci0JCXhtaXQtPnRhaWwgPSAoeG1pdC0+dGFpbCArIDEpICYgKFVB UlRfWE1JVF9TSVpFIC0gMSk7Ci0JCXVwLT5pY291bnQudHgrKzsKLQkJaWYgKHVhcnRfY2lyY19l bXB0eSh4bWl0KSkKLQkJCWJyZWFrOwotCX0gd2hpbGUgKC0tY291bnQgPiAwKTsKLQotCWlmICh1 YXJ0X2NpcmNfY2hhcnNfcGVuZGluZyh4bWl0KSA8IFdBS0VVUF9DSEFSUykKLQkJdWFydF93cml0 ZV93YWtldXAodXApOwotCi0JaWYgKHVhcnRfY2lyY19lbXB0eSh4bWl0KSkKLQkJc2VyaWFsX3R4 eDlfc3RvcF90eCh1cCk7CisJdWFydF9wb3J0X3R4X2xpbWl0ZWQodXAsIGNoLCBUWFg5X1NJT19U WF9GSUZPLAorCQl0cnVlLAorCQlzaW9fb3V0KHVwLCBUWFg5X1NJVEZJRk8sIGNoKSwKKwkJKHt9 KSk7CiB9CiAKIHN0YXRpYyBpcnFyZXR1cm5fdCBzZXJpYWxfdHh4OV9pbnRlcnJ1cHQoaW50IGly cSwgdm9pZCAqZGV2X2lkKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy90dHkvc2VyaWFsL3NpZml2ZS5j IGIvZHJpdmVycy90dHkvc2VyaWFsL3NpZml2ZS5jCmluZGV4IDQ3NjFmMTcyMTAzYS4uNjRjZmQ0 NTVmNTU2IDEwMDY0NAotLS0gYS9kcml2ZXJzL3R0eS9zZXJpYWwvc2lmaXZlLmMKKysrIGIvZHJp dmVycy90dHkvc2VyaWFsL3NpZml2ZS5jCkBAIC0yODgsMzMgKzI4OCwxMiBAQCBzdGF0aWMgdm9p ZCBfX3NzcF90cmFuc21pdF9jaGFyKHN0cnVjdCBzaWZpdmVfc2VyaWFsX3BvcnQgKnNzcCwgaW50 IGNoKQogICovCiBzdGF0aWMgdm9pZCBfX3NzcF90cmFuc21pdF9jaGFycyhzdHJ1Y3Qgc2lmaXZl X3NlcmlhbF9wb3J0ICpzc3ApCiB7Ci0Jc3RydWN0IGNpcmNfYnVmICp4bWl0ID0gJnNzcC0+cG9y dC5zdGF0ZS0+eG1pdDsKLQlpbnQgY291bnQ7Ci0KLQlpZiAoc3NwLT5wb3J0LnhfY2hhcikgewot CQlfX3NzcF90cmFuc21pdF9jaGFyKHNzcCwgc3NwLT5wb3J0LnhfY2hhcik7Ci0JCXNzcC0+cG9y dC5pY291bnQudHgrKzsKLQkJc3NwLT5wb3J0LnhfY2hhciA9IDA7Ci0JCXJldHVybjsKLQl9Ci0J aWYgKHVhcnRfY2lyY19lbXB0eSh4bWl0KSB8fCB1YXJ0X3R4X3N0b3BwZWQoJnNzcC0+cG9ydCkp IHsKLQkJc2lmaXZlX3NlcmlhbF9zdG9wX3R4KCZzc3AtPnBvcnQpOwotCQlyZXR1cm47Ci0JfQot CWNvdW50ID0gU0lGSVZFX1RYX0ZJRk9fREVQVEg7Ci0JZG8gewotCQlfX3NzcF90cmFuc21pdF9j aGFyKHNzcCwgeG1pdC0+YnVmW3htaXQtPnRhaWxdKTsKLQkJeG1pdC0+dGFpbCA9ICh4bWl0LT50 YWlsICsgMSkgJiAoVUFSVF9YTUlUX1NJWkUgLSAxKTsKLQkJc3NwLT5wb3J0Lmljb3VudC50eCsr OwotCQlpZiAodWFydF9jaXJjX2VtcHR5KHhtaXQpKQotCQkJYnJlYWs7Ci0JfSB3aGlsZSAoLS1j b3VudCA+IDApOwotCi0JaWYgKHVhcnRfY2lyY19jaGFyc19wZW5kaW5nKHhtaXQpIDwgV0FLRVVQ X0NIQVJTKQotCQl1YXJ0X3dyaXRlX3dha2V1cCgmc3NwLT5wb3J0KTsKKwl1OCBjaDsKIAotCWlm ICh1YXJ0X2NpcmNfZW1wdHkoeG1pdCkpCi0JCXNpZml2ZV9zZXJpYWxfc3RvcF90eCgmc3NwLT5w b3J0KTsKKwl1YXJ0X3BvcnRfdHhfbGltaXRlZCgmc3NwLT5wb3J0LCBjaCwgU0lGSVZFX1RYX0ZJ Rk9fREVQVEgsCisJCXRydWUsCisJCV9fc3NwX3RyYW5zbWl0X2NoYXIoc3NwLCBjaCksCisJCSh7 fSkpOwogfQogCiAvKioKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdHR5L3NlcmlhbC9zcHJkX3Nlcmlh bC5jIGIvZHJpdmVycy90dHkvc2VyaWFsL3NwcmRfc2VyaWFsLmMKaW5kZXggMzQyYTg3OTY3NjMx Li4zZjM0ZjdiYjc3MDAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdHR5L3NlcmlhbC9zcHJkX3Nlcmlh bC5jCisrKyBiL2RyaXZlcnMvdHR5L3NlcmlhbC9zcHJkX3NlcmlhbC5jCkBAIC02MjYsMzUgKzYy NiwxMiBAQCBzdGF0aWMgaW5saW5lIHZvaWQgc3ByZF9yeChzdHJ1Y3QgdWFydF9wb3J0ICpwb3J0 KQogCiBzdGF0aWMgaW5saW5lIHZvaWQgc3ByZF90eChzdHJ1Y3QgdWFydF9wb3J0ICpwb3J0KQog ewotCXN0cnVjdCBjaXJjX2J1ZiAqeG1pdCA9ICZwb3J0LT5zdGF0ZS0+eG1pdDsKLQlpbnQgY291 bnQ7Ci0KLQlpZiAocG9ydC0+eF9jaGFyKSB7Ci0JCXNlcmlhbF9vdXQocG9ydCwgU1BSRF9UWEQs IHBvcnQtPnhfY2hhcik7Ci0JCXBvcnQtPmljb3VudC50eCsrOwotCQlwb3J0LT54X2NoYXIgPSAw OwotCQlyZXR1cm47Ci0JfQotCi0JaWYgKHVhcnRfY2lyY19lbXB0eSh4bWl0KSB8fCB1YXJ0X3R4 X3N0b3BwZWQocG9ydCkpIHsKLQkJc3ByZF9zdG9wX3R4KHBvcnQpOwotCQlyZXR1cm47Ci0JfQot Ci0JY291bnQgPSBUSExEX1RYX0VNUFRZOwotCWRvIHsKLQkJc2VyaWFsX291dChwb3J0LCBTUFJE X1RYRCwgeG1pdC0+YnVmW3htaXQtPnRhaWxdKTsKLQkJeG1pdC0+dGFpbCA9ICh4bWl0LT50YWls ICsgMSkgJiAoVUFSVF9YTUlUX1NJWkUgLSAxKTsKLQkJcG9ydC0+aWNvdW50LnR4Kys7Ci0JCWlm ICh1YXJ0X2NpcmNfZW1wdHkoeG1pdCkpCi0JCQlicmVhazsKLQl9IHdoaWxlICgtLWNvdW50ID4g MCk7Ci0KLQlpZiAodWFydF9jaXJjX2NoYXJzX3BlbmRpbmcoeG1pdCkgPCBXQUtFVVBfQ0hBUlMp Ci0JCXVhcnRfd3JpdGVfd2FrZXVwKHBvcnQpOworCXU4IGNoOwogCi0JaWYgKHVhcnRfY2lyY19l bXB0eSh4bWl0KSkKLQkJc3ByZF9zdG9wX3R4KHBvcnQpOworCXVhcnRfcG9ydF90eF9saW1pdGVk KHBvcnQsIGNoLCBUSExEX1RYX0VNUFRZLAorCQl0cnVlLAorCQlzZXJpYWxfb3V0KHBvcnQsIFNQ UkRfVFhELCBjaCksCisJCSh7fSkpOwogfQogCiAvKiB0aGlzIGhhbmRsZXMgdGhlIGludGVycnVw dCBmcm9tIG9uZSBwb3J0ICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3R0eS9zZXJpYWwvc3QtYXNj LmMgYi9kcml2ZXJzL3R0eS9zZXJpYWwvc3QtYXNjLmMKaW5kZXggZmNlY2VhNjg5YTBkLi41MjE1 ZTY5MTBmNjggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdHR5L3NlcmlhbC9zdC1hc2MuYworKysgYi9k cml2ZXJzL3R0eS9zZXJpYWwvc3QtYXNjLmMKQEAgLTIzNyw1MCArMjM3LDEyIEBAIHN0YXRpYyBp bmxpbmUgdW5zaWduZWQgYXNjX2h3X3R4cm9vbShzdHJ1Y3QgdWFydF9wb3J0ICpwb3J0KQogICov CiBzdGF0aWMgdm9pZCBhc2NfdHJhbnNtaXRfY2hhcnMoc3RydWN0IHVhcnRfcG9ydCAqcG9ydCkK IHsKLQlzdHJ1Y3QgY2lyY19idWYgKnhtaXQgPSAmcG9ydC0+c3RhdGUtPnhtaXQ7Ci0JaW50IHR4 cm9vbTsKLQl1bnNpZ25lZCBjaGFyIGM7Ci0KLQl0eHJvb20gPSBhc2NfaHdfdHhyb29tKHBvcnQp OwotCi0JaWYgKCh0eHJvb20gIT0gMCkgJiYgcG9ydC0+eF9jaGFyKSB7Ci0JCWMgPSBwb3J0LT54 X2NoYXI7Ci0JCXBvcnQtPnhfY2hhciA9IDA7Ci0JCWFzY19vdXQocG9ydCwgQVNDX1RYQlVGLCBj KTsKLQkJcG9ydC0+aWNvdW50LnR4Kys7Ci0JCXR4cm9vbSA9IGFzY19od190eHJvb20ocG9ydCk7 Ci0JfQotCi0JaWYgKHVhcnRfdHhfc3RvcHBlZChwb3J0KSkgewotCQkvKgotCQkgKiBXZSBzaG91 bGQgdHJ5IGFuZCBzdG9wIHRoZSBoYXJkd2FyZSBoZXJlLCBidXQgSQotCQkgKiBkb24ndCB0aGlu ayB0aGUgQVNDIGhhcyBhbnkgd2F5IHRvIGRvIHRoYXQuCi0JCSAqLwotCQlhc2NfZGlzYWJsZV90 eF9pbnRlcnJ1cHRzKHBvcnQpOwotCQlyZXR1cm47Ci0JfQotCi0JaWYgKHVhcnRfY2lyY19lbXB0 eSh4bWl0KSkgewotCQlhc2NfZGlzYWJsZV90eF9pbnRlcnJ1cHRzKHBvcnQpOwotCQlyZXR1cm47 Ci0JfQotCi0JaWYgKHR4cm9vbSA9PSAwKQotCQlyZXR1cm47Ci0KLQlkbyB7Ci0JCWMgPSB4bWl0 LT5idWZbeG1pdC0+dGFpbF07Ci0JCXhtaXQtPnRhaWwgPSAoeG1pdC0+dGFpbCArIDEpICYgKFVB UlRfWE1JVF9TSVpFIC0gMSk7Ci0JCWFzY19vdXQocG9ydCwgQVNDX1RYQlVGLCBjKTsKLQkJcG9y dC0+aWNvdW50LnR4Kys7Ci0JCXR4cm9vbS0tOwotCX0gd2hpbGUgKCh0eHJvb20gPiAwKSAmJiAo IXVhcnRfY2lyY19lbXB0eSh4bWl0KSkpOwotCi0JaWYgKHVhcnRfY2lyY19jaGFyc19wZW5kaW5n KHhtaXQpIDwgV0FLRVVQX0NIQVJTKQotCQl1YXJ0X3dyaXRlX3dha2V1cChwb3J0KTsKKwl1OCBj aDsKIAotCWlmICh1YXJ0X2NpcmNfZW1wdHkoeG1pdCkpCi0JCWFzY19kaXNhYmxlX3R4X2ludGVy cnVwdHMocG9ydCk7CisJdWFydF9wb3J0X3R4X2xpbWl0ZWQocG9ydCwgY2gsIGFzY19od190eHJv b20ocG9ydCksCisJCXRydWUsCisJCWFzY19vdXQocG9ydCwgQVNDX1RYQlVGLCBjaCksCisJCSh7 fSkpOwogfQogCiBzdGF0aWMgdm9pZCBhc2NfcmVjZWl2ZV9jaGFycyhzdHJ1Y3QgdWFydF9wb3J0 ICpwb3J0KQotLSAKMi4zNy4zCgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX18KbGludXgtcmlzY3YgbWFpbGluZyBsaXN0CmxpbnV4LXJpc2N2QGxpc3RzLmlu ZnJhZGVhZC5vcmcKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9s aW51eC1yaXNjdgo=