1 // SPDX-License-Identifier: GPL-2.0 2 /* Copyright(c) 2013 - 2021 Intel Corporation. */ 3 4 #ifdef CONFIG_I40E_DCB 5 #include "i40e.h" 6 #include <net/dcbnl.h> 7 8 #define I40E_DCBNL_STATUS_SUCCESS 0 9 #define I40E_DCBNL_STATUS_ERROR 1 10 static bool i40e_dcbnl_find_app(struct i40e_dcbx_config *cfg, 11 struct i40e_dcb_app_priority_table *app); 12 /** 13 * i40e_get_pfc_delay - retrieve PFC Link Delay 14 * @hw: pointer to hardware struct 15 * @delay: holds the PFC Link delay value 16 * 17 * Returns PFC Link Delay from the PRTDCB_GENC.PFCLDA 18 **/ 19 static void i40e_get_pfc_delay(struct i40e_hw *hw, u16 *delay) 20 { 21 u32 val; 22 23 val = rd32(hw, I40E_PRTDCB_GENC); 24 *delay = (u16)((val & I40E_PRTDCB_GENC_PFCLDA_MASK) >> 25 I40E_PRTDCB_GENC_PFCLDA_SHIFT); 26 } 27 28 /** 29 * i40e_dcbnl_ieee_getets - retrieve local IEEE ETS configuration 30 * @dev: the corresponding netdev 31 * @ets: structure to hold the ETS information 32 * 33 * Returns local IEEE ETS configuration 34 **/ 35 static int i40e_dcbnl_ieee_getets(struct net_device *dev, 36 struct ieee_ets *ets) 37 { 38 struct i40e_pf *pf = i40e_netdev_to_pf(dev); 39 struct i40e_dcbx_config *dcbxcfg; 40 41 if (!(pf->dcbx_cap & DCB_CAP_DCBX_VER_IEEE)) 42 return -EINVAL; 43 44 dcbxcfg = &pf->hw.local_dcbx_config; 45 ets->willing = dcbxcfg->etscfg.willing; 46 ets->ets_cap = I40E_MAX_TRAFFIC_CLASS; 47 ets->cbs = dcbxcfg->etscfg.cbs; 48 memcpy(ets->tc_tx_bw, dcbxcfg->etscfg.tcbwtable, 49 sizeof(ets->tc_tx_bw)); 50 memcpy(ets->tc_rx_bw, dcbxcfg->etscfg.tcbwtable, 51 sizeof(ets->tc_rx_bw)); 52 memcpy(ets->tc_tsa, dcbxcfg->etscfg.tsatable, 53 sizeof(ets->tc_tsa)); 54 memcpy(ets->prio_tc, dcbxcfg->etscfg.prioritytable, 55 sizeof(ets->prio_tc)); 56 memcpy(ets->tc_reco_bw, dcbxcfg->etsrec.tcbwtable, 57 sizeof(ets->tc_reco_bw)); 58 memcpy(ets->tc_reco_tsa, dcbxcfg->etsrec.tsatable, 59 sizeof(ets->tc_reco_tsa)); 60 memcpy(ets->reco_prio_tc, dcbxcfg->etscfg.prioritytable, 61 sizeof(ets->reco_prio_tc)); 62 63 return 0; 64 } 65 66 /** 67 * i40e_dcbnl_ieee_getpfc - retrieve local IEEE PFC configuration 68 * @dev: the corresponding netdev 69 * @pfc: structure to hold the PFC information 70 * 71 * Returns local IEEE PFC configuration 72 **/ 73 static int i40e_dcbnl_ieee_getpfc(struct net_device *dev, 74 struct ieee_pfc *pfc) 75 { 76 struct i40e_pf *pf = i40e_netdev_to_pf(dev); 77 struct i40e_dcbx_config *dcbxcfg; 78 struct i40e_hw *hw = &pf->hw; 79 int i; 80 81 if (!(pf->dcbx_cap & DCB_CAP_DCBX_VER_IEEE)) 82 return -EINVAL; 83 84 dcbxcfg = &hw->local_dcbx_config; 85 pfc->pfc_cap = dcbxcfg->pfc.pfccap; 86 pfc->pfc_en = dcbxcfg->pfc.pfcenable; 87 pfc->mbc = dcbxcfg->pfc.mbc; 88 i40e_get_pfc_delay(hw, &pfc->delay); 89 90 /* Get Requests/Indications */ 91 for (i = 0; i < I40E_MAX_TRAFFIC_CLASS; i++) { 92 pfc->requests[i] = pf->stats.priority_xoff_tx[i]; 93 pfc->indications[i] = pf->stats.priority_xoff_rx[i]; 94 } 95 96 return 0; 97 } 98 99 /** 100 * i40e_dcbnl_ieee_setets - set IEEE ETS configuration 101 * @netdev: the corresponding netdev 102 * @ets: structure to hold the ETS information 103 * 104 * Set IEEE ETS configuration 105 **/ 106 static int i40e_dcbnl_ieee_setets(struct net_device *netdev, 107 struct ieee_ets *ets) 108 { 109 struct i40e_pf *pf = i40e_netdev_to_pf(netdev); 110 struct i40e_dcbx_config *old_cfg; 111 int i, ret; 112 113 if (!(pf->dcbx_cap & DCB_CAP_DCBX_VER_IEEE) || 114 (pf->dcbx_cap & DCB_CAP_DCBX_LLD_MANAGED)) 115 return -EINVAL; 116 117 old_cfg = &pf->hw.local_dcbx_config; 118 /* Copy current config into temp */ 119 pf->tmp_cfg = *old_cfg; 120 121 /* Update the ETS configuration for temp */ 122 pf->tmp_cfg.etscfg.willing = ets->willing; 123 pf->tmp_cfg.etscfg.maxtcs = I40E_MAX_TRAFFIC_CLASS; 124 pf->tmp_cfg.etscfg.cbs = ets->cbs; 125 for (i = 0; i < I40E_MAX_TRAFFIC_CLASS; i++) { 126 pf->tmp_cfg.etscfg.tcbwtable[i] = ets->tc_tx_bw[i]; 127 pf->tmp_cfg.etscfg.tsatable[i] = ets->tc_tsa[i]; 128 pf->tmp_cfg.etscfg.prioritytable[i] = ets->prio_tc[i]; 129 pf->tmp_cfg.etsrec.tcbwtable[i] = ets->tc_reco_bw[i]; 130 pf->tmp_cfg.etsrec.tsatable[i] = ets->tc_reco_tsa[i]; 131 pf->tmp_cfg.etsrec.prioritytable[i] = ets->reco_prio_tc[i]; 132 } 133 134 /* Commit changes to HW */ 135 ret = i40e_hw_dcb_config(pf, &pf->tmp_cfg); 136 if (ret) { 137 dev_info(&pf->pdev->dev, 138 "Failed setting DCB ETS configuration err %pe aq_err %s\n", 139 ERR_PTR(ret), 140 i40e_aq_str(&pf->hw, pf->hw.aq.asq_last_status)); 141 return -EINVAL; 142 } 143 144 return 0; 145 } 146 147 /** 148 * i40e_dcbnl_ieee_setpfc - set local IEEE PFC configuration 149 * @netdev: the corresponding netdev 150 * @pfc: structure to hold the PFC information 151 * 152 * Sets local IEEE PFC configuration 153 **/ 154 static int i40e_dcbnl_ieee_setpfc(struct net_device *netdev, 155 struct ieee_pfc *pfc) 156 { 157 struct i40e_pf *pf = i40e_netdev_to_pf(netdev); 158 struct i40e_dcbx_config *old_cfg; 159 int ret; 160 161 if (!(pf->dcbx_cap & DCB_CAP_DCBX_VER_IEEE) || 162 (pf->dcbx_cap & DCB_CAP_DCBX_LLD_MANAGED)) 163 return -EINVAL; 164 165 old_cfg = &pf->hw.local_dcbx_config; 166 /* Copy current config into temp */ 167 pf->tmp_cfg = *old_cfg; 168 if (pfc->pfc_cap) 169 pf->tmp_cfg.pfc.pfccap = pfc->pfc_cap; 170 else 171 pf->tmp_cfg.pfc.pfccap = I40E_MAX_TRAFFIC_CLASS; 172 pf->tmp_cfg.pfc.pfcenable = pfc->pfc_en; 173 174 ret = i40e_hw_dcb_config(pf, &pf->tmp_cfg); 175 if (ret) { 176 dev_info(&pf->pdev->dev, 177 "Failed setting DCB PFC configuration err %pe aq_err %s\n", 178 ERR_PTR(ret), 179 i40e_aq_str(&pf->hw, pf->hw.aq.asq_last_status)); 180 return -EINVAL; 181 } 182 183 return 0; 184 } 185 186 /** 187 * i40e_dcbnl_ieee_setapp - set local IEEE App configuration 188 * @netdev: the corresponding netdev 189 * @app: structure to hold the Application information 190 * 191 * Sets local IEEE App configuration 192 **/ 193 static int i40e_dcbnl_ieee_setapp(struct net_device *netdev, 194 struct dcb_app *app) 195 { 196 struct i40e_pf *pf = i40e_netdev_to_pf(netdev); 197 struct i40e_dcb_app_priority_table new_app; 198 struct i40e_dcbx_config *old_cfg; 199 int ret; 200 201 if (!(pf->dcbx_cap & DCB_CAP_DCBX_VER_IEEE) || 202 (pf->dcbx_cap & DCB_CAP_DCBX_LLD_MANAGED)) 203 return -EINVAL; 204 205 old_cfg = &pf->hw.local_dcbx_config; 206 if (old_cfg->numapps == I40E_DCBX_MAX_APPS) 207 return -EINVAL; 208 209 ret = dcb_ieee_setapp(netdev, app); 210 if (ret) 211 return ret; 212 213 new_app.selector = app->selector; 214 new_app.protocolid = app->protocol; 215 new_app.priority = app->priority; 216 /* Already internally available */ 217 if (i40e_dcbnl_find_app(old_cfg, &new_app)) 218 return 0; 219 220 /* Copy current config into temp */ 221 pf->tmp_cfg = *old_cfg; 222 /* Add the app */ 223 pf->tmp_cfg.app[pf->tmp_cfg.numapps++] = new_app; 224 225 ret = i40e_hw_dcb_config(pf, &pf->tmp_cfg); 226 if (ret) { 227 dev_info(&pf->pdev->dev, 228 "Failed setting DCB configuration err %pe aq_err %s\n", 229 ERR_PTR(ret), 230 i40e_aq_str(&pf->hw, pf->hw.aq.asq_last_status)); 231 return -EINVAL; 232 } 233 234 return 0; 235 } 236 237 /** 238 * i40e_dcbnl_ieee_delapp - delete local IEEE App configuration 239 * @netdev: the corresponding netdev 240 * @app: structure to hold the Application information 241 * 242 * Deletes local IEEE App configuration other than the first application 243 * required by firmware 244 **/ 245 static int i40e_dcbnl_ieee_delapp(struct net_device *netdev, 246 struct dcb_app *app) 247 { 248 struct i40e_pf *pf = i40e_netdev_to_pf(netdev); 249 struct i40e_dcbx_config *old_cfg; 250 int i, j, ret; 251 252 if (!(pf->dcbx_cap & DCB_CAP_DCBX_VER_IEEE) || 253 (pf->dcbx_cap & DCB_CAP_DCBX_LLD_MANAGED)) 254 return -EINVAL; 255 256 ret = dcb_ieee_delapp(netdev, app); 257 if (ret) 258 return ret; 259 260 old_cfg = &pf->hw.local_dcbx_config; 261 /* Need one app for FW so keep it */ 262 if (old_cfg->numapps == 1) 263 return 0; 264 265 /* Copy current config into temp */ 266 pf->tmp_cfg = *old_cfg; 267 268 /* Find and reset the app */ 269 for (i = 1; i < pf->tmp_cfg.numapps; i++) { 270 if (app->selector == pf->tmp_cfg.app[i].selector && 271 app->protocol == pf->tmp_cfg.app[i].protocolid && 272 app->priority == pf->tmp_cfg.app[i].priority) { 273 /* Reset the app data */ 274 pf->tmp_cfg.app[i].selector = 0; 275 pf->tmp_cfg.app[i].protocolid = 0; 276 pf->tmp_cfg.app[i].priority = 0; 277 break; 278 } 279 } 280 281 /* If the specific DCB app not found */ 282 if (i == pf->tmp_cfg.numapps) 283 return -EINVAL; 284 285 pf->tmp_cfg.numapps--; 286 /* Overwrite the tmp_cfg app */ 287 for (j = i; j < pf->tmp_cfg.numapps; j++) 288 pf->tmp_cfg.app[j] = old_cfg->app[j + 1]; 289 290 ret = i40e_hw_dcb_config(pf, &pf->tmp_cfg); 291 if (ret) { 292 dev_info(&pf->pdev->dev, 293 "Failed setting DCB configuration err %pe aq_err %s\n", 294 ERR_PTR(ret), 295 i40e_aq_str(&pf->hw, pf->hw.aq.asq_last_status)); 296 return -EINVAL; 297 } 298 299 return 0; 300 } 301 302 /** 303 * i40e_dcbnl_getstate - Get DCB enabled state 304 * @netdev: the corresponding netdev 305 * 306 * Get the current DCB enabled state 307 **/ 308 static u8 i40e_dcbnl_getstate(struct net_device *netdev) 309 { 310 struct i40e_pf *pf = i40e_netdev_to_pf(netdev); 311 312 dev_dbg(&pf->pdev->dev, "DCB state=%d\n", 313 !!(pf->flags & I40E_FLAG_DCB_ENABLED)); 314 return !!(pf->flags & I40E_FLAG_DCB_ENABLED); 315 } 316 317 /** 318 * i40e_dcbnl_setstate - Set DCB state 319 * @netdev: the corresponding netdev 320 * @state: enable or disable 321 * 322 * Set the DCB state 323 **/ 324 static u8 i40e_dcbnl_setstate(struct net_device *netdev, u8 state) 325 { 326 struct i40e_pf *pf = i40e_netdev_to_pf(netdev); 327 int ret = I40E_DCBNL_STATUS_SUCCESS; 328 329 if (!(pf->dcbx_cap & DCB_CAP_DCBX_VER_CEE) || 330 (pf->dcbx_cap & DCB_CAP_DCBX_LLD_MANAGED)) 331 return ret; 332 333 dev_dbg(&pf->pdev->dev, "new state=%d current state=%d\n", 334 state, (pf->flags & I40E_FLAG_DCB_ENABLED) ? 1 : 0); 335 /* Nothing to do */ 336 if (!state == !(pf->flags & I40E_FLAG_DCB_ENABLED)) 337 return ret; 338 339 if (i40e_is_sw_dcb(pf)) { 340 if (state) { 341 pf->flags |= I40E_FLAG_DCB_ENABLED; 342 memcpy(&pf->hw.desired_dcbx_config, 343 &pf->hw.local_dcbx_config, 344 sizeof(struct i40e_dcbx_config)); 345 } else { 346 pf->flags &= ~I40E_FLAG_DCB_ENABLED; 347 } 348 } else { 349 /* Cannot directly manipulate FW LLDP Agent */ 350 ret = I40E_DCBNL_STATUS_ERROR; 351 } 352 return ret; 353 } 354 355 /** 356 * i40e_dcbnl_set_pg_tc_cfg_tx - Set CEE PG Tx config 357 * @netdev: the corresponding netdev 358 * @tc: the corresponding traffic class 359 * @prio_type: the traffic priority type 360 * @bwg_id: the BW group id the traffic class belongs to 361 * @bw_pct: the BW percentage for the corresponding BWG 362 * @up_map: prio mapped to corresponding tc 363 * 364 * Set Tx PG settings for CEE mode 365 **/ 366 static void i40e_dcbnl_set_pg_tc_cfg_tx(struct net_device *netdev, int tc, 367 u8 prio_type, u8 bwg_id, u8 bw_pct, 368 u8 up_map) 369 { 370 struct i40e_pf *pf = i40e_netdev_to_pf(netdev); 371 int i; 372 373 if (!(pf->dcbx_cap & DCB_CAP_DCBX_VER_CEE) || 374 (pf->dcbx_cap & DCB_CAP_DCBX_LLD_MANAGED)) 375 return; 376 377 /* LLTC not supported yet */ 378 if (tc >= I40E_MAX_TRAFFIC_CLASS) 379 return; 380 381 /* prio_type, bwg_id and bw_pct per UP are not supported */ 382 383 /* Use only up_map to map tc */ 384 for (i = 0; i < I40E_MAX_TRAFFIC_CLASS; i++) { 385 if (up_map & BIT(i)) 386 pf->tmp_cfg.etscfg.prioritytable[i] = tc; 387 } 388 pf->tmp_cfg.etscfg.tsatable[tc] = I40E_IEEE_TSA_ETS; 389 dev_dbg(&pf->pdev->dev, 390 "Set PG config tc=%d bwg_id=%d prio_type=%d bw_pct=%d up_map=%d\n", 391 tc, bwg_id, prio_type, bw_pct, up_map); 392 } 393 394 /** 395 * i40e_dcbnl_set_pg_bwg_cfg_tx - Set CEE PG Tx BW config 396 * @netdev: the corresponding netdev 397 * @pgid: the corresponding traffic class 398 * @bw_pct: the BW percentage for the specified traffic class 399 * 400 * Set Tx BW settings for CEE mode 401 **/ 402 static void i40e_dcbnl_set_pg_bwg_cfg_tx(struct net_device *netdev, int pgid, 403 u8 bw_pct) 404 { 405 struct i40e_pf *pf = i40e_netdev_to_pf(netdev); 406 407 if (!(pf->dcbx_cap & DCB_CAP_DCBX_VER_CEE) || 408 (pf->dcbx_cap & DCB_CAP_DCBX_LLD_MANAGED)) 409 return; 410 411 /* LLTC not supported yet */ 412 if (pgid >= I40E_MAX_TRAFFIC_CLASS) 413 return; 414 415 pf->tmp_cfg.etscfg.tcbwtable[pgid] = bw_pct; 416 dev_dbg(&pf->pdev->dev, "Set PG BW config tc=%d bw_pct=%d\n", 417 pgid, bw_pct); 418 } 419 420 /** 421 * i40e_dcbnl_set_pg_tc_cfg_rx - Set CEE PG Rx config 422 * @netdev: the corresponding netdev 423 * @prio: the corresponding traffic class 424 * @prio_type: the traffic priority type 425 * @pgid: the BW group id the traffic class belongs to 426 * @bw_pct: the BW percentage for the corresponding BWG 427 * @up_map: prio mapped to corresponding tc 428 * 429 * Set Rx BW settings for CEE mode. The hardware does not support this 430 * so we won't allow setting of this parameter. 431 **/ 432 static void i40e_dcbnl_set_pg_tc_cfg_rx(struct net_device *netdev, 433 int __always_unused prio, 434 u8 __always_unused prio_type, 435 u8 __always_unused pgid, 436 u8 __always_unused bw_pct, 437 u8 __always_unused up_map) 438 { 439 struct i40e_pf *pf = i40e_netdev_to_pf(netdev); 440 441 dev_dbg(&pf->pdev->dev, "Rx TC PG Config Not Supported.\n"); 442 } 443 444 /** 445 * i40e_dcbnl_set_pg_bwg_cfg_rx - Set CEE PG Rx config 446 * @netdev: the corresponding netdev 447 * @pgid: the corresponding traffic class 448 * @bw_pct: the BW percentage for the specified traffic class 449 * 450 * Set Rx BW settings for CEE mode. The hardware does not support this 451 * so we won't allow setting of this parameter. 452 **/ 453 static void i40e_dcbnl_set_pg_bwg_cfg_rx(struct net_device *netdev, int pgid, 454 u8 bw_pct) 455 { 456 struct i40e_pf *pf = i40e_netdev_to_pf(netdev); 457 458 dev_dbg(&pf->pdev->dev, "Rx BWG PG Config Not Supported.\n"); 459 } 460 461 /** 462 * i40e_dcbnl_get_pg_tc_cfg_tx - Get CEE PG Tx config 463 * @netdev: the corresponding netdev 464 * @prio: the corresponding user priority 465 * @prio_type: traffic priority type 466 * @pgid: the BW group ID the traffic class belongs to 467 * @bw_pct: BW percentage for the corresponding BWG 468 * @up_map: prio mapped to corresponding TC 469 * 470 * Get Tx PG settings for CEE mode 471 **/ 472 static void i40e_dcbnl_get_pg_tc_cfg_tx(struct net_device *netdev, int prio, 473 u8 __always_unused *prio_type, 474 u8 *pgid, 475 u8 __always_unused *bw_pct, 476 u8 __always_unused *up_map) 477 { 478 struct i40e_pf *pf = i40e_netdev_to_pf(netdev); 479 480 if (!(pf->dcbx_cap & DCB_CAP_DCBX_VER_CEE) || 481 (pf->dcbx_cap & DCB_CAP_DCBX_LLD_MANAGED)) 482 return; 483 484 if (prio >= I40E_MAX_USER_PRIORITY) 485 return; 486 487 *pgid = pf->hw.local_dcbx_config.etscfg.prioritytable[prio]; 488 dev_dbg(&pf->pdev->dev, "Get PG config prio=%d tc=%d\n", 489 prio, *pgid); 490 } 491 492 /** 493 * i40e_dcbnl_get_pg_bwg_cfg_tx - Get CEE PG BW config 494 * @netdev: the corresponding netdev 495 * @pgid: the corresponding traffic class 496 * @bw_pct: the BW percentage for the corresponding TC 497 * 498 * Get Tx BW settings for given TC in CEE mode 499 **/ 500 static void i40e_dcbnl_get_pg_bwg_cfg_tx(struct net_device *netdev, int pgid, 501 u8 *bw_pct) 502 { 503 struct i40e_pf *pf = i40e_netdev_to_pf(netdev); 504 505 if (!(pf->dcbx_cap & DCB_CAP_DCBX_VER_CEE) || 506 (pf->dcbx_cap & DCB_CAP_DCBX_LLD_MANAGED)) 507 return; 508 509 if (pgid >= I40E_MAX_TRAFFIC_CLASS) 510 return; 511 512 *bw_pct = pf->hw.local_dcbx_config.etscfg.tcbwtable[pgid]; 513 dev_dbg(&pf->pdev->dev, "Get PG BW config tc=%d bw_pct=%d\n", 514 pgid, *bw_pct); 515 } 516 517 /** 518 * i40e_dcbnl_get_pg_tc_cfg_rx - Get CEE PG Rx config 519 * @netdev: the corresponding netdev 520 * @prio: the corresponding user priority 521 * @prio_type: the traffic priority type 522 * @pgid: the PG ID 523 * @bw_pct: the BW percentage for the corresponding BWG 524 * @up_map: prio mapped to corresponding TC 525 * 526 * Get Rx PG settings for CEE mode. The UP2TC map is applied in same 527 * manner for Tx and Rx (symmetrical) so return the TC information for 528 * given priority accordingly. 529 **/ 530 static void i40e_dcbnl_get_pg_tc_cfg_rx(struct net_device *netdev, int prio, 531 u8 *prio_type, u8 *pgid, u8 *bw_pct, 532 u8 *up_map) 533 { 534 struct i40e_pf *pf = i40e_netdev_to_pf(netdev); 535 536 if (!(pf->dcbx_cap & DCB_CAP_DCBX_VER_CEE) || 537 (pf->dcbx_cap & DCB_CAP_DCBX_LLD_MANAGED)) 538 return; 539 540 if (prio >= I40E_MAX_USER_PRIORITY) 541 return; 542 543 *pgid = pf->hw.local_dcbx_config.etscfg.prioritytable[prio]; 544 } 545 546 /** 547 * i40e_dcbnl_get_pg_bwg_cfg_rx - Get CEE PG BW Rx config 548 * @netdev: the corresponding netdev 549 * @pgid: the corresponding traffic class 550 * @bw_pct: the BW percentage for the corresponding TC 551 * 552 * Get Rx BW settings for given TC in CEE mode 553 * The adapter doesn't support Rx ETS and runs in strict priority 554 * mode in Rx path and hence just return 0. 555 **/ 556 static void i40e_dcbnl_get_pg_bwg_cfg_rx(struct net_device *netdev, int pgid, 557 u8 *bw_pct) 558 { 559 struct i40e_pf *pf = i40e_netdev_to_pf(netdev); 560 561 if (!(pf->dcbx_cap & DCB_CAP_DCBX_VER_CEE) || 562 (pf->dcbx_cap & DCB_CAP_DCBX_LLD_MANAGED)) 563 return; 564 *bw_pct = 0; 565 } 566 567 /** 568 * i40e_dcbnl_set_pfc_cfg - Set CEE PFC configuration 569 * @netdev: the corresponding netdev 570 * @prio: the corresponding user priority 571 * @setting: the PFC setting for given priority 572 * 573 * Set the PFC enabled/disabled setting for given user priority 574 **/ 575 static void i40e_dcbnl_set_pfc_cfg(struct net_device *netdev, int prio, 576 u8 setting) 577 { 578 struct i40e_pf *pf = i40e_netdev_to_pf(netdev); 579 580 if (!(pf->dcbx_cap & DCB_CAP_DCBX_VER_CEE) || 581 (pf->dcbx_cap & DCB_CAP_DCBX_LLD_MANAGED)) 582 return; 583 584 if (prio >= I40E_MAX_USER_PRIORITY) 585 return; 586 587 pf->tmp_cfg.pfc.pfccap = I40E_MAX_TRAFFIC_CLASS; 588 if (setting) 589 pf->tmp_cfg.pfc.pfcenable |= BIT(prio); 590 else 591 pf->tmp_cfg.pfc.pfcenable &= ~BIT(prio); 592 dev_dbg(&pf->pdev->dev, 593 "Set PFC Config up=%d setting=%d pfcenable=0x%x\n", 594 prio, setting, pf->tmp_cfg.pfc.pfcenable); 595 } 596 597 /** 598 * i40e_dcbnl_get_pfc_cfg - Get CEE PFC configuration 599 * @netdev: the corresponding netdev 600 * @prio: the corresponding user priority 601 * @setting: the PFC setting for given priority 602 * 603 * Get the PFC enabled/disabled setting for given user priority 604 **/ 605 static void i40e_dcbnl_get_pfc_cfg(struct net_device *netdev, int prio, 606 u8 *setting) 607 { 608 struct i40e_pf *pf = i40e_netdev_to_pf(netdev); 609 610 if (!(pf->dcbx_cap & DCB_CAP_DCBX_VER_CEE) || 611 (pf->dcbx_cap & DCB_CAP_DCBX_LLD_MANAGED)) 612 return; 613 614 if (prio >= I40E_MAX_USER_PRIORITY) 615 return; 616 617 *setting = (pf->hw.local_dcbx_config.pfc.pfcenable >> prio) & 0x1; 618 dev_dbg(&pf->pdev->dev, 619 "Get PFC Config up=%d setting=%d pfcenable=0x%x\n", 620 prio, *setting, pf->hw.local_dcbx_config.pfc.pfcenable); 621 } 622 623 /** 624 * i40e_dcbnl_cee_set_all - Commit CEE DCB settings to hardware 625 * @netdev: the corresponding netdev 626 * 627 * Commit the current DCB configuration to hardware 628 **/ 629 static u8 i40e_dcbnl_cee_set_all(struct net_device *netdev) 630 { 631 struct i40e_pf *pf = i40e_netdev_to_pf(netdev); 632 int err; 633 634 if (!(pf->dcbx_cap & DCB_CAP_DCBX_VER_CEE) || 635 (pf->dcbx_cap & DCB_CAP_DCBX_LLD_MANAGED)) 636 return I40E_DCBNL_STATUS_ERROR; 637 638 dev_dbg(&pf->pdev->dev, "Commit DCB Configuration to the hardware\n"); 639 err = i40e_hw_dcb_config(pf, &pf->tmp_cfg); 640 641 return err ? I40E_DCBNL_STATUS_ERROR : I40E_DCBNL_STATUS_SUCCESS; 642 } 643 644 /** 645 * i40e_dcbnl_get_cap - Get DCBX capabilities of adapter 646 * @netdev: the corresponding netdev 647 * @capid: the capability type 648 * @cap: the capability value 649 * 650 * Return the capability value for a given capability type 651 **/ 652 static u8 i40e_dcbnl_get_cap(struct net_device *netdev, int capid, u8 *cap) 653 { 654 struct i40e_pf *pf = i40e_netdev_to_pf(netdev); 655 656 if (!(pf->flags & I40E_FLAG_DCB_CAPABLE)) 657 return I40E_DCBNL_STATUS_ERROR; 658 659 switch (capid) { 660 case DCB_CAP_ATTR_PG: 661 case DCB_CAP_ATTR_PFC: 662 *cap = true; 663 break; 664 case DCB_CAP_ATTR_PG_TCS: 665 case DCB_CAP_ATTR_PFC_TCS: 666 *cap = 0x80; 667 break; 668 case DCB_CAP_ATTR_DCBX: 669 *cap = pf->dcbx_cap; 670 break; 671 case DCB_CAP_ATTR_UP2TC: 672 case DCB_CAP_ATTR_GSP: 673 case DCB_CAP_ATTR_BCN: 674 default: 675 *cap = false; 676 break; 677 } 678 679 dev_dbg(&pf->pdev->dev, "Get Capability cap=%d capval=0x%x\n", 680 capid, *cap); 681 return I40E_DCBNL_STATUS_SUCCESS; 682 } 683 684 /** 685 * i40e_dcbnl_getnumtcs - Get max number of traffic classes supported 686 * @netdev: the corresponding netdev 687 * @tcid: the TC id 688 * @num: total number of TCs supported by the device 689 * 690 * Return the total number of TCs supported by the adapter 691 **/ 692 static int i40e_dcbnl_getnumtcs(struct net_device *netdev, int tcid, u8 *num) 693 { 694 struct i40e_pf *pf = i40e_netdev_to_pf(netdev); 695 696 if (!(pf->flags & I40E_FLAG_DCB_CAPABLE)) 697 return -EINVAL; 698 699 *num = I40E_MAX_TRAFFIC_CLASS; 700 return 0; 701 } 702 703 /** 704 * i40e_dcbnl_setnumtcs - Set CEE number of traffic classes 705 * @netdev: the corresponding netdev 706 * @tcid: the TC id 707 * @num: total number of TCs 708 * 709 * Set the total number of TCs (Unsupported) 710 **/ 711 static int i40e_dcbnl_setnumtcs(struct net_device *netdev, int tcid, u8 num) 712 { 713 return -EINVAL; 714 } 715 716 /** 717 * i40e_dcbnl_getpfcstate - Get CEE PFC mode 718 * @netdev: the corresponding netdev 719 * 720 * Get the current PFC enabled state 721 **/ 722 static u8 i40e_dcbnl_getpfcstate(struct net_device *netdev) 723 { 724 struct i40e_pf *pf = i40e_netdev_to_pf(netdev); 725 726 /* Return enabled if any PFC enabled UP */ 727 if (pf->hw.local_dcbx_config.pfc.pfcenable) 728 return 1; 729 else 730 return 0; 731 } 732 733 /** 734 * i40e_dcbnl_setpfcstate - Set CEE PFC mode 735 * @netdev: the corresponding netdev 736 * @state: required state 737 * 738 * The PFC state to be set; this is enabled/disabled based on the PFC 739 * priority settings and not via this call for i40e driver 740 **/ 741 static void i40e_dcbnl_setpfcstate(struct net_device *netdev, u8 state) 742 { 743 struct i40e_pf *pf = i40e_netdev_to_pf(netdev); 744 745 dev_dbg(&pf->pdev->dev, "PFC State is modified via PFC config.\n"); 746 } 747 748 /** 749 * i40e_dcbnl_getapp - Get CEE APP 750 * @netdev: the corresponding netdev 751 * @idtype: the App selector 752 * @id: the App ethtype or port number 753 * 754 * Return the CEE mode app for the given idtype and id 755 **/ 756 static int i40e_dcbnl_getapp(struct net_device *netdev, u8 idtype, u16 id) 757 { 758 struct i40e_pf *pf = i40e_netdev_to_pf(netdev); 759 struct dcb_app app = { 760 .selector = idtype, 761 .protocol = id, 762 }; 763 764 if (!(pf->dcbx_cap & DCB_CAP_DCBX_VER_CEE) || 765 (pf->dcbx_cap & DCB_CAP_DCBX_LLD_MANAGED)) 766 return -EINVAL; 767 768 return dcb_getapp(netdev, &app); 769 } 770 771 /** 772 * i40e_dcbnl_setdcbx - set required DCBx capability 773 * @netdev: the corresponding netdev 774 * @mode: new DCB mode managed or CEE+IEEE 775 * 776 * Set DCBx capability features 777 **/ 778 static u8 i40e_dcbnl_setdcbx(struct net_device *netdev, u8 mode) 779 { 780 struct i40e_pf *pf = i40e_netdev_to_pf(netdev); 781 782 /* Do not allow to set mode if managed by Firmware */ 783 if (pf->dcbx_cap & DCB_CAP_DCBX_LLD_MANAGED) 784 return I40E_DCBNL_STATUS_ERROR; 785 786 /* No support for LLD_MANAGED modes or CEE+IEEE */ 787 if ((mode & DCB_CAP_DCBX_LLD_MANAGED) || 788 ((mode & DCB_CAP_DCBX_VER_IEEE) && (mode & DCB_CAP_DCBX_VER_CEE)) || 789 !(mode & DCB_CAP_DCBX_HOST)) 790 return I40E_DCBNL_STATUS_ERROR; 791 792 /* Already set to the given mode no change */ 793 if (mode == pf->dcbx_cap) 794 return I40E_DCBNL_STATUS_SUCCESS; 795 796 pf->dcbx_cap = mode; 797 if (mode & DCB_CAP_DCBX_VER_CEE) 798 pf->hw.local_dcbx_config.dcbx_mode = I40E_DCBX_MODE_CEE; 799 else 800 pf->hw.local_dcbx_config.dcbx_mode = I40E_DCBX_MODE_IEEE; 801 802 dev_dbg(&pf->pdev->dev, "mode=%d\n", mode); 803 return I40E_DCBNL_STATUS_SUCCESS; 804 } 805 806 /** 807 * i40e_dcbnl_getdcbx - retrieve current DCBx capability 808 * @dev: the corresponding netdev 809 * 810 * Returns DCBx capability features 811 **/ 812 static u8 i40e_dcbnl_getdcbx(struct net_device *dev) 813 { 814 struct i40e_pf *pf = i40e_netdev_to_pf(dev); 815 816 return pf->dcbx_cap; 817 } 818 819 /** 820 * i40e_dcbnl_get_perm_hw_addr - MAC address used by DCBx 821 * @dev: the corresponding netdev 822 * @perm_addr: buffer to store the MAC address 823 * 824 * Returns the SAN MAC address used for LLDP exchange 825 **/ 826 static void i40e_dcbnl_get_perm_hw_addr(struct net_device *dev, 827 u8 *perm_addr) 828 { 829 struct i40e_pf *pf = i40e_netdev_to_pf(dev); 830 int i, j; 831 832 memset(perm_addr, 0xff, MAX_ADDR_LEN); 833 834 for (i = 0; i < dev->addr_len; i++) 835 perm_addr[i] = pf->hw.mac.perm_addr[i]; 836 837 for (j = 0; j < dev->addr_len; j++, i++) 838 perm_addr[i] = pf->hw.mac.san_addr[j]; 839 } 840 841 static const struct dcbnl_rtnl_ops dcbnl_ops = { 842 .ieee_getets = i40e_dcbnl_ieee_getets, 843 .ieee_getpfc = i40e_dcbnl_ieee_getpfc, 844 .getdcbx = i40e_dcbnl_getdcbx, 845 .getpermhwaddr = i40e_dcbnl_get_perm_hw_addr, 846 .ieee_setets = i40e_dcbnl_ieee_setets, 847 .ieee_setpfc = i40e_dcbnl_ieee_setpfc, 848 .ieee_setapp = i40e_dcbnl_ieee_setapp, 849 .ieee_delapp = i40e_dcbnl_ieee_delapp, 850 .getstate = i40e_dcbnl_getstate, 851 .setstate = i40e_dcbnl_setstate, 852 .setpgtccfgtx = i40e_dcbnl_set_pg_tc_cfg_tx, 853 .setpgbwgcfgtx = i40e_dcbnl_set_pg_bwg_cfg_tx, 854 .setpgtccfgrx = i40e_dcbnl_set_pg_tc_cfg_rx, 855 .setpgbwgcfgrx = i40e_dcbnl_set_pg_bwg_cfg_rx, 856 .getpgtccfgtx = i40e_dcbnl_get_pg_tc_cfg_tx, 857 .getpgbwgcfgtx = i40e_dcbnl_get_pg_bwg_cfg_tx, 858 .getpgtccfgrx = i40e_dcbnl_get_pg_tc_cfg_rx, 859 .getpgbwgcfgrx = i40e_dcbnl_get_pg_bwg_cfg_rx, 860 .setpfccfg = i40e_dcbnl_set_pfc_cfg, 861 .getpfccfg = i40e_dcbnl_get_pfc_cfg, 862 .setall = i40e_dcbnl_cee_set_all, 863 .getcap = i40e_dcbnl_get_cap, 864 .getnumtcs = i40e_dcbnl_getnumtcs, 865 .setnumtcs = i40e_dcbnl_setnumtcs, 866 .getpfcstate = i40e_dcbnl_getpfcstate, 867 .setpfcstate = i40e_dcbnl_setpfcstate, 868 .getapp = i40e_dcbnl_getapp, 869 .setdcbx = i40e_dcbnl_setdcbx, 870 }; 871 872 /** 873 * i40e_dcbnl_set_all - set all the apps and ieee data from DCBx config 874 * @vsi: the corresponding vsi 875 * 876 * Set up all the IEEE APPs in the DCBNL App Table and generate event for 877 * other settings 878 **/ 879 void i40e_dcbnl_set_all(struct i40e_vsi *vsi) 880 { 881 struct net_device *dev = vsi->netdev; 882 struct i40e_pf *pf = i40e_netdev_to_pf(dev); 883 struct i40e_dcbx_config *dcbxcfg; 884 struct i40e_hw *hw = &pf->hw; 885 struct dcb_app sapp; 886 u8 prio, tc_map; 887 int i; 888 889 /* SW DCB taken care by DCBNL set calls */ 890 if (pf->dcbx_cap & DCB_CAP_DCBX_HOST) 891 return; 892 893 /* DCB not enabled */ 894 if (!(pf->flags & I40E_FLAG_DCB_ENABLED)) 895 return; 896 897 /* MFP mode but not an iSCSI PF so return */ 898 if ((pf->flags & I40E_FLAG_MFP_ENABLED) && !(hw->func_caps.iscsi)) 899 return; 900 901 dcbxcfg = &hw->local_dcbx_config; 902 903 /* Set up all the App TLVs if DCBx is negotiated */ 904 for (i = 0; i < dcbxcfg->numapps; i++) { 905 prio = dcbxcfg->app[i].priority; 906 tc_map = BIT(dcbxcfg->etscfg.prioritytable[prio]); 907 908 /* Add APP only if the TC is enabled for this VSI */ 909 if (tc_map & vsi->tc_config.enabled_tc) { 910 sapp.selector = dcbxcfg->app[i].selector; 911 sapp.protocol = dcbxcfg->app[i].protocolid; 912 sapp.priority = prio; 913 dcb_ieee_setapp(dev, &sapp); 914 } 915 } 916 917 /* Notify user-space of the changes */ 918 dcbnl_ieee_notify(dev, RTM_SETDCB, DCB_CMD_IEEE_SET, 0, 0); 919 } 920 921 /** 922 * i40e_dcbnl_vsi_del_app - Delete APP for given VSI 923 * @vsi: the corresponding vsi 924 * @app: APP to delete 925 * 926 * Delete given APP from the DCBNL APP table for given 927 * VSI 928 **/ 929 static int i40e_dcbnl_vsi_del_app(struct i40e_vsi *vsi, 930 struct i40e_dcb_app_priority_table *app) 931 { 932 struct net_device *dev = vsi->netdev; 933 struct dcb_app sapp; 934 935 if (!dev) 936 return -EINVAL; 937 938 sapp.selector = app->selector; 939 sapp.protocol = app->protocolid; 940 sapp.priority = app->priority; 941 return dcb_ieee_delapp(dev, &sapp); 942 } 943 944 /** 945 * i40e_dcbnl_del_app - Delete APP on all VSIs 946 * @pf: the corresponding PF 947 * @app: APP to delete 948 * 949 * Delete given APP from all the VSIs for given PF 950 **/ 951 static void i40e_dcbnl_del_app(struct i40e_pf *pf, 952 struct i40e_dcb_app_priority_table *app) 953 { 954 int v, err; 955 956 for (v = 0; v < pf->num_alloc_vsi; v++) { 957 if (pf->vsi[v] && pf->vsi[v]->netdev) { 958 err = i40e_dcbnl_vsi_del_app(pf->vsi[v], app); 959 dev_dbg(&pf->pdev->dev, "Deleting app for VSI seid=%d err=%d sel=%d proto=0x%x prio=%d\n", 960 pf->vsi[v]->seid, err, app->selector, 961 app->protocolid, app->priority); 962 } 963 } 964 } 965 966 /** 967 * i40e_dcbnl_find_app - Search APP in given DCB config 968 * @cfg: DCBX configuration data 969 * @app: APP to search for 970 * 971 * Find given APP in the DCB configuration 972 **/ 973 static bool i40e_dcbnl_find_app(struct i40e_dcbx_config *cfg, 974 struct i40e_dcb_app_priority_table *app) 975 { 976 int i; 977 978 for (i = 0; i < cfg->numapps; i++) { 979 if (app->selector == cfg->app[i].selector && 980 app->protocolid == cfg->app[i].protocolid && 981 app->priority == cfg->app[i].priority) 982 return true; 983 } 984 985 return false; 986 } 987 988 /** 989 * i40e_dcbnl_flush_apps - Delete all removed APPs 990 * @pf: the corresponding PF 991 * @old_cfg: old DCBX configuration data 992 * @new_cfg: new DCBX configuration data 993 * 994 * Find and delete all APPs that are not present in the passed 995 * DCB configuration 996 **/ 997 void i40e_dcbnl_flush_apps(struct i40e_pf *pf, 998 struct i40e_dcbx_config *old_cfg, 999 struct i40e_dcbx_config *new_cfg) 1000 { 1001 struct i40e_dcb_app_priority_table app; 1002 int i; 1003 1004 /* MFP mode but not an iSCSI PF so return */ 1005 if ((pf->flags & I40E_FLAG_MFP_ENABLED) && !(pf->hw.func_caps.iscsi)) 1006 return; 1007 1008 for (i = 0; i < old_cfg->numapps; i++) { 1009 app = old_cfg->app[i]; 1010 /* The APP is not available anymore delete it */ 1011 if (!i40e_dcbnl_find_app(new_cfg, &app)) 1012 i40e_dcbnl_del_app(pf, &app); 1013 } 1014 } 1015 1016 /** 1017 * i40e_dcbnl_setup - DCBNL setup 1018 * @vsi: the corresponding vsi 1019 * 1020 * Set up DCBNL ops and initial APP TLVs 1021 **/ 1022 void i40e_dcbnl_setup(struct i40e_vsi *vsi) 1023 { 1024 struct net_device *dev = vsi->netdev; 1025 struct i40e_pf *pf = i40e_netdev_to_pf(dev); 1026 1027 /* Not DCB capable */ 1028 if (!(pf->flags & I40E_FLAG_DCB_CAPABLE)) 1029 return; 1030 1031 dev->dcbnl_ops = &dcbnl_ops; 1032 1033 /* Set initial IEEE DCB settings */ 1034 i40e_dcbnl_set_all(vsi); 1035 } 1036 #endif /* CONFIG_I40E_DCB */ 1037