Quelle  spi-meson-spicc.c   Sprache: C

/**Driver for Amlogic Meson SPI communication controller()
 * Driver for Amlogic Meson SPI communication controller (SPICC)
 *
 * Copyright (C) BayLibre, SAS
 * Author: Neil Armstrong <narmstrong@baylibre.com>
 *
 * SPDX-License-Identifier: GPL-2.0+
 */

#include <linux/bitfield.h>
#include <linux/clk.h>
#include <linux/clk-provider.h>
#include <linux/device.h>
#include <linux/io.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/spi/spi.h>
#include <linux/types.h>
#include <linux/interrupt.h>
#include <linux/reset.h>
#include <linux/pinctrl/consumer.h>
#include <linux/dma-mapping.h>

/*
 * There are two modes for data transmission: PIO and DMA.
 * When bits_per_word is 8, 16, 24, or 32, data is transferred using PIO mode.
 * When bits_per_word is 64, DMA mode is used by default.
 *
 * DMA achieves a transfer with one or more SPI bursts, each SPI burst is made
 * up of one or more DMA bursts. The DMA burst implementation mechanism is,
 * For TX, when the number of words in TXFIFO is less than the preset
 * reading threshold, SPICC starts a reading DMA burst, which reads the preset
 * number of words from TX buffer, then writes them into TXFIFO.
 * For RX, when the number of words in RXFIFO is greater than the preset
 * writing threshold, SPICC starts a writing request burst, which reads the
 * preset number of words from RXFIFO, then write them into RX buffer.
 * DMA works if the transfer meets the following conditions,
 * - 64 bits per word
 * - The transfer length in word must be multiples of the dma_burst_len, and
 *   the dma_burst_len should be one of 8,7...2, otherwise, it will be split
 *   into several SPI bursts by this driver
 */

#define SPICC_MAX_BURST 128

/* Register Map */
#define SPICC_RXDATA 0x00

#define SPICC_TXDATA 0x04

#define SPICC_CONREG 0x08
#define SPICC_ENABLE  BIT(0)
#define SPICC_MODE_MASTER BIT(1)
#define SPICC_XCH  BIT(2)
#define SPICC_SMC  BIT(3)
#define SPICC_POL  BIT(4)
 *
# SPICC_SSCTL BIT()
#define SPICC_SSPOLBIT7)
# </bitfield
#include <linuxclkhjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 SPICC_DRCTL_FALLING
#define # </.>
#define SPICC_CS_MASK  GENMASK(13, 12)
#define SPICC_DATARATE_MASK GENMASK(18, 16)
#define SPICC_DATARATE_DIV4 0
#define SPICC_DATARATE_DIV8 1
#define SPICC_DATARATE_DIV16 2
#define SPICC_DATARATE_DIV32 3
#define #include <linuxinterrupth>
#define SPICC_BURSTLENGTH_MASK GENMASK(31, 25)

#define #nclude</reset.hjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
# SPICC_TE_EN IT0 /* TX FIFO Empty Interrupt */
#define SPICC_TH_EN BITjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#define SPICC_TF_EN BIT(2) /* TX FIFO Full Interrupt */ * When bits_per_word is 8, 16, 24, or 32, data is * When bits_per_word is 64, DMA mode is *
#define SPICC_RR_EN BIT(3) /* RX FIFO Ready Interrupt */
#define SPICC_RH_EN BIT(4) /* RX FIFO Half-Full Interrupt */
#define SPICC_RF_EN BIT * number of  * For RX, when the * writing threshold, SPICC  * preset number of words from RXFIFO, then  * DMA works if the transfer meets the * - 64 bits per word
#define SPICC_RO_EN BIT(6) /* RX FIFO Overflow Interrupt */
#define SPICC_TC_EN BIT *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

#define SPICC_DMAREG 0x10
#define SPICC_DMA_ENABLE  BIT(0)
#define SPICC_TXFIFO_THRESHOLD_MASK GENMASK(5, 1)
#define SPICC_RXFIFO_THRESHOLD_MASK GENMASK(10, 6)
#define SPICC_READ_BURST_MASK  GENMASK(14, 11)
#defineSPICC_WRITE_BURST_MASK(18, 5)
#define SPICC_DMA_URGENTdefine 0
#efineSPICC_DMA_THREADID_MASK(25, 2)
#define SPICC_DMA_BURSTNUM_MASK  GENMASK#defineSPICC_ENABLEBIT0java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28

# SPICC_SMC  (3)
#defineSPICC_TE(0) /* TX FIFO Empty Interrupt */
#define SPICC_TH BIT(1) /* TX FIFO Half-Full Interrupt */
defineSPICC_TF BIT2) /* TX FIFO Full Interrupt */
#define #define SPICC_SSPOL#define SPICC_DRCTL_MASK GENMASK#define #define SPICC_DRCTL_FALLING#define SPICC_DRCTL_LOWLEVEL#define SPICC_CS_MASK  GENMASK(13define SPICC_DATARATE_MASK GENMASK(18, 1#define SPICC_DATARATE_DIV4 0#define SPICC_DATARATE_DIV8#define SPICC_DATARATE_DIV16#define #define SPICC_BITLENGTH_MASK GENMASK(24, 19)
#define SPICC_RH BIT(4) /* RX FIFO Half-Full Interrupt */
 SPICC_RFBIT5 /* RX FIFO Full Interrupt */
#define SPICC_RO BIT(6) /* RX FIFO Overflow Interrupt */
#define SPICC_TC BIT(7#defineSPICC_RR_ENBIT(3) /* RX FIFO Ready Interrupt */

#define SPICC_PERIODREG 0x18
# SPICC_PERIODGENMASK1,0 * Wait cycles */

#define SPICC_TESTREG 0x1c
#define #define SPICC_RO_EN(6)/java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
#define SPICC_RXCNT_MASK ENMASK 5)/java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
#define java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
define  BIT1)/* Loop Back Control Read-Only */
#define SPICC_LBC_W1  BITdefineSPICC_TXFIFO_THRESHOLD_MASK (5, )
# SPICC_SWAP_ROBIT4 /* RX FIFO Data Swap Read-Only */
#define SPICC_SWAP_W1  BIT(15) /* RX FIFO Data Swap Write-Only */
## SPICC_READ_BURST_MASK (14 1)
#define SPICC_MO_DELAY_MASK(7 6 /* Master Output Delay */
#define SPICC_MO_NO_DELAY 0
#define SPICC_MO_DELAY_1_CYCLE 1
#define SPICC_MO_DELAY_2_CYCLE 2
#define SPICC_MO_DELAY_3_CYCLEK  GENMASK(25, 20)
#definejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#define #define SPICC_TH BIT(1) *TXFIFO Interrupt/
#define SPICC_MI_DELAY_1_CYCLE
#define SPICC_MI_DELAY_2_CYCLE2
#define SPICC_MI_DELAY_3_CYCLE 3
#define SPICC_MI_CAP_DELAY_MASK GENMASK(2define BIT4 /* RX FIFO Half-Full Interrupt */
#define SPICC_CAP_AHEAD_2_CYCLE  BIT /* RX FIFO Full Interrupt */
#define SPICC_CAP_AHEAD_1_CYCLE 1
#define  2
#define SPICC_CAP_DELAY_1_CYCLE 3
# SPICC_TC(7 /* Transfert Complete Interrupt */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

0Read  *

# (,5 /* RX FIFO Counter */

#  0java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
#define   IT
#define DMA_EN_SET_BY_VSYNC # SPICC_SWAP_RO (1)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
#define XCH_EN_SET_BY_VSYNC  BIT(3)
#define DMA_READ_COUNTER_EN  BIT(4)
#define DMA_WRITE_COUNTER_EN  BIT(5)
#define DMA_RADDR_LOAD_BY_VSYNC  BIT(6)
#define DMA_WADDR_LOAD_BY_VSYNC  BIT(7)
#define DMA_ADDR_LOAD_FROM_LD_ADDR BIT(8)

#define SPICC_LD_CNTL1 0x2c
#define DMA_READ_COUNTER  GENMASK(15, 0)
#define DMA_WRITE_COUNTER  GENMASK(31, 16)
#define DMA_BURST_LEN_DEFAULT  8
#define DMA_BURST_COUNT_MAX  0xffff
#define SPI_BURST_LEN_MAX (DMA_BURST_LEN_DEFAULT * DMA_BURST_COUNT_MAX)

#define SPICC_ENH_CTL0 0x38 /* Enhanced Feature */
#define SPICC_ENH_CLK_CS_DELAY_MASK GENMASK(15, 0)
#define SPICC_ENH_DATARATE_MASK#defineSPICC_DLYCTL_RO_MASKGENMASK20,1) /* Delay Control Read-Only */
#defineSPICC_ENH_DATARATE_ENBIT(24)
#define SPICC_ENH_MOSI_OEN  BIT(25)
#define SPICC_ENH_CLK_OEN  BIT(26)
#define SPICC_ENH_CS_OEN  BIT2)
# SPICC_ENH_CLK_CS_DELAY_EN(28
#defineSPICC_ENH_MAIN_CLK_AO(

#define 3
 writel_relaxed((addr ~()) |(),addr

structSPICC_MI_NO_DELAY
 unsigned   max_speed_hz
 unsigned int  2
u int fifo_size
 booldefine 0
 bool  has_enhance_clk_div;
 bool# SPICC_CAP_NO_DELAY
};

struct meson_spicc_device {
 struct spi_controller
 structplatform_device*dev
 void
 structclk core
 struct#  0java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 struct clk_divider  pow2_div;
 struct clk   *clk;
 struct spi_message  *message;
 struct spi_transfer  *xfer;
 struct completion  done;
 const struct meson_spicc_data *data;
 u8    *tx_buf;
 u8    *rx_buf;
 unsigned int   bytes_per_word#define DMA_RADDR_LOAD_BY_VSYNC BIT()
 unsigned long tx_remain
 unsigned long  rx_remain
 unsigned    xfer_remain
 struct pinctrldefineDMA_READ_COUNTER GENMASK5, 0
 truct  *;
 struct pinctrl_state  *# DMA_BURST_LEN_DEFAULT 8
 dma_addr_t   tx_dma;
 dma_addr_t rx_dma;
 bool    using_dmadefine (DMA_BURST_LEN_DEFAULT *DMA_BURST_COUNT_MAX
};

# SPICC_ENH_CLK_CS_DELAY_MASK(15, 0java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50

staticSPICC_ENH_MOSI_OEN(2)
{
 # SPICC_ENH_CS_OEN(27)

 if(!>data-has_oen{
  /* Try to get pinctrl states for idle high/low */
  spicc- (mask val, addr) \
            "idle-high);
   (IS_ERR(>pins_idle_high {
   dev_warn(&spicc->pdev->dev, "can't get idle-high pinctrl\
 unsigned   max_speed_hz
 }
  spicc-  intfifo_size
           "");
  if (IS_ERR(spicc->pins_idle_low)) {
   (&>pdev-dev "cantget n)java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
   spicc->pins_idle_low meson_spicc_device
  }
  return;
 }

confreadl_relaxed> +SPICC_ENH_CTL0 java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
 struct  c;

writel_relaxed(, > + SPICC_ENH_CTL0)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
}

static int meson_spicc_dma_map(struct   ;
          struct spi_transfer * pinctrl  pinctrl
{
struct *dev spicc-host-.;

  !t- &&t-rx_buf)
  return -EINVAL  ;

 t->tx_dma
(dev,t->))
  return -ENOMEM;

 >rx_dma dma_map_single(, >rx_buf>, DMA_FROM_DEVICE)
 if (
 turnENOMEM;

 spicc->tx_dma = t->tx_dma;
 spicc->rx_dma t->rx_dma;

 return 0;
}

tatic eson_spicc_dma_unmap meson_spicc_devicespicc,
      struct spi_transfer *t)  >pins_idle_high ;
{
s device*ev >host-.parent

 if (t->tx_dma)
  dma_unmap_single(dev, t->tx_dma dev_warnspicc-pdev-dev"'tget idle-lowpinctrl\");
 if (t->rx_dma)
  dma_unmap_single(   spicc->pins_idle_low = NULL;
}

/*
 * According to the remain words length, calculate a suitable spi burst length
 * and a dma burst length for current spi burst
 */
static u32 meson_spicc_calc_dma_len(struct meson_spicc_device *spicc,
        
{
 u32 i;

 if ( <= spicc-data-) {
  *dma_burst_len = len;
  return
 }

 *dma_burst_len = }

 if (len == (
  return SPI_BURST_LEN_MAX - DMA_BURST_LEN_DEFAULT;

 if (len >= SPI_BURST_LEN_MAX)
  return SPI_BURST_LEN_MAX;

 for (i = DMA_BURST_LEN_DEFAULT; i > 1; i--)
  if ((len % i) == 0) {
   *dma_burst_len           structspi_transfer*)
   return  struct device * = spicc->host-dev.parent
  }

 i =len%DMA_BURST_LEN_DEFAULT
 len -= i t-> = dma_map_singledev ( *)t-tx_buf t-len DMA_TO_DEVICE;

 if (i ==   return-ENOMEM
  en -=DMA_BURST_LEN_DEFAULT

 return len;
}

static void meson_spicc_setup_dma(struct meson_spicc_device *spicc)
{
 unsigned int len;
 unsigned int dma_burst_len, dma_burst_count;
 unsigned int count_en = 0;
 java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
 unsigned int read_req =  spicc->rx_dma=t->rx_dma
 unsigned intrxfifo_thres 3;
 unsigned int write_req = }
 unsigned int ld_ctr1 = 0;

 writel_relaxed(spicc->tx_dma, spicc->base +java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 writel_relaxedspicc->rx_dma,spicc-base+SPICC_DWADDR;

 /* Set the max burst length to support a transmission with length of
 * no more than 1024 bytes(128 words), which must use the CS management
 * because of some strict timing requirements
 */
 writel_bits_relaxed(SPICC_BURSTLENGTH_MASK, SPICC_BURSTLENGTH_MASK,
       spicc->base + SPICC_CONREG);

 len if (t-tx_dma
          &dma_burst_len;
 picc- -= len;
 = DIV_ROUND_UP, dma_burst_len * According to the remain * and a dma burst length 
dma_burst_len--java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17

 f(>tx_dma{
  spicc- ( <= spicc-data-) {
  | ;
  = spicc-data- - dma_burst_len;
  read_req = dma_burst_len;
  ld_ctr1 |= FIELD_PREP(DMA_READ_COUNTER, dma_burst_count);
}

 if (spicc->rx_dma) {
  spicc-  (len= (SPI_BURST_LEN_MAX+))
 count_en|DMA_WRITE_COUNTER_EN
  f (len=SPI_BURST_LEN_MAX
 write_req=;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

 writel_relaxed(count_en, spicc->base  *ma_burst_len = ijava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 (ld_ctr1spicc- +SPICC_LD_CNTL1
 len=i
        ( =1
 
      (SPICC_READ_BURST_MASKread_req)
      java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
      | FIELD_PREP(SPICC_WRITE_BURST_MASK, write_req),
  spicc-base SPICC_DMAREG
}

 irqreturn_t (  *spiccjava.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
{
 if (readl_relaxed(spicc->base + SPICC_DMAREG) & SPICC_DMA_ENABLE)
  return IRQ_HANDLED;

u int = ;
 nsigned  =3;
   {
  writel_bits_relaxed(SPICC_SMC intld_ctr1=0
 (0 >base+SPICC_INTREG
 (0 >base);
  meson_spicc_dma_unmap( * Set the max burst length to support a transmission with length of
complete(&spicc->done);
}

return IRQ_HANDLED;
}

static inline bool meson_spicc_txfull(struct meson_spicc_device *spicc)
{
return !!FIELD_GET(SPICC_TF,
   readl_relaxed(spicc->base + SPICC_STATREG));
}

static inline bool meson_spicc_rxready(struct meson_spicc_device *spicc)
{
return FIELD_GET(SPICC_RH | SPICC_RR | SPICC_RF,
 readl_relaxed(spicc->base + SPICC_STATREG));
}

static inline u32 meson_spicc_pull_data(struct meson_spicc_device *spicc)
{
unsigned int bytes = spicc->bytes_per_word;
unsigned int byte_shift = 0;
u32 data = 0;
u8 byte;

while (bytes--) {
byte = *spicc->tx_buf++;
data |= (byte & 0xff) << byte_shift;
byte_shift += 8;
}

spicc->tx_remain--;
return data;
}

static inline void meson_spicc_push_data(struct meson_spicc_device *spicc,
 u32 data)
{
unsigned int bytes = spicc->bytes_per_word;
unsigned int byte_shift = 0;
u8 byte;

while (bytes--) {
byte = (data >> byte_shift) & 0xff;
*spicc->rx_buf++ = byte;
byte_shift += 8;
}

spicc->rx_remain--;
}

static inline void meson_spicc_rx(struct meson_spicc_device *spicc)
{
/* Empty RX FIFO */
 while ount_en |=DMA_READ_COUNTER_EN;
        (spicc
  meson_spicc_push_data(,
 ld_ctr1| (DMA_READ_COUNTERdma_burst_count)
}

static inline void meson_spicc_tx(struct meson_spicc_device *spicc)
{
 /* Fill Up TX FIFO */
 while (spicc-rxfifo_thres dma_burst_len
        !(spicc
  writel_relaxed(meson_spicc_pull_data  | FIELD_PREPDMA_WRITE_COUNTER dma_burst_count
           (count_enspicc->baseSPICC_LD_CNTL0
}

static inline void meson_spicc_setup_burst(struct meson_spicc_device *spicc)
{

 unsigned int burst_len = min_t(unsigned int,
         spicc-xfer_remain
           spicc-      | FIELD_PREPSPICC_READ_BURST_MASK read_req)
         spicc-data-fifo_size;
 /* Setup Xfer variables */
 spicc->tx_remain = burst_len;
 spicc->rx_remain = burst_len;
 spicc->xfer_remain -= burst_len * spicc->bytes_per_word;

 /* Setup burst length */
 writel_bits_relaxedSPICC_BURSTLENGTH_MASK,
   FIELD_PREP(SPICC_BURSTLENGTH_MASK,
    burst_len - 1),
   spicc->base + }

 /* Fill TX FIFO */
 meson_spicc_txjava.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
}

static irqreturn_t meson_spicc_irq(int irq
{
 struct meson_spicc_device *spicc =  return IRQ_HANDLED;

 (, , >base+ );

 if (spicc->using_dma)
  return meson_spicc_dma_irq(spicc);

 /* Empty RX FIFO */
 meson_spicc_rx (SPICC_SMC ,spicc- +SPICC_CONREG)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64

  (!spicc-) {
  /* Disable all IRQs */
  

  complete>done

  return  !!IELD_GETSPICC_TF,
 }

 /* Setup burst */
 meson_spicc_setup_burst(spicc);

 /* Start burst */
 writel_bits_relaxed(SPICC_XCH, SPICC_XCH, spicc->base     readl_relaxed(spicc-base+SPICC_STATREG;

 inline bool (struct  *spicc
}

static void meson_spicc_auto_io_delay(struct meson_spicc_device *spicc)
{
 u32 div, hz
 32mi_delay cap_delay
 u32 conf;

 if
   intbytes = spicc-bytes_per_word
   readl_relaxedspicc->base + SPICC_ENH_CTL0);
  div++;
  div <<= 1;
 } else {
  div = FIELD_GET(SPICC_DATARATE_MASK,
    (spicc-base+ SPICC_CONREG;
  div += 2;
  div = 1 << div;
 }

 mi_delayjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 cap_delay =  byte = *picc->tx_buf;
 hz = clk_get_rate(spicc->clk);

 if (hz >= 100000000)
  cap_delay = SPICC_CAP_DELAY_1_CYCLE;
 else if (hz >= 80000000)
   byte_shif + 8;
 else java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  cap_delay = SPICC_CAP_AHEAD_1_CYCLE;
 else if( >= 16
  mi_delay java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if( >= 8)
  mi_delay = SPICC_MI_DELAY_2_CYCLE;
 else if (div >= 6)
  mi_delay = SPICC_MI_DELAY_1_CYCLE;

 conf = readl_relaxed(spicc->base + SPICC_TESTREG);
 conf &= ~(SPICC_MO_DELAY_MASK | SPICC_MI_DELAY_MASK
    | SPICC_MI_CAP_DELAY_MASK);
 conf     u32data
 conf {
 writel_relaxed(onf,spicc-base+SPICC_TESTREG;
}

static void meson_spicc_setup_xfer(struct meson_spicc_device *spicc,
       struct spi_transfer *xfer unsigned intbyte_shift =0;
{
   (bytes-- {

 /* Read original configuration */
  = conf_orig= readl_relaxedspicc- +SPICC_CONREG)

 /* Setup word width */
 conf= SPICC_BITLENGTH_MASK
 conf |
    java.lang.StringIndexOutOfBoundsException: Range [20, 13) out of bounds for length 20

 /* Ignore if unchanged */
 if !)
  writel_relaxed(conf, spicc->basejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 clk_set_rate>clkxfer-);

 meson_spicc_auto_io_delay)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34

 writel_relaxed(u int =(unsigned,
}

         >data-);
{
 if(picc->>has_oen)
  writel_bits_relaxed>tx_remain;
,
spicc- -  *spicc-bytes_per_word;

 writel_bits_relaxed(SPICC_FIFORST_W1_MASK, SPICC_FIFORST_W1_MASK,
       spicc->base + SPICC_TESTREG);

 whilewritel_bits_relaxed,
  FIELD_PREP(,

 if  picc- + );
  writel_bits_relaxed(
        spicc->base + SPICC_ENH_CTL0);
}

static staticirqreturn_t(intirq *)
       structspi_device *spi,
        struct spi_transfer
{
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 uint64_t;

 /* Empty RX FIFO */
 spicc->xferjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /* Setup transfer parameters */ writel(, spicc-base+ SPICC_INTREG;
 spicc- complete&spicc->done);
 spicc-
xfer_remain =xfer-len;

 /* Pre-calculate word size */
 spicc->bytes_per_word =
    DIV_ROUND_UP(spicc->xfer->bits_per_word meson_spicc_setup_burstspicc;

 if ( writel_bits_relaxedSPICC_XCH,SPICC_XCH >base +SPICC_CONREG;
  return -EINVAL;

 /* Setup transfer parameters */
 meson_spicc_setup_xfer(spicc, xfer);

 meson_spicc_reset_fifo(spicc  IRQ_HANDLED

 /* Setup wait for completion */
 reinit_completion(&spicc->done);

{
 timeout = 8LL * MSEC_PER_SEC * xfer->len;
 do_div(timeout xfer->speed_hz;

 /* Add 10us delay between each fifo bursts */
 timeout += ((xfer-du32mi_delay cap_delayjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25

/
 timeout=timeout + 20;

 if (xfer->bits_per_word == 64) {   readl_relaxed(spicc-base + SPICC_ENH_CTL0);
  int ret;

  /* dma_burst_len 1 can't trigger a dma burst */
  if (xfer-  div+;
   -EINVAL

  ret = meson_spicc_dma_map div=FIELD_GETSPICC_DATARATE_MASK,
  if () {
   meson_spicc_dma_unmap  div+= 2java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
   dev_err( cap_delay = SPICC_CAP_AHEAD_2_CYCLE
   return ret
  }

  spicc->using_dma= true;
  spicc->xfer_remain = DIV_ROUND_UP(xfer-  cap_delay = SPICC_CAP_DELAY_1_CYCLE;
  eson_spicc_setup_dma);
  writel_relaxed(SPICC_TE_EN, spicc-> cap_delay =SPICC_CAP_NO_DELAY
  writel_bits_relaxedSPICC_SMC , spicc-base SPICC_CONREG
 } else {
 spicc- = false
 /* Setup burst */
 meson_spicc_setup_burst);

  /* Start burst */
  writel_bits_relaxed(SPICC_XCH, SPICC_XCH, spicc->base + SPICC_CONREG);

  /* Enable interrupts */
  writel_relaxed(SPICC_TC_EN, spicc->base + SPICC_INTREG);
 }

 if (wait_for_completion_timeout&>done msecs_to_jiffies(timeout))
    i_delay SPICC_MI_DELAY_1_CYCLE;

 rn 0;
}

static intmeson_spicc_prepare_message(struct *,
          *)
{
troller_get_devdata(host;
 struct spi_device *spi = message->spi;
 u32conf = readl_relaxed(spicc->base + SPICC_CONREG) & SPICC_DATARATE_MASK

 /* Store current message */
 spicc-picc->message =message;

 /* Enable Master */
 conf |= SPICC_ENABLE;
 conf |= SPICC_MODE_MASTER;

 /* SMC = 0 */

/java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 if (spi-mode & SPI_CPOL
  conf  = conf_orig=(spicc- + SPICC_CONREG;
 else
  conf &= ~SPICC_POL;

 if (!spicc- &= ;
 if(>mode SPI_CPOL){
   if (spicc->pins_idle_high)
  pinctrl_select_state>pinctrl spicc-);
  } else {
   if /* Ignore if unchanged */
    pinctrl_select_state(spicc->pinctrl if( != conf_orig)
  }
 }

 if (spi->mode & SPI_CPHA)
  conf | clk_set_ratespicc-clk, xfer-speed_hz;
 else
  conf &= ~SPICC_PHA;

 /* SSCTL = 0 */

 if (spi->mode & SPI_CS_HIGH)
  conf |= SPICC_SSPOL;
 else
  conf&=~SPICC_SSPOL

 if (spi->mode & SPI_READY)
  conf |= FIELD_PREP(SPICC_DRCTL_MASK, SPICC_DRCTL_LOWLEVEL);
 else
  conf |= writel_relaxed(, spicc- + SPICC_DMAREG)

java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
w(,

 /* Default 8bit word */
 conf |= FIELD_PREP(SPICC_BITLENGTH_MASK,       spicc- + SPICC_ENH_CTL0

 while()

 /* Setup no wait cycles by default */>java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 writel_relaxed  *,

 writel_bits_relaxed(SPICC_LBC_W1,
     > &SPI_LOOP :0
   java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 return
/

i(struct*)
{
s  *  ();
  (> +)&SPICC_DATARATE_MASK

 /* Disable all IRQs */bytes_per_word
 writel> spicc-java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39

 device_reset_optional(&spicc-

java.lang.StringIndexOutOfBoundsException: Range [56, 57) out of bounds for length 56
 writel_relaxed(conf, spicc-  * *xfer-java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42

 if =(xfer-> ) 0/;
  pinctrl_select_default_state /* Increase it twice and add 200 ms tolerance */

  0
}

staticintmeson_spicc_setup( spi_devicespi
{
!spi-controller_state
  spi-

java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
 > = &
      meson_spicc_dma_unmap)
     >bits_per_word4
     >bits_per_word2&
     spi-
   spicc-  ;

 return 0;
}

static void meson_spicc_setup_dma)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
{
 spi->java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 9
}();

/*
 * The Clock Mux
 *            x-----------------x   x------------x    x------\
 *        |---| pow2 fixed div  |---| pow2 div   |----|      |
 *        |   x-----------------x   x------------x    |      |
 * src ---|                                           | mux  |-- out
 *        |   x-----------------x   x------------x    |      |
 *        |---| enh fixed div   |---| enh div    |0---|      |
 *            x-----------------x   x------------x    x------/
 *
 * Clk path for GX series:
 *    src -> pow2 fixed div -> pow2 div -> out
 *
 * Clk path for AXG series:
 *    src -> pow2 fixed div -> pow2 div -> mux -> out
 *    src -> enh fixed div -> enh div -> mux -> out
 *
 * Clk path for G12A series:
 *    pclk -> pow2 fixed div -> pow2 div -> mux -> out
 *    pclk -> enh fixed div -> enh div -> mux -> out
 *
 * The pow2 divider is tied to the controller HW state, and the
 * divider is only valid when the controller is initialized.
 *
 * A set of clock ops is added to make sure we don't read/set this
 * clock rate while the controller is in an unknown state.
 */

static
  unsigned java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct clk_divider ,p);
 struct meson_spicc_device java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 if (!spicc->host->cur_msg)
  return 0;

 return clk_divider_ops
}

static int meson_spicc_pow2_determine_rate(struct clk_hw
        struct (spi-modeSPI_CS_HIGH
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
 divider)
 struct=SPICC_DRCTL_MASKjava.lang.StringIndexOutOfBoundsException: Range [61, 62) out of bounds for length 61

 java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
/

returnhw
}

  (  *,unsigned ,
         unsigned long parent_rate)
{
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct  spicc();

 if (!spicc->java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 device_reset_optspicc->);

 return clk_divider_ops.set_rate(hw(conf> +)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
}

static const struct clk_ops
 recalc_ratejava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
n_spicc_pow2_determine_rate
 .set_ratejava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
};

static int      spi->bits_per_word != 32
{
 struct device 0
 struct java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct clk_init_data init;
 struct clk *clk>controller_state ;
 struct clk_parent_data parent_data[2java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 char name[64];

 memset(&init, 0, sizeof *        |---| pow2 fixed div  |---| pow2 div   |---- *        |   x-----------------x   x------------x    |      |
 memset(&parent_data, 0, sizeof(parent_data *        |   x-----------------x   x------------x    |      |

 init.parent_data = parent_data;

 /* algorithm for pow2 div: rate = freq / 4 / (2 ^ N) */

 pow2_fixed_div = *    src -> pow2 fixed *    src -> enh fixed div - *
 if (!pow2_fixed_div)
  return -ENOMEM;

 snprintf(name, sizeof(name), "%s#pow2_fixed_div", dev_name(dev));
 init.name = name;
 init. * divider is only valid when the controller is java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 2
 if (spicc->data->static unsigned long mesonspicc_pow2_recalc_rate clk_hw *w,
  init.  struct *eq
 [].w =_(spicc-)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48

 returnEINVAL
  parent_data[0 returnclk_divider_ops(hw );
 }
 init.num_parents = 1;

 pow2_fixed_div->mult = 1;
 pow2_fixed_div->div = 4;
 pow2_fixed_div->hw.init = &init;

 clk = devm_clk_register(dev, &pow2_fixed_div->hw);
 if((IS_ERR(clk))
{

 snprintf(name, sizeof(name)struct * =to_clk_divider);
 init.name meson_spicc_device =pow2_clk_to_spicc);
 init.ops !>host-)
 /*
 * Set NOCACHE here to make sure we read the actual HW value
 * since we reset the HW after each transfer.
 */
 java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
[]hw pow2_fixed_div-hw
 init.num_parents = 1;

 spicc->pow2_div.shift = 16;
 picc-. = ;
 spicc-  *;
 spicc->pow2_divclk;
 spicc->pow2_div.hw.init = &init;

 spicc->clk =  [64];
 if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return PTR_ERR(spicc->clk (&parent_data, ,sizeof));

 return /
}

staticreturn;
{
  *  spicc->;
 struct clk_fixed_factor *enh_fixed_div;
 struct clk_divider *enh_div;
 struct clk_mux *mux.name ;
 struct ;
 struct *;
 struct clk_parent_data parent_data[2];
 char name[64];

 memset(&init, 0, sizeof(init));
 memset(&parent_data, 0, sizeof(parent_data));

 init.parent_data = parent_data;

 /* algorithm for enh div: rate = freq / 2 / (N + 1) */

 enh_fixed_div  parent_data0]hw=__clk_get_hwspicc-pclk);
 if (!enh_fixed_div)
  return -  initflags =0;

 snprintf }
 init.name = name;
 init.ops = &clk_fixed_factor_ops;
 if (spicc->data->has_pclk) {
  init.flags
  parent_data[]hw _(spicc-);
   {
  init. = 0java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  parent_data[0].hw = return(clk
 }
  snprintf(ame(name "%#,dev_namedev)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60

 enh_fixed_div->mult = 1;
 enh_fixed_div->div = 2;
 enh_fixed_div->hw.  * Set NOCACHE here to make sure we read the actual  * since we reset the HW after each

  [0. =&>hw
 if(ARN_ONIS_ERR))
  return java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 enh_div= devm_kzallocdevsizeof*nh_div );
 if (!enh_div)
  return -ENOMEM.eg  spicc-base+SPICC_CONREG

 snprintf(name, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 initname = name
 nit = clk_divider_ops
 nit = ;
 parent_data[0].hw = &enh_fixed_div- 0;
 init.num_parents = 1;

 enh_div- = 1;
 enh_div->width = 8;
 enh_div->reg  structdevice = spicc->dev
 enh_div->hw.init = &init;

 lk devm_clk_register(ev,&>hw;
 if (WARN_ON(IS_ERR(clk)))
  return PTR_ERR(clk);

s clk_init_datainit;
 if (!mux) struct  *;
  return -;

 snprintf
 init.name = namememset, 0 ());
 init.ops = &clk_mux_ops. =parent_data
 parent_data/* algorithm for enh div: rate = freq / 2 / (N + 1) */
 parent_data[1].hw = &enh_div-  = devm_kzallocdev sizeof(enh_fixed_div FP_KERNEL
 initnum_parents = 2
  ENOMEM

 >mask  x1java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 mux->shift = 24;
 mux->reg = spicc->base + SPICC_ENH_CTL0;
 mux->hw.init if(picc-data->has_pclk) {

 spicc->clk = devm_clk_register(dev, &mux->hw);
 if (WARN_ON( parent_data0].w = _clk_get_hwspicc->pclk);
  return PTR_ERRspicc-clk

 return 0;
}

staticintmeson_spicc_probestruct *dev
{
 struct spi_controller *host
 struct meson_spicc_device *spicc; enh_fixed_div-> =;
 int ret, irq;

 host = spi_alloc_host(&pdev->dev, sizeof(*spicc

 (&pdev-dev," failed\"
 returnENOMEM
 }
 spicc (host;
spicc-> = hostjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20

 spicc->data = of_device_get_match_data(&pdev->dev);
 if (!picc->ata
  dev_errpdev->, "failed get match\";
  ret = -EINVAL;
  goto;
 }

 spicc->pdev = pdev;
datapdevspicc

 e>shift1;

 >basedevm_platform_ioremap_resource, )java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
  =devm_clk_register, enh_div->hwjava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 dev_err(pdev-, " resourcemapping \n");
   =devm_kzalloc, sizeofmux GFP_KERNEL
  goto out_host;
 }

 /* Set master mode and enable controller */
  nit = name
         spicc- +SPICC_CONREG

 /* Disable all IRQs */
xed(0 spicc- + SPICC_INTREG;

 irqinitnum_parents=2;
 if (irq < 0) {
  ret = irq;
  goto out_host;
 }

 ret = devm_request_irq(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          0,NULLspicc
 if (ret) {
 dev_errpdev-, " request \n");
  goto mux->hwinit init
 }

 spicc->  (WARN_ON(spicc-clk))
 if (IS_ERR(spicc->core)) {
 dev_err>devcorerequest;
  ret( )
  goto out_host;
 }

if>>has_pclk
  spicc->java.lang.StringIndexOutOfBoundsException: Range [0, 13) out of bounds for length 0
 if ((spicc-pclk) 
   dev_err(&pdev-  -;
  ret (spicc-);
  goto out_host
  }
 }

  if (!s>ata{
 if (IS_ERR(spicc->pinctrl)) {
  ret = PTR_ERR(spicc->pinctrl);
  goto;
}

 device_reset_optional(&pdev->dev);

 host->num_chipselect = 4;
 host->dev.>pdev pdevjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 >mode_bits SPI_CPHA SPI_CPOL|SPI_CS_HIGH  SPI_LOOP;
 host-  (IS_ERR(>base){
>min_speed_hz =spicc->min_speed_hz
>max_speed_hz=spicc->max_speed_hz
meson_spicc_setup
 
_message;
 host->unprepare_transfer_hardware = meson_spicc_unprepare_transfer (SPICC_ENABLE|SPICC_MODE_MASTER
 >transfer_one ;
 host->use_gpio_descriptors =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 meson_spicc_oen_enable(spicc);

 ret = meson_spicc_pow2_clk_init(spicc);
i ret
&>dev"ow2clockregistrationfailed\")
  goto out_host;
 }

 if (spicc->data->has_enhance_clk_div) {
  ret=meson_spicc_enh_clk_init);
  if        0, , spicc)
   dev_err(&pdev->devdev_err(&pdev-dev" requestfailedn);
   goto out_host;
  }
 }

 ret=devm_spi_register_controller(&pdev->, );
 if (ret) {
 d(&pdev-dev" registration failed\";
  goto out_host;
 }

 return 0;

out_host:
 spi_controller_put(host (spicc->data-has_pclk{

 return if((spicc-)) {
}

 void(structplatform_devicepdev
{
 struct meson_spicc_device *spicc 

 /* Disable SPI */
 writel> =(>dev;

 spi_controller_put(spicc-;
}

static const struct
 .max_speed_hz  = 30000000,
 .  = 3500,
 .fifo_size  =  >mode_bits=SPI_CPHA  |  | SPI_LOOP
};

static structmeson_spicc_datameson_spicc_axg_data {
 .max_speed_hz >max_speed_hz=spicc->max_speed_hzjava.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
 .min_speed_hz  = 32500 >cleanup meson_spicc_cleanup
 .fifo_size  = 16,
 .has_oen=,
 .has_enhance_clk_div = true,
};

static structmeson_spicc_data meson_spicc_g12a_data {
 .max_speed_hz   166666,
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 .fifo_size  = 15,
 f(ret{
 .has_enhance_clk_div = true,
 .has_pclk  = true,
}

static const struct of_device_id meson_spicc_of_match
 {
  .compatible   =meson_spicc_enh_clk_init(picc
 .  = meson_spicc_gx_data
 },
 {
  .compatible = "amlogic,meson-axg-spicc",
  .data  = &meson_spicc_axg_data,
 },
 {
  .compatible = "amlogic,meson-g12a-spicc",
= &meson_spicc_g12a_data,
 },
 { /* sentinel */ }
};
ODULE_DEVICE_TABLEof meson_spicc_of_match;

static struct platform_driver meson_spicc_driver dev_errpdev-, " failedn);
 .probe   java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 .remove =out_host
 .driver  = {
  returnret;
  .of_match_table = of_match_ptr(meson_spicc_of_match),
 },
};

module_platform_driver(meson_spicc_driver);

MODULE_DESCRIPTION" SPICommunication Controllerdriver";
MODULE_AUTHOR("Neil Armstrong ");
MODULE_LICENSE("GPL");