korg/linux
0
0
Fork 0
mirror of https://mirrors.bfsu.edu.cn/git/linux.git synced 2024-12-28 05:24:47 +08:00
Code Issues Packages Projects Releases Wiki Activity

spi: stm32: renaming of spi_master into spi_controller

Browse Source 
Preparing introduction of SPI device, rename the spi_master structure
into spi_controller. This doesn't have any functional impact since
spi_master was already a macro for spi_controller.
Referring now to ctrl instead of master since the spi_controller
structure might not be used as a master controller only.

Signed-off-by: Alain Volmat <alain.volmat@foss.st.com>
Signed-off-by: Valentin Caron <valentin.caron@foss.st.com>
Link: https://lore.kernel.org/r/20230615075815.310261-2-valentin.caron@foss.st.com
Signed-off-by: Mark Brown <broonie@kernel.org>
This commit is contained in:
Alain Volmat 2023-06-15 09:58:12 +02:00 committed by Mark Brown
parent 0ad902aa3b
commit 6f486556ab
No known key found for this signature in database
GPG Key ID: 24D68B725D5487D0
1 changed files with 77 additions and 77 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1,6 +1,6 @@
// SPDX-License-Identifier: GPL-2.0 // SPDX-License-Identifier: GPL-2.0
// //
// STMicroelectronics STM32 SPI Controller driver (master mode only) // STMicroelectronics STM32 SPI Controller driver
// //
// Copyright (C) 2017, STMicroelectronics - All Rights Reserved // Copyright (C) 2017, STMicroelectronics - All Rights Reserved
// Author(s): Amelie Delaunay <amelie.delaunay@st.com> for STMicroelectronics. // Author(s): Amelie Delaunay <amelie.delaunay@st.com> for STMicroelectronics.
@ -258,7 +258,7 @@ struct stm32_spi_cfg {
/** /**
* struct stm32_spi - private data of the SPI controller * struct stm32_spi - private data of the SPI controller
* @dev: driver model representation of the controller * @dev: driver model representation of the controller
* @master: controller master interface * @ctrl: controller interface
* @cfg: compatible configuration data * @cfg: compatible configuration data
* @base: virtual memory area * @base: virtual memory area
* @clk: hw kernel clock feeding the SPI clock generator * @clk: hw kernel clock feeding the SPI clock generator
@ -283,7 +283,7 @@ struct stm32_spi_cfg {
*/ */
struct stm32_spi { struct stm32_spi {
struct device *dev; struct device *dev;
struct spi_master *master; struct spi_controller *ctrl;
const struct stm32_spi_cfg *cfg; const struct stm32_spi_cfg *cfg;
void __iomem *base; void __iomem *base;
struct clk *clk; struct clk *clk;
@ -437,9 +437,9 @@ static int stm32_spi_prepare_mbr(struct stm32_spi *spi, u32 speed_hz,
div = DIV_ROUND_CLOSEST(spi->clk_rate & ~0x1, speed_hz); div = DIV_ROUND_CLOSEST(spi->clk_rate & ~0x1, speed_hz);
/* /*
* SPI framework set xfer->speed_hz to master->max_speed_hz if * SPI framework set xfer->speed_hz to ctrl->max_speed_hz if
* xfer->speed_hz is greater than master->max_speed_hz, and it returns * xfer->speed_hz is greater than ctrl->max_speed_hz, and it returns
* an error when xfer->speed_hz is lower than master->min_speed_hz, so * an error when xfer->speed_hz is lower than ctrl->min_speed_hz, so
* no need to check it there. * no need to check it there.
* However, we need to ensure the following calculations. * However, we need to ensure the following calculations.
*/ */
@ -714,19 +714,19 @@ static void stm32h7_spi_disable(struct stm32_spi *spi)
/** /**
* stm32_spi_can_dma - Determine if the transfer is eligible for DMA use * stm32_spi_can_dma - Determine if the transfer is eligible for DMA use
* @master: controller master interface * @ctrl: controller interface
* @spi_dev: pointer to the spi device * @spi_dev: pointer to the spi device
* @transfer: pointer to spi transfer * @transfer: pointer to spi transfer
* *
* If driver has fifo and the current transfer size is greater than fifo size, * If driver has fifo and the current transfer size is greater than fifo size,
* use DMA. Otherwise use DMA for transfer longer than defined DMA min bytes. * use DMA. Otherwise use DMA for transfer longer than defined DMA min bytes.
*/ */
static bool stm32_spi_can_dma(struct spi_master *master, static bool stm32_spi_can_dma(struct spi_controller *ctrl,
struct spi_device *spi_dev, struct spi_device *spi_dev,
struct spi_transfer *transfer) struct spi_transfer *transfer)
{ {
unsigned int dma_size; unsigned int dma_size;
struct stm32_spi *spi = spi_master_get_devdata(master); struct stm32_spi *spi = spi_controller_get_devdata(ctrl);
if (spi->cfg->has_fifo) if (spi->cfg->has_fifo)
dma_size = spi->fifo_size; dma_size = spi->fifo_size;
@ -742,12 +742,12 @@ static bool stm32_spi_can_dma(struct spi_master *master,
/** /**
* stm32f4_spi_irq_event - Interrupt handler for SPI controller events * stm32f4_spi_irq_event - Interrupt handler for SPI controller events
* @irq: interrupt line * @irq: interrupt line
* @dev_id: SPI controller master interface * @dev_id: SPI controller ctrl interface
*/ */
static irqreturn_t stm32f4_spi_irq_event(int irq, void *dev_id) static irqreturn_t stm32f4_spi_irq_event(int irq, void *dev_id)
{ {
struct spi_master *master = dev_id; struct spi_controller *ctrl = dev_id;
struct stm32_spi *spi = spi_master_get_devdata(master); struct stm32_spi *spi = spi_controller_get_devdata(ctrl);
u32 sr, mask = 0; u32 sr, mask = 0;
bool end = false; bool end = false;
@ -830,14 +830,14 @@ end_irq:
/** /**
* stm32f4_spi_irq_thread - Thread of interrupt handler for SPI controller * stm32f4_spi_irq_thread - Thread of interrupt handler for SPI controller
* @irq: interrupt line * @irq: interrupt line
* @dev_id: SPI controller master interface * @dev_id: SPI controller interface
*/ */
static irqreturn_t stm32f4_spi_irq_thread(int irq, void *dev_id) static irqreturn_t stm32f4_spi_irq_thread(int irq, void *dev_id)
{ {
struct spi_master *master = dev_id; struct spi_controller *ctrl = dev_id;
struct stm32_spi *spi = spi_master_get_devdata(master); struct stm32_spi *spi = spi_controller_get_devdata(ctrl);
spi_finalize_current_transfer(master); spi_finalize_current_transfer(ctrl);
stm32f4_spi_disable(spi); stm32f4_spi_disable(spi);
return IRQ_HANDLED; return IRQ_HANDLED;
@ -846,12 +846,12 @@ static irqreturn_t stm32f4_spi_irq_thread(int irq, void *dev_id)
/** /**
* stm32h7_spi_irq_thread - Thread of interrupt handler for SPI controller * stm32h7_spi_irq_thread - Thread of interrupt handler for SPI controller
* @irq: interrupt line * @irq: interrupt line
* @dev_id: SPI controller master interface * @dev_id: SPI controller interface
*/ */
static irqreturn_t stm32h7_spi_irq_thread(int irq, void *dev_id) static irqreturn_t stm32h7_spi_irq_thread(int irq, void *dev_id)
{ {
struct spi_master *master = dev_id; struct spi_controller *ctrl = dev_id;
struct stm32_spi *spi = spi_master_get_devdata(master); struct stm32_spi *spi = spi_controller_get_devdata(ctrl);
u32 sr, ier, mask; u32 sr, ier, mask;
unsigned long flags; unsigned long flags;
bool end = false; bool end = false;
@ -931,7 +931,7 @@ static irqreturn_t stm32h7_spi_irq_thread(int irq, void *dev_id)
if (end) { if (end) {
stm32h7_spi_disable(spi); stm32h7_spi_disable(spi);
spi_finalize_current_transfer(master); spi_finalize_current_transfer(ctrl);
} }
return IRQ_HANDLED; return IRQ_HANDLED;
@ -939,13 +939,13 @@ static irqreturn_t stm32h7_spi_irq_thread(int irq, void *dev_id)
/** /**
* stm32_spi_prepare_msg - set up the controller to transfer a single message * stm32_spi_prepare_msg - set up the controller to transfer a single message
* @master: controller master interface * @ctrl: controller interface
* @msg: pointer to spi message * @msg: pointer to spi message
*/ */
static int stm32_spi_prepare_msg(struct spi_master *master, static int stm32_spi_prepare_msg(struct spi_controller *ctrl,
struct spi_message *msg) struct spi_message *msg)
{ {
struct stm32_spi *spi = spi_master_get_devdata(master); struct stm32_spi *spi = spi_controller_get_devdata(ctrl);
struct spi_device *spi_dev = msg->spi; struct spi_device *spi_dev = msg->spi;
struct device_node *np = spi_dev->dev.of_node; struct device_node *np = spi_dev->dev.of_node;
unsigned long flags; unsigned long flags;
@ -984,7 +984,7 @@ static int stm32_spi_prepare_msg(struct spi_master *master,
if (spi->cfg->set_number_of_data) { if (spi->cfg->set_number_of_data) {
int ret; int ret;
ret = spi_split_transfers_maxwords(master, msg, ret = spi_split_transfers_maxsize(ctrl, msg,
STM32H7_SPI_TSIZE_MAX, STM32H7_SPI_TSIZE_MAX,
GFP_KERNEL | GFP_DMA); GFP_KERNEL | GFP_DMA);
if (ret) if (ret)
@ -1016,7 +1016,7 @@ static void stm32f4_spi_dma_tx_cb(void *data)
struct stm32_spi *spi = data; struct stm32_spi *spi = data;
if (spi->cur_comm == SPI_SIMPLEX_TX || spi->cur_comm == SPI_3WIRE_TX) { if (spi->cur_comm == SPI_SIMPLEX_TX || spi->cur_comm == SPI_3WIRE_TX) {
spi_finalize_current_transfer(spi->master); spi_finalize_current_transfer(spi->ctrl);
stm32f4_spi_disable(spi); stm32f4_spi_disable(spi);
} }
} }
@ -1031,7 +1031,7 @@ static void stm32_spi_dma_rx_cb(void *data)
{ {
struct stm32_spi *spi = data; struct stm32_spi *spi = data;
spi_finalize_current_transfer(spi->master); spi_finalize_current_transfer(spi->ctrl);
spi->cfg->disable(spi); spi->cfg->disable(spi);
} }
@ -1589,18 +1589,18 @@ out:
/** /**
* stm32_spi_transfer_one - transfer a single spi_transfer * stm32_spi_transfer_one - transfer a single spi_transfer
* @master: controller master interface * @ctrl: controller interface
* @spi_dev: pointer to the spi device * @spi_dev: pointer to the spi device
* @transfer: pointer to spi transfer * @transfer: pointer to spi transfer
* *
* It must return 0 if the transfer is finished or 1 if the transfer is still * It must return 0 if the transfer is finished or 1 if the transfer is still
* in progress. * in progress.
*/ */
static int stm32_spi_transfer_one(struct spi_master *master, static int stm32_spi_transfer_one(struct spi_controller *ctrl,
struct spi_device *spi_dev, struct spi_device *spi_dev,
struct spi_transfer *transfer) struct spi_transfer *transfer)
{ {
struct stm32_spi *spi = spi_master_get_devdata(master); struct stm32_spi *spi = spi_controller_get_devdata(ctrl);
int ret; int ret;
spi->tx_buf = transfer->tx_buf; spi->tx_buf = transfer->tx_buf;
@ -1608,8 +1608,8 @@ static int stm32_spi_transfer_one(struct spi_master *master,
spi->tx_len = spi->tx_buf ? transfer->len : 0; spi->tx_len = spi->tx_buf ? transfer->len : 0;
spi->rx_len = spi->rx_buf ? transfer->len : 0; spi->rx_len = spi->rx_buf ? transfer->len : 0;
spi->cur_usedma = (master->can_dma && spi->cur_usedma = (ctrl->can_dma &&
master->can_dma(master, spi_dev, transfer)); ctrl->can_dma(ctrl, spi_dev, transfer));
ret = stm32_spi_transfer_one_setup(spi, spi_dev, transfer); ret = stm32_spi_transfer_one_setup(spi, spi_dev, transfer);
if (ret) { if (ret) {
@ -1625,13 +1625,13 @@ static int stm32_spi_transfer_one(struct spi_master *master,
/** /**
* stm32_spi_unprepare_msg - relax the hardware * stm32_spi_unprepare_msg - relax the hardware
* @master: controller master interface * @ctrl: controller interface
* @msg: pointer to the spi message * @msg: pointer to the spi message
*/ */
static int stm32_spi_unprepare_msg(struct spi_master *master, static int stm32_spi_unprepare_msg(struct spi_controller *ctrl,
struct spi_message *msg) struct spi_message *msg)
{ {
struct stm32_spi *spi = spi_master_get_devdata(master); struct stm32_spi *spi = spi_controller_get_devdata(ctrl);
spi->cfg->disable(spi); spi->cfg->disable(spi);
@ -1758,22 +1758,22 @@ MODULE_DEVICE_TABLE(of, stm32_spi_of_match);
static int stm32_spi_probe(struct platform_device *pdev) static int stm32_spi_probe(struct platform_device *pdev)
{ {
struct spi_master *master; struct spi_controller *ctrl;
struct stm32_spi *spi; struct stm32_spi *spi;
struct resource *res; struct resource *res;
struct reset_control *rst; struct reset_control *rst;
int ret; int ret;
master = devm_spi_alloc_master(&pdev->dev, sizeof(struct stm32_spi)); ctrl = devm_spi_alloc_master(&pdev->dev, sizeof(struct stm32_spi));
if (!master) { if (!ctrl) {
dev_err(&pdev->dev, "spi master allocation failed\n"); dev_err(&pdev->dev, "spi master allocation failed\n");
return -ENOMEM; return -ENOMEM;
} }
platform_set_drvdata(pdev, master); platform_set_drvdata(pdev, ctrl);
spi = spi_master_get_devdata(master); spi = spi_controller_get_devdata(ctrl);
spi->dev = &pdev->dev; spi->dev = &pdev->dev;
spi->master = master; spi->ctrl = ctrl;
spin_lock_init(&spi->lock); spin_lock_init(&spi->lock);
spi->cfg = (const struct stm32_spi_cfg *) spi->cfg = (const struct stm32_spi_cfg *)
@ -1794,7 +1794,7 @@ static int stm32_spi_probe(struct platform_device *pdev)
ret = devm_request_threaded_irq(&pdev->dev, spi->irq, ret = devm_request_threaded_irq(&pdev->dev, spi->irq,
spi->cfg->irq_handler_event, spi->cfg->irq_handler_event,
spi->cfg->irq_handler_thread, spi->cfg->irq_handler_thread,
IRQF_ONESHOT, pdev->name, master); IRQF_ONESHOT, pdev->name, ctrl);
if (ret) { if (ret) {
dev_err(&pdev->dev, "irq%d request failed: %d\n", spi->irq, dev_err(&pdev->dev, "irq%d request failed: %d\n", spi->irq,
ret); ret);
@ -1843,19 +1843,19 @@ static int stm32_spi_probe(struct platform_device *pdev)
goto err_clk_disable; goto err_clk_disable;
} }
master->dev.of_node = pdev->dev.of_node; ctrl->dev.of_node = pdev->dev.of_node;
master->auto_runtime_pm = true; ctrl->auto_runtime_pm = true;
master->bus_num = pdev->id; ctrl->bus_num = pdev->id;
master->mode_bits = SPI_CPHA | SPI_CPOL | SPI_CS_HIGH | SPI_LSB_FIRST | ctrl->mode_bits = SPI_CPHA | SPI_CPOL | SPI_CS_HIGH | SPI_LSB_FIRST |
SPI_3WIRE; SPI_3WIRE;
master->bits_per_word_mask = spi->cfg->get_bpw_mask(spi); ctrl->bits_per_word_mask = spi->cfg->get_bpw_mask(spi);
master->max_speed_hz = spi->clk_rate / spi->cfg->baud_rate_div_min; ctrl->max_speed_hz = spi->clk_rate / spi->cfg->baud_rate_div_min;
master->min_speed_hz = spi->clk_rate / spi->cfg->baud_rate_div_max; ctrl->min_speed_hz = spi->clk_rate / spi->cfg->baud_rate_div_max;
master->use_gpio_descriptors = true; ctrl->use_gpio_descriptors = true;
master->prepare_message = stm32_spi_prepare_msg; ctrl->prepare_message = stm32_spi_prepare_msg;
master->transfer_one = stm32_spi_transfer_one; ctrl->transfer_one = stm32_spi_transfer_one;
master->unprepare_message = stm32_spi_unprepare_msg; ctrl->unprepare_message = stm32_spi_unprepare_msg;
master->flags = spi->cfg->flags; ctrl->flags = spi->cfg->flags;
spi->dma_tx = dma_request_chan(spi->dev, "tx"); spi->dma_tx = dma_request_chan(spi->dev, "tx");
if (IS_ERR(spi->dma_tx)) { if (IS_ERR(spi->dma_tx)) {
@ -1866,7 +1866,7 @@ static int stm32_spi_probe(struct platform_device *pdev)
dev_warn(&pdev->dev, "failed to request tx dma channel\n"); dev_warn(&pdev->dev, "failed to request tx dma channel\n");
} else { } else {
master->dma_tx = spi->dma_tx; ctrl->dma_tx = spi->dma_tx;
} }
spi->dma_rx = dma_request_chan(spi->dev, "rx"); spi->dma_rx = dma_request_chan(spi->dev, "rx");
@ -1878,11 +1878,11 @@ static int stm32_spi_probe(struct platform_device *pdev)
dev_warn(&pdev->dev, "failed to request rx dma channel\n"); dev_warn(&pdev->dev, "failed to request rx dma channel\n");
} else { } else {
master->dma_rx = spi->dma_rx; ctrl->dma_rx = spi->dma_rx;
} }
if (spi->dma_tx || spi->dma_rx) if (spi->dma_tx || spi->dma_rx)
master->can_dma = stm32_spi_can_dma; ctrl->can_dma = stm32_spi_can_dma;
pm_runtime_set_autosuspend_delay(&pdev->dev, pm_runtime_set_autosuspend_delay(&pdev->dev,
STM32_SPI_AUTOSUSPEND_DELAY); STM32_SPI_AUTOSUSPEND_DELAY);
@ -1891,9 +1891,9 @@ static int stm32_spi_probe(struct platform_device *pdev)
pm_runtime_get_noresume(&pdev->dev); pm_runtime_get_noresume(&pdev->dev);
pm_runtime_enable(&pdev->dev); pm_runtime_enable(&pdev->dev);
ret = spi_register_master(master); ret = spi_register_controller(ctrl);
if (ret) { if (ret) {
dev_err(&pdev->dev, "spi master registration failed: %d\n", dev_err(&pdev->dev, "spi controller registration failed: %d\n",
ret); ret);
goto err_pm_disable; goto err_pm_disable;
} }
@ -1923,12 +1923,12 @@ err_clk_disable:
static void stm32_spi_remove(struct platform_device *pdev) static void stm32_spi_remove(struct platform_device *pdev)
{ {
struct spi_master *master = platform_get_drvdata(pdev); struct spi_controller *ctrl = platform_get_drvdata(pdev);
struct stm32_spi *spi = spi_master_get_devdata(master); struct stm32_spi *spi = spi_controller_get_devdata(ctrl);
pm_runtime_get_sync(&pdev->dev); pm_runtime_get_sync(&pdev->dev);
spi_unregister_master(master); spi_unregister_controller(ctrl);
spi->cfg->disable(spi); spi->cfg->disable(spi);
pm_runtime_disable(&pdev->dev); pm_runtime_disable(&pdev->dev);
@ -1936,10 +1936,10 @@ static void stm32_spi_remove(struct platform_device *pdev)
pm_runtime_set_suspended(&pdev->dev); pm_runtime_set_suspended(&pdev->dev);
pm_runtime_dont_use_autosuspend(&pdev->dev); pm_runtime_dont_use_autosuspend(&pdev->dev);
if (master->dma_tx) if (ctrl->dma_tx)
dma_release_channel(master->dma_tx); dma_release_channel(ctrl->dma_tx);
if (master->dma_rx) if (ctrl->dma_rx)
dma_release_channel(master->dma_rx); dma_release_channel(ctrl->dma_rx);
clk_disable_unprepare(spi->clk); clk_disable_unprepare(spi->clk);
@ -1949,8 +1949,8 @@ static void stm32_spi_remove(struct platform_device *pdev)
static int __maybe_unused stm32_spi_runtime_suspend(struct device *dev) static int __maybe_unused stm32_spi_runtime_suspend(struct device *dev)
{ {
struct spi_master *master = dev_get_drvdata(dev); struct spi_controller *ctrl = dev_get_drvdata(dev);
struct stm32_spi *spi = spi_master_get_devdata(master); struct stm32_spi *spi = spi_controller_get_devdata(ctrl);
clk_disable_unprepare(spi->clk); clk_disable_unprepare(spi->clk);
@ -1959,8 +1959,8 @@ static int __maybe_unused stm32_spi_runtime_suspend(struct device *dev)
static int __maybe_unused stm32_spi_runtime_resume(struct device *dev) static int __maybe_unused stm32_spi_runtime_resume(struct device *dev)
{ {
struct spi_master *master = dev_get_drvdata(dev); struct spi_controller *ctrl = dev_get_drvdata(dev);
struct stm32_spi *spi = spi_master_get_devdata(master); struct stm32_spi *spi = spi_controller_get_devdata(ctrl);
int ret; int ret;
ret = pinctrl_pm_select_default_state(dev); ret = pinctrl_pm_select_default_state(dev);
@ -1972,10 +1972,10 @@ static int __maybe_unused stm32_spi_runtime_resume(struct device *dev)
static int __maybe_unused stm32_spi_suspend(struct device *dev) static int __maybe_unused stm32_spi_suspend(struct device *dev)
{ {
struct spi_master *master = dev_get_drvdata(dev); struct spi_controller *ctrl = dev_get_drvdata(dev);
int ret; int ret;
ret = spi_master_suspend(master); ret = spi_controller_suspend(ctrl);
if (ret) if (ret)
return ret; return ret;
@ -1984,15 +1984,15 @@ static int __maybe_unused stm32_spi_suspend(struct device *dev)
static int __maybe_unused stm32_spi_resume(struct device *dev) static int __maybe_unused stm32_spi_resume(struct device *dev)
{ {
struct spi_master *master = dev_get_drvdata(dev); struct spi_controller *ctrl = dev_get_drvdata(dev);
struct stm32_spi *spi = spi_master_get_devdata(master); struct stm32_spi *spi = spi_controller_get_devdata(ctrl);
int ret; int ret;
ret = pm_runtime_force_resume(dev); ret = pm_runtime_force_resume(dev);
if (ret) if (ret)
return ret; return ret;
ret = spi_master_resume(master); ret = spi_controller_resume(ctrl);
if (ret) { if (ret) {
clk_disable_unprepare(spi->clk); clk_disable_unprepare(spi->clk);
return ret; return ret;