priority, resp_count);
}
+int
+roc_npc_mcam_enable_all_entries(struct roc_npc *roc_npc, bool enable)
+{
+ struct npc *npc = roc_npc_to_npc_priv(roc_npc);
+
+ return npc_flow_enable_all_entries(npc, enable);
+}
+
int
roc_npc_mcam_alloc_entry(struct roc_npc *roc_npc, struct roc_npc_flow *mcam,
struct roc_npc_flow *ref_mcam, int prio,
if (roc_model_is_cn10k())
return (npc->mcam_entries - NPC_MCAME_RESVD_10XX - 1);
+ else if (roc_model_is_cn98xx())
+ return (npc->mcam_entries - NPC_MCAME_RESVD_98XX - 1);
else
return (npc->mcam_entries - NPC_MCAME_RESVD_9XXX - 1);
}
roc_npc->kex_capability = npc_get_kex_capability(npc);
roc_npc->rx_parse_nibble = npc->keyx_supp_nmask[NPC_MCAM_RX];
- npc->mark_actions = 0;
-
npc->mcam_entries = npc_mcam_tot_entries() >> npc->keyw[NPC_MCAM_RX];
/* Free, free_rev, live and live_rev entries */
return rc;
}
- sz = npc->flow_max_priority * sizeof(struct npc_mcam_ents_info);
- npc->flow_entry_info = plt_zmalloc(sz, 0);
- if (npc->flow_entry_info == NULL) {
- plt_err("flow_entry_info alloc failed");
- rc = NPC_ERR_NO_MEM;
- goto done;
- }
-
- sz = npc->flow_max_priority * sizeof(struct plt_bitmap *);
- npc->free_entries = plt_zmalloc(sz, 0);
- if (npc->free_entries == NULL) {
- plt_err("free_entries alloc failed");
- rc = NPC_ERR_NO_MEM;
- goto done;
- }
-
- sz = npc->flow_max_priority * sizeof(struct plt_bitmap *);
- npc->free_entries_rev = plt_zmalloc(sz, 0);
- if (npc->free_entries_rev == NULL) {
- plt_err("free_entries_rev alloc failed");
- rc = NPC_ERR_NO_MEM;
- goto done;
- }
-
- sz = npc->flow_max_priority * sizeof(struct plt_bitmap *);
- npc->live_entries = plt_zmalloc(sz, 0);
- if (npc->live_entries == NULL) {
- plt_err("live_entries alloc failed");
- rc = NPC_ERR_NO_MEM;
- goto done;
- }
-
- sz = npc->flow_max_priority * sizeof(struct plt_bitmap *);
- npc->live_entries_rev = plt_zmalloc(sz, 0);
- if (npc->live_entries_rev == NULL) {
- plt_err("live_entries_rev alloc failed");
- rc = NPC_ERR_NO_MEM;
- goto done;
- }
-
sz = npc->flow_max_priority * sizeof(struct npc_flow_list);
npc->flow_list = plt_zmalloc(sz, 0);
if (npc->flow_list == NULL) {
goto done;
}
+ sz = npc->flow_max_priority * sizeof(struct npc_prio_flow_list_head);
+ npc->prio_flow_list = plt_zmalloc(sz, 0);
+ if (npc->prio_flow_list == NULL) {
+ plt_err("prio_flow_list alloc failed");
+ rc = NPC_ERR_NO_MEM;
+ goto done;
+ }
+
npc_mem = mem;
for (idx = 0; idx < npc->flow_max_priority; idx++) {
TAILQ_INIT(&npc->flow_list[idx]);
-
- npc->free_entries[idx] =
- plt_bitmap_init(npc->mcam_entries, mem, bmap_sz);
- mem += bmap_sz;
-
- npc->free_entries_rev[idx] =
- plt_bitmap_init(npc->mcam_entries, mem, bmap_sz);
- mem += bmap_sz;
-
- npc->live_entries[idx] =
- plt_bitmap_init(npc->mcam_entries, mem, bmap_sz);
- mem += bmap_sz;
-
- npc->live_entries_rev[idx] =
- plt_bitmap_init(npc->mcam_entries, mem, bmap_sz);
- mem += bmap_sz;
-
- npc->flow_entry_info[idx].free_ent = 0;
- npc->flow_entry_info[idx].live_ent = 0;
- npc->flow_entry_info[idx].max_id = 0;
- npc->flow_entry_info[idx].min_id = ~(0);
+ TAILQ_INIT(&npc->prio_flow_list[idx]);
}
npc->rss_grps = NPC_RSS_GRPS;
done:
if (npc->flow_list)
plt_free(npc->flow_list);
- if (npc->live_entries_rev)
- plt_free(npc->live_entries_rev);
- if (npc->live_entries)
- plt_free(npc->live_entries);
- if (npc->free_entries_rev)
- plt_free(npc->free_entries_rev);
- if (npc->free_entries)
- plt_free(npc->free_entries);
- if (npc->flow_entry_info)
- plt_free(npc->flow_entry_info);
+ if (npc->prio_flow_list)
+ plt_free(npc->prio_flow_list);
if (npc_mem)
plt_free(npc_mem);
return rc;
npc->flow_list = NULL;
}
- if (npc->live_entries_rev) {
- plt_free(npc->live_entries_rev);
- npc->live_entries_rev = NULL;
+ if (npc->prio_flow_list) {
+ plt_free(npc->prio_flow_list);
+ npc->prio_flow_list = NULL;
}
- if (npc->live_entries) {
- plt_free(npc->live_entries);
- npc->live_entries = NULL;
+ return 0;
+}
+
+int
+roc_npc_validate_portid_action(struct roc_npc *roc_npc_src,
+ struct roc_npc *roc_npc_dst)
+{
+ struct roc_nix *roc_nix_src = roc_npc_src->roc_nix;
+ struct nix *nix_src = roc_nix_to_nix_priv(roc_nix_src);
+ struct roc_nix *roc_nix_dst = roc_npc_dst->roc_nix;
+ struct nix *nix_dst = roc_nix_to_nix_priv(roc_nix_dst);
+
+ if (roc_nix_is_pf(roc_npc_dst->roc_nix)) {
+ plt_err("Output port should be VF");
+ return -EINVAL;
}
- if (npc->free_entries_rev) {
- plt_free(npc->free_entries_rev);
- npc->free_entries_rev = NULL;
+ if (nix_dst->dev.vf >= nix_src->dev.maxvf) {
+ plt_err("Invalid VF for output port");
+ return -EINVAL;
}
- if (npc->free_entries) {
- plt_free(npc->free_entries);
- npc->free_entries = NULL;
+ if (nix_src->dev.pf != nix_dst->dev.pf) {
+ plt_err("Output port should be VF of ingress PF");
+ return -EINVAL;
}
+ return 0;
+}
- if (npc->flow_entry_info) {
- plt_free(npc->flow_entry_info);
- npc->flow_entry_info = NULL;
+static int
+npc_parse_msns_action(struct roc_npc *roc_npc, const struct roc_npc_action *act,
+ struct roc_npc_flow *flow, uint8_t *has_msns_action)
+{
+ const struct roc_npc_sec_action *sec_action;
+ union {
+ uint64_t reg;
+ union nix_rx_vtag_action_u act;
+ } vtag_act;
+
+ if (roc_npc->roc_nix->custom_sa_action == 0 ||
+ roc_model_is_cn9k() == 1 || act->conf == NULL)
+ return 0;
+
+ *has_msns_action = true;
+ sec_action = act->conf;
+
+ vtag_act.reg = 0;
+ vtag_act.act.sa_xor = sec_action->sa_xor;
+ vtag_act.act.sa_hi = sec_action->sa_hi;
+ vtag_act.act.sa_lo = sec_action->sa_lo;
+
+ switch (sec_action->alg) {
+ case ROC_NPC_SEC_ACTION_ALG0:
+ break;
+ case ROC_NPC_SEC_ACTION_ALG1:
+ vtag_act.act.vtag1_valid = false;
+ vtag_act.act.vtag1_lid = ROC_NPC_SEC_ACTION_ALG1;
+ break;
+ case ROC_NPC_SEC_ACTION_ALG2:
+ vtag_act.act.vtag1_valid = false;
+ vtag_act.act.vtag1_lid = ROC_NPC_SEC_ACTION_ALG2;
+ break;
+ default:
+ return -1;
}
+ flow->vtag_action = vtag_act.reg;
+
return 0;
}
static int
-npc_parse_actions(struct npc *npc, const struct roc_npc_attr *attr,
+npc_parse_actions(struct roc_npc *roc_npc, const struct roc_npc_attr *attr,
const struct roc_npc_action actions[],
struct roc_npc_flow *flow)
{
+ const struct roc_npc_action_port_id *act_portid;
+ struct npc *npc = roc_npc_to_npc_priv(roc_npc);
const struct roc_npc_action_mark *act_mark;
+ const struct roc_npc_action_meter *act_mtr;
const struct roc_npc_action_queue *act_q;
const struct roc_npc_action_vf *vf_act;
bool vlan_insert_action = false;
+ uint8_t has_msns_act = 0;
int sel_act, req_act = 0;
uint16_t pf_func, vf_id;
+ struct roc_nix *roc_nix;
int errcode = 0;
int mark = 0;
int rq = 0;
+ int rc = 0;
/* Initialize actions */
flow->ctr_id = NPC_COUNTER_NONE;
+ flow->mtr_id = ROC_NIX_MTR_ID_INVALID;
pf_func = npc->pf_func;
for (; actions->type != ROC_NPC_ACTION_TYPE_END; actions++) {
}
mark = act_mark->id + 1;
req_act |= ROC_NPC_ACTION_TYPE_MARK;
- npc->mark_actions += 1;
break;
case ROC_NPC_ACTION_TYPE_FLAG:
mark = NPC_FLOW_FLAG_VAL;
req_act |= ROC_NPC_ACTION_TYPE_FLAG;
- npc->mark_actions += 1;
break;
case ROC_NPC_ACTION_TYPE_COUNT:
pf_func = (pf_func | (vf_id + 1));
break;
+ case ROC_NPC_ACTION_TYPE_PORT_ID:
+ act_portid = (const struct roc_npc_action_port_id *)
+ actions->conf;
+ pf_func &= (0xfc00);
+ pf_func = (pf_func | (act_portid->id + 1));
+ req_act |= ROC_NPC_ACTION_TYPE_VF;
+ break;
+
case ROC_NPC_ACTION_TYPE_QUEUE:
act_q = (const struct roc_npc_action_queue *)
actions->conf;
* NPC_SECURITY_ACTION_TYPE_INLINE_PROTOCOL &&
* session_protocol ==
* NPC_SECURITY_PROTOCOL_IPSEC
- *
- * RSS is not supported with inline ipsec. Get the
- * rq from associated conf, or make
- * ROC_NPC_ACTION_TYPE_QUEUE compulsory with this
- * action.
- * Currently, rq = 0 is assumed.
*/
req_act |= ROC_NPC_ACTION_TYPE_SEC;
rq = 0;
+ roc_nix = roc_npc->roc_nix;
+
+ /* Special processing when with inline device */
+ if (roc_nix_inb_is_with_inl_dev(roc_nix) &&
+ roc_nix_inl_dev_is_probed()) {
+ struct roc_nix_rq *inl_rq;
+
+ inl_rq = roc_nix_inl_dev_rq(roc_nix);
+ if (!inl_rq) {
+ errcode = NPC_ERR_INTERNAL;
+ goto err_exit;
+ }
+ rq = inl_rq->qid;
+ pf_func = nix_inl_dev_pffunc_get();
+ }
+ rc = npc_parse_msns_action(roc_npc, actions, flow,
+ &has_msns_act);
+ if (rc) {
+ errcode = NPC_ERR_ACTION_NOTSUP;
+ goto err_exit;
+ }
break;
case ROC_NPC_ACTION_TYPE_VLAN_STRIP:
req_act |= ROC_NPC_ACTION_TYPE_VLAN_STRIP;
case ROC_NPC_ACTION_TYPE_VLAN_PCP_INSERT:
req_act |= ROC_NPC_ACTION_TYPE_VLAN_PCP_INSERT;
break;
+ case ROC_NPC_ACTION_TYPE_METER:
+ act_mtr = (const struct roc_npc_action_meter *)
+ actions->conf;
+ flow->mtr_id = act_mtr->mtr_id;
+ req_act |= ROC_NPC_ACTION_TYPE_METER;
+ break;
default:
errcode = NPC_ERR_ACTION_NOTSUP;
goto err_exit;
goto err_exit;
}
+ if (has_msns_act && (vlan_insert_action ||
+ (req_act & ROC_NPC_ACTION_TYPE_VLAN_STRIP))) {
+ plt_err("Both MSNS and VLAN insert/strip action can't be supported"
+ " together");
+ errcode = NPC_ERR_ACTION_NOTSUP;
+ goto err_exit;
+ }
+
/* Both STRIP and INSERT actions are not supported */
if (vlan_insert_action && (req_act & ROC_NPC_ACTION_TYPE_VLAN_STRIP)) {
errcode = NPC_ERR_ACTION_NOTSUP;
struct roc_npc_flow *flow, struct npc_parse_state *pst)
{
npc_parse_stage_func_t parse_stage_funcs[] = {
- npc_parse_meta_items, npc_parse_cpt_hdr, npc_parse_higig2_hdr,
- npc_parse_la, npc_parse_lb, npc_parse_lc,
- npc_parse_ld, npc_parse_le, npc_parse_lf,
- npc_parse_lg, npc_parse_lh,
+ npc_parse_meta_items, npc_parse_mark_item, npc_parse_pre_l2,
+ npc_parse_cpt_hdr, npc_parse_higig2_hdr, npc_parse_la,
+ npc_parse_lb, npc_parse_lc, npc_parse_ld,
+ npc_parse_le, npc_parse_lf, npc_parse_lg,
+ npc_parse_lh,
};
uint8_t layer = 0;
int key_offset;
}
static int
-npc_parse_rule(struct npc *npc, const struct roc_npc_attr *attr,
+npc_parse_rule(struct roc_npc *roc_npc, const struct roc_npc_attr *attr,
const struct roc_npc_item_info pattern[],
const struct roc_npc_action actions[], struct roc_npc_flow *flow,
struct npc_parse_state *pst)
{
+ struct npc *npc = roc_npc_to_npc_priv(roc_npc);
int err;
/* Check attr */
return err;
/* Check action */
- err = npc_parse_actions(npc, attr, actions, flow);
+ err = npc_parse_actions(roc_npc, attr, actions, flow);
if (err)
return err;
return 0;
struct npc_parse_state parse_state = {0};
int rc;
- rc = npc_parse_rule(npc, attr, pattern, actions, flow, &parse_state);
+ rc = npc_parse_rule(roc_npc, attr, pattern, actions, flow,
+ &parse_state);
if (rc)
return rc;
return 0;
}
-int
-roc_npc_mark_actions_get(struct roc_npc *roc_npc)
-{
- struct npc *npc = roc_npc_to_npc_priv(roc_npc);
-
- return npc->mark_actions;
-}
-
-int
-roc_npc_mark_actions_sub_return(struct roc_npc *roc_npc, uint32_t count)
-{
- struct npc *npc = roc_npc_to_npc_priv(roc_npc);
-
- npc->mark_actions -= count;
- return npc->mark_actions;
-}
-
static int
npc_vtag_cfg_delete(struct roc_npc *roc_npc, struct roc_npc_flow *flow)
{
vtag_cfg->cfg_type = VTAG_TX;
vtag_cfg->vtag_size = NIX_VTAGSIZE_T4;
vtag_cfg->tx.vtag0 =
- ((vlan_info[0].vlan_ethtype << 16) |
+ (((uint32_t)vlan_info[0].vlan_ethtype << 16) |
(vlan_info[0].vlan_pcp << 13) | vlan_info[0].vlan_id);
vtag_cfg->tx.cfg_vtag0 = 1;
if (flow->vtag_insert_count == 2) {
vtag_cfg->tx.vtag1 =
- ((vlan_info[1].vlan_ethtype << 16) |
+ (((uint32_t)vlan_info[1].vlan_ethtype << 16) |
(vlan_info[1].vlan_pcp << 13) | vlan_info[1].vlan_id);
vtag_cfg->tx.cfg_vtag1 = 1;
int rc;
npc->channel = roc_npc->channel;
+ npc->is_sdp_link = roc_nix_is_sdp(roc_npc->roc_nix);
+ if (npc->is_sdp_link) {
+ if (roc_npc->is_sdp_mask_set) {
+ npc->sdp_channel = roc_npc->sdp_channel;
+ npc->sdp_channel_mask = roc_npc->sdp_channel_mask;
+ } else {
+ /* By default set the channel and mask to cover
+ * the whole SDP channel range.
+ */
+ npc->sdp_channel = (uint16_t)NIX_CHAN_SDP_CH_START;
+ npc->sdp_channel_mask = (uint16_t)NIX_CHAN_SDP_CH_START;
+ }
+ }
flow = plt_zmalloc(sizeof(*flow), 0);
if (flow == NULL) {
}
memset(flow, 0, sizeof(*flow));
- rc = npc_parse_rule(npc, attr, pattern, actions, flow, &parse_state);
+ rc = npc_parse_rule(roc_npc, attr, pattern, actions, flow,
+ &parse_state);
if (rc != 0) {
*errcode = rc;
goto err_exit;
roc_npc_flow_destroy(struct roc_npc *roc_npc, struct roc_npc_flow *flow)
{
struct npc *npc = roc_npc_to_npc_priv(roc_npc);
- struct plt_bitmap *bmap;
int rc;
rc = npc_rss_group_free(npc, flow);
return rc;
}
+ if (flow->ctr_id != NPC_COUNTER_NONE) {
+ rc = roc_npc_mcam_clear_counter(roc_npc, flow->ctr_id);
+ if (rc != 0)
+ return rc;
+
+ rc = npc_mcam_free_counter(npc, flow->ctr_id);
+ if (rc != 0)
+ return rc;
+ }
+
rc = npc_mcam_free_entry(npc, flow->mcam_id);
if (rc != 0)
return rc;
TAILQ_REMOVE(&npc->flow_list[flow->priority], flow, next);
- bmap = npc->live_entries[flow->priority];
- plt_bitmap_clear(bmap, flow->mcam_id);
+ npc_delete_prio_list_entry(npc, flow);
plt_free(flow);
return 0;
}
}
}
+
+int
+roc_npc_mcam_merge_base_steering_rule(struct roc_npc *roc_npc,
+ struct roc_npc_flow *flow)
+{
+ struct npc_mcam_read_base_rule_rsp *base_rule_rsp;
+ struct npc *npc = roc_npc_to_npc_priv(roc_npc);
+ struct mcam_entry *base_entry;
+ int idx, rc;
+
+ if (roc_nix_is_pf(roc_npc->roc_nix))
+ return 0;
+
+ (void)mbox_alloc_msg_npc_read_base_steer_rule(npc->mbox);
+ rc = mbox_process_msg(npc->mbox, (void *)&base_rule_rsp);
+ if (rc) {
+ plt_err("Failed to fetch VF's base MCAM entry");
+ return rc;
+ }
+ base_entry = &base_rule_rsp->entry_data;
+ for (idx = 0; idx < ROC_NPC_MAX_MCAM_WIDTH_DWORDS; idx++) {
+ flow->mcam_data[idx] |= base_entry->kw[idx];
+ flow->mcam_mask[idx] |= base_entry->kw_mask[idx];
+ }
+
+ return 0;
+}
git.droids-corp.org / dpdk.git / blobdiff