net: hns3: refactor PF rss get APIs with new common rss get APIs

This patch firstly uses new rss parameter struct(hclge_comm_rss_cfg) as
child member of hclge_dev and deletes the original child rss parameter
members in vport. All the vport child rss parameter members used in PF rss
module is modified according to the new hclge_comm_rss_cfg.

Secondly PF rss get APIs are refactored to use new common rss get APIs. The
old rss get APIs in PF are deleted.

Signed-off-by: Jie Wang <wangjie125@huawei.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_dcb.c b/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_dcb.c
index 375ebf105a9aae48bf07384e6515a480b7e8eeda..69b8673436ca9a6da5bc43722c8a770a31307c44 100644 (file)
--- a/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_dcb.c
+++ b/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_dcb.c
@@ -203,7 +203,7 @@ static int hclge_map_update(struct hclge_dev *hdev)
        if (ret)
                return ret;
 
-       hclge_rss_indir_init_cfg(hdev);
+       hclge_comm_rss_indir_init_cfg(hdev->ae_dev, &hdev->rss_cfg);
 
        return hclge_rss_init_hw(hdev);
 }

diff --git a/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.c b/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.c
index a365b94124371c22458132954e91a8c74fb8ce25..1cf11b93697296623cdc541acb11fd4cc8744c8e 100644 (file)
--- a/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.c
+++ b/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.c
@@ -4719,11 +4719,6 @@ static int hclge_put_vector(struct hnae3_handle *handle, int vector)
        return 0;
 }
 
-static u32 hclge_get_rss_key_size(struct hnae3_handle *handle)
-{
-       return HCLGE_RSS_KEY_SIZE;
-}
-
 static int hclge_set_rss_algo_key(struct hclge_dev *hdev,
                                  const u8 hfunc, const u8 *key)
 {
@@ -4837,22 +4832,6 @@ static int hclge_set_rss_tc_mode(struct hclge_dev *hdev, u16 *tc_valid,
        return ret;
 }
 
-static void hclge_get_rss_type(struct hclge_vport *vport)
-{
-       if (vport->rss_tuple_sets.ipv4_tcp_en ||
-           vport->rss_tuple_sets.ipv4_udp_en ||
-           vport->rss_tuple_sets.ipv4_sctp_en ||
-           vport->rss_tuple_sets.ipv6_tcp_en ||
-           vport->rss_tuple_sets.ipv6_udp_en ||
-           vport->rss_tuple_sets.ipv6_sctp_en)
-               vport->nic.kinfo.rss_type = PKT_HASH_TYPE_L4;
-       else if (vport->rss_tuple_sets.ipv4_fragment_en ||
-                vport->rss_tuple_sets.ipv6_fragment_en)
-               vport->nic.kinfo.rss_type = PKT_HASH_TYPE_L3;
-       else
-               vport->nic.kinfo.rss_type = PKT_HASH_TYPE_NONE;
-}
-
 static int hclge_set_rss_input_tuple(struct hclge_dev *hdev)
 {
        struct hclge_rss_input_tuple_cmd *req;
@@ -4864,15 +4843,16 @@ static int hclge_set_rss_input_tuple(struct hclge_dev *hdev)
        req = (struct hclge_rss_input_tuple_cmd *)desc.data;
 
        /* Get the tuple cfg from pf */
-       req->ipv4_tcp_en = hdev->vport[0].rss_tuple_sets.ipv4_tcp_en;
-       req->ipv4_udp_en = hdev->vport[0].rss_tuple_sets.ipv4_udp_en;
-       req->ipv4_sctp_en = hdev->vport[0].rss_tuple_sets.ipv4_sctp_en;
-       req->ipv4_fragment_en = hdev->vport[0].rss_tuple_sets.ipv4_fragment_en;
-       req->ipv6_tcp_en = hdev->vport[0].rss_tuple_sets.ipv6_tcp_en;
-       req->ipv6_udp_en = hdev->vport[0].rss_tuple_sets.ipv6_udp_en;
-       req->ipv6_sctp_en = hdev->vport[0].rss_tuple_sets.ipv6_sctp_en;
-       req->ipv6_fragment_en = hdev->vport[0].rss_tuple_sets.ipv6_fragment_en;
-       hclge_get_rss_type(&hdev->vport[0]);
+       req->ipv4_tcp_en = hdev->rss_cfg.rss_tuple_sets.ipv4_tcp_en;
+       req->ipv4_udp_en = hdev->rss_cfg.rss_tuple_sets.ipv4_udp_en;
+       req->ipv4_sctp_en = hdev->rss_cfg.rss_tuple_sets.ipv4_sctp_en;
+       req->ipv4_fragment_en = hdev->rss_cfg.rss_tuple_sets.ipv4_fragment_en;
+       req->ipv6_tcp_en = hdev->rss_cfg.rss_tuple_sets.ipv6_tcp_en;
+       req->ipv6_udp_en = hdev->rss_cfg.rss_tuple_sets.ipv6_udp_en;
+       req->ipv6_sctp_en = hdev->rss_cfg.rss_tuple_sets.ipv6_sctp_en;
+       req->ipv6_fragment_en = hdev->rss_cfg.rss_tuple_sets.ipv6_fragment_en;
+       hclge_comm_get_rss_type(&hdev->vport[0].nic,
+                               &hdev->rss_cfg.rss_tuple_sets);
        ret = hclge_cmd_send(&hdev->hw, &desc, 1);
        if (ret)
                dev_err(&hdev->pdev->dev,
@@ -4885,11 +4865,12 @@ static int hclge_get_rss(struct hnae3_handle *handle, u32 *indir,
 {
        struct hnae3_ae_dev *ae_dev = pci_get_drvdata(handle->pdev);
        struct hclge_vport *vport = hclge_get_vport(handle);
+       struct hclge_comm_rss_cfg *rss_cfg = &vport->back->rss_cfg;
        int i;
 
        /* Get hash algorithm */
        if (hfunc) {
-               switch (vport->rss_algo) {
+               switch (rss_cfg->rss_algo) {
                case HCLGE_RSS_HASH_ALGO_TOEPLITZ:
                        *hfunc = ETH_RSS_HASH_TOP;
                        break;
@@ -4904,34 +4885,16 @@ static int hclge_get_rss(struct hnae3_handle *handle, u32 *indir,
 
        /* Get the RSS Key required by the user */
        if (key)
-               memcpy(key, vport->rss_hash_key, HCLGE_RSS_KEY_SIZE);
+               memcpy(key, rss_cfg->rss_hash_key, HCLGE_RSS_KEY_SIZE);
 
        /* Get indirect table */
        if (indir)
                for (i = 0; i < ae_dev->dev_specs.rss_ind_tbl_size; i++)
-                       indir[i] =  vport->rss_indirection_tbl[i];
+                       indir[i] =  rss_cfg->rss_indirection_tbl[i];
 
        return 0;
 }
 
-static int hclge_parse_rss_hfunc(struct hclge_vport *vport, const u8 hfunc,
-                                u8 *hash_algo)
-{
-       switch (hfunc) {
-       case ETH_RSS_HASH_TOP:
-               *hash_algo = HCLGE_RSS_HASH_ALGO_TOEPLITZ;
-               return 0;
-       case ETH_RSS_HASH_XOR:
-               *hash_algo = HCLGE_RSS_HASH_ALGO_SIMPLE;
-               return 0;
-       case ETH_RSS_HASH_NO_CHANGE:
-               *hash_algo = vport->rss_algo;
-               return 0;
-       default:
-               return -EINVAL;
-       }
-}
-
 static int hclge_set_rss(struct hnae3_handle *handle, const u32 *indir,
                         const  u8 *key, const  u8 hfunc)
 {
@@ -4941,7 +4904,7 @@ static int hclge_set_rss(struct hnae3_handle *handle, const u32 *indir,
        u8 hash_algo;
        int ret, i;
 
-       ret = hclge_parse_rss_hfunc(vport, hfunc, &hash_algo);
+       ret = hclge_comm_parse_rss_hfunc(&hdev->rss_cfg, hfunc, &hash_algo);
        if (ret) {
                dev_err(&hdev->pdev->dev, "invalid hfunc type %u\n", hfunc);
                return ret;
@@ -4954,21 +4917,22 @@ static int hclge_set_rss(struct hnae3_handle *handle, const u32 *indir,
                        return ret;
 
                /* Update the shadow RSS key with user specified qids */
-               memcpy(vport->rss_hash_key, key, HCLGE_RSS_KEY_SIZE);
+               memcpy(hdev->rss_cfg.rss_hash_key, key, HCLGE_RSS_KEY_SIZE);
        } else {
                ret = hclge_set_rss_algo_key(hdev, hash_algo,
-                                            vport->rss_hash_key);
+                                            hdev->rss_cfg.rss_hash_key);
                if (ret)
                        return ret;
        }
-       vport->rss_algo = hash_algo;
+       hdev->rss_cfg.rss_algo = hash_algo;
 
        /* Update the shadow RSS table with user specified qids */
        for (i = 0; i < ae_dev->dev_specs.rss_ind_tbl_size; i++)
-               vport->rss_indirection_tbl[i] = indir[i];
+               hdev->rss_cfg.rss_indirection_tbl[i] = indir[i];
 
        /* Update the hardware */
-       return hclge_set_rss_indir_table(hdev, vport->rss_indirection_tbl);
+       return hclge_set_rss_indir_table(hdev,
+                                        hdev->rss_cfg.rss_indirection_tbl);
 }
 
 static u8 hclge_get_rss_hash_bits(struct ethtool_rxnfc *nfc)
@@ -5001,16 +4965,17 @@ static int hclge_init_rss_tuple_cmd(struct hclge_vport *vport,
                                    struct hclge_rss_input_tuple_cmd *req)
 {
        struct hclge_dev *hdev = vport->back;
+       struct hclge_comm_rss_cfg *rss_cfg = &hdev->rss_cfg;
        u8 tuple_sets;
 
-       req->ipv4_tcp_en = vport->rss_tuple_sets.ipv4_tcp_en;
-       req->ipv4_udp_en = vport->rss_tuple_sets.ipv4_udp_en;
-       req->ipv4_sctp_en = vport->rss_tuple_sets.ipv4_sctp_en;
-       req->ipv4_fragment_en = vport->rss_tuple_sets.ipv4_fragment_en;
-       req->ipv6_tcp_en = vport->rss_tuple_sets.ipv6_tcp_en;
-       req->ipv6_udp_en = vport->rss_tuple_sets.ipv6_udp_en;
-       req->ipv6_sctp_en = vport->rss_tuple_sets.ipv6_sctp_en;
-       req->ipv6_fragment_en = vport->rss_tuple_sets.ipv6_fragment_en;
+       req->ipv4_tcp_en = rss_cfg->rss_tuple_sets.ipv4_tcp_en;
+       req->ipv4_udp_en = rss_cfg->rss_tuple_sets.ipv4_udp_en;
+       req->ipv4_sctp_en = rss_cfg->rss_tuple_sets.ipv4_sctp_en;
+       req->ipv4_fragment_en = rss_cfg->rss_tuple_sets.ipv4_fragment_en;
+       req->ipv6_tcp_en = rss_cfg->rss_tuple_sets.ipv6_tcp_en;
+       req->ipv6_udp_en = rss_cfg->rss_tuple_sets.ipv6_udp_en;
+       req->ipv6_sctp_en = rss_cfg->rss_tuple_sets.ipv6_sctp_en;
+       req->ipv6_fragment_en = rss_cfg->rss_tuple_sets.ipv6_fragment_en;
 
        tuple_sets = hclge_get_rss_hash_bits(nfc);
        switch (nfc->flow_type) {
@@ -5079,48 +5044,15 @@ static int hclge_set_rss_tuple(struct hnae3_handle *handle,
                return ret;
        }
 
-       vport->rss_tuple_sets.ipv4_tcp_en = req->ipv4_tcp_en;
-       vport->rss_tuple_sets.ipv4_udp_en = req->ipv4_udp_en;
-       vport->rss_tuple_sets.ipv4_sctp_en = req->ipv4_sctp_en;
-       vport->rss_tuple_sets.ipv4_fragment_en = req->ipv4_fragment_en;
-       vport->rss_tuple_sets.ipv6_tcp_en = req->ipv6_tcp_en;
-       vport->rss_tuple_sets.ipv6_udp_en = req->ipv6_udp_en;
-       vport->rss_tuple_sets.ipv6_sctp_en = req->ipv6_sctp_en;
-       vport->rss_tuple_sets.ipv6_fragment_en = req->ipv6_fragment_en;
-       hclge_get_rss_type(vport);
-       return 0;
-}
-
-static int hclge_get_vport_rss_tuple(struct hclge_vport *vport, int flow_type,
-                                    u8 *tuple_sets)
-{
-       switch (flow_type) {
-       case TCP_V4_FLOW:
-               *tuple_sets = vport->rss_tuple_sets.ipv4_tcp_en;
-               break;
-       case UDP_V4_FLOW:
-               *tuple_sets = vport->rss_tuple_sets.ipv4_udp_en;
-               break;
-       case TCP_V6_FLOW:
-               *tuple_sets = vport->rss_tuple_sets.ipv6_tcp_en;
-               break;
-       case UDP_V6_FLOW:
-               *tuple_sets = vport->rss_tuple_sets.ipv6_udp_en;
-               break;
-       case SCTP_V4_FLOW:
-               *tuple_sets = vport->rss_tuple_sets.ipv4_sctp_en;
-               break;
-       case SCTP_V6_FLOW:
-               *tuple_sets = vport->rss_tuple_sets.ipv6_sctp_en;
-               break;
-       case IPV4_FLOW:
-       case IPV6_FLOW:
-               *tuple_sets = HCLGE_S_IP_BIT | HCLGE_D_IP_BIT;
-               break;
-       default:
-               return -EINVAL;
-       }
-
+       hdev->rss_cfg.rss_tuple_sets.ipv4_tcp_en = req->ipv4_tcp_en;
+       hdev->rss_cfg.rss_tuple_sets.ipv4_udp_en = req->ipv4_udp_en;
+       hdev->rss_cfg.rss_tuple_sets.ipv4_sctp_en = req->ipv4_sctp_en;
+       hdev->rss_cfg.rss_tuple_sets.ipv4_fragment_en = req->ipv4_fragment_en;
+       hdev->rss_cfg.rss_tuple_sets.ipv6_tcp_en = req->ipv6_tcp_en;
+       hdev->rss_cfg.rss_tuple_sets.ipv6_udp_en = req->ipv6_udp_en;
+       hdev->rss_cfg.rss_tuple_sets.ipv6_sctp_en = req->ipv6_sctp_en;
+       hdev->rss_cfg.rss_tuple_sets.ipv6_fragment_en = req->ipv6_fragment_en;
+       hclge_comm_get_rss_type(&vport->nic, &hdev->rss_cfg.rss_tuple_sets);
        return 0;
 }
 
@@ -5149,7 +5081,8 @@ static int hclge_get_rss_tuple(struct hnae3_handle *handle,
 
        nfc->data = 0;
 
-       ret = hclge_get_vport_rss_tuple(vport, nfc->flow_type, &tuple_sets);
+       ret = hclge_comm_get_rss_tuple(&vport->back->rss_cfg, nfc->flow_type,
+                                      &tuple_sets);
        if (ret || !tuple_sets)
                return ret;
 
@@ -5211,10 +5144,9 @@ static int hclge_init_rss_tc_mode(struct hclge_dev *hdev)
 
 int hclge_rss_init_hw(struct hclge_dev *hdev)
 {
-       struct hclge_vport *vport = hdev->vport;
-       u16 *rss_indir = vport[0].rss_indirection_tbl;
-       u8 *key = vport[0].rss_hash_key;
-       u8 hfunc = vport[0].rss_algo;
+       u16 *rss_indir = hdev->rss_cfg.rss_indirection_tbl;
+       u8 *key = hdev->rss_cfg.rss_hash_key;
+       u8 hfunc = hdev->rss_cfg.rss_algo;
        int ret;
 
        ret = hclge_set_rss_indir_table(hdev, rss_indir);
@@ -5232,48 +5164,39 @@ int hclge_rss_init_hw(struct hclge_dev *hdev)
        return hclge_init_rss_tc_mode(hdev);
 }
 
-void hclge_rss_indir_init_cfg(struct hclge_dev *hdev)
-{
-       struct hclge_vport *vport = &hdev->vport[0];
-       int i;
-
-       for (i = 0; i < hdev->ae_dev->dev_specs.rss_ind_tbl_size; i++)
-               vport->rss_indirection_tbl[i] = i % vport->alloc_rss_size;
-}
-
 static int hclge_rss_init_cfg(struct hclge_dev *hdev)
 {
        u16 rss_ind_tbl_size = hdev->ae_dev->dev_specs.rss_ind_tbl_size;
        int rss_algo = HCLGE_RSS_HASH_ALGO_TOEPLITZ;
-       struct hclge_vport *vport = &hdev->vport[0];
+       struct hclge_comm_rss_cfg *rss_cfg = &hdev->rss_cfg;
        u16 *rss_ind_tbl;
 
        if (hdev->ae_dev->dev_version >= HNAE3_DEVICE_VERSION_V2)
                rss_algo = HCLGE_RSS_HASH_ALGO_SIMPLE;
 
-       vport->rss_tuple_sets.ipv4_tcp_en = HCLGE_RSS_INPUT_TUPLE_OTHER;
-       vport->rss_tuple_sets.ipv4_udp_en = HCLGE_RSS_INPUT_TUPLE_OTHER;
-       vport->rss_tuple_sets.ipv4_sctp_en = HCLGE_RSS_INPUT_TUPLE_SCTP;
-       vport->rss_tuple_sets.ipv4_fragment_en = HCLGE_RSS_INPUT_TUPLE_OTHER;
-       vport->rss_tuple_sets.ipv6_tcp_en = HCLGE_RSS_INPUT_TUPLE_OTHER;
-       vport->rss_tuple_sets.ipv6_udp_en = HCLGE_RSS_INPUT_TUPLE_OTHER;
-       vport->rss_tuple_sets.ipv6_sctp_en =
+       rss_cfg->rss_tuple_sets.ipv4_tcp_en = HCLGE_RSS_INPUT_TUPLE_OTHER;
+       rss_cfg->rss_tuple_sets.ipv4_udp_en = HCLGE_RSS_INPUT_TUPLE_OTHER;
+       rss_cfg->rss_tuple_sets.ipv4_sctp_en = HCLGE_RSS_INPUT_TUPLE_SCTP;
+       rss_cfg->rss_tuple_sets.ipv4_fragment_en = HCLGE_RSS_INPUT_TUPLE_OTHER;
+       rss_cfg->rss_tuple_sets.ipv6_tcp_en = HCLGE_RSS_INPUT_TUPLE_OTHER;
+       rss_cfg->rss_tuple_sets.ipv6_udp_en = HCLGE_RSS_INPUT_TUPLE_OTHER;
+       rss_cfg->rss_tuple_sets.ipv6_sctp_en =
                hdev->ae_dev->dev_version <= HNAE3_DEVICE_VERSION_V2 ?
                HCLGE_RSS_INPUT_TUPLE_SCTP_NO_PORT :
                HCLGE_RSS_INPUT_TUPLE_SCTP;
-       vport->rss_tuple_sets.ipv6_fragment_en = HCLGE_RSS_INPUT_TUPLE_OTHER;
+       rss_cfg->rss_tuple_sets.ipv6_fragment_en = HCLGE_RSS_INPUT_TUPLE_OTHER;
 
-       vport->rss_algo = rss_algo;
+       rss_cfg->rss_algo = rss_algo;
 
        rss_ind_tbl = devm_kcalloc(&hdev->pdev->dev, rss_ind_tbl_size,
                                   sizeof(*rss_ind_tbl), GFP_KERNEL);
        if (!rss_ind_tbl)
                return -ENOMEM;
 
-       vport->rss_indirection_tbl = rss_ind_tbl;
-       memcpy(vport->rss_hash_key, hclge_hash_key, HCLGE_RSS_KEY_SIZE);
+       rss_cfg->rss_indirection_tbl = rss_ind_tbl;
+       memcpy(rss_cfg->rss_hash_key, hclge_hash_key, HCLGE_RSS_KEY_SIZE);
 
-       hclge_rss_indir_init_cfg(hdev);
+       hclge_comm_rss_indir_init_cfg(hdev->ae_dev, rss_cfg);
 
        return 0;
 }
@@ -13213,7 +13136,7 @@ static const struct hnae3_ae_ops hclge_ops = {
        .check_port_speed = hclge_check_port_speed,
        .get_fec = hclge_get_fec,
        .set_fec = hclge_set_fec,
-       .get_rss_key_size = hclge_get_rss_key_size,
+       .get_rss_key_size = hclge_comm_get_rss_key_size,
        .get_rss = hclge_get_rss,
        .set_rss = hclge_set_rss,
        .set_rss_tuple = hclge_set_rss_tuple,

diff --git a/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.h b/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.h
index 9764094aadeccbc4593b7eaa1855571ecbbcf1c4..85139b1377e9c2fb7c1d1faf0d0fa30380b14ae1 100644 (file)
--- a/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.h
+++ b/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_main.h
@@ -13,6 +13,7 @@
 #include "hclge_cmd.h"
 #include "hclge_ptp.h"
 #include "hnae3.h"
+#include "hclge_comm_rss.h"
 
 #define HCLGE_MOD_VERSION "1.0"
 #define HCLGE_DRIVER_NAME "hclge"
@@ -968,6 +969,7 @@ struct hclge_dev {
        cpumask_t affinity_mask;
        struct hclge_ptp *ptp;
        struct devlink *devlink;
+       struct hclge_comm_rss_cfg rss_cfg;
 };
 
 /* VPort level vlan tag configuration for TX direction */
@@ -994,17 +996,6 @@ struct hclge_rx_vtag_cfg {
        bool strip_tag2_discard_en; /* Outer vlan tag discard for BD enable */
 };
 
-struct hclge_rss_tuple_cfg {
-       u8 ipv4_tcp_en;
-       u8 ipv4_udp_en;
-       u8 ipv4_sctp_en;
-       u8 ipv4_fragment_en;
-       u8 ipv6_tcp_en;
-       u8 ipv6_udp_en;
-       u8 ipv6_sctp_en;
-       u8 ipv6_fragment_en;
-};
-
 enum HCLGE_VPORT_STATE {
        HCLGE_VPORT_STATE_ALIVE,
        HCLGE_VPORT_STATE_MAC_TBL_CHANGE,
@@ -1038,15 +1029,6 @@ struct hclge_vf_info {
 struct hclge_vport {
        u16 alloc_tqps; /* Allocated Tx/Rx queues */
 
-       u8  rss_hash_key[HCLGE_RSS_KEY_SIZE]; /* User configured hash keys */
-       /* User configured lookup table entries */
-       u16 *rss_indirection_tbl;
-       int rss_algo;           /* User configured hash algorithm */
-       /* User configured rss tuple sets */
-       struct hclge_rss_tuple_cfg rss_tuple_sets;
-
-       u16 alloc_rss_size;
-
        u16 qs_offset;
        u32 bw_limit;           /* VSI BW Limit (0 = disabled) */
        u8  dwrr;
@@ -1125,7 +1107,6 @@ int hclge_en_hw_strip_rxvtag(struct hnae3_handle *handle, bool enable);
 
 int hclge_buffer_alloc(struct hclge_dev *hdev);
 int hclge_rss_init_hw(struct hclge_dev *hdev);
-void hclge_rss_indir_init_cfg(struct hclge_dev *hdev);
 
 void hclge_mbx_handler(struct hclge_dev *hdev);
 int hclge_reset_tqp(struct hnae3_handle *handle);

diff --git a/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_mbx.c b/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_mbx.c
index db13033b60f452f1aed45a11e79a8b50a8297f17..6799d16de34b9490f60fe67c94a2619e329e0ca4 100644 (file)
--- a/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_mbx.c
+++ b/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_mbx.c
@@ -4,6 +4,7 @@
 #include "hclge_main.h"
 #include "hclge_mbx.h"
 #include "hnae3.h"
+#include "hclge_comm_rss.h"
 
 #define CREATE_TRACE_POINTS
 #include "hclge_trace.h"
@@ -612,15 +613,17 @@ static void hclge_get_rss_key(struct hclge_vport *vport,
 {
 #define HCLGE_RSS_MBX_RESP_LEN 8
        struct hclge_dev *hdev = vport->back;
+       struct hclge_comm_rss_cfg *rss_cfg;
        u8 index;
 
        index = mbx_req->msg.data[0];
+       rss_cfg = &hdev->rss_cfg;
 
        /* Check the query index of rss_hash_key from VF, make sure no
         * more than the size of rss_hash_key.
         */
        if (((index + 1) * HCLGE_RSS_MBX_RESP_LEN) >
-             sizeof(vport[0].rss_hash_key)) {
+             sizeof(rss_cfg->rss_hash_key)) {
                dev_warn(&hdev->pdev->dev,
                         "failed to get the rss hash key, the index(%u) invalid !\n",
                         index);
@@ -628,7 +631,7 @@ static void hclge_get_rss_key(struct hclge_vport *vport,
        }
 
        memcpy(resp_msg->data,
-              &hdev->vport[0].rss_hash_key[index * HCLGE_RSS_MBX_RESP_LEN],
+              &rss_cfg->rss_hash_key[index * HCLGE_RSS_MBX_RESP_LEN],
               HCLGE_RSS_MBX_RESP_LEN);
        resp_msg->len = HCLGE_RSS_MBX_RESP_LEN;
 }

diff --git a/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_tm.c b/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_tm.c
index 3edbfc8d17e8aadf45c7b8d551f94cf153f069fb..089f4444b7e3e3484bb30a883de139926968e367 100644 (file)
--- a/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_tm.c
+++ b/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_tm.c
@@ -678,8 +678,8 @@ static void hclge_tm_vport_tc_info_update(struct hclge_vport *vport)
        hclge_tm_update_kinfo_rss_size(vport);
        kinfo->num_tqps = hclge_vport_get_tqp_num(vport);
        vport->dwrr = 100;  /* 100 percent as init */
-       vport->alloc_rss_size = kinfo->rss_size;
        vport->bw_limit = hdev->tm_info.pg_info[0].bw_limit;
+       hdev->rss_cfg.rss_size = kinfo->rss_size;
 
        /* when enable mqprio, the tc_info has been updated. */
        if (kinfo->tc_info.mqprio_active)