1 // SPDX-License-Identifier: GPL-2.0 2 /* Copyright (c) 2019, Intel Corporation. */ 3 4 #include "ice_dcb_lib.h" 5 6 /** 7 * ice_vsi_cfg_netdev_tc - Setup the netdev TC configuration 8 * @vsi: the VSI being configured 9 * @ena_tc: TC map to be enabled 10 */ 11 void ice_vsi_cfg_netdev_tc(struct ice_vsi *vsi, u8 ena_tc) 12 { 13 struct net_device *netdev = vsi->netdev; 14 struct ice_pf *pf = vsi->back; 15 struct ice_dcbx_cfg *dcbcfg; 16 u8 netdev_tc; 17 int i; 18 19 if (!netdev) 20 return; 21 22 if (!ena_tc) { 23 netdev_reset_tc(netdev); 24 return; 25 } 26 27 if (netdev_set_num_tc(netdev, vsi->tc_cfg.numtc)) 28 return; 29 30 dcbcfg = &pf->hw.port_info->local_dcbx_cfg; 31 32 ice_for_each_traffic_class(i) 33 if (vsi->tc_cfg.ena_tc & BIT(i)) 34 netdev_set_tc_queue(netdev, 35 vsi->tc_cfg.tc_info[i].netdev_tc, 36 vsi->tc_cfg.tc_info[i].qcount_tx, 37 vsi->tc_cfg.tc_info[i].qoffset); 38 39 for (i = 0; i < ICE_MAX_USER_PRIORITY; i++) { 40 u8 ets_tc = dcbcfg->etscfg.prio_table[i]; 41 42 /* Get the mapped netdev TC# for the UP */ 43 netdev_tc = vsi->tc_cfg.tc_info[ets_tc].netdev_tc; 44 netdev_set_prio_tc_map(netdev, i, netdev_tc); 45 } 46 } 47 48 /** 49 * ice_dcb_get_ena_tc - return bitmap of enabled TCs 50 * @dcbcfg: DCB config to evaluate for enabled TCs 51 */ 52 u8 ice_dcb_get_ena_tc(struct ice_dcbx_cfg *dcbcfg) 53 { 54 u8 i, num_tc, ena_tc = 1; 55 56 num_tc = ice_dcb_get_num_tc(dcbcfg); 57 58 for (i = 0; i < num_tc; i++) 59 ena_tc |= BIT(i); 60 61 return ena_tc; 62 } 63 64 /** 65 * ice_dcb_get_num_tc - Get the number of TCs from DCBX config 66 * @dcbcfg: config to retrieve number of TCs from 67 */ 68 u8 ice_dcb_get_num_tc(struct ice_dcbx_cfg *dcbcfg) 69 { 70 bool tc_unused = false; 71 u8 num_tc = 0; 72 u8 ret = 0; 73 int i; 74 75 /* Scan the ETS Config Priority Table to find traffic classes 76 * enabled and create a bitmask of enabled TCs 77 */ 78 for (i = 0; i < CEE_DCBX_MAX_PRIO; i++) 79 num_tc |= BIT(dcbcfg->etscfg.prio_table[i]); 80 81 /* Scan bitmask for contiguous TCs starting with TC0 */ 82 for (i = 0; i < IEEE_8021QAZ_MAX_TCS; i++) { 83 if (num_tc & BIT(i)) { 84 if (!tc_unused) { 85 ret++; 86 } else { 87 pr_err("Non-contiguous TCs - Disabling DCB\n"); 88 return 1; 89 } 90 } else { 91 tc_unused = true; 92 } 93 } 94 95 /* There is always at least 1 TC */ 96 if (!ret) 97 ret = 1; 98 99 return ret; 100 } 101 102 /** 103 * ice_vsi_cfg_dcb_rings - Update rings to reflect DCB TC 104 * @vsi: VSI owner of rings being updated 105 */ 106 void ice_vsi_cfg_dcb_rings(struct ice_vsi *vsi) 107 { 108 struct ice_ring *tx_ring, *rx_ring; 109 u16 qoffset, qcount; 110 int i, n; 111 112 if (!test_bit(ICE_FLAG_DCB_ENA, vsi->back->flags)) { 113 /* Reset the TC information */ 114 for (i = 0; i < vsi->num_txq; i++) { 115 tx_ring = vsi->tx_rings[i]; 116 tx_ring->dcb_tc = 0; 117 } 118 for (i = 0; i < vsi->num_rxq; i++) { 119 rx_ring = vsi->rx_rings[i]; 120 rx_ring->dcb_tc = 0; 121 } 122 return; 123 } 124 125 ice_for_each_traffic_class(n) { 126 if (!(vsi->tc_cfg.ena_tc & BIT(n))) 127 break; 128 129 qoffset = vsi->tc_cfg.tc_info[n].qoffset; 130 qcount = vsi->tc_cfg.tc_info[n].qcount_tx; 131 for (i = qoffset; i < (qoffset + qcount); i++) { 132 tx_ring = vsi->tx_rings[i]; 133 rx_ring = vsi->rx_rings[i]; 134 tx_ring->dcb_tc = n; 135 rx_ring->dcb_tc = n; 136 } 137 } 138 } 139 140 /** 141 * ice_pf_dcb_recfg - Reconfigure all VEBs and VSIs 142 * @pf: pointer to the PF struct 143 * 144 * Assumed caller has already disabled all VSIs before 145 * calling this function. Reconfiguring DCB based on 146 * local_dcbx_cfg. 147 */ 148 static void ice_pf_dcb_recfg(struct ice_pf *pf) 149 { 150 struct ice_dcbx_cfg *dcbcfg = &pf->hw.port_info->local_dcbx_cfg; 151 u8 tc_map = 0; 152 int v, ret; 153 154 /* Update each VSI */ 155 ice_for_each_vsi(pf, v) { 156 if (!pf->vsi[v]) 157 continue; 158 159 if (pf->vsi[v]->type == ICE_VSI_PF) 160 tc_map = ice_dcb_get_ena_tc(dcbcfg); 161 else 162 tc_map = ICE_DFLT_TRAFFIC_CLASS; 163 164 ret = ice_vsi_cfg_tc(pf->vsi[v], tc_map); 165 if (ret) { 166 dev_err(&pf->pdev->dev, 167 "Failed to config TC for VSI index: %d\n", 168 pf->vsi[v]->idx); 169 continue; 170 } 171 172 ice_vsi_map_rings_to_vectors(pf->vsi[v]); 173 } 174 } 175 176 /** 177 * ice_pf_dcb_cfg - Apply new DCB configuration 178 * @pf: pointer to the PF struct 179 * @new_cfg: DCBX config to apply 180 * @locked: is the RTNL held 181 */ 182 static 183 int ice_pf_dcb_cfg(struct ice_pf *pf, struct ice_dcbx_cfg *new_cfg, bool locked) 184 { 185 struct ice_dcbx_cfg *old_cfg, *curr_cfg; 186 struct ice_aqc_port_ets_elem buf = { 0 }; 187 int ret = 0; 188 189 curr_cfg = &pf->hw.port_info->local_dcbx_cfg; 190 191 /* Enable DCB tagging only when more than one TC */ 192 if (ice_dcb_get_num_tc(new_cfg) > 1) { 193 dev_dbg(&pf->pdev->dev, "DCB tagging enabled (num TC > 1)\n"); 194 set_bit(ICE_FLAG_DCB_ENA, pf->flags); 195 } else { 196 dev_dbg(&pf->pdev->dev, "DCB tagging disabled (num TC = 1)\n"); 197 clear_bit(ICE_FLAG_DCB_ENA, pf->flags); 198 } 199 200 if (!memcmp(new_cfg, curr_cfg, sizeof(*new_cfg))) { 201 dev_dbg(&pf->pdev->dev, "No change in DCB config required\n"); 202 return ret; 203 } 204 205 /* Store old config in case FW config fails */ 206 old_cfg = devm_kzalloc(&pf->pdev->dev, sizeof(*old_cfg), GFP_KERNEL); 207 memcpy(old_cfg, curr_cfg, sizeof(*old_cfg)); 208 209 /* avoid race conditions by holding the lock while disabling and 210 * re-enabling the VSI 211 */ 212 if (!locked) 213 rtnl_lock(); 214 ice_pf_dis_all_vsi(pf, true); 215 216 memcpy(curr_cfg, new_cfg, sizeof(*curr_cfg)); 217 memcpy(&curr_cfg->etsrec, &curr_cfg->etscfg, sizeof(curr_cfg->etsrec)); 218 219 /* Only send new config to HW if we are in SW LLDP mode. Otherwise, 220 * the new config came from the HW in the first place. 221 */ 222 if (pf->hw.port_info->is_sw_lldp) { 223 ret = ice_set_dcb_cfg(pf->hw.port_info); 224 if (ret) { 225 dev_err(&pf->pdev->dev, "Set DCB Config failed\n"); 226 /* Restore previous settings to local config */ 227 memcpy(curr_cfg, old_cfg, sizeof(*curr_cfg)); 228 goto out; 229 } 230 } 231 232 ret = ice_query_port_ets(pf->hw.port_info, &buf, sizeof(buf), NULL); 233 if (ret) { 234 dev_err(&pf->pdev->dev, "Query Port ETS failed\n"); 235 goto out; 236 } 237 238 ice_pf_dcb_recfg(pf); 239 240 out: 241 ice_pf_ena_all_vsi(pf, true); 242 if (!locked) 243 rtnl_unlock(); 244 devm_kfree(&pf->pdev->dev, old_cfg); 245 return ret; 246 } 247 248 /** 249 * ice_cfg_etsrec_defaults - Set default ETS recommended DCB config 250 * @pi: port information structure 251 */ 252 static void ice_cfg_etsrec_defaults(struct ice_port_info *pi) 253 { 254 struct ice_dcbx_cfg *dcbcfg = &pi->local_dcbx_cfg; 255 u8 i; 256 257 /* Ensure ETS recommended DCB configuration is not already set */ 258 if (dcbcfg->etsrec.maxtcs) 259 return; 260 261 /* In CEE mode, set the default to 1 TC */ 262 dcbcfg->etsrec.maxtcs = 1; 263 for (i = 0; i < ICE_MAX_TRAFFIC_CLASS; i++) { 264 dcbcfg->etsrec.tcbwtable[i] = i ? 0 : 100; 265 dcbcfg->etsrec.tsatable[i] = i ? ICE_IEEE_TSA_STRICT : 266 ICE_IEEE_TSA_ETS; 267 } 268 } 269 270 /** 271 * ice_dcb_need_recfg - Check if DCB needs reconfig 272 * @pf: board private structure 273 * @old_cfg: current DCB config 274 * @new_cfg: new DCB config 275 */ 276 static bool 277 ice_dcb_need_recfg(struct ice_pf *pf, struct ice_dcbx_cfg *old_cfg, 278 struct ice_dcbx_cfg *new_cfg) 279 { 280 bool need_reconfig = false; 281 282 /* Check if ETS configuration has changed */ 283 if (memcmp(&new_cfg->etscfg, &old_cfg->etscfg, 284 sizeof(new_cfg->etscfg))) { 285 /* If Priority Table has changed reconfig is needed */ 286 if (memcmp(&new_cfg->etscfg.prio_table, 287 &old_cfg->etscfg.prio_table, 288 sizeof(new_cfg->etscfg.prio_table))) { 289 need_reconfig = true; 290 dev_dbg(&pf->pdev->dev, "ETS UP2TC changed.\n"); 291 } 292 293 if (memcmp(&new_cfg->etscfg.tcbwtable, 294 &old_cfg->etscfg.tcbwtable, 295 sizeof(new_cfg->etscfg.tcbwtable))) 296 dev_dbg(&pf->pdev->dev, "ETS TC BW Table changed.\n"); 297 298 if (memcmp(&new_cfg->etscfg.tsatable, 299 &old_cfg->etscfg.tsatable, 300 sizeof(new_cfg->etscfg.tsatable))) 301 dev_dbg(&pf->pdev->dev, "ETS TSA Table changed.\n"); 302 } 303 304 /* Check if PFC configuration has changed */ 305 if (memcmp(&new_cfg->pfc, &old_cfg->pfc, sizeof(new_cfg->pfc))) { 306 need_reconfig = true; 307 dev_dbg(&pf->pdev->dev, "PFC config change detected.\n"); 308 } 309 310 /* Check if APP Table has changed */ 311 if (memcmp(&new_cfg->app, &old_cfg->app, sizeof(new_cfg->app))) { 312 need_reconfig = true; 313 dev_dbg(&pf->pdev->dev, "APP Table change detected.\n"); 314 } 315 316 dev_dbg(&pf->pdev->dev, "dcb need_reconfig=%d\n", need_reconfig); 317 return need_reconfig; 318 } 319 320 /** 321 * ice_dcb_rebuild - rebuild DCB post reset 322 * @pf: physical function instance 323 */ 324 void ice_dcb_rebuild(struct ice_pf *pf) 325 { 326 struct ice_dcbx_cfg *local_dcbx_cfg, *desired_dcbx_cfg, *prev_cfg; 327 struct ice_aqc_port_ets_elem buf = { 0 }; 328 enum ice_status ret; 329 330 ret = ice_query_port_ets(pf->hw.port_info, &buf, sizeof(buf), NULL); 331 if (ret) { 332 dev_err(&pf->pdev->dev, "Query Port ETS failed\n"); 333 goto dcb_error; 334 } 335 336 /* If DCB was not enabled previously, we are done */ 337 if (!test_bit(ICE_FLAG_DCB_ENA, pf->flags)) 338 return; 339 340 local_dcbx_cfg = &pf->hw.port_info->local_dcbx_cfg; 341 desired_dcbx_cfg = &pf->hw.port_info->desired_dcbx_cfg; 342 343 /* Save current willing state and force FW to unwilling */ 344 local_dcbx_cfg->etscfg.willing = 0x0; 345 local_dcbx_cfg->pfc.willing = 0x0; 346 local_dcbx_cfg->app_mode = ICE_DCBX_APPS_NON_WILLING; 347 348 ice_cfg_etsrec_defaults(pf->hw.port_info); 349 ret = ice_set_dcb_cfg(pf->hw.port_info); 350 if (ret) { 351 dev_err(&pf->pdev->dev, "Failed to set DCB to unwilling\n"); 352 goto dcb_error; 353 } 354 355 /* Retrieve DCB config and ensure same as current in SW */ 356 prev_cfg = devm_kmemdup(&pf->pdev->dev, local_dcbx_cfg, 357 sizeof(*prev_cfg), GFP_KERNEL); 358 if (!prev_cfg) { 359 dev_err(&pf->pdev->dev, "Failed to alloc space for DCB cfg\n"); 360 goto dcb_error; 361 } 362 363 ice_init_dcb(&pf->hw, true); 364 if (pf->hw.port_info->dcbx_status == ICE_DCBX_STATUS_DIS) 365 pf->hw.port_info->is_sw_lldp = true; 366 else 367 pf->hw.port_info->is_sw_lldp = false; 368 369 if (ice_dcb_need_recfg(pf, prev_cfg, local_dcbx_cfg)) { 370 /* difference in cfg detected - disable DCB till next MIB */ 371 dev_err(&pf->pdev->dev, "Set local MIB not accurate\n"); 372 goto dcb_error; 373 } 374 375 /* fetched config congruent to previous configuration */ 376 devm_kfree(&pf->pdev->dev, prev_cfg); 377 378 /* Set the local desired config */ 379 if (local_dcbx_cfg->dcbx_mode == ICE_DCBX_MODE_CEE) 380 memcpy(local_dcbx_cfg, desired_dcbx_cfg, 381 sizeof(*local_dcbx_cfg)); 382 383 ice_cfg_etsrec_defaults(pf->hw.port_info); 384 ret = ice_set_dcb_cfg(pf->hw.port_info); 385 if (ret) { 386 dev_err(&pf->pdev->dev, "Failed to set desired config\n"); 387 goto dcb_error; 388 } 389 dev_info(&pf->pdev->dev, "DCB restored after reset\n"); 390 ret = ice_query_port_ets(pf->hw.port_info, &buf, sizeof(buf), NULL); 391 if (ret) { 392 dev_err(&pf->pdev->dev, "Query Port ETS failed\n"); 393 goto dcb_error; 394 } 395 396 return; 397 398 dcb_error: 399 dev_err(&pf->pdev->dev, "Disabling DCB until new settings occur\n"); 400 prev_cfg = devm_kzalloc(&pf->pdev->dev, sizeof(*prev_cfg), GFP_KERNEL); 401 prev_cfg->etscfg.willing = true; 402 prev_cfg->etscfg.tcbwtable[0] = ICE_TC_MAX_BW; 403 prev_cfg->etscfg.tsatable[0] = ICE_IEEE_TSA_ETS; 404 memcpy(&prev_cfg->etsrec, &prev_cfg->etscfg, sizeof(prev_cfg->etsrec)); 405 ice_pf_dcb_cfg(pf, prev_cfg, false); 406 devm_kfree(&pf->pdev->dev, prev_cfg); 407 } 408 409 /** 410 * ice_dcb_init_cfg - set the initial DCB config in SW 411 * @pf: PF to apply config to 412 * @locked: Is the RTNL held 413 */ 414 static int ice_dcb_init_cfg(struct ice_pf *pf, bool locked) 415 { 416 struct ice_dcbx_cfg *newcfg; 417 struct ice_port_info *pi; 418 int ret = 0; 419 420 pi = pf->hw.port_info; 421 newcfg = devm_kzalloc(&pf->pdev->dev, sizeof(*newcfg), GFP_KERNEL); 422 if (!newcfg) 423 return -ENOMEM; 424 425 memcpy(newcfg, &pi->local_dcbx_cfg, sizeof(*newcfg)); 426 memset(&pi->local_dcbx_cfg, 0, sizeof(*newcfg)); 427 428 dev_info(&pf->pdev->dev, "Configuring initial DCB values\n"); 429 if (ice_pf_dcb_cfg(pf, newcfg, locked)) 430 ret = -EINVAL; 431 432 devm_kfree(&pf->pdev->dev, newcfg); 433 434 return ret; 435 } 436 437 /** 438 * ice_dcb_sw_default_config - Apply a default DCB config 439 * @pf: PF to apply config to 440 * @locked: was this function called with RTNL held 441 */ 442 static int ice_dcb_sw_dflt_cfg(struct ice_pf *pf, bool locked) 443 { 444 struct ice_aqc_port_ets_elem buf = { 0 }; 445 struct ice_dcbx_cfg *dcbcfg; 446 struct ice_port_info *pi; 447 struct ice_hw *hw; 448 int ret; 449 450 hw = &pf->hw; 451 pi = hw->port_info; 452 dcbcfg = devm_kzalloc(&pf->pdev->dev, sizeof(*dcbcfg), GFP_KERNEL); 453 454 memset(dcbcfg, 0, sizeof(*dcbcfg)); 455 memset(&pi->local_dcbx_cfg, 0, sizeof(*dcbcfg)); 456 457 dcbcfg->etscfg.willing = 1; 458 dcbcfg->etscfg.maxtcs = hw->func_caps.common_cap.maxtc; 459 dcbcfg->etscfg.tcbwtable[0] = 100; 460 dcbcfg->etscfg.tsatable[0] = ICE_IEEE_TSA_ETS; 461 462 memcpy(&dcbcfg->etsrec, &dcbcfg->etscfg, 463 sizeof(dcbcfg->etsrec)); 464 dcbcfg->etsrec.willing = 0; 465 466 dcbcfg->pfc.willing = 1; 467 dcbcfg->pfc.pfccap = hw->func_caps.common_cap.maxtc; 468 469 dcbcfg->numapps = 1; 470 dcbcfg->app[0].selector = ICE_APP_SEL_ETHTYPE; 471 dcbcfg->app[0].priority = 3; 472 dcbcfg->app[0].prot_id = ICE_APP_PROT_ID_FCOE; 473 474 ret = ice_pf_dcb_cfg(pf, dcbcfg, locked); 475 devm_kfree(&pf->pdev->dev, dcbcfg); 476 if (ret) 477 return ret; 478 479 return ice_query_port_ets(pi, &buf, sizeof(buf), NULL); 480 } 481 482 /** 483 * ice_init_pf_dcb - initialize DCB for a PF 484 * @pf: PF to initialize DCB for 485 * @locked: Was function called with RTNL held 486 */ 487 int ice_init_pf_dcb(struct ice_pf *pf, bool locked) 488 { 489 struct device *dev = &pf->pdev->dev; 490 struct ice_port_info *port_info; 491 struct ice_hw *hw = &pf->hw; 492 int err; 493 494 port_info = hw->port_info; 495 496 err = ice_init_dcb(hw, false); 497 if (err && !port_info->is_sw_lldp) { 498 dev_err(&pf->pdev->dev, "Error initializing DCB %d\n", err); 499 goto dcb_init_err; 500 } 501 502 dev_info(&pf->pdev->dev, 503 "DCB is enabled in the hardware, max number of TCs supported on this port are %d\n", 504 pf->hw.func_caps.common_cap.maxtc); 505 if (err) { 506 /* FW LLDP is disabled, activate SW DCBX/LLDP mode */ 507 dev_info(&pf->pdev->dev, 508 "FW LLDP is disabled, DCBx/LLDP in SW mode.\n"); 509 clear_bit(ICE_FLAG_FW_LLDP_AGENT, pf->flags); 510 err = ice_dcb_sw_dflt_cfg(pf, locked); 511 if (err) { 512 dev_err(&pf->pdev->dev, 513 "Failed to set local DCB config %d\n", err); 514 err = -EIO; 515 goto dcb_init_err; 516 } 517 518 pf->dcbx_cap = DCB_CAP_DCBX_HOST | DCB_CAP_DCBX_VER_IEEE; 519 return 0; 520 } 521 522 set_bit(ICE_FLAG_FW_LLDP_AGENT, pf->flags); 523 524 /* DCBX in FW and LLDP enabled in FW */ 525 pf->dcbx_cap = DCB_CAP_DCBX_LLD_MANAGED | DCB_CAP_DCBX_VER_IEEE; 526 527 err = ice_dcb_init_cfg(pf, locked); 528 if (err) 529 goto dcb_init_err; 530 531 return err; 532 533 dcb_init_err: 534 dev_err(dev, "DCB init failed\n"); 535 return err; 536 } 537 538 /** 539 * ice_update_dcb_stats - Update DCB stats counters 540 * @pf: PF whose stats needs to be updated 541 */ 542 void ice_update_dcb_stats(struct ice_pf *pf) 543 { 544 struct ice_hw_port_stats *prev_ps, *cur_ps; 545 struct ice_hw *hw = &pf->hw; 546 u8 port; 547 int i; 548 549 port = hw->port_info->lport; 550 prev_ps = &pf->stats_prev; 551 cur_ps = &pf->stats; 552 553 for (i = 0; i < 8; i++) { 554 ice_stat_update32(hw, GLPRT_PXOFFRXC(port, i), 555 pf->stat_prev_loaded, 556 &prev_ps->priority_xoff_rx[i], 557 &cur_ps->priority_xoff_rx[i]); 558 ice_stat_update32(hw, GLPRT_PXONRXC(port, i), 559 pf->stat_prev_loaded, 560 &prev_ps->priority_xon_rx[i], 561 &cur_ps->priority_xon_rx[i]); 562 ice_stat_update32(hw, GLPRT_PXONTXC(port, i), 563 pf->stat_prev_loaded, 564 &prev_ps->priority_xon_tx[i], 565 &cur_ps->priority_xon_tx[i]); 566 ice_stat_update32(hw, GLPRT_PXOFFTXC(port, i), 567 pf->stat_prev_loaded, 568 &prev_ps->priority_xoff_tx[i], 569 &cur_ps->priority_xoff_tx[i]); 570 ice_stat_update32(hw, GLPRT_RXON2OFFCNT(port, i), 571 pf->stat_prev_loaded, 572 &prev_ps->priority_xon_2_xoff[i], 573 &cur_ps->priority_xon_2_xoff[i]); 574 } 575 } 576 577 /** 578 * ice_tx_prepare_vlan_flags_dcb - prepare VLAN tagging for DCB 579 * @tx_ring: ring to send buffer on 580 * @first: pointer to struct ice_tx_buf 581 */ 582 int 583 ice_tx_prepare_vlan_flags_dcb(struct ice_ring *tx_ring, 584 struct ice_tx_buf *first) 585 { 586 struct sk_buff *skb = first->skb; 587 588 if (!test_bit(ICE_FLAG_DCB_ENA, tx_ring->vsi->back->flags)) 589 return 0; 590 591 /* Insert 802.1p priority into VLAN header */ 592 if ((first->tx_flags & (ICE_TX_FLAGS_HW_VLAN | ICE_TX_FLAGS_SW_VLAN)) || 593 skb->priority != TC_PRIO_CONTROL) { 594 first->tx_flags &= ~ICE_TX_FLAGS_VLAN_PR_M; 595 /* Mask the lower 3 bits to set the 802.1p priority */ 596 first->tx_flags |= (skb->priority & 0x7) << 597 ICE_TX_FLAGS_VLAN_PR_S; 598 if (first->tx_flags & ICE_TX_FLAGS_SW_VLAN) { 599 struct vlan_ethhdr *vhdr; 600 int rc; 601 602 rc = skb_cow_head(skb, 0); 603 if (rc < 0) 604 return rc; 605 vhdr = (struct vlan_ethhdr *)skb->data; 606 vhdr->h_vlan_TCI = htons(first->tx_flags >> 607 ICE_TX_FLAGS_VLAN_S); 608 } else { 609 first->tx_flags |= ICE_TX_FLAGS_HW_VLAN; 610 } 611 } 612 613 return 0; 614 } 615 616 /** 617 * ice_dcb_process_lldp_set_mib_change - Process MIB change 618 * @pf: ptr to ice_pf 619 * @event: pointer to the admin queue receive event 620 */ 621 void 622 ice_dcb_process_lldp_set_mib_change(struct ice_pf *pf, 623 struct ice_rq_event_info *event) 624 { 625 struct ice_aqc_port_ets_elem buf = { 0 }; 626 struct ice_aqc_lldp_get_mib *mib; 627 struct ice_dcbx_cfg tmp_dcbx_cfg; 628 bool need_reconfig = false; 629 struct ice_port_info *pi; 630 u8 type; 631 int ret; 632 633 /* Not DCB capable or capability disabled */ 634 if (!(test_bit(ICE_FLAG_DCB_CAPABLE, pf->flags))) 635 return; 636 637 if (pf->dcbx_cap & DCB_CAP_DCBX_HOST) { 638 dev_dbg(&pf->pdev->dev, 639 "MIB Change Event in HOST mode\n"); 640 return; 641 } 642 643 pi = pf->hw.port_info; 644 mib = (struct ice_aqc_lldp_get_mib *)&event->desc.params.raw; 645 /* Ignore if event is not for Nearest Bridge */ 646 type = ((mib->type >> ICE_AQ_LLDP_BRID_TYPE_S) & 647 ICE_AQ_LLDP_BRID_TYPE_M); 648 dev_dbg(&pf->pdev->dev, "LLDP event MIB bridge type 0x%x\n", type); 649 if (type != ICE_AQ_LLDP_BRID_TYPE_NEAREST_BRID) 650 return; 651 652 /* Check MIB Type and return if event for Remote MIB update */ 653 type = mib->type & ICE_AQ_LLDP_MIB_TYPE_M; 654 dev_dbg(&pf->pdev->dev, 655 "LLDP event mib type %s\n", type ? "remote" : "local"); 656 if (type == ICE_AQ_LLDP_MIB_REMOTE) { 657 /* Update the remote cached instance and return */ 658 ret = ice_aq_get_dcb_cfg(pi->hw, ICE_AQ_LLDP_MIB_REMOTE, 659 ICE_AQ_LLDP_BRID_TYPE_NEAREST_BRID, 660 &pi->remote_dcbx_cfg); 661 if (ret) { 662 dev_err(&pf->pdev->dev, "Failed to get remote DCB config\n"); 663 return; 664 } 665 } 666 667 /* store the old configuration */ 668 tmp_dcbx_cfg = pf->hw.port_info->local_dcbx_cfg; 669 670 /* Reset the old DCBX configuration data */ 671 memset(&pi->local_dcbx_cfg, 0, sizeof(pi->local_dcbx_cfg)); 672 673 /* Get updated DCBX data from firmware */ 674 ret = ice_get_dcb_cfg(pf->hw.port_info); 675 if (ret) { 676 dev_err(&pf->pdev->dev, "Failed to get DCB config\n"); 677 return; 678 } 679 680 /* No change detected in DCBX configs */ 681 if (!memcmp(&tmp_dcbx_cfg, &pi->local_dcbx_cfg, sizeof(tmp_dcbx_cfg))) { 682 dev_dbg(&pf->pdev->dev, 683 "No change detected in DCBX configuration.\n"); 684 return; 685 } 686 687 need_reconfig = ice_dcb_need_recfg(pf, &tmp_dcbx_cfg, 688 &pi->local_dcbx_cfg); 689 if (!need_reconfig) 690 return; 691 692 /* Enable DCB tagging only when more than one TC */ 693 if (ice_dcb_get_num_tc(&pi->local_dcbx_cfg) > 1) { 694 dev_dbg(&pf->pdev->dev, "DCB tagging enabled (num TC > 1)\n"); 695 set_bit(ICE_FLAG_DCB_ENA, pf->flags); 696 } else { 697 dev_dbg(&pf->pdev->dev, "DCB tagging disabled (num TC = 1)\n"); 698 clear_bit(ICE_FLAG_DCB_ENA, pf->flags); 699 } 700 701 rtnl_lock(); 702 ice_pf_dis_all_vsi(pf, true); 703 704 ret = ice_query_port_ets(pf->hw.port_info, &buf, sizeof(buf), NULL); 705 if (ret) { 706 dev_err(&pf->pdev->dev, "Query Port ETS failed\n"); 707 rtnl_unlock(); 708 return; 709 } 710 711 /* changes in configuration update VSI */ 712 ice_pf_dcb_recfg(pf); 713 714 ice_pf_ena_all_vsi(pf, true); 715 rtnl_unlock(); 716 } 717