d/numam-dpdk
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

net/qede: fix RSS

Browse Source 
This patch includes the following:

- Fix missing hash_key_size advertisement
- Fix RSS hash query function
- Update RSS offload flag
- Accept user provided RSS configuration params via rx_adv_conf
  in dev_configure()
- Decouple RSS configuration from common qed_update_vport() and
  instead make use of existing RSS APIs for default RSS configuration

Fixes: 6d9e26c42c0d ("net/qede: get RSS hash configuration")
Fixes: 9c5d0a669f9b ("net/qede: fix RSS")

Signed-off-by: Harish Patil <harish.patil@qlogic.com>
This commit is contained in:
Harish Patil 2016-12-22 16:48:09 -08:00 committed by Ferruh Yigit
parent 3d4bb44116
commit 7ab35bf6b9
6 changed files with 240 additions and 212 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

79
drivers/net/qede/qede_eth_if.c
View File

@ -68,6 +68,33 @@ static int qed_stop_vport(struct ecore_dev *edev, uint8_t vport_id)
return 0;
}
bool qed_update_rss_parm_cmt(struct ecore_dev *edev, uint16_t *p_tbl)
{
uint16_t max = 0, k;
bool rss_mode = 0; /* disable */
int divisor;
/* Find largest entry, since it's possible RSS needs to
* be disabled [in case only 1 queue per-hwfn]
*/
for (k = 0; k < ECORE_RSS_IND_TABLE_SIZE; k++)
max = (max > p_tbl[k]) ? max : p_tbl[k];
/* Either fix RSS values or disable RSS */
if (edev->num_hwfns < max + 1) {
divisor = (max + edev->num_hwfns - 1) / edev->num_hwfns;
DP_VERBOSE(edev, ECORE_MSG_SPQ,
"CMT - fixing RSS values (modulo %02x)\n",
divisor);
for (k = 0; k < ECORE_RSS_IND_TABLE_SIZE; k++)
p_tbl[k] = p_tbl[k] % divisor;
rss_mode = 1;
}
return rss_mode;
}
static int
qed_update_vport(struct ecore_dev *edev, struct qed_update_vport_params *params)
{
@ -94,58 +121,6 @@ qed_update_vport(struct ecore_dev *edev, struct qed_update_vport_params *params)
params->update_accept_any_vlan_flg;
sp_params.mtu = params->mtu;
/* RSS - is a bit tricky, since upper-layer isn't familiar with hwfns.
* We need to re-fix the rss values per engine for CMT.
*/
if (edev->num_hwfns > 1 && params->update_rss_flg) {
struct qed_update_vport_rss_params *rss = &params->rss_params;
int k, max = 0;
/* Find largest entry, since it's possible RSS needs to
* be disabled [in case only 1 queue per-hwfn]
*/
for (k = 0; k < ECORE_RSS_IND_TABLE_SIZE; k++)
max = (max > rss->rss_ind_table[k]) ?
max : rss->rss_ind_table[k];
/* Either fix RSS values or disable RSS */
if (edev->num_hwfns < max + 1) {
int divisor = (max + edev->num_hwfns - 1) /
edev->num_hwfns;
DP_VERBOSE(edev, ECORE_MSG_SPQ,
"CMT - fixing RSS values (modulo %02x)\n",
divisor);
for (k = 0; k < ECORE_RSS_IND_TABLE_SIZE; k++)
rss->rss_ind_table[k] =
rss->rss_ind_table[k] % divisor;
} else {
DP_VERBOSE(edev, ECORE_MSG_SPQ,
"CMT - 1 queue per-hwfn; Disabling RSS\n");
params->update_rss_flg = 0;
}
}
/* Now, update the RSS configuration for actual configuration */
if (params->update_rss_flg) {
sp_rss_params.update_rss_config = 1;
sp_rss_params.rss_enable = 1;
sp_rss_params.update_rss_capabilities = 1;
sp_rss_params.update_rss_ind_table = 1;
sp_rss_params.update_rss_key = 1;
sp_rss_params.rss_caps = ECORE_RSS_IPV4 | ECORE_RSS_IPV6 |
ECORE_RSS_IPV4_TCP | ECORE_RSS_IPV6_TCP;
sp_rss_params.rss_table_size_log = 7; /* 2^7 = 128 */
rte_memcpy(sp_rss_params.rss_ind_table,
params->rss_params.rss_ind_table,
ECORE_RSS_IND_TABLE_SIZE * sizeof(uint16_t));
rte_memcpy(sp_rss_params.rss_key, params->rss_params.rss_key,
ECORE_RSS_KEY_SIZE * sizeof(uint32_t));
sp_params.rss_params = &sp_rss_params;
}
for_each_hwfn(edev, i) {
struct ecore_hwfn *p_hwfn = &edev->hwfns[i];

9
drivers/net/qede/qede_eth_if.h
View File

@ -47,12 +47,6 @@ struct qed_dev_eth_info {
bool is_legacy;
};
struct qed_update_vport_rss_params {
uint16_t rss_ind_table[128];
uint32_t rss_key[10];
u8 rss_caps;
};
struct qed_stop_rxq_params {
uint8_t rss_id;
uint8_t rx_queue_id;
@ -71,7 +65,6 @@ struct qed_update_vport_params {
uint8_t update_accept_any_vlan_flg;
uint8_t accept_any_vlan;
uint8_t update_rss_flg;
struct qed_update_vport_rss_params rss_params;
uint16_t mtu;
};
@ -145,4 +138,6 @@ const struct qed_eth_ops *qed_get_eth_ops();
int qed_configure_filter_rx_mode(struct rte_eth_dev *eth_dev,
enum qed_filter_rx_mode_type type);
bool qed_update_rss_parm_cmt(struct ecore_dev *edev, uint16_t *p_tbl);
#endif /* _QEDE_ETH_IF_H */

255
drivers/net/qede/qede_ethdev.c
View File

@ -788,6 +788,54 @@ static int qede_init_vport(struct qede_dev *qdev)
return 0;
}
static void qede_prandom_bytes(uint32_t *buff)
{
uint8_t i;
srand((unsigned int)time(NULL));
for (i = 0; i < ECORE_RSS_KEY_SIZE; i++)
buff[i] = rand();
}
static int qede_config_rss(struct rte_eth_dev *eth_dev)
{
struct qede_dev *qdev = QEDE_INIT_QDEV(eth_dev);
struct ecore_dev *edev = QEDE_INIT_EDEV(qdev);
uint32_t def_rss_key[ECORE_RSS_KEY_SIZE];
struct rte_eth_rss_reta_entry64 reta_conf[2];
struct rte_eth_rss_conf rss_conf;
uint32_t i, id, pos, q;
rss_conf = eth_dev->data->dev_conf.rx_adv_conf.rss_conf;
if (!rss_conf.rss_key) {
DP_INFO(edev, "Applying driver default key\n");
rss_conf.rss_key_len = ECORE_RSS_KEY_SIZE * sizeof(uint32_t);
qede_prandom_bytes(&def_rss_key[0]);
rss_conf.rss_key = (uint8_t *)&def_rss_key[0];
}
/* Configure RSS hash */
if (qede_rss_hash_update(eth_dev, &rss_conf))
return -EINVAL;
/* Configure default RETA */
memset(reta_conf, 0, sizeof(reta_conf));
for (i = 0; i < ECORE_RSS_IND_TABLE_SIZE; i++)
reta_conf[i / RTE_RETA_GROUP_SIZE].mask = UINT64_MAX;
for (i = 0; i < ECORE_RSS_IND_TABLE_SIZE; i++) {
id = i / RTE_RETA_GROUP_SIZE;
pos = i % RTE_RETA_GROUP_SIZE;
q = i % QEDE_RSS_COUNT(qdev);
reta_conf[id].reta[pos] = q;
}
if (qede_rss_reta_update(eth_dev, &reta_conf[0],
ECORE_RSS_IND_TABLE_SIZE))
return -EINVAL;
return 0;
}
static int qede_dev_configure(struct rte_eth_dev *eth_dev)
{
struct qede_dev *qdev = eth_dev->data->dev_private;
@ -856,6 +904,26 @@ static int qede_dev_configure(struct rte_eth_dev *eth_dev)
if (rc != 0)
return rc;
/* Do RSS configuration after vport-start */
switch (rxmode->mq_mode) {
case ETH_MQ_RX_RSS:
rc = qede_config_rss(eth_dev);
if (rc != 0) {
qdev->ops->vport_stop(edev, 0);
qede_dealloc_fp_resc(eth_dev);
return -EINVAL;
}
break;
case ETH_MQ_RX_NONE:
DP_INFO(edev, "RSS is disabled\n");
break;
default:
DP_ERR(edev, "Unsupported RSS mode\n");
qdev->ops->vport_stop(edev, 0);
qede_dealloc_fp_resc(eth_dev);
return -EINVAL;
}
SLIST_INIT(&qdev->vlan_list_head);
/* Add primary mac for PF */
@ -914,6 +982,7 @@ qede_dev_info_get(struct rte_eth_dev *eth_dev,
else
dev_info->max_vfs = (uint16_t)NUM_OF_VFS(&qdev->edev);
dev_info->reta_size = ECORE_RSS_IND_TABLE_SIZE;
dev_info->hash_key_size = ECORE_RSS_KEY_SIZE * sizeof(uint32_t);
dev_info->flow_type_rss_offloads = (uint64_t)QEDE_RSS_OFFLOAD_ALL;
dev_info->default_txconf = (struct rte_eth_txconf) {
@ -1371,7 +1440,7 @@ qede_dev_supported_ptypes_get(struct rte_eth_dev *eth_dev)
return NULL;
}
void qede_init_rss_caps(uint8_t *rss_caps, uint64_t hf)
static void qede_init_rss_caps(uint8_t *rss_caps, uint64_t hf)
{
*rss_caps = 0;
*rss_caps |= (hf & ETH_RSS_IPV4) ? ECORE_RSS_IPV4 : 0;
@ -1385,71 +1454,100 @@ void qede_init_rss_caps(uint8_t *rss_caps, uint64_t hf)
static int qede_rss_hash_update(struct rte_eth_dev *eth_dev,
struct rte_eth_rss_conf *rss_conf)
{
struct qed_update_vport_params vport_update_params;
struct qede_dev *qdev = eth_dev->data->dev_private;
struct ecore_dev *edev = &qdev->edev;
struct qede_dev *qdev = QEDE_INIT_QDEV(eth_dev);
struct ecore_dev *edev = QEDE_INIT_EDEV(qdev);
struct ecore_sp_vport_update_params vport_update_params;
struct ecore_rss_params rss_params;
struct ecore_rss_params params;
struct ecore_hwfn *p_hwfn;
uint32_t *key = (uint32_t *)rss_conf->rss_key;
uint64_t hf = rss_conf->rss_hf;
int i;
uint8_t len = rss_conf->rss_key_len;
uint8_t i;
int rc;
memset(&vport_update_params, 0, sizeof(vport_update_params));
memset(&rss_params, 0, sizeof(rss_params));
DP_INFO(edev, "RSS hf = 0x%lx len = %u key = %p\n",
(unsigned long)hf, len, key);
if (hf != 0) {
/* Enable RSS */
qede_init_rss_caps(&qdev->rss_params.rss_caps, hf);
memcpy(&vport_update_params.rss_params, &qdev->rss_params,
sizeof(vport_update_params.rss_params));
if (key)
memcpy(qdev->rss_params.rss_key, rss_conf->rss_key,
rss_conf->rss_key_len);
vport_update_params.update_rss_flg = 1;
qdev->rss_enabled = 1;
} else {
/* Disable RSS */
qdev->rss_enabled = 0;
/* Enabling RSS */
DP_INFO(edev, "Enabling rss\n");
/* RSS caps */
qede_init_rss_caps(&rss_params.rss_caps, hf);
rss_params.update_rss_capabilities = 1;
/* RSS hash key */
if (key) {
if (len > (ECORE_RSS_KEY_SIZE * sizeof(uint32_t))) {
DP_ERR(edev, "RSS key length exceeds limit\n");
return -EINVAL;
}
DP_INFO(edev, "Applying user supplied hash key\n");
rss_params.update_rss_key = 1;
memcpy(&rss_params.rss_key, key, len);
}
rss_params.rss_enable = 1;
}
/* If the mapping doesn't fit any supported, return */
if (qdev->rss_params.rss_caps == 0 && hf != 0)
return -EINVAL;
DP_INFO(edev, "%s\n", (vport_update_params.update_rss_flg) ?
"Enabling RSS" : "Disabling RSS");
rss_params.update_rss_config = 1;
/* tbl_size has to be set with capabilities */
rss_params.rss_table_size_log = 7;
vport_update_params.vport_id = 0;
vport_update_params.rss_params = &rss_params;
return qdev->ops->vport_update(edev, &vport_update_params);
for_each_hwfn(edev, i) {
p_hwfn = &edev->hwfns[i];
vport_update_params.opaque_fid = p_hwfn->hw_info.opaque_fid;
rc = ecore_sp_vport_update(p_hwfn, &vport_update_params,
ECORE_SPQ_MODE_EBLOCK, NULL);
if (rc) {
DP_ERR(edev, "vport-update for RSS failed\n");
return rc;
}
}
qdev->rss_enable = rss_params.rss_enable;
/* Update local structure for hash query */
qdev->rss_conf.rss_hf = hf;
qdev->rss_conf.rss_key_len = len;
if (qdev->rss_enable) {
if (qdev->rss_conf.rss_key == NULL) {
qdev->rss_conf.rss_key = (uint8_t *)malloc(len);
if (qdev->rss_conf.rss_key == NULL) {
DP_ERR(edev, "No memory to store RSS key\n");
return -ENOMEM;
}
}
if (key && len) {
DP_INFO(edev, "Storing RSS key\n");
memcpy(qdev->rss_conf.rss_key, key, len);
}
} else if (!qdev->rss_enable && len == 0) {
if (qdev->rss_conf.rss_key) {
free(qdev->rss_conf.rss_key);
qdev->rss_conf.rss_key = NULL;
DP_INFO(edev, "Free RSS key\n");
}
}
return 0;
}
int qede_rss_hash_conf_get(struct rte_eth_dev *eth_dev,
static int qede_rss_hash_conf_get(struct rte_eth_dev *eth_dev,
struct rte_eth_rss_conf *rss_conf)
{
struct qede_dev *qdev = eth_dev->data->dev_private;
uint64_t hf;
struct qede_dev *qdev = QEDE_INIT_QDEV(eth_dev);
if (rss_conf->rss_key_len < sizeof(qdev->rss_params.rss_key))
return -EINVAL;
if (rss_conf->rss_key)
memcpy(rss_conf->rss_key, qdev->rss_params.rss_key,
sizeof(qdev->rss_params.rss_key));
hf = 0;
hf |= (qdev->rss_params.rss_caps & ECORE_RSS_IPV4) ?
ETH_RSS_IPV4 : 0;
hf |= (qdev->rss_params.rss_caps & ECORE_RSS_IPV6) ?
ETH_RSS_IPV6 : 0;
hf |= (qdev->rss_params.rss_caps & ECORE_RSS_IPV6) ?
ETH_RSS_IPV6_EX : 0;
hf |= (qdev->rss_params.rss_caps & ECORE_RSS_IPV4_TCP) ?
ETH_RSS_NONFRAG_IPV4_TCP : 0;
hf |= (qdev->rss_params.rss_caps & ECORE_RSS_IPV6_TCP) ?
ETH_RSS_NONFRAG_IPV6_TCP : 0;
hf |= (qdev->rss_params.rss_caps & ECORE_RSS_IPV6_TCP) ?
ETH_RSS_IPV6_TCP_EX : 0;
rss_conf->rss_hf = hf;
rss_conf->rss_hf = qdev->rss_conf.rss_hf;
rss_conf->rss_key_len = qdev->rss_conf.rss_key_len;
if (rss_conf->rss_key && qdev->rss_conf.rss_key)
memcpy(rss_conf->rss_key, qdev->rss_conf.rss_key,
rss_conf->rss_key_len);
return 0;
}
@ -1457,10 +1555,14 @@ static int qede_rss_reta_update(struct rte_eth_dev *eth_dev,
struct rte_eth_rss_reta_entry64 *reta_conf,
uint16_t reta_size)
{
struct qed_update_vport_params vport_update_params;
struct qede_dev *qdev = eth_dev->data->dev_private;
struct ecore_dev *edev = &qdev->edev;
struct qede_dev *qdev = QEDE_INIT_QDEV(eth_dev);
struct ecore_dev *edev = QEDE_INIT_EDEV(qdev);
struct ecore_sp_vport_update_params vport_update_params;
struct ecore_rss_params params;
struct ecore_hwfn *p_hwfn;
uint16_t i, idx, shift;
uint8_t entry;
int rc;
if (reta_size > ETH_RSS_RETA_SIZE_128) {
DP_ERR(edev, "reta_size %d is not supported by hardware\n",
@ -1469,42 +1571,67 @@ static int qede_rss_reta_update(struct rte_eth_dev *eth_dev,
}
memset(&vport_update_params, 0, sizeof(vport_update_params));
memcpy(&vport_update_params.rss_params, &qdev->rss_params,
sizeof(vport_update_params.rss_params));
memset(&params, 0, sizeof(params));
for (i = 0; i < reta_size; i++) {
idx = i / RTE_RETA_GROUP_SIZE;
shift = i % RTE_RETA_GROUP_SIZE;
if (reta_conf[idx].mask & (1ULL << shift)) {
uint8_t entry = reta_conf[idx].reta[shift];
qdev->rss_params.rss_ind_table[i] = entry;
entry = reta_conf[idx].reta[shift];
params.rss_ind_table[i] = entry;
}
}
vport_update_params.update_rss_flg = 1;
/* Fix up RETA for CMT mode device */
if (edev->num_hwfns > 1)
qdev->rss_enable = qed_update_rss_parm_cmt(edev,
&params.rss_ind_table[0]);
params.update_rss_ind_table = 1;
params.rss_table_size_log = 7;
params.update_rss_config = 1;
vport_update_params.vport_id = 0;
/* Use the current value of rss_enable */
params.rss_enable = qdev->rss_enable;
vport_update_params.rss_params = &params;
return qdev->ops->vport_update(edev, &vport_update_params);
for_each_hwfn(edev, i) {
p_hwfn = &edev->hwfns[i];
vport_update_params.opaque_fid = p_hwfn->hw_info.opaque_fid;
rc = ecore_sp_vport_update(p_hwfn, &vport_update_params,
ECORE_SPQ_MODE_EBLOCK, NULL);
if (rc) {
DP_ERR(edev, "vport-update for RSS failed\n");
return rc;
}
}
/* Update the local copy for RETA query command */
memcpy(qdev->rss_ind_table, params.rss_ind_table,
sizeof(params.rss_ind_table));
return 0;
}
int qede_rss_reta_query(struct rte_eth_dev *eth_dev,
struct rte_eth_rss_reta_entry64 *reta_conf,
uint16_t reta_size)
static int qede_rss_reta_query(struct rte_eth_dev *eth_dev,
struct rte_eth_rss_reta_entry64 *reta_conf,
uint16_t reta_size)
{
struct qede_dev *qdev = eth_dev->data->dev_private;
struct ecore_dev *edev = &qdev->edev;
uint16_t i, idx, shift;
uint8_t entry;
if (reta_size > ETH_RSS_RETA_SIZE_128) {
struct ecore_dev *edev = &qdev->edev;
DP_ERR(edev, "reta_size %d is not supported\n",
reta_size);
return -EINVAL;
}
for (i = 0; i < reta_size; i++) {
idx = i / RTE_RETA_GROUP_SIZE;
shift = i % RTE_RETA_GROUP_SIZE;
if (reta_conf[idx].mask & (1ULL << shift)) {
uint8_t entry = qdev->rss_params.rss_ind_table[i];
entry = qdev->rss_ind_table[i];
reta_conf[idx].reta[shift] = entry;
}
}

9
drivers/net/qede/qede_ethdev.h
View File

@ -152,8 +152,11 @@ struct qede_dev {
struct qede_fastpath *fp_array;
uint8_t num_tc;
uint16_t mtu;
bool rss_enabled;
struct qed_update_vport_rss_params rss_params;
bool rss_enable;
struct rte_eth_rss_conf rss_conf;
uint16_t rss_ind_table[ECORE_RSS_IND_TABLE_SIZE];
uint64_t rss_hf;
uint8_t rss_key_len;
uint32_t flags;
bool gro_disable;
uint16_t num_queues;
@ -185,6 +188,8 @@ static int qede_rss_reta_update(struct rte_eth_dev *eth_dev,
struct rte_eth_rss_reta_entry64 *reta_conf,
uint16_t reta_size);
static void qede_init_rss_caps(uint8_t *rss_caps, uint64_t hf);
static inline uint32_t qede_rx_cqe_to_pkt_type(uint16_t flags);
/* Non-static functions */

90
drivers/net/qede/qede_rxtx.c
View File

@ -507,83 +507,11 @@ qede_update_rx_prod(struct qede_dev *edev, struct qede_rx_queue *rxq)
PMD_RX_LOG(DEBUG, rxq, "bd_prod %u cqe_prod %u\n", bd_prod, cqe_prod);
}
static inline uint32_t
qede_rxfh_indir_default(uint32_t index, uint32_t n_rx_rings)
{
return index % n_rx_rings;
}
static void qede_prandom_bytes(uint32_t *buff, size_t bytes)
{
unsigned int i;
srand((unsigned int)time(NULL));
for (i = 0; i < ECORE_RSS_KEY_SIZE; i++)
buff[i] = rand();
}
static bool
qede_check_vport_rss_enable(struct rte_eth_dev *eth_dev,
struct qed_update_vport_rss_params *rss_params)
{
struct rte_eth_rss_conf rss_conf;
enum rte_eth_rx_mq_mode mode = eth_dev->data->dev_conf.rxmode.mq_mode;
struct qede_dev *qdev = eth_dev->data->dev_private;
struct ecore_dev *edev = &qdev->edev;
uint8_t rss_caps;
unsigned int i;
uint64_t hf;
uint32_t *key;
PMD_INIT_FUNC_TRACE(edev);
rss_conf = eth_dev->data->dev_conf.rx_adv_conf.rss_conf;
key = (uint32_t *)rss_conf.rss_key;
hf = rss_conf.rss_hf;
/* Check if RSS conditions are met.
* Note: Even though its meaningless to enable RSS with one queue, it
* could be used to produce RSS Hash, so skipping that check.
*/
if (!(mode & ETH_MQ_RX_RSS)) {
DP_INFO(edev, "RSS flag is not set\n");
return false;
}
if (hf == 0) {
DP_INFO(edev, "Request to disable RSS\n");
return false;
}
memset(rss_params, 0, sizeof(*rss_params));
for (i = 0; i < ECORE_RSS_IND_TABLE_SIZE; i++)
rss_params->rss_ind_table[i] = qede_rxfh_indir_default(i,
QEDE_RSS_COUNT(qdev));
if (!key)
qede_prandom_bytes(rss_params->rss_key,
sizeof(rss_params->rss_key));
else
memcpy(rss_params->rss_key, rss_conf.rss_key,
rss_conf.rss_key_len);
qede_init_rss_caps(&rss_caps, hf);
rss_params->rss_caps = rss_caps;
DP_INFO(edev, "RSS conditions are met\n");
return true;
}
static int qede_start_queues(struct rte_eth_dev *eth_dev, bool clear_stats)
{
struct qede_dev *qdev = eth_dev->data->dev_private;
struct ecore_dev *edev = &qdev->edev;
struct ecore_queue_start_common_params q_params;
struct qed_update_vport_rss_params *rss_params = &qdev->rss_params;
struct qed_dev_info *qed_info = &qdev->dev_info.common;
struct qed_update_vport_params vport_update_params;
struct qede_tx_queue *txq;
@ -682,16 +610,6 @@ static int qede_start_queues(struct rte_eth_dev *eth_dev, bool clear_stats)
vport_update_params.tx_switching_flg = 1;
}
if (qede_check_vport_rss_enable(eth_dev, rss_params)) {
vport_update_params.update_rss_flg = 1;
qdev->rss_enabled = 1;
} else {
qdev->rss_enabled = 0;
}
rte_memcpy(&vport_update_params.rss_params, rss_params,
sizeof(*rss_params));
rc = qdev->ops->vport_update(edev, &vport_update_params);
if (rc) {
DP_ERR(edev, "Update V-PORT failed %d\n", rc);
@ -1091,7 +1009,7 @@ qede_recv_pkts(void *p_rxq, struct rte_mbuf **rx_pkts, uint16_t nb_pkts)
htype = (uint8_t)GET_FIELD(fp_cqe->bitfields,
ETH_FAST_PATH_RX_REG_CQE_RSS_HASH_TYPE);
if (qdev->rss_enabled && htype) {
if (qdev->rss_enable && htype) {
rx_mb->ol_flags |= PKT_RX_RSS_HASH;
rx_mb->hash.rss = rte_le_to_cpu_32(fp_cqe->rss_hash);
PMD_RX_LOG(DEBUG, rxq, "Hash result 0x%x\n",
@ -1410,7 +1328,7 @@ int qede_dev_start(struct rte_eth_dev *eth_dev)
struct ecore_dev *edev = &qdev->edev;
struct qed_link_output link_output;
struct qede_fastpath *fp;
int rc, i;
int rc;
DP_INFO(edev, "Device state is %d\n", qdev->state);
@ -1620,10 +1538,14 @@ void qede_free_mem_load(struct rte_eth_dev *eth_dev)
for_each_queue(id) {
fp = &qdev->fp_array[id];
if (fp->type & QEDE_FASTPATH_RX) {
if (!fp->rxq)
continue;
qede_rx_queue_release(fp->rxq);
eth_dev->data->rx_queues[id] = NULL;
} else {
for (tc = 0; tc < qdev->num_tc; tc++) {
if (!fp->txqs[tc])
continue;
txq_idx = fp->txqs[tc]->queue_id;
qede_tx_queue_release(fp->txqs[tc]);
eth_dev->data->tx_queues[txq_idx] = NULL;

10
drivers/net/qede/qede_rxtx.h
View File

@ -64,9 +64,13 @@
#define QEDE_ETH_OVERHEAD (ETHER_HDR_LEN + 8 + 8 + QEDE_FW_RX_ALIGN_END)
/* TBD: Excluding IPV6 */
#define QEDE_RSS_OFFLOAD_ALL (ETH_RSS_IPV4 | ETH_RSS_NONFRAG_IPV4_TCP | \
ETH_RSS_NONFRAG_IPV4_UDP | ETH_RSS_VXLAN)
#define QEDE_RSS_OFFLOAD_ALL (ETH_RSS_IPV4 |\
ETH_RSS_NONFRAG_IPV4_TCP |\
ETH_RSS_NONFRAG_IPV4_UDP |\
ETH_RSS_IPV6 |\
ETH_RSS_NONFRAG_IPV6_TCP |\
ETH_RSS_NONFRAG_IPV6_UDP |\
ETH_RSS_VXLAN)
#define QEDE_TXQ_FLAGS ((uint32_t)ETH_TXQ_FLAGS_NOMULTSEGS)