spi: qup: Vote for interconnect bandwidth to DRAM

When the SPI QUP controller is used together with a DMA engine it needs
to vote for the interconnect path to the DRAM. Otherwise it may be
unable to access the memory quickly enough.

The requested peak bandwidth is dependent on the SPI core/bus clock so
that the bandwidth scales together with the selected SPI speed.

To avoid sending votes too often the bandwidth is always requested when
a DMA transfer starts, but dropped only on runtime suspend. Runtime
suspend should only happen if no transfer is active. After resumption we
can defer the next vote until the first DMA transfer actually happens.

Signed-off-by: Stephan Gerhold <stephan.gerhold@kernkonzept.com>
Link: https://lore.kernel.org/r/20230919-spi-qup-dvfs-v2-4-1bac2e9ab8db@kernkonzept.com
Signed-off-by: Mark Brown <broonie@kernel.org>

diff --git a/drivers/spi/spi-qup.c b/drivers/spi/spi-qup.c
index bf043be3a2a97aa690caae30aa0e4c05df30fd0c..2af63040ac6e85dbf6bb788dc327212f258fc898 100644 (file)
--- a/drivers/spi/spi-qup.c
+++ b/drivers/spi/spi-qup.c
@@ -6,6 +6,7 @@
 #include <linux/clk.h>
 #include <linux/delay.h>
 #include <linux/err.h>
+#include <linux/interconnect.h>
 #include <linux/interrupt.h>
 #include <linux/io.h>
 #include <linux/list.h>
@@ -122,11 +123,14 @@
 #define SPI_DELAY_THRESHOLD            1
 #define SPI_DELAY_RETRY                        10
 
+#define SPI_BUS_WIDTH                  8
+
 struct spi_qup {
        void __iomem            *base;
        struct device           *dev;
        struct clk              *cclk;  /* core clock */
        struct clk              *iclk;  /* interface clock */
+       struct icc_path         *icc_path; /* interconnect to RAM */
        int                     irq;
        spinlock_t              lock;
 
@@ -149,6 +153,8 @@ struct spi_qup {
        int                     mode;
        struct dma_slave_config rx_conf;
        struct dma_slave_config tx_conf;
+
+       u32                     bw_speed_hz;
 };
 
 static int spi_qup_io_config(struct spi_device *spi, struct spi_transfer *xfer);
@@ -181,6 +187,23 @@ static inline bool spi_qup_is_valid_state(struct spi_qup *controller)
        return opstate & QUP_STATE_VALID;
 }
 
+static int spi_qup_vote_bw(struct spi_qup *controller, u32 speed_hz)
+{
+       u32 needed_peak_bw;
+       int ret;
+
+       if (controller->bw_speed_hz == speed_hz)
+               return 0;
+
+       needed_peak_bw = Bps_to_icc(speed_hz * SPI_BUS_WIDTH);
+       ret = icc_set_bw(controller->icc_path, 0, needed_peak_bw);
+       if (ret)
+               return ret;
+
+       controller->bw_speed_hz = speed_hz;
+       return 0;
+}
+
 static int spi_qup_set_state(struct spi_qup *controller, u32 state)
 {
        unsigned long loop;
@@ -451,6 +474,12 @@ static int spi_qup_do_dma(struct spi_device *spi, struct spi_transfer *xfer,
        struct scatterlist *tx_sgl, *rx_sgl;
        int ret;
 
+       ret = spi_qup_vote_bw(qup, xfer->speed_hz);
+       if (ret) {
+               dev_err(qup->dev, "fail to vote for ICC bandwidth: %d\n", ret);
+               return -EIO;
+       }
+
        if (xfer->rx_buf)
                rx_done = spi_qup_dma_done;
        else if (xfer->tx_buf)
@@ -994,6 +1023,7 @@ static void spi_qup_set_cs(struct spi_device *spi, bool val)
 static int spi_qup_probe(struct platform_device *pdev)
 {
        struct spi_controller *host;
+       struct icc_path *icc_path;
        struct clk *iclk, *cclk;
        struct spi_qup *controller;
        struct resource *res;
@@ -1019,6 +1049,11 @@ static int spi_qup_probe(struct platform_device *pdev)
        if (IS_ERR(iclk))
                return PTR_ERR(iclk);
 
+       icc_path = devm_of_icc_get(dev, NULL);
+       if (IS_ERR(icc_path))
+               return dev_err_probe(dev, PTR_ERR(icc_path),
+                                    "failed to get interconnect path\n");
+
        /* This is optional parameter */
        if (of_property_read_u32(dev->of_node, "spi-max-frequency", &max_freq))
                max_freq = SPI_MAX_RATE;
@@ -1070,6 +1105,7 @@ static int spi_qup_probe(struct platform_device *pdev)
        controller->base = base;
        controller->iclk = iclk;
        controller->cclk = cclk;
+       controller->icc_path = icc_path;
        controller->irq = irq;
 
        ret = spi_qup_init_dma(host, res->start);
@@ -1190,6 +1226,7 @@ static int spi_qup_pm_suspend_runtime(struct device *device)
        writel_relaxed(config, controller->base + QUP_CONFIG);
 
        clk_disable_unprepare(controller->cclk);
+       spi_qup_vote_bw(controller, 0);
        clk_disable_unprepare(controller->iclk);
 
        return 0;
@@ -1241,6 +1278,7 @@ static int spi_qup_suspend(struct device *device)
                return ret;
 
        clk_disable_unprepare(controller->cclk);
+       spi_qup_vote_bw(controller, 0);
        clk_disable_unprepare(controller->iclk);
        return 0;
 }