Commit 2cb59424 authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'octeonx2-mcam-management-rework' 



Subbaraya Sundeep says:

====================
octeontx2: Rework MCAM flows management for VFs

From Octeontx2 hardware point of view there is no
difference between PFs and VFs. Hence with refactoring
in driver the packet classification features or offloads
can be supported by VFs also. This patchset unifies the
mcam flows management so that VFs can also support
ntuple filters. Since there are MCAM allocations by
all PFs and VFs in the system it is required to have
the ability to modify number of mcam rules count
for a PF/VF in runtime. This is achieved by using devlink.
Below is the summary of patches:

Patch 1,2,3 are trivial patches which helps in debugging
in case of errors by using custom error codes and
displaying proper error messages.

Patches 4,5 brings rx-all and ntuple support
for CGX mapped VFs and LBK VFs.

Patches 6,7,8 brings devlink support to
PF netdev driver so that mcam entries count
can be changed at runtime.
To change mcam rule count at runtime where multiple rule
allocations are done sorting is required.
Also both ntuple and TC rules needs to be unified.

Patch 9 is related to AF NPC where a PF
allocated entries are allocated at bottom(low priority).

On CN10K there is slight change in reading
NPC counters which is handled by patch 10.

Patch 11 is to allow packets from CPT for
NPC parsing on CN10K.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 354e1f9d aee51224

drivers/net/ethernet/marvell/octeontx2/af/mbox.h

+16 −0
Original line number Diff line number Diff line
@@ -1078,6 +1078,13 @@ enum npc_af_status { 
	NPC_MCAM_ALLOC_DENIED	= -702,

	NPC_MCAM_ALLOC_FAILED	= -703,

	NPC_MCAM_PERM_DENIED	= -704,

	NPC_FLOW_INTF_INVALID	= -707,

	NPC_FLOW_CHAN_INVALID	= -708,

	NPC_FLOW_NO_NIXLF	= -709,

	NPC_FLOW_NOT_SUPPORTED	= -710,

	NPC_FLOW_VF_PERM_DENIED	= -711,

	NPC_FLOW_VF_NOT_INIT	= -712,

	NPC_FLOW_VF_OVERLAP	= -713,

};



struct npc_mcam_alloc_entry_req {
@@ -1426,4 +1433,13 @@ struct cpt_rxc_time_cfg_req { 
	u16 active_limit;

};



/* CGX mailbox error codes

 * Range 1101 - 1200.

 */

enum cgx_af_status {

	LMAC_AF_ERR_INVALID_PARAM	= -1101,

	LMAC_AF_ERR_PF_NOT_MAPPED	= -1102,

	LMAC_AF_ERR_PERM_DENIED		= -1103,

};



#endif /* MBOX_H */

drivers/net/ethernet/marvell/octeontx2/af/rvu.c

+73 −19
Original line number Diff line number Diff line
@@ -924,16 +924,26 @@ static int rvu_setup_hw_resources(struct rvu *rvu) 
	block->lfreset_reg = NPA_AF_LF_RST;

	sprintf(block->name, "NPA");

	err = rvu_alloc_bitmap(&block->lf);

	if (err)

	if (err) {

		dev_err(rvu->dev,

			"%s: Failed to allocate NPA LF bitmap\n", __func__);

		return err;

	}



nix:

	err = rvu_setup_nix_hw_resource(rvu, BLKADDR_NIX0);

	if (err)

	if (err) {

		dev_err(rvu->dev,

			"%s: Failed to allocate NIX0 LFs bitmap\n", __func__);

		return err;

	}



	err = rvu_setup_nix_hw_resource(rvu, BLKADDR_NIX1);

	if (err)

	if (err) {

		dev_err(rvu->dev,

			"%s: Failed to allocate NIX1 LFs bitmap\n", __func__);

		return err;

	}



	/* Init SSO group's bitmap */

	block = &hw->block[BLKADDR_SSO];
@@ -953,8 +963,11 @@ static int rvu_setup_hw_resources(struct rvu *rvu) 
	block->lfreset_reg = SSO_AF_LF_HWGRP_RST;

	sprintf(block->name, "SSO GROUP");

	err = rvu_alloc_bitmap(&block->lf);

	if (err)

	if (err) {

		dev_err(rvu->dev,

			"%s: Failed to allocate SSO LF bitmap\n", __func__);

		return err;

	}



ssow:

	/* Init SSO workslot's bitmap */
@@ -974,8 +987,11 @@ static int rvu_setup_hw_resources(struct rvu *rvu) 
	block->lfreset_reg = SSOW_AF_LF_HWS_RST;

	sprintf(block->name, "SSOWS");

	err = rvu_alloc_bitmap(&block->lf);

	if (err)

	if (err) {

		dev_err(rvu->dev,

			"%s: Failed to allocate SSOW LF bitmap\n", __func__);

		return err;

	}



tim:

	/* Init TIM LF's bitmap */
@@ -996,35 +1012,55 @@ static int rvu_setup_hw_resources(struct rvu *rvu) 
	block->lfreset_reg = TIM_AF_LF_RST;

	sprintf(block->name, "TIM");

	err = rvu_alloc_bitmap(&block->lf);

	if (err)

	if (err) {

		dev_err(rvu->dev,

			"%s: Failed to allocate TIM LF bitmap\n", __func__);

		return err;

	}



cpt:

	err = rvu_setup_cpt_hw_resource(rvu, BLKADDR_CPT0);

	if (err)

	if (err) {

		dev_err(rvu->dev,

			"%s: Failed to allocate CPT0 LF bitmap\n", __func__);

		return err;

	}

	err = rvu_setup_cpt_hw_resource(rvu, BLKADDR_CPT1);

	if (err) {

		dev_err(rvu->dev,

			"%s: Failed to allocate CPT1 LF bitmap\n", __func__);

		return err;

	}

	if (err)

		return err;



	/* Allocate memory for PFVF data */

	rvu->pf = devm_kcalloc(rvu->dev, hw->total_pfs,

			       sizeof(struct rvu_pfvf), GFP_KERNEL);

	if (!rvu->pf)

	if (!rvu->pf) {

		dev_err(rvu->dev,

			"%s: Failed to allocate memory for PF's rvu_pfvf struct\n", __func__);

		return -ENOMEM;

	}



	rvu->hwvf = devm_kcalloc(rvu->dev, hw->total_vfs,

				 sizeof(struct rvu_pfvf), GFP_KERNEL);

	if (!rvu->hwvf)

	if (!rvu->hwvf) {

		dev_err(rvu->dev,

			"%s: Failed to allocate memory for VF's rvu_pfvf struct\n", __func__);

		return -ENOMEM;

	}



	mutex_init(&rvu->rsrc_lock);



	rvu_fwdata_init(rvu);



	err = rvu_setup_msix_resources(rvu);

	if (err)

	if (err) {

		dev_err(rvu->dev,

			"%s: Failed to setup MSIX resources\n", __func__);

		return err;

	}



	for (blkid = 0; blkid < BLK_COUNT; blkid++) {

		block = &hw->block[blkid];
@@ -1050,25 +1086,33 @@ static int rvu_setup_hw_resources(struct rvu *rvu) 
		goto msix_err;



	err = rvu_npc_init(rvu);

	if (err)

	if (err) {

		dev_err(rvu->dev, "%s: Failed to initialize npc\n", __func__);

		goto npc_err;

	}



	err = rvu_cgx_init(rvu);

	if (err)

	if (err) {

		dev_err(rvu->dev, "%s: Failed to initialize cgx\n", __func__);

		goto cgx_err;

	}



	/* Assign MACs for CGX mapped functions */

	rvu_setup_pfvf_macaddress(rvu);



	err = rvu_npa_init(rvu);

	if (err)

	if (err) {

		dev_err(rvu->dev, "%s: Failed to initialize npa\n", __func__);

		goto npa_err;

	}



	rvu_get_lbk_bufsize(rvu);



	err = rvu_nix_init(rvu);

	if (err)

	if (err) {

		dev_err(rvu->dev, "%s: Failed to initialize nix\n", __func__);

		goto nix_err;

	}



	rvu_program_channels(rvu);
@@ -2984,27 +3028,37 @@ static int rvu_probe(struct pci_dev *pdev, const struct pci_device_id *id) 
	err = rvu_mbox_init(rvu, &rvu->afpf_wq_info, TYPE_AFPF,

			    rvu->hw->total_pfs, rvu_afpf_mbox_handler,

			    rvu_afpf_mbox_up_handler);

	if (err)

	if (err) {

		dev_err(dev, "%s: Failed to initialize mbox\n", __func__);

		goto err_hwsetup;

	}



	err = rvu_flr_init(rvu);

	if (err)

	if (err) {

		dev_err(dev, "%s: Failed to initialize flr\n", __func__);

		goto err_mbox;

	}



	err = rvu_register_interrupts(rvu);

	if (err)

	if (err) {

		dev_err(dev, "%s: Failed to register interrupts\n", __func__);

		goto err_flr;

	}



	err = rvu_register_dl(rvu);

	if (err)

	if (err) {

		dev_err(dev, "%s: Failed to register devlink\n", __func__);

		goto err_irq;

	}



	rvu_setup_rvum_blk_revid(rvu);



	/* Enable AF's VFs (if any) */

	err = rvu_enable_sriov(rvu);

	if (err)

	if (err) {

		dev_err(dev, "%s: Failed to enable sriov\n", __func__);

		goto err_dl;

	}



	/* Initialize debugfs */

	rvu_dbg_init(rvu);

drivers/net/ethernet/marvell/octeontx2/af/rvu.h

+1 −0
Original line number Diff line number Diff line
@@ -356,6 +356,7 @@ struct rvu_hwinfo { 
	u16	npc_counters;	   /* No of match stats counters */

	u32	lbk_bufsize;	   /* FIFO size supported by LBK */

	bool	npc_ext_set;	   /* Extended register set */

	u64     npc_stat_ena;      /* Match stats enable bit */



	struct hw_cap    cap;

	struct rvu_block block[BLK_COUNT]; /* Block info */

drivers/net/ethernet/marvell/octeontx2/af/rvu_cgx.c

+6 −6
Original line number Diff line number Diff line
@@ -448,7 +448,7 @@ int rvu_cgx_config_rxtx(struct rvu *rvu, u16 pcifunc, bool start) 
	u8 cgx_id, lmac_id;



	if (!is_cgx_config_permitted(rvu, pcifunc))

		return -EPERM;

		return LMAC_AF_ERR_PERM_DENIED;



	rvu_get_cgx_lmac_id(rvu->pf2cgxlmac_map[pf], &cgx_id, &lmac_id);
@@ -507,7 +507,7 @@ static int rvu_lmac_get_stats(struct rvu *rvu, struct msg_req *req, 
	void *cgxd;



	if (!is_cgx_config_permitted(rvu, req->hdr.pcifunc))

		return -ENODEV;

		return LMAC_AF_ERR_PERM_DENIED;



	rvu_get_cgx_lmac_id(rvu->pf2cgxlmac_map[pf], &cgx_idx, &lmac);

	cgxd = rvu_cgx_pdata(cgx_idx, rvu);
@@ -561,7 +561,7 @@ int rvu_mbox_handler_cgx_fec_stats(struct rvu *rvu, 
	void *cgxd;



	if (!is_cgx_config_permitted(rvu, req->hdr.pcifunc))

		return -EPERM;

		return LMAC_AF_ERR_PERM_DENIED;

	rvu_get_cgx_lmac_id(rvu->pf2cgxlmac_map[pf], &cgx_idx, &lmac);



	cgxd = rvu_cgx_pdata(cgx_idx, rvu);
@@ -888,7 +888,7 @@ int rvu_mbox_handler_cgx_get_phy_fec_stats(struct rvu *rvu, struct msg_req *req, 
	u8 cgx_id, lmac_id;



	if (!is_pf_cgxmapped(rvu, pf))

		return -EPERM;

		return LMAC_AF_ERR_PF_NOT_MAPPED;



	rvu_get_cgx_lmac_id(rvu->pf2cgxlmac_map[pf], &cgx_id, &lmac_id);

	return cgx_get_phy_fec_stats(rvu_cgx_pdata(cgx_id, rvu), lmac_id);
@@ -1046,7 +1046,7 @@ int rvu_mbox_handler_cgx_mac_addr_reset(struct rvu *rvu, struct msg_req *req, 
	u8 cgx_id, lmac_id;



	if (!is_cgx_config_permitted(rvu, req->hdr.pcifunc))

		return -EPERM;

		return LMAC_AF_ERR_PERM_DENIED;



	rvu_get_cgx_lmac_id(rvu->pf2cgxlmac_map[pf], &cgx_id, &lmac_id);

	return cgx_lmac_addr_reset(cgx_id, lmac_id);
@@ -1060,7 +1060,7 @@ int rvu_mbox_handler_cgx_mac_addr_update(struct rvu *rvu, 
	u8 cgx_id, lmac_id;



	if (!is_cgx_config_permitted(rvu, req->hdr.pcifunc))

		return -EPERM;

		return LMAC_AF_ERR_PERM_DENIED;



	rvu_get_cgx_lmac_id(rvu->pf2cgxlmac_map[pf], &cgx_id, &lmac_id);

	return cgx_lmac_addr_update(cgx_id, lmac_id, req->mac_addr, req->index);

drivers/net/ethernet/marvell/octeontx2/af/rvu_nix.c

+31 −14
Original line number Diff line number Diff line
@@ -984,7 +984,7 @@ static int rvu_nix_aq_enq_inst(struct rvu *rvu, struct nix_aq_enq_req *req, 


	nix_hw =  get_nix_hw(rvu->hw, blkaddr);

	if (!nix_hw)

		return -EINVAL;

		return NIX_AF_ERR_INVALID_NIXBLK;



	return rvu_nix_blk_aq_enq_inst(rvu, nix_hw, req, rsp);

}
@@ -1405,7 +1405,7 @@ int rvu_mbox_handler_nix_mark_format_cfg(struct rvu *rvu, 


	nix_hw = get_nix_hw(rvu->hw, blkaddr);

	if (!nix_hw)

		return -EINVAL;

		return NIX_AF_ERR_INVALID_NIXBLK;



	cfg = (((u32)req->offset & 0x7) << 16) |

	      (((u32)req->y_mask & 0xF) << 12) |
@@ -1673,7 +1673,7 @@ int rvu_mbox_handler_nix_txsch_alloc(struct rvu *rvu, 


	nix_hw = get_nix_hw(rvu->hw, blkaddr);

	if (!nix_hw)

		return -EINVAL;

		return NIX_AF_ERR_INVALID_NIXBLK;



	mutex_lock(&rvu->rsrc_lock);
@@ -1795,7 +1795,7 @@ static int nix_txschq_free(struct rvu *rvu, u16 pcifunc) 


	nix_hw = get_nix_hw(rvu->hw, blkaddr);

	if (!nix_hw)

		return -EINVAL;

		return NIX_AF_ERR_INVALID_NIXBLK;



	nixlf = rvu_get_lf(rvu, &hw->block[blkaddr], pcifunc, 0);

	if (nixlf < 0)
@@ -1866,7 +1866,7 @@ static int nix_txschq_free_one(struct rvu *rvu, 


	nix_hw = get_nix_hw(rvu->hw, blkaddr);

	if (!nix_hw)

		return -EINVAL;

		return NIX_AF_ERR_INVALID_NIXBLK;



	nixlf = rvu_get_lf(rvu, &hw->block[blkaddr], pcifunc, 0);

	if (nixlf < 0)
@@ -2066,7 +2066,7 @@ int rvu_mbox_handler_nix_txschq_cfg(struct rvu *rvu, 


	nix_hw = get_nix_hw(rvu->hw, blkaddr);

	if (!nix_hw)

		return -EINVAL;

		return NIX_AF_ERR_INVALID_NIXBLK;



	txsch = &nix_hw->txsch[req->lvl];

	pfvf_map = txsch->pfvf_map;
@@ -2164,8 +2164,12 @@ static int nix_tx_vtag_free(struct rvu *rvu, int blkaddr, 
			    u16 pcifunc, int index)

{

	struct nix_hw *nix_hw = get_nix_hw(rvu->hw, blkaddr);

	struct nix_txvlan *vlan = &nix_hw->txvlan;

	struct nix_txvlan *vlan;



	if (!nix_hw)

		return NIX_AF_ERR_INVALID_NIXBLK;



	vlan = &nix_hw->txvlan;

	if (vlan->entry2pfvf_map[index] != pcifunc)

		return NIX_AF_ERR_PARAM;
@@ -2206,10 +2210,15 @@ static int nix_tx_vtag_alloc(struct rvu *rvu, int blkaddr, 
			     u64 vtag, u8 size)

{

	struct nix_hw *nix_hw = get_nix_hw(rvu->hw, blkaddr);

	struct nix_txvlan *vlan = &nix_hw->txvlan;

	struct nix_txvlan *vlan;

	u64 regval;

	int index;



	if (!nix_hw)

		return NIX_AF_ERR_INVALID_NIXBLK;



	vlan = &nix_hw->txvlan;



	mutex_lock(&vlan->rsrc_lock);



	index = rvu_alloc_rsrc(&vlan->rsrc);
@@ -2234,12 +2243,16 @@ static int nix_tx_vtag_decfg(struct rvu *rvu, int blkaddr, 
			     struct nix_vtag_config *req)

{

	struct nix_hw *nix_hw = get_nix_hw(rvu->hw, blkaddr);

	struct nix_txvlan *vlan = &nix_hw->txvlan;

	u16 pcifunc = req->hdr.pcifunc;

	int idx0 = req->tx.vtag0_idx;

	int idx1 = req->tx.vtag1_idx;

	struct nix_txvlan *vlan;

	int err = 0;



	if (!nix_hw)

		return NIX_AF_ERR_INVALID_NIXBLK;



	vlan = &nix_hw->txvlan;

	if (req->tx.free_vtag0 && req->tx.free_vtag1)

		if (vlan->entry2pfvf_map[idx0] != pcifunc ||

		    vlan->entry2pfvf_map[idx1] != pcifunc)
@@ -2266,9 +2279,13 @@ static int nix_tx_vtag_cfg(struct rvu *rvu, int blkaddr, 
			   struct nix_vtag_config_rsp *rsp)

{

	struct nix_hw *nix_hw = get_nix_hw(rvu->hw, blkaddr);

	struct nix_txvlan *vlan = &nix_hw->txvlan;

	struct nix_txvlan *vlan;

	u16 pcifunc = req->hdr.pcifunc;



	if (!nix_hw)

		return NIX_AF_ERR_INVALID_NIXBLK;



	vlan = &nix_hw->txvlan;

	if (req->tx.cfg_vtag0) {

		rsp->vtag0_idx =

			nix_tx_vtag_alloc(rvu, blkaddr,
@@ -3142,7 +3159,7 @@ static int reserve_flowkey_alg_idx(struct rvu *rvu, int blkaddr, u32 flow_cfg) 


	hw = get_nix_hw(rvu->hw, blkaddr);

	if (!hw)

		return -EINVAL;

		return NIX_AF_ERR_INVALID_NIXBLK;



	/* No room to add new flow hash algoritham */

	if (hw->flowkey.in_use >= NIX_FLOW_KEY_ALG_MAX)
@@ -3182,7 +3199,7 @@ int rvu_mbox_handler_nix_rss_flowkey_cfg(struct rvu *rvu, 


	nix_hw = get_nix_hw(rvu->hw, blkaddr);

	if (!nix_hw)

		return -EINVAL;

		return NIX_AF_ERR_INVALID_NIXBLK;



	alg_idx = get_flowkey_alg_idx(nix_hw, req->flowkey_cfg);

	/* Failed to get algo index from the exiting list, reserve new  */
@@ -3459,7 +3476,7 @@ int rvu_mbox_handler_nix_set_hw_frs(struct rvu *rvu, struct nix_frs_cfg *req, 


	nix_hw = get_nix_hw(rvu->hw, blkaddr);

	if (!nix_hw)

		return -EINVAL;

		return NIX_AF_ERR_INVALID_NIXBLK;



	if (is_afvf(pcifunc))

		rvu_get_lbk_link_max_frs(rvu, &max_mtu);
@@ -4126,7 +4143,7 @@ int rvu_mbox_handler_nix_lso_format_cfg(struct rvu *rvu, 


	nix_hw = get_nix_hw(rvu->hw, blkaddr);

	if (!nix_hw)

		return -EINVAL;

		return NIX_AF_ERR_INVALID_NIXBLK;



	/* Find existing matching LSO format, if any */

	for (idx = 0; idx < nix_hw->lso.in_use; idx++) {