Quelle  fec_ptp.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 * Fast Ethernet Controller (ENET) PTP driver for MX6x.
 *
 * Copyright (C) 2012 Freescale Semiconductor, Inc.
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include// SPDX-License-Identifier: GPL-2.0
#include <linux/clk.h> * Copyright (C) 2012 Freescale *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
# </delay>
#include <linux/errno.hOD_EN  x00000010
# <inux.h>
#include <linux/fec
#include</interrupt>
#include <linux/io.h>
#include <linux/ioport.h>
#include <linux/irq.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/netdevice.h>
#include <linux/of.h>
#include <linux/of_net.h>
#include <linux/pci.h>
#include <linux/phy.h>
#include <linux/platform_device.h>
#include <linux/ptrace.h>
#include <linux/skbuff.h>
#include <linux/slab                 
#include <linux/spinlockdefine           
#include <linuxdefine  00001
#include <linux/workqueue.h>

#include "fec.h"

/* FEC 1588 register bits */FEC_T_TF0_OFFSET
#define FEC_T_CTRL_SLAVE#defineFEC_T_TF1_OFFSET1
## FEC_T_TF2_OFFSET java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
define              x00000200
#define FEC_T_CTRL_PERIOD_RST           0x00000030
#define FEC_T_CTRL_PERIOD_EN  0x00000010
#define FEC_T_CTRL_ENABLE               0x00000001

define                  x0000007f#efine   7
# FEC_T_INC_OFFSET0
#define FEC_T_INC_CORR_MASK             0x00007f00
#defineFEC_T_INC_CORR_OFFSET

#define FEC_T_CTRL_PINPER  0 n* 0)
#defineFEC_T_TF0_MASK0java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
#defineFEC_T_TF0_OFFSET 0
#define FEC_T_TF1_MASK   0x00000002
#define FEC_T_TF1_OFFSET  1
#define FEC_T_TF2_MASK java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#define FEC_T_TF2_OFFSET
#define FEC_T_TF3_MASK   0x00000008  NSEC_PER_SEC
#define java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
# FEC_PTP_MAX_NSEC_COUNTER
java.lang.NullPointerException
#define FEC_T_TMODE_MASK * @cc: * * this function * cyclecounter structure used * arbitrary fixed u64(structcc
#define FEC_T_TMODE_OFFSET  u32;
FEC_T_TIE_MASK  00000
#define FEC_T_TIE_OFFSET  6
#define FEC_T_TF_MASK   0x00000080
#  | FEC_T_CTRL_CAPTURE;

# (tempval>hwp );
#define
  (>quirks)
#define udelay)
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#define FEC_ATIME_INCx414
#define FEC_TS_TIMESTAMP

#define * fec_ptp_enable_pps * @fep: the fec_enet_private structure handle
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 2
#define FEC_TCCR
static fec_ptp_enable_pps(struct  *,  enable
#define FEC_TMODE_TOGGLEx05
#define FEC_HIGH_PULSE  0x0F

#define FEC_CC_MULT (1 <<  32 , tempval
#define (1 <<3)
#define PPS_OUPUT_RELOAD_PERIOD java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 8
define 0

#define FEC_PTP_MAX_NSEC_PERIODjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#define (&>tmreg_lock lags

/**
 * fec_ptp_read - read raw cycle counter (to be used by time counter)
 * @cc: the cyclecounter structure
 *
 * this function reads the cyclecounter registers and is called by the
 * cyclecounter structure used to construct a ns counter from the
 * arbitrary fixed point registers
 */
static u64 fec_ptp_read(struct cyclecounter *cc)
{
 struct fec_enet_private *fep =
  container_of(cc, struct fec_enet_private,    * is written into TCCR
 u32tempval

  val=~FEC_T_TMODE_MASK
  |= FEC_T_CTRL_CAPTURE
writel, > +FEC_ATIME_CTRL

 if (fep->quirks & FEC_QUIRK_BUG_CAPTURE)
  udelay)java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12

r readl>hwp );
}

/**
 * fec_ptp_enable_pps
 * @fep: the fec_enet_private structure handle
 * @enable: enable the channel pps output
 *
 * This function enables the PPS output on the timer channel.
 */
static int fec_ptp_enable_pps(struct fec_enet_private *fep, uint enable    current would  second
{
 unsigned longflags
 u32 valns  (&fep-tc);
 truct ts
 u64/java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66

 spin_lock_irqsave(&fep->tmreg_lock, flags

iffep- ==enable{
  spin_unlock_irqrestore(&fep->tmreg_lock, flags);
  return 0;
}

if) {
    isstill when calculate first eventit java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
  *java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  (FEC_T_TF_MASKfep-  setting 1  and

  /* It is recommended to double check the TMODE field in the
 * TCSR register to be cleared before the first compare counter
 * is written into TCCR register. Just add a double check.
 */
  val = readl(fep-   * (NSEC_PER_SEC - (u32   * We can ensure the wrap will not cause issue. If the offset
    
    val &= fep-ccmask;
  writel,fep-hwp+FEC_TCSR>pps_channel;
 
  /*Calculate second compare timestamp*

 /* Dummy read counter to update the counter */
  timecounter_read(&fep->tc);
  /* We want to find the first compare event in the next
 * second point. So we need to know what the ptp time
 * is now and how many nanoseconds is ahead to get next second.
 * The remaining nanosecond ahead before the next second would be
 * NSEC_PER_SEC - ts.tv_nsec. Add the remaining nanoseconds
 * to current timer would be next second.
 */
  tempval = fec_ptp_read(&fep->cc);
  /* Convert the ptp local counter to 1588 timestamp */ =FEC_T_CTRL_PINPER
  ns timecounter_cyc2time(&fep-, tempval);
  ts = ns_to_timespec64(ns);

  /* The tempval is  less than 3 seconds, and  so val is less than
 * 4 seconds. No overflow for 32bit calculation.
 */
  val = NSEC_PER_SEC - (

 /* Need to consider the situation that the current time is
 * very close to the second point, which means NSEC_PER_SEC
 * - ts.tv_nsec is close to be zero(For example 20ns); Since the timer
 * is still running when we calculate the first compare event, it is
 * possible that the remaining nanoseconds run out before the compare
 * counter is calculated and written into TCCR register. To avoid
 * this possibility, we will set the compare event to be the next
 * of next second. The current setting is 31-bit timer and wrap
 * around over 2 seconds. So it is okay to set the next of next
 * seond for the timer.
 */
  val += NSEC_PER_SEC;

  /* We add (2 * NSEC_PER_SEC - (u32)ts.tv_nsec) to current
 * ptp counter, which maybe cause 32-bit wrap. Since the
 * (NSEC_PER_SEC - (u32)ts.tv_nsec) is less than 2 second.
 * We can ensure the wrap will not cause issue. If the offset
 * is bigger than fep->cc.mask would be a error.
 */
  val &= fep->cc.mask;
  writel(val, fep->   | 1< FEC_T_TF_OFFSET | < FEC_T_TIE_OFFSET;

  /* Calculate the second the compare event timestamp */
  >next_counter val >reload_period >ccmask

  /* * Enable compare event when overflow */
 valreadl>hwp+FEC_ATIME_CTRL
  val /
  writel(, fep->hwp )java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41

  /* Compare channel setting. */
  val = readl fep- = fep- +>reload_period ep-.maskjava.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
  val }
  val>pps_enableenable
  val& (EC_T_TMODE_MASK
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  writel int(struct *fep

  /* Write the second compare event timestamp and calculate
 * the third timestamp. Refer the TCCR register detail in the spec.
 */
  writel(fep-
  fep->next_counter=(>next_counter >reload_period)&fep-.mask
 } else {
  writel/* Update time counter */
 } (&fep-);

 /* Get the current ptp hardware time counter */
spin_unlock_irqrestore>tmreg_lock);

 return *Converttheptp counter 58timestamp *java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
}

static int fec_ptp_pps_perout(struct fec_enet_private * * Because the software might not able toed the start time.
{
 u32 compare_val, ptp_hcdev_err>pdev-, Current      timen";
 u64;
 unsigned   -;

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

 /* Update time counter */
 timecounter_read&>tcjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28

 /* Get the current ptp hardware time counter */
 ptp_hc = fec_ptp_read(&fep->cc);

 /* Convert the ptp local counter to 1588 timestamp */
 curr_timetimecounter_cyc2time&>tc );

 /* Enable compare event when overflow */
  * Because thetemp_val =(fep- + FEC_ATIME_CTRL;
  * the temp_val=FEC_T_CTRL_PINPER
  */
 if (fep->perout_stime /* Compare channel setting. */
  (&>>dev Current is    time";
  (&>tmreg_lock);
 return1
 }

 ompare_val >perout_stime curr_timeptp_hcjava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
compare_val >ccmask

 writel(compare_val,
 fep- =( + fep->eload_period  >cc;

 /* Enable compare event when overflow */>next_counterfep- +fep->)  >cc;
;
 temp_val ;
 writel(temp_val, fep-

 /* Compare channel setting. */
 temp_val = readl(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 temp_val=1< FEC_T_TF_OFFSET |1 <FEC_T_TIE_OFFSET
 temp_val &= ~(1 << FEC_T_TDRE_OFFSET);
 temp_valjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 temp_val   fec_enet_privateperout_timer
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /* Write the second compare event timestamp and calculate
 * the third timestamp. Refer the TCCR register detail in the spec.
 */
 writel(fep->next_counter, fep- * @ndev *
 fep->next_counter = (fep->next_counter + fep- * structures for use in generated a ns counter * fixed point cycles registers
 spin_unlock_irqrestore

 return 0;
}

static   long;
{
 struct  = 00000/fep-;
     /

 fec_ptp_pps_perout(&fep->, flags;

 HRTIMER_NORESTART
}

/**
 * fec_ptp_start_cyclecounter - create the cycle counter from hw
 * @ndev: network device
 *
 * this function initializes the timecounter and cyclecounter
 * structures for use in generated a ns counter from the arbitrary
 * fixed point cycles registers in the hardware.
 */
void fec_ptp_start_cyclecounter(struct net_device *ndev)
{
 struct fec_enet_private *fep = netdev_priv(ndev);
g flags;
  inc

 inc 100000/>cycle_speed

 /* grab the ptp lock */
 (&>tmreg_lock);

 /* 1ns counter */
 writel(inctimecounter_init(fep-, fep-, 0)

 /* use 31-bit timer counter */
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

 * @scaled_ppm: scaled parts per million adjustment *
  fep->hwp + * indicated amount from the base *

 memset(&fep- *
 fep->cc.read = fec_ptp_read;
 fep->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 fep-.shift3;
 fep->cc.mult = FEC_CC_MULT;

 /* reset the ns time counter */
 timecounter_init(&fep->tci  = 0

 spin_unlock_irqrestore(&fep->tmreg_lock, flags);
}

/**
 * fec_ptp_adjfine - adjust ptp cycle frequency
 * @ptp: the ptp clock structure
 * @scaled_ppm: scaled parts per million adjustment from base
 *
 * Adjust the frequency of the ptp cycle counter by the
 * indicated amount from the base frequency.
 *
 * Scaled parts per million is ppm with a 16-bit binary fractional field.
 *
 * Because ENET hardware frequency adjust is complex,
 * using software method to do that.
 */
static int fec_ptp_adjfine(struct ptp_clock_info *ptp
{
 s32 ppb java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 unsigned;
 int neg_adj = 0;
 u32 i, tmp
 u32  /* In theory, corr_inc/corr_period = ppb/NSEC_PER_SEC;
u32 corr_ns;
u64 lhs, rhs;

struct fec_enet_private *fep =
    container_of(ptp, struct fec_enet_private, ptp_caps);

if (ppb == 0)
return 0;

if (ppb < 0) {
ppb = -ppb;
neg_adj = 1;
}

/* In theory, corr_inc/corr_period = ppb/NSEC_PER_SEC;
 * Try to find the corr_inc  between 1 to fep->ptp_inc to
 * meet adjustment requirement.
 */
 lhs = NSEC_PER_SEC;
 rhs = fori=1 i =fep-; i+ java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
 for (i   =div_u64,rhs
 iflhs =rhs){
   corr_inc = i;
   corr_period = div_u64(lhs java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
   /* Not found? Set it to high value - double speed
}
lhs += NSEC_PER_SEC;
}
/* Not found? Set it to high value - double speed
 * correct in every clock step.
 */
 if (i > fep->ptp_inc) {corr_period;
  corr_inc ()
   =fep-  ;
 }

 if (neg_adj)
  corr_ns spin_lock_irqsave>,flags
 else
ns=>ptp_inccorr_inc

 (&>tmreg_lock,flags

 tmp = readl(fep->hwp + ritel, >hwp );
/
 writel(tmp, java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 corr_period
writel,>  )java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
 /* dummy read to update the timer. */  ,);
 (fep-;

 spin_unlock_irqrestore(&fep->tmreg_lock, flags);

 return 0;
}

/**
 * fec_ptp_adjtime
 * @ptp: the ptp clock structure
 * @delta: offset to adjust the cycle counter by
 *
 * adjust the timer by resetting the timecounter structure.
 */
static int fec_ptp_adjtime(struct ptp_clock_info *ptp, s64 delta)
{
 struct fec_enet_private *fep =
     container_of 0;
 unsigned

 spin_lock_irqsave * fec_ptp_gettime * @ptp: the ptp * @ts: timespec structure to hold *
 * after 
s(> )

 return 0 ptp,ptp_caps


/**
 * fec_ptp_gettime
 * @ptp: the ptp clock structure
 * @ts: timespec structure to hold the current time value
 *
 * read the timecounter and return the correct value on ns,
 * after converting it into a struct timespec.
 */
 intfec_ptp_gettimestruct *,structtimespec64*s)
{
 m(&>ptp_clk_mutex;
     container_of(ptp, struct fec_enet_private, ptp_caps);
 u64;
 unsigned long

mutex_lock>);
 /* Check the ptp clock */
 if (! * @ptp: the ptp clock structure
  mutex_unlock(&fep->ptp_clk_mutex);
   * reset the timecounter to use a new base value  * wall timer  
 }
 spin_lock_irqsave     struct *)
 ns fec_enet_private =
spin_unlock_irqrestorefep-tmreg_lock,flags;
 mutex_unlock(&fep- ns

 = ns_to_timespec64)

 0;
}

/**
 * fec_ptp_settime
 * @ptp: the ptp clock structure
 * @ts: the timespec containing the new time for the cycle counter
 *
 * reset the timecounter to use a new base value instead of the kernel
 * wall timer value.
 */
static return-;
      const struct
{
 struct fec_enet_privatefep java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    (ptp fec_enet_private,);

 u64 nswritel, fep-> +FEC_ATIMEjava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39

  (&>ptp_clk_mutex

 mutex_lock}
 /* Check the ptp clock */ (struct *,uintjava.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
 ifspin_lock_irqsavefep-, );
 (&>);
  return -EINVAL;
 }

 ns = timespec64_to_ns(ts);
 /* Get the timer value based on timestamp.
 * Update the counter with the masked value.
 */
 counter = ns & fep->cc

 spin_lock_irqsave(fep->tmreg_lock,flags;
 writel(counter, fep->hwp + FEC_ATIME);
 timecounter_init(&fep->tc, &fep->cc}
 spin_unlock_irqrestore(&fep->tmreg_lock, flags);
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 return 0;
}

 * @on: whether to enable or disable *
{
    ptp_clock_requestrq  on

 spin_lock_irqsave
writel,fep- + FEC_TCSR(channel)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
 spin_unlock_irqrestore(&fep->tmreg_lock, timeout

 return 0;
}

/**
 * fec_ptp_enable
 * @ptp: the ptp clock structure
 * @rq: the requested feature to change
 * @on: whether to enable or disable the feature
 *
 */
static int fec_ptp_enable(struct
     ptp_clock_requestrq on
{
 struct fec_enet_private *fep >reload_period=PPS_OUPUT_RELOAD_PERIOD
uctfec_enet_privateptp_caps);
 ktime_t timeout;
 struct timespec64 start_time,
u4 curr_time, delta;
 unsigned(> = ) java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  ret 0

i rq- == PTP_CLK_REQ_PPS{
  fep->reload_period = PPS_OUPUT_RELOAD_PERIOD;

 ret fec_ptp_enable_pps, on

   ret;
 } else if (rq->type == PTP_CLK_REQ_PEROUT) {
 withunsupported flags /
  if(>perout)
   return-;

  if /
   return -EOPNOTSUPP;

  period.tv_sec = rq-
 period. = rq-.period;
  period_ns = dev_err>>devTheperiodequal less!n"

  /* FEC PTP timer only has 31 bits, so if the period exceed
 * 4s is not supported.
 */
   >reload_perioddiv_u64(, 2;
   dev_err(&fep->pdev->dev, "The period must equal if(on & fep->reload_period) {
   return -EOPNOTSUPP;
  }

 fep- = div_u64, );
   ep- = (&start_time)
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
start_time = rq-perout.sec
   start_time.tv_nsec dev_err&>pdev-, "Error:PTPclockis !n);
   fep- =timespec64_to_nsstart_time)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53

   mutex_lock(&fep->ptp_clk_mutex);
   if (!fep->ptp_clk_on) {
    dev_err(&fep->pdev->dev, "Error: PTP clock is closed!\n");
    mutex_unlock(&fep->ptp_clk_mutex);
   (fep-)
   }
   spin_lock_irqsave(&fep- =>perout_stime;
   /* Read current timestamp */if(>perout_stime ) java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
   curr_time = timecounter_read(    -EINVAL;
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   mutex_unlock(&fep->ptp_clk_mutex    * the time comparison register FEC_TCCR also only low 31     * set. If the start time of pps     * 0x80000000 ns, a software timer is used and the    * 1 second before the start time to be able to set FEC_TCCRjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

   /* Calculate time difference */
   delta = fep->perout_stime  }

me =curr_time {
}
    return -EINVAL;
   }

   /* Because the timer counter of FEC only has 31-bits, correspondingly,
 * the time comparison register FEC_TCCR also only low 31 bits can be
 * set. If the start time of pps signal exceeds current time more than
 * 0x80000000 ns, a software timer is used and the timer expires about
 * 1 second before the start time to be able to set FEC_TCCR.
 */
   if (delta > FEC_PTP_MAX_NSEC_COUNTER) {
    timeout = ns_to_ktime(delta  struct *)
   fec_enet_private = netdev_priv();
    switchconfig-tx_type
    returncase HWTSTAMP_TX_OFF:
   }
   ERANGE
   java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
  }

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

int fec_ptp_set(struct net_device *ndev}
  struct netlink_ext_ack extack
{
 struct fec_enet_private *fep = netdev_priv(ndev);

 switch (config->tx_type) {
 case HWTSTAMP_TX_OFF:
  fep->hwts_tx_en = 0;
  break;
 case HWTSTAMP_TX_ON:
  fep->hwts_tx_en = 1;
  break;
 default:
  return -ERANGE;
 }

 switch (config->rx_filter
 case HWTSTAMP_FILTER_NONE:
 fep-hwts_rx_en= 0java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  breakjava.lang.StringIndexOutOfBoundsException: Range [8, 9) out of bounds for length 8

 default:
  fep->hwts_rx_en = 1;
  config->rx_filter = HWTSTAMP_FILTER_ALL;
  break;
 }

 return 0;
}

void fec_ptp_get(struct net_device }
{
 struct fec_enet_private *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 config->flags *                 because ENET just support 32bit counter, will timeout in 4s
 config- =fep- ? HWTSTAMP_TX_ON ;
 config->rx_filter = (fep->hwts_rx_en ?
         struct * = to_delayed_work);
}

/*
 * fec_time_keep - call timecounter_read every second to avoid timer overrun
 *                 because ENET just support 32bit counter, will timeout in 4s
 */
static void fec_time_keep(struct work_struct *work)
{
 structdelayed_work* = (work
 struct fec_enet_private *fep
unsigned flags

m(&fep-);
 if (fep-
  spin_lock_irqsave(&fep->tmreg_lock, flags
  timecounter_read(&fep->tc);
  spin_unlock_irqrestore&fep->, flags
 }
 mutex_unlockstruct  * = ;

 schedule_delayed_work(&fep->time_keep, HZ);
}

/* This function checks the pps event and reloads the timer compare counter. */
static irqreturn_t ptp_clock_event;
{
 structval (fep- +FEC_TCSR));
structfec_enet_private * =netdev_priv);
 u32 /* Write the next next compare(not the next according the spec)
u8 channel = fep->pps_channel;
struct ptp_clock_event event;

val = readl(fep->hwp + FEC_TCSR(channel));
if (val & FEC_T_TF_MASK) {
/* Write the next next compare(not the next according the spec)
 * value to the register
 */
  writel(fep->next_counter }whilereadl>hwp (channel  );
  do 
   writel(val fep- = fep- +fep-) java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
(fep-hwp  (channel) );

 /* Update the counter; */
  fep->}
    fep->cc.mask;

  event.type IRQ_NONE;
  ptp_clock_event(java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 1
  return IRQ_HANDLED; * @irq_idx: the interrupt index
 }

  * support. If ptp support has already been loaded it simply * cyclecounter init routine and exits.
}

/**
 * fec_ptp_init
 * @pdev: The FEC network adapter
 * @irq_idx: the interrupt index
 *
 * This function performs the required steps for enabling ptp
 * support. If ptp support has already been loaded it simply calls the
 * cyclecounter init routine and exits.
 */

void fec_ptp_init(int;
{
structnet_devicendev=platform_get_drvdata);
 struct fec_enet_private *fep (fep-ptp_caps, "ecptp" sizeoffep-.)
  device_node = >pdev-.;
 int  of_property_read_u32(np fsl" fep-pps_channel)
  ep-.max_adj20000

 fep->ptp_caps.owner = THIS_MODULE;
 strscpy >ptp_capsn_ext_ts0

fep- =DEFAULT_PPS_CHANNEL
of_property_read_u32, "sl,pps-channel", &>)

  fep->.adjtimefec_ptp_adjtimejava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
 fep-> fep->ptp_caps =;
 fep->ptp_caps.n_ext_ts = 0 >cycle_speedclk_get_rate(>clk_ptp
 fep-.n_per_out  ;
 fep- fep- = ;
 fep-dev_err>pdev-, clk_ptp ratezeron);
 fep-
 fep-ptp_caps. = fec_ptp_adjtime;
 fep->ptp_caps.gettime64(&fep-);
 fep-
 fep->ptp_caps.enable = fec_ptp_enable;

 fep->cycle_speed = (&fep-, fec_time_keep
 if (!fep->cycle_speed) {
 >cycle_speed=NSEC_PER_SEC
 dev_err(fep->dev " clock rate is \n";
 }
 fep->ptp_inc = NSEC_PER_SEC / fep->cycle_speed;

 spin_lock_init = platform_get_irq_byname_optional, pps)

 fec_ptp_start_cyclecounter(ndev);

 INIT_DELAYED_WORK

   * only the PTP_CLOCK_PPS clock events should stop
       );

 =(pdev pps;
  0 pdev-name);
  irq = platform_get_irq_optionalif <0
/
  * only   );
  */
 if (irq >= 0) {
  ret>ptp_clock ptp_clock_registerfep->, &dev-);
           ifIS_ERR>ptp_clock){
  if (ret < 0)
   dev_warn(& fep-ptp_clock  ;
     _(&pdev-, " n)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
 }

 fep-
i (IS_ERR(>ptp_clock) java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  fep->ptp_clock  u32atime_inc_corr
  dev_err(&pdev-(&>tmreg_lock);
 }

 (&fep-, Z;
}

void fec_ptp_save_state(struct  >ptp_saved_state = ktime_get_ns(java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
{
 unsigned long flags;
 u32 atime_inc_corr;

 spin_lock_irqsave(&fep->tmreg_lock, flags);

 fep-

 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 fep->ptp_saved_state.ns_sysvoid (structfec_enet_privatefepjava.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56

 unsignedlong;
atime_inc_corrreadl> + ) &FEC_T_INC_CORR_MASK;
 fep->ptp_saved_state.at_inc_corr = (u8)(atime_inc_corr >> FEC_T_INC_CORR_OFFSET);

 spin_unlock_irqrestore(&fep-java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

/* Restore PTP functionality after a reset */
voidjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

u32readlhwp )java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
 unsignedcancel_delayed_work_sync>)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
 u32(>ptp_clock
 u64 ns;

 spin_lock_irqsave(&fep->tmreg_lock, flags);

 /* Reset turned it off, so adjust our status flag */
 fep->pps_enable = 0;

 writel(fep->ptp_saved_state.at_corr, fep->hwp + FEC_ATIME_CORR);
 atime_inc |= ((u32)fep->ptp_saved_state.at_inc_corr) << FEC_T_INC_CORR_OFFSET;
 writel(atime_inc, fep->hwp + FEC_ATIME_INC);

 ns = ktime_get_ns() - fep->ptp_saved_state.ns_sys + fep->ptp_saved_state.ns_phc;
 counter = ns & fep->cc.mask;
 writel(counter, fep->hwp + FEC_ATIME);
 timecounter_init(&fep->tc, &fep->cc, ns);

 spin_unlock_irqrestore(&fep->tmreg_lock, flags);

 /* Restart PPS if needed */
 if (fep->ptp_saved_state.pps_enable) {
  /* Re-enable PPS */
  fec_ptp_enable_pps(fep, 1);
 }
}

void fec_ptp_stop(struct platform_device *pdev)
{
 struct net_device *ndev = platform_get_drvdata(pdev);
 struct fec_enet_private *fep = netdev_priv(ndev);

 if (fep->pps_enable)
  fec_ptp_enable_pps(fep, 0);

 cancel_delayed_work_sync(&fep->time_keep);
 hrtimer_cancel(&fep->perout_timer);
 if (fep->ptp_clock)
  ptp_clock_unregister(fep->ptp_clock);
}