Commit 90a825a4 authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'dpaa2-switch-tc-hw-offload' 



Ioana Ciornei says:

====================
dpaa2-switch: add tc hardware offload on ingress traffic

This patch set adds tc hardware offload on ingress traffic in
dpaa2-switch. The cls flower and matchall classifiers are supported
using the same ACL infrastructure supported by the dpaa2-switch.

The first patch creates a new structure to hold all the necessary
information related to an ACL table. This structure is used in the next
patches to create a link between each switch port and the table used.
Multiple ports can share the same ACL table when they also share the
ingress tc block. Also, some small changes in the priority of the
default STP trap is done in the second patch.

The support for cls flower is added in the 3rd patch, while the 4th
one builds on top of the infrastructure put in place and adds cls
matchall support.

The following flow keys are supported:
 - Ethernet: dst_mac/src_mac
 - IPv4: dst_ip/src_ip/ip_proto/tos
 - VLAN: vlan_id/vlan_prio/vlan_tpid/vlan_dei
 - L4: dst_port/src_port

Each filter can support only one action from the following list:
 - drop
 - mirred egress redirect
 - trap

With the last patch, we reuse the dpaa2_switch_acl_entry_add() function
added previously instead of open-coding the install of a new ACL entry
into the table.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 5871d0c6 16617954

drivers/net/ethernet/freescale/dpaa2/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -11,7 +11,7 @@ fsl-dpaa2-eth-objs := dpaa2-eth.o dpaa2-ethtool.o dpni.o dpaa2-mac.o dpmac.o dpa 
fsl-dpaa2-eth-${CONFIG_FSL_DPAA2_ETH_DCB} += dpaa2-eth-dcb.o

fsl-dpaa2-eth-${CONFIG_DEBUG_FS} += dpaa2-eth-debugfs.o

fsl-dpaa2-ptp-objs	:= dpaa2-ptp.o dprtc.o

fsl-dpaa2-switch-objs	:= dpaa2-switch.o dpaa2-switch-ethtool.o dpsw.o

fsl-dpaa2-switch-objs	:= dpaa2-switch.o dpaa2-switch-ethtool.o dpsw.o dpaa2-switch-flower.o



# Needed by the tracing framework

CFLAGS_dpaa2-eth.o := -I$(src)

drivers/net/ethernet/freescale/dpaa2/dpaa2-switch-flower.c

0 → 100644
+492 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

/*

 * DPAA2 Ethernet Switch flower support

 *

 * Copyright 2021 NXP

 *

 */



#include "dpaa2-switch.h"



static int dpaa2_switch_flower_parse_key(struct flow_cls_offload *cls,

					 struct dpsw_acl_key *acl_key)

{

	struct flow_rule *rule = flow_cls_offload_flow_rule(cls);

	struct flow_dissector *dissector = rule->match.dissector;

	struct netlink_ext_ack *extack = cls->common.extack;

	struct dpsw_acl_fields *acl_h, *acl_m;



	if (dissector->used_keys &

	    ~(BIT(FLOW_DISSECTOR_KEY_BASIC) |

	      BIT(FLOW_DISSECTOR_KEY_CONTROL) |

	      BIT(FLOW_DISSECTOR_KEY_ETH_ADDRS) |

	      BIT(FLOW_DISSECTOR_KEY_VLAN) |

	      BIT(FLOW_DISSECTOR_KEY_PORTS) |

	      BIT(FLOW_DISSECTOR_KEY_IP) |

	      BIT(FLOW_DISSECTOR_KEY_IPV6_ADDRS) |

	      BIT(FLOW_DISSECTOR_KEY_IPV4_ADDRS))) {

		NL_SET_ERR_MSG_MOD(extack,

				   "Unsupported keys used");

		return -EOPNOTSUPP;

	}



	acl_h = &acl_key->match;

	acl_m = &acl_key->mask;



	if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_BASIC)) {

		struct flow_match_basic match;



		flow_rule_match_basic(rule, &match);

		acl_h->l3_protocol = match.key->ip_proto;

		acl_h->l2_ether_type = be16_to_cpu(match.key->n_proto);

		acl_m->l3_protocol = match.mask->ip_proto;

		acl_m->l2_ether_type = be16_to_cpu(match.mask->n_proto);

	}



	if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_ETH_ADDRS)) {

		struct flow_match_eth_addrs match;



		flow_rule_match_eth_addrs(rule, &match);

		ether_addr_copy(acl_h->l2_dest_mac, &match.key->dst[0]);

		ether_addr_copy(acl_h->l2_source_mac, &match.key->src[0]);

		ether_addr_copy(acl_m->l2_dest_mac, &match.mask->dst[0]);

		ether_addr_copy(acl_m->l2_source_mac, &match.mask->src[0]);

	}



	if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_VLAN)) {

		struct flow_match_vlan match;



		flow_rule_match_vlan(rule, &match);

		acl_h->l2_vlan_id = match.key->vlan_id;

		acl_h->l2_tpid = be16_to_cpu(match.key->vlan_tpid);

		acl_h->l2_pcp_dei = match.key->vlan_priority << 1 |

				    match.key->vlan_dei;



		acl_m->l2_vlan_id = match.mask->vlan_id;

		acl_m->l2_tpid = be16_to_cpu(match.mask->vlan_tpid);

		acl_m->l2_pcp_dei = match.mask->vlan_priority << 1 |

				    match.mask->vlan_dei;

	}



	if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_IPV4_ADDRS)) {

		struct flow_match_ipv4_addrs match;



		flow_rule_match_ipv4_addrs(rule, &match);

		acl_h->l3_source_ip = be32_to_cpu(match.key->src);

		acl_h->l3_dest_ip = be32_to_cpu(match.key->dst);

		acl_m->l3_source_ip = be32_to_cpu(match.mask->src);

		acl_m->l3_dest_ip = be32_to_cpu(match.mask->dst);

	}



	if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_PORTS)) {

		struct flow_match_ports match;



		flow_rule_match_ports(rule, &match);

		acl_h->l4_source_port = be16_to_cpu(match.key->src);

		acl_h->l4_dest_port = be16_to_cpu(match.key->dst);

		acl_m->l4_source_port = be16_to_cpu(match.mask->src);

		acl_m->l4_dest_port = be16_to_cpu(match.mask->dst);

	}



	if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_IP)) {

		struct flow_match_ip match;



		flow_rule_match_ip(rule, &match);

		if (match.mask->ttl != 0) {

			NL_SET_ERR_MSG_MOD(extack,

					   "Matching on TTL not supported");

			return -EOPNOTSUPP;

		}



		if ((match.mask->tos & 0x3) != 0) {

			NL_SET_ERR_MSG_MOD(extack,

					   "Matching on ECN not supported, only DSCP");

			return -EOPNOTSUPP;

		}



		acl_h->l3_dscp = match.key->tos >> 2;

		acl_m->l3_dscp = match.mask->tos >> 2;

	}



	return 0;

}



int dpaa2_switch_acl_entry_add(struct dpaa2_switch_acl_tbl *acl_tbl,

			       struct dpaa2_switch_acl_entry *entry)

{

	struct dpsw_acl_entry_cfg *acl_entry_cfg = &entry->cfg;

	struct ethsw_core *ethsw = acl_tbl->ethsw;

	struct dpsw_acl_key *acl_key = &entry->key;

	struct device *dev = ethsw->dev;

	u8 *cmd_buff;

	int err;



	cmd_buff = kzalloc(DPAA2_ETHSW_PORT_ACL_CMD_BUF_SIZE, GFP_KERNEL);

	if (!cmd_buff)

		return -ENOMEM;



	dpsw_acl_prepare_entry_cfg(acl_key, cmd_buff);



	acl_entry_cfg->key_iova = dma_map_single(dev, cmd_buff,

						 DPAA2_ETHSW_PORT_ACL_CMD_BUF_SIZE,

						 DMA_TO_DEVICE);

	if (unlikely(dma_mapping_error(dev, acl_entry_cfg->key_iova))) {

		dev_err(dev, "DMA mapping failed\n");

		return -EFAULT;

	}



	err = dpsw_acl_add_entry(ethsw->mc_io, 0, ethsw->dpsw_handle,

				 acl_tbl->id, acl_entry_cfg);



	dma_unmap_single(dev, acl_entry_cfg->key_iova, sizeof(cmd_buff),

			 DMA_TO_DEVICE);

	if (err) {

		dev_err(dev, "dpsw_acl_add_entry() failed %d\n", err);

		return err;

	}



	kfree(cmd_buff);



	return 0;

}



static int dpaa2_switch_acl_entry_remove(struct dpaa2_switch_acl_tbl *acl_tbl,

					 struct dpaa2_switch_acl_entry *entry)

{

	struct dpsw_acl_entry_cfg *acl_entry_cfg = &entry->cfg;

	struct dpsw_acl_key *acl_key = &entry->key;

	struct ethsw_core *ethsw = acl_tbl->ethsw;

	struct device *dev = ethsw->dev;

	u8 *cmd_buff;

	int err;



	cmd_buff = kzalloc(DPAA2_ETHSW_PORT_ACL_CMD_BUF_SIZE, GFP_KERNEL);

	if (!cmd_buff)

		return -ENOMEM;



	dpsw_acl_prepare_entry_cfg(acl_key, cmd_buff);



	acl_entry_cfg->key_iova = dma_map_single(dev, cmd_buff,

						 DPAA2_ETHSW_PORT_ACL_CMD_BUF_SIZE,

						 DMA_TO_DEVICE);

	if (unlikely(dma_mapping_error(dev, acl_entry_cfg->key_iova))) {

		dev_err(dev, "DMA mapping failed\n");

		return -EFAULT;

	}



	err = dpsw_acl_remove_entry(ethsw->mc_io, 0, ethsw->dpsw_handle,

				    acl_tbl->id, acl_entry_cfg);



	dma_unmap_single(dev, acl_entry_cfg->key_iova, sizeof(cmd_buff),

			 DMA_TO_DEVICE);

	if (err) {

		dev_err(dev, "dpsw_acl_remove_entry() failed %d\n", err);

		return err;

	}



	kfree(cmd_buff);



	return 0;

}



static int

dpaa2_switch_acl_entry_add_to_list(struct dpaa2_switch_acl_tbl *acl_tbl,

				   struct dpaa2_switch_acl_entry *entry)

{

	struct dpaa2_switch_acl_entry *tmp;

	struct list_head *pos, *n;

	int index = 0;



	if (list_empty(&acl_tbl->entries)) {

		list_add(&entry->list, &acl_tbl->entries);

		return index;

	}



	list_for_each_safe(pos, n, &acl_tbl->entries) {

		tmp = list_entry(pos, struct dpaa2_switch_acl_entry, list);

		if (entry->prio < tmp->prio)

			break;

		index++;

	}

	list_add(&entry->list, pos->prev);

	return index;

}



static struct dpaa2_switch_acl_entry*

dpaa2_switch_acl_entry_get_by_index(struct dpaa2_switch_acl_tbl *acl_tbl,

				    int index)

{

	struct dpaa2_switch_acl_entry *tmp;

	int i = 0;



	list_for_each_entry(tmp, &acl_tbl->entries, list) {

		if (i == index)

			return tmp;

		++i;

	}



	return NULL;

}



static int

dpaa2_switch_acl_entry_set_precedence(struct dpaa2_switch_acl_tbl *acl_tbl,

				      struct dpaa2_switch_acl_entry *entry,

				      int precedence)

{

	int err;



	err = dpaa2_switch_acl_entry_remove(acl_tbl, entry);

	if (err)

		return err;



	entry->cfg.precedence = precedence;

	return dpaa2_switch_acl_entry_add(acl_tbl, entry);

}



static int dpaa2_switch_acl_tbl_add_entry(struct dpaa2_switch_acl_tbl *acl_tbl,

					  struct dpaa2_switch_acl_entry *entry)

{

	struct dpaa2_switch_acl_entry *tmp;

	int index, i, precedence, err;



	/* Add the new ACL entry to the linked list and get its index */

	index = dpaa2_switch_acl_entry_add_to_list(acl_tbl, entry);



	/* Move up in priority the ACL entries to make space

	 * for the new filter.

	 */

	precedence = DPAA2_ETHSW_PORT_MAX_ACL_ENTRIES - acl_tbl->num_rules - 1;

	for (i = 0; i < index; i++) {

		tmp = dpaa2_switch_acl_entry_get_by_index(acl_tbl, i);



		err = dpaa2_switch_acl_entry_set_precedence(acl_tbl, tmp,

							    precedence);

		if (err)

			return err;



		precedence++;

	}



	/* Add the new entry to hardware */

	entry->cfg.precedence = precedence;

	err = dpaa2_switch_acl_entry_add(acl_tbl, entry);

	acl_tbl->num_rules++;



	return err;

}



static struct dpaa2_switch_acl_entry *

dpaa2_switch_acl_tbl_find_entry_by_cookie(struct dpaa2_switch_acl_tbl *acl_tbl,

					  unsigned long cookie)

{

	struct dpaa2_switch_acl_entry *tmp, *n;



	list_for_each_entry_safe(tmp, n, &acl_tbl->entries, list) {

		if (tmp->cookie == cookie)

			return tmp;

	}

	return NULL;

}



static int

dpaa2_switch_acl_entry_get_index(struct dpaa2_switch_acl_tbl *acl_tbl,

				 struct dpaa2_switch_acl_entry *entry)

{

	struct dpaa2_switch_acl_entry *tmp, *n;

	int index = 0;



	list_for_each_entry_safe(tmp, n, &acl_tbl->entries, list) {

		if (tmp->cookie == entry->cookie)

			return index;

		index++;

	}

	return -ENOENT;

}



static int

dpaa2_switch_acl_tbl_remove_entry(struct dpaa2_switch_acl_tbl *acl_tbl,

				  struct dpaa2_switch_acl_entry *entry)

{

	struct dpaa2_switch_acl_entry *tmp;

	int index, i, precedence, err;



	index = dpaa2_switch_acl_entry_get_index(acl_tbl, entry);



	/* Remove from hardware the ACL entry */

	err = dpaa2_switch_acl_entry_remove(acl_tbl, entry);

	if (err)

		return err;



	acl_tbl->num_rules--;



	/* Remove it from the list also */

	list_del(&entry->list);



	/* Move down in priority the entries over the deleted one */

	precedence = entry->cfg.precedence;

	for (i = index - 1; i >= 0; i--) {

		tmp = dpaa2_switch_acl_entry_get_by_index(acl_tbl, i);

		err = dpaa2_switch_acl_entry_set_precedence(acl_tbl, tmp,

							    precedence);

		if (err)

			return err;



		precedence--;

	}



	kfree(entry);



	return 0;

}



static int dpaa2_switch_tc_parse_action(struct ethsw_core *ethsw,

					struct flow_action_entry *cls_act,

					struct dpsw_acl_result *dpsw_act,

					struct netlink_ext_ack *extack)

{

	int err = 0;



	switch (cls_act->id) {

	case FLOW_ACTION_TRAP:

		dpsw_act->action = DPSW_ACL_ACTION_REDIRECT_TO_CTRL_IF;

		break;

	case FLOW_ACTION_REDIRECT:

		if (!dpaa2_switch_port_dev_check(cls_act->dev)) {

			NL_SET_ERR_MSG_MOD(extack,

					   "Destination not a DPAA2 switch port");

			return -EOPNOTSUPP;

		}



		dpsw_act->if_id = dpaa2_switch_get_index(ethsw, cls_act->dev);

		dpsw_act->action = DPSW_ACL_ACTION_REDIRECT;

		break;

	case FLOW_ACTION_DROP:

		dpsw_act->action = DPSW_ACL_ACTION_DROP;

		break;

	default:

		NL_SET_ERR_MSG_MOD(extack,

				   "Action not supported");

		err = -EOPNOTSUPP;

		goto out;

	}



out:

	return err;

}



int dpaa2_switch_cls_flower_replace(struct dpaa2_switch_acl_tbl *acl_tbl,

				    struct flow_cls_offload *cls)

{

	struct flow_rule *rule = flow_cls_offload_flow_rule(cls);

	struct netlink_ext_ack *extack = cls->common.extack;

	struct ethsw_core *ethsw = acl_tbl->ethsw;

	struct dpaa2_switch_acl_entry *acl_entry;

	struct flow_action_entry *act;

	int err;



	if (!flow_offload_has_one_action(&rule->action)) {

		NL_SET_ERR_MSG(extack, "Only singular actions are supported");

		return -EOPNOTSUPP;

	}



	if (dpaa2_switch_acl_tbl_is_full(acl_tbl)) {

		NL_SET_ERR_MSG(extack, "Maximum filter capacity reached");

		return -ENOMEM;

	}



	acl_entry = kzalloc(sizeof(*acl_entry), GFP_KERNEL);

	if (!acl_entry)

		return -ENOMEM;



	err = dpaa2_switch_flower_parse_key(cls, &acl_entry->key);

	if (err)

		goto free_acl_entry;



	act = &rule->action.entries[0];

	err = dpaa2_switch_tc_parse_action(ethsw, act,

					   &acl_entry->cfg.result, extack);

	if (err)

		goto free_acl_entry;



	acl_entry->prio = cls->common.prio;

	acl_entry->cookie = cls->cookie;



	err = dpaa2_switch_acl_tbl_add_entry(acl_tbl, acl_entry);

	if (err)

		goto free_acl_entry;



	return 0;



free_acl_entry:

	kfree(acl_entry);



	return err;

}



int dpaa2_switch_cls_flower_destroy(struct dpaa2_switch_acl_tbl *acl_tbl,

				    struct flow_cls_offload *cls)

{

	struct dpaa2_switch_acl_entry *entry;



	entry = dpaa2_switch_acl_tbl_find_entry_by_cookie(acl_tbl, cls->cookie);

	if (!entry)

		return 0;



	return dpaa2_switch_acl_tbl_remove_entry(acl_tbl, entry);

}



int dpaa2_switch_cls_matchall_replace(struct dpaa2_switch_acl_tbl *acl_tbl,

				      struct tc_cls_matchall_offload *cls)

{

	struct netlink_ext_ack *extack = cls->common.extack;

	struct ethsw_core *ethsw = acl_tbl->ethsw;

	struct dpaa2_switch_acl_entry *acl_entry;

	struct flow_action_entry *act;

	int err;



	if (!flow_offload_has_one_action(&cls->rule->action)) {

		NL_SET_ERR_MSG(extack, "Only singular actions are supported");

		return -EOPNOTSUPP;

	}



	if (dpaa2_switch_acl_tbl_is_full(acl_tbl)) {

		NL_SET_ERR_MSG(extack, "Maximum filter capacity reached");

		return -ENOMEM;

	}



	acl_entry = kzalloc(sizeof(*acl_entry), GFP_KERNEL);

	if (!acl_entry)

		return -ENOMEM;



	act = &cls->rule->action.entries[0];

	err = dpaa2_switch_tc_parse_action(ethsw, act,

					   &acl_entry->cfg.result, extack);

	if (err)

		goto free_acl_entry;



	acl_entry->prio = cls->common.prio;

	acl_entry->cookie = cls->cookie;



	err = dpaa2_switch_acl_tbl_add_entry(acl_tbl, acl_entry);

	if (err)

		goto free_acl_entry;



	return 0;



free_acl_entry:

	kfree(acl_entry);



	return err;

}



int dpaa2_switch_cls_matchall_destroy(struct dpaa2_switch_acl_tbl *acl_tbl,

				      struct tc_cls_matchall_offload *cls)

{

	struct dpaa2_switch_acl_entry *entry;



	entry = dpaa2_switch_acl_tbl_find_entry_by_cookie(acl_tbl, cls->cookie);

	if (!entry)

		return 0;



	return  dpaa2_switch_acl_tbl_remove_entry(acl_tbl, entry);

}

drivers/net/ethernet/freescale/dpaa2/dpaa2-switch.c

+299 −64

File changed.

Preview size limit exceeded, changes collapsed.

drivers/net/ethernet/freescale/dpaa2/dpaa2-switch.h

+62 −2
Original line number Diff line number Diff line
@@ -18,6 +18,7 @@ 
#include <net/switchdev.h>

#include <linux/if_bridge.h>

#include <linux/fsl/mc.h>

#include <net/pkt_cls.h>

#include <soc/fsl/dpaa2-io.h>



#include "dpsw.h"
@@ -80,6 +81,8 @@ 
	(DPAA2_SWITCH_TX_DATA_OFFSET + DPAA2_SWITCH_TX_BUF_ALIGN)



#define DPAA2_ETHSW_PORT_MAX_ACL_ENTRIES	16

#define DPAA2_ETHSW_PORT_DEFAULT_TRAPS		1



#define DPAA2_ETHSW_PORT_ACL_CMD_BUF_SIZE	256



extern const struct ethtool_ops dpaa2_switch_port_ethtool_ops;
@@ -101,6 +104,34 @@ struct dpaa2_switch_fdb { 
	bool			in_use;

};



struct dpaa2_switch_acl_entry {

	struct list_head	list;

	u16			prio;

	unsigned long		cookie;



	struct dpsw_acl_entry_cfg cfg;

	struct dpsw_acl_key	key;

};



struct dpaa2_switch_acl_tbl {

	struct list_head	entries;

	struct ethsw_core	*ethsw;

	u64			ports;



	u16			id;

	u8			num_rules;

	bool			in_use;

};



static inline bool

dpaa2_switch_acl_tbl_is_full(struct dpaa2_switch_acl_tbl *acl_tbl)

{

	if ((acl_tbl->num_rules + DPAA2_ETHSW_PORT_DEFAULT_TRAPS) >=

	    DPAA2_ETHSW_PORT_MAX_ACL_ENTRIES)

		return true;

	return false;

}



/* Per port private data */

struct ethsw_port_priv {

	struct net_device	*netdev;
@@ -118,8 +149,7 @@ struct ethsw_port_priv { 
	bool			ucast_flood;

	bool			learn_ena;



	u16			acl_tbl;

	u8			acl_num_rules;

	struct dpaa2_switch_acl_tbl *acl_tbl;

};



/* Switch data */
@@ -145,8 +175,21 @@ struct ethsw_core { 
	int				napi_users;



	struct dpaa2_switch_fdb		*fdbs;

	struct dpaa2_switch_acl_tbl	*acls;

};



static inline int dpaa2_switch_get_index(struct ethsw_core *ethsw,

					 struct net_device *netdev)

{

	int i;



	for (i = 0; i < ethsw->sw_attr.num_ifs; i++)

		if (ethsw->ports[i]->netdev == netdev)

			return ethsw->ports[i]->idx;



	return -EINVAL;

}



static inline bool dpaa2_switch_supports_cpu_traffic(struct ethsw_core *ethsw)

{

	if (ethsw->sw_attr.options & DPSW_OPT_CTRL_IF_DIS) {
@@ -183,4 +226,21 @@ int dpaa2_switch_port_vlans_del(struct net_device *netdev, 
typedef int dpaa2_switch_fdb_cb_t(struct ethsw_port_priv *port_priv,

				  struct fdb_dump_entry *fdb_entry,

				  void *data);



/* TC offload */



int dpaa2_switch_cls_flower_replace(struct dpaa2_switch_acl_tbl *acl_tbl,

				    struct flow_cls_offload *cls);



int dpaa2_switch_cls_flower_destroy(struct dpaa2_switch_acl_tbl *acl_tbl,

				    struct flow_cls_offload *cls);



int dpaa2_switch_cls_matchall_replace(struct dpaa2_switch_acl_tbl *acl_tbl,

				      struct tc_cls_matchall_offload *cls);



int dpaa2_switch_cls_matchall_destroy(struct dpaa2_switch_acl_tbl *acl_tbl,

				      struct tc_cls_matchall_offload *cls);



int dpaa2_switch_acl_entry_add(struct dpaa2_switch_acl_tbl *acl_tbl,

			       struct dpaa2_switch_acl_entry *entry);

#endif	/* __ETHSW_H */

drivers/net/ethernet/freescale/dpaa2/dpsw-cmd.h

+1 −0
Original line number Diff line number Diff line
@@ -77,6 +77,7 @@ 
#define DPSW_CMDID_ACL_ADD                  DPSW_CMD_ID(0x090)

#define DPSW_CMDID_ACL_REMOVE               DPSW_CMD_ID(0x091)

#define DPSW_CMDID_ACL_ADD_ENTRY            DPSW_CMD_ID(0x092)

#define DPSW_CMDID_ACL_REMOVE_ENTRY         DPSW_CMD_ID(0x093)

#define DPSW_CMDID_ACL_ADD_IF               DPSW_CMD_ID(0x094)

#define DPSW_CMDID_ACL_REMOVE_IF            DPSW_CMD_ID(0x095)