Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-12-29 14:21:47 +00:00
Code Issues Packages Projects Releases Wiki Activity

spi: sun6i: switch to use modern name

Browse Source 
Change legacy name master to modern name host or controller.

No functional changed.

Signed-off-by: Yang Yingliang <yangyingliang@huawei.com>
Link: https://msgid.link/r/20231128093031.3707034-8-yangyingliang@huawei.com
Signed-off-by: Mark Brown <broonie@kernel.org>
This commit is contained in:
Yang Yingliang 2023-11-28 17:30:12 +08:00 committed by Mark Brown
parent 6d232cc8a7
commit 9f55bb7989
No known key found for this signature in database
GPG Key ID: 24D68B725D5487D0
1 changed files with 74 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

148
drivers/spi/spi-sun6i.c
View File

@ -97,7 +97,7 @@ struct sun6i_spi_cfg {
}; };
struct sun6i_spi { struct sun6i_spi {
struct spi_master *master; struct spi_controller *host;
void __iomem *base_addr; void __iomem *base_addr;
dma_addr_t dma_addr_rx; dma_addr_t dma_addr_rx;
dma_addr_t dma_addr_tx; dma_addr_t dma_addr_tx;
@ -181,7 +181,7 @@ static inline void sun6i_spi_fill_fifo(struct sun6i_spi *sspi)
static void sun6i_spi_set_cs(struct spi_device *spi, bool enable) static void sun6i_spi_set_cs(struct spi_device *spi, bool enable)
{ {
struct sun6i_spi *sspi = spi_master_get_devdata(spi->master); struct sun6i_spi *sspi = spi_controller_get_devdata(spi->controller);
u32 reg; u32 reg;
reg = sun6i_spi_read(sspi, SUN6I_TFR_CTL_REG); reg = sun6i_spi_read(sspi, SUN6I_TFR_CTL_REG);
@ -212,7 +212,7 @@ static int sun6i_spi_prepare_dma(struct sun6i_spi *sspi,
struct spi_transfer *tfr) struct spi_transfer *tfr)
{ {
struct dma_async_tx_descriptor *rxdesc, *txdesc; struct dma_async_tx_descriptor *rxdesc, *txdesc;
struct spi_master *master = sspi->master; struct spi_controller *host = sspi->host;
rxdesc = NULL; rxdesc = NULL;
if (tfr->rx_buf) { if (tfr->rx_buf) {
@ -223,9 +223,9 @@ static int sun6i_spi_prepare_dma(struct sun6i_spi *sspi,
.src_maxburst = 8, .src_maxburst = 8,
}; };
dmaengine_slave_config(master->dma_rx, &rxconf); dmaengine_slave_config(host->dma_rx, &rxconf);
rxdesc = dmaengine_prep_slave_sg(master->dma_rx, rxdesc = dmaengine_prep_slave_sg(host->dma_rx,
tfr->rx_sg.sgl, tfr->rx_sg.sgl,
tfr->rx_sg.nents, tfr->rx_sg.nents,
DMA_DEV_TO_MEM, DMA_DEV_TO_MEM,
@ -245,38 +245,38 @@ static int sun6i_spi_prepare_dma(struct sun6i_spi *sspi,
.dst_maxburst = 8, .dst_maxburst = 8,
}; };
dmaengine_slave_config(master->dma_tx, &txconf); dmaengine_slave_config(host->dma_tx, &txconf);
txdesc = dmaengine_prep_slave_sg(master->dma_tx, txdesc = dmaengine_prep_slave_sg(host->dma_tx,
tfr->tx_sg.sgl, tfr->tx_sg.sgl,
tfr->tx_sg.nents, tfr->tx_sg.nents,
DMA_MEM_TO_DEV, DMA_MEM_TO_DEV,
DMA_PREP_INTERRUPT); DMA_PREP_INTERRUPT);
if (!txdesc) { if (!txdesc) {
if (rxdesc) if (rxdesc)
dmaengine_terminate_sync(master->dma_rx); dmaengine_terminate_sync(host->dma_rx);
return -EINVAL; return -EINVAL;
} }
} }
if (tfr->rx_buf) { if (tfr->rx_buf) {
dmaengine_submit(rxdesc); dmaengine_submit(rxdesc);
dma_async_issue_pending(master->dma_rx); dma_async_issue_pending(host->dma_rx);
} }
if (tfr->tx_buf) { if (tfr->tx_buf) {
dmaengine_submit(txdesc); dmaengine_submit(txdesc);
dma_async_issue_pending(master->dma_tx); dma_async_issue_pending(host->dma_tx);
} }
return 0; return 0;
} }
static int sun6i_spi_transfer_one(struct spi_master *master, static int sun6i_spi_transfer_one(struct spi_controller *host,
struct spi_device *spi, struct spi_device *spi,
struct spi_transfer *tfr) struct spi_transfer *tfr)
{ {
struct sun6i_spi *sspi = spi_master_get_devdata(master); struct sun6i_spi *sspi = spi_controller_get_devdata(host);
unsigned int div, div_cdr1, div_cdr2, timeout; unsigned int div, div_cdr1, div_cdr2, timeout;
unsigned int start, end, tx_time; unsigned int start, end, tx_time;
unsigned int trig_level; unsigned int trig_level;
@ -293,7 +293,7 @@ static int sun6i_spi_transfer_one(struct spi_master *master,
sspi->tx_buf = tfr->tx_buf; sspi->tx_buf = tfr->tx_buf;
sspi->rx_buf = tfr->rx_buf; sspi->rx_buf = tfr->rx_buf;
sspi->len = tfr->len; sspi->len = tfr->len;
use_dma = master->can_dma ? master->can_dma(master, spi, tfr) : false; use_dma = host->can_dma ? host->can_dma(host, spi, tfr) : false;
/* Clear pending interrupts */ /* Clear pending interrupts */
sun6i_spi_write(sspi, SUN6I_INT_STA_REG, ~0); sun6i_spi_write(sspi, SUN6I_INT_STA_REG, ~0);
@ -463,7 +463,7 @@ static int sun6i_spi_transfer_one(struct spi_master *master,
} else { } else {
ret = sun6i_spi_prepare_dma(sspi, tfr); ret = sun6i_spi_prepare_dma(sspi, tfr);
if (ret) { if (ret) {
dev_warn(&master->dev, dev_warn(&host->dev,
"%s: prepare DMA failed, ret=%d", "%s: prepare DMA failed, ret=%d",
dev_name(&spi->dev), ret); dev_name(&spi->dev), ret);
return ret; return ret;
@ -486,7 +486,7 @@ static int sun6i_spi_transfer_one(struct spi_master *master,
reg = sun6i_spi_read(sspi, SUN6I_TFR_CTL_REG); reg = sun6i_spi_read(sspi, SUN6I_TFR_CTL_REG);
sun6i_spi_write(sspi, SUN6I_TFR_CTL_REG, reg | SUN6I_TFR_CTL_XCH); sun6i_spi_write(sspi, SUN6I_TFR_CTL_REG, reg | SUN6I_TFR_CTL_XCH);
tx_time = spi_controller_xfer_timeout(master, tfr); tx_time = spi_controller_xfer_timeout(host, tfr);
start = jiffies; start = jiffies;
timeout = wait_for_completion_timeout(&sspi->done, timeout = wait_for_completion_timeout(&sspi->done,
msecs_to_jiffies(tx_time)); msecs_to_jiffies(tx_time));
@ -502,13 +502,13 @@ static int sun6i_spi_transfer_one(struct spi_master *master,
timeout = wait_for_completion_timeout(&sspi->dma_rx_done, timeout = wait_for_completion_timeout(&sspi->dma_rx_done,
timeout); timeout);
if (!timeout) if (!timeout)
dev_warn(&master->dev, "RX DMA timeout\n"); dev_warn(&host->dev, "RX DMA timeout\n");
} }
} }
end = jiffies; end = jiffies;
if (!timeout) { if (!timeout) {
dev_warn(&master->dev, dev_warn(&host->dev,
"%s: timeout transferring %u bytes@%iHz for %i(%i)ms", "%s: timeout transferring %u bytes@%iHz for %i(%i)ms",
dev_name(&spi->dev), tfr->len, tfr->speed_hz, dev_name(&spi->dev), tfr->len, tfr->speed_hz,
jiffies_to_msecs(end - start), tx_time); jiffies_to_msecs(end - start), tx_time);
@ -518,8 +518,8 @@ static int sun6i_spi_transfer_one(struct spi_master *master,
sun6i_spi_write(sspi, SUN6I_INT_CTL_REG, 0); sun6i_spi_write(sspi, SUN6I_INT_CTL_REG, 0);
if (ret && use_dma) { if (ret && use_dma) {
dmaengine_terminate_sync(master->dma_rx); dmaengine_terminate_sync(host->dma_rx);
dmaengine_terminate_sync(master->dma_tx); dmaengine_terminate_sync(host->dma_tx);
} }
return ret; return ret;
@ -564,8 +564,8 @@ static irqreturn_t sun6i_spi_handler(int irq, void *dev_id)
static int sun6i_spi_runtime_resume(struct device *dev) static int sun6i_spi_runtime_resume(struct device *dev)
{ {
struct spi_master *master = dev_get_drvdata(dev); struct spi_controller *host = dev_get_drvdata(dev);
struct sun6i_spi *sspi = spi_master_get_devdata(master); struct sun6i_spi *sspi = spi_controller_get_devdata(host);
int ret; int ret;
ret = clk_prepare_enable(sspi->hclk); ret = clk_prepare_enable(sspi->hclk);
@ -601,8 +601,8 @@ out:
static int sun6i_spi_runtime_suspend(struct device *dev) static int sun6i_spi_runtime_suspend(struct device *dev)
{ {
struct spi_master *master = dev_get_drvdata(dev); struct spi_controller *host = dev_get_drvdata(dev);
struct sun6i_spi *sspi = spi_master_get_devdata(master); struct sun6i_spi *sspi = spi_controller_get_devdata(host);
reset_control_assert(sspi->rstc); reset_control_assert(sspi->rstc);
clk_disable_unprepare(sspi->mclk); clk_disable_unprepare(sspi->mclk);
@ -611,11 +611,11 @@ static int sun6i_spi_runtime_suspend(struct device *dev)
return 0; return 0;
} }
static bool sun6i_spi_can_dma(struct spi_master *master, static bool sun6i_spi_can_dma(struct spi_controller *host,
struct spi_device *spi, struct spi_device *spi,
struct spi_transfer *xfer) struct spi_transfer *xfer)
{ {
struct sun6i_spi *sspi = spi_master_get_devdata(master); struct sun6i_spi *sspi = spi_controller_get_devdata(host);
/* /*
* If the number of spi words to transfer is less or equal than * If the number of spi words to transfer is less or equal than
@ -627,67 +627,67 @@ static bool sun6i_spi_can_dma(struct spi_master *master,
static int sun6i_spi_probe(struct platform_device *pdev) static int sun6i_spi_probe(struct platform_device *pdev)
{ {
struct spi_master *master; struct spi_controller *host;
struct sun6i_spi *sspi; struct sun6i_spi *sspi;
struct resource *mem; struct resource *mem;
int ret = 0, irq; int ret = 0, irq;
master = spi_alloc_master(&pdev->dev, sizeof(struct sun6i_spi)); host = spi_alloc_host(&pdev->dev, sizeof(struct sun6i_spi));
if (!master) { if (!host) {
dev_err(&pdev->dev, "Unable to allocate SPI Master\n"); dev_err(&pdev->dev, "Unable to allocate SPI Host\n");
return -ENOMEM; return -ENOMEM;
} }
platform_set_drvdata(pdev, master); platform_set_drvdata(pdev, host);
sspi = spi_master_get_devdata(master); sspi = spi_controller_get_devdata(host);
sspi->base_addr = devm_platform_get_and_ioremap_resource(pdev, 0, &mem); sspi->base_addr = devm_platform_get_and_ioremap_resource(pdev, 0, &mem);
if (IS_ERR(sspi->base_addr)) { if (IS_ERR(sspi->base_addr)) {
ret = PTR_ERR(sspi->base_addr); ret = PTR_ERR(sspi->base_addr);
goto err_free_master; goto err_free_host;
} }
irq = platform_get_irq(pdev, 0); irq = platform_get_irq(pdev, 0);
if (irq < 0) { if (irq < 0) {
ret = -ENXIO; ret = -ENXIO;
goto err_free_master; goto err_free_host;
} }
ret = devm_request_irq(&pdev->dev, irq, sun6i_spi_handler, ret = devm_request_irq(&pdev->dev, irq, sun6i_spi_handler,
0, "sun6i-spi", sspi); 0, "sun6i-spi", sspi);
if (ret) { if (ret) {
dev_err(&pdev->dev, "Cannot request IRQ\n"); dev_err(&pdev->dev, "Cannot request IRQ\n");
goto err_free_master; goto err_free_host;
} }
sspi->master = master; sspi->host = host;
sspi->cfg = of_device_get_match_data(&pdev->dev); sspi->cfg = of_device_get_match_data(&pdev->dev);
master->max_speed_hz = 100 * 1000 * 1000; host->max_speed_hz = 100 * 1000 * 1000;
master->min_speed_hz = 3 * 1000; host->min_speed_hz = 3 * 1000;
master->use_gpio_descriptors = true; host->use_gpio_descriptors = true;
master->set_cs = sun6i_spi_set_cs; host->set_cs = sun6i_spi_set_cs;
master->transfer_one = sun6i_spi_transfer_one; host->transfer_one = sun6i_spi_transfer_one;
master->num_chipselect = 4; host->num_chipselect = 4;
master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_CS_HIGH | SPI_LSB_FIRST | host->mode_bits = SPI_CPOL | SPI_CPHA | SPI_CS_HIGH | SPI_LSB_FIRST |
sspi->cfg->mode_bits; sspi->cfg->mode_bits;
master->bits_per_word_mask = SPI_BPW_MASK(8); host->bits_per_word_mask = SPI_BPW_MASK(8);
master->dev.of_node = pdev->dev.of_node; host->dev.of_node = pdev->dev.of_node;
master->auto_runtime_pm = true; host->auto_runtime_pm = true;
master->max_transfer_size = sun6i_spi_max_transfer_size; host->max_transfer_size = sun6i_spi_max_transfer_size;
sspi->hclk = devm_clk_get(&pdev->dev, "ahb"); sspi->hclk = devm_clk_get(&pdev->dev, "ahb");
if (IS_ERR(sspi->hclk)) { if (IS_ERR(sspi->hclk)) {
dev_err(&pdev->dev, "Unable to acquire AHB clock\n"); dev_err(&pdev->dev, "Unable to acquire AHB clock\n");
ret = PTR_ERR(sspi->hclk); ret = PTR_ERR(sspi->hclk);
goto err_free_master; goto err_free_host;
} }
sspi->mclk = devm_clk_get(&pdev->dev, "mod"); sspi->mclk = devm_clk_get(&pdev->dev, "mod");
if (IS_ERR(sspi->mclk)) { if (IS_ERR(sspi->mclk)) {
dev_err(&pdev->dev, "Unable to acquire module clock\n"); dev_err(&pdev->dev, "Unable to acquire module clock\n");
ret = PTR_ERR(sspi->mclk); ret = PTR_ERR(sspi->mclk);
goto err_free_master; goto err_free_host;
} }
init_completion(&sspi->done); init_completion(&sspi->done);
@ -697,34 +697,34 @@ static int sun6i_spi_probe(struct platform_device *pdev)
if (IS_ERR(sspi->rstc)) { if (IS_ERR(sspi->rstc)) {
dev_err(&pdev->dev, "Couldn't get reset controller\n"); dev_err(&pdev->dev, "Couldn't get reset controller\n");
ret = PTR_ERR(sspi->rstc); ret = PTR_ERR(sspi->rstc);
goto err_free_master; goto err_free_host;
} }
master->dma_tx = dma_request_chan(&pdev->dev, "tx"); host->dma_tx = dma_request_chan(&pdev->dev, "tx");
if (IS_ERR(master->dma_tx)) { if (IS_ERR(host->dma_tx)) {
/* Check tx to see if we need defer probing driver */ /* Check tx to see if we need defer probing driver */
if (PTR_ERR(master->dma_tx) == -EPROBE_DEFER) { if (PTR_ERR(host->dma_tx) == -EPROBE_DEFER) {
ret = -EPROBE_DEFER; ret = -EPROBE_DEFER;
goto err_free_master; goto err_free_host;
} }
dev_warn(&pdev->dev, "Failed to request TX DMA channel\n"); dev_warn(&pdev->dev, "Failed to request TX DMA channel\n");
master->dma_tx = NULL; host->dma_tx = NULL;
} }
master->dma_rx = dma_request_chan(&pdev->dev, "rx"); host->dma_rx = dma_request_chan(&pdev->dev, "rx");
if (IS_ERR(master->dma_rx)) { if (IS_ERR(host->dma_rx)) {
if (PTR_ERR(master->dma_rx) == -EPROBE_DEFER) { if (PTR_ERR(host->dma_rx) == -EPROBE_DEFER) {
ret = -EPROBE_DEFER; ret = -EPROBE_DEFER;
goto err_free_dma_tx; goto err_free_dma_tx;
} }
dev_warn(&pdev->dev, "Failed to request RX DMA channel\n"); dev_warn(&pdev->dev, "Failed to request RX DMA channel\n");
master->dma_rx = NULL; host->dma_rx = NULL;
} }
if (master->dma_tx && master->dma_rx) { if (host->dma_tx && host->dma_rx) {
sspi->dma_addr_tx = mem->start + SUN6I_TXDATA_REG; sspi->dma_addr_tx = mem->start + SUN6I_TXDATA_REG;
sspi->dma_addr_rx = mem->start + SUN6I_RXDATA_REG; sspi->dma_addr_rx = mem->start + SUN6I_RXDATA_REG;
master->can_dma = sun6i_spi_can_dma; host->can_dma = sun6i_spi_can_dma;
} }
/* /*
@ -742,9 +742,9 @@ static int sun6i_spi_probe(struct platform_device *pdev)
pm_runtime_set_active(&pdev->dev); pm_runtime_set_active(&pdev->dev);
pm_runtime_enable(&pdev->dev); pm_runtime_enable(&pdev->dev);
ret = devm_spi_register_master(&pdev->dev, master); ret = devm_spi_register_controller(&pdev->dev, host);
if (ret) { if (ret) {
dev_err(&pdev->dev, "cannot register SPI master\n"); dev_err(&pdev->dev, "cannot register SPI host\n");
goto err_pm_disable; goto err_pm_disable;
} }
@ -754,26 +754,26 @@ err_pm_disable:
pm_runtime_disable(&pdev->dev); pm_runtime_disable(&pdev->dev);
sun6i_spi_runtime_suspend(&pdev->dev); sun6i_spi_runtime_suspend(&pdev->dev);
err_free_dma_rx: err_free_dma_rx:
if (master->dma_rx) if (host->dma_rx)
dma_release_channel(master->dma_rx); dma_release_channel(host->dma_rx);
err_free_dma_tx: err_free_dma_tx:
if (master->dma_tx) if (host->dma_tx)
dma_release_channel(master->dma_tx); dma_release_channel(host->dma_tx);
err_free_master: err_free_host:
spi_master_put(master); spi_controller_put(host);
return ret; return ret;
} }
static void sun6i_spi_remove(struct platform_device *pdev) static void sun6i_spi_remove(struct platform_device *pdev)
{ {
struct spi_master *master = platform_get_drvdata(pdev); struct spi_controller *host = platform_get_drvdata(pdev);
pm_runtime_force_suspend(&pdev->dev); pm_runtime_force_suspend(&pdev->dev);
if (master->dma_tx) if (host->dma_tx)
dma_release_channel(master->dma_tx); dma_release_channel(host->dma_tx);
if (master->dma_rx) if (host->dma_rx)
dma_release_channel(master->dma_rx); dma_release_channel(host->dma_rx);
} }
static const struct sun6i_spi_cfg sun6i_a31_spi_cfg = { static const struct sun6i_spi_cfg sun6i_a31_spi_cfg = {