1 /* 2 * Copyright (C) 2013-2014 Chelsio Communications. All rights reserved. 3 * 4 * Written by Anish Bhatt (anish@chelsio.com) 5 * Casey Leedom (leedom@chelsio.com) 6 * 7 * This program is free software; you can redistribute it and/or modify it 8 * under the terms and conditions of the GNU General Public License, 9 * version 2, as published by the Free Software Foundation. 10 * 11 * This program is distributed in the hope it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 14 * more details. 15 * 16 * The full GNU General Public License is included in this distribution in 17 * the file called "COPYING". 18 * 19 */ 20 21 #include "cxgb4.h" 22 23 /* DCBx version control 24 */ 25 static const char * const dcb_ver_array[] = { 26 "Unknown", 27 "DCBx-CIN", 28 "DCBx-CEE 1.01", 29 "DCBx-IEEE", 30 "", "", "", 31 "Auto Negotiated" 32 }; 33 34 /* Initialize a port's Data Center Bridging state. Typically used after a 35 * Link Down event. 36 */ 37 void cxgb4_dcb_state_init(struct net_device *dev) 38 { 39 struct port_info *pi = netdev2pinfo(dev); 40 struct port_dcb_info *dcb = &pi->dcb; 41 int version_temp = dcb->dcb_version; 42 43 memset(dcb, 0, sizeof(struct port_dcb_info)); 44 dcb->state = CXGB4_DCB_STATE_START; 45 if (version_temp) 46 dcb->dcb_version = version_temp; 47 48 netdev_dbg(dev, "%s: Initializing DCB state for port[%d]\n", 49 __func__, pi->port_id); 50 } 51 52 void cxgb4_dcb_version_init(struct net_device *dev) 53 { 54 struct port_info *pi = netdev2pinfo(dev); 55 struct port_dcb_info *dcb = &pi->dcb; 56 57 /* Any writes here are only done on kernels that exlicitly need 58 * a specific version, say < 2.6.38 which only support CEE 59 */ 60 dcb->dcb_version = FW_PORT_DCB_VER_AUTO; 61 } 62 63 static void cxgb4_dcb_cleanup_apps(struct net_device *dev) 64 { 65 struct port_info *pi = netdev2pinfo(dev); 66 struct adapter *adap = pi->adapter; 67 struct port_dcb_info *dcb = &pi->dcb; 68 struct dcb_app app; 69 int i, err; 70 71 /* zero priority implies remove */ 72 app.priority = 0; 73 74 for (i = 0; i < CXGB4_MAX_DCBX_APP_SUPPORTED; i++) { 75 /* Check if app list is exhausted */ 76 if (!dcb->app_priority[i].protocolid) 77 break; 78 79 app.protocol = dcb->app_priority[i].protocolid; 80 81 if (dcb->dcb_version == FW_PORT_DCB_VER_IEEE) { 82 app.priority = dcb->app_priority[i].user_prio_map; 83 app.selector = dcb->app_priority[i].sel_field + 1; 84 err = dcb_ieee_delapp(dev, &app); 85 } else { 86 app.selector = !!(dcb->app_priority[i].sel_field); 87 err = dcb_setapp(dev, &app); 88 } 89 90 if (err) { 91 dev_err(adap->pdev_dev, 92 "Failed DCB Clear %s Application Priority: sel=%d, prot=%d, , err=%d\n", 93 dcb_ver_array[dcb->dcb_version], app.selector, 94 app.protocol, -err); 95 break; 96 } 97 } 98 } 99 100 /* Finite State machine for Data Center Bridging. 101 */ 102 void cxgb4_dcb_state_fsm(struct net_device *dev, 103 enum cxgb4_dcb_state_input transition_to) 104 { 105 struct port_info *pi = netdev2pinfo(dev); 106 struct port_dcb_info *dcb = &pi->dcb; 107 struct adapter *adap = pi->adapter; 108 enum cxgb4_dcb_state current_state = dcb->state; 109 110 netdev_dbg(dev, "%s: State change from %d to %d for %s\n", 111 __func__, dcb->state, transition_to, dev->name); 112 113 switch (current_state) { 114 case CXGB4_DCB_STATE_START: { 115 switch (transition_to) { 116 case CXGB4_DCB_INPUT_FW_DISABLED: { 117 /* we're going to use Host DCB */ 118 dcb->state = CXGB4_DCB_STATE_HOST; 119 dcb->supported = CXGB4_DCBX_HOST_SUPPORT; 120 break; 121 } 122 123 case CXGB4_DCB_INPUT_FW_ENABLED: { 124 /* we're going to use Firmware DCB */ 125 dcb->state = CXGB4_DCB_STATE_FW_INCOMPLETE; 126 dcb->supported = DCB_CAP_DCBX_LLD_MANAGED; 127 if (dcb->dcb_version == FW_PORT_DCB_VER_IEEE) 128 dcb->supported |= DCB_CAP_DCBX_VER_IEEE; 129 else 130 dcb->supported |= DCB_CAP_DCBX_VER_CEE; 131 break; 132 } 133 134 case CXGB4_DCB_INPUT_FW_INCOMPLETE: { 135 /* expected transition */ 136 break; 137 } 138 139 case CXGB4_DCB_INPUT_FW_ALLSYNCED: { 140 dcb->state = CXGB4_DCB_STATE_FW_ALLSYNCED; 141 break; 142 } 143 144 default: 145 goto bad_state_input; 146 } 147 break; 148 } 149 150 case CXGB4_DCB_STATE_FW_INCOMPLETE: { 151 switch (transition_to) { 152 case CXGB4_DCB_INPUT_FW_ENABLED: { 153 /* we're alreaady in firmware DCB mode */ 154 break; 155 } 156 157 case CXGB4_DCB_INPUT_FW_INCOMPLETE: { 158 /* we're already incomplete */ 159 break; 160 } 161 162 case CXGB4_DCB_INPUT_FW_ALLSYNCED: { 163 dcb->state = CXGB4_DCB_STATE_FW_ALLSYNCED; 164 dcb->enabled = 1; 165 linkwatch_fire_event(dev); 166 break; 167 } 168 169 default: 170 goto bad_state_input; 171 } 172 break; 173 } 174 175 case CXGB4_DCB_STATE_FW_ALLSYNCED: { 176 switch (transition_to) { 177 case CXGB4_DCB_INPUT_FW_ENABLED: { 178 /* we're alreaady in firmware DCB mode */ 179 break; 180 } 181 182 case CXGB4_DCB_INPUT_FW_INCOMPLETE: { 183 /* We were successfully running with firmware DCB but 184 * now it's telling us that it's in an "incomplete 185 * state. We need to reset back to a ground state 186 * of incomplete. 187 */ 188 cxgb4_dcb_cleanup_apps(dev); 189 cxgb4_dcb_state_init(dev); 190 dcb->state = CXGB4_DCB_STATE_FW_INCOMPLETE; 191 dcb->supported = CXGB4_DCBX_FW_SUPPORT; 192 linkwatch_fire_event(dev); 193 break; 194 } 195 196 case CXGB4_DCB_INPUT_FW_ALLSYNCED: { 197 /* we're already all sync'ed 198 * this is only applicable for IEEE or 199 * when another VI already completed negotiaton 200 */ 201 dcb->enabled = 1; 202 linkwatch_fire_event(dev); 203 break; 204 } 205 206 default: 207 goto bad_state_input; 208 } 209 break; 210 } 211 212 case CXGB4_DCB_STATE_HOST: { 213 switch (transition_to) { 214 case CXGB4_DCB_INPUT_FW_DISABLED: { 215 /* we're alreaady in Host DCB mode */ 216 break; 217 } 218 219 default: 220 goto bad_state_input; 221 } 222 break; 223 } 224 225 default: 226 goto bad_state_transition; 227 } 228 return; 229 230 bad_state_input: 231 dev_err(adap->pdev_dev, "cxgb4_dcb_state_fsm: illegal input symbol %d\n", 232 transition_to); 233 return; 234 235 bad_state_transition: 236 dev_err(adap->pdev_dev, "cxgb4_dcb_state_fsm: bad state transition, state = %d, input = %d\n", 237 current_state, transition_to); 238 } 239 240 /* Handle a DCB/DCBX update message from the firmware. 241 */ 242 void cxgb4_dcb_handle_fw_update(struct adapter *adap, 243 const struct fw_port_cmd *pcmd) 244 { 245 const union fw_port_dcb *fwdcb = &pcmd->u.dcb; 246 int port = FW_PORT_CMD_PORTID_G(be32_to_cpu(pcmd->op_to_portid)); 247 struct net_device *dev = adap->port[port]; 248 struct port_info *pi = netdev_priv(dev); 249 struct port_dcb_info *dcb = &pi->dcb; 250 int dcb_type = pcmd->u.dcb.pgid.type; 251 int dcb_running_version; 252 253 /* Handle Firmware DCB Control messages separately since they drive 254 * our state machine. 255 */ 256 if (dcb_type == FW_PORT_DCB_TYPE_CONTROL) { 257 enum cxgb4_dcb_state_input input = 258 ((pcmd->u.dcb.control.all_syncd_pkd & 259 FW_PORT_CMD_ALL_SYNCD_F) 260 ? CXGB4_DCB_STATE_FW_ALLSYNCED 261 : CXGB4_DCB_STATE_FW_INCOMPLETE); 262 263 if (dcb->dcb_version != FW_PORT_DCB_VER_UNKNOWN) { 264 dcb_running_version = FW_PORT_CMD_DCB_VERSION_G( 265 be16_to_cpu( 266 pcmd->u.dcb.control.dcb_version_to_app_state)); 267 if (dcb_running_version == FW_PORT_DCB_VER_CEE1D01 || 268 dcb_running_version == FW_PORT_DCB_VER_IEEE) { 269 dcb->dcb_version = dcb_running_version; 270 dev_warn(adap->pdev_dev, "Interface %s is running %s\n", 271 dev->name, 272 dcb_ver_array[dcb->dcb_version]); 273 } else { 274 dev_warn(adap->pdev_dev, 275 "Something screwed up, requested firmware for %s, but firmware returned %s instead\n", 276 dcb_ver_array[dcb->dcb_version], 277 dcb_ver_array[dcb_running_version]); 278 dcb->dcb_version = FW_PORT_DCB_VER_UNKNOWN; 279 } 280 } 281 282 cxgb4_dcb_state_fsm(dev, input); 283 return; 284 } 285 286 /* It's weird, and almost certainly an error, to get Firmware DCB 287 * messages when we either haven't been told whether we're going to be 288 * doing Host or Firmware DCB; and even worse when we've been told 289 * that we're doing Host DCB! 290 */ 291 if (dcb->state == CXGB4_DCB_STATE_START || 292 dcb->state == CXGB4_DCB_STATE_HOST) { 293 dev_err(adap->pdev_dev, "Receiving Firmware DCB messages in State %d\n", 294 dcb->state); 295 return; 296 } 297 298 /* Now handle the general Firmware DCB update messages ... 299 */ 300 switch (dcb_type) { 301 case FW_PORT_DCB_TYPE_PGID: 302 dcb->pgid = be32_to_cpu(fwdcb->pgid.pgid); 303 dcb->msgs |= CXGB4_DCB_FW_PGID; 304 break; 305 306 case FW_PORT_DCB_TYPE_PGRATE: 307 dcb->pg_num_tcs_supported = fwdcb->pgrate.num_tcs_supported; 308 memcpy(dcb->pgrate, &fwdcb->pgrate.pgrate, 309 sizeof(dcb->pgrate)); 310 memcpy(dcb->tsa, &fwdcb->pgrate.tsa, 311 sizeof(dcb->tsa)); 312 dcb->msgs |= CXGB4_DCB_FW_PGRATE; 313 if (dcb->msgs & CXGB4_DCB_FW_PGID) 314 IEEE_FAUX_SYNC(dev, dcb); 315 break; 316 317 case FW_PORT_DCB_TYPE_PRIORATE: 318 memcpy(dcb->priorate, &fwdcb->priorate.strict_priorate, 319 sizeof(dcb->priorate)); 320 dcb->msgs |= CXGB4_DCB_FW_PRIORATE; 321 break; 322 323 case FW_PORT_DCB_TYPE_PFC: 324 dcb->pfcen = fwdcb->pfc.pfcen; 325 dcb->pfc_num_tcs_supported = fwdcb->pfc.max_pfc_tcs; 326 dcb->msgs |= CXGB4_DCB_FW_PFC; 327 IEEE_FAUX_SYNC(dev, dcb); 328 break; 329 330 case FW_PORT_DCB_TYPE_APP_ID: { 331 const struct fw_port_app_priority *fwap = &fwdcb->app_priority; 332 int idx = fwap->idx; 333 struct app_priority *ap = &dcb->app_priority[idx]; 334 335 struct dcb_app app = { 336 .protocol = be16_to_cpu(fwap->protocolid), 337 }; 338 int err; 339 340 /* Convert from firmware format to relevant format 341 * when using app selector 342 */ 343 if (dcb->dcb_version == FW_PORT_DCB_VER_IEEE) { 344 app.selector = (fwap->sel_field + 1); 345 app.priority = ffs(fwap->user_prio_map) - 1; 346 err = dcb_ieee_setapp(dev, &app); 347 IEEE_FAUX_SYNC(dev, dcb); 348 } else { 349 /* Default is CEE */ 350 app.selector = !!(fwap->sel_field); 351 app.priority = fwap->user_prio_map; 352 err = dcb_setapp(dev, &app); 353 } 354 355 if (err) 356 dev_err(adap->pdev_dev, 357 "Failed DCB Set Application Priority: sel=%d, prot=%d, prio=%d, err=%d\n", 358 app.selector, app.protocol, app.priority, -err); 359 360 ap->user_prio_map = fwap->user_prio_map; 361 ap->sel_field = fwap->sel_field; 362 ap->protocolid = be16_to_cpu(fwap->protocolid); 363 dcb->msgs |= CXGB4_DCB_FW_APP_ID; 364 break; 365 } 366 367 default: 368 dev_err(adap->pdev_dev, "Unknown DCB update type received %x\n", 369 dcb_type); 370 break; 371 } 372 } 373 374 /* Data Center Bridging netlink operations. 375 */ 376 377 378 /* Get current DCB enabled/disabled state. 379 */ 380 static u8 cxgb4_getstate(struct net_device *dev) 381 { 382 struct port_info *pi = netdev2pinfo(dev); 383 384 return pi->dcb.enabled; 385 } 386 387 /* Set DCB enabled/disabled. 388 */ 389 static u8 cxgb4_setstate(struct net_device *dev, u8 enabled) 390 { 391 struct port_info *pi = netdev2pinfo(dev); 392 393 /* If DCBx is host-managed, dcb is enabled by outside lldp agents */ 394 if (pi->dcb.state == CXGB4_DCB_STATE_HOST) { 395 pi->dcb.enabled = enabled; 396 return 0; 397 } 398 399 /* Firmware doesn't provide any mechanism to control the DCB state. 400 */ 401 if (enabled != (pi->dcb.state == CXGB4_DCB_STATE_FW_ALLSYNCED)) 402 return 1; 403 404 return 0; 405 } 406 407 static void cxgb4_getpgtccfg(struct net_device *dev, int tc, 408 u8 *prio_type, u8 *pgid, u8 *bw_per, 409 u8 *up_tc_map, int local) 410 { 411 struct fw_port_cmd pcmd; 412 struct port_info *pi = netdev2pinfo(dev); 413 struct adapter *adap = pi->adapter; 414 int err; 415 416 *prio_type = *pgid = *bw_per = *up_tc_map = 0; 417 418 if (local) 419 INIT_PORT_DCB_READ_LOCAL_CMD(pcmd, pi->port_id); 420 else 421 INIT_PORT_DCB_READ_PEER_CMD(pcmd, pi->port_id); 422 423 pcmd.u.dcb.pgid.type = FW_PORT_DCB_TYPE_PGID; 424 err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd); 425 if (err != FW_PORT_DCB_CFG_SUCCESS) { 426 dev_err(adap->pdev_dev, "DCB read PGID failed with %d\n", -err); 427 return; 428 } 429 *pgid = (be32_to_cpu(pcmd.u.dcb.pgid.pgid) >> (tc * 4)) & 0xf; 430 431 if (local) 432 INIT_PORT_DCB_READ_LOCAL_CMD(pcmd, pi->port_id); 433 else 434 INIT_PORT_DCB_READ_PEER_CMD(pcmd, pi->port_id); 435 pcmd.u.dcb.pgrate.type = FW_PORT_DCB_TYPE_PGRATE; 436 err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd); 437 if (err != FW_PORT_DCB_CFG_SUCCESS) { 438 dev_err(adap->pdev_dev, "DCB read PGRATE failed with %d\n", 439 -err); 440 return; 441 } 442 443 *bw_per = pcmd.u.dcb.pgrate.pgrate[*pgid]; 444 *up_tc_map = (1 << tc); 445 446 /* prio_type is link strict */ 447 if (*pgid != 0xF) 448 *prio_type = 0x2; 449 } 450 451 static void cxgb4_getpgtccfg_tx(struct net_device *dev, int tc, 452 u8 *prio_type, u8 *pgid, u8 *bw_per, 453 u8 *up_tc_map) 454 { 455 /* tc 0 is written at MSB position */ 456 return cxgb4_getpgtccfg(dev, (7 - tc), prio_type, pgid, bw_per, 457 up_tc_map, 1); 458 } 459 460 461 static void cxgb4_getpgtccfg_rx(struct net_device *dev, int tc, 462 u8 *prio_type, u8 *pgid, u8 *bw_per, 463 u8 *up_tc_map) 464 { 465 /* tc 0 is written at MSB position */ 466 return cxgb4_getpgtccfg(dev, (7 - tc), prio_type, pgid, bw_per, 467 up_tc_map, 0); 468 } 469 470 static void cxgb4_setpgtccfg_tx(struct net_device *dev, int tc, 471 u8 prio_type, u8 pgid, u8 bw_per, 472 u8 up_tc_map) 473 { 474 struct fw_port_cmd pcmd; 475 struct port_info *pi = netdev2pinfo(dev); 476 struct adapter *adap = pi->adapter; 477 int fw_tc = 7 - tc; 478 u32 _pgid; 479 int err; 480 481 if (pgid == DCB_ATTR_VALUE_UNDEFINED) 482 return; 483 if (bw_per == DCB_ATTR_VALUE_UNDEFINED) 484 return; 485 486 INIT_PORT_DCB_READ_LOCAL_CMD(pcmd, pi->port_id); 487 pcmd.u.dcb.pgid.type = FW_PORT_DCB_TYPE_PGID; 488 489 err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd); 490 if (err != FW_PORT_DCB_CFG_SUCCESS) { 491 dev_err(adap->pdev_dev, "DCB read PGID failed with %d\n", -err); 492 return; 493 } 494 495 _pgid = be32_to_cpu(pcmd.u.dcb.pgid.pgid); 496 _pgid &= ~(0xF << (fw_tc * 4)); 497 _pgid |= pgid << (fw_tc * 4); 498 pcmd.u.dcb.pgid.pgid = cpu_to_be32(_pgid); 499 500 INIT_PORT_DCB_WRITE_CMD(pcmd, pi->port_id); 501 502 err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd); 503 if (err != FW_PORT_DCB_CFG_SUCCESS) { 504 dev_err(adap->pdev_dev, "DCB write PGID failed with %d\n", 505 -err); 506 return; 507 } 508 509 memset(&pcmd, 0, sizeof(struct fw_port_cmd)); 510 511 INIT_PORT_DCB_READ_LOCAL_CMD(pcmd, pi->port_id); 512 pcmd.u.dcb.pgrate.type = FW_PORT_DCB_TYPE_PGRATE; 513 514 err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd); 515 if (err != FW_PORT_DCB_CFG_SUCCESS) { 516 dev_err(adap->pdev_dev, "DCB read PGRATE failed with %d\n", 517 -err); 518 return; 519 } 520 521 pcmd.u.dcb.pgrate.pgrate[pgid] = bw_per; 522 523 INIT_PORT_DCB_WRITE_CMD(pcmd, pi->port_id); 524 if (pi->dcb.state == CXGB4_DCB_STATE_HOST) 525 pcmd.op_to_portid |= cpu_to_be32(FW_PORT_CMD_APPLY_F); 526 527 err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd); 528 if (err != FW_PORT_DCB_CFG_SUCCESS) 529 dev_err(adap->pdev_dev, "DCB write PGRATE failed with %d\n", 530 -err); 531 } 532 533 static void cxgb4_getpgbwgcfg(struct net_device *dev, int pgid, u8 *bw_per, 534 int local) 535 { 536 struct fw_port_cmd pcmd; 537 struct port_info *pi = netdev2pinfo(dev); 538 struct adapter *adap = pi->adapter; 539 int err; 540 541 if (local) 542 INIT_PORT_DCB_READ_LOCAL_CMD(pcmd, pi->port_id); 543 else 544 INIT_PORT_DCB_READ_PEER_CMD(pcmd, pi->port_id); 545 546 pcmd.u.dcb.pgrate.type = FW_PORT_DCB_TYPE_PGRATE; 547 err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd); 548 if (err != FW_PORT_DCB_CFG_SUCCESS) { 549 dev_err(adap->pdev_dev, "DCB read PGRATE failed with %d\n", 550 -err); 551 return; 552 } 553 554 *bw_per = pcmd.u.dcb.pgrate.pgrate[pgid]; 555 } 556 557 static void cxgb4_getpgbwgcfg_tx(struct net_device *dev, int pgid, u8 *bw_per) 558 { 559 return cxgb4_getpgbwgcfg(dev, pgid, bw_per, 1); 560 } 561 562 static void cxgb4_getpgbwgcfg_rx(struct net_device *dev, int pgid, u8 *bw_per) 563 { 564 return cxgb4_getpgbwgcfg(dev, pgid, bw_per, 0); 565 } 566 567 static void cxgb4_setpgbwgcfg_tx(struct net_device *dev, int pgid, 568 u8 bw_per) 569 { 570 struct fw_port_cmd pcmd; 571 struct port_info *pi = netdev2pinfo(dev); 572 struct adapter *adap = pi->adapter; 573 int err; 574 575 INIT_PORT_DCB_READ_LOCAL_CMD(pcmd, pi->port_id); 576 pcmd.u.dcb.pgrate.type = FW_PORT_DCB_TYPE_PGRATE; 577 578 err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd); 579 if (err != FW_PORT_DCB_CFG_SUCCESS) { 580 dev_err(adap->pdev_dev, "DCB read PGRATE failed with %d\n", 581 -err); 582 return; 583 } 584 585 pcmd.u.dcb.pgrate.pgrate[pgid] = bw_per; 586 587 INIT_PORT_DCB_WRITE_CMD(pcmd, pi->port_id); 588 if (pi->dcb.state == CXGB4_DCB_STATE_HOST) 589 pcmd.op_to_portid |= cpu_to_be32(FW_PORT_CMD_APPLY_F); 590 591 err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd); 592 593 if (err != FW_PORT_DCB_CFG_SUCCESS) 594 dev_err(adap->pdev_dev, "DCB write PGRATE failed with %d\n", 595 -err); 596 } 597 598 /* Return whether the specified Traffic Class Priority has Priority Pause 599 * Frames enabled. 600 */ 601 static void cxgb4_getpfccfg(struct net_device *dev, int priority, u8 *pfccfg) 602 { 603 struct port_info *pi = netdev2pinfo(dev); 604 struct port_dcb_info *dcb = &pi->dcb; 605 606 if (dcb->state != CXGB4_DCB_STATE_FW_ALLSYNCED || 607 priority >= CXGB4_MAX_PRIORITY) 608 *pfccfg = 0; 609 else 610 *pfccfg = (pi->dcb.pfcen >> (7 - priority)) & 1; 611 } 612 613 /* Enable/disable Priority Pause Frames for the specified Traffic Class 614 * Priority. 615 */ 616 static void cxgb4_setpfccfg(struct net_device *dev, int priority, u8 pfccfg) 617 { 618 struct fw_port_cmd pcmd; 619 struct port_info *pi = netdev2pinfo(dev); 620 struct adapter *adap = pi->adapter; 621 int err; 622 623 if (pi->dcb.state != CXGB4_DCB_STATE_FW_ALLSYNCED || 624 priority >= CXGB4_MAX_PRIORITY) 625 return; 626 627 INIT_PORT_DCB_WRITE_CMD(pcmd, pi->port_id); 628 if (pi->dcb.state == CXGB4_DCB_STATE_HOST) 629 pcmd.op_to_portid |= cpu_to_be32(FW_PORT_CMD_APPLY_F); 630 631 pcmd.u.dcb.pfc.type = FW_PORT_DCB_TYPE_PFC; 632 pcmd.u.dcb.pfc.pfcen = pi->dcb.pfcen; 633 634 if (pfccfg) 635 pcmd.u.dcb.pfc.pfcen |= (1 << (7 - priority)); 636 else 637 pcmd.u.dcb.pfc.pfcen &= (~(1 << (7 - priority))); 638 639 err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd); 640 if (err != FW_PORT_DCB_CFG_SUCCESS) { 641 dev_err(adap->pdev_dev, "DCB PFC write failed with %d\n", -err); 642 return; 643 } 644 645 pi->dcb.pfcen = pcmd.u.dcb.pfc.pfcen; 646 } 647 648 static u8 cxgb4_setall(struct net_device *dev) 649 { 650 return 0; 651 } 652 653 /* Return DCB capabilities. 654 */ 655 static u8 cxgb4_getcap(struct net_device *dev, int cap_id, u8 *caps) 656 { 657 struct port_info *pi = netdev2pinfo(dev); 658 659 switch (cap_id) { 660 case DCB_CAP_ATTR_PG: 661 case DCB_CAP_ATTR_PFC: 662 *caps = true; 663 break; 664 665 case DCB_CAP_ATTR_PG_TCS: 666 /* 8 priorities for PG represented by bitmap */ 667 *caps = 0x80; 668 break; 669 670 case DCB_CAP_ATTR_PFC_TCS: 671 /* 8 priorities for PFC represented by bitmap */ 672 *caps = 0x80; 673 break; 674 675 case DCB_CAP_ATTR_GSP: 676 *caps = true; 677 break; 678 679 case DCB_CAP_ATTR_UP2TC: 680 case DCB_CAP_ATTR_BCN: 681 *caps = false; 682 break; 683 684 case DCB_CAP_ATTR_DCBX: 685 *caps = pi->dcb.supported; 686 break; 687 688 default: 689 *caps = false; 690 } 691 692 return 0; 693 } 694 695 /* Return the number of Traffic Classes for the indicated Traffic Class ID. 696 */ 697 static int cxgb4_getnumtcs(struct net_device *dev, int tcs_id, u8 *num) 698 { 699 struct port_info *pi = netdev2pinfo(dev); 700 701 switch (tcs_id) { 702 case DCB_NUMTCS_ATTR_PG: 703 if (pi->dcb.msgs & CXGB4_DCB_FW_PGRATE) 704 *num = pi->dcb.pg_num_tcs_supported; 705 else 706 *num = 0x8; 707 break; 708 709 case DCB_NUMTCS_ATTR_PFC: 710 *num = 0x8; 711 break; 712 713 default: 714 return -EINVAL; 715 } 716 717 return 0; 718 } 719 720 /* Set the number of Traffic Classes supported for the indicated Traffic Class 721 * ID. 722 */ 723 static int cxgb4_setnumtcs(struct net_device *dev, int tcs_id, u8 num) 724 { 725 /* Setting the number of Traffic Classes isn't supported. 726 */ 727 return -ENOSYS; 728 } 729 730 /* Return whether Priority Flow Control is enabled. */ 731 static u8 cxgb4_getpfcstate(struct net_device *dev) 732 { 733 struct port_info *pi = netdev2pinfo(dev); 734 735 if (pi->dcb.state != CXGB4_DCB_STATE_FW_ALLSYNCED) 736 return false; 737 738 return pi->dcb.pfcen != 0; 739 } 740 741 /* Enable/disable Priority Flow Control. */ 742 static void cxgb4_setpfcstate(struct net_device *dev, u8 state) 743 { 744 /* We can't enable/disable Priority Flow Control but we also can't 745 * return an error ... 746 */ 747 } 748 749 /* Return the Application User Priority Map associated with the specified 750 * Application ID. 751 */ 752 static int __cxgb4_getapp(struct net_device *dev, u8 app_idtype, u16 app_id, 753 int peer) 754 { 755 struct port_info *pi = netdev2pinfo(dev); 756 struct adapter *adap = pi->adapter; 757 int i; 758 759 if (pi->dcb.state != CXGB4_DCB_STATE_FW_ALLSYNCED) 760 return 0; 761 762 for (i = 0; i < CXGB4_MAX_DCBX_APP_SUPPORTED; i++) { 763 struct fw_port_cmd pcmd; 764 int err; 765 766 if (peer) 767 INIT_PORT_DCB_READ_PEER_CMD(pcmd, pi->port_id); 768 else 769 INIT_PORT_DCB_READ_LOCAL_CMD(pcmd, pi->port_id); 770 771 pcmd.u.dcb.app_priority.type = FW_PORT_DCB_TYPE_APP_ID; 772 pcmd.u.dcb.app_priority.idx = i; 773 774 err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd); 775 if (err != FW_PORT_DCB_CFG_SUCCESS) { 776 dev_err(adap->pdev_dev, "DCB APP read failed with %d\n", 777 -err); 778 return err; 779 } 780 if (be16_to_cpu(pcmd.u.dcb.app_priority.protocolid) == app_id) 781 if (pcmd.u.dcb.app_priority.sel_field == app_idtype) 782 return pcmd.u.dcb.app_priority.user_prio_map; 783 784 /* exhausted app list */ 785 if (!pcmd.u.dcb.app_priority.protocolid) 786 break; 787 } 788 789 return -EEXIST; 790 } 791 792 /* Return the Application User Priority Map associated with the specified 793 * Application ID. 794 */ 795 static int cxgb4_getapp(struct net_device *dev, u8 app_idtype, u16 app_id) 796 { 797 return __cxgb4_getapp(dev, app_idtype, app_id, 0); 798 } 799 800 /* Write a new Application User Priority Map for the specified Application ID 801 */ 802 static int __cxgb4_setapp(struct net_device *dev, u8 app_idtype, u16 app_id, 803 u8 app_prio) 804 { 805 struct fw_port_cmd pcmd; 806 struct port_info *pi = netdev2pinfo(dev); 807 struct adapter *adap = pi->adapter; 808 int i, err; 809 810 811 if (pi->dcb.state != CXGB4_DCB_STATE_FW_ALLSYNCED) 812 return -EINVAL; 813 814 /* DCB info gets thrown away on link up */ 815 if (!netif_carrier_ok(dev)) 816 return -ENOLINK; 817 818 for (i = 0; i < CXGB4_MAX_DCBX_APP_SUPPORTED; i++) { 819 INIT_PORT_DCB_READ_LOCAL_CMD(pcmd, pi->port_id); 820 pcmd.u.dcb.app_priority.type = FW_PORT_DCB_TYPE_APP_ID; 821 pcmd.u.dcb.app_priority.idx = i; 822 err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd); 823 824 if (err != FW_PORT_DCB_CFG_SUCCESS) { 825 dev_err(adap->pdev_dev, "DCB app table read failed with %d\n", 826 -err); 827 return err; 828 } 829 if (be16_to_cpu(pcmd.u.dcb.app_priority.protocolid) == app_id) { 830 /* overwrite existing app table */ 831 pcmd.u.dcb.app_priority.protocolid = 0; 832 break; 833 } 834 /* find first empty slot */ 835 if (!pcmd.u.dcb.app_priority.protocolid) 836 break; 837 } 838 839 if (i == CXGB4_MAX_DCBX_APP_SUPPORTED) { 840 /* no empty slots available */ 841 dev_err(adap->pdev_dev, "DCB app table full\n"); 842 return -EBUSY; 843 } 844 845 /* write out new app table entry */ 846 INIT_PORT_DCB_WRITE_CMD(pcmd, pi->port_id); 847 if (pi->dcb.state == CXGB4_DCB_STATE_HOST) 848 pcmd.op_to_portid |= cpu_to_be32(FW_PORT_CMD_APPLY_F); 849 850 pcmd.u.dcb.app_priority.type = FW_PORT_DCB_TYPE_APP_ID; 851 pcmd.u.dcb.app_priority.protocolid = cpu_to_be16(app_id); 852 pcmd.u.dcb.app_priority.sel_field = app_idtype; 853 pcmd.u.dcb.app_priority.user_prio_map = app_prio; 854 pcmd.u.dcb.app_priority.idx = i; 855 856 err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd); 857 if (err != FW_PORT_DCB_CFG_SUCCESS) { 858 dev_err(adap->pdev_dev, "DCB app table write failed with %d\n", 859 -err); 860 return err; 861 } 862 863 return 0; 864 } 865 866 /* Priority for CEE inside dcb_app is bitmask, with 0 being an invalid value */ 867 static int cxgb4_setapp(struct net_device *dev, u8 app_idtype, u16 app_id, 868 u8 app_prio) 869 { 870 int ret; 871 struct dcb_app app = { 872 .selector = app_idtype, 873 .protocol = app_id, 874 .priority = app_prio, 875 }; 876 877 if (app_idtype != DCB_APP_IDTYPE_ETHTYPE && 878 app_idtype != DCB_APP_IDTYPE_PORTNUM) 879 return -EINVAL; 880 881 /* Convert app_idtype to a format that firmware understands */ 882 ret = __cxgb4_setapp(dev, app_idtype == DCB_APP_IDTYPE_ETHTYPE ? 883 app_idtype : 3, app_id, app_prio); 884 if (ret) 885 return ret; 886 887 return dcb_setapp(dev, &app); 888 } 889 890 /* Return whether IEEE Data Center Bridging has been negotiated. 891 */ 892 static inline int 893 cxgb4_ieee_negotiation_complete(struct net_device *dev, 894 enum cxgb4_dcb_fw_msgs dcb_subtype) 895 { 896 struct port_info *pi = netdev2pinfo(dev); 897 struct port_dcb_info *dcb = &pi->dcb; 898 899 if (dcb_subtype && !(dcb->msgs & dcb_subtype)) 900 return 0; 901 902 return (dcb->state == CXGB4_DCB_STATE_FW_ALLSYNCED && 903 (dcb->supported & DCB_CAP_DCBX_VER_IEEE)); 904 } 905 906 static int cxgb4_ieee_read_ets(struct net_device *dev, struct ieee_ets *ets, 907 int local) 908 { 909 struct port_info *pi = netdev2pinfo(dev); 910 struct port_dcb_info *dcb = &pi->dcb; 911 struct adapter *adap = pi->adapter; 912 uint32_t tc_info; 913 struct fw_port_cmd pcmd; 914 int i, bwg, err; 915 916 if (!(dcb->msgs & (CXGB4_DCB_FW_PGID | CXGB4_DCB_FW_PGRATE))) 917 return 0; 918 919 ets->ets_cap = dcb->pg_num_tcs_supported; 920 921 if (local) { 922 ets->willing = 1; 923 INIT_PORT_DCB_READ_LOCAL_CMD(pcmd, pi->port_id); 924 } else { 925 INIT_PORT_DCB_READ_PEER_CMD(pcmd, pi->port_id); 926 } 927 928 pcmd.u.dcb.pgid.type = FW_PORT_DCB_TYPE_PGID; 929 err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd); 930 if (err != FW_PORT_DCB_CFG_SUCCESS) { 931 dev_err(adap->pdev_dev, "DCB read PGID failed with %d\n", -err); 932 return err; 933 } 934 935 tc_info = be32_to_cpu(pcmd.u.dcb.pgid.pgid); 936 937 if (local) 938 INIT_PORT_DCB_READ_LOCAL_CMD(pcmd, pi->port_id); 939 else 940 INIT_PORT_DCB_READ_PEER_CMD(pcmd, pi->port_id); 941 942 pcmd.u.dcb.pgrate.type = FW_PORT_DCB_TYPE_PGRATE; 943 err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd); 944 if (err != FW_PORT_DCB_CFG_SUCCESS) { 945 dev_err(adap->pdev_dev, "DCB read PGRATE failed with %d\n", 946 -err); 947 return err; 948 } 949 950 for (i = 0; i < IEEE_8021QAZ_MAX_TCS; i++) { 951 bwg = (tc_info >> ((7 - i) * 4)) & 0xF; 952 ets->prio_tc[i] = bwg; 953 ets->tc_tx_bw[i] = pcmd.u.dcb.pgrate.pgrate[i]; 954 ets->tc_rx_bw[i] = ets->tc_tx_bw[i]; 955 ets->tc_tsa[i] = pcmd.u.dcb.pgrate.tsa[i]; 956 } 957 958 return 0; 959 } 960 961 static int cxgb4_ieee_get_ets(struct net_device *dev, struct ieee_ets *ets) 962 { 963 return cxgb4_ieee_read_ets(dev, ets, 1); 964 } 965 966 /* We reuse this for peer PFC as well, as we can't have it enabled one way */ 967 static int cxgb4_ieee_get_pfc(struct net_device *dev, struct ieee_pfc *pfc) 968 { 969 struct port_info *pi = netdev2pinfo(dev); 970 struct port_dcb_info *dcb = &pi->dcb; 971 972 memset(pfc, 0, sizeof(struct ieee_pfc)); 973 974 if (!(dcb->msgs & CXGB4_DCB_FW_PFC)) 975 return 0; 976 977 pfc->pfc_cap = dcb->pfc_num_tcs_supported; 978 pfc->pfc_en = bitswap_1(dcb->pfcen); 979 980 return 0; 981 } 982 983 static int cxgb4_ieee_peer_ets(struct net_device *dev, struct ieee_ets *ets) 984 { 985 return cxgb4_ieee_read_ets(dev, ets, 0); 986 } 987 988 /* Fill in the Application User Priority Map associated with the 989 * specified Application. 990 * Priority for IEEE dcb_app is an integer, with 0 being a valid value 991 */ 992 static int cxgb4_ieee_getapp(struct net_device *dev, struct dcb_app *app) 993 { 994 int prio; 995 996 if (!cxgb4_ieee_negotiation_complete(dev, CXGB4_DCB_FW_APP_ID)) 997 return -EINVAL; 998 if (!(app->selector && app->protocol)) 999 return -EINVAL; 1000 1001 /* Try querying firmware first, use firmware format */ 1002 prio = __cxgb4_getapp(dev, app->selector - 1, app->protocol, 0); 1003 1004 if (prio < 0) 1005 prio = dcb_ieee_getapp_mask(dev, app); 1006 1007 app->priority = ffs(prio) - 1; 1008 return 0; 1009 } 1010 1011 /* Write a new Application User Priority Map for the specified Application ID. 1012 * Priority for IEEE dcb_app is an integer, with 0 being a valid value 1013 */ 1014 static int cxgb4_ieee_setapp(struct net_device *dev, struct dcb_app *app) 1015 { 1016 int ret; 1017 1018 if (!cxgb4_ieee_negotiation_complete(dev, CXGB4_DCB_FW_APP_ID)) 1019 return -EINVAL; 1020 if (!(app->selector && app->protocol)) 1021 return -EINVAL; 1022 1023 if (!(app->selector > IEEE_8021QAZ_APP_SEL_ETHERTYPE && 1024 app->selector < IEEE_8021QAZ_APP_SEL_ANY)) 1025 return -EINVAL; 1026 1027 /* change selector to a format that firmware understands */ 1028 ret = __cxgb4_setapp(dev, app->selector - 1, app->protocol, 1029 (1 << app->priority)); 1030 if (ret) 1031 return ret; 1032 1033 return dcb_ieee_setapp(dev, app); 1034 } 1035 1036 /* Return our DCBX parameters. 1037 */ 1038 static u8 cxgb4_getdcbx(struct net_device *dev) 1039 { 1040 struct port_info *pi = netdev2pinfo(dev); 1041 1042 /* This is already set by cxgb4_set_dcb_caps, so just return it */ 1043 return pi->dcb.supported; 1044 } 1045 1046 /* Set our DCBX parameters. 1047 */ 1048 static u8 cxgb4_setdcbx(struct net_device *dev, u8 dcb_request) 1049 { 1050 struct port_info *pi = netdev2pinfo(dev); 1051 1052 /* Filter out requests which exceed our capabilities. 1053 */ 1054 if ((dcb_request & (CXGB4_DCBX_FW_SUPPORT | CXGB4_DCBX_HOST_SUPPORT)) 1055 != dcb_request) 1056 return 1; 1057 1058 /* Can't enable DCB if we haven't successfully negotiated it. 1059 */ 1060 if (pi->dcb.state != CXGB4_DCB_STATE_FW_ALLSYNCED) 1061 return 1; 1062 1063 /* There's currently no mechanism to allow for the firmware DCBX 1064 * negotiation to be changed from the Host Driver. If the caller 1065 * requests exactly the same parameters that we already have then 1066 * we'll allow them to be successfully "set" ... 1067 */ 1068 if (dcb_request != pi->dcb.supported) 1069 return 1; 1070 1071 pi->dcb.supported = dcb_request; 1072 return 0; 1073 } 1074 1075 static int cxgb4_getpeer_app(struct net_device *dev, 1076 struct dcb_peer_app_info *info, u16 *app_count) 1077 { 1078 struct fw_port_cmd pcmd; 1079 struct port_info *pi = netdev2pinfo(dev); 1080 struct adapter *adap = pi->adapter; 1081 int i, err = 0; 1082 1083 if (pi->dcb.state != CXGB4_DCB_STATE_FW_ALLSYNCED) 1084 return 1; 1085 1086 info->willing = 0; 1087 info->error = 0; 1088 1089 *app_count = 0; 1090 for (i = 0; i < CXGB4_MAX_DCBX_APP_SUPPORTED; i++) { 1091 INIT_PORT_DCB_READ_PEER_CMD(pcmd, pi->port_id); 1092 pcmd.u.dcb.app_priority.type = FW_PORT_DCB_TYPE_APP_ID; 1093 pcmd.u.dcb.app_priority.idx = *app_count; 1094 err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd); 1095 1096 if (err != FW_PORT_DCB_CFG_SUCCESS) { 1097 dev_err(adap->pdev_dev, "DCB app table read failed with %d\n", 1098 -err); 1099 return err; 1100 } 1101 1102 /* find first empty slot */ 1103 if (!pcmd.u.dcb.app_priority.protocolid) 1104 break; 1105 } 1106 *app_count = i; 1107 return err; 1108 } 1109 1110 static int cxgb4_getpeerapp_tbl(struct net_device *dev, struct dcb_app *table) 1111 { 1112 struct fw_port_cmd pcmd; 1113 struct port_info *pi = netdev2pinfo(dev); 1114 struct adapter *adap = pi->adapter; 1115 int i, err = 0; 1116 1117 if (pi->dcb.state != CXGB4_DCB_STATE_FW_ALLSYNCED) 1118 return 1; 1119 1120 for (i = 0; i < CXGB4_MAX_DCBX_APP_SUPPORTED; i++) { 1121 INIT_PORT_DCB_READ_PEER_CMD(pcmd, pi->port_id); 1122 pcmd.u.dcb.app_priority.type = FW_PORT_DCB_TYPE_APP_ID; 1123 pcmd.u.dcb.app_priority.idx = i; 1124 err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd); 1125 1126 if (err != FW_PORT_DCB_CFG_SUCCESS) { 1127 dev_err(adap->pdev_dev, "DCB app table read failed with %d\n", 1128 -err); 1129 return err; 1130 } 1131 1132 /* find first empty slot */ 1133 if (!pcmd.u.dcb.app_priority.protocolid) 1134 break; 1135 1136 table[i].selector = pcmd.u.dcb.app_priority.sel_field; 1137 table[i].protocol = 1138 be16_to_cpu(pcmd.u.dcb.app_priority.protocolid); 1139 table[i].priority = 1140 ffs(pcmd.u.dcb.app_priority.user_prio_map) - 1; 1141 } 1142 return err; 1143 } 1144 1145 /* Return Priority Group information. 1146 */ 1147 static int cxgb4_cee_peer_getpg(struct net_device *dev, struct cee_pg *pg) 1148 { 1149 struct fw_port_cmd pcmd; 1150 struct port_info *pi = netdev2pinfo(dev); 1151 struct adapter *adap = pi->adapter; 1152 u32 pgid; 1153 int i, err; 1154 1155 /* We're always "willing" -- the Switch Fabric always dictates the 1156 * DCBX parameters to us. 1157 */ 1158 pg->willing = true; 1159 1160 INIT_PORT_DCB_READ_PEER_CMD(pcmd, pi->port_id); 1161 pcmd.u.dcb.pgid.type = FW_PORT_DCB_TYPE_PGID; 1162 err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd); 1163 if (err != FW_PORT_DCB_CFG_SUCCESS) { 1164 dev_err(adap->pdev_dev, "DCB read PGID failed with %d\n", -err); 1165 return err; 1166 } 1167 pgid = be32_to_cpu(pcmd.u.dcb.pgid.pgid); 1168 1169 for (i = 0; i < CXGB4_MAX_PRIORITY; i++) 1170 pg->prio_pg[7 - i] = (pgid >> (i * 4)) & 0xF; 1171 1172 INIT_PORT_DCB_READ_PEER_CMD(pcmd, pi->port_id); 1173 pcmd.u.dcb.pgrate.type = FW_PORT_DCB_TYPE_PGRATE; 1174 err = t4_wr_mbox(adap, adap->mbox, &pcmd, sizeof(pcmd), &pcmd); 1175 if (err != FW_PORT_DCB_CFG_SUCCESS) { 1176 dev_err(adap->pdev_dev, "DCB read PGRATE failed with %d\n", 1177 -err); 1178 return err; 1179 } 1180 1181 for (i = 0; i < CXGB4_MAX_PRIORITY; i++) 1182 pg->pg_bw[i] = pcmd.u.dcb.pgrate.pgrate[i]; 1183 1184 return 0; 1185 } 1186 1187 /* Return Priority Flow Control information. 1188 */ 1189 static int cxgb4_cee_peer_getpfc(struct net_device *dev, struct cee_pfc *pfc) 1190 { 1191 struct port_info *pi = netdev2pinfo(dev); 1192 1193 cxgb4_getnumtcs(dev, DCB_NUMTCS_ATTR_PFC, &(pfc->tcs_supported)); 1194 1195 /* Firmware sends this to us in a formwat that is a bit flipped version 1196 * of spec, correct it before we send it to host. This is taken care of 1197 * by bit shifting in other uses of pfcen 1198 */ 1199 pfc->pfc_en = bitswap_1(pi->dcb.pfcen); 1200 1201 return 0; 1202 } 1203 1204 const struct dcbnl_rtnl_ops cxgb4_dcb_ops = { 1205 .ieee_getets = cxgb4_ieee_get_ets, 1206 .ieee_getpfc = cxgb4_ieee_get_pfc, 1207 .ieee_getapp = cxgb4_ieee_getapp, 1208 .ieee_setapp = cxgb4_ieee_setapp, 1209 .ieee_peer_getets = cxgb4_ieee_peer_ets, 1210 .ieee_peer_getpfc = cxgb4_ieee_get_pfc, 1211 1212 /* CEE std */ 1213 .getstate = cxgb4_getstate, 1214 .setstate = cxgb4_setstate, 1215 .getpgtccfgtx = cxgb4_getpgtccfg_tx, 1216 .getpgbwgcfgtx = cxgb4_getpgbwgcfg_tx, 1217 .getpgtccfgrx = cxgb4_getpgtccfg_rx, 1218 .getpgbwgcfgrx = cxgb4_getpgbwgcfg_rx, 1219 .setpgtccfgtx = cxgb4_setpgtccfg_tx, 1220 .setpgbwgcfgtx = cxgb4_setpgbwgcfg_tx, 1221 .setpfccfg = cxgb4_setpfccfg, 1222 .getpfccfg = cxgb4_getpfccfg, 1223 .setall = cxgb4_setall, 1224 .getcap = cxgb4_getcap, 1225 .getnumtcs = cxgb4_getnumtcs, 1226 .setnumtcs = cxgb4_setnumtcs, 1227 .getpfcstate = cxgb4_getpfcstate, 1228 .setpfcstate = cxgb4_setpfcstate, 1229 .getapp = cxgb4_getapp, 1230 .setapp = cxgb4_setapp, 1231 1232 /* DCBX configuration */ 1233 .getdcbx = cxgb4_getdcbx, 1234 .setdcbx = cxgb4_setdcbx, 1235 1236 /* peer apps */ 1237 .peer_getappinfo = cxgb4_getpeer_app, 1238 .peer_getapptable = cxgb4_getpeerapp_tbl, 1239 1240 /* CEE peer */ 1241 .cee_peer_getpg = cxgb4_cee_peer_getpg, 1242 .cee_peer_getpfc = cxgb4_cee_peer_getpfc, 1243 }; 1244