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