Author | Tokens | Token Proportion | Commits | Commit Proportion |
---|---|---|---|---|
Anish Bhatt | 5908 | 98.42% | 13 | 61.90% |
Ganesh Goudar | 76 | 1.27% | 2 | 9.52% |
Hariprasad Shenai | 12 | 0.20% | 2 | 9.52% |
Thomas Gleixner | 2 | 0.03% | 1 | 4.76% |
Lad Prabhakar | 2 | 0.03% | 1 | 4.76% |
Nathan Chancellor | 2 | 0.03% | 1 | 4.76% |
Li kunyu | 1 | 0.02% | 1 | 4.76% |
Total | 6003 | 21 |
// 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, };
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1