Quelle  ocelot_ptp.c   Sprache: C

// SPDX-License-Identifier: (GPL-2.0 OR MIT)
/* Microsemi Ocelot PTP clock driver
 *
 * Copyright (c) 2017 Microsemi Corporation
 * Copyright 2020 NXP
 */
#include <linux/time64.h>

#include <linux/dsa/ocelot.h>
#include <linux/ptp_classify.h>
#include <soc/mscc/ocelot_ptp.h>
#include <soc/mscc/ocelot_sys.h>
#include <soc/mscc/ocelot_vcap.h>
#include <soc/mscc/ocelot.h>
#include "ocelot.h"

#define OCELOT_PTP_TX_TSTAMP_TIMEOUT  (5 * HZ)

int ocelot_ptp_gettime64(struct ptp_clock_info *ptp, struct timespec64 *ts)
{
 struct ocelot *ocelot = container_of(ptp, struct ocelot, ptp_info);
 unsigned long flags;
 time64_t s;
 u32 val;
 s64 ns;

 spin_lock_irqsave(&ocelot->ptp_clock_lock, flags);

 val = ocelot_read_rix(ocelot, PTP_PIN_CFG, TOD_ACC_PIN);
 val &= ~(PTP_PIN_CFG_SYNC | PTP_PIN_CFG_ACTION_MASK | PTP_PIN_CFG_DOM);
 val |= PTP_PIN_CFG_ACTION(PTP_PIN_ACTION_SAVE);
 ocelot_write_rix(ocelot, val, PTP_PIN_CFG, TOD_ACC_PIN);

 s = ocelot_read_rix(ocelot, PTP_PIN_TOD_SEC_MSB, TOD_ACC_PIN) & 0xffff;
 s <<= 32;
 s += ocelot_read_rix(ocelot, PTP_PIN_TOD_SEC_LSB, TOD_ACC_PIN);
 ns = ocelot_read_rix(ocelot, PTP_PIN_TOD_NSEC, TOD_ACC_PIN);

 spin_unlock_irqrestore(&ocelot->ptp_clock_lock, flags);

 /* Deal with negative values */
 if (ns >= 0x3ffffff0 && ns <= 0x3fffffff) {
  s--;
  ns &= 0xf;
  ns += 999999984;
 }

 set_normalized_timespec64(ts, s, ns);
 return 0;
}
EXPORT_SYMBOL(ocelot_ptp_gettime64);

int ocelot_ptp_settime64(struct ptp_clock_info *ptp,
    const struct timespec64 *ts)
{
 struct ocelot *ocelot = container_of(ptp, struct ocelot, ptp_info);
 unsigned long flags;
 u32 val;

 spin_lock_irqsave(&ocelot->ptp_clock_lock, flags);

 val = ocelot_read_rix(ocelot, PTP_PIN_CFG, TOD_ACC_PIN);
 val &= ~(PTP_PIN_CFG_SYNC | PTP_PIN_CFG_ACTION_MASK | PTP_PIN_CFG_DOM);
 val |= PTP_PIN_CFG_ACTION(PTP_PIN_ACTION_IDLE);

 ocelot_write_rix(ocelot, val, PTP_PIN_CFG, TOD_ACC_PIN);

 ocelot_write_rix(ocelot, lower_32_bits(ts->tv_sec), PTP_PIN_TOD_SEC_LSB,
    TOD_ACC_PIN);
 ocelot_write_rix(ocelot, upper_32_bits(ts->tv_sec), PTP_PIN_TOD_SEC_MSB,
    TOD_ACC_PIN);
 ocelot_write_rix(ocelot, ts->tv_nsec, PTP_PIN_TOD_NSEC, TOD_ACC_PIN);

 val = ocelot_read_rix(ocelot, PTP_PIN_CFG, TOD_ACC_PIN);
 val &= ~(PTP_PIN_CFG_SYNC | PTP_PIN_CFG_ACTION_MASK | PTP_PIN_CFG_DOM);
 val |= PTP_PIN_CFG_ACTION(PTP_PIN_ACTION_LOAD);

 ocelot_write_rix(ocelot, val, PTP_PIN_CFG, TOD_ACC_PIN);

 spin_unlock_irqrestore(&ocelot->ptp_clock_lock, flags);

 if (ocelot->ops->tas_clock_adjust)
  ocelot->ops->tas_clock_adjust(ocelot);

 return 0;
}
EXPORT_SYMBOL(ocelot_ptp_settime64);

int ocelot_ptp_adjtime(struct ptp_clock_info *ptp, s64 delta)
{
 if (delta > -(NSEC_PER_SEC / 2) && delta < (NSEC_PER_SEC / 2)) {
  struct ocelot *ocelot = container_of(ptp, struct ocelot,
           ptp_info);
  unsigned long flags;
  u32 val;

  spin_lock_irqsave(&ocelot->ptp_clock_lock, flags);

  val = ocelot_read_rix(ocelot, PTP_PIN_CFG, TOD_ACC_PIN);
  val &= ~(PTP_PIN_CFG_SYNC | PTP_PIN_CFG_ACTION_MASK |
    PTP_PIN_CFG_DOM);
  val |= PTP_PIN_CFG_ACTION(PTP_PIN_ACTION_IDLE);

  ocelot_write_rix(ocelot, val, PTP_PIN_CFG, TOD_ACC_PIN);

  ocelot_write_rix(ocelot, 0, PTP_PIN_TOD_SEC_LSB, TOD_ACC_PIN);
  ocelot_write_rix(ocelot, 0, PTP_PIN_TOD_SEC_MSB, TOD_ACC_PIN);
  ocelot_write_rix(ocelot, delta, PTP_PIN_TOD_NSEC, TOD_ACC_PIN);

  val = ocelot_read_rix(ocelot, PTP_PIN_CFG, TOD_ACC_PIN);
  val &= ~(PTP_PIN_CFG_SYNC | PTP_PIN_CFG_ACTION_MASK |
    PTP_PIN_CFG_DOM);
  val |= PTP_PIN_CFG_ACTION(PTP_PIN_ACTION_DELTA);

  ocelot_write_rix(ocelot, val, PTP_PIN_CFG, TOD_ACC_PIN);

  spin_unlock_irqrestore(&ocelot->ptp_clock_lock, flags);

  if (ocelot->ops->tas_clock_adjust)
   ocelot->ops->tas_clock_adjust(ocelot);
 } else {
  /* Fall back using ocelot_ptp_settime64 which is not exact. */
  struct timespec64 ts;
  u64 now;

  ocelot_ptp_gettime64(ptp, &ts);

  now = ktime_to_ns(timespec64_to_ktime(ts));
  ts = ns_to_timespec64(now + delta);

  ocelot_ptp_settime64(ptp, &ts);
 }

 return 0;
}
EXPORT_SYMBOL(ocelot_ptp_adjtime);

int ocelot_ptp_adjfine(struct ptp_clock_info *ptp, long scaled_ppm)
{
 struct ocelot *ocelot = container_of(ptp, struct ocelot, ptp_info);
 u32 unit = 0, direction = 0;
 unsigned long flags;
 u64 adj = 0;

 spin_lock_irqsave(&ocelot->ptp_clock_lock, flags);

 if (!scaled_ppm)
  goto disable_adj;

 if (scaled_ppm < 0) {
  direction = PTP_CFG_CLK_ADJ_CFG_DIR;
  scaled_ppm = -scaled_ppm;
 }

 adj = PSEC_PER_SEC << 16;
 do_div(adj, scaled_ppm);
 do_div(adj, 1000);

 /* If the adjustment value is too large, use ns instead */
 if (adj >= (1L << 30)) {
  unit = PTP_CFG_CLK_ADJ_FREQ_NS;
  do_div(adj, 1000);
 }

 /* Still too big */
 if (adj >= (1L << 30))
  goto disable_adj;

 ocelot_write(ocelot, unit | adj, PTP_CLK_CFG_ADJ_FREQ);
 ocelot_write(ocelot, PTP_CFG_CLK_ADJ_CFG_ENA | direction,
       PTP_CLK_CFG_ADJ_CFG);

 spin_unlock_irqrestore(&ocelot->ptp_clock_lock, flags);
 return 0;

disable_adj:
 ocelot_write(ocelot, 0, PTP_CLK_CFG_ADJ_CFG);

 spin_unlock_irqrestore(&ocelot->ptp_clock_lock, flags);
 return 0;
}
EXPORT_SYMBOL(ocelot_ptp_adjfine);

int ocelot_ptp_verify(struct ptp_clock_info *ptp, unsigned int pin,
        enum ptp_pin_function func, unsigned int chan)
{
 switch (func) {
 case PTP_PF_NONE:
 case PTP_PF_PEROUT:
  break;
 case PTP_PF_EXTTS:
 case PTP_PF_PHYSYNC:
  return -1;
 }
 return 0;
}
EXPORT_SYMBOL(ocelot_ptp_verify);

int ocelot_ptp_enable(struct ptp_clock_info *ptp,
        struct ptp_clock_request *rq, int on)
{
 struct ocelot *ocelot = container_of(ptp, struct ocelot, ptp_info);
 struct timespec64 ts_phase, ts_period;
 enum ocelot_ptp_pins ptp_pin;
 unsigned long flags;
 bool pps = false;
 int pin = -1;
 s64 wf_high;
 s64 wf_low;
 u32 val;

 switch (rq->type) {
 case PTP_CLK_REQ_PEROUT:
  pin = ptp_find_pin(ocelot->ptp_clock, PTP_PF_PEROUT,
       rq->perout.index);
  if (pin == 0)
   ptp_pin = PTP_PIN_0;
  else if (pin == 1)
   ptp_pin = PTP_PIN_1;
  else if (pin == 2)
   ptp_pin = PTP_PIN_2;
  else if (pin == 3)
   ptp_pin = PTP_PIN_3;
  else
   return -EBUSY;

  ts_period.tv_sec = rq->perout.period.sec;
  ts_period.tv_nsec = rq->perout.period.nsec;

  if (ts_period.tv_sec == 1 && ts_period.tv_nsec == 0)
   pps = true;

  /* Handle turning off */
  if (!on) {
   spin_lock_irqsave(&ocelot->ptp_clock_lock, flags);
   val = PTP_PIN_CFG_ACTION(PTP_PIN_ACTION_IDLE);
   ocelot_write_rix(ocelot, val, PTP_PIN_CFG, ptp_pin);
   spin_unlock_irqrestore(&ocelot->ptp_clock_lock, flags);
   break;
  }

  if (rq->perout.flags & PTP_PEROUT_PHASE) {
   ts_phase.tv_sec = rq->perout.phase.sec;
   ts_phase.tv_nsec = rq->perout.phase.nsec;
  } else {
   /* Compatibility */
   ts_phase.tv_sec = rq->perout.start.sec;
   ts_phase.tv_nsec = rq->perout.start.nsec;
  }
  if (ts_phase.tv_sec || (ts_phase.tv_nsec && !pps)) {
   dev_warn(ocelot->dev,
     "Absolute start time not supported!\n");
   dev_warn(ocelot->dev,
     "Accept nsec for PPS phase adjustment, otherwise start time should be 0 0.\n");
   return -EINVAL;
  }

  /* Calculate waveform high and low times */
  if (rq->perout.flags & PTP_PEROUT_DUTY_CYCLE) {
   struct timespec64 ts_on;

   ts_on.tv_sec = rq->perout.on.sec;
   ts_on.tv_nsec = rq->perout.on.nsec;

   wf_high = timespec64_to_ns(&ts_on);
  } else {
   if (pps) {
    wf_high = 1000;
   } else {
    wf_high = timespec64_to_ns(&ts_period);
    wf_high = div_s64(wf_high, 2);
   }
  }

  wf_low = timespec64_to_ns(&ts_period);
  wf_low -= wf_high;

  /* Handle PPS request */
  if (pps) {
   spin_lock_irqsave(&ocelot->ptp_clock_lock, flags);
   ocelot_write_rix(ocelot, ts_phase.tv_nsec,
      PTP_PIN_WF_LOW_PERIOD, ptp_pin);
   ocelot_write_rix(ocelot, wf_high,
      PTP_PIN_WF_HIGH_PERIOD, ptp_pin);
   val = PTP_PIN_CFG_ACTION(PTP_PIN_ACTION_CLOCK);
   val |= PTP_PIN_CFG_SYNC;
   ocelot_write_rix(ocelot, val, PTP_PIN_CFG, ptp_pin);
   spin_unlock_irqrestore(&ocelot->ptp_clock_lock, flags);
   break;
  }

  /* Handle periodic clock */
  if (wf_high > 0x3fffffff || wf_high <= 0x6)
   return -EINVAL;
  if (wf_low > 0x3fffffff || wf_low <= 0x6)
   return -EINVAL;

  spin_lock_irqsave(&ocelot->ptp_clock_lock, flags);
  ocelot_write_rix(ocelot, wf_low, PTP_PIN_WF_LOW_PERIOD,
     ptp_pin);
  ocelot_write_rix(ocelot, wf_high, PTP_PIN_WF_HIGH_PERIOD,
     ptp_pin);
  val = PTP_PIN_CFG_ACTION(PTP_PIN_ACTION_CLOCK);
  ocelot_write_rix(ocelot, val, PTP_PIN_CFG, ptp_pin);
  spin_unlock_irqrestore(&ocelot->ptp_clock_lock, flags);
  break;
 default:
  return -EOPNOTSUPP;
 }
 return 0;
}
EXPORT_SYMBOL(ocelot_ptp_enable);

static void ocelot_populate_l2_ptp_trap_key(struct ocelot_vcap_filter *trap)
{
 trap->key_type = OCELOT_VCAP_KEY_ETYPE;
 *(__be16 *)trap->key.etype.etype.value = htons(ETH_P_1588);
 *(__be16 *)trap->key.etype.etype.mask = htons(0xffff);
}

static void
ocelot_populate_ipv4_ptp_event_trap_key(struct ocelot_vcap_filter *trap)
{
 trap->key_type = OCELOT_VCAP_KEY_IPV4;
 trap->key.ipv4.proto.value[0] = IPPROTO_UDP;
 trap->key.ipv4.proto.mask[0] = 0xff;
 trap->key.ipv4.dport.value = PTP_EV_PORT;
 trap->key.ipv4.dport.mask = 0xffff;
}

static void
ocelot_populate_ipv6_ptp_event_trap_key(struct ocelot_vcap_filter *trap)
{
 trap->key_type = OCELOT_VCAP_KEY_IPV6;
 trap->key.ipv6.proto.value[0] = IPPROTO_UDP;
 trap->key.ipv6.proto.mask[0] = 0xff;
 trap->key.ipv6.dport.value = PTP_EV_PORT;
 trap->key.ipv6.dport.mask = 0xffff;
}

static void
ocelot_populate_ipv4_ptp_general_trap_key(struct ocelot_vcap_filter *trap)
{
 trap->key_type = OCELOT_VCAP_KEY_IPV4;
 trap->key.ipv4.proto.value[0] = IPPROTO_UDP;
 trap->key.ipv4.proto.mask[0] = 0xff;
 trap->key.ipv4.dport.value = PTP_GEN_PORT;
 trap->key.ipv4.dport.mask = 0xffff;
}

static void
ocelot_populate_ipv6_ptp_general_trap_key(struct ocelot_vcap_filter *trap)
{
 trap->key_type = OCELOT_VCAP_KEY_IPV6;
 trap->key.ipv6.proto.value[0] = IPPROTO_UDP;
 trap->key.ipv6.proto.mask[0] = 0xff;
 trap->key.ipv6.dport.value = PTP_GEN_PORT;
 trap->key.ipv6.dport.mask = 0xffff;
}

static int ocelot_l2_ptp_trap_add(struct ocelot *ocelot, int port)
{
 unsigned long l2_cookie = OCELOT_VCAP_IS2_L2_PTP_TRAP(ocelot);

 return ocelot_trap_add(ocelot, port, l2_cookie, true,
          ocelot_populate_l2_ptp_trap_key);
}

static int ocelot_l2_ptp_trap_del(struct ocelot *ocelot, int port)
{
 unsigned long l2_cookie = OCELOT_VCAP_IS2_L2_PTP_TRAP(ocelot);

 return ocelot_trap_del(ocelot, port, l2_cookie);
}

static int ocelot_ipv4_ptp_trap_add(struct ocelot *ocelot, int port)
{
 unsigned long ipv4_gen_cookie = OCELOT_VCAP_IS2_IPV4_GEN_PTP_TRAP(ocelot);
 unsigned long ipv4_ev_cookie = OCELOT_VCAP_IS2_IPV4_EV_PTP_TRAP(ocelot);
 int err;

 err = ocelot_trap_add(ocelot, port, ipv4_ev_cookie, true,
         ocelot_populate_ipv4_ptp_event_trap_key);
 if (err)
  return err;

 err = ocelot_trap_add(ocelot, port, ipv4_gen_cookie, false,
         ocelot_populate_ipv4_ptp_general_trap_key);
 if (err)
  ocelot_trap_del(ocelot, port, ipv4_ev_cookie);

 return err;
}

static int ocelot_ipv4_ptp_trap_del(struct ocelot *ocelot, int port)
{
 unsigned long ipv4_gen_cookie = OCELOT_VCAP_IS2_IPV4_GEN_PTP_TRAP(ocelot);
 unsigned long ipv4_ev_cookie = OCELOT_VCAP_IS2_IPV4_EV_PTP_TRAP(ocelot);
 int err;

 err = ocelot_trap_del(ocelot, port, ipv4_ev_cookie);
 err |= ocelot_trap_del(ocelot, port, ipv4_gen_cookie);
 return err;
}

static int ocelot_ipv6_ptp_trap_add(struct ocelot *ocelot, int port)
{
 unsigned long ipv6_gen_cookie = OCELOT_VCAP_IS2_IPV6_GEN_PTP_TRAP(ocelot);
 unsigned long ipv6_ev_cookie = OCELOT_VCAP_IS2_IPV6_EV_PTP_TRAP(ocelot);
 int err;

 err = ocelot_trap_add(ocelot, port, ipv6_ev_cookie, true,
         ocelot_populate_ipv6_ptp_event_trap_key);
 if (err)
  return err;

 err = ocelot_trap_add(ocelot, port, ipv6_gen_cookie, false,
         ocelot_populate_ipv6_ptp_general_trap_key);
 if (err)
  ocelot_trap_del(ocelot, port, ipv6_ev_cookie);

 return err;
}

static int ocelot_ipv6_ptp_trap_del(struct ocelot *ocelot, int port)
{
 unsigned long ipv6_gen_cookie = OCELOT_VCAP_IS2_IPV6_GEN_PTP_TRAP(ocelot);
 unsigned long ipv6_ev_cookie = OCELOT_VCAP_IS2_IPV6_EV_PTP_TRAP(ocelot);
 int err;

 err = ocelot_trap_del(ocelot, port, ipv6_ev_cookie);
 err |= ocelot_trap_del(ocelot, port, ipv6_gen_cookie);
 return err;
}

static int ocelot_setup_ptp_traps(struct ocelot *ocelot, int port,
      bool l2, bool l4)
{
 struct ocelot_port *ocelot_port = ocelot->ports[port];
 int err;

 ocelot_port->trap_proto &= ~(OCELOT_PROTO_PTP_L2 |
         OCELOT_PROTO_PTP_L4);

 if (l2)
  err = ocelot_l2_ptp_trap_add(ocelot, port);
 else
  err = ocelot_l2_ptp_trap_del(ocelot, port);
 if (err)
  return err;

 if (l4) {
  err = ocelot_ipv4_ptp_trap_add(ocelot, port);
  if (err)
   goto err_ipv4;

  err = ocelot_ipv6_ptp_trap_add(ocelot, port);
  if (err)
   goto err_ipv6;
 } else {
  err = ocelot_ipv4_ptp_trap_del(ocelot, port);

  err |= ocelot_ipv6_ptp_trap_del(ocelot, port);
 }
 if (err)
  return err;

 if (l2)
  ocelot_port->trap_proto |= OCELOT_PROTO_PTP_L2;
 if (l4)
  ocelot_port->trap_proto |= OCELOT_PROTO_PTP_L4;

 return 0;

err_ipv6:
 ocelot_ipv4_ptp_trap_del(ocelot, port);
err_ipv4:
 if (l2)
  ocelot_l2_ptp_trap_del(ocelot, port);
 return err;
}

static int ocelot_traps_to_ptp_rx_filter(unsigned int proto)
{
 if ((proto & OCELOT_PROTO_PTP_L2) && (proto & OCELOT_PROTO_PTP_L4))
  return HWTSTAMP_FILTER_PTP_V2_EVENT;
 else if (proto & OCELOT_PROTO_PTP_L2)
  return HWTSTAMP_FILTER_PTP_V2_L2_EVENT;
 else if (proto & OCELOT_PROTO_PTP_L4)
  return HWTSTAMP_FILTER_PTP_V2_L4_EVENT;

 return HWTSTAMP_FILTER_NONE;
}

static int ocelot_ptp_tx_type_to_cmd(int tx_type, int *ptp_cmd)
{
 switch (tx_type) {
 case HWTSTAMP_TX_ON:
  *ptp_cmd = IFH_REW_OP_TWO_STEP_PTP;
  break;
 case HWTSTAMP_TX_ONESTEP_SYNC:
  /* IFH_REW_OP_ONE_STEP_PTP updates the correctionField,
 * what we need to update is the originTimestamp.
 */
  *ptp_cmd = IFH_REW_OP_ORIGIN_PTP;
  break;
 case HWTSTAMP_TX_OFF:
  *ptp_cmd = 0;
  break;
 default:
  return -ERANGE;
 }

 return 0;
}

void ocelot_hwstamp_get(struct ocelot *ocelot, int port,
   struct kernel_hwtstamp_config *cfg)
{
 struct ocelot_port *ocelot_port = ocelot->ports[port];

 switch (ocelot_port->ptp_cmd) {
 case IFH_REW_OP_TWO_STEP_PTP:
  cfg->tx_type = HWTSTAMP_TX_ON;
  break;
 case IFH_REW_OP_ORIGIN_PTP:
  cfg->tx_type = HWTSTAMP_TX_ONESTEP_SYNC;
  break;
 default:
  cfg->tx_type = HWTSTAMP_TX_OFF;
  break;
 }

 cfg->rx_filter = ocelot_traps_to_ptp_rx_filter(ocelot_port->trap_proto);
}
EXPORT_SYMBOL(ocelot_hwstamp_get);

int ocelot_hwstamp_set(struct ocelot *ocelot, int port,
         struct kernel_hwtstamp_config *cfg,
         struct netlink_ext_ack *extack)
{
 struct ocelot_port *ocelot_port = ocelot->ports[port];
 bool l2 = false, l4 = false;
 int ptp_cmd;
 int err;

 /* Tx type sanity check */
 err = ocelot_ptp_tx_type_to_cmd(cfg->tx_type, &ptp_cmd);
 if (err)
  return err;

 switch (cfg->rx_filter) {
 case HWTSTAMP_FILTER_NONE:
  break;
 case HWTSTAMP_FILTER_PTP_V2_L4_EVENT:
 case HWTSTAMP_FILTER_PTP_V2_L4_SYNC:
 case HWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQ:
  l4 = true;
  break;
 case HWTSTAMP_FILTER_PTP_V2_L2_EVENT:
 case HWTSTAMP_FILTER_PTP_V2_L2_SYNC:
 case HWTSTAMP_FILTER_PTP_V2_L2_DELAY_REQ:
  l2 = true;
  break;
 case HWTSTAMP_FILTER_PTP_V2_EVENT:
 case HWTSTAMP_FILTER_PTP_V2_SYNC:
 case HWTSTAMP_FILTER_PTP_V2_DELAY_REQ:
  l2 = true;
  l4 = true;
  break;
 default:
  return -ERANGE;
 }

 err = ocelot_setup_ptp_traps(ocelot, port, l2, l4);
 if (err)
  return err;

 ocelot_port->ptp_cmd = ptp_cmd;

 cfg->rx_filter = ocelot_traps_to_ptp_rx_filter(ocelot_port->trap_proto);

 return 0;
}
EXPORT_SYMBOL(ocelot_hwstamp_set);

int ocelot_get_ts_info(struct ocelot *ocelot, int port,
         struct kernel_ethtool_ts_info *info)
{
 if (ocelot->ptp_clock) {
  info->phc_index = ptp_clock_index(ocelot->ptp_clock);
 } else {
  info->so_timestamping |= SOF_TIMESTAMPING_TX_SOFTWARE;
  return 0;
 }
 info->so_timestamping |= SOF_TIMESTAMPING_TX_SOFTWARE |
     SOF_TIMESTAMPING_TX_HARDWARE |
     SOF_TIMESTAMPING_RX_HARDWARE |
     SOF_TIMESTAMPING_RAW_HARDWARE;
 info->tx_types = BIT(HWTSTAMP_TX_OFF) | BIT(HWTSTAMP_TX_ON) |
    BIT(HWTSTAMP_TX_ONESTEP_SYNC);
 info->rx_filters = BIT(HWTSTAMP_FILTER_NONE) |
      BIT(HWTSTAMP_FILTER_PTP_V2_EVENT) |
      BIT(HWTSTAMP_FILTER_PTP_V2_L2_EVENT) |
      BIT(HWTSTAMP_FILTER_PTP_V2_L4_EVENT);

 return 0;
}
EXPORT_SYMBOL(ocelot_get_ts_info);

static struct sk_buff *ocelot_port_dequeue_ptp_tx_skb(struct ocelot *ocelot,
            int port, u8 ts_id,
            u32 seqid)
{
 struct ocelot_port *ocelot_port = ocelot->ports[port];
 struct sk_buff *skb, *skb_tmp, *skb_match = NULL;
 struct ptp_header *hdr;

 spin_lock(&ocelot->ts_id_lock);

 skb_queue_walk_safe(&ocelot_port->tx_skbs, skb, skb_tmp) {
  if (OCELOT_SKB_CB(skb)->ts_id != ts_id)
   continue;

  /* Check that the timestamp ID is for the expected PTP
 * sequenceId. We don't have to test ptp_parse_header() against
 * NULL, because we've pre-validated the packet's ptp_class.
 */
  hdr = ptp_parse_header(skb, OCELOT_SKB_CB(skb)->ptp_class);
  if (seqid != ntohs(hdr->sequence_id))
   continue;

  __skb_unlink(skb, &ocelot_port->tx_skbs);
  ocelot->ptp_skbs_in_flight--;
  skb_match = skb;
  break;
 }

 spin_unlock(&ocelot->ts_id_lock);

 return skb_match;
}

static int ocelot_port_queue_ptp_tx_skb(struct ocelot *ocelot, int port,
     struct sk_buff *clone)
{
 struct ocelot_port *ocelot_port = ocelot->ports[port];
 DECLARE_BITMAP(ts_id_in_flight, OCELOT_MAX_PTP_ID);
 struct sk_buff *skb, *skb_tmp;
 unsigned long n;

 spin_lock(&ocelot->ts_id_lock);

 /* To get a better chance of acquiring a timestamp ID, first flush the
 * stale packets still waiting in the TX timestamping queue. They are
 * probably lost.
 */
 skb_queue_walk_safe(&ocelot_port->tx_skbs, skb, skb_tmp) {
  if (time_before(OCELOT_SKB_CB(skb)->ptp_tx_time +
    OCELOT_PTP_TX_TSTAMP_TIMEOUT, jiffies)) {
   u64_stats_update_begin(&ocelot_port->ts_stats->syncp);
   ocelot_port->ts_stats->lost++;
   u64_stats_update_end(&ocelot_port->ts_stats->syncp);

   dev_dbg_ratelimited(ocelot->dev,
         "port %d invalidating stale timestamp ID %u which seems lost\n",
         port, OCELOT_SKB_CB(skb)->ts_id);

   __skb_unlink(skb, &ocelot_port->tx_skbs);
   kfree_skb(skb);
   ocelot->ptp_skbs_in_flight--;
  } else {
   __set_bit(OCELOT_SKB_CB(skb)->ts_id, ts_id_in_flight);
  }
 }

 if (ocelot->ptp_skbs_in_flight == OCELOT_PTP_FIFO_SIZE) {
  spin_unlock(&ocelot->ts_id_lock);
  return -EBUSY;
 }

 n = find_first_zero_bit(ts_id_in_flight, OCELOT_MAX_PTP_ID);
 if (n == OCELOT_MAX_PTP_ID) {
  spin_unlock(&ocelot->ts_id_lock);
  return -EBUSY;
 }

 /* Found an available timestamp ID, use it */
 OCELOT_SKB_CB(clone)->ts_id = n;
 OCELOT_SKB_CB(clone)->ptp_tx_time = jiffies;
 ocelot->ptp_skbs_in_flight++;
 __skb_queue_tail(&ocelot_port->tx_skbs, clone);

 spin_unlock(&ocelot->ts_id_lock);

 dev_dbg_ratelimited(ocelot->dev, "port %d timestamp id %lu\n", port, n);

 return 0;
}

static bool ocelot_ptp_is_onestep_sync(struct sk_buff *skb,
           unsigned int ptp_class)
{
 struct ptp_header *hdr;
 u8 msgtype, twostep;

 hdr = ptp_parse_header(skb, ptp_class);
 if (!hdr)
  return false;

 msgtype = ptp_get_msgtype(hdr, ptp_class);
 twostep = hdr->flag_field[0] & 0x2;

 if (msgtype == PTP_MSGTYPE_SYNC && twostep == 0)
  return true;

 return false;
}

int ocelot_port_txtstamp_request(struct ocelot *ocelot, int port,
     struct sk_buff *skb,
     struct sk_buff **clone)
{
 struct ocelot_port *ocelot_port = ocelot->ports[port];
 u8 ptp_cmd = ocelot_port->ptp_cmd;
 unsigned int ptp_class;
 int err;

 /* Don't do anything if PTP timestamping not enabled */
 if (!ptp_cmd)
  return 0;

 ptp_class = ptp_classify_raw(skb);
 if (ptp_class == PTP_CLASS_NONE) {
  err = -EINVAL;
  goto error;
 }

 /* Store ptp_cmd in OCELOT_SKB_CB(skb)->ptp_cmd */
 if (ptp_cmd == IFH_REW_OP_ORIGIN_PTP) {
  if (ocelot_ptp_is_onestep_sync(skb, ptp_class)) {
   OCELOT_SKB_CB(skb)->ptp_cmd = ptp_cmd;

   u64_stats_update_begin(&ocelot_port->ts_stats->syncp);
   ocelot_port->ts_stats->onestep_pkts_unconfirmed++;
   u64_stats_update_end(&ocelot_port->ts_stats->syncp);

   return 0;
  }

  /* Fall back to two-step timestamping */
  ptp_cmd = IFH_REW_OP_TWO_STEP_PTP;
 }

 if (ptp_cmd == IFH_REW_OP_TWO_STEP_PTP) {
  *clone = skb_clone_sk(skb);
  if (!(*clone)) {
   err = -ENOMEM;
   goto error;
  }

  /* Store timestamp ID in OCELOT_SKB_CB(clone)->ts_id */
  err = ocelot_port_queue_ptp_tx_skb(ocelot, port, *clone);
  if (err) {
   kfree_skb(*clone);
   goto error;
  }

  skb_shinfo(*clone)->tx_flags |= SKBTX_IN_PROGRESS;
  OCELOT_SKB_CB(skb)->ptp_cmd = ptp_cmd;
  OCELOT_SKB_CB(*clone)->ptp_class = ptp_class;
 }

 return 0;

error:
 u64_stats_update_begin(&ocelot_port->ts_stats->syncp);
 ocelot_port->ts_stats->err++;
 u64_stats_update_end(&ocelot_port->ts_stats->syncp);
 return err;
}
EXPORT_SYMBOL(ocelot_port_txtstamp_request);

static void ocelot_get_hwtimestamp(struct ocelot *ocelot,
       struct timespec64 *ts)
{
 unsigned long flags;
 u32 val;

 spin_lock_irqsave(&ocelot->ptp_clock_lock, flags);

 /* Read current PTP time to get seconds */
 val = ocelot_read_rix(ocelot, PTP_PIN_CFG, TOD_ACC_PIN);

 val &= ~(PTP_PIN_CFG_SYNC | PTP_PIN_CFG_ACTION_MASK | PTP_PIN_CFG_DOM);
 val |= PTP_PIN_CFG_ACTION(PTP_PIN_ACTION_SAVE);
 ocelot_write_rix(ocelot, val, PTP_PIN_CFG, TOD_ACC_PIN);
 ts->tv_sec = ocelot_read_rix(ocelot, PTP_PIN_TOD_SEC_LSB, TOD_ACC_PIN);

 /* Read packet HW timestamp from FIFO */
 val = ocelot_read(ocelot, SYS_PTP_TXSTAMP);
 ts->tv_nsec = SYS_PTP_TXSTAMP_PTP_TXSTAMP(val);

 /* Sec has incremented since the ts was registered */
 if ((ts->tv_sec & 0x1) != !!(val & SYS_PTP_TXSTAMP_PTP_TXSTAMP_SEC))
  ts->tv_sec--;

 spin_unlock_irqrestore(&ocelot->ptp_clock_lock, flags);
}

void ocelot_get_txtstamp(struct ocelot *ocelot)
{
 int budget = OCELOT_PTP_QUEUE_SZ;

 while (budget--) {
  struct skb_shared_hwtstamps shhwtstamps;
  struct ocelot_port *ocelot_port;
  u32 val, id, seqid, txport;
  struct sk_buff *skb_match;
  struct timespec64 ts;

  val = ocelot_read(ocelot, SYS_PTP_STATUS);

  /* Check if a timestamp can be retrieved */
  if (!(val & SYS_PTP_STATUS_PTP_MESS_VLD))
   break;

  WARN_ON(val & SYS_PTP_STATUS_PTP_OVFL);

  /* Retrieve the ts ID and Tx port */
  id = SYS_PTP_STATUS_PTP_MESS_ID_X(val);
  txport = SYS_PTP_STATUS_PTP_MESS_TXPORT_X(val);
  seqid = SYS_PTP_STATUS_PTP_MESS_SEQ_ID(val);
  ocelot_port = ocelot->ports[txport];

  /* Retrieve its associated skb */
  skb_match = ocelot_port_dequeue_ptp_tx_skb(ocelot, txport, id,
          seqid);
  if (!skb_match) {
   u64_stats_update_begin(&ocelot_port->ts_stats->syncp);
   ocelot_port->ts_stats->err++;
   u64_stats_update_end(&ocelot_port->ts_stats->syncp);

   dev_dbg_ratelimited(ocelot->dev,
         "port %d received TX timestamp (seqid %d, ts id %u) for packet previously declared stale\n",
         txport, seqid, id);

   goto next_ts;
  }

  u64_stats_update_begin(&ocelot_port->ts_stats->syncp);
  ocelot_port->ts_stats->pkts++;
  u64_stats_update_end(&ocelot_port->ts_stats->syncp);

  /* Get the h/w timestamp */
  ocelot_get_hwtimestamp(ocelot, &ts);

  /* Set the timestamp into the skb */
  memset(&shhwtstamps, 0, sizeof(shhwtstamps));
  shhwtstamps.hwtstamp = ktime_set(ts.tv_sec, ts.tv_nsec);
  skb_complete_tx_timestamp(skb_match, &shhwtstamps);

next_ts:
  ocelot_write(ocelot, SYS_PTP_NXT_PTP_NXT, SYS_PTP_NXT);
 }
}
EXPORT_SYMBOL(ocelot_get_txtstamp);

int ocelot_init_timestamp(struct ocelot *ocelot,
     const struct ptp_clock_info *info)
{
 struct ptp_clock *ptp_clock;
 int i;

 ocelot->ptp_info = *info;

 for (i = 0; i < OCELOT_PTP_PINS_NUM; i++) {
  struct ptp_pin_desc *p = &ocelot->ptp_pins[i];

  snprintf(p->name, sizeof(p->name), "switch_1588_dat%d", i);
  p->index = i;
  p->func = PTP_PF_NONE;
 }

 ocelot->ptp_info.pin_config = &ocelot->ptp_pins[0];

 ptp_clock = ptp_clock_register(&ocelot->ptp_info, ocelot->dev);
 if (IS_ERR(ptp_clock))
  return PTR_ERR(ptp_clock);
 /* Check if PHC support is missing at the configuration level */
 if (!ptp_clock)
  return 0;

 ocelot->ptp_clock = ptp_clock;

 ocelot_write(ocelot, SYS_PTP_CFG_PTP_STAMP_WID(30), SYS_PTP_CFG);
 ocelot_write(ocelot, 0xffffffff, ANA_TABLES_PTP_ID_LOW);
 ocelot_write(ocelot, 0xffffffff, ANA_TABLES_PTP_ID_HIGH);

 ocelot_write(ocelot, PTP_CFG_MISC_PTP_EN, PTP_CFG_MISC);

 return 0;
}
EXPORT_SYMBOL(ocelot_init_timestamp);

int ocelot_deinit_timestamp(struct ocelot *ocelot)
{
 if (ocelot->ptp_clock)
  ptp_clock_unregister(ocelot->ptp_clock);
 return 0;
}
EXPORT_SYMBOL(ocelot_deinit_timestamp);