1 /******************************************************************************
3 Copyright (c) 2001-2014, Intel Corporation
6 Redistribution and use in source and binary forms, with or without
7 modification, are permitted provided that the following conditions are met:
9 1. Redistributions of source code must retain the above copyright notice,
10 this list of conditions and the following disclaimer.
12 2. Redistributions in binary form must reproduce the above copyright
13 notice, this list of conditions and the following disclaimer in the
14 documentation and/or other materials provided with the distribution.
16 3. Neither the name of the Intel Corporation nor the names of its
17 contributors may be used to endorse or promote products derived from
18 this software without specific prior written permission.
20 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
24 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 POSSIBILITY OF SUCH DAMAGE.
32 ******************************************************************************/
36 #include "ixgbe_type.h"
37 #include "ixgbe_dcb.h"
38 #include "ixgbe_dcb_82598.h"
39 #include "ixgbe_dcb_82599.h"
42 * ixgbe_dcb_calculate_tc_credits - This calculates the ieee traffic class
43 * credits from the configured bandwidth percentages. Credits
44 * are the smallest unit programmable into the underlying
45 * hardware. The IEEE 802.1Qaz specification do not use bandwidth
46 * groups so this is much simplified from the CEE case.
48 s32 ixgbe_dcb_calculate_tc_credits(u8 *bw, u16 *refill, u16 *max,
51 int min_percent = 100;
52 int min_credit, multiplier;
55 min_credit = ((max_frame_size / 2) + IXGBE_DCB_CREDIT_QUANTUM - 1) /
56 IXGBE_DCB_CREDIT_QUANTUM;
58 for (i = 0; i < IXGBE_DCB_MAX_TRAFFIC_CLASS; i++) {
59 if (bw[i] < min_percent && bw[i])
63 multiplier = (min_credit / min_percent) + 1;
65 /* Find out the hw credits for each TC */
66 for (i = 0; i < IXGBE_DCB_MAX_TRAFFIC_CLASS; i++) {
67 int val = min(bw[i] * multiplier, IXGBE_DCB_MAX_CREDIT_REFILL);
73 max[i] = bw[i] ? (bw[i]*IXGBE_DCB_MAX_CREDIT)/100 : min_credit;
80 * ixgbe_dcb_calculate_tc_credits_cee - Calculates traffic class credits
81 * @ixgbe_dcb_config: Struct containing DCB settings.
82 * @direction: Configuring either Tx or Rx.
84 * This function calculates the credits allocated to each traffic class.
85 * It should be called only after the rules are checked by
86 * ixgbe_dcb_check_config_cee().
88 s32 ixgbe_dcb_calculate_tc_credits_cee(struct ixgbe_hw *hw,
89 struct ixgbe_dcb_config *dcb_config,
90 u32 max_frame_size, u8 direction)
92 struct ixgbe_dcb_tc_path *p;
93 u32 min_multiplier = 0;
94 u16 min_percent = 100;
95 s32 ret_val = IXGBE_SUCCESS;
96 /* Initialization values default for Tx settings */
98 u32 credit_refill = 0;
100 u16 link_percentage = 0;
104 if (dcb_config == NULL) {
105 ret_val = IXGBE_ERR_CONFIG;
109 min_credit = ((max_frame_size / 2) + IXGBE_DCB_CREDIT_QUANTUM - 1) /
110 IXGBE_DCB_CREDIT_QUANTUM;
112 /* Find smallest link percentage */
113 for (i = 0; i < IXGBE_DCB_MAX_TRAFFIC_CLASS; i++) {
114 p = &dcb_config->tc_config[i].path[direction];
115 bw_percent = dcb_config->bw_percentage[direction][p->bwg_id];
116 link_percentage = p->bwg_percent;
118 link_percentage = (link_percentage * bw_percent) / 100;
120 if (link_percentage && link_percentage < min_percent)
121 min_percent = link_percentage;
125 * The ratio between traffic classes will control the bandwidth
126 * percentages seen on the wire. To calculate this ratio we use
127 * a multiplier. It is required that the refill credits must be
128 * larger than the max frame size so here we find the smallest
129 * multiplier that will allow all bandwidth percentages to be
130 * greater than the max frame size.
132 min_multiplier = (min_credit / min_percent) + 1;
134 /* Find out the link percentage for each TC first */
135 for (i = 0; i < IXGBE_DCB_MAX_TRAFFIC_CLASS; i++) {
136 p = &dcb_config->tc_config[i].path[direction];
137 bw_percent = dcb_config->bw_percentage[direction][p->bwg_id];
139 link_percentage = p->bwg_percent;
140 /* Must be careful of integer division for very small nums */
141 link_percentage = (link_percentage * bw_percent) / 100;
142 if (p->bwg_percent > 0 && link_percentage == 0)
145 /* Save link_percentage for reference */
146 p->link_percent = (u8)link_percentage;
148 /* Calculate credit refill ratio using multiplier */
149 credit_refill = min(link_percentage * min_multiplier,
150 (u32)IXGBE_DCB_MAX_CREDIT_REFILL);
151 p->data_credits_refill = (u16)credit_refill;
153 /* Calculate maximum credit for the TC */
154 credit_max = (link_percentage * IXGBE_DCB_MAX_CREDIT) / 100;
157 * Adjustment based on rule checking, if the percentage
158 * of a TC is too small, the maximum credit may not be
159 * enough to send out a jumbo frame in data plane arbitration.
161 if (credit_max && (credit_max < min_credit))
162 credit_max = min_credit;
164 if (direction == IXGBE_DCB_TX_CONFIG) {
166 * Adjustment based on rule checking, if the
167 * percentage of a TC is too small, the maximum
168 * credit may not be enough to send out a TSO
169 * packet in descriptor plane arbitration.
171 if (credit_max && (credit_max <
172 IXGBE_DCB_MIN_TSO_CREDIT)
173 && (hw->mac.type == ixgbe_mac_82598EB))
174 credit_max = IXGBE_DCB_MIN_TSO_CREDIT;
176 dcb_config->tc_config[i].desc_credits_max =
180 p->data_credits_max = (u16)credit_max;
188 * ixgbe_dcb_unpack_pfc_cee - Unpack dcb_config PFC info
189 * @cfg: dcb configuration to unpack into hardware consumable fields
190 * @map: user priority to traffic class map
191 * @pfc_up: u8 to store user priority PFC bitmask
193 * This unpacks the dcb configuration PFC info which is stored per
194 * traffic class into a 8bit user priority bitmask that can be
195 * consumed by hardware routines. The priority to tc map must be
196 * updated before calling this routine to use current up-to maps.
198 void ixgbe_dcb_unpack_pfc_cee(struct ixgbe_dcb_config *cfg, u8 *map, u8 *pfc_up)
200 struct ixgbe_dcb_tc_config *tc_config = &cfg->tc_config[0];
204 * If the TC for this user priority has PFC enabled then set the
205 * matching bit in 'pfc_up' to reflect that PFC is enabled.
207 for (*pfc_up = 0, up = 0; up < IXGBE_DCB_MAX_USER_PRIORITY; up++) {
208 if (tc_config[map[up]].pfc != ixgbe_dcb_pfc_disabled)
213 void ixgbe_dcb_unpack_refill_cee(struct ixgbe_dcb_config *cfg, int direction,
216 struct ixgbe_dcb_tc_config *tc_config = &cfg->tc_config[0];
219 for (tc = 0; tc < IXGBE_DCB_MAX_TRAFFIC_CLASS; tc++)
220 refill[tc] = tc_config[tc].path[direction].data_credits_refill;
223 void ixgbe_dcb_unpack_max_cee(struct ixgbe_dcb_config *cfg, u16 *max)
225 struct ixgbe_dcb_tc_config *tc_config = &cfg->tc_config[0];
228 for (tc = 0; tc < IXGBE_DCB_MAX_TRAFFIC_CLASS; tc++)
229 max[tc] = tc_config[tc].desc_credits_max;
232 void ixgbe_dcb_unpack_bwgid_cee(struct ixgbe_dcb_config *cfg, int direction,
235 struct ixgbe_dcb_tc_config *tc_config = &cfg->tc_config[0];
238 for (tc = 0; tc < IXGBE_DCB_MAX_TRAFFIC_CLASS; tc++)
239 bwgid[tc] = tc_config[tc].path[direction].bwg_id;
242 void ixgbe_dcb_unpack_tsa_cee(struct ixgbe_dcb_config *cfg, int direction,
245 struct ixgbe_dcb_tc_config *tc_config = &cfg->tc_config[0];
248 for (tc = 0; tc < IXGBE_DCB_MAX_TRAFFIC_CLASS; tc++)
249 tsa[tc] = tc_config[tc].path[direction].tsa;
252 u8 ixgbe_dcb_get_tc_from_up(struct ixgbe_dcb_config *cfg, int direction, u8 up)
254 struct ixgbe_dcb_tc_config *tc_config = &cfg->tc_config[0];
255 u8 prio_mask = 1 << up;
256 u8 tc = cfg->num_tcs.pg_tcs;
258 /* If tc is 0 then DCB is likely not enabled or supported */
263 * Test from maximum TC to 1 and report the first match we find. If
264 * we find no match we can assume that the TC is 0 since the TC must
265 * be set for all user priorities
267 for (tc--; tc; tc--) {
268 if (prio_mask & tc_config[tc].path[direction].up_to_tc_bitmap)
275 void ixgbe_dcb_unpack_map_cee(struct ixgbe_dcb_config *cfg, int direction,
280 for (up = 0; up < IXGBE_DCB_MAX_USER_PRIORITY; up++)
281 map[up] = ixgbe_dcb_get_tc_from_up(cfg, direction, up);
285 * ixgbe_dcb_config - Struct containing DCB settings.
286 * @dcb_config: Pointer to DCB config structure
288 * This function checks DCB rules for DCB settings.
289 * The following rules are checked:
290 * 1. The sum of bandwidth percentages of all Bandwidth Groups must total 100%.
291 * 2. The sum of bandwidth percentages of all Traffic Classes within a Bandwidth
292 * Group must total 100.
293 * 3. A Traffic Class should not be set to both Link Strict Priority
294 * and Group Strict Priority.
295 * 4. Link strict Bandwidth Groups can only have link strict traffic classes
296 * with zero bandwidth.
298 s32 ixgbe_dcb_check_config_cee(struct ixgbe_dcb_config *dcb_config)
300 struct ixgbe_dcb_tc_path *p;
301 s32 ret_val = IXGBE_SUCCESS;
302 u8 i, j, bw = 0, bw_id;
303 u8 bw_sum[2][IXGBE_DCB_MAX_BW_GROUP];
304 bool link_strict[2][IXGBE_DCB_MAX_BW_GROUP];
306 memset(bw_sum, 0, sizeof(bw_sum));
307 memset(link_strict, 0, sizeof(link_strict));
309 /* First Tx, then Rx */
310 for (i = 0; i < 2; i++) {
311 /* Check each traffic class for rule violation */
312 for (j = 0; j < IXGBE_DCB_MAX_TRAFFIC_CLASS; j++) {
313 p = &dcb_config->tc_config[j].path[i];
318 if (bw_id >= IXGBE_DCB_MAX_BW_GROUP) {
319 ret_val = IXGBE_ERR_CONFIG;
322 if (p->tsa == ixgbe_dcb_tsa_strict) {
323 link_strict[i][bw_id] = TRUE;
324 /* Link strict should have zero bandwidth */
326 ret_val = IXGBE_ERR_CONFIG;
331 * Traffic classes without link strict
332 * should have non-zero bandwidth.
334 ret_val = IXGBE_ERR_CONFIG;
337 bw_sum[i][bw_id] += bw;
342 /* Check each bandwidth group for rule violation */
343 for (j = 0; j < IXGBE_DCB_MAX_BW_GROUP; j++) {
344 bw += dcb_config->bw_percentage[i][j];
346 * Sum of bandwidth percentages of all traffic classes
347 * within a Bandwidth Group must total 100 except for
348 * link strict group (zero bandwidth).
350 if (link_strict[i][j]) {
353 * Link strict group should have zero
356 ret_val = IXGBE_ERR_CONFIG;
359 } else if (bw_sum[i][j] != IXGBE_DCB_BW_PERCENT &&
361 ret_val = IXGBE_ERR_CONFIG;
366 if (bw != IXGBE_DCB_BW_PERCENT) {
367 ret_val = IXGBE_ERR_CONFIG;
373 DEBUGOUT2("DCB error code %d while checking %s settings.\n",
374 ret_val, (i == IXGBE_DCB_TX_CONFIG) ? "Tx" : "Rx");
380 * ixgbe_dcb_get_tc_stats - Returns status of each traffic class
381 * @hw: pointer to hardware structure
382 * @stats: pointer to statistics structure
383 * @tc_count: Number of elements in bwg_array.
385 * This function returns the status data for each of the Traffic Classes in use.
387 s32 ixgbe_dcb_get_tc_stats(struct ixgbe_hw *hw, struct ixgbe_hw_stats *stats,
390 s32 ret = IXGBE_NOT_IMPLEMENTED;
391 switch (hw->mac.type) {
392 case ixgbe_mac_82598EB:
393 ret = ixgbe_dcb_get_tc_stats_82598(hw, stats, tc_count);
395 case ixgbe_mac_82599EB:
398 case ixgbe_mac_X550EM_x:
399 case ixgbe_mac_X550EM_a:
400 #if !defined(NO_82599_SUPPORT) || !defined(NO_X540_SUPPORT)
401 ret = ixgbe_dcb_get_tc_stats_82599(hw, stats, tc_count);
411 * ixgbe_dcb_get_pfc_stats - Returns CBFC status of each traffic class
412 * @hw: pointer to hardware structure
413 * @stats: pointer to statistics structure
414 * @tc_count: Number of elements in bwg_array.
416 * This function returns the CBFC status data for each of the Traffic Classes.
418 s32 ixgbe_dcb_get_pfc_stats(struct ixgbe_hw *hw, struct ixgbe_hw_stats *stats,
421 s32 ret = IXGBE_NOT_IMPLEMENTED;
422 switch (hw->mac.type) {
423 case ixgbe_mac_82598EB:
424 ret = ixgbe_dcb_get_pfc_stats_82598(hw, stats, tc_count);
426 case ixgbe_mac_82599EB:
429 case ixgbe_mac_X550EM_x:
430 case ixgbe_mac_X550EM_a:
431 #if !defined(NO_82599_SUPPORT) || !defined(NO_X540_SUPPORT)
432 ret = ixgbe_dcb_get_pfc_stats_82599(hw, stats, tc_count);
442 * ixgbe_dcb_config_rx_arbiter_cee - Config Rx arbiter
443 * @hw: pointer to hardware structure
444 * @dcb_config: pointer to ixgbe_dcb_config structure
446 * Configure Rx Data Arbiter and credits for each traffic class.
448 s32 ixgbe_dcb_config_rx_arbiter_cee(struct ixgbe_hw *hw,
449 struct ixgbe_dcb_config *dcb_config)
451 s32 ret = IXGBE_NOT_IMPLEMENTED;
452 u8 tsa[IXGBE_DCB_MAX_TRAFFIC_CLASS] = { 0 };
453 u8 bwgid[IXGBE_DCB_MAX_TRAFFIC_CLASS] = { 0 };
454 u8 map[IXGBE_DCB_MAX_USER_PRIORITY] = { 0 };
455 u16 refill[IXGBE_DCB_MAX_TRAFFIC_CLASS] = { 0 };
456 u16 max[IXGBE_DCB_MAX_TRAFFIC_CLASS] = { 0 };
458 ixgbe_dcb_unpack_refill_cee(dcb_config, IXGBE_DCB_TX_CONFIG, refill);
459 ixgbe_dcb_unpack_max_cee(dcb_config, max);
460 ixgbe_dcb_unpack_bwgid_cee(dcb_config, IXGBE_DCB_TX_CONFIG, bwgid);
461 ixgbe_dcb_unpack_tsa_cee(dcb_config, IXGBE_DCB_TX_CONFIG, tsa);
462 ixgbe_dcb_unpack_map_cee(dcb_config, IXGBE_DCB_TX_CONFIG, map);
464 switch (hw->mac.type) {
465 case ixgbe_mac_82598EB:
466 ret = ixgbe_dcb_config_rx_arbiter_82598(hw, refill, max, tsa);
468 case ixgbe_mac_82599EB:
471 case ixgbe_mac_X550EM_x:
472 case ixgbe_mac_X550EM_a:
473 #if !defined(NO_82599_SUPPORT) || !defined(NO_X540_SUPPORT)
474 ret = ixgbe_dcb_config_rx_arbiter_82599(hw, refill, max, bwgid,
485 * ixgbe_dcb_config_tx_desc_arbiter_cee - Config Tx Desc arbiter
486 * @hw: pointer to hardware structure
487 * @dcb_config: pointer to ixgbe_dcb_config structure
489 * Configure Tx Descriptor Arbiter and credits for each traffic class.
491 s32 ixgbe_dcb_config_tx_desc_arbiter_cee(struct ixgbe_hw *hw,
492 struct ixgbe_dcb_config *dcb_config)
494 s32 ret = IXGBE_NOT_IMPLEMENTED;
495 u8 tsa[IXGBE_DCB_MAX_TRAFFIC_CLASS];
496 u8 bwgid[IXGBE_DCB_MAX_TRAFFIC_CLASS];
497 u16 refill[IXGBE_DCB_MAX_TRAFFIC_CLASS];
498 u16 max[IXGBE_DCB_MAX_TRAFFIC_CLASS];
500 ixgbe_dcb_unpack_refill_cee(dcb_config, IXGBE_DCB_TX_CONFIG, refill);
501 ixgbe_dcb_unpack_max_cee(dcb_config, max);
502 ixgbe_dcb_unpack_bwgid_cee(dcb_config, IXGBE_DCB_TX_CONFIG, bwgid);
503 ixgbe_dcb_unpack_tsa_cee(dcb_config, IXGBE_DCB_TX_CONFIG, tsa);
505 switch (hw->mac.type) {
506 case ixgbe_mac_82598EB:
507 ret = ixgbe_dcb_config_tx_desc_arbiter_82598(hw, refill, max,
510 case ixgbe_mac_82599EB:
513 case ixgbe_mac_X550EM_x:
514 case ixgbe_mac_X550EM_a:
515 #if !defined(NO_82599_SUPPORT) || !defined(NO_X540_SUPPORT)
516 ret = ixgbe_dcb_config_tx_desc_arbiter_82599(hw, refill, max,
527 * ixgbe_dcb_config_tx_data_arbiter_cee - Config Tx data arbiter
528 * @hw: pointer to hardware structure
529 * @dcb_config: pointer to ixgbe_dcb_config structure
531 * Configure Tx Data Arbiter and credits for each traffic class.
533 s32 ixgbe_dcb_config_tx_data_arbiter_cee(struct ixgbe_hw *hw,
534 struct ixgbe_dcb_config *dcb_config)
536 s32 ret = IXGBE_NOT_IMPLEMENTED;
537 u8 tsa[IXGBE_DCB_MAX_TRAFFIC_CLASS];
538 u8 bwgid[IXGBE_DCB_MAX_TRAFFIC_CLASS];
539 u8 map[IXGBE_DCB_MAX_USER_PRIORITY] = { 0 };
540 u16 refill[IXGBE_DCB_MAX_TRAFFIC_CLASS];
541 u16 max[IXGBE_DCB_MAX_TRAFFIC_CLASS];
543 ixgbe_dcb_unpack_refill_cee(dcb_config, IXGBE_DCB_TX_CONFIG, refill);
544 ixgbe_dcb_unpack_max_cee(dcb_config, max);
545 ixgbe_dcb_unpack_bwgid_cee(dcb_config, IXGBE_DCB_TX_CONFIG, bwgid);
546 ixgbe_dcb_unpack_tsa_cee(dcb_config, IXGBE_DCB_TX_CONFIG, tsa);
547 ixgbe_dcb_unpack_map_cee(dcb_config, IXGBE_DCB_TX_CONFIG, map);
549 switch (hw->mac.type) {
550 case ixgbe_mac_82598EB:
551 ret = ixgbe_dcb_config_tx_data_arbiter_82598(hw, refill, max,
554 case ixgbe_mac_82599EB:
557 case ixgbe_mac_X550EM_x:
558 case ixgbe_mac_X550EM_a:
559 #if !defined(NO_82599_SUPPORT) || !defined(NO_X540_SUPPORT)
560 ret = ixgbe_dcb_config_tx_data_arbiter_82599(hw, refill, max,
572 * ixgbe_dcb_config_pfc_cee - Config priority flow control
573 * @hw: pointer to hardware structure
574 * @dcb_config: pointer to ixgbe_dcb_config structure
576 * Configure Priority Flow Control for each traffic class.
578 s32 ixgbe_dcb_config_pfc_cee(struct ixgbe_hw *hw,
579 struct ixgbe_dcb_config *dcb_config)
581 s32 ret = IXGBE_NOT_IMPLEMENTED;
583 u8 map[IXGBE_DCB_MAX_USER_PRIORITY] = { 0 };
585 ixgbe_dcb_unpack_map_cee(dcb_config, IXGBE_DCB_TX_CONFIG, map);
586 ixgbe_dcb_unpack_pfc_cee(dcb_config, map, &pfc_en);
588 switch (hw->mac.type) {
589 case ixgbe_mac_82598EB:
590 ret = ixgbe_dcb_config_pfc_82598(hw, pfc_en);
592 case ixgbe_mac_82599EB:
595 case ixgbe_mac_X550EM_x:
596 case ixgbe_mac_X550EM_a:
597 #if !defined(NO_82599_SUPPORT) || !defined(NO_X540_SUPPORT)
598 ret = ixgbe_dcb_config_pfc_82599(hw, pfc_en, map);
608 * ixgbe_dcb_config_tc_stats - Config traffic class statistics
609 * @hw: pointer to hardware structure
611 * Configure queue statistics registers, all queues belonging to same traffic
612 * class uses a single set of queue statistics counters.
614 s32 ixgbe_dcb_config_tc_stats(struct ixgbe_hw *hw)
616 s32 ret = IXGBE_NOT_IMPLEMENTED;
617 switch (hw->mac.type) {
618 case ixgbe_mac_82598EB:
619 ret = ixgbe_dcb_config_tc_stats_82598(hw);
621 case ixgbe_mac_82599EB:
624 case ixgbe_mac_X550EM_x:
625 case ixgbe_mac_X550EM_a:
626 #if !defined(NO_82599_SUPPORT) || !defined(NO_X540_SUPPORT)
627 ret = ixgbe_dcb_config_tc_stats_82599(hw, NULL);
637 * ixgbe_dcb_hw_config_cee - Config and enable DCB
638 * @hw: pointer to hardware structure
639 * @dcb_config: pointer to ixgbe_dcb_config structure
641 * Configure dcb settings and enable dcb mode.
643 s32 ixgbe_dcb_hw_config_cee(struct ixgbe_hw *hw,
644 struct ixgbe_dcb_config *dcb_config)
646 s32 ret = IXGBE_NOT_IMPLEMENTED;
648 u8 tsa[IXGBE_DCB_MAX_TRAFFIC_CLASS];
649 u8 bwgid[IXGBE_DCB_MAX_TRAFFIC_CLASS];
650 u8 map[IXGBE_DCB_MAX_USER_PRIORITY] = { 0 };
651 u16 refill[IXGBE_DCB_MAX_TRAFFIC_CLASS];
652 u16 max[IXGBE_DCB_MAX_TRAFFIC_CLASS];
654 /* Unpack CEE standard containers */
655 ixgbe_dcb_unpack_refill_cee(dcb_config, IXGBE_DCB_TX_CONFIG, refill);
656 ixgbe_dcb_unpack_max_cee(dcb_config, max);
657 ixgbe_dcb_unpack_bwgid_cee(dcb_config, IXGBE_DCB_TX_CONFIG, bwgid);
658 ixgbe_dcb_unpack_tsa_cee(dcb_config, IXGBE_DCB_TX_CONFIG, tsa);
659 ixgbe_dcb_unpack_map_cee(dcb_config, IXGBE_DCB_TX_CONFIG, map);
661 hw->mac.ops.setup_rxpba(hw, dcb_config->num_tcs.pg_tcs,
662 0, dcb_config->rx_pba_cfg);
664 switch (hw->mac.type) {
665 case ixgbe_mac_82598EB:
666 ret = ixgbe_dcb_hw_config_82598(hw, dcb_config->link_speed,
667 refill, max, bwgid, tsa);
669 case ixgbe_mac_82599EB:
672 case ixgbe_mac_X550EM_x:
673 case ixgbe_mac_X550EM_a:
674 #if !defined(NO_82599_SUPPORT) || !defined(NO_X540_SUPPORT)
675 ixgbe_dcb_config_82599(hw, dcb_config);
676 ret = ixgbe_dcb_hw_config_82599(hw, dcb_config->link_speed,
680 ixgbe_dcb_config_tc_stats_82599(hw, dcb_config);
687 if (!ret && dcb_config->pfc_mode_enable) {
688 ixgbe_dcb_unpack_pfc_cee(dcb_config, map, &pfc_en);
689 ret = ixgbe_dcb_config_pfc(hw, pfc_en, map);
695 /* Helper routines to abstract HW specifics from DCB netlink ops */
696 s32 ixgbe_dcb_config_pfc(struct ixgbe_hw *hw, u8 pfc_en, u8 *map)
698 int ret = IXGBE_ERR_PARAM;
700 switch (hw->mac.type) {
701 case ixgbe_mac_82598EB:
702 ret = ixgbe_dcb_config_pfc_82598(hw, pfc_en);
704 case ixgbe_mac_82599EB:
707 case ixgbe_mac_X550EM_x:
708 case ixgbe_mac_X550EM_a:
709 #if !defined(NO_82599_SUPPORT) || !defined(NO_X540_SUPPORT)
710 ret = ixgbe_dcb_config_pfc_82599(hw, pfc_en, map);
719 s32 ixgbe_dcb_hw_config(struct ixgbe_hw *hw, u16 *refill, u16 *max,
720 u8 *bwg_id, u8 *tsa, u8 *map)
722 switch (hw->mac.type) {
723 case ixgbe_mac_82598EB:
724 ixgbe_dcb_config_rx_arbiter_82598(hw, refill, max, tsa);
725 ixgbe_dcb_config_tx_desc_arbiter_82598(hw, refill, max, bwg_id,
727 ixgbe_dcb_config_tx_data_arbiter_82598(hw, refill, max, bwg_id,
730 case ixgbe_mac_82599EB:
733 case ixgbe_mac_X550EM_x:
734 case ixgbe_mac_X550EM_a:
735 #if !defined(NO_82599_SUPPORT) || !defined(NO_X540_SUPPORT)
736 ixgbe_dcb_config_rx_arbiter_82599(hw, refill, max, bwg_id,
738 ixgbe_dcb_config_tx_desc_arbiter_82599(hw, refill, max, bwg_id,
740 ixgbe_dcb_config_tx_data_arbiter_82599(hw, refill, max, bwg_id,