Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0+
0002 // Copyright (c) 2021-2021 Hisilicon Limited.
0003 #include <linux/skbuff.h>
0004 
0005 #include "hnae3.h"
0006 #include "hclge_comm_cmd.h"
0007 #include "hclge_comm_rss.h"
0008 
0009 static const u8 hclge_comm_hash_key[] = {
0010     0x6D, 0x5A, 0x56, 0xDA, 0x25, 0x5B, 0x0E, 0xC2,
0011     0x41, 0x67, 0x25, 0x3D, 0x43, 0xA3, 0x8F, 0xB0,
0012     0xD0, 0xCA, 0x2B, 0xCB, 0xAE, 0x7B, 0x30, 0xB4,
0013     0x77, 0xCB, 0x2D, 0xA3, 0x80, 0x30, 0xF2, 0x0C,
0014     0x6A, 0x42, 0xB7, 0x3B, 0xBE, 0xAC, 0x01, 0xFA
0015 };
0016 
0017 static void
0018 hclge_comm_init_rss_tuple(struct hnae3_ae_dev *ae_dev,
0019               struct hclge_comm_rss_tuple_cfg *rss_tuple_cfg)
0020 {
0021     rss_tuple_cfg->ipv4_tcp_en = HCLGE_COMM_RSS_INPUT_TUPLE_OTHER;
0022     rss_tuple_cfg->ipv4_udp_en = HCLGE_COMM_RSS_INPUT_TUPLE_OTHER;
0023     rss_tuple_cfg->ipv4_sctp_en = HCLGE_COMM_RSS_INPUT_TUPLE_SCTP;
0024     rss_tuple_cfg->ipv4_fragment_en = HCLGE_COMM_RSS_INPUT_TUPLE_OTHER;
0025     rss_tuple_cfg->ipv6_tcp_en = HCLGE_COMM_RSS_INPUT_TUPLE_OTHER;
0026     rss_tuple_cfg->ipv6_udp_en = HCLGE_COMM_RSS_INPUT_TUPLE_OTHER;
0027     rss_tuple_cfg->ipv6_sctp_en =
0028         ae_dev->dev_version <= HNAE3_DEVICE_VERSION_V2 ?
0029         HCLGE_COMM_RSS_INPUT_TUPLE_SCTP_NO_PORT :
0030         HCLGE_COMM_RSS_INPUT_TUPLE_SCTP;
0031     rss_tuple_cfg->ipv6_fragment_en = HCLGE_COMM_RSS_INPUT_TUPLE_OTHER;
0032 }
0033 
0034 int hclge_comm_rss_init_cfg(struct hnae3_handle *nic,
0035                 struct hnae3_ae_dev *ae_dev,
0036                 struct hclge_comm_rss_cfg *rss_cfg)
0037 {
0038     u16 rss_ind_tbl_size = ae_dev->dev_specs.rss_ind_tbl_size;
0039     int rss_algo = HCLGE_COMM_RSS_HASH_ALGO_TOEPLITZ;
0040     u16 *rss_ind_tbl;
0041 
0042     if (nic->flags & HNAE3_SUPPORT_VF)
0043         rss_cfg->rss_size = nic->kinfo.rss_size;
0044 
0045     if (ae_dev->dev_version >= HNAE3_DEVICE_VERSION_V2)
0046         rss_algo = HCLGE_COMM_RSS_HASH_ALGO_SIMPLE;
0047 
0048     hclge_comm_init_rss_tuple(ae_dev, &rss_cfg->rss_tuple_sets);
0049 
0050     rss_cfg->rss_algo = rss_algo;
0051 
0052     rss_ind_tbl = devm_kcalloc(&ae_dev->pdev->dev, rss_ind_tbl_size,
0053                    sizeof(*rss_ind_tbl), GFP_KERNEL);
0054     if (!rss_ind_tbl)
0055         return -ENOMEM;
0056 
0057     rss_cfg->rss_indirection_tbl = rss_ind_tbl;
0058     memcpy(rss_cfg->rss_hash_key, hclge_comm_hash_key,
0059            HCLGE_COMM_RSS_KEY_SIZE);
0060 
0061     hclge_comm_rss_indir_init_cfg(ae_dev, rss_cfg);
0062 
0063     return 0;
0064 }
0065 
0066 void hclge_comm_get_rss_tc_info(u16 rss_size, u8 hw_tc_map, u16 *tc_offset,
0067                 u16 *tc_valid, u16 *tc_size)
0068 {
0069     u16 roundup_size;
0070     u32 i;
0071 
0072     roundup_size = roundup_pow_of_two(rss_size);
0073     roundup_size = ilog2(roundup_size);
0074 
0075     for (i = 0; i < HCLGE_COMM_MAX_TC_NUM; i++) {
0076         tc_valid[i] = 1;
0077         tc_size[i] = roundup_size;
0078         tc_offset[i] = (hw_tc_map & BIT(i)) ? rss_size * i : 0;
0079     }
0080 }
0081 
0082 int hclge_comm_set_rss_tc_mode(struct hclge_comm_hw *hw, u16 *tc_offset,
0083                    u16 *tc_valid, u16 *tc_size)
0084 {
0085     struct hclge_comm_rss_tc_mode_cmd *req;
0086     struct hclge_desc desc;
0087     unsigned int i;
0088     int ret;
0089 
0090     req = (struct hclge_comm_rss_tc_mode_cmd *)desc.data;
0091 
0092     hclge_comm_cmd_setup_basic_desc(&desc, HCLGE_OPC_RSS_TC_MODE, false);
0093     for (i = 0; i < HCLGE_COMM_MAX_TC_NUM; i++) {
0094         u16 mode = 0;
0095 
0096         hnae3_set_bit(mode, HCLGE_COMM_RSS_TC_VALID_B,
0097                   (tc_valid[i] & 0x1));
0098         hnae3_set_field(mode, HCLGE_COMM_RSS_TC_SIZE_M,
0099                 HCLGE_COMM_RSS_TC_SIZE_S, tc_size[i]);
0100         hnae3_set_bit(mode, HCLGE_COMM_RSS_TC_SIZE_MSB_B,
0101                   tc_size[i] >> HCLGE_COMM_RSS_TC_SIZE_MSB_OFFSET &
0102                   0x1);
0103         hnae3_set_field(mode, HCLGE_COMM_RSS_TC_OFFSET_M,
0104                 HCLGE_COMM_RSS_TC_OFFSET_S, tc_offset[i]);
0105 
0106         req->rss_tc_mode[i] = cpu_to_le16(mode);
0107     }
0108 
0109     ret = hclge_comm_cmd_send(hw, &desc, 1);
0110     if (ret)
0111         dev_err(&hw->cmq.csq.pdev->dev,
0112             "failed to set rss tc mode, ret = %d.\n", ret);
0113 
0114     return ret;
0115 }
0116 
0117 int hclge_comm_set_rss_hash_key(struct hclge_comm_rss_cfg *rss_cfg,
0118                 struct hclge_comm_hw *hw, const u8 *key,
0119                 const u8 hfunc)
0120 {
0121     u8 hash_algo;
0122     int ret;
0123 
0124     ret = hclge_comm_parse_rss_hfunc(rss_cfg, hfunc, &hash_algo);
0125     if (ret)
0126         return ret;
0127 
0128     /* Set the RSS Hash Key if specififed by the user */
0129     if (key) {
0130         ret = hclge_comm_set_rss_algo_key(hw, hash_algo, key);
0131         if (ret)
0132             return ret;
0133 
0134         /* Update the shadow RSS key with user specified qids */
0135         memcpy(rss_cfg->rss_hash_key, key, HCLGE_COMM_RSS_KEY_SIZE);
0136     } else {
0137         ret = hclge_comm_set_rss_algo_key(hw, hash_algo,
0138                           rss_cfg->rss_hash_key);
0139         if (ret)
0140             return ret;
0141     }
0142     rss_cfg->rss_algo = hash_algo;
0143 
0144     return 0;
0145 }
0146 
0147 int hclge_comm_set_rss_tuple(struct hnae3_ae_dev *ae_dev,
0148                  struct hclge_comm_hw *hw,
0149                  struct hclge_comm_rss_cfg *rss_cfg,
0150                  struct ethtool_rxnfc *nfc)
0151 {
0152     struct hclge_comm_rss_input_tuple_cmd *req;
0153     struct hclge_desc desc;
0154     int ret;
0155 
0156     if (nfc->data &
0157         ~(RXH_IP_SRC | RXH_IP_DST | RXH_L4_B_0_1 | RXH_L4_B_2_3))
0158         return -EINVAL;
0159 
0160     req = (struct hclge_comm_rss_input_tuple_cmd *)desc.data;
0161     hclge_comm_cmd_setup_basic_desc(&desc, HCLGE_OPC_RSS_INPUT_TUPLE,
0162                     false);
0163 
0164     ret = hclge_comm_init_rss_tuple_cmd(rss_cfg, nfc, ae_dev, req);
0165     if (ret) {
0166         dev_err(&hw->cmq.csq.pdev->dev,
0167             "failed to init rss tuple cmd, ret = %d.\n", ret);
0168         return ret;
0169     }
0170 
0171     ret = hclge_comm_cmd_send(hw, &desc, 1);
0172     if (ret) {
0173         dev_err(&hw->cmq.csq.pdev->dev,
0174             "failed to set rss tuple, ret = %d.\n", ret);
0175         return ret;
0176     }
0177 
0178     rss_cfg->rss_tuple_sets.ipv4_tcp_en = req->ipv4_tcp_en;
0179     rss_cfg->rss_tuple_sets.ipv4_udp_en = req->ipv4_udp_en;
0180     rss_cfg->rss_tuple_sets.ipv4_sctp_en = req->ipv4_sctp_en;
0181     rss_cfg->rss_tuple_sets.ipv4_fragment_en = req->ipv4_fragment_en;
0182     rss_cfg->rss_tuple_sets.ipv6_tcp_en = req->ipv6_tcp_en;
0183     rss_cfg->rss_tuple_sets.ipv6_udp_en = req->ipv6_udp_en;
0184     rss_cfg->rss_tuple_sets.ipv6_sctp_en = req->ipv6_sctp_en;
0185     rss_cfg->rss_tuple_sets.ipv6_fragment_en = req->ipv6_fragment_en;
0186     return 0;
0187 }
0188 
0189 u32 hclge_comm_get_rss_key_size(struct hnae3_handle *handle)
0190 {
0191     return HCLGE_COMM_RSS_KEY_SIZE;
0192 }
0193 
0194 void hclge_comm_get_rss_type(struct hnae3_handle *nic,
0195                  struct hclge_comm_rss_tuple_cfg *rss_tuple_sets)
0196 {
0197     if (rss_tuple_sets->ipv4_tcp_en ||
0198         rss_tuple_sets->ipv4_udp_en ||
0199         rss_tuple_sets->ipv4_sctp_en ||
0200         rss_tuple_sets->ipv6_tcp_en ||
0201         rss_tuple_sets->ipv6_udp_en ||
0202         rss_tuple_sets->ipv6_sctp_en)
0203         nic->kinfo.rss_type = PKT_HASH_TYPE_L4;
0204     else if (rss_tuple_sets->ipv4_fragment_en ||
0205          rss_tuple_sets->ipv6_fragment_en)
0206         nic->kinfo.rss_type = PKT_HASH_TYPE_L3;
0207     else
0208         nic->kinfo.rss_type = PKT_HASH_TYPE_NONE;
0209 }
0210 
0211 int hclge_comm_parse_rss_hfunc(struct hclge_comm_rss_cfg *rss_cfg,
0212                    const u8 hfunc, u8 *hash_algo)
0213 {
0214     switch (hfunc) {
0215     case ETH_RSS_HASH_TOP:
0216         *hash_algo = HCLGE_COMM_RSS_HASH_ALGO_TOEPLITZ;
0217         return 0;
0218     case ETH_RSS_HASH_XOR:
0219         *hash_algo = HCLGE_COMM_RSS_HASH_ALGO_SIMPLE;
0220         return 0;
0221     case ETH_RSS_HASH_NO_CHANGE:
0222         *hash_algo = rss_cfg->rss_algo;
0223         return 0;
0224     default:
0225         return -EINVAL;
0226     }
0227 }
0228 
0229 void hclge_comm_rss_indir_init_cfg(struct hnae3_ae_dev *ae_dev,
0230                    struct hclge_comm_rss_cfg *rss_cfg)
0231 {
0232     u16 i;
0233     /* Initialize RSS indirect table */
0234     for (i = 0; i < ae_dev->dev_specs.rss_ind_tbl_size; i++)
0235         rss_cfg->rss_indirection_tbl[i] = i % rss_cfg->rss_size;
0236 }
0237 
0238 int hclge_comm_get_rss_tuple(struct hclge_comm_rss_cfg *rss_cfg, int flow_type,
0239                  u8 *tuple_sets)
0240 {
0241     switch (flow_type) {
0242     case TCP_V4_FLOW:
0243         *tuple_sets = rss_cfg->rss_tuple_sets.ipv4_tcp_en;
0244         break;
0245     case UDP_V4_FLOW:
0246         *tuple_sets = rss_cfg->rss_tuple_sets.ipv4_udp_en;
0247         break;
0248     case TCP_V6_FLOW:
0249         *tuple_sets = rss_cfg->rss_tuple_sets.ipv6_tcp_en;
0250         break;
0251     case UDP_V6_FLOW:
0252         *tuple_sets = rss_cfg->rss_tuple_sets.ipv6_udp_en;
0253         break;
0254     case SCTP_V4_FLOW:
0255         *tuple_sets = rss_cfg->rss_tuple_sets.ipv4_sctp_en;
0256         break;
0257     case SCTP_V6_FLOW:
0258         *tuple_sets = rss_cfg->rss_tuple_sets.ipv6_sctp_en;
0259         break;
0260     case IPV4_FLOW:
0261     case IPV6_FLOW:
0262         *tuple_sets = HCLGE_COMM_S_IP_BIT | HCLGE_COMM_D_IP_BIT;
0263         break;
0264     default:
0265         return -EINVAL;
0266     }
0267 
0268     return 0;
0269 }
0270 
0271 static void
0272 hclge_comm_append_rss_msb_info(struct hclge_comm_rss_ind_tbl_cmd *req,
0273                    u16 qid, u32 j)
0274 {
0275     u8 rss_msb_oft;
0276     u8 rss_msb_val;
0277 
0278     rss_msb_oft =
0279         j * HCLGE_COMM_RSS_CFG_TBL_BW_H / BITS_PER_BYTE;
0280     rss_msb_val = (qid >> HCLGE_COMM_RSS_CFG_TBL_BW_L & 0x1) <<
0281         (j * HCLGE_COMM_RSS_CFG_TBL_BW_H % BITS_PER_BYTE);
0282     req->rss_qid_h[rss_msb_oft] |= rss_msb_val;
0283 }
0284 
0285 int hclge_comm_set_rss_indir_table(struct hnae3_ae_dev *ae_dev,
0286                    struct hclge_comm_hw *hw, const u16 *indir)
0287 {
0288     struct hclge_comm_rss_ind_tbl_cmd *req;
0289     struct hclge_desc desc;
0290     u16 rss_cfg_tbl_num;
0291     int ret;
0292     u16 qid;
0293     u16 i;
0294     u32 j;
0295 
0296     req = (struct hclge_comm_rss_ind_tbl_cmd *)desc.data;
0297     rss_cfg_tbl_num = ae_dev->dev_specs.rss_ind_tbl_size /
0298               HCLGE_COMM_RSS_CFG_TBL_SIZE;
0299 
0300     for (i = 0; i < rss_cfg_tbl_num; i++) {
0301         hclge_comm_cmd_setup_basic_desc(&desc,
0302                         HCLGE_OPC_RSS_INDIR_TABLE,
0303                         false);
0304 
0305         req->start_table_index =
0306             cpu_to_le16(i * HCLGE_COMM_RSS_CFG_TBL_SIZE);
0307         req->rss_set_bitmap =
0308             cpu_to_le16(HCLGE_COMM_RSS_SET_BITMAP_MSK);
0309         for (j = 0; j < HCLGE_COMM_RSS_CFG_TBL_SIZE; j++) {
0310             qid = indir[i * HCLGE_COMM_RSS_CFG_TBL_SIZE + j];
0311             req->rss_qid_l[j] = qid & 0xff;
0312             hclge_comm_append_rss_msb_info(req, qid, j);
0313         }
0314         ret = hclge_comm_cmd_send(hw, &desc, 1);
0315         if (ret) {
0316             dev_err(&hw->cmq.csq.pdev->dev,
0317                 "failed to configure rss table, ret = %d.\n",
0318                 ret);
0319             return ret;
0320         }
0321     }
0322     return 0;
0323 }
0324 
0325 int hclge_comm_set_rss_input_tuple(struct hnae3_handle *nic,
0326                    struct hclge_comm_hw *hw, bool is_pf,
0327                    struct hclge_comm_rss_cfg *rss_cfg)
0328 {
0329     struct hclge_comm_rss_input_tuple_cmd *req;
0330     struct hclge_desc desc;
0331     int ret;
0332 
0333     hclge_comm_cmd_setup_basic_desc(&desc, HCLGE_OPC_RSS_INPUT_TUPLE,
0334                     false);
0335 
0336     req = (struct hclge_comm_rss_input_tuple_cmd *)desc.data;
0337 
0338     req->ipv4_tcp_en = rss_cfg->rss_tuple_sets.ipv4_tcp_en;
0339     req->ipv4_udp_en = rss_cfg->rss_tuple_sets.ipv4_udp_en;
0340     req->ipv4_sctp_en = rss_cfg->rss_tuple_sets.ipv4_sctp_en;
0341     req->ipv4_fragment_en = rss_cfg->rss_tuple_sets.ipv4_fragment_en;
0342     req->ipv6_tcp_en = rss_cfg->rss_tuple_sets.ipv6_tcp_en;
0343     req->ipv6_udp_en = rss_cfg->rss_tuple_sets.ipv6_udp_en;
0344     req->ipv6_sctp_en = rss_cfg->rss_tuple_sets.ipv6_sctp_en;
0345     req->ipv6_fragment_en = rss_cfg->rss_tuple_sets.ipv6_fragment_en;
0346 
0347     if (is_pf)
0348         hclge_comm_get_rss_type(nic, &rss_cfg->rss_tuple_sets);
0349 
0350     ret = hclge_comm_cmd_send(hw, &desc, 1);
0351     if (ret)
0352         dev_err(&hw->cmq.csq.pdev->dev,
0353             "failed to configure rss input, ret = %d.\n", ret);
0354     return ret;
0355 }
0356 
0357 void hclge_comm_get_rss_hash_info(struct hclge_comm_rss_cfg *rss_cfg, u8 *key,
0358                   u8 *hfunc)
0359 {
0360     /* Get hash algorithm */
0361     if (hfunc) {
0362         switch (rss_cfg->rss_algo) {
0363         case HCLGE_COMM_RSS_HASH_ALGO_TOEPLITZ:
0364             *hfunc = ETH_RSS_HASH_TOP;
0365             break;
0366         case HCLGE_COMM_RSS_HASH_ALGO_SIMPLE:
0367             *hfunc = ETH_RSS_HASH_XOR;
0368             break;
0369         default:
0370             *hfunc = ETH_RSS_HASH_UNKNOWN;
0371             break;
0372         }
0373     }
0374 
0375     /* Get the RSS Key required by the user */
0376     if (key)
0377         memcpy(key, rss_cfg->rss_hash_key, HCLGE_COMM_RSS_KEY_SIZE);
0378 }
0379 
0380 void hclge_comm_get_rss_indir_tbl(struct hclge_comm_rss_cfg *rss_cfg,
0381                   u32 *indir, u16 rss_ind_tbl_size)
0382 {
0383     u16 i;
0384 
0385     if (!indir)
0386         return;
0387 
0388     for (i = 0; i < rss_ind_tbl_size; i++)
0389         indir[i] = rss_cfg->rss_indirection_tbl[i];
0390 }
0391 
0392 int hclge_comm_set_rss_algo_key(struct hclge_comm_hw *hw, const u8 hfunc,
0393                 const u8 *key)
0394 {
0395     struct hclge_comm_rss_config_cmd *req;
0396     unsigned int key_offset = 0;
0397     struct hclge_desc desc;
0398     int key_counts;
0399     int key_size;
0400     int ret;
0401 
0402     key_counts = HCLGE_COMM_RSS_KEY_SIZE;
0403     req = (struct hclge_comm_rss_config_cmd *)desc.data;
0404 
0405     while (key_counts) {
0406         hclge_comm_cmd_setup_basic_desc(&desc,
0407                         HCLGE_OPC_RSS_GENERIC_CONFIG,
0408                         false);
0409 
0410         req->hash_config |= (hfunc & HCLGE_COMM_RSS_HASH_ALGO_MASK);
0411         req->hash_config |=
0412             (key_offset << HCLGE_COMM_RSS_HASH_KEY_OFFSET_B);
0413 
0414         key_size = min(HCLGE_COMM_RSS_HASH_KEY_NUM, key_counts);
0415         memcpy(req->hash_key,
0416                key + key_offset * HCLGE_COMM_RSS_HASH_KEY_NUM,
0417                key_size);
0418 
0419         key_counts -= key_size;
0420         key_offset++;
0421         ret = hclge_comm_cmd_send(hw, &desc, 1);
0422         if (ret) {
0423             dev_err(&hw->cmq.csq.pdev->dev,
0424                 "failed to configure RSS key, ret = %d.\n",
0425                 ret);
0426             return ret;
0427         }
0428     }
0429 
0430     return 0;
0431 }
0432 
0433 static u8 hclge_comm_get_rss_hash_bits(struct ethtool_rxnfc *nfc)
0434 {
0435     u8 hash_sets = nfc->data & RXH_L4_B_0_1 ? HCLGE_COMM_S_PORT_BIT : 0;
0436 
0437     if (nfc->data & RXH_L4_B_2_3)
0438         hash_sets |= HCLGE_COMM_D_PORT_BIT;
0439     else
0440         hash_sets &= ~HCLGE_COMM_D_PORT_BIT;
0441 
0442     if (nfc->data & RXH_IP_SRC)
0443         hash_sets |= HCLGE_COMM_S_IP_BIT;
0444     else
0445         hash_sets &= ~HCLGE_COMM_S_IP_BIT;
0446 
0447     if (nfc->data & RXH_IP_DST)
0448         hash_sets |= HCLGE_COMM_D_IP_BIT;
0449     else
0450         hash_sets &= ~HCLGE_COMM_D_IP_BIT;
0451 
0452     if (nfc->flow_type == SCTP_V4_FLOW || nfc->flow_type == SCTP_V6_FLOW)
0453         hash_sets |= HCLGE_COMM_V_TAG_BIT;
0454 
0455     return hash_sets;
0456 }
0457 
0458 int hclge_comm_init_rss_tuple_cmd(struct hclge_comm_rss_cfg *rss_cfg,
0459                   struct ethtool_rxnfc *nfc,
0460                   struct hnae3_ae_dev *ae_dev,
0461                   struct hclge_comm_rss_input_tuple_cmd *req)
0462 {
0463     u8 tuple_sets;
0464 
0465     req->ipv4_tcp_en = rss_cfg->rss_tuple_sets.ipv4_tcp_en;
0466     req->ipv4_udp_en = rss_cfg->rss_tuple_sets.ipv4_udp_en;
0467     req->ipv4_sctp_en = rss_cfg->rss_tuple_sets.ipv4_sctp_en;
0468     req->ipv4_fragment_en = rss_cfg->rss_tuple_sets.ipv4_fragment_en;
0469     req->ipv6_tcp_en = rss_cfg->rss_tuple_sets.ipv6_tcp_en;
0470     req->ipv6_udp_en = rss_cfg->rss_tuple_sets.ipv6_udp_en;
0471     req->ipv6_sctp_en = rss_cfg->rss_tuple_sets.ipv6_sctp_en;
0472     req->ipv6_fragment_en = rss_cfg->rss_tuple_sets.ipv6_fragment_en;
0473 
0474     tuple_sets = hclge_comm_get_rss_hash_bits(nfc);
0475     switch (nfc->flow_type) {
0476     case TCP_V4_FLOW:
0477         req->ipv4_tcp_en = tuple_sets;
0478         break;
0479     case TCP_V6_FLOW:
0480         req->ipv6_tcp_en = tuple_sets;
0481         break;
0482     case UDP_V4_FLOW:
0483         req->ipv4_udp_en = tuple_sets;
0484         break;
0485     case UDP_V6_FLOW:
0486         req->ipv6_udp_en = tuple_sets;
0487         break;
0488     case SCTP_V4_FLOW:
0489         req->ipv4_sctp_en = tuple_sets;
0490         break;
0491     case SCTP_V6_FLOW:
0492         if (ae_dev->dev_version <= HNAE3_DEVICE_VERSION_V2 &&
0493             (nfc->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)))
0494             return -EINVAL;
0495 
0496         req->ipv6_sctp_en = tuple_sets;
0497         break;
0498     case IPV4_FLOW:
0499         req->ipv4_fragment_en = HCLGE_COMM_RSS_INPUT_TUPLE_OTHER;
0500         break;
0501     case IPV6_FLOW:
0502         req->ipv6_fragment_en = HCLGE_COMM_RSS_INPUT_TUPLE_OTHER;
0503         break;
0504     default:
0505         return -EINVAL;
0506     }
0507 
0508     return 0;
0509 }
0510 
0511 u64 hclge_comm_convert_rss_tuple(u8 tuple_sets)
0512 {
0513     u64 tuple_data = 0;
0514 
0515     if (tuple_sets & HCLGE_COMM_D_PORT_BIT)
0516         tuple_data |= RXH_L4_B_2_3;
0517     if (tuple_sets & HCLGE_COMM_S_PORT_BIT)
0518         tuple_data |= RXH_L4_B_0_1;
0519     if (tuple_sets & HCLGE_COMM_D_IP_BIT)
0520         tuple_data |= RXH_IP_DST;
0521     if (tuple_sets & HCLGE_COMM_S_IP_BIT)
0522         tuple_data |= RXH_IP_SRC;
0523 
0524     return tuple_data;
0525 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!