net/sfc: factor out RSS fields from adapter info

RSS handling will need more sophisticated fields
in the adapter context storage in future patches.
This patch groups existing fields in a dedicated
structure and updates the rest of the code.

Signed-off-by: Ivan Malov <ivan.malov@oktetlabs.ru>
Signed-off-by: Andrew Rybchenko <arybchenko@solarflare.com>

diff --git a/drivers/net/sfc/sfc.c b/drivers/net/sfc/sfc.c
index 41ebd0b..1066a5e 100644 (file)
--- a/drivers/net/sfc/sfc.c
+++ b/drivers/net/sfc/sfc.c
@@ -640,6 +640,7 @@ static const uint8_t default_rss_key[EFX_RSS_KEY_SIZE] = {
 static int
 sfc_set_rss_defaults(struct sfc_adapter *sa)
 {
+       struct sfc_rss *rss = &sa->rss;
        int rc;
 
        rc = efx_intr_init(sa->nic, sa->intr.type, NULL);
@@ -654,11 +655,11 @@ sfc_set_rss_defaults(struct sfc_adapter *sa)
        if (rc != 0)
                goto fail_rx_init;
 
-       rc = efx_rx_scale_default_support_get(sa->nic, &sa->rss_support);
+       rc = efx_rx_scale_default_support_get(sa->nic, &rss->context_type);
        if (rc != 0)
                goto fail_scale_support_get;
 
-       rc = efx_rx_hash_default_support_get(sa->nic, &sa->hash_support);
+       rc = efx_rx_hash_default_support_get(sa->nic, &rss->hash_support);
        if (rc != 0)
                goto fail_hash_support_get;
 
@@ -666,9 +667,9 @@ sfc_set_rss_defaults(struct sfc_adapter *sa)
        efx_ev_fini(sa->nic);
        efx_intr_fini(sa->nic);
 
-       sa->rss_hash_types = sfc_rte_to_efx_hash_type(SFC_RSS_OFFLOADS);
+       rss->hash_types = sfc_rte_to_efx_hash_type(SFC_RSS_OFFLOADS);
 
-       rte_memcpy(sa->rss_key, default_rss_key, sizeof(sa->rss_key));
+       rte_memcpy(rss->key, default_rss_key, sizeof(rss->key));
 
        return 0;
 

diff --git a/drivers/net/sfc/sfc.h b/drivers/net/sfc/sfc.h
index 805f211..9c76d7f 100644 (file)
--- a/drivers/net/sfc/sfc.h
+++ b/drivers/net/sfc/sfc.h
@@ -154,6 +154,15 @@ struct sfc_port {
        uint32_t                mac_stats_mask[EFX_MAC_STATS_MASK_NPAGES];
 };
 
+struct sfc_rss {
+       unsigned int                    channels;
+       efx_rx_scale_context_type_t     context_type;
+       efx_rx_hash_support_t           hash_support;
+       efx_rx_hash_type_t              hash_types;
+       unsigned int                    tbl[EFX_RSS_TBL_SIZE];
+       uint8_t                         key[EFX_RSS_KEY_SIZE];
+};
+
 /* Adapter private data */
 struct sfc_adapter {
        /*
@@ -223,13 +232,7 @@ struct sfc_adapter {
 
        boolean_t                       tso;
 
-       unsigned int                    rss_channels;
-
-       efx_rx_scale_context_type_t     rss_support;
-       efx_rx_hash_support_t           hash_support;
-       efx_rx_hash_type_t              rss_hash_types;
-       unsigned int                    rss_tbl[EFX_RSS_TBL_SIZE];
-       uint8_t                         rss_key[EFX_RSS_KEY_SIZE];
+       struct sfc_rss                  rss;
 
        /*
         * Shared memory copy of the Rx datapath name to be used by

diff --git a/drivers/net/sfc/sfc_ethdev.c b/drivers/net/sfc/sfc_ethdev.c
index be6d449..359d6d2 100644 (file)
--- a/drivers/net/sfc/sfc_ethdev.c
+++ b/drivers/net/sfc/sfc_ethdev.c
@@ -85,6 +85,7 @@ sfc_dev_infos_get(struct rte_eth_dev *dev, struct rte_eth_dev_info *dev_info)
 {
        struct sfc_adapter *sa = dev->data->dev_private;
        const efx_nic_cfg_t *encp = efx_nic_cfg_get(sa->nic);
+       struct sfc_rss *rss = &sa->rss;
        uint64_t txq_offloads_def = 0;
 
        sfc_log_init(sa, "entry");
@@ -151,7 +152,7 @@ sfc_dev_infos_get(struct rte_eth_dev *dev, struct rte_eth_dev_info *dev_info)
        if (~sa->dp_tx->features & SFC_DP_TX_FEAT_REFCNT)
                dev_info->default_txconf.txq_flags |= ETH_TXQ_FLAGS_NOREFCOUNT;
 
-       if (sa->rss_support != EFX_RX_SCALE_UNAVAILABLE) {
+       if (rss->context_type != EFX_RX_SCALE_UNAVAILABLE) {
                dev_info->reta_size = EFX_RSS_TBL_SIZE;
                dev_info->hash_key_size = EFX_RSS_KEY_SIZE;
                dev_info->flow_type_rss_offloads = SFC_RSS_OFFLOADS;
@@ -1360,12 +1361,13 @@ sfc_dev_rss_hash_conf_get(struct rte_eth_dev *dev,
                          struct rte_eth_rss_conf *rss_conf)
 {
        struct sfc_adapter *sa = dev->data->dev_private;
+       struct sfc_rss *rss = &sa->rss;
        struct sfc_port *port = &sa->port;
 
-       if ((sa->rss_support != EFX_RX_SCALE_EXCLUSIVE) || port->isolated)
+       if (rss->context_type != EFX_RX_SCALE_EXCLUSIVE || port->isolated)
                return -ENOTSUP;
 
-       if (sa->rss_channels == 0)
+       if (rss->channels == 0)
                return -EINVAL;
 
        sfc_adapter_lock(sa);
@@ -1376,10 +1378,10 @@ sfc_dev_rss_hash_conf_get(struct rte_eth_dev *dev,
         * flags which corresponds to the active EFX configuration stored
         * locally in 'sfc_adapter' and kept up-to-date
         */
-       rss_conf->rss_hf = sfc_efx_to_rte_hash_type(sa->rss_hash_types);
+       rss_conf->rss_hf = sfc_efx_to_rte_hash_type(rss->hash_types);
        rss_conf->rss_key_len = EFX_RSS_KEY_SIZE;
        if (rss_conf->rss_key != NULL)
-               rte_memcpy(rss_conf->rss_key, sa->rss_key, EFX_RSS_KEY_SIZE);
+               rte_memcpy(rss_conf->rss_key, rss->key, EFX_RSS_KEY_SIZE);
 
        sfc_adapter_unlock(sa);
 
@@ -1391,6 +1393,7 @@ sfc_dev_rss_hash_update(struct rte_eth_dev *dev,
                        struct rte_eth_rss_conf *rss_conf)
 {
        struct sfc_adapter *sa = dev->data->dev_private;
+       struct sfc_rss *rss = &sa->rss;
        struct sfc_port *port = &sa->port;
        unsigned int efx_hash_types;
        int rc = 0;
@@ -1398,20 +1401,20 @@ sfc_dev_rss_hash_update(struct rte_eth_dev *dev,
        if (port->isolated)
                return -ENOTSUP;
 
-       if (sa->rss_support != EFX_RX_SCALE_EXCLUSIVE) {
+       if (rss->context_type != EFX_RX_SCALE_EXCLUSIVE) {
                sfc_err(sa, "RSS is not available");
                return -ENOTSUP;
        }
 
-       if (sa->rss_channels == 0) {
+       if (rss->channels == 0) {
                sfc_err(sa, "RSS is not configured");
                return -EINVAL;
        }
 
        if ((rss_conf->rss_key != NULL) &&
-           (rss_conf->rss_key_len != sizeof(sa->rss_key))) {
+           (rss_conf->rss_key_len != sizeof(rss->key))) {
                sfc_err(sa, "RSS key size is wrong (should be %lu)",
-                       sizeof(sa->rss_key));
+                       sizeof(rss->key));
                return -EINVAL;
        }
 
@@ -1435,15 +1438,15 @@ sfc_dev_rss_hash_update(struct rte_eth_dev *dev,
                        rc = efx_rx_scale_key_set(sa->nic,
                                                  EFX_RSS_CONTEXT_DEFAULT,
                                                  rss_conf->rss_key,
-                                                 sizeof(sa->rss_key));
+                                                 sizeof(rss->key));
                        if (rc != 0)
                                goto fail_scale_key_set;
                }
 
-               rte_memcpy(sa->rss_key, rss_conf->rss_key, sizeof(sa->rss_key));
+               rte_memcpy(rss->key, rss_conf->rss_key, sizeof(rss->key));
        }
 
-       sa->rss_hash_types = efx_hash_types;
+       rss->hash_types = efx_hash_types;
 
        sfc_adapter_unlock(sa);
 
@@ -1452,7 +1455,7 @@ sfc_dev_rss_hash_update(struct rte_eth_dev *dev,
 fail_scale_key_set:
        if (efx_rx_scale_mode_set(sa->nic, EFX_RSS_CONTEXT_DEFAULT,
                                  EFX_RX_HASHALG_TOEPLITZ,
-                                 sa->rss_hash_types, B_TRUE) != 0)
+                                 rss->hash_types, B_TRUE) != 0)
                sfc_err(sa, "failed to restore RSS mode");
 
 fail_scale_mode_set:
@@ -1466,13 +1469,14 @@ sfc_dev_rss_reta_query(struct rte_eth_dev *dev,
                       uint16_t reta_size)
 {
        struct sfc_adapter *sa = dev->data->dev_private;
+       struct sfc_rss *rss = &sa->rss;
        struct sfc_port *port = &sa->port;
        int entry;
 
-       if ((sa->rss_support != EFX_RX_SCALE_EXCLUSIVE) || port->isolated)
+       if (rss->context_type != EFX_RX_SCALE_EXCLUSIVE || port->isolated)
                return -ENOTSUP;
 
-       if (sa->rss_channels == 0)
+       if (rss->channels == 0)
                return -EINVAL;
 
        if (reta_size != EFX_RSS_TBL_SIZE)
@@ -1485,7 +1489,7 @@ sfc_dev_rss_reta_query(struct rte_eth_dev *dev,
                int grp_idx = entry % RTE_RETA_GROUP_SIZE;
 
                if ((reta_conf[grp].mask >> grp_idx) & 1)
-                       reta_conf[grp].reta[grp_idx] = sa->rss_tbl[entry];
+                       reta_conf[grp].reta[grp_idx] = rss->tbl[entry];
        }
 
        sfc_adapter_unlock(sa);
@@ -1499,6 +1503,7 @@ sfc_dev_rss_reta_update(struct rte_eth_dev *dev,
                        uint16_t reta_size)
 {
        struct sfc_adapter *sa = dev->data->dev_private;
+       struct sfc_rss *rss = &sa->rss;
        struct sfc_port *port = &sa->port;
        unsigned int *rss_tbl_new;
        uint16_t entry;
@@ -1508,12 +1513,12 @@ sfc_dev_rss_reta_update(struct rte_eth_dev *dev,
        if (port->isolated)
                return -ENOTSUP;
 
-       if (sa->rss_support != EFX_RX_SCALE_EXCLUSIVE) {
+       if (rss->context_type != EFX_RX_SCALE_EXCLUSIVE) {
                sfc_err(sa, "RSS is not available");
                return -ENOTSUP;
        }
 
-       if (sa->rss_channels == 0) {
+       if (rss->channels == 0) {
                sfc_err(sa, "RSS is not configured");
                return -EINVAL;
        }
@@ -1524,13 +1529,13 @@ sfc_dev_rss_reta_update(struct rte_eth_dev *dev,
                return -EINVAL;
        }
 
-       rss_tbl_new = rte_zmalloc("rss_tbl_new", sizeof(sa->rss_tbl), 0);
+       rss_tbl_new = rte_zmalloc("rss_tbl_new", sizeof(rss->tbl), 0);
        if (rss_tbl_new == NULL)
                return -ENOMEM;
 
        sfc_adapter_lock(sa);
 
-       rte_memcpy(rss_tbl_new, sa->rss_tbl, sizeof(sa->rss_tbl));
+       rte_memcpy(rss_tbl_new, rss->tbl, sizeof(rss->tbl));
 
        for (entry = 0; entry < reta_size; entry++) {
                int grp_idx = entry % RTE_RETA_GROUP_SIZE;
@@ -1539,7 +1544,7 @@ sfc_dev_rss_reta_update(struct rte_eth_dev *dev,
                grp = &reta_conf[entry / RTE_RETA_GROUP_SIZE];
 
                if (grp->mask & (1ull << grp_idx)) {
-                       if (grp->reta[grp_idx] >= sa->rss_channels) {
+                       if (grp->reta[grp_idx] >= rss->channels) {
                                rc = EINVAL;
                                goto bad_reta_entry;
                        }
@@ -1554,7 +1559,7 @@ sfc_dev_rss_reta_update(struct rte_eth_dev *dev,
                        goto fail_scale_tbl_set;
        }
 
-       rte_memcpy(sa->rss_tbl, rss_tbl_new, sizeof(sa->rss_tbl));
+       rte_memcpy(rss->tbl, rss_tbl_new, sizeof(rss->tbl));
 
 fail_scale_tbl_set:
 bad_reta_entry:

diff --git a/drivers/net/sfc/sfc_flow.c b/drivers/net/sfc/sfc_flow.c
index 9c09cdb..f664cfa 100644 (file)
--- a/drivers/net/sfc/sfc_flow.c
+++ b/drivers/net/sfc/sfc_flow.c
@@ -1250,18 +1250,20 @@ sfc_flow_parse_queue(struct sfc_adapter *sa,
 
 static int
 sfc_flow_parse_rss(struct sfc_adapter *sa,
-                  const struct rte_flow_action_rss *rss,
+                  const struct rte_flow_action_rss *action_rss,
                   struct rte_flow *flow)
 {
+       struct sfc_rss *rss = &sa->rss;
        unsigned int rxq_sw_index;
        struct sfc_rxq *rxq;
        unsigned int rxq_hw_index_min;
        unsigned int rxq_hw_index_max;
+       uint64_t rss_hf;
        const uint8_t *rss_key;
        struct sfc_flow_rss *sfc_rss_conf = &flow->rss_conf;
        unsigned int i;
 
-       if (rss->queue_num == 0)
+       if (action_rss->queue_num == 0)
                return -EINVAL;
 
        rxq_sw_index = sa->rxq_count - 1;
@@ -1269,8 +1271,8 @@ sfc_flow_parse_rss(struct sfc_adapter *sa,
        rxq_hw_index_min = rxq->hw_index;
        rxq_hw_index_max = 0;
 
-       for (i = 0; i < rss->queue_num; ++i) {
-               rxq_sw_index = rss->queue[i];
+       for (i = 0; i < action_rss->queue_num; ++i) {
+               rxq_sw_index = action_rss->queue[i];
 
                if (rxq_sw_index >= sa->rxq_count)
                        return -EINVAL;
@@ -1284,7 +1286,7 @@ sfc_flow_parse_rss(struct sfc_adapter *sa,
                        rxq_hw_index_max = rxq->hw_index;
        }
 
-       switch (rss->func) {
+       switch (action_rss->func) {
        case RTE_ETH_HASH_FUNCTION_DEFAULT:
        case RTE_ETH_HASH_FUNCTION_TOEPLITZ:
                break;
@@ -1292,30 +1294,32 @@ sfc_flow_parse_rss(struct sfc_adapter *sa,
                return -EINVAL;
        }
 
-       if (rss->level)
+       if (action_rss->level)
                return -EINVAL;
 
-       if ((rss->types & ~SFC_RSS_OFFLOADS) != 0)
+       rss_hf = action_rss->types;
+       if ((rss_hf & ~SFC_RSS_OFFLOADS) != 0)
                return -EINVAL;
 
-       if (rss->key_len) {
-               if (rss->key_len != sizeof(sa->rss_key))
+       if (action_rss->key_len) {
+               if (action_rss->key_len != sizeof(rss->key))
                        return -EINVAL;
 
-               rss_key = rss->key;
+               rss_key = action_rss->key;
        } else {
-               rss_key = sa->rss_key;
+               rss_key = rss->key;
        }
 
        flow->rss = B_TRUE;
 
        sfc_rss_conf->rxq_hw_index_min = rxq_hw_index_min;
        sfc_rss_conf->rxq_hw_index_max = rxq_hw_index_max;
-       sfc_rss_conf->rss_hash_types = sfc_rte_to_efx_hash_type(rss->types);
-       rte_memcpy(sfc_rss_conf->rss_key, rss_key, sizeof(sa->rss_key));
+       sfc_rss_conf->rss_hash_types = sfc_rte_to_efx_hash_type(rss_hf);
+       rte_memcpy(sfc_rss_conf->rss_key, rss_key, sizeof(rss->key));
 
        for (i = 0; i < RTE_DIM(sfc_rss_conf->rss_tbl); ++i) {
-               unsigned int rxq_sw_index = rss->queue[i % rss->queue_num];
+               unsigned int nb_queues = action_rss->queue_num;
+               unsigned int rxq_sw_index = action_rss->queue[i % nb_queues];
                struct sfc_rxq *rxq = sa->rxq_info[rxq_sw_index].rxq;
 
                sfc_rss_conf->rss_tbl[i] = rxq->hw_index - rxq_hw_index_min;
@@ -1372,14 +1376,15 @@ static int
 sfc_flow_filter_insert(struct sfc_adapter *sa,
                       struct rte_flow *flow)
 {
-       struct sfc_flow_rss *rss = &flow->rss_conf;
+       struct sfc_rss *rss = &sa->rss;
+       struct sfc_flow_rss *flow_rss = &flow->rss_conf;
        uint32_t efs_rss_context = EFX_RSS_CONTEXT_DEFAULT;
        unsigned int i;
        int rc = 0;
 
        if (flow->rss) {
-               unsigned int rss_spread = MIN(rss->rxq_hw_index_max -
-                                             rss->rxq_hw_index_min + 1,
+               unsigned int rss_spread = MIN(flow_rss->rxq_hw_index_max -
+                                             flow_rss->rxq_hw_index_min + 1,
                                              EFX_MAXRSS);
 
                rc = efx_rx_scale_context_alloc(sa->nic,
@@ -1391,13 +1396,13 @@ sfc_flow_filter_insert(struct sfc_adapter *sa,
 
                rc = efx_rx_scale_mode_set(sa->nic, efs_rss_context,
                                           EFX_RX_HASHALG_TOEPLITZ,
-                                          rss->rss_hash_types, B_TRUE);
+                                          flow_rss->rss_hash_types, B_TRUE);
                if (rc != 0)
                        goto fail_scale_mode_set;
 
                rc = efx_rx_scale_key_set(sa->nic, efs_rss_context,
-                                         rss->rss_key,
-                                         sizeof(sa->rss_key));
+                                         flow_rss->rss_key,
+                                         sizeof(rss->key));
                if (rc != 0)
                        goto fail_scale_key_set;
 
@@ -1411,7 +1416,7 @@ sfc_flow_filter_insert(struct sfc_adapter *sa,
                        efx_filter_spec_t *spec = &flow->spec.filters[i];
 
                        spec->efs_rss_context = efs_rss_context;
-                       spec->efs_dmaq_id = rss->rxq_hw_index_min;
+                       spec->efs_dmaq_id = flow_rss->rxq_hw_index_min;
                        spec->efs_flags |= EFX_FILTER_FLAG_RX_RSS;
                }
        }
@@ -1430,7 +1435,8 @@ sfc_flow_filter_insert(struct sfc_adapter *sa,
                 * the table entries, and the operation will succeed
                 */
                rc = efx_rx_scale_tbl_set(sa->nic, efs_rss_context,
-                                         rss->rss_tbl, RTE_DIM(rss->rss_tbl));
+                                         flow_rss->rss_tbl,
+                                         RTE_DIM(flow_rss->rss_tbl));
                if (rc != 0)
                        goto fail_scale_tbl_set;
        }

diff --git a/drivers/net/sfc/sfc_rx.c b/drivers/net/sfc/sfc_rx.c
index c30f230..816436a 100644 (file)
--- a/drivers/net/sfc/sfc_rx.c
+++ b/drivers/net/sfc/sfc_rx.c
@@ -608,7 +608,8 @@ sfc_rx_qflush(struct sfc_adapter *sa, unsigned int sw_index)
 static int
 sfc_rx_default_rxq_set_filter(struct sfc_adapter *sa, struct sfc_rxq *rxq)
 {
-       boolean_t rss = (sa->rss_channels > 0) ? B_TRUE : B_FALSE;
+       struct sfc_rss *rss = &sa->rss;
+       boolean_t need_rss = (rss->channels > 0) ? B_TRUE : B_FALSE;
        struct sfc_port *port = &sa->port;
        int rc;
 
@@ -620,7 +621,7 @@ sfc_rx_default_rxq_set_filter(struct sfc_adapter *sa, struct sfc_rxq *rxq)
         * repeat this step without promiscuous and all-multicast flags set
         */
 retry:
-       rc = efx_mac_filter_default_rxq_set(sa->nic, rxq->common, rss);
+       rc = efx_mac_filter_default_rxq_set(sa->nic, rxq->common, need_rss);
        if (rc == 0)
                return 0;
        else if (rc != EOPNOTSUPP)
@@ -970,6 +971,7 @@ sfc_rx_qinit(struct sfc_adapter *sa, unsigned int sw_index,
             struct rte_mempool *mb_pool)
 {
        const efx_nic_cfg_t *encp = efx_nic_cfg_get(sa->nic);
+       struct sfc_rss *rss = &sa->rss;
        int rc;
        unsigned int rxq_entries;
        unsigned int evq_entries;
@@ -1059,7 +1061,7 @@ sfc_rx_qinit(struct sfc_adapter *sa, unsigned int sw_index,
        info.batch_max = encp->enc_rx_batch_max;
        info.prefix_size = encp->enc_rx_prefix_size;
 
-       if (sa->hash_support == EFX_RX_HASH_AVAILABLE && sa->rss_channels > 0)
+       if (rss->hash_support == EFX_RX_HASH_AVAILABLE && rss->channels > 0)
                info.flags |= SFC_RXQ_FLAG_RSS_HASH;
 
        info.rxq_entries = rxq_info->entries;
@@ -1178,9 +1180,10 @@ static int
 sfc_rx_process_adv_conf_rss(struct sfc_adapter *sa,
                            struct rte_eth_rss_conf *conf)
 {
-       efx_rx_hash_type_t efx_hash_types = sa->rss_hash_types;
+       struct sfc_rss *rss = &sa->rss;
+       efx_rx_hash_type_t efx_hash_types = rss->hash_types;
 
-       if (sa->rss_support != EFX_RX_SCALE_EXCLUSIVE) {
+       if (rss->context_type != EFX_RX_SCALE_EXCLUSIVE) {
                if ((conf->rss_hf != 0 && conf->rss_hf != SFC_RSS_OFFLOADS) ||
                    conf->rss_key != NULL)
                        return EINVAL;
@@ -1196,15 +1199,15 @@ sfc_rx_process_adv_conf_rss(struct sfc_adapter *sa,
        }
 
        if (conf->rss_key != NULL) {
-               if (conf->rss_key_len != sizeof(sa->rss_key)) {
+               if (conf->rss_key_len != sizeof(rss->key)) {
                        sfc_err(sa, "RSS key size is wrong (should be %lu)",
-                               sizeof(sa->rss_key));
+                               sizeof(rss->key));
                        return EINVAL;
                }
-               rte_memcpy(sa->rss_key, conf->rss_key, sizeof(sa->rss_key));
+               rte_memcpy(rss->key, conf->rss_key, sizeof(rss->key));
        }
 
-       sa->rss_hash_types = efx_hash_types;
+       rss->hash_types = efx_hash_types;
 
        return 0;
 }
@@ -1212,23 +1215,23 @@ sfc_rx_process_adv_conf_rss(struct sfc_adapter *sa,
 static int
 sfc_rx_rss_config(struct sfc_adapter *sa)
 {
+       struct sfc_rss *rss = &sa->rss;
        int rc = 0;
 
-       if (sa->rss_channels > 0) {
+       if (rss->channels > 0) {
                rc = efx_rx_scale_mode_set(sa->nic, EFX_RSS_CONTEXT_DEFAULT,
                                           EFX_RX_HASHALG_TOEPLITZ,
-                                          sa->rss_hash_types, B_TRUE);
+                                          rss->hash_types, B_TRUE);
                if (rc != 0)
                        goto finish;
 
                rc = efx_rx_scale_key_set(sa->nic, EFX_RSS_CONTEXT_DEFAULT,
-                                         sa->rss_key,
-                                         sizeof(sa->rss_key));
+                                         rss->key, sizeof(rss->key));
                if (rc != 0)
                        goto finish;
 
                rc = efx_rx_scale_tbl_set(sa->nic, EFX_RSS_CONTEXT_DEFAULT,
-                                         sa->rss_tbl, RTE_DIM(sa->rss_tbl));
+                                         rss->tbl, RTE_DIM(rss->tbl));
        }
 
 finish:
@@ -1307,6 +1310,7 @@ sfc_rx_qinit_info(struct sfc_adapter *sa, unsigned int sw_index)
 static int
 sfc_rx_check_mode(struct sfc_adapter *sa, struct rte_eth_rxmode *rxmode)
 {
+       struct sfc_rss *rss = &sa->rss;
        uint64_t offloads_supported = sfc_rx_get_dev_offload_caps(sa) |
                                      sfc_rx_get_queue_offload_caps(sa);
        uint64_t offloads_rejected = rxmode->offloads & ~offloads_supported;
@@ -1317,7 +1321,7 @@ sfc_rx_check_mode(struct sfc_adapter *sa, struct rte_eth_rxmode *rxmode)
                /* No special checks are required */
                break;
        case ETH_MQ_RX_RSS:
-               if (sa->rss_support == EFX_RX_SCALE_UNAVAILABLE) {
+               if (rss->context_type == EFX_RX_SCALE_UNAVAILABLE) {
                        sfc_err(sa, "RSS is not available");
                        rc = EINVAL;
                }
@@ -1374,6 +1378,7 @@ sfc_rx_fini_queues(struct sfc_adapter *sa, unsigned int nb_rx_queues)
 int
 sfc_rx_configure(struct sfc_adapter *sa)
 {
+       struct sfc_rss *rss = &sa->rss;
        struct rte_eth_conf *dev_conf = &sa->eth_dev->data->dev_conf;
        const unsigned int nb_rx_queues = sa->eth_dev->data->nb_rx_queues;
        int rc;
@@ -1423,15 +1428,15 @@ sfc_rx_configure(struct sfc_adapter *sa)
                sa->rxq_count++;
        }
 
-       sa->rss_channels = (dev_conf->rxmode.mq_mode == ETH_MQ_RX_RSS) ?
-                          MIN(sa->rxq_count, EFX_MAXRSS) : 0;
+       rss->channels = (dev_conf->rxmode.mq_mode == ETH_MQ_RX_RSS) ?
+                        MIN(sa->rxq_count, EFX_MAXRSS) : 0;
 
-       if (sa->rss_channels > 0) {
+       if (rss->channels > 0) {
                struct rte_eth_rss_conf *adv_conf_rss;
                unsigned int sw_index;
 
                for (sw_index = 0; sw_index < EFX_RSS_TBL_SIZE; ++sw_index)
-                       sa->rss_tbl[sw_index] = sw_index % sa->rss_channels;
+                       rss->tbl[sw_index] = sw_index % rss->channels;
 
                adv_conf_rss = &dev_conf->rx_adv_conf.rss_conf;
                rc = sfc_rx_process_adv_conf_rss(sa, adv_conf_rss);
@@ -1461,9 +1466,11 @@ fail_check_mode:
 void
 sfc_rx_close(struct sfc_adapter *sa)
 {
+       struct sfc_rss *rss = &sa->rss;
+
        sfc_rx_fini_queues(sa, 0);
 
-       sa->rss_channels = 0;
+       rss->channels = 0;
 
        rte_free(sa->rxq_info);
        sa->rxq_info = NULL;