1 // SPDX-License-Identifier: GPL-2.0 2 /* Copyright (c) 2019, Intel Corporation. */ 3 4 #include "ice_dcb_lib.h" 5 #include "ice_dcb_nl.h" 6 7 /** 8 * ice_vsi_cfg_netdev_tc - Setup the netdev TC configuration 9 * @vsi: the VSI being configured 10 * @ena_tc: TC map to be enabled 11 */ 12 void ice_vsi_cfg_netdev_tc(struct ice_vsi *vsi, u8 ena_tc) 13 { 14 struct net_device *netdev = vsi->netdev; 15 struct ice_pf *pf = vsi->back; 16 struct ice_dcbx_cfg *dcbcfg; 17 u8 netdev_tc; 18 int i; 19 20 if (!netdev) 21 return; 22 23 if (!ena_tc) { 24 netdev_reset_tc(netdev); 25 return; 26 } 27 28 if (netdev_set_num_tc(netdev, vsi->tc_cfg.numtc)) 29 return; 30 31 dcbcfg = &pf->hw.port_info->qos_cfg.local_dcbx_cfg; 32 33 ice_for_each_traffic_class(i) 34 if (vsi->tc_cfg.ena_tc & BIT(i)) 35 netdev_set_tc_queue(netdev, 36 vsi->tc_cfg.tc_info[i].netdev_tc, 37 vsi->tc_cfg.tc_info[i].qcount_tx, 38 vsi->tc_cfg.tc_info[i].qoffset); 39 40 for (i = 0; i < ICE_MAX_USER_PRIORITY; i++) { 41 u8 ets_tc = dcbcfg->etscfg.prio_table[i]; 42 43 /* Get the mapped netdev TC# for the UP */ 44 netdev_tc = vsi->tc_cfg.tc_info[ets_tc].netdev_tc; 45 netdev_set_prio_tc_map(netdev, i, netdev_tc); 46 } 47 } 48 49 /** 50 * ice_dcb_get_ena_tc - return bitmap of enabled TCs 51 * @dcbcfg: DCB config to evaluate for enabled TCs 52 */ 53 u8 ice_dcb_get_ena_tc(struct ice_dcbx_cfg *dcbcfg) 54 { 55 u8 i, num_tc, ena_tc = 1; 56 57 num_tc = ice_dcb_get_num_tc(dcbcfg); 58 59 for (i = 0; i < num_tc; i++) 60 ena_tc |= BIT(i); 61 62 return ena_tc; 63 } 64 65 /** 66 * ice_is_pfc_causing_hung_q 67 * @pf: pointer to PF structure 68 * @txqueue: Tx queue which is supposedly hung queue 69 * 70 * find if PFC is causing the hung queue, if yes return true else false 71 */ 72 bool ice_is_pfc_causing_hung_q(struct ice_pf *pf, unsigned int txqueue) 73 { 74 u8 num_tcs = 0, i, tc, up_mapped_tc, up_in_tc = 0; 75 u64 ref_prio_xoff[ICE_MAX_UP]; 76 struct ice_vsi *vsi; 77 u32 up2tc; 78 79 vsi = ice_get_main_vsi(pf); 80 if (!vsi) 81 return false; 82 83 ice_for_each_traffic_class(i) 84 if (vsi->tc_cfg.ena_tc & BIT(i)) 85 num_tcs++; 86 87 /* first find out the TC to which the hung queue belongs to */ 88 for (tc = 0; tc < num_tcs - 1; tc++) 89 if (ice_find_q_in_range(vsi->tc_cfg.tc_info[tc].qoffset, 90 vsi->tc_cfg.tc_info[tc + 1].qoffset, 91 txqueue)) 92 break; 93 94 /* Build a bit map of all UPs associated to the suspect hung queue TC, 95 * so that we check for its counter increment. 96 */ 97 up2tc = rd32(&pf->hw, PRTDCB_TUP2TC); 98 for (i = 0; i < ICE_MAX_UP; i++) { 99 up_mapped_tc = (up2tc >> (i * 3)) & 0x7; 100 if (up_mapped_tc == tc) 101 up_in_tc |= BIT(i); 102 } 103 104 /* Now that we figured out that hung queue is PFC enabled, still the 105 * Tx timeout can be legitimate. So to make sure Tx timeout is 106 * absolutely caused by PFC storm, check if the counters are 107 * incrementing. 108 */ 109 for (i = 0; i < ICE_MAX_UP; i++) 110 if (up_in_tc & BIT(i)) 111 ref_prio_xoff[i] = pf->stats.priority_xoff_rx[i]; 112 113 ice_update_dcb_stats(pf); 114 115 for (i = 0; i < ICE_MAX_UP; i++) 116 if (up_in_tc & BIT(i)) 117 if (pf->stats.priority_xoff_rx[i] > ref_prio_xoff[i]) 118 return true; 119 120 return false; 121 } 122 123 /** 124 * ice_dcb_get_mode - gets the DCB mode 125 * @port_info: pointer to port info structure 126 * @host: if set it's HOST if not it's MANAGED 127 */ 128 static u8 ice_dcb_get_mode(struct ice_port_info *port_info, bool host) 129 { 130 u8 mode; 131 132 if (host) 133 mode = DCB_CAP_DCBX_HOST; 134 else 135 mode = DCB_CAP_DCBX_LLD_MANAGED; 136 137 if (port_info->qos_cfg.local_dcbx_cfg.dcbx_mode & ICE_DCBX_MODE_CEE) 138 return mode | DCB_CAP_DCBX_VER_CEE; 139 else 140 return mode | DCB_CAP_DCBX_VER_IEEE; 141 } 142 143 /** 144 * ice_dcb_get_num_tc - Get the number of TCs from DCBX config 145 * @dcbcfg: config to retrieve number of TCs from 146 */ 147 u8 ice_dcb_get_num_tc(struct ice_dcbx_cfg *dcbcfg) 148 { 149 bool tc_unused = false; 150 u8 num_tc = 0; 151 u8 ret = 0; 152 int i; 153 154 /* Scan the ETS Config Priority Table to find traffic classes 155 * enabled and create a bitmask of enabled TCs 156 */ 157 for (i = 0; i < CEE_DCBX_MAX_PRIO; i++) 158 num_tc |= BIT(dcbcfg->etscfg.prio_table[i]); 159 160 /* Scan bitmask for contiguous TCs starting with TC0 */ 161 for (i = 0; i < IEEE_8021QAZ_MAX_TCS; i++) { 162 if (num_tc & BIT(i)) { 163 if (!tc_unused) { 164 ret++; 165 } else { 166 pr_err("Non-contiguous TCs - Disabling DCB\n"); 167 return 1; 168 } 169 } else { 170 tc_unused = true; 171 } 172 } 173 174 /* There is always at least 1 TC */ 175 if (!ret) 176 ret = 1; 177 178 return ret; 179 } 180 181 /** 182 * ice_dcb_get_tc - Get the TC associated with the queue 183 * @vsi: ptr to the VSI 184 * @queue_index: queue number associated with VSI 185 */ 186 u8 ice_dcb_get_tc(struct ice_vsi *vsi, int queue_index) 187 { 188 return vsi->tx_rings[queue_index]->dcb_tc; 189 } 190 191 /** 192 * ice_vsi_cfg_dcb_rings - Update rings to reflect DCB TC 193 * @vsi: VSI owner of rings being updated 194 */ 195 void ice_vsi_cfg_dcb_rings(struct ice_vsi *vsi) 196 { 197 struct ice_ring *tx_ring, *rx_ring; 198 u16 qoffset, qcount; 199 int i, n; 200 201 if (!test_bit(ICE_FLAG_DCB_ENA, vsi->back->flags)) { 202 /* Reset the TC information */ 203 for (i = 0; i < vsi->num_txq; i++) { 204 tx_ring = vsi->tx_rings[i]; 205 tx_ring->dcb_tc = 0; 206 } 207 for (i = 0; i < vsi->num_rxq; i++) { 208 rx_ring = vsi->rx_rings[i]; 209 rx_ring->dcb_tc = 0; 210 } 211 return; 212 } 213 214 ice_for_each_traffic_class(n) { 215 if (!(vsi->tc_cfg.ena_tc & BIT(n))) 216 break; 217 218 qoffset = vsi->tc_cfg.tc_info[n].qoffset; 219 qcount = vsi->tc_cfg.tc_info[n].qcount_tx; 220 for (i = qoffset; i < (qoffset + qcount); i++) { 221 tx_ring = vsi->tx_rings[i]; 222 rx_ring = vsi->rx_rings[i]; 223 tx_ring->dcb_tc = n; 224 rx_ring->dcb_tc = n; 225 } 226 } 227 } 228 229 /** 230 * ice_dcb_bwchk - check if ETS bandwidth input parameters are correct 231 * @pf: pointer to the PF struct 232 * @dcbcfg: pointer to DCB config structure 233 */ 234 int ice_dcb_bwchk(struct ice_pf *pf, struct ice_dcbx_cfg *dcbcfg) 235 { 236 struct ice_dcb_ets_cfg *etscfg = &dcbcfg->etscfg; 237 u8 num_tc, total_bw = 0; 238 int i; 239 240 /* returns number of contigous TCs and 1 TC for non-contigous TCs, 241 * since at least 1 TC has to be configured 242 */ 243 num_tc = ice_dcb_get_num_tc(dcbcfg); 244 245 /* no bandwidth checks required if there's only one TC, so assign 246 * all bandwidth to TC0 and return 247 */ 248 if (num_tc == 1) { 249 etscfg->tcbwtable[0] = ICE_TC_MAX_BW; 250 return 0; 251 } 252 253 for (i = 0; i < num_tc; i++) 254 total_bw += etscfg->tcbwtable[i]; 255 256 if (!total_bw) { 257 etscfg->tcbwtable[0] = ICE_TC_MAX_BW; 258 } else if (total_bw != ICE_TC_MAX_BW) { 259 dev_err(ice_pf_to_dev(pf), "Invalid config, total bandwidth must equal 100\n"); 260 return -EINVAL; 261 } 262 263 return 0; 264 } 265 266 /** 267 * ice_pf_dcb_cfg - Apply new DCB configuration 268 * @pf: pointer to the PF struct 269 * @new_cfg: DCBX config to apply 270 * @locked: is the RTNL held 271 */ 272 int ice_pf_dcb_cfg(struct ice_pf *pf, struct ice_dcbx_cfg *new_cfg, bool locked) 273 { 274 struct ice_aqc_port_ets_elem buf = { 0 }; 275 struct ice_dcbx_cfg *old_cfg, *curr_cfg; 276 struct device *dev = ice_pf_to_dev(pf); 277 int ret = ICE_DCB_NO_HW_CHG; 278 struct ice_vsi *pf_vsi; 279 280 curr_cfg = &pf->hw.port_info->qos_cfg.local_dcbx_cfg; 281 282 /* FW does not care if change happened */ 283 if (!pf->hw.port_info->qos_cfg.is_sw_lldp) 284 ret = ICE_DCB_HW_CHG_RST; 285 286 /* Enable DCB tagging only when more than one TC */ 287 if (ice_dcb_get_num_tc(new_cfg) > 1) { 288 dev_dbg(dev, "DCB tagging enabled (num TC > 1)\n"); 289 set_bit(ICE_FLAG_DCB_ENA, pf->flags); 290 } else { 291 dev_dbg(dev, "DCB tagging disabled (num TC = 1)\n"); 292 clear_bit(ICE_FLAG_DCB_ENA, pf->flags); 293 } 294 295 if (!memcmp(new_cfg, curr_cfg, sizeof(*new_cfg))) { 296 dev_dbg(dev, "No change in DCB config required\n"); 297 return ret; 298 } 299 300 if (ice_dcb_bwchk(pf, new_cfg)) 301 return -EINVAL; 302 303 /* Store old config in case FW config fails */ 304 old_cfg = kmemdup(curr_cfg, sizeof(*old_cfg), GFP_KERNEL); 305 if (!old_cfg) 306 return -ENOMEM; 307 308 dev_info(dev, "Commit DCB Configuration to the hardware\n"); 309 pf_vsi = ice_get_main_vsi(pf); 310 if (!pf_vsi) { 311 dev_dbg(dev, "PF VSI doesn't exist\n"); 312 ret = -EINVAL; 313 goto free_cfg; 314 } 315 316 /* avoid race conditions by holding the lock while disabling and 317 * re-enabling the VSI 318 */ 319 if (!locked) 320 rtnl_lock(); 321 ice_dis_vsi(pf_vsi, true); 322 323 memcpy(curr_cfg, new_cfg, sizeof(*curr_cfg)); 324 memcpy(&curr_cfg->etsrec, &curr_cfg->etscfg, sizeof(curr_cfg->etsrec)); 325 memcpy(&new_cfg->etsrec, &curr_cfg->etscfg, sizeof(curr_cfg->etsrec)); 326 327 /* Only send new config to HW if we are in SW LLDP mode. Otherwise, 328 * the new config came from the HW in the first place. 329 */ 330 if (pf->hw.port_info->qos_cfg.is_sw_lldp) { 331 ret = ice_set_dcb_cfg(pf->hw.port_info); 332 if (ret) { 333 dev_err(dev, "Set DCB Config failed\n"); 334 /* Restore previous settings to local config */ 335 memcpy(curr_cfg, old_cfg, sizeof(*curr_cfg)); 336 goto out; 337 } 338 } 339 340 ret = ice_query_port_ets(pf->hw.port_info, &buf, sizeof(buf), NULL); 341 if (ret) { 342 dev_err(dev, "Query Port ETS failed\n"); 343 goto out; 344 } 345 346 ice_pf_dcb_recfg(pf); 347 348 out: 349 ice_ena_vsi(pf_vsi, true); 350 if (!locked) 351 rtnl_unlock(); 352 free_cfg: 353 kfree(old_cfg); 354 return ret; 355 } 356 357 /** 358 * ice_cfg_etsrec_defaults - Set default ETS recommended DCB config 359 * @pi: port information structure 360 */ 361 static void ice_cfg_etsrec_defaults(struct ice_port_info *pi) 362 { 363 struct ice_dcbx_cfg *dcbcfg = &pi->qos_cfg.local_dcbx_cfg; 364 u8 i; 365 366 /* Ensure ETS recommended DCB configuration is not already set */ 367 if (dcbcfg->etsrec.maxtcs) 368 return; 369 370 /* In CEE mode, set the default to 1 TC */ 371 dcbcfg->etsrec.maxtcs = 1; 372 for (i = 0; i < ICE_MAX_TRAFFIC_CLASS; i++) { 373 dcbcfg->etsrec.tcbwtable[i] = i ? 0 : 100; 374 dcbcfg->etsrec.tsatable[i] = i ? ICE_IEEE_TSA_STRICT : 375 ICE_IEEE_TSA_ETS; 376 } 377 } 378 379 /** 380 * ice_dcb_need_recfg - Check if DCB needs reconfig 381 * @pf: board private structure 382 * @old_cfg: current DCB config 383 * @new_cfg: new DCB config 384 */ 385 static bool 386 ice_dcb_need_recfg(struct ice_pf *pf, struct ice_dcbx_cfg *old_cfg, 387 struct ice_dcbx_cfg *new_cfg) 388 { 389 struct device *dev = ice_pf_to_dev(pf); 390 bool need_reconfig = false; 391 392 /* Check if ETS configuration has changed */ 393 if (memcmp(&new_cfg->etscfg, &old_cfg->etscfg, 394 sizeof(new_cfg->etscfg))) { 395 /* If Priority Table has changed reconfig is needed */ 396 if (memcmp(&new_cfg->etscfg.prio_table, 397 &old_cfg->etscfg.prio_table, 398 sizeof(new_cfg->etscfg.prio_table))) { 399 need_reconfig = true; 400 dev_dbg(dev, "ETS UP2TC changed.\n"); 401 } 402 403 if (memcmp(&new_cfg->etscfg.tcbwtable, 404 &old_cfg->etscfg.tcbwtable, 405 sizeof(new_cfg->etscfg.tcbwtable))) 406 dev_dbg(dev, "ETS TC BW Table changed.\n"); 407 408 if (memcmp(&new_cfg->etscfg.tsatable, 409 &old_cfg->etscfg.tsatable, 410 sizeof(new_cfg->etscfg.tsatable))) 411 dev_dbg(dev, "ETS TSA Table changed.\n"); 412 } 413 414 /* Check if PFC configuration has changed */ 415 if (memcmp(&new_cfg->pfc, &old_cfg->pfc, sizeof(new_cfg->pfc))) { 416 need_reconfig = true; 417 dev_dbg(dev, "PFC config change detected.\n"); 418 } 419 420 /* Check if APP Table has changed */ 421 if (memcmp(&new_cfg->app, &old_cfg->app, sizeof(new_cfg->app))) { 422 need_reconfig = true; 423 dev_dbg(dev, "APP Table change detected.\n"); 424 } 425 426 dev_dbg(dev, "dcb need_reconfig=%d\n", need_reconfig); 427 return need_reconfig; 428 } 429 430 /** 431 * ice_dcb_rebuild - rebuild DCB post reset 432 * @pf: physical function instance 433 */ 434 void ice_dcb_rebuild(struct ice_pf *pf) 435 { 436 struct ice_aqc_port_ets_elem buf = { 0 }; 437 struct device *dev = ice_pf_to_dev(pf); 438 struct ice_dcbx_cfg *err_cfg; 439 enum ice_status ret; 440 441 ret = ice_query_port_ets(pf->hw.port_info, &buf, sizeof(buf), NULL); 442 if (ret) { 443 dev_err(dev, "Query Port ETS failed\n"); 444 goto dcb_error; 445 } 446 447 mutex_lock(&pf->tc_mutex); 448 449 if (!pf->hw.port_info->qos_cfg.is_sw_lldp) 450 ice_cfg_etsrec_defaults(pf->hw.port_info); 451 452 ret = ice_set_dcb_cfg(pf->hw.port_info); 453 if (ret) { 454 dev_err(dev, "Failed to set DCB config in rebuild\n"); 455 goto dcb_error; 456 } 457 458 if (!pf->hw.port_info->qos_cfg.is_sw_lldp) { 459 ret = ice_cfg_lldp_mib_change(&pf->hw, true); 460 if (ret && !pf->hw.port_info->qos_cfg.is_sw_lldp) { 461 dev_err(dev, "Failed to register for MIB changes\n"); 462 goto dcb_error; 463 } 464 } 465 466 dev_info(dev, "DCB info restored\n"); 467 ret = ice_query_port_ets(pf->hw.port_info, &buf, sizeof(buf), NULL); 468 if (ret) { 469 dev_err(dev, "Query Port ETS failed\n"); 470 goto dcb_error; 471 } 472 473 mutex_unlock(&pf->tc_mutex); 474 475 return; 476 477 dcb_error: 478 dev_err(dev, "Disabling DCB until new settings occur\n"); 479 err_cfg = kzalloc(sizeof(*err_cfg), GFP_KERNEL); 480 if (!err_cfg) { 481 mutex_unlock(&pf->tc_mutex); 482 return; 483 } 484 485 err_cfg->etscfg.willing = true; 486 err_cfg->etscfg.tcbwtable[0] = ICE_TC_MAX_BW; 487 err_cfg->etscfg.tsatable[0] = ICE_IEEE_TSA_ETS; 488 memcpy(&err_cfg->etsrec, &err_cfg->etscfg, sizeof(err_cfg->etsrec)); 489 /* Coverity warns the return code of ice_pf_dcb_cfg() is not checked 490 * here as is done for other calls to that function. That check is 491 * not necessary since this is in this function's error cleanup path. 492 * Suppress the Coverity warning with the following comment... 493 */ 494 /* coverity[check_return] */ 495 ice_pf_dcb_cfg(pf, err_cfg, false); 496 kfree(err_cfg); 497 498 mutex_unlock(&pf->tc_mutex); 499 } 500 501 /** 502 * ice_dcb_init_cfg - set the initial DCB config in SW 503 * @pf: PF to apply config to 504 * @locked: Is the RTNL held 505 */ 506 static int ice_dcb_init_cfg(struct ice_pf *pf, bool locked) 507 { 508 struct ice_dcbx_cfg *newcfg; 509 struct ice_port_info *pi; 510 int ret = 0; 511 512 pi = pf->hw.port_info; 513 newcfg = kmemdup(&pi->qos_cfg.local_dcbx_cfg, sizeof(*newcfg), 514 GFP_KERNEL); 515 if (!newcfg) 516 return -ENOMEM; 517 518 memset(&pi->qos_cfg.local_dcbx_cfg, 0, sizeof(*newcfg)); 519 520 dev_info(ice_pf_to_dev(pf), "Configuring initial DCB values\n"); 521 if (ice_pf_dcb_cfg(pf, newcfg, locked)) 522 ret = -EINVAL; 523 524 kfree(newcfg); 525 526 return ret; 527 } 528 529 /** 530 * ice_dcb_sw_dflt_cfg - Apply a default DCB config 531 * @pf: PF to apply config to 532 * @ets_willing: configure ETS willing 533 * @locked: was this function called with RTNL held 534 */ 535 static int ice_dcb_sw_dflt_cfg(struct ice_pf *pf, bool ets_willing, bool locked) 536 { 537 struct ice_aqc_port_ets_elem buf = { 0 }; 538 struct ice_dcbx_cfg *dcbcfg; 539 struct ice_port_info *pi; 540 struct ice_hw *hw; 541 int ret; 542 543 hw = &pf->hw; 544 pi = hw->port_info; 545 dcbcfg = kzalloc(sizeof(*dcbcfg), GFP_KERNEL); 546 if (!dcbcfg) 547 return -ENOMEM; 548 549 memset(&pi->qos_cfg.local_dcbx_cfg, 0, sizeof(*dcbcfg)); 550 551 dcbcfg->etscfg.willing = ets_willing ? 1 : 0; 552 dcbcfg->etscfg.maxtcs = hw->func_caps.common_cap.maxtc; 553 dcbcfg->etscfg.tcbwtable[0] = 100; 554 dcbcfg->etscfg.tsatable[0] = ICE_IEEE_TSA_ETS; 555 556 memcpy(&dcbcfg->etsrec, &dcbcfg->etscfg, 557 sizeof(dcbcfg->etsrec)); 558 dcbcfg->etsrec.willing = 0; 559 560 dcbcfg->pfc.willing = 1; 561 dcbcfg->pfc.pfccap = hw->func_caps.common_cap.maxtc; 562 563 dcbcfg->numapps = 1; 564 dcbcfg->app[0].selector = ICE_APP_SEL_ETHTYPE; 565 dcbcfg->app[0].priority = 3; 566 dcbcfg->app[0].prot_id = ICE_APP_PROT_ID_FCOE; 567 568 ret = ice_pf_dcb_cfg(pf, dcbcfg, locked); 569 kfree(dcbcfg); 570 if (ret) 571 return ret; 572 573 return ice_query_port_ets(pi, &buf, sizeof(buf), NULL); 574 } 575 576 /** 577 * ice_dcb_tc_contig - Check that TCs are contiguous 578 * @prio_table: pointer to priority table 579 * 580 * Check if TCs begin with TC0 and are contiguous 581 */ 582 static bool ice_dcb_tc_contig(u8 *prio_table) 583 { 584 bool found_empty = false; 585 u8 used_tc = 0; 586 int i; 587 588 /* Create a bitmap of used TCs */ 589 for (i = 0; i < CEE_DCBX_MAX_PRIO; i++) 590 used_tc |= BIT(prio_table[i]); 591 592 for (i = 0; i < CEE_DCBX_MAX_PRIO; i++) { 593 if (used_tc & BIT(i)) { 594 if (found_empty) 595 return false; 596 } else { 597 found_empty = true; 598 } 599 } 600 601 return true; 602 } 603 604 /** 605 * ice_dcb_noncontig_cfg - Configure DCB for non-contiguous TCs 606 * @pf: pointer to the PF struct 607 * 608 * If non-contiguous TCs, then configure SW DCB with TC0 and ETS non-willing 609 */ 610 static int ice_dcb_noncontig_cfg(struct ice_pf *pf) 611 { 612 struct ice_dcbx_cfg *dcbcfg = &pf->hw.port_info->qos_cfg.local_dcbx_cfg; 613 struct device *dev = ice_pf_to_dev(pf); 614 int ret; 615 616 /* Configure SW DCB default with ETS non-willing */ 617 ret = ice_dcb_sw_dflt_cfg(pf, false, true); 618 if (ret) { 619 dev_err(dev, "Failed to set local DCB config %d\n", ret); 620 return ret; 621 } 622 623 /* Reconfigure with ETS willing so that FW will send LLDP MIB event */ 624 dcbcfg->etscfg.willing = 1; 625 ret = ice_set_dcb_cfg(pf->hw.port_info); 626 if (ret) 627 dev_err(dev, "Failed to set DCB to unwilling\n"); 628 629 return ret; 630 } 631 632 /** 633 * ice_pf_dcb_recfg - Reconfigure all VEBs and VSIs 634 * @pf: pointer to the PF struct 635 * 636 * Assumed caller has already disabled all VSIs before 637 * calling this function. Reconfiguring DCB based on 638 * local_dcbx_cfg. 639 */ 640 void ice_pf_dcb_recfg(struct ice_pf *pf) 641 { 642 struct ice_dcbx_cfg *dcbcfg = &pf->hw.port_info->qos_cfg.local_dcbx_cfg; 643 u8 tc_map = 0; 644 int v, ret; 645 646 /* Update each VSI */ 647 ice_for_each_vsi(pf, v) { 648 struct ice_vsi *vsi = pf->vsi[v]; 649 650 if (!vsi) 651 continue; 652 653 if (vsi->type == ICE_VSI_PF) { 654 tc_map = ice_dcb_get_ena_tc(dcbcfg); 655 656 /* If DCBX request non-contiguous TC, then configure 657 * default TC 658 */ 659 if (!ice_dcb_tc_contig(dcbcfg->etscfg.prio_table)) { 660 tc_map = ICE_DFLT_TRAFFIC_CLASS; 661 ice_dcb_noncontig_cfg(pf); 662 } 663 } else { 664 tc_map = ICE_DFLT_TRAFFIC_CLASS; 665 } 666 667 ret = ice_vsi_cfg_tc(vsi, tc_map); 668 if (ret) { 669 dev_err(ice_pf_to_dev(pf), "Failed to config TC for VSI index: %d\n", 670 vsi->idx); 671 continue; 672 } 673 674 ice_vsi_map_rings_to_vectors(vsi); 675 if (vsi->type == ICE_VSI_PF) 676 ice_dcbnl_set_all(vsi); 677 } 678 } 679 680 /** 681 * ice_init_pf_dcb - initialize DCB for a PF 682 * @pf: PF to initialize DCB for 683 * @locked: Was function called with RTNL held 684 */ 685 int ice_init_pf_dcb(struct ice_pf *pf, bool locked) 686 { 687 struct device *dev = ice_pf_to_dev(pf); 688 struct ice_port_info *port_info; 689 struct ice_hw *hw = &pf->hw; 690 int err; 691 692 port_info = hw->port_info; 693 694 err = ice_init_dcb(hw, false); 695 if (err && !port_info->qos_cfg.is_sw_lldp) { 696 dev_err(dev, "Error initializing DCB %d\n", err); 697 goto dcb_init_err; 698 } 699 700 dev_info(dev, "DCB is enabled in the hardware, max number of TCs supported on this port are %d\n", 701 pf->hw.func_caps.common_cap.maxtc); 702 if (err) { 703 struct ice_vsi *pf_vsi; 704 705 /* FW LLDP is disabled, activate SW DCBX/LLDP mode */ 706 dev_info(dev, "FW LLDP is disabled, DCBx/LLDP in SW mode.\n"); 707 clear_bit(ICE_FLAG_FW_LLDP_AGENT, pf->flags); 708 err = ice_dcb_sw_dflt_cfg(pf, true, locked); 709 if (err) { 710 dev_err(dev, "Failed to set local DCB config %d\n", 711 err); 712 err = -EIO; 713 goto dcb_init_err; 714 } 715 716 /* If the FW DCBX engine is not running then Rx LLDP packets 717 * need to be redirected up the stack. 718 */ 719 pf_vsi = ice_get_main_vsi(pf); 720 if (!pf_vsi) { 721 dev_err(dev, "Failed to set local DCB config\n"); 722 err = -EIO; 723 goto dcb_init_err; 724 } 725 726 ice_cfg_sw_lldp(pf_vsi, false, true); 727 728 pf->dcbx_cap = ice_dcb_get_mode(port_info, true); 729 return 0; 730 } 731 732 set_bit(ICE_FLAG_FW_LLDP_AGENT, pf->flags); 733 734 /* DCBX/LLDP enabled in FW, set DCBNL mode advertisement */ 735 pf->dcbx_cap = ice_dcb_get_mode(port_info, false); 736 737 err = ice_dcb_init_cfg(pf, locked); 738 if (err) 739 goto dcb_init_err; 740 741 return err; 742 743 dcb_init_err: 744 dev_err(dev, "DCB init failed\n"); 745 return err; 746 } 747 748 /** 749 * ice_update_dcb_stats - Update DCB stats counters 750 * @pf: PF whose stats needs to be updated 751 */ 752 void ice_update_dcb_stats(struct ice_pf *pf) 753 { 754 struct ice_hw_port_stats *prev_ps, *cur_ps; 755 struct ice_hw *hw = &pf->hw; 756 u8 port; 757 int i; 758 759 port = hw->port_info->lport; 760 prev_ps = &pf->stats_prev; 761 cur_ps = &pf->stats; 762 763 for (i = 0; i < 8; i++) { 764 ice_stat_update32(hw, GLPRT_PXOFFRXC(port, i), 765 pf->stat_prev_loaded, 766 &prev_ps->priority_xoff_rx[i], 767 &cur_ps->priority_xoff_rx[i]); 768 ice_stat_update32(hw, GLPRT_PXONRXC(port, i), 769 pf->stat_prev_loaded, 770 &prev_ps->priority_xon_rx[i], 771 &cur_ps->priority_xon_rx[i]); 772 ice_stat_update32(hw, GLPRT_PXONTXC(port, i), 773 pf->stat_prev_loaded, 774 &prev_ps->priority_xon_tx[i], 775 &cur_ps->priority_xon_tx[i]); 776 ice_stat_update32(hw, GLPRT_PXOFFTXC(port, i), 777 pf->stat_prev_loaded, 778 &prev_ps->priority_xoff_tx[i], 779 &cur_ps->priority_xoff_tx[i]); 780 ice_stat_update32(hw, GLPRT_RXON2OFFCNT(port, i), 781 pf->stat_prev_loaded, 782 &prev_ps->priority_xon_2_xoff[i], 783 &cur_ps->priority_xon_2_xoff[i]); 784 } 785 } 786 787 /** 788 * ice_tx_prepare_vlan_flags_dcb - prepare VLAN tagging for DCB 789 * @tx_ring: ring to send buffer on 790 * @first: pointer to struct ice_tx_buf 791 * 792 * This should not be called if the outer VLAN is software offloaded as the VLAN 793 * tag will already be configured with the correct ID and priority bits 794 */ 795 void 796 ice_tx_prepare_vlan_flags_dcb(struct ice_ring *tx_ring, 797 struct ice_tx_buf *first) 798 { 799 struct sk_buff *skb = first->skb; 800 801 if (!test_bit(ICE_FLAG_DCB_ENA, tx_ring->vsi->back->flags)) 802 return; 803 804 /* Insert 802.1p priority into VLAN header */ 805 if ((first->tx_flags & ICE_TX_FLAGS_HW_VLAN) || 806 skb->priority != TC_PRIO_CONTROL) { 807 first->tx_flags &= ~ICE_TX_FLAGS_VLAN_PR_M; 808 /* Mask the lower 3 bits to set the 802.1p priority */ 809 first->tx_flags |= (skb->priority & 0x7) << 810 ICE_TX_FLAGS_VLAN_PR_S; 811 /* if this is not already set it means a VLAN 0 + priority needs 812 * to be offloaded 813 */ 814 first->tx_flags |= ICE_TX_FLAGS_HW_VLAN; 815 } 816 } 817 818 /** 819 * ice_dcb_process_lldp_set_mib_change - Process MIB change 820 * @pf: ptr to ice_pf 821 * @event: pointer to the admin queue receive event 822 */ 823 void 824 ice_dcb_process_lldp_set_mib_change(struct ice_pf *pf, 825 struct ice_rq_event_info *event) 826 { 827 struct ice_aqc_port_ets_elem buf = { 0 }; 828 struct device *dev = ice_pf_to_dev(pf); 829 struct ice_aqc_lldp_get_mib *mib; 830 struct ice_dcbx_cfg tmp_dcbx_cfg; 831 bool need_reconfig = false; 832 struct ice_port_info *pi; 833 struct ice_vsi *pf_vsi; 834 u8 mib_type; 835 int ret; 836 837 /* Not DCB capable or capability disabled */ 838 if (!(test_bit(ICE_FLAG_DCB_CAPABLE, pf->flags))) 839 return; 840 841 if (pf->dcbx_cap & DCB_CAP_DCBX_HOST) { 842 dev_dbg(dev, "MIB Change Event in HOST mode\n"); 843 return; 844 } 845 846 pi = pf->hw.port_info; 847 mib = (struct ice_aqc_lldp_get_mib *)&event->desc.params.raw; 848 /* Ignore if event is not for Nearest Bridge */ 849 mib_type = ((mib->type >> ICE_AQ_LLDP_BRID_TYPE_S) & 850 ICE_AQ_LLDP_BRID_TYPE_M); 851 dev_dbg(dev, "LLDP event MIB bridge type 0x%x\n", mib_type); 852 if (mib_type != ICE_AQ_LLDP_BRID_TYPE_NEAREST_BRID) 853 return; 854 855 /* Check MIB Type and return if event for Remote MIB update */ 856 mib_type = mib->type & ICE_AQ_LLDP_MIB_TYPE_M; 857 dev_dbg(dev, "LLDP event mib type %s\n", mib_type ? "remote" : "local"); 858 if (mib_type == ICE_AQ_LLDP_MIB_REMOTE) { 859 /* Update the remote cached instance and return */ 860 ret = ice_aq_get_dcb_cfg(pi->hw, ICE_AQ_LLDP_MIB_REMOTE, 861 ICE_AQ_LLDP_BRID_TYPE_NEAREST_BRID, 862 &pi->qos_cfg.remote_dcbx_cfg); 863 if (ret) { 864 dev_err(dev, "Failed to get remote DCB config\n"); 865 return; 866 } 867 } 868 869 mutex_lock(&pf->tc_mutex); 870 871 /* store the old configuration */ 872 tmp_dcbx_cfg = pf->hw.port_info->qos_cfg.local_dcbx_cfg; 873 874 /* Reset the old DCBX configuration data */ 875 memset(&pi->qos_cfg.local_dcbx_cfg, 0, 876 sizeof(pi->qos_cfg.local_dcbx_cfg)); 877 878 /* Get updated DCBX data from firmware */ 879 ret = ice_get_dcb_cfg(pf->hw.port_info); 880 if (ret) { 881 dev_err(dev, "Failed to get DCB config\n"); 882 goto out; 883 } 884 885 /* No change detected in DCBX configs */ 886 if (!memcmp(&tmp_dcbx_cfg, &pi->qos_cfg.local_dcbx_cfg, 887 sizeof(tmp_dcbx_cfg))) { 888 dev_dbg(dev, "No change detected in DCBX configuration.\n"); 889 goto out; 890 } 891 892 pf->dcbx_cap = ice_dcb_get_mode(pi, false); 893 894 need_reconfig = ice_dcb_need_recfg(pf, &tmp_dcbx_cfg, 895 &pi->qos_cfg.local_dcbx_cfg); 896 ice_dcbnl_flush_apps(pf, &tmp_dcbx_cfg, &pi->qos_cfg.local_dcbx_cfg); 897 if (!need_reconfig) 898 goto out; 899 900 /* Enable DCB tagging only when more than one TC */ 901 if (ice_dcb_get_num_tc(&pi->qos_cfg.local_dcbx_cfg) > 1) { 902 dev_dbg(dev, "DCB tagging enabled (num TC > 1)\n"); 903 set_bit(ICE_FLAG_DCB_ENA, pf->flags); 904 } else { 905 dev_dbg(dev, "DCB tagging disabled (num TC = 1)\n"); 906 clear_bit(ICE_FLAG_DCB_ENA, pf->flags); 907 } 908 909 pf_vsi = ice_get_main_vsi(pf); 910 if (!pf_vsi) { 911 dev_dbg(dev, "PF VSI doesn't exist\n"); 912 goto out; 913 } 914 915 rtnl_lock(); 916 ice_dis_vsi(pf_vsi, true); 917 918 ret = ice_query_port_ets(pf->hw.port_info, &buf, sizeof(buf), NULL); 919 if (ret) { 920 dev_err(dev, "Query Port ETS failed\n"); 921 goto unlock_rtnl; 922 } 923 924 /* changes in configuration update VSI */ 925 ice_pf_dcb_recfg(pf); 926 927 ice_ena_vsi(pf_vsi, true); 928 unlock_rtnl: 929 rtnl_unlock(); 930 out: 931 mutex_unlock(&pf->tc_mutex); 932 } 933