1 // SPDX-License-Identifier: GPL-2.0 2 /* Copyright (c) 2019, Intel Corporation. */ 3 4 #include "ice.h" 5 #include "ice_dcb.h" 6 #include "ice_dcb_lib.h" 7 #include "ice_dcb_nl.h" 8 #include <net/dcbnl.h> 9 10 /** 11 * ice_dcbnl_devreset - perform enough of a ifdown/ifup to sync DCBNL info 12 * @netdev: device associated with interface that needs reset 13 */ 14 static void ice_dcbnl_devreset(struct net_device *netdev) 15 { 16 struct ice_pf *pf = ice_netdev_to_pf(netdev); 17 18 while (ice_is_reset_in_progress(pf->state)) 19 usleep_range(1000, 2000); 20 21 dev_close(netdev); 22 netdev_state_change(netdev); 23 dev_open(netdev, NULL); 24 netdev_state_change(netdev); 25 } 26 27 /** 28 * ice_dcbnl_getets - retrieve local ETS configuration 29 * @netdev: the relevant netdev 30 * @ets: struct to hold ETS configuration 31 */ 32 static int ice_dcbnl_getets(struct net_device *netdev, struct ieee_ets *ets) 33 { 34 struct ice_dcbx_cfg *dcbxcfg; 35 struct ice_pf *pf; 36 37 pf = ice_netdev_to_pf(netdev); 38 dcbxcfg = &pf->hw.port_info->qos_cfg.local_dcbx_cfg; 39 40 ets->willing = dcbxcfg->etscfg.willing; 41 ets->ets_cap = dcbxcfg->etscfg.maxtcs; 42 ets->cbs = dcbxcfg->etscfg.cbs; 43 memcpy(ets->tc_tx_bw, dcbxcfg->etscfg.tcbwtable, sizeof(ets->tc_tx_bw)); 44 memcpy(ets->tc_rx_bw, dcbxcfg->etscfg.tcbwtable, sizeof(ets->tc_rx_bw)); 45 memcpy(ets->tc_tsa, dcbxcfg->etscfg.tsatable, sizeof(ets->tc_tsa)); 46 memcpy(ets->prio_tc, dcbxcfg->etscfg.prio_table, sizeof(ets->prio_tc)); 47 memcpy(ets->tc_reco_bw, dcbxcfg->etsrec.tcbwtable, 48 sizeof(ets->tc_reco_bw)); 49 memcpy(ets->tc_reco_tsa, dcbxcfg->etsrec.tsatable, 50 sizeof(ets->tc_reco_tsa)); 51 memcpy(ets->reco_prio_tc, dcbxcfg->etscfg.prio_table, 52 sizeof(ets->reco_prio_tc)); 53 54 return 0; 55 } 56 57 /** 58 * ice_dcbnl_setets - set IEEE ETS configuration 59 * @netdev: pointer to relevant netdev 60 * @ets: struct to hold ETS configuration 61 */ 62 static int ice_dcbnl_setets(struct net_device *netdev, struct ieee_ets *ets) 63 { 64 struct ice_pf *pf = ice_netdev_to_pf(netdev); 65 struct ice_dcbx_cfg *new_cfg; 66 int bwcfg = 0, bwrec = 0; 67 int err, i; 68 69 if ((pf->dcbx_cap & DCB_CAP_DCBX_LLD_MANAGED) || 70 !(pf->dcbx_cap & DCB_CAP_DCBX_VER_IEEE)) 71 return -EINVAL; 72 73 new_cfg = &pf->hw.port_info->qos_cfg.desired_dcbx_cfg; 74 75 mutex_lock(&pf->tc_mutex); 76 77 new_cfg->etscfg.willing = ets->willing; 78 new_cfg->etscfg.cbs = ets->cbs; 79 ice_for_each_traffic_class(i) { 80 new_cfg->etscfg.tcbwtable[i] = ets->tc_tx_bw[i]; 81 bwcfg += ets->tc_tx_bw[i]; 82 new_cfg->etscfg.tsatable[i] = ets->tc_tsa[i]; 83 if (new_cfg->pfc_mode == ICE_QOS_MODE_VLAN) { 84 /* in DSCP mode up->tc mapping cannot change */ 85 new_cfg->etscfg.prio_table[i] = ets->prio_tc[i]; 86 new_cfg->etsrec.prio_table[i] = ets->reco_prio_tc[i]; 87 } 88 new_cfg->etsrec.tcbwtable[i] = ets->tc_reco_bw[i]; 89 bwrec += ets->tc_reco_bw[i]; 90 new_cfg->etsrec.tsatable[i] = ets->tc_reco_tsa[i]; 91 } 92 93 if (ice_dcb_bwchk(pf, new_cfg)) { 94 err = -EINVAL; 95 goto ets_out; 96 } 97 98 new_cfg->etscfg.maxtcs = pf->hw.func_caps.common_cap.maxtc; 99 100 if (!bwcfg) 101 new_cfg->etscfg.tcbwtable[0] = 100; 102 103 if (!bwrec) 104 new_cfg->etsrec.tcbwtable[0] = 100; 105 106 err = ice_pf_dcb_cfg(pf, new_cfg, true); 107 /* return of zero indicates new cfg applied */ 108 if (err == ICE_DCB_HW_CHG_RST) 109 ice_dcbnl_devreset(netdev); 110 if (err == ICE_DCB_NO_HW_CHG) 111 err = ICE_DCB_HW_CHG_RST; 112 113 ets_out: 114 mutex_unlock(&pf->tc_mutex); 115 return err; 116 } 117 118 /** 119 * ice_dcbnl_getnumtcs - Get max number of traffic classes supported 120 * @dev: pointer to netdev struct 121 * @tcid: TC ID 122 * @num: total number of TCs supported by the adapter 123 * 124 * Return the total number of TCs supported 125 */ 126 static int 127 ice_dcbnl_getnumtcs(struct net_device *dev, int __always_unused tcid, u8 *num) 128 { 129 struct ice_pf *pf = ice_netdev_to_pf(dev); 130 131 if (!test_bit(ICE_FLAG_DCB_CAPABLE, pf->flags)) 132 return -EINVAL; 133 134 *num = pf->hw.func_caps.common_cap.maxtc; 135 return 0; 136 } 137 138 /** 139 * ice_dcbnl_getdcbx - retrieve current DCBX capability 140 * @netdev: pointer to the netdev struct 141 */ 142 static u8 ice_dcbnl_getdcbx(struct net_device *netdev) 143 { 144 struct ice_pf *pf = ice_netdev_to_pf(netdev); 145 146 return pf->dcbx_cap; 147 } 148 149 /** 150 * ice_dcbnl_setdcbx - set required DCBX capability 151 * @netdev: the corresponding netdev 152 * @mode: required mode 153 */ 154 static u8 ice_dcbnl_setdcbx(struct net_device *netdev, u8 mode) 155 { 156 struct ice_pf *pf = ice_netdev_to_pf(netdev); 157 struct ice_qos_cfg *qos_cfg; 158 159 /* if FW LLDP agent is running, DCBNL not allowed to change mode */ 160 if (test_bit(ICE_FLAG_FW_LLDP_AGENT, pf->flags)) 161 return ICE_DCB_NO_HW_CHG; 162 163 /* No support for LLD_MANAGED modes or CEE+IEEE */ 164 if ((mode & DCB_CAP_DCBX_LLD_MANAGED) || 165 ((mode & DCB_CAP_DCBX_VER_IEEE) && (mode & DCB_CAP_DCBX_VER_CEE)) || 166 !(mode & DCB_CAP_DCBX_HOST)) 167 return ICE_DCB_NO_HW_CHG; 168 169 /* Already set to the given mode no change */ 170 if (mode == pf->dcbx_cap) 171 return ICE_DCB_NO_HW_CHG; 172 173 qos_cfg = &pf->hw.port_info->qos_cfg; 174 175 /* DSCP configuration is not DCBx negotiated */ 176 if (qos_cfg->local_dcbx_cfg.pfc_mode == ICE_QOS_MODE_DSCP) 177 return ICE_DCB_NO_HW_CHG; 178 179 pf->dcbx_cap = mode; 180 181 if (mode & DCB_CAP_DCBX_VER_CEE) 182 qos_cfg->local_dcbx_cfg.dcbx_mode = ICE_DCBX_MODE_CEE; 183 else 184 qos_cfg->local_dcbx_cfg.dcbx_mode = ICE_DCBX_MODE_IEEE; 185 186 dev_info(ice_pf_to_dev(pf), "DCBx mode = 0x%x\n", mode); 187 return ICE_DCB_HW_CHG_RST; 188 } 189 190 /** 191 * ice_dcbnl_get_perm_hw_addr - MAC address used by DCBX 192 * @netdev: pointer to netdev struct 193 * @perm_addr: buffer to return permanent MAC address 194 */ 195 static void ice_dcbnl_get_perm_hw_addr(struct net_device *netdev, u8 *perm_addr) 196 { 197 struct ice_pf *pf = ice_netdev_to_pf(netdev); 198 struct ice_port_info *pi = pf->hw.port_info; 199 int i, j; 200 201 memset(perm_addr, 0xff, MAX_ADDR_LEN); 202 203 for (i = 0; i < netdev->addr_len; i++) 204 perm_addr[i] = pi->mac.perm_addr[i]; 205 206 for (j = 0; j < netdev->addr_len; j++, i++) 207 perm_addr[i] = pi->mac.perm_addr[j]; 208 } 209 210 /** 211 * ice_get_pfc_delay - Retrieve PFC Link Delay 212 * @hw: pointer to HW struct 213 * @delay: holds the PFC Link Delay value 214 */ 215 static void ice_get_pfc_delay(struct ice_hw *hw, u16 *delay) 216 { 217 u32 val; 218 219 val = rd32(hw, PRTDCB_GENC); 220 *delay = (u16)((val & PRTDCB_GENC_PFCLDA_M) >> PRTDCB_GENC_PFCLDA_S); 221 } 222 223 /** 224 * ice_dcbnl_getpfc - retrieve local IEEE PFC config 225 * @netdev: pointer to netdev struct 226 * @pfc: struct to hold PFC info 227 */ 228 static int ice_dcbnl_getpfc(struct net_device *netdev, struct ieee_pfc *pfc) 229 { 230 struct ice_pf *pf = ice_netdev_to_pf(netdev); 231 struct ice_port_info *pi = pf->hw.port_info; 232 struct ice_dcbx_cfg *dcbxcfg; 233 int i; 234 235 dcbxcfg = &pi->qos_cfg.local_dcbx_cfg; 236 pfc->pfc_cap = dcbxcfg->pfc.pfccap; 237 pfc->pfc_en = dcbxcfg->pfc.pfcena; 238 pfc->mbc = dcbxcfg->pfc.mbc; 239 ice_get_pfc_delay(&pf->hw, &pfc->delay); 240 241 ice_for_each_traffic_class(i) { 242 pfc->requests[i] = pf->stats.priority_xoff_tx[i]; 243 pfc->indications[i] = pf->stats.priority_xoff_rx[i]; 244 } 245 246 return 0; 247 } 248 249 /** 250 * ice_dcbnl_setpfc - set local IEEE PFC config 251 * @netdev: pointer to relevant netdev 252 * @pfc: pointer to struct holding PFC config 253 */ 254 static int ice_dcbnl_setpfc(struct net_device *netdev, struct ieee_pfc *pfc) 255 { 256 struct ice_pf *pf = ice_netdev_to_pf(netdev); 257 struct ice_dcbx_cfg *new_cfg; 258 int err; 259 260 if ((pf->dcbx_cap & DCB_CAP_DCBX_LLD_MANAGED) || 261 !(pf->dcbx_cap & DCB_CAP_DCBX_VER_IEEE)) 262 return -EINVAL; 263 264 mutex_lock(&pf->tc_mutex); 265 266 new_cfg = &pf->hw.port_info->qos_cfg.desired_dcbx_cfg; 267 268 if (pfc->pfc_cap) 269 new_cfg->pfc.pfccap = pfc->pfc_cap; 270 else 271 new_cfg->pfc.pfccap = pf->hw.func_caps.common_cap.maxtc; 272 273 new_cfg->pfc.pfcena = pfc->pfc_en; 274 275 err = ice_pf_dcb_cfg(pf, new_cfg, true); 276 if (err == ICE_DCB_HW_CHG_RST) 277 ice_dcbnl_devreset(netdev); 278 if (err == ICE_DCB_NO_HW_CHG) 279 err = ICE_DCB_HW_CHG_RST; 280 mutex_unlock(&pf->tc_mutex); 281 return err; 282 } 283 284 /** 285 * ice_dcbnl_get_pfc_cfg - Get CEE PFC config 286 * @netdev: pointer to netdev struct 287 * @prio: corresponding user priority 288 * @setting: the PFC setting for given priority 289 */ 290 static void 291 ice_dcbnl_get_pfc_cfg(struct net_device *netdev, int prio, u8 *setting) 292 { 293 struct ice_pf *pf = ice_netdev_to_pf(netdev); 294 struct ice_port_info *pi = pf->hw.port_info; 295 296 if ((pf->dcbx_cap & DCB_CAP_DCBX_LLD_MANAGED) || 297 !(pf->dcbx_cap & DCB_CAP_DCBX_VER_CEE)) 298 return; 299 300 if (prio >= ICE_MAX_USER_PRIORITY) 301 return; 302 303 *setting = (pi->qos_cfg.local_dcbx_cfg.pfc.pfcena >> prio) & 0x1; 304 dev_dbg(ice_pf_to_dev(pf), "Get PFC Config up=%d, setting=%d, pfcenable=0x%x\n", 305 prio, *setting, pi->qos_cfg.local_dcbx_cfg.pfc.pfcena); 306 } 307 308 /** 309 * ice_dcbnl_set_pfc_cfg - Set CEE PFC config 310 * @netdev: the corresponding netdev 311 * @prio: User Priority 312 * @set: PFC setting to apply 313 */ 314 static void ice_dcbnl_set_pfc_cfg(struct net_device *netdev, int prio, u8 set) 315 { 316 struct ice_pf *pf = ice_netdev_to_pf(netdev); 317 struct ice_dcbx_cfg *new_cfg; 318 319 if ((pf->dcbx_cap & DCB_CAP_DCBX_LLD_MANAGED) || 320 !(pf->dcbx_cap & DCB_CAP_DCBX_VER_CEE)) 321 return; 322 323 if (prio >= ICE_MAX_USER_PRIORITY) 324 return; 325 326 new_cfg = &pf->hw.port_info->qos_cfg.desired_dcbx_cfg; 327 328 new_cfg->pfc.pfccap = pf->hw.func_caps.common_cap.maxtc; 329 if (set) 330 new_cfg->pfc.pfcena |= BIT(prio); 331 else 332 new_cfg->pfc.pfcena &= ~BIT(prio); 333 334 dev_dbg(ice_pf_to_dev(pf), "Set PFC config UP:%d set:%d pfcena:0x%x\n", 335 prio, set, new_cfg->pfc.pfcena); 336 } 337 338 /** 339 * ice_dcbnl_getpfcstate - get CEE PFC mode 340 * @netdev: pointer to netdev struct 341 */ 342 static u8 ice_dcbnl_getpfcstate(struct net_device *netdev) 343 { 344 struct ice_pf *pf = ice_netdev_to_pf(netdev); 345 struct ice_port_info *pi = pf->hw.port_info; 346 347 /* Return enabled if any UP enabled for PFC */ 348 if (pi->qos_cfg.local_dcbx_cfg.pfc.pfcena) 349 return 1; 350 351 return 0; 352 } 353 354 /** 355 * ice_dcbnl_getstate - get DCB enabled state 356 * @netdev: pointer to netdev struct 357 */ 358 static u8 ice_dcbnl_getstate(struct net_device *netdev) 359 { 360 struct ice_pf *pf = ice_netdev_to_pf(netdev); 361 u8 state = 0; 362 363 state = test_bit(ICE_FLAG_DCB_CAPABLE, pf->flags); 364 365 dev_dbg(ice_pf_to_dev(pf), "DCB enabled state = %d\n", state); 366 return state; 367 } 368 369 /** 370 * ice_dcbnl_setstate - Set CEE DCB state 371 * @netdev: pointer to relevant netdev 372 * @state: state value to set 373 */ 374 static u8 ice_dcbnl_setstate(struct net_device *netdev, u8 state) 375 { 376 struct ice_pf *pf = ice_netdev_to_pf(netdev); 377 378 if ((pf->dcbx_cap & DCB_CAP_DCBX_LLD_MANAGED) || 379 !(pf->dcbx_cap & DCB_CAP_DCBX_VER_CEE)) 380 return ICE_DCB_NO_HW_CHG; 381 382 /* Nothing to do */ 383 if (!!state == test_bit(ICE_FLAG_DCB_ENA, pf->flags)) 384 return ICE_DCB_NO_HW_CHG; 385 386 if (state) { 387 set_bit(ICE_FLAG_DCB_ENA, pf->flags); 388 memcpy(&pf->hw.port_info->qos_cfg.desired_dcbx_cfg, 389 &pf->hw.port_info->qos_cfg.local_dcbx_cfg, 390 sizeof(struct ice_dcbx_cfg)); 391 } else { 392 clear_bit(ICE_FLAG_DCB_ENA, pf->flags); 393 } 394 395 return ICE_DCB_HW_CHG; 396 } 397 398 /** 399 * ice_dcbnl_get_pg_tc_cfg_tx - get CEE PG Tx config 400 * @netdev: pointer to netdev struct 401 * @prio: the corresponding user priority 402 * @prio_type: traffic priority type 403 * @pgid: the BW group ID the traffic class belongs to 404 * @bw_pct: BW percentage for the corresponding BWG 405 * @up_map: prio mapped to corresponding TC 406 */ 407 static void 408 ice_dcbnl_get_pg_tc_cfg_tx(struct net_device *netdev, int prio, 409 u8 __always_unused *prio_type, u8 *pgid, 410 u8 __always_unused *bw_pct, 411 u8 __always_unused *up_map) 412 { 413 struct ice_pf *pf = ice_netdev_to_pf(netdev); 414 struct ice_port_info *pi = pf->hw.port_info; 415 416 if ((pf->dcbx_cap & DCB_CAP_DCBX_LLD_MANAGED) || 417 !(pf->dcbx_cap & DCB_CAP_DCBX_VER_CEE)) 418 return; 419 420 if (prio >= ICE_MAX_USER_PRIORITY) 421 return; 422 423 *pgid = pi->qos_cfg.local_dcbx_cfg.etscfg.prio_table[prio]; 424 dev_dbg(ice_pf_to_dev(pf), "Get PG config prio=%d tc=%d\n", prio, 425 *pgid); 426 } 427 428 /** 429 * ice_dcbnl_set_pg_tc_cfg_tx - set CEE PG Tx config 430 * @netdev: pointer to relevant netdev 431 * @tc: the corresponding traffic class 432 * @prio_type: the traffic priority type 433 * @bwg_id: the BW group ID the TC belongs to 434 * @bw_pct: the BW perventage for the BWG 435 * @up_map: prio mapped to corresponding TC 436 */ 437 static void 438 ice_dcbnl_set_pg_tc_cfg_tx(struct net_device *netdev, int tc, 439 u8 __always_unused prio_type, 440 u8 __always_unused bwg_id, 441 u8 __always_unused bw_pct, u8 up_map) 442 { 443 struct ice_pf *pf = ice_netdev_to_pf(netdev); 444 struct ice_dcbx_cfg *new_cfg; 445 int i; 446 447 if ((pf->dcbx_cap & DCB_CAP_DCBX_LLD_MANAGED) || 448 !(pf->dcbx_cap & DCB_CAP_DCBX_VER_CEE)) 449 return; 450 451 if (tc >= ICE_MAX_TRAFFIC_CLASS) 452 return; 453 454 new_cfg = &pf->hw.port_info->qos_cfg.desired_dcbx_cfg; 455 456 /* prio_type, bwg_id and bw_pct per UP are not supported */ 457 458 ice_for_each_traffic_class(i) { 459 if (up_map & BIT(i)) 460 new_cfg->etscfg.prio_table[i] = tc; 461 } 462 new_cfg->etscfg.tsatable[tc] = ICE_IEEE_TSA_ETS; 463 } 464 465 /** 466 * ice_dcbnl_get_pg_bwg_cfg_tx - Get CEE PGBW config 467 * @netdev: pointer to the netdev struct 468 * @pgid: corresponding traffic class 469 * @bw_pct: the BW percentage for the corresponding TC 470 */ 471 static void 472 ice_dcbnl_get_pg_bwg_cfg_tx(struct net_device *netdev, int pgid, u8 *bw_pct) 473 { 474 struct ice_pf *pf = ice_netdev_to_pf(netdev); 475 struct ice_port_info *pi = pf->hw.port_info; 476 477 if ((pf->dcbx_cap & DCB_CAP_DCBX_LLD_MANAGED) || 478 !(pf->dcbx_cap & DCB_CAP_DCBX_VER_CEE)) 479 return; 480 481 if (pgid >= ICE_MAX_TRAFFIC_CLASS) 482 return; 483 484 *bw_pct = pi->qos_cfg.local_dcbx_cfg.etscfg.tcbwtable[pgid]; 485 dev_dbg(ice_pf_to_dev(pf), "Get PG BW config tc=%d bw_pct=%d\n", 486 pgid, *bw_pct); 487 } 488 489 /** 490 * ice_dcbnl_set_pg_bwg_cfg_tx - set CEE PG Tx BW config 491 * @netdev: the corresponding netdev 492 * @pgid: Correspongind traffic class 493 * @bw_pct: the BW percentage for the specified TC 494 */ 495 static void 496 ice_dcbnl_set_pg_bwg_cfg_tx(struct net_device *netdev, int pgid, u8 bw_pct) 497 { 498 struct ice_pf *pf = ice_netdev_to_pf(netdev); 499 struct ice_dcbx_cfg *new_cfg; 500 501 if ((pf->dcbx_cap & DCB_CAP_DCBX_LLD_MANAGED) || 502 !(pf->dcbx_cap & DCB_CAP_DCBX_VER_CEE)) 503 return; 504 505 if (pgid >= ICE_MAX_TRAFFIC_CLASS) 506 return; 507 508 new_cfg = &pf->hw.port_info->qos_cfg.desired_dcbx_cfg; 509 510 new_cfg->etscfg.tcbwtable[pgid] = bw_pct; 511 } 512 513 /** 514 * ice_dcbnl_get_pg_tc_cfg_rx - Get CEE PG Rx config 515 * @netdev: pointer to netdev struct 516 * @prio: the corresponding user priority 517 * @prio_type: the traffic priority type 518 * @pgid: the PG ID 519 * @bw_pct: the BW percentage for the corresponding BWG 520 * @up_map: prio mapped to corresponding TC 521 */ 522 static void 523 ice_dcbnl_get_pg_tc_cfg_rx(struct net_device *netdev, int prio, 524 u8 __always_unused *prio_type, u8 *pgid, 525 u8 __always_unused *bw_pct, 526 u8 __always_unused *up_map) 527 { 528 struct ice_pf *pf = ice_netdev_to_pf(netdev); 529 struct ice_port_info *pi = pf->hw.port_info; 530 531 if ((pf->dcbx_cap & DCB_CAP_DCBX_LLD_MANAGED) || 532 !(pf->dcbx_cap & DCB_CAP_DCBX_VER_CEE)) 533 return; 534 535 if (prio >= ICE_MAX_USER_PRIORITY) 536 return; 537 538 *pgid = pi->qos_cfg.local_dcbx_cfg.etscfg.prio_table[prio]; 539 } 540 541 /** 542 * ice_dcbnl_set_pg_tc_cfg_rx 543 * @netdev: relevant netdev struct 544 * @prio: corresponding user priority 545 * @prio_type: the traffic priority type 546 * @pgid: the PG ID 547 * @bw_pct: BW percentage for corresponding BWG 548 * @up_map: prio mapped to corresponding TC 549 * 550 * lldpad requires this function pointer to be non-NULL to complete CEE config. 551 */ 552 static void 553 ice_dcbnl_set_pg_tc_cfg_rx(struct net_device *netdev, 554 int __always_unused prio, 555 u8 __always_unused prio_type, 556 u8 __always_unused pgid, 557 u8 __always_unused bw_pct, 558 u8 __always_unused up_map) 559 { 560 struct ice_pf *pf = ice_netdev_to_pf(netdev); 561 562 dev_dbg(ice_pf_to_dev(pf), "Rx TC PG Config Not Supported.\n"); 563 } 564 565 /** 566 * ice_dcbnl_get_pg_bwg_cfg_rx - Get CEE PG BW Rx config 567 * @netdev: pointer to netdev struct 568 * @pgid: the corresponding traffic class 569 * @bw_pct: the BW percentage for the corresponding TC 570 */ 571 static void 572 ice_dcbnl_get_pg_bwg_cfg_rx(struct net_device *netdev, int __always_unused pgid, 573 u8 *bw_pct) 574 { 575 struct ice_pf *pf = ice_netdev_to_pf(netdev); 576 577 if ((pf->dcbx_cap & DCB_CAP_DCBX_LLD_MANAGED) || 578 !(pf->dcbx_cap & DCB_CAP_DCBX_VER_CEE)) 579 return; 580 581 *bw_pct = 0; 582 } 583 584 /** 585 * ice_dcbnl_set_pg_bwg_cfg_rx 586 * @netdev: the corresponding netdev 587 * @pgid: corresponding TC 588 * @bw_pct: BW percentage for given TC 589 * 590 * lldpad requires this function pointer to be non-NULL to complete CEE config. 591 */ 592 static void 593 ice_dcbnl_set_pg_bwg_cfg_rx(struct net_device *netdev, int __always_unused pgid, 594 u8 __always_unused bw_pct) 595 { 596 struct ice_pf *pf = ice_netdev_to_pf(netdev); 597 598 dev_dbg(ice_pf_to_dev(pf), "Rx BWG PG Config Not Supported.\n"); 599 } 600 601 /** 602 * ice_dcbnl_get_cap - Get DCBX capabilities of adapter 603 * @netdev: pointer to netdev struct 604 * @capid: the capability type 605 * @cap: the capability value 606 */ 607 static u8 ice_dcbnl_get_cap(struct net_device *netdev, int capid, u8 *cap) 608 { 609 struct ice_pf *pf = ice_netdev_to_pf(netdev); 610 611 if (!(test_bit(ICE_FLAG_DCB_CAPABLE, pf->flags))) 612 return ICE_DCB_NO_HW_CHG; 613 614 switch (capid) { 615 case DCB_CAP_ATTR_PG: 616 *cap = true; 617 break; 618 case DCB_CAP_ATTR_PFC: 619 *cap = true; 620 break; 621 case DCB_CAP_ATTR_UP2TC: 622 *cap = false; 623 break; 624 case DCB_CAP_ATTR_PG_TCS: 625 *cap = 0x80; 626 break; 627 case DCB_CAP_ATTR_PFC_TCS: 628 *cap = 0x80; 629 break; 630 case DCB_CAP_ATTR_GSP: 631 *cap = false; 632 break; 633 case DCB_CAP_ATTR_BCN: 634 *cap = false; 635 break; 636 case DCB_CAP_ATTR_DCBX: 637 *cap = pf->dcbx_cap; 638 break; 639 default: 640 *cap = false; 641 break; 642 } 643 644 dev_dbg(ice_pf_to_dev(pf), "DCBX Get Capability cap=%d capval=0x%x\n", 645 capid, *cap); 646 return 0; 647 } 648 649 /** 650 * ice_dcbnl_getapp - get CEE APP 651 * @netdev: pointer to netdev struct 652 * @idtype: the App selector 653 * @id: the App ethtype or port number 654 */ 655 static int ice_dcbnl_getapp(struct net_device *netdev, u8 idtype, u16 id) 656 { 657 struct ice_pf *pf = ice_netdev_to_pf(netdev); 658 struct dcb_app app = { 659 .selector = idtype, 660 .protocol = id, 661 }; 662 663 if ((pf->dcbx_cap & DCB_CAP_DCBX_LLD_MANAGED) || 664 !(pf->dcbx_cap & DCB_CAP_DCBX_VER_CEE)) 665 return -EINVAL; 666 667 return dcb_getapp(netdev, &app); 668 } 669 670 /** 671 * ice_dcbnl_find_app - Search for APP in given DCB config 672 * @cfg: struct to hold DCBX config 673 * @app: struct to hold app data to look for 674 */ 675 static bool 676 ice_dcbnl_find_app(struct ice_dcbx_cfg *cfg, 677 struct ice_dcb_app_priority_table *app) 678 { 679 unsigned int i; 680 681 for (i = 0; i < cfg->numapps; i++) { 682 if (app->selector == cfg->app[i].selector && 683 app->prot_id == cfg->app[i].prot_id && 684 app->priority == cfg->app[i].priority) 685 return true; 686 } 687 688 return false; 689 } 690 691 #define ICE_BYTES_PER_DSCP_VAL 8 692 693 /** 694 * ice_dcbnl_setapp - set local IEEE App config 695 * @netdev: relevant netdev struct 696 * @app: struct to hold app config info 697 */ 698 static int ice_dcbnl_setapp(struct net_device *netdev, struct dcb_app *app) 699 { 700 struct ice_pf *pf = ice_netdev_to_pf(netdev); 701 struct ice_dcb_app_priority_table new_app; 702 struct ice_dcbx_cfg *old_cfg, *new_cfg; 703 u8 max_tc; 704 int ret; 705 706 /* ONLY DSCP APP TLVs have operational significance */ 707 if (app->selector != IEEE_8021QAZ_APP_SEL_DSCP) 708 return -EINVAL; 709 710 /* only allow APP TLVs in SW Mode */ 711 if (pf->dcbx_cap & DCB_CAP_DCBX_LLD_MANAGED) { 712 netdev_err(netdev, "can't do DSCP QoS when FW DCB agent active\n"); 713 return -EINVAL; 714 } 715 716 if (!(pf->dcbx_cap & DCB_CAP_DCBX_VER_IEEE)) 717 return -EINVAL; 718 719 if (!ice_is_feature_supported(pf, ICE_F_DSCP)) 720 return -EOPNOTSUPP; 721 722 if (app->protocol >= ICE_DSCP_NUM_VAL) { 723 netdev_err(netdev, "DSCP value 0x%04X out of range\n", 724 app->protocol); 725 return -EINVAL; 726 } 727 728 max_tc = pf->hw.func_caps.common_cap.maxtc; 729 if (app->priority >= max_tc) { 730 netdev_err(netdev, "TC %d out of range, max TC %d\n", 731 app->priority, max_tc); 732 return -EINVAL; 733 } 734 735 /* grab TC mutex */ 736 mutex_lock(&pf->tc_mutex); 737 738 new_cfg = &pf->hw.port_info->qos_cfg.desired_dcbx_cfg; 739 old_cfg = &pf->hw.port_info->qos_cfg.local_dcbx_cfg; 740 741 ret = dcb_ieee_setapp(netdev, app); 742 if (ret) 743 goto setapp_out; 744 745 if (test_and_set_bit(app->protocol, new_cfg->dscp_mapped)) { 746 netdev_err(netdev, "DSCP value 0x%04X already user mapped\n", 747 app->protocol); 748 ret = dcb_ieee_delapp(netdev, app); 749 if (ret) 750 netdev_err(netdev, "Failed to delete re-mapping TLV\n"); 751 ret = -EINVAL; 752 goto setapp_out; 753 } 754 755 new_app.selector = app->selector; 756 new_app.prot_id = app->protocol; 757 new_app.priority = app->priority; 758 759 /* If port is not in DSCP mode, need to set */ 760 if (old_cfg->pfc_mode == ICE_QOS_MODE_VLAN) { 761 int i, j; 762 763 /* set DSCP mode */ 764 ret = ice_aq_set_pfc_mode(&pf->hw, ICE_AQC_PFC_DSCP_BASED_PFC, 765 NULL); 766 if (ret) { 767 netdev_err(netdev, "Failed to set DSCP PFC mode %d\n", 768 ret); 769 goto setapp_out; 770 } 771 netdev_info(netdev, "Switched QoS to L3 DSCP mode\n"); 772 773 new_cfg->pfc_mode = ICE_QOS_MODE_DSCP; 774 775 /* set default DSCP QoS values */ 776 new_cfg->etscfg.willing = 0; 777 new_cfg->pfc.pfccap = max_tc; 778 new_cfg->pfc.willing = 0; 779 780 for (i = 0; i < max_tc; i++) 781 for (j = 0; j < ICE_BYTES_PER_DSCP_VAL; j++) { 782 int dscp, offset; 783 784 dscp = (i * max_tc) + j; 785 offset = max_tc * ICE_BYTES_PER_DSCP_VAL; 786 787 new_cfg->dscp_map[dscp] = i; 788 /* if less that 8 TCs supported */ 789 if (max_tc < ICE_MAX_TRAFFIC_CLASS) 790 new_cfg->dscp_map[dscp + offset] = i; 791 } 792 793 new_cfg->etscfg.tcbwtable[0] = 100; 794 new_cfg->etscfg.tsatable[0] = ICE_IEEE_TSA_ETS; 795 new_cfg->etscfg.prio_table[0] = 0; 796 797 for (i = 1; i < max_tc; i++) { 798 new_cfg->etscfg.tcbwtable[i] = 0; 799 new_cfg->etscfg.tsatable[i] = ICE_IEEE_TSA_ETS; 800 new_cfg->etscfg.prio_table[i] = i; 801 } 802 } /* end of switching to DSCP mode */ 803 804 /* apply new mapping for this DSCP value */ 805 new_cfg->dscp_map[app->protocol] = app->priority; 806 new_cfg->app[new_cfg->numapps++] = new_app; 807 808 ret = ice_pf_dcb_cfg(pf, new_cfg, true); 809 /* return of zero indicates new cfg applied */ 810 if (ret == ICE_DCB_HW_CHG_RST) 811 ice_dcbnl_devreset(netdev); 812 else 813 ret = ICE_DCB_NO_HW_CHG; 814 815 setapp_out: 816 mutex_unlock(&pf->tc_mutex); 817 return ret; 818 } 819 820 /** 821 * ice_dcbnl_delapp - Delete local IEEE App config 822 * @netdev: relevant netdev 823 * @app: struct to hold app too delete 824 * 825 * Will not delete first application required by the FW 826 */ 827 static int ice_dcbnl_delapp(struct net_device *netdev, struct dcb_app *app) 828 { 829 struct ice_pf *pf = ice_netdev_to_pf(netdev); 830 struct ice_dcbx_cfg *old_cfg, *new_cfg; 831 unsigned int i, j; 832 int ret = 0; 833 834 if (pf->dcbx_cap & DCB_CAP_DCBX_LLD_MANAGED) { 835 netdev_err(netdev, "can't delete DSCP netlink app when FW DCB agent is active\n"); 836 return -EINVAL; 837 } 838 839 mutex_lock(&pf->tc_mutex); 840 old_cfg = &pf->hw.port_info->qos_cfg.local_dcbx_cfg; 841 842 ret = dcb_ieee_delapp(netdev, app); 843 if (ret) 844 goto delapp_out; 845 846 new_cfg = &pf->hw.port_info->qos_cfg.desired_dcbx_cfg; 847 848 for (i = 0; i < new_cfg->numapps; i++) { 849 if (app->selector == new_cfg->app[i].selector && 850 app->protocol == new_cfg->app[i].prot_id && 851 app->priority == new_cfg->app[i].priority) { 852 new_cfg->app[i].selector = 0; 853 new_cfg->app[i].prot_id = 0; 854 new_cfg->app[i].priority = 0; 855 break; 856 } 857 } 858 859 /* Did not find DCB App */ 860 if (i == new_cfg->numapps) { 861 ret = -EINVAL; 862 goto delapp_out; 863 } 864 865 new_cfg->numapps--; 866 867 for (j = i; j < new_cfg->numapps; j++) { 868 new_cfg->app[j].selector = old_cfg->app[j + 1].selector; 869 new_cfg->app[j].prot_id = old_cfg->app[j + 1].prot_id; 870 new_cfg->app[j].priority = old_cfg->app[j + 1].priority; 871 } 872 873 /* if not a DSCP APP TLV or DSCP is not supported, we are done */ 874 if (app->selector != IEEE_8021QAZ_APP_SEL_DSCP || 875 !ice_is_feature_supported(pf, ICE_F_DSCP)) { 876 ret = ICE_DCB_HW_CHG; 877 goto delapp_out; 878 } 879 880 /* if DSCP TLV, then need to address change in mapping */ 881 clear_bit(app->protocol, new_cfg->dscp_mapped); 882 /* remap this DSCP value to default value */ 883 new_cfg->dscp_map[app->protocol] = app->protocol % 884 ICE_BYTES_PER_DSCP_VAL; 885 886 /* if the last DSCP mapping just got deleted, need to switch 887 * to L2 VLAN QoS mode 888 */ 889 if (bitmap_empty(new_cfg->dscp_mapped, ICE_DSCP_NUM_VAL) && 890 new_cfg->pfc_mode == ICE_QOS_MODE_DSCP) { 891 ret = ice_aq_set_pfc_mode(&pf->hw, 892 ICE_AQC_PFC_VLAN_BASED_PFC, 893 NULL); 894 if (ret) { 895 netdev_info(netdev, "Failed to set VLAN PFC mode %d\n", 896 ret); 897 goto delapp_out; 898 } 899 netdev_info(netdev, "Switched QoS to L2 VLAN mode\n"); 900 901 new_cfg->pfc_mode = ICE_QOS_MODE_VLAN; 902 903 ret = ice_dcb_sw_dflt_cfg(pf, true, true); 904 } else { 905 ret = ice_pf_dcb_cfg(pf, new_cfg, true); 906 } 907 908 /* return of ICE_DCB_HW_CHG_RST indicates new cfg applied 909 * and reset needs to be performed 910 */ 911 if (ret == ICE_DCB_HW_CHG_RST) 912 ice_dcbnl_devreset(netdev); 913 914 /* if the change was not siginificant enough to actually call 915 * the reconfiguration flow, we still need to tell caller that 916 * their request was successfully handled 917 */ 918 if (ret == ICE_DCB_NO_HW_CHG) 919 ret = ICE_DCB_HW_CHG; 920 921 delapp_out: 922 mutex_unlock(&pf->tc_mutex); 923 return ret; 924 } 925 926 /** 927 * ice_dcbnl_cee_set_all - Commit CEE DCB settings to HW 928 * @netdev: the corresponding netdev 929 */ 930 static u8 ice_dcbnl_cee_set_all(struct net_device *netdev) 931 { 932 struct ice_pf *pf = ice_netdev_to_pf(netdev); 933 struct ice_dcbx_cfg *new_cfg; 934 int err; 935 936 if ((pf->dcbx_cap & DCB_CAP_DCBX_LLD_MANAGED) || 937 !(pf->dcbx_cap & DCB_CAP_DCBX_VER_CEE)) 938 return ICE_DCB_NO_HW_CHG; 939 940 new_cfg = &pf->hw.port_info->qos_cfg.desired_dcbx_cfg; 941 942 mutex_lock(&pf->tc_mutex); 943 944 err = ice_pf_dcb_cfg(pf, new_cfg, true); 945 946 mutex_unlock(&pf->tc_mutex); 947 return (err != ICE_DCB_HW_CHG_RST) ? ICE_DCB_NO_HW_CHG : err; 948 } 949 950 static const struct dcbnl_rtnl_ops dcbnl_ops = { 951 /* IEEE 802.1Qaz std */ 952 .ieee_getets = ice_dcbnl_getets, 953 .ieee_setets = ice_dcbnl_setets, 954 .ieee_getpfc = ice_dcbnl_getpfc, 955 .ieee_setpfc = ice_dcbnl_setpfc, 956 .ieee_setapp = ice_dcbnl_setapp, 957 .ieee_delapp = ice_dcbnl_delapp, 958 959 /* CEE std */ 960 .getstate = ice_dcbnl_getstate, 961 .setstate = ice_dcbnl_setstate, 962 .getpermhwaddr = ice_dcbnl_get_perm_hw_addr, 963 .setpgtccfgtx = ice_dcbnl_set_pg_tc_cfg_tx, 964 .setpgbwgcfgtx = ice_dcbnl_set_pg_bwg_cfg_tx, 965 .setpgtccfgrx = ice_dcbnl_set_pg_tc_cfg_rx, 966 .setpgbwgcfgrx = ice_dcbnl_set_pg_bwg_cfg_rx, 967 .getpgtccfgtx = ice_dcbnl_get_pg_tc_cfg_tx, 968 .getpgbwgcfgtx = ice_dcbnl_get_pg_bwg_cfg_tx, 969 .getpgtccfgrx = ice_dcbnl_get_pg_tc_cfg_rx, 970 .getpgbwgcfgrx = ice_dcbnl_get_pg_bwg_cfg_rx, 971 .setpfccfg = ice_dcbnl_set_pfc_cfg, 972 .getpfccfg = ice_dcbnl_get_pfc_cfg, 973 .setall = ice_dcbnl_cee_set_all, 974 .getcap = ice_dcbnl_get_cap, 975 .getnumtcs = ice_dcbnl_getnumtcs, 976 .getpfcstate = ice_dcbnl_getpfcstate, 977 .getapp = ice_dcbnl_getapp, 978 979 /* DCBX configuration */ 980 .getdcbx = ice_dcbnl_getdcbx, 981 .setdcbx = ice_dcbnl_setdcbx, 982 }; 983 984 /** 985 * ice_dcbnl_set_all - set all the apps and ieee data from DCBX config 986 * @vsi: pointer to VSI struct 987 */ 988 void ice_dcbnl_set_all(struct ice_vsi *vsi) 989 { 990 struct net_device *netdev = vsi->netdev; 991 struct ice_dcbx_cfg *dcbxcfg; 992 struct ice_port_info *pi; 993 struct dcb_app sapp; 994 struct ice_pf *pf; 995 unsigned int i; 996 997 if (!netdev) 998 return; 999 1000 pf = ice_netdev_to_pf(netdev); 1001 pi = pf->hw.port_info; 1002 1003 /* SW DCB taken care of by SW Default Config */ 1004 if (pf->dcbx_cap & DCB_CAP_DCBX_HOST) 1005 return; 1006 1007 /* DCB not enabled */ 1008 if (!test_bit(ICE_FLAG_DCB_ENA, pf->flags)) 1009 return; 1010 1011 dcbxcfg = &pi->qos_cfg.local_dcbx_cfg; 1012 1013 for (i = 0; i < dcbxcfg->numapps; i++) { 1014 u8 prio, tc_map; 1015 1016 prio = dcbxcfg->app[i].priority; 1017 tc_map = BIT(dcbxcfg->etscfg.prio_table[prio]); 1018 1019 /* Add APP only if the TC is enabled for this VSI */ 1020 if (tc_map & vsi->tc_cfg.ena_tc) { 1021 sapp.selector = dcbxcfg->app[i].selector; 1022 sapp.protocol = dcbxcfg->app[i].prot_id; 1023 sapp.priority = prio; 1024 dcb_ieee_setapp(netdev, &sapp); 1025 } 1026 } 1027 /* Notify user-space of the changes */ 1028 dcbnl_ieee_notify(netdev, RTM_SETDCB, DCB_CMD_IEEE_SET, 0, 0); 1029 } 1030 1031 /** 1032 * ice_dcbnl_vsi_del_app - Delete APP on all VSIs 1033 * @vsi: pointer to the main VSI 1034 * @app: APP to delete 1035 * 1036 * Delete given APP from all the VSIs for given PF 1037 */ 1038 static void 1039 ice_dcbnl_vsi_del_app(struct ice_vsi *vsi, 1040 struct ice_dcb_app_priority_table *app) 1041 { 1042 struct dcb_app sapp; 1043 int err; 1044 1045 sapp.selector = app->selector; 1046 sapp.protocol = app->prot_id; 1047 sapp.priority = app->priority; 1048 err = ice_dcbnl_delapp(vsi->netdev, &sapp); 1049 dev_dbg(ice_pf_to_dev(vsi->back), "Deleting app for VSI idx=%d err=%d sel=%d proto=0x%x, prio=%d\n", 1050 vsi->idx, err, app->selector, app->prot_id, app->priority); 1051 } 1052 1053 /** 1054 * ice_dcbnl_flush_apps - Delete all removed APPs 1055 * @pf: the corresponding PF 1056 * @old_cfg: old DCBX configuration data 1057 * @new_cfg: new DCBX configuration data 1058 * 1059 * Find and delete all APPS that are not present in the passed 1060 * DCB configuration 1061 */ 1062 void 1063 ice_dcbnl_flush_apps(struct ice_pf *pf, struct ice_dcbx_cfg *old_cfg, 1064 struct ice_dcbx_cfg *new_cfg) 1065 { 1066 struct ice_vsi *main_vsi = ice_get_main_vsi(pf); 1067 unsigned int i; 1068 1069 if (!main_vsi) 1070 return; 1071 1072 for (i = 0; i < old_cfg->numapps; i++) { 1073 struct ice_dcb_app_priority_table app = old_cfg->app[i]; 1074 1075 /* The APP is not available anymore delete it */ 1076 if (!ice_dcbnl_find_app(new_cfg, &app)) 1077 ice_dcbnl_vsi_del_app(main_vsi, &app); 1078 } 1079 } 1080 1081 /** 1082 * ice_dcbnl_setup - setup DCBNL 1083 * @vsi: VSI to get associated netdev from 1084 */ 1085 void ice_dcbnl_setup(struct ice_vsi *vsi) 1086 { 1087 struct net_device *netdev = vsi->netdev; 1088 struct ice_pf *pf; 1089 1090 pf = ice_netdev_to_pf(netdev); 1091 if (!test_bit(ICE_FLAG_DCB_CAPABLE, pf->flags)) 1092 return; 1093 1094 netdev->dcbnl_ops = &dcbnl_ops; 1095 ice_dcbnl_set_all(vsi); 1096 } 1097