LCOV - code coverage report
Current view: top level - drivers/net/ixgbe/base - ixgbe_dcb_82599.c (source / functions) Hit Total Coverage
Test: Code coverage Lines: 0 165 0.0 %
Date: 2024-01-22 16:26:08 Functions: 0 9 0.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 111 0.0 %

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  * Copyright(c) 2001-2020 Intel Corporation
       3                 :            :  */
       4                 :            : 
       5                 :            : 
       6                 :            : #include "ixgbe_type.h"
       7                 :            : #include "ixgbe_dcb.h"
       8                 :            : #include "ixgbe_dcb_82599.h"
       9                 :            : 
      10                 :            : /**
      11                 :            :  * ixgbe_dcb_get_tc_stats_82599 - Returns status for each traffic class
      12                 :            :  * @hw: pointer to hardware structure
      13                 :            :  * @stats: pointer to statistics structure
      14                 :            :  * @tc_count:  Number of elements in bwg_array.
      15                 :            :  *
      16                 :            :  * This function returns the status data for each of the Traffic Classes in use.
      17                 :            :  */
      18                 :          0 : s32 ixgbe_dcb_get_tc_stats_82599(struct ixgbe_hw *hw,
      19                 :            :                                  struct ixgbe_hw_stats *stats,
      20                 :            :                                  u8 tc_count)
      21                 :            : {
      22                 :            :         int tc;
      23                 :            : 
      24                 :          0 :         DEBUGFUNC("dcb_get_tc_stats");
      25                 :            : 
      26         [ #  # ]:          0 :         if (tc_count > IXGBE_DCB_MAX_TRAFFIC_CLASS)
      27                 :            :                 return IXGBE_ERR_PARAM;
      28                 :            : 
      29                 :            :         /* Statistics pertaining to each traffic class */
      30         [ #  # ]:          0 :         for (tc = 0; tc < tc_count; tc++) {
      31                 :            :                 /* Transmitted Packets */
      32                 :          0 :                 stats->qptc[tc] += IXGBE_READ_REG(hw, IXGBE_QPTC(tc));
      33                 :            :                 /* Transmitted Bytes (read low first to prevent missed carry) */
      34                 :          0 :                 stats->qbtc[tc] += IXGBE_READ_REG(hw, IXGBE_QBTC_L(tc));
      35                 :          0 :                 stats->qbtc[tc] +=
      36                 :          0 :                         (((u64)(IXGBE_READ_REG(hw, IXGBE_QBTC_H(tc)))) << 32);
      37                 :            :                 /* Received Packets */
      38                 :          0 :                 stats->qprc[tc] += IXGBE_READ_REG(hw, IXGBE_QPRC(tc));
      39                 :            :                 /* Received Bytes (read low first to prevent missed carry) */
      40                 :          0 :                 stats->qbrc[tc] += IXGBE_READ_REG(hw, IXGBE_QBRC_L(tc));
      41                 :          0 :                 stats->qbrc[tc] +=
      42                 :          0 :                         (((u64)(IXGBE_READ_REG(hw, IXGBE_QBRC_H(tc)))) << 32);
      43                 :            : 
      44                 :            :                 /* Received Dropped Packet */
      45                 :          0 :                 stats->qprdc[tc] += IXGBE_READ_REG(hw, IXGBE_QPRDC(tc));
      46                 :            :         }
      47                 :            : 
      48                 :            :         return IXGBE_SUCCESS;
      49                 :            : }
      50                 :            : 
      51                 :            : /**
      52                 :            :  * ixgbe_dcb_get_pfc_stats_82599 - Return CBFC status data
      53                 :            :  * @hw: pointer to hardware structure
      54                 :            :  * @stats: pointer to statistics structure
      55                 :            :  * @tc_count:  Number of elements in bwg_array.
      56                 :            :  *
      57                 :            :  * This function returns the CBFC status data for each of the Traffic Classes.
      58                 :            :  */
      59                 :          0 : s32 ixgbe_dcb_get_pfc_stats_82599(struct ixgbe_hw *hw,
      60                 :            :                                   struct ixgbe_hw_stats *stats,
      61                 :            :                                   u8 tc_count)
      62                 :            : {
      63                 :            :         int tc;
      64                 :            : 
      65                 :          0 :         DEBUGFUNC("dcb_get_pfc_stats");
      66                 :            : 
      67         [ #  # ]:          0 :         if (tc_count > IXGBE_DCB_MAX_TRAFFIC_CLASS)
      68                 :            :                 return IXGBE_ERR_PARAM;
      69                 :            : 
      70         [ #  # ]:          0 :         for (tc = 0; tc < tc_count; tc++) {
      71                 :            :                 /* Priority XOFF Transmitted */
      72                 :          0 :                 stats->pxofftxc[tc] += IXGBE_READ_REG(hw, IXGBE_PXOFFTXC(tc));
      73                 :            :                 /* Priority XOFF Received */
      74                 :          0 :                 stats->pxoffrxc[tc] += IXGBE_READ_REG(hw, IXGBE_PXOFFRXCNT(tc));
      75                 :            :         }
      76                 :            : 
      77                 :            :         return IXGBE_SUCCESS;
      78                 :            : }
      79                 :            : 
      80                 :            : /**
      81                 :            :  * ixgbe_dcb_config_rx_arbiter_82599 - Config Rx Data arbiter
      82                 :            :  * @hw: pointer to hardware structure
      83                 :            :  * @refill: refill credits index by traffic class
      84                 :            :  * @max: max credits index by traffic class
      85                 :            :  * @bwg_id: bandwidth grouping indexed by traffic class
      86                 :            :  * @tsa: transmission selection algorithm indexed by traffic class
      87                 :            :  * @map: priority to tc assignments indexed by priority
      88                 :            :  *
      89                 :            :  * Configure Rx Packet Arbiter and credits for each traffic class.
      90                 :            :  */
      91                 :          0 : s32 ixgbe_dcb_config_rx_arbiter_82599(struct ixgbe_hw *hw, u16 *refill,
      92                 :            :                                       u16 *max, u8 *bwg_id, u8 *tsa,
      93                 :            :                                       u8 *map)
      94                 :            : {
      95                 :            :         u32 reg = 0;
      96                 :            :         u32 credit_refill = 0;
      97                 :            :         u32 credit_max = 0;
      98                 :            :         u8  i = 0;
      99                 :            : 
     100                 :            :         /*
     101                 :            :          * Disable the arbiter before changing parameters
     102                 :            :          * (always enable recycle mode; WSP)
     103                 :            :          */
     104                 :            :         reg = IXGBE_RTRPCS_RRM | IXGBE_RTRPCS_RAC | IXGBE_RTRPCS_ARBDIS;
     105                 :          0 :         IXGBE_WRITE_REG(hw, IXGBE_RTRPCS, reg);
     106                 :            : 
     107                 :            :         /*
     108                 :            :          * map all UPs to TCs. up_to_tc_bitmap for each TC has corresponding
     109                 :            :          * bits sets for the UPs that needs to be mappped to that TC.
     110                 :            :          * e.g if priorities 6 and 7 are to be mapped to a TC then the
     111                 :            :          * up_to_tc_bitmap value for that TC will be 11000000 in binary.
     112                 :            :          */
     113                 :            :         reg = 0;
     114         [ #  # ]:          0 :         for (i = 0; i < IXGBE_DCB_MAX_USER_PRIORITY; i++)
     115                 :          0 :                 reg |= (map[i] << (i * IXGBE_RTRUP2TC_UP_SHIFT));
     116                 :            : 
     117                 :          0 :         IXGBE_WRITE_REG(hw, IXGBE_RTRUP2TC, reg);
     118                 :            : 
     119                 :            :         /* Configure traffic class credits and priority */
     120         [ #  # ]:          0 :         for (i = 0; i < IXGBE_DCB_MAX_TRAFFIC_CLASS; i++) {
     121                 :          0 :                 credit_refill = refill[i];
     122                 :          0 :                 credit_max = max[i];
     123                 :          0 :                 reg = credit_refill | (credit_max << IXGBE_RTRPT4C_MCL_SHIFT);
     124                 :            : 
     125                 :          0 :                 reg |= (u32)(bwg_id[i]) << IXGBE_RTRPT4C_BWG_SHIFT;
     126                 :            : 
     127         [ #  # ]:          0 :                 if (tsa[i] == ixgbe_dcb_tsa_strict)
     128                 :          0 :                         reg |= IXGBE_RTRPT4C_LSP;
     129                 :            : 
     130                 :          0 :                 IXGBE_WRITE_REG(hw, IXGBE_RTRPT4C(i), reg);
     131                 :            :         }
     132                 :            : 
     133                 :            :         /*
     134                 :            :          * Configure Rx packet plane (recycle mode; WSP) and
     135                 :            :          * enable arbiter
     136                 :            :          */
     137                 :            :         reg = IXGBE_RTRPCS_RRM | IXGBE_RTRPCS_RAC;
     138                 :          0 :         IXGBE_WRITE_REG(hw, IXGBE_RTRPCS, reg);
     139                 :            : 
     140                 :          0 :         return IXGBE_SUCCESS;
     141                 :            : }
     142                 :            : 
     143                 :            : /**
     144                 :            :  * ixgbe_dcb_config_tx_desc_arbiter_82599 - Config Tx Desc. arbiter
     145                 :            :  * @hw: pointer to hardware structure
     146                 :            :  * @refill: refill credits index by traffic class
     147                 :            :  * @max: max credits index by traffic class
     148                 :            :  * @bwg_id: bandwidth grouping indexed by traffic class
     149                 :            :  * @tsa: transmission selection algorithm indexed by traffic class
     150                 :            :  *
     151                 :            :  * Configure Tx Descriptor Arbiter and credits for each traffic class.
     152                 :            :  */
     153                 :          0 : s32 ixgbe_dcb_config_tx_desc_arbiter_82599(struct ixgbe_hw *hw, u16 *refill,
     154                 :            :                                            u16 *max, u8 *bwg_id, u8 *tsa)
     155                 :            : {
     156                 :            :         u32 reg, max_credits;
     157                 :            :         u8  i;
     158                 :            : 
     159                 :            :         /* Clear the per-Tx queue credits; we use per-TC instead */
     160         [ #  # ]:          0 :         for (i = 0; i < 128; i++) {
     161                 :          0 :                 IXGBE_WRITE_REG(hw, IXGBE_RTTDQSEL, i);
     162                 :          0 :                 IXGBE_WRITE_REG(hw, IXGBE_RTTDT1C, 0);
     163                 :            :         }
     164                 :            : 
     165                 :            :         /* Configure traffic class credits and priority */
     166         [ #  # ]:          0 :         for (i = 0; i < IXGBE_DCB_MAX_TRAFFIC_CLASS; i++) {
     167                 :          0 :                 max_credits = max[i];
     168                 :          0 :                 reg = max_credits << IXGBE_RTTDT2C_MCL_SHIFT;
     169                 :          0 :                 reg |= (u32)(refill[i]);
     170                 :          0 :                 reg |= (u32)(bwg_id[i]) << IXGBE_RTTDT2C_BWG_SHIFT;
     171                 :            : 
     172         [ #  # ]:          0 :                 if (tsa[i] == ixgbe_dcb_tsa_group_strict_cee)
     173                 :          0 :                         reg |= IXGBE_RTTDT2C_GSP;
     174                 :            : 
     175         [ #  # ]:          0 :                 if (tsa[i] == ixgbe_dcb_tsa_strict)
     176                 :          0 :                         reg |= IXGBE_RTTDT2C_LSP;
     177                 :            : 
     178                 :          0 :                 IXGBE_WRITE_REG(hw, IXGBE_RTTDT2C(i), reg);
     179                 :            :         }
     180                 :            : 
     181                 :            :         /*
     182                 :            :          * Configure Tx descriptor plane (recycle mode; WSP) and
     183                 :            :          * enable arbiter
     184                 :            :          */
     185                 :            :         reg = IXGBE_RTTDCS_TDPAC | IXGBE_RTTDCS_TDRM;
     186                 :          0 :         IXGBE_WRITE_REG(hw, IXGBE_RTTDCS, reg);
     187                 :            : 
     188                 :          0 :         return IXGBE_SUCCESS;
     189                 :            : }
     190                 :            : 
     191                 :            : /**
     192                 :            :  * ixgbe_dcb_config_tx_data_arbiter_82599 - Config Tx Data arbiter
     193                 :            :  * @hw: pointer to hardware structure
     194                 :            :  * @refill: refill credits index by traffic class
     195                 :            :  * @max: max credits index by traffic class
     196                 :            :  * @bwg_id: bandwidth grouping indexed by traffic class
     197                 :            :  * @tsa: transmission selection algorithm indexed by traffic class
     198                 :            :  * @map: priority to tc assignments indexed by priority
     199                 :            :  *
     200                 :            :  * Configure Tx Packet Arbiter and credits for each traffic class.
     201                 :            :  */
     202                 :          0 : s32 ixgbe_dcb_config_tx_data_arbiter_82599(struct ixgbe_hw *hw, u16 *refill,
     203                 :            :                                            u16 *max, u8 *bwg_id, u8 *tsa,
     204                 :            :                                            u8 *map)
     205                 :            : {
     206                 :            :         u32 reg;
     207                 :            :         u8 i;
     208                 :            : 
     209                 :            :         /*
     210                 :            :          * Disable the arbiter before changing parameters
     211                 :            :          * (always enable recycle mode; SP; arb delay)
     212                 :            :          */
     213                 :            :         reg = IXGBE_RTTPCS_TPPAC | IXGBE_RTTPCS_TPRM |
     214                 :            :               (IXGBE_RTTPCS_ARBD_DCB << IXGBE_RTTPCS_ARBD_SHIFT) |
     215                 :            :               IXGBE_RTTPCS_ARBDIS;
     216                 :          0 :         IXGBE_WRITE_REG(hw, IXGBE_RTTPCS, reg);
     217                 :            : 
     218                 :            :         /*
     219                 :            :          * map all UPs to TCs. up_to_tc_bitmap for each TC has corresponding
     220                 :            :          * bits sets for the UPs that needs to be mappped to that TC.
     221                 :            :          * e.g if priorities 6 and 7 are to be mapped to a TC then the
     222                 :            :          * up_to_tc_bitmap value for that TC will be 11000000 in binary.
     223                 :            :          */
     224                 :            :         reg = 0;
     225         [ #  # ]:          0 :         for (i = 0; i < IXGBE_DCB_MAX_USER_PRIORITY; i++)
     226                 :          0 :                 reg |= (map[i] << (i * IXGBE_RTTUP2TC_UP_SHIFT));
     227                 :            : 
     228                 :          0 :         IXGBE_WRITE_REG(hw, IXGBE_RTTUP2TC, reg);
     229                 :            : 
     230                 :            :         /* Configure traffic class credits and priority */
     231         [ #  # ]:          0 :         for (i = 0; i < IXGBE_DCB_MAX_TRAFFIC_CLASS; i++) {
     232                 :          0 :                 reg = refill[i];
     233                 :          0 :                 reg |= (u32)(max[i]) << IXGBE_RTTPT2C_MCL_SHIFT;
     234                 :          0 :                 reg |= (u32)(bwg_id[i]) << IXGBE_RTTPT2C_BWG_SHIFT;
     235                 :            : 
     236         [ #  # ]:          0 :                 if (tsa[i] == ixgbe_dcb_tsa_group_strict_cee)
     237                 :          0 :                         reg |= IXGBE_RTTPT2C_GSP;
     238                 :            : 
     239         [ #  # ]:          0 :                 if (tsa[i] == ixgbe_dcb_tsa_strict)
     240                 :          0 :                         reg |= IXGBE_RTTPT2C_LSP;
     241                 :            : 
     242                 :          0 :                 IXGBE_WRITE_REG(hw, IXGBE_RTTPT2C(i), reg);
     243                 :            :         }
     244                 :            : 
     245                 :            :         /*
     246                 :            :          * Configure Tx packet plane (recycle mode; SP; arb delay) and
     247                 :            :          * enable arbiter
     248                 :            :          */
     249                 :            :         reg = IXGBE_RTTPCS_TPPAC | IXGBE_RTTPCS_TPRM |
     250                 :            :               (IXGBE_RTTPCS_ARBD_DCB << IXGBE_RTTPCS_ARBD_SHIFT);
     251                 :          0 :         IXGBE_WRITE_REG(hw, IXGBE_RTTPCS, reg);
     252                 :            : 
     253                 :          0 :         return IXGBE_SUCCESS;
     254                 :            : }
     255                 :            : 
     256                 :            : /**
     257                 :            :  * ixgbe_dcb_config_pfc_82599 - Configure priority flow control
     258                 :            :  * @hw: pointer to hardware structure
     259                 :            :  * @pfc_en: enabled pfc bitmask
     260                 :            :  * @map: priority to tc assignments indexed by priority
     261                 :            :  *
     262                 :            :  * Configure Priority Flow Control (PFC) for each traffic class.
     263                 :            :  */
     264                 :          0 : s32 ixgbe_dcb_config_pfc_82599(struct ixgbe_hw *hw, u8 pfc_en, u8 *map)
     265                 :            : {
     266                 :            :         u32 i, j, fcrtl, reg;
     267                 :            :         u8 max_tc = 0;
     268                 :            : 
     269                 :            :         /* Enable Transmit Priority Flow Control */
     270                 :          0 :         IXGBE_WRITE_REG(hw, IXGBE_FCCFG, IXGBE_FCCFG_TFCE_PRIORITY);
     271                 :            : 
     272                 :            :         /* Enable Receive Priority Flow Control */
     273                 :          0 :         reg = IXGBE_READ_REG(hw, IXGBE_MFLCN);
     274                 :            :         reg |= IXGBE_MFLCN_DPF;
     275                 :            : 
     276                 :            :         /*
     277                 :            :          * X540 supports per TC Rx priority flow control.  So
     278                 :            :          * clear all TCs and only enable those that should be
     279                 :            :          * enabled.
     280                 :            :          */
     281                 :          0 :         reg &= ~(IXGBE_MFLCN_RPFCE_MASK | IXGBE_MFLCN_RFCE);
     282                 :            : 
     283         [ #  # ]:          0 :         if (hw->mac.type >= ixgbe_mac_X540)
     284                 :          0 :                 reg |= pfc_en << IXGBE_MFLCN_RPFCE_SHIFT;
     285                 :            : 
     286         [ #  # ]:          0 :         if (pfc_en)
     287                 :          0 :                 reg |= IXGBE_MFLCN_RPFCE;
     288                 :            : 
     289                 :          0 :         IXGBE_WRITE_REG(hw, IXGBE_MFLCN, reg);
     290                 :            : 
     291         [ #  # ]:          0 :         for (i = 0; i < IXGBE_DCB_MAX_USER_PRIORITY; i++) {
     292                 :          0 :                 if (map[i] > max_tc)
     293                 :            :                         max_tc = map[i];
     294                 :            :         }
     295                 :            : 
     296                 :            : 
     297                 :            :         /* Configure PFC Tx thresholds per TC */
     298         [ #  # ]:          0 :         for (i = 0; i <= max_tc; i++) {
     299                 :            :                 int enabled = 0;
     300                 :            : 
     301         [ #  # ]:          0 :                 for (j = 0; j < IXGBE_DCB_MAX_USER_PRIORITY; j++) {
     302   [ #  #  #  # ]:          0 :                         if ((map[j] == i) && (pfc_en & (1 << j))) {
     303                 :            :                                 enabled = 1;
     304                 :            :                                 break;
     305                 :            :                         }
     306                 :            :                 }
     307                 :            : 
     308         [ #  # ]:          0 :                 if (enabled) {
     309                 :          0 :                         reg = (hw->fc.high_water[i] << 10) | IXGBE_FCRTH_FCEN;
     310                 :          0 :                         fcrtl = (hw->fc.low_water[i] << 10) | IXGBE_FCRTL_XONE;
     311                 :          0 :                         IXGBE_WRITE_REG(hw, IXGBE_FCRTL_82599(i), fcrtl);
     312                 :            :                 } else {
     313                 :            :                         /*
     314                 :            :                          * In order to prevent Tx hangs when the internal Tx
     315                 :            :                          * switch is enabled we must set the high water mark
     316                 :            :                          * to the Rx packet buffer size - 24KB.  This allows
     317                 :            :                          * the Tx switch to function even under heavy Rx
     318                 :            :                          * workloads.
     319                 :            :                          */
     320                 :          0 :                         reg = IXGBE_READ_REG(hw, IXGBE_RXPBSIZE(i)) - 24576;
     321                 :          0 :                         IXGBE_WRITE_REG(hw, IXGBE_FCRTL_82599(i), 0);
     322                 :            :                 }
     323                 :            : 
     324                 :          0 :                 IXGBE_WRITE_REG(hw, IXGBE_FCRTH_82599(i), reg);
     325                 :            :         }
     326                 :            : 
     327         [ #  # ]:          0 :         for (; i < IXGBE_DCB_MAX_TRAFFIC_CLASS; i++) {
     328                 :          0 :                 IXGBE_WRITE_REG(hw, IXGBE_FCRTL_82599(i), 0);
     329                 :          0 :                 IXGBE_WRITE_REG(hw, IXGBE_FCRTH_82599(i), 0);
     330                 :            :         }
     331                 :            : 
     332                 :            :         /* Configure pause time (2 TCs per register) */
     333                 :          0 :         reg = hw->fc.pause_time | (hw->fc.pause_time << 16);
     334         [ #  # ]:          0 :         for (i = 0; i < (IXGBE_DCB_MAX_TRAFFIC_CLASS / 2); i++)
     335                 :          0 :                 IXGBE_WRITE_REG(hw, IXGBE_FCTTV(i), reg);
     336                 :            : 
     337                 :            :         /* Configure flow control refresh threshold value */
     338                 :          0 :         IXGBE_WRITE_REG(hw, IXGBE_FCRTV, hw->fc.pause_time / 2);
     339                 :            : 
     340                 :          0 :         return IXGBE_SUCCESS;
     341                 :            : }
     342                 :            : 
     343                 :            : /**
     344                 :            :  * ixgbe_dcb_config_tc_stats_82599 - Config traffic class statistics
     345                 :            :  * @hw: pointer to hardware structure
     346                 :            :  * @dcb_config: pointer to ixgbe_dcb_config structure
     347                 :            :  *
     348                 :            :  * Configure queue statistics registers, all queues belonging to same traffic
     349                 :            :  * class uses a single set of queue statistics counters.
     350                 :            :  */
     351                 :          0 : s32 ixgbe_dcb_config_tc_stats_82599(struct ixgbe_hw *hw,
     352                 :            :                                     struct ixgbe_dcb_config *dcb_config)
     353                 :            : {
     354                 :            :         u32 reg = 0;
     355                 :            :         u8  i   = 0;
     356                 :            :         u8 tc_count = 8;
     357                 :            :         bool vt_mode = false;
     358                 :            : 
     359         [ #  # ]:          0 :         if (dcb_config != NULL) {
     360                 :          0 :                 tc_count = dcb_config->num_tcs.pg_tcs;
     361                 :          0 :                 vt_mode = dcb_config->vt_mode;
     362                 :            :         }
     363                 :            : 
     364   [ #  #  #  # ]:          0 :         if (!((tc_count == 8 && vt_mode == false) || tc_count == 4))
     365                 :            :                 return IXGBE_ERR_PARAM;
     366                 :            : 
     367         [ #  # ]:          0 :         if (tc_count == 8 && vt_mode == false) {
     368                 :            :                 /*
     369                 :            :                  * Receive Queues stats setting
     370                 :            :                  * 32 RQSMR registers, each configuring 4 queues.
     371                 :            :                  *
     372                 :            :                  * Set all 16 queues of each TC to the same stat
     373                 :            :                  * with TC 'n' going to stat 'n'.
     374                 :            :                  */
     375         [ #  # ]:          0 :                 for (i = 0; i < 32; i++) {
     376                 :          0 :                         reg = 0x01010101 * (i / 4);
     377                 :          0 :                         IXGBE_WRITE_REG(hw, IXGBE_RQSMR(i), reg);
     378                 :            :                 }
     379                 :            :                 /*
     380                 :            :                  * Transmit Queues stats setting
     381                 :            :                  * 32 TQSM registers, each controlling 4 queues.
     382                 :            :                  *
     383                 :            :                  * Set all queues of each TC to the same stat
     384                 :            :                  * with TC 'n' going to stat 'n'.
     385                 :            :                  * Tx queues are allocated non-uniformly to TCs:
     386                 :            :                  * 32, 32, 16, 16, 8, 8, 8, 8.
     387                 :            :                  */
     388         [ #  # ]:          0 :                 for (i = 0; i < 32; i++) {
     389         [ #  # ]:          0 :                         if (i < 8)
     390                 :            :                                 reg = 0x00000000;
     391         [ #  # ]:          0 :                         else if (i < 16)
     392                 :            :                                 reg = 0x01010101;
     393         [ #  # ]:          0 :                         else if (i < 20)
     394                 :            :                                 reg = 0x02020202;
     395         [ #  # ]:          0 :                         else if (i < 24)
     396                 :            :                                 reg = 0x03030303;
     397         [ #  # ]:          0 :                         else if (i < 26)
     398                 :            :                                 reg = 0x04040404;
     399         [ #  # ]:          0 :                         else if (i < 28)
     400                 :            :                                 reg = 0x05050505;
     401         [ #  # ]:          0 :                         else if (i < 30)
     402                 :            :                                 reg = 0x06060606;
     403                 :            :                         else
     404                 :            :                                 reg = 0x07070707;
     405                 :          0 :                         IXGBE_WRITE_REG(hw, IXGBE_TQSM(i), reg);
     406                 :            :                 }
     407         [ #  # ]:          0 :         } else if (tc_count == 4 && vt_mode == false) {
     408                 :            :                 /*
     409                 :            :                  * Receive Queues stats setting
     410                 :            :                  * 32 RQSMR registers, each configuring 4 queues.
     411                 :            :                  *
     412                 :            :                  * Set all 16 queues of each TC to the same stat
     413                 :            :                  * with TC 'n' going to stat 'n'.
     414                 :            :                  */
     415         [ #  # ]:          0 :                 for (i = 0; i < 32; i++) {
     416         [ #  # ]:          0 :                         if (i % 8 > 3)
     417                 :            :                                 /* In 4 TC mode, odd 16-queue ranges are
     418                 :            :                                  *  not used.
     419                 :            :                                 */
     420                 :          0 :                                 continue;
     421                 :          0 :                         reg = 0x01010101 * (i / 8);
     422                 :          0 :                         IXGBE_WRITE_REG(hw, IXGBE_RQSMR(i), reg);
     423                 :            :                 }
     424                 :            :                 /*
     425                 :            :                  * Transmit Queues stats setting
     426                 :            :                  * 32 TQSM registers, each controlling 4 queues.
     427                 :            :                  *
     428                 :            :                  * Set all queues of each TC to the same stat
     429                 :            :                  * with TC 'n' going to stat 'n'.
     430                 :            :                  * Tx queues are allocated non-uniformly to TCs:
     431                 :            :                  * 64, 32, 16, 16.
     432                 :            :                  */
     433         [ #  # ]:          0 :                 for (i = 0; i < 32; i++) {
     434         [ #  # ]:          0 :                         if (i < 16)
     435                 :            :                                 reg = 0x00000000;
     436         [ #  # ]:          0 :                         else if (i < 24)
     437                 :            :                                 reg = 0x01010101;
     438         [ #  # ]:          0 :                         else if (i < 28)
     439                 :            :                                 reg = 0x02020202;
     440                 :            :                         else
     441                 :            :                                 reg = 0x03030303;
     442                 :          0 :                         IXGBE_WRITE_REG(hw, IXGBE_TQSM(i), reg);
     443                 :            :                 }
     444         [ #  # ]:          0 :         } else if (tc_count == 4 && vt_mode == true) {
     445                 :            :                 /*
     446                 :            :                  * Receive Queues stats setting
     447                 :            :                  * 32 RQSMR registers, each configuring 4 queues.
     448                 :            :                  *
     449                 :            :                  * Queue Indexing in 32 VF with DCB mode maps 4 TC's to each
     450                 :            :                  * pool. Set all 32 queues of each TC across pools to the same
     451                 :            :                  * stat with TC 'n' going to stat 'n'.
     452                 :            :                  */
     453         [ #  # ]:          0 :                 for (i = 0; i < 32; i++)
     454                 :          0 :                         IXGBE_WRITE_REG(hw, IXGBE_RQSMR(i), 0x03020100);
     455                 :            :                 /*
     456                 :            :                  * Transmit Queues stats setting
     457                 :            :                  * 32 TQSM registers, each controlling 4 queues.
     458                 :            :                  *
     459                 :            :                  * Queue Indexing in 32 VF with DCB mode maps 4 TC's to each
     460                 :            :                  * pool. Set all 32 queues of each TC across pools to the same
     461                 :            :                  * stat with TC 'n' going to stat 'n'.
     462                 :            :                  */
     463         [ #  # ]:          0 :                 for (i = 0; i < 32; i++)
     464                 :          0 :                         IXGBE_WRITE_REG(hw, IXGBE_TQSM(i), 0x03020100);
     465                 :            :         }
     466                 :            : 
     467                 :            :         return IXGBE_SUCCESS;
     468                 :            : }
     469                 :            : 
     470                 :            : /**
     471                 :            :  * ixgbe_dcb_config_82599 - Configure general DCB parameters
     472                 :            :  * @hw: pointer to hardware structure
     473                 :            :  * @dcb_config: pointer to ixgbe_dcb_config structure
     474                 :            :  *
     475                 :            :  * Configure general DCB parameters.
     476                 :            :  */
     477                 :          0 : s32 ixgbe_dcb_config_82599(struct ixgbe_hw *hw,
     478                 :            :                            struct ixgbe_dcb_config *dcb_config)
     479                 :            : {
     480                 :            :         u32 reg;
     481                 :            :         u32 q;
     482                 :            : 
     483                 :            :         /* Disable the Tx desc arbiter so that MTQC can be changed */
     484                 :          0 :         reg = IXGBE_READ_REG(hw, IXGBE_RTTDCS);
     485                 :          0 :         reg |= IXGBE_RTTDCS_ARBDIS;
     486                 :          0 :         IXGBE_WRITE_REG(hw, IXGBE_RTTDCS, reg);
     487                 :            : 
     488                 :          0 :         reg = IXGBE_READ_REG(hw, IXGBE_MRQC);
     489         [ #  # ]:          0 :         if (dcb_config->num_tcs.pg_tcs == 8) {
     490                 :            :                 /* Enable DCB for Rx with 8 TCs */
     491      [ #  #  # ]:          0 :                 switch (reg & IXGBE_MRQC_MRQE_MASK) {
     492                 :          0 :                 case 0:
     493                 :            :                 case IXGBE_MRQC_RT4TCEN:
     494                 :            :                         /* RSS disabled cases */
     495                 :          0 :                         reg = (reg & ~IXGBE_MRQC_MRQE_MASK) |
     496                 :            :                               IXGBE_MRQC_RT8TCEN;
     497                 :          0 :                         break;
     498                 :          0 :                 case IXGBE_MRQC_RSSEN:
     499                 :            :                 case IXGBE_MRQC_RTRSS4TCEN:
     500                 :            :                         /* RSS enabled cases */
     501                 :          0 :                         reg = (reg & ~IXGBE_MRQC_MRQE_MASK) |
     502                 :            :                               IXGBE_MRQC_RTRSS8TCEN;
     503                 :          0 :                         break;
     504                 :            :                 default:
     505                 :            :                         /*
     506                 :            :                          * Unsupported value, assume stale data,
     507                 :            :                          * overwrite no RSS
     508                 :            :                          */
     509                 :          0 :                         ASSERT(0);
     510                 :            :                         reg = (reg & ~IXGBE_MRQC_MRQE_MASK) |
     511                 :            :                               IXGBE_MRQC_RT8TCEN;
     512                 :            :                 }
     513                 :            :         }
     514         [ #  # ]:          0 :         if (dcb_config->num_tcs.pg_tcs == 4) {
     515                 :            :                 /* We support both VT-on and VT-off with 4 TCs. */
     516         [ #  # ]:          0 :                 if (dcb_config->vt_mode)
     517                 :          0 :                         reg = (reg & ~IXGBE_MRQC_MRQE_MASK) |
     518                 :            :                               IXGBE_MRQC_VMDQRT4TCEN;
     519                 :            :                 else
     520                 :          0 :                         reg = (reg & ~IXGBE_MRQC_MRQE_MASK) |
     521                 :            :                               IXGBE_MRQC_RTRSS4TCEN;
     522                 :            :         }
     523                 :          0 :         IXGBE_WRITE_REG(hw, IXGBE_MRQC, reg);
     524                 :            : 
     525                 :            :         /* Enable DCB for Tx with 8 TCs */
     526         [ #  # ]:          0 :         if (dcb_config->num_tcs.pg_tcs == 8)
     527                 :            :                 reg = IXGBE_MTQC_RT_ENA | IXGBE_MTQC_8TC_8TQ;
     528                 :            :         else {
     529                 :            :                 /* We support both VT-on and VT-off with 4 TCs. */
     530                 :            :                 reg = IXGBE_MTQC_RT_ENA | IXGBE_MTQC_4TC_4TQ;
     531         [ #  # ]:          0 :                 if (dcb_config->vt_mode)
     532                 :            :                         reg |= IXGBE_MTQC_VT_ENA;
     533                 :            :         }
     534                 :          0 :         IXGBE_WRITE_REG(hw, IXGBE_MTQC, reg);
     535                 :            : 
     536                 :            :         /* Disable drop for all queues */
     537         [ #  # ]:          0 :         for (q = 0; q < 128; q++)
     538                 :          0 :                 IXGBE_WRITE_REG(hw, IXGBE_QDE,
     539                 :            :                                 (IXGBE_QDE_WRITE | (q << IXGBE_QDE_IDX_SHIFT)));
     540                 :            : 
     541                 :            :         /* Enable the Tx desc arbiter */
     542                 :          0 :         reg = IXGBE_READ_REG(hw, IXGBE_RTTDCS);
     543                 :          0 :         reg &= ~IXGBE_RTTDCS_ARBDIS;
     544                 :          0 :         IXGBE_WRITE_REG(hw, IXGBE_RTTDCS, reg);
     545                 :            : 
     546                 :            :         /* Enable Security TX Buffer IFG for DCB */
     547                 :          0 :         reg = IXGBE_READ_REG(hw, IXGBE_SECTXMINIFG);
     548                 :          0 :         reg |= IXGBE_SECTX_DCB;
     549                 :          0 :         IXGBE_WRITE_REG(hw, IXGBE_SECTXMINIFG, reg);
     550                 :            : 
     551                 :          0 :         return IXGBE_SUCCESS;
     552                 :            : }
     553                 :            : 
     554                 :            : /**
     555                 :            :  * ixgbe_dcb_hw_config_82599 - Configure and enable DCB
     556                 :            :  * @hw: pointer to hardware structure
     557                 :            :  * @link_speed: unused
     558                 :            :  * @refill: refill credits index by traffic class
     559                 :            :  * @max: max credits index by traffic class
     560                 :            :  * @bwg_id: bandwidth grouping indexed by traffic class
     561                 :            :  * @tsa: transmission selection algorithm indexed by traffic class
     562                 :            :  * @map: priority to tc assignments indexed by priority
     563                 :            :  *
     564                 :            :  * Configure dcb settings and enable dcb mode.
     565                 :            :  */
     566                 :          0 : s32 ixgbe_dcb_hw_config_82599(struct ixgbe_hw *hw, int link_speed,
     567                 :            :                               u16 *refill, u16 *max, u8 *bwg_id, u8 *tsa,
     568                 :            :                               u8 *map)
     569                 :            : {
     570                 :            :         UNREFERENCED_1PARAMETER(link_speed);
     571                 :            : 
     572                 :          0 :         ixgbe_dcb_config_rx_arbiter_82599(hw, refill, max, bwg_id, tsa,
     573                 :            :                                           map);
     574                 :          0 :         ixgbe_dcb_config_tx_desc_arbiter_82599(hw, refill, max, bwg_id,
     575                 :            :                                                tsa);
     576                 :          0 :         ixgbe_dcb_config_tx_data_arbiter_82599(hw, refill, max, bwg_id,
     577                 :            :                                                tsa, map);
     578                 :            : 
     579                 :          0 :         return IXGBE_SUCCESS;
     580                 :            : }
     581                 :            : 

Generated by: LCOV version 1.14