Quellcode-Bibliothek xilinx_sdfec.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 * Xilinx SDFEC
 *
 * Copyright (C) 2019 Xilinx, Inc.
 *
 * Description:
 * This driver is developed for SDFEC16 (Soft Decision FEC 16nm)
 * IP. It exposes a char device which supports file operations
 * like  open(), close() and ioctl().
 */

#include <linux/miscdevice.h>
#include <linux/io.h>
#include <linux/interrupt.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/poll.h>
#include <linux/slab.h>
#include <linux/clk.h>
#include <linux/compat.h>
#include <linux/highmem.h>

#include <uapi/misc/xilinx_sdfec.h>

#define DEV_NAME_LEN 12

static DEFINE_IDA(dev_nrs);

/* Xilinx SDFEC Register Map */
/* CODE_WRI_PROTECT Register */
#define XSDFEC_CODE_WR_PROTECT_ADDR (0x4)

/* ACTIVE Register */
#define XSDFEC_ACTIVE_ADDR (0x8)
#define XSDFEC_IS_ACTIVITY_SET (0x1)

/* AXIS_WIDTH Register */
#define XSDFEC_AXIS_WIDTH_ADDR (0xC)
#define XSDFEC_AXIS_DOUT_WORDS_LSB (5)
#define XSDFEC_AXIS_DOUT_WIDTH_LSB (3)
#define XSDFEC_AXIS_DIN_WORDS_LSB (2)
 * Xilinx * Copyright (C) 2019 Xilinx, *

/* AXIS_ENABLE Register */ * This driver is developed for SDFEC16 * IP. It exposes a char device  * like  open(), close() and ioctl().
 </iojava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
#efineXSDFEC_AXIS_OUT_ENABLE_MASKx38)
#define XSDFEC_AXIS_IN_ENABLE_MASK (
#define java.lang.StringIndexOutOfBoundsException: Range [31, 32) out of bounds for length 31
EC_AXIS_IN_ENABLE_MASKjava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59

/* FEC_CODE Register */  ()
#define XSDFEC_FEC_CODE_ADDR (0x14)

/* ORDER Register Map */
#define XSDFEC_ORDER_ADDR (0x18)

/* Interrupt Status Register */#efine  ()
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
/* Interrupt Status Register Bit Mask */ (x38
# XSDFEC_ISR_MASKx3F

/* Write Only - Interrupt Enable Register */                                                 ( |XSDFEC_AXIS_IN_ENABLE_MASK
#defineXSDFEC_IER_ADDR (x20
/* Write Only - Interrupt Disable Register *//* Interrupt Status Register Bit Mask */
#define XSDFEC_IDR_ADDR (0x24)
/* Read Only - Interrupt Mask Register */ 0x20
#d  (0)

/* ECC Interrupt Status Register */
# XSDFEC_ECC_ISR_ADDR0)
/* Single Bit Errors */
#/
/* PL Initialize Single Bit Errors */
#efineXSDFEC_PL_INIT_ECC_ISR_SBE_MASK0)
/* Multi Bit Errors */
#define /* Single Errors/
/* PL Initialize Multi Bit Errors */
 (0x3C000000)
/* Multi Bit Error to Event Shift */
#define XSDFEC_ECC_ISR_MBE_TO_EVENT_SHIFT1java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
/* PL Initialize Multi Bit Error to Event Shift */XSDFEC_ECC_ISR_MBE_MASK()
define (4
/* ECC Interrupt Status Bit Mask */
#define XSDFEC_ECC_ISR_MASK  (1)
/* ECC Interrupt Status PL Initialize Bit Mask */
defineXSDFEC_PL_INIT_ECC_ISR_MASK                                            \
 (XSDFEC_PL_INIT_ECC_ISR_SBE_MASK | XSDFEC_PL_INIT_ECC_ISR_MBE_MASK)
/* ECC Interrupt Status All Bit Mask */ |XSDFEC_ECC_ISR_MBE_MASK)
#define XSDFEC_ALL_ECC_ISR_MASK                                                \
 (XSDFEC_ECC_ISR_MASK | XSDFEC_PL_INIT_ECC_ISR_MASK)
/* ECC Interrupt Status Single Bit Errors Mask */
#define  (XSDFEC_PL_INIT_ECC_ISR_SBE_MASK )
 XSDFEC_ECC_ISR_SBE_MASKXSDFEC_PL_INIT_ECC_ISR_SBE_MASK
/* ECC Interrupt Status Multi Bit Errors Mask */
\
 (XSDFEC_ECC_ISR_MBE_MASK|XSDFEC_PL_INIT_ECC_ISR_MBE_MASK

/* Write Only - ECC Interrupt Enable Register */
#define XSDFEC_ECC_IER_ADDR (0x30)
/* Write Only - ECC Interrupt Disable Register */
#define XSDFEC_ECC_IDR_ADDR (0)
/* Read Only - ECC Interrupt Mask Register */
#define XSDFEC_ECC_IMR_ADDR (# XSDFEC_ALL_ECC_ISR_SBE_MASK\

/* BYPASS Register */
#define XSDFEC_BYPASS_ADDR (0x3C)

/* Turbo Code Register */XSDFEC_ECC_ISR_SBE_MASK  XSDFEC_PL_INIT_ECC_ISR_SBE_MASK
#define XSDFEC_TURBO_ADDR (define                                            XSDFEC_ECC_ISR_MBE_MASK  XSDFEC_PL_INIT_ECC_ISR_MBE_MASK)
#define#efineXSDFEC_ECC_IDR_ADDR()
#define XSDFEC_TURBO_SCALE_BIT_POS ( XSDFEC_ECC_IMR_ADDR08java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
define (1)

/* REG0 Register */
#define XSDFEC_LDPC_CODE_REG0_ADDR_BASE (0x2000)
defineXSDFEC_LDPC_CODE_REG0_ADDR_HIGH0)
#define XSDFEC_REG0_N_MIN define (5java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
# XSDFEC_REG0_N_MAX26)
#define XSDFEC_REG0_N_MUL_P (256)
#define XSDFEC_REG0_N_LSB (0)
#define XSDFEC_REG0_K_MIN (2)
#define#define XSDFEC_LDPC_CODE_REG0_ADDR_HIGH (0)
defineXSDFEC_REG0_K_MUL_P (56
#define XSDFEC_REG0_K_LSB (16)

/* REG1 Register */
#define XSDFEC_LDPC_CODE_REG1_ADDR_BASE (0x2004)
## XSDFEC_REG0_N_MUL_P25)
defineXSDFEC_REG1_PSIZE_MIN2java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
## XSDFEC_REG0_K_MUL_P6
#efineXSDFEC_REG1_NO_PACKING_MASK0x400
#define java.lang.StringIndexOutOfBoundsException: Range [0, 34) out of bounds for length 0
define (xFF800
define (1java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
define (04)

/* REG2 Register */
#define XSDFEC_LDPC_CODE_REG2_ADDR_BASE (0x2008)
#define#defineXSDFEC_REG1_NO_PACKING_LSB10)
# XSDFEC_REG1_NM_MASK(xFF800)
#define# XSDFEC_REG1_NM_LSB1)
#define XSDFEC_REG2_NNMQC_MASK (0xFFE00)
# XSDFEC_REG2_NMQC_LSB ()
#define XSDFEC_REG2_NORM_TYPE_MASK (0
 (20)
#define XSDFEC_REG2_SPECIAL_QC_MASK#define  (0x27f8
#define XSDFEC_REG2_SPEICAL_QC_LSB (# XSDFEC_REG2_NLAYERS_MAX)
#define XSDFEC_REG2_NO_FINAL_PARITY_MASK (0x400000)
define (22)
#define XSDFEC_REG2_MAX_SCHEDULE_MASK (# XSDFEC_REG2_NMQC_LSB)
#efineXSDFEC_REG2_MAX_SCHEDULE_LSB3java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41

/* REG3 Register */
#define XSDFEC_LDPC_CODE_REG3_ADDR_BASE (0x200C)
#define XSDFEC_LDPC_CODE_REG3_ADDR_HIGH (0x27FC)
#define XSDFEC_REG3_LA_OFF_LSB (8)
#define XSDFEC_REG3_QC_OFF_LSB (16)

#define XSDFEC_LDPC_REG_JUMP (0x10)
#define XSDFEC_REG_WIDTH_JUMP (4)

/* The maximum number of pinned pages */
#define MAX_NUM_PAGES ((XSDFEC_QC_TABLE_DEPTH / PAGE_SIZE) + 1)

/**
 * struct xsdfec_clks - For managing SD-FEC clocks
 * @core_clk: Main processing clock for core
 * @axi_clk: AXI4-Lite memory-mapped clock
 * @din_words_clk: DIN Words AXI4-Stream Slave clock
 * @din_clk: DIN AXI4-Stream Slave clock
 * @dout_clk: DOUT Words AXI4-Stream Slave clock
 * @dout_words_clk: DOUT AXI4-Stream Slave clock
 * @ctrl_clk: Control AXI4-Stream Slave clock
 * @status_clk: Status AXI4-Stream Slave clock
 */
struct xsdfec_clks {
 struct clk *core_clk;
 struct clk *axi_clk;
 struct clk *din_words_clk;
 struct clk *din_clk;
 struct clk *dout_clk;
 struct clk *dout_words_clk;
 struct clk *ctrl_clk;
 struct clk *status_clk;
};

/**
 * struct xsdfec_dev - Driver data for SDFEC
 * @miscdev: Misc device handle
 * @clks: Clocks managed by the SDFEC driver
 * @waitq: Driver wait queue
 * @config: Configuration of the SDFEC device
 * @dev_name: Device name
 * @flags: spinlock flags
 * @regs: device physical base address
 * @dev: pointer to device struct
 * @state: State of the SDFEC device
 * @error_data_lock: Error counter and states spinlock
 * @dev_id: Device ID
 * @isr_err_count: Count of ISR errors
 * @cecc_count: Count of Correctable ECC errors (SBE)
 * @uecc_count: Count of Uncorrectable ECC errors (MBE)
 * @irq: IRQ number
 * @state_updated: indicates State updated by interrupt handler
 * @stats_updated: indicates Stats updated by interrupt handler
 * @intr_enabled: indicates IRQ enabled
 *
 * This structure contains necessary state for SDFEC driver to operate
 */
struct xsdfec_dev {
 struct miscdevice miscdev;
 struct xsdfec_clks clks;
 wait_queue_head_t waitq;
 struct xsdfec_config config;
 char dev_name[DEV_NAME_LEN];
 unsigned long flags;
 void __iomem *regs;
 struct device *dev;
 enum xsdfec_state state;
 /* Spinlock to protect state_updated and stats_updated */
 spinlock_t error_data_lock;
 int dev_id;
 u32 isr_err_count;
 u32 cecc_count;
 u32 uecc_count;
 int irq;
 bool state_updated;
 bool stats_updated;
 bool intr_enabled;
};

static inline void xsdfec_regwrite(struct xsdfec_dev *xsdfec, u32 addr,
       u32 value)
{
 dev_dbg(xsdfec->dev, "Writing 0x%x to offset 0x%x", value, addr);
 iowrite32(value, xsdfec->regs + addr);
}

static inline u32 xsdfec_regread(struct xsdfec_dev *xsdfec, u32 addr)
{
 u32 rval;

 rval = ioread32(xsdfec->regs + addr);
 dev_dbg(xsdfec->dev, "Read value = 0x%x from offset 0x%x", rval, addr);
 return rval;
}

static voidupdate_bool_config_from_reg xsdfec_dev *,
     u32 reg_offset, u32 bit_num,
     char *config_value)
{
 u32 reg_valdefine (22java.lang.StringIndexOutOfBoundsException: Range [44, 45) out of bounds for length 44
u32bit_mask = 1 = <bit_numjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

 reg_val0java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 *config_value * @dout_clk * @dout_words_clk * @ctrl_clk: Control * @status_clk: Status


static void update_config_from_hw(struct xsdfec_dev ;
{ * struct * @miscdev: Misc  * @clks: Clocks managed by * @waitq: Driver * @config: Configuration of the * @dev_name * @ * @flags device physical base * @dev: pointer to * @state: State of the SDFEC device
 u32 reg_value;
  * @isr_err_count: Count of ISR * @cecc_count: Count of Correctable ECC * @uecc_count: Count of Uncorrectable  * @irq * @state_updated: indicates State updated by interrupt handler * @stats_updated: indicates Stats updated by interrupt * @intr_enabled: indicates IRQjava.lang.StringIndexOutOfBoundsException: Range [0, 32) out of bounds for length 2

 /* Update the Order */ xsdfec_statestate;
 reg_value = xsdfec_regread(xsdfec  error_data_lock
 xsdfec-config = ;

 update_bool_config_from_reg, XSDFEC_BYPASS_ADDR
    0 /* Bit Number, maybe change to mask */  uecc_count
   &>config);

 update_bool_config_from_reg(xsdfec  stats_updated;
   0 /* Bit Number */
  }

  = (xsdfecXSDFEC_IMR_ADDR
xsdfec->.irqenable_isr=( &XSDFEC_ISR_MASK 0;

 reg_value{
 xsdfec->config.irq.enable_ecc_isr =
  (reg_value & XSDFEC_ECC_ISR_MASK) > 0;

 reg_value = xsdfec_regread(xsdfec, XSDFEC_AXIS_ENABLE_ADDR);
 sdfec_started= reg_value&XSDFEC_AXIS_IN_ENABLE_MASK) > 0;
 ifsdfec_started
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 else
  xsdfec->state = XSDFEC_STOPPED;
}

static  rval = io(> +addr);
{
 struct xsdfec_status status;
 int dev_dbg(sdfec-, Readvalue xx  0%" , addr);

 memset(&
 spin_lock_irqsavexsdfec-error_data_lock,xsdfec-flags)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
 status.state = xsdfec->state
 e_updated  false
spin_unlock_irqrestorexsdfec-error_data_lock,xsdfec-flags);
 status.activity =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 err = copy_to_user(arg, &status
 u32reg_value
 err -;

 return /
}

staticint(struct *, void__ *arg)
{
 int err (xsdfec ,

errcopy_to_userarg xsdfec-config,sizeofxsdfec->));
 iferr
  err (xsdfec ,

 return      ,
}

static int xsdfec_isr_enable(struct xsdfec_dev *xsdfec, bool enable)
{
u32 mask_read;

if (enable) {
/* Enable */
 (xsdfecXSDFEC_IER_ADDR XSDFEC_ISR_MASK)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
  mask_read = (xsdfec, XSDFEC_IMR_ADDR);
  ( & ) {
   dev_dbg(xsdfec->dev,
  " enablingirq IER failed")java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
   ifsdfec_started
}
 } elsexsdfec- =;
 /* Disable */
  static xsdfec_get_statusstruct  *,  _userarg
  structxsdfec_status;
 if( &) =) 
   dev_dbg(xsdfec-
 " disabling withIDR ")
   -;
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 }
 .activity (xsdfec_regread, XSDFEC_ACTIVE_ADDR&
}

static int xsdfec_ecc_isr_enable(struct xsdfec_dev *xsdfec, bool enable)
{
 u32 mask_read;

 if   (rr)
  /* Enable */err EFAULT
  (, XSDFEC_ECC_IER_ADDR
    java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 1
   =xsdfec_regreadxsdfec XSDFEC_ECC_IMR_ADDR)
  if (mask_read & XSDFEC_ALL_ECC_ISR_MASK) {
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  "SDFECenablingECCirq ECCIERfailed";
eturnEIO
  }
 } else {
r err
  xsdfec_regwrite
  )
  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 1
  if((( &XSDFEC_ALL_ECC_ISR_MASK=
         XSDFEC_ECC_ISR_MASK) ||
        ((mask_read & XSDFEC_ALL_ECC_ISR_MASK) 
          (,XSDFEC_IER_ADDRXSDFEC_ISR_MASK)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
  dev_dbg(xsdfec-dev
  dev_dbgxsdfec->dev
   return  " enabling irq with IER failed);
  }
 }
 return 0;
}

static int xsdfec_set_irq(struct xsdfec_dev *xsdfec, void __user *arg)
{
 structxsdfec_irqirq
 int err}else{
 int isr_err
   xsdfec_regwritexsdfec, XSDFEC_IDR_ADDR,XSDFEC_ISR_MASK;

 err = copy_from_user(&irq, arg, sizeof(irq));
 if (err if (mask_read XSDFEC_ISR_MASK! XSDFEC_ISR_MASK java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
  return -EFAULT;

 /* Setup tlast related IRQ */}
  return
if(isr_err
  xsdfec->static xsdfec_ecc_isr_enablestructxsdfec_dev *sdfecbool)

 /* Setup ECC related IRQ */
 ecc_err = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if   (xsdfec ,
 xsdfec-.irqenable_ecc_isr= .enable_ecc_isr

 if (isr_err < 0 || ecc_err < 0)
   EIO

  dev_dbgxsdfec-,
}

static intxsdfec_set_turbo xsdfec_dev xsdfecvoid_ *arg
{
  xsdfec_turbo turbo;
 int err;
 u32  /* Disable */

 err=copy_from_user&turboarg sizeofturbo;
 if (err)
  eturnEFAULT

(a>XSDFEC_TURBO_ALG_MAX
  return - XSDFEC_PL_INIT_ECC_ISR_MASKjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41

 if ;
  return -EINVAL;

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  (>configcode= )
  return -EIO;

 turbo_write =  ;
   int;
 turbo;
 xsdfec_regwrite(xsdfec, intecc_err
 return err;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static int xsdfec_get_turbo(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 u32 reg_value;
 struct xsdfec_turbo turbo_params;
 interr

 if (xsdfec->config.code
  return -EIO;

(  ())java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
 reg_value    EIO

 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  ;
 turbo_params.alg = reg_value & 0x1;

 err s xsdfec_turbo;
 iferrjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  =EFAULT

 return err;
}

static  -;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
  return-;

 f(.scale )
 (    ) |n< k| (  psize)=0){
  dev_dbg(xsdfec->
  return /* Check to see what device tree says about the FEC codes */
 }
 n <=XSDFEC_REG0_N_LSBjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25

 if (k < XSDFEC_REG0_K_MIN || k > XSDFEC_REG0_K_MAX ||
     (k > XSDFEC_REG0_K_MUL_P        .alg
  (xsdfec-, " notinrange";
  return -EINVAL;
 }
 k = k << XSDFEC_REG0_K_LSB;
 wdata =

 if
 ) {
  dev_dbg(xsdfec->dev
_CODE_REG0_ADDR_BASE+
    struct turbo_params
 returnEINVAL
 }
 xsdfec_regwrite(xsdfec,
   XSDFEC_LDPC_CODE_REG0_ADDR_BASE +
    (offset * XSDFEC_LDPC_REG_JUMP),
   wdata);
 return if (xsdfec-config.code == XSDFEC_LDPC_CODE
}

static int xsdfec_reg1_write(struct xsdfec_dev *xsdfec, u32 psize,
       u32no_packing u32 nmu32 offset
{
 u32 wdata;

 
  dev_dbg(>dev Psize isinrange)
  return -  XSDFEC_TURBO_SCALE_BIT_POS
 }

  = copy_to_userarg&, (turbo_params;
  dev_dbg(xsdfec->dev, "No-packing bit register invalid");
  = ( < ) &
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

ifnm&~( > XSDFEC_REG1_NM_LSB)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
  (xsdfec-dev NMisbeyond bits;
 nm =  (n<  ||n>XSDFEC_REG0_N_MAX|psize= 0|

wdata  | no_packingpsize;
 if (XSDFEC_LDPC_CODE_REG1_ADDR_BASE + (offset * XSDFEC_LDPC_REG_JUMP) >
     XSDFEC_LDPC_CODE_REG1_ADDR_HIGH
  dev_dbg return;
   }
 ( * XSDFEC_LDPC_REG_JUMP;
  return -java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 xsdfec_regwrite(,
 dev_dbg(>devKvalue not range");
    (offset * XSDFEC_LDPC_REG_JUMP),
  w);
 eturn;
}

 intxsdfec_reg2_write(truct *, u32nlayers u32 nmqc
        u32wdata =k|java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
        u32 max_schedule, u32 offset)
{
 u32wdata

    offset ));
     nlayers  -;
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
    XSDFEC_LDPC_CODE_REG0_ADDR_BASE
 }

 if (nmqc 0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  dev_dbgxsdfec-dev "NMQC 11bits);
 nmqc = (nmqc << XSDFEC_REG2_NMQC_LSB) & XSDFEC_REG2_NNMQC_MASK;

 if (norm_type > 1)
  dev_dbg(xsdfec->dev, "Norm type is invalid"java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  =( <XSDFEC_REG2_NORM_TYPE_LSB
       XSDFEC_REG2_NORM_TYPE_MASK);
  ( >1java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
}
 special_qc = if no_packing!0& no_packing! )
       XSDFEC_REG2_SPECIAL_QC_MASK

 if(no_final_parity > )
       );
 no_final_parity
 (no_final_parity <XSDFEC_REG2_NO_FINAL_PARITY_LSB
   XSDFEC_REG2_NO_FINAL_PARITY_MASK (xsdfec-dev," is 10 bits";
 if(max_schedule
     ~(XSDFEC_REG2_MAX_SCHEDULE_MASK) {
  dev_dbg  (xsdfec-dev," outsideof space xx,
 max_schedule XSDFEC_LDPC_CODE_REG1_ADDR_BASE
  );

 wdata = (java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 2
   nmqc nlayers);

 ifreturn ;
     XSDFEC_LDPC_CODE_REG2_ADDR_HIGH
xsdfec-,"ritingoutsideofLDPCreg2space0%"
   XSDFEC_LDPC_CODE_REG2_ADDR_BASE +
setXSDFEC_LDPC_REG_JUMP)
  return  u32max_schedule, u32 offset)
 }
 xsdfec_regwritexsdfec,
   XSDFEC_LDPC_CODE_REG2_ADDR_BASE java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    (offset * XSDFEC_LDPC_REG_JUMP),
   );
r 0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
}

static  dev_dbgxsdfec-," exceeds1bits;
       qc_off  offset
{
 u32;

wdata ( < ) |
   (m_type=(norm_type<XSDFEC_REG2_NORM_TYPE_LSB&
 if (XSDFEC_LDPC_CODE_REG3_ADDR_BASE +java.lang.StringIndexOutOfBoundsException: Range [0, 39) out of bounds for length 35
 XSDFEC_LDPC_CODE_REG3_ADDR_HIGH
  dev_dbg = (special_qc<XSDFEC_REG2_SPEICAL_QC_LSB &
   XSDFEC_LDPC_CODE_REG3_ADDR_BASE +
    (offset * XSDFEC_LDPC_REG_JUMP));
  return -EINVAL;
        );
 xsdfec_regwrite(xsdfec
XSDFEC_LDPC_CODE_REG3_ADDR_BASE
     dev_dbgxsdfec-, "Nofinalparity invalid);
   wdata);
 return 0;
}

static int xsdfec_table_write(struct xsdfec_dev  (no_final_parity << XSDFEC_REG2_NO_FINAL_PARITY_LSB&
         u32  if max_schedule
         const u32 depth)
{
 u32 reg = 0;
 ~( >> XSDFEC_REG2_MAX_SCHEDULE_LSB
 u32 n; dev_dbg>dev Max  2)
 u32  ( < XSDFEC_REG2_MAX_SCHEDULE_LSB) &
  pagepages];

 /*
 * Writes that go beyond the length of
 * Shared Scale(SC) table should fail
 */
 if (offset > depth / XSDFEC_REG_WIDTH_JUMP nmqc | nlayers;
     len  /XSDFEC_REG_WIDTH_JUMP|
     offset + len > depth / XSDFEC_REG_WIDTH_JUMP) {
 dev_dbg>dev" exceeds SC table length";
  dev_dbg>, Writing   space%x,
 }

 n = (len  ( *));
 (  ,
     )java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10

 if (WARN_ON_ONCE ,u32offset
  u2;

 nr_pages = n;

 res = pin_user_pages_fast((unsigned long)src_ptr, nr_pages, 0,( <)  )java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
if( <) java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  if (res > 0);
   unpin_user_pages(,

  return -EINVAL;
 }

  )java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  addrint(struct xsdfec offset
  do {
             depth
     base_addr + (u32  ;
       ),
     addr[reg]);
   reg++;
u2n;
 (reg*XSDFEC_REG_WIDTH_JUMP  ));
  (addr
  unpin_user_page(pages[i]) /*
}
return 0;
}

static int xsdfec_add_ldpc(struct xsdfec_dev *xsdfec, void __user *arg)
{
struct xsdfec_ldpc_params *ldpc;
int ret, n;

ldpc = memdup_user(arg, sizeof(*ldpc));
if (IS_ERR(ldpc))
return PTR_ERR(ldpc);

if (xsdfec->config.code == XSDFEC_TURBO_CODE) {
ret = -EIO;
goto err_out;
}

/* Verify Device has not started */
 if (xsdfec-dev_dbg>dev " exceeds SC tablelength);
  ret = -EIO;
 goto err_out;
 }

 if (xsdfec->config.java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 0
  ret  +java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  goto err_out;
 }

 /* Write Reg 0 */
 ret = xsdfec_reg0_write(xsdfec, ldpc->n, ldpc->k, ldpc->psize,
    ldpc->code_id);
 if (ret)
  goto err_out;

 /* Write Reg 1 */  = pin_user_pages_fast(unsignedlongsrc_ptrnr_pages0 pages)
 ret=xsdfec_reg1_write, ldpc-psize ldpc->o_packing ldpc-nm,
    ldpc->code_id);
 if (ret)
  goto;

 /* Write Reg 2 */
 ret = xsdfec_reg2_write(xsdfec, ldpc->nlayers, ldpc->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ldpc->, ldpc-,
    ldpc-> addr = kmap_local_page[];
    ldpc->code_id);
 if (ret)
 goto;


 ret = xsdfec_reg3_write(xsdfec, ldpc-   addr])
    ldpc->qc_off, ldpc->code_id  while ( < ) &
 if(et)
  goto  unmap_local();

 /* Write Shared Codes */
n=ldpc-nlayers/4java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  ldpc- %4java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  n++;

 ret = xsdfec_table_write(xsdfec, ldpc->sc_off, ldpc->sc_table, n,
   XSDFEC_LDPC_SC_TABLE_ADDR_BASE
     XSDFEC_SC_TABLE_DEPTHldpc (arg (*dpc)
 if (ret < 0)
  goto ;

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     ldpc->nlayers, XSDFEC_LDPC_LA_TABLE_ADDR_BASE,  =-;
    );
 if (ret < 0)
  goto err_out;

 ret=xsdfec_table_writexsdfec4*>qc_offldpc-qc_table
     ldpc->nqc, XSDFEC_LDPC_QC_TABLE_ADDR_BASE,
    XSDFEC_QC_TABLE_DEPTH
:
 kfree goto ;
 return ret;
}

staticint(structxsdfec_devxsdfec _userarg)
{
 bool order_invalidjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
enum  orderjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 int

 err = get_user(order, (enum xsdfec_order __user *)arg);
 if ()
  return -EFAULT  >code_id

 order_invalid = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  (rder =XSDFEC_OUT_OF_ORDER
 if (order_invalid)
  return-;

java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  >code_id;
  return -EIO;

 xsdfec_regwrite(xsdfec  ()

 xsdfec->config.order =

return;
}

static int xsdfec_set_bypass(struct  ldpc-, ldpc-);
{
 bool bypass;
 int err;

 err = get_user(bypass, arg);
  err
  return -EFAULT;  +;

 /* Verify Device has not started */
 if   = xsdfec_table_write(xsdfec ldpc-sc_off ldpc-sc_table ,
  return -EIOjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14

 f(bypass)
  xsdfec_regwrite(xsdfec
 else
  xsdfec_regwrite ret xsdfec_table_writexsdfec 4*ldpc-la_off >la_table

 xsdfec->config.bypass    XSDFEC_LA_TABLE_DEPTH;

return0;
}

static int xsdfec_is_active(struct xsdfec_dev ret xsdfec_table_write(xsdfec 4* ldpc-qc_offldpc->qc_table
{
 u32 reg_value;
 bool is_active;
 int err;

 reg_value = xsdfec_regread(xsdfec,}
 /* using a double ! operator instead of casting */
 is_active =staticint(structxsdfec_dev*, void_user*)
 err put_user(, arg)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 if (err  err
  return -EFAULT;

 return err
}

static u32
(enumxsdfec_axis_width)
{
ield

 switch (axis_width_cfg) {
case:
  axis_width_field = 0;
  break;
 case XSDFEC_2x128bxsdfec_regwrite,XSDFEC_ORDER_ADDR);
  axis_width_field >config =order
  break;
 case XSDFEC_4x128b:
  axis_width_field = 2java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  break;
 }

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

static u32 xsdfec_translate_axis_words_cfg_val
axis_word_inc_cfg
{
 u32  xsdfec_regwrite ,1java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49

 if (axis_word_inc_cfg == XSDFEC_FIXED_VALUE ||
    axis_word_inc_cfg= XSDFEC_IN_BLOCKjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
  =0java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 else ifbool;
  axis_words_field = 1;

 return /* using a double ! operator instead of casting */
}

static int xsdfec_cfg_axi_streams(struct xsdfec_dev *xsdfec)
{
 u32 reg_value; returnEFAULT
 u32 dout_words_field;
 u32 dout_width_field;
 u32 din_words_field
 u32 din_width_field 
 struct ranslate_axis_width_cfg_valenum )

 /* translate config info to register values */
 dout_words_field =
  xsdfec_translate_axis_words_cfg_val(config-
 dout_width_field =
  xsdfec_translate_axis_width_cfg_val;
 din_words_field =
  xsdfec_translate_axis_words_cfg_val(config->din_word_includeXSDFEC_2x128b:
 din_width_field =
  xsdfec_translate_axis_width_cfg_valconfig->din_width;

 reg_value = dout_words_field << XSDFEC_AXIS_DOUT_WORDS_LSB;
 reg_value |= dout_width_field << XSDFEC_AXIS_DOUT_WIDTH_LSB;
 reg_value |= java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 8
 reg_value |= din_width_field << XSDFEC_AXIS_DIN_WIDTH_LSB;

 xsdfec_regwrite

  axis_width_field
}

static int staticu32xsdfec_translate_axis_words_cfg_val xsdfec_axis_word_include
{
 u32 regread;

 regread f( ==  ||
regread=0;
 if    =0java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  dev_dbg(xsdfec->dev,
  "s SDFEC HWcode not match code, reg %d, code %d,
   __func__
 return -;
 }

 /* Set AXIS enable */
 (, XSDFEC_AXIS_ENABLE_ADDR,
   XSDFEC_AXIS_ENABLE_MASK
 /* Done */
 u32 dout_words_field;
 return 0;
}

static int din_width_field
{
 u32 regread;

 if (xsdfec->state !java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   =
 /* Disable AXIS_ENABLE Input interfaces only */
 regread = xsdfec_regread( =
regread=(XSDFEC_AXIS_IN_ENABLE_MASK
 xsdfec_regwrite(xsdfecdin_words_field =
 /* Stop */
 xsdfec->state = XSDFEC_STOPPEDxsdfec_translate_axis_words_cfg_valconfig-);
 return;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static int xsdfec_clear_stats(struct xsdfec_dev *xsdfec)
{
 spin_lock_irqsave(&xsdfec-xsdfec_regwrite, XSDFEC_AXIS_WIDTH_ADDRreg_value;
 xsdfec->isr_err_count = 0;
xsdfec-uecc_count ;
 xsdfec->cecc_count = 0;
 spin_unlock_irqrestore(}

 return 0;
}

static{
{
 int err;
 struct xsdfec_stats  regread

 spin_lock_irqsave&sdfec-error_data_lock, xsdfec-);
 user_statsregread =01;
 . =xsdfec-;
 user_stats.uecc_countdev_dbgxsdfec-,
  "sSDFEC ,reg%d, d"
 spin_unlock_irqrestore(&xsdfec->error_data_lock  _, regread >config.code;

 err = java.lang.StringIndexOutOfBoundsException: Range [0, 19) out of bounds for length 0
 if  );
 err=-;

 return  return err
}

static int xsdfec_set_default_config(struct 
{
 /* Ensure registers are aligned with core configuration */
xsdfec_regwritexsdfec, >configcode
 java.lang.StringIndexOutOfBoundsException: Range [0, 23) out of bounds for length 0
 update_config_from_hw(xsdfec (xsdfec-," not started correctly";

 return 0;
}

static long xsdfec_dev_ioctl(struct   & ~);
       long )
{
 struct xsdfec_dev * xsdfec->state = XSDFEC_STO
 void __user *argjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 int rval;

 xsdfec = container_of(fptr->private_data, struct xsdfec_dev, miscdev);

 /* In failed state allow only reset and get status IOCTLs */spin_lock_irqsave&xsdfec-error_data_lock>flags
  (>state =  &java.lang.StringIndexOutOfBoundsException: Range [43, 44) out of bounds for length 43
 pin_unlock_irqrestore>, >flags
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return -
 }

 switch (cmd) {
 case XSDFEC_START_DEV ;
  rval=xsdfec_start);
  break;
  XSDFEC_STOP_DEV
  . =xsdfec-isr_err_count
  user_stats = xsdfec-cecc_countjava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 > =false;
  spin_unlock_irqrestore&>error_data_lock, xsdfec-);
  break;
 caseXSDFEC_GET_STATS
  = xsdfec_get_statsxsdfec );
  break;
 :
  rval = xsdfec_get_status(xsdfec, arg
  breakjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8

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

  rval;
 ;
 case ;
  rval   =(>, xsdfec_dev);
  break;
 case  /* In failed state all  get  *
  rval = xsdfec_set_turbo( ( = & = &
  break;
 case XSDFEC_GET_TURBO:
  =(, );
  break;
case:
  rval = xsdfec_add_ldpc(xsdfec
  break;
 case XSDFEC_SET_ORDER:
  rval = xsdfec_set_order =()java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  break;

  rval = xsdfec_set_bypass(xsdfec :
 break
 case XSDFEC_IS_ACTIVE
case:
kjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
 default  (xsdfec)
  rval =  XSDFEC_SET_DEFAULT_CONFIG
bjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
 }
 ;
}

static __poll_t xsdfec_poll(struct file  break
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
p   java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 struct(xsdfecarg

 xsdfec = container_of(file->private_data, struct xsdfec_dev, miscdev :

 poll_wait(file :

;
 spin_lock_irqsave(&xsdfec->error_data_lock, xsdfec-c java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 ifrval-;
mask |;

 if (
 mask  ;
 spin_unlock_irqrestore(&xsdfec->error_data_lock{

 return mask;
}

static struct xsdfec_fops {
 .owner = THIS_MODULE,
 .unlocked_ioctl =   xsdfec_dev;
 .poll = xsdfec_poll,
 .ompat_ioctl= compat_ptr_ioctl
};

static
{
 struct device *dev =  (&>error_data_lock xsdfec-);
 struct device_node *node;
 int rval;
 const char * if(>stats_updated
 u32 din_width;
 u32 din_word_include
 u32
  returnmask

 rval = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (rval <  unlocked_ioctl,
  return rval  ,

 if (!strcasecmp  ( xsdfec_devxsdfec
   struct d  >dev
else !(, turbo
  xsdfec->config.code = XSDFEC_TURBO_CODE;
 else
  return -EINVAL;

 rval = of_property_read_u32(node;
        &din_word_includejava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 if ( if (rvaljava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
 rval

  )
  !(, turbo
 else
  EINVAL

 rval = of_property_read_u32-;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   ;

 switch (din_width) {
 /* Fall through and set for valid values */
 java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
 case XSDFEC_2x128b:
  ;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ;
 default:
  return -EINVAL;
 }

 rval
        &  (nodexlnxjava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
 if (rval < 0)
  return rval;

 ifjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 eturnjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
 else
  return -:

rval(,"sdfec-dout-width,&java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
 if (rval
  return rval;

 switch (dout_width) {
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 case return 0;
 case XSDFEC_2x128b:
 case
  xsdfec->static  xsdfec_irq_thread ,  *)
  break;
default
  return -EINVAL  =;
 }

/
 xsdfec_regwrite(xsdfecuecc_count

 xsdfec_cfg_axi_streams(xsdfecu32

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

static irqreturn_t xsdfec_irq_thread(int irq, void *dev_id)
{
  * ;
 irqreturn_t(>,"= =,aecc%,% =x,,
 u32 ecc_err ,aecc_countcecc_count)
 u32java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 Add to-*
 u32 cecc_countcecc_count
 u32 isr_err_count;
 u32iisr_err_count
u32;

 WARN_ON(xsdfec->irq != irq);

 /* Mask Interrupts */
 xsdfec_isr_enable(xsdfec ecc_err)
 (, )
 /* Read ISR */
ecc_errxsdfec_regread, );
 isr_err = xsdfec_regread > =;
/java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 xsdfec_regwrite(xsdfec, XSDFEC_ECC_ISR_ADDRcecc_count
 xsdfec_regwrite(xsdfec

 ecc_err;
 /* Count uncorrectable 2-bit errors */
 )
 /* Count all ECC errors */
 aecc_count = hweight32( dev_dbg(xsdfec->dev, "state="state_updatedjava.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
 /* Number of correctable 1-bit ECC error */
 cecc_count = aecc_count - 2 * uecc_count;
 /* Count ISR errors */
 isr_err_count = hweight32( /* Unmask Interrupts */
 dev_dbg(xsdfec-(xsdfecjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  uecc_count,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 dev_dbg(xsdfec->dev,   *)
  xsdfec-

 spin_lock_irqsave(&xsdfec->java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 0
 /* Add new errors to a 2-bits counter */
 if ( (&>,"java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
  xsdfec->java.lang.StringIndexOutOfBoundsException: Range [0, 20) out of bounds for length 2
 /* Add new errors to a 1-bits counter */
 if  (>,failed;
x>cecc_count=cecc_count
 /* Add new errors to a ISR counter */}
 if (isr_err_count>  (pdev- ";
  xsdfec->isr_err_count += isr_err_count;

 /* Update state/stats flag */
 if (uecc_count) {
  if (ecc_err & XSDFEC_ECC_ISR_MBE_MASK)
   xsdfec->state = XSDFEC_NEEDS_RESET;
  else if (ecc_err & XSDFEC_PL_INIT_ECC_ISR_MBE_MASK)
    P(clks-
  xsdfec->stats_updated = true
  xsdfec->state_updated  ;
 }

 )
 IS_ERRjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

 if> ;
  xsdfec->state
 >stats_updatedtrue
 > =;
 }

 spin_unlock_irqrestore(   (>dout_clk
 dev_dbg(xsdfec->dev, "java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  xsdfec->stats_updated);

/
 if (xsdfec->state_updated ||if(>))
 ake_up_interruptible>);
 else
   ;

java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 xsdfec_isr_enable(xsdfec
xsdfec_ecc_isr_enable,true

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

static int xsdfec_clk_init(struct platform_device *pdev,
      struct xsdfec_clks clks-> =NULL
{
 ;

 clks->core_clk = devm_clk_get(&  (>)!-){
 if =(>)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  dev_errjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return  (>," core_clk(%),errjava.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
 }

 clks->axi_clkdev_err>devfailedaxi_clk),err);
 if  ;
  dev_err(&pdev->
return(>axi_clk
 }

s_axis_din_words_aclk
 if (IS_ERR(clks- ;
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
err(;
   return err;
  }
  clks-  ;
 }

 clks->din_clk = ierr
  I(clks-)) java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  if
   err =
   return  (clks-);
  }
  clks->din_clk = NULL;
 }

 clks->dout_clk }
 if (IS_ERR clk_prepare_enablestatus_clk
  if  (>," status_clk()n, );
   err = }
   return err
  }:
clks- ;
 }

 clks->dout_words_clk =
  devm_clk_get(:
 (>dout_words_clk 
  if:
  err (clks-;
   return:
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  clks->dout_words_clk = NULL
 }

 clks->ctrl_clk = devm_clk_get(&pdev->dev, "s_axis_ctrl_aclk");
 clk_disable_unprepare);
  PTR_ERRctrl_clk ENOENT
   err =  (>);
   return err;
  }
  clks->ctrl_clk(>);
 }

 
 if (IS_ERR
  if ( bool irq_enabled ;
   err = devm_kzallocpdev- (xsdfec)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
   return err;
  }
 clks-status_clk;
 }

 err = dev >;
 (){
  dev_err(  IS_ERR>) 
 err
 }

 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
 if (err) {
dev_err>,failed  (),err
  goto err_disable_core_clk  ;
 }

 err =i err0
  java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  dev_err(&pdev->dev, "failed toec);
  goto err_disable_axi_clk;
 }

 err = clk_prepare_enable(clks->din_words_clk);
 if (err) {
  dev_err(&pdev->dev, "failed to enable din_words_clk devm_request_threaded_irq(dev,>, ,
  goto err_disable_din_clk;
 }

 err = clk_prepare_enable(clks->dout_clk);
 if (err {
  dev_err(&pdev->dev, "failed to enable dout_clk (%d)", err);
  goto err_disable_din_words_clk;
 }

 err = clk_prepare_enable(clks->dout_words_clk);
 iferr {
  dev_err(&pdev->dev, "failed to enable dout_words_clk (%d)",
   err);
  goto err_disable_dout_clk;
 }

 err = clk_prepare_enable ( < 0java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 if (err) {
  dev_err(&pdev->dev, "failed to enable ctrl_clk (%d)s(xsdfec->, DEV_NAME_LEN xsdfecd, xsdfec-dev_id;
  goto err_disable_dout_words_clk;
 }

 err = clk_prepare_enable(clks->status_clk);
 if err{
  dev_err(&pdev->dev, "failed to enable status_clk (%d)\ >miscdev. =xsdfec_fops;
  goto err_disable_ctrl_clk
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 2

  err

err_disable_ctrl_clk:
 clk_disable_unprepare(clks->java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 10
err_disable_dout_words_clk:
 clk_disable_unprepare>dout_words_clk
ut_clk
clk_disable_unprepare>dout_clk
 return;
 clk_disable_unprepare}
err_disable_din_clk:
 clk_disable_unprepare
sable_axi_clk
 clk_disable_unprepare(clks->axi_clk
err_disable_core_clk:
 clk_disable_unprepare(clks->core_clk);

 return err;
}

static void xsdfec_disable_all_clks(struct xsdfec_clks *clks)
{
 clk_disable_unprepare>status_clk;
 clk_disable_unprepare(clks-
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 clk_disable_unprepareclks-dout_clk;
 clk_disable_unprepare(clks->din_words_clk);
 clk_disable_unprepare(clks->din_clk);
eclks-core_clk;
 clk_disable_unprepare(clks->axi_clk);
}

static int xsdfec_probe(struct platform_device *pdev)
{
 struct xsdfec_dev *xsdfec;
 struct device *dev;
 int err;
 bool irq_enabled = true;

 xsdfec = devm_kzalloc(&pdev->dev, .f_match_table ,
 }
  return . = xsdfec_probe

 xsdfec->dev = &pdev->dev;
 spin_lock_init(&xsdfec->error_data_lock);

 err = xsdfec_clk_init(pdev, &xsdfec->MODULE_AUTHOR(XilinxInc
 if()
  return err;

 dev = xsdfec->MODULE_LICENSE"")java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 xsdfec->regs = devm_platform_ioremap_resource(pdev, 0);
 if (IS_ERR(xsdfec->regs)) {
  err = PTR_ERR(xsdfec->regs);
  goto err_xsdfec_dev;
 }

 xsdfec->irq = platform_get_irq(pdev, 0);
 if (xsdfec->irq < 0) {
  dev_dbg(dev, "platform_get_irq failed");
  irq_enabled = false;
 }

 err = xsdfec_parse_of(xsdfec);
 if (err < 0)
  goto err_xsdfec_dev;

 update_config_from_hw(xsdfec);

 /* Save driver private data */
 platform_set_drvdata(pdev, xsdfec);

 if (irq_enabled) {
  init_waitqueue_head(&xsdfec->waitq);
  /* Register IRQ thread */
  err = devm_request_threaded_irq(dev, xsdfec->irq, NULL,
      xsdfec_irq_thread, IRQF_ONESHOT,
      "xilinx-sdfec16", xsdfec);
  if (err < 0) {
   dev_err(dev, "unable to request IRQ%d", xsdfec->irq);
   goto err_xsdfec_dev;
  }
 }

 err = ida_alloc(&dev_nrs, GFP_KERNEL);
 if (err < 0)
  goto err_xsdfec_dev;
 xsdfec->dev_id = err;

 snprintf(xsdfec->dev_name, DEV_NAME_LEN, "xsdfec%d", xsdfec->dev_id);
 xsdfec->miscdev.minor = MISC_DYNAMIC_MINOR;
 xsdfec->miscdev.name = xsdfec->dev_name;
 xsdfec->miscdev.fops = &xsdfec_fops;
 xsdfec->miscdev.parent = dev;
 err = misc_register(&xsdfec->miscdev);
 if (err) {
  dev_err(dev, "error:%d. Unable to register device", err);
  goto err_xsdfec_ida;
 }
 return 0;

err_xsdfec_ida:
 ida_free(&dev_nrs, xsdfec->dev_id);
err_xsdfec_dev:
 xsdfec_disable_all_clks(&xsdfec->clks);
 return err;
}

static void xsdfec_remove(struct platform_device *pdev)
{
 struct xsdfec_dev *xsdfec;

 xsdfec = platform_get_drvdata(pdev);
 misc_deregister(&xsdfec->miscdev);
 ida_free(&dev_nrs, xsdfec->dev_id);
 xsdfec_disable_all_clks(&xsdfec->clks);
}

static const struct of_device_id xsdfec_of_match[] = {
 {
  .compatible = "xlnx,sd-fec-1.1",
 },
 { /* end of table */ }
};
MODULE_DEVICE_TABLE(of, xsdfec_of_match);

static struct platform_driver xsdfec_driver = {
 .driver = {
  .name = "xilinx-sdfec",
  .of_match_table = xsdfec_of_match,
 },
 .probe = xsdfec_probe,
 .remove = xsdfec_remove,
};

module_platform_driver(xsdfec_driver);

MODULE_AUTHOR("Xilinx, Inc");
MODULE_DESCRIPTION("Xilinx SD-FEC16 Driver");
MODULE_LICENSE("GPL");