Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 6133e78f authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'gred-add-offload-support' 



Jakub Kicinski says:

====================
gred: add offload support

This series adds support for GRED offload in the nfp driver.  So
far we have only supported the RED Qdisc offload, but we need a
way to differentiate traffic types e.g. based on DSCP marking.

It may seem like PRIO+RED is a good match for this job, however,
(a) we don't need strict priority behaviour of PRIO, and (b) PRIO
uses the legacy way of mapping ToS fields to bands, which is quite
awkward and limitting.

The less commonly used GRED Qdisc is a better much for the scenario,
it allows multiple sets of RED parameters and queue lengths to be
maintained with a single FIFO queue.  This is exactly how nfp offload
behaves.  We use a trivial u32 classifier to assign packets to virtual
queues.

There is also the minor advantage that GRED can't have its child
changed, therefore limitting ways in which the configuration of SW
path can diverge from HW offload.

Last patch of the series adds support for (G)RED in non-ECN mode,
where packets are dropped instead of marked.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents e432abfb 340a4864

drivers/net/ethernet/netronome/nfp/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -56,6 +56,7 @@ endif 


ifeq ($(CONFIG_NFP_APP_ABM_NIC),y)

nfp-objs += \

	    abm/cls.o \

	    abm/ctrl.o \

	    abm/qdisc.o \

	    abm/main.o

drivers/net/ethernet/netronome/nfp/abm/cls.c

0 → 100644
+283 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)

/* Copyright (C) 2018 Netronome Systems, Inc. */



#include <linux/bitfield.h>

#include <net/pkt_cls.h>



#include "../nfpcore/nfp_cpp.h"

#include "../nfp_app.h"

#include "../nfp_net_repr.h"

#include "main.h"



struct nfp_abm_u32_match {

	u32 handle;

	u32 band;

	u8 mask;

	u8 val;

	struct list_head list;

};



static bool

nfp_abm_u32_check_knode(struct nfp_abm *abm, struct tc_cls_u32_knode *knode,

			__be16 proto, struct netlink_ext_ack *extack)

{

	struct tc_u32_key *k;

	unsigned int tos_off;



	if (knode->exts && tcf_exts_has_actions(knode->exts)) {

		NL_SET_ERR_MSG_MOD(extack, "action offload not supported");

		return false;

	}

	if (knode->link_handle) {

		NL_SET_ERR_MSG_MOD(extack, "linking not supported");

		return false;

	}

	if (knode->sel->flags != TC_U32_TERMINAL) {

		NL_SET_ERR_MSG_MOD(extack,

				   "flags must be equal to TC_U32_TERMINAL");

		return false;

	}

	if (knode->sel->off || knode->sel->offshift || knode->sel->offmask ||

	    knode->sel->offoff || knode->fshift) {

		NL_SET_ERR_MSG_MOD(extack, "variable offseting not supported");

		return false;

	}

	if (knode->sel->hoff || knode->sel->hmask) {

		NL_SET_ERR_MSG_MOD(extack, "hashing not supported");

		return false;

	}

	if (knode->val || knode->mask) {

		NL_SET_ERR_MSG_MOD(extack, "matching on mark not supported");

		return false;

	}

	if (knode->res && knode->res->class) {

		NL_SET_ERR_MSG_MOD(extack, "setting non-0 class not supported");

		return false;

	}

	if (knode->res && knode->res->classid >= abm->num_bands) {

		NL_SET_ERR_MSG_MOD(extack,

				   "classid higher than number of bands");

		return false;

	}

	if (knode->sel->nkeys != 1) {

		NL_SET_ERR_MSG_MOD(extack, "exactly one key required");

		return false;

	}



	switch (proto) {

	case htons(ETH_P_IP):

		tos_off = 16;

		break;

	case htons(ETH_P_IPV6):

		tos_off = 20;

		break;

	default:

		NL_SET_ERR_MSG_MOD(extack, "only IP and IPv6 supported as filter protocol");

		return false;

	}



	k = &knode->sel->keys[0];

	if (k->offmask) {

		NL_SET_ERR_MSG_MOD(extack, "offset mask - variable offseting not supported");

		return false;

	}

	if (k->off) {

		NL_SET_ERR_MSG_MOD(extack, "only DSCP fields can be matched");

		return false;

	}

	if (k->val & ~k->mask) {

		NL_SET_ERR_MSG_MOD(extack, "mask does not cover the key");

		return false;

	}

	if (be32_to_cpu(k->mask) >> tos_off & ~abm->dscp_mask) {

		NL_SET_ERR_MSG_MOD(extack, "only high DSCP class selector bits can be used");

		nfp_err(abm->app->cpp,

			"u32 offload: requested mask %x FW can support only %x\n",

			be32_to_cpu(k->mask) >> tos_off, abm->dscp_mask);

		return false;

	}



	return true;

}



/* This filter list -> map conversion is O(n * m), we expect single digit or

 * low double digit number of prios and likewise for the filters.  Also u32

 * doesn't report stats, so it's really only setup time cost.

 */

static unsigned int

nfp_abm_find_band_for_prio(struct nfp_abm_link *alink, unsigned int prio)

{

	struct nfp_abm_u32_match *iter;



	list_for_each_entry(iter, &alink->dscp_map, list)

		if ((prio & iter->mask) == iter->val)

			return iter->band;



	return alink->def_band;

}



static int nfp_abm_update_band_map(struct nfp_abm_link *alink)

{

	unsigned int i, bits_per_prio, prios_per_word, base_shift;

	struct nfp_abm *abm = alink->abm;

	u32 field_mask;



	alink->has_prio = !list_empty(&alink->dscp_map);



	bits_per_prio = roundup_pow_of_two(order_base_2(abm->num_bands));

	field_mask = (1 << bits_per_prio) - 1;

	prios_per_word = sizeof(u32) * BITS_PER_BYTE / bits_per_prio;



	/* FW mask applies from top bits */

	base_shift = 8 - order_base_2(abm->num_prios);



	for (i = 0; i < abm->num_prios; i++) {

		unsigned int offset;

		u32 *word;

		u8 band;



		word = &alink->prio_map[i / prios_per_word];

		offset = (i % prios_per_word) * bits_per_prio;



		band = nfp_abm_find_band_for_prio(alink, i << base_shift);



		*word &= ~(field_mask << offset);

		*word |= band << offset;

	}



	/* Qdisc offload status may change if has_prio changed */

	nfp_abm_qdisc_offload_update(alink);



	return nfp_abm_ctrl_prio_map_update(alink, alink->prio_map);

}



static void

nfp_abm_u32_knode_delete(struct nfp_abm_link *alink,

			 struct tc_cls_u32_knode *knode)

{

	struct nfp_abm_u32_match *iter;



	list_for_each_entry(iter, &alink->dscp_map, list)

		if (iter->handle == knode->handle) {

			list_del(&iter->list);

			kfree(iter);

			nfp_abm_update_band_map(alink);

			return;

		}

}



static int

nfp_abm_u32_knode_replace(struct nfp_abm_link *alink,

			  struct tc_cls_u32_knode *knode,

			  __be16 proto, struct netlink_ext_ack *extack)

{

	struct nfp_abm_u32_match *match = NULL, *iter;

	unsigned int tos_off;

	u8 mask, val;

	int err;



	if (!nfp_abm_u32_check_knode(alink->abm, knode, proto, extack))

		goto err_delete;



	tos_off = proto == htons(ETH_P_IP) ? 16 : 20;



	/* Extract the DSCP Class Selector bits */

	val = be32_to_cpu(knode->sel->keys[0].val) >> tos_off & 0xff;

	mask = be32_to_cpu(knode->sel->keys[0].mask) >> tos_off & 0xff;



	/* Check if there is no conflicting mapping and find match by handle */

	list_for_each_entry(iter, &alink->dscp_map, list) {

		u32 cmask;



		if (iter->handle == knode->handle) {

			match = iter;

			continue;

		}



		cmask = iter->mask & mask;

		if ((iter->val & cmask) == (val & cmask) &&

		    iter->band != knode->res->classid) {

			NL_SET_ERR_MSG_MOD(extack, "conflict with already offloaded filter");

			goto err_delete;

		}

	}



	if (!match) {

		match = kzalloc(sizeof(*match), GFP_KERNEL);

		if (!match)

			return -ENOMEM;

		list_add(&match->list, &alink->dscp_map);

	}

	match->handle = knode->handle;

	match->band = knode->res->classid;

	match->mask = mask;

	match->val = val;



	err = nfp_abm_update_band_map(alink);

	if (err)

		goto err_delete;



	return 0;



err_delete:

	nfp_abm_u32_knode_delete(alink, knode);

	return -EOPNOTSUPP;

}



static int nfp_abm_setup_tc_block_cb(enum tc_setup_type type,

				     void *type_data, void *cb_priv)

{

	struct tc_cls_u32_offload *cls_u32 = type_data;

	struct nfp_repr *repr = cb_priv;

	struct nfp_abm_link *alink;



	alink = repr->app_priv;



	if (type != TC_SETUP_CLSU32) {

		NL_SET_ERR_MSG_MOD(cls_u32->common.extack,

				   "only offload of u32 classifier supported");

		return -EOPNOTSUPP;

	}

	if (!tc_cls_can_offload_and_chain0(repr->netdev, &cls_u32->common))

		return -EOPNOTSUPP;



	if (cls_u32->common.protocol != htons(ETH_P_IP) &&

	    cls_u32->common.protocol != htons(ETH_P_IPV6)) {

		NL_SET_ERR_MSG_MOD(cls_u32->common.extack,

				   "only IP and IPv6 supported as filter protocol");

		return -EOPNOTSUPP;

	}



	switch (cls_u32->command) {

	case TC_CLSU32_NEW_KNODE:

	case TC_CLSU32_REPLACE_KNODE:

		return nfp_abm_u32_knode_replace(alink, &cls_u32->knode,

						 cls_u32->common.protocol,

						 cls_u32->common.extack);

	case TC_CLSU32_DELETE_KNODE:

		nfp_abm_u32_knode_delete(alink, &cls_u32->knode);

		return 0;

	default:

		return -EOPNOTSUPP;

	}

}



int nfp_abm_setup_cls_block(struct net_device *netdev, struct nfp_repr *repr,

			    struct tc_block_offload *f)

{

	if (f->binder_type != TCF_BLOCK_BINDER_TYPE_CLSACT_EGRESS)

		return -EOPNOTSUPP;



	switch (f->command) {

	case TC_BLOCK_BIND:

		return tcf_block_cb_register(f->block,

					     nfp_abm_setup_tc_block_cb,

					     repr, repr, f->extack);

	case TC_BLOCK_UNBIND:

		tcf_block_cb_unregister(f->block, nfp_abm_setup_tc_block_cb,

					repr);

		return 0;

	default:

		return -EOPNOTSUPP;

	}

}

drivers/net/ethernet/netronome/nfp/abm/ctrl.c

+240 −47
Original line number Diff line number Diff line 
// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)

/* Copyright (C) 2018 Netronome Systems, Inc. */



#include <linux/bitops.h>

#include <linux/kernel.h>

#include <linux/log2.h>



#include "../nfpcore/nfp_cpp.h"

#include "../nfpcore/nfp_nffw.h"
@@ -11,38 +13,56 @@ 
#include "../nfp_net.h"

#include "main.h"



#define NFP_QLVL_SYM_NAME	"_abi_nfd_out_q_lvls_%u"

#define NFP_NUM_PRIOS_SYM_NAME	"_abi_pci_dscp_num_prio_%u"

#define NFP_NUM_BANDS_SYM_NAME	"_abi_pci_dscp_num_band_%u"

#define NFP_ACT_MASK_SYM_NAME	"_abi_nfd_out_q_actions_%u"



#define NFP_QLVL_SYM_NAME	"_abi_nfd_out_q_lvls_%u%s"

#define NFP_QLVL_STRIDE		16

#define NFP_QLVL_BLOG_BYTES	0

#define NFP_QLVL_BLOG_PKTS	4

#define NFP_QLVL_THRS		8

#define NFP_QLVL_ACT		12



#define NFP_QMSTAT_SYM_NAME	"_abi_nfdqm%u_stats"

#define NFP_QMSTAT_SYM_NAME	"_abi_nfdqm%u_stats%s"

#define NFP_QMSTAT_STRIDE	32

#define NFP_QMSTAT_NON_STO	0

#define NFP_QMSTAT_STO		8

#define NFP_QMSTAT_DROP		16

#define NFP_QMSTAT_ECN		24



#define NFP_Q_STAT_SYM_NAME	"_abi_nfd_rxq_stats%u%s"

#define NFP_Q_STAT_STRIDE	16

#define NFP_Q_STAT_PKTS		0

#define NFP_Q_STAT_BYTES	8



#define NFP_NET_ABM_MBOX_CMD		NFP_NET_CFG_MBOX_SIMPLE_CMD

#define NFP_NET_ABM_MBOX_RET		NFP_NET_CFG_MBOX_SIMPLE_RET

#define NFP_NET_ABM_MBOX_DATALEN	NFP_NET_CFG_MBOX_SIMPLE_VAL

#define NFP_NET_ABM_MBOX_RESERVED	(NFP_NET_CFG_MBOX_SIMPLE_VAL + 4)

#define NFP_NET_ABM_MBOX_DATA		(NFP_NET_CFG_MBOX_SIMPLE_VAL + 8)



static int

nfp_abm_ctrl_stat(struct nfp_abm_link *alink, const struct nfp_rtsym *sym,

		  unsigned int stride, unsigned int offset, unsigned int i,

		  bool is_u64, u64 *res)

		  unsigned int stride, unsigned int offset, unsigned int band,

		  unsigned int queue, bool is_u64, u64 *res)

{

	struct nfp_cpp *cpp = alink->abm->app->cpp;

	u64 val, sym_offset;

	unsigned int qid;

	u32 val32;

	int err;



	sym_offset = (alink->queue_base + i) * stride + offset;

	qid = band * NFP_NET_MAX_RX_RINGS + alink->queue_base + queue;



	sym_offset = qid * stride + offset;

	if (is_u64)

		err = __nfp_rtsym_readq(cpp, sym, 3, 0, sym_offset, &val);

	else

		err = __nfp_rtsym_readl(cpp, sym, 3, 0, sym_offset, &val32);

	if (err) {

		nfp_err(cpp,

			"RED offload reading stat failed on vNIC %d queue %d\n",

			alink->id, i);

		nfp_err(cpp, "RED offload reading stat failed on vNIC %d band %d queue %d (+ %d)\n",

			alink->id, band, queue, alink->queue_base);

		return err;

	}
@@ -73,81 +93,156 @@ int __nfp_abm_ctrl_set_q_lvl(struct nfp_abm *abm, unsigned int id, u32 val) 
	return 0;

}



int nfp_abm_ctrl_set_q_lvl(struct nfp_abm_link *alink, unsigned int queue,

			   u32 val)

int nfp_abm_ctrl_set_q_lvl(struct nfp_abm_link *alink, unsigned int band,

			   unsigned int queue, u32 val)

{

	unsigned int threshold;



	threshold = alink->queue_base + queue;

	threshold = band * NFP_NET_MAX_RX_RINGS + alink->queue_base + queue;



	return __nfp_abm_ctrl_set_q_lvl(alink->abm, threshold, val);

}



u64 nfp_abm_ctrl_stat_non_sto(struct nfp_abm_link *alink, unsigned int i)

int __nfp_abm_ctrl_set_q_act(struct nfp_abm *abm, unsigned int id,

			     enum nfp_abm_q_action act)

{

	struct nfp_cpp *cpp = abm->app->cpp;

	u64 sym_offset;

	int err;



	if (abm->actions[id] == act)

		return 0;



	sym_offset = id * NFP_QLVL_STRIDE + NFP_QLVL_ACT;

	err = __nfp_rtsym_writel(cpp, abm->q_lvls, 4, 0, sym_offset, act);

	if (err) {

		nfp_err(cpp,

			"RED offload setting action failed on subqueue %d\n",

			id);

		return err;

	}



	abm->actions[id] = act;

	return 0;

}



int nfp_abm_ctrl_set_q_act(struct nfp_abm_link *alink, unsigned int band,

			   unsigned int queue, enum nfp_abm_q_action act)

{

	unsigned int qid;



	qid = band * NFP_NET_MAX_RX_RINGS + alink->queue_base + queue;



	return __nfp_abm_ctrl_set_q_act(alink->abm, qid, act);

}



u64 nfp_abm_ctrl_stat_non_sto(struct nfp_abm_link *alink, unsigned int queue)

{

	unsigned int band;

	u64 val, sum = 0;



	for (band = 0; band < alink->abm->num_bands; band++) {

		if (nfp_abm_ctrl_stat(alink, alink->abm->qm_stats,

				      NFP_QMSTAT_STRIDE, NFP_QMSTAT_NON_STO,

				      band, queue, true, &val))

			return 0;

		sum += val;

	}



	return sum;

}



u64 nfp_abm_ctrl_stat_sto(struct nfp_abm_link *alink, unsigned int queue)

{

	u64 val;

	unsigned int band;

	u64 val, sum = 0;



	if (nfp_abm_ctrl_stat(alink, alink->abm->qm_stats, NFP_QMSTAT_STRIDE,

			      NFP_QMSTAT_NON_STO, i, true, &val))

	for (band = 0; band < alink->abm->num_bands; band++) {

		if (nfp_abm_ctrl_stat(alink, alink->abm->qm_stats,

				      NFP_QMSTAT_STRIDE, NFP_QMSTAT_STO,

				      band, queue, true, &val))

			return 0;

	return val;

		sum += val;

	}



	return sum;

}



u64 nfp_abm_ctrl_stat_sto(struct nfp_abm_link *alink, unsigned int i)

static int

nfp_abm_ctrl_stat_basic(struct nfp_abm_link *alink, unsigned int band,

			unsigned int queue, unsigned int off, u64 *val)

{

	u64 val;

	if (!nfp_abm_has_prio(alink->abm)) {

		if (!band) {

			unsigned int id = alink->queue_base + queue;



			*val = nn_readq(alink->vnic,

					NFP_NET_CFG_RXR_STATS(id) + off);

		} else {

			*val = 0;

		}



	if (nfp_abm_ctrl_stat(alink, alink->abm->qm_stats, NFP_QMSTAT_STRIDE,

			      NFP_QMSTAT_STO, i, true, &val))

		return 0;

	return val;

	} else {

		return nfp_abm_ctrl_stat(alink, alink->abm->q_stats,

					 NFP_Q_STAT_STRIDE, off, band, queue,

					 true, val);

	}

}



int nfp_abm_ctrl_read_q_stats(struct nfp_abm_link *alink, unsigned int i,

			      struct nfp_alink_stats *stats)

int nfp_abm_ctrl_read_q_stats(struct nfp_abm_link *alink, unsigned int band,

			      unsigned int queue, struct nfp_alink_stats *stats)

{

	int err;



	stats->tx_pkts = nn_readq(alink->vnic, NFP_NET_CFG_RXR_STATS(i));

	stats->tx_bytes = nn_readq(alink->vnic, NFP_NET_CFG_RXR_STATS(i) + 8);

	err = nfp_abm_ctrl_stat_basic(alink, band, queue, NFP_Q_STAT_PKTS,

				      &stats->tx_pkts);

	if (err)

		return err;



	err = nfp_abm_ctrl_stat(alink, alink->abm->q_lvls,

				NFP_QLVL_STRIDE, NFP_QLVL_BLOG_BYTES,

				i, false, &stats->backlog_bytes);

	err = nfp_abm_ctrl_stat_basic(alink, band, queue, NFP_Q_STAT_BYTES,

				      &stats->tx_bytes);

	if (err)

		return err;



	err = nfp_abm_ctrl_stat(alink, alink->abm->q_lvls, NFP_QLVL_STRIDE,

				NFP_QLVL_BLOG_BYTES, band, queue, false,

				&stats->backlog_bytes);

	if (err)

		return err;



	err = nfp_abm_ctrl_stat(alink, alink->abm->q_lvls,

				NFP_QLVL_STRIDE, NFP_QLVL_BLOG_PKTS,

				i, false, &stats->backlog_pkts);

				band, queue, false, &stats->backlog_pkts);

	if (err)

		return err;



	err = nfp_abm_ctrl_stat(alink, alink->abm->qm_stats,

				NFP_QMSTAT_STRIDE, NFP_QMSTAT_DROP,

				i, true, &stats->drops);

				band, queue, true, &stats->drops);

	if (err)

		return err;



	return nfp_abm_ctrl_stat(alink, alink->abm->qm_stats,

				 NFP_QMSTAT_STRIDE, NFP_QMSTAT_ECN,

				 i, true, &stats->overlimits);

				 band, queue, true, &stats->overlimits);

}



int nfp_abm_ctrl_read_q_xstats(struct nfp_abm_link *alink, unsigned int i,

int nfp_abm_ctrl_read_q_xstats(struct nfp_abm_link *alink,

			       unsigned int band, unsigned int queue,

			       struct nfp_alink_xstats *xstats)

{

	int err;



	err = nfp_abm_ctrl_stat(alink, alink->abm->qm_stats,

				NFP_QMSTAT_STRIDE, NFP_QMSTAT_DROP,

				i, true, &xstats->pdrop);

				band, queue, true, &xstats->pdrop);

	if (err)

		return err;



	return nfp_abm_ctrl_stat(alink, alink->abm->qm_stats,

				 NFP_QMSTAT_STRIDE, NFP_QMSTAT_ECN,

				 i, true, &xstats->ecn_marked);

				 band, queue, true, &xstats->ecn_marked);

}



int nfp_abm_ctrl_qm_enable(struct nfp_abm *abm)
@@ -162,10 +257,64 @@ int nfp_abm_ctrl_qm_disable(struct nfp_abm *abm) 
			    NULL, 0, NULL, 0);

}



void nfp_abm_ctrl_read_params(struct nfp_abm_link *alink)

int nfp_abm_ctrl_prio_map_update(struct nfp_abm_link *alink, u32 *packed)

{

	struct nfp_net *nn = alink->vnic;

	unsigned int i;

	int err;



	/* Write data_len and wipe reserved */

	nn_writeq(nn, nn->tlv_caps.mbox_off + NFP_NET_ABM_MBOX_DATALEN,

		  alink->abm->prio_map_len);



	for (i = 0; i < alink->abm->prio_map_len; i += sizeof(u32))

		nn_writel(nn, nn->tlv_caps.mbox_off + NFP_NET_ABM_MBOX_DATA + i,

			  packed[i / sizeof(u32)]);



	err = nfp_net_reconfig_mbox(nn,

				    NFP_NET_CFG_MBOX_CMD_PCI_DSCP_PRIOMAP_SET);

	if (err)

		nfp_err(alink->abm->app->cpp,

			"setting DSCP -> VQ map failed with error %d\n", err);

	return err;

}



static int nfp_abm_ctrl_prio_check_params(struct nfp_abm_link *alink)

{

	struct nfp_abm *abm = alink->abm;

	struct nfp_net *nn = alink->vnic;

	unsigned int min_mbox_sz;



	if (!nfp_abm_has_prio(alink->abm))

		return 0;



	min_mbox_sz = NFP_NET_ABM_MBOX_DATA + alink->abm->prio_map_len;

	if (nn->tlv_caps.mbox_len < min_mbox_sz) {

		nfp_err(abm->app->pf->cpp, "vNIC mailbox too small for prio offload: %u, need: %u\n",

			nn->tlv_caps.mbox_len,  min_mbox_sz);

		return -EINVAL;

	}



	return 0;

}



int nfp_abm_ctrl_read_params(struct nfp_abm_link *alink)

{

	alink->queue_base = nn_readl(alink->vnic, NFP_NET_CFG_START_RXQ);

	alink->queue_base /= alink->vnic->stride_rx;



	return nfp_abm_ctrl_prio_check_params(alink);

}



static unsigned int nfp_abm_ctrl_prio_map_size(struct nfp_abm *abm)

{

	unsigned int size;



	size = roundup_pow_of_two(order_base_2(abm->num_bands));

	size = DIV_ROUND_UP(size * abm->num_prios, BITS_PER_BYTE);

	size = round_up(size, sizeof(u32));



	return size;

}



static const struct nfp_rtsym *
@@ -189,33 +338,77 @@ nfp_abm_ctrl_find_rtsym(struct nfp_pf *pf, const char *name, unsigned int size) 
}



static const struct nfp_rtsym *

nfp_abm_ctrl_find_q_rtsym(struct nfp_pf *pf, const char *name,

			  unsigned int size)

nfp_abm_ctrl_find_q_rtsym(struct nfp_abm *abm, const char *name_fmt,

			  size_t size)

{

	return nfp_abm_ctrl_find_rtsym(pf, name, size * NFP_NET_MAX_RX_RINGS);

	char pf_symbol[64];



	size = array3_size(size, abm->num_bands, NFP_NET_MAX_RX_RINGS);

	snprintf(pf_symbol, sizeof(pf_symbol), name_fmt,

		 abm->pf_id, nfp_abm_has_prio(abm) ? "_per_band" : "");



	return nfp_abm_ctrl_find_rtsym(abm->app->pf, pf_symbol, size);

}



int nfp_abm_ctrl_find_addrs(struct nfp_abm *abm)

{

	struct nfp_pf *pf = abm->app->pf;

	const struct nfp_rtsym *sym;

	unsigned int pf_id;

	char pf_symbol[64];



	pf_id =	nfp_cppcore_pcie_unit(pf->cpp);

	abm->pf_id = pf_id;

	int res;



	abm->pf_id = nfp_cppcore_pcie_unit(pf->cpp);



	/* Read count of prios and prio bands */

	res = nfp_pf_rtsym_read_optional(pf, NFP_NUM_BANDS_SYM_NAME, 1);

	if (res < 0)

		return res;

	abm->num_bands = res;



	res = nfp_pf_rtsym_read_optional(pf, NFP_NUM_PRIOS_SYM_NAME, 1);

	if (res < 0)

		return res;

	abm->num_prios = res;



	/* Read available actions */

	res = nfp_pf_rtsym_read_optional(pf, NFP_ACT_MASK_SYM_NAME,

					 BIT(NFP_ABM_ACT_MARK_DROP));

	if (res < 0)

		return res;

	abm->action_mask = res;



	abm->prio_map_len = nfp_abm_ctrl_prio_map_size(abm);

	abm->dscp_mask = GENMASK(7, 8 - order_base_2(abm->num_prios));



	/* Check values are sane, U16_MAX is arbitrarily chosen as max */

	if (!is_power_of_2(abm->num_bands) || !is_power_of_2(abm->num_prios) ||

	    abm->num_bands > U16_MAX || abm->num_prios > U16_MAX ||

	    (abm->num_bands == 1) != (abm->num_prios == 1)) {

		nfp_err(pf->cpp,

			"invalid priomap description num bands: %u and num prios: %u\n",

			abm->num_bands, abm->num_prios);

		return -EINVAL;

	}



	snprintf(pf_symbol, sizeof(pf_symbol), NFP_QLVL_SYM_NAME, pf_id);

	sym = nfp_abm_ctrl_find_q_rtsym(pf, pf_symbol, NFP_QLVL_STRIDE);

	/* Find level and stat symbols */

	sym = nfp_abm_ctrl_find_q_rtsym(abm, NFP_QLVL_SYM_NAME,

					NFP_QLVL_STRIDE);

	if (IS_ERR(sym))

		return PTR_ERR(sym);

	abm->q_lvls = sym;



	snprintf(pf_symbol, sizeof(pf_symbol), NFP_QMSTAT_SYM_NAME, pf_id);

	sym = nfp_abm_ctrl_find_q_rtsym(pf, pf_symbol, NFP_QMSTAT_STRIDE);

	sym = nfp_abm_ctrl_find_q_rtsym(abm, NFP_QMSTAT_SYM_NAME,

					NFP_QMSTAT_STRIDE);

	if (IS_ERR(sym))

		return PTR_ERR(sym);

	abm->qm_stats = sym;



	if (nfp_abm_has_prio(abm)) {

		sym = nfp_abm_ctrl_find_q_rtsym(abm, NFP_Q_STAT_SYM_NAME,

						NFP_Q_STAT_STRIDE);

		if (IS_ERR(sym))

			return PTR_ERR(sym);

		abm->q_stats = sym;

	}



	return 0;

}

drivers/net/ethernet/netronome/nfp/abm/main.c

+42 −6
Original line number Diff line number Diff line
@@ -44,6 +44,10 @@ nfp_abm_setup_tc(struct nfp_app *app, struct net_device *netdev, 
		return nfp_abm_setup_tc_mq(netdev, repr->app_priv, type_data);

	case TC_SETUP_QDISC_RED:

		return nfp_abm_setup_tc_red(netdev, repr->app_priv, type_data);

	case TC_SETUP_QDISC_GRED:

		return nfp_abm_setup_tc_gred(netdev, repr->app_priv, type_data);

	case TC_SETUP_BLOCK:

		return nfp_abm_setup_cls_block(netdev, repr, type_data);

	default:

		return -EOPNOTSUPP;

	}
@@ -313,21 +317,32 @@ nfp_abm_vnic_alloc(struct nfp_app *app, struct nfp_net *nn, unsigned int id) 
	alink->id = id;

	alink->total_queues = alink->vnic->max_rx_rings;



	INIT_LIST_HEAD(&alink->dscp_map);



	err = nfp_abm_ctrl_read_params(alink);

	if (err)

		goto err_free_alink;



	alink->prio_map = kzalloc(abm->prio_map_len, GFP_KERNEL);

	if (!alink->prio_map)

		goto err_free_alink;



	/* This is a multi-host app, make sure MAC/PHY is up, but don't

	 * make the MAC/PHY state follow the state of any of the ports.

	 */

	err = nfp_eth_set_configured(app->cpp, eth_port->index, true);

	if (err < 0)

		goto err_free_alink;

		goto err_free_priomap;



	netif_keep_dst(nn->dp.netdev);



	nfp_abm_vnic_set_mac(app->pf, abm, nn, id);

	nfp_abm_ctrl_read_params(alink);

	INIT_RADIX_TREE(&alink->qdiscs, GFP_KERNEL);



	return 0;



err_free_priomap:

	kfree(alink->prio_map);

err_free_alink:

	kfree(alink);

	return err;
@@ -339,9 +354,19 @@ static void nfp_abm_vnic_free(struct nfp_app *app, struct nfp_net *nn) 


	nfp_abm_kill_reprs(alink->abm, alink);

	WARN(!radix_tree_empty(&alink->qdiscs), "left over qdiscs\n");

	kfree(alink->prio_map);

	kfree(alink);

}



static int nfp_abm_vnic_init(struct nfp_app *app, struct nfp_net *nn)

{

	struct nfp_abm_link *alink = nn->app_priv;



	if (nfp_abm_has_prio(alink->abm))

		return nfp_abm_ctrl_prio_map_update(alink, alink->prio_map);

	return 0;

}



static u64 *

nfp_abm_port_get_stats(struct nfp_app *app, struct nfp_port *port, u64 *data)

{
@@ -422,7 +447,7 @@ static int nfp_abm_init(struct nfp_app *app) 
		goto err_free_abm;



	err = -ENOMEM;

	abm->num_thresholds = NFP_NET_MAX_RX_RINGS;

	abm->num_thresholds = array_size(abm->num_bands, NFP_NET_MAX_RX_RINGS);

	abm->threshold_undef = bitmap_zalloc(abm->num_thresholds, GFP_KERNEL);

	if (!abm->threshold_undef)

		goto err_free_abm;
@@ -431,18 +456,25 @@ static int nfp_abm_init(struct nfp_app *app) 
				   sizeof(*abm->thresholds), GFP_KERNEL);

	if (!abm->thresholds)

		goto err_free_thresh_umap;

	for (i = 0; i < NFP_NET_MAX_RX_RINGS; i++)

	for (i = 0; i < abm->num_bands * NFP_NET_MAX_RX_RINGS; i++)

		__nfp_abm_ctrl_set_q_lvl(abm, i, NFP_ABM_LVL_INFINITY);



	abm->actions = kvcalloc(abm->num_thresholds, sizeof(*abm->actions),

				GFP_KERNEL);

	if (!abm->actions)

		goto err_free_thresh;

	for (i = 0; i < abm->num_bands * NFP_NET_MAX_RX_RINGS; i++)

		__nfp_abm_ctrl_set_q_act(abm, i, NFP_ABM_ACT_DROP);



	/* We start in legacy mode, make sure advanced queuing is disabled */

	err = nfp_abm_ctrl_qm_disable(abm);

	if (err)

		goto err_free_thresh;

		goto err_free_act;



	err = -ENOMEM;

	reprs = nfp_reprs_alloc(pf->max_data_vnics);

	if (!reprs)

		goto err_free_thresh;

		goto err_free_act;

	RCU_INIT_POINTER(app->reprs[NFP_REPR_TYPE_PHYS_PORT], reprs);



	reprs = nfp_reprs_alloc(pf->max_data_vnics);
@@ -454,6 +486,8 @@ static int nfp_abm_init(struct nfp_app *app) 


err_free_phys:

	nfp_reprs_clean_and_free_by_type(app, NFP_REPR_TYPE_PHYS_PORT);

err_free_act:

	kvfree(abm->actions);

err_free_thresh:

	kvfree(abm->thresholds);

err_free_thresh_umap:
@@ -472,6 +506,7 @@ static void nfp_abm_clean(struct nfp_app *app) 
	nfp_reprs_clean_and_free_by_type(app, NFP_REPR_TYPE_PF);

	nfp_reprs_clean_and_free_by_type(app, NFP_REPR_TYPE_PHYS_PORT);

	bitmap_free(abm->threshold_undef);

	kvfree(abm->actions);

	kvfree(abm->thresholds);

	kfree(abm);

	app->priv = NULL;
@@ -486,6 +521,7 @@ const struct nfp_app_type app_abm = { 


	.vnic_alloc	= nfp_abm_vnic_alloc,

	.vnic_free	= nfp_abm_vnic_free,

	.vnic_init	= nfp_abm_vnic_init,



	.port_get_stats		= nfp_abm_port_get_stats,

	.port_get_stats_count	= nfp_abm_port_get_stats_count,

drivers/net/ethernet/netronome/nfp/abm/main.h

+97 −16

File changed.

Preview size limit exceeded, changes collapsed.