Quelle  ice_dpll.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/* Copyright (C) 2022, Intel Corporation. */

#include "ice.h"
#include "ice_lib.h"
#include "ice_trace.h"
#include <linux/dpll.h>

#define ICE_CGU_STATE_ACQ_ERR_THRESHOLD  50
#define ICE_DPLL_PIN_IDX_INVALID  0xff
#define ICE_DPLL_RCLK_NUM_PER_PF  1
#define ICE_DPLL_PIN_ESYNC_PULSE_HIGH_PERCENT 25
#define ICE_DPLL_PIN_GEN_RCLK_FREQ  1953125
#define ICE_DPLL_PIN_PRIO_OUTPUT  0xff
#define ICE_DPLL_INPUT_REF_NUM   10
#define ICE_DPLL_PHASE_OFFSET_PERIOD  2
#define ICE_DPLL_SW_PIN_INPUT_BASE_SFP  4
#define ICE_DPLL_SW_PIN_INPUT_BASE_QSFP  6
#define ICE_DPLL_SW_PIN_OUTPUT_BASE  0

#define ICE_DPLL_PIN_SW_INPUT_ABS(in_idx) \
 (ICE_DPLL_SW_PIN_INPUT_BASE_SFP + (in_idx))

#define ICE_DPLL_PIN_SW_1_INPUT_ABS_IDX \
 (ICE_DPLL_PIN_SW_INPUT_ABS(ICE_DPLL_PIN_SW_1_IDX))

#define ICE_DPLL_PIN_SW_2_INPUT_ABS_IDX \
 (ICE_DPLL_PIN_SW_INPUT_ABS(ICE_DPLL_PIN_SW_2_IDX))

#define ICE_DPLL_PIN_SW_OUTPUT_ABS(out_idx) \
 (ICE_DPLL_SW_PIN_OUTPUT_BASE + (out_idx))

#define ICE_DPLL_PIN_SW_1_OUTPUT_ABS_IDX \
 (ICE_DPLL_PIN_SW_OUTPUT_ABS(ICE_DPLL_PIN_SW_1_IDX))

#define ICE_DPLL_PIN_SW_2_OUTPUT_ABS_IDX \
 (ICE_DPLL_PIN_SW_OUTPUT_ABS(ICE_DPLL_PIN_SW_2_IDX))

#define ICE_SR_PFA_DPLL_DEFAULTS  0x152
#define ICE_DPLL_PFA_REF_SYNC_TYPE  0x2420
#define ICE_DPLL_PFA_REF_SYNC_TYPE2  0x2424
#define ICE_DPLL_PFA_END   0xFFFF
#define ICE_DPLL_PFA_HEADER_LEN   4
#define ICE_DPLL_PFA_ENTRY_LEN   3
#define ICE_DPLL_PFA_MAILBOX_REF_SYNC_PIN_S 4
#define ICE_DPLL_PFA_MASK_OFFSET  1
#define ICE_DPLL_PFA_VALUE_OFFSET  2

#define ICE_DPLL_E810C_SFP_NC_PINS  2
#define ICE_DPLL_E810C_SFP_NC_START  4

/**
 * enum ice_dpll_pin_type - enumerate ice pin types:
 * @ICE_DPLL_PIN_INVALID: invalid pin type
 * @ICE_DPLL_PIN_TYPE_INPUT: input pin
 * @ICE_DPLL_PIN_TYPE_OUTPUT: output pin
 * @ICE_DPLL_PIN_TYPE_RCLK_INPUT: recovery clock input pin
 * @ICE_DPLL_PIN_TYPE_SOFTWARE: software controlled SMA/U.FL pins
 */
enum ice_dpll_pin_type {
 ICE_DPLL_PIN_INVALID,
 ICE_DPLL_PIN_TYPE_INPUT,
 ICE_DPLL_PIN_TYPE_OUTPUT,
 ICE_DPLL_PIN_TYPE_RCLK_INPUT,
 ICE_DPLL_PIN_TYPE_SOFTWARE,
};

static const char * const pin_type_name[] = {
 [ICE_DPLL_PIN_TYPE_INPUT] = "input",
 [ICE_DPLL_PIN_TYPE_OUTPUT] = "output",
 [ICE_DPLL_PIN_TYPE_RCLK_INPUT] = "rclk-input",
 [ICE_DPLL_PIN_TYPE_SOFTWARE] = "software",
};

static const char * const ice_dpll_sw_pin_sma[] = { "SMA1", "SMA2" };
static const char * const ice_dpll_sw_pin_ufl[] = { "U.FL1", "U.FL2" };

static const struct dpll_pin_frequency ice_esync_range[] = {
 DPLL_PIN_FREQUENCY_RANGE(0, DPLL_PIN_FREQUENCY_1_HZ),
};

/**
 * ice_dpll_is_sw_pin - check if given pin shall be controlled by SW
 * @pf: private board structure
 * @index: index of a pin as understood by FW
 * @input: true for input, false for output
 *
 * Check if the pin shall be controlled by SW - instead of providing raw access
 * for pin control. For E810 NIC with dpll there is additional MUX-related logic
 * between SMA/U.FL pins/connectors and dpll device, best to give user access
 * with series of wrapper functions as from user perspective they convey single
 * functionality rather then separated pins.
 *
 * Return:
 * * true - pin controlled by SW
 * * false - pin not controlled by SW
 */
static bool ice_dpll_is_sw_pin(struct ice_pf *pf, u8 index, bool input)
{
 if (input && pf->hw.device_id == ICE_DEV_ID_E810C_QSFP)
  index -= ICE_DPLL_SW_PIN_INPUT_BASE_QSFP -
    ICE_DPLL_SW_PIN_INPUT_BASE_SFP;

 if ((input && (index == ICE_DPLL_PIN_SW_1_INPUT_ABS_IDX ||
         index == ICE_DPLL_PIN_SW_2_INPUT_ABS_IDX)) ||
     (!input && (index == ICE_DPLL_PIN_SW_1_OUTPUT_ABS_IDX ||
   index == ICE_DPLL_PIN_SW_2_OUTPUT_ABS_IDX)))
  return true;
 return false;
}

/**
 * ice_dpll_is_reset - check if reset is in progress
 * @pf: private board structure
 * @extack: error reporting
 *
 * If reset is in progress, fill extack with error.
 *
 * Return:
 * * false - no reset in progress
 * * true - reset in progress
 */
static bool ice_dpll_is_reset(struct ice_pf *pf, struct netlink_ext_ack *extack)
{
 if (ice_is_reset_in_progress(pf->state)) {
  NL_SET_ERR_MSG(extack, "PF reset in progress");
  return true;
 }
 return false;
}

/**
 * ice_dpll_pin_freq_set - set pin's frequency
 * @pf: private board structure
 * @pin: pointer to a pin
 * @pin_type: type of pin being configured
 * @freq: frequency to be set
 * @extack: error reporting
 *
 * Set requested frequency on a pin.
 *
 * Context: Called under pf->dplls.lock
 * Return:
 * * 0 - success
 * * negative - error on AQ or wrong pin type given
 */
static int
ice_dpll_pin_freq_set(struct ice_pf *pf, struct ice_dpll_pin *pin,
        enum ice_dpll_pin_type pin_type, const u32 freq,
        struct netlink_ext_ack *extack)
{
 u8 flags;
 int ret;

 switch (pin_type) {
 case ICE_DPLL_PIN_TYPE_INPUT:
  flags = ICE_AQC_SET_CGU_IN_CFG_FLG1_UPDATE_FREQ;
  ret = ice_aq_set_input_pin_cfg(&pf->hw, pin->idx, flags,
            pin->flags[0], freq, 0);
  break;
 case ICE_DPLL_PIN_TYPE_OUTPUT:
  flags = ICE_AQC_SET_CGU_OUT_CFG_UPDATE_FREQ;
  ret = ice_aq_set_output_pin_cfg(&pf->hw, pin->idx, flags,
      0, freq, 0);
  break;
 default:
  return -EINVAL;
 }
 if (ret) {
  NL_SET_ERR_MSG_FMT(extack,
       "err:%d %s failed to set pin freq:%u on pin:%u",
       ret,
       libie_aq_str(pf->hw.adminq.sq_last_status),
       freq, pin->idx);
  return ret;
 }
 pin->freq = freq;

 return 0;
}

/**
 * ice_dpll_frequency_set - wrapper for pin callback for set frequency
 * @pin: pointer to a pin
 * @pin_priv: private data pointer passed on pin registration
 * @dpll: pointer to dpll
 * @dpll_priv: private data pointer passed on dpll registration
 * @frequency: frequency to be set
 * @extack: error reporting
 * @pin_type: type of pin being configured
 *
 * Wraps internal set frequency command on a pin.
 *
 * Context: Acquires pf->dplls.lock
 * Return:
 * * 0 - success
 * * negative - error pin not found or couldn't set in hw
 */
static int
ice_dpll_frequency_set(const struct dpll_pin *pin, void *pin_priv,
         const struct dpll_device *dpll, void *dpll_priv,
         const u32 frequency,
         struct netlink_ext_ack *extack,
         enum ice_dpll_pin_type pin_type)
{
 struct ice_dpll_pin *p = pin_priv;
 struct ice_dpll *d = dpll_priv;
 struct ice_pf *pf = d->pf;
 int ret;

 if (ice_dpll_is_reset(pf, extack))
  return -EBUSY;

 mutex_lock(&pf->dplls.lock);
 ret = ice_dpll_pin_freq_set(pf, p, pin_type, frequency, extack);
 mutex_unlock(&pf->dplls.lock);

 return ret;
}

/**
 * ice_dpll_input_frequency_set - input pin callback for set frequency
 * @pin: pointer to a pin
 * @pin_priv: private data pointer passed on pin registration
 * @dpll: pointer to dpll
 * @dpll_priv: private data pointer passed on dpll registration
 * @frequency: frequency to be set
 * @extack: error reporting
 *
 * Wraps internal set frequency command on a pin.
 *
 * Context: Calls a function which acquires pf->dplls.lock
 * Return:
 * * 0 - success
 * * negative - error pin not found or couldn't set in hw
 */
static int
ice_dpll_input_frequency_set(const struct dpll_pin *pin, void *pin_priv,
        const struct dpll_device *dpll, void *dpll_priv,
        u64 frequency, struct netlink_ext_ack *extack)
{
 return ice_dpll_frequency_set(pin, pin_priv, dpll, dpll_priv, frequency,
          extack, ICE_DPLL_PIN_TYPE_INPUT);
}

/**
 * ice_dpll_output_frequency_set - output pin callback for set frequency
 * @pin: pointer to a pin
 * @pin_priv: private data pointer passed on pin registration
 * @dpll: pointer to dpll
 * @dpll_priv: private data pointer passed on dpll registration
 * @frequency: frequency to be set
 * @extack: error reporting
 *
 * Wraps internal set frequency command on a pin.
 *
 * Context: Calls a function which acquires pf->dplls.lock
 * Return:
 * * 0 - success
 * * negative - error pin not found or couldn't set in hw
 */
static int
ice_dpll_output_frequency_set(const struct dpll_pin *pin, void *pin_priv,
         const struct dpll_device *dpll, void *dpll_priv,
         u64 frequency, struct netlink_ext_ack *extack)
{
 return ice_dpll_frequency_set(pin, pin_priv, dpll, dpll_priv, frequency,
          extack, ICE_DPLL_PIN_TYPE_OUTPUT);
}

/**
 * ice_dpll_frequency_get - wrapper for pin callback for get frequency
 * @pin: pointer to a pin
 * @pin_priv: private data pointer passed on pin registration
 * @dpll: pointer to dpll
 * @dpll_priv: private data pointer passed on dpll registration
 * @frequency: on success holds pin's frequency
 * @extack: error reporting
 * @pin_type: type of pin being configured
 *
 * Wraps internal get frequency command of a pin.
 *
 * Context: Acquires pf->dplls.lock
 * Return:
 * * 0 - success
 * * negative - error pin not found or couldn't get from hw
 */
static int
ice_dpll_frequency_get(const struct dpll_pin *pin, void *pin_priv,
         const struct dpll_device *dpll, void *dpll_priv,
         u64 *frequency, struct netlink_ext_ack *extack,
         enum ice_dpll_pin_type pin_type)
{
 struct ice_dpll_pin *p = pin_priv;
 struct ice_dpll *d = dpll_priv;
 struct ice_pf *pf = d->pf;

 mutex_lock(&pf->dplls.lock);
 *frequency = p->freq;
 mutex_unlock(&pf->dplls.lock);

 return 0;
}

/**
 * ice_dpll_input_frequency_get - input pin callback for get frequency
 * @pin: pointer to a pin
 * @pin_priv: private data pointer passed on pin registration
 * @dpll: pointer to dpll
 * @dpll_priv: private data pointer passed on dpll registration
 * @frequency: on success holds pin's frequency
 * @extack: error reporting
 *
 * Wraps internal get frequency command of a input pin.
 *
 * Context: Calls a function which acquires pf->dplls.lock
 * Return:
 * * 0 - success
 * * negative - error pin not found or couldn't get from hw
 */
static int
ice_dpll_input_frequency_get(const struct dpll_pin *pin, void *pin_priv,
        const struct dpll_device *dpll, void *dpll_priv,
        u64 *frequency, struct netlink_ext_ack *extack)
{
 return ice_dpll_frequency_get(pin, pin_priv, dpll, dpll_priv, frequency,
          extack, ICE_DPLL_PIN_TYPE_INPUT);
}

/**
 * ice_dpll_output_frequency_get - output pin callback for get frequency
 * @pin: pointer to a pin
 * @pin_priv: private data pointer passed on pin registration
 * @dpll: pointer to dpll
 * @dpll_priv: private data pointer passed on dpll registration
 * @frequency: on success holds pin's frequency
 * @extack: error reporting
 *
 * Wraps internal get frequency command of a pin.
 *
 * Context: Calls a function which acquires pf->dplls.lock
 * Return:
 * * 0 - success
 * * negative - error pin not found or couldn't get from hw
 */
static int
ice_dpll_output_frequency_get(const struct dpll_pin *pin, void *pin_priv,
         const struct dpll_device *dpll, void *dpll_priv,
         u64 *frequency, struct netlink_ext_ack *extack)
{
 return ice_dpll_frequency_get(pin, pin_priv, dpll, dpll_priv, frequency,
          extack, ICE_DPLL_PIN_TYPE_OUTPUT);
}

/**
 * ice_dpll_sw_pin_frequency_set - callback to set frequency of SW pin
 * @pin: pointer to a pin
 * @pin_priv: private data pointer passed on pin registration
 * @dpll: pointer to dpll
 * @dpll_priv: private data pointer passed on dpll registration
 * @frequency: on success holds pin's frequency
 * @extack: error reporting
 *
 * Calls set frequency command for corresponding and active input/output pin.
 *
 * Context: Calls a function which acquires and releases pf->dplls.lock
 * Return:
 * * 0 - success
 * * negative - error pin not active or couldn't get from hw
 */
static int
ice_dpll_sw_pin_frequency_set(const struct dpll_pin *pin, void *pin_priv,
         const struct dpll_device *dpll, void *dpll_priv,
         u64 frequency, struct netlink_ext_ack *extack)
{
 struct ice_dpll_pin *sma = pin_priv;
 int ret;

 if (!sma->active) {
  NL_SET_ERR_MSG(extack, "pin is not active");
  return -EINVAL;
 }
 if (sma->direction == DPLL_PIN_DIRECTION_INPUT)
  ret = ice_dpll_input_frequency_set(NULL, sma->input, dpll,
         dpll_priv, frequency,
         extack);
 else
  ret = ice_dpll_output_frequency_set(NULL, sma->output, dpll,
          dpll_priv, frequency,
          extack);

 return ret;
}

/**
 * ice_dpll_sw_pin_frequency_get - callback for get frequency of SW pin
 * @pin: pointer to a pin
 * @pin_priv: private data pointer passed on pin registration
 * @dpll: pointer to dpll
 * @dpll_priv: private data pointer passed on dpll registration
 * @frequency: on success holds pin's frequency
 * @extack: error reporting
 *
 * Calls get frequency command for corresponding active input/output.
 *
 * Context: Calls a function which acquires and releases pf->dplls.lock
 * Return:
 * * 0 - success
 * * negative - error pin not active or couldn't get from hw
 */
static int
ice_dpll_sw_pin_frequency_get(const struct dpll_pin *pin, void *pin_priv,
         const struct dpll_device *dpll, void *dpll_priv,
         u64 *frequency, struct netlink_ext_ack *extack)
{
 struct ice_dpll_pin *sma = pin_priv;
 int ret;

 if (!sma->active) {
  *frequency = 0;
  return 0;
 }
 if (sma->direction == DPLL_PIN_DIRECTION_INPUT) {
  ret = ice_dpll_input_frequency_get(NULL, sma->input, dpll,
         dpll_priv, frequency,
         extack);
 } else {
  ret = ice_dpll_output_frequency_get(NULL, sma->output, dpll,
          dpll_priv, frequency,
          extack);
 }

 return ret;
}

/**
 * ice_dpll_pin_enable - enable a pin on dplls
 * @hw: board private hw structure
 * @pin: pointer to a pin
 * @dpll_idx: dpll index to connect to output pin
 * @pin_type: type of pin being enabled
 * @extack: error reporting
 *
 * Enable a pin on both dplls. Store current state in pin->flags.
 *
 * Context: Called under pf->dplls.lock
 * Return:
 * * 0 - OK
 * * negative - error
 */
static int
ice_dpll_pin_enable(struct ice_hw *hw, struct ice_dpll_pin *pin,
      u8 dpll_idx, enum ice_dpll_pin_type pin_type,
      struct netlink_ext_ack *extack)
{
 u8 flags = 0;
 int ret;

 switch (pin_type) {
 case ICE_DPLL_PIN_TYPE_INPUT:
  if (pin->flags[0] & ICE_AQC_GET_CGU_IN_CFG_FLG2_ESYNC_EN)
   flags |= ICE_AQC_SET_CGU_IN_CFG_FLG2_ESYNC_EN;
  flags |= ICE_AQC_SET_CGU_IN_CFG_FLG2_INPUT_EN;
  ret = ice_aq_set_input_pin_cfg(hw, pin->idx, 0, flags, 0, 0);
  break;
 case ICE_DPLL_PIN_TYPE_OUTPUT:
  flags = ICE_AQC_SET_CGU_OUT_CFG_UPDATE_SRC_SEL;
  if (pin->flags[0] & ICE_AQC_GET_CGU_OUT_CFG_ESYNC_EN)
   flags |= ICE_AQC_SET_CGU_OUT_CFG_ESYNC_EN;
  flags |= ICE_AQC_SET_CGU_OUT_CFG_OUT_EN;
  ret = ice_aq_set_output_pin_cfg(hw, pin->idx, flags, dpll_idx,
      0, 0);
  break;
 default:
  return -EINVAL;
 }
 if (ret)
  NL_SET_ERR_MSG_FMT(extack,
       "err:%d %s failed to enable %s pin:%u",
       ret, libie_aq_str(hw->adminq.sq_last_status),
       pin_type_name[pin_type], pin->idx);

 return ret;
}

/**
 * ice_dpll_pin_disable - disable a pin on dplls
 * @hw: board private hw structure
 * @pin: pointer to a pin
 * @pin_type: type of pin being disabled
 * @extack: error reporting
 *
 * Disable a pin on both dplls. Store current state in pin->flags.
 *
 * Context: Called under pf->dplls.lock
 * Return:
 * * 0 - OK
 * * negative - error
 */
static int
ice_dpll_pin_disable(struct ice_hw *hw, struct ice_dpll_pin *pin,
       enum ice_dpll_pin_type pin_type,
       struct netlink_ext_ack *extack)
{
 u8 flags = 0;
 int ret;

 switch (pin_type) {
 case ICE_DPLL_PIN_TYPE_INPUT:
  if (pin->flags[0] & ICE_AQC_GET_CGU_IN_CFG_FLG2_ESYNC_EN)
   flags |= ICE_AQC_SET_CGU_IN_CFG_FLG2_ESYNC_EN;
  ret = ice_aq_set_input_pin_cfg(hw, pin->idx, 0, flags, 0, 0);
  break;
 case ICE_DPLL_PIN_TYPE_OUTPUT:
  if (pin->flags[0] & ICE_AQC_GET_CGU_OUT_CFG_ESYNC_EN)
   flags |= ICE_AQC_SET_CGU_OUT_CFG_ESYNC_EN;
  ret = ice_aq_set_output_pin_cfg(hw, pin->idx, flags, 0, 0, 0);
  break;
 default:
  return -EINVAL;
 }
 if (ret)
  NL_SET_ERR_MSG_FMT(extack,
       "err:%d %s failed to disable %s pin:%u",
       ret, libie_aq_str(hw->adminq.sq_last_status),
       pin_type_name[pin_type], pin->idx);

 return ret;
}

/**
 * ice_dpll_sw_pins_update - update status of all SW pins
 * @pf: private board struct
 *
 * Determine and update pin struct fields (direction/active) of their current
 * values for all the SW controlled pins.
 *
 * Context: Call with pf->dplls.lock held
 * Return:
 * * 0 - OK
 * * negative - error
 */
static int
ice_dpll_sw_pins_update(struct ice_pf *pf)
{
 struct ice_dplls *d = &pf->dplls;
 struct ice_dpll_pin *p;
 u8 data = 0;
 int ret;

 ret = ice_read_sma_ctrl(&pf->hw, &data);
 if (ret)
  return ret;
 /* no change since last check */
 if (d->sma_data == data)
  return 0;

 /*
 * SMA1/U.FL1 vs SMA2/U.FL2 are using different bit scheme to decide
 * on their direction and if are active
 */
 p = &d->sma[ICE_DPLL_PIN_SW_1_IDX];
 p->active = true;
 p->direction = DPLL_PIN_DIRECTION_INPUT;
 if (data & ICE_SMA1_DIR_EN) {
  p->direction = DPLL_PIN_DIRECTION_OUTPUT;
  if (data & ICE_SMA1_TX_EN)
   p->active = false;
 }

 p = &d->sma[ICE_DPLL_PIN_SW_2_IDX];
 p->active = true;
 p->direction = DPLL_PIN_DIRECTION_INPUT;
 if ((data & ICE_SMA2_INACTIVE_MASK) == ICE_SMA2_INACTIVE_MASK)
  p->active = false;
 else if (data & ICE_SMA2_DIR_EN)
  p->direction = DPLL_PIN_DIRECTION_OUTPUT;

 p = &d->ufl[ICE_DPLL_PIN_SW_1_IDX];
 if (!(data & (ICE_SMA1_DIR_EN | ICE_SMA1_TX_EN)))
  p->active = true;
 else
  p->active = false;

 p = &d->ufl[ICE_DPLL_PIN_SW_2_IDX];
 p->active = (data & ICE_SMA2_DIR_EN) && !(data & ICE_SMA2_UFL2_RX_DIS);
 d->sma_data = data;

 return 0;
}

/**
 * ice_dpll_pin_state_update - update pin's state
 * @pf: private board struct
 * @pin: structure with pin attributes to be updated
 * @pin_type: type of pin being updated
 * @extack: error reporting
 *
 * Determine pin current state and frequency, then update struct
 * holding the pin info. For input pin states are separated for each
 * dpll, for rclk pins states are separated for each parent.
 *
 * Context: Called under pf->dplls.lock
 * Return:
 * * 0 - OK
 * * negative - error
 */
static int
ice_dpll_pin_state_update(struct ice_pf *pf, struct ice_dpll_pin *pin,
     enum ice_dpll_pin_type pin_type,
     struct netlink_ext_ack *extack)
{
 u8 parent, port_num = ICE_AQC_SET_PHY_REC_CLK_OUT_CURR_PORT;
 int ret;

 switch (pin_type) {
 case ICE_DPLL_PIN_TYPE_INPUT:
  ret = ice_aq_get_input_pin_cfg// SPDX-License-Identifier: GPL-2.0/* Copyright (C) 2022, Intel Corporation. */
   # .
            pin-,>);
  if (ret)
   goto err;
  if (ICE_AQC_GET_CGU_IN_CFG_FLG2_INPUT_EN & pin->flags[0]) {
   if (pin->pin) {
    pin->state[pf->dplls.eec.dpll_idx] =
     pin->pin == pf->dplls.eec.active_input ?
     DPLL_PIN_STATE_CONNECTED :
     DPLL_PIN_STATE_SELECTABLE;
    pin->state[pf->dplls.pps.dpll_idx] =
     pin->pin == pf->dplls.pps.active_input ?
     DPLL_PIN_STATE_CONNECTED :
     DPLL_PIN_STATE_SELECTABLE;
   } else {
    pin->[pf->.eec.pll_idx
     DPLL_PIN_STATE_SELECTABLE;
    pin->state[pf->dplls.pps.dpll_idx] =
     DPLL_PIN_STATE_SELECTABLE;
   }
 } else {
 # ICE_DPLL_PIN_ESYNC_PULSE_HIGH_PERCENT5
    DPLL_PIN_STATE_DISCONNECTEDdefine  0xff
   pin-># ICE_DPLL_PHASE_OFFSET_PERIOD
   DPLL_PIN_STATE_DISCONNECTED;
  }
  break;
 caseICE_DPLL_PIN_TYPE_OUTPUT
  ret  ice_aq_get_output_pin_cfg&pf-hw pin-idx
    &in-flags0,&,
     &>freq );
   ()
   err

 parentICE_AQC_GET_CGU_OUT_CFG_DPLL_SRC_SEL;
  ICE_DPLL_PIN_SW_OUTPUT_ABS))
  >statepf->plls.dpll_idx
   ICE_DPLL_PIN_SW_OUTPUT_ABS)
  DPLL_PIN_STATE_CONNECTED
    ;
   >state>.pps] =
   arent>dplls.dpll_idx
 java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
    DPLL_PIN_STATE_DISCONNECTEDenumice_dpll_pin_type{ ,
}
  >state>dplls.] =
    DPLL_PIN_STATE_DISCONNECTEDICE_DPLL_PIN_TYPE_INPUT ""
   pin->[]  rclk-input ICE_DPLL_PIN_TYPE_SOFTWAREsoftware
  DPLL_PIN_STATE_DISCONNECTED
sta     []={UFL1,"." }java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
  break;
 case:
  for (parent = 0; parent * @pf: private * @index: index of  * @input: true for  * Check if the pin shall be * for pin control. For E810 NIC * between SMA/U.FL pins/ * with series of wrapper functions as from user * functionality rather then *  * * true - pin controlled * * false - pin not controlled by SW
       ++){
   u8 p = parent;

   ret = ice_aq_get_phy_rec_clk_out(&pf->hw, &p,
num,
    pin-[parent
   r false
   * ice_dpll_is_reset - check if reset * @pf: private  * @extack * If reset is in progress ** * false - no reset * * true -java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    goto err;
 if(CE_AQC_GET_PHY_REC_CLK_OUT_OUT_EN
       pin-[parent)
   }
   else
    pin->state[parent] =
     DPLL_PIN_STATE_DISCONNECTED;
  }
  break
 * ice_dpll_pin_freq_set - set pin's frequency
  ret = ice_dpll_sw_pins_update(pf * @freq: frequency  * @extack *
  if (ret)
   goto * * negative - errorjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
break
 default        netlink_ext_ack)
  return ;
 }

 return 0;
err:
 if (extack)
  NL_SET_ERR_MSG_FMT(extack,
       " case ICE_DPLL_PIN_TYPE_INPUT:
       ret,
      (pf->w..sq_last_status,
      pin_type_namepin_type] pin->);
 else
  dev_err_ratelimited(pf
     err% s   %pin%\"
       ,
   libie_aq_str>.adminqsq_last_status)
        pin_type_namepin_type pin-);
 return;
}

/**
 * ice_dpll_hw_input_prio_set - set input priority value in hardware
 * @pf: board private structure
 * @dpll: ice dpll pointer
 * @pin: ice pin pointer
 * @prio: priority value being set on a dpll
 * @extack: error reporting
 *
 * Internal wrapper for setting the priority in the hardware.
 *
 * Context: Called under pf->dplls.lock
 * Return:
 * * 0 - success
 * * negative - failure
 */
static int
ice_dpll_hw_input_prio_set(struct ice_pf * @pin: pointer  * @pin_priv * * @ * @pin_type: type  *
  * * * 0 * * negative - error pin not
     netlink_ext_ack extack
{
 int;

 ret (&f-, >, >idx
          (u8        structnetlink_ext_ack*xtackjava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
i ret
(,
 ret(,  , frequency );
  ,
   java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
       prio * @frequency:  * @extack *
 else
  dpll-- success * * negative - error pin not found

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

/**
 * ice_dpll_lock_status_get - get dpll lock status callback
 * @dpll: registered dpll pointer
 * @dpll_priv: private data pointer passed on dpll registration
 * @status: on success holds dpll's lock status
 * @status_error: status error value
 * @extack: error reporting
 *
 * Dpll subsystem callback, provides dpll's lock status.
 *
 * Context: Acquires pf->dplls.lock
 * Return:
 * * 0 - success
 * * negative - failure
 */
static int
ice_dpll_lock_status_get(const        frequency netlink_ext_ack)
  enum *status
   enum dpll_lock_status_error *,
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 struct ice_dpll *d = dpll_priv;
 struct * @pin: pointer * @pin_priv: private data * @dpll: pointer to * @dpll_priv: private data pointer passed * @frequency: on * @extack * @pin_type: type of pin being configured

 mutex_lock(&ice_dpll_frequency_get(onst dpll_pin pinvoid,
 * = d-;
 mutex_unlock u64 *, struct  *,

 return
}

/**
 * ice_dpll_mode_get - get dpll's working mode
 * @dpll: registered dpll pointer
 * @dpll_priv: private data pointer passed on dpll registration
 * @mode: on success holds current working mode of dpll
 * @extack: error reporting
 *
 * Dpll subsystem callback. Provides working mode of dpll.
 *
 * Context: Acquires pf->dplls.lock
 * Return:
 * * 0 - success
 * * negative - failure
 */
static int ice_dpll_mode_get(const * @dpll: pointer  * @dpll_priv: private data * @frequency: on success g
         * * 0  * * negative - error pin 
        structnetlink_ext_ack*extack
{
 struct *d=dpll_priv
 struct ice_pf   u64*, struct *)

k(>dplls);
 *mode =
 mutex_unlock(&pf->dplls.lock);

 return 0;
}

/**
 * ice_dpll_phase_offset_monitor_set - set phase offset monitor state
 * @dpll: registered dpll pointer
 * @dpll_priv: private data pointer passed on dpll registration
 * @state: feature state to be set
 * @extack: error reporting
 *
 * Dpll subsystem callback. Enable/disable phase offset monitor feature of dpll.
 *
 * Context: Acquires and releases pf->dplls.lock
 * Return: 0 - success
 */
 int(const   *,
          void *  extack);
          enum  * ice_dpll_sw_pin_frequency_set - callback to set frequency * @pin: pointer to  * @pin_priv: private data pointer passed * @dpll: pointer to dpll
          struct netlink_ext_ack *extack *
{
 struct  * * negative - error pin not active or
   *pf >pf

 mutex_lock(        struct *dpll  *pll_priv
ifstate )
  d-
 else
  d->phase_offset_monitor_period = 0;
 mutex_unlockpf-.lockjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31

 return;
}

/**
 * ice_dpll_phase_offset_monitor_get - get phase offset monitor state
 * @dpll: registered dpll pointer
 * @dpll_priv: private data pointer passed on dpll registration
 * @state: on success holds current state of phase offset monitor
 * @extack: error reporting
 *
 * Dpll subsystem callback. Provides current state of phase offset monitor
 * features on dpll device.
 *
 * Context: Acquires and releases pf->dplls.lock
 * Return: 0 - success
 */
static int ice_dpll_phase_offset_monitor_get * @pin: pointer to a pina pointer passed on pin * @dpll: pointer * @dpll_priv: private * @frequency: on success * @extack *
          void *dpll_priv,
          enum dpll_feature_state * * negative - error pin not active or *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        struct *extackjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
{
  *d=dpll_priv
  pf;

(&>.);
 }
  *   (NULL,,
 else
} {
 mutex_unlock>dpllslock

return;
}

/**
 * ice_dpll_pin_state_set - set pin's state on dpll
 * @pin: pointer to a pin
 * @pin_priv: private data pointer passed on pin registration
 * @dpll: registered dpll pointer
 * @dpll_priv: private data pointer passed on dpll registration
 * @enable: if pin shalll be enabled
 * @extack: error reporting
 * @pin_type: type of a pin
 *
 * Set pin state on a pin.
 *
 * Context: Acquires pf->dplls.lock
 * Return:
 * * 0 - OK or no change required
 * * negative - error
 */
staticflags;
ice_dpll_pin_state_set dpll_pin*, void,
         const struct dpll_device *dpll, void *dpll_priv,
        bool, struct netlink_ext_ackextack
         enum ice_dpll_pin_type
{
structice_dpll_pin* = pin_priv;
 struct ice_dpll *d = dpll_priv;
 struct ice_pf *pf = d->pf;
 int ret;

 if (ice_dpll_is_reset(pf, extack))
  return -EBUSY;

   flags | ICE_AQC_SET_CGU_OUT_CFG_ESYNC_EN
  (enablejava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  ret:
       extack);
 else
  ret = java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 2
if!)
  = (pf, p , extack)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
 mutex_unlock(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 return * ice_dpll_pin_disable - disable a pin on dplls
}

/**
 * ice_dpll_output_state_set - enable/disable output pin on dpll device
 * @pin: pointer to a pin
 * @pin_priv: private data pointer passed on pin registration
 * @dpll: dpll being configured
 * @dpll_priv: private data pointer passed on dpll registration
 * @state: state of pin to be set
 * @extack: error reporting
 *
 * Dpll subsystem callback. Set given state on output type pin.
 *
 * Context: Calls a function which acquires pf->dplls.lock
 * Return:
 * * 0 - successfully enabled mode
 * * negative - failed to enable mode
 */
 int
ice_dpll_output_state_set =ice_aq_set_input_pin_cfghw pin->idx,0, lags,0;
     const struct   ICE_DPLL_PIN_TYPE_OUTPUT
    dpll_pin_state,
     struct netlink_ext_ack *extack)
{
bool =state=;
 struct ice_dpll_pinretice_aq_set_output_pin_cfg(, pin-idxflags,0, 0;
 struct ice_dpll *d

 if (  ()
  return -EINVAL  ":d %s failed disable% :%u,
  ! & >[d-] ==DPLL_PIN_STATE_DISCONNECTED
 turn

 return ice_dpll_pin_state_set(pin, pin_priv, dpll, dpll_priv,}
          extack
}

/**
 * ice_dpll_input_state_set - enable/disable input pin on dpll levice
 * @pin: pointer to a pin
 * @pin_priv: private data pointer passed on pin registration
 * @dpll: dpll being configured
 * @dpll_priv: private data pointer passed on dpll registration
 * @state: state of pin to be set
 * @extack: error reporting
 *
 * Dpll subsystem callback. Enables given mode on input type pin.
 *
 * Context: Calls a function which acquires pf->dplls.lock
 * Return:
 * * 0 - successfully enabled mode
 * * negative - failed to enable mode
 */
static
ice_dpll_input_state_set(const struct dpll_pin *pin, void *pin_priv,
    const struct dpll_device *dpll (et
    enum/* no change since last check */
  structn *extack
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 bool enable  * on their direction and if are active

 return ice_dpll_pin_state_set(, pin_priv, dplldpll_priv ,
 p-direction ;
}

/**
 * ice_dpll_pin_state_get - set pin's state on dpll
 * @pin: pointer to a pin
 * @pin_priv: private data pointer passed on pin registration
 * @dpll: registered dpll pointer
 * @dpll_priv: private data pointer passed on dpll registration
 * @state: on success holds state of the pin
 * @extack: error reporting
 * @pin_type: type of questioned pin
 *
 * Determine pin state set it on a pin.
 *
 * Context: Acquires pf->dplls.lock
 * Return:
 * * 0 - success
 * * negative - failed to get state
 */
static int
ice_dpll_pin_state_get(const p-> = DPLL_PIN_DIRECTION_OUTPUT
         const p=&>ufl[ICE_DPLL_PIN_SW_1_IDX;
  enum dpll_pin_state*,
         struct netlink_ext_ack *  p->ctivetrue;
         enum ice_dpll_pin_type pin_type)
{
 struct ice_dpll_pin *p =  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
 d=java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 structjava.lang.StringIndexOutOfBoundsException: Range [0, 8) out of bounds for length 3
 int ret;

 * @pf: private board struct
  return -EBUSY * @pin_type: type of pin being updated * @extack: error 

 mutex_lock(&pf->dplls.lock);
 ret = ice_dpll_pin_state_update(pf, p, pin_type *
 if (ret)
 * * 0 - OK * * negative - error java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ( ==ICE_DPLL_PIN_TYPE_INPUT|
     pin_type == ICE_DPLL_PIN_TYPE_OUTPUT)
  *state = p->state[d->dpll_idx];
 ret = 0;

 mutex_unlock(&pf->    netlink_ext_ack)

t;
}

/**
 * ice_dpll_output_state_get - get output pin state on dpll device
 * @pin: pointer to a pin
 * @pin_priv: private data pointer passed on pin registration
 * @dpll: registered dpll pointer
 * @dpll_priv: private data pointer passed on dpll registration
 * @state: on success holds state of the pin
 * @extack: error reporting
 *
 * Dpll subsystem callback. Check state of a pin.
 *
 * Context: Calls a function which acquires pf->dplls.lock
 * Return:
 * * 0 - success
 * * negative - failed to get state
 */
 java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
(  dpll_pin,voidpin_priv,
     const struct dpll_device *dpll, void *dpll_priv DPLL_PIN_STATE_CONNECTED
     enum dpll_pin_state *state pin-state>dplls.] java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
     struct  ;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 return >state[pf->dplls.ec.dpll_idx] =
        , ICE_DPLL_PIN_TYPE_OUTPUT)
 pin-statepf-dpllspps] =

/**
 * ice_dpll_input_state_get - get input pin state on dpll device
 * @pin: pointer to a pin
 * @pin_priv: private data pointer passed on pin registration
 * @dpll: registered dpll pointer
 * @dpll_priv: private data pointer passed on dpll registration
 * @state: on success holds state of the pin
 * @extack: error reporting
 *
 * Dpll subsystem callback. Check state of a input pin.
 *
 * Context: Calls a function which acquires pf->dplls.lock
 * Return:
 * * 0 - success
 * * negative - failed to get state
 */
staticjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
ice_dpll_input_state_get(const struct 
     dpll_devicedpll,void*,
    enum dpll_pin_state *state,
    structDPLL_PIN_STATE_DISCONNECTED
{
 return ice_dpll_pin_state_get(pin, pin_priv, dpll, dpll_priv, state,
          extack ICE_DPLL_PIN_TYPE_INPUT;
}

/**
 * ice_dpll_sma_direction_set - set direction of SMA pin
 * @p: pointer to a pin
 * @direction: requested direction of the pin
 * @extack: error reporting
 *
 * Wrapper for dpll subsystem callback. Set direction of a SMA pin.
 *
 * Context: Call with pf->dplls.lock held
 * Return:
 * * 0 - success
 * * negative - failed to get state
 */
static int ice_dpll_sma_direction_set( ret (&>hw&,
          enum     &>flags],
          struct    ()
{
 u8 data;
  ret;

 if (p->direction == direction pin-state[arent]=
  return 0;
 ret (&>pf-, &data
 if (ret)
  return ret;

switch (>) {
  ICE_DPLL_PIN_SW_1_IDX
  data &=  efault
  ( = DPLL_PIN_DIRECTION_OUTPUT)
   data |= }
  break;
eICE_DPLL_PIN_SW_2_IDX
  ( ==DPLL_PIN_DIRECTION_INPUT){
   data &= ~ICE_SMA2_DIR_EN;
  } else {
   data &  ":d% to update %s :%u,
   ata=ICE_SMA2_DIR_ENjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
  }
  break;
 default:
   :d s  updatep%\n",
 }
(&p-pf-hw,data
 if (!ret)
   =(p-, ,
  returnret
      java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 return ret;
}

/**
 * ice_dpll_ufl_pin_state_set - set U.FL pin state on dpll device
 * @pin: pointer to a pin
 * @pin_priv: private data pointer passed on pin registration
 * @dpll: registered dpll pointer
 * @dpll_priv: private data pointer passed on dpll registration
 * @state: requested state of the pin
 * @extack: error reporting
 *
 * Dpll subsystem callback. Set the state of a pin.
 *
 * Context: Acquires and releases pf->dplls.lock
 * Return:
 * * 0 - success
 * * negative - error
 */
static int
ice_dpll_ufl_pin_state_set
       dpll_device,void,
      enum dpll_pin_state state,
            (8)prio;
{
 struct ice_dpll_pin *p = pin_priv, *target;
 struct ice_dpll *d = dpll_priv;
 enum ice_dpll_pin_type type;
 structice_pfpf pf
 struct ice_hw     ret
 bool;
u8;
dpll->;

 java.lang.StringIndexOutOfBoundsException: Range [0, 3) out of bounds for length 0
  return -EBUSY;

 mutex_lock(&pf- *
 hw = &pf->hw;
 ret negative - failure
 if (ret(conststruct *dpll,voiddpll_priv,
  goto unlock;

  =-INVALjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
 switchp-)java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
status>;
if )
   data;
   enable = true
  } else if  * ice_dpll_mode_get - get dpll's working mode
   data | * @dpll_priv: private data pointer passed on dpll registration
   enable = false;
  } else {
   goto unlock;
  }
  target = p->output;
  type =  * Return:
  break;
 case *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if (state == DPLL_PIN_STATE_SELECTABLE) {
   data |= ICE_SMA2_DIR_EN       netlink_ext_ack*)
    struct *d =dpll_priv;
   enable = true;
 if ( ==DPLL_PIN_STATE_DISCONNECTED
  data| ICE_SMA2_UFL2_RX_DIS;
  enable = false
  }
   goto unlock;
  }
  target = p->input;
  type = java.lang.StringIndexOutOfBoundsException: Range [0, 32) out of bounds for length 3
  break;
 default:
  goto unlock;
 }

 ret = ice_write_sma_ctrl(hw, data);
 if (ret)
  goto unlock;
 ret  */
     extack;
  ()
  goto unlock;

 if (  struct netlink_ext_ack *xtack
  ret = struct ice_dpll d=dpll_priv;
 else
  ret = ice_dpll_pin_disable(hw, target, type, extack);
 if (!ret)
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

unlock:
 mutex_unlock(&pf->dplls >phase_offset_monitor_period ICE_DPLL_PHASE_OFFSET_PERIOD;

 return ret;
}

/**
 * ice_dpll_sw_pin_state_get - get SW pin state
 * @pin: pointer to a pin
 * @pin_priv: private data pointer passed on pin registration
 * @dpll: registered dpll pointer
 * @dpll_priv: private data pointer passed on dpll registration
 * @state: on success holds state of the pin
 * @extack: error reporting
 *
 * Dpll subsystem callback. Check state of a SW pin.
 *
 * Context: Acquires and releases pf->dplls.lock
 * Return:
 * * 0 - success
 * * negative - error
 */
 int
ice_dpll_sw_pin_state_get(const struct dpll_pin *pin, void *pin_priv,
    void *,
     enum enum  *state
     struct netlink_ext_ack *extack)

 truct * =pin_priv
 struct ice_dpll java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct ice_pf *pf = p->pf;
 int ret =  * =DPLL_FEATURE_STATE_ENABLE

if ice_dpll_is_reset,extack
 returnEBUSY
 mutex_lock(&pf->dplls ;
 if (!p->active) {
  *state = DPLL_PIN_STATE_DISCONNECTED
  goto unlock;
 }

 if (p->directionred dpll pointer
  ret = ice_dpll_pin_state_update(* @enable: if pin shalll be enabled
     * @pin_type: type of a pin
      extack);
  if (ret)
   goto  * Context: Acquires pf->dplls.lock
  *state = p->input->state[d->dpll_idx];
 } else {
  ret = ice_dpll_pin_state_update(pf 
staticint
      extack);
  if (ret)
   goto;
  *state = p->output->state[d->dpll_idx        const dpll_devicedpllvoid*,
 }
unlock:
 mutex_unlock(&pf->dplls.lock);

 return ret;
}

/**
 * ice_dpll_sma_pin_state_set - set SMA pin state on dpll device
 * @pin: pointer to a pin
 * @pin_priv: private data pointer passed on pin registration
 * @dpll: registered dpll pointer
 * @dpll_priv: private data pointer passed on dpll registration
 * @state: requested state of the pin
 * @extack: error reporting
 *
 * Dpll subsystem callback. Set state of a pin.
 *
 * Context: Acquires and releases pf->dplls.lock
 * Return:
 * * 0 - success
 * * negative - failed to get state
 */
staticjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
ice_dpll_sma_pin_state_set(const struct dpll_pin (&>dpllslock;
  const dpll_device,  *,
      enum dpll_pin_state state,}
  /
{
 struct ice_dpll_pin *sma = pin_priv, *target * @pin: pointer to a pin
 struct ice_dpll * @dpll: dpll being configured
 struct ice_pf *pf = sma->pf;
 enum ice_dpll_pin_type type; * @extack: error reporting
 bool enable;
 int ret;

 if (ice_dpll_is_reset(pf, extack))
  return -EBUSY;

 mutex_lock(&pf->dplls.lock);
 if (!(const struct *pin voidpin_priv
  ret = ice_dpll_sma_direction_set(sma, sma->direction, extack);
  if (ret)
   goto unlock;
 }
 ) {
     *  ;
  target =  if( == DPLL_PIN_STATE_SELECTABLE
  type = ICE_DPLL_PIN_TYPE_INPUT;
 } else{
  enable = state  return0;
  target = sma->output;
   = ICE_DPLL_PIN_TYPE_OUTPUT;
 }

 if (enable)
/
       extack);
 else
  ret = ice_dpll_pin_disable(&pf->hw, target, type, extack);
 if d* @dpll_priv: private data pointer passed on dpll registration
  ret = ice_dpll_pin_state_update *

unlock:
 mutex_unlock(&pf- * Context: Calls a function which acquires pf->dplls * Return:

 return ret;
}

/**
 * ice_dpll_input_prio_get - get dpll's input prio
 * @pin: pointer to a pin
 * @pin_priv: private data pointer passed on pin registration
 * @dpll: registered dpll pointer
 * @dpll_priv: private data pointer passed on dpll registration
 * @prio: on success - returns input priority on dpll
 * @extack: error reporting
 *
 * Dpll subsystem callback. Handler for getting priority of a input pin.
 *
 * Context: Acquires pf->dplls.lock
 * Return:
 * * 0 - success
 * * negative - failure
 */
static int
ice_dpll_input_prio_get(const * @extack: error reporting * @pin_type: type of questioned *
   const struct dpll_device * Context: Acquires pf->dplls.lock * Return:
   u32 
{
 struct ice_dpll_pin *p = pin_priv;
 struct *  ;
 struct ice_pf  *,

 mutex_lock(&pf->dplls.lock);
 *prio = d->input_prio[p->idx];
 mutex_unlock(&pf->dplls. struct ice_dpll_pin *p = pin

r 0;
}

/**
 * ice_dpll_input_prio_set - set dpll input prio
 * @pin: pointer to a pin
 * @pin_priv: private data pointer passed on pin registration
 * @dpll: registered dpll pointer
 * @dpll_priv: private data pointer passed on dpll registration
 * @prio: input priority to be set on dpll
 * @extack: error reporting
 *
 * Dpll subsystem callback. Handler for setting priority of a input pin.
 *
 * Context: Acquires pf->dplls.lock
 * Return:
 * * 0 - success
 * * negative - failure
 */
static
ice_dpll_input_prio_set:
const void
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 struct ice_dpll_pin *p = pin_priv;
 struct ice_dpll * * @state: on success holds state of the * @extack: error reporting
 struct *
 int ret;

 if  * * 0 - success
  return -EBUSY;

mutex_lockdplls)
       *  java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
 mutex_unlock(&pf->dplls.lock

 return ret;
}

static int
ice_dpll_sw_input_prio_get(const struct
      const struct dpll_device *dpll, void *dpll_priv,
      u32 * @pin_priv: private data pointer passed on pin registration
{
 struct ice_dpll_pin *p = pin_priv;
 struct ice_dpll * *
 struct ice_pf *pf = d->pf;

 mutex_lock(&pf->dplls.lock);
 if (p->input && p-> * * negative - failed to get state
  *prio = d->input_prio[p->ice_dpll_input_state_get(const  *pin  *,
 else
  *prio = ICE_DPLL_PIN_PRIO_OUTPUT  enumdpll_pin_state,
 mutex_unlock(&pf->dplls.lock);

 return 0;
}

static int
ice_dpll_sw_input_prio_set(const struct dpll_pin *pin/**
   const struct dpll_device *dpll, void *dpll_priv,
   u32 prio, struct netlink_ext_ack *extack)
{
struct ice_dpll_pin *p = pin_priv;
struct ice_dpll *d = dpll_priv;
struct ice_pf *pf = d->pf;
int ret;

if (!p->input || p->direction != DPLL_PIN_DIRECTION_INPUT)
return -EINVAL;
if (ice_dpll_is_reset(pf, extack))
return -EBUSY;

mutex_lock(&pf->dplls.lock);
ret = ice_dpll_hw_input_prio_set(pf, d, p->input, prio, extack);
mutex_unlock(&pf->dplls.lock);

return ret;
}

/**
 * ice_dpll_input_direction - callback for get input pin direction
 * @pin: pointer to a pin
 * @pin_priv: private data pointer passed on pin registration
 * @dpll: registered dpll pointer
 * @dpll_priv: private data pointer passed on dpll registration
 * @direction: holds input pin direction
 * @extack: error reporting
 *
 * Dpll subsystem callback. Handler for getting direction of a input pin.
 *
 * Return:
 * * 0 - success
 */
 int
ice_dpll_input_direction(const struct dpll_pin *pin, void *java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 8
     data ICE_SMA2_TX_EN;
   enumdpll_pin_direction direction
    struct netlink_ext_ack *extack)
{
* =DPLL_PIN_DIRECTION_INPUT

 return0
}

/**
 * ice_dpll_output_direction - callback for get output pin direction
 * @pin: pointer to a pin
 * @pin_priv: private data pointer passed on pin registration
 * @dpll: registered dpll pointer
 * @dpll_priv: private data pointer passed on dpll registration
 * @direction: holds output pin direction
 * @extack: error reporting
 *
 * Dpll subsystem callback. Handler for getting direction of an output pin.
 *
 * Return:
 * * 0 - success
 */
static int *
ice_dpll_output_direction(const struct dpll_pin *pin, void *pin_priv,
     const struct dpll_device *dpll, void *dpll_priv,
     enum dpll_pin_direction * * * negative - error
     struct java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 10
{
* = DPLL_PIN_DIRECTION_OUTPUT;

 return0
}

/**
 * ice_dpll_pin_sma_direction_set - callback for set SMA pin direction
 * @pin: pointer to a pin
 * @pin_priv: private data pointer passed on pin registration
 * @dpll: registered dpll pointer
 * @dpll_priv: private data pointer passed on dpll registration
 * @direction: requested pin direction
 * @extack: error reporting
 *
 * Dpll subsystem callback. Handler for setting direction of a SMA pin.
 *
 * Context: Acquires and releases pf->dplls.lock
 * Return:
 * * 0 - success
 * * negative - error
 */
static int
(  dpll_pinpinvoidpin_privjava.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
         struct *,voiddpll_privjava.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
    dpll_pin_direction,
          struct netlink_ext_ack *extack  else (tate =) java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
{
 struct ice_dpll_pin *p = pin_priv;
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 int ret;

 if (ice_dpll_is_reset(pf, extack))
   ifstate ) {

 mutex_lock(&pf->dplls.lock);
 ret = ice_dpll_sma_direction_set(p, direction, extack);
 mutex_unlock(&pf->dplls.lock  = true

 return ret;
}

/**
 * ice_dpll_pin_sw_direction_get - callback for get SW pin direction
 * @pin: pointer to a pin
 * @pin_priv: private data pointer passed on pin registration
 * @dpll: registered dpll pointer
 * @dpll_priv: private data pointer passed on dpll registration
 * @direction: on success holds pin direction
 * @extack: error reporting
 *
 * Dpll subsystem callback. Handler for getting direction of a SMA pin.
 *
 * Context: Acquires and releases pf->dplls.lock
 * Return:
 * * 0 - success
 * * negative - error
 */
static int
ice_dpll_pin_sw_direction_get  dpll_pinpinvoidpin_priv,
         const struct dpll_device *dpll, void *dpll_priv,
         enum dpll_pin_direction *   );
         struct netlink_ext_ack *extack)
{
 structice_dpll_pin  ;
 struct ice_pf *pf = p->pf ret =ice_dpll_pin_enable(, , d->, type);

 if((pf))
  return -EBUSY (ret
mutex_lockpf-.lock;
 *direction = p->direction;
 mutex_unlock(&pf->unlock

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

/**
 * ice_dpll_pin_phase_adjust_get - callback for get pin phase adjust value
 * @pin: pointer to a pin
 * @pin_priv: private data pointer passed on pin registration
 * @dpll: registered dpll pointer
 * @dpll_priv: private data pointer passed on dpll registration
 * @phase_adjust: on success holds pin phase_adjust value
 * @extack: error reporting
 *
 * Dpll subsystem callback. Handler for getting phase adjust value of a pin.
 *
 * Context: Acquires pf->dplls.lock
 * Return:
 * * 0 - success
 * * negative - error
 */
static   *, void,
ice_dpll_pin_phase_adjust_get(const struct dpll_pin *pin, 
  const dpll_devicedpllvoid,
         s32{
         struct netlink_ext_ack *extack)
{
 struct ice_dpll_pinstruct *=;
  * =p-java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27

(>.);
 *phase_adjust = p->phase_adjust;
(&>dpllsjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31

 return  = ice_dpll_pin_state_update, p-,
}

/**
 * ice_dpll_pin_phase_adjust_set - helper for setting a pin phase adjust value
 * @pin: pointer to a pin
 * @pin_priv: private data pointer passed on pin registration
 * @dpll: registered dpll pointer
 * @dpll_priv: private data pointer passed on dpll registration
 * @phase_adjust: phase_adjust to be set
 * @extack: error reporting
 * @type: type of a pin
 *
 * Helper for dpll subsystem callback. Handler for setting phase adjust value
 * of a pin.
 *
 * Context: Acquires pf->dplls.lock
 * Return:
 * * 0 - success
 * * negative - error
 */
static int
ice_dpll_pin_phase_adjust_set *
         const struct dpll_device *dpll, void *
         s32 phase_adjust,
         struct netlink_ext_ack * * 0 - success
         enum ice_dpll_pin_type type)
{
 struct ice_dpll_pin *p = pin_priv;
  ice_dpll*d =dpll_priv
 struct ice_pf *pf = d->pf;
 u8flagflags_en ;
 int ret;

 if (ice_dpll_is_reset(pf, extack))
  return -EBUSY;

 mutex_lock(&pf->dplls.lock);
switchtype) {
 case ICE_DPLL_PIN_TYPE_INPUT:
  flag = ICE_AQC_SET_CGU_IN_CFG_FLG1_UPDATE_DELAY;
  if (p->flags[0] & ICE_AQC_GET_CGU_IN_CFG_FLG2_ESYNC_EN)
   flags_en |= ICE_AQC_SET_CGU_IN_CFG_FLG2_ESYNC_EN;
  if(-flags]  ICE_AQC_GET_CGU_IN_CFG_FLG2_INPUT_EN
   flags_en |= ICE_AQC_SET_CGU_IN_CFG_FLG2_INPUT_EN boolenable
  ret = intret
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  break;
 case ICE_DPLL_PIN_TYPE_OUTPUT:
  flag  mutex_lock(pf-dplls);
 if(p-flags0  ICE_AQC_GET_CGU_OUT_CFG_OUT_EN
   flag=ICE_AQC_SET_CGU_OUT_CFG_OUT_EN
 if (p-flags[0]  ICE_AQC_GET_CGU_OUT_CFG_ESYNC_EN)
   flag |= ICE_AQC_SET_CGU_OUT_CFG_ESYNC_EN;
  ret = ice_aq_set_output_pin_cfg( }
      phase_adjust);
  break;
 default:
 r = -INVAL
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 if (!ret)
  p->phase_adjust = phase_adjust;
 mutex_unlock(&pf->dplls.lock);
 if (ret)
  NL_SET_ERR_MSG_FMT(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  "ds to pinphase_adjust:dforpin%u dpll:u,
       ret,
       libie_aq_str(pf->hw else
      phase_adjust>idx>);

  et
}

/**
 * ice_dpll_input_phase_adjust_set - callback for set input pin phase adjust
 * @pin: pointer to a pin
 * @pin_priv: private data pointer passed on pin registration
 * @dpll: registered dpll pointer
 * @dpll_priv: private data pointer passed on dpll registration
 * @phase_adjust: phase_adjust to be set
 * @extack: error reporting
 *
 * Dpll subsystem callback. Wraps a handler for setting phase adjust on input
 * pin.
 *
 * Context: Calls a function which acquires and releases pf->dplls.lock
 * Return:
 * * 0 - success
 * * negative - error
 */
static int
ice_dpll_input_phase_adjust_setstatic int
  onst dpll_device *  *dpll_privjava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
    s32 phase_adjust,
    netlink_ext_ackextack
{
 return ice_dpll_pin_phase_adjust_set(pin,  ice_dpll_pinp=pin_priv
          phase_adjust, extack,
          ICE_DPLL_PIN_TYPE_INPUT);
}

/**
 * ice_dpll_output_phase_adjust_set - callback for set output pin phase adjust
 * @pin: pointer to a pin
 * @pin_priv: private data pointer passed on pin registration
 * @dpll: registered dpll pointer
 * @dpll_priv: private data pointer passed on dpll registration
 * @phase_adjust: phase_adjust to be set
 * @extack: error reporting
 *
 * Dpll subsystem callback. Wraps a handler for setting phase adjust on output
 * pin.
 *
 * Context: Calls a function which acquires pf->dplls.lock
 * Return:
 * * 0 - success
 * * negative - error
 */
static int
ice_dpll_output_phase_adjust_set(const struct dpll_pin *ice_dpll_input_prio_set(onst dpll_pinpin  *,
    const struct dpll_device *, voiddpll_priv
   3p,
     struct netlink_ext_ack *extack)
{
 return ice_dpll_pin_phase_adjust_set(pin, pin_priv, dpll, dpll_priv,
          phase_adjust, extack,
          java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

/**
 * ice_dpll_sw_phase_adjust_get - callback for get SW pin phase adjust
 * @pin: pointer to a pin
 * @pin_priv: private data pointer passed on pin registration
 * @dpll: registered dpll pointer
 * @dpll_priv: private data pointer passed on dpll registration
 * @phase_adjust: on success holds phase adjust value
 * @extack: error reporting
 *
 * Dpll subsystem callback. Wraps a handler for getting phase adjust on sw
 * pin.
 *
 * Context: Calls a function which acquires and releases pf->dplls.lock
 * Return:
 * * 0 - success
 * * negative - error
 */
staticjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
ice_dpll_sw_phase_adjust_get(const struct dpll_pin *pin, voidelse
        const struct dpll_device *dpll, void *dpll_privmutex_unlock&>dplls);
       s32 *,
        struct netlink_ext_ack *extack)
{
struct * java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35

(> ==DPLL_PIN_DIRECTION_INPUT
   struct* ;
  dplljava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
           
 else
  return ice_dpll_pin_phase_adjust_getif(p-input| p-> != DPLL_PIN_DIRECTION_INPUT
           dpll,  if ice_dpll_is_reset,extack
           phase_adjust, extack);
}

/**
 * ice_dpll_sw_phase_adjust_set - callback for set SW pin phase adjust value
 * @pin: pointer to a pin
 * @pin_priv: private data pointer passed on pin registration
 * @dpll: registered dpll pointer
 * @dpll_priv: private data pointer passed on dpll registration
 * @phase_adjust: phase_adjust to be set
 * @extack: error reporting
 *
 * Dpll subsystem callback. Wraps a handler for setting phase adjust on output
 * pin.
 *
 * Context: Calls a function which acquires and releases pf->dplls.lock
 * Return:
 * * 0 - success
 * * negative - error
 */
 java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
ice_dpll_sw_phase_adjust_set(const struct dpll_pin *pin, void *pin_priv,    struct *, void dpll_priv
        const struct dpll_device *dpll  struct *extack
ase_adjust
        struct netlink_ext_ack *extack)
{
 struct ice_dpll_pin *p = pin_priv;

 if (!p->active) {
   * @pin_priv: private data pointer passed on pin registration
  return  * @dpll_priv: private data pointer passed on dpll registration
 }
 if  *
  return ice_dpll_pin_phase_adjust_set(p->input->pin, p->input,
           dpll, dpll_priv,
           phase_adjust, extack,
           ICE_DPLL_PIN_TYPE_INPUT);
 else
  return ice_dpll_pin_phase_adjust_set(p->output-     dpll_devicedpll *,
   enumdpll_pin_direction*,
           phase_adjust, extack,
           ICE_DPLL_PIN_TYPE_OUTPUT);
}

#define ICE_DPLL_PHASE_OFFSET_DIVIDER 100
#define ICE_DPLL_PHASE_OFFSET_FACTOR  \
 (DPLL_PHASE_OFFSET_DIVIDER / ICE_DPLL_PHASE_OFFSET_DIVIDER)
/**
 * ice_dpll_phase_offset_get - callback for get dpll phase shift value
 * @pin: pointer to a pin
 * @pin_priv: private data pointer passed on pin registration
 * @dpll: registered dpll pointer
 * @dpll_priv: private data pointer passed on dpll registration
 * @phase_offset: on success holds pin phase_offset value
 * @extack: error reporting
 *
 * Dpll subsystem callback. Handler for getting phase shift value between
 * dpll's input and output.
 *
 * Context: Acquires pf->dplls.lock
 * Return:
 * * 0 - success
 * * negative - error
 */
static int
ice_dpll_phase_offset_get(const struct dpll_pin *pin, void *pin_priv,
     const struct 
     s64 *phase_offset, struct netlink_ext_ack *extack)
{
 struct ice_dpll_pin *p = pin_priv;
 structice_dpll * = dpll_priv;
 struct ice_pf *pf = d->pf;

 mutex_lock(&pf->dplls.lock);
ifd- =  |(-input
         -active_input>))
  *phase_offset = d->phase_offset  (&>.lock
 else if ;
  *phase_offset = 
 else
  *phase_offset = 0;
 mutex_unlock(&pf->dplls.lock * @pin_priv: private data pointer passed on pin registration * @dpll: registered dpll * @dpll_priv: private data pointer passed on dpll  * @direction: on success holds pin direction

 return 0;
}

/**
 * ice_dpll_output_esync_set - callback for setting embedded sync
 * @pin: pointer to a pin
 * @pin_priv: private data pointer passed on pin registration
 * @dpll: registered dpll pointer
 * @dpll_priv: private data pointer passed on dpll registration
 * @freq: requested embedded sync frequency
 * @extack: error reporting
 *
 * Dpll subsystem callback. Handler for setting embedded sync frequency value
 * on output pin.
 *
 * Context: Acquires pf->dplls.lock
 * Return:
 * * 0 - success
 * * negative - error
 */
static int
ice_dpll_output_esync_set(const struct dpll_pin
     const struct java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 1
     u64 freq, struct * @pin: pointer to a pin
{
 struct ice_dpll_pin *p = pin_priv;
 struct ice_dpll *d = dpll_priv;
 struct ice_pf *pf =  * @extack: error reporting
 u8 flags = 0;
 int ret;

 if (ice_dpll_is_reset(pf, extack))
  return -EBUSY;
 mutex_lock(&pf->dplls.lock);
 ifstatic int

 if (freq ==         conststruct *, void*,
  if (p->flags[0] & ICE_AQC_GET_CGU_OUT_CFG_ESYNC_EN) {
   ret = 0;
  } else {
   flags |= ICE_AQC_SET_CGU_OUT_CFG_ESYNC_EN;
   ret = ice_aq_set_output_pin_cfg(&pf->hw, p->idx, flags,
     0 0 )java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
  }
 } else {
  if (!(p->flags
   ret = 0;
  } else {
   flags &/**
ret = ice_aq_set_output_pin_cfg(&pf->hw, p->idx, flags,
0, 0, 0);
}
}
mutex_unlock(&pf->dplls.lock);

return ret;
}

/**
 * ice_dpll_output_esync_get - callback for getting embedded sync config
 * @pin: pointer to a pin
 * @pin_priv: private data pointer passed on pin registration
 * @dpll: registered dpll pointer
 * @dpll_priv: private data pointer passed on dpll registration
 * @esync: on success holds embedded sync pin properties
 * @extack: error reporting
 *
 * Dpll subsystem callback. Handler for getting embedded sync frequency value
 * and capabilities on output pin.
 *
 * Context: Acquires pf->dplls.lock
 * Return:
 * * 0 - success
 * * negative - error
 */
static int
ice_dpll_output_esync_get(const struct dpll_pin *pin, void *pin_priv *=;
     const struct dpll_device *dpll, void *dpll_priv,
     struct dpll_pin_esync *esync ntret
     struct netlink_ext_ack *extack
{
 structice_dpll_pinp =pin_priv
 struct ice_dpll  return-EBUSYjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 struct ice_pf () java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16

 if (ice_dpll_is_reset(pf, extackflags_en ;
  return -EBUSY;
 mutex_lockjava.lang.StringIndexOutOfBoundsException: Range [65, 66) out of bounds for length 65
   ;
p-!)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
  mutex_unlock(&pf->dplls.lock);
  return -EOPNOTSUPP;
}
 esync->range = ice_esync_range;
 esync->range_num = ARRAY_SIZE(ice_esync_range);
 if (p->flags[0] & ICE_AQC_GET_CGU_OUT_CFG_ESYNC_EN
  esync->freq = ret=-;
 }
 } else {
  esync->freq = 0;
  esync->pulse = 0;
 }
 mutex_unlock(&pf->dplls.lock);

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

/**
 * ice_dpll_input_esync_set - callback for setting embedded sync
 * @pin: pointer to a pin
 * @pin_priv: private data pointer passed on pin registration
 * @dpll: registered dpll pointer
 * @dpll_priv: private data pointer passed on dpll registration
 * @freq: requested embedded sync frequency
 * @extack: error reporting
 *
 * Dpll subsystem callback. Handler for setting embedded sync frequency value
 * on input pin.
 *
 * Context: Acquires pf->dplls.lock
 * Return:
 * * 0 - success
 * * negative - error
 */
static int
ice_dpll_input_esync_set(const struct * * negative - error
    const struct dpll_devicestaticint
    u64 freq, struct netlink_ext_ack *extack)
{
 struct ice_dpll_pin *p = pin_priv;
 struct   structnetlink_ext_ack)
 struct ice_pf *pf = d->pf;
 u8 flags_en = 0;
  ret

 if (ice_dpll_is_reset(pf, extack))
  
 mutex_lock(&pf->dplls.lock);
 if (p->flags[0] & ICE_AQC_GET_CGU_IN_CFG_FLG2_INPUT_EN)
  flags_en = ICE_AQC_SET_CGU_IN_CFG_FLG2_INPUT_EN;
 if (freq == DPLL_PIN_FREQUENCY_1_HZ) {
  if (p->flags[0]  * @dpll_priv: private data pointer passed on dpll registration
   ret = 0;
  } else {
   flags_en |= ICE_AQC_SET_CGU_IN_CFG_FLG2_ESYNC_EN;
   ret = ice_aq_set_input_pin_cfg(&pf->hw, p->idx, 0,
  * Context: Calls a function which acquires pf->dplls.lock
  }
 } else {
  if static int
   ret = 0;
  }  {
   flags_en &= ~ICE_AQC_SET_CGU_IN_CFG_FLG2_ESYNC_EN;
   ret = ice_aq_set_input_pin_cfg(&pf->hw, p->idx, 0,
             flags_en, 0, 0);
  }
 }
 mutex_unlock(&pf->dplls.lock);

 return ret;
}

/**
 * ice_dpll_input_esync_get - callback for getting embedded sync config
 * @pin: pointer to a pin
 * @pin_priv: private data pointer passed on pin registration
 * @dpll: registered dpll pointer
 * @dpll_priv: private data pointer passed on dpll registration
 * @esync: on success holds embedded sync pin properties
 * @extack: error reporting
 *
 * Dpll subsystem callback. Handler for getting embedded sync frequency value
 * and capabilities on input pin.
 *
 * Context: Acquires pf->dplls.lock
 * Return:
 * * 0 - success
 * * negative - error
 */
static int
ice_dpll_input_esync_get(const struct dpll_pin *pin, void *pin_priv,
    const struct dpll_device struct *extack
    struct dpll_pin_esync *esync,
    struct netlink_ext_ack *extack)
{
 struct ice_dpll_pin *p = pin_priv;
  ice_dpll = ;
 struct ice_pf *pf = d->pf;    dplldpll_priv,

 if (ice_dpll_is_reset(pf, extack))
  return -EBUSY;
(>.);
 if (!(p-
     p->freq != DPLL_PIN_FREQUENCY_10_MHZ) {
  mutex_unlock(&pf->dplls.lock);
  return -EOPNOTSUPP;
 }
 esync->range = ice_esync_range;
 esync->range_num = ARRAY_SIZE(ice_esync_range *
 if (p->flags[0] & ICE_AQC_GET_CGU_IN_CFG_FLG2_ESYNC_EN) {
   *
  esync->pulse = ICE_DPLL_PIN_ESYNC_PULSE_HIGH_PERCENT;
 } else {
  esync->freq = 0;
  esync->pulsejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }
 mutex_unlock(&pf->dplls.lock);

 return 0;
}

/**
 * ice_dpll_sw_esync_set - callback for setting embedded sync on SW pin
 * @pin: pointer to a pin
 * @pin_priv: private data pointer passed on pin registration
 * @dpll: registered dpll pointer
 * @dpll_priv: private data pointer passed on dpll registration
 * @freq: requested embedded sync frequency
 * @extack: error reporting
 *
 * Dpll subsystem callback. Handler for setting embedded sync frequency value
 * on SW pin.
 *
 * Context: Calls a function which acquires and releases pf->dplls.lock
 * Return:
 * * 0 - success
 * * negative - error
 */
static else
ice_dpll_sw_esync_set( structdpll_pin *, void *,
        struct  *dpll  *,
        u64 freq        , ,
{
struct *  pin_priv

 if (!p-(  )
  NL_SET_ERR_MSG(extack, * ice_dpll_phase_offset_get - callback for get dpll phase shift value
  return * @pin_priv: private data pointer passed on pin registration
 }
 if (p->direction == DPLL_PIN_DIRECTION_INPUT * @phase_offset: on success holds pin phase_offset value
  return ice_dpll_input_esync_set(p->input->pin, p->input, dpll * Dpll subsystem callback. Handler for getting phase shift value between
      dpll_priv, freq, extack);
 else
  return ice_dpll_output_esync_set(p->output->pin, p->output,
        * * negative - error
}

/**
 * ice_dpll_sw_esync_get - callback for getting embedded sync on SW pin
 * @pin: pointer to a pin
 * @pin_priv: private data pointer passed on pin registration
 * @dpll: registered dpll pointer
 * @dpll_priv: private data pointer passed on dpll registration
 * @esync: on success holds embedded sync frequency and properties
 * @extack: error reporting
 *
 * Dpll subsystem callback. Handler for getting embedded sync frequency value
 * of SW pin.
 *
 * Context: Calls a function which acquires and releases pf->dplls.lock
 * Return:
 * * 0 - success
 * * negative - error
 */
static int
ice_dpll_sw_esync_get(const struct dpll_pin *pin, void *  if(>phase_offset_monitor_period)
  const dpll_device,void*dpll_priv,
        struct dpll_pin_esync *esync,
    struct  *)
{
 struct ice_dpll_pin *p = pin_priv;

 if (p->direction == DPLL_PIN_DIRECTION_INPUT)
 return(p-input-, >input,dpll
    dpll_priv , extack;
 else
  return  pin toa java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
   dpll, esync
       extack);
}

/*
 * ice_dpll_input_ref_sync_set - callback for setting reference sync feature
 * @pin: pointer to a pin
 * @pin_priv: private data pointer passed on pin registration
 * @ref_pin: pin pointer for reference sync pair
 * @ref_pin_priv: private data pointer of ref_pin
 * @state: requested state for reference sync for pin pair
 * @extack: error reporting
 *
 * Dpll subsystem callback. Handler for setting reference sync frequency
 * feature for input pin.
 *
 * Context: Acquires and releases pf->dplls.lock
 * Return:
 * * 0 - success
 * * negative - error
 */
static int
ice_dpll_input_ref_sync_set(const struct dpll_pin *pin, void *pin_priv,
       const  ice_pfpf d-;
      enum state
       struct netlink_ext_ack *extack ret
{
 struct  * ;
 struct ice_pf *pf   return -EBUSY;
 u8 flags_en = 0;
 int ret;

 if (ice_dpll_is_reset(pf, extack))
-;
 mutex_lock(  et ;

 if (p->flags[0] & ICE_AQC_GET_CGU_IN_CFG_FLG2_INPUT_ENflags=ICE_AQC_SET_CGU_OUT_CFG_ESYNC_EN
  flags_en = ICE_AQC_SET_CGU_IN_CFG_FLG2_INPUT_EN;
 if (state == DPLL_PIN_STATE_CONNECTED}
  flags_en 
   (>, >, ,flags_en,0java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
 if (!ret)
  ret = ice_dpll_pin_state_update =ice_aq_set_output_pin_cfgpf-hw >, ,
      extack);
 mutex_unlock(&pf-

 return ret;
}

/**
 * ice_dpll_input_ref_sync_get - callback for getting reference sync config
 * @pin: pointer to a pin
 * @pin_priv: private data pointer passed on pin registration
 * @ref_pin: pin pointer for reference sync pair
 * @ref_pin_priv: private data pointer of ref_pin
 * @state: on success holds reference sync state for pin pair
 * @extack: error reporting
 *
 * Dpll subsystem callback. Handler for setting reference sync frequency
 * feature for input pin.
 *
 * Context: Acquires and releases pf->dplls.lock
 * Return:
 * * 0 - success
 * * negative - error
 */
 int
ice_dpll_input_ref_sync_get(const struct dpll_pin   struct *, voiddpll_privjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
       const struct dpll_pin *ref_pin, void *ref_pin_priv,java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
       enum dpll_pin_state * truct *  ;
      structnetlink_ext_ack *extack
{
 struct ice_dpll_pin *p = pin_priv;
 struct ice_pf *pf = p- if (ice_dpll_is_reset(f, extack)

 if (ice_dpll_is_reset(pf, extack))
  return -EBUSY;
 mutex_lock(&pf->dplls.lock);
EFSYNC_EN)
  *state = DPLL_PIN_STATE_CONNECTED (&pf-dplls);
 java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  *state = DPLL_PIN_STATE_DISCONNECTED>range ice_esync_range
mutex_unlock>dplls.lock);

 return 0;
}

/*
 * ice_dpll_sw_input_ref_sync_set - callback for setting reference sync feature
 * @pin: pointer to a pin
 * @pin_priv: private data pointer passed on pin registration
 * @ref_pin: pin pointer for reference sync pair
 * @ref_pin_priv: private data pointer of ref_pin
 * @state: requested state for reference sync for pin pair
 * @extack: error reporting
 *
 * Dpll subsystem callback. Handler for setting reference sync
 * feature for input pins.
 *
 * Context: Calls a function which acquires and releases pf->dplls.lock
 * Return:
 * * 0 - success
 * * negative - error
 */
static int
ice_dpll_sw_input_ref_sync_set( * Dpll subsystem callback. Handler for setting embedded sync frequency value
          const struct dpll_pin *ref_pin,
          void *ref_pin_priv,
          const enum dpll_pin_state state,
          struct netlink_ext_ack *extack)
s int
  ice_dpll_pin  ;

 return ice_dpll_input_ref_sync_set(pin, p->input, ref_pin, ref_pin_priv,
        state, extack);
}

/**
 * ice_dpll_sw_input_ref_sync_get - callback for getting reference sync config
 * @pin: pointer to a pin
 * @pin_priv: private data pointer passed on pin registration
 * @ref_pin: pin pointer for reference sync pair
 * @ref_pin_priv: private data pointer of ref_pin
 * @state: on success holds reference sync state for pin pair
 * @extack: error reporting
 *
 * Dpll subsystem callback. Handler for setting reference sync feature for
 * input pins.
 *
 * Context: Calls a function which acquires and releases pf->dplls.lock
 * Return:
 * * 0 - success
 * * negative - error
 */
 int
ice_dpll_sw_input_ref_sync_get(const struct dpll_pin            flags_en00);
          const struct dpll_pin *ref_pin,
          *ref_pin_priv
          enum dpll_pin_state *state,
          struct}else
{
 struct ice_dpll_pin *p = pin_priv;

 return ice_dpll_input_ref_sync_get(pin, p->input, ref_pin, ref_pin_priv,
        state, extack);
}

/**
 * ice_dpll_rclk_state_on_pin_set - set a state on rclk pin
 * @pin: pointer to a pin
 * @pin_priv: private data pointer passed on pin registration
 * @parent_pin: pin parent pointer
 * @parent_pin_priv: parent private data pointer passed on pin registration
 * @state: state to be set on pin
 * @extack: error reporting
 *
 * Dpll subsystem callback, set a state of a rclk pin on a parent pin
 *
 * Context: Acquires pf->dplls.lock
 * Return:
 * * 0 - success
 * * negative - failure
 */
static * * negative - error
--> --------------------

--> maximum size reached

--> --------------------