Quelle  cxgb4_dcb.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 *  Copyright (C) 2013-2014 Chelsio Communications.  All rights reserved.
 *
 *  Written by Anish Bhatt (anish@chelsio.com)
 *        Casey Leedom (leedom@chelsio.com)
 */

#include "cxgb4.h"

/* DCBx version control
 */
const char * const dcb_ver_array[] = {
 "Unknown",
 "DCBx-CIN",
 "DCBx-CEE 1.01",
 "DCBx-IEEE",
 "", "", "",
 "Auto Negotiated"
};

static inline bool cxgb4_dcb_state_synced(enum cxgb4_dcb_state state)
{
 if (state == CXGB4_DCB_STATE_FW_ALLSYNCED ||
     state == CXGB4_DCB_STATE_HOST)
  return true;
 else
  return false;
}

/* Initialize a port's Data Center Bridging state.
 */
void cxgb4_dcb_state_init(struct net_device *dev)
{
 struct port_info *pi = netdev2pinfo(dev);
 struct port_dcb_info *dcb = &pi->dcb;
 int version_temp = dcb->dcb_version;

 memset(dcb, 0, sizeof(struct port_dcb_info));
 dcb->state = CXGB4_DCB_STATE_START;
 if (version_temp)
  dcb->dcb_version = version_temp;

 netdev_dbg(dev, "%s: Initializing DCB state for port[%d]\n",
      __func__, pi->port_id);
}

void cxgb4_dcb_version_init(struct net_device *dev)
{
 struct port_info *pi = netdev2pinfo(dev);
 struct port_dcb_info *dcb = &pi->dcb;

 /* Any writes here are only done on kernels that exlicitly need
 * a specific version, say < 2.6.38 which only support CEE
 */
 dcb->dcb_version = FW_PORT_DCB_VER_AUTO;
}

static void cxgb4_dcb_cleanup_apps(struct net_device *dev)
{
 struct port_info *pi = netdev2pinfo(dev);
 struct adapter *adap = pi->adapter;
 struct port_dcb_info *dcb = &pi->dcb;
 struct dcb_app app;
 int i, err;

 /* zero priority implies remove */
 app.priority = 0;

 for (i = 0; i < CXGB4_MAX_DCBX_APP_SUPPORTED; i++) {
  /* Check if app list is exhausted */
  if (!dcb->app_priority[i].protocolid)
   break;

  app.protocol = dcb->app_priority[i].protocolid;

  if (dcb->dcb_version == FW_PORT_DCB_VER_IEEE) {
   app.priority = dcb->app_priority[i].user_prio_map;
   app.selector = dcb->app_priority[i].sel_field + 1;
   err = dcb_ieee_delapp(dev, &app);
  } else {
   app.selector = !!(dcb->app_priority[i].sel_field);
   err = dcb_setapp(dev, &app);
  }

  if (err) {
   dev_err(adap->pdev_dev,
    "Failed DCB Clear %s Application Priority: sel=%d, prot=%d, err=%d\n",
    dcb_ver_array[dcb->dcb_version], app.selector,
    app.protocol, -err);
   break;
  }
 }
}

/* Reset a port's Data Center Bridging state.  Typically used after a
 * Link Down event.
 */
void cxgb4_dcb_reset(struct net_device *dev)
{
 cxgb4_dcb_cleanup_apps(dev);
 cxgb4_dcb_state_init(dev);
}

/* update the dcb port support, if version is IEEE then set it to
 * FW_PORT_DCB_VER_IEEE and if DCB_CAP_DCBX_VER_CEE is already set then
 * clear that. and if it is set to CEE then set dcb supported to
 * DCB_CAP_DCBX_VER_CEE & if DCB_CAP_DCBX_VER_IEEE is set, clear it
 */
static inline void cxgb4_dcb_update_support(struct port_dcb_info *dcb)
{
 if (dcb->dcb_version == FW_PORT_DCB_VER_IEEE) {
  if (dcb->supported & DCB_CAP_DCBX_VER_CEE)
   dcb->supported &= ~DCB_CAP_DCBX_VER_CEE;
  dcb->supported |= DCB_CAP_DCBX_VER_IEEE;
 } else if (dcb->dcb_version == FW_PORT_DCB_VER_CEE1D01) {
  if (dcb->supported & DCB_CAP_DCBX_VER_IEEE)
   dcb->supported &= ~DCB_CAP_DCBX_VER_IEEE;
  dcb->supported |= DCB_CAP_DCBX_VER_CEE;
 }
}

/* Finite State machine for Data Center Bridging.
 */
void cxgb4_dcb_state_fsm(struct net_device *dev,
    enum cxgb4_dcb_state_input transition_to)
{
 struct port_info *pi = netdev2pinfo(dev);
 struct port_dcb_info *dcb = &pi->dcb;
 struct adapter *adap = pi->adapter;
 enum cxgb4_dcb_state current_state = dcb->state;

 netdev_dbg(dev, "%s: State change from %d to %d for %s\n",
      __func__, dcb->state, transition_to, dev->name);

 switch (current_state) {
 case CXGB4_DCB_STATE_START: {
  switch (transition_to) {
  case CXGB4_DCB_INPUT_FW_DISABLED: {
   /* we're going to use Host DCB */
   dcb->state = CXGB4_DCB_STATE_HOST;
   dcb->supported = CXGB4_DCBX_HOST_SUPPORT;
   break;
  }

  case CXGB4_DCB_INPUT_FW_ENABLED: {
   /* we're going to use Firmware DCB */
   dcb->state = CXGB4_DCB_STATE_FW_INCOMPLETE;
   dcb->supported = DCB_CAP_DCBX_LLD_MANAGED;
   if (dcb->dcb_version == FW_PORT_DCB_VER_IEEE)
    dcb->supported |= DCB_CAP_DCBX_VER_IEEE;
   else
    dcb->supported |= DCB_CAP_DCBX_VER_CEE;
   break;
  }

  case CXGB4_DCB_INPUT_FW_INCOMPLETE: {
   /* expected transition */
   break;
  }

  case CXGB4_DCB_INPUT_FW_ALLSYNCED: {
   dcb->state = CXGB4_DCB_STATE_FW_ALLSYNCED;
   break;
  }

  default:
   goto bad_state_input;
  }
  break;
 }

 case CXGB4_DCB_STATE_FW_INCOMPLETE: {
  if (transition_to != CXGB4_DCB_INPUT_FW_DISABLED) {
   /* during this CXGB4_DCB_STATE_FW_INCOMPLETE state,
 * check if the dcb version is changed (there can be
 * mismatch in default config & the negotiated switch
 * configuration at FW, so update the dcb support
 * accordingly.
 */
   cxgb4_dcb_update_support(dcb);
  }
  switch (transition_to) {
  case CXGB4_DCB_INPUT_FW_ENABLED: {
   /* we're alreaady in firmware DCB mode */
   break;
  }

  case CXGB4_DCB_INPUT_FW_INCOMPLETE: {
   /* we're already incomplete */
   break;
  }

  case CXGB4_DCB_INPUT_FW_ALLSYNCED: {
   dcb->state = CXGB4_DCB_STATE_FW_ALLSYNCED;
   dcb->enabled = 1;
   linkwatch_fire_event(dev);
   break;
  }

  default:
   goto bad_state_input;
  }
  break;
 }

 case CXGB4_DCB_STATE_FW_ALLSYNCED: {
  switch (transition_to) {
  case CXGB4_DCB_INPUT_FW_ENABLED: {
   /* we're alreaady in firmware DCB mode */
   break;
  }

  case CXGB4_DCB_INPUT_FW_INCOMPLETE: {
   /* We were successfully running with firmware DCB but
 * now it's telling us that it's in an "incomplete
 * state.  We need to reset back to a ground state
 * of incomplete.
 */
   cxgb4_dcb_reset(dev);
   dcb->state = CXGB4_DCB_STATE_FW_INCOMPLETE;
   dcb->supported = CXGB4_DCBX_FW_SUPPORT;
   linkwatch_fire_event(dev);
   break;
  }

  case CXGB4_DCB_INPUT_FW_ALLSYNCED: {
   /* we're already all sync'ed
 * this is only applicable for IEEE or
 * when another VI already completed negotiaton
 */
   dcb->enabled = 1;
   linkwatch_fire_event(dev);
   break;
  }

  default:
   goto bad_state_input;
  }
  break;
 }

 case CXGB4_DCB_STATE_HOST: {
  switch (transition_to) {
  case CXGB4_DCB_INPUT_FW_DISABLED: {
   /* we're alreaady in Host DCB mode */
   break;
  }

  default:
   goto bad_state_input;
  }
  break;
 }

 default:
  goto bad_state_transition;
 }
 return;

bad_state_input:
 dev_err(adap->pdev_dev, "cxgb4_dcb_state_fsm: illegal input symbol %d\n",
  transition_to);
 return;

bad_state_transition:
 dev_err(adap->pdev_dev, "cxgb4_dcb_state_fsm: bad state transition, state = %d, input = %d\n",
  current_state, transition_to);
}

/* Handle a DCB/DCBX update message from the firmware.
 */
void cxgb4_dcb_handle_fw_update(struct adapter *adap,
    const struct fw_port_cmd *pcmd)
{
 const union fw_port_dcb *fwdcb = &pcmd->u.dcb;
 int port = FW_PORT_CMD_PORTID_G(be32_to_cpu(pcmd->op_to_portid));
 struct net_device *dev = adap->port[adap->chan_map[port]];
 struct port_info *pi = netdev_priv(dev);
 struct port_dcb_info *dcb = &pi->dcb;
 int dcb_type = pcmd->u.dcb.pgid.type;
 int dcb_running_version;

 /* Handle Firmware DCB Control messages separately since they drive
 * our state machine.
 */
 if (dcb_type == FW_PORT_DCB_TYPE_CONTROL) {
  enum cxgb4_dcb_state_input input =
   ((pcmd->u.dcb.control.all_syncd_pkd &
     FW_PORT_CMD_ALL_SYNCD_F)
    ? CXGB4_DCB_INPUT_FW_ALLSYNCED
    : CXGB4_DCB_INPUT_FW_INCOMPLETE);

  if (dcb->dcb_version != FW_PORT_DCB_VER_UNKNOWN) {
   dcb_running_version = FW_PORT_CMD_DCB_VERSION_G(
    be16_to_cpu(
    pcmd->u.dcb.control.dcb_version_to_app_state));
   if (dcb_running_version == FW_PORT_DCB_VER_CEE1D01 ||
       dcb_running_version == FW_PORT_DCB_VER_IEEE) {
    dcb->dcb_version = dcb_running_version;
    dev_warn(adap->pdev_dev, "Interface %s is running %s\n",
      dev->name,
      dcb_ver_array[dcb->dcb_version]);
   } else {
    dev_warn(adap->pdev_dev,
      "Something screwed up, requested firmware for %s, but firmware returned %s instead\n",
      dcb_ver_array[dcb->dcb_version],
      dcb_ver_array[dcb_running_version]);
    dcb->dcb_version = FW_PORT_DCB_VER_UNKNOWN;
   }
  }

  cxgb4_dcb_state_fsm(dev, input);
  return;
 }

 /* It's weird, and almost certainly an error, to get Firmware DCB
 * messages when we either haven't been told whether we're going to be
 * doing Host or Firmware DCB; and even worse when we've been told
 * that we're doing Host DCB!
 */
 if (dcb->state == CXGB4_DCB_STATE_START ||
     dcb->state == CXGB4_DCB_STATE_HOST) {
  dev_err(adap->pdev_dev, "Receiving Firmware DCB messages in State %d\n",
   dcb->state);
  return;
 }

 /* Now handle the general Firmware DCB update messages ...
 */
 switch (dcb_type) {
 case FW_PORT_DCB_TYPE_PGID:
  dcb->pgid = be32_to_cpu(fwdcb->pgid.pgid);
  dcb->msgs |= CXGB4_DCB_FW_PGID;
  break;

 case FW_PORT_DCB_TYPE_PGRATE:
  dcb->pg_num_tcs_supported = fwdcb->pgrate.num_tcs_supported;
  memcpy(dcb->pgrate, &fwdcb->pgrate.pgrate,
         sizeof(dcb->pgrate));
  memcpy(dcb->tsa, &fwdcb->pgrate.tsa,
         sizeof(dcb->tsa));
  dcb->msgs |= CXGB4_DCB_FW_PGRATE;
  if (dcb->msgs & CXGB4_DCB_FW_PGID)
   IEEE_FAUX_SYNC(dev, dcb);
  break;

 case FW_PORT_DCB_TYPE_PRIORATE:
  memcpy(dcb->priorate, &fwdcb->priorate.strict_priorate,
         sizeof(dcb->priorate));
  dcb->msgs |= CXGB4_DCB_FW_PRIORATE;
  break;

 case FW_PORT_DCB_TYPE_PFC:
  dcb->pfcen = fwdcb->pfc.pfcen;
  dcb->pfc_num_tcs_supported = fwdcb->pfc.max_pfc_tcs;
  dcb->msgs |= CXGB4_DCB_FW_PFC;
  IEEE_FAUX_SYNC(dev, dcb);
  break;

 case FW_PORT_DCB_TYPE_APP_ID: {
  const struct fw_port_app_priority *fwap = &fwdcb->app_priority;
  int idx = fwap->idx;
  struct app_priority *ap = &dcb->app_priority[idx];

  struct dcb_app app = {
   .protocol = be16_to_cpu(fwap->protocolid),
  };
  int err;

  /* Convert from firmware format to relevant format
 * when using app selector
 */
  if (dcb->dcb_version == FW_PORT_DCB_VER_IEEE) {
   app.selector = (fwap->sel_field + 1);
   app.priority = ffs(fwap->user_prio_map) - 1;
   err = dcb_ieee_setapp(dev, &app);
   IEEE_FAUX_SYNC(dev, dcb);
  } else {
   /* Default is CEE */
   app.selector = !!(fwap->sel_field);
   app.priority = fwap->user_prio_map;
   err = dcb_setapp(dev, &app);
  }

  if (err)
   dev_err(adap->pdev_dev,
    "Failed DCB Set Application Priority: sel=%d, prot=%d, prio=%d, err=%d\n",
    app.selector, app.protocol, app.priority, -err);

  ap->user_prio_map = fwap->user_prio_map;
  ap->sel_field = fwap->sel_field;
  ap->protocolid = be16_to_cpu(fwap->protocolid);
  dcb->msgs |= CXGB4_DCB_FW_APP_ID;
  break;
 }

 default:
  dev_err(adap->pdev_dev, "Unknown DCB update type received %x\n",
   dcb_type);
  break;
 }
}

/* Data Center Bridging netlink operations.
 */


/* Get current DCB enabled/disabled state.
 */
static u8 cxgb4_getstate(struct net_device *dev)
{
 struct port_info *pi = netdev2pinfo(dev);

 return pi->dcb.enabled;
}

/* Set DCB enabled/disabled.
 */
static u8 cxgb4_setstate(struct net_device *dev, u8 enabled)
{
 struct port_info *pi = netdev2pinfo(dev);

 /* If DCBx is host-managed, dcb is enabled by outside lldp agents */
 if (pi->dcb.state == CXGB4_DCB_STATE_HOST) {
  pi->dcb.enabled = enabled;
  return 0;
 }

 /* Firmware doesn't provide any mechanism to control the DCB state.
 */
 if (enabled != (pi->dcb.state == CXGB4_DCB_STATE_FW_ALLSYNCED))
  return 1;

 return 0;
}

static void cxgb4_getpgtccfg(struct net_device *dev, int tc,
        u8 *prio_type, u8 *pgid, u8 *bw_per,
        u8 *up_tc_map, int local)
{
 struct fw_port_cmd pcmd;
 struct port_info *pi = netdev2pinfo(dev);
 struct adapter *adap = pi->adapter;
 int err;

 *prio_type = *pgid = *bw_per = *up_tc_map = 0;

 if (local)
  INIT_PORT_DCB_READ_LOCAL_CMD(pcmd, pi->port_id);
 else
  INIT_PORT_DCB_READ_PEER_CMD(pcmd, pi->port_id);

 pcmd.u.dcb.pgid.type = FW_PORT_DCB_TYPE_PGID;
 err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd);
 if (err != FW_PORT_DCB_CFG_SUCCESS) {
  dev_err(adap->pdev_dev, "DCB read PGID failed with %d\n", -err);
  return;
 }
 *pgid = (be32_to_cpu(pcmd.u.dcb.pgid.pgid) >> (tc * 4)) & 0xf;

 if (local)
  INIT_PORT_DCB_READ_LOCAL_CMD(pcmd, pi->port_id);
 else
  INIT_PORT_DCB_READ_PEER_CMD(pcmd, pi->port_id);
 pcmd.u.dcb.pgrate.type = FW_PORT_DCB_TYPE_PGRATE;
 err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd);
 if (err != FW_PORT_DCB_CFG_SUCCESS) {
  dev_err(adap->pdev_dev, "DCB read PGRATE failed with %d\n",
   -err);
  return;
 }

 *bw_per = pcmd.u.dcb.pgrate.pgrate[*pgid];
 *up_tc_map = (1 << tc);

 /* prio_type is link strict */
 if (*pgid != 0xF)
  *prio_type = 0x2;
}

static void cxgb4_getpgtccfg_tx(struct net_device *dev, int tc,
    u8 *prio_type, u8 *pgid, u8 *bw_per,
    u8 *up_tc_map)
{
 /* tc 0 is written at MSB position */
 return cxgb4_getpgtccfg(dev, (7 - tc), prio_type, pgid, bw_per,
    up_tc_map, 1);
}


static void cxgb4_getpgtccfg_rx(struct net_device *dev, int tc,
    u8 *prio_type, u8 *pgid, u8 *bw_per,
    u8 *up_tc_map)
{
 /* tc 0 is written at MSB position */
 return cxgb4_getpgtccfg(dev, (7 - tc), prio_type, pgid, bw_per,
    up_tc_map, 0);
}

static void cxgb4_setpgtccfg_tx(struct net_device *dev, int tc,
    u8 prio_type, u8 pgid, u8 bw_per,
    u8 up_tc_map)
{
 struct fw_port_cmd pcmd;
 struct port_info *pi = netdev2pinfo(dev);
 struct adapter *adap = pi->adapter;
 int fw_tc = 7 - tc;
 u32 _pgid;
 int err;

 if (pgid == DCB_ATTR_VALUE_UNDEFINED)
  return;
 if (bw_per == DCB_ATTR_VALUE_UNDEFINED)
  return;

 INIT_PORT_DCB_READ_LOCAL_CMD(pcmd, pi->port_id);
 pcmd.u.dcb.pgid.type = FW_PORT_DCB_TYPE_PGID;

 err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd);
 if (err != FW_PORT_DCB_CFG_SUCCESS) {
  dev_err(adap->pdev_dev, "DCB read PGID failed with %d\n", -err);
  return;
 }

 _pgid = be32_to_cpu(pcmd.u.dcb.pgid.pgid);
 _pgid &= ~(0xF << (fw_tc * 4));
 _pgid |= pgid << (fw_tc * 4);
 pcmd.u.dcb.pgid.pgid = cpu_to_be32(_pgid);

 INIT_PORT_DCB_WRITE_CMD(pcmd, pi->port_id);

 err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd);
 if (err != FW_PORT_DCB_CFG_SUCCESS) {
  dev_err(adap->pdev_dev, "DCB write PGID failed with %d\n",
   -err);
  return;
 }

 memset(&pcmd, 0, sizeof(struct fw_port_cmd));

 INIT_PORT_DCB_READ_LOCAL_CMD(pcmd, pi->port_id);
 pcmd.u.dcb.pgrate.type = FW_PORT_DCB_TYPE_PGRATE;

 err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd);
 if (err != FW_PORT_DCB_CFG_SUCCESS) {
  dev_err(adap->pdev_dev, "DCB read PGRATE failed with %d\n",
   -err);
  return;
 }

 pcmd.u.dcb.pgrate.pgrate[pgid] = bw_per;

 INIT_PORT_DCB_WRITE_CMD(pcmd, pi->port_id);
 if (pi->dcb.state == CXGB4_DCB_STATE_HOST)
  pcmd.op_to_portid |= cpu_to_be32(FW_PORT_CMD_APPLY_F);

 err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd);
 if (err != FW_PORT_DCB_CFG_SUCCESS)
  dev_err(adap->pdev_dev, "DCB write PGRATE failed with %d\n",
   -err);
}

static void cxgb4_getpgbwgcfg(struct net_device *dev, int pgid, u8 *bw_per,
         int local)
{
 struct fw_port_cmd pcmd;
 struct port_info *pi = netdev2pinfo(dev);
 struct adapter *adap = pi->adapter;
 int err;

 if (local)
  INIT_PORT_DCB_READ_LOCAL_CMD(pcmd, pi->port_id);
 else
  INIT_PORT_DCB_READ_PEER_CMD(pcmd, pi->port_id);

 pcmd.u.dcb.pgrate.type = FW_PORT_DCB_TYPE_PGRATE;
 err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd);
 if (err != FW_PORT_DCB_CFG_SUCCESS) {
  dev_err(adap->pdev_dev, "DCB read PGRATE failed with %d\n",
   -err);
  return;
 }

 *bw_per = pcmd.u.dcb.pgrate.pgrate[pgid];
}

static void cxgb4_getpgbwgcfg_tx(struct net_device *dev, int pgid, u8 *bw_per)
{
 return cxgb4_getpgbwgcfg(dev, pgid, bw_per, 1);
}

static void cxgb4_getpgbwgcfg_rx(struct net_device *dev, int pgid, u8 *bw_per)
{
 return cxgb4_getpgbwgcfg(dev, pgid, bw_per, 0);
}

static void cxgb4_setpgbwgcfg_tx(struct net_device *dev, int pgid,
     u8 bw_per)
{
 struct fw_port_cmd pcmd;
 struct port_info *pi = netdev2pinfo(dev);
 struct adapter *adap = pi->adapter;
 int err;

 INIT_PORT_DCB_READ_LOCAL_CMD(pcmd, pi->port_id);
 pcmd.u.dcb.pgrate.type = FW_PORT_DCB_TYPE_PGRATE;

 err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd);
 if (err != FW_PORT_DCB_CFG_SUCCESS) {
  dev_err(adap->pdev_dev, "DCB read PGRATE failed with %d\n",
   -err);
  return;
 }

 pcmd.u.dcb.pgrate.pgrate[pgid] = bw_per;

 INIT_PORT_DCB_WRITE_CMD(pcmd, pi->port_id);
 if (pi->dcb.state == CXGB4_DCB_STATE_HOST)
  pcmd.op_to_portid |= cpu_to_be32(FW_PORT_CMD_APPLY_F);

 err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd);

 if (err != FW_PORT_DCB_CFG_SUCCESS)
  dev_err(adap->pdev_dev, "DCB write PGRATE failed with %d\n",
   -err);
}

/* Return whether the specified Traffic Class Priority has Priority Pause
 * Frames enabled.
 */
static void cxgb4_getpfccfg(struct net_device *dev, int priority, u8 *pfccfg)
{
 struct port_info *pi = netdev2pinfo(dev);
 struct port_dcb_info *dcb = &pi->dcb;

 if (!cxgb4_dcb_state_synced(dcb->state) ||
     priority >= CXGB4_MAX_PRIORITY)
  *pfccfg = 0;
 else
  *pfccfg = (pi->dcb.pfcen >> (7 - priority)) & 1;
}

/* Enable/disable Priority Pause Frames for the specified Traffic Class
 * Priority.
 */
static void cxgb4_setpfccfg(struct net_device *dev, int priority, u8 pfccfg)
{
 struct fw_port_cmd pcmd;
 struct port_info *pi = netdev2pinfo(dev);
 struct adapter *adap = pi->adapter;
 int err;

 if (!cxgb4_dcb_state_synced(pi->dcb.state) ||
     priority >= CXGB4_MAX_PRIORITY)
  return;

 INIT_PORT_DCB_WRITE_CMD(pcmd, pi->port_id);
 if (pi->dcb.state == CXGB4_DCB_STATE_HOST)
  pcmd.op_to_portid |= cpu_to_be32(FW_PORT_CMD_APPLY_F);

 pcmd.u.dcb.pfc.type = FW_PORT_DCB_TYPE_PFC;
 pcmd.u.dcb.pfc.pfcen = pi->dcb.pfcen;

 if (pfccfg)
  pcmd.u.dcb.pfc.pfcen |= (1 << (7 - priority));
 else
  pcmd.u.dcb.pfc.pfcen &= (~(1 << (7 - priority)));

 err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd);
 if (err != FW_PORT_DCB_CFG_SUCCESS) {
  dev_err(adap->pdev_dev, "DCB PFC write failed with %d\n", -err);
  return;
 }

 pi->dcb.pfcen = pcmd.u.dcb.pfc.pfcen;
}

static u8 cxgb4_setall(struct net_device *dev)
{
 return 0;
}

/* Return DCB capabilities.
 */
static u8 cxgb4_getcap(struct net_device *dev, int cap_id, u8 *caps)
{
 struct port_info *pi = netdev2pinfo(dev);

 switch (cap_id) {
 case DCB_CAP_ATTR_PG:
 case DCB_CAP_ATTR_PFC:
  *caps = true;
  break;

 case DCB_CAP_ATTR_PG_TCS:
  /* 8 priorities for PG represented by bitmap */
  *caps = 0x80;
  break;

 case DCB_CAP_ATTR_PFC_TCS:
  /* 8 priorities for PFC represented by bitmap */
  *caps = 0x80;
  break;

 case DCB_CAP_ATTR_GSP:
  *caps = true;
  break;

 case DCB_CAP_ATTR_UP2TC:
 case DCB_CAP_ATTR_BCN:
  *caps = false;
  break;

 case DCB_CAP_ATTR_DCBX:
  *caps = pi->dcb.supported;
  break;

 default:
  *caps = false;
 }

 return 0;
}

/* Return the number of Traffic Classes for the indicated Traffic Class ID.
 */
static int cxgb4_getnumtcs(struct net_device *dev, int tcs_id, u8 *num)
{
 struct port_info *pi = netdev2pinfo(dev);

 switch (tcs_id) {
 case DCB_NUMTCS_ATTR_PG:
  if (pi->dcb.msgs & CXGB4_DCB_FW_PGRATE)
   *num = pi->dcb.pg_num_tcs_supported;
  else
   *num = 0x8;
  break;

 case DCB_NUMTCS_ATTR_PFC:
  *num = 0x8;
  break;

 default:
  return -EINVAL;
 }

 return 0;
}

/* Set the number of Traffic Classes supported for the indicated Traffic Class
 * ID.
 */
static int cxgb4_setnumtcs(struct net_device *dev, int tcs_id, u8 num)
{
 /* Setting the number of Traffic Classes isn't supported.
 */
 return -ENOSYS;
}

/* Return whether Priority Flow Control is enabled.  */
static u8 cxgb4_getpfcstate(struct net_device *dev)
{
 struct port_info *pi = netdev2pinfo(dev);

 if (!cxgb4_dcb_state_synced(pi->dcb.state))
  return false;

 return pi->dcb.pfcen != 0;
}

/* Enable/disable Priority Flow Control. */
static void cxgb4_setpfcstate(struct net_device *dev, u8 state)
{
 /* We can't enable/disable Priority Flow Control but we also can't
 * return an error ...
 */
}

/* Return the Application User Priority Map associated with the specified
 * Application ID.
 */
static int __cxgb4_getapp(struct net_device *dev, u8 app_idtype, u16 app_id,
     int peer)
{
 struct port_info *pi = netdev2pinfo(dev);
 struct adapter *adap = pi->adapter;
 int i;

 if (!cxgb4_dcb_state_synced(pi->dcb.state))
  return 0;

 for (i = 0; i < CXGB4_MAX_DCBX_APP_SUPPORTED; i++) {
  struct fw_port_cmd pcmd;
  int err;

  if (peer)
   INIT_PORT_DCB_READ_PEER_CMD(pcmd, pi->port_id);
  else
   INIT_PORT_DCB_READ_LOCAL_CMD(pcmd, pi->port_id);

  pcmd.u.dcb.app_priority.type = FW_PORT_DCB_TYPE_APP_ID;
  pcmd.u.dcb.app_priority.idx = i;

  err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd);
  if (err != FW_PORT_DCB_CFG_SUCCESS) {
   dev_err(adap->pdev_dev, "DCB APP read failed with %d\n",
    -err);
   return err;
  }
  if (be16_to_cpu(pcmd.u.dcb.app_priority.protocolid) == app_id)
   if (pcmd.u.dcb.app_priority.sel_field == app_idtype)
    return pcmd.u.dcb.app_priority.user_prio_map;

  /* exhausted app list */
  if (!pcmd.u.dcb.app_priority.protocolid)
   break;
 }

 return -EEXIST;
}

/* Return the Application User Priority Map associated with the specified
 * Application ID.
 */
static int cxgb4_getapp(struct net_device *dev, u8 app_idtype, u16 app_id)
{
 /* Convert app_idtype to firmware format before querying */
 return __cxgb4_getapp(dev, app_idtype == DCB_APP_IDTYPE_ETHTYPE ?
         app_idtype : 3, app_id, 0);
}

/* Write a new Application User Priority Map for the specified Application ID
 */
static int __cxgb4_setapp(struct net_device *dev, u8 app_idtype, u16 app_id,
     u8 app_prio)
{
 struct fw_port_cmd pcmd;
 struct port_info *pi = netdev2pinfo(dev);
 struct adapter *adap = pi->adapter;
 int i, err;


 if (!cxgb4_dcb_state_synced(pi->dcb.state))
  return -EINVAL;

 /* DCB info gets thrown away on link up */
 if (!netif_carrier_ok(dev))
  return -ENOLINK;

 for (i = 0; i < CXGB4_MAX_DCBX_APP_SUPPORTED; i++) {
  INIT_PORT_DCB_READ_LOCAL_CMD(pcmd, pi->port_id);
  pcmd.u.dcb.app_priority.type = FW_PORT_DCB_TYPE_APP_ID;
  pcmd.u.dcb.app_priority.idx = i;
  err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd);

  if (err != FW_PORT_DCB_CFG_SUCCESS) {
   dev_err(adap->pdev_dev, "DCB app table read failed with %d\n",
    -err);
   return err;
  }
  if (be16_to_cpu(pcmd.u.dcb.app_priority.protocolid) == app_id) {
   /* overwrite existing app table */
   pcmd.u.dcb.app_priority.protocolid = 0;
   break;
  }
  /* find first empty slot */
  if (!pcmd.u.dcb.app_priority.protocolid)
   break;
 }

 if (i == CXGB4_MAX_DCBX_APP_SUPPORTED) {
  /* no empty slots available */
  dev_err(adap->pdev_dev, "DCB app table full\n");
  return -EBUSY;
 }

 /* write out new app table entry */
 INIT_PORT_DCB_WRITE_CMD(pcmd, pi->port_id);
 if (pi->dcb.state == CXGB4_DCB_STATE_HOST)
  pcmd.op_to_portid |= cpu_to_be32(FW_PORT_CMD_APPLY_F);

 pcmd.u.dcb.app_priority.type = FW_PORT_DCB_TYPE_APP_ID;
 pcmd.u.dcb.app_priority.protocolid = cpu_to_be16(app_id);
 pcmd.u.dcb.app_priority.sel_field = app_idtype;
 pcmd.u.dcb.app_priority.user_prio_map = app_prio;
 pcmd.u.dcb.app_priority.idx = i;

 err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd);
 if (err != FW_PORT_DCB_CFG_SUCCESS) {
  dev_err(adap->pdev_dev, "DCB app table write failed with %d\n",
   -err);
  return err;
 }

 return 0;
}

/* Priority for CEE inside dcb_app is bitmask, with 0 being an invalid value */
static int cxgb4_setapp(struct net_device *dev, u8 app_idtype, u16 app_id,
   u8 app_prio)
{
 int ret;
 struct dcb_app app = {
  .selector = app_idtype,
  .protocol = app_id,
  .priority = app_prio,
 };

 if (app_idtype != DCB_APP_IDTYPE_ETHTYPE &&
     app_idtype != DCB_APP_IDTYPE_PORTNUM)
  return -EINVAL;

 /* Convert app_idtype to a format that firmware understands */
 ret = __cxgb4_setapp(dev, app_idtype == DCB_APP_IDTYPE_ETHTYPE ?
         app_idtype : 3, app_id, app_prio);
 if (ret)
  return ret;

 return dcb_setapp(dev, &app);
}

/* Return whether IEEE Data Center Bridging has been negotiated.
 */
static inline int
cxgb4_ieee_negotiation_complete(struct net_device *dev,
    enum cxgb4_dcb_fw_msgs dcb_subtype)
{
 struct port_info *pi = netdev2pinfo(dev);
 struct port_dcb_info *dcb = &pi->dcb;

 if (dcb->state == CXGB4_DCB_STATE_FW_ALLSYNCED)
  if (dcb_subtype && !(dcb->msgs & dcb_subtype))
   return 0;

 return (cxgb4_dcb_state_synced(dcb->state) &&
  (dcb->supported & DCB_CAP_DCBX_VER_IEEE));
}

static int cxgb4_ieee_read_ets(struct net_device *dev, struct ieee_ets *ets,
          int local)
{
 struct port_info *pi = netdev2pinfo(dev);
 struct port_dcb_info *dcb = &pi->dcb;
 struct adapter *adap = pi->adapter;
 uint32_t tc_info;
 struct fw_port_cmd pcmd;
 int i, bwg, err;

 if (!(dcb->msgs & (CXGB4_DCB_FW_PGID | CXGB4_DCB_FW_PGRATE)))
  return 0;

 ets->ets_cap =  dcb->pg_num_tcs_supported;

 if (local) {
  ets->willing = 1;
  INIT_PORT_DCB_READ_LOCAL_CMD(pcmd, pi->port_id);
 } else {
  INIT_PORT_DCB_READ_PEER_CMD(pcmd, pi->port_id);
 }

 pcmd.u.dcb.pgid.type = FW_PORT_DCB_TYPE_PGID;
 err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd);
 if (err != FW_PORT_DCB_CFG_SUCCESS) {
  dev_err(adap->pdev_dev, "DCB read PGID failed with %d\n", -err);
  return err;
 }

 tc_info = be32_to_cpu(pcmd.u.dcb.pgid.pgid);

 if (local)
  INIT_PORT_DCB_READ_LOCAL_CMD(pcmd, pi->port_id);
 else
  INIT_PORT_DCB_READ_PEER_CMD(pcmd, pi->port_id);

 pcmd.u.dcb.pgrate.type = FW_PORT_DCB_TYPE_PGRATE;
 err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd);
 if (err != FW_PORT_DCB_CFG_SUCCESS) {
  dev_err(adap->pdev_dev, "DCB read PGRATE failed with %d\n",
   -err);
  return err;
 }

 for (i = 0; i < IEEE_8021QAZ_MAX_TCS; i++) {
  bwg = (tc_info >> ((7 - i) * 4)) & 0xF;
  ets->prio_tc[i] = bwg;
  ets->tc_tx_bw[i] = pcmd.u.dcb.pgrate.pgrate[i];
  ets->tc_rx_bw[i] = ets->tc_tx_bw[i];
  ets->tc_tsa[i] = pcmd.u.dcb.pgrate.tsa[i];
 }

 return 0;
}

static int cxgb4_ieee_get_ets(struct net_device *dev, struct ieee_ets *ets)
{
 return cxgb4_ieee_read_ets(dev, ets, 1);
}

/* We reuse this for peer PFC as well, as we can't have it enabled one way */
static int cxgb4_ieee_get_pfc(struct net_device *dev, struct ieee_pfc *pfc)
{
 struct port_info *pi = netdev2pinfo(dev);
 struct port_dcb_info *dcb = &pi->dcb;

 memset(pfc, 0, sizeof(struct ieee_pfc));

 if (!(dcb->msgs & CXGB4_DCB_FW_PFC))
  return 0;

 pfc->pfc_cap = dcb->pfc_num_tcs_supported;
 pfc->pfc_en = bitswap_1(dcb->pfcen);

 return 0;
}

static int cxgb4_ieee_peer_ets(struct net_device *dev, struct ieee_ets *ets)
{
 return cxgb4_ieee_read_ets(dev, ets, 0);
}

/* Fill in the Application User Priority Map associated with the
 * specified Application.
 * Priority for IEEE dcb_app is an integer, with 0 being a valid value
 */
static int cxgb4_ieee_getapp(struct net_device *dev, struct dcb_app *app)
{
 int prio;

 if (!cxgb4_ieee_negotiation_complete(dev, CXGB4_DCB_FW_APP_ID))
  return -EINVAL;
 if (!(app->selector && app->protocol))
  return -EINVAL;

 /* Try querying firmware first, use firmware format */
 prio = __cxgb4_getapp(dev, app->selector - 1, app->protocol, 0);

 if (prio < 0)
  prio = dcb_ieee_getapp_mask(dev, app);

 app->priority = ffs(prio) - 1;
 return 0;
}

/* Write a new Application User Priority Map for the specified Application ID.
 * Priority for IEEE dcb_app is an integer, with 0 being a valid value
 */
static int cxgb4_ieee_setapp(struct net_device *dev, struct dcb_app *app)
{
 int ret;

 if (!cxgb4_ieee_negotiation_complete(dev, CXGB4_DCB_FW_APP_ID))
  return -EINVAL;
 if (!(app->selector && app->protocol))
  return -EINVAL;

 if (!(app->selector > IEEE_8021QAZ_APP_SEL_ETHERTYPE  &&
       app->selector < IEEE_8021QAZ_APP_SEL_ANY))
  return -EINVAL;

 /* change selector to a format that firmware understands */
 ret = __cxgb4_setapp(dev, app->selector - 1, app->protocol,
        (1 << app->priority));
 if (ret)
  return ret;

 return dcb_ieee_setapp(dev, app);
}

/* Return our DCBX parameters.
 */
static u8 cxgb4_getdcbx(struct net_device *dev)
{
 struct port_info *pi = netdev2pinfo(dev);

 /* This is already set by cxgb4_set_dcb_caps, so just return it */
 return pi->dcb.supported;
}

/* Set our DCBX parameters.
 */
static u8 cxgb4_setdcbx(struct net_device *dev, u8 dcb_request)
{
 struct port_info *pi = netdev2pinfo(dev);

 /* Filter out requests which exceed our capabilities.
 */
 if ((dcb_request & (CXGB4_DCBX_FW_SUPPORT | CXGB4_DCBX_HOST_SUPPORT))
     != dcb_request)
  return 1;

 /* Can't enable DCB if we haven't successfully negotiated it.
 */
 if (!cxgb4_dcb_state_synced(pi->dcb.state))
  return 1;

 /* There's currently no mechanism to allow for the firmware DCBX
 * negotiation to be changed from the Host Driver.  If the caller
 * requests exactly the same parameters that we already have then
 * we'll allow them to be successfully "set" ...
 */
 if (dcb_request != pi->dcb.supported)
  return 1;

 pi->dcb.supported = dcb_request;
 return 0;
}

static int cxgb4_getpeer_app(struct net_device *dev,
        struct dcb_peer_app_info *info, u16 *app_count)
{
 struct fw_port_cmd pcmd;
 struct port_info *pi = netdev2pinfo(dev);
 struct adapter *adap = pi->adapter;
 int i, err = 0;

 if (!cxgb4_dcb_state_synced(pi->dcb.state))
  return 1;

 info->willing = 0;
 info->error = 0;

 *app_count = 0;
 for (i = 0; i < CXGB4_MAX_DCBX_APP_SUPPORTED; i++) {
  INIT_PORT_DCB_READ_PEER_CMD(pcmd, pi->port_id);
  pcmd.u.dcb.app_priority.type = FW_PORT_DCB_TYPE_APP_ID;
  pcmd.u.dcb.app_priority.idx = *app_count;
  err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd);

  if (err != FW_PORT_DCB_CFG_SUCCESS) {
   dev_err(adap->pdev_dev, "DCB app table read failed with %d\n",
    -err);
   return err;
  }

  /* find first empty slot */
  if (!pcmd.u.dcb.app_priority.protocolid)
   break;
 }
 *app_count = i;
 return err;
}

static int cxgb4_getpeerapp_tbl(struct net_device *dev, struct dcb_app *table)
{
 struct fw_port_cmd pcmd;
 struct port_info *pi = netdev2pinfo(dev);
 struct adapter *adap = pi->adapter;
 int i, err = 0;

 if (!cxgb4_dcb_state_synced(pi->dcb.state))
  return 1;

 for (i = 0; i < CXGB4_MAX_DCBX_APP_SUPPORTED; i++) {
  INIT_PORT_DCB_READ_PEER_CMD(pcmd, pi->port_id);
  pcmd.u.dcb.app_priority.type = FW_PORT_DCB_TYPE_APP_ID;
  pcmd.u.dcb.app_priority.idx = i;
  err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd);

  if (err != FW_PORT_DCB_CFG_SUCCESS) {
   dev_err(adap->pdev_dev, "DCB app table read failed with %d\n",
    -err);
   return err;
  }

  /* find first empty slot */
  if (!pcmd.u.dcb.app_priority.protocolid)
   break;

  table[i].selector = (pcmd.u.dcb.app_priority.sel_field + 1);
  table[i].protocol =
   be16_to_cpu(pcmd.u.dcb.app_priority.protocolid);
  table[i].priority =
   ffs(pcmd.u.dcb.app_priority.user_prio_map) - 1;
 }
 return err;
}

/* Return Priority Group information.
 */
static int cxgb4_cee_peer_getpg(struct net_device *dev, struct cee_pg *pg)
{
 struct fw_port_cmd pcmd;
 struct port_info *pi = netdev2pinfo(dev);
 struct adapter *adap = pi->adapter;
 u32 pgid;
 int i, err;

 /* We're always "willing" -- the Switch Fabric always dictates the
 * DCBX parameters to us.
 */
 pg->willing = true;

 INIT_PORT_DCB_READ_PEER_CMD(pcmd, pi->port_id);
 pcmd.u.dcb.pgid.type = FW_PORT_DCB_TYPE_PGID;
 err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd);
 if (err != FW_PORT_DCB_CFG_SUCCESS) {
  dev_err(adap->pdev_dev, "DCB read PGID failed with %d\n", -err);
  return err;
 }
 pgid = be32_to_cpu(pcmd.u.dcb.pgid.pgid);

 for (i = 0; i < CXGB4_MAX_PRIORITY; i++)
  pg->prio_pg[7 - i] = (pgid >> (i * 4)) & 0xF;

 INIT_PORT_DCB_READ_PEER_CMD(pcmd, pi->port_id);
 pcmd.u.dcb.pgrate.type = FW_PORT_DCB_TYPE_PGRATE;
 err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd);
 if (err != FW_PORT_DCB_CFG_SUCCESS) {
  dev_err(adap->pdev_dev, "DCB read PGRATE failed with %d\n",
   -err);
  return err;
 }

 for (i = 0; i < CXGB4_MAX_PRIORITY; i++)
  pg->pg_bw[i] = pcmd.u.dcb.pgrate.pgrate[i];

 pg->tcs_supported = pcmd.u.dcb.pgrate.num_tcs_supported;

 return 0;
}

/* Return Priority Flow Control information.
 */
static int cxgb4_cee_peer_getpfc(struct net_device *dev, struct cee_pfc *pfc)
{
 struct port_info *pi = netdev2pinfo(dev);

 cxgb4_getnumtcs(dev, DCB_NUMTCS_ATTR_PFC, &(pfc->tcs_supported));

 /* Firmware sends this to us in a formwat that is a bit flipped version
 * of spec, correct it before we send it to host. This is taken care of
 * by bit shifting in other uses of pfcen
 */
 pfc->pfc_en = bitswap_1(pi->dcb.pfcen);

 pfc->tcs_supported = pi->dcb.pfc_num_tcs_supported;

 return 0;
}

const struct dcbnl_rtnl_ops cxgb4_dcb_ops = {
 .ieee_getets  = cxgb4_ieee_get_ets,
 .ieee_getpfc  = cxgb4_ieee_get_pfc,
 .ieee_getapp  = cxgb4_ieee_getapp,
 .ieee_setapp  = cxgb4_ieee_setapp,
 .ieee_peer_getets = cxgb4_ieee_peer_ets,
 .ieee_peer_getpfc = cxgb4_ieee_get_pfc,

 /* CEE std */
 .getstate  = cxgb4_getstate,
 .setstate  = cxgb4_setstate,
 .getpgtccfgtx  = cxgb4_getpgtccfg_tx,
 .getpgbwgcfgtx  = cxgb4_getpgbwgcfg_tx,
 .getpgtccfgrx  = cxgb4_getpgtccfg_rx,
 .getpgbwgcfgrx  = cxgb4_getpgbwgcfg_rx,
 .setpgtccfgtx  = cxgb4_setpgtccfg_tx,
 .setpgbwgcfgtx  = cxgb4_setpgbwgcfg_tx,
 .setpfccfg  = cxgb4_setpfccfg,
 .getpfccfg  = cxgb4_getpfccfg,
 .setall   = cxgb4_setall,
 .getcap   = cxgb4_getcap,
 .getnumtcs  = cxgb4_getnumtcs,
 .setnumtcs  = cxgb4_setnumtcs,
 .getpfcstate  = cxgb4_getpfcstate,
 .setpfcstate  = cxgb4_setpfcstate,
 .getapp   = cxgb4_getapp,
 .setapp   = cxgb4_setapp,

 /* DCBX configuration */
 .getdcbx  = cxgb4_getdcbx,
 .setdcbx  = cxgb4_setdcbx,

 /* peer apps */
 .peer_getappinfo = cxgb4_getpeer_app,
 .peer_getapptable = cxgb4_getpeerapp_tbl,

 /* CEE peer */
 .cee_peer_getpg  = cxgb4_cee_peer_getpg,
 .cee_peer_getpfc = cxgb4_cee_peer_getpfc,
};