spi: img-spfi: switch to use modern name

Change legacy name master to modern name host or controller.

No functional changed.

Signed-off-by: Yang Yingliang <yangyingliang@huawei.com>
Link: https://lore.kernel.org/r/20230807124105.3429709-16-yangyingliang@huawei.com
Signed-off-by: Mark Brown <broonie@kernel.org>

diff --git a/drivers/spi/spi-img-spfi.c b/drivers/spi/spi-img-spfi.c
index d775f87770e333b1f4503634d78512c7aefc2b35..d8360f94d3b7df1b10de2dd3507e7ba9e5e08b65 100644 (file)
--- a/drivers/spi/spi-img-spfi.c
+++ b/drivers/spi/spi-img-spfi.c
@@ -86,7 +86,7 @@
 
 struct img_spfi {
        struct device *dev;
-       struct spi_master *master;
+       struct spi_controller *host;
        spinlock_t lock;
 
        void __iomem *regs;
@@ -221,11 +221,11 @@ static unsigned int spfi_pio_read8(struct img_spfi *spfi, u8 *buf,
        return count;
 }
 
-static int img_spfi_start_pio(struct spi_master *master,
+static int img_spfi_start_pio(struct spi_controller *host,
                               struct spi_device *spi,
                               struct spi_transfer *xfer)
 {
-       struct img_spfi *spfi = spi_master_get_devdata(spi->master);
+       struct img_spfi *spfi = spi_controller_get_devdata(spi->controller);
        unsigned int tx_bytes = 0, rx_bytes = 0;
        const void *tx_buf = xfer->tx_buf;
        void *rx_buf = xfer->rx_buf;
@@ -285,7 +285,7 @@ static void img_spfi_dma_rx_cb(void *data)
        spin_lock_irqsave(&spfi->lock, flags);
        spfi->rx_dma_busy = false;
        if (!spfi->tx_dma_busy)
-               spi_finalize_current_transfer(spfi->master);
+               spi_finalize_current_transfer(spfi->host);
        spin_unlock_irqrestore(&spfi->lock, flags);
 }
 
@@ -299,15 +299,15 @@ static void img_spfi_dma_tx_cb(void *data)
        spin_lock_irqsave(&spfi->lock, flags);
        spfi->tx_dma_busy = false;
        if (!spfi->rx_dma_busy)
-               spi_finalize_current_transfer(spfi->master);
+               spi_finalize_current_transfer(spfi->host);
        spin_unlock_irqrestore(&spfi->lock, flags);
 }
 
-static int img_spfi_start_dma(struct spi_master *master,
+static int img_spfi_start_dma(struct spi_controller *host,
                              struct spi_device *spi,
                              struct spi_transfer *xfer)
 {
-       struct img_spfi *spfi = spi_master_get_devdata(spi->master);
+       struct img_spfi *spfi = spi_controller_get_devdata(spi->controller);
        struct dma_async_tx_descriptor *rxdesc = NULL, *txdesc = NULL;
        struct dma_slave_config rxconf, txconf;
 
@@ -384,10 +384,10 @@ stop_dma:
        return -EIO;
 }
 
-static void img_spfi_handle_err(struct spi_master *master,
+static void img_spfi_handle_err(struct spi_controller *host,
                                struct spi_message *msg)
 {
-       struct img_spfi *spfi = spi_master_get_devdata(master);
+       struct img_spfi *spfi = spi_controller_get_devdata(host);
        unsigned long flags;
 
        /*
@@ -405,9 +405,9 @@ static void img_spfi_handle_err(struct spi_master *master,
        spin_unlock_irqrestore(&spfi->lock, flags);
 }
 
-static int img_spfi_prepare(struct spi_master *master, struct spi_message *msg)
+static int img_spfi_prepare(struct spi_controller *host, struct spi_message *msg)
 {
-       struct img_spfi *spfi = spi_master_get_devdata(master);
+       struct img_spfi *spfi = spi_controller_get_devdata(host);
        u32 val;
 
        val = spfi_readl(spfi, SPFI_PORT_STATE);
@@ -427,20 +427,20 @@ static int img_spfi_prepare(struct spi_master *master, struct spi_message *msg)
        return 0;
 }
 
-static int img_spfi_unprepare(struct spi_master *master,
+static int img_spfi_unprepare(struct spi_controller *host,
                              struct spi_message *msg)
 {
-       struct img_spfi *spfi = spi_master_get_devdata(master);
+       struct img_spfi *spfi = spi_controller_get_devdata(host);
 
        spfi_reset(spfi);
 
        return 0;
 }
 
-static void img_spfi_config(struct spi_master *master, struct spi_device *spi,
+static void img_spfi_config(struct spi_controller *host, struct spi_device *spi,
                            struct spi_transfer *xfer)
 {
-       struct img_spfi *spfi = spi_master_get_devdata(spi->master);
+       struct img_spfi *spfi = spi_controller_get_devdata(spi->controller);
        u32 val, div;
 
        /*
@@ -476,11 +476,11 @@ static void img_spfi_config(struct spi_master *master, struct spi_device *spi,
        spfi_writel(spfi, val, SPFI_CONTROL);
 }
 
-static int img_spfi_transfer_one(struct spi_master *master,
+static int img_spfi_transfer_one(struct spi_controller *host,
                                 struct spi_device *spi,
                                 struct spi_transfer *xfer)
 {
-       struct img_spfi *spfi = spi_master_get_devdata(spi->master);
+       struct img_spfi *spfi = spi_controller_get_devdata(spi->controller);
        int ret;
 
        if (xfer->len > SPFI_TRANSACTION_TSIZE_MASK) {
@@ -490,16 +490,16 @@ static int img_spfi_transfer_one(struct spi_master *master,
                return -EINVAL;
        }
 
-       img_spfi_config(master, spi, xfer);
-       if (master->can_dma && master->can_dma(master, spi, xfer))
-               ret = img_spfi_start_dma(master, spi, xfer);
+       img_spfi_config(host, spi, xfer);
+       if (host->can_dma && host->can_dma(host, spi, xfer))
+               ret = img_spfi_start_dma(host, spi, xfer);
        else
-               ret = img_spfi_start_pio(master, spi, xfer);
+               ret = img_spfi_start_pio(host, spi, xfer);
 
        return ret;
 }
 
-static bool img_spfi_can_dma(struct spi_master *master, struct spi_device *spi,
+static bool img_spfi_can_dma(struct spi_controller *host, struct spi_device *spi,
                             struct spi_transfer *xfer)
 {
        if (xfer->len > SPFI_32BIT_FIFO_SIZE)
@@ -524,20 +524,20 @@ static irqreturn_t img_spfi_irq(int irq, void *dev_id)
 
 static int img_spfi_probe(struct platform_device *pdev)
 {
-       struct spi_master *master;
+       struct spi_controller *host;
        struct img_spfi *spfi;
        struct resource *res;
        int ret;
        u32 max_speed_hz;
 
-       master = spi_alloc_master(&pdev->dev, sizeof(*spfi));
-       if (!master)
+       host = spi_alloc_host(&pdev->dev, sizeof(*spfi));
+       if (!host)
                return -ENOMEM;
-       platform_set_drvdata(pdev, master);
+       platform_set_drvdata(pdev, host);
 
-       spfi = spi_master_get_devdata(master);
+       spfi = spi_controller_get_devdata(host);
        spfi->dev = &pdev->dev;
-       spfi->master = master;
+       spfi->host = host;
        spin_lock_init(&spfi->lock);
 
        spfi->regs = devm_platform_get_and_ioremap_resource(pdev, 0, &res);
@@ -582,15 +582,15 @@ static int img_spfi_probe(struct platform_device *pdev)
         */
        spfi_writel(spfi, SPFI_INTERRUPT_IACCESS, SPFI_INTERRUPT_ENABLE);
 
-       master->auto_runtime_pm = true;
-       master->bus_num = pdev->id;
-       master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_TX_DUAL | SPI_RX_DUAL;
+       host->auto_runtime_pm = true;
+       host->bus_num = pdev->id;
+       host->mode_bits = SPI_CPOL | SPI_CPHA | SPI_TX_DUAL | SPI_RX_DUAL;
        if (of_property_read_bool(spfi->dev->of_node, "img,supports-quad-mode"))
-               master->mode_bits |= SPI_TX_QUAD | SPI_RX_QUAD;
-       master->dev.of_node = pdev->dev.of_node;
-       master->bits_per_word_mask = SPI_BPW_MASK(32) | SPI_BPW_MASK(8);
-       master->max_speed_hz = clk_get_rate(spfi->spfi_clk) / 4;
-       master->min_speed_hz = clk_get_rate(spfi->spfi_clk) / 512;
+               host->mode_bits |= SPI_TX_QUAD | SPI_RX_QUAD;
+       host->dev.of_node = pdev->dev.of_node;
+       host->bits_per_word_mask = SPI_BPW_MASK(32) | SPI_BPW_MASK(8);
+       host->max_speed_hz = clk_get_rate(spfi->spfi_clk) / 4;
+       host->min_speed_hz = clk_get_rate(spfi->spfi_clk) / 512;
 
        /*
         * Maximum speed supported by spfi is limited to the lower value
@@ -601,15 +601,15 @@ static int img_spfi_probe(struct platform_device *pdev)
         */
        if (!of_property_read_u32(spfi->dev->of_node, "spfi-max-frequency",
                                  &max_speed_hz)) {
-               if (master->max_speed_hz > max_speed_hz)
-                       master->max_speed_hz = max_speed_hz;
+               if (host->max_speed_hz > max_speed_hz)
+                       host->max_speed_hz = max_speed_hz;
        }
 
-       master->transfer_one = img_spfi_transfer_one;
-       master->prepare_message = img_spfi_prepare;
-       master->unprepare_message = img_spfi_unprepare;
-       master->handle_err = img_spfi_handle_err;
-       master->use_gpio_descriptors = true;
+       host->transfer_one = img_spfi_transfer_one;
+       host->prepare_message = img_spfi_prepare;
+       host->unprepare_message = img_spfi_unprepare;
+       host->handle_err = img_spfi_handle_err;
+       host->use_gpio_descriptors = true;
 
        spfi->tx_ch = dma_request_chan(spfi->dev, "tx");
        if (IS_ERR(spfi->tx_ch)) {
@@ -636,15 +636,15 @@ static int img_spfi_probe(struct platform_device *pdev)
                spfi->rx_ch = NULL;
                dev_warn(spfi->dev, "Failed to get DMA channels, falling back to PIO mode\n");
        } else {
-               master->dma_tx = spfi->tx_ch;
-               master->dma_rx = spfi->rx_ch;
-               master->can_dma = img_spfi_can_dma;
+               host->dma_tx = spfi->tx_ch;
+               host->dma_rx = spfi->rx_ch;
+               host->can_dma = img_spfi_can_dma;
        }
 
        pm_runtime_set_active(spfi->dev);
        pm_runtime_enable(spfi->dev);
 
-       ret = devm_spi_register_master(spfi->dev, master);
+       ret = devm_spi_register_controller(spfi->dev, host);
        if (ret)
                goto disable_pm;
 
@@ -660,15 +660,15 @@ disable_pm:
 disable_pclk:
        clk_disable_unprepare(spfi->sys_clk);
 put_spi:
-       spi_master_put(master);
+       spi_controller_put(host);
 
        return ret;
 }
 
 static void img_spfi_remove(struct platform_device *pdev)
 {
-       struct spi_master *master = platform_get_drvdata(pdev);
-       struct img_spfi *spfi = spi_master_get_devdata(master);
+       struct spi_controller *host = platform_get_drvdata(pdev);
+       struct img_spfi *spfi = spi_controller_get_devdata(host);
 
        if (spfi->tx_ch)
                dma_release_channel(spfi->tx_ch);
@@ -685,8 +685,8 @@ static void img_spfi_remove(struct platform_device *pdev)
 #ifdef CONFIG_PM
 static int img_spfi_runtime_suspend(struct device *dev)
 {
-       struct spi_master *master = dev_get_drvdata(dev);
-       struct img_spfi *spfi = spi_master_get_devdata(master);
+       struct spi_controller *host = dev_get_drvdata(dev);
+       struct img_spfi *spfi = spi_controller_get_devdata(host);
 
        clk_disable_unprepare(spfi->spfi_clk);
        clk_disable_unprepare(spfi->sys_clk);
@@ -696,8 +696,8 @@ static int img_spfi_runtime_suspend(struct device *dev)
 
 static int img_spfi_runtime_resume(struct device *dev)
 {
-       struct spi_master *master = dev_get_drvdata(dev);
-       struct img_spfi *spfi = spi_master_get_devdata(master);
+       struct spi_controller *host = dev_get_drvdata(dev);
+       struct img_spfi *spfi = spi_controller_get_devdata(host);
        int ret;
 
        ret = clk_prepare_enable(spfi->sys_clk);
@@ -716,15 +716,15 @@ static int img_spfi_runtime_resume(struct device *dev)
 #ifdef CONFIG_PM_SLEEP
 static int img_spfi_suspend(struct device *dev)
 {
-       struct spi_master *master = dev_get_drvdata(dev);
+       struct spi_controller *host = dev_get_drvdata(dev);
 
-       return spi_master_suspend(master);
+       return spi_controller_suspend(host);
 }
 
 static int img_spfi_resume(struct device *dev)
 {
-       struct spi_master *master = dev_get_drvdata(dev);
-       struct img_spfi *spfi = spi_master_get_devdata(master);
+       struct spi_controller *host = dev_get_drvdata(dev);
+       struct img_spfi *spfi = spi_controller_get_devdata(host);
        int ret;
 
        ret = pm_runtime_resume_and_get(dev);
@@ -733,7 +733,7 @@ static int img_spfi_resume(struct device *dev)
        spfi_reset(spfi);
        pm_runtime_put(dev);
 
-       return spi_master_resume(master);
+       return spi_controller_resume(host);
 }
 #endif /* CONFIG_PM_SLEEP */