spi: atmel: fix DMA channel and bounce buffer leaks

The original code set use_dma to false when dma_alloc_coherent() for
bounce buffers failed, but DMA channels acquired earlier via
atmel_spi_configure_dma() were never freed.

When devm_request_irq() or clk_prepare_enable() failed later in probe,
the driver also did not release DMA channels or bounce buffers already
allocated.

The out_free_dma error path released DMA channels but did not free the
bounce buffers.

Fix by moving bounce buffer allocation into atmel_spi_configure_dma()
and registering the devres cleanup for DMA channels and bounce buffers.

Fixes: a9889ed62d06 ("spi: atmel: Implements transfers with bounce buffer")
Signed-off-by: Felix Gu <ustc.gu@gmail.com>
Link: https://patch.msgid.link/20260522-atmel-v3-1-23f8c6e6aa43@gmail.com
Signed-off-by: Mark Brown <broonie@kernel.org>

diff --git a/drivers/spi/spi-atmel.c b/drivers/spi/spi-atmel.c
index 25aa294631c83464ba668702d2ef3ea1054f1488..c8012c82c3a788e0c0e2e2011316138aee9e4645 100644 (file)
--- a/drivers/spi/spi-atmel.c
+++ b/drivers/spi/spi-atmel.c
@@ -559,6 +559,38 @@ static int atmel_spi_dma_slave_config(struct atmel_spi *as, u8 bits_per_word)
        return err;
 }
 
+static void atmel_spi_release_dma(void *data)
+{
+       struct spi_controller *host = data;
+       struct atmel_spi *as = spi_controller_get_devdata(host);
+       struct device *dev = &as->pdev->dev;
+
+       if (host->dma_tx) {
+               dma_release_channel(host->dma_tx);
+               host->dma_tx = NULL;
+       }
+
+       if (host->dma_rx) {
+               dma_release_channel(host->dma_rx);
+               host->dma_rx = NULL;
+       }
+
+       if (IS_ENABLED(CONFIG_SOC_SAM_V4_V5)) {
+               if (as->addr_tx_bbuf) {
+                       dma_free_coherent(dev, SPI_MAX_DMA_XFER,
+                                         as->addr_tx_bbuf,
+                                         as->dma_addr_tx_bbuf);
+                       as->addr_tx_bbuf = NULL;
+               }
+               if (as->addr_rx_bbuf) {
+                       dma_free_coherent(dev, SPI_MAX_DMA_XFER,
+                                         as->addr_rx_bbuf,
+                                         as->dma_addr_rx_bbuf);
+                       as->addr_rx_bbuf = NULL;
+               }
+       }
+}
+
 static int atmel_spi_configure_dma(struct spi_controller *host,
                                   struct atmel_spi *as)
 {
@@ -569,7 +601,8 @@ static int atmel_spi_configure_dma(struct spi_controller *host,
        if (IS_ERR(host->dma_tx)) {
                err = PTR_ERR(host->dma_tx);
                dev_dbg(dev, "No TX DMA channel, DMA is disabled\n");
-               goto error_clear;
+               host->dma_tx = NULL;
+               return err;
        }
 
        host->dma_rx = dma_request_chan(dev, "rx");
@@ -580,26 +613,45 @@ static int atmel_spi_configure_dma(struct spi_controller *host,
                 * requested tx channel.
                 */
                dev_dbg(dev, "No RX DMA channel, DMA is disabled\n");
-               goto error;
+               host->dma_rx = NULL;
+               goto err_release_dma;
        }
 
        err = atmel_spi_dma_slave_config(as, 8);
        if (err)
-               goto error;
+               goto err_release_dma;
+
+       if (IS_ENABLED(CONFIG_SOC_SAM_V4_V5)) {
+               as->addr_tx_bbuf = dma_alloc_coherent(dev, SPI_MAX_DMA_XFER,
+                                                     &as->dma_addr_tx_bbuf,
+                                                     GFP_KERNEL | GFP_DMA);
+               if (!as->addr_tx_bbuf) {
+                       err = -ENOMEM;
+                       goto err_release_dma;
+               }
+
+               as->addr_rx_bbuf = dma_alloc_coherent(dev, SPI_MAX_DMA_XFER,
+                                                     &as->dma_addr_rx_bbuf,
+                                                     GFP_KERNEL | GFP_DMA);
+               if (!as->addr_rx_bbuf) {
+                       err = -ENOMEM;
+                       goto err_release_dma;
+               }
+       }
+
+       err = devm_add_action_or_reset(dev, atmel_spi_release_dma, host);
+       if (err)
+               return err;
 
        dev_info(&as->pdev->dev,
-                       "Using %s (tx) and %s (rx) for DMA transfers\n",
-                       dma_chan_name(host->dma_tx),
-                       dma_chan_name(host->dma_rx));
+                "Using %s (tx) and %s (rx) for DMA transfers\n",
+                dma_chan_name(host->dma_tx), dma_chan_name(host->dma_rx));
 
        return 0;
-error:
-       if (!IS_ERR(host->dma_rx))
-               dma_release_channel(host->dma_rx);
-       if (!IS_ERR(host->dma_tx))
-               dma_release_channel(host->dma_tx);
-error_clear:
-       host->dma_tx = host->dma_rx = NULL;
+
+err_release_dma:
+       atmel_spi_release_dma(host);
+
        return err;
 }
 
@@ -611,18 +663,6 @@ static void atmel_spi_stop_dma(struct spi_controller *host)
                dmaengine_terminate_all(host->dma_tx);
 }
 
-static void atmel_spi_release_dma(struct spi_controller *host)
-{
-       if (host->dma_rx) {
-               dma_release_channel(host->dma_rx);
-               host->dma_rx = NULL;
-       }
-       if (host->dma_tx) {
-               dma_release_channel(host->dma_tx);
-               host->dma_tx = NULL;
-       }
-}
-
 /* This function is called by the DMA driver from tasklet context */
 static void dma_callback(void *data)
 {
@@ -1581,30 +1621,6 @@ static int atmel_spi_probe(struct platform_device *pdev)
                as->use_pdc = true;
        }
 
-       if (IS_ENABLED(CONFIG_SOC_SAM_V4_V5)) {
-               as->addr_rx_bbuf = dma_alloc_coherent(&pdev->dev,
-                                                     SPI_MAX_DMA_XFER,
-                                                     &as->dma_addr_rx_bbuf,
-                                                     GFP_KERNEL | GFP_DMA);
-               if (!as->addr_rx_bbuf) {
-                       as->use_dma = false;
-               } else {
-                       as->addr_tx_bbuf = dma_alloc_coherent(&pdev->dev,
-                                       SPI_MAX_DMA_XFER,
-                                       &as->dma_addr_tx_bbuf,
-                                       GFP_KERNEL | GFP_DMA);
-                       if (!as->addr_tx_bbuf) {
-                               as->use_dma = false;
-                               dma_free_coherent(&pdev->dev, SPI_MAX_DMA_XFER,
-                                                 as->addr_rx_bbuf,
-                                                 as->dma_addr_rx_bbuf);
-                       }
-               }
-               if (!as->use_dma)
-                       dev_info(host->dev.parent,
-                                "  can not allocate dma coherent memory\n");
-       }
-
        if (as->caps.has_dma_support && !as->use_dma)
                dev_info(&pdev->dev, "Atmel SPI Controller using PIO only\n");
 
@@ -1664,13 +1680,10 @@ static int atmel_spi_probe(struct platform_device *pdev)
 out_free_dma:
        pm_runtime_disable(&pdev->dev);
        pm_runtime_set_suspended(&pdev->dev);
-
-       if (as->use_dma)
-               atmel_spi_release_dma(host);
-
        spi_writel(as, CR, SPI_BIT(SWRST));
        spi_writel(as, CR, SPI_BIT(SWRST)); /* AT91SAM9263 Rev B workaround */
-       clk_disable_unprepare(as->gclk);
+       if (as->gclk)
+               clk_disable_unprepare(as->gclk);
 out_disable_clk:
        clk_disable_unprepare(clk);
 
@@ -1687,18 +1700,8 @@ static void atmel_spi_remove(struct platform_device *pdev)
        spi_unregister_controller(host);
 
        /* reset the hardware and block queue progress */
-       if (as->use_dma) {
+       if (as->use_dma)
                atmel_spi_stop_dma(host);
-               atmel_spi_release_dma(host);
-               if (IS_ENABLED(CONFIG_SOC_SAM_V4_V5)) {
-                       dma_free_coherent(&pdev->dev, SPI_MAX_DMA_XFER,
-                                         as->addr_tx_bbuf,
-                                         as->dma_addr_tx_bbuf);
-                       dma_free_coherent(&pdev->dev, SPI_MAX_DMA_XFER,
-                                         as->addr_rx_bbuf,
-                                         as->dma_addr_rx_bbuf);
-               }
-       }
 
        spin_lock_irq(&as->lock);
        spi_writel(as, CR, SPI_BIT(SWRST));