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 static 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 687 ice_vsi_map_rings_to_vectors(vsi); 688 if (vsi->type == ICE_VSI_PF) 689 ice_dcbnl_set_all(vsi); 690 } 691 /* Notify the AUX drivers that TC change is finished */ 692 event = kzalloc(sizeof(*event), GFP_KERNEL); 693 if (!event) 694 return; 695 696 set_bit(IIDC_EVENT_AFTER_TC_CHANGE, event->type); 697 ice_send_event_to_aux(pf, event); 698 kfree(event); 699 } 700 701 /** 702 * ice_init_pf_dcb - initialize DCB for a PF 703 * @pf: PF to initialize DCB for 704 * @locked: Was function called with RTNL held 705 */ 706 int ice_init_pf_dcb(struct ice_pf *pf, bool locked) 707 { 708 struct device *dev = ice_pf_to_dev(pf); 709 struct ice_port_info *port_info; 710 struct ice_hw *hw = &pf->hw; 711 int err; 712 713 port_info = hw->port_info; 714 715 err = ice_init_dcb(hw, false); 716 if (err && !port_info->qos_cfg.is_sw_lldp) { 717 dev_err(dev, "Error initializing DCB %d\n", err); 718 goto dcb_init_err; 719 } 720 721 dev_info(dev, "DCB is enabled in the hardware, max number of TCs supported on this port are %d\n", 722 pf->hw.func_caps.common_cap.maxtc); 723 if (err) { 724 struct ice_vsi *pf_vsi; 725 726 /* FW LLDP is disabled, activate SW DCBX/LLDP mode */ 727 dev_info(dev, "FW LLDP is disabled, DCBx/LLDP in SW mode.\n"); 728 clear_bit(ICE_FLAG_FW_LLDP_AGENT, pf->flags); 729 err = ice_dcb_sw_dflt_cfg(pf, true, locked); 730 if (err) { 731 dev_err(dev, "Failed to set local DCB config %d\n", 732 err); 733 err = -EIO; 734 goto dcb_init_err; 735 } 736 737 /* If the FW DCBX engine is not running then Rx LLDP packets 738 * need to be redirected up the stack. 739 */ 740 pf_vsi = ice_get_main_vsi(pf); 741 if (!pf_vsi) { 742 dev_err(dev, "Failed to set local DCB config\n"); 743 err = -EIO; 744 goto dcb_init_err; 745 } 746 747 ice_cfg_sw_lldp(pf_vsi, false, true); 748 749 pf->dcbx_cap = ice_dcb_get_mode(port_info, true); 750 return 0; 751 } 752 753 set_bit(ICE_FLAG_FW_LLDP_AGENT, pf->flags); 754 755 /* DCBX/LLDP enabled in FW, set DCBNL mode advertisement */ 756 pf->dcbx_cap = ice_dcb_get_mode(port_info, false); 757 758 err = ice_dcb_init_cfg(pf, locked); 759 if (err) 760 goto dcb_init_err; 761 762 return err; 763 764 dcb_init_err: 765 dev_err(dev, "DCB init failed\n"); 766 return err; 767 } 768 769 /** 770 * ice_update_dcb_stats - Update DCB stats counters 771 * @pf: PF whose stats needs to be updated 772 */ 773 void ice_update_dcb_stats(struct ice_pf *pf) 774 { 775 struct ice_hw_port_stats *prev_ps, *cur_ps; 776 struct ice_hw *hw = &pf->hw; 777 u8 port; 778 int i; 779 780 port = hw->port_info->lport; 781 prev_ps = &pf->stats_prev; 782 cur_ps = &pf->stats; 783 784 for (i = 0; i < 8; i++) { 785 ice_stat_update32(hw, GLPRT_PXOFFRXC(port, i), 786 pf->stat_prev_loaded, 787 &prev_ps->priority_xoff_rx[i], 788 &cur_ps->priority_xoff_rx[i]); 789 ice_stat_update32(hw, GLPRT_PXONRXC(port, i), 790 pf->stat_prev_loaded, 791 &prev_ps->priority_xon_rx[i], 792 &cur_ps->priority_xon_rx[i]); 793 ice_stat_update32(hw, GLPRT_PXONTXC(port, i), 794 pf->stat_prev_loaded, 795 &prev_ps->priority_xon_tx[i], 796 &cur_ps->priority_xon_tx[i]); 797 ice_stat_update32(hw, GLPRT_PXOFFTXC(port, i), 798 pf->stat_prev_loaded, 799 &prev_ps->priority_xoff_tx[i], 800 &cur_ps->priority_xoff_tx[i]); 801 ice_stat_update32(hw, GLPRT_RXON2OFFCNT(port, i), 802 pf->stat_prev_loaded, 803 &prev_ps->priority_xon_2_xoff[i], 804 &cur_ps->priority_xon_2_xoff[i]); 805 } 806 } 807 808 /** 809 * ice_tx_prepare_vlan_flags_dcb - prepare VLAN tagging for DCB 810 * @tx_ring: ring to send buffer on 811 * @first: pointer to struct ice_tx_buf 812 * 813 * This should not be called if the outer VLAN is software offloaded as the VLAN 814 * tag will already be configured with the correct ID and priority bits 815 */ 816 void 817 ice_tx_prepare_vlan_flags_dcb(struct ice_ring *tx_ring, 818 struct ice_tx_buf *first) 819 { 820 struct sk_buff *skb = first->skb; 821 822 if (!test_bit(ICE_FLAG_DCB_ENA, tx_ring->vsi->back->flags)) 823 return; 824 825 /* Insert 802.1p priority into VLAN header */ 826 if ((first->tx_flags & ICE_TX_FLAGS_HW_VLAN) || 827 skb->priority != TC_PRIO_CONTROL) { 828 first->tx_flags &= ~ICE_TX_FLAGS_VLAN_PR_M; 829 /* Mask the lower 3 bits to set the 802.1p priority */ 830 first->tx_flags |= (skb->priority & 0x7) << 831 ICE_TX_FLAGS_VLAN_PR_S; 832 /* if this is not already set it means a VLAN 0 + priority needs 833 * to be offloaded 834 */ 835 first->tx_flags |= ICE_TX_FLAGS_HW_VLAN; 836 } 837 } 838 839 /** 840 * ice_dcb_process_lldp_set_mib_change - Process MIB change 841 * @pf: ptr to ice_pf 842 * @event: pointer to the admin queue receive event 843 */ 844 void 845 ice_dcb_process_lldp_set_mib_change(struct ice_pf *pf, 846 struct ice_rq_event_info *event) 847 { 848 struct ice_aqc_port_ets_elem buf = { 0 }; 849 struct device *dev = ice_pf_to_dev(pf); 850 struct ice_aqc_lldp_get_mib *mib; 851 struct ice_dcbx_cfg tmp_dcbx_cfg; 852 bool need_reconfig = false; 853 struct ice_port_info *pi; 854 struct ice_vsi *pf_vsi; 855 u8 mib_type; 856 int ret; 857 858 /* Not DCB capable or capability disabled */ 859 if (!(test_bit(ICE_FLAG_DCB_CAPABLE, pf->flags))) 860 return; 861 862 if (pf->dcbx_cap & DCB_CAP_DCBX_HOST) { 863 dev_dbg(dev, "MIB Change Event in HOST mode\n"); 864 return; 865 } 866 867 pi = pf->hw.port_info; 868 mib = (struct ice_aqc_lldp_get_mib *)&event->desc.params.raw; 869 /* Ignore if event is not for Nearest Bridge */ 870 mib_type = ((mib->type >> ICE_AQ_LLDP_BRID_TYPE_S) & 871 ICE_AQ_LLDP_BRID_TYPE_M); 872 dev_dbg(dev, "LLDP event MIB bridge type 0x%x\n", mib_type); 873 if (mib_type != ICE_AQ_LLDP_BRID_TYPE_NEAREST_BRID) 874 return; 875 876 /* Check MIB Type and return if event for Remote MIB update */ 877 mib_type = mib->type & ICE_AQ_LLDP_MIB_TYPE_M; 878 dev_dbg(dev, "LLDP event mib type %s\n", mib_type ? "remote" : "local"); 879 if (mib_type == ICE_AQ_LLDP_MIB_REMOTE) { 880 /* Update the remote cached instance and return */ 881 ret = ice_aq_get_dcb_cfg(pi->hw, ICE_AQ_LLDP_MIB_REMOTE, 882 ICE_AQ_LLDP_BRID_TYPE_NEAREST_BRID, 883 &pi->qos_cfg.remote_dcbx_cfg); 884 if (ret) { 885 dev_err(dev, "Failed to get remote DCB config\n"); 886 return; 887 } 888 } 889 890 mutex_lock(&pf->tc_mutex); 891 892 /* store the old configuration */ 893 tmp_dcbx_cfg = pf->hw.port_info->qos_cfg.local_dcbx_cfg; 894 895 /* Reset the old DCBX configuration data */ 896 memset(&pi->qos_cfg.local_dcbx_cfg, 0, 897 sizeof(pi->qos_cfg.local_dcbx_cfg)); 898 899 /* Get updated DCBX data from firmware */ 900 ret = ice_get_dcb_cfg(pf->hw.port_info); 901 if (ret) { 902 dev_err(dev, "Failed to get DCB config\n"); 903 goto out; 904 } 905 906 /* No change detected in DCBX configs */ 907 if (!memcmp(&tmp_dcbx_cfg, &pi->qos_cfg.local_dcbx_cfg, 908 sizeof(tmp_dcbx_cfg))) { 909 dev_dbg(dev, "No change detected in DCBX configuration.\n"); 910 goto out; 911 } 912 913 pf->dcbx_cap = ice_dcb_get_mode(pi, false); 914 915 need_reconfig = ice_dcb_need_recfg(pf, &tmp_dcbx_cfg, 916 &pi->qos_cfg.local_dcbx_cfg); 917 ice_dcbnl_flush_apps(pf, &tmp_dcbx_cfg, &pi->qos_cfg.local_dcbx_cfg); 918 if (!need_reconfig) 919 goto out; 920 921 /* Enable DCB tagging only when more than one TC */ 922 if (ice_dcb_get_num_tc(&pi->qos_cfg.local_dcbx_cfg) > 1) { 923 dev_dbg(dev, "DCB tagging enabled (num TC > 1)\n"); 924 set_bit(ICE_FLAG_DCB_ENA, pf->flags); 925 } else { 926 dev_dbg(dev, "DCB tagging disabled (num TC = 1)\n"); 927 clear_bit(ICE_FLAG_DCB_ENA, pf->flags); 928 } 929 930 pf_vsi = ice_get_main_vsi(pf); 931 if (!pf_vsi) { 932 dev_dbg(dev, "PF VSI doesn't exist\n"); 933 goto out; 934 } 935 936 rtnl_lock(); 937 ice_dis_vsi(pf_vsi, true); 938 939 ret = ice_query_port_ets(pf->hw.port_info, &buf, sizeof(buf), NULL); 940 if (ret) { 941 dev_err(dev, "Query Port ETS failed\n"); 942 goto unlock_rtnl; 943 } 944 945 /* changes in configuration update VSI */ 946 ice_pf_dcb_recfg(pf); 947 948 ice_ena_vsi(pf_vsi, true); 949 unlock_rtnl: 950 rtnl_unlock(); 951 out: 952 mutex_unlock(&pf->tc_mutex); 953 } 954