From mboxrd@z Thu Jan 1 00:00:00 1970 Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.remote-ip=209.85.161.41 ARC-Seal: i=1; d=subspace.kernel.org; s=arc20261015; a=rsa-sha256; cv=none; t=1793259472; b=p9xrczvPX+zZAGDfPX4lWiAMvaycmplR94VAkPVT8FkwRJi81eRQl4AKWmVVhU7IPest EUDsT2gpNmR/AWn9Iy35Gb12DuP79xlKGvcMezMnD9Yj9CsSm82QSoqce+ifu/hjLsfus ORx0VSsvuZge6VscIbMm5vSi74OgYfFSx/v/VISox4bfKlAT8HRzV8rCeXXvKHt79fMFz 2QePkLTaCsBrq6aF/xuirWj6MJt9lRzDUM20P73mA/6nmvutCcWtYC/UJCEA5jZvX4TkZ 1L0VGbhdi2EIWEw0uXdi9VuQ09G3qA5TONnEjAAAu2GBVq9PESTgixBEdLMQ/sVyGqA== ARC-Message-Signature: i=1; d=subspace.kernel.org; s=arc20261015; a=rsa-sha256; c=relaxed/relaxed; t=1793259472; h=DMARC-Filter:Received:DKIM-Signature:X-Google-DKIM-Signature: X-Gm-Message-State:X-Gm-Gg:X-Received:Received:From:Date:Subject: MIME-Version:Content-Type:Content-Transfer-Encoding:Message-Id: References:In-Reply-To:To:Cc:X-Mailer; bh=IoEeKGj5Rb+/PqG19pTDm0eU9V7+dHzr/ro/KBS+xAs=; b=seQEV96HgXOXHogBjNyo5A5kbCuOnF4ypDTeVWZW2OTBoV4WOrZnr5FePwPK6U8UL6KK xZn317WLoNmvxKvITd/XOh6joCo6W8InPp5e2v4RTzclxJWPoUr7Oqenxe/enaIBG2gBc sQc2jCEOG/20JMD/0v0c7c9CgSCQ1Y6WwlOSVbCUcGYDMCHQc7XSBjl79kbKZQD0nBQVo jxgbSqctfXgfE4mou/mTXArvuntZPQVQxTJpqdj0bmfHIUe/5kyXG+nbuRsfJ0w4v8RP+ K65wUD2uXqn6Hazph9j0zupcwCtX9aep1Hu74HrebQmPIXxj5LFZ7NT/ie3DfOKiv2A== ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20260707 header.b=hnxRa4Lt; arc=none smtp.remote-ip=209.85.161.41 Received: from mail-oo1-f41.google.com (mail-oo1-f41.google.com [209.85.161.41]) (using TLSv1.3 with cipher TLS_AES_128_GCM_SHA256 (128/128 bits) key-exchange X25519 server-signature ECDSA (prime256v1) server-digest SHA256) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id A144A60A261C for ; Thu, 29 Oct 2026 07:37:51 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.4.2 smtp.subspace.kernel.org A144A60A261C Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key, unprotected) header.d=gmail.com header.i=@gmail.com header.a=rsa-sha256 header.s=20260707 header.b=hnxRa4Lt Received: by mail-oo1-f41.google.com with SMTP id 006d021491bc7-6e560e00a86so1394353eaf.1 for ; Thu, 29 Oct 2026 00:37:51 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20260707; t=1793259470; x=1793864270; darn=vger.kernel.org; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :content-type:mime-version:subject:date:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=IoEeKGj5Rb+/PqG19pTDm0eU9V7+dHzr/ro/KBS+xAs=; b=hnxRa4LtspMsUM28oVd8nhzZIDmJZcl1nv4v918WgYkH7BOszPO9w7ro9s4qzIZ3gl lKmR9vAfg20jMYRpzqyxe2712t0EhKERtf9Zy5YTRLFKtBrF7e8u15B8AXTYJJy5h+JC QkuTG4Mxba4Vmafq1jbcA+srRe/wjaJHEVfkdMaIG0E4r19n3MbH5mVEjtHzsM4d7id3 DzN1WreqYSnHhEr444K74VwiqBPq/CsFqNu8AhMu1+rsk92a3fGg325FimqWkEd869Jv KyUR+QWHGUBiXNWsHeKBY08tI3pH2OgVoWdCMvoHerakBBbTcnAGqIMSQoYKaLzeBfs8 Bw7g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20260707; t=1793259470; x=1793864270; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :content-type:mime-version:subject:date:from:x-gm-gg :x-gm-message-state:from:to:cc:subject:date:message-id:reply-to :content-type; bh=IoEeKGj5Rb+/PqG19pTDm0eU9V7+dHzr/ro/KBS+xAs=; b=NvOsQLqoNyIxyVkOAhIQFcF0OFa1s3FlFGFYqG1HrDfI0H5ximkk1UZKIkm5XqOh+y GJoolhMjK9ntWDVMzbU/YlVZK6Q+IEzj9lyD4jIcAe/qszu8ZJ6NUWY0kvnB5TrKPgk2 Nb0N2Va7TASyIqXhmPArDt3zrzQMM0Ho61yH5U7aJPfWqZRPlFWOO4c5FW1wQGYWRw0f /aknchBYIydtM1kUZN2wW6sphDaBaGmAdvWeGL3htnyuKcKFn7DhS2xyt7iPBN+weJNN JammZRYu3qV8xIaCIGSI/CfsUm9woOQOZ7zYKSQDaFqsOHCfQyociePGzs3B0hrMjhOb EIPQ== X-Gm-Message-State: AFq9FYLLR55uPWoWsDh5VbYvoxQ23KlijJ/T1z6QBhMz5i7SK4pb1qk2 ab+q6Uvroa2H4ZVUI6kqCxafvzMm33PwDhwguhONJvbmVX4S+f/avZ7f X-Gm-Gg: AYBFou2ZoJOjETnaTmiZc+dr2EOqKypuXKd1Zio8wVEAJZp0sk38WRp2SKIDE53MASP N8+FmTchbqhQuWcjE5kOwW1QKp7EWfLHqo8zigqAczDEXXl2ltuI/9ezicuaIfyydPxrrCXf7B7 VbtPr093faj/yhesF29UDVuqbp1ob2qBLQWTbdvJksg37BZoTkox03QvVLPFaooy+K7kxGGNHD6 C+dMhqRLJCbOX/+qsaOxyMPbW2xsVUE+whX5bSgv3DLnc4ndA3MNS5Cy8F0DXR6yoqMqFAAIKNF 5QxQVYgGBgvexXX+e5ozZQ+ko8adthasPXL2tpUNrQqq51zBCAI5/MZHLJ7VugpKQ6QySNE3A8C dLWBiZVbv7RL2e6iFIKtxc8yoDXyJgGuFdu6Z/312R6FFBDqaXKkTx4krwhB2R20CSv8XsGwnvR xm+qB8NLGnpgDZoNagv5KPP49dhzBBgIZ0sGdxE1ILB7dGx9JgjIeabt4R2DClyqfZeA1YPHmlt nvhHlzE8ulbCPcV5hnvgQ27385QmhREa//IA1CmMjC0eYK4h6E8saDgx6derECAcfEfngsy1nwB ZI8RtaOZRpyfgnhpw5EIWPqeiEyWw6n77priOVzY4UyGkQwKrpPzdmEHGCYnAs516o1PLkl3RMJ e0lZ9kFNLrvVFV+aAmYRk6WtdFlsRSIvcGWv7TIb0N3BbPH4RB4E86jXwwHKpenratu2GvxeAUs vN4jSUPEK4Np502wwEU904qL0pUwHwBCsuK3e0UbdDZBgl3pdlr9Uz9RgOM7QNVbHQdfWaDgr3/ Q== X-Received: by 2002:a05:6820:1ca3:b0:6f8:6290:a8bd with SMTP id 006d021491bc7-713f1a60eccmr2905743eaf.53.1793259470532; Thu, 29 Oct 2026 00:37:50 -0700 (PDT) Received: from [127.0.1.1] (174-29-1-49.hlrn.qwest.net. [174.29.1.49]) by smtp.gmail.com with ESMTPSA id 5614622812f47-563c3638604sm3321976b6e.1.2026.10.29.00.37.49 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 29 Oct 2026 00:37:50 -0700 (PDT) From: James Hilliard Date: Thu, 29 Oct 2026 01:37:00 -0600 Subject: [PATCH v8 4/6] serial: 8250: drain canceled TX DMA before reusing its buffer X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Post: List-Help: List-Subscribe: List-Unsubscribe: List-Owner: Precedence: list MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: 7bit Message-Id: <20261029-submit-serial-8250-dma-cancel-v1-v8-4-3fd56ba352ed@gmail.com> References: <20261029-submit-serial-8250-dma-cancel-v1-v8-0-3fd56ba352ed@gmail.com> In-Reply-To: <20261029-submit-serial-8250-dma-cancel-v1-v8-0-3fd56ba352ed@gmail.com> To: Greg Kroah-Hartman , Jiri Slaby , Raul E Rangel , =?utf-8?q?Ilpo_J=C3=A4rvinen?= , Andy Shevchenko , Heikki Krogerus , Tony Lindgren , Sebastian Andrzej Siewior , Richard Genoud , Nicolas Ferre , Alexandre Belloni , Claudiu Beznea , Jacky Huang , Shan-Chun Hung , =?utf-8?q?Pali_Roh=C3=A1r?= , Frank Li , Sascha Hauer , Pengutronix Kernel Team , Fabio Estevam , "Maciej W. Rozycki" , Timur Tabi Cc: linux-kernel@vger.kernel.org, linux-serial@vger.kernel.org, linux-arm-kernel@lists.infradead.org, imx@lists.linux.dev, linuxppc-dev@lists.ozlabs.org, James Hilliard X-Mailer: b4 0.15.2 uart_flush_buffer() resets the transmit kfifo before calling the driver. serial8250_tx_dma_flush() terminates DMA asynchronously and clears tx_running, allowing a new write to replace tx_size while a detached callback has not yet run. That callback can then consume bytes from the new transmission. Reusing the reset kfifo can also overwrite the source of a transfer that has not stopped yet. Reserve the flushed FIFO storage through serial core before returning from the flush callback. Keep tx_running set until a worker synchronizes the terminated channel, suppressing old callbacks and new submissions during that interval. Return the mapping to CPU ownership before releasing the reservation and waking writers. Normal transfers continue to use the FIFO directly. Reuse the locked completion processing after retirement, including OMAP delayed register restoration and transmitter-empty handling. Take a runtime PM reference around worker UART accesses and drain the worker before releasing the channels. Shutdown releases the FIFO reservation after stopping DMA and unmapping its source. Serial core keeps writes and wakeups gated until startup or resume makes the port ready again. Track a flushed FIFO separately from the transfer length. If termination fails, retain the reservation until normal completion and account the completed bytes without advancing the reset FIFO. After successful cancellation, process a zero-length completion once callbacks have drained. The race was found by inspecting cancellation and restart while preparing H616 UART DMA support. Retain the tx_running check in both completion callbacks. Releasing the reservation relies on the DMA provider draining detached callbacks when dmaengine_synchronize() returns; provider callback-lifetime fixes supply that guarantee for controllers which previously lacked it. Fixes: a424a34b8fad ("serial: 8250: Fix TX deadlock when using DMA") Signed-off-by: James Hilliard --- drivers/tty/serial/8250/8250.h | 20 +++++- drivers/tty/serial/8250/8250_dma.c | 130 ++++++++++++++++++++++++++---------- drivers/tty/serial/8250/8250_omap.c | 21 ++++-- 3 files changed, 125 insertions(+), 46 deletions(-) diff --git a/drivers/tty/serial/8250/8250.h b/drivers/tty/serial/8250/8250.h index 974a47f24084..9f01fa36fa3c 100644 --- a/drivers/tty/serial/8250/8250.h +++ b/drivers/tty/serial/8250/8250.h @@ -11,6 +11,7 @@ #include #include #include +#include #include "../serial_mctrl_gpio.h" @@ -19,6 +20,10 @@ struct uart_8250_dma { int (*rx_dma)(struct uart_8250_port *p); void (*prepare_tx_dma)(struct uart_8250_port *p); void (*prepare_rx_dma)(struct uart_8250_port *p); + /* Completion processing with the port lock held. */ + void (*tx_complete)(struct uart_8250_port *p); + struct work_struct tx_flush_work; + struct uart_8250_port *port; /* Filter function */ dma_filter_fn fn; @@ -52,7 +57,9 @@ struct uart_8250_dma { unsigned char tx_err; unsigned char rx_running; /* Protected by the UART port lock. */ - bool shutting_down; + bool shutting_down:1; + bool tx_terminating:1; + bool tx_flushed:1; }; struct old_serial_port { @@ -400,8 +407,15 @@ static inline int is_omap1510_8250(struct uart_8250_port *pt) #endif #ifdef CONFIG_SERIAL_8250_DMA +static inline bool serial8250_tx_dma_blocked(struct uart_8250_dma *dma) +{ + return dma->shutting_down || dma->tx_terminating; +} + extern int serial8250_tx_dma(struct uart_8250_port *); extern void serial8250_tx_dma_flush(struct uart_8250_port *); +void serial8250_tx_dma_sync_buffer(struct uart_8250_port *p, + struct scatterlist *sgl, unsigned int nents); extern int serial8250_rx_dma(struct uart_8250_port *); extern void serial8250_rx_dma_flush(struct uart_8250_port *); extern int serial8250_request_dma(struct uart_8250_port *); @@ -434,7 +448,7 @@ static inline void serial8250_tx_dma_pause(struct uart_8250_port *p) { struct uart_8250_dma *dma = p->dma; - if (!dma->tx_running) + if (!dma->tx_running || serial8250_tx_dma_blocked(dma)) return; dmaengine_pause(dma->txchan); @@ -444,7 +458,7 @@ static inline void serial8250_tx_dma_resume(struct uart_8250_port *p) { struct uart_8250_dma *dma = p->dma; - if (!dma->tx_running) + if (!dma->tx_running || serial8250_tx_dma_blocked(dma)) return; dmaengine_resume(dma->txchan); diff --git a/drivers/tty/serial/8250/8250_dma.c b/drivers/tty/serial/8250/8250_dma.c index 57fc7915adac..344f0dd24b41 100644 --- a/drivers/tty/serial/8250/8250_dma.c +++ b/drivers/tty/serial/8250/8250_dma.c @@ -11,24 +11,23 @@ #include "8250.h" -static void __dma_tx_complete(void *param) +static void serial8250_tx_dma_complete(struct uart_8250_port *p) { - struct uart_8250_port *p = param; struct uart_8250_dma *dma = p->dma; struct tty_port *tport = &p->port.state->port; - unsigned long flags; int ret; - uart_port_lock_irqsave(&p->port, &flags); - if (dma->shutting_down) - goto out; - dma_sync_single_for_cpu(dmaengine_get_dma_device(dma->txchan), dma->tx_addr, UART_XMIT_SIZE, DMA_TO_DEVICE); dma->tx_running = 0; - uart_xmit_advance(&p->port, dma->tx_size); + if (dma->tx_flushed) { + p->port.icount.tx += dma->tx_size; + uart_xmit_unblock(&p->port); + } else { + uart_xmit_advance(&p->port, dma->tx_size); + } if (kfifo_len(&tport->xmit_fifo) < WAKEUP_CHARS) uart_write_wakeup(&p->port); @@ -36,11 +35,57 @@ static void __dma_tx_complete(void *param) ret = serial8250_tx_dma(p); if (ret || !dma->tx_running) serial8250_set_THRI(p); +} -out: - uart_port_unlock_irqrestore(&p->port, flags); +static void __dma_tx_complete(void *param) +{ + struct uart_8250_port *p = param; + struct uart_8250_dma *dma = p->dma; + + guard(uart_port_lock_irqsave)(&p->port); + + if (serial8250_tx_dma_blocked(dma) || !dma->tx_running) + return; + serial8250_tx_dma_complete(p); +} + +static void serial8250_tx_dma_flush_work(struct work_struct *work) +{ + struct uart_8250_dma *dma = container_of(work, struct uart_8250_dma, tx_flush_work); + struct uart_8250_port *p = dma->port; + + /* Neither the channel nor its buffer may be reused before this returns. */ + dmaengine_synchronize(dma->txchan); + + guard(serial8250_rpm)(p); + + guard(uart_port_lock_irqsave)(&p->port); + + dma->tx_terminating = false; + dma->tx_size = 0; + if (dma->shutting_down) + return; + dma->tx_complete(p); } +void serial8250_tx_dma_sync_buffer(struct uart_8250_port *p, + struct scatterlist *sgl, unsigned int nents) +{ + struct uart_8250_dma *dma = p->dma; + struct device *dev = dmaengine_get_dma_device(dma->txchan); + struct scatterlist *sg; + unsigned int i; + + /* DMA reads the FIFO directly; its occupied ranges remain reserved. */ + for_each_sg(sgl, sg, nents, i) { + size_t offset = sg_dma_address(sg) - dma->tx_addr; + + dma_sync_single_range_for_device(dev, dma->tx_addr, offset, + sg_dma_len(sg), DMA_TO_DEVICE); + } +} +EXPORT_SYMBOL_GPL(serial8250_tx_dma_sync_buffer); + static void __dma_rx_complete(struct uart_8250_port *p) { struct uart_8250_dma *dma = p->dma; @@ -101,7 +146,7 @@ int serial8250_tx_dma(struct uart_8250_port *p) int i; int ret; - if (dma->shutting_down) + if (serial8250_tx_dma_blocked(dma)) return 0; if (dma->tx_running) { @@ -131,24 +176,25 @@ int serial8250_tx_dma(struct uart_8250_port *p) dma->tx_size += sg_dma_len(sg); serial8250_do_prepare_tx_dma(p); + serial8250_tx_dma_sync_buffer(p, sgl, ret); desc = dmaengine_prep_slave_sg(dma->txchan, sgl, ret, DMA_MEM_TO_DEV, DMA_PREP_INTERRUPT | DMA_CTRL_ACK); if (!desc) { + dma_sync_single_for_cpu(dmaengine_get_dma_device(dma->txchan), dma->tx_addr, + UART_XMIT_SIZE, DMA_TO_DEVICE); ret = -EBUSY; goto err; } dma->tx_running = 1; + dma->tx_flushed = false; + dma->tx_complete = serial8250_tx_dma_complete; desc->callback = __dma_tx_complete; desc->callback_param = p; dma->tx_cookie = dmaengine_submit(desc); - - dma_sync_single_for_device(dmaengine_get_dma_device(dma->txchan), dma->tx_addr, - UART_XMIT_SIZE, DMA_TO_DEVICE); - dma_async_issue_pending(dma->txchan); serial8250_clear_THRI(p); dma->tx_err = 0; @@ -162,32 +208,31 @@ int serial8250_tx_dma(struct uart_8250_port *p) void serial8250_tx_dma_flush(struct uart_8250_port *p) { struct uart_8250_dma *dma = p->dma; + int ret; - if (!dma->tx_running) + if (!dma->tx_running || serial8250_tx_dma_blocked(dma)) return; /* * kfifo_reset() has been called by the serial core, avoid - * advancing and underflowing in __dma_tx_complete(). + * advancing the reset FIFO when the old transfer completes. */ - dma->tx_size = 0; + dma->tx_flushed = true; + /* The core reset the FIFO indices, but DMA may still read its storage. */ + uart_xmit_block(&p->port); /* * We can't use `dmaengine_terminate_sync` because `uart_flush_buffer` is * holding the uart port spinlock. */ - dmaengine_terminate_async(dma->txchan); - - /* - * The callback might or might not run. If it doesn't run, we need to ensure - * that `tx_running` is cleared so that we can schedule new transactions. - * If it does run, then the zombie callback will clear `tx_running` again - * and perform a no-op since `tx_size` was cleared above. - * - * In either case, we ASSUME the DMA transaction will terminate before we - * issue a new `serial8250_tx_dma`. - */ - dma->tx_running = 0; + dma->tx_terminating = true; + ret = dmaengine_terminate_async(dma->txchan); + if (ret) { + /* Keep the buffer owned by the transfer until its callback runs. */ + dma->tx_terminating = false; + return; + } + schedule_work(&dma->tx_flush_work); } int serial8250_rx_dma(struct uart_8250_port *p) @@ -312,21 +357,28 @@ int serial8250_request_dma(struct uart_8250_port *p) goto err; } - /* TX buffer */ + /* Normal TX uses serial core's FIFO; flush reserves it until retirement. */ dma->tx_addr = dma_map_single(tx_dev, p->port.state->port.xmit_buf, UART_XMIT_SIZE, DMA_TO_DEVICE); if (dma_mapping_error(tx_dev, dma->tx_addr)) { - dma_free_coherent(rx_dev, dma->rx_size, - dma->rx_buf, dma->rx_addr); ret = -ENOMEM; - goto err; + goto free_rx; } + dma_sync_single_for_cpu(tx_dev, dma->tx_addr, UART_XMIT_SIZE, DMA_TO_DEVICE); + + dma->port = p; + INIT_WORK(&dma->tx_flush_work, serial8250_tx_dma_flush_work); - scoped_guard(uart_port_lock_irqsave, &p->port) + scoped_guard(uart_port_lock_irqsave, &p->port) { + dma->tx_terminating = false; + dma->tx_flushed = false; dma->shutting_down = false; + } dev_dbg_ratelimited(p->port.dev, "got both dma channels\n"); return 0; +free_rx: + dma_free_coherent(rx_dev, dma->rx_size, dma->rx_buf, dma->rx_addr); err: dma_release_channel(dma->txchan); release_rx: @@ -342,6 +394,8 @@ void serial8250_release_dma(struct uart_8250_port *p) if (!dma) return; + cancel_work_sync(&dma->tx_flush_work); + /* Release RX resources */ dmaengine_terminate_sync(dma->rxchan); dma->rx_running = 0; @@ -356,7 +410,11 @@ void serial8250_release_dma(struct uart_8250_port *p) UART_XMIT_SIZE, DMA_TO_DEVICE); dma_release_channel(dma->txchan); dma->txchan = NULL; - dma->tx_running = 0; + scoped_guard(uart_port_lock_irqsave, &p->port) { + dma->tx_running = 0; + dma->tx_terminating = false; + uart_xmit_unblock(&p->port); + } dev_dbg_ratelimited(p->port.dev, "dma channels released\n"); } diff --git a/drivers/tty/serial/8250/8250_omap.c b/drivers/tty/serial/8250/8250_omap.c index b6f108d34854..13507409a5b6 100644 --- a/drivers/tty/serial/8250/8250_omap.c +++ b/drivers/tty/serial/8250/8250_omap.c @@ -1092,7 +1092,12 @@ static void omap_8250_tx_dma_complete(struct uart_8250_port *p) dma->tx_running = 0; - uart_xmit_advance(&p->port, dma->tx_size); + if (dma->tx_flushed) { + p->port.icount.tx += dma->tx_size; + uart_xmit_unblock(&p->port); + } else { + uart_xmit_advance(&p->port, dma->tx_size); + } if (priv->delayed_restore) { priv->delayed_restore = 0; @@ -1125,7 +1130,7 @@ static void omap_8250_dma_tx_complete(void *param) guard(uart_port_lock_irqsave)(&p->port); - if (dma->shutting_down) + if (serial8250_tx_dma_blocked(dma) || !dma->tx_running) return; omap_8250_tx_dma_complete(p); } @@ -1140,7 +1145,7 @@ static int omap_8250_tx_dma(struct uart_8250_port *p) int skip_byte = -1; int ret; - if (dma->shutting_down || dma->tx_running) + if (serial8250_tx_dma_blocked(dma) || dma->tx_running) return 0; if (uart_tx_stopped(&p->port) || kfifo_is_empty(&tport->xmit_fifo)) { @@ -1199,24 +1204,26 @@ static int omap_8250_tx_dma(struct uart_8250_port *p) goto err; } + serial8250_tx_dma_sync_buffer(p, &sg, 1); + desc = dmaengine_prep_slave_sg(dma->txchan, &sg, 1, DMA_MEM_TO_DEV, DMA_PREP_INTERRUPT | DMA_CTRL_ACK); if (!desc) { + dma_sync_single_for_cpu(dmaengine_get_dma_device(dma->txchan), dma->tx_addr, + UART_XMIT_SIZE, DMA_TO_DEVICE); ret = -EBUSY; goto err; } dma->tx_size = sg_dma_len(&sg); dma->tx_running = 1; + dma->tx_flushed = false; + dma->tx_complete = omap_8250_tx_dma_complete; desc->callback = omap_8250_dma_tx_complete; desc->callback_param = p; dma->tx_cookie = dmaengine_submit(desc); - - dma_sync_single_for_device(dmaengine_get_dma_device(dma->txchan), dma->tx_addr, - UART_XMIT_SIZE, DMA_TO_DEVICE); - dma_async_issue_pending(dma->txchan); if (dma->tx_err) dma->tx_err = 0; -- 2.53.0