broadcom/bnxt/bnxt_tc.c

44 /* Return the dst fid of the func for flow forwarding
370 			      struct bnxt_tc_flow *flow)
391 		flow->l2_key.ether_type = match.key->n_proto;
392 		flow->l2_mask.ether_type = match.mask->n_proto;
396 			flow->l4_key.ip_proto = match.key->ip_proto;
397 			flow->l4_mask.ip_proto = match.mask->ip_proto;
405 		flow->flags |= BNXT_TC_FLOW_FLAGS_ETH_ADDRS;
406 		ether_addr_copy(flow->l2_key.dmac, match.key->dst);
407 		ether_addr_copy(flow->l2_mask.dmac, match.mask->dst);
408 		ether_addr_copy(flow->l2_key.smac, match.key->src);
409 		ether_addr_copy(flow->l2_mask.smac, match.mask->src);
416 		flow->l2_key.inner_vlan_tci =
419 		flow->l2_mask.inner_vlan_tci =
422 		flow->l2_key.inner_vlan_tpid = htons(ETH_P_8021Q);
423 		flow->l2_mask.inner_vlan_tpid = htons(0xffff);
424 		flow->l2_key.num_vlans = 1;
431 		flow->flags |= BNXT_TC_FLOW_FLAGS_IPV4_ADDRS;
432 		flow->l3_key.ipv4.daddr.s_addr = match.key->dst;
433 		flow->l3_mask.ipv4.daddr.s_addr = match.mask->dst;
434 		flow->l3_key.ipv4.saddr.s_addr = match.key->src;
435 		flow->l3_mask.ipv4.saddr.s_addr = match.mask->src;
440 		flow->flags |= BNXT_TC_FLOW_FLAGS_IPV6_ADDRS;
441 		flow->l3_key.ipv6.daddr = match.key->dst;
442 		flow->l3_mask.ipv6.daddr = match.mask->dst;
443 		flow->l3_key.ipv6.saddr = match.key->src;
444 		flow->l3_mask.ipv6.saddr = match.mask->src;
451 		flow->flags |= BNXT_TC_FLOW_FLAGS_PORTS;
452 		flow->l4_key.ports.dport = match.key->dst;
453 		flow->l4_mask.ports.dport = match.mask->dst;
454 		flow->l4_key.ports.sport = match.key->src;
455 		flow->l4_mask.ports.sport = match.mask->src;
462 		flow->flags |= BNXT_TC_FLOW_FLAGS_ICMP;
463 		flow->l4_key.icmp.type = match.key->type;
464 		flow->l4_key.icmp.code = match.key->code;
465 		flow->l4_mask.icmp.type = match.mask->type;
466 		flow->l4_mask.icmp.code = match.mask->code;
473 		flow->flags |= BNXT_TC_FLOW_FLAGS_TUNL_IPV4_ADDRS;
474 		flow->tun_key.u.ipv4.dst = match.key->dst;
475 		flow->tun_mask.u.ipv4.dst = match.mask->dst;
476 		flow->tun_key.u.ipv4.src = match.key->src;
477 		flow->tun_mask.u.ipv4.src = match.mask->src;
487 		flow->flags |= BNXT_TC_FLOW_FLAGS_TUNL_ID;
488 		flow->tun_key.tun_id = key32_to_tunnel_id(match.key->keyid);
489 		flow->tun_mask.tun_id = key32_to_tunnel_id(match.mask->keyid);
496 		flow->flags |= BNXT_TC_FLOW_FLAGS_TUNL_PORTS;
497 		flow->tun_key.tp_dst = match.key->dst;
498 		flow->tun_mask.tp_dst = match.mask->dst;
499 		flow->tun_key.tp_src = match.key->src;
500 		flow->tun_mask.tp_src = match.mask->src;
503 	return bnxt_tc_parse_actions(bp, &flow->actions, &rule->action,
589 static int bnxt_hwrm_cfa_flow_alloc(struct bnxt *bp, struct bnxt_tc_flow *flow,
594 	struct bnxt_tc_actions *actions = &flow->actions;
595 	struct bnxt_tc_l3_key *l3_mask = &flow->l3_mask;
596 	struct bnxt_tc_l3_key *l3_key = &flow->l3_key;
606 	req->src_fid = cpu_to_le16(flow->src_fid);
686 	req->ethertype = flow->l2_key.ether_type;
687 	req->ip_proto = flow->l4_key.ip_proto;
689 	if (flow->flags & BNXT_TC_FLOW_FLAGS_ETH_ADDRS) {
690 		memcpy(req->dmac, flow->l2_key.dmac, ETH_ALEN);
691 		memcpy(req->smac, flow->l2_key.smac, ETH_ALEN);
694 	if (flow->l2_key.num_vlans > 0) {
700 		req->outer_vlan_tci = flow->l2_key.inner_vlan_tci;
703 	/* If all IP and L4 fields are wildcarded then this is an L2 flow */
705 	    is_wildcard(&flow->l4_mask, sizeof(flow->l4_mask))) {
708 		flow_flags |= flow->l2_key.ether_type == htons(ETH_P_IP) ?
712 		if (flow->flags & BNXT_TC_FLOW_FLAGS_IPV4_ADDRS) {
719 		} else if (flow->flags & BNXT_TC_FLOW_FLAGS_IPV6_ADDRS) {
731 	if (flow->flags & BNXT_TC_FLOW_FLAGS_PORTS) {
732 		req->l4_src_port = flow->l4_key.ports.sport;
733 		req->l4_src_port_mask = flow->l4_mask.ports.sport;
734 		req->l4_dst_port = flow->l4_key.ports.dport;
735 		req->l4_dst_port_mask = flow->l4_mask.ports.dport;
736 	} else if (flow->flags & BNXT_TC_FLOW_FLAGS_ICMP) {
738 		req->l4_src_port = htons(flow->l4_key.icmp.type);
739 		req->l4_src_port_mask = htons(flow->l4_mask.icmp.type);
740 		req->l4_dst_port = htons(flow->l4_key.icmp.code);
741 		req->l4_dst_port_mask = htons(flow->l4_mask.icmp.code);
777 		 *		    flow handle      flow handle
779 		 * flow_handle      flow handle      flow context id
780 		 * ext_flow_handle  INVALID	     flow handle
781 		 * flow_id	    INVALID	     flow counter id
794 				       struct bnxt_tc_flow *flow,
800 	struct ip_tunnel_key *tun_key = &flow->tun_key;
815 	if (flow->flags & BNXT_TC_FLOW_FLAGS_TUNL_ID) {
821 	if (flow->flags & BNXT_TC_FLOW_FLAGS_TUNL_ETH_ADDRS) {
833 	if (flow->flags & BNXT_TC_FLOW_FLAGS_TUNL_IPV4_ADDRS) {
843 	if (flow->flags & BNXT_TC_FLOW_FLAGS_TUNL_PORTS) {
956 	/* remove flow_node from the L2 shared flow list */
1001 /* Get the ref_flow_handle for a flow by checking if there are any other
1002  * flows that share the same L2 key as this flow.
1005 bnxt_tc_get_ref_flow_handle(struct bnxt *bp, struct bnxt_tc_flow *flow,
1015 				      &flow->l2_key);
1019 	/* If any other flow is using this l2_node, use it's flow_handle
1032 	 * with a matching l2 key can use the flow_handle of this flow
1041 /* After the flow parsing is done, this routine is used for checking
1042  * if there are any aspects of the flow that prevent it from being
1045 static bool bnxt_tc_can_offload(struct bnxt *bp, struct bnxt_tc_flow *flow)
1048 	if ((flow->flags & BNXT_TC_FLOW_FLAGS_PORTS) &&
1049 	    (flow->l4_key.ip_proto != IPPROTO_TCP &&
1050 	     flow->l4_key.ip_proto != IPPROTO_UDP)) {
1052 			    flow->l4_key.ip_proto);
1057 	if (bits_set(&flow->l2_key.smac, sizeof(flow->l2_key.smac)) &&
1058 	    !is_exactmatch(flow->l2_mask.smac, sizeof(flow->l2_mask.smac))) {
1062 	if (bits_set(&flow->l2_key.dmac, sizeof(flow->l2_key.dmac)) &&
1063 	    !is_exactmatch(&flow->l2_mask.dmac, sizeof(flow->l2_mask.dmac))) {
1069 	if (bits_set(&flow->l2_key.inner_vlan_tci,
1070 		     sizeof(flow->l2_key.inner_vlan_tci)) &&
1071 	    !is_vlan_tci_allowed(flow->l2_mask.inner_vlan_tci,
1072 				 flow->l2_key.inner_vlan_tci)) {
1076 	if (bits_set(&flow->l2_key.inner_vlan_tpid,
1077 		     sizeof(flow->l2_key.inner_vlan_tpid)) &&
1078 	    !is_exactmatch(&flow->l2_mask.inner_vlan_tpid,
1079 			   sizeof(flow->l2_mask.inner_vlan_tpid))) {
1085 	if (!is_exactmatch(&flow->l2_mask.ether_type,
1086 			   sizeof(flow->l2_mask.ether_type))) {
1154 					struct bnxt_tc_flow *flow,
1169 	/* If any other flow is using this decap_l2_node, use it's decap_handle
1184 	 * this flow as their ref_decap_handle
1200 	/* remove flow_node from the decap L2 sharing flow list */
1235 	struct flowi4 flow = { {0} };
1241 	flow.flowi4_proto = IPPROTO_UDP;
1242 	flow.fl4_dport = tun_key->tp_dst;
1243 	flow.daddr = tun_key->u.ipv4.dst;
1245 	rt = ip_route_output_key(dev_net(real_dst_dev), &flow);
1247 		netdev_info(bp->dev, "no route to %pI4b\n", &flow.daddr);
1274 			    netdev_name(dst_dev), &flow.daddr,
1280 	nbr = dst_neigh_lookup(&rt->dst, &flow.daddr);
1283 			    &flow.daddr);
1288 	tun_key->u.ipv4.src = flow.saddr;
1304 static int bnxt_tc_get_decap_handle(struct bnxt *bp, struct bnxt_tc_flow *flow,
1308 	struct ip_tunnel_key *decap_key = &flow->tun_key;
1317 	/* Check if there's another flow using the same tunnel decap.
1338 	tun_key.u.ipv4.dst = flow->tun_key.u.ipv4.src;
1339 	tun_key.tp_dst = flow->tun_key.tp_dst;
1352 	flow->flags |= BNXT_TC_FLOW_FLAGS_TUNL_ETH_ADDRS;
1356 	 * key and if so, pass that flow's decap_filter_handle as the
1357 	 * ref_decap_handle for this flow.
1359 	rc = bnxt_tc_get_ref_decap_handle(bp, flow, decap_l2_info, flow_node,
1365 	rc = hwrm_cfa_decap_filter_alloc(bp, flow, decap_l2_info,
1402 static int bnxt_tc_get_encap_handle(struct bnxt *bp, struct bnxt_tc_flow *flow,
1406 	struct ip_tunnel_key *encap_key = &flow->actions.tun_encap_key;
1411 	/* Check if there's another flow using the same tunnel encap.
1447 				      struct bnxt_tc_flow *flow,
1450 	if (flow->actions.flags & BNXT_TC_ACTION_FLAG_TUNNEL_DECAP)
1452 	else if (flow->actions.flags & BNXT_TC_ACTION_FLAG_TUNNEL_ENCAP)
1457 				     struct bnxt_tc_flow *flow,
1461 	if (flow->actions.flags & BNXT_TC_ACTION_FLAG_TUNNEL_DECAP)
1462 		return bnxt_tc_get_decap_handle(bp, flow, flow_node,
1464 	else if (flow->actions.flags & BNXT_TC_ACTION_FLAG_TUNNEL_ENCAP)
1465 		return bnxt_tc_get_encap_handle(bp, flow, flow_node,
1476 	/* send HWRM cmd to free the flow-id */
1482 	bnxt_tc_put_tunnel_handle(bp, &flow_node->flow, flow_node);
1499 static void bnxt_tc_set_flow_dir(struct bnxt *bp, struct bnxt_tc_flow *flow,
1502 	flow->l2_key.dir = (bp->pf.fw_fid == src_fid) ? BNXT_DIR_RX : BNXT_DIR_TX;
1505 static void bnxt_tc_set_src_fid(struct bnxt *bp, struct bnxt_tc_flow *flow,
1508 	if (flow->actions.flags & BNXT_TC_ACTION_FLAG_TUNNEL_DECAP)
1509 		flow->src_fid = bp->pf.fw_fid;
1511 		flow->src_fid = src_fid;
1514 /* Add a new flow or replace an existing flow.
1517  * 1. while adding a new flow
1520  *    c) link l2-key with flow
1521  * 2. while deleting a flow
1522  *    a) unlinking l2-key from flow
1532 	struct bnxt_tc_flow *flow;
1537 	/* allocate memory for the new flow and it's node */
1544 	flow = &new_node->flow;
1546 	rc = bnxt_tc_parse_flow(bp, tc_flow_cmd, flow);
1550 	bnxt_tc_set_src_fid(bp, flow, src_fid);
1551 	bnxt_tc_set_flow_dir(bp, flow, flow->src_fid);
1553 	if (!bnxt_tc_can_offload(bp, flow)) {
1559 	/* If a flow exists with the same cookie, delete it */
1566 	/* Check if the L2 part of the flow has been offloaded already.
1570 	rc = bnxt_tc_get_ref_flow_handle(bp, flow, new_node, &ref_flow_handle);
1574 	/* If the flow involves tunnel encap/decap, get tunnel_handle */
1575 	rc = bnxt_tc_get_tunnel_handle(bp, flow, new_node, &tunnel_handle);
1579 	/* send HWRM cmd to alloc the flow */
1580 	rc = bnxt_hwrm_cfa_flow_alloc(bp, flow, ref_flow_handle,
1585 	flow->lastused = jiffies;
1586 	spin_lock_init(&flow->stats_lock);
1587 	/* add new flow to flow-table */
1599 	bnxt_tc_put_tunnel_handle(bp, flow, new_node);
1633 	struct bnxt_tc_flow *flow;
1642 	flow = &flow_node->flow;
1643 	curr_stats = &flow->stats;
1644 	prev_stats = &flow->prev_stats;
1646 	spin_lock(&flow->stats_lock);
1650 	lastused = flow->lastused;
1651 	spin_unlock(&flow->stats_lock);
1667 		/* If flow_id is used to fetch flow stats then:
1669 		 * 2. 15th bit of flow_handle must specify the flow
1672 		if (flow_node->flow.l2_key.dir == BNXT_DIR_RX)
1773 		struct bnxt_tc_flow *flow = &flow_node->flow;
1775 		spin_lock(&flow->stats_lock);
1776 		bnxt_flow_stats_accum(tc_info, &flow->stats,
1778 		if (flow->stats.packets != flow->prev_stats.packets)
1779 			flow->lastused = jiffies;
1780 		spin_unlock(&flow->stats_lock);