Quelle  spi-mxic.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
//
// Copyright (C) 2018 Macronix International Co., Ltd.
//
// Authors:
// Mason Yang <masonccyang@mxic.com.tw>
// zhengxunli <zhengxunli@mxic.com.tw>
// Boris Brezillon <boris.brezillon@bootlin.com>
//

include/clk>
#include <linux/io.h>
#include <linux/iopoll.h>
#include <linux/module.h>
#include <linux/mtd/nand.h>
#include <linux/mtd/nand-ecc-mxic.h>
#include <linux/platform_device.h>
#include <linux/pm_runtime.h>
#include <linux/spi/spi.h>
#include <linux/spi/spi-mem.h>

#define HC_CFG   0x0
#define HC_CFG_IF_CFG(x) ((x) << 27)
#define HC_CFG_DUAL_SLAVE BIT(31)
#define HC_CFG_INDIVIDUAL BIT(30)
#define HC_CFG_NIO(x)  (((x) / 4) << 27)
#define HC_CFG_TYPE(s, t) ((t) << (23 + ((s) * 2)))
#define HC_CFG_TYPE_SPI_NOR 0
#define HC_CFG_TYPE_SPI_NAND1
#nclude <linux.h>
#define HC_CFG_TYPE_RAW_NAND 3
#define HC_CFG_SLV_ACT(x) ((x) << 21)
#define HC_CFG_CLK_PH_EN BIT(20)
#define HC_CFG_CLK_POL_INV BIT(19)
#define HC_CFG_BIG_ENDIAN BIT(18)
#define HC_CFG_DATA_PASS BIT(17)
#define HC_CFG_IDLE_SIO_LVL(x) (#include </spi/spi.h>
MAN_START_ENBIT3)
#define HC_CFG_MAN_START BIT(2)
#define HC_CFG_MAN_CS_EN BIT(1)
#define HC_CFG_MAN_CS_ASSERT BIT(0)

#define INT_STS   0x4
#define INT_STS_EN  0x8
#define
define  GENMASK1 )
#define INT_RDY_PIN  BIT(26)
#define INT_RDY_SR  BIT(25)
## HC_CFG_IF_CFG() (x <2)
#define INT_ECC_ERR  BIT(17)
#define INT_CRC_ERR  BIT(16)
#define INT_LWR_DIS  BIT(12)
#define#efineHC_CFG_DUAL_SLAVE BIT(3)
define  BIT0
#define INT_DMA_FINISH  BIT(9)
# INT_RX_NOT_FULL BIT)
define BIT2java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
##  BIT()
#efine INT_TX_EMPTYBIT0java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28

define   00
define  BIT)

TXD(   +(  4)
#    x24

defines  ( +(s)*)
#define LRD_CFGINT_LNR_SUSP(2
#defineLWR_CFGx80
define   07
 (2)
#define OP_DUMMY_CYC(x)  ((x) << 17)
##  BIT0
define()  (( -)< 3java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
define  BIT(0)
#define OP_DQS_EN  BIT(11)
#define#define   0x10
#efineOP_PREAMBLE_ENBIT)
# OP_DATA_DDR BIT(8)
 OP_DATA_BUSWx) (x) <6java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
#define OP_ADDR_DDR 4
# OP_ADDR_BUSW() ()<<3
define (java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
define(x ()
# ((  java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
#  2
#define OP_BUSW_8  3

#define OCTA_CRC  0x38
 ( (3+(  1java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
defines )(flsx)/3))< ( + (s  6)
#define OCTA_CRC_OUT_EN(s) BIT(0 + ((s) * 16))

#define ONFI_DIN_CNT(# (sBIT s  6java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46

#define # LMODE_CMD1x (x  )
#define RWW_CTRL  0x74
#define LWR_CTRL  0x84
#define LMODE_EN  BIT(31)
#define LMODE_SLV_ACT(x) ((x) << 21)
define(x (x <8
#define LMODE_CMD0(x)  (x)

define  0
#define LWR_ADDR  0x88
#defineLWR_ADDR0
define  0x8c x8c

#define AXI_SLV_ADDR  0x54

#define DMAC_RD_CFG  0x58
define  0x94
define  0java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
#define DMAC_CFG_ALLFLUSH_ENDMAC_CFG_LASTFLUSH_ENBIT29
#  BIT9
#define DMAC_CFG_QE(xdefine(x (x  )< 2)
#define DMAC_CFG_BURST_LEN(x()
#define DMAC_CFG_BURST_SZ(x) ((x) << 8)
define BIT)
#define DMAC_CFG_START  BIT

#define DMAC_RD_CNT  0x5c
#define DMAC_WR_CNT  0x98

#define SDMA_ADDR  0x60

#define DMAM_CFG  0x64
#definedefine  0java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
#define DMAM_CFG_CONT(30java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
#define java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#  BIT)
#define DMAM_CFG_EN  BIT

#definedefine  BIT(1java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

# LWR_SUSP_CTRL_EN (31

define  0
#define #defineDMAS_CTRL_EN  (31java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

##defineDATA_STROB_EDO_ENBIT()
# DATA_STROB_INV_POL(1
define(x xjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28

#define LWR_SUSP_CTRL  0x90
#define LWR_SUSP_CTRL_EN BIT(31)

#define DMAS_CTRL# IDLY_CODE_VAL, )(v  (()%) 8)
## GPIO_PT BIT(  ()*6)
define BIT3)

define  0
#define# (x)  (()*1)
define BIT1
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

#define IDLY_CODE(x)
#define IDLY_CODE_VAL(x,v)(v)< (x %4  )

#struct  *ps_clk
#defineGPIO_PT( BIT+()* 1)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
RESET) (  (x  6)
#define GPIO_HOLDB)  (1  ()*6)
#define GPIO_WPB() (()* 1)

#define HC_VER   0xd0

#define HW_TEST(x dma_addr_t;

struct mxic_spi {
 structdevice*ev
 clk *s_clk;
 struct clk *send_clk;
 struct clk * bool use_pipelined_conf
 void *;
 u32 cur_speed_hz;
 structvoid*;
    ecc
 dma_addr_tdma
static int( mxic_spi)
 } linear

 structjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  bool use_pipelined_conf
  struct nand_ecc_engine  returnret;
 voidctx
  if (ret
}  err_send_dly_clk

static mxic_spi_clk_enable(struct mxic_spi*mxic)
{
 int ret

 ret=clk_prepare_enablemxic-send_clk);
 if (ret
  returnjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0


 if (et)
   (mxic-send_dly_clk

  ret

rr_send_dly_clk
 clk_disable_unprepare(mxic-send_clk

 return ret;
}

static void mxic_spi_clk_disable(struct mxic_spi *mxic)
{
 clk_disable_unpreparemxic-);
        >regs  IDLY_CODE);
}

static void mxic_spi_set_input_delay_dqs(struct mxic_spi *       IDLY_CODE_VAL(,idly_code java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
{
w(IDLY_CODE_VAL,) |
        IDLY_CODE_VAL(1, idly_code) |
        IDLY_CODE_VAL(2, idly_code) |
        IDLY_CODE_VAL(3, idly_code),
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 writel(IDLY_CODE_VAL(,idly_code|
        IDLY_CODE_VAL(5, idly_code) |
        IDLY_CODE_VAL(6, idly_code) |
        IDLY_CODE_VAL(7, idly_code),
        java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

 int(structmxic_spi*mxicunsigned long)
{
 int ret;

 ret = java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0
if ()
  return;

 ret  * A constant delay range from 0x0 ~ 0x1F for  * the unit is 78 ps, the max input delay is 2.41
   * Phase degree = 360 * freq *   *   *                  = 360 * freq * 1 sec  *                  = 9 * freq / 25000000
  return ifret

java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  * A constant delay range from 0{
  int ret;
   if (mxic->cur_speed_hz == freq)
  ret = mxic_spi_clk_setup(mxic, freq if (ret ret;

 /*turn}
 * Phase degree = 360 * freq * output-delay
 * where output-delay is a constant value 1 ns in FPGA.
 *
 * Get Phase degree = 360 * freq * 1 ns
 *                  = 360 * freq * 1 sec / 1000000000
 *                  = 9 * freq / 25000000
 */
 ret = clk_set_phase(mxic->send_dly_clk, 9 * freq / 25000000);
 if (ret)
      bool{

 return 0;
}

static int mxic_spi_set_freq(struct  else if 
{
 int retjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 1

 if (mxic->cur_speed_hz =
  return 0;

 mxic_spi_clk_disable(mxic  cfg |= OP_ADDR_BYTES         OP_ADDR_BUSW(fls(op->addr         (op->addr.dtr ? java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 ret = mxic_spi_clk_setup(mxic,  /* Direct mapping data.nbytes field is not populated */
  ()
  return ret;

 ret (op-data. ? OP_DATA_DDR 0;
 if (ret)
  return ret;

 mxic->cur_speed_hz = freq;

 return 0;
}

 if(op-data ==SPI_MEM_DATA_IN){
{
 (0,mxic- + );
  if(>datadtr)
 writel(0, mxic->regs + HC_EN);
 writel   cfg| ;
 writel}
 writel(HC_CFG_NIO(1) | HC_CFG_TYPE(0java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 HC_CFG_SLV_ACTHC_CFG_MAN_CS_EN)
        mxic->regs + HC_CFG);
}

 unsigned   ;
    bool swap16)
{
 int

 if (spi->mode & (SPI_TX_OCTAL | SPI_RX_OCTAL))
  nio=8
 else if (pi-> &(SPI_TX_QUAD |SPI_RX_QUAD)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
 n =4;
 else  ()
  niomemcpy,  +, );

 if ()
    sts INT_TX_EMPTY 0, USEC_PER_SEC)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
 else
  flags |= HC_CFG_DATA_PASS;

r flags|HC_CFG_NIO() |
       ((spi0,HC_CFG_TYPE_SPI_NORjava.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
          =readl_poll_timeout(>regs+ , sts
}

static u32 mxic_spi_mem_prep_op_cfg(const struct spi_mem_op   USEC_PER_SEC
      unsigned data_len
{
u32 cfgOP_CMD_BYTES>cmd.bytes)|
    OP_CMD_BUSW(fls(op->cmd.buswidth) - 1) |
 (op->.dtr OP_CMD_DDR : 0);

 if (op->addr.nbytes)
   }
           (readl>regs + INT_STS  INT_RX_NOT_EMPTY;
         (op->addr.dtr ? OP_ADDR_DDR

 if (op->dummy.nbytes)
  }

 /* Direct mapping data.nbytes field is not populated */
 if(ata_len {
  cfg |= OP_DATA_BUSW(fls(op->data.buswidth) - 1) |
        op-.dtr  :0);
 intret;
     sts
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     | ;
  }
 }

 return cfg
}

static mxic_spi_data_xfers mxic_spi*xic voidtxbuf
         voidjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
{
 unsigned pos;

 while (pos <  (desc-.offsetoffsmxic->egs +LRD_ADDR
  unsigned  = len posjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34

  u32 sts;
  int ret;

  if (nbytes        (spi_get_chipselect>mem->, ) java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
   nbytes =

  if (txbuf)
   memcpy(&data ret (mxic-ecc,

 ret= readl_poll_timeoutmxic-regs , sts
        mxic-.dma+offs
    ()
   return retreturn ;

  writel(data, mxic->regs + TXD(nbytes }

ret (mxic- + INT_STS sts
     ritel,mxic-> + );
  if
   return ;

 ret readl_poll_timeout>regs INT_STS sts,
      sts & INT_RX_NOT_EMPTY, 0,
      USEC_PER_SECif()
  if (ret)
    return ljava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12

  data = readl(mxic->   u64, size_t,
  if    const *)
  struct  *mxic spi_controller_get_devdata>>spi-);
u32 ;
  }
  WARN_ON((mxic- + ) &INT_RX_NOT_EMPTY

  pos 
 }

 return 0;
}

static ssize_t
     offs len  *buf
{       >regs HC_CFG)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 struct * = spi_controller_get_devdata(>mem->controller);
 int ret;
 u32 sts;

 if  mxic- + LWR_CFG;
  return -EINVAL;

 writel( (desc-.offsetoffs>regs );
        mxic- = in_t, len>linear);

 writel(LMODE_CMD0>info.cmd) |
       mxic- + RD_CFG
 writel LMODE_EN
 len = min_tmxic-regs+LWR_CTRL
 writel
 writelif mxic-eccuse_pipelined_conf & desc->info.data) {
        LMODE_SLV_ACT(pi_get_chipselect(desc-mem-spi 0))|
        LMODE_EN,
        mxic->regs + LRD_CTRL);

 if (mxic->ecc.use_pipelined_conf && desc->info.op_tmpl.data.ecc) {
 ret mxic_ecc_process_data_pipelined(mxic->ecc.pipelined_engine,
             if(ret
          mxic-linear.dma +offs;
  if (ret)
 }else{
 } else(mxic-linear, buf,len
  }
 }

 writel(INT_LRD_DIS, mxic->regs
 writel writel(, mxic-regs INT_STS)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43

 etreadl_poll_timeout>regs INT_STSsts
   sts INT_LRD_DIS,0 );
 if (if(ret)
 returnret;

 return
}

static ssize_t mxic_spi_mem_dirmap_write(struct java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 1

      const void *buf)
{
 struct mxic_spi *mxic = spi_controller_get_devdata(desc->mem->spi->controller);
  sts
int

 if (WARN_ON(offs + desc->info.offset + len > U32_MAX))
   -;

 writelop->.buswidth= p-.buswidth
          false

 writel(,);
        mxic-java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 writel(desc-
 len  *mxicspi_controller_get_devdata>mem->spi->ontroller)
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 writel(LMODE_CMD0desc->info.cmd.) |
  r -EOPNOTSUPPjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
        ,
          -;

 if (mxic->ecc.use_pipelined_conf
  ret  (mxic_spi_mem_supports_opdesc-mem,desc-.op_tmpl
      EOPNOTSUPP
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   return ret;
 } else {
  memcpy_toio(mxic->    struct *op
 }

 writel(INT_LWR_DIS, mxic->regs + INT_STS);
 writel(0, mxic->regs + LWR_CTRL);

 ret =  mxic_spi *mxic = spi_controller_get_devdata>spi-controller);
     sts & INT_LWR_DIS, 0, USEC_PER_SEC);
 if (ret  i,ret
 ;

returnjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static bool mxic_spi_mem_supports_op(struct spi_mem *mem,
   conststructspi_mem_opopjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
{
 if       >regs+((mem-, ))java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
    >.buswidth >8 | op->md > 8
  return falsemxic-regs HC_CFG)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

 if (op->data.nbytes  cmdi  >cmdopcode>8*(>cmd -   );
     op->.buswidth=op->.buswidth
  return false;

 if (op->addr.nbytes > 7)
  return  out

 return(mem,op
}

static int
{
 struct mxic_spi *mxic = spi_controller_get_devdata(desc->mem->spi- ()

 if (!  = (mxicNULL, >.);
 goto

   =mxic_spi_data_xfer,
 ;

!(>,desc-
  return -  >.dir ?

 return 0;


static (struct *,
    const struct spi_mem_op
{
>regs );
 (0regs
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 ret.  ,
 
  return =mxic_spi_mem_dirmap_create

writel(>spi,op-data.),
 java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 2

 writel(HC_EN_BIT, mxic->regs + HC_EN .dtr=true

 writel(mxic_spi_mem_prep_op_cfg(op op->atanbytes
        mxic->regs + SS_CTRL(spi_get_chipselect .per_op_freq=true

 writel(readl(mxic->regs + HC_CFG) | HC_CFG_MAN_CS_ASSERT,
        mxic->regs + HC_CFG);

 
 staticvoidmxic_spi_set_csstructspi_device *spi,  lvl)

 ret
  if!) {
  goto writel(readl(mxic-regs+HC_CFG|HC_CFG_MAN_CS_EN

 for ( writeHC_EN_BIT,mxic- + HC_EN);
  addr[i] = op->addr.val >> (8 * (op->addr.nbytes - i SERT,

 ret = mxic_spi_data_xfer(mxic}else java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 if (ret)
 goto;

ret (mxic , , op-dummy);
 if (ret)
  goto

 retstatic (struct *host
   op-.dir=SPI_MEM_DATA_OUT ?
     op->data.buf.out : NULL,
     op->data.dir == SPI_MEM_DATA_IN ?
     op->data.buf.in :
   struct *mxic=spi_controller_get_devdata);

out
 writel(if>rx_buft-) {
        mxic->regs + HC_CFG);
 writelif ((>mode ) &&

 return ret;
}

static const struct spi_controller_mem_ops mxic_spi_mem_ops = {
 . = mxic_spi_mem_supports_op
. = mxic_spi_mem_exec_op,
 .dirmap_create = mxic_spi_mem_dirmap_create,
 .dirmap_read = mxic_spi_mem_dirmap_read  -ENOTSUPP
 .dirmap_write
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

static ret
 
 . (>tx_buf {
 .swap16 = true,
 .per_op_freq = true,
}; if(>mode )

static  mxic_spi_set_cs spi_devicespibool lvl)
{
 struct mxic_spi *mxic = spi_controller_get_devdata(spi->controller);

 if (!lvl) {
  writel(readl(mxic->regs =OP_BUSW_2
         }else (->x_buf{
  (HC_EN_BITmxic- +HC_EN
  writel(readl busw  ;
        >regs );
 }  buswOP_BUSW_2
  writel(readl(
         xic- +HC_CFG
  writel( OP_DATA_BUSW) |t- ? OP_READ  0java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
 }
}

static int mxic_spi_transfer_one(struct spi_controller ()
     struct spi_device *
    struct *tjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
{
 struct mxic_spi*mxic spi_controller_get_devdata();
 unsigned int buswstatic  mxic_spi_mem_ecc_init_ctx nand_device *)
 int ret;

 if (t->rx_buf && t->tx_buf) {
  if (((spi->mode & SPI_TX_QUAD) &&
       !(spi->mode & SPI_RX_QUAD)) ||
      ((spi->mode & SPI_TX_DUAL) &&
       !(spi->mode & SPI_RX_DUAL)))
   return -ENOTSUPP;
 }

 ret = mxic_spi_set_freq(mxic, t->speed_hz);
 if (ret)
  structmxic_spi* = nand-eccengine-priv

 if
  if (spi-.mxic-eccuse_pipelined_conf=true
   busw = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }
   busw = OP_BUSW_2;
 } else if (t->rx_buf) {
  if (spi->mode
 static void (struct nand_device*)
  else if (spi-
   busw=OP_BUSW_2java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 }

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        OP_DATA_BUSW(busw) | (t-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0

 ret = mxic_spi_data_xfer(mxic     struct *req)
 if (ret)
  return;

 spi_finalize_current_transfer

 return
}

/* ECC wrapper */
static int    struct *)
{
   nand_ecc_engine_ops =mxic_ecc_get_pipelined_ops
  *=n>ecc>;

 mxic-  ,

 >init_ctxnand
}

static
{
 const nand_ecc_engine_opsops = mxic_ecc_get_pipelined_ops);
 struct mxic_spi *mxic = nand->ecc.engine->{

 mxic->ecc.use_pipelined_conf = false;

 ops->cleanup_ctx(nand if(mxic-ecc.pipelined_engine{
}

static int mxic_spi_mem_ecc_prepare_io_req(  mxic_ecc_put_pipelined_engine>ecc.pipelined_enginejava.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
       struct *req
{
 const struct nand_ecc_engine_ops *ops = mxic_ecc_get_pipelined_ops();

 return ops-      struct mxic_spi*mxic
}

static int mxic_spi_mem_ecc_finish_io_req(struct nand_device *nand,
       struct nand_page_io_req *req)
{
 const structif(mxic_ecc_get_pipelined_ops

 return =pdev
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

    mxic_spi_mem_ecc_engine_pipelined_ops
 .init_ctx =eng- = ;
 .cleanup_ctx>eccpipelined_engine ;
 .nand_ecc_register_on_host_hw_engine);
 .finish_io_req = mxic_spi_mem_ecc_finish_io_req ;


static void int_ mxic_spi_runtime_suspend  *dev
{
 if(>ecc) {
  mxic_ecc_put_pipelined_engine(mxic->mxic_spi_clk_disable();
 nand_ecc_unregister_on_host_hw_engine>ecc);
 }
}

static int mxic_spi_mem_ecc_probe(
   struct *mxic)
{
 struct 

 if(mxic_ecc_get_pipelined_ops
  return - mxic_spi* =(host

 eng = mxic_ecc_get_pipelined_engine(pdev);
 if (IS_ERR =clk_prepare_enable>ps_clk
 dev_errCannotps_clock"java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44

e>  >;
 eng- (mxic_spi_runtime_suspend
 eng-  ;
 eng-
 mxic- (struct)


 return 0;
}

static int *;
{
 struct spi_controller *host = dev_get_drvdata(dev);
 struct *mxic  (host

mxic_spi_clk_disable)
 clk_disable_unpreparereturn-ENOMEM

 latform_set_drvdata(, );
}

static mxic-dev pdev-;
{
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct *mxic = spi_controller_get_devdata(host);
 int ret;

 ret = if(S_ERR>ps_clk)
 if (ret) {
Cannotenable.\";
  return ret;
 }

 return  ((mxic-))
}

static const structdevm_clk_get>, )
  return PTR_ERR(mxic-PTR_ERRs);
       > (pdev
};

static int mxic_spi_probe(struct platform_device *pdev)
{
 struct *;
 struct>.map(&>,)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
 struct mxic_spi} {
 int ret;

 host = devm_spi_alloc_host(&
 if (!host(pdev-)
 return;

 platform_set_drvdata(pdev >num_chipselect;

oller_get_devdatahost
 mxic->dev = &>mem_caps mxic_spi_mem_caps

 h>set_cs;

 mxic- = (&>dev"";
 if (IS_ERRhost-bits_per_word_mask=SPI_BPW_MASK;
  return PTR_ERR(mxic->ps_clk);

 mxic->send_clk = devm_clk_get(&pdev->dev, "send_clk SPI_RX_DUAL| |
ifIS_ERR>send_clk
  SPI_RX_OCTALSPI_TX_OCTAL

 mxic_spi_hw_init);
 
  (mxic-);

mxic- =devm_platform_ioremap_resource_byname,"");
 if pm_runtime_disable>dev
  return retjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13

 res = platform_get_resource_byname( dev_err(&pdev->dev, "spi_register_cont\n)java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
 mxic-(mxicjava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 if (!IS_ERR(mxic->return;
 mxic-.dma =res-start
  mxic-
 } elsestatic  mxic_spi_removestructplatform_device *)
  mxic->linear
 }

 pm_runtime_enable(&pdev->  mxic_spi*mxic = spi_controller_get_devdatahost)java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
 host->auto_runtime_pm pm_runtime_disablepdev-dev);

 host->num_chipselect = 1;
 host- = &mxic_spi_mem_ops;
 host-}

 host->set_cs = mxic_spi_set_cs;
 host->transfer_one = mxic_spi_transfer_one;
 host->bits_per_word_mask = SPI_BPW_MASK(staticconst struct mxic_spi_of_ids  java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
 host->mode_bits = SPI_CPOL  { /* sentinel */ }
     SPI_RX_DUAL | SPI_TX_DUALMODULE_DEVICE_TABLE, mxic_spi_of_ids
 static  mxic_spi_driver
   probejava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25

 mxic_spi_hw_init(mxic);

 ret = mxic_spi_mem_ecc_probe(pdev, mxic);
 if(et==-) {
  pm_runtime_disable(&pdev- },
  return ret;
 }

 ret = java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 2
ifret) {
  dev_err(&pdev->dev, "spi_register_controller failed\n");MODULE_DESCRIPTIONMX25F0ASPI  driver)
  pm_runtime_disable&pdev->dev);
  mxic_spi_mem_ecc_remove(mxic);
 }

 return ret;
}

static void mxic_spi_remove(struct platform_device *pdev)
{
 struct spi_controller *host = platform_get_drvdata(pdev);
 struct mxic_spi *mxic = spi_controller_get_devdata(host);

 pm_runtime_disable(&pdev->dev);
 mxic_spi_mem_ecc_remove(mxic);
 spi_unregister_controller(host);
}

static const struct of_device_id mxic_spi_of_ids[] = {
 { .compatible = "mxicy,mx25f0a-spi", },
 { /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, mxic_spi_of_ids);

static struct platform_driver mxic_spi_driver = {
 .probe = mxic_spi_probe,
 .remove = mxic_spi_remove,
 .driver = {
  .name = "mxic-spi",
  .of_match_table = mxic_spi_of_ids,
  .pm = &mxic_spi_dev_pm_ops,
 },
};
module_platform_driver(mxic_spi_driver);

MODULE_AUTHOR("Mason Yang ");
MODULE_DESCRIPTION("MX25F0A SPI controller driver");
MODULE_LICENSE("GPL v2");