1 // SPDX-License-Identifier: GPL-2.0 2 /* Copyright (c) 2019, Intel Corporation. */ 3 4 #include "ice_common.h" 5 #include "ice_sched.h" 6 #include "ice_dcb.h" 7 8 /** 9 * ice_aq_get_lldp_mib 10 * @hw: pointer to the HW struct 11 * @bridge_type: type of bridge requested 12 * @mib_type: Local, Remote or both Local and Remote MIBs 13 * @buf: pointer to the caller-supplied buffer to store the MIB block 14 * @buf_size: size of the buffer (in bytes) 15 * @local_len: length of the returned Local LLDP MIB 16 * @remote_len: length of the returned Remote LLDP MIB 17 * @cd: pointer to command details structure or NULL 18 * 19 * Requests the complete LLDP MIB (entire packet). (0x0A00) 20 */ 21 static int 22 ice_aq_get_lldp_mib(struct ice_hw *hw, u8 bridge_type, u8 mib_type, void *buf, 23 u16 buf_size, u16 *local_len, u16 *remote_len, 24 struct ice_sq_cd *cd) 25 { 26 struct ice_aqc_lldp_get_mib *cmd; 27 struct ice_aq_desc desc; 28 int status; 29 30 cmd = &desc.params.lldp_get_mib; 31 32 if (buf_size == 0 || !buf) 33 return -EINVAL; 34 35 ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_lldp_get_mib); 36 37 cmd->type = mib_type & ICE_AQ_LLDP_MIB_TYPE_M; 38 cmd->type |= (bridge_type << ICE_AQ_LLDP_BRID_TYPE_S) & 39 ICE_AQ_LLDP_BRID_TYPE_M; 40 41 desc.datalen = cpu_to_le16(buf_size); 42 43 status = ice_aq_send_cmd(hw, &desc, buf, buf_size, cd); 44 if (!status) { 45 if (local_len) 46 *local_len = le16_to_cpu(cmd->local_len); 47 if (remote_len) 48 *remote_len = le16_to_cpu(cmd->remote_len); 49 } 50 51 return status; 52 } 53 54 /** 55 * ice_aq_cfg_lldp_mib_change 56 * @hw: pointer to the HW struct 57 * @ena_update: Enable or Disable event posting 58 * @cd: pointer to command details structure or NULL 59 * 60 * Enable or Disable posting of an event on ARQ when LLDP MIB 61 * associated with the interface changes (0x0A01) 62 */ 63 static int 64 ice_aq_cfg_lldp_mib_change(struct ice_hw *hw, bool ena_update, 65 struct ice_sq_cd *cd) 66 { 67 struct ice_aqc_lldp_set_mib_change *cmd; 68 struct ice_aq_desc desc; 69 70 cmd = &desc.params.lldp_set_event; 71 72 ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_lldp_set_mib_change); 73 74 if (!ena_update) 75 cmd->command |= ICE_AQ_LLDP_MIB_UPDATE_DIS; 76 77 return ice_aq_send_cmd(hw, &desc, NULL, 0, cd); 78 } 79 80 /** 81 * ice_aq_stop_lldp 82 * @hw: pointer to the HW struct 83 * @shutdown_lldp_agent: True if LLDP Agent needs to be Shutdown 84 * False if LLDP Agent needs to be Stopped 85 * @persist: True if Stop/Shutdown of LLDP Agent needs to be persistent across 86 * reboots 87 * @cd: pointer to command details structure or NULL 88 * 89 * Stop or Shutdown the embedded LLDP Agent (0x0A05) 90 */ 91 int 92 ice_aq_stop_lldp(struct ice_hw *hw, bool shutdown_lldp_agent, bool persist, 93 struct ice_sq_cd *cd) 94 { 95 struct ice_aqc_lldp_stop *cmd; 96 struct ice_aq_desc desc; 97 98 cmd = &desc.params.lldp_stop; 99 100 ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_lldp_stop); 101 102 if (shutdown_lldp_agent) 103 cmd->command |= ICE_AQ_LLDP_AGENT_SHUTDOWN; 104 105 if (persist) 106 cmd->command |= ICE_AQ_LLDP_AGENT_PERSIST_DIS; 107 108 return ice_aq_send_cmd(hw, &desc, NULL, 0, cd); 109 } 110 111 /** 112 * ice_aq_start_lldp 113 * @hw: pointer to the HW struct 114 * @persist: True if Start of LLDP Agent needs to be persistent across reboots 115 * @cd: pointer to command details structure or NULL 116 * 117 * Start the embedded LLDP Agent on all ports. (0x0A06) 118 */ 119 int ice_aq_start_lldp(struct ice_hw *hw, bool persist, struct ice_sq_cd *cd) 120 { 121 struct ice_aqc_lldp_start *cmd; 122 struct ice_aq_desc desc; 123 124 cmd = &desc.params.lldp_start; 125 126 ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_lldp_start); 127 128 cmd->command = ICE_AQ_LLDP_AGENT_START; 129 130 if (persist) 131 cmd->command |= ICE_AQ_LLDP_AGENT_PERSIST_ENA; 132 133 return ice_aq_send_cmd(hw, &desc, NULL, 0, cd); 134 } 135 136 /** 137 * ice_get_dcbx_status 138 * @hw: pointer to the HW struct 139 * 140 * Get the DCBX status from the Firmware 141 */ 142 static u8 ice_get_dcbx_status(struct ice_hw *hw) 143 { 144 u32 reg; 145 146 reg = rd32(hw, PRTDCB_GENS); 147 return (u8)((reg & PRTDCB_GENS_DCBX_STATUS_M) >> 148 PRTDCB_GENS_DCBX_STATUS_S); 149 } 150 151 /** 152 * ice_parse_ieee_ets_common_tlv 153 * @buf: Data buffer to be parsed for ETS CFG/REC data 154 * @ets_cfg: Container to store parsed data 155 * 156 * Parses the common data of IEEE 802.1Qaz ETS CFG/REC TLV 157 */ 158 static void 159 ice_parse_ieee_ets_common_tlv(u8 *buf, struct ice_dcb_ets_cfg *ets_cfg) 160 { 161 u8 offset = 0; 162 int i; 163 164 /* Priority Assignment Table (4 octets) 165 * Octets:| 1 | 2 | 3 | 4 | 166 * ----------------------------------------- 167 * |pri0|pri1|pri2|pri3|pri4|pri5|pri6|pri7| 168 * ----------------------------------------- 169 * Bits:|7 4|3 0|7 4|3 0|7 4|3 0|7 4|3 0| 170 * ----------------------------------------- 171 */ 172 for (i = 0; i < 4; i++) { 173 ets_cfg->prio_table[i * 2] = 174 ((buf[offset] & ICE_IEEE_ETS_PRIO_1_M) >> 175 ICE_IEEE_ETS_PRIO_1_S); 176 ets_cfg->prio_table[i * 2 + 1] = 177 ((buf[offset] & ICE_IEEE_ETS_PRIO_0_M) >> 178 ICE_IEEE_ETS_PRIO_0_S); 179 offset++; 180 } 181 182 /* TC Bandwidth Table (8 octets) 183 * Octets:| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 184 * --------------------------------- 185 * |tc0|tc1|tc2|tc3|tc4|tc5|tc6|tc7| 186 * --------------------------------- 187 * 188 * TSA Assignment Table (8 octets) 189 * Octets:| 9 | 10| 11| 12| 13| 14| 15| 16| 190 * --------------------------------- 191 * |tc0|tc1|tc2|tc3|tc4|tc5|tc6|tc7| 192 * --------------------------------- 193 */ 194 ice_for_each_traffic_class(i) { 195 ets_cfg->tcbwtable[i] = buf[offset]; 196 ets_cfg->tsatable[i] = buf[ICE_MAX_TRAFFIC_CLASS + offset++]; 197 } 198 } 199 200 /** 201 * ice_parse_ieee_etscfg_tlv 202 * @tlv: IEEE 802.1Qaz ETS CFG TLV 203 * @dcbcfg: Local store to update ETS CFG data 204 * 205 * Parses IEEE 802.1Qaz ETS CFG TLV 206 */ 207 static void 208 ice_parse_ieee_etscfg_tlv(struct ice_lldp_org_tlv *tlv, 209 struct ice_dcbx_cfg *dcbcfg) 210 { 211 struct ice_dcb_ets_cfg *etscfg; 212 u8 *buf = tlv->tlvinfo; 213 214 /* First Octet post subtype 215 * -------------------------- 216 * |will-|CBS | Re- | Max | 217 * |ing | |served| TCs | 218 * -------------------------- 219 * |1bit | 1bit|3 bits|3bits| 220 */ 221 etscfg = &dcbcfg->etscfg; 222 etscfg->willing = ((buf[0] & ICE_IEEE_ETS_WILLING_M) >> 223 ICE_IEEE_ETS_WILLING_S); 224 etscfg->cbs = ((buf[0] & ICE_IEEE_ETS_CBS_M) >> ICE_IEEE_ETS_CBS_S); 225 etscfg->maxtcs = ((buf[0] & ICE_IEEE_ETS_MAXTC_M) >> 226 ICE_IEEE_ETS_MAXTC_S); 227 228 /* Begin parsing at Priority Assignment Table (offset 1 in buf) */ 229 ice_parse_ieee_ets_common_tlv(&buf[1], etscfg); 230 } 231 232 /** 233 * ice_parse_ieee_etsrec_tlv 234 * @tlv: IEEE 802.1Qaz ETS REC TLV 235 * @dcbcfg: Local store to update ETS REC data 236 * 237 * Parses IEEE 802.1Qaz ETS REC TLV 238 */ 239 static void 240 ice_parse_ieee_etsrec_tlv(struct ice_lldp_org_tlv *tlv, 241 struct ice_dcbx_cfg *dcbcfg) 242 { 243 u8 *buf = tlv->tlvinfo; 244 245 /* Begin parsing at Priority Assignment Table (offset 1 in buf) */ 246 ice_parse_ieee_ets_common_tlv(&buf[1], &dcbcfg->etsrec); 247 } 248 249 /** 250 * ice_parse_ieee_pfccfg_tlv 251 * @tlv: IEEE 802.1Qaz PFC CFG TLV 252 * @dcbcfg: Local store to update PFC CFG data 253 * 254 * Parses IEEE 802.1Qaz PFC CFG TLV 255 */ 256 static void 257 ice_parse_ieee_pfccfg_tlv(struct ice_lldp_org_tlv *tlv, 258 struct ice_dcbx_cfg *dcbcfg) 259 { 260 u8 *buf = tlv->tlvinfo; 261 262 /* ---------------------------------------- 263 * |will-|MBC | Re- | PFC | PFC Enable | 264 * |ing | |served| cap | | 265 * ----------------------------------------- 266 * |1bit | 1bit|2 bits|4bits| 1 octet | 267 */ 268 dcbcfg->pfc.willing = ((buf[0] & ICE_IEEE_PFC_WILLING_M) >> 269 ICE_IEEE_PFC_WILLING_S); 270 dcbcfg->pfc.mbc = ((buf[0] & ICE_IEEE_PFC_MBC_M) >> ICE_IEEE_PFC_MBC_S); 271 dcbcfg->pfc.pfccap = ((buf[0] & ICE_IEEE_PFC_CAP_M) >> 272 ICE_IEEE_PFC_CAP_S); 273 dcbcfg->pfc.pfcena = buf[1]; 274 } 275 276 /** 277 * ice_parse_ieee_app_tlv 278 * @tlv: IEEE 802.1Qaz APP TLV 279 * @dcbcfg: Local store to update APP PRIO data 280 * 281 * Parses IEEE 802.1Qaz APP PRIO TLV 282 */ 283 static void 284 ice_parse_ieee_app_tlv(struct ice_lldp_org_tlv *tlv, 285 struct ice_dcbx_cfg *dcbcfg) 286 { 287 u16 offset = 0; 288 u16 typelen; 289 int i = 0; 290 u16 len; 291 u8 *buf; 292 293 typelen = ntohs(tlv->typelen); 294 len = ((typelen & ICE_LLDP_TLV_LEN_M) >> ICE_LLDP_TLV_LEN_S); 295 buf = tlv->tlvinfo; 296 297 /* Removing sizeof(ouisubtype) and reserved byte from len. 298 * Remaining len div 3 is number of APP TLVs. 299 */ 300 len -= (sizeof(tlv->ouisubtype) + 1); 301 302 /* Move offset to App Priority Table */ 303 offset++; 304 305 /* Application Priority Table (3 octets) 306 * Octets:| 1 | 2 | 3 | 307 * ----------------------------------------- 308 * |Priority|Rsrvd| Sel | Protocol ID | 309 * ----------------------------------------- 310 * Bits:|23 21|20 19|18 16|15 0| 311 * ----------------------------------------- 312 */ 313 while (offset < len) { 314 dcbcfg->app[i].priority = ((buf[offset] & 315 ICE_IEEE_APP_PRIO_M) >> 316 ICE_IEEE_APP_PRIO_S); 317 dcbcfg->app[i].selector = ((buf[offset] & 318 ICE_IEEE_APP_SEL_M) >> 319 ICE_IEEE_APP_SEL_S); 320 dcbcfg->app[i].prot_id = (buf[offset + 1] << 0x8) | 321 buf[offset + 2]; 322 /* Move to next app */ 323 offset += 3; 324 i++; 325 if (i >= ICE_DCBX_MAX_APPS) 326 break; 327 } 328 329 dcbcfg->numapps = i; 330 } 331 332 /** 333 * ice_parse_ieee_tlv 334 * @tlv: IEEE 802.1Qaz TLV 335 * @dcbcfg: Local store to update ETS REC data 336 * 337 * Get the TLV subtype and send it to parsing function 338 * based on the subtype value 339 */ 340 static void 341 ice_parse_ieee_tlv(struct ice_lldp_org_tlv *tlv, struct ice_dcbx_cfg *dcbcfg) 342 { 343 u32 ouisubtype; 344 u8 subtype; 345 346 ouisubtype = ntohl(tlv->ouisubtype); 347 subtype = (u8)((ouisubtype & ICE_LLDP_TLV_SUBTYPE_M) >> 348 ICE_LLDP_TLV_SUBTYPE_S); 349 switch (subtype) { 350 case ICE_IEEE_SUBTYPE_ETS_CFG: 351 ice_parse_ieee_etscfg_tlv(tlv, dcbcfg); 352 break; 353 case ICE_IEEE_SUBTYPE_ETS_REC: 354 ice_parse_ieee_etsrec_tlv(tlv, dcbcfg); 355 break; 356 case ICE_IEEE_SUBTYPE_PFC_CFG: 357 ice_parse_ieee_pfccfg_tlv(tlv, dcbcfg); 358 break; 359 case ICE_IEEE_SUBTYPE_APP_PRI: 360 ice_parse_ieee_app_tlv(tlv, dcbcfg); 361 break; 362 default: 363 break; 364 } 365 } 366 367 /** 368 * ice_parse_cee_pgcfg_tlv 369 * @tlv: CEE DCBX PG CFG TLV 370 * @dcbcfg: Local store to update ETS CFG data 371 * 372 * Parses CEE DCBX PG CFG TLV 373 */ 374 static void 375 ice_parse_cee_pgcfg_tlv(struct ice_cee_feat_tlv *tlv, 376 struct ice_dcbx_cfg *dcbcfg) 377 { 378 struct ice_dcb_ets_cfg *etscfg; 379 u8 *buf = tlv->tlvinfo; 380 u16 offset = 0; 381 int i; 382 383 etscfg = &dcbcfg->etscfg; 384 385 if (tlv->en_will_err & ICE_CEE_FEAT_TLV_WILLING_M) 386 etscfg->willing = 1; 387 388 etscfg->cbs = 0; 389 /* Priority Group Table (4 octets) 390 * Octets:| 1 | 2 | 3 | 4 | 391 * ----------------------------------------- 392 * |pri0|pri1|pri2|pri3|pri4|pri5|pri6|pri7| 393 * ----------------------------------------- 394 * Bits:|7 4|3 0|7 4|3 0|7 4|3 0|7 4|3 0| 395 * ----------------------------------------- 396 */ 397 for (i = 0; i < 4; i++) { 398 etscfg->prio_table[i * 2] = 399 ((buf[offset] & ICE_CEE_PGID_PRIO_1_M) >> 400 ICE_CEE_PGID_PRIO_1_S); 401 etscfg->prio_table[i * 2 + 1] = 402 ((buf[offset] & ICE_CEE_PGID_PRIO_0_M) >> 403 ICE_CEE_PGID_PRIO_0_S); 404 offset++; 405 } 406 407 /* PG Percentage Table (8 octets) 408 * Octets:| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 409 * --------------------------------- 410 * |pg0|pg1|pg2|pg3|pg4|pg5|pg6|pg7| 411 * --------------------------------- 412 */ 413 ice_for_each_traffic_class(i) { 414 etscfg->tcbwtable[i] = buf[offset++]; 415 416 if (etscfg->prio_table[i] == ICE_CEE_PGID_STRICT) 417 dcbcfg->etscfg.tsatable[i] = ICE_IEEE_TSA_STRICT; 418 else 419 dcbcfg->etscfg.tsatable[i] = ICE_IEEE_TSA_ETS; 420 } 421 422 /* Number of TCs supported (1 octet) */ 423 etscfg->maxtcs = buf[offset]; 424 } 425 426 /** 427 * ice_parse_cee_pfccfg_tlv 428 * @tlv: CEE DCBX PFC CFG TLV 429 * @dcbcfg: Local store to update PFC CFG data 430 * 431 * Parses CEE DCBX PFC CFG TLV 432 */ 433 static void 434 ice_parse_cee_pfccfg_tlv(struct ice_cee_feat_tlv *tlv, 435 struct ice_dcbx_cfg *dcbcfg) 436 { 437 u8 *buf = tlv->tlvinfo; 438 439 if (tlv->en_will_err & ICE_CEE_FEAT_TLV_WILLING_M) 440 dcbcfg->pfc.willing = 1; 441 442 /* ------------------------ 443 * | PFC Enable | PFC TCs | 444 * ------------------------ 445 * | 1 octet | 1 octet | 446 */ 447 dcbcfg->pfc.pfcena = buf[0]; 448 dcbcfg->pfc.pfccap = buf[1]; 449 } 450 451 /** 452 * ice_parse_cee_app_tlv 453 * @tlv: CEE DCBX APP TLV 454 * @dcbcfg: Local store to update APP PRIO data 455 * 456 * Parses CEE DCBX APP PRIO TLV 457 */ 458 static void 459 ice_parse_cee_app_tlv(struct ice_cee_feat_tlv *tlv, struct ice_dcbx_cfg *dcbcfg) 460 { 461 u16 len, typelen, offset = 0; 462 struct ice_cee_app_prio *app; 463 u8 i; 464 465 typelen = ntohs(tlv->hdr.typelen); 466 len = ((typelen & ICE_LLDP_TLV_LEN_M) >> ICE_LLDP_TLV_LEN_S); 467 468 dcbcfg->numapps = len / sizeof(*app); 469 if (!dcbcfg->numapps) 470 return; 471 if (dcbcfg->numapps > ICE_DCBX_MAX_APPS) 472 dcbcfg->numapps = ICE_DCBX_MAX_APPS; 473 474 for (i = 0; i < dcbcfg->numapps; i++) { 475 u8 up, selector; 476 477 app = (struct ice_cee_app_prio *)(tlv->tlvinfo + offset); 478 for (up = 0; up < ICE_MAX_USER_PRIORITY; up++) 479 if (app->prio_map & BIT(up)) 480 break; 481 482 dcbcfg->app[i].priority = up; 483 484 /* Get Selector from lower 2 bits, and convert to IEEE */ 485 selector = (app->upper_oui_sel & ICE_CEE_APP_SELECTOR_M); 486 switch (selector) { 487 case ICE_CEE_APP_SEL_ETHTYPE: 488 dcbcfg->app[i].selector = ICE_APP_SEL_ETHTYPE; 489 break; 490 case ICE_CEE_APP_SEL_TCPIP: 491 dcbcfg->app[i].selector = ICE_APP_SEL_TCPIP; 492 break; 493 default: 494 /* Keep selector as it is for unknown types */ 495 dcbcfg->app[i].selector = selector; 496 } 497 498 dcbcfg->app[i].prot_id = ntohs(app->protocol); 499 /* Move to next app */ 500 offset += sizeof(*app); 501 } 502 } 503 504 /** 505 * ice_parse_cee_tlv 506 * @tlv: CEE DCBX TLV 507 * @dcbcfg: Local store to update DCBX config data 508 * 509 * Get the TLV subtype and send it to parsing function 510 * based on the subtype value 511 */ 512 static void 513 ice_parse_cee_tlv(struct ice_lldp_org_tlv *tlv, struct ice_dcbx_cfg *dcbcfg) 514 { 515 struct ice_cee_feat_tlv *sub_tlv; 516 u8 subtype, feat_tlv_count = 0; 517 u16 len, tlvlen, typelen; 518 u32 ouisubtype; 519 520 ouisubtype = ntohl(tlv->ouisubtype); 521 subtype = (u8)((ouisubtype & ICE_LLDP_TLV_SUBTYPE_M) >> 522 ICE_LLDP_TLV_SUBTYPE_S); 523 /* Return if not CEE DCBX */ 524 if (subtype != ICE_CEE_DCBX_TYPE) 525 return; 526 527 typelen = ntohs(tlv->typelen); 528 tlvlen = ((typelen & ICE_LLDP_TLV_LEN_M) >> ICE_LLDP_TLV_LEN_S); 529 len = sizeof(tlv->typelen) + sizeof(ouisubtype) + 530 sizeof(struct ice_cee_ctrl_tlv); 531 /* Return if no CEE DCBX Feature TLVs */ 532 if (tlvlen <= len) 533 return; 534 535 sub_tlv = (struct ice_cee_feat_tlv *)((char *)tlv + len); 536 while (feat_tlv_count < ICE_CEE_MAX_FEAT_TYPE) { 537 u16 sublen; 538 539 typelen = ntohs(sub_tlv->hdr.typelen); 540 sublen = ((typelen & ICE_LLDP_TLV_LEN_M) >> ICE_LLDP_TLV_LEN_S); 541 subtype = (u8)((typelen & ICE_LLDP_TLV_TYPE_M) >> 542 ICE_LLDP_TLV_TYPE_S); 543 switch (subtype) { 544 case ICE_CEE_SUBTYPE_PG_CFG: 545 ice_parse_cee_pgcfg_tlv(sub_tlv, dcbcfg); 546 break; 547 case ICE_CEE_SUBTYPE_PFC_CFG: 548 ice_parse_cee_pfccfg_tlv(sub_tlv, dcbcfg); 549 break; 550 case ICE_CEE_SUBTYPE_APP_PRI: 551 ice_parse_cee_app_tlv(sub_tlv, dcbcfg); 552 break; 553 default: 554 return; /* Invalid Sub-type return */ 555 } 556 feat_tlv_count++; 557 /* Move to next sub TLV */ 558 sub_tlv = (struct ice_cee_feat_tlv *) 559 ((char *)sub_tlv + sizeof(sub_tlv->hdr.typelen) + 560 sublen); 561 } 562 } 563 564 /** 565 * ice_parse_org_tlv 566 * @tlv: Organization specific TLV 567 * @dcbcfg: Local store to update ETS REC data 568 * 569 * Currently only IEEE 802.1Qaz TLV is supported, all others 570 * will be returned 571 */ 572 static void 573 ice_parse_org_tlv(struct ice_lldp_org_tlv *tlv, struct ice_dcbx_cfg *dcbcfg) 574 { 575 u32 ouisubtype; 576 u32 oui; 577 578 ouisubtype = ntohl(tlv->ouisubtype); 579 oui = ((ouisubtype & ICE_LLDP_TLV_OUI_M) >> ICE_LLDP_TLV_OUI_S); 580 switch (oui) { 581 case ICE_IEEE_8021QAZ_OUI: 582 ice_parse_ieee_tlv(tlv, dcbcfg); 583 break; 584 case ICE_CEE_DCBX_OUI: 585 ice_parse_cee_tlv(tlv, dcbcfg); 586 break; 587 default: 588 break; 589 } 590 } 591 592 /** 593 * ice_lldp_to_dcb_cfg 594 * @lldpmib: LLDPDU to be parsed 595 * @dcbcfg: store for LLDPDU data 596 * 597 * Parse DCB configuration from the LLDPDU 598 */ 599 static int ice_lldp_to_dcb_cfg(u8 *lldpmib, struct ice_dcbx_cfg *dcbcfg) 600 { 601 struct ice_lldp_org_tlv *tlv; 602 u16 offset = 0; 603 int ret = 0; 604 u16 typelen; 605 u16 type; 606 u16 len; 607 608 if (!lldpmib || !dcbcfg) 609 return -EINVAL; 610 611 /* set to the start of LLDPDU */ 612 lldpmib += ETH_HLEN; 613 tlv = (struct ice_lldp_org_tlv *)lldpmib; 614 while (1) { 615 typelen = ntohs(tlv->typelen); 616 type = ((typelen & ICE_LLDP_TLV_TYPE_M) >> ICE_LLDP_TLV_TYPE_S); 617 len = ((typelen & ICE_LLDP_TLV_LEN_M) >> ICE_LLDP_TLV_LEN_S); 618 offset += sizeof(typelen) + len; 619 620 /* END TLV or beyond LLDPDU size */ 621 if (type == ICE_TLV_TYPE_END || offset > ICE_LLDPDU_SIZE) 622 break; 623 624 switch (type) { 625 case ICE_TLV_TYPE_ORG: 626 ice_parse_org_tlv(tlv, dcbcfg); 627 break; 628 default: 629 break; 630 } 631 632 /* Move to next TLV */ 633 tlv = (struct ice_lldp_org_tlv *) 634 ((char *)tlv + sizeof(tlv->typelen) + len); 635 } 636 637 return ret; 638 } 639 640 /** 641 * ice_aq_get_dcb_cfg 642 * @hw: pointer to the HW struct 643 * @mib_type: MIB type for the query 644 * @bridgetype: bridge type for the query (remote) 645 * @dcbcfg: store for LLDPDU data 646 * 647 * Query DCB configuration from the firmware 648 */ 649 int 650 ice_aq_get_dcb_cfg(struct ice_hw *hw, u8 mib_type, u8 bridgetype, 651 struct ice_dcbx_cfg *dcbcfg) 652 { 653 u8 *lldpmib; 654 int ret; 655 656 /* Allocate the LLDPDU */ 657 lldpmib = devm_kzalloc(ice_hw_to_dev(hw), ICE_LLDPDU_SIZE, GFP_KERNEL); 658 if (!lldpmib) 659 return -ENOMEM; 660 661 ret = ice_aq_get_lldp_mib(hw, bridgetype, mib_type, (void *)lldpmib, 662 ICE_LLDPDU_SIZE, NULL, NULL, NULL); 663 664 if (!ret) 665 /* Parse LLDP MIB to get DCB configuration */ 666 ret = ice_lldp_to_dcb_cfg(lldpmib, dcbcfg); 667 668 devm_kfree(ice_hw_to_dev(hw), lldpmib); 669 670 return ret; 671 } 672 673 /** 674 * ice_aq_start_stop_dcbx - Start/Stop DCBX service in FW 675 * @hw: pointer to the HW struct 676 * @start_dcbx_agent: True if DCBX Agent needs to be started 677 * False if DCBX Agent needs to be stopped 678 * @dcbx_agent_status: FW indicates back the DCBX agent status 679 * True if DCBX Agent is active 680 * False if DCBX Agent is stopped 681 * @cd: pointer to command details structure or NULL 682 * 683 * Start/Stop the embedded dcbx Agent. In case that this wrapper function 684 * returns 0, caller will need to check if FW returns back the same 685 * value as stated in dcbx_agent_status, and react accordingly. (0x0A09) 686 */ 687 int 688 ice_aq_start_stop_dcbx(struct ice_hw *hw, bool start_dcbx_agent, 689 bool *dcbx_agent_status, struct ice_sq_cd *cd) 690 { 691 struct ice_aqc_lldp_stop_start_specific_agent *cmd; 692 struct ice_aq_desc desc; 693 u16 opcode; 694 int status; 695 696 cmd = &desc.params.lldp_agent_ctrl; 697 698 opcode = ice_aqc_opc_lldp_stop_start_specific_agent; 699 700 ice_fill_dflt_direct_cmd_desc(&desc, opcode); 701 702 if (start_dcbx_agent) 703 cmd->command = ICE_AQC_START_STOP_AGENT_START_DCBX; 704 705 status = ice_aq_send_cmd(hw, &desc, NULL, 0, cd); 706 707 *dcbx_agent_status = false; 708 709 if (!status && 710 cmd->command == ICE_AQC_START_STOP_AGENT_START_DCBX) 711 *dcbx_agent_status = true; 712 713 return status; 714 } 715 716 /** 717 * ice_aq_get_cee_dcb_cfg 718 * @hw: pointer to the HW struct 719 * @buff: response buffer that stores CEE operational configuration 720 * @cd: pointer to command details structure or NULL 721 * 722 * Get CEE DCBX mode operational configuration from firmware (0x0A07) 723 */ 724 static int 725 ice_aq_get_cee_dcb_cfg(struct ice_hw *hw, 726 struct ice_aqc_get_cee_dcb_cfg_resp *buff, 727 struct ice_sq_cd *cd) 728 { 729 struct ice_aq_desc desc; 730 731 ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_get_cee_dcb_cfg); 732 733 return ice_aq_send_cmd(hw, &desc, (void *)buff, sizeof(*buff), cd); 734 } 735 736 /** 737 * ice_aq_set_pfc_mode - Set PFC mode 738 * @hw: pointer to the HW struct 739 * @pfc_mode: value of PFC mode to set 740 * @cd: pointer to command details structure or NULL 741 * 742 * This AQ call configures the PFC mode to DSCP-based PFC mode or 743 * VLAN-based PFC (0x0303) 744 */ 745 int ice_aq_set_pfc_mode(struct ice_hw *hw, u8 pfc_mode, struct ice_sq_cd *cd) 746 { 747 struct ice_aqc_set_query_pfc_mode *cmd; 748 struct ice_aq_desc desc; 749 int status; 750 751 if (pfc_mode > ICE_AQC_PFC_DSCP_BASED_PFC) 752 return -EINVAL; 753 754 cmd = &desc.params.set_query_pfc_mode; 755 756 ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_set_pfc_mode); 757 758 cmd->pfc_mode = pfc_mode; 759 760 status = ice_aq_send_cmd(hw, &desc, NULL, 0, cd); 761 if (status) 762 return status; 763 764 /* FW will write the PFC mode set back into cmd->pfc_mode, but if DCB is 765 * disabled, FW will write back 0 to cmd->pfc_mode. After the AQ has 766 * been executed, check if cmd->pfc_mode is what was requested. If not, 767 * return an error. 768 */ 769 if (cmd->pfc_mode != pfc_mode) 770 return -EOPNOTSUPP; 771 772 return 0; 773 } 774 775 /** 776 * ice_cee_to_dcb_cfg 777 * @cee_cfg: pointer to CEE configuration struct 778 * @pi: port information structure 779 * 780 * Convert CEE configuration from firmware to DCB configuration 781 */ 782 static void 783 ice_cee_to_dcb_cfg(struct ice_aqc_get_cee_dcb_cfg_resp *cee_cfg, 784 struct ice_port_info *pi) 785 { 786 u32 status, tlv_status = le32_to_cpu(cee_cfg->tlv_status); 787 u32 ice_aqc_cee_status_mask, ice_aqc_cee_status_shift, j; 788 u8 i, err, sync, oper, app_index, ice_app_sel_type; 789 u16 app_prio = le16_to_cpu(cee_cfg->oper_app_prio); 790 u16 ice_aqc_cee_app_mask, ice_aqc_cee_app_shift; 791 struct ice_dcbx_cfg *cmp_dcbcfg, *dcbcfg; 792 u16 ice_app_prot_id_type; 793 794 dcbcfg = &pi->qos_cfg.local_dcbx_cfg; 795 dcbcfg->dcbx_mode = ICE_DCBX_MODE_CEE; 796 dcbcfg->tlv_status = tlv_status; 797 798 /* CEE PG data */ 799 dcbcfg->etscfg.maxtcs = cee_cfg->oper_num_tc; 800 801 /* Note that the FW creates the oper_prio_tc nibbles reversed 802 * from those in the CEE Priority Group sub-TLV. 803 */ 804 for (i = 0; i < ICE_MAX_TRAFFIC_CLASS / 2; i++) { 805 dcbcfg->etscfg.prio_table[i * 2] = 806 ((cee_cfg->oper_prio_tc[i] & ICE_CEE_PGID_PRIO_0_M) >> 807 ICE_CEE_PGID_PRIO_0_S); 808 dcbcfg->etscfg.prio_table[i * 2 + 1] = 809 ((cee_cfg->oper_prio_tc[i] & ICE_CEE_PGID_PRIO_1_M) >> 810 ICE_CEE_PGID_PRIO_1_S); 811 } 812 813 ice_for_each_traffic_class(i) { 814 dcbcfg->etscfg.tcbwtable[i] = cee_cfg->oper_tc_bw[i]; 815 816 if (dcbcfg->etscfg.prio_table[i] == ICE_CEE_PGID_STRICT) { 817 /* Map it to next empty TC */ 818 dcbcfg->etscfg.prio_table[i] = cee_cfg->oper_num_tc - 1; 819 dcbcfg->etscfg.tsatable[i] = ICE_IEEE_TSA_STRICT; 820 } else { 821 dcbcfg->etscfg.tsatable[i] = ICE_IEEE_TSA_ETS; 822 } 823 } 824 825 /* CEE PFC data */ 826 dcbcfg->pfc.pfcena = cee_cfg->oper_pfc_en; 827 dcbcfg->pfc.pfccap = ICE_MAX_TRAFFIC_CLASS; 828 829 /* CEE APP TLV data */ 830 if (dcbcfg->app_mode == ICE_DCBX_APPS_NON_WILLING) 831 cmp_dcbcfg = &pi->qos_cfg.desired_dcbx_cfg; 832 else 833 cmp_dcbcfg = &pi->qos_cfg.remote_dcbx_cfg; 834 835 app_index = 0; 836 for (i = 0; i < 3; i++) { 837 if (i == 0) { 838 /* FCoE APP */ 839 ice_aqc_cee_status_mask = ICE_AQC_CEE_FCOE_STATUS_M; 840 ice_aqc_cee_status_shift = ICE_AQC_CEE_FCOE_STATUS_S; 841 ice_aqc_cee_app_mask = ICE_AQC_CEE_APP_FCOE_M; 842 ice_aqc_cee_app_shift = ICE_AQC_CEE_APP_FCOE_S; 843 ice_app_sel_type = ICE_APP_SEL_ETHTYPE; 844 ice_app_prot_id_type = ETH_P_FCOE; 845 } else if (i == 1) { 846 /* iSCSI APP */ 847 ice_aqc_cee_status_mask = ICE_AQC_CEE_ISCSI_STATUS_M; 848 ice_aqc_cee_status_shift = ICE_AQC_CEE_ISCSI_STATUS_S; 849 ice_aqc_cee_app_mask = ICE_AQC_CEE_APP_ISCSI_M; 850 ice_aqc_cee_app_shift = ICE_AQC_CEE_APP_ISCSI_S; 851 ice_app_sel_type = ICE_APP_SEL_TCPIP; 852 ice_app_prot_id_type = ISCSI_LISTEN_PORT; 853 854 for (j = 0; j < cmp_dcbcfg->numapps; j++) { 855 u16 prot_id = cmp_dcbcfg->app[j].prot_id; 856 u8 sel = cmp_dcbcfg->app[j].selector; 857 858 if (sel == ICE_APP_SEL_TCPIP && 859 (prot_id == ISCSI_LISTEN_PORT || 860 prot_id == ICE_APP_PROT_ID_ISCSI_860)) { 861 ice_app_prot_id_type = prot_id; 862 break; 863 } 864 } 865 } else { 866 /* FIP APP */ 867 ice_aqc_cee_status_mask = ICE_AQC_CEE_FIP_STATUS_M; 868 ice_aqc_cee_status_shift = ICE_AQC_CEE_FIP_STATUS_S; 869 ice_aqc_cee_app_mask = ICE_AQC_CEE_APP_FIP_M; 870 ice_aqc_cee_app_shift = ICE_AQC_CEE_APP_FIP_S; 871 ice_app_sel_type = ICE_APP_SEL_ETHTYPE; 872 ice_app_prot_id_type = ETH_P_FIP; 873 } 874 875 status = (tlv_status & ice_aqc_cee_status_mask) >> 876 ice_aqc_cee_status_shift; 877 err = (status & ICE_TLV_STATUS_ERR) ? 1 : 0; 878 sync = (status & ICE_TLV_STATUS_SYNC) ? 1 : 0; 879 oper = (status & ICE_TLV_STATUS_OPER) ? 1 : 0; 880 /* Add FCoE/iSCSI/FIP APP if Error is False and 881 * Oper/Sync is True 882 */ 883 if (!err && sync && oper) { 884 dcbcfg->app[app_index].priority = 885 (app_prio & ice_aqc_cee_app_mask) >> 886 ice_aqc_cee_app_shift; 887 dcbcfg->app[app_index].selector = ice_app_sel_type; 888 dcbcfg->app[app_index].prot_id = ice_app_prot_id_type; 889 app_index++; 890 } 891 } 892 893 dcbcfg->numapps = app_index; 894 } 895 896 /** 897 * ice_get_ieee_or_cee_dcb_cfg 898 * @pi: port information structure 899 * @dcbx_mode: mode of DCBX (IEEE or CEE) 900 * 901 * Get IEEE or CEE mode DCB configuration from the Firmware 902 */ 903 static int ice_get_ieee_or_cee_dcb_cfg(struct ice_port_info *pi, u8 dcbx_mode) 904 { 905 struct ice_dcbx_cfg *dcbx_cfg = NULL; 906 int ret; 907 908 if (!pi) 909 return -EINVAL; 910 911 if (dcbx_mode == ICE_DCBX_MODE_IEEE) 912 dcbx_cfg = &pi->qos_cfg.local_dcbx_cfg; 913 else if (dcbx_mode == ICE_DCBX_MODE_CEE) 914 dcbx_cfg = &pi->qos_cfg.desired_dcbx_cfg; 915 916 /* Get Local DCB Config in case of ICE_DCBX_MODE_IEEE 917 * or get CEE DCB Desired Config in case of ICE_DCBX_MODE_CEE 918 */ 919 ret = ice_aq_get_dcb_cfg(pi->hw, ICE_AQ_LLDP_MIB_LOCAL, 920 ICE_AQ_LLDP_BRID_TYPE_NEAREST_BRID, dcbx_cfg); 921 if (ret) 922 goto out; 923 924 /* Get Remote DCB Config */ 925 dcbx_cfg = &pi->qos_cfg.remote_dcbx_cfg; 926 ret = ice_aq_get_dcb_cfg(pi->hw, ICE_AQ_LLDP_MIB_REMOTE, 927 ICE_AQ_LLDP_BRID_TYPE_NEAREST_BRID, dcbx_cfg); 928 /* Don't treat ENOENT as an error for Remote MIBs */ 929 if (pi->hw->adminq.sq_last_status == ICE_AQ_RC_ENOENT) 930 ret = 0; 931 932 out: 933 return ret; 934 } 935 936 /** 937 * ice_get_dcb_cfg 938 * @pi: port information structure 939 * 940 * Get DCB configuration from the Firmware 941 */ 942 int ice_get_dcb_cfg(struct ice_port_info *pi) 943 { 944 struct ice_aqc_get_cee_dcb_cfg_resp cee_cfg; 945 struct ice_dcbx_cfg *dcbx_cfg; 946 int ret; 947 948 if (!pi) 949 return -EINVAL; 950 951 ret = ice_aq_get_cee_dcb_cfg(pi->hw, &cee_cfg, NULL); 952 if (!ret) { 953 /* CEE mode */ 954 ret = ice_get_ieee_or_cee_dcb_cfg(pi, ICE_DCBX_MODE_CEE); 955 ice_cee_to_dcb_cfg(&cee_cfg, pi); 956 } else if (pi->hw->adminq.sq_last_status == ICE_AQ_RC_ENOENT) { 957 /* CEE mode not enabled try querying IEEE data */ 958 dcbx_cfg = &pi->qos_cfg.local_dcbx_cfg; 959 dcbx_cfg->dcbx_mode = ICE_DCBX_MODE_IEEE; 960 ret = ice_get_ieee_or_cee_dcb_cfg(pi, ICE_DCBX_MODE_IEEE); 961 } 962 963 return ret; 964 } 965 966 /** 967 * ice_init_dcb 968 * @hw: pointer to the HW struct 969 * @enable_mib_change: enable MIB change event 970 * 971 * Update DCB configuration from the Firmware 972 */ 973 int ice_init_dcb(struct ice_hw *hw, bool enable_mib_change) 974 { 975 struct ice_qos_cfg *qos_cfg = &hw->port_info->qos_cfg; 976 int ret = 0; 977 978 if (!hw->func_caps.common_cap.dcb) 979 return -EOPNOTSUPP; 980 981 qos_cfg->is_sw_lldp = true; 982 983 /* Get DCBX status */ 984 qos_cfg->dcbx_status = ice_get_dcbx_status(hw); 985 986 if (qos_cfg->dcbx_status == ICE_DCBX_STATUS_DONE || 987 qos_cfg->dcbx_status == ICE_DCBX_STATUS_IN_PROGRESS || 988 qos_cfg->dcbx_status == ICE_DCBX_STATUS_NOT_STARTED) { 989 /* Get current DCBX configuration */ 990 ret = ice_get_dcb_cfg(hw->port_info); 991 if (ret) 992 return ret; 993 qos_cfg->is_sw_lldp = false; 994 } else if (qos_cfg->dcbx_status == ICE_DCBX_STATUS_DIS) { 995 return -EBUSY; 996 } 997 998 /* Configure the LLDP MIB change event */ 999 if (enable_mib_change) { 1000 ret = ice_aq_cfg_lldp_mib_change(hw, true, NULL); 1001 if (ret) 1002 qos_cfg->is_sw_lldp = true; 1003 } 1004 1005 return ret; 1006 } 1007 1008 /** 1009 * ice_cfg_lldp_mib_change 1010 * @hw: pointer to the HW struct 1011 * @ena_mib: enable/disable MIB change event 1012 * 1013 * Configure (disable/enable) MIB 1014 */ 1015 int ice_cfg_lldp_mib_change(struct ice_hw *hw, bool ena_mib) 1016 { 1017 struct ice_qos_cfg *qos_cfg = &hw->port_info->qos_cfg; 1018 int ret; 1019 1020 if (!hw->func_caps.common_cap.dcb) 1021 return -EOPNOTSUPP; 1022 1023 /* Get DCBX status */ 1024 qos_cfg->dcbx_status = ice_get_dcbx_status(hw); 1025 1026 if (qos_cfg->dcbx_status == ICE_DCBX_STATUS_DIS) 1027 return -EBUSY; 1028 1029 ret = ice_aq_cfg_lldp_mib_change(hw, ena_mib, NULL); 1030 if (!ret) 1031 qos_cfg->is_sw_lldp = !ena_mib; 1032 1033 return ret; 1034 } 1035 1036 /** 1037 * ice_add_ieee_ets_common_tlv 1038 * @buf: Data buffer to be populated with ice_dcb_ets_cfg data 1039 * @ets_cfg: Container for ice_dcb_ets_cfg data 1040 * 1041 * Populate the TLV buffer with ice_dcb_ets_cfg data 1042 */ 1043 static void 1044 ice_add_ieee_ets_common_tlv(u8 *buf, struct ice_dcb_ets_cfg *ets_cfg) 1045 { 1046 u8 priority0, priority1; 1047 u8 offset = 0; 1048 int i; 1049 1050 /* Priority Assignment Table (4 octets) 1051 * Octets:| 1 | 2 | 3 | 4 | 1052 * ----------------------------------------- 1053 * |pri0|pri1|pri2|pri3|pri4|pri5|pri6|pri7| 1054 * ----------------------------------------- 1055 * Bits:|7 4|3 0|7 4|3 0|7 4|3 0|7 4|3 0| 1056 * ----------------------------------------- 1057 */ 1058 for (i = 0; i < ICE_MAX_TRAFFIC_CLASS / 2; i++) { 1059 priority0 = ets_cfg->prio_table[i * 2] & 0xF; 1060 priority1 = ets_cfg->prio_table[i * 2 + 1] & 0xF; 1061 buf[offset] = (priority0 << ICE_IEEE_ETS_PRIO_1_S) | priority1; 1062 offset++; 1063 } 1064 1065 /* TC Bandwidth Table (8 octets) 1066 * Octets:| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 1067 * --------------------------------- 1068 * |tc0|tc1|tc2|tc3|tc4|tc5|tc6|tc7| 1069 * --------------------------------- 1070 * 1071 * TSA Assignment Table (8 octets) 1072 * Octets:| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 1073 * --------------------------------- 1074 * |tc0|tc1|tc2|tc3|tc4|tc5|tc6|tc7| 1075 * --------------------------------- 1076 */ 1077 ice_for_each_traffic_class(i) { 1078 buf[offset] = ets_cfg->tcbwtable[i]; 1079 buf[ICE_MAX_TRAFFIC_CLASS + offset] = ets_cfg->tsatable[i]; 1080 offset++; 1081 } 1082 } 1083 1084 /** 1085 * ice_add_ieee_ets_tlv - Prepare ETS TLV in IEEE format 1086 * @tlv: Fill the ETS config data in IEEE format 1087 * @dcbcfg: Local store which holds the DCB Config 1088 * 1089 * Prepare IEEE 802.1Qaz ETS CFG TLV 1090 */ 1091 static void 1092 ice_add_ieee_ets_tlv(struct ice_lldp_org_tlv *tlv, struct ice_dcbx_cfg *dcbcfg) 1093 { 1094 struct ice_dcb_ets_cfg *etscfg; 1095 u8 *buf = tlv->tlvinfo; 1096 u8 maxtcwilling = 0; 1097 u32 ouisubtype; 1098 u16 typelen; 1099 1100 typelen = ((ICE_TLV_TYPE_ORG << ICE_LLDP_TLV_TYPE_S) | 1101 ICE_IEEE_ETS_TLV_LEN); 1102 tlv->typelen = htons(typelen); 1103 1104 ouisubtype = ((ICE_IEEE_8021QAZ_OUI << ICE_LLDP_TLV_OUI_S) | 1105 ICE_IEEE_SUBTYPE_ETS_CFG); 1106 tlv->ouisubtype = htonl(ouisubtype); 1107 1108 /* First Octet post subtype 1109 * -------------------------- 1110 * |will-|CBS | Re- | Max | 1111 * |ing | |served| TCs | 1112 * -------------------------- 1113 * |1bit | 1bit|3 bits|3bits| 1114 */ 1115 etscfg = &dcbcfg->etscfg; 1116 if (etscfg->willing) 1117 maxtcwilling = BIT(ICE_IEEE_ETS_WILLING_S); 1118 maxtcwilling |= etscfg->maxtcs & ICE_IEEE_ETS_MAXTC_M; 1119 buf[0] = maxtcwilling; 1120 1121 /* Begin adding at Priority Assignment Table (offset 1 in buf) */ 1122 ice_add_ieee_ets_common_tlv(&buf[1], etscfg); 1123 } 1124 1125 /** 1126 * ice_add_ieee_etsrec_tlv - Prepare ETS Recommended TLV in IEEE format 1127 * @tlv: Fill ETS Recommended TLV in IEEE format 1128 * @dcbcfg: Local store which holds the DCB Config 1129 * 1130 * Prepare IEEE 802.1Qaz ETS REC TLV 1131 */ 1132 static void 1133 ice_add_ieee_etsrec_tlv(struct ice_lldp_org_tlv *tlv, 1134 struct ice_dcbx_cfg *dcbcfg) 1135 { 1136 struct ice_dcb_ets_cfg *etsrec; 1137 u8 *buf = tlv->tlvinfo; 1138 u32 ouisubtype; 1139 u16 typelen; 1140 1141 typelen = ((ICE_TLV_TYPE_ORG << ICE_LLDP_TLV_TYPE_S) | 1142 ICE_IEEE_ETS_TLV_LEN); 1143 tlv->typelen = htons(typelen); 1144 1145 ouisubtype = ((ICE_IEEE_8021QAZ_OUI << ICE_LLDP_TLV_OUI_S) | 1146 ICE_IEEE_SUBTYPE_ETS_REC); 1147 tlv->ouisubtype = htonl(ouisubtype); 1148 1149 etsrec = &dcbcfg->etsrec; 1150 1151 /* First Octet is reserved */ 1152 /* Begin adding at Priority Assignment Table (offset 1 in buf) */ 1153 ice_add_ieee_ets_common_tlv(&buf[1], etsrec); 1154 } 1155 1156 /** 1157 * ice_add_ieee_pfc_tlv - Prepare PFC TLV in IEEE format 1158 * @tlv: Fill PFC TLV in IEEE format 1159 * @dcbcfg: Local store which holds the PFC CFG data 1160 * 1161 * Prepare IEEE 802.1Qaz PFC CFG TLV 1162 */ 1163 static void 1164 ice_add_ieee_pfc_tlv(struct ice_lldp_org_tlv *tlv, struct ice_dcbx_cfg *dcbcfg) 1165 { 1166 u8 *buf = tlv->tlvinfo; 1167 u32 ouisubtype; 1168 u16 typelen; 1169 1170 typelen = ((ICE_TLV_TYPE_ORG << ICE_LLDP_TLV_TYPE_S) | 1171 ICE_IEEE_PFC_TLV_LEN); 1172 tlv->typelen = htons(typelen); 1173 1174 ouisubtype = ((ICE_IEEE_8021QAZ_OUI << ICE_LLDP_TLV_OUI_S) | 1175 ICE_IEEE_SUBTYPE_PFC_CFG); 1176 tlv->ouisubtype = htonl(ouisubtype); 1177 1178 /* ---------------------------------------- 1179 * |will-|MBC | Re- | PFC | PFC Enable | 1180 * |ing | |served| cap | | 1181 * ----------------------------------------- 1182 * |1bit | 1bit|2 bits|4bits| 1 octet | 1183 */ 1184 if (dcbcfg->pfc.willing) 1185 buf[0] = BIT(ICE_IEEE_PFC_WILLING_S); 1186 1187 if (dcbcfg->pfc.mbc) 1188 buf[0] |= BIT(ICE_IEEE_PFC_MBC_S); 1189 1190 buf[0] |= dcbcfg->pfc.pfccap & 0xF; 1191 buf[1] = dcbcfg->pfc.pfcena; 1192 } 1193 1194 /** 1195 * ice_add_ieee_app_pri_tlv - Prepare APP TLV in IEEE format 1196 * @tlv: Fill APP TLV in IEEE format 1197 * @dcbcfg: Local store which holds the APP CFG data 1198 * 1199 * Prepare IEEE 802.1Qaz APP CFG TLV 1200 */ 1201 static void 1202 ice_add_ieee_app_pri_tlv(struct ice_lldp_org_tlv *tlv, 1203 struct ice_dcbx_cfg *dcbcfg) 1204 { 1205 u16 typelen, len, offset = 0; 1206 u8 priority, selector, i = 0; 1207 u8 *buf = tlv->tlvinfo; 1208 u32 ouisubtype; 1209 1210 /* No APP TLVs then just return */ 1211 if (dcbcfg->numapps == 0) 1212 return; 1213 ouisubtype = ((ICE_IEEE_8021QAZ_OUI << ICE_LLDP_TLV_OUI_S) | 1214 ICE_IEEE_SUBTYPE_APP_PRI); 1215 tlv->ouisubtype = htonl(ouisubtype); 1216 1217 /* Move offset to App Priority Table */ 1218 offset++; 1219 /* Application Priority Table (3 octets) 1220 * Octets:| 1 | 2 | 3 | 1221 * ----------------------------------------- 1222 * |Priority|Rsrvd| Sel | Protocol ID | 1223 * ----------------------------------------- 1224 * Bits:|23 21|20 19|18 16|15 0| 1225 * ----------------------------------------- 1226 */ 1227 while (i < dcbcfg->numapps) { 1228 priority = dcbcfg->app[i].priority & 0x7; 1229 selector = dcbcfg->app[i].selector & 0x7; 1230 buf[offset] = (priority << ICE_IEEE_APP_PRIO_S) | selector; 1231 buf[offset + 1] = (dcbcfg->app[i].prot_id >> 0x8) & 0xFF; 1232 buf[offset + 2] = dcbcfg->app[i].prot_id & 0xFF; 1233 /* Move to next app */ 1234 offset += 3; 1235 i++; 1236 if (i >= ICE_DCBX_MAX_APPS) 1237 break; 1238 } 1239 /* len includes size of ouisubtype + 1 reserved + 3*numapps */ 1240 len = sizeof(tlv->ouisubtype) + 1 + (i * 3); 1241 typelen = ((ICE_TLV_TYPE_ORG << ICE_LLDP_TLV_TYPE_S) | (len & 0x1FF)); 1242 tlv->typelen = htons(typelen); 1243 } 1244 1245 /** 1246 * ice_add_dscp_up_tlv - Prepare DSCP to UP TLV 1247 * @tlv: location to build the TLV data 1248 * @dcbcfg: location of data to convert to TLV 1249 */ 1250 static void 1251 ice_add_dscp_up_tlv(struct ice_lldp_org_tlv *tlv, struct ice_dcbx_cfg *dcbcfg) 1252 { 1253 u8 *buf = tlv->tlvinfo; 1254 u32 ouisubtype; 1255 u16 typelen; 1256 int i; 1257 1258 typelen = ((ICE_TLV_TYPE_ORG << ICE_LLDP_TLV_TYPE_S) | 1259 ICE_DSCP_UP_TLV_LEN); 1260 tlv->typelen = htons(typelen); 1261 1262 ouisubtype = (u32)((ICE_DSCP_OUI << ICE_LLDP_TLV_OUI_S) | 1263 ICE_DSCP_SUBTYPE_DSCP2UP); 1264 tlv->ouisubtype = htonl(ouisubtype); 1265 1266 /* bytes 0 - 63 - IPv4 DSCP2UP LUT */ 1267 for (i = 0; i < ICE_DSCP_NUM_VAL; i++) { 1268 /* IPv4 mapping */ 1269 buf[i] = dcbcfg->dscp_map[i]; 1270 /* IPv6 mapping */ 1271 buf[i + ICE_DSCP_IPV6_OFFSET] = dcbcfg->dscp_map[i]; 1272 } 1273 1274 /* byte 64 - IPv4 untagged traffic */ 1275 buf[i] = 0; 1276 1277 /* byte 144 - IPv6 untagged traffic */ 1278 buf[i + ICE_DSCP_IPV6_OFFSET] = 0; 1279 } 1280 1281 #define ICE_BYTES_PER_TC 8 1282 /** 1283 * ice_add_dscp_enf_tlv - Prepare DSCP Enforcement TLV 1284 * @tlv: location to build the TLV data 1285 */ 1286 static void 1287 ice_add_dscp_enf_tlv(struct ice_lldp_org_tlv *tlv) 1288 { 1289 u8 *buf = tlv->tlvinfo; 1290 u32 ouisubtype; 1291 u16 typelen; 1292 1293 typelen = ((ICE_TLV_TYPE_ORG << ICE_LLDP_TLV_TYPE_S) | 1294 ICE_DSCP_ENF_TLV_LEN); 1295 tlv->typelen = htons(typelen); 1296 1297 ouisubtype = (u32)((ICE_DSCP_OUI << ICE_LLDP_TLV_OUI_S) | 1298 ICE_DSCP_SUBTYPE_ENFORCE); 1299 tlv->ouisubtype = htonl(ouisubtype); 1300 1301 /* Allow all DSCP values to be valid for all TC's (IPv4 and IPv6) */ 1302 memset(buf, 0, 2 * (ICE_MAX_TRAFFIC_CLASS * ICE_BYTES_PER_TC)); 1303 } 1304 1305 /** 1306 * ice_add_dscp_tc_bw_tlv - Prepare DSCP BW for TC TLV 1307 * @tlv: location to build the TLV data 1308 * @dcbcfg: location of the data to convert to TLV 1309 */ 1310 static void 1311 ice_add_dscp_tc_bw_tlv(struct ice_lldp_org_tlv *tlv, 1312 struct ice_dcbx_cfg *dcbcfg) 1313 { 1314 struct ice_dcb_ets_cfg *etscfg; 1315 u8 *buf = tlv->tlvinfo; 1316 u32 ouisubtype; 1317 u8 offset = 0; 1318 u16 typelen; 1319 int i; 1320 1321 typelen = ((ICE_TLV_TYPE_ORG << ICE_LLDP_TLV_TYPE_S) | 1322 ICE_DSCP_TC_BW_TLV_LEN); 1323 tlv->typelen = htons(typelen); 1324 1325 ouisubtype = (u32)((ICE_DSCP_OUI << ICE_LLDP_TLV_OUI_S) | 1326 ICE_DSCP_SUBTYPE_TCBW); 1327 tlv->ouisubtype = htonl(ouisubtype); 1328 1329 /* First Octect after subtype 1330 * ---------------------------- 1331 * | RSV | CBS | RSV | Max TCs | 1332 * | 1b | 1b | 3b | 3b | 1333 * ---------------------------- 1334 */ 1335 etscfg = &dcbcfg->etscfg; 1336 buf[0] = etscfg->maxtcs & ICE_IEEE_ETS_MAXTC_M; 1337 1338 /* bytes 1 - 4 reserved */ 1339 offset = 5; 1340 1341 /* TC BW table 1342 * bytes 0 - 7 for TC 0 - 7 1343 * 1344 * TSA Assignment table 1345 * bytes 8 - 15 for TC 0 - 7 1346 */ 1347 for (i = 0; i < ICE_MAX_TRAFFIC_CLASS; i++) { 1348 buf[offset] = etscfg->tcbwtable[i]; 1349 buf[offset + ICE_MAX_TRAFFIC_CLASS] = etscfg->tsatable[i]; 1350 offset++; 1351 } 1352 } 1353 1354 /** 1355 * ice_add_dscp_pfc_tlv - Prepare DSCP PFC TLV 1356 * @tlv: Fill PFC TLV in IEEE format 1357 * @dcbcfg: Local store which holds the PFC CFG data 1358 */ 1359 static void 1360 ice_add_dscp_pfc_tlv(struct ice_lldp_org_tlv *tlv, struct ice_dcbx_cfg *dcbcfg) 1361 { 1362 u8 *buf = tlv->tlvinfo; 1363 u32 ouisubtype; 1364 u16 typelen; 1365 1366 typelen = ((ICE_TLV_TYPE_ORG << ICE_LLDP_TLV_TYPE_S) | 1367 ICE_DSCP_PFC_TLV_LEN); 1368 tlv->typelen = htons(typelen); 1369 1370 ouisubtype = (u32)((ICE_DSCP_OUI << ICE_LLDP_TLV_OUI_S) | 1371 ICE_DSCP_SUBTYPE_PFC); 1372 tlv->ouisubtype = htonl(ouisubtype); 1373 1374 buf[0] = dcbcfg->pfc.pfccap & 0xF; 1375 buf[1] = dcbcfg->pfc.pfcena & 0xF; 1376 } 1377 1378 /** 1379 * ice_add_dcb_tlv - Add all IEEE or DSCP TLVs 1380 * @tlv: Fill TLV data in IEEE format 1381 * @dcbcfg: Local store which holds the DCB Config 1382 * @tlvid: Type of IEEE TLV 1383 * 1384 * Add tlv information 1385 */ 1386 static void 1387 ice_add_dcb_tlv(struct ice_lldp_org_tlv *tlv, struct ice_dcbx_cfg *dcbcfg, 1388 u16 tlvid) 1389 { 1390 if (dcbcfg->pfc_mode == ICE_QOS_MODE_VLAN) { 1391 switch (tlvid) { 1392 case ICE_IEEE_TLV_ID_ETS_CFG: 1393 ice_add_ieee_ets_tlv(tlv, dcbcfg); 1394 break; 1395 case ICE_IEEE_TLV_ID_ETS_REC: 1396 ice_add_ieee_etsrec_tlv(tlv, dcbcfg); 1397 break; 1398 case ICE_IEEE_TLV_ID_PFC_CFG: 1399 ice_add_ieee_pfc_tlv(tlv, dcbcfg); 1400 break; 1401 case ICE_IEEE_TLV_ID_APP_PRI: 1402 ice_add_ieee_app_pri_tlv(tlv, dcbcfg); 1403 break; 1404 default: 1405 break; 1406 } 1407 } else { 1408 /* pfc_mode == ICE_QOS_MODE_DSCP */ 1409 switch (tlvid) { 1410 case ICE_TLV_ID_DSCP_UP: 1411 ice_add_dscp_up_tlv(tlv, dcbcfg); 1412 break; 1413 case ICE_TLV_ID_DSCP_ENF: 1414 ice_add_dscp_enf_tlv(tlv); 1415 break; 1416 case ICE_TLV_ID_DSCP_TC_BW: 1417 ice_add_dscp_tc_bw_tlv(tlv, dcbcfg); 1418 break; 1419 case ICE_TLV_ID_DSCP_TO_PFC: 1420 ice_add_dscp_pfc_tlv(tlv, dcbcfg); 1421 break; 1422 default: 1423 break; 1424 } 1425 } 1426 } 1427 1428 /** 1429 * ice_dcb_cfg_to_lldp - Convert DCB configuration to MIB format 1430 * @lldpmib: pointer to the HW struct 1431 * @miblen: length of LLDP MIB 1432 * @dcbcfg: Local store which holds the DCB Config 1433 * 1434 * Convert the DCB configuration to MIB format 1435 */ 1436 static void 1437 ice_dcb_cfg_to_lldp(u8 *lldpmib, u16 *miblen, struct ice_dcbx_cfg *dcbcfg) 1438 { 1439 u16 len, offset = 0, tlvid = ICE_TLV_ID_START; 1440 struct ice_lldp_org_tlv *tlv; 1441 u16 typelen; 1442 1443 tlv = (struct ice_lldp_org_tlv *)lldpmib; 1444 while (1) { 1445 ice_add_dcb_tlv(tlv, dcbcfg, tlvid++); 1446 typelen = ntohs(tlv->typelen); 1447 len = (typelen & ICE_LLDP_TLV_LEN_M) >> ICE_LLDP_TLV_LEN_S; 1448 if (len) 1449 offset += len + 2; 1450 /* END TLV or beyond LLDPDU size */ 1451 if (tlvid >= ICE_TLV_ID_END_OF_LLDPPDU || 1452 offset > ICE_LLDPDU_SIZE) 1453 break; 1454 /* Move to next TLV */ 1455 if (len) 1456 tlv = (struct ice_lldp_org_tlv *) 1457 ((char *)tlv + sizeof(tlv->typelen) + len); 1458 } 1459 *miblen = offset; 1460 } 1461 1462 /** 1463 * ice_set_dcb_cfg - Set the local LLDP MIB to FW 1464 * @pi: port information structure 1465 * 1466 * Set DCB configuration to the Firmware 1467 */ 1468 int ice_set_dcb_cfg(struct ice_port_info *pi) 1469 { 1470 u8 mib_type, *lldpmib = NULL; 1471 struct ice_dcbx_cfg *dcbcfg; 1472 struct ice_hw *hw; 1473 u16 miblen; 1474 int ret; 1475 1476 if (!pi) 1477 return -EINVAL; 1478 1479 hw = pi->hw; 1480 1481 /* update the HW local config */ 1482 dcbcfg = &pi->qos_cfg.local_dcbx_cfg; 1483 /* Allocate the LLDPDU */ 1484 lldpmib = devm_kzalloc(ice_hw_to_dev(hw), ICE_LLDPDU_SIZE, GFP_KERNEL); 1485 if (!lldpmib) 1486 return -ENOMEM; 1487 1488 mib_type = SET_LOCAL_MIB_TYPE_LOCAL_MIB; 1489 if (dcbcfg->app_mode == ICE_DCBX_APPS_NON_WILLING) 1490 mib_type |= SET_LOCAL_MIB_TYPE_CEE_NON_WILLING; 1491 1492 ice_dcb_cfg_to_lldp(lldpmib, &miblen, dcbcfg); 1493 ret = ice_aq_set_lldp_mib(hw, mib_type, (void *)lldpmib, miblen, 1494 NULL); 1495 1496 devm_kfree(ice_hw_to_dev(hw), lldpmib); 1497 1498 return ret; 1499 } 1500 1501 /** 1502 * ice_aq_query_port_ets - query port ETS configuration 1503 * @pi: port information structure 1504 * @buf: pointer to buffer 1505 * @buf_size: buffer size in bytes 1506 * @cd: pointer to command details structure or NULL 1507 * 1508 * query current port ETS configuration 1509 */ 1510 static int 1511 ice_aq_query_port_ets(struct ice_port_info *pi, 1512 struct ice_aqc_port_ets_elem *buf, u16 buf_size, 1513 struct ice_sq_cd *cd) 1514 { 1515 struct ice_aqc_query_port_ets *cmd; 1516 struct ice_aq_desc desc; 1517 int status; 1518 1519 if (!pi) 1520 return -EINVAL; 1521 cmd = &desc.params.port_ets; 1522 ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_query_port_ets); 1523 cmd->port_teid = pi->root->info.node_teid; 1524 1525 status = ice_aq_send_cmd(pi->hw, &desc, buf, buf_size, cd); 1526 return status; 1527 } 1528 1529 /** 1530 * ice_update_port_tc_tree_cfg - update TC tree configuration 1531 * @pi: port information structure 1532 * @buf: pointer to buffer 1533 * 1534 * update the SW DB with the new TC changes 1535 */ 1536 static int 1537 ice_update_port_tc_tree_cfg(struct ice_port_info *pi, 1538 struct ice_aqc_port_ets_elem *buf) 1539 { 1540 struct ice_sched_node *node, *tc_node; 1541 struct ice_aqc_txsched_elem_data elem; 1542 u32 teid1, teid2; 1543 int status = 0; 1544 u8 i, j; 1545 1546 if (!pi) 1547 return -EINVAL; 1548 /* suspend the missing TC nodes */ 1549 for (i = 0; i < pi->root->num_children; i++) { 1550 teid1 = le32_to_cpu(pi->root->children[i]->info.node_teid); 1551 ice_for_each_traffic_class(j) { 1552 teid2 = le32_to_cpu(buf->tc_node_teid[j]); 1553 if (teid1 == teid2) 1554 break; 1555 } 1556 if (j < ICE_MAX_TRAFFIC_CLASS) 1557 continue; 1558 /* TC is missing */ 1559 pi->root->children[i]->in_use = false; 1560 } 1561 /* add the new TC nodes */ 1562 ice_for_each_traffic_class(j) { 1563 teid2 = le32_to_cpu(buf->tc_node_teid[j]); 1564 if (teid2 == ICE_INVAL_TEID) 1565 continue; 1566 /* Is it already present in the tree ? */ 1567 for (i = 0; i < pi->root->num_children; i++) { 1568 tc_node = pi->root->children[i]; 1569 if (!tc_node) 1570 continue; 1571 teid1 = le32_to_cpu(tc_node->info.node_teid); 1572 if (teid1 == teid2) { 1573 tc_node->tc_num = j; 1574 tc_node->in_use = true; 1575 break; 1576 } 1577 } 1578 if (i < pi->root->num_children) 1579 continue; 1580 /* new TC */ 1581 status = ice_sched_query_elem(pi->hw, teid2, &elem); 1582 if (!status) 1583 status = ice_sched_add_node(pi, 1, &elem, NULL); 1584 if (status) 1585 break; 1586 /* update the TC number */ 1587 node = ice_sched_find_node_by_teid(pi->root, teid2); 1588 if (node) 1589 node->tc_num = j; 1590 } 1591 return status; 1592 } 1593 1594 /** 1595 * ice_query_port_ets - query port ETS configuration 1596 * @pi: port information structure 1597 * @buf: pointer to buffer 1598 * @buf_size: buffer size in bytes 1599 * @cd: pointer to command details structure or NULL 1600 * 1601 * query current port ETS configuration and update the 1602 * SW DB with the TC changes 1603 */ 1604 int 1605 ice_query_port_ets(struct ice_port_info *pi, 1606 struct ice_aqc_port_ets_elem *buf, u16 buf_size, 1607 struct ice_sq_cd *cd) 1608 { 1609 int status; 1610 1611 mutex_lock(&pi->sched_lock); 1612 status = ice_aq_query_port_ets(pi, buf, buf_size, cd); 1613 if (!status) 1614 status = ice_update_port_tc_tree_cfg(pi, buf); 1615 mutex_unlock(&pi->sched_lock); 1616 return status; 1617 } 1618