[ceph.git] / ceph / src / spdk / dpdk / drivers / net / bnxt / bnxt_filter.c

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright(c) 2014-2018 Broadcom
 * All rights reserved.
 */

#include <sys/queue.h>

#include <rte_byteorder.h>
#include <rte_log.h>
#include <rte_malloc.h>
#include <rte_flow.h>
#include <rte_flow_driver.h>
#include <rte_tailq.h>

#include "bnxt.h"
#include "bnxt_filter.h"
#include "bnxt_hwrm.h"
#include "bnxt_vnic.h"
#include "hsi_struct_def_dpdk.h"

/*
 * Filter Functions
 */

struct bnxt_filter_info *bnxt_alloc_filter(struct bnxt *bp)
{
	struct bnxt_filter_info *filter;

	/* Find the 1st unused filter from the free_filter_list pool*/
	filter = STAILQ_FIRST(&bp->free_filter_list);
	if (!filter) {
		PMD_DRV_LOG(ERR, "No more free filter resources\n");
		return NULL;
	}
	STAILQ_REMOVE_HEAD(&bp->free_filter_list, next);

	/* Default to L2 MAC Addr filter */
	filter->flags = HWRM_CFA_L2_FILTER_ALLOC_INPUT_FLAGS_PATH_RX;
	filter->enables = HWRM_CFA_L2_FILTER_ALLOC_INPUT_ENABLES_L2_ADDR |
			HWRM_CFA_L2_FILTER_ALLOC_INPUT_ENABLES_L2_ADDR_MASK;
	memcpy(filter->l2_addr, bp->eth_dev->data->mac_addrs->addr_bytes,
	       ETHER_ADDR_LEN);
	memset(filter->l2_addr_mask, 0xff, ETHER_ADDR_LEN);
	return filter;
}

struct bnxt_filter_info *bnxt_alloc_vf_filter(struct bnxt *bp, uint16_t vf)
{
	struct bnxt_filter_info *filter;

	filter = rte_zmalloc("bnxt_vf_filter_info", sizeof(*filter), 0);
	if (!filter) {
		PMD_DRV_LOG(ERR, "Failed to alloc memory for VF %hu filters\n",
			vf);
		return NULL;
	}

	filter->fw_l2_filter_id = UINT64_MAX;
	STAILQ_INSERT_TAIL(&bp->pf.vf_info[vf].filter, filter, next);
	return filter;
}

void bnxt_init_filters(struct bnxt *bp)
{
	struct bnxt_filter_info *filter;
	int i, max_filters;

	max_filters = bp->max_l2_ctx;
	STAILQ_INIT(&bp->free_filter_list);
	for (i = 0; i < max_filters; i++) {
		filter = &bp->filter_info[i];
		filter->fw_l2_filter_id = UINT64_MAX;
		filter->fw_em_filter_id = UINT64_MAX;
		filter->fw_ntuple_filter_id = UINT64_MAX;
		STAILQ_INSERT_TAIL(&bp->free_filter_list, filter, next);
	}
}

void bnxt_free_all_filters(struct bnxt *bp)
{
	struct bnxt_vnic_info *vnic;
	struct bnxt_filter_info *filter, *temp_filter;
	unsigned int i;

//	for (i = 0; i < MAX_FF_POOLS; i++) {
	for (i = 0; i < bp->nr_vnics; i++) {
		vnic = &bp->vnic_info[i];
		filter = STAILQ_FIRST(&vnic->filter);
		while (filter) {
			temp_filter = STAILQ_NEXT(filter, next);
			STAILQ_REMOVE(&vnic->filter, filter,
					bnxt_filter_info, next);
			STAILQ_INSERT_TAIL(&bp->free_filter_list,
					filter, next);
			filter = temp_filter;
		}
		STAILQ_INIT(&vnic->filter);
	}

	for (i = 0; i < bp->pf.max_vfs; i++) {
		STAILQ_FOREACH(filter, &bp->pf.vf_info[i].filter, next) {
			bnxt_hwrm_clear_l2_filter(bp, filter);
		}
	}
}

void bnxt_free_filter_mem(struct bnxt *bp)
{
	struct bnxt_filter_info *filter;
	uint16_t max_filters, i;
	int rc = 0;

	if (bp->filter_info == NULL)
		return;

	/* Ensure that all filters are freed */
	max_filters = bp->max_l2_ctx;
	for (i = 0; i < max_filters; i++) {
		filter = &bp->filter_info[i];
		if (filter->fw_l2_filter_id != ((uint64_t)-1) &&
		    filter->filter_type == HWRM_CFA_L2_FILTER) {
			PMD_DRV_LOG(ERR, "L2 filter is not free\n");
			/* Call HWRM to try to free filter again */
			rc = bnxt_hwrm_clear_l2_filter(bp, filter);
			if (rc)
				PMD_DRV_LOG(ERR,
					    "Cannot free L2 filter: %d\n",
					    rc);
		}
		filter->fw_l2_filter_id = UINT64_MAX;

		if (filter->fw_ntuple_filter_id != ((uint64_t)-1) &&
		    filter->filter_type == HWRM_CFA_NTUPLE_FILTER) {
			PMD_DRV_LOG(ERR, "NTUPLE filter is not free\n");
			/* Call HWRM to try to free filter again */
			rc = bnxt_hwrm_clear_ntuple_filter(bp, filter);
			if (rc)
				PMD_DRV_LOG(ERR,
					    "Cannot free NTUPLE filter: %d\n",
					    rc);
		}
		filter->fw_ntuple_filter_id = UINT64_MAX;
	}
	STAILQ_INIT(&bp->free_filter_list);

	rte_free(bp->filter_info);
	bp->filter_info = NULL;

	for (i = 0; i < bp->pf.max_vfs; i++) {
		STAILQ_FOREACH(filter, &bp->pf.vf_info[i].filter, next) {
			rte_free(filter);
			STAILQ_REMOVE(&bp->pf.vf_info[i].filter, filter,
				      bnxt_filter_info, next);
		}
	}
}

int bnxt_alloc_filter_mem(struct bnxt *bp)
{
	struct bnxt_filter_info *filter_mem;
	uint16_t max_filters;

	max_filters = bp->max_l2_ctx;
	/* Allocate memory for VNIC pool and filter pool */
	filter_mem = rte_zmalloc("bnxt_filter_info",
				 max_filters * sizeof(struct bnxt_filter_info),
				 0);
	if (filter_mem == NULL) {
		PMD_DRV_LOG(ERR, "Failed to alloc memory for %d filters",
			max_filters);
		return -ENOMEM;
	}
	bp->filter_info = filter_mem;
	return 0;
}

struct bnxt_filter_info *bnxt_get_unused_filter(struct bnxt *bp)
{
	struct bnxt_filter_info *filter;

	/* Find the 1st unused filter from the free_filter_list pool*/
	filter = STAILQ_FIRST(&bp->free_filter_list);
	if (!filter) {
		PMD_DRV_LOG(ERR, "No more free filter resources\n");
		return NULL;
	}
	STAILQ_REMOVE_HEAD(&bp->free_filter_list, next);

	return filter;
}

void bnxt_free_filter(struct bnxt *bp, struct bnxt_filter_info *filter)
{
	STAILQ_INSERT_TAIL(&bp->free_filter_list, filter, next);
}
Commit	Line	Data
11fdf7f2 TL	1	/* SPDX-License-Identifier: BSD-3-Clause
	2	* Copyright(c) 2014-2018 Broadcom
	3	* All rights reserved.
	4	*/
	5
	6	#include <sys/queue.h>
	7
	8	#include <rte_byteorder.h>
	9	#include <rte_log.h>
	10	#include <rte_malloc.h>
	11	#include <rte_flow.h>
	12	#include <rte_flow_driver.h>
	13	#include <rte_tailq.h>
	14
	15	#include "bnxt.h"
	16	#include "bnxt_filter.h"
	17	#include "bnxt_hwrm.h"
	18	#include "bnxt_vnic.h"
	19	#include "hsi_struct_def_dpdk.h"
	20
	21	/*
	22	* Filter Functions
	23	*/
	24
	25	struct bnxt_filter_info bnxt_alloc_filter(struct bnxt bp)
	26	{
	27	struct bnxt_filter_info *filter;
	28
	29	/* Find the 1st unused filter from the free_filter_list pool*/
	30	filter = STAILQ_FIRST(&bp->free_filter_list);
	31	if (!filter) {
	32	PMD_DRV_LOG(ERR, "No more free filter resources\n");
	33	return NULL;
	34	}
	35	STAILQ_REMOVE_HEAD(&bp->free_filter_list, next);
	36
	37	/* Default to L2 MAC Addr filter */
	38	filter->flags = HWRM_CFA_L2_FILTER_ALLOC_INPUT_FLAGS_PATH_RX;
	39	filter->enables = HWRM_CFA_L2_FILTER_ALLOC_INPUT_ENABLES_L2_ADDR \|
	40	HWRM_CFA_L2_FILTER_ALLOC_INPUT_ENABLES_L2_ADDR_MASK;
	41	memcpy(filter->l2_addr, bp->eth_dev->data->mac_addrs->addr_bytes,
	42	ETHER_ADDR_LEN);
	43	memset(filter->l2_addr_mask, 0xff, ETHER_ADDR_LEN);
	44	return filter;
	45	}
	46
	47	struct bnxt_filter_info bnxt_alloc_vf_filter(struct bnxt bp, uint16_t vf)
	48	{
	49	struct bnxt_filter_info *filter;
	50
	51	filter = rte_zmalloc("bnxt_vf_filter_info", sizeof(*filter), 0);
	52	if (!filter) {
	53	PMD_DRV_LOG(ERR, "Failed to alloc memory for VF %hu filters\n",
	54	vf);
	55	return NULL;
	56	}
	57
	58	filter->fw_l2_filter_id = UINT64_MAX;
	59	STAILQ_INSERT_TAIL(&bp->pf.vf_info[vf].filter, filter, next);
	60	return filter;
	61	}
	62
	63	void bnxt_init_filters(struct bnxt *bp)
	64	{
65	struct bnxt_filter_info *filter;
66	int i, max_filters;
67
68	max_filters = bp->max_l2_ctx;
69	STAILQ_INIT(&bp->free_filter_list);
70	for (i = 0; i < max_filters; i++) {
71	filter = &bp->filter_info[i];
72	filter->fw_l2_filter_id = UINT64_MAX;
73	filter->fw_em_filter_id = UINT64_MAX;
74	filter->fw_ntuple_filter_id = UINT64_MAX;
75	STAILQ_INSERT_TAIL(&bp->free_filter_list, filter, next);
76	}
77	}
78
79	void bnxt_free_all_filters(struct bnxt *bp)
80	{
81	struct bnxt_vnic_info *vnic;
82	struct bnxt_filter_info filter, temp_filter;
9f95a23c TL	83	unsigned int i;
	84
	85	// for (i = 0; i < MAX_FF_POOLS; i++) {
	86	for (i = 0; i < bp->nr_vnics; i++) {
	87	vnic = &bp->vnic_info[i];
	88	filter = STAILQ_FIRST(&vnic->filter);
	89	while (filter) {
	90	temp_filter = STAILQ_NEXT(filter, next);
	91	STAILQ_REMOVE(&vnic->filter, filter,
	92	bnxt_filter_info, next);
	93	STAILQ_INSERT_TAIL(&bp->free_filter_list,
	94	filter, next);
	95	filter = temp_filter;
11fdf7f2	96	}
9f95a23c	97	STAILQ_INIT(&vnic->filter);
11fdf7f2 TL	98	}
	99
	100	for (i = 0; i < bp->pf.max_vfs; i++) {
	101	STAILQ_FOREACH(filter, &bp->pf.vf_info[i].filter, next) {
	102	bnxt_hwrm_clear_l2_filter(bp, filter);
	103	}
	104	}
	105	}
	106
	107	void bnxt_free_filter_mem(struct bnxt *bp)
	108	{
	109	struct bnxt_filter_info *filter;
	110	uint16_t max_filters, i;
	111	int rc = 0;
	112
	113	if (bp->filter_info == NULL)
	114	return;
	115
	116	/* Ensure that all filters are freed */
	117	max_filters = bp->max_l2_ctx;
	118	for (i = 0; i < max_filters; i++) {
	119	filter = &bp->filter_info[i];
	120	if (filter->fw_l2_filter_id != ((uint64_t)-1) &&
	121	filter->filter_type == HWRM_CFA_L2_FILTER) {
	122	PMD_DRV_LOG(ERR, "L2 filter is not free\n");
	123	/* Call HWRM to try to free filter again */
	124	rc = bnxt_hwrm_clear_l2_filter(bp, filter);
	125	if (rc)
	126	PMD_DRV_LOG(ERR,
	127	"Cannot free L2 filter: %d\n",
	128	rc);
	129	}
	130	filter->fw_l2_filter_id = UINT64_MAX;
	131
	132	if (filter->fw_ntuple_filter_id != ((uint64_t)-1) &&
	133	filter->filter_type == HWRM_CFA_NTUPLE_FILTER) {
	134	PMD_DRV_LOG(ERR, "NTUPLE filter is not free\n");
	135	/* Call HWRM to try to free filter again */
	136	rc = bnxt_hwrm_clear_ntuple_filter(bp, filter);
	137	if (rc)
	138	PMD_DRV_LOG(ERR,
	139	"Cannot free NTUPLE filter: %d\n",
	140	rc);
	141	}
	142	filter->fw_ntuple_filter_id = UINT64_MAX;
	143	}
	144	STAILQ_INIT(&bp->free_filter_list);
	145
	146	rte_free(bp->filter_info);
	147	bp->filter_info = NULL;
	148
	149	for (i = 0; i < bp->pf.max_vfs; i++) {
	150	STAILQ_FOREACH(filter, &bp->pf.vf_info[i].filter, next) {
	151	rte_free(filter);
	152	STAILQ_REMOVE(&bp->pf.vf_info[i].filter, filter,
	153	bnxt_filter_info, next);
	154	}
	155	}
	156	}
	157
	158	int bnxt_alloc_filter_mem(struct bnxt *bp)
	159	{
	160	struct bnxt_filter_info *filter_mem;
	161	uint16_t max_filters;
162
163	max_filters = bp->max_l2_ctx;
164	/* Allocate memory for VNIC pool and filter pool */
165	filter_mem = rte_zmalloc("bnxt_filter_info",
166	max_filters * sizeof(struct bnxt_filter_info),
167	0);
168	if (filter_mem == NULL) {
169	PMD_DRV_LOG(ERR, "Failed to alloc memory for %d filters",
170	max_filters);
171	return -ENOMEM;
172	}
173	bp->filter_info = filter_mem;
174	return 0;
175	}
176
177	struct bnxt_filter_info bnxt_get_unused_filter(struct bnxt bp)
178	{
179	struct bnxt_filter_info *filter;
180
181	/* Find the 1st unused filter from the free_filter_list pool*/
182	filter = STAILQ_FIRST(&bp->free_filter_list);
183	if (!filter) {
184	PMD_DRV_LOG(ERR, "No more free filter resources\n");
185	return NULL;
186	}
187	STAILQ_REMOVE_HEAD(&bp->free_filter_list, next);
188
189	return filter;
190	}
191
192	void bnxt_free_filter(struct bnxt bp, struct bnxt_filter_info filter)
193	{
194	STAILQ_INSERT_TAIL(&bp->free_filter_list, filter, next);
195	}