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