Quelle  i2c-imx-lpi2c.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0+
/*
 * This is i.MX low power i2c controller driver.
 *
 * Copyright 2016 Freescale Semiconductor, Inc.
 */

#include <linux/clk.h>
#include <linux/completion.h>
#include <linux/delay.h>
#include <linux/dma-mapping.h>
#include <linux/dmaengine.h>
#include <linux/err.h>
#include <linux/errno.h>
#include <linux/i2c.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/io.h>
#include <linux/iopoll.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/pinctrl/consumer.h>
#include <linux/platform_device.h>
#include <linux/pm_runtime.h>
#include <linux/sched.h>
#include <linux/slab.h>

#define DRIVER_NAME "imx-lpi2c"

#define LPI2C_PARAM 0x04 /* i2c RX/TX FIFO size */
#define LPI2C_MCR 0x10 /* i2c contrl register */
#define LPI2C_MSR 0x14 /* i2c status register */
#define LPI2C_MIER 0x18 /* i2c interrupt enable */
#define LPI2C_MDER 0x1C /* i2c DMA enable */
#define LPI2C_MCFGR0 0x20 /* i2c master configuration */
#define LPI2C_MCFGR1 0x24 /* i2c master configuration */
#define LPI2C_MCFGR2 0x28 /* i2c master configuration */
#define LPI2C_MCFGR3 0x2C /* i2c master configuration */
#define LPI2C_MCCR0 0x48 /* i2c master clk configuration */
#define LPI2C_MCCR1 0x50 /* i2c master clk configuration */
#define LPI2C_MFCR 0x58 /* i2c master FIFO control */
#define LPI2C_MFSR 0x5C /* i2c master FIFO status */
#define LPI2C_MTDR 0x60 /* i2c master TX data register */
#define LPI2C_MRDR 0x70 /* i2c master RX data register */

#define LPI2C_SCR 0x110 /* i2c target control register */
#define LPI2C_SSR 0x114 /* i2c target status register */
#define LPI2C_SIER 0x118 /* i2c target interrupt enable */
#define LPI2C_SDER 0x11C /* i2c target DMA enable */
#define LPI2C_SCFGR0 0x120 /* i2c target configuration */
#define LPI2C_SCFGR1 0x124 /* i2c target configuration */
#define LPI2C_SCFGR2 0x128 /* i2c target configuration */
#define LPI2C_SAMR 0x140 /* i2c target address match */
#define LPI2C_SASR 0x150 /* i2c target address status */
#define LPI2C_STAR 0x154 /* i2c target transmit ACK */
#define LPI2C_STDR 0x160 /* i2c target transmit data */
#define LPI2C_SRDR 0x170 /* i2c target receive data */
#define LPI2C_SRDROR 0x178 /* i2c target receive data read only */

/* i2c command */
#define TRAN_DATA 0X00
#define RECV_DATA 0X01
#define GEN_STOP 0X02
#define RECV_DISCARD 0X03
#define GEN_START 0X04
#define START_NACK 0X05
#define START_HIGH 0X06
#define START_HIGH_NACK 0X07

#define MCR_MEN  BIT(0)
#define MCR_RST  BIT(1)
#define MCR_DOZEN BIT(2)
#define MCR_DBGEN BIT(3)
#define MCR_RTF  BIT(8)
#define MCR_RRF  BIT(9)
#define MSR_TDF  BIT(0)
#define MSR_RDF  BIT(1)
#define MSR_SDF  BIT(9)
#define MSR_NDF  BIT(10)
#define MSR_ALF  BIT(11)
#define MSR_MBF  BIT(24)
#define MSR_BBF  BIT(25)
#define MIER_TDIE BIT(0)
#define MIER_RDIE BIT(1)
#define MIER_SDIE BIT(9)
#define MIER_NDIE BIT(10)
#define MCFGR1_AUTOSTOP BIT(8)
#define MCFGR1_IGNACK BIT(9)
#define MRDR_RXEMPTY BIT(14)
#define MDER_TDDE BIT(0)
#define MDER_RDDE BIT(1)

#define SCR_SEN  BIT(0)
#define SCR_RST  BIT(1)
#define SCR_FILTEN BIT(4)
#define SCR_RTF  BIT(8)
#define SCR_RRF  BIT(9)
#define SSR_TDF  BIT(0)
#define SSR_RDF  BIT(1)
#define SSR_AVF  BIT(2)
#define SSR_TAF  BIT(3)
#define SSR_RSF  BIT(8)
#define SSR_SDF  BIT(9)
#define SSR_BEF  BIT(10)
#define SSR_FEF  BIT(11)
#define SSR_SBF  BIT(24)
#define SSR_BBF  BIT(25)
#define SSR_CLEAR_BITS (SSR_RSF | SSR_SDF | SSR_BEF | SSR_FEF)
#define SIER_TDIE// SPDX-License-Identifier: GPL-2.0+
#define SIER_RDIE BIT(1)
#define *
#define SIER_TAIE BIT(3)
#define SIER_RSIE *
defineSIER_SDIEBIT9
 SIER_BEIEBIT(0
#efineSIER_FEIE(11)
#define SIER_AM0F BIT(12)
#efineSCFGR1_RXSTALLBIT)
#define SCFGR1_TXDSTALL BIT(2)
#define SCFGR2_FILTSDA_SHIFT 24
#define SCFGR2_FILTSCL_SHIFT 16
#define SCFGR2_CLKHOLD(x) (x)
#define SCFGR2_FILTSDA(x) ((x) << SCFGR2_FILTSDA_SHIFT)
#define SCFGR2_FILTSCL(x) ((x) << SCFGR2_FILTSCL_SHIFT)
#define SASR_READ_REQ 0x1
#define SLAVE_INT_FLAG (SIER_TDIE | SIER_RDIE | SIER_AVIE | \
    SIER_SDIE | SIER_BEIE)

#define I2C_CLK_RATIO 2
#define CHUNK_DATA 256

#define I2C_PM_TIMEOUT  10 /* ms */
#define I2C_DMA_THRESHOLD 8 /* bytes */

enum lpi2c_imx_mode {
 STANDARD, /* 100+Kbps */
 FAST,  /* 400+Kbps */
 FAST_PLUS, /* 1.0+Mbps */
 HS,  /* 3.4+Mbps */
 ULTRA_FAST, /* 5.0+Mbps */
};

enum lpi2c_imx_pincfg {
 TWO_PIN_OD,
 TWO_PIN_OO,# <linuxdmaengineh>
 TWO_PIN_PP
 ,
#include </inith

struct lpi2c_imx_dma {
 bool  using_pio_mode;
 u8  rx_cmd_buf_len#include<linux/ioh>
 u8  dma_buf#nclude<inuxkernel
 u16  *rx_cmd_buf;
 unsigned int dma_len </of.h>
 unsignedinttx_burst_num
unsigned rx_burst_num;
 #include/pm_runtime.h>
 resource_size_t phy_addr;
 dma_addr_t dma_tx_addr;
 dma_addr_t dma_addr;
 enum dma_data_direction dma_data_dir;
 enum dma_transfer_direction dma_transfer_dir;
 struct dma_chan *chan_tx;
 struct dma_chan *chan_rx;
};

struct lpi2c_imx_struct {
 struct i2c_adapter adapter;
 int#include <linux.h>
 struct clk_bulk_data *clks;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 _define 0 /* i2c status register */#efine LPI2C_MIER 0 /* i2c interrupt enable */
 __u8 # LPI2C_MCFGR0 0 /* i2c master configuration */
 struct completion complete;
 unsigned long  rate_perdefineLPI2C_MCFGR2028/* i2c master configuration */
 #defineLPI2C_MCCR00 /* i2c master clk configuration */#define LPI2C_MCCR10 /* i2c master clk configuration */
 unsigned int  #define LPI2C_MFSR0 /* i2c master FIFO status */
 unsigned int  block_data
 unsigned intdefineLPI2C_MRDR 0 /* i2c master RX data register */
 unsigned int  txfifosize;
 unsigned int rxfifosize
 enumlpi2c_imx_modemode
 structi2c_bus_recovery_info;
 booldefineLPI2C_SCFGR0 0x120 /* i2c target configuration */

 struct i2c_client *;
};

#define lpi2c_imx_read_msr_poll_timeout(atomic, val, cond)# LPI2C_SCFGR2 0x128
 (efine LPI2C_SAMRx140
         cond, 0, 500000) #define LPI2C_SASR0 /* i2c target address status */
    readl_poll_timeout(lpi2c_imx-># LPI2C_STDR x160
 # LPI2C_SRDR 0 /* i2c target receive data */

/
   # TRAN_DATA 0
{define 0X01
 writel, lpi2c_imx->base LPI2C_MIER;
}

static int lpi2c_imx_bus_busy(struct lpi2c_imx_structdefine 0X05
{
 unsigned int#efine MCR_MENBIT(0
 interr

 err BIT)
         & MSR_ALF  | MSR_MBF;

 /* check for arbitration lost, clear if set */
 if ( & MSR_ALF){
  writel# MSR_TDF BIT
 return EAGAIN
 }

 /* check for bus not busy */  BIT)
iferr
  dev_dbg# MSR_MBF(24)
  (>adapter)
   i2c_recover_bus(&lpi2c_imx-#efineMIER_TDIE(0
  # BIT)
 }

 return;
}

static u32 lpi2c_imx_txfifo_cnt BIT4)
{
 return readl(lpi2c_imx->base + LPI2C_MFSR) & 0xff  BIT1
}

static void lpi2c_imx_set_mode(struct SCR_FILTEN (4)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
unsigned bitratelpi2c_imx-;
#   BITjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23

 if (java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
mode=;
define BIT)
  mode = FAST;
 else if (bitrate < #efine BIT2
  mode=FAST_PLUS
 else if (# SIER_SDIE (9)
 mode HS;
 else
  mode SIER_FEIEBIT(11

 lpi2c_imx->mode mode;
}define BIT1)

static int lpi2c_imx_start(struct lpi2c_imx_struct *lpi2c_imx,
  structi2c_msgmsgs bool)
{
 unsigned int temp;

 temp = #SCFGR2_FILTSCL_SHIFT 16
RTF
 (temp, >base+LPI2C_MCR;
# SCFGR2_FILTSCLx)(x) < SCFGR2_FILTSCL_SHIFT

 tempdefineSLAVE_INT_FLAG(IER_TDIE SIER_RDIE |SIER_AVIE|\
 writel(temp,     | SIER_BEIE

returnlpi2c_imx_bus_busylpi2c_imx atomic);
}

static void lpi2c_imx_stop(struct lpi2c_imx_struct *lpi2c_imx, bool atomic)
{
 unsigned int temp;
 int err;

 # I2C_DMA_THRESHOLD  /* bytes */

 _poll_timeout, temptemp)

 if FAST_PLUS /* 1.0+Mbps */
  , /* 5.0+Mbps */
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   struct lpi2c_imx_dma {
 }
}

/* CLKLO = I2C_CLK_RATIO * CLKHI, SETHOLD = CLKHI, DATAVD = CLKHI/2 */
static int lpi2c_imx_config(struct lpi2c_imx_struct *lpi2c_imx)
{
 u8 prescale, filt bool  using_pio_mode
unsigned intclk_rate clk_cycle , clklo;
 ncfg pincfg
 unsignedint temp

 lpi2c_imx_set_mode(lpi2c_imx);

 clk_rate = lpi2c_imx->rate_per;

resource_size_t phy_addr
  = 0;
 else
  filt = 2;

 for (prescale = 0; prescale <= dma_addr_t;
  clk_cycle=clk_rate (1 < prescale  lpi2c_imx-bitrate
       - 3 enum dma_t dma_transfer_dir;
  clkhi = DIV_ROUND_UP(clk_cycle dma_chan *han_tx
 = clk_cycle -clkhi
 if(clklo 6)
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

ifprescale 7java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
 returnEINVAL

 /* set MCFGR1: PINCFG, PRESCALE, IGNACK */
if(>mode==ULTRA_FAST)
  unsigned  msglen
 else
  = TWO_PIN_OD
temp prescale|pincfg<2;

-mode= ULTRA_FAST
  temp |= unsigned  intrxfifosize

 writel i2c_bus_recovery_info;

 /* set MCFGR2: FILTSDA, FILTSCL */
  struct i2c_client *target};
 writel#define lpi2c_imx_read_msr_poll_timeout(atomic, val, cond)                    \

 /* set MCCR: DATAVD, SETHOLD, CLKHI, CLKLO */ (atomic ? readl_poll_timeout_atomic(lpi2c_imx->base + LPI2C_MSR, val, \
 sethold = clkhi;
 datavd =    readl_poll_timeout(lpi2c_imx->base + LPI2C_MSR, val, cond,  \
 temp = datavd << 24 | java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if {
  writel(temp, lpi2c_imx-}
 else
  writel(temp, lpi2c_imx->base + LPI2C_MCCR0{

 return 0;
}

static           temp & (MSR_ALF | MSR_BBF java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 unsignedint temp
 intret;

 ret = pm_runtime_resume_and_get(lpi2c_imx->adapter.dev.parent java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 if (ret  (&lpi2c_imx-.dev "usnotworkn")
  E;

 temp = MCR_RST;
writel, >base+LPI2C_MCR)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 ret =
 if  void(struct lpi2c_imx_struct *lpi2c_imx)
  goto rpm_put;

 temp = readl
  |;
   struct *, bool)

 return 0;

rpm_put:
 pm_runtime_mark_last_busy(lpi2c_imx->adapter.dev.parent);
 pm_runtime_put_autosuspend(lpi2c_imx-> temp readl(lpi2c_imx- + LPI2C_MCR;

 return ret writel(temp >base+ LPI2C_MCRjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
}

 ritel, lpi2c_imx-base LPI2C_MTDR);
{
 u32 tempreturnlpi2c_imx_bus_busy(lpi2c_imx );

 temp =static void(struct  *lpi2c_imx  atomic)
 temp &= ~MCR_MEN;
 writel(temp, lpi2c_imx->base + LPI2C_MCR);

 pm_runtime_mark_last_busy(lpi2c_imx->adapter.dev.{
 pm_runtime_put_autosuspend(lpi2c_imx->adapter.dev.parent);

 return0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
}

static int err = lpi2(atomic, , temp&MSR_SDF;
{
 unsigned long;

 time_left dev_dbglpi2c_imx-adapterdev, " timeout\";

 return time_left ? 0 : -ETIMEDOUT;
}

static intlpi2c_imx_txfifo_emptystruct *lpi2c_imx bool atomic
{
 unsigned int
 int err;

 err = lpi2c_imx_read_msr_poll_timeout(atomic, temp,
static intlpi2c_imx_configstruct lpi2c_imx_structlpi2c_imx

 if   prescale filtsethold datavd;
  dev_dbg(&lpi2c_imx-.dev,"NDF detected\n";
  return -EIO;
 }

  (err {
  
  lpi2c_imx_set_modelpi2c_imx);
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return -ETIMEDOUT;
 }

 return 0;
}

static void lpi2c_imx_set_tx_watermark(struct lpi2c_imx_struct *lpi2c_imx)
{
writellpi2c_imx->txfifosize> ,lpi2c_imx-base + LPI2C_MFCR;
}

static void lpi2c_imx_set_rx_watermarkelse
{
 unsigned int for (prescale = 0;prescale=;p++) {

 remaining = lpi2c_imx->msglen - lpi2c_imx->delivered;

 if (remaining >    -  -(filt>1;
  temp =lpi2c_imx-rxfifosize> 1
 else clklo - clkhi
  ifclklo 64java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17

 writel(temp << 16, lpi2c_imx->base + LPI2C_MFCR returnEINVAL
}

static boolif(>mode )
{
 unsigned

 txcnt = readl(lpi2c_imx-t = prescale | pincfg <2;

 while (txcnt < lpi2c_imx->txfifosize) {
 if(lpi2c_imx-> == lpi2c_imx-)
   break;

 datalpi2c_imx->[lpi2c_imx-delivered]
  writel /* set MCFGR2: FILTSDA, FILTSCL */ = ( << 6 |filt 2)
 txcnt
 }

 if (lpi2c_imx->delivered sethold ;
   if(!tomic
  lpi2c_imx_intctrllpi2c_imx,  | MIER_NDIE;
  return false;
 }

 if (!atomic)
   if(>mode= HS)

 return true;
}

static lpi2c_imx_read_rxfifostruct *lpi2c_imx bool)
{
 unsigned (temp lpi2c_imx-> + LPI2C_MCCR0
   0

 do {
  data static lpi2c_imx_master_enable lpi2c_imx_struct*pi2c_imx)
 if(ata MRDR_RXEMPTY)
   break  inttemp

  lpi2c_imx-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 } while ( if ret 0

 /*
 * First byte is the length of remaining packet in the SMBus block
 * data read. Add it to msgs->len.
 */
 if (lpi2c_imx->block_data) {
 b = lpi2c_imx-rx_buf0]
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if()

 remaining lpi2c_imx-msglen lpi2c_imx-delivered

 if (!remainingtemp = readl>base+LPI2C_MCR
  )
   complete(temp,lpi2c_imx- + LPI2C_MCR;
  return
  return 0;

 /* not finished, still waiting for rx data */
lpi2c_imx_set_rx_watermark);

 /* multiple receive commands */
 if (lpi2c_imx- ret
  lpi2c_imx-}
  temp = remaining;
  temp |= (RECV_DATA << 8);
  writel int lpi2c_imx_master_disablestruct *lpi2c_imx)
 } else if (!(lpi2c_imx->delivered & 0xff)) {
   32;
  tempjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 writel, lpi2c_imx- + LPI2C_MTDR;
 }

 if (!atomic)
  lpi2c_imx_intctrl(lpi2c_imx, MIER_RDIE);

 returnfalse
}

static void lpi2c_imx_write(struct lpi2c_imx_struct *lpi2c_imx,
      structi2c_msgmsgs
{
 lpi2c_imx-tx_buf msgs-buf
 lpi2c_imx_set_tx_watermark(lpi2c_imx)}
 lpi2c_imx_write_txfifo(lpi2c_imx, false);
}

static  lpi2c_imx_write_atomicstructlpi2c_imx_structlpi2c_imx
      struct
{
 u32 temp;
 int err;

 lpi2c_imx-tx_buf msgs->buf

 err   time_left 0 :-ETIMEDOUT;
    }
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (temp & MSR_NDF)
  return -EIO;

 return err
}

static  lpi2c_imx_read_init lpi2c_imx_struct*pi2c_imx,
    struct i2c_msg *msgs)
{
 unsignedint temp

 lpi2c_imx->rx_buf = msgs->buf;
 lpi2c_imx->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  -;
 temp
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
w(temp>base+);
}

static bool lpi2c_imx_read_chunk_atomic(struct lpi2c_imx_struct *lpi2c_imx)
{
 u32 rxcnt;

 rxcnt = (readl(lpi2c_imx->base + LPI2C_MFSR) >> rxcnt = (readl(lpi2c_imx->base + LPI2C_MFSR) >> 
 if eturn0
  return}

 if (!lpi2c_imx_read_rxfifo(lpi2c_imx, true))
  return false;

 return true;
}

static int lpi2c_imx_read_atomic
     struct i2c_msgstatic  lpi2c_imx_set_rx_watermarkstructlpi2c_imx_structlpi2c_imx
{
 u32 temp;
 int tmo_us;

t = 0000;
 do {
  if (lpi2c_imx_read_chunk_atomic(lpi2c_imx))
  return 0

     = lpi2c_imx-rxfifosize > 1

  ( & MSR_NDF
   return - (temp< 6 >baseLPI2C_MFCR

  udelay(100);
  tmo_us -= 100;
 } while (tmo_us > 0);

 return -ETIMEDOUT;
}

static bool is_use_dma(struct lpi2c_imx_struct *lpi2c_imx, struct i2c_msg *msg)
{
 if (lpi2c_imx-can_use_dma
  return false; unsignedint data, ;

 /*
 * When the length of data is less than I2C_DMA_THRESHOLD,
 * cpu mode is used directly to avoid low performance.
 */
 return !(msg->len < I2C_DMA_THRESHOLDiflpi2c_imx- == lpi2c_imx-msglen
}

static int lpi2c_imx_pio_xfer(struct lpi2c_imx_struct *lpi2c_imx,
   ++;
{
 reinit_completion

 if(sg-flags ) {
  lpi2c_imx_read_init(lpi2c_imx, msg);
  lpi2c_imx_intctrl(lpi2c_imx, MIER_RDIE | MIER_NDIE);
 } else {
i2c_imx_writelpi2c_imx msg;
 }

 return lpi2c_imx_pio_msg_complete eturn;
}

static int lpi2c_imx_pio_xfer_atomic (atomic
   structi2c_msg*msg
{
 if (msg->flags true
  lpi2c_imx_read_init(lpi2c_imx
  static boollpi2c_imx_read_rxfifo(struct lpi2c_imx_structlpi2c_imx bool)
 }

  lpi2c_imx_write_atomic, msg);
}

static int lpi2c_imx_dma_timeout_calculate(struct lpi2c_imx_struct *lpi2c_imx)
{
 unsigned long data (lpi2c_imx-base+LPI2C_MRDR);

 time = 8 * lpi2c_imx->dma->dma_len * 1000 / lpi2c_imx->bitrate;

  lpi2c_imx-rx_buf[lpi2c_imx-delivered+]= & 0xff
 time while(1;

 /* Double calculated time *//*
return secs_to_jiffies(time);
}

static int lpi2c_imx_alloc_rx_cmd_buf(struct lpi2c_imx_struct *lpi2c_imx)
{
struct lpi2c_imx_dma *dma = lpi2c_imx->dma;
u16 rx_remain = dma->dma_len;
int cmd_num;
u16 temp;

/*
 * Calculate the number of rx command words via the DMA TX channel
 * writing into command register based on the i2c msg len, and build
 * the rx command words buffer.
 */
cmd_num (rx_remain CHUNK_DATA;
 dma->rx_cmd_buf = kcalloc(cmd_num, sizeof(u16), GFP_KERNEL);
 dma- = cmd_num*sizeofu16);

 ifif (remaining{
  dev_err(&lpi2c_imx->adapter.dev, "Alloc RX cmd buffer
  return-NOMEM
 }

 for (int i = 0; i < cmd_num ; }
  temp =/* not finished, still waiting for rx data */
  temp|=(RECV_DATA < 8);
  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
 d>[ =temp;
 }

 return 0;
}

static int lpi2c_imx_dma_msg_complete(struct lpi2c_imx_struct *lpi2c_imx  |= ( < 8;
{
 unsigned longtime_left,time

 time = lpi2c_imx_dma_timeout_calculate(lpi2c_imx);
time_left =wait_for_completion_timeout&lpi2c_imx->, time);
 if (time_left  writeltemp lpi2c_imx-base + LPI2C_MTDR)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  returnjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 }

 return  structi2c_msgmsgs
}

 void lpi2c_dma_unmapstruct  *dma
{
 struct dma_chanchan  dma-> == 
    ? dma->chan_rx : dma-

 dma_unmap_single>device-devdma->dma_addr,
    s i2c_msgmsgs

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

static void lpi2c_cleanup_rx_cmd_dma(struct lpi2c_imx_dma *dma)

 (dma-);
 dma_unmap_single(dma- ( & MSR_NDF)
   dma-, );
}

static void java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0
{
 if  i2c_msgmsgs)
 (>);
else dma- = )
  dmaengine_terminate_sync(dma->chan_tx)

 lpi2c_dma_unmap(dma);
}

static void lpi2c_dma_callback(void * lpi2c_imx_set_rx_watermark(lpi2c_imx;
{
 struct lpi2c_imx_struct *lpi2c_imxtemp | RECV_DATA<8;

 complete(&lpi2c_imx->complete);
}

static int lpi2c_dma_rx_cmd_submit(struct lpi2c_imx_struct *lpi2c_imx)
{
 structdma_async_tx_descriptorrx_cmd_desc
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct dma_chan *txchan = dma->chan_txif !)
 dma_cookie_t;

 dma->dma_tx_addr 
         (!(lpi2c_imx ))
       DMA_TO_DEVICE false
 if (java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 13
  dev_err(&lpi2c_imx->adapter.dev, "DMA map failed, use pio\n");
  return -EINVAL;
 }staticintlpi2c_imx_read_atomicstructlpi2c_imx_struct*pi2c_imx

 rx_cmd_desc = {
    u32;
        java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 12
 if (!rx_cmd_desc = 1000000;
  dev_err {
  goto desc_prepare_err_exit  (lpi2c_imx_read_chunk_atomiclpi2c_imx))
 }

 cookie temp readl(lpi2c_imx-base LPI2C_MSR;
 if (dma_submit_error(cookie)) {
  dev_err(&lpi2c_imx->adapter.dev, "submitting DMA failed, use pio\n");
  goto submit_err_exit;
 }

dma_async_issue_pending);

 return   return -EIO

desc_prepare_err_exit
 dma_unmap_singletmo_us= 10;
    dma- }whiletmo_us 0;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

submit_err_exit:
 dma_unmap_single(txchan-
   dma-rx_cmd_buf_len, DMA_TO_DEVICE
 dmaengine_desc_free(rx_cmd_desc
 returnif(lpi2c_imx-can_use_dma
}

static int lpi2c_dma_submit(struct lpi2c_imx_struct *lpi2c_imx)
{
 struct lpi2c_imx_dma
  dma_async_tx_descriptor
  c;
 ;

 if (dma->dma_msg_flag & I2C_M_RD) {
  chan = dma->chan_rx;
 dma-java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  dma-(&lpi2c_imx-complete)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
 }else
  lpi2c_imx_read_initlpi2c_imx, );
  dma->dma_data_dirlpi2c_imx_intctrl, MIER_RDIE MIER_NDIE;
 }elsejava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 }

dma- = dma_map_single>device-,
           dma-}
 if (dma_mapping_error intlpi2c_imx_pio_xfer_atomic  *,
 dev_err>adapter, "DMA ,usepion")
  return ifmsg- & I2C_M_RDjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

(chandma-,
        dma->dma_len
     static  lpi2c_imx_dma_timeout_calculate  *lpi2c_imx)
 java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
  dev_errtime   *lpi2c_imx->>dma_len 00 /lpi2c_imx-;
  goto desc_prepare_err_exit; /* Add extra second for scheduler related activities */
 }

 reinit_completionlpi2c_imx-complete;
 desc- ()java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
 desc->callback_param = lpi2c_imx;

 cookie dmaengine_submitdesc
 ifu16 rx_remain dma->dma_len
  intcmd_num
  goto temp
 }

 /* Can't switch to PIO mode when DMA have started transfer */  * Calculate the number of rx command words via the  * writing into command register based on the i2c msg len, and  * the rx command words buffer  
dma- ;

  >rx_cmd_bufkcalloccmd_numsizeof),GFP_KERNEL)java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61

   !>rx_cmd_bufjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24

desc_prepare_err_exit:
 (dma;
 return -EINVAL;

_exit
 lpi2c_dma_unmap(dma);
 dmaengine_desc_free(desc);
 return   |=( <<8;
}

static int lpi2c_imx_find_max_burst_num(unsigned int fifosize, unsigned int len)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  0;

 for
  static lpi2c_imx_dma_msg_complete lpi2c_imx_struct)
   break;

 return i;
}

/* =lpi2c_imx_dma_timeout_calculate);
 * For a highest DMA efficiency, tx/rx burst number should be calculated according
 * to the FIFO depth.
 */
static(lpi2c_imx-.dev"OError n Transfern)
{
  lpi2c_imx_dma = >dma
 unsigned int cmd_num;

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  /*
 * One RX cmd word can trigger DMA receive no more than 256 bytes.
 * The number of RX cmd words should be calculated based on the data
 * length.
 */
  cmd_num = DIV_ROUND_UP(dma->dma_len, java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 34
 = lpi2c_imx_find_max_burst_num(>txfifosize
       dma-, dma-);
  dma-
       dma-);
 }
  dma->tx_burst_num =static lpi2c_cleanup_rx_cmd_dmal *dma
         dma- (dma-);
 }
}

static  lpi2c_cleanup_dmastruct *)

   dma- = )
struct rx }  = }java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
 int ret;

 lpi2c_imx_dma_burst_num_calculatelpi2c_imx);

 lpi2c_dma_unmap);
 
  tx.dst_addr_width = DMA_SLAVE_BUSWIDTH_2_BYTES;
  tx.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  tx.direction = DMA_MEM_TO_DEV;
  ret = dmaengine_slave_config lpi2c_imx_structlpi2c_imx =( lpi2c_imx_structdata
  if
 r ret;

  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  rx.src_addr_width = DMA_SLAVE_BUSWIDTH_1_BYTE;
  rx.src_maxburst = struct dma_async_tx_descriptorrx_cmd_desc;
 rxdirection= DMA_DEV_TO_MEM
  ret = dmaengine_slave_config(  dma_chantxchan = >chan_tx
  ifret 0
   return ret;
  else{
    dma-, dma-,
  tx     DMA_TO_DEVICE;
  tx.dst_maxburst ((txchan-device->, dma-)) {
  tx.direction = DMA_MEM_TO_DEV;
  ret = dmaengine_slave_config(dma->chan_tx, &tx) dev_errlpi2c_imx-.dev" mapfailed,use pio\")
 ifret )
   return
 }

 return 0;
}

static void lpi2c_dma_enable(struct lpi2c_imx_struct *lpi2c_imx)
{
   !) {
 /*
 * TX interrupt will be triggered when the number of words in
 * the transmit FIFO is equal or less than TX watermark.
 * RX interrupt will be triggered when the number of words in
 * the receive FIFO is greater than RX watermark.
 * In order to trigger the DMA interrupt, TX watermark should be
 * set equal to the DMA TX burst number but RX watermark should
 * be set less than the DMA RX burst number.
 */
 if (dma->dma_msg_flag & I2C_M_RD) {
  /* Set I2C TX/RX watermark */
  writel(dma->tx_burst_num|(dma->rx_burst_num - 1)<<16
         lpi2c_imx->base + LPI2C_MFCR);
 /
  writel(MDER_TDDE | MDER_RDDE, lpi2c_imx-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 } else {
  /* Set I2C TX watermark */
  writel(dma->tx_burst_num, lpi2c_imx->base + LPI2C_MFCR);
 /* Enable I2C DMA TX function */
  writel(MDER_TDDE, lpi2c_imx->base goto;
 }

 /* Enable NACK detected */
 lpi2c_imx_intctrl(lpi2c_imx 0;
};

/*
 * When lpi2c is in TX DMA mode we can use one DMA TX channel to write
 * data word into TXFIFO, but in RX DMA mode it is different.
 *
 * The LPI2C MTDR register is a command data and transmit data register.
 * Bits 8-10 are the command data field and Bits 0-7 are the transmit
 * data field. When the LPI2C master needs to read data, the number of
 * bytes to read should be set in the command field and RECV_DATA should
 * be set into the command data field to receive (DATA[7:0] + 1) bytes.
 * The recv data command word is made of RECV_DATA in the command data
 * field and the number of bytes to read in transmit data field. When the
 * length of data to be read exceeds 256 bytes, recv data command word
 * needs to be written to TXFIFO multiple times.
 *
 * So when in RX DMA mode, the TX channel also must to be configured to
 * send RX command words and the RX command word must be set in advance
 * before transmitting.
 */
static int lpi2c_imx_dma_xfer(struct lpi2c_imx_struct *lpi2c_imx dma-, DMA_TO_DEVICE;
         struct i2c_msg *msg)
{
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 int ret;

 /* When DMA mode fails before transferring, CPU mode can be used. */
 dma->using_pio_mode = true;

 s dma_chan*chan;
_ =msg-;
 dma->dma_buf (ma-dma_msg_flag ) java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 if >dma_transfer_dir;
  return} else

 ret>dma_data_dir ;
  dma- = ;
  dev_err(&lpi2c_imx->java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 0
  goto disable_dma       >, dma-, dma-);
}

 lpi2c_dma_enable(lpi2c_imx);

 ret = lpi2c_dma_submit(lpi2c_imx) dev_err(lpi2c_imx->.dev" failed, \";
 if (ret) {
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  goto disable_dma;
 }

 dma-  )java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
buf);
  ifgoto;
   goto disable_cleanup_data_dma;

  ret = lpi2c_dma_rx_cmd_submit(lpi2c_imx);
  if (ret)
  goto disable_cleanup_data_dma
 }

 ret =  cookie = dmaengine_submit);
 if (ret ((cookie) java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 goto disable_cleanup_all_dma

 NACKin transfer, upall transfers/
 if ((readl(lpi2c_imx->base + LPI2C_MSR) & MSR_NDF) && !ret) {
  = EIO
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

 if(>dma_msg_flag I2C_M_RD
 
  dma-, DMA_TO_DEVICE
 lpi2c_dma_unmap(dma);

 goto disable_dma;

isable_cleanup_all_dma:
 dma- &)

disable_cleanup_data_dma
 (dma
disable_dma:
 /* Disable I2C DMA function */
 writel

if>dma_msg_flag)
  kfree(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 if (ret)
  i2c_put_dma_safe_msg_buf(dma->dma_buf, msg, false)  if!leni)
 else
 i2c_put_dma_safe_msg_buf>dma_bufmsg);

 return ret
}

static int lpi2c_imx_xfer_common(struct i2c_adapter *adapter,
     struct i2c_msg  lpi2c_imx_dma_burst_num_calculate lpi2c_imx_struct)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct lpi2c_imx_struct *lpi2c_imx = i2c_get_adapdata(adapter);
 unsigned int temp;
 int i resultjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15

 result = lpi2c_imx_master_enable(lpi2c_imx);
 if (result)
  return result;

 for (i = 0; i < num; i cmd_num (dma-, CHUNK_DATA)
  result(lpi2c_imxmsgs,atomic);
  if (result)
   goto disable;

  /* quick smbus */
  ifnum 1 msgs[].len == )
     dma->rx_burst_num=lpi2c_imx_find_max_burst_num>,

 lpi2c_imx- = NULL
  lpi2c_imx->tx_buf  {
  lpi2c_imx->delivered = 0;
  lpi2c_imx->msglen = msgs[i].len;

  if (atomic) {
   = lpi2c_imx_pio_xfer_atomic, &[i])java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
 }else {
   init_completion(&lpi2c_imx->complete)java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

   if (is_use_dma(lpi2c_imx, & dma_slave_config = } tx };
    result = lpi2c_imx_dma_xfer
    ifresultlpi2c_imx->using_pio_mode
     resultif dma- & I2C_M_RD{
   } else {
    result = lpi2c_imx_pio_xfer( tx = >phy_addrLPI2C_MTDR
  }
  }

  if ( tx. = DMA_MEM_TO_DEV;
  goto;

  if (!(msgs[i].flags & I2C_M_RD)) {
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   if (result)
    stop
  }
}

stop:
 lpi2c_imx_stop(lpi2c_imx, atomic);

temp=readl>base );
 if ((temp & MSR_NDF ( < 0
  result = -EIO;

disable:
lpi2c_imx_master_disable);

 dev_dbglpi2c_imx->adapter., " _,
  (result.direction ;
    ret

 returnjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
}

static int java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 1
structlpi2c_imx_dmadma=lpi2c_imx-dma;
 return lpi2c_imx_xfer_common
}

static int lpi2c_imx_xfer_atomic(struct i2c_adapter *  * the transmit FIFO is equal or less than TX  * RX interrupt will be triggered when the number  * the receive FIFO is greater than RX watermark.
{
 return lpi2c_imx_xfer_common(adapter, msgs, num, true);  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

static irqreturn_t  writel>tx_burst_num (>rx_burst_num1)< 6java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
     u32 ssr,  u32 ssr, u32 /RX */
{
 u8 value;
 u32 sasr;

 /* Arbitration lost */
 if (sier_filter & SSR_BEF)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 writel >baseLPI2C_SIER)
  return IRQ_HANDLED;
 }

 /* Address detected */
 ifjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  =(lpi2c_imx- + )java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  if (SASR_READ_REQ & sasr
   /* Read request */
   i2c_slave_event * data word into TXFIFO, but in RX DMA mode *
   writel(value, lpi2c_imx->base + LPI2C_STDR);
   goto ret;
  } else {
   /* Write request */
   i2c_slave_event * bytes to read should be set in the command field and RECV_DATA should
  }
 }

 if (sier_filter & SSR_SDF)
  /* STOP */
  i2c_slave_event * field and the number of bytes to read in transmit  * length of data to be read exceeds 256 bytes, recv data command * needs to be written to TXFIFO multiple times.

 if (sier_filter & SSR_TDF) {
  /* Target send data */
lave_event>target, &value
  writel        structi2c_msg *msg
 }

 if( & SSR_RDF {
  /* Target receive data */
  value = readl(lpi2c_imx->base + LPI2C_SRDR nt;
  i2c_slave_event(lpi2c_imx->targetjava.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
 }

ret
 /* Clear SSR */>ma_msg_flag  >flags
writel &SSR_CLEAR_BITS >baseLPI2C_SSR);
 return IRQ_HANDLED (dma-)
}

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 unsigned intenabled;
 unsigned int  dev_err>adapter, Failed  DMAd\"ret;

 enabled = readl  goto disable_dma;

 lpi2c_imx_intctrl(lpi2c_imx, 0);l(lpi2c_imx;
 temp = readl(lpi2c_imx->base + LPI2C_MSR);
 temp &= enabled;

 if (temp () {
  complete>adapter, " submission failed (%d\"r)
  if(tempMSR_RDF
  lpi2c_imx_read_rxfifo(lpi2c_imx, false);
 else if (temp & MSR_TDF)
  lpi2c_imx_write_txfifo(lpi2c_imx, false);

 return IRQ_HANDLED;
}

static irqreturn_t lpi2c_imx_isr(int irq
{
 struct lpi2c_imx_struct if()

 if (lpi2c_imx->target) {
  u32 scr =java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
 * When encountering NACK in transfer, clean up all DMA transfers */
  u32 ((>baseLPI2C_MSR)&MSR_NDF&!) {

  /*
 * The target is enabled and an interrupt has been triggered.
 * Enter the target's irq handler.
 */
  if ((scr
   returnif(ma-> & I2C_M_RDjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 }

 /*
 * Otherwise the interrupt has been triggered by the master.
 * Enter the master's irq handler.
 */
 returnlpi2c_imx_master_isr();
}ifdma- & 2)

static void lpi2c_imx_target_init:
{
 u32 temp;

 /* reset target module */
 writel(0,lpi2c_imx- + );
 writel(0, lpi2c_imx->base + LPI2C_SCR) if (dma- & I2C_M_RDjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34

 /* Set target address */
 writellpi2c_imx->addr<1,lpi2c_imx- + LPI2C_SAMR)

 java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

 /*
 * set SCFGR2: FILTSDA, FILTSCL and CLKHOLD
 *
 * FILTSCL/FILTSDA can eliminate signal skew. It should generally be
 * set to the same value and should be set >= 50ns.
 *
 * CLKHOLD is only used when clock stretching is enabled, but it will
 * extend the clock stretching to ensure there is an additional delay
 * between the target driving SDA and the target releasing the SCL pin.
 *
 * CLKHOLD setting is crucial for lpi2c target. When master read data
 * from target, if there is a delay caused by cpu idle, excessive load,
 * or other delays between two bytes in one message transmission, it
 * will cause a short interval time between the driving SDA signal and
 * releasing SCL signal. The lpi2c master will mistakenly think it is a stop
 * signal resulting in an arbitration failure. This issue can be avoided
 * by setting CLKHOLD.
 *
 * In order to ensure lpi2c function normally when the lpi2c speed is as
 * low as 100kHz, CLKHOLD should be set to 3 and it is also compatible with
 * higher clock frequency like 400kHz and 1MHz.
 */
 temp = SCFGR2_FILTSDA(2) | SCFGR2_FILTSCL(2java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 writel(temp, lpi2c_imx->base = lpi2c_imx_start(, &sgsi,);

 /*
 * Enable module:
 * SCR_FILTEN can enable digital filter and output delay counter for LPI2C
 * target mode. So SCR_FILTEN need be asserted when enable SDA/SCL FILTER
 * and CLKHOLD.
 */
 writel(SCR_SEN | SCR_FILTEN, lpi2c_imx->base + LPI2C_SCR

 /* Enable interrupt from i2c module */ > = NULL
, >baseLPI2C_SIER
}

static int lpi2c_imx_register_target(struct i2c_client *client)
{
 struct lpi2c_imx_struct *lpi2c_imx = i2c_get_adapdata(client-result(lpi2c_imx &[i])
 int ret;

 if (lpi2c_imx-
  return - if is_use_dma, &msgs])java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41

 lpi2c_imx->target = client;

 ret  result(lpi2c_imx&[i)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
 if (ret < 0) {
  dev_err(&lpi2c_imx->adapter.dev, 
  return ret;}
 }

 lpi2c_imx_target_init(lpi2c_imx);

 return 0;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static  lpi2c_imx_unregister_target  *)
{
struct *lpi2c_imx (client-);
 int ret;

 if (!lpi2c_imx->target)
  return -EINVAL;

 /* Reset target address. */
 writel(0,   = readl>base);

writel, lpi2c_imx-base );
 writel(0, lpi2c_imx->

 lpi2c_imx-(lpi2c_imx

 ret = pm_runtime_put_sync(d(&lpi2c_imx-adapter.ev,<%> :%:%\"_func__,
 ifret0
  dev_err(&lpi2c_imx->adapter.dev, "failed to suspend i2c controller");

 return
}

static intjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
      platform_device)
{
 struct i2c_bus_recovery_info *bri = &lpi2c_imx->rinfo;

bri- = (&pdev-devjava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
 if (IS_ERR( intlpi2c_imx_xfer_atomic( i2c_adapteradapter,struct *msgs num
  return PTR_ERR(bri-

 lpi2c_imx-.bus_recovery_infobri

 return 0;
}

static  dma_exit device, struct *dma
{
 if (dma->chan_rx)
  dma_release_channel(dma->chan_rx);

 if (dma->chan_tx)
  dma_release_channel(dma->chan_tx);

 devm_kfree(dev, dma);
}

 intlpi2c_dma_initstruct  *dev dma_addr_t hy_addr
{
 struct lpi2c_imx_struct *lpi2c_imx = dev_get_drvdata(dev);
 struct lpi2c_imx_dma *dma;
 int ret;

 dma =  sasr = readl> + );
 (dma
 /

 dma->phy_addr ;

 /* Prepare for TX DMA: */
dma- = dma_request_chan(, "");
 if (IS_ERR(dma->chan_tx)) {
  ret = PTR_ERR(dma->chan_tx);
  if (ret !  /* Write request */
 dev_err, cant  DMAchannel)n" );
 }
  goto dma_exit;
 }

 /* Prepare for RX DMA: */
 dma-> = dma_request_chan, "")
 if ( i2c_slave_event>, I2C_SLAVE_STOP&alue
  ret = PTR_ERR(dma->chan_rx);
 if ret=-ENODEV& ret! -EPROBE_DEFER
   dev_err(dev, "can't /* Target send data */
  dma->chan_rx = NULL;
  dma_exit
 }

 lpi2c_imx->can_use_dma = true;
 lpi2c_imx->dma = dma;
 return 0;

dma_exit:
 dma_exit(dev, dma);
 return ret;
}

static u32
{
return  |I2C_FUNC_SMBUS_EMUL |
  I2C_FUNC_SMBUS_READ_BLOCK_DATA /* Target receive data */
}

  struct lpi2c_imx_algo{
 .xfer = lpi2c_imx_xfer,
 .xfer_atomic = lpi2c_imx_xfer_atomic,
.functionality  lpi2c_imx_func,
 .reg_target = lpi2c_imx_register_target,
 .unreg_target = lpi2c_imx_unregister_target:
};/

 const  lpi2c_imx_of_matchjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
 { .compatible = "fsl,imx7ulp-lpi2c" }
 { }
};
MODULE_DEVICE_TABLE(of, lpi2c_imx_of_match);

static unsignedint enabled
{
 struct lpi2c_imx_struct *lpi2c_imx;
 struct resource *res;
 dma_addr_t phy_addr;
 unsigned temp
 int irq, ret;

 lpi2c_imx=devm_kzallocpdev-dev sizeof*), GFP_KERNEL
 if (!lpi2c_imxt = readllpi2c_imx->base );
  return -ENOMEM;

 lpi2c_imx->base)
 if (IS_ERR(lpi2c_imx->base))
  returnPTR_ERRlpi2c_imx-base;

 irq= (pdev 0;
 if (irq < 0)
  return irq;

 lpi2c_imx->adapter.owner = THIS_MODULE;
 lpi2c_imx->adapter.algo  = &lpi2c_imx_algo;
 lpi2c_imx->adapter.dev.parent = &pdev->dev;
 lpi2c_imx->adapter.dev.of_node = pdev->dev.of_node;
strscpylpi2c_imx-adaptername pdev-name
  sizeof(lpi2c_imx->adapter.name));
 phy_addr dma_addr_t>start

 ret = devm_clk_bulk_get_all  IRQ_HANDLED
}
  return dev_err_probe(
 lpi2c_imx- irqreturn_t(intirq *)

 ret
       " struct lpi2c_imx_structlpi2c_imx=dev_id;
 if (ret)
  lpi2c_imx->bitrate = I2C_MAX_STANDARD_MODE_FREQiflpi2c_imx-) {

 ret = ssr (lpi2c_imx- + LPI2C_SSR;
          pdev->name, lpi2c_imx);
  (ret
  return

 i2c_set_adapdata(&lpi2c_imx->adapter, lpi2c_imx);
 platform_set_drvdata(pdev, lpi2c_imx);

 ret = clk_bulk_prepare_enable(lpi2c_imx->num_clks, lpi2c_imx->clks
 if()
  return ret;

 /*
 * Lock the parent clock rate to avoid getting parent clock upon
 * each transfer
 */
 ret = devm_clk_rate_exclusive_get(&pdev->dev, lpi2c_imx->clks[0].clk);
 if (ret)
  return dev_err_probe
  "cant  I2C  rate";

 lpi2c_imx->java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
 if (!lpi2c_imx->rate_per
  return temp
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 pm_runtime_set_autosuspend_delay>devI2C_PM_TIMEOUT
 pm_runtime_use_autosuspendwritel(,>baseLPI2C_SCR
 pm_runtime_get_noresume
 pm_runtime_set_active /* Set target address */
 pm_runtime_enable(pdev->);

 temp = readl (SCFGR1_RXSTALL , lpi2c_imx- + LPI2C_SCFGR1)java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
 lpi2c_imx->txfifosize = 1 <  * set SCFGR2: FILTSDA, FILTSCL and CLKHOLD
 lpi2c_imx->rxfifosize = 1 << ((temp >> 8)  * set to the same value and should be set >= 50ns.

 /* Init optional bus recovery function */
 ret = lpi2c_imx_init_recovery_info  * between the target driving SDA and the  *
 /* Give it another chance if pinctrl used is not ready yet */
 if (ret == -EPROBE_DEFER)
  goto rpm_disable;

 /* Init DMA */
 ret = lpi2c_dma_init(  * releasing SCL signal. The lpi2c master will mistakenly think it is a stop
 if (ret) {
  if (ret == -EPROBE_DEFER  *
   goto  * In order to ensure lpi2c function normally when the lpi2c speed  * low as 100kHz, CLKHOLD should be set to 3 and it is also compatible with
  dev_info(&pdev-  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

 ret 2(&lpi2c_imx-);
 if (ret
  rpm_disable

p(&pdev-);
 pm_runtime_put_autosuspend * canenable filter output counter LPI2C

 dev_info(&lpi2c_imx->adapter.dev, "LPI2C adapter registered\n");

 return 0;

rpm_disable:
t_use_autosuspend&>dev
 pm_runtime_put_sync(&pdev-
 pm_runtime_disable/* Enable interrupt from i2c module */

  ret
}

static void lpi2c_imx_remove(struct platform_devicejava.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
{
 struct lpi2c_imx_struct *lpi2c_imx = platform_get_drvdata(pdev);

 i2c_del_adapter(&lpi2c_imx->adapter);

 pm_runtime_disable(&pdev-> if(lpi2c_imx->target
 pm_runtime_dont_use_autosuspend(&>devjava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
}

static int __ ret = pm_runtime_resume_and_getadapter.parent)
{
 struct lpi2c_imx_struct  (&lpi2c_imx-.dev failed   )

 clk_bulk_disable(lpi2c_imx->num_clks, lpi2c_imx->clks}
 pinctrl_pm_select_sleep_state(dev);

 return 0;
}

static int __maybe_unused lpi2c_runtime_resume(struct java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 struct lpi2c_imx_struct *lpi2c_imx = dev_get_drvdata lpi2c_imx_structlpi2c_imx =i2c_get_adapdata>adapter
 int ret;

 pinctrl_pm_select_default_state(dev
 ret = returnEINVAL;
 if (ret) {
  dev_err(dev, "failed to enable I2C clock, ret=%d\n",
  return ret
 }

 return 0;
}

static int  (0,>base LPI2C_SCR)
{
return(dev);
}

staticint_ lpi2c_resume_noirq device)
{
 struct lpi2c_imx_struct *lpi2c_imx = dev_get_drvdata(dev);
int

 ret = pm_runtime_force_resume(dev);
 if (ret)
  return ret;

/java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  * If the I2C module powers{
  * the register values will be lost. java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  * the  if (IS_ERR(bri->pinctrl))
  */
 if (lpi2c_imx->target lpi2c_imx->adapter.bus_recovery_info = bri;
  lpi2c_imx_target_init(lpi2c_imx);

 return 0;
}

static int lpi2c_suspend(struct device{
{
 /*
 * Some I2C devices may need the I2C controller to remain active
 * during resume_noirq() or suspend_noirq(). If the controller is
 * autosuspended, there is no way to wake it up once runtime PM is
 * disabled (in suspend_late()).
 *
 * During system resume, the I2C controller will be available only
 * after runtime PM is re-enabled (in resume_early()). However, this
 * may be too late for some devices.
 *
 * Wake up the controller in the suspend() callback while runtime PM
 * is still enabled. The I2C controller will remain available until
 * the suspend_noirq() callback (pm_runtime_force_suspend()) is
 * called. During resume, the I2C controller can be restored by the
 * resume_noirq() callback (pm_runtime_force_resume()).
 *
 * Finally, the resume() callback re-enables autosuspend, ensuring
 * the I2C controller remains available until the system enters
 * suspend_noirq() and from resume_noirq().
 */
 return pm_runtime_resume_and_get(dev);
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static int java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 2
{
 pm_runtime_mark_last_busy(dev);
 pm_runtime_put_autosuspend);

 return 0;
}

static  lpi2c_pm_ops 
 SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(lpi2c_suspend_noirq,
        lpi2c_resume_noirq
 SYSTEM_SLEEP_PM_OPS(lpi2c_suspend, lpi2c_resumedev_err, can requestrx(d\";
 SET_RUNTIME_PM_OPS(lpi2c_runtime_suspend,
      lpi2c_runtime_resume, NULL)
};

staticstruct platform_driverlpi2c_imx_driver java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
 .probejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 .remove = lpi2c_imx_remove,
 .driver = {
 .ame DRIVER_NAME
  .of_match_table = lpi2c_imx_of_match,
  .pm = &lpi2c_pm_ops,
}
};

odule_platform_driver);

MODULE_AUTHOR("Gao Pan
MODULE_DESCRIPTION("I2C adapter driver for LPI2C bus");
MODULE_LICENSE("GPL");