{
struct npc *npc = roc_npc_to_npc_priv(roc_npc);
- return npc->vtag_actions;
+ return npc->vtag_strip_actions;
}
int
{
struct npc *npc = roc_npc_to_npc_priv(roc_npc);
- npc->vtag_actions -= count;
- return npc->vtag_actions;
+ npc->vtag_strip_actions -= count;
+ return npc->vtag_strip_actions;
}
int
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);
}
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;
+}
- if (npc->free_entries_rev) {
- plt_free(npc->free_entries_rev);
- npc->free_entries_rev = NULL;
+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) {
- plt_free(npc->free_entries);
- npc->free_entries = NULL;
+ if (nix_dst->dev.vf >= nix_src->dev.maxvf) {
+ plt_err("Invalid VF for output port");
+ return -EINVAL;
}
- if (npc->flow_entry_info) {
- plt_free(npc->flow_entry_info);
- npc->flow_entry_info = NULL;
+ if (nix_src->dev.pf != nix_dst->dev.pf) {
+ plt_err("Output port should be VF of ingress PF");
+ return -EINVAL;
}
-
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;
/* 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++) {
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;
+
+ /* Special processing when with inline device */
+ if (roc_nix_inb_is_with_inl_dev(roc_npc->roc_nix) &&
+ roc_nix_inl_dev_is_probed()) {
+ rq = 0;
+ pf_func = nix_inl_dev_pffunc_get();
+ }
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 (req_act &
+ ~(ROC_NPC_ACTION_TYPE_VLAN_INSERT |
+ ROC_NPC_ACTION_TYPE_VLAN_ETHTYPE_INSERT |
+ ROC_NPC_ACTION_TYPE_VLAN_PCP_INSERT |
+ ROC_NPC_ACTION_TYPE_DROP | ROC_NPC_ACTION_TYPE_COUNT)) {
+ plt_err("Only VLAN insert, drop, count supported on Egress");
+ errcode = NPC_ERR_ACTION_NOTSUP;
+ goto err_exit;
+ }
+
+ if (vlan_insert_action &&
+ (req_act & ROC_NPC_ACTION_TYPE_DROP)) {
+ plt_err("Both VLAN insert and drop actions cannot be supported");
+ errcode = NPC_ERR_ACTION_NOTSUP;
+ goto err_exit;
+ }
+
if (req_act & ROC_NPC_ACTION_TYPE_DROP) {
flow->npc_action = NIX_TX_ACTIONOP_DROP;
} else if ((req_act & ROC_NPC_ACTION_TYPE_COUNT) ||
}
if (req_act & ROC_NPC_ACTION_TYPE_VLAN_STRIP)
- npc->vtag_actions++;
-
- /* Only VLAN action is provided */
- if (req_act == ROC_NPC_ACTION_TYPE_VLAN_STRIP)
- flow->npc_action = NIX_RX_ACTIONOP_UCAST;
+ npc->vtag_strip_actions++;
/* Set NIX_RX_ACTIONOP */
- if (req_act & (ROC_NPC_ACTION_TYPE_PF | ROC_NPC_ACTION_TYPE_VF)) {
+ if (req_act == ROC_NPC_ACTION_TYPE_VLAN_STRIP) {
+ /* Only VLAN action is provided */
+ flow->npc_action = NIX_RX_ACTIONOP_UCAST;
+ } else if (req_act &
+ (ROC_NPC_ACTION_TYPE_PF | ROC_NPC_ACTION_TYPE_VF)) {
flow->npc_action = NIX_RX_ACTIONOP_UCAST;
if (req_act & ROC_NPC_ACTION_TYPE_QUEUE)
flow->npc_action |= (uint64_t)rq << 20;
}
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;
vtag_cfg->tx.vtag0_idx = tx_vtag_action.act.vtag0_def;
vtag_cfg->tx.free_vtag0 = true;
+ if (flow->vtag_insert_count == 2) {
+ vtag_cfg->tx.vtag1_idx = tx_vtag_action.act.vtag1_def;
+ vtag_cfg->tx.free_vtag1 = true;
+ }
+
rc = mbox_process_msg(mbox, (void *)&rsp);
if (rc)
return rc;
}
static int
-npc_vtag_action_program(struct roc_npc *roc_npc,
- const struct roc_npc_action actions[],
- struct roc_npc_flow *flow)
+npc_vtag_insert_action_parse(const struct roc_npc_action actions[],
+ struct roc_npc_flow *flow,
+ struct npc_action_vtag_info *vlan_info,
+ int *parsed_cnt)
{
- uint16_t vlan_id = 0, vlan_ethtype = ROC_ETHER_TYPE_VLAN;
- struct npc *npc = roc_npc_to_npc_priv(roc_npc);
- struct roc_nix *roc_nix = roc_npc->roc_nix;
- struct nix_vtag_config *vtag_cfg;
- struct nix_vtag_config_rsp *rsp;
- uint64_t rx_vtag_action = 0;
- uint8_t vlan_pcp = 0;
- struct mbox *mbox;
- struct nix *nix;
- int rc;
-
- union {
- uint64_t reg;
- struct nix_tx_vtag_action_s act;
- } tx_vtag_action;
-
- nix = roc_nix_to_nix_priv(roc_nix);
- mbox = (&nix->dev)->mbox;
-
- flow->vtag_insert_enabled = false;
+ bool vlan_id_found = false, ethtype_found = false, pcp_found = false;
+ int count = 0;
- for (; actions->type != ROC_NPC_ACTION_TYPE_END; actions++) {
- if (actions->type == ROC_NPC_ACTION_TYPE_VLAN_STRIP) {
- if (npc->vtag_actions == 1) {
- vtag_cfg = mbox_alloc_msg_nix_vtag_cfg(mbox);
+ *parsed_cnt = 0;
- if (vtag_cfg == NULL)
- return -ENOSPC;
+ /* This function parses parameters of one VLAN. When a parameter is
+ * found repeated, it treats it as the end of first VLAN's parameters
+ * and returns. The caller calls again to parse the parameters of the
+ * second VLAN.
+ */
- vtag_cfg->cfg_type = VTAG_RX;
- vtag_cfg->rx.strip_vtag = 1;
- /* Always capture */
- vtag_cfg->rx.capture_vtag = 1;
- vtag_cfg->vtag_size = NIX_VTAGSIZE_T4;
- vtag_cfg->rx.vtag_type = 0;
+ for (; count < NPC_ACTION_MAX_VLAN_PARAMS; count++, actions++) {
+ if (actions->type == ROC_NPC_ACTION_TYPE_VLAN_INSERT) {
+ if (vlan_id_found)
+ return 0;
- rc = mbox_process(mbox);
- if (rc)
- return rc;
- }
-
- rx_vtag_action |= (NIX_RX_VTAGACTION_VTAG_VALID << 15);
- rx_vtag_action |= ((uint64_t)NPC_LID_LB << 8);
- rx_vtag_action |= NIX_RX_VTAGACTION_VTAG0_RELPTR;
- flow->vtag_action = rx_vtag_action;
- } else if (actions->type == ROC_NPC_ACTION_TYPE_VLAN_INSERT) {
const struct roc_npc_action_of_set_vlan_vid *vtag =
(const struct roc_npc_action_of_set_vlan_vid *)
actions->conf;
- vlan_id = plt_be_to_cpu_16(vtag->vlan_vid);
- if (vlan_id > 0xfff) {
+
+ vlan_info->vlan_id = plt_be_to_cpu_16(vtag->vlan_vid);
+
+ if (vlan_info->vlan_id > 0xfff) {
plt_err("Invalid vlan_id for set vlan action");
return -EINVAL;
}
+
flow->vtag_insert_enabled = true;
+ (*parsed_cnt)++;
+ vlan_id_found = true;
} else if (actions->type ==
ROC_NPC_ACTION_TYPE_VLAN_ETHTYPE_INSERT) {
+ if (ethtype_found)
+ return 0;
+
const struct roc_npc_action_of_push_vlan *ethtype =
(const struct roc_npc_action_of_push_vlan *)
actions->conf;
- vlan_ethtype = plt_be_to_cpu_16(ethtype->ethertype);
- if (vlan_ethtype != ROC_ETHER_TYPE_VLAN &&
- vlan_ethtype != ROC_ETHER_TYPE_QINQ) {
+ vlan_info->vlan_ethtype =
+ plt_be_to_cpu_16(ethtype->ethertype);
+ if (vlan_info->vlan_ethtype != ROC_ETHER_TYPE_VLAN &&
+ vlan_info->vlan_ethtype != ROC_ETHER_TYPE_QINQ) {
plt_err("Invalid ethtype specified for push"
" vlan action");
return -EINVAL;
}
flow->vtag_insert_enabled = true;
+ (*parsed_cnt)++;
+ ethtype_found = true;
} else if (actions->type ==
ROC_NPC_ACTION_TYPE_VLAN_PCP_INSERT) {
+ if (pcp_found)
+ return 0;
const struct roc_npc_action_of_set_vlan_pcp *pcp =
(const struct roc_npc_action_of_set_vlan_pcp *)
actions->conf;
- vlan_pcp = pcp->vlan_pcp;
- if (vlan_pcp > 0x7) {
+ vlan_info->vlan_pcp = pcp->vlan_pcp;
+ if (vlan_info->vlan_pcp > 0x7) {
plt_err("Invalid PCP value for pcp action");
return -EINVAL;
}
flow->vtag_insert_enabled = true;
+ (*parsed_cnt)++;
+ pcp_found = true;
+ } else {
+ return 0;
}
}
- if (flow->vtag_insert_enabled) {
- vtag_cfg = mbox_alloc_msg_nix_vtag_cfg(mbox);
+ return 0;
+}
- if (vtag_cfg == NULL)
- return -ENOSPC;
+static int
+npc_vtag_insert_action_configure(struct mbox *mbox, struct roc_npc_flow *flow,
+ struct npc_action_vtag_info *vlan_info)
+{
+ struct nix_vtag_config *vtag_cfg;
+ struct nix_vtag_config_rsp *rsp;
+ int rc = 0;
- vtag_cfg->cfg_type = VTAG_TX;
- vtag_cfg->vtag_size = NIX_VTAGSIZE_T4;
- vtag_cfg->tx.vtag0 =
- ((vlan_ethtype << 16) | (vlan_pcp << 13) | vlan_id);
+ union {
+ uint64_t reg;
+ struct nix_tx_vtag_action_s act;
+ } tx_vtag_action;
- vtag_cfg->tx.cfg_vtag0 = 1;
- rc = mbox_process_msg(mbox, (void *)&rsp);
- if (rc)
- return rc;
+ vtag_cfg = mbox_alloc_msg_nix_vtag_cfg(mbox);
- if (rsp->vtag0_idx < 0) {
- plt_err("Failed to config TX VTAG action");
- return -EINVAL;
- }
+ if (vtag_cfg == NULL)
+ return -ENOSPC;
+
+ vtag_cfg->cfg_type = VTAG_TX;
+ vtag_cfg->vtag_size = NIX_VTAGSIZE_T4;
+ vtag_cfg->tx.vtag0 =
+ ((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) |
+ (vlan_info[1].vlan_pcp << 13) | vlan_info[1].vlan_id);
+
+ vtag_cfg->tx.cfg_vtag1 = 1;
+ }
- tx_vtag_action.reg = 0;
- tx_vtag_action.act.vtag0_def = rsp->vtag0_idx;
- tx_vtag_action.act.vtag0_lid = NPC_LID_LA;
- tx_vtag_action.act.vtag0_op = NIX_TX_VTAGOP_INSERT;
- tx_vtag_action.act.vtag0_relptr =
+ rc = mbox_process_msg(mbox, (void *)&rsp);
+ if (rc)
+ return rc;
+
+ if (rsp->vtag0_idx < 0 ||
+ ((flow->vtag_insert_count == 2) && (rsp->vtag1_idx < 0))) {
+ plt_err("Failed to config TX VTAG action");
+ return -EINVAL;
+ }
+
+ tx_vtag_action.reg = 0;
+ tx_vtag_action.act.vtag0_def = rsp->vtag0_idx;
+ tx_vtag_action.act.vtag0_lid = NPC_LID_LA;
+ tx_vtag_action.act.vtag0_op = NIX_TX_VTAGOP_INSERT;
+ tx_vtag_action.act.vtag0_relptr = NIX_TX_VTAGACTION_VTAG0_RELPTR;
+
+ if (flow->vtag_insert_count == 2) {
+ tx_vtag_action.act.vtag1_def = rsp->vtag1_idx;
+ tx_vtag_action.act.vtag1_lid = NPC_LID_LA;
+ tx_vtag_action.act.vtag1_op = NIX_TX_VTAGOP_INSERT;
+ /* NIX_TX_VTAG_ACTION_S
+ * If Vtag 0 is inserted, hardware adjusts the Vtag 1 byte
+ * offset accordingly. Thus, if the two offsets are equal in
+ * the structure, hardware inserts Vtag 1 immediately after
+ * Vtag 0 in the packet.
+ */
+ tx_vtag_action.act.vtag1_relptr =
NIX_TX_VTAGACTION_VTAG0_RELPTR;
- flow->vtag_action = tx_vtag_action.reg;
+ }
+
+ flow->vtag_action = tx_vtag_action.reg;
+
+ return 0;
+}
+
+static int
+npc_vtag_strip_action_configure(struct mbox *mbox,
+ const struct roc_npc_action actions[],
+ struct roc_npc_flow *flow, int *strip_cnt)
+{
+ struct nix_vtag_config *vtag_cfg;
+ uint64_t rx_vtag_action = 0;
+ int count = 0, rc = 0;
+
+ *strip_cnt = 0;
+
+ for (; count < NPC_ACTION_MAX_VLANS_STRIPPED; count++, actions++) {
+ if (actions->type == ROC_NPC_ACTION_TYPE_VLAN_STRIP)
+ (*strip_cnt)++;
+ }
+
+ vtag_cfg = mbox_alloc_msg_nix_vtag_cfg(mbox);
+
+ if (vtag_cfg == NULL)
+ return -ENOSPC;
+
+ vtag_cfg->cfg_type = VTAG_RX;
+ vtag_cfg->rx.strip_vtag = 1;
+ /* Always capture */
+ vtag_cfg->rx.capture_vtag = 1;
+ vtag_cfg->vtag_size = NIX_VTAGSIZE_T4;
+ vtag_cfg->rx.vtag_type = 0;
+
+ rc = mbox_process(mbox);
+ if (rc)
+ return rc;
+
+ rx_vtag_action |= (NIX_RX_VTAGACTION_VTAG_VALID << 15);
+ rx_vtag_action |= ((uint64_t)NPC_LID_LB << 8);
+ rx_vtag_action |= NIX_RX_VTAGACTION_VTAG0_RELPTR;
+
+ if (*strip_cnt == 2) {
+ rx_vtag_action |= (NIX_RX_VTAGACTION_VTAG_VALID << 47);
+ rx_vtag_action |= ((uint64_t)NPC_LID_LB << 40);
+ rx_vtag_action |= NIX_RX_VTAGACTION_VTAG0_RELPTR << 32;
+ }
+ flow->vtag_action = rx_vtag_action;
+
+ return 0;
+}
+
+static int
+npc_vtag_action_program(struct roc_npc *roc_npc,
+ const struct roc_npc_action actions[],
+ struct roc_npc_flow *flow)
+{
+ bool vlan_strip_parsed = false, vlan_insert_parsed = false;
+ const struct roc_npc_action *insert_actions;
+ struct roc_nix *roc_nix = roc_npc->roc_nix;
+ struct npc_action_vtag_info vlan_info[2];
+ int parsed_cnt = 0, strip_cnt = 0;
+ int tot_vlan_params = 0;
+ struct mbox *mbox;
+ struct nix *nix;
+ int i, rc;
+
+ nix = roc_nix_to_nix_priv(roc_nix);
+ mbox = (&nix->dev)->mbox;
+
+ memset(vlan_info, 0, sizeof(vlan_info));
+
+ flow->vtag_insert_enabled = false;
+
+ for (; actions->type != ROC_NPC_ACTION_TYPE_END; actions++) {
+ if (actions->type == ROC_NPC_ACTION_TYPE_VLAN_STRIP) {
+ if (vlan_strip_parsed) {
+ plt_err("Incorrect VLAN strip actions");
+ return -EINVAL;
+ }
+ rc = npc_vtag_strip_action_configure(mbox, actions,
+ flow, &strip_cnt);
+ if (rc)
+ return rc;
+
+ if (strip_cnt == 2)
+ actions++;
+
+ vlan_strip_parsed = true;
+ } else if (actions->type == ROC_NPC_ACTION_TYPE_VLAN_INSERT ||
+ actions->type ==
+ ROC_NPC_ACTION_TYPE_VLAN_ETHTYPE_INSERT ||
+ actions->type ==
+ ROC_NPC_ACTION_TYPE_VLAN_PCP_INSERT) {
+ if (vlan_insert_parsed) {
+ plt_err("Incorrect VLAN insert actions");
+ return -EINVAL;
+ }
+
+ insert_actions = actions;
+
+ for (i = 0; i < 2; i++) {
+ rc = npc_vtag_insert_action_parse(
+ insert_actions, flow, &vlan_info[i],
+ &parsed_cnt);
+
+ if (rc)
+ return rc;
+
+ if (parsed_cnt) {
+ insert_actions += parsed_cnt;
+ tot_vlan_params += parsed_cnt;
+ flow->vtag_insert_count++;
+ }
+ }
+ actions += tot_vlan_params - 1;
+ vlan_insert_parsed = true;
+ }
+ }
+
+ if (flow->vtag_insert_enabled) {
+ rc = npc_vtag_insert_action_configure(mbox, flow, vlan_info);
+
+ if (rc)
+ return rc;
}
return 0;
}
struct npc_flow_list *list;
int rc;
+ npc->channel = roc_npc->channel;
+
flow = plt_zmalloc(sizeof(*flow), 0);
if (flow == NULL) {
*errcode = NPC_ERR_NO_MEM;
}
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);
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