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 iidc_event *event; 279 struct ice_vsi *pf_vsi; 280 281 curr_cfg = &pf->hw.port_info->qos_cfg.local_dcbx_cfg; 282 283 /* FW does not care if change happened */ 284 if (!pf->hw.port_info->qos_cfg.is_sw_lldp) 285 ret = ICE_DCB_HW_CHG_RST; 286 287 /* Enable DCB tagging only when more than one TC */ 288 if (ice_dcb_get_num_tc(new_cfg) > 1) { 289 dev_dbg(dev, "DCB tagging enabled (num TC > 1)\n"); 290 set_bit(ICE_FLAG_DCB_ENA, pf->flags); 291 } else { 292 dev_dbg(dev, "DCB tagging disabled (num TC = 1)\n"); 293 clear_bit(ICE_FLAG_DCB_ENA, pf->flags); 294 } 295 296 if (!memcmp(new_cfg, curr_cfg, sizeof(*new_cfg))) { 297 dev_dbg(dev, "No change in DCB config required\n"); 298 return ret; 299 } 300 301 if (ice_dcb_bwchk(pf, new_cfg)) 302 return -EINVAL; 303 304 /* Store old config in case FW config fails */ 305 old_cfg = kmemdup(curr_cfg, sizeof(*old_cfg), GFP_KERNEL); 306 if (!old_cfg) 307 return -ENOMEM; 308 309 dev_info(dev, "Commit DCB Configuration to the hardware\n"); 310 pf_vsi = ice_get_main_vsi(pf); 311 if (!pf_vsi) { 312 dev_dbg(dev, "PF VSI doesn't exist\n"); 313 ret = -EINVAL; 314 goto free_cfg; 315 } 316 317 /* Notify AUX drivers about impending change to TCs */ 318 event = kzalloc(sizeof(*event), GFP_KERNEL); 319 if (!event) { 320 ret = -ENOMEM; 321 goto free_cfg; 322 } 323 324 set_bit(IIDC_EVENT_BEFORE_TC_CHANGE, event->type); 325 ice_send_event_to_aux(pf, event); 326 kfree(event); 327 328 /* avoid race conditions by holding the lock while disabling and 329 * re-enabling the VSI 330 */ 331 if (!locked) 332 rtnl_lock(); 333 ice_dis_vsi(pf_vsi, true); 334 335 memcpy(curr_cfg, new_cfg, sizeof(*curr_cfg)); 336 memcpy(&curr_cfg->etsrec, &curr_cfg->etscfg, sizeof(curr_cfg->etsrec)); 337 memcpy(&new_cfg->etsrec, &curr_cfg->etscfg, sizeof(curr_cfg->etsrec)); 338 339 /* Only send new config to HW if we are in SW LLDP mode. Otherwise, 340 * the new config came from the HW in the first place. 341 */ 342 if (pf->hw.port_info->qos_cfg.is_sw_lldp) { 343 ret = ice_set_dcb_cfg(pf->hw.port_info); 344 if (ret) { 345 dev_err(dev, "Set DCB Config failed\n"); 346 /* Restore previous settings to local config */ 347 memcpy(curr_cfg, old_cfg, sizeof(*curr_cfg)); 348 goto out; 349 } 350 } 351 352 ret = ice_query_port_ets(pf->hw.port_info, &buf, sizeof(buf), NULL); 353 if (ret) { 354 dev_err(dev, "Query Port ETS failed\n"); 355 goto out; 356 } 357 358 ice_pf_dcb_recfg(pf); 359 360 out: 361 ice_ena_vsi(pf_vsi, true); 362 if (!locked) 363 rtnl_unlock(); 364 free_cfg: 365 kfree(old_cfg); 366 return ret; 367 } 368 369 /** 370 * ice_cfg_etsrec_defaults - Set default ETS recommended DCB config 371 * @pi: port information structure 372 */ 373 static void ice_cfg_etsrec_defaults(struct ice_port_info *pi) 374 { 375 struct ice_dcbx_cfg *dcbcfg = &pi->qos_cfg.local_dcbx_cfg; 376 u8 i; 377 378 /* Ensure ETS recommended DCB configuration is not already set */ 379 if (dcbcfg->etsrec.maxtcs) 380 return; 381 382 /* In CEE mode, set the default to 1 TC */ 383 dcbcfg->etsrec.maxtcs = 1; 384 for (i = 0; i < ICE_MAX_TRAFFIC_CLASS; i++) { 385 dcbcfg->etsrec.tcbwtable[i] = i ? 0 : 100; 386 dcbcfg->etsrec.tsatable[i] = i ? ICE_IEEE_TSA_STRICT : 387 ICE_IEEE_TSA_ETS; 388 } 389 } 390 391 /** 392 * ice_dcb_need_recfg - Check if DCB needs reconfig 393 * @pf: board private structure 394 * @old_cfg: current DCB config 395 * @new_cfg: new DCB config 396 */ 397 static bool 398 ice_dcb_need_recfg(struct ice_pf *pf, struct ice_dcbx_cfg *old_cfg, 399 struct ice_dcbx_cfg *new_cfg) 400 { 401 struct device *dev = ice_pf_to_dev(pf); 402 bool need_reconfig = false; 403 404 /* Check if ETS configuration has changed */ 405 if (memcmp(&new_cfg->etscfg, &old_cfg->etscfg, 406 sizeof(new_cfg->etscfg))) { 407 /* If Priority Table has changed reconfig is needed */ 408 if (memcmp(&new_cfg->etscfg.prio_table, 409 &old_cfg->etscfg.prio_table, 410 sizeof(new_cfg->etscfg.prio_table))) { 411 need_reconfig = true; 412 dev_dbg(dev, "ETS UP2TC changed.\n"); 413 } 414 415 if (memcmp(&new_cfg->etscfg.tcbwtable, 416 &old_cfg->etscfg.tcbwtable, 417 sizeof(new_cfg->etscfg.tcbwtable))) 418 dev_dbg(dev, "ETS TC BW Table changed.\n"); 419 420 if (memcmp(&new_cfg->etscfg.tsatable, 421 &old_cfg->etscfg.tsatable, 422 sizeof(new_cfg->etscfg.tsatable))) 423 dev_dbg(dev, "ETS TSA Table changed.\n"); 424 } 425 426 /* Check if PFC configuration has changed */ 427 if (memcmp(&new_cfg->pfc, &old_cfg->pfc, sizeof(new_cfg->pfc))) { 428 need_reconfig = true; 429 dev_dbg(dev, "PFC config change detected.\n"); 430 } 431 432 /* Check if APP Table has changed */ 433 if (memcmp(&new_cfg->app, &old_cfg->app, sizeof(new_cfg->app))) { 434 need_reconfig = true; 435 dev_dbg(dev, "APP Table change detected.\n"); 436 } 437 438 dev_dbg(dev, "dcb need_reconfig=%d\n", need_reconfig); 439 return need_reconfig; 440 } 441 442 /** 443 * ice_dcb_rebuild - rebuild DCB post reset 444 * @pf: physical function instance 445 */ 446 void ice_dcb_rebuild(struct ice_pf *pf) 447 { 448 struct ice_aqc_port_ets_elem buf = { 0 }; 449 struct device *dev = ice_pf_to_dev(pf); 450 struct ice_dcbx_cfg *err_cfg; 451 enum ice_status ret; 452 453 ret = ice_query_port_ets(pf->hw.port_info, &buf, sizeof(buf), NULL); 454 if (ret) { 455 dev_err(dev, "Query Port ETS failed\n"); 456 goto dcb_error; 457 } 458 459 mutex_lock(&pf->tc_mutex); 460 461 if (!pf->hw.port_info->qos_cfg.is_sw_lldp) 462 ice_cfg_etsrec_defaults(pf->hw.port_info); 463 464 ret = ice_set_dcb_cfg(pf->hw.port_info); 465 if (ret) { 466 dev_err(dev, "Failed to set DCB config in rebuild\n"); 467 goto dcb_error; 468 } 469 470 if (!pf->hw.port_info->qos_cfg.is_sw_lldp) { 471 ret = ice_cfg_lldp_mib_change(&pf->hw, true); 472 if (ret && !pf->hw.port_info->qos_cfg.is_sw_lldp) { 473 dev_err(dev, "Failed to register for MIB changes\n"); 474 goto dcb_error; 475 } 476 } 477 478 dev_info(dev, "DCB info restored\n"); 479 ret = ice_query_port_ets(pf->hw.port_info, &buf, sizeof(buf), NULL); 480 if (ret) { 481 dev_err(dev, "Query Port ETS failed\n"); 482 goto dcb_error; 483 } 484 485 mutex_unlock(&pf->tc_mutex); 486 487 return; 488 489 dcb_error: 490 dev_err(dev, "Disabling DCB until new settings occur\n"); 491 err_cfg = kzalloc(sizeof(*err_cfg), GFP_KERNEL); 492 if (!err_cfg) { 493 mutex_unlock(&pf->tc_mutex); 494 return; 495 } 496 497 err_cfg->etscfg.willing = true; 498 err_cfg->etscfg.tcbwtable[0] = ICE_TC_MAX_BW; 499 err_cfg->etscfg.tsatable[0] = ICE_IEEE_TSA_ETS; 500 memcpy(&err_cfg->etsrec, &err_cfg->etscfg, sizeof(err_cfg->etsrec)); 501 /* Coverity warns the return code of ice_pf_dcb_cfg() is not checked 502 * here as is done for other calls to that function. That check is 503 * not necessary since this is in this function's error cleanup path. 504 * Suppress the Coverity warning with the following comment... 505 */ 506 /* coverity[check_return] */ 507 ice_pf_dcb_cfg(pf, err_cfg, false); 508 kfree(err_cfg); 509 510 mutex_unlock(&pf->tc_mutex); 511 } 512 513 /** 514 * ice_dcb_init_cfg - set the initial DCB config in SW 515 * @pf: PF to apply config to 516 * @locked: Is the RTNL held 517 */ 518 static int ice_dcb_init_cfg(struct ice_pf *pf, bool locked) 519 { 520 struct ice_dcbx_cfg *newcfg; 521 struct ice_port_info *pi; 522 int ret = 0; 523 524 pi = pf->hw.port_info; 525 newcfg = kmemdup(&pi->qos_cfg.local_dcbx_cfg, sizeof(*newcfg), 526 GFP_KERNEL); 527 if (!newcfg) 528 return -ENOMEM; 529 530 memset(&pi->qos_cfg.local_dcbx_cfg, 0, sizeof(*newcfg)); 531 532 dev_info(ice_pf_to_dev(pf), "Configuring initial DCB values\n"); 533 if (ice_pf_dcb_cfg(pf, newcfg, locked)) 534 ret = -EINVAL; 535 536 kfree(newcfg); 537 538 return ret; 539 } 540 541 /** 542 * ice_dcb_sw_dflt_cfg - Apply a default DCB config 543 * @pf: PF to apply config to 544 * @ets_willing: configure ETS willing 545 * @locked: was this function called with RTNL held 546 */ 547 int ice_dcb_sw_dflt_cfg(struct ice_pf *pf, bool ets_willing, bool locked) 548 { 549 struct ice_aqc_port_ets_elem buf = { 0 }; 550 struct ice_dcbx_cfg *dcbcfg; 551 struct ice_port_info *pi; 552 struct ice_hw *hw; 553 int ret; 554 555 hw = &pf->hw; 556 pi = hw->port_info; 557 dcbcfg = kzalloc(sizeof(*dcbcfg), GFP_KERNEL); 558 if (!dcbcfg) 559 return -ENOMEM; 560 561 memset(&pi->qos_cfg.local_dcbx_cfg, 0, sizeof(*dcbcfg)); 562 563 dcbcfg->etscfg.willing = ets_willing ? 1 : 0; 564 dcbcfg->etscfg.maxtcs = hw->func_caps.common_cap.maxtc; 565 dcbcfg->etscfg.tcbwtable[0] = 100; 566 dcbcfg->etscfg.tsatable[0] = ICE_IEEE_TSA_ETS; 567 568 memcpy(&dcbcfg->etsrec, &dcbcfg->etscfg, 569 sizeof(dcbcfg->etsrec)); 570 dcbcfg->etsrec.willing = 0; 571 572 dcbcfg->pfc.willing = 1; 573 dcbcfg->pfc.pfccap = hw->func_caps.common_cap.maxtc; 574 575 dcbcfg->numapps = 1; 576 dcbcfg->app[0].selector = ICE_APP_SEL_ETHTYPE; 577 dcbcfg->app[0].priority = 3; 578 dcbcfg->app[0].prot_id = ETH_P_FCOE; 579 580 ret = ice_pf_dcb_cfg(pf, dcbcfg, locked); 581 kfree(dcbcfg); 582 if (ret) 583 return ret; 584 585 return ice_query_port_ets(pi, &buf, sizeof(buf), NULL); 586 } 587 588 /** 589 * ice_dcb_tc_contig - Check that TCs are contiguous 590 * @prio_table: pointer to priority table 591 * 592 * Check if TCs begin with TC0 and are contiguous 593 */ 594 static bool ice_dcb_tc_contig(u8 *prio_table) 595 { 596 bool found_empty = false; 597 u8 used_tc = 0; 598 int i; 599 600 /* Create a bitmap of used TCs */ 601 for (i = 0; i < CEE_DCBX_MAX_PRIO; i++) 602 used_tc |= BIT(prio_table[i]); 603 604 for (i = 0; i < CEE_DCBX_MAX_PRIO; i++) { 605 if (used_tc & BIT(i)) { 606 if (found_empty) 607 return false; 608 } else { 609 found_empty = true; 610 } 611 } 612 613 return true; 614 } 615 616 /** 617 * ice_dcb_noncontig_cfg - Configure DCB for non-contiguous TCs 618 * @pf: pointer to the PF struct 619 * 620 * If non-contiguous TCs, then configure SW DCB with TC0 and ETS non-willing 621 */ 622 static int ice_dcb_noncontig_cfg(struct ice_pf *pf) 623 { 624 struct ice_dcbx_cfg *dcbcfg = &pf->hw.port_info->qos_cfg.local_dcbx_cfg; 625 struct device *dev = ice_pf_to_dev(pf); 626 int ret; 627 628 /* Configure SW DCB default with ETS non-willing */ 629 ret = ice_dcb_sw_dflt_cfg(pf, false, true); 630 if (ret) { 631 dev_err(dev, "Failed to set local DCB config %d\n", ret); 632 return ret; 633 } 634 635 /* Reconfigure with ETS willing so that FW will send LLDP MIB event */ 636 dcbcfg->etscfg.willing = 1; 637 ret = ice_set_dcb_cfg(pf->hw.port_info); 638 if (ret) 639 dev_err(dev, "Failed to set DCB to unwilling\n"); 640 641 return ret; 642 } 643 644 /** 645 * ice_pf_dcb_recfg - Reconfigure all VEBs and VSIs 646 * @pf: pointer to the PF struct 647 * 648 * Assumed caller has already disabled all VSIs before 649 * calling this function. Reconfiguring DCB based on 650 * local_dcbx_cfg. 651 */ 652 void ice_pf_dcb_recfg(struct ice_pf *pf) 653 { 654 struct ice_dcbx_cfg *dcbcfg = &pf->hw.port_info->qos_cfg.local_dcbx_cfg; 655 struct iidc_event *event; 656 u8 tc_map = 0; 657 int v, ret; 658 659 /* Update each VSI */ 660 ice_for_each_vsi(pf, v) { 661 struct ice_vsi *vsi = pf->vsi[v]; 662 663 if (!vsi) 664 continue; 665 666 if (vsi->type == ICE_VSI_PF) { 667 tc_map = ice_dcb_get_ena_tc(dcbcfg); 668 669 /* If DCBX request non-contiguous TC, then configure 670 * default TC 671 */ 672 if (!ice_dcb_tc_contig(dcbcfg->etscfg.prio_table)) { 673 tc_map = ICE_DFLT_TRAFFIC_CLASS; 674 ice_dcb_noncontig_cfg(pf); 675 } 676 } else { 677 tc_map = ICE_DFLT_TRAFFIC_CLASS; 678 } 679 680 ret = ice_vsi_cfg_tc(vsi, tc_map); 681 if (ret) { 682 dev_err(ice_pf_to_dev(pf), "Failed to config TC for VSI index: %d\n", 683 vsi->idx); 684 continue; 685 } 686 /* no need to proceed with remaining cfg if it is switchdev 687 * VSI 688 */ 689 if (vsi->type == ICE_VSI_SWITCHDEV_CTRL) 690 continue; 691 692 ice_vsi_map_rings_to_vectors(vsi); 693 if (vsi->type == ICE_VSI_PF) 694 ice_dcbnl_set_all(vsi); 695 } 696 /* Notify the AUX drivers that TC change is finished */ 697 event = kzalloc(sizeof(*event), GFP_KERNEL); 698 if (!event) 699 return; 700 701 set_bit(IIDC_EVENT_AFTER_TC_CHANGE, event->type); 702 ice_send_event_to_aux(pf, event); 703 kfree(event); 704 } 705 706 /** 707 * ice_init_pf_dcb - initialize DCB for a PF 708 * @pf: PF to initialize DCB for 709 * @locked: Was function called with RTNL held 710 */ 711 int ice_init_pf_dcb(struct ice_pf *pf, bool locked) 712 { 713 struct device *dev = ice_pf_to_dev(pf); 714 struct ice_port_info *port_info; 715 struct ice_hw *hw = &pf->hw; 716 int err; 717 718 port_info = hw->port_info; 719 720 err = ice_init_dcb(hw, false); 721 if (err && !port_info->qos_cfg.is_sw_lldp) { 722 dev_err(dev, "Error initializing DCB %d\n", err); 723 goto dcb_init_err; 724 } 725 726 dev_info(dev, "DCB is enabled in the hardware, max number of TCs supported on this port are %d\n", 727 pf->hw.func_caps.common_cap.maxtc); 728 if (err) { 729 struct ice_vsi *pf_vsi; 730 731 /* FW LLDP is disabled, activate SW DCBX/LLDP mode */ 732 dev_info(dev, "FW LLDP is disabled, DCBx/LLDP in SW mode.\n"); 733 clear_bit(ICE_FLAG_FW_LLDP_AGENT, pf->flags); 734 err = ice_aq_set_pfc_mode(&pf->hw, ICE_AQC_PFC_VLAN_BASED_PFC, 735 NULL); 736 if (err) 737 dev_info(dev, "Failed to set VLAN PFC mode\n"); 738 739 err = ice_dcb_sw_dflt_cfg(pf, true, locked); 740 if (err) { 741 dev_err(dev, "Failed to set local DCB config %d\n", 742 err); 743 err = -EIO; 744 goto dcb_init_err; 745 } 746 747 /* If the FW DCBX engine is not running then Rx LLDP packets 748 * need to be redirected up the stack. 749 */ 750 pf_vsi = ice_get_main_vsi(pf); 751 if (!pf_vsi) { 752 dev_err(dev, "Failed to set local DCB config\n"); 753 err = -EIO; 754 goto dcb_init_err; 755 } 756 757 ice_cfg_sw_lldp(pf_vsi, false, true); 758 759 pf->dcbx_cap = ice_dcb_get_mode(port_info, true); 760 return 0; 761 } 762 763 set_bit(ICE_FLAG_FW_LLDP_AGENT, pf->flags); 764 765 /* DCBX/LLDP enabled in FW, set DCBNL mode advertisement */ 766 pf->dcbx_cap = ice_dcb_get_mode(port_info, false); 767 768 err = ice_dcb_init_cfg(pf, locked); 769 if (err) 770 goto dcb_init_err; 771 772 return err; 773 774 dcb_init_err: 775 dev_err(dev, "DCB init failed\n"); 776 return err; 777 } 778 779 /** 780 * ice_update_dcb_stats - Update DCB stats counters 781 * @pf: PF whose stats needs to be updated 782 */ 783 void ice_update_dcb_stats(struct ice_pf *pf) 784 { 785 struct ice_hw_port_stats *prev_ps, *cur_ps; 786 struct ice_hw *hw = &pf->hw; 787 u8 port; 788 int i; 789 790 port = hw->port_info->lport; 791 prev_ps = &pf->stats_prev; 792 cur_ps = &pf->stats; 793 794 for (i = 0; i < 8; i++) { 795 ice_stat_update32(hw, GLPRT_PXOFFRXC(port, i), 796 pf->stat_prev_loaded, 797 &prev_ps->priority_xoff_rx[i], 798 &cur_ps->priority_xoff_rx[i]); 799 ice_stat_update32(hw, GLPRT_PXONRXC(port, i), 800 pf->stat_prev_loaded, 801 &prev_ps->priority_xon_rx[i], 802 &cur_ps->priority_xon_rx[i]); 803 ice_stat_update32(hw, GLPRT_PXONTXC(port, i), 804 pf->stat_prev_loaded, 805 &prev_ps->priority_xon_tx[i], 806 &cur_ps->priority_xon_tx[i]); 807 ice_stat_update32(hw, GLPRT_PXOFFTXC(port, i), 808 pf->stat_prev_loaded, 809 &prev_ps->priority_xoff_tx[i], 810 &cur_ps->priority_xoff_tx[i]); 811 ice_stat_update32(hw, GLPRT_RXON2OFFCNT(port, i), 812 pf->stat_prev_loaded, 813 &prev_ps->priority_xon_2_xoff[i], 814 &cur_ps->priority_xon_2_xoff[i]); 815 } 816 } 817 818 /** 819 * ice_tx_prepare_vlan_flags_dcb - prepare VLAN tagging for DCB 820 * @tx_ring: ring to send buffer on 821 * @first: pointer to struct ice_tx_buf 822 * 823 * This should not be called if the outer VLAN is software offloaded as the VLAN 824 * tag will already be configured with the correct ID and priority bits 825 */ 826 void 827 ice_tx_prepare_vlan_flags_dcb(struct ice_ring *tx_ring, 828 struct ice_tx_buf *first) 829 { 830 struct sk_buff *skb = first->skb; 831 832 if (!test_bit(ICE_FLAG_DCB_ENA, tx_ring->vsi->back->flags)) 833 return; 834 835 /* Insert 802.1p priority into VLAN header */ 836 if ((first->tx_flags & ICE_TX_FLAGS_HW_VLAN) || 837 skb->priority != TC_PRIO_CONTROL) { 838 first->tx_flags &= ~ICE_TX_FLAGS_VLAN_PR_M; 839 /* Mask the lower 3 bits to set the 802.1p priority */ 840 first->tx_flags |= (skb->priority & 0x7) << 841 ICE_TX_FLAGS_VLAN_PR_S; 842 /* if this is not already set it means a VLAN 0 + priority needs 843 * to be offloaded 844 */ 845 first->tx_flags |= ICE_TX_FLAGS_HW_VLAN; 846 } 847 } 848 849 /** 850 * ice_dcb_process_lldp_set_mib_change - Process MIB change 851 * @pf: ptr to ice_pf 852 * @event: pointer to the admin queue receive event 853 */ 854 void 855 ice_dcb_process_lldp_set_mib_change(struct ice_pf *pf, 856 struct ice_rq_event_info *event) 857 { 858 struct ice_aqc_port_ets_elem buf = { 0 }; 859 struct device *dev = ice_pf_to_dev(pf); 860 struct ice_aqc_lldp_get_mib *mib; 861 struct ice_dcbx_cfg tmp_dcbx_cfg; 862 bool need_reconfig = false; 863 struct ice_port_info *pi; 864 struct ice_vsi *pf_vsi; 865 u8 mib_type; 866 int ret; 867 868 /* Not DCB capable or capability disabled */ 869 if (!(test_bit(ICE_FLAG_DCB_CAPABLE, pf->flags))) 870 return; 871 872 if (pf->dcbx_cap & DCB_CAP_DCBX_HOST) { 873 dev_dbg(dev, "MIB Change Event in HOST mode\n"); 874 return; 875 } 876 877 pi = pf->hw.port_info; 878 mib = (struct ice_aqc_lldp_get_mib *)&event->desc.params.raw; 879 /* Ignore if event is not for Nearest Bridge */ 880 mib_type = ((mib->type >> ICE_AQ_LLDP_BRID_TYPE_S) & 881 ICE_AQ_LLDP_BRID_TYPE_M); 882 dev_dbg(dev, "LLDP event MIB bridge type 0x%x\n", mib_type); 883 if (mib_type != ICE_AQ_LLDP_BRID_TYPE_NEAREST_BRID) 884 return; 885 886 /* Check MIB Type and return if event for Remote MIB update */ 887 mib_type = mib->type & ICE_AQ_LLDP_MIB_TYPE_M; 888 dev_dbg(dev, "LLDP event mib type %s\n", mib_type ? "remote" : "local"); 889 if (mib_type == ICE_AQ_LLDP_MIB_REMOTE) { 890 /* Update the remote cached instance and return */ 891 ret = ice_aq_get_dcb_cfg(pi->hw, ICE_AQ_LLDP_MIB_REMOTE, 892 ICE_AQ_LLDP_BRID_TYPE_NEAREST_BRID, 893 &pi->qos_cfg.remote_dcbx_cfg); 894 if (ret) { 895 dev_err(dev, "Failed to get remote DCB config\n"); 896 return; 897 } 898 } 899 900 mutex_lock(&pf->tc_mutex); 901 902 /* store the old configuration */ 903 tmp_dcbx_cfg = pf->hw.port_info->qos_cfg.local_dcbx_cfg; 904 905 /* Reset the old DCBX configuration data */ 906 memset(&pi->qos_cfg.local_dcbx_cfg, 0, 907 sizeof(pi->qos_cfg.local_dcbx_cfg)); 908 909 /* Get updated DCBX data from firmware */ 910 ret = ice_get_dcb_cfg(pf->hw.port_info); 911 if (ret) { 912 dev_err(dev, "Failed to get DCB config\n"); 913 goto out; 914 } 915 916 /* No change detected in DCBX configs */ 917 if (!memcmp(&tmp_dcbx_cfg, &pi->qos_cfg.local_dcbx_cfg, 918 sizeof(tmp_dcbx_cfg))) { 919 dev_dbg(dev, "No change detected in DCBX configuration.\n"); 920 goto out; 921 } 922 923 pf->dcbx_cap = ice_dcb_get_mode(pi, false); 924 925 need_reconfig = ice_dcb_need_recfg(pf, &tmp_dcbx_cfg, 926 &pi->qos_cfg.local_dcbx_cfg); 927 ice_dcbnl_flush_apps(pf, &tmp_dcbx_cfg, &pi->qos_cfg.local_dcbx_cfg); 928 if (!need_reconfig) 929 goto out; 930 931 /* Enable DCB tagging only when more than one TC */ 932 if (ice_dcb_get_num_tc(&pi->qos_cfg.local_dcbx_cfg) > 1) { 933 dev_dbg(dev, "DCB tagging enabled (num TC > 1)\n"); 934 set_bit(ICE_FLAG_DCB_ENA, pf->flags); 935 } else { 936 dev_dbg(dev, "DCB tagging disabled (num TC = 1)\n"); 937 clear_bit(ICE_FLAG_DCB_ENA, pf->flags); 938 } 939 940 pf_vsi = ice_get_main_vsi(pf); 941 if (!pf_vsi) { 942 dev_dbg(dev, "PF VSI doesn't exist\n"); 943 goto out; 944 } 945 946 rtnl_lock(); 947 ice_dis_vsi(pf_vsi, true); 948 949 ret = ice_query_port_ets(pf->hw.port_info, &buf, sizeof(buf), NULL); 950 if (ret) { 951 dev_err(dev, "Query Port ETS failed\n"); 952 goto unlock_rtnl; 953 } 954 955 /* changes in configuration update VSI */ 956 ice_pf_dcb_recfg(pf); 957 958 ice_ena_vsi(pf_vsi, true); 959 unlock_rtnl: 960 rtnl_unlock(); 961 out: 962 mutex_unlock(&pf->tc_mutex); 963 } 964