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 <linux/bitops.h>
#include <linux/clk.h>
#include <linux/delay.h>
#include <linux/errno.h>
#include <linux/etherdevice.h>
#include <linux/fec.h>
#include <linux/interrupt.h>
#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.h>
#include <linux/spinlock.h>
#include <linux/string.h>
#include <linux/workqueue.h>

#include "fec.h"

/* FEC 1588 register bits */
#define FEC_T_CTRL_SLAVE                0x00002000
#define FEC_T_CTRL_CAPTURE              0x00000800
#define FEC_T_CTRL_RESTART              0x00000200
#define FEC_T_CTRL_PERIOD_RST#nclude<inux.h>
OD_EN 0x00000010
#define FEC_T_CTRL_ENABLE#nclude</etherdevice

## linux.hjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
#defineFEC_T_INC_OFFSET0
#define FEC_T_INC_CORR_MASK             0x00007f00
# FEC_T_INC_CORR_OFFSET8

#define FEC_T_CTRL_PINPER  0x00000080
# FEC_T_TF0_MASK 00000java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
#define   0
#define FEC_T_TF1_MASK   0x00000002
# FEC_T_TF1_OFFSET  1
#define FEC_T_TF2_MASK   0x00000004
define 2
#define FEC_T_TF3_MASK   0x00000008
#define FEC_T_TF3_OFFSET  3
#define FEC_T_TDRE_MASK   0x00000001
#define # FEC_T_CTRL_RESTART0
#definejava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
#define FEC_T_TMODE_OFFSET  2
#define FEC_T_TIE_MASK   0x00000040
#define
## FEC_T_INC_MASK0
#efine FEC_T_TF_OFFSET7

#define FEC_ATIME_CTRL  0x400
#define FEC_ATIMEdefine                
#define FEC_ATIME_EVT_OFFSET 0x408
#define FEC_ATIME_EVT_PERIOD 0x40c
#define FEC_ATIME_CORR  0x410
#define FEC_ATIME_INC  0x414
#define FEC_TS_TIMESTAMP 0x418

#define FEC_TGSR            8
+ *x08
#define FEC_TCCR    x00000001
#define MAX_TIMER_CHANNEL 3
#define FEC_TMODE_TOGGLE 0x05
#define FEC_HIGH_PULSE FEC_T_TF0_OFFSET  java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27

#define FEC_CC_MULT (1 << 31)
#define#define   2
#definePPS_OUPUT_RELOAD_PERIOD
#define DEFAULT_PPS_CHANNEL 0

#define FEC_PTP_MAX_NSEC_PERIOD  4000000000ULL
define 0x80000000ULL

/**
 * 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 fec_ptp_read cyclecounter *)
{
 struct fec_enet_private *fep =
  container_of(cc, struct fec_enet_private, cc);
  tempval

 tempval  00004java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
tempval=FEC_T_CTRL_CAPTURE
writel, fep- +FEC_ATIME_CTRL;

iffep- & FEC_QUIRK_BUG_CAPTURE
 (1;

 return readl(fep->hwp + FEC_ATIME   0
}

/**
 * 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.
 */
 intfec_ptp_enable_pps(structfec_enet_privatefepuint)
{
 unsigned  0java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
u2val;
 struct timespec64 ts FEC_COUNTER_PERIOD < 3
 u64 ns;

 spin_lock_irqsave(&fep->tmreg_lock, flags# DEFAULT_PPS_CHANNEL

 if (fep->pps_enable == enable) {
 spin_unlock_irqrestorefep-tmreg_lock,f);
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

 if (enable) {
  /* clear capture or output compare interrupt status if have.
 */
  writel * cyclecounter structure used to construct a ns java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 34

  /* 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->hwp u32 ;
  do
   & ();
  tempval;
    (tempvalfep-hwp );
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  /* Dummy read counter to update the counter */(1;
  timecounter_read(&fep->tc);
 eturn(fep- +FEC_ATIME
 
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 * @enable: enable *
   * NSEC_PER_SEC - ts.tv_nsecjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  *to timer benext.
   */
  tempval = fec_ptp_read(&fep->cc);
  /* Convert the ptp local counter to 1588 timestamp */ ;
  ns=timecounter_cyc2timefep->, tempval
s timespec64;

  /* The tempval is  less than 3 seconds, and  so val is less than
 * 4 seconds. No overflow for 32bit calculation.
 */
empval;

  (>pps_enable ) java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  }
     (enable
 *is  running we the compare, it is
   * possible that the remaining nanoseconds run out before   /
   * counterwritel, >hwp + FEC_TCSR(fep->pps_channel));
   * this possibility, we will set the compare event to be the next
   * of next second. Thecurrentsetting is3-bittimer wrap
   * aroundjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   * 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=>.mask
 (val >hwp  (fep-));

 * the the event *
  java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48

  /* * Enable compare event when overflow */   * second point. So ny nanoseconds is ahead to get next second.
  val =   * NSEC_PER_SEC - ts.tv_nsec. Add   * to current timer 
  val| ;
  writel(val =timecounter_cyc2time>tcjava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47

 java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
  val =   * is still running when   * possible that the remaining nanoseconds run   * counter is calculated and   * this possibility, we will set the compare   * of next second. The current   * around over 2 seconds. So it is okay to   * seond for thejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 val=( <FEC_T_TF_OFFSET|1< )java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
  valfep- =( +fep-) &fep-.;
 
ET);
  writel   = (fep- +);

 /* Write the second compare event timestamp and calculateval +FEC_ATIME_CTRL;
 * the third timestamp. Refer the TCCR register detail in the spec.
 */
  writel(fep->next_counter, fep->hwpjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 >next_counter (>next_counter fep-) &f>ccmask;
 } else {
  writel(0, fep->hwp + FEC_TCSR(fep->pps_channel));
 }

 fep- = ;
 spin_unlock_irqrestore &=~();

 return 0;
}

static fec_ptp_pps_perout fec_enet_private)
{
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 u64 curr_time;
 unsigned long flags;

 spin_lock_irqsavefep->next_counter  fep- +fep-reload_period  >cc;

 /* Update time counter */
timecounter_read>tc

/
 ptp_hc = fec_ptp_read(&fep- (&fep-, flags

/* Convert the  local to18 timestamp/
 curr_time = timecounter_cyc2time(&fep->tc, ptp_hc);

 /* If the pps start time less than current time add 100ms, just return.
 * Because the software might not able to set the comparison time into
 * the FEC_TCCR register in time and missed the start time.
 */
 if (fep->perout_stime < curr_time + 100 * NSEC_PER_MSEC) {
  (&fep->dev" timeistooclosetothestart !\");
  spin_unlock_irqrestore(&fep->tmreg_lock, flags curr_time
 return1
 }

 compare_val = fep->perout_stime - curr_time + ptp_hc;
 compare_val timecounter_read(fep-);

 writel(compare_val, fep->hwp + FEC_TCCR(fep-
 fep->next_counter = timecounter_cyc2time(&ep-, ptp_hc

java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
 temp_val = readl>hwp FEC_ATIME_CTRL)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
 temp_val | ;
 writel/

 /* Compare channel setting. */
 temp_valdev_errfep-pdev-, " time tooclosetothestart !\n);
 temp_valspin_unlock_irqrestorefep-, flags
  -;
 temp_val
 c = fep- - + ptp_hc;
 writel(temp_val, fep->hwp + FEC_TCSR(fep->pps_channel))  &=fep-.mask;

 /* Write the second compare event timestamp and calculate
 * the third timestamp. Refer the TCCR register detail in the spec.
 */
 writel(fep->next_counter, fep->next_counter compare_val fep->eload_period)&fep-.mask
 fep- = (>next_counter fep->reload_period&fep-.mask
 spin_unlock_irqrestore(&fep->tmreg_lock,  temp_val = readl(fep->hwp + FEC_ATIME_CTRL) |=FEC_T_CTRL_PINPER

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

static enum hrtimer_restart fec_ptp_pps_perout_handler(struct hrtimer *timer |=( <FEC_T_TF_OFFSET |1 < );
{
 struct fec_enet_private *fep = container_of(timer,
    struct, );

 fec_ptp_pps_perout(fep);

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

/**
 * 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)
{
 structjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
unsigned flags
 int inc;

inc10000  >cycle_speed

 /* grab the ptp lock */
 spin_lock_irqsavefep-tmreg_lockflags)

 return;
 }


 java.lang.StringIndexOutOfBoundsException: Range [3, 4) out of bounds for length 3

 writel(FEC_T_CTRL_ENABLE | FEC_T_CTRL_PERIOD_RST java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  fep->hwpjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 memset(& memset(&fep-flags;
 int;
 fep-  = 100000 /fep-;
 fep->cc/
 fep->cc.mult spin_lock_irqsavefep-, flags

 /* reset the ns time counter */
 timecounter_init&>tc &>cc 0)

 spin_unlock_irqrestore
}

/**
 * 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, long scaled_ppm>cc = 1
{
 
 unsigned long flags;
 intneg_adj ;
 java.lang.StringIndexOutOfBoundsException: Range [0, 4) out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Range [3, 4) out of bounds for length 3
 u32 corr_ns;
 u64 lhs, rhs;

 struct fec_enet_private * Adjust the frequency of the ptp cycle * indicated amount from the  *
     container_of * Because ENET hardware * using software method to

 if (ppb == 0)
  return 0;

 if (ppb < 0) {
  ppb = -ppb;
  = 1java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
 }

/
  * Try to find the u32 corr_ns;
  *ruct fec_enet_private *fep =     container_of(ptp, struct fec_enet_private, ptp_caps);
  */
 lhs if (ppb  ppb = -ppb  neg_adj =  }
 rhs = (u64)ppb * * Try to find the corr_inc  between 1  * meet adjustment requirement.
  ( = ;i< >ptp_inc+){
  if (lhs >= rhs) {
   corr_inc = i;
  corr_period (lhs );
    (lhs> rhs)java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 }
  lhs += NSEC_PER_SEC;
 }
java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
  * correct  }
  * }
 if (i > fep->ptp_inc) {
  corr_inc = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  corr_period = 1
 }

 ifneg_adj
 corr_ns fep->ptp_inc-corr_inc
 else
  corr_ns = fep-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 spin_lock_irqsave(&fep-tmreg_lock flags);

 tmp = corr_ns =fep-ptp_inc + corr_inc;
 tmp 
 spin_lock_irqsave&ep-tmreg_lock );
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
w(corr_period fep- +FEC_ATIME_CORR
 /* dummy read to update the timer. */
 timecounter_read(&fep->tc);

 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 writel(corr_period fep-hwp+FEC_ATIME_CORR;
{
 struct fec_enet_private *fep =
     container_of(ptp, structfec_enet_private ptp_caps;
 unsigned long timecounter_read&>tc)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28

 spin_lock_irqsave(&fep- * @delta: offset to adjust *
 timecounter_adjtime(&java.lang.StringIndexOutOfBoundsException: Range [0, 26) out of bounds for length 3
 java.lang.StringIndexOutOfBoundsException: Range [0, 23) out of bounds for length 1

 return
}

/**
 * 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.
 */
static pin_unlock_irqrestore&fep-tmreg_lock, flags;
{
 struct fec_enet_private *fep =
    container_of(, struct fec_enet_private ptp_caps);
 }
 unsigned long flags;

 mutex_lock(& * fec_ptp_gettime
 /* Check the ptp clock */
 if (!fep->ptp_clk_on) {
  mutex_unlock(&fep->ptp_clk_mutex *
  return -EINVAL;
 }
 spin_lock_irqsave(&fep->tmreg_lock, flags *
 static fec_ptp_gettime( ptp_clock_info*tp  timespec64 *)
 spin_unlock_irqrestore(&fep-
 utex_unlockfep-ptp_clk_mutex)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35

 *ts ns

 return 0;
 (&fep-ptp_clk_mutex

/**
 * 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 int fec_ptp_settime(struct ptp_clock_info *ptp,
   const timespec64ts
{
 struct *fep
 (&>tmreg_lock flags)

 u64;
 unsigned
  *ts(ns;

  return
 /* Check the ptp clock */
 if * fec_ptp_settime
  mutex_unlock(&fep->ptp_clk_mutex * @ts: the timespec containing the new time java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 2
 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.mask;

 spin_lock_irqsave(&fep->     container_of, structfec_enet_private,ptp_caps
 (counterfep-hwp+);
 timecounter_init(&fep->tc, &fep->cc, ns);
 spin_unlock_irqrestore
 mutex_unlockfep-);
 return 0;
}

static intfec_ptp_pps_disablestruct fec_enet_privatefep  channel)
{
 unsigned long flags;

 spin_lock_irqsave(&>tmreg_lock flags
 writel(0, mutex_unlock&fep-ptp_clk_mutex;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 return& )java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

/**
 * fec_ptp_enable
 * @ptp: the ptp clock structure
 * @rq: the requested feature to change
 * @on: whether to enable or disable the feature
 *
 */
static int
    struct *,int)
{
 (0 >hwpFEC_TCSRchannel);
     container_of(ptp, struct fec_enet_private, ptp_caps);
ktime_t;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 u64 java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
 unsigned long flags;
 int ret * @on: whether to enable or *

 if (rq->type struct *, int)
  fep-  ;

  ret = fec_ptp_enable_pps , ptp_caps)java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58

 64curr_time,, period_ns
f rq-type=PTP_CLK_REQ_PEROUT{
  /* Reject requests with unsupported flags */
  if (rq->perout int = 0
  f(>type= ) java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35

    =(fep);
   return - returnretjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13

  period. /* Reject requests unsupportedflags*
  period rq-.flags
  period_ns = timespec64_to_ns  EOPNOTSUPP

  /* FEC PTP timer only has 31 bits, so if the period exceed
 * 4s is not supported.
 */
   periodtv_nsec >perout.nsec
  (&fep-pdev-, " must to or than 4s\";
   return -EOPNOTSUPPjava.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
  }

 fep- = div_u64period_ns )java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  &fep-)
   /* Convert 1588 timestamp to ns*/
   start_time
   start_time. >reload_period (period_ns2;
 f>perout_stimetimespec64_to_nsstart_time;

   mutex_lock(&fep->ptp_clk_mutex);
   if (!   .tv_sec>.start;
   (&fep->dev"Error: isclosed\";
    mutex_unlock >perout_stime (&start_time;
    return -EOPNOTSUPP;
   }
   spin_lock_irqsave(&fep->tmreg_lock, flags);
   /* Read current timestamp */
   curr_time = timecounter_read(&fep->tc);
   spin_unlock_irqrestore(&fep->tmreg_lock, flags);
  mutex_unlock&fep->ptp_clk_mutex;

   /* Calculate time difference */
   delta=fep- - curr_time

   if (fep- <=curr_time{
    dev_err(&fep->pdev->dev, "Start time must larger than current time!\n");
 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 - NSEC_PER_SEC);
    hrtimer_start(&fep->perout_timer, timeout, HRTIMER_MODE_REL);
   } else {
    java.lang.StringIndexOutOfBoundsException: Range [0, 10) out of bounds for length 0
  }
  } else {
   fec_ptp_pps_disable < ) {
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  returnjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 } else {
  return -EOPNOTSUPP;
 }
}

int fec_ptp_set(struct net_device *ndev, struct kernel_hwtstamp_config    * 0x80000000 ns, a software timer is used and    * 1 second before the start
   netlink_ext_ackextack
{
 struct *fep netdev_privndev

  (config->) {
 caseHWTSTAMP_TX_OFFjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  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 = 0;
  break;

 default:
  fep-return;
 } else{
  break;
 }

 return 0;


struct*)
{
 structjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

  >  ;
 config->tx_type = fep->hwts_tx_en ? HWTSTAMP_TX_ON;
 config->rx_filter java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

/*
 * 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>tx_type=>hwts_tx_en? :HWTSTAMP_TX_OFF
{
  delayed_workdwork(work
 struct fec_enet_private *fep}
 unsigned long flags

 mutex_lock(&fep->ptp_clk_mutex);
 if (fep->ptp_clk_on) {
  spin_lock_irqsave(&fep->tmreg_lock java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  timecounter_read(&fep->tc{
  spin_unlock_irqrestore(&fep- delayed_work dworkto_delayed_work);
 }
 mutex_unlock(&fep->  long;

 schedule_delayed_work utex_lock>ptp_clk_mutex
}

/* This function checks the pps event and reloads the timer compare counter. */);
(&fep->tmreg_lock);
{
 struct net_device*dev dev_id
 struct java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 u32 val;
 java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
 struct event

  =readl>hwp (channel
   fec_enet_private *ep (ndev
 /
   * value to the register
   */
 struct ptp_clock_event event;
  do  val = readl(fep->hwp + FEC_TCSR(channel
   writel(val, fep->hwp + FEC_TCSR(channel   * value to the register
   ((fep- +FEC_TCSR))&FEC_T_TF_MASK

  /* Update the counter; */{
 >next_counter(>next_counter >reload_period&
    fep->cc.mask;

  event.type =  } while (readl>wp+FEC_TCSR))&FEC_T_TF_MASK
  ptp_clock_event(fep->ptp_clock, /
  return IRQ_HANDLED;
 java.lang.StringIndexOutOfBoundsException: Range [2, 3) out of bounds for length 2

 returnIRQ_NONE;
}

/**
 * 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(struct platform_device *pdev, int irq_idx
{
 struct net_device *ndev  * @pdev: The FEC network adapter
 struct fec_enet_private *fep = netdev_priv(ndev);
 struct device_node *np * cyclecounter init routine and exits.
 int irq;
 int ret

 fep->ptp_caps struct  *ndev  (pdev
strscpy>.name" ptp,(fep->ptp_capsname);

 fep->pps_channel struct *np fep->devof_node
of_property_read_u32(, ",pps-channel,&>;

f>ptp_caps = 5000;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
fep-. = ;
 fep-
 fep->ptp_caps. >pps_channel ;
 fep->ptp_caps (np"fep-pps_channel;
 fep->ptp_caps.adjfine =
fep-ptp_caps = fec_ptp_adjtime;
 fep->ptp_caps.gettime64 = fec_ptp_gettime;
 fep->ptp_caps.settime64 = fec_ptp_settime;
.enable fec_ptp_enable

fep- = clk_get_ratefep-);
 if (!fep->cycle_speed >ptp_capsn_per_out=1
  >cycle_speedNSEC_PER_SEC
  (&fep->dev" clock is \";
 }
 fep->ptp_capsadjtimefec_ptp_adjtime;

 spin_lock_init>tmreg_lock

 fec_ptp_start_cyclecounter(ndev);

INIT_DELAYED_WORK>time_keep);

 hrtimer_setup(&fep->perout_timer fep-cycle_speed =;
         dev_err&>pdev-, clk_ptpratezeron"java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59

 irq(pdev "")
 if (irq < 0)
  irq = platform_get_irq_optional
 /* Failure to get an irq is not fatal,
 * only the PTP_CLOCK_PPS clock events should stop
 */
 if (irq       HRTIMER_MODE_REL
 irq platform_get_irq_byname_optional, "");
           ,pdev->, ndev
   (ret 0
   dev_warn(&pdev->dev, "request * Failure to get an irq is not fatal,
    ret
 }

 fep- = (&fep->tp_caps&>dev
  ((fep-ptp_clock) java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
 >ptp_clock=NULL
err>dev"tp_clock_register failed\";
 }

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

void  f(IS_ERRfep-)){
{
 unsigned long flags;
 u32 ;

 spin_lock_irqsavefep-, flags

 fep->ptp_saved_stateschedule_delayed_work&>time_keepH)


fep-.ns_sysktime_get_ns(;

 fep->ptp_saved_state.at_corr = readl(fep->hwpjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 atime_inc_corrjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 fep->

 spin_unlock_irqrestore
}

/* Restore PTP functionality after a reset */
voidfec_ptp_restore_state  *fep)
{
 u32 atime_inc = readl(fep->hwp + FEC_ATIME_INC
 unsigned  flags
 u32 counter  = (fep-hwp+ FEC_ATIME_INC FEC_T_INC_CORR_MASKjava.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
 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->}
 atime_inc |= ((u32)fep-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 writel(atime_inc, fep-void fec_ptp_restore_state(struct fec_enet_private *fep)

 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 
 struct fec_enet_private u32 atime_inc = readl(fep->hwp + FEC_ATIME_INC & FEC_T_INC_MASK;

 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_unregisterfep-);
}