path: root/platform/linux-keystone2/odp_classification.c

/* Copyright (c) 2014, Linaro Limited
 * Copyright (c) 2015, Texas Instruments Incorporated
 * All rights reserved.
 *
 * SPDX-License-Identifier:     BSD-3-Clause
 */

#include <odp/classification.h>
#include <odp/queue.h>
#include <odp/byteorder.h>
#include <odp/pool.h>
#include <odp/packet_io.h>
#include <odp/spinlock.h>

#include <odp/plat/debug.h>
#include <odp/plat/shared_resource.h>

#include <odp_internal.h>
#include <ccan/list/list.h>

#include "pa_lut_entry.h"
#include "cppi_flow.h"
#include "odp_packet_io_internal.h"
#include "odp_cls_internal.h"
#include "odp_pool_internal.h"
#include "odp_queue_internal.h"

#define ODP_CONFIG_COS_ENTRIES		 16
#define ODP_CONFIG_PMR_ENTRIES		128
#define ODP_CONFIG_PMRSET_ENTRIES	 64
#define ODP_CONFIG_PMRS_IN_PMRSET	  5
#define ODP_CONFIG_PMR_LINK_ENTRIES	128

#define ODP_CONFIG_MAX_TERM_SIZE	 16

static const char odp_cos_table_name[] = "odp_cos_entries";
static const char pmr_table_name[] = "pmr_entries";

enum term_layer {
	L2_TERM = 0,
	L3_TERM,
	L4_TERM,
};
struct term_params_s {
	uint8_t lenght;
	enum term_layer layer;
};

static struct term_params_s pmr_term_params[] = {
		[ODP_PMR_ETHTYPE_0] = { .lenght = 2, .layer = L2_TERM},
		[ODP_PMR_VLAN_ID_0] = { .lenght = 2, .layer = L2_TERM},
		[ODP_PMR_DMAC]      = { .lenght = 6, .layer = L2_TERM},
		[ODP_PMR_IPPROTO]   = { .lenght = 1, .layer = L3_TERM},
		[ODP_PMR_SIP_ADDR]  = { .lenght = 4, .layer = L3_TERM},
		[ODP_PMR_DIP_ADDR]  = { .lenght = 4, .layer = L3_TERM},
		[ODP_PMR_SIP6_ADDR] = { .lenght = 16, .layer = L3_TERM},
		[ODP_PMR_DIP6_ADDR] = { .lenght = 16, .layer = L3_TERM},
		[ODP_PMR_IPSEC_SPI] = { .lenght = 4, .layer = L3_TERM},
		[ODP_PMR_UDP_DPORT] = { .lenght = 2, .layer = L4_TERM},
		[ODP_PMR_TCP_DPORT] = { .lenght = 2, .layer = L4_TERM},
};

typedef uint8_t cos_id_t;

typedef struct cos_entry_s {
	odp_queue_t queue;		/* Associated Queue */
	odp_pool_t  pool;		/* Associated Buffer pool */
	size_t headroom;		/* Headroom for this CoS */
	shres_head_t entry_head;
	struct list_head pmr_out;
	struct list_head pmr_in;
	uint8_t pmr_out_cnt;
	uint8_t pmr_in_cnt;
	paLnkHandle_t l2_vlink;
	paLnkHandle_t l3_vlink;
	cppi_flow_entry_t *cppi_flow;
	pa_entry_t *pa_out_entry;
	char name[ODP_COS_NAME_LEN];	/* name */
	union {
		struct {
			uint8_t l2:1;
			uint8_t l3:1;
			uint8_t l4:1;
		};
		uint8_t all;
	} pmr_layers;
	struct {
		uint8_t activated:1;
	} flags;
} cos_entry_t;

typedef struct term_vals_s {
	odp_pmr_term_e term;
	union {
		uint8_t val[16];
		uint32_t val_int32;
		uint64_t val_int64[2];
	};
	uint8_t mask[16];
} term_vals_t;

typedef struct pmr_s {
	int term_num;
	term_vals_t terms[ODP_CONFIG_PMRS_IN_PMRSET];
	shres_head_t entry_head;

	/* CoS links */
	struct list_node src_cos_node;
	struct list_node dst_cos_node;
	struct list_node affected_node;
	cos_entry_t *src_cos, *dst_cos; /* redundant ? */
	pa_entry_t *pa_entry;

	odp_pktio_t pktio;
	enum term_layer layer;
	struct {
		uint8_t activated:1;
		uint8_t default_pmr:1;
	} flags;
} pmr_entry_t;

static shres_table_t *cos_tbl;
static shres_table_t *pmr_tbl;

static paRouteInfo2_t route_lut1_continue ODP_UNUSED = {
		.dest = pa_DEST_CONTINUE_PARSE_LUT1,
		.customType = pa_CUSTOM_TYPE_NONE,
};
static paRouteInfo2_t route_lut2_continue ODP_UNUSED = {
		.dest = pa_DEST_CONTINUE_PARSE_LUT2,
		.customType = pa_CUSTOM_TYPE_NONE,
};
static paRouteInfo2_t route_discard ODP_UNUSED = {
		.dest = pa_DEST_DISCARD,
};

static int cos_activate(cos_entry_t *entry);
static int cos_deactivate(cos_entry_t *entry);
static int pmr_activate(pmr_entry_t *pmr);
static int pmr_deactivate(pmr_entry_t *pmr);
static int cos_tree_activate(cos_entry_t *entry);
static int cos_tree_deactivate(cos_entry_t *entry);
static odp_pktio_t cos_get_pktio(cos_entry_t *entry, int deact);
static odp_pktio_t _cos_get_pktio(cos_entry_t *entry, int deact);

/**
 * Lock for classification tree update. Updates should not be frequent, so
 * global lock should be fine for now.
 *
 * @todo: implement more granular locking */
static odp_spinlock_t classification_lock;
static int tree_deep;
static int act_tree_deep = 0;

static inline void cls_tree_lock(void)
{
	odp_spinlock_lock(&classification_lock);
}

static inline void cls_tree_unlock(void)
{
	odp_spinlock_unlock(&classification_lock);
}

static inline cos_entry_t *_odp_cos_entry(odp_cos_t cos)
{
	return (cos_entry_t *)(void *)cos;
}

static inline odp_cos_t _odp_cos_from_entry(cos_entry_t *entry)
{
	return (odp_cos_t)entry;
}

static inline pmr_entry_t *_odp_pmr_entry(odp_pmr_t pmr)
{
	return (pmr_entry_t *)(void *)pmr;
}

static inline odp_pmr_t _odp_pmr_from_entry(pmr_entry_t *entry)
{
	return (odp_pmr_t)entry;
}

static inline pmr_entry_t *_odp_pmr_set_entry(odp_pmr_set_t pmr_set)
{
	return (pmr_entry_t *)(void *)pmr_set;
}

static inline odp_pmr_set_t _odp_pmr_set_from_entry(pmr_entry_t *entry)
{
	return (odp_pmr_set_t)entry;
}

static inline void cos_add_pmr_in(cos_entry_t *cos, pmr_entry_t *pmr)
{
	list_add(&cos->pmr_in, &pmr->dst_cos_node);
	cos->pmr_in_cnt++;
}

static inline void cos_rm_pmr_in(cos_entry_t *cos, pmr_entry_t *pmr)
{
	list_del_from(&cos->pmr_in, &pmr->dst_cos_node);
	cos->pmr_in_cnt--;
}

static inline void cos_add_pmr_out(cos_entry_t *cos, pmr_entry_t *pmr)
{
	list_add(&cos->pmr_out,  &pmr->src_cos_node);
	cos->pmr_out_cnt++;
}

static inline void cos_rm_pmr_out(cos_entry_t *cos, pmr_entry_t *pmr)
{
	list_del_from(&cos->pmr_out,  &pmr->src_cos_node);
	cos->pmr_out_cnt--;
}

static inline int __odp_pmr_destroy(pmr_entry_t *entry)
{
	return shres_free(pmr_tbl, entry);
}

static void pmr_disconnect_source(pmr_entry_t *entry)
{
	if (entry->src_cos) {
		cos_rm_pmr_out(entry->src_cos, entry);
		entry->src_cos = NULL;
	} else if (entry->pktio != ODP_PKTIO_INVALID) {
		_pktio_rm_pmr_out(entry->pktio, &entry->src_cos_node);
		entry->pktio = ODP_PKTIO_INVALID;
	}
}

static void pmr_disconnect(pmr_entry_t *entry)
{
	if (entry->dst_cos) {
		cos_rm_pmr_in(entry->dst_cos, entry);
		entry->dst_cos = NULL;
	}

	pmr_disconnect_source(entry);
}

static int cos_free_cb(void *data)
{
	pmr_entry_t *pmr, *npmr;
	cos_entry_t *entry = data;

	act_tree_deep = 0;
	if (cos_tree_deactivate(entry) < 0)
		return -1;

	/* remove CoS and disconnect it's PMRs from the tree */
	list_for_each_safe(&entry->pmr_in, pmr, npmr, dst_cos_node) {
		if (pmr->flags.default_pmr) {
			/* delete dummy default PMRs for default CoS */
			if (pmr->pktio != ODP_PKTIO_INVALID)
				_pktio_rm_pmr_default(pmr->pktio);
			else
				__odp_pmr_destroy(pmr);
		} else {
			pmr_disconnect(pmr);
		}
	}

	list_for_each_safe(&entry->pmr_out, pmr, npmr, src_cos_node)
		pmr_disconnect(pmr);

	if (entry->pool != ODP_POOL_INVALID)
		_odp_pool_put(entry->pool);

	if (entry->queue != ODP_QUEUE_INVALID)
		_queue_put(entry->queue);

	ODP_DBG("CoS \"%s\" destroyed\n", entry->name);
	return 0;
}

/*
 * For now we suppose that PMR is only one entry and
 * cannot be reused in several trees
 */
static int pmr_free_cb(void *data)
{
	int ret = 0;
	pmr_entry_t *pmr_in;
	pmr_entry_t *entry = data;
	int cos_deactivate = 1;

	/* deactivate */
	if (entry->flags.activated) {
		list_for_each(&entry->dst_cos->pmr_in, pmr_in, dst_cos_node) {
			if (entry != pmr_in && pmr_in->flags.activated) {
				cos_deactivate = 0;
				break;
			}
		}

		if (cos_deactivate) {
			/* here PMR also will be deactivated */
			act_tree_deep = 0;
			ret = cos_tree_deactivate(entry->dst_cos);
		} else {
			ret = pmr_deactivate(entry);
		}
	}

	if (ODP_DEBUG_PRINT == 1 && !ret) {
		if ((entry->src_cos || entry->pktio != ODP_PKTIO_INVALID) &&
		    entry->dst_cos)
			ODP_DBG("\"%s\" - PMR - \"%s\" destroyed\n",
				entry->pktio ? _pktio_name(entry->pktio) :
				entry->src_cos->name, entry->dst_cos->name);
		else
			ODP_DBG("PMR destroyed\n");
	}

	/* disconnect from the tree */
	entry->flags.default_pmr = 0;
	pmr_disconnect(entry);

	return ret;
}

int odp_classification_init_global(void)
{
	cos_tbl = shres_table_create(odp_cos_table_name,
				     cos_entry_t,
				     ODP_CONFIG_COS_ENTRIES,
				     cos_free_cb);
	if (cos_tbl == SHRES_TABLE_INVALID)
		return -1;

	pmr_tbl = shres_table_create(pmr_table_name, pmr_entry_t,
				     ODP_CONFIG_PMR_ENTRIES +
				     ODP_CONFIG_PMRSET_ENTRIES, pmr_free_cb);
	if (pmr_tbl == SHRES_TABLE_INVALID)
		return -1;

	odp_spinlock_init(&classification_lock);

	return 0;
}

int odp_classification_term_global(void)
{
	int num;
	int ret = 0;

	num = shres_table_destroy(odp_cos_table_name);
	if (num < 0)
		ret = -1;

	num = shres_table_destroy(pmr_table_name);
	if (num < 0)
		ret = -1;

	return ret;
}

unsigned long long odp_pmr_terms_cap(void)
{
	unsigned long long term_cap = 0;

	term_cap |= (1 << ODP_PMR_ETHTYPE_0);
	term_cap |= (1 << ODP_PMR_VLAN_ID_0);
	term_cap |= (1 << ODP_PMR_DMAC);
	term_cap |= (1 << ODP_PMR_IPPROTO);
	term_cap |= (1 << ODP_PMR_UDP_DPORT);
	term_cap |= (1 << ODP_PMR_TCP_DPORT);
	term_cap |= (1 << ODP_PMR_SIP_ADDR);
	term_cap |= (1 << ODP_PMR_DIP_ADDR);
	term_cap |= (1 << ODP_PMR_SIP6_ADDR);
	term_cap |= (1 << ODP_PMR_DIP6_ADDR);
	term_cap |= (1 << ODP_PMR_IPSEC_SPI);
	return term_cap;
}

unsigned odp_pmr_terms_avail(void)
{
	uint32_t entries =  shres_table_num_entries(pmr_tbl);
	uint32_t entries_alloc =  shres_table_num_entries_allocated(pmr_tbl);
	ODP_AS_STR(entries >= entries_alloc, "entries >= entries_alloc");
	return entries - entries_alloc;
}

int _pmr_hard_update(odp_pmr_t pmr)
{
	pmr_entry_t *entry = _odp_pmr_entry(pmr);

	if (pmr_deactivate(entry) < 0)
		return -1;
	return pmr_activate(entry);
}

static inline int __odp_cos_set_pool(odp_cos_t cos, odp_pool_t pool)
{
	if (cos == ODP_COS_INVALID || pool == ODP_POOL_INVALID) {
		cls_tree_unlock();
		ODP_ERR("Invalid input parameters\n");
		return -1;
	}

	cos_entry_t *entry = _odp_cos_entry(cos);

	if (entry->flags.activated) {
		cls_tree_unlock();
		ODP_ERR("Modifying attached CoS is not supported yet\n");
		return -1;
	}

	if (_odp_pool_get(pool) < 0) {
		cls_tree_unlock();
		ODP_ERR("Pool is not allocated\n");
		return -1;
	}

	entry->pool = pool;
	return 0;
}

int odp_cls_cos_pool_set(odp_cos_t cos, odp_pool_t pool)
{
	int ret;

	cls_tree_lock();
	ret = __odp_cos_set_pool(cos, pool);
	cls_tree_unlock();

	return ret;
}

odp_pool_t odp_cls_cos_pool(odp_cos_t cos)
{
	odp_pool_t pool;
	cos_entry_t *entry = _odp_cos_entry(cos);

	entry = _odp_cos_entry(cos);

	shres_lock(entry);
	pool = entry->pool;
	shres_unlock(entry);

	return pool;
}

static inline int __odp_cos_queue_set(odp_cos_t cos, odp_queue_t queue)
{
	if (cos == ODP_COS_INVALID || queue == ODP_QUEUE_INVALID) {
		cls_tree_unlock();
		ODP_ERR("Invalid input parameters\n");
		return -1;
	}

	cos_entry_t *entry = _odp_cos_entry(cos);

	if (entry->flags.activated) {
		cls_tree_unlock();
		ODP_ERR("Modifying active CoS is not supported yet\n");
		return -1;
	}

	if (_queue_get(queue) < 0) {
		cls_tree_unlock();
		ODP_ERR("Queue is not allocated\n");
		return -1;
	}

	entry->queue = queue;
	return 0;
}

int odp_cos_queue_set(odp_cos_t cos, odp_queue_t queue)
{
	int ret;

	cls_tree_lock();
	ret = __odp_cos_queue_set(cos, queue);
	cls_tree_unlock();

	return ret;
}

odp_queue_t odp_cos_queue(odp_cos_t cos)
{
	odp_queue_t queue;
	cos_entry_t *entry = _odp_cos_entry(cos);

	entry = _odp_cos_entry(cos);

	shres_lock(entry);
	queue = entry->queue;
	shres_unlock(entry);

	return queue;
}

void odp_cls_cos_param_init(odp_cls_cos_param_t *param)
{
	param->queue = ODP_QUEUE_INVALID;
	param->pool = ODP_POOL_INVALID;
	param->drop_policy = ODP_COS_DROP_NEVER;
}

odp_cos_t odp_cls_cos_create(const char *name,
			     odp_cls_cos_param_t *param)
{
	odp_cos_t cos;
	cos_entry_t *entry;

	entry = shres_alloc(cos_tbl, typeof(*entry));
	if (!entry) {
		ODP_ERR("Couldn't allocate CoS\n");
		return ODP_COS_INVALID;
	}

	strncpy(entry->name, name, ODP_COS_NAME_LEN - 1);
	entry->name[ODP_COS_NAME_LEN - 1] = 0;
	entry->queue = ODP_QUEUE_INVALID;
	entry->pool = ODP_POOL_INVALID;
	entry->cppi_flow = NULL;
	entry->headroom = ODP_CONFIG_PACKET_HEADROOM;
	list_head_init(&entry->pmr_in);
	list_head_init(&entry->pmr_out);
	entry->pmr_in_cnt = 0;
	entry->pmr_out_cnt = 0;
	entry->l2_vlink = NULL;
	entry->l3_vlink = NULL;
	entry->pmr_layers.all = 0;
	entry->flags.activated = 0;
	ODP_DBG("CoS \"%s\" created\n", entry->name);

	cos = _odp_cos_from_entry(entry);
	if (param->pool != ODP_POOL_INVALID &&
	    __odp_cos_set_pool(cos, param->pool))
		goto err;
	if (param->queue != ODP_QUEUE_INVALID &&
	    __odp_cos_queue_set(cos, param->queue))
		goto err;

	if (odp_cos_drop_set(cos, param->drop_policy))
		goto err;

	return _odp_cos_from_entry(entry);

err:
	shres_free(cos_tbl, _odp_cos_entry(cos));
	return ODP_COS_INVALID;
}

int odp_cos_destroy(odp_cos_t cos)
{
	int ret;

	cls_tree_lock();
	if (cos == ODP_COS_INVALID) {
		cls_tree_unlock();
		ODP_ERR("Invalid input parameters\n");
		return -1;
	}

	ret = shres_free(cos_tbl, _odp_cos_entry(cos));
	cls_tree_unlock();
	return ret;
}

int odp_cos_drop_set(odp_cos_t cos_id ODP_UNUSED, odp_cls_drop_t drop_policy)
{
	if (drop_policy == ODP_COS_DROP_NEVER)
		return 0;

	if (drop_policy == ODP_COS_DROP_POOL)
		return 0;

	ODP_UNIMPLEMENTED();
	return -1;
}

int odp_cos_with_l2_priority(odp_pktio_t pktio_in ODP_UNUSED,
			     uint8_t num_qos ODP_UNUSED,
			     uint8_t qos_table[] ODP_UNUSED,
			     odp_cos_t cos_table[] ODP_UNUSED)
{
	ODP_UNIMPLEMENTED();
	return -1;
}

int odp_cos_with_l3_qos(odp_pktio_t pktio_in ODP_UNUSED,
			uint32_t num_qos ODP_UNUSED,
			uint8_t qos_table[] ODP_UNUSED,
			odp_cos_t cos_table[] ODP_UNUSED,
			odp_bool_t l3_preference ODP_UNUSED)
{
	ODP_UNIMPLEMENTED();
	return -1;
}

static int pmr_term_validate(odp_pmr_term_e term, uint32_t val_sz)
{
	unsigned long long cap = odp_pmr_terms_cap();

	if (!(cap & (1 << term))) {
		ODP_ERR("Unsupported term: %d\n", term);
		return -1;
	}

	if (pmr_term_params[term].lenght != val_sz) {
		ODP_ERR("Wrong term size: %u\n", val_sz);
		return -1;
	}

	return 0;
}

static int pmr_check_layer_overlap(pmr_entry_t *entry)
{
	uint32_t pmr_word = 0;
	odp_pmr_term_e term;
	pmr_entry_t *pmr;

	/* read PMR internal terms */
	for (int i = 0; i < entry->term_num; i++)
		pmr_word |= (1 << entry->terms[i].term);

	/* check source PMR overlap */
	if (entry->src_cos &&
	    entry->src_cos->pmr_layers.all & (1 << entry->layer)) {
		if (entry->src_cos->pmr_in_cnt > 1) {
			ODP_ERR("Cannot cascade from CoS with multiple input PMRs one of them the same layer, CoS = %s\n",
				entry->src_cos->name);
			return -1;
		}

		/* check if not overlap with src PMR */
		pmr = list_top(&entry->src_cos->pmr_in,
			       typeof(*pmr), dst_cos_node);
		for (int i = 0; i < pmr->term_num; i++) {
			term = pmr->terms[i].term;
			if (pmr_word & (1 << term)) {
				ODP_ERR("Cannot cascade from CoS with the same input PMR, CoS = %s\n",
					entry->src_cos->name);
				return -1;
			}

			pmr_word |= (1 << term);
		}
	}

	/* check potential destination PMRs overlap */
	int dst_host_has_out_layer = 0;
	list_for_each(&entry->dst_cos->pmr_out, pmr, src_cos_node) {
		if (pmr->layer != entry->layer)
			continue;

		dst_host_has_out_layer = 1;
		for (int i = 0; i < pmr->term_num; i++) {
			if (!(pmr_word & (1 << pmr->terms[i].term)))
				continue;

			ODP_ERR("Cannot cascade to CoS with the same output PMRs, CoS = %s\n",
				entry->dst_cos->name);
			return -1;
		}
	}

	if (dst_host_has_out_layer && entry->dst_cos->pmr_in_cnt > 1) {
		ODP_ERR("Cannot cascade to CoS with the same layer output PMRs and multiple inputs, CoS = %s\n",
			entry->dst_cos->name);
		return -1;
	}

	return 0;
}

static int pmr_l2_connection_validate(pmr_entry_t *entry)
{
	if (entry->src_cos) {
		if (entry->src_cos->pmr_in_cnt > 1) {
			ODP_ERR("Can't create L2 PMR from source CoS with multiple input PMRs yet\n");
			return -1;
		}

		if (entry->src_cos->pmr_layers.l3 ||
		    entry->src_cos->pmr_layers.l4) {
			ODP_ERR("L2 PMR can be cascaded to L2 PMR only, CoS = %s\n",
				entry->src_cos);
			return -1;
		}
	} else if (entry->pktio != ODP_PKTIO_INVALID) {
		if (_pktio_pmr_out_cnt(entry->pktio) > 1 &&
		    entry->flags.default_pmr) {
			ODP_ERR("default CoS has to be connected first!\n");
			return -1;
		}
	} else {
		ODP_ERR("PMR w/o source CoS cannot be activated\n");
		return -1;
	}


	if (!entry->flags.default_pmr) {
		odp_pktio_t pktio = cos_get_pktio(entry->dst_cos, 0);

		if (pktio != ODP_PKTIO_INVALID &&
		    !odp_pktio_promisc_mode(pktio)) {
			for (int i = 0; i < entry->term_num; i++) {
				if (entry->terms[i].term != ODP_PMR_DMAC)
					continue;
				ODP_ERR("You cannot add DMAC PMR in not promiscuous mode\n");
				return -1;
			}
		}
	}

	if (pmr_check_layer_overlap(entry) < 0)
		return -1;

	return 0;
}

static int pmr_l3_connection_validate(pmr_entry_t *entry)
{
	if (pmr_check_layer_overlap(entry) < 0)
		return -1;

	if (entry->src_cos && entry->src_cos->pmr_layers.l4) {
			ODP_ERR("L3 PMR can't be cascaded from L4 PMR, CoS = %s\n",
				entry->src_cos->name);
			return -1;
	}

	if (entry->pktio != ODP_PKTIO_INVALID) {
		if (_pktio_pmr_default(entry->pktio) == ODP_PMR_INVAL) {
			/*
			 * TODO: in case of inq_default create dummy default
			 * CoS and use it as the source for L3.
			 */
			ODP_ERR("L3 PMR can't be cascaded from pktio w/o default CoS\n");
			return -1;
		}
	}

	return 0;
}

static int pmr_l4_connection_validate(pmr_entry_t *entry)
{
	if (entry->term_num > 1) {
		ODP_ERR("You cannot create PMRset with UDP and TCP\n");
		return -1;
	}

	if (entry->src_cos && entry->src_cos->pmr_layers.l4) {
		ODP_ERR("L4 PMR can't be cascaded from CoS with L4 PMR, CoS = %s\n",
			entry->src_cos->name);
		return -1;
	}

	return 0;
}

static int pmr_connection_validate(pmr_entry_t *entry)
{
	int ret;

	switch (entry->layer) {
	case L2_TERM:
		ret = pmr_l2_connection_validate(entry);
		break;
	case L3_TERM:
		ret = pmr_l3_connection_validate(entry);
		break;
	case L4_TERM:
		ret = pmr_l4_connection_validate(entry);
		break;
	default:
		ODP_ABORT("Unexpected term layer\n");
		return -1;
	}

	return ret;
}

/**
 * cos_get_pktio - get source pktio.
 * @entry - entry for looking from
 * @deact - equal 1 if deactivation patch, 0 if activation
 *
 * returns src pktio or ODP_PKTIO_INVALID if pktio is not connected or ambiguous
 */
static odp_pktio_t cos_get_pktio(cos_entry_t *entry, int deact)
{
	tree_deep = 0;
	return _cos_get_pktio(entry, deact);
}

static odp_pktio_t _cos_get_pktio(cos_entry_t *entry, int deact)
{
	pmr_entry_t *pmr_entry;
	odp_pktio_t local_pktio = ODP_PKTIO_INVALID;
	odp_pktio_t other_pktio = ODP_PKTIO_INVALID;

	tree_deep++;
	list_for_each(&entry->pmr_in, pmr_entry, dst_cos_node) {
		if (pmr_entry->src_cos == NULL &&
		    pmr_entry->pktio != ODP_PKTIO_INVALID) {
			if (local_pktio == ODP_PKTIO_INVALID)
				local_pktio = pmr_entry->pktio;
			else if (local_pktio != pmr_entry->pktio)
				goto err;
		} else if (pmr_entry->src_cos->flags.activated || deact) {
			ODP_AS_STR(tree_deep < ODP_CONFIG_COS_ENTRIES,
				   "CoS number overhead");

			other_pktio =
				_cos_get_pktio(pmr_entry->src_cos, deact);
			if (other_pktio == ODP_PKTIO_INVALID)
				goto err;

			if (local_pktio == ODP_PKTIO_INVALID)
				local_pktio = other_pktio;
			else if (other_pktio != local_pktio)
				goto err;
		}
	}

	tree_deep--;
	return local_pktio;
err:
	tree_deep--;
	return ODP_PKTIO_INVALID;
}

static int _pmr_dmac(pmr_entry_t *entry, struct pa_entry_params_s *init_params,
		     term_vals_t *term_val)
{
	odp_pktio_t pktio = cos_get_pktio(entry->dst_cos, 0);
	int promisc_mode = odp_pktio_promisc_mode(pktio);

	if ((!promisc_mode && entry->flags.default_pmr) ||
	    (promisc_mode && !entry->flags.default_pmr)) {
		memcpy(&init_params->l2.eth_info.dst,
		       term_val->val, pa_MAC_ADDR_SIZE);
		init_params->l2.eth_info.validBitMap |= pa_ETH_INFO_VALID_DST;
	} else if (!entry->flags.default_pmr && !promisc_mode) {
		return -1;
	}

	return 0;
}

/*
 * It's an activation function for L2 PMR and it's supposed that
 * all links are connected above.
 */
static int pmr_l2_activate(pmr_entry_t *entry, odp_queue_t queue)
{
	paRouteInfo2_t route_host = {
		.validBitMap = 0,
		.dest = pa_DEST_HOST,
		.flowId = cppi_flow_id(entry->dst_cos->cppi_flow),
		.queue = _odp_queue_to_qmss_queue(queue),
		.swInfo0 = _odp_queue_sched_tag(queue),
		.mRouteIndex = pa_NO_MULTI_ROUTE,
	};

	struct pa_entry_params_s init_params = {
		.type = PA_LUT_TYPE_L2,
		.l2 = {
			.params = {
				.validBitMap = pa_PARAM_VALID_NEXTLINK,
				.nextLink = entry->dst_cos->l2_vlink,
				.routeInfo = &route_lut1_continue,
				.nextRtFail = &route_host,
			},
		},
	};

	ODP_AS_STR(entry->src_cos == NULL,
		   "Cascading of L2 PMRs is not implemented yet");

	paEthInfo2_t *eth_info = &init_params.l2.eth_info;
	eth_info->inport = _odp_pktio_port_id(entry->pktio);
	eth_info->validBitMap |= pa_ETH_INFO_VALID_INPORT;

	/* Copy initial parameters from previous L2 PMR */
	if (entry->src_cos && entry->src_cos->pmr_layers.l2) {
		pmr_entry_t *pmr_in = list_top(&entry->src_cos->pmr_in,
					       pmr_entry_t, dst_cos_node);
		memcpy(eth_info,
		       &pa_entry_params(pmr_in->pa_entry)->l2.eth_info,
		       sizeof(*eth_info));
	}

	/* cycle in case of PMR match set */
	for (int i = 0; i < entry->term_num; i++) {
		term_vals_t *term_val = &entry->terms[i];
		switch (term_val->term) {
		case ODP_PMR_DMAC:
			if (_pmr_dmac(entry, &init_params, term_val) < 0)
				ODP_ABORT("You cannot add DMAC PMR in not promiscuous mode\n");
			break;
		case ODP_PMR_ETHTYPE_0:
			memcpy(&eth_info->ethertype, term_val->val,
			       pmr_term_params[term_val->term].lenght);
			eth_info->validBitMap |= pa_ETH_INFO_VALID_VLAN;
			break;
		case ODP_PMR_VLAN_ID_0:
			memcpy(&eth_info->vlan, term_val->val,
			       pmr_term_params[term_val->term].lenght);
			eth_info->validBitMap |= pa_ETH_INFO_VALID_VLAN;
			break;
		default:
			ODP_ABORT("Unknown L2 PMR term\n");
			break;
		}
	}

	entry->pa_entry = pa_create_entry(&init_params);
	if (!entry->pa_entry) {
		ODP_ERR("failed to create MAC entry\n");
		return -1;
	}

	return 0;
}

static int pmr_l3_activate(pmr_entry_t *entry, odp_queue_t queue)
{
	cos_entry_t *src_cos_entry;
	paRouteInfo2_t route_host = {
		.dest = pa_DEST_HOST,
		.swInfo0 = _odp_queue_sched_tag(queue),
		.flowId = cppi_flow_id(entry->dst_cos->cppi_flow),
		.queue = _odp_queue_to_qmss_queue(queue),
	};

	src_cos_entry = entry->src_cos != NULL ? entry->src_cos :
		_odp_pmr_entry(_pktio_pmr_default(entry->pktio))->dst_cos;

	struct pa_entry_params_s l3_init_params = {
		.type = PA_LUT_TYPE_L3,
		.l3 = {
			.params = {
				.validBitMap = pa_PARAM_VALID_PREVLINK |
				pa_PARAM_VALID_NEXTLINK,
				.routeInfo = &route_lut2_continue,
				.nextRtFail = &route_host,
				.prevLink = src_cos_entry->l2_vlink,
				.nextLink = entry->dst_cos->l3_vlink,
			},
		},
	};

	/* Copy initial parameters from previous L3 PMR */
	paIpInfo2_t *ip_info = &l3_init_params.l3.ip_info;
	if (entry->src_cos && entry->src_cos->pmr_layers.l3) {
		pmr_entry_t *pmr_in = list_top(&entry->src_cos->pmr_in,
					       pmr_entry_t, dst_cos_node);

		memcpy(ip_info, &pa_entry_params(pmr_in->pa_entry)->l3.ip_info,
		       sizeof(*ip_info));
	}

	for (int i = 0; i < entry->term_num; i++) {
		odp_pmr_term_e term = entry->terms[i].term;
		struct term_params_s term_params = pmr_term_params[term];

		switch (term) {
		case ODP_PMR_SIP_ADDR:
		{
			uint32_t ip_addr;
			ip_addr = odp_cpu_to_be_32(entry->terms[i].val_int32);
			ip_info->ipType = pa_IPV4;
			memcpy(&ip_info->src.ipv4,
			       (char *)&ip_addr, term_params.lenght);
			ip_info->validBitMap |= pa_IP_INFO_VALID_SRC;
			break;
		}
		case ODP_PMR_DIP_ADDR:
		{
			uint32_t ip_addr;
			ip_addr = odp_cpu_to_be_32(entry->terms[i].val_int32);
			ip_info->ipType = pa_IPV4;
			memcpy(&ip_info->dst.ipv4,
			       (char *)&ip_addr, term_params.lenght);
			ip_info->validBitMap |= pa_IP_INFO_VALID_DST;
			break;
		}
		case ODP_PMR_SIP6_ADDR:
			ip_info->ipType = pa_IPV6;
			memcpy(&ip_info->src.ipv6,
			       entry->terms[i].val, term_params.lenght);
			ip_info->validBitMap |= pa_IP_INFO_VALID_SRC;
			break;
		case ODP_PMR_DIP6_ADDR:
			ip_info->ipType = pa_IPV6;
			memcpy(&ip_info->dst.ipv6,
			       entry->terms[i].val, term_params.lenght);
			ip_info->validBitMap |= pa_IP_INFO_VALID_DST;
			break;
		case ODP_PMR_IPPROTO:
			memcpy(&ip_info->proto,
			       entry->terms[i].val, term_params.lenght);
			ip_info->validBitMap |= pa_IP_INFO_VALID_PROTO;
			break;
		case ODP_PMR_IPSEC_SPI:
			memcpy(&ip_info->spi,
			       entry->terms[i].val, term_params.lenght);
			ip_info->validBitMap |= pa_IP_INFO_VALID_SPI;
			break;
		default:
			ODP_ABORT("Unexpected term\n");
		}
	}

	entry->pa_entry = pa_create_entry(&l3_init_params);
	if (!entry->pa_entry) {
		ODP_ERR("failed to create L3 entry\n");
		return -1;
	}

	return 0;
}

static int pmr_l4_activate(pmr_entry_t *entry, odp_queue_t queue)
{
	cos_entry_t *src_cos_entry;
	odp_pmr_term_e term = entry->terms[0].term;

	paRouteInfo2_t route_host = {
		.dest = pa_DEST_HOST,
		.swInfo0 = _odp_queue_sched_tag(queue),
		.flowId = cppi_flow_id(entry->dst_cos->cppi_flow),
		.queue = _odp_queue_to_qmss_queue(queue),
	};

	src_cos_entry = entry->src_cos != NULL ? entry->src_cos :
		_odp_pmr_entry(_pktio_pmr_default(entry->pktio))->dst_cos;

	struct pa_entry_params_s init_params = {
		.type = PA_LUT_TYPE_L4,
		.l4 = {
			.route = &route_host,
			.prev_link = src_cos_entry->l3_vlink,
		},
	};

	switch (term) {
	case ODP_PMR_UDP_DPORT:
	case ODP_PMR_TCP_DPORT:
		memcpy(&init_params.l4.dest_port, entry->terms[0].val,
		       pmr_term_params[term].lenght);
		break;
	default:
		ODP_ABORT("Unexpected term\n");
	}

	entry->pa_entry = pa_create_entry(&init_params);
	if (!entry->pa_entry) {
		ODP_ERR("failed to create L4 entry\n");
		return -1;
	}
	return 0;
}

odp_pmr_t odp_pmr_create(const odp_pmr_match_t *match)
{
	pmr_entry_t *entry;
	odp_pmr_term_e term = match->term;
	uint32_t val_sz = match->val_sz;

	const uint8_t *mask_u8 = match->mask;
	if (pmr_term_validate(term, val_sz))
		return ODP_PMR_INVAL;
	for (unsigned int i = 0; i < val_sz; i++) {
		/* Wildcarding is not supported by K2KH PA */
		if (mask_u8[i] != 0xFF)
			return ODP_PMR_INVAL;
	}

	entry = shres_alloc(pmr_tbl, typeof(*entry));
	if (!entry)
		return ODP_PMR_INVAL;

	entry->terms[0].term = term;
	memcpy(entry->terms[0].val, match->val, val_sz);
	memset(entry->terms[0].mask, 0xFF, val_sz);
	entry->term_num = 1;
	entry->layer = pmr_term_params[term].layer;
	entry->flags.activated = 0;
	entry->flags.default_pmr = 0;
	entry->pa_entry = NULL;
	entry->src_cos = NULL;
	entry->dst_cos = NULL;
	entry->pktio = ODP_PKTIO_INVALID;
	ODP_DBG("PMR created\n");
	return _odp_pmr_from_entry(entry);
}

int __odp_pmr_destroy_nolock(odp_pmr_t pmr)
{
	if (pmr == ODP_PMR_INVAL) {
		ODP_ERR("Invalid input parameters\n");
		return -1;
	}

	return __odp_pmr_destroy(_odp_pmr_entry(pmr));
}

int odp_pmr_destroy(odp_pmr_t pmr)
{
	int ret;

	cls_tree_lock();
	ret = __odp_pmr_destroy_nolock(pmr);
	cls_tree_unlock();
	return ret;
}

int odp_pmr_match_set_create(int num_terms, const odp_pmr_match_t *terms,
			     odp_pmr_set_t *pmr_set_id)
{
	uint32_t pmr_word;
	pmr_entry_t *entry;

	*pmr_set_id = ODP_PMR_SET_INVAL;

	if (num_terms > ODP_CONFIG_PMRS_IN_PMRSET) {
		ODP_ERR("no of terms greater than supported ODP_PMRTERM_MAX\n");
		return -1;
	}

	entry = shres_alloc(pmr_tbl, typeof(*entry));
	if (!entry)
		return -1;

	entry->flags.activated = 0;
	entry->flags.default_pmr = 0;
	entry->pa_entry = NULL;
	entry->src_cos = NULL;
	entry->dst_cos = NULL;
	entry->pktio = ODP_PKTIO_INVALID;
	ODP_DBG("PMR created\n");

	pmr_word = 0;
	entry->layer = pmr_term_params[terms[0].term].layer;
	for (int i = 0; i < num_terms; i++) {
		if (pmr_term_validate(terms[i].term, terms[i].val_sz) < 0)
			goto err;

		if (pmr_word & (1 << terms[i].term)) {
			ODP_ERR("Cannot create PMRset with the same PMRs\n");
			goto err;
		}
		pmr_word |= (1 << terms[i].term);

		if (pmr_term_params[terms[i].term].layer != entry->layer) {
			ODP_ERR("Cannot create PMRset with PMRs on different layers\n");
			goto err;
		}

		memcpy(entry->terms[i].val, terms[i].val, terms[i].val_sz);
		memset(entry->terms[i].mask, 0xFF, terms[i].val_sz);
		entry->terms[i].term = terms[i].term;
	}

	entry->term_num = num_terms;
	*pmr_set_id = _odp_pmr_set_from_entry(entry);
	return num_terms;
err:
	shres_free(pmr_tbl, entry);
	return -1;
}

int odp_pmr_match_set_destroy(odp_pmr_set_t pmr_set)
{
	int ret;

	cls_tree_lock();
	if (pmr_set == ODP_PMR_SET_INVAL) {
		cls_tree_unlock();
		ODP_ERR("Invalid input parameters\n");
		return -1;
	}

	pmr_entry_t *entry = _odp_pmr_set_entry(pmr_set);
	ret = shres_free(pmr_tbl, entry);
	if (ret < 0)
		pmr_set = ODP_PMR_SET_INVAL;
	cls_tree_unlock();
	return ret;
}

int odp_pktio_pmr_match_set_cos(odp_pmr_set_t pmr_set, odp_pktio_t src_pktio,
				odp_cos_t dst_cos)
{
	pmr_entry_t *entry = _odp_pmr_set_entry(pmr_set);
	odp_pmr_t pmr = _odp_pmr_from_entry(entry);

	return odp_pktio_pmr_cos(pmr, src_pktio, dst_cos);
}

static inline int odp_pktio_pmr_cos_nolock(odp_pmr_t pmr, odp_pktio_t src_pktio,
					   odp_cos_t dst_cos)
{
	if (pmr == ODP_PMR_INVAL ||
	    src_pktio == ODP_PKTIO_INVALID || dst_cos == ODP_COS_INVALID) {
		ODP_ERR("Invalid input parameters\n");
		return -1;
	}

	pmr_entry_t *entry = _odp_pmr_entry(pmr);

	/* save links to restore in case of error */
	cos_entry_t *res_dst_cos = entry->dst_cos;
	cos_entry_t *res_src_cos = entry->src_cos;
	odp_pktio_t res_pktio = entry->pktio;

	cos_entry_t *dst_cos_entry = _odp_cos_entry(dst_cos);
	/*
	 * TODO: if PMR is currently activated, then we need to
	 * allocate and activate another one and add it to the list
	 * of "under" PMRs. For now suppose that it's not activated.
	 */
	ODP_AS_STR(entry->flags.activated == 0,
		   "Currently a PMR cannot be used in several places.");

	/* connect PMR in the tree */
	entry->dst_cos = dst_cos_entry;
	entry->src_cos = NULL;
	entry->pktio = src_pktio;
	cos_add_pmr_in(dst_cos_entry, entry);
	_pktio_add_pmr_out(src_pktio, &entry->src_cos_node);

	if (pmr_connection_validate(entry) < 0)
		goto err;

	/* activate tree, including connected PMRs */
	act_tree_deep = 0;
	if (cos_tree_activate(dst_cos_entry) < 0)
		goto err;

	/* save layer info to dst CoS */
	dst_cos_entry->pmr_layers.all |= (1 << entry->layer);
	return 0;
err:
	_pktio_rm_pmr_out(src_pktio, &entry->src_cos_node);
	cos_rm_pmr_in(dst_cos_entry, entry);
	entry->pktio = res_pktio;
	entry->src_cos = res_src_cos;
	entry->dst_cos = res_dst_cos;
	return -1;
}

int odp_pktio_pmr_cos(odp_pmr_t pmr, odp_pktio_t src_pktio, odp_cos_t dst_cos)
{
	int ret;

	cls_tree_lock();
	ret = odp_pktio_pmr_cos_nolock(pmr, src_pktio, dst_cos);
	cls_tree_unlock();

	return ret;
}

int __odp_pktio_pmr_cos_nolock(odp_pmr_t pmr, odp_pktio_t src_pktio,
			       odp_cos_t dst_cos)
{
	return odp_pktio_pmr_cos_nolock(pmr, src_pktio, dst_cos);
}

int odp_cos_pmr_cos(odp_pmr_t pmr, odp_cos_t src_cos, odp_cos_t dst_cos)
{
	cls_tree_lock();
	if (pmr == ODP_PMR_INVAL ||
	    src_cos == ODP_COS_INVALID || dst_cos == ODP_COS_INVALID) {
		cls_tree_unlock();
		return -1;
	}

	pmr_entry_t *entry = _odp_pmr_entry(pmr);
	cos_entry_t *dst_cos_entry = _odp_cos_entry(dst_cos);
	cos_entry_t *src_cos_entry = _odp_cos_entry(src_cos);

	/* save links to restore in case of error */
	cos_entry_t *res_dst_cos = entry->dst_cos;
	cos_entry_t *res_src_cos = entry->src_cos;

	entry->dst_cos = dst_cos_entry;
	entry->src_cos = src_cos_entry;

	cos_add_pmr_in(dst_cos_entry, entry);
	cos_add_pmr_out(src_cos_entry, entry);

	if (pmr_connection_validate(entry))
		goto err;

	/* if src CoS is not active - no need for activation */
	if (src_cos_entry->flags.activated) {
		/* activate tree, including connected PMRs */
		act_tree_deep = 0;
		if (cos_tree_activate(dst_cos_entry) < 0)
			goto err;
	}

	/* save layer info to dst CoS */
	dst_cos_entry->pmr_layers.all |= (1 << entry->layer);
	cls_tree_unlock();
	return 0;
err:
	cos_rm_pmr_out(src_cos_entry, entry);
	cos_rm_pmr_in(dst_cos_entry, entry);
	entry->src_cos = res_src_cos;
	entry->dst_cos = res_dst_cos;
	cls_tree_unlock();
	return -1;
}

static int cos_pool_queue_get(cos_entry_t *entry, odp_pool_t *pool,
			      odp_queue_t *queue)
{
	odp_pktio_t pktio;

	if (entry->pool == ODP_POOL_INVALID ||
	    entry->queue == ODP_QUEUE_INVALID) {
		pktio = cos_get_pktio(entry, 0);
		if (pktio == ODP_PKTIO_INVALID) {
			ODP_ERR("Ambiguous pktio when connecting %s CoS\n",
				entry->name);
			return -1;
		}
	}

	*pool = entry->pool == ODP_POOL_INVALID ? _pktio_in_pool(pktio) :
						 entry->pool;
	if (_odp_pool_get(*pool) < 0) {
		ODP_ERR("Pool was not allocated\n");
		return -1;
	}

	*queue = entry->queue == ODP_QUEUE_INVALID ? _pktio_inq_default(pktio) :
						    entry->queue;
	if (*queue == ODP_QUEUE_INVALID) {
		ODP_ERR("Cannot get inq_default for %s CoS\n", entry->name);
		goto put_pool;
	}

	if (_queue_get(*queue) < 0) {
		ODP_ERR("Queue was not allocated\n");
		goto put_pool;
	}

	return 0;

put_pool:
	if (entry->pool == ODP_POOL_INVALID)
		_odp_pool_put(*pool);
	return -1;
}

static int cos_activate(cos_entry_t *entry)
{
	odp_pool_t pool;
	odp_queue_t queue;

	paRouteInfo2_t route_host = {
		.validBitMap = 0,
		.dest = pa_DEST_HOST,
		.mRouteIndex = pa_NO_MULTI_ROUTE,
	};

	struct pa_entry_params_s l3_init_params = {
		.type = PA_LUT_TYPE_L3,
		.l3 = {
			.params = {
				.validBitMap = pa_PARAM_VALID_PREVLINK |
					       pa_PARAM_VALID_NEXTLINK,
				.routeInfo = &route_lut2_continue,
				.nextRtFail = &route_host,
			},
		},
	};

	if (cos_pool_queue_get(entry, &pool, &queue) < 0)
		return -1;

	entry->cppi_flow = _odp_pool_cppi_flow_create(pool,
						      _odp_pool_headroom(pool));
	if (!entry->cppi_flow) {
		ODP_ERR("Failed to create CPPI flow\n");
		goto put_pool_queue;
	}

	route_host.queue = _odp_queue_to_qmss_queue(queue);
	route_host.swInfo0 = _odp_queue_sched_tag(queue);
	route_host.flowId = cppi_flow_id(entry->cppi_flow);

	entry->l2_vlink = pa_add_virtual_link(pa_VIRTUAL_LNK_TYPE_MAC);
	if (!entry->l2_vlink) {
		ODP_ERR("Couldn't add virtual link\n");
		goto destroy_flow;
	}

	entry->l3_vlink = pa_add_virtual_link(pa_VIRTUAL_LNK_TYPE_OUTER_IP);
	if (!entry->l3_vlink) {
		ODP_ERR("Couldn't add virtual link\n");
		goto del_l2_vlink;
	}

	l3_init_params.l3.params.prevLink = entry->l2_vlink;
	l3_init_params.l3.params.nextLink = entry->l3_vlink;

	entry->pa_out_entry = pa_create_entry(&l3_init_params);
	if (!entry->pa_out_entry) {
		ODP_ERR("failed to create L3 entry\n");
		goto del_l3_vlink;
	}

	entry->flags.activated = 1;
	ODP_DBG("CoS \"%s\" activated\n", entry->name);
	return 0;
del_l3_vlink:
	pa_del_virtual_link(entry->l3_vlink);
	entry->l3_vlink = NULL;

del_l2_vlink:
	pa_del_virtual_link(entry->l2_vlink);
	entry->l2_vlink = NULL;
destroy_flow:
	cppi_flow_destroy(entry->cppi_flow);
	entry->cppi_flow = NULL;
put_pool_queue:
	_odp_pool_put(pool);
	_queue_put(queue);
	return -1;
}

static int cos_pool_queue_put(cos_entry_t *entry)
{
	odp_pool_t pool;
	odp_queue_t queue;
	odp_pktio_t pktio;

	if (entry->pool == ODP_POOL_INVALID ||
	    entry->queue == ODP_QUEUE_INVALID) {
		pktio = cos_get_pktio(entry, 1);
		if (pktio == ODP_PKTIO_INVALID) {
			ODP_ERR("Ambiguous pktio when deactivating %s CoS\n",
				entry->name);
			return -1;
		}
	}

	pool = entry->pool == ODP_POOL_INVALID ? _pktio_in_pool(pktio) :
						 entry->pool;
	_odp_pool_put(pool);

	queue = entry->queue == ODP_QUEUE_INVALID ? _pktio_inq_default(pktio) :
						    entry->queue;
	if (queue == ODP_QUEUE_INVALID) {
		ODP_ERR("Cannot get queue for %s CoS\n", entry->name);
		return -1;
	}
	_queue_put(queue);

	return 0;
}

static int cos_deactivate(cos_entry_t *entry)
{
	if (pa_destroy_entry(entry->pa_out_entry) < 0)
		return -1;
	if (cppi_flow_destroy(entry->cppi_flow) < 0)
		return -1;
	if (cos_pool_queue_put(entry) < 0)
		return -1;

	entry->flags.activated = 0;
	ODP_DBG("CoS \"%s\" deactivated\n", entry->name);
	return 0;
}

/*
 * This primitive function is called only if pmr can be
 * really activated, that is when src CoS is active and
 * dst CoS is active
 */
static int pmr_activate(pmr_entry_t *entry)
{
	int ret;
	odp_pool_t pool;
	odp_queue_t queue;

	if (cos_pool_queue_get(entry->dst_cos, &pool, &queue) < 0)
		return -1;

	switch (entry->layer) {
	case L2_TERM:
		ret = pmr_l2_activate(entry, queue);
		break;
	case L3_TERM:
		ret = pmr_l3_activate(entry, queue);
		break;
	case L4_TERM:
		ret = pmr_l4_activate(entry, queue);
		break;
	default:
		ret = -1;
		ODP_ABORT("Unexpected term layer\n");
	}

	if (ret) {
		ODP_ERR("failed to activate PMR\n");
		goto err;
	}

	if (cppi_flow_get(entry->dst_cos->cppi_flow) < 0)
		goto err;

	entry->flags.activated = 1;
	ODP_DBG("\"%s\" - PMR - \"%s\" activated\n", entry->pktio ?
		_pktio_name(entry->pktio) : entry->src_cos->name,
		entry->dst_cos->name);
	return 0;
err:
	_odp_pool_put(pool);
	_queue_put(queue);
	return -1;
}

static int pmr_deactivate(pmr_entry_t *entry)
{
	if (pa_destroy_entry(entry->pa_entry))
		return -1;

	entry->pa_entry = NULL;
	entry->flags.activated = 0;

	if (cos_pool_queue_put(entry->dst_cos) < 0)
		return -1;

	if (cppi_flow_put(entry->dst_cos->cppi_flow) < 0)
		return -1;

	ODP_DBG("\"%s\" - PMR - \"%s\" deactivated\n", entry->pktio ?
		_pktio_name(entry->pktio) : entry->src_cos->name,
		entry->dst_cos->name);

	return 0;
}

/**
 * cos_tree_activate - activate the tree after given CoS, including CoS itself and
 * all src PMRs connected to it, if the PMRs have activated src.
 * returns -1 when error and 0 on success
 */
static int cos_tree_activate(cos_entry_t *entry)
{
	pmr_entry_t *pmr;
	int activation = 0;

	/* activate "in" PMRs and CoS itself */
	list_for_each(&entry->pmr_in, pmr, dst_cos_node) {
		if (pmr->flags.activated)
			continue;

		/* skip PMRs that cannot be activated */
		if (pmr->src_cos && !pmr->src_cos->flags.activated)
			continue;

		/* activate given CoS if needed */
		if (!entry->flags.activated) {
			if (cos_activate(entry) < 0) {
				ODP_ERR("failed to activate CoS: %s\n",
					entry->name);
				goto err;
			}
			activation = 1;
			++act_tree_deep;
		}

		/* now activate PMR, as we have dst and src CoSes */
		if (pmr_activate(pmr) < 0) {
			ODP_ERR("failed to activate PMR of CoS: %s\n",
				entry->name);
			goto err;
		}
	}

	/* Cos was active initially, so no need to continue */
	if (!activation)
		return 0;

	list_for_each(&entry->pmr_out, pmr, src_cos_node) {
		ODP_AS_STR(act_tree_deep < ODP_CONFIG_COS_ENTRIES,
			   "CoS number overhead");
		if (!pmr->dst_cos)
			continue;
		if (cos_tree_activate(pmr->dst_cos) < 0)
			goto err;
	}

	--act_tree_deep;
	return 0;
err:
	ODP_ERR("Cannot activate some parts of the tree");
	act_tree_deep = 0;
	return -1;
}

/*
 * Deactivate the tree after given CoS. All tree after the CoS will be
 * unactivated, but if for some reason one of the CoSes after the tree
 * is on another active branch it's entry and after it will stay active.
 * It also invalidets all src PMR connected to given CoS.
 *
 * Returns -1 on error and 0 on success
 */
static int cos_tree_deactivate(cos_entry_t *entry)
{
	pmr_entry_t *pmr;

	/* deactivate "in" PMRs for root CoS */
	list_for_each(&entry->pmr_in, pmr, dst_cos_node) {
		if (!pmr->flags.activated)
			continue;

		if (act_tree_deep)
			return 0;

		if (pmr_deactivate(pmr) < 0)
			goto err;
	}

	if (entry->flags.activated) {
		if (cos_deactivate(entry) < 0) {
			ODP_ERR("failed to deactivate CoS: %s\n", entry->name);
			goto err;
		}
		++act_tree_deep;
	} else {
		return 0;
	}

	/* deactivate "out" PMRs and their dst CoSes*/
	list_for_each(&entry->pmr_out, pmr, src_cos_node) {
		if (!pmr->flags.activated)
			continue;

		if (pmr_deactivate(pmr) < 0)
			goto err;

		if (cos_tree_deactivate(pmr->dst_cos) < 0)
			goto err;
	}

	--act_tree_deep;
	return 0;

err:
	ODP_ERR("Cannot activate some parts of the tree\n");
	act_tree_deep = 0;
	return -1;
}

odp_cos_t _pmr_dst_cos(odp_pmr_t pmr)
{
	pmr_entry_t *entry = _odp_pmr_entry(pmr);
	return _odp_cos_from_entry(entry->dst_cos);
}

void _pmr_mark_default(odp_pmr_t default_pmr)
{
	pmr_entry_t *entry;

	entry = _odp_pmr_entry(default_pmr);
	entry->flags.default_pmr = 1;
}

int _cls_deactivate_pmr_list(struct list_head *pmr_list)
{
	pmr_entry_t *entry;

	list_for_each(pmr_list, entry, src_cos_node) {
		act_tree_deep = 0;
		if (cos_tree_deactivate(entry->dst_cos) < 0)
			return -1;
	}

	return 0;
}

int _cls_activate_pmr_list(struct list_head *pmr_list)
{
	pmr_entry_t *entry;

	list_for_each(pmr_list, entry, src_cos_node) {
		act_tree_deep = 0;
		if (cos_tree_activate(entry->dst_cos) < 0)
			return -1;
	}

	return 0;
}

int _cls_disconnect_pmr_list(struct list_head *pmr_list)
{
	pmr_entry_t *entry, *nentry;

	list_for_each_safe(pmr_list, entry, nentry, src_cos_node) {
		act_tree_deep = 0;
		if (cos_tree_deactivate(entry->dst_cos) < 0)
			return -1;

		pmr_disconnect_source(entry);
	}

	return 0;
}

static inline void _list_replace(struct list_head *old, struct list_head *new)
{
	if (list_empty(old))
		return;

	list_swap(&old->n, &new->n);
}

void _cls_replace_cos(odp_cos_t old_cos, odp_cos_t new_cos)
{
	pmr_entry_t *pmr_entry;
	cos_entry_t *old_entry = _odp_cos_entry(old_cos);
	cos_entry_t *new_entry = _odp_cos_entry(new_cos);

	_list_replace(&old_entry->pmr_in, &new_entry->pmr_in);
	_list_replace(&old_entry->pmr_out, &new_entry->pmr_out);
	new_entry->pmr_in_cnt = old_entry->pmr_in_cnt;
	new_entry->pmr_out_cnt = old_entry->pmr_out_cnt;
	new_entry->pmr_layers = old_entry->pmr_layers;
	new_entry->flags = old_entry->flags;

	list_for_each(&new_entry->pmr_in, pmr_entry, dst_cos_node)
		pmr_entry->dst_cos = new_entry;

	list_for_each(&new_entry->pmr_out, pmr_entry, src_cos_node)
		pmr_entry->src_cos = new_entry;

	list_head_init(&old_entry->pmr_in);
	list_head_init(&old_entry->pmr_out);
	old_entry->pmr_in_cnt = 0;
	old_entry->pmr_out_cnt = 0;
	old_entry->pmr_layers.all = 0;
	old_entry->flags.activated = 0;
}