Re: [PATCH 2/4] spi: dw: Put the driver entities naming in order

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



On Fri, Nov 12, 2021 at 10:51 PM Serge Semin
<Sergey.Semin@xxxxxxxxxxxxxxxxxxxx> wrote:
>
> Mostly due to a long driver history it's methods and macro names look a
> bit messy. In particularly that concerns the code their prefixes. A
> biggest part of the driver functions and macros have got the dw_spi/DW_SPI
> prefixes. But there are some entities which have been just
> "spi_/SPI_"-prefixed. Especially that concerns the CSR and their fields
> macro definitions. It makes the code harder to comprehend since such
> methods and macros can be easily confused with the global SPI-subsystem
> exports. In this case the only possible way to more or less quickly
> distinguish one naming space from another is either by context or by the
> argument type, which most of the times isn't that easy anyway. In addition
> to that a new DW SSI IP-core support has been added in the framework of
> commit e539f435cb9c ("spi: dw: Add support for DesignWare DWC_ssi"), which
> introduced a new set or macro-prefixes to describe CTRLR0-specific fields
> and worsen the situation. Finally there are methods with
> no DW SPI driver-reference prefix at all, that make the code reading even
> harder. So in order to ease the driver hacking let's bring the code naming
> to a common base:
> 1) Each method is supposed to have "dw_spi_" prefix so to be easily
> distinguished from the kernel API, e.g. SPI-subsystem methods and macros.
> (Exception is the local implementation of the readl/writel methods since
> being just the regspace accessors.)
> 2) Each generically used macro should have DW_SPI_-prefix thus being
> easily comprehended as the local driver definition.
> 3) DW APB SSI and DW SSI specific macros should have prefixes as DW_PSSI_

In the compatible strings the parameter has "assi" and not "pssi".
What did I miss?

> and DW_HSSI_ respectively so referring to the system buses they support
> (APB and AHB similarly to the DT clocks naming like pclk, hclk).
>
> Signed-off-by: Serge Semin <Sergey.Semin@xxxxxxxxxxxxxxxxxxxx>
>
> ---
>
> Folks, any ideas of a better naming scheme especially for the DW APB SSI
> and DW SSI specific macros are very welcome.
> ---
>  drivers/spi/spi-dw-bt1.c  |   8 +--
>  drivers/spi/spi-dw-core.c | 138 ++++++++++++++++++------------------
>  drivers/spi/spi-dw-dma.c  |  50 ++++++-------
>  drivers/spi/spi-dw-mmio.c |  20 +++---
>  drivers/spi/spi-dw-pci.c  |  59 ++++++++--------
>  drivers/spi/spi-dw.h      | 145 +++++++++++++++++++-------------------
>  6 files changed, 211 insertions(+), 209 deletions(-)
>
> diff --git a/drivers/spi/spi-dw-bt1.c b/drivers/spi/spi-dw-bt1.c
> index 5be6b7b80c21..0411088dc443 100644
> --- a/drivers/spi/spi-dw-bt1.c
> +++ b/drivers/spi/spi-dw-bt1.c
> @@ -123,7 +123,7 @@ static ssize_t dw_spi_bt1_dirmap_read(struct spi_mem_dirmap_desc *desc,
>         len = min_t(size_t, len, dwsbt1->map_len - offs);
>
>         /* Collect the controller configuration required by the operation */
> -       cfg.tmode = SPI_TMOD_EPROMREAD;
> +       cfg.tmode = DW_SPI_CTRLR0_TMOD_EPROMREAD;
>         cfg.dfs = 8;
>         cfg.ndf = 4;
>         cfg.freq = mem->spi->max_speed_hz;
> @@ -131,13 +131,13 @@ static ssize_t dw_spi_bt1_dirmap_read(struct spi_mem_dirmap_desc *desc,
>         /* Make sure the corresponding CS is de-asserted on transmission */
>         dw_spi_set_cs(mem->spi, false);
>
> -       spi_enable_chip(dws, 0);
> +       dw_spi_enable_chip(dws, 0);
>
>         dw_spi_update_config(dws, mem->spi, &cfg);
>
> -       spi_umask_intr(dws, SPI_INT_RXFI);
> +       dw_spi_umask_intr(dws, DW_SPI_INT_RXFI);
>
> -       spi_enable_chip(dws, 1);
> +       dw_spi_enable_chip(dws, 1);
>
>         /*
>          * Enable the transparent mode of the System Boot Controller.
> diff --git a/drivers/spi/spi-dw-core.c b/drivers/spi/spi-dw-core.c
> index f5446d9c6f27..4d91ffb5c0d8 100644
> --- a/drivers/spi/spi-dw-core.c
> +++ b/drivers/spi/spi-dw-core.c
> @@ -24,7 +24,7 @@
>  #endif
>
>  /* Slave spi_device related */
> -struct chip_data {
> +struct dw_spi_chip_data {
>         u32 cr0;
>         u32 rx_sample_dly;      /* RX sample delay */
>  };
> @@ -109,7 +109,7 @@ void dw_spi_set_cs(struct spi_device *spi, bool enable)
>  EXPORT_SYMBOL_GPL(dw_spi_set_cs);
>
>  /* Return the max entries we can fill into tx fifo */
> -static inline u32 tx_max(struct dw_spi *dws)
> +static inline u32 dw_spi_tx_max(struct dw_spi *dws)
>  {
>         u32 tx_room, rxtx_gap;
>
> @@ -129,14 +129,14 @@ static inline u32 tx_max(struct dw_spi *dws)
>  }
>
>  /* Return the max entries we should read out of rx fifo */
> -static inline u32 rx_max(struct dw_spi *dws)
> +static inline u32 dw_spi_rx_max(struct dw_spi *dws)
>  {
>         return min_t(u32, dws->rx_len, dw_readl(dws, DW_SPI_RXFLR));
>  }
>
>  static void dw_writer(struct dw_spi *dws)
>  {
> -       u32 max = tx_max(dws);
> +       u32 max = dw_spi_tx_max(dws);
>         u32 txw = 0;
>
>         while (max--) {
> @@ -157,7 +157,7 @@ static void dw_writer(struct dw_spi *dws)
>
>  static void dw_reader(struct dw_spi *dws)
>  {
> -       u32 max = rx_max(dws);
> +       u32 max = dw_spi_rx_max(dws);
>         u32 rxw;
>
>         while (max--) {
> @@ -186,24 +186,24 @@ int dw_spi_check_status(struct dw_spi *dws, bool raw)
>         else
>                 irq_status = dw_readl(dws, DW_SPI_ISR);
>
> -       if (irq_status & SPI_INT_RXOI) {
> +       if (irq_status & DW_SPI_INT_RXOI) {
>                 dev_err(&dws->master->dev, "RX FIFO overflow detected\n");
>                 ret = -EIO;
>         }
>
> -       if (irq_status & SPI_INT_RXUI) {
> +       if (irq_status & DW_SPI_INT_RXUI) {
>                 dev_err(&dws->master->dev, "RX FIFO underflow detected\n");
>                 ret = -EIO;
>         }
>
> -       if (irq_status & SPI_INT_TXOI) {
> +       if (irq_status & DW_SPI_INT_TXOI) {
>                 dev_err(&dws->master->dev, "TX FIFO overflow detected\n");
>                 ret = -EIO;
>         }
>
>         /* Generically handle the erroneous situation */
>         if (ret) {
> -               spi_reset_chip(dws);
> +               dw_spi_reset_chip(dws);
>                 if (dws->master->cur_msg)
>                         dws->master->cur_msg->status = ret;
>         }
> @@ -230,7 +230,7 @@ static irqreturn_t dw_spi_transfer_handler(struct dw_spi *dws)
>          */
>         dw_reader(dws);
>         if (!dws->rx_len) {
> -               spi_mask_intr(dws, 0xff);
> +               dw_spi_mask_intr(dws, 0xff);
>                 spi_finalize_current_transfer(dws->master);
>         } else if (dws->rx_len <= dw_readl(dws, DW_SPI_RXFTLR)) {
>                 dw_writel(dws, DW_SPI_RXFTLR, dws->rx_len - 1);
> @@ -241,10 +241,10 @@ static irqreturn_t dw_spi_transfer_handler(struct dw_spi *dws)
>          * disabled after the data transmission is finished so not to
>          * have the TXE IRQ flood at the final stage of the transfer.
>          */
> -       if (irq_status & SPI_INT_TXEI) {
> +       if (irq_status & DW_SPI_INT_TXEI) {
>                 dw_writer(dws);
>                 if (!dws->tx_len)
> -                       spi_mask_intr(dws, SPI_INT_TXEI);
> +                       dw_spi_mask_intr(dws, DW_SPI_INT_TXEI);
>         }
>
>         return IRQ_HANDLED;
> @@ -260,7 +260,7 @@ static irqreturn_t dw_spi_irq(int irq, void *dev_id)
>                 return IRQ_NONE;
>
>         if (!master->cur_msg) {
> -               spi_mask_intr(dws, 0xff);
> +               dw_spi_mask_intr(dws, 0xff);
>                 return IRQ_HANDLED;
>         }
>
> @@ -271,37 +271,37 @@ static u32 dw_spi_prepare_cr0(struct dw_spi *dws, struct spi_device *spi)
>  {
>         u32 cr0 = 0;
>
> -       if (!(dws->caps & DW_SPI_CAP_DWC_SSI)) {
> +       if (!(dws->caps & DW_SPI_CAP_DWC_HSSI)) {
>                 /* CTRLR0[ 5: 4] Frame Format */
> -               cr0 |= SPI_FRF_MOTO_SPI << SPI_FRF_OFFSET;
> +               cr0 |= DW_SPI_CTRLR0_FRF_MOTO_SPI << DW_PSSI_CTRLR0_FRF_OFFSET;
>
>                 /*
>                  * SPI mode (SCPOL|SCPH)
>                  * CTRLR0[ 6] Serial Clock Phase
>                  * CTRLR0[ 7] Serial Clock Polarity
>                  */
> -               cr0 |= ((spi->mode & SPI_CPOL) ? 1 : 0) << SPI_SCOL_OFFSET;
> -               cr0 |= ((spi->mode & SPI_CPHA) ? 1 : 0) << SPI_SCPH_OFFSET;
> +               cr0 |= ((spi->mode & SPI_CPOL) ? 1 : 0) << DW_PSSI_CTRLR0_SCOL_OFFSET;
> +               cr0 |= ((spi->mode & SPI_CPHA) ? 1 : 0) << DW_PSSI_CTRLR0_SCPH_OFFSET;
>
>                 /* CTRLR0[11] Shift Register Loop */
> -               cr0 |= ((spi->mode & SPI_LOOP) ? 1 : 0) << SPI_SRL_OFFSET;
> +               cr0 |= ((spi->mode & SPI_LOOP) ? 1 : 0) << DW_PSSI_CTRLR0_SRL_OFFSET;
>         } else {
>                 /* CTRLR0[ 7: 6] Frame Format */
> -               cr0 |= SPI_FRF_MOTO_SPI << DWC_SSI_CTRLR0_FRF_OFFSET;
> +               cr0 |= DW_SPI_CTRLR0_FRF_MOTO_SPI << DW_HSSI_CTRLR0_FRF_OFFSET;
>
>                 /*
>                  * SPI mode (SCPOL|SCPH)
>                  * CTRLR0[ 8] Serial Clock Phase
>                  * CTRLR0[ 9] Serial Clock Polarity
>                  */
> -               cr0 |= ((spi->mode & SPI_CPOL) ? 1 : 0) << DWC_SSI_CTRLR0_SCPOL_OFFSET;
> -               cr0 |= ((spi->mode & SPI_CPHA) ? 1 : 0) << DWC_SSI_CTRLR0_SCPH_OFFSET;
> +               cr0 |= ((spi->mode & SPI_CPOL) ? 1 : 0) << DW_HSSI_CTRLR0_SCPOL_OFFSET;
> +               cr0 |= ((spi->mode & SPI_CPHA) ? 1 : 0) << DW_HSSI_CTRLR0_SCPH_OFFSET;
>
>                 /* CTRLR0[13] Shift Register Loop */
> -               cr0 |= ((spi->mode & SPI_LOOP) ? 1 : 0) << DWC_SSI_CTRLR0_SRL_OFFSET;
> +               cr0 |= ((spi->mode & SPI_LOOP) ? 1 : 0) << DW_HSSI_CTRLR0_SRL_OFFSET;
>
>                 if (dws->caps & DW_SPI_CAP_KEEMBAY_MST)
> -                       cr0 |= DWC_SSI_CTRLR0_KEEMBAY_MST;
> +                       cr0 |= DW_HSSI_CTRLR0_KEEMBAY_MST;
>         }
>
>         return cr0;
> @@ -310,7 +310,7 @@ static u32 dw_spi_prepare_cr0(struct dw_spi *dws, struct spi_device *spi)
>  void dw_spi_update_config(struct dw_spi *dws, struct spi_device *spi,
>                           struct dw_spi_cfg *cfg)
>  {
> -       struct chip_data *chip = spi_get_ctldata(spi);
> +       struct dw_spi_chip_data *chip = spi_get_ctldata(spi);
>         u32 cr0 = chip->cr0;
>         u32 speed_hz;
>         u16 clk_div;
> @@ -318,16 +318,17 @@ void dw_spi_update_config(struct dw_spi *dws, struct spi_device *spi,
>         /* CTRLR0[ 4/3: 0] or CTRLR0[ 20: 16] Data Frame Size */
>         cr0 |= (cfg->dfs - 1) << dws->dfs_offset;
>
> -       if (!(dws->caps & DW_SPI_CAP_DWC_SSI))
> +       if (!(dws->caps & DW_SPI_CAP_DWC_HSSI))
>                 /* CTRLR0[ 9:8] Transfer Mode */
> -               cr0 |= cfg->tmode << SPI_TMOD_OFFSET;
> +               cr0 |= cfg->tmode << DW_PSSI_CTRLR0_TMOD_OFFSET;
>         else
>                 /* CTRLR0[11:10] Transfer Mode */
> -               cr0 |= cfg->tmode << DWC_SSI_CTRLR0_TMOD_OFFSET;
> +               cr0 |= cfg->tmode << DW_HSSI_CTRLR0_TMOD_OFFSET;
>
>         dw_writel(dws, DW_SPI_CTRLR0, cr0);
>
> -       if (cfg->tmode == SPI_TMOD_EPROMREAD || cfg->tmode == SPI_TMOD_RO)
> +       if (cfg->tmode == DW_SPI_CTRLR0_TMOD_EPROMREAD ||
> +           cfg->tmode == DW_SPI_CTRLR0_TMOD_RO)
>                 dw_writel(dws, DW_SPI_CTRLR1, cfg->ndf ? cfg->ndf - 1 : 0);
>
>         /* Note DW APB SSI clock divider doesn't support odd numbers */
> @@ -335,7 +336,7 @@ void dw_spi_update_config(struct dw_spi *dws, struct spi_device *spi,
>         speed_hz = dws->max_freq / clk_div;
>
>         if (dws->current_freq != speed_hz) {
> -               spi_set_clk(dws, clk_div);
> +               dw_spi_set_clk(dws, clk_div);
>                 dws->current_freq = speed_hz;
>         }
>
> @@ -363,9 +364,9 @@ static void dw_spi_irq_setup(struct dw_spi *dws)
>
>         dws->transfer_handler = dw_spi_transfer_handler;
>
> -       imask = SPI_INT_TXEI | SPI_INT_TXOI | SPI_INT_RXUI | SPI_INT_RXOI |
> -               SPI_INT_RXFI;
> -       spi_umask_intr(dws, imask);
> +       imask = DW_SPI_INT_TXEI | DW_SPI_INT_TXOI |
> +               DW_SPI_INT_RXUI | DW_SPI_INT_RXOI | DW_SPI_INT_RXFI;
> +       dw_spi_umask_intr(dws, imask);
>  }
>
>  /*
> @@ -405,11 +406,12 @@ static int dw_spi_poll_transfer(struct dw_spi *dws,
>  }
>
>  static int dw_spi_transfer_one(struct spi_controller *master,
> -               struct spi_device *spi, struct spi_transfer *transfer)
> +                              struct spi_device *spi,
> +                              struct spi_transfer *transfer)
>  {
>         struct dw_spi *dws = spi_controller_get_devdata(master);
>         struct dw_spi_cfg cfg = {
> -               .tmode = SPI_TMOD_TR,
> +               .tmode = DW_SPI_CTRLR0_TMOD_TR,
>                 .dfs = transfer->bits_per_word,
>                 .freq = transfer->speed_hz,
>         };
> @@ -425,7 +427,7 @@ static int dw_spi_transfer_one(struct spi_controller *master,
>         /* Ensure the data above is visible for all CPUs */
>         smp_mb();
>
> -       spi_enable_chip(dws, 0);
> +       dw_spi_enable_chip(dws, 0);
>
>         dw_spi_update_config(dws, spi, &cfg);
>
> @@ -436,7 +438,7 @@ static int dw_spi_transfer_one(struct spi_controller *master,
>                 dws->dma_mapped = master->cur_msg_mapped;
>
>         /* For poll mode just disable all interrupts */
> -       spi_mask_intr(dws, 0xff);
> +       dw_spi_mask_intr(dws, 0xff);
>
>         if (dws->dma_mapped) {
>                 ret = dws->dma_ops->dma_setup(dws, transfer);
> @@ -444,7 +446,7 @@ static int dw_spi_transfer_one(struct spi_controller *master,
>                         return ret;
>         }
>
> -       spi_enable_chip(dws, 1);
> +       dw_spi_enable_chip(dws, 1);
>
>         if (dws->dma_mapped)
>                 return dws->dma_ops->dma_transfer(dws, transfer);
> @@ -457,20 +459,20 @@ static int dw_spi_transfer_one(struct spi_controller *master,
>  }
>
>  static void dw_spi_handle_err(struct spi_controller *master,
> -               struct spi_message *msg)
> +                             struct spi_message *msg)
>  {
>         struct dw_spi *dws = spi_controller_get_devdata(master);
>
>         if (dws->dma_mapped)
>                 dws->dma_ops->dma_stop(dws);
>
> -       spi_reset_chip(dws);
> +       dw_spi_reset_chip(dws);
>  }
>
>  static int dw_spi_adjust_mem_op_size(struct spi_mem *mem, struct spi_mem_op *op)
>  {
>         if (op->data.dir == SPI_MEM_DATA_IN)
> -               op->data.nbytes = clamp_val(op->data.nbytes, 0, SPI_NDF_MASK + 1);
> +               op->data.nbytes = clamp_val(op->data.nbytes, 0, DW_SPI_NDF_MASK + 1);
>
>         return 0;
>  }
> @@ -498,7 +500,7 @@ static int dw_spi_init_mem_buf(struct dw_spi *dws, const struct spi_mem_op *op)
>         if (op->data.dir == SPI_MEM_DATA_OUT)
>                 len += op->data.nbytes;
>
> -       if (len <= SPI_BUF_SIZE) {
> +       if (len <= DW_SPI_BUF_SIZE) {
>                 out = dws->buf;
>         } else {
>                 out = kzalloc(len, GFP_KERNEL);
> @@ -512,9 +514,9 @@ static int dw_spi_init_mem_buf(struct dw_spi *dws, const struct spi_mem_op *op)
>          * single buffer in order to speed the data transmission up.
>          */
>         for (i = 0; i < op->cmd.nbytes; ++i)
> -               out[i] = SPI_GET_BYTE(op->cmd.opcode, op->cmd.nbytes - i - 1);
> +               out[i] = DW_SPI_GET_BYTE(op->cmd.opcode, op->cmd.nbytes - i - 1);
>         for (j = 0; j < op->addr.nbytes; ++i, ++j)
> -               out[i] = SPI_GET_BYTE(op->addr.val, op->addr.nbytes - j - 1);
> +               out[i] = DW_SPI_GET_BYTE(op->addr.val, op->addr.nbytes - j - 1);
>         for (j = 0; j < op->dummy.nbytes; ++i, ++j)
>                 out[i] = 0x0;
>
> @@ -587,7 +589,7 @@ static int dw_spi_write_then_read(struct dw_spi *dws, struct spi_device *spi)
>                 entries = readl_relaxed(dws->regs + DW_SPI_RXFLR);
>                 if (!entries) {
>                         sts = readl_relaxed(dws->regs + DW_SPI_RISR);
> -                       if (sts & SPI_INT_RXOI) {
> +                       if (sts & DW_SPI_INT_RXOI) {
>                                 dev_err(&dws->master->dev, "FIFO overflow on Rx\n");
>                                 return -EIO;
>                         }
> @@ -603,12 +605,12 @@ static int dw_spi_write_then_read(struct dw_spi *dws, struct spi_device *spi)
>
>  static inline bool dw_spi_ctlr_busy(struct dw_spi *dws)
>  {
> -       return dw_readl(dws, DW_SPI_SR) & SR_BUSY;
> +       return dw_readl(dws, DW_SPI_SR) & DW_SPI_SR_BUSY;
>  }
>
>  static int dw_spi_wait_mem_op_done(struct dw_spi *dws)
>  {
> -       int retry = SPI_WAIT_RETRIES;
> +       int retry = DW_SPI_WAIT_RETRIES;
>         struct spi_delay delay;
>         unsigned long ns, us;
>         u32 nents;
> @@ -638,9 +640,9 @@ static int dw_spi_wait_mem_op_done(struct dw_spi *dws)
>
>  static void dw_spi_stop_mem_op(struct dw_spi *dws, struct spi_device *spi)
>  {
> -       spi_enable_chip(dws, 0);
> +       dw_spi_enable_chip(dws, 0);
>         dw_spi_set_cs(spi, true);
> -       spi_enable_chip(dws, 1);
> +       dw_spi_enable_chip(dws, 1);
>  }
>
>  /*
> @@ -673,19 +675,19 @@ static int dw_spi_exec_mem_op(struct spi_mem *mem, const struct spi_mem_op *op)
>         cfg.dfs = 8;
>         cfg.freq = clamp(mem->spi->max_speed_hz, 0U, dws->max_mem_freq);
>         if (op->data.dir == SPI_MEM_DATA_IN) {
> -               cfg.tmode = SPI_TMOD_EPROMREAD;
> +               cfg.tmode = DW_SPI_CTRLR0_TMOD_EPROMREAD;
>                 cfg.ndf = op->data.nbytes;
>         } else {
> -               cfg.tmode = SPI_TMOD_TO;
> +               cfg.tmode = DW_SPI_CTRLR0_TMOD_TO;
>         }
>
> -       spi_enable_chip(dws, 0);
> +       dw_spi_enable_chip(dws, 0);
>
>         dw_spi_update_config(dws, mem->spi, &cfg);
>
> -       spi_mask_intr(dws, 0xff);
> +       dw_spi_mask_intr(dws, 0xff);
>
> -       spi_enable_chip(dws, 1);
> +       dw_spi_enable_chip(dws, 1);
>
>         /*
>          * DW APB SSI controller has very nasty peculiarities. First originally
> @@ -768,7 +770,7 @@ static void dw_spi_init_mem_ops(struct dw_spi *dws)
>  static int dw_spi_setup(struct spi_device *spi)
>  {
>         struct dw_spi *dws = spi_controller_get_devdata(spi->controller);
> -       struct chip_data *chip;
> +       struct dw_spi_chip_data *chip;
>
>         /* Only alloc on first setup */
>         chip = spi_get_ctldata(spi);
> @@ -776,7 +778,7 @@ static int dw_spi_setup(struct spi_device *spi)
>                 struct dw_spi *dws = spi_controller_get_devdata(spi->controller);
>                 u32 rx_sample_dly_ns;
>
> -               chip = kzalloc(sizeof(struct chip_data), GFP_KERNEL);
> +               chip = kzalloc(sizeof(*chip), GFP_KERNEL);
>                 if (!chip)
>                         return -ENOMEM;
>                 spi_set_ctldata(spi, chip);
> @@ -803,16 +805,16 @@ static int dw_spi_setup(struct spi_device *spi)
>
>  static void dw_spi_cleanup(struct spi_device *spi)
>  {
> -       struct chip_data *chip = spi_get_ctldata(spi);
> +       struct dw_spi_chip_data *chip = spi_get_ctldata(spi);
>
>         kfree(chip);
>         spi_set_ctldata(spi, NULL);
>  }
>
>  /* Restart the controller, disable all interrupts, clean rx fifo */
> -static void spi_hw_init(struct device *dev, struct dw_spi *dws)
> +static void dw_spi_hw_init(struct device *dev, struct dw_spi *dws)
>  {
> -       spi_reset_chip(dws);
> +       dw_spi_reset_chip(dws);
>
>         /*
>          * Try to detect the FIFO depth if not set by interface driver,
> @@ -837,18 +839,18 @@ static void spi_hw_init(struct device *dev, struct dw_spi *dws)
>          * writability. Note DWC SSI controller also has the extended DFS, but
>          * with zero offset.
>          */
> -       if (!(dws->caps & DW_SPI_CAP_DWC_SSI)) {
> +       if (!(dws->caps & DW_SPI_CAP_DWC_HSSI)) {
>                 u32 cr0, tmp = dw_readl(dws, DW_SPI_CTRLR0);
>
> -               spi_enable_chip(dws, 0);
> +               dw_spi_enable_chip(dws, 0);
>                 dw_writel(dws, DW_SPI_CTRLR0, 0xffffffff);
>                 cr0 = dw_readl(dws, DW_SPI_CTRLR0);
>                 dw_writel(dws, DW_SPI_CTRLR0, tmp);
> -               spi_enable_chip(dws, 1);
> +               dw_spi_enable_chip(dws, 1);
>
> -               if (!(cr0 & SPI_DFS_MASK)) {
> +               if (!(cr0 & DW_PSSI_CTRLR0_DFS_MASK)) {
>                         dws->caps |= DW_SPI_CAP_DFS32;
> -                       dws->dfs_offset = SPI_DFS32_OFFSET;
> +                       dws->dfs_offset = DW_PSSI_CTRLR0_DFS32_OFFSET;
>                         dev_dbg(dev, "Detected 32-bits max data frame size\n");
>                 }
>         } else {
> @@ -878,7 +880,7 @@ int dw_spi_add_host(struct device *dev, struct dw_spi *dws)
>         spi_controller_set_devdata(master, dws);
>
>         /* Basic HW init */
> -       spi_hw_init(dev, dws);
> +       dw_spi_hw_init(dev, dws);
>
>         ret = request_irq(dws->irq, dw_spi_irq, IRQF_SHARED, dev_name(dev),
>                           master);
> @@ -939,7 +941,7 @@ int dw_spi_add_host(struct device *dev, struct dw_spi *dws)
>  err_dma_exit:
>         if (dws->dma_ops && dws->dma_ops->dma_exit)
>                 dws->dma_ops->dma_exit(dws);
> -       spi_enable_chip(dws, 0);
> +       dw_spi_enable_chip(dws, 0);
>         free_irq(dws->irq, master);
>  err_free_master:
>         spi_controller_put(master);
> @@ -956,7 +958,7 @@ void dw_spi_remove_host(struct dw_spi *dws)
>         if (dws->dma_ops && dws->dma_ops->dma_exit)
>                 dws->dma_ops->dma_exit(dws);
>
> -       spi_shutdown_chip(dws);
> +       dw_spi_shutdown_chip(dws);
>
>         free_irq(dws->irq, dws->master);
>  }
> @@ -970,14 +972,14 @@ int dw_spi_suspend_host(struct dw_spi *dws)
>         if (ret)
>                 return ret;
>
> -       spi_shutdown_chip(dws);
> +       dw_spi_shutdown_chip(dws);
>         return 0;
>  }
>  EXPORT_SYMBOL_GPL(dw_spi_suspend_host);
>
>  int dw_spi_resume_host(struct dw_spi *dws)
>  {
> -       spi_hw_init(&dws->master->dev, dws);
> +       dw_spi_hw_init(&dws->master->dev, dws);
>         return spi_controller_resume(dws->master);
>  }
>  EXPORT_SYMBOL_GPL(dw_spi_resume_host);
> diff --git a/drivers/spi/spi-dw-dma.c b/drivers/spi/spi-dw-dma.c
> index a09831c62192..fd6a2154d2ce 100644
> --- a/drivers/spi/spi-dw-dma.c
> +++ b/drivers/spi/spi-dw-dma.c
> @@ -17,10 +17,10 @@
>
>  #include "spi-dw.h"
>
> -#define RX_BUSY                0
> -#define RX_BURST_LEVEL 16
> -#define TX_BUSY                1
> -#define TX_BURST_LEVEL 16
> +#define DW_SPI_RX_BUSY         0
> +#define DW_SPI_RX_BURST_LEVEL  16
> +#define DW_SPI_TX_BUSY         1
> +#define DW_SPI_TX_BURST_LEVEL  16
>
>  static bool dw_spi_dma_chan_filter(struct dma_chan *chan, void *param)
>  {
> @@ -45,7 +45,7 @@ static void dw_spi_dma_maxburst_init(struct dw_spi *dws)
>         if (!ret && caps.max_burst)
>                 max_burst = caps.max_burst;
>         else
> -               max_burst = RX_BURST_LEVEL;
> +               max_burst = DW_SPI_RX_BURST_LEVEL;
>
>         dws->rxburst = min(max_burst, def_burst);
>         dw_writel(dws, DW_SPI_DMARDLR, dws->rxburst - 1);
> @@ -54,7 +54,7 @@ static void dw_spi_dma_maxburst_init(struct dw_spi *dws)
>         if (!ret && caps.max_burst)
>                 max_burst = caps.max_burst;
>         else
> -               max_burst = TX_BURST_LEVEL;
> +               max_burst = DW_SPI_TX_BURST_LEVEL;
>
>         /*
>          * Having a Rx DMA channel serviced with higher priority than a Tx DMA
> @@ -226,13 +226,13 @@ static int dw_spi_dma_wait(struct dw_spi *dws, unsigned int len, u32 speed)
>
>  static inline bool dw_spi_dma_tx_busy(struct dw_spi *dws)
>  {
> -       return !(dw_readl(dws, DW_SPI_SR) & SR_TF_EMPT);
> +       return !(dw_readl(dws, DW_SPI_SR) & DW_SPI_SR_TF_EMPT);
>  }
>
>  static int dw_spi_dma_wait_tx_done(struct dw_spi *dws,
>                                    struct spi_transfer *xfer)
>  {
> -       int retry = SPI_WAIT_RETRIES;
> +       int retry = DW_SPI_WAIT_RETRIES;
>         struct spi_delay delay;
>         u32 nents;
>
> @@ -259,8 +259,8 @@ static void dw_spi_dma_tx_done(void *arg)
>  {
>         struct dw_spi *dws = arg;
>
> -       clear_bit(TX_BUSY, &dws->dma_chan_busy);
> -       if (test_bit(RX_BUSY, &dws->dma_chan_busy))
> +       clear_bit(DW_SPI_TX_BUSY, &dws->dma_chan_busy);
> +       if (test_bit(DW_SPI_RX_BUSY, &dws->dma_chan_busy))
>                 return;
>
>         complete(&dws->dma_completion);
> @@ -304,19 +304,19 @@ static int dw_spi_dma_submit_tx(struct dw_spi *dws, struct scatterlist *sgl,
>                 return ret;
>         }
>
> -       set_bit(TX_BUSY, &dws->dma_chan_busy);
> +       set_bit(DW_SPI_TX_BUSY, &dws->dma_chan_busy);
>
>         return 0;
>  }
>
>  static inline bool dw_spi_dma_rx_busy(struct dw_spi *dws)
>  {
> -       return !!(dw_readl(dws, DW_SPI_SR) & SR_RF_NOT_EMPT);
> +       return !!(dw_readl(dws, DW_SPI_SR) & DW_SPI_SR_RF_NOT_EMPT);
>  }
>
>  static int dw_spi_dma_wait_rx_done(struct dw_spi *dws)
>  {
> -       int retry = SPI_WAIT_RETRIES;
> +       int retry = DW_SPI_WAIT_RETRIES;
>         struct spi_delay delay;
>         unsigned long ns, us;
>         u32 nents;
> @@ -360,8 +360,8 @@ static void dw_spi_dma_rx_done(void *arg)
>  {
>         struct dw_spi *dws = arg;
>
> -       clear_bit(RX_BUSY, &dws->dma_chan_busy);
> -       if (test_bit(TX_BUSY, &dws->dma_chan_busy))
> +       clear_bit(DW_SPI_RX_BUSY, &dws->dma_chan_busy);
> +       if (test_bit(DW_SPI_TX_BUSY, &dws->dma_chan_busy))
>                 return;
>
>         complete(&dws->dma_completion);
> @@ -405,7 +405,7 @@ static int dw_spi_dma_submit_rx(struct dw_spi *dws, struct scatterlist *sgl,
>                 return ret;
>         }
>
> -       set_bit(RX_BUSY, &dws->dma_chan_busy);
> +       set_bit(DW_SPI_RX_BUSY, &dws->dma_chan_busy);
>
>         return 0;
>  }
> @@ -430,16 +430,16 @@ static int dw_spi_dma_setup(struct dw_spi *dws, struct spi_transfer *xfer)
>         }
>
>         /* Set the DMA handshaking interface */
> -       dma_ctrl = SPI_DMA_TDMAE;
> +       dma_ctrl = DW_SPI_DMACR_TDMAE;
>         if (xfer->rx_buf)
> -               dma_ctrl |= SPI_DMA_RDMAE;
> +               dma_ctrl |= DW_SPI_DMACR_RDMAE;
>         dw_writel(dws, DW_SPI_DMACR, dma_ctrl);
>
>         /* Set the interrupt mask */
> -       imr = SPI_INT_TXOI;
> +       imr = DW_SPI_INT_TXOI;
>         if (xfer->rx_buf)
> -               imr |= SPI_INT_RXUI | SPI_INT_RXOI;
> -       spi_umask_intr(dws, imr);
> +               imr |= DW_SPI_INT_RXUI | DW_SPI_INT_RXOI;
> +       dw_spi_umask_intr(dws, imr);
>
>         reinit_completion(&dws->dma_completion);
>
> @@ -615,13 +615,13 @@ static int dw_spi_dma_transfer(struct dw_spi *dws, struct spi_transfer *xfer)
>
>  static void dw_spi_dma_stop(struct dw_spi *dws)
>  {
> -       if (test_bit(TX_BUSY, &dws->dma_chan_busy)) {
> +       if (test_bit(DW_SPI_TX_BUSY, &dws->dma_chan_busy)) {
>                 dmaengine_terminate_sync(dws->txchan);
> -               clear_bit(TX_BUSY, &dws->dma_chan_busy);
> +               clear_bit(DW_SPI_TX_BUSY, &dws->dma_chan_busy);
>         }
> -       if (test_bit(RX_BUSY, &dws->dma_chan_busy)) {
> +       if (test_bit(DW_SPI_RX_BUSY, &dws->dma_chan_busy)) {
>                 dmaengine_terminate_sync(dws->rxchan);
> -               clear_bit(RX_BUSY, &dws->dma_chan_busy);
> +               clear_bit(DW_SPI_RX_BUSY, &dws->dma_chan_busy);
>         }
>  }
>
> diff --git a/drivers/spi/spi-dw-mmio.c b/drivers/spi/spi-dw-mmio.c
> index 17c06039a74d..435c91aecbca 100644
> --- a/drivers/spi/spi-dw-mmio.c
> +++ b/drivers/spi/spi-dw-mmio.c
> @@ -196,18 +196,18 @@ static int dw_spi_alpine_init(struct platform_device *pdev,
>         return 0;
>  }
>
> -static int dw_spi_dw_apb_init(struct platform_device *pdev,
> -                             struct dw_spi_mmio *dwsmmio)
> +static int dw_spi_assi_init(struct platform_device *pdev,
> +                           struct dw_spi_mmio *dwsmmio)
>  {
>         dw_spi_dma_setup_generic(&dwsmmio->dws);
>
>         return 0;
>  }
>
> -static int dw_spi_dwc_ssi_init(struct platform_device *pdev,
> -                              struct dw_spi_mmio *dwsmmio)
> +static int dw_spi_hssi_init(struct platform_device *pdev,
> +                           struct dw_spi_mmio *dwsmmio)
>  {
> -       dwsmmio->dws.caps = DW_SPI_CAP_DWC_SSI;
> +       dwsmmio->dws.caps = DW_SPI_CAP_DWC_HSSI;
>
>         dw_spi_dma_setup_generic(&dwsmmio->dws);
>
> @@ -217,7 +217,7 @@ static int dw_spi_dwc_ssi_init(struct platform_device *pdev,
>  static int dw_spi_keembay_init(struct platform_device *pdev,
>                                struct dw_spi_mmio *dwsmmio)
>  {
> -       dwsmmio->dws.caps = DW_SPI_CAP_KEEMBAY_MST | DW_SPI_CAP_DWC_SSI;
> +       dwsmmio->dws.caps = DW_SPI_CAP_KEEMBAY_MST | DW_SPI_CAP_DWC_HSSI;
>
>         return 0;
>  }
> @@ -342,12 +342,12 @@ static int dw_spi_mmio_remove(struct platform_device *pdev)
>  }
>
>  static const struct of_device_id dw_spi_mmio_of_match[] = {
> -       { .compatible = "snps,dw-apb-ssi", .data = dw_spi_dw_apb_init},
> +       { .compatible = "snps,dw-apb-ssi", .data = dw_spi_assi_init},
>         { .compatible = "mscc,ocelot-spi", .data = dw_spi_mscc_ocelot_init},
>         { .compatible = "mscc,jaguar2-spi", .data = dw_spi_mscc_jaguar2_init},
>         { .compatible = "amazon,alpine-dw-apb-ssi", .data = dw_spi_alpine_init},
> -       { .compatible = "renesas,rzn1-spi", .data = dw_spi_dw_apb_init},
> -       { .compatible = "snps,dwc-ssi-1.01a", .data = dw_spi_dwc_ssi_init},
> +       { .compatible = "renesas,rzn1-spi", .data = dw_spi_assi_init},
> +       { .compatible = "snps,dwc-ssi-1.01a", .data = dw_spi_hssi_init},
>         { .compatible = "intel,keembay-ssi", .data = dw_spi_keembay_init},
>         { .compatible = "microchip,sparx5-spi", dw_spi_mscc_sparx5_init},
>         { .compatible = "canaan,k210-spi", dw_spi_canaan_k210_init},
> @@ -357,7 +357,7 @@ MODULE_DEVICE_TABLE(of, dw_spi_mmio_of_match);
>
>  #ifdef CONFIG_ACPI
>  static const struct acpi_device_id dw_spi_mmio_acpi_match[] = {
> -       {"HISI0173", (kernel_ulong_t)dw_spi_dw_apb_init},
> +       {"HISI0173", (kernel_ulong_t)dw_spi_assi_init},
>         {},
>  };
>  MODULE_DEVICE_TABLE(acpi, dw_spi_mmio_acpi_match);
> diff --git a/drivers/spi/spi-dw-pci.c b/drivers/spi/spi-dw-pci.c
> index 8a91cd58102f..e4a239bc3d36 100644
> --- a/drivers/spi/spi-dw-pci.c
> +++ b/drivers/spi/spi-dw-pci.c
> @@ -24,14 +24,14 @@
>  #define CLK_SPI_CDIV_MASK      0x00000e00
>  #define CLK_SPI_DISABLE_OFFSET 8
>
> -struct spi_pci_desc {
> +struct dw_spi_pci_desc {
>         int     (*setup)(struct dw_spi *);
>         u16     num_cs;
>         u16     bus_num;
>         u32     max_freq;
>  };
>
> -static int spi_mid_init(struct dw_spi *dws)
> +static int dw_spi_pci_mid_init(struct dw_spi *dws)
>  {
>         void __iomem *clk_reg;
>         u32 clk_cdiv;
> @@ -53,36 +53,36 @@ static int spi_mid_init(struct dw_spi *dws)
>         return 0;
>  }
>
> -static int spi_generic_init(struct dw_spi *dws)
> +static int dw_spi_pci_generic_init(struct dw_spi *dws)
>  {
>         dw_spi_dma_setup_generic(dws);
>
>         return 0;
>  }
>
> -static struct spi_pci_desc spi_pci_mid_desc_1 = {
> -       .setup = spi_mid_init,
> +static struct dw_spi_pci_desc dw_spi_pci_mid_desc_1 = {
> +       .setup = dw_spi_pci_mid_init,
>         .num_cs = 5,
>         .bus_num = 0,
>  };
>
> -static struct spi_pci_desc spi_pci_mid_desc_2 = {
> -       .setup = spi_mid_init,
> +static struct dw_spi_pci_desc dw_spi_pci_mid_desc_2 = {
> +       .setup = dw_spi_pci_mid_init,
>         .num_cs = 2,
>         .bus_num = 1,
>  };
>
> -static struct spi_pci_desc spi_pci_ehl_desc = {
> -       .setup = spi_generic_init,
> +static struct dw_spi_pci_desc dw_spi_pci_ehl_desc = {
> +       .setup = dw_spi_pci_generic_init,
>         .num_cs = 2,
>         .bus_num = -1,
>         .max_freq = 100000000,
>  };
>
> -static int spi_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
> +static int dw_spi_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
>  {
> +       struct dw_spi_pci_desc *desc = (struct dw_spi_pci_desc *)ent->driver_data;
>         struct dw_spi *dws;
> -       struct spi_pci_desc *desc = (struct spi_pci_desc *)ent->driver_data;
>         int pci_bar = 0;
>         int ret;
>
> @@ -150,7 +150,7 @@ static int spi_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
>         return ret;
>  }
>
> -static void spi_pci_remove(struct pci_dev *pdev)
> +static void dw_spi_pci_remove(struct pci_dev *pdev)
>  {
>         struct dw_spi *dws = pci_get_drvdata(pdev);
>
> @@ -162,14 +162,14 @@ static void spi_pci_remove(struct pci_dev *pdev)
>  }
>
>  #ifdef CONFIG_PM_SLEEP
> -static int spi_suspend(struct device *dev)
> +static int dw_spi_pci_suspend(struct device *dev)
>  {
>         struct dw_spi *dws = dev_get_drvdata(dev);
>
>         return dw_spi_suspend_host(dws);
>  }
>
> -static int spi_resume(struct device *dev)
> +static int dw_spi_pci_resume(struct device *dev)
>  {
>         struct dw_spi *dws = dev_get_drvdata(dev);
>
> @@ -177,38 +177,37 @@ static int spi_resume(struct device *dev)
>  }
>  #endif
>
> -static SIMPLE_DEV_PM_OPS(dw_spi_pm_ops, spi_suspend, spi_resume);
> +static SIMPLE_DEV_PM_OPS(dw_spi_pci_pm_ops, dw_spi_pci_suspend, dw_spi_pci_resume);
>
> -static const struct pci_device_id pci_ids[] = {
> +static const struct pci_device_id dw_spi_pci_ids[] = {
>         /* Intel MID platform SPI controller 0 */
>         /*
>          * The access to the device 8086:0801 is disabled by HW, since it's
>          * exclusively used by SCU to communicate with MSIC.
>          */
>         /* Intel MID platform SPI controller 1 */
> -       { PCI_VDEVICE(INTEL, 0x0800), (kernel_ulong_t)&spi_pci_mid_desc_1},
> +       { PCI_VDEVICE(INTEL, 0x0800), (kernel_ulong_t)&dw_spi_pci_mid_desc_1},
>         /* Intel MID platform SPI controller 2 */
> -       { PCI_VDEVICE(INTEL, 0x0812), (kernel_ulong_t)&spi_pci_mid_desc_2},
> +       { PCI_VDEVICE(INTEL, 0x0812), (kernel_ulong_t)&dw_spi_pci_mid_desc_2},
>         /* Intel Elkhart Lake PSE SPI controllers */
> -       { PCI_VDEVICE(INTEL, 0x4b84), (kernel_ulong_t)&spi_pci_ehl_desc},
> -       { PCI_VDEVICE(INTEL, 0x4b85), (kernel_ulong_t)&spi_pci_ehl_desc},
> -       { PCI_VDEVICE(INTEL, 0x4b86), (kernel_ulong_t)&spi_pci_ehl_desc},
> -       { PCI_VDEVICE(INTEL, 0x4b87), (kernel_ulong_t)&spi_pci_ehl_desc},
> +       { PCI_VDEVICE(INTEL, 0x4b84), (kernel_ulong_t)&dw_spi_pci_ehl_desc},
> +       { PCI_VDEVICE(INTEL, 0x4b85), (kernel_ulong_t)&dw_spi_pci_ehl_desc},
> +       { PCI_VDEVICE(INTEL, 0x4b86), (kernel_ulong_t)&dw_spi_pci_ehl_desc},
> +       { PCI_VDEVICE(INTEL, 0x4b87), (kernel_ulong_t)&dw_spi_pci_ehl_desc},
>         {},
>  };
> -MODULE_DEVICE_TABLE(pci, pci_ids);
> +MODULE_DEVICE_TABLE(pci, dw_spi_pci_ids);
>
> -static struct pci_driver dw_spi_driver = {
> +static struct pci_driver dw_spi_pci_driver = {
>         .name =         DRIVER_NAME,
> -       .id_table =     pci_ids,
> -       .probe =        spi_pci_probe,
> -       .remove =       spi_pci_remove,
> +       .id_table =     dw_spi_pci_ids,
> +       .probe =        dw_spi_pci_probe,
> +       .remove =       dw_spi_pci_remove,
>         .driver         = {
> -               .pm     = &dw_spi_pm_ops,
> +               .pm     = &dw_spi_pci_pm_ops,
>         },
>  };
> -
> -module_pci_driver(dw_spi_driver);
> +module_pci_driver(dw_spi_pci_driver);
>
>  MODULE_AUTHOR("Feng Tang <feng.tang@xxxxxxxxx>");
>  MODULE_DESCRIPTION("PCI interface driver for DW SPI Core");
> diff --git a/drivers/spi/spi-dw.h b/drivers/spi/spi-dw.h
> index 467c342bfe56..893b78c43a50 100644
> --- a/drivers/spi/spi-dw.h
> +++ b/drivers/spi/spi-dw.h
> @@ -1,6 +1,6 @@
>  /* SPDX-License-Identifier: GPL-2.0 */
> -#ifndef DW_SPI_HEADER_H
> -#define DW_SPI_HEADER_H
> +#ifndef __SPI_DW_H__
> +#define __SPI_DW_H__
>
>  #include <linux/bits.h>
>  #include <linux/completion.h>
> @@ -11,7 +11,7 @@
>  #include <linux/spi/spi-mem.h>
>  #include <linux/bitfield.h>
>
> -/* Register offsets */
> +/* Register offsets (Generic for both DWC APB SSI and DWC SSI IP-cores) */
>  #define DW_SPI_CTRLR0                  0x00
>  #define DW_SPI_CTRLR1                  0x04
>  #define DW_SPI_SSIENR                  0x08
> @@ -40,84 +40,85 @@
>  #define DW_SPI_RX_SAMPLE_DLY           0xf0
>  #define DW_SPI_CS_OVERRIDE             0xf4
>
> -/* Bit fields in CTRLR0 */
> -#define SPI_DFS_OFFSET                 0
> -#define SPI_DFS_MASK                   GENMASK(3, 0)
> -#define SPI_DFS32_OFFSET               16
> -
> -#define SPI_FRF_OFFSET                 4
> -#define SPI_FRF_MOTO_SPI               0x0
> -#define SPI_FRF_TI_SSP                 0x1
> -#define SPI_FRF_NS_MICROWIRE           0x2
> -#define SPI_FRF_RESV                   0x3
> -
> -#define SPI_MODE_OFFSET                        6
> -#define SPI_SCPH_OFFSET                        6
> -#define SPI_SCOL_OFFSET                        7
> -
> -#define SPI_TMOD_OFFSET                        8
> -#define SPI_TMOD_MASK                  (0x3 << SPI_TMOD_OFFSET)
> -#define        SPI_TMOD_TR                     0x0             /* xmit & recv */
> -#define SPI_TMOD_TO                    0x1             /* xmit only */
> -#define SPI_TMOD_RO                    0x2             /* recv only */
> -#define SPI_TMOD_EPROMREAD             0x3             /* eeprom read mode */
> -
> -#define SPI_SLVOE_OFFSET               10
> -#define SPI_SRL_OFFSET                 11
> -#define SPI_CFS_OFFSET                 12
> -
> -/* Bit fields in CTRLR0 based on DWC_ssi_databook.pdf v1.01a */
> -#define DWC_SSI_CTRLR0_SRL_OFFSET      13
> -#define DWC_SSI_CTRLR0_TMOD_OFFSET     10
> -#define DWC_SSI_CTRLR0_TMOD_MASK       GENMASK(11, 10)
> -#define DWC_SSI_CTRLR0_SCPOL_OFFSET    9
> -#define DWC_SSI_CTRLR0_SCPH_OFFSET     8
> -#define DWC_SSI_CTRLR0_FRF_OFFSET      6
> -#define DWC_SSI_CTRLR0_DFS_OFFSET      0
> +/* Bit fields in CTRLR0 (DWC APB SSI) */
> +#define DW_PSSI_CTRLR0_DFS_OFFSET              0
> +#define DW_PSSI_CTRLR0_DFS_MASK                        GENMASK(3, 0)
> +#define DW_PSSI_CTRLR0_DFS32_OFFSET            16
> +
> +#define DW_PSSI_CTRLR0_FRF_OFFSET              4
> +#define DW_SPI_CTRLR0_FRF_MOTO_SPI             0x0
> +#define DW_SPI_CTRLR0_FRF_TI_SSP               0x1
> +#define DW_SPI_CTRLR0_FRF_NS_MICROWIRE         0x2
> +#define DW_SPI_CTRLR0_FRF_RESV                 0x3
> +
> +#define DW_PSSI_CTRLR0_MODE_OFFSET             6
> +#define DW_PSSI_CTRLR0_SCPH_OFFSET             6
> +#define DW_PSSI_CTRLR0_SCOL_OFFSET             7
> +
> +#define DW_PSSI_CTRLR0_TMOD_OFFSET             8
> +#define DW_PSSI_CTRLR0_TMOD_MASK               (0x3 << DW_PSSI_CTRLR0_TMOD_OFFSET)
> +#define DW_SPI_CTRLR0_TMOD_TR                  0x0     /* xmit & recv */
> +#define DW_SPI_CTRLR0_TMOD_TO                  0x1     /* xmit only */
> +#define DW_SPI_CTRLR0_TMOD_RO                  0x2     /* recv only */
> +#define DW_SPI_CTRLR0_TMOD_EPROMREAD           0x3     /* eeprom read mode */
> +
> +#define DW_PSSI_CTRLR0_SLVOE_OFFSET            10
> +#define DW_PSSI_CTRLR0_SRL_OFFSET              11
> +#define DW_PSSI_CTRLR0_CFS_OFFSET              12
> +
> +/* Bit fields in CTRLR0 (DWC SSI with AHB interface) */
> +#define DW_HSSI_CTRLR0_SRL_OFFSET              13
> +#define DW_HSSI_CTRLR0_TMOD_OFFSET             10
> +#define DW_HSSI_CTRLR0_TMOD_MASK               GENMASK(11, 10)
> +#define DW_HSSI_CTRLR0_SCPOL_OFFSET            9
> +#define DW_HSSI_CTRLR0_SCPH_OFFSET             8
> +#define DW_HSSI_CTRLR0_FRF_OFFSET              6
> +#define DW_HSSI_CTRLR0_DFS_OFFSET              0
>
>  /*
>   * For Keem Bay, CTRLR0[31] is used to select controller mode.
>   * 0: SSI is slave
>   * 1: SSI is master
>   */
> -#define DWC_SSI_CTRLR0_KEEMBAY_MST     BIT(31)
> +#define DW_HSSI_CTRLR0_KEEMBAY_MST             BIT(31)
>
>  /* Bit fields in CTRLR1 */
> -#define SPI_NDF_MASK                   GENMASK(15, 0)
> +#define DW_SPI_NDF_MASK                                GENMASK(15, 0)
>
>  /* Bit fields in SR, 7 bits */
> -#define SR_MASK                                0x7f            /* cover 7 bits */
> -#define SR_BUSY                                (1 << 0)
> -#define SR_TF_NOT_FULL                 (1 << 1)
> -#define SR_TF_EMPT                     (1 << 2)
> -#define SR_RF_NOT_EMPT                 (1 << 3)
> -#define SR_RF_FULL                     (1 << 4)
> -#define SR_TX_ERR                      (1 << 5)
> -#define SR_DCOL                                (1 << 6)
> +#define DW_SPI_SR_MASK                         0x7f    /* cover 7 bits */
> +#define DW_SPI_SR_BUSY                         (1 << 0)
> +#define DW_SPI_SR_TF_NOT_FULL                  (1 << 1)
> +#define DW_SPI_SR_TF_EMPT                      (1 << 2)
> +#define DW_SPI_SR_RF_NOT_EMPT                  (1 << 3)
> +#define DW_SPI_SR_RF_FULL                      (1 << 4)
> +#define DW_SPI_SR_TX_ERR                       (1 << 5)
> +#define DW_SPI_SR_DCOL                         (1 << 6)
>
>  /* Bit fields in ISR, IMR, RISR, 7 bits */
> -#define SPI_INT_TXEI                   (1 << 0)
> -#define SPI_INT_TXOI                   (1 << 1)
> -#define SPI_INT_RXUI                   (1 << 2)
> -#define SPI_INT_RXOI                   (1 << 3)
> -#define SPI_INT_RXFI                   (1 << 4)
> -#define SPI_INT_MSTI                   (1 << 5)
> +#define DW_SPI_INT_TXEI                                (1 << 0)
> +#define DW_SPI_INT_TXOI                                (1 << 1)
> +#define DW_SPI_INT_RXUI                                (1 << 2)
> +#define DW_SPI_INT_RXOI                                (1 << 3)
> +#define DW_SPI_INT_RXFI                                (1 << 4)
> +#define DW_SPI_INT_MSTI                                (1 << 5)
>
>  /* Bit fields in DMACR */
> -#define SPI_DMA_RDMAE                  (1 << 0)
> -#define SPI_DMA_TDMAE                  (1 << 1)
> +#define DW_SPI_DMACR_RDMAE                     (1 << 0)
> +#define DW_SPI_DMACR_TDMAE                     (1 << 1)
>
> -#define SPI_WAIT_RETRIES               5
> -#define SPI_BUF_SIZE \
> +/* Mem/DMA operations helpers */
> +#define DW_SPI_WAIT_RETRIES                    5
> +#define DW_SPI_BUF_SIZE \
>         (sizeof_field(struct spi_mem_op, cmd.opcode) + \
>          sizeof_field(struct spi_mem_op, addr.val) + 256)
> -#define SPI_GET_BYTE(_val, _idx) \
> +#define DW_SPI_GET_BYTE(_val, _idx) \
>         ((_val) >> (BITS_PER_BYTE * (_idx)) & 0xff)
>
>  /* DW SPI capabilities */
>  #define DW_SPI_CAP_CS_OVERRIDE         BIT(0)
>  #define DW_SPI_CAP_KEEMBAY_MST         BIT(1)
> -#define DW_SPI_CAP_DWC_SSI             BIT(2)
> +#define DW_SPI_CAP_DWC_HSSI            BIT(2)
>  #define DW_SPI_CAP_DFS32               BIT(3)
>
>  /* Slave spi_transfer/spi_mem_op related */
> @@ -162,7 +163,7 @@ struct dw_spi {
>         unsigned int            tx_len;
>         void                    *rx;
>         unsigned int            rx_len;
> -       u8                      buf[SPI_BUF_SIZE];
> +       u8                      buf[DW_SPI_BUF_SIZE];
>         int                     dma_mapped;
>         u8                      n_bytes;        /* current is a 1/2 bytes op */
>         irqreturn_t             (*transfer_handler)(struct dw_spi *dws);
> @@ -224,18 +225,18 @@ static inline void dw_write_io_reg(struct dw_spi *dws, u32 offset, u32 val)
>         }
>  }
>
> -static inline void spi_enable_chip(struct dw_spi *dws, int enable)
> +static inline void dw_spi_enable_chip(struct dw_spi *dws, int enable)
>  {
>         dw_writel(dws, DW_SPI_SSIENR, (enable ? 1 : 0));
>  }
>
> -static inline void spi_set_clk(struct dw_spi *dws, u16 div)
> +static inline void dw_spi_set_clk(struct dw_spi *dws, u16 div)
>  {
>         dw_writel(dws, DW_SPI_BAUDR, div);
>  }
>
>  /* Disable IRQ bits */
> -static inline void spi_mask_intr(struct dw_spi *dws, u32 mask)
> +static inline void dw_spi_mask_intr(struct dw_spi *dws, u32 mask)
>  {
>         u32 new_mask;
>
> @@ -244,7 +245,7 @@ static inline void spi_mask_intr(struct dw_spi *dws, u32 mask)
>  }
>
>  /* Enable IRQ bits */
> -static inline void spi_umask_intr(struct dw_spi *dws, u32 mask)
> +static inline void dw_spi_umask_intr(struct dw_spi *dws, u32 mask)
>  {
>         u32 new_mask;
>
> @@ -257,19 +258,19 @@ static inline void spi_umask_intr(struct dw_spi *dws, u32 mask)
>   * and CS, then re-enables the controller back. Transmit and receive FIFO
>   * buffers are cleared when the device is disabled.
>   */
> -static inline void spi_reset_chip(struct dw_spi *dws)
> +static inline void dw_spi_reset_chip(struct dw_spi *dws)
>  {
> -       spi_enable_chip(dws, 0);
> -       spi_mask_intr(dws, 0xff);
> +       dw_spi_enable_chip(dws, 0);
> +       dw_spi_mask_intr(dws, 0xff);
>         dw_readl(dws, DW_SPI_ICR);
>         dw_writel(dws, DW_SPI_SER, 0);
> -       spi_enable_chip(dws, 1);
> +       dw_spi_enable_chip(dws, 1);
>  }
>
> -static inline void spi_shutdown_chip(struct dw_spi *dws)
> +static inline void dw_spi_shutdown_chip(struct dw_spi *dws)
>  {
> -       spi_enable_chip(dws, 0);
> -       spi_set_clk(dws, 0);
> +       dw_spi_enable_chip(dws, 0);
> +       dw_spi_set_clk(dws, 0);
>  }
>
>  extern void dw_spi_set_cs(struct spi_device *spi, bool enable);
> @@ -293,4 +294,4 @@ static inline void dw_spi_dma_setup_generic(struct dw_spi *dws) {}
>
>  #endif /* !CONFIG_SPI_DW_DMA */
>
> -#endif /* DW_SPI_HEADER_H */
> +#endif /* __SPI_DW_H__ */
> --
> 2.33.0
>


-- 
With Best Regards,
Andy Shevchenko



[Index of Archives]     [Linux Kernel]     [Linux ARM (vger)]     [Linux ARM MSM]     [Linux Omap]     [Linux Arm]     [Linux Tegra]     [Fedora ARM]     [Linux for Samsung SOC]     [eCos]     [Linux Fastboot]     [Gcc Help]     [Git]     [DCCP]     [IETF Announce]     [Security]     [Linux MIPS]     [Yosemite Campsites]

  Powered by Linux