Merge branch 'sparx5-IS2-VCAP'
Steen Hegelund says:
====================
Add support for Sparx5 IS2 VCAP
This provides initial support for the Sparx5 VCAP functionality via the
'tc' traffic control userspace tool and its flower filter.
Overview:
=========
The supported flower filter keys and actions are:
- source and destination MAC address keys
- trap action
- pass action
The supported Sparx5 VCAPs are: IS2 (see below for more info)
The VCAP (Versatile Content-Aware Processor) feature is essentially a TCAM
with rules consisting of:
- Programmable key fields
- Programmable action fields
- A counter (which may be only one bit wide)
Besides this each VCAP has:
- A number of independent lookups
- A keyset configuration typically per port per lookup
VCAPs are used in many of the TSN features such as PSFP, PTP, FRER as well
as the general shaping, policing and access control, so it is an important
building block for these advanced features.
Functionality:
==============
When a frame is passed to a VCAP the VCAP will generate a set of keys
(keyset) based on the traffic type. If there is a rule created with this
keyset in the VCAP and the values of the keys matches the values in the
keyset of the frame, the rule is said to match and the actions in the rule
will be executed and the rule counter will be incremented. No more rules
will be examined in this VCAP lookup.
If there is no match in the current lookup the frame will be matched
against the next lookup (some VCAPs do the processing of the lookups in
parallel).
The Sparx5 SoC has 6 different VCAP types:
- IS0: Ingress Stage 0 (AKA CLM) mostly handles classification
- IS2: Ingress Stage 2 mostly handles access control
- IP6PFX: IPv6 prefix: Provides tables for IPV6 address management
- LPM: Longest Path Match for IP guarding and routing
- ES0: Egress Stage 0 is mostly used for CPU copying and multicast handling
- ES2: Egress Stage 2 is known as the rewriter and mostly updates tags
Design:
=======
The VCAP implementation provides switchcore independent handling of rules
and supports:
- Creating and deleting rules
- Updating and getting rules
The platform specific API implementation as well as the platform specific
model of the VCAP instances are attached to the VCAP API and a client can
then access rules via the API in a platform independent way, with the
limitations that each VCAP has in terms of is supported keys and actions.
The VCAP model is generated from information delivered by the designers of
the VCAP hardware.
Here is an illustration of this:
+------------------+ +------------------+
| TC flower filter | | PTP client |
| for Sparx5 | | for Sparx5 |
+-------------\----+ +---------/--------+
\ /
\ /
\ /
\ /
\ /
+----v--------v----+
| VCAP API |
+---------|--------+
|
|
|
|
+---------v--------+
| VCAP control |
| instance |
+----/--------|----+
/ |
/ |
/ |
/ |
+--------------v---+ +----v-------------+
| Sparx5 VCAP | | Sparx5 VCAP API |
| model | | Implementation |
+------------------+ +---------|--------+
|
|
|
|
+---------v--------+
| Sparx5 VCAP HW |
+------------------+
Delivery:
=========
For now only the IS2 is supported but later the IS0, ES0 and ES2 will be
added. There are currently no plans to support the IP6PFX and the LPM
VCAPs.
The IS2 VCAP has 4 lookups and they are accessible with a TC chain id:
- chain 8000000: IS2 Lookup 0
- chain 8100000: IS2 Lookup 1
- chain 8200000: IS2 Lookup 2
- chain 8300000: IS2 Lookup 3
These lookups are executed in parallel by the IS2 VCAP but the actions are
executed in series (the datasheet explains what happens if actions
overlap).
The functionality of TC flower as well as TC matchall filters will be
expanded in later submissions as well as the number of VCAPs supported.
This is current plan:
- add support for more TC flower filter keys and extend the Sparx5 port
keyset configuration
- support for TC protocol all
- debugfs support for inspecting rules
- TC flower filter statistics
- Sparx5 IS0 VCAP support and more TC keys and actions to support this
- add TC policer and drop action support (depends on the Sparx5 QoS support
upstreamed separately)
- Sparx5 ES0 VCAP support and more TC actions to support this
- TC flower template support
- TC matchall filter support for mirroring and policing ports
- TC flower filter mirror action support
- Sparx5 ES2 VCAP support
The LAN966x switchcore will also be updated to use the VCAP API as well as
future Microchip switches.
The LAN966x has 3 VCAPS (IS1, IS2 and ES0) and a slightly different keyset
and actionset portfolio than Sparx5.
Version History:
================
v3 Moved the sparx5_tc_flower_set_exterr function to the VCAP API and
renamed it.
Moved the sparx5_netbytes_copy function to the VCAP_API and renamed
it (thanks Horatiu Vultur).
Fixed indentation in the vcap_write_rule function.
Added a comment mentioning the typegroup table terminator in the
vcap_iter_skip_tg function.
v2 Made the KUNIT test model a superset of the real model to fix a
kernel robot build error.
v1 Initial version
====================
Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
David S. Miller
commit
c1aa0a9078
@ -2439,6 +2439,7 @@ L: linux-arm-kernel@lists.infradead.org (moderated for non-subscribers)
|
||||
S: Supported
|
||||
T: git git://github.com/microchip-ung/linux-upstream.git
|
||||
F: arch/arm64/boot/dts/microchip/
|
||||
F: drivers/net/ethernet/microchip/vcap/
|
||||
F: drivers/pinctrl/pinctrl-microchip-sgpio.c
|
||||
N: sparx5
|
||||
|
||||
|
||||
@ -57,5 +57,6 @@ config LAN743X
|
||||
|
||||
source "drivers/net/ethernet/microchip/lan966x/Kconfig"
|
||||
source "drivers/net/ethernet/microchip/sparx5/Kconfig"
|
||||
source "drivers/net/ethernet/microchip/vcap/Kconfig"
|
||||
|
||||
endif # NET_VENDOR_MICROCHIP
|
||||
|
||||
@ -11,3 +11,4 @@ lan743x-objs := lan743x_main.o lan743x_ethtool.o lan743x_ptp.o
|
||||
|
||||
obj-$(CONFIG_LAN966X_SWITCH) += lan966x/
|
||||
obj-$(CONFIG_SPARX5_SWITCH) += sparx5/
|
||||
obj-$(CONFIG_VCAP) += vcap/
|
||||
|
||||
@ -9,5 +9,6 @@ config SPARX5_SWITCH
|
||||
select PHYLINK
|
||||
select PHY_SPARX5_SERDES
|
||||
select RESET_CONTROLLER
|
||||
select VCAP
|
||||
help
|
||||
This driver supports the Sparx5 network switch device.
|
||||
|
||||
@ -5,7 +5,11 @@
|
||||
|
||||
obj-$(CONFIG_SPARX5_SWITCH) += sparx5-switch.o
|
||||
|
||||
sparx5-switch-objs := sparx5_main.o sparx5_packet.o \
|
||||
sparx5-switch-y := sparx5_main.o sparx5_packet.o \
|
||||
sparx5_netdev.o sparx5_phylink.o sparx5_port.o sparx5_mactable.o sparx5_vlan.o \
|
||||
sparx5_switchdev.o sparx5_calendar.o sparx5_ethtool.o sparx5_fdma.o \
|
||||
sparx5_ptp.o sparx5_pgid.o sparx5_tc.o sparx5_qos.o
|
||||
sparx5_ptp.o sparx5_pgid.o sparx5_tc.o sparx5_qos.o \
|
||||
sparx5_vcap_impl.o sparx5_vcap_ag_api.o sparx5_tc_flower.o
|
||||
|
||||
# Provide include files
|
||||
ccflags-y += -I$(srctree)/drivers/net/ethernet/microchip/vcap
|
||||
|
||||
@ -672,6 +672,14 @@ static int sparx5_start(struct sparx5 *sparx5)
|
||||
|
||||
sparx5_board_init(sparx5);
|
||||
err = sparx5_register_notifier_blocks(sparx5);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
err = sparx5_vcap_init(sparx5);
|
||||
if (err) {
|
||||
sparx5_unregister_notifier_blocks(sparx5);
|
||||
return err;
|
||||
}
|
||||
|
||||
/* Start Frame DMA with fallback to register based INJ/XTR */
|
||||
err = -ENXIO;
|
||||
@ -906,6 +914,7 @@ static int mchp_sparx5_remove(struct platform_device *pdev)
|
||||
sparx5_ptp_deinit(sparx5);
|
||||
sparx5_fdma_stop(sparx5);
|
||||
sparx5_cleanup_ports(sparx5);
|
||||
sparx5_vcap_destroy(sparx5);
|
||||
/* Unregister netdevs */
|
||||
sparx5_unregister_notifier_blocks(sparx5);
|
||||
|
||||
|
||||
@ -288,6 +288,8 @@ struct sparx5 {
|
||||
struct mutex ptp_lock; /* lock for ptp interface state */
|
||||
u16 ptp_skbs;
|
||||
int ptp_irq;
|
||||
/* VCAP */
|
||||
struct vcap_control *vcap_ctrl;
|
||||
/* PGID allocation map */
|
||||
u8 pgid_map[PGID_TABLE_SIZE];
|
||||
};
|
||||
@ -382,6 +384,10 @@ void sparx5_ptp_txtstamp_release(struct sparx5_port *port,
|
||||
struct sk_buff *skb);
|
||||
irqreturn_t sparx5_ptp_irq_handler(int irq, void *args);
|
||||
|
||||
/* sparx5_vcap_impl.c */
|
||||
int sparx5_vcap_init(struct sparx5 *sparx5);
|
||||
void sparx5_vcap_destroy(struct sparx5 *sparx5);
|
||||
|
||||
/* sparx5_pgid.c */
|
||||
enum sparx5_pgid_type {
|
||||
SPX5_PGID_FREE,
|
||||
|
||||
@ -4,8 +4,8 @@
|
||||
* Copyright (c) 2021 Microchip Technology Inc.
|
||||
*/
|
||||
|
||||
/* This file is autogenerated by cml-utils 2022-02-26 14:15:01 +0100.
|
||||
* Commit ID: 98bdd3d171cc2a1afd30d241d41a4281d471a48c (dirty)
|
||||
/* This file is autogenerated by cml-utils 2022-09-12 14:22:42 +0200.
|
||||
* Commit ID: 06aecbca4eab6e85d87f665fe6b6348c48146245
|
||||
*/
|
||||
|
||||
#ifndef _SPARX5_MAIN_REGS_H_
|
||||
@ -171,6 +171,162 @@ enum sparx5_target {
|
||||
/* ANA_AC:STAT_CNT_CFG_PORT:STAT_LSB_CNT */
|
||||
#define ANA_AC_PORT_STAT_LSB_CNT(g, r) __REG(TARGET_ANA_AC, 0, 1, 843776, g, 70, 64, 20, r, 4, 4)
|
||||
|
||||
/* ANA_ACL:COMMON:VCAP_S2_CFG */
|
||||
#define ANA_ACL_VCAP_S2_CFG(r) __REG(TARGET_ANA_ACL, 0, 1, 32768, 0, 1, 592, 0, r, 70, 4)
|
||||
|
||||
#define ANA_ACL_VCAP_S2_CFG_SEC_ROUTE_HANDLING_ENA BIT(28)
|
||||
#define ANA_ACL_VCAP_S2_CFG_SEC_ROUTE_HANDLING_ENA_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_VCAP_S2_CFG_SEC_ROUTE_HANDLING_ENA, x)
|
||||
#define ANA_ACL_VCAP_S2_CFG_SEC_ROUTE_HANDLING_ENA_GET(x)\
|
||||
FIELD_GET(ANA_ACL_VCAP_S2_CFG_SEC_ROUTE_HANDLING_ENA, x)
|
||||
|
||||
#define ANA_ACL_VCAP_S2_CFG_SEC_TYPE_OAM_ENA GENMASK(27, 26)
|
||||
#define ANA_ACL_VCAP_S2_CFG_SEC_TYPE_OAM_ENA_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_VCAP_S2_CFG_SEC_TYPE_OAM_ENA, x)
|
||||
#define ANA_ACL_VCAP_S2_CFG_SEC_TYPE_OAM_ENA_GET(x)\
|
||||
FIELD_GET(ANA_ACL_VCAP_S2_CFG_SEC_TYPE_OAM_ENA, x)
|
||||
|
||||
#define ANA_ACL_VCAP_S2_CFG_SEC_TYPE_IP6_TCPUDP_OTHER_ENA GENMASK(25, 24)
|
||||
#define ANA_ACL_VCAP_S2_CFG_SEC_TYPE_IP6_TCPUDP_OTHER_ENA_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_VCAP_S2_CFG_SEC_TYPE_IP6_TCPUDP_OTHER_ENA, x)
|
||||
#define ANA_ACL_VCAP_S2_CFG_SEC_TYPE_IP6_TCPUDP_OTHER_ENA_GET(x)\
|
||||
FIELD_GET(ANA_ACL_VCAP_S2_CFG_SEC_TYPE_IP6_TCPUDP_OTHER_ENA, x)
|
||||
|
||||
#define ANA_ACL_VCAP_S2_CFG_SEC_TYPE_IP6_VID_ENA GENMASK(23, 22)
|
||||
#define ANA_ACL_VCAP_S2_CFG_SEC_TYPE_IP6_VID_ENA_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_VCAP_S2_CFG_SEC_TYPE_IP6_VID_ENA, x)
|
||||
#define ANA_ACL_VCAP_S2_CFG_SEC_TYPE_IP6_VID_ENA_GET(x)\
|
||||
FIELD_GET(ANA_ACL_VCAP_S2_CFG_SEC_TYPE_IP6_VID_ENA, x)
|
||||
|
||||
#define ANA_ACL_VCAP_S2_CFG_SEC_TYPE_IP6_STD_ENA GENMASK(21, 20)
|
||||
#define ANA_ACL_VCAP_S2_CFG_SEC_TYPE_IP6_STD_ENA_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_VCAP_S2_CFG_SEC_TYPE_IP6_STD_ENA, x)
|
||||
#define ANA_ACL_VCAP_S2_CFG_SEC_TYPE_IP6_STD_ENA_GET(x)\
|
||||
FIELD_GET(ANA_ACL_VCAP_S2_CFG_SEC_TYPE_IP6_STD_ENA, x)
|
||||
|
||||
#define ANA_ACL_VCAP_S2_CFG_SEC_TYPE_IP6_TCPUDP_ENA GENMASK(19, 18)
|
||||
#define ANA_ACL_VCAP_S2_CFG_SEC_TYPE_IP6_TCPUDP_ENA_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_VCAP_S2_CFG_SEC_TYPE_IP6_TCPUDP_ENA, x)
|
||||
#define ANA_ACL_VCAP_S2_CFG_SEC_TYPE_IP6_TCPUDP_ENA_GET(x)\
|
||||
FIELD_GET(ANA_ACL_VCAP_S2_CFG_SEC_TYPE_IP6_TCPUDP_ENA, x)
|
||||
|
||||
#define ANA_ACL_VCAP_S2_CFG_SEC_TYPE_IP_7TUPLE_ENA GENMASK(17, 16)
|
||||
#define ANA_ACL_VCAP_S2_CFG_SEC_TYPE_IP_7TUPLE_ENA_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_VCAP_S2_CFG_SEC_TYPE_IP_7TUPLE_ENA, x)
|
||||
#define ANA_ACL_VCAP_S2_CFG_SEC_TYPE_IP_7TUPLE_ENA_GET(x)\
|
||||
FIELD_GET(ANA_ACL_VCAP_S2_CFG_SEC_TYPE_IP_7TUPLE_ENA, x)
|
||||
|
||||
#define ANA_ACL_VCAP_S2_CFG_SEC_TYPE_IP4_VID_ENA GENMASK(15, 14)
|
||||
#define ANA_ACL_VCAP_S2_CFG_SEC_TYPE_IP4_VID_ENA_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_VCAP_S2_CFG_SEC_TYPE_IP4_VID_ENA, x)
|
||||
#define ANA_ACL_VCAP_S2_CFG_SEC_TYPE_IP4_VID_ENA_GET(x)\
|
||||
FIELD_GET(ANA_ACL_VCAP_S2_CFG_SEC_TYPE_IP4_VID_ENA, x)
|
||||
|
||||
#define ANA_ACL_VCAP_S2_CFG_SEC_TYPE_IP4_TCPUDP_ENA GENMASK(13, 12)
|
||||
#define ANA_ACL_VCAP_S2_CFG_SEC_TYPE_IP4_TCPUDP_ENA_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_VCAP_S2_CFG_SEC_TYPE_IP4_TCPUDP_ENA, x)
|
||||
#define ANA_ACL_VCAP_S2_CFG_SEC_TYPE_IP4_TCPUDP_ENA_GET(x)\
|
||||
FIELD_GET(ANA_ACL_VCAP_S2_CFG_SEC_TYPE_IP4_TCPUDP_ENA, x)
|
||||
|
||||
#define ANA_ACL_VCAP_S2_CFG_SEC_TYPE_IP4_OTHER_ENA GENMASK(11, 10)
|
||||
#define ANA_ACL_VCAP_S2_CFG_SEC_TYPE_IP4_OTHER_ENA_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_VCAP_S2_CFG_SEC_TYPE_IP4_OTHER_ENA, x)
|
||||
#define ANA_ACL_VCAP_S2_CFG_SEC_TYPE_IP4_OTHER_ENA_GET(x)\
|
||||
FIELD_GET(ANA_ACL_VCAP_S2_CFG_SEC_TYPE_IP4_OTHER_ENA, x)
|
||||
|
||||
#define ANA_ACL_VCAP_S2_CFG_SEC_TYPE_ARP_ENA GENMASK(9, 8)
|
||||
#define ANA_ACL_VCAP_S2_CFG_SEC_TYPE_ARP_ENA_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_VCAP_S2_CFG_SEC_TYPE_ARP_ENA, x)
|
||||
#define ANA_ACL_VCAP_S2_CFG_SEC_TYPE_ARP_ENA_GET(x)\
|
||||
FIELD_GET(ANA_ACL_VCAP_S2_CFG_SEC_TYPE_ARP_ENA, x)
|
||||
|
||||
#define ANA_ACL_VCAP_S2_CFG_SEC_TYPE_MAC_SNAP_ENA GENMASK(7, 6)
|
||||
#define ANA_ACL_VCAP_S2_CFG_SEC_TYPE_MAC_SNAP_ENA_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_VCAP_S2_CFG_SEC_TYPE_MAC_SNAP_ENA, x)
|
||||
#define ANA_ACL_VCAP_S2_CFG_SEC_TYPE_MAC_SNAP_ENA_GET(x)\
|
||||
FIELD_GET(ANA_ACL_VCAP_S2_CFG_SEC_TYPE_MAC_SNAP_ENA, x)
|
||||
|
||||
#define ANA_ACL_VCAP_S2_CFG_SEC_TYPE_MAC_LLC_ENA GENMASK(5, 4)
|
||||
#define ANA_ACL_VCAP_S2_CFG_SEC_TYPE_MAC_LLC_ENA_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_VCAP_S2_CFG_SEC_TYPE_MAC_LLC_ENA, x)
|
||||
#define ANA_ACL_VCAP_S2_CFG_SEC_TYPE_MAC_LLC_ENA_GET(x)\
|
||||
FIELD_GET(ANA_ACL_VCAP_S2_CFG_SEC_TYPE_MAC_LLC_ENA, x)
|
||||
|
||||
#define ANA_ACL_VCAP_S2_CFG_SEC_ENA GENMASK(3, 0)
|
||||
#define ANA_ACL_VCAP_S2_CFG_SEC_ENA_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_VCAP_S2_CFG_SEC_ENA, x)
|
||||
#define ANA_ACL_VCAP_S2_CFG_SEC_ENA_GET(x)\
|
||||
FIELD_GET(ANA_ACL_VCAP_S2_CFG_SEC_ENA, x)
|
||||
|
||||
/* ANA_ACL:COMMON:SWAP_IP_CTRL */
|
||||
#define ANA_ACL_SWAP_IP_CTRL __REG(TARGET_ANA_ACL, 0, 1, 32768, 0, 1, 592, 412, 0, 1, 4)
|
||||
|
||||
#define ANA_ACL_SWAP_IP_CTRL_DMAC_REPL_OFFSET_VAL GENMASK(23, 18)
|
||||
#define ANA_ACL_SWAP_IP_CTRL_DMAC_REPL_OFFSET_VAL_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_SWAP_IP_CTRL_DMAC_REPL_OFFSET_VAL, x)
|
||||
#define ANA_ACL_SWAP_IP_CTRL_DMAC_REPL_OFFSET_VAL_GET(x)\
|
||||
FIELD_GET(ANA_ACL_SWAP_IP_CTRL_DMAC_REPL_OFFSET_VAL, x)
|
||||
|
||||
#define ANA_ACL_SWAP_IP_CTRL_IP_SWAP_IP6_HOPC_VAL GENMASK(17, 10)
|
||||
#define ANA_ACL_SWAP_IP_CTRL_IP_SWAP_IP6_HOPC_VAL_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_SWAP_IP_CTRL_IP_SWAP_IP6_HOPC_VAL, x)
|
||||
#define ANA_ACL_SWAP_IP_CTRL_IP_SWAP_IP6_HOPC_VAL_GET(x)\
|
||||
FIELD_GET(ANA_ACL_SWAP_IP_CTRL_IP_SWAP_IP6_HOPC_VAL, x)
|
||||
|
||||
#define ANA_ACL_SWAP_IP_CTRL_IP_SWAP_IP4_TTL_VAL GENMASK(9, 2)
|
||||
#define ANA_ACL_SWAP_IP_CTRL_IP_SWAP_IP4_TTL_VAL_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_SWAP_IP_CTRL_IP_SWAP_IP4_TTL_VAL, x)
|
||||
#define ANA_ACL_SWAP_IP_CTRL_IP_SWAP_IP4_TTL_VAL_GET(x)\
|
||||
FIELD_GET(ANA_ACL_SWAP_IP_CTRL_IP_SWAP_IP4_TTL_VAL, x)
|
||||
|
||||
#define ANA_ACL_SWAP_IP_CTRL_IP_SWAP_IP6_HOPC_ENA BIT(1)
|
||||
#define ANA_ACL_SWAP_IP_CTRL_IP_SWAP_IP6_HOPC_ENA_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_SWAP_IP_CTRL_IP_SWAP_IP6_HOPC_ENA, x)
|
||||
#define ANA_ACL_SWAP_IP_CTRL_IP_SWAP_IP6_HOPC_ENA_GET(x)\
|
||||
FIELD_GET(ANA_ACL_SWAP_IP_CTRL_IP_SWAP_IP6_HOPC_ENA, x)
|
||||
|
||||
#define ANA_ACL_SWAP_IP_CTRL_IP_SWAP_IP4_TTL_ENA BIT(0)
|
||||
#define ANA_ACL_SWAP_IP_CTRL_IP_SWAP_IP4_TTL_ENA_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_SWAP_IP_CTRL_IP_SWAP_IP4_TTL_ENA, x)
|
||||
#define ANA_ACL_SWAP_IP_CTRL_IP_SWAP_IP4_TTL_ENA_GET(x)\
|
||||
FIELD_GET(ANA_ACL_SWAP_IP_CTRL_IP_SWAP_IP4_TTL_ENA, x)
|
||||
|
||||
/* ANA_ACL:COMMON:VCAP_S2_RLEG_STAT */
|
||||
#define ANA_ACL_VCAP_S2_RLEG_STAT(r) __REG(TARGET_ANA_ACL, 0, 1, 32768, 0, 1, 592, 424, r, 4, 4)
|
||||
|
||||
#define ANA_ACL_VCAP_S2_RLEG_STAT_IRLEG_STAT_MASK GENMASK(12, 6)
|
||||
#define ANA_ACL_VCAP_S2_RLEG_STAT_IRLEG_STAT_MASK_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_VCAP_S2_RLEG_STAT_IRLEG_STAT_MASK, x)
|
||||
#define ANA_ACL_VCAP_S2_RLEG_STAT_IRLEG_STAT_MASK_GET(x)\
|
||||
FIELD_GET(ANA_ACL_VCAP_S2_RLEG_STAT_IRLEG_STAT_MASK, x)
|
||||
|
||||
#define ANA_ACL_VCAP_S2_RLEG_STAT_ERLEG_STAT_MASK GENMASK(5, 0)
|
||||
#define ANA_ACL_VCAP_S2_RLEG_STAT_ERLEG_STAT_MASK_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_VCAP_S2_RLEG_STAT_ERLEG_STAT_MASK, x)
|
||||
#define ANA_ACL_VCAP_S2_RLEG_STAT_ERLEG_STAT_MASK_GET(x)\
|
||||
FIELD_GET(ANA_ACL_VCAP_S2_RLEG_STAT_ERLEG_STAT_MASK, x)
|
||||
|
||||
/* ANA_ACL:COMMON:VCAP_S2_FRAGMENT_CFG */
|
||||
#define ANA_ACL_VCAP_S2_FRAGMENT_CFG __REG(TARGET_ANA_ACL, 0, 1, 32768, 0, 1, 592, 440, 0, 1, 4)
|
||||
|
||||
#define ANA_ACL_VCAP_S2_FRAGMENT_CFG_L4_MIN_LEN GENMASK(9, 5)
|
||||
#define ANA_ACL_VCAP_S2_FRAGMENT_CFG_L4_MIN_LEN_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_VCAP_S2_FRAGMENT_CFG_L4_MIN_LEN, x)
|
||||
#define ANA_ACL_VCAP_S2_FRAGMENT_CFG_L4_MIN_LEN_GET(x)\
|
||||
FIELD_GET(ANA_ACL_VCAP_S2_FRAGMENT_CFG_L4_MIN_LEN, x)
|
||||
|
||||
#define ANA_ACL_VCAP_S2_FRAGMENT_CFG_FRAGMENT_OFFSET_THRES_DIS BIT(4)
|
||||
#define ANA_ACL_VCAP_S2_FRAGMENT_CFG_FRAGMENT_OFFSET_THRES_DIS_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_VCAP_S2_FRAGMENT_CFG_FRAGMENT_OFFSET_THRES_DIS, x)
|
||||
#define ANA_ACL_VCAP_S2_FRAGMENT_CFG_FRAGMENT_OFFSET_THRES_DIS_GET(x)\
|
||||
FIELD_GET(ANA_ACL_VCAP_S2_FRAGMENT_CFG_FRAGMENT_OFFSET_THRES_DIS, x)
|
||||
|
||||
#define ANA_ACL_VCAP_S2_FRAGMENT_CFG_FRAGMENT_OFFSET_THRES GENMASK(3, 0)
|
||||
#define ANA_ACL_VCAP_S2_FRAGMENT_CFG_FRAGMENT_OFFSET_THRES_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_VCAP_S2_FRAGMENT_CFG_FRAGMENT_OFFSET_THRES, x)
|
||||
#define ANA_ACL_VCAP_S2_FRAGMENT_CFG_FRAGMENT_OFFSET_THRES_GET(x)\
|
||||
FIELD_GET(ANA_ACL_VCAP_S2_FRAGMENT_CFG_FRAGMENT_OFFSET_THRES, x)
|
||||
|
||||
/* ANA_ACL:COMMON:OWN_UPSID */
|
||||
#define ANA_ACL_OWN_UPSID(r) __REG(TARGET_ANA_ACL, 0, 1, 32768, 0, 1, 592, 580, r, 3, 4)
|
||||
|
||||
@ -180,6 +336,174 @@ enum sparx5_target {
|
||||
#define ANA_ACL_OWN_UPSID_OWN_UPSID_GET(x)\
|
||||
FIELD_GET(ANA_ACL_OWN_UPSID_OWN_UPSID, x)
|
||||
|
||||
/* ANA_ACL:KEY_SEL:VCAP_S2_KEY_SEL */
|
||||
#define ANA_ACL_VCAP_S2_KEY_SEL(g, r) __REG(TARGET_ANA_ACL, 0, 1, 34200, g, 134, 16, 0, r, 4, 4)
|
||||
|
||||
#define ANA_ACL_VCAP_S2_KEY_SEL_KEY_SEL_ENA BIT(13)
|
||||
#define ANA_ACL_VCAP_S2_KEY_SEL_KEY_SEL_ENA_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_VCAP_S2_KEY_SEL_KEY_SEL_ENA, x)
|
||||
#define ANA_ACL_VCAP_S2_KEY_SEL_KEY_SEL_ENA_GET(x)\
|
||||
FIELD_GET(ANA_ACL_VCAP_S2_KEY_SEL_KEY_SEL_ENA, x)
|
||||
|
||||
#define ANA_ACL_VCAP_S2_KEY_SEL_IGR_PORT_MASK_SEL BIT(12)
|
||||
#define ANA_ACL_VCAP_S2_KEY_SEL_IGR_PORT_MASK_SEL_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_VCAP_S2_KEY_SEL_IGR_PORT_MASK_SEL, x)
|
||||
#define ANA_ACL_VCAP_S2_KEY_SEL_IGR_PORT_MASK_SEL_GET(x)\
|
||||
FIELD_GET(ANA_ACL_VCAP_S2_KEY_SEL_IGR_PORT_MASK_SEL, x)
|
||||
|
||||
#define ANA_ACL_VCAP_S2_KEY_SEL_NON_ETH_KEY_SEL GENMASK(11, 10)
|
||||
#define ANA_ACL_VCAP_S2_KEY_SEL_NON_ETH_KEY_SEL_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_VCAP_S2_KEY_SEL_NON_ETH_KEY_SEL, x)
|
||||
#define ANA_ACL_VCAP_S2_KEY_SEL_NON_ETH_KEY_SEL_GET(x)\
|
||||
FIELD_GET(ANA_ACL_VCAP_S2_KEY_SEL_NON_ETH_KEY_SEL, x)
|
||||
|
||||
#define ANA_ACL_VCAP_S2_KEY_SEL_IP4_MC_KEY_SEL GENMASK(9, 8)
|
||||
#define ANA_ACL_VCAP_S2_KEY_SEL_IP4_MC_KEY_SEL_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_VCAP_S2_KEY_SEL_IP4_MC_KEY_SEL, x)
|
||||
#define ANA_ACL_VCAP_S2_KEY_SEL_IP4_MC_KEY_SEL_GET(x)\
|
||||
FIELD_GET(ANA_ACL_VCAP_S2_KEY_SEL_IP4_MC_KEY_SEL, x)
|
||||
|
||||
#define ANA_ACL_VCAP_S2_KEY_SEL_IP4_UC_KEY_SEL GENMASK(7, 6)
|
||||
#define ANA_ACL_VCAP_S2_KEY_SEL_IP4_UC_KEY_SEL_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_VCAP_S2_KEY_SEL_IP4_UC_KEY_SEL, x)
|
||||
#define ANA_ACL_VCAP_S2_KEY_SEL_IP4_UC_KEY_SEL_GET(x)\
|
||||
FIELD_GET(ANA_ACL_VCAP_S2_KEY_SEL_IP4_UC_KEY_SEL, x)
|
||||
|
||||
#define ANA_ACL_VCAP_S2_KEY_SEL_IP6_MC_KEY_SEL GENMASK(5, 3)
|
||||
#define ANA_ACL_VCAP_S2_KEY_SEL_IP6_MC_KEY_SEL_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_VCAP_S2_KEY_SEL_IP6_MC_KEY_SEL, x)
|
||||
#define ANA_ACL_VCAP_S2_KEY_SEL_IP6_MC_KEY_SEL_GET(x)\
|
||||
FIELD_GET(ANA_ACL_VCAP_S2_KEY_SEL_IP6_MC_KEY_SEL, x)
|
||||
|
||||
#define ANA_ACL_VCAP_S2_KEY_SEL_IP6_UC_KEY_SEL GENMASK(2, 1)
|
||||
#define ANA_ACL_VCAP_S2_KEY_SEL_IP6_UC_KEY_SEL_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_VCAP_S2_KEY_SEL_IP6_UC_KEY_SEL, x)
|
||||
#define ANA_ACL_VCAP_S2_KEY_SEL_IP6_UC_KEY_SEL_GET(x)\
|
||||
FIELD_GET(ANA_ACL_VCAP_S2_KEY_SEL_IP6_UC_KEY_SEL, x)
|
||||
|
||||
#define ANA_ACL_VCAP_S2_KEY_SEL_ARP_KEY_SEL BIT(0)
|
||||
#define ANA_ACL_VCAP_S2_KEY_SEL_ARP_KEY_SEL_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_VCAP_S2_KEY_SEL_ARP_KEY_SEL, x)
|
||||
#define ANA_ACL_VCAP_S2_KEY_SEL_ARP_KEY_SEL_GET(x)\
|
||||
FIELD_GET(ANA_ACL_VCAP_S2_KEY_SEL_ARP_KEY_SEL, x)
|
||||
|
||||
/* ANA_ACL:CNT_A:CNT_A */
|
||||
#define ANA_ACL_CNT_A(g) __REG(TARGET_ANA_ACL, 0, 1, 0, g, 4096, 4, 0, 0, 1, 4)
|
||||
|
||||
/* ANA_ACL:CNT_B:CNT_B */
|
||||
#define ANA_ACL_CNT_B(g) __REG(TARGET_ANA_ACL, 0, 1, 16384, g, 4096, 4, 0, 0, 1, 4)
|
||||
|
||||
/* ANA_ACL:STICKY:SEC_LOOKUP_STICKY */
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY(r) __REG(TARGET_ANA_ACL, 0, 1, 36408, 0, 1, 16, 0, r, 4, 4)
|
||||
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_KEY_SEL_CLM_STICKY BIT(17)
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_KEY_SEL_CLM_STICKY_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_SEC_LOOKUP_STICKY_KEY_SEL_CLM_STICKY, x)
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_KEY_SEL_CLM_STICKY_GET(x)\
|
||||
FIELD_GET(ANA_ACL_SEC_LOOKUP_STICKY_KEY_SEL_CLM_STICKY, x)
|
||||
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_KEY_SEL_IRLEG_STICKY BIT(16)
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_KEY_SEL_IRLEG_STICKY_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_SEC_LOOKUP_STICKY_KEY_SEL_IRLEG_STICKY, x)
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_KEY_SEL_IRLEG_STICKY_GET(x)\
|
||||
FIELD_GET(ANA_ACL_SEC_LOOKUP_STICKY_KEY_SEL_IRLEG_STICKY, x)
|
||||
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_KEY_SEL_ERLEG_STICKY BIT(15)
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_KEY_SEL_ERLEG_STICKY_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_SEC_LOOKUP_STICKY_KEY_SEL_ERLEG_STICKY, x)
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_KEY_SEL_ERLEG_STICKY_GET(x)\
|
||||
FIELD_GET(ANA_ACL_SEC_LOOKUP_STICKY_KEY_SEL_ERLEG_STICKY, x)
|
||||
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_KEY_SEL_PORT_STICKY BIT(14)
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_KEY_SEL_PORT_STICKY_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_SEC_LOOKUP_STICKY_KEY_SEL_PORT_STICKY, x)
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_KEY_SEL_PORT_STICKY_GET(x)\
|
||||
FIELD_GET(ANA_ACL_SEC_LOOKUP_STICKY_KEY_SEL_PORT_STICKY, x)
|
||||
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_CUSTOM2_STICKY BIT(13)
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_CUSTOM2_STICKY_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_CUSTOM2_STICKY, x)
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_CUSTOM2_STICKY_GET(x)\
|
||||
FIELD_GET(ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_CUSTOM2_STICKY, x)
|
||||
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_CUSTOM1_STICKY BIT(12)
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_CUSTOM1_STICKY_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_CUSTOM1_STICKY, x)
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_CUSTOM1_STICKY_GET(x)\
|
||||
FIELD_GET(ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_CUSTOM1_STICKY, x)
|
||||
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_OAM_STICKY BIT(11)
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_OAM_STICKY_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_OAM_STICKY, x)
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_OAM_STICKY_GET(x)\
|
||||
FIELD_GET(ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_OAM_STICKY, x)
|
||||
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_IP6_VID_STICKY BIT(10)
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_IP6_VID_STICKY_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_IP6_VID_STICKY, x)
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_IP6_VID_STICKY_GET(x)\
|
||||
FIELD_GET(ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_IP6_VID_STICKY, x)
|
||||
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_IP6_STD_STICKY BIT(9)
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_IP6_STD_STICKY_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_IP6_STD_STICKY, x)
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_IP6_STD_STICKY_GET(x)\
|
||||
FIELD_GET(ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_IP6_STD_STICKY, x)
|
||||
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_IP6_TCPUDP_STICKY BIT(8)
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_IP6_TCPUDP_STICKY_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_IP6_TCPUDP_STICKY, x)
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_IP6_TCPUDP_STICKY_GET(x)\
|
||||
FIELD_GET(ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_IP6_TCPUDP_STICKY, x)
|
||||
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_IP_7TUPLE_STICKY BIT(7)
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_IP_7TUPLE_STICKY_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_IP_7TUPLE_STICKY, x)
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_IP_7TUPLE_STICKY_GET(x)\
|
||||
FIELD_GET(ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_IP_7TUPLE_STICKY, x)
|
||||
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_IP4_VID_STICKY BIT(6)
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_IP4_VID_STICKY_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_IP4_VID_STICKY, x)
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_IP4_VID_STICKY_GET(x)\
|
||||
FIELD_GET(ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_IP4_VID_STICKY, x)
|
||||
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_IP4_TCPUDP_STICKY BIT(5)
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_IP4_TCPUDP_STICKY_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_IP4_TCPUDP_STICKY, x)
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_IP4_TCPUDP_STICKY_GET(x)\
|
||||
FIELD_GET(ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_IP4_TCPUDP_STICKY, x)
|
||||
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_IP4_OTHER_STICKY BIT(4)
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_IP4_OTHER_STICKY_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_IP4_OTHER_STICKY, x)
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_IP4_OTHER_STICKY_GET(x)\
|
||||
FIELD_GET(ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_IP4_OTHER_STICKY, x)
|
||||
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_ARP_STICKY BIT(3)
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_ARP_STICKY_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_ARP_STICKY, x)
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_ARP_STICKY_GET(x)\
|
||||
FIELD_GET(ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_ARP_STICKY, x)
|
||||
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_MAC_SNAP_STICKY BIT(2)
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_MAC_SNAP_STICKY_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_MAC_SNAP_STICKY, x)
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_MAC_SNAP_STICKY_GET(x)\
|
||||
FIELD_GET(ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_MAC_SNAP_STICKY, x)
|
||||
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_MAC_LLC_STICKY BIT(1)
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_MAC_LLC_STICKY_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_MAC_LLC_STICKY, x)
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_MAC_LLC_STICKY_GET(x)\
|
||||
FIELD_GET(ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_MAC_LLC_STICKY, x)
|
||||
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_MAC_ETYPE_STICKY BIT(0)
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_MAC_ETYPE_STICKY_SET(x)\
|
||||
FIELD_PREP(ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_MAC_ETYPE_STICKY, x)
|
||||
#define ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_MAC_ETYPE_STICKY_GET(x)\
|
||||
FIELD_GET(ANA_ACL_SEC_LOOKUP_STICKY_SEC_TYPE_MAC_ETYPE_STICKY, x)
|
||||
|
||||
/* ANA_AC_POL:POL_ALL_CFG:POL_UPD_INT_CFG */
|
||||
#define ANA_AC_POL_POL_UPD_INT_CFG __REG(TARGET_ANA_AC_POL, 0, 1, 75968, 0, 1, 1160, 1148, 0, 1, 4)
|
||||
|
||||
@ -5039,6 +5363,138 @@ enum sparx5_target {
|
||||
#define REW_RAM_INIT_RAM_CFG_HOOK_GET(x)\
|
||||
FIELD_GET(REW_RAM_INIT_RAM_CFG_HOOK, x)
|
||||
|
||||
/* VCAP_SUPER:VCAP_CORE_CFG:VCAP_UPDATE_CTRL */
|
||||
#define VCAP_SUPER_CTRL __REG(TARGET_VCAP_SUPER, 0, 1, 0, 0, 1, 8, 0, 0, 1, 4)
|
||||
|
||||
#define VCAP_SUPER_CTRL_UPDATE_CMD GENMASK(24, 22)
|
||||
#define VCAP_SUPER_CTRL_UPDATE_CMD_SET(x)\
|
||||
FIELD_PREP(VCAP_SUPER_CTRL_UPDATE_CMD, x)
|
||||
#define VCAP_SUPER_CTRL_UPDATE_CMD_GET(x)\
|
||||
FIELD_GET(VCAP_SUPER_CTRL_UPDATE_CMD, x)
|
||||
|
||||
#define VCAP_SUPER_CTRL_UPDATE_ENTRY_DIS BIT(21)
|
||||
#define VCAP_SUPER_CTRL_UPDATE_ENTRY_DIS_SET(x)\
|
||||
FIELD_PREP(VCAP_SUPER_CTRL_UPDATE_ENTRY_DIS, x)
|
||||
#define VCAP_SUPER_CTRL_UPDATE_ENTRY_DIS_GET(x)\
|
||||
FIELD_GET(VCAP_SUPER_CTRL_UPDATE_ENTRY_DIS, x)
|
||||
|
||||
#define VCAP_SUPER_CTRL_UPDATE_ACTION_DIS BIT(20)
|
||||
#define VCAP_SUPER_CTRL_UPDATE_ACTION_DIS_SET(x)\
|
||||
FIELD_PREP(VCAP_SUPER_CTRL_UPDATE_ACTION_DIS, x)
|
||||
#define VCAP_SUPER_CTRL_UPDATE_ACTION_DIS_GET(x)\
|
||||
FIELD_GET(VCAP_SUPER_CTRL_UPDATE_ACTION_DIS, x)
|
||||
|
||||
#define VCAP_SUPER_CTRL_UPDATE_CNT_DIS BIT(19)
|
||||
#define VCAP_SUPER_CTRL_UPDATE_CNT_DIS_SET(x)\
|
||||
FIELD_PREP(VCAP_SUPER_CTRL_UPDATE_CNT_DIS, x)
|
||||
#define VCAP_SUPER_CTRL_UPDATE_CNT_DIS_GET(x)\
|
||||
FIELD_GET(VCAP_SUPER_CTRL_UPDATE_CNT_DIS, x)
|
||||
|
||||
#define VCAP_SUPER_CTRL_UPDATE_ADDR GENMASK(18, 3)
|
||||
#define VCAP_SUPER_CTRL_UPDATE_ADDR_SET(x)\
|
||||
FIELD_PREP(VCAP_SUPER_CTRL_UPDATE_ADDR, x)
|
||||
#define VCAP_SUPER_CTRL_UPDATE_ADDR_GET(x)\
|
||||
FIELD_GET(VCAP_SUPER_CTRL_UPDATE_ADDR, x)
|
||||
|
||||
#define VCAP_SUPER_CTRL_UPDATE_SHOT BIT(2)
|
||||
#define VCAP_SUPER_CTRL_UPDATE_SHOT_SET(x)\
|
||||
FIELD_PREP(VCAP_SUPER_CTRL_UPDATE_SHOT, x)
|
||||
#define VCAP_SUPER_CTRL_UPDATE_SHOT_GET(x)\
|
||||
FIELD_GET(VCAP_SUPER_CTRL_UPDATE_SHOT, x)
|
||||
|
||||
#define VCAP_SUPER_CTRL_CLEAR_CACHE BIT(1)
|
||||
#define VCAP_SUPER_CTRL_CLEAR_CACHE_SET(x)\
|
||||
FIELD_PREP(VCAP_SUPER_CTRL_CLEAR_CACHE, x)
|
||||
#define VCAP_SUPER_CTRL_CLEAR_CACHE_GET(x)\
|
||||
FIELD_GET(VCAP_SUPER_CTRL_CLEAR_CACHE, x)
|
||||
|
||||
#define VCAP_SUPER_CTRL_MV_TRAFFIC_IGN BIT(0)
|
||||
#define VCAP_SUPER_CTRL_MV_TRAFFIC_IGN_SET(x)\
|
||||
FIELD_PREP(VCAP_SUPER_CTRL_MV_TRAFFIC_IGN, x)
|
||||
#define VCAP_SUPER_CTRL_MV_TRAFFIC_IGN_GET(x)\
|
||||
FIELD_GET(VCAP_SUPER_CTRL_MV_TRAFFIC_IGN, x)
|
||||
|
||||
/* VCAP_SUPER:VCAP_CORE_CFG:VCAP_MV_CFG */
|
||||
#define VCAP_SUPER_CFG __REG(TARGET_VCAP_SUPER, 0, 1, 0, 0, 1, 8, 4, 0, 1, 4)
|
||||
|
||||
#define VCAP_SUPER_CFG_MV_NUM_POS GENMASK(31, 16)
|
||||
#define VCAP_SUPER_CFG_MV_NUM_POS_SET(x)\
|
||||
FIELD_PREP(VCAP_SUPER_CFG_MV_NUM_POS, x)
|
||||
#define VCAP_SUPER_CFG_MV_NUM_POS_GET(x)\
|
||||
FIELD_GET(VCAP_SUPER_CFG_MV_NUM_POS, x)
|
||||
|
||||
#define VCAP_SUPER_CFG_MV_SIZE GENMASK(15, 0)
|
||||
#define VCAP_SUPER_CFG_MV_SIZE_SET(x)\
|
||||
FIELD_PREP(VCAP_SUPER_CFG_MV_SIZE, x)
|
||||
#define VCAP_SUPER_CFG_MV_SIZE_GET(x)\
|
||||
FIELD_GET(VCAP_SUPER_CFG_MV_SIZE, x)
|
||||
|
||||
/* VCAP_SUPER:VCAP_CORE_CACHE:VCAP_ENTRY_DAT */
|
||||
#define VCAP_SUPER_VCAP_ENTRY_DAT(r) __REG(TARGET_VCAP_SUPER, 0, 1, 8, 0, 1, 904, 0, r, 64, 4)
|
||||
|
||||
/* VCAP_SUPER:VCAP_CORE_CACHE:VCAP_MASK_DAT */
|
||||
#define VCAP_SUPER_VCAP_MASK_DAT(r) __REG(TARGET_VCAP_SUPER, 0, 1, 8, 0, 1, 904, 256, r, 64, 4)
|
||||
|
||||
/* VCAP_SUPER:VCAP_CORE_CACHE:VCAP_ACTION_DAT */
|
||||
#define VCAP_SUPER_VCAP_ACTION_DAT(r) __REG(TARGET_VCAP_SUPER, 0, 1, 8, 0, 1, 904, 512, r, 64, 4)
|
||||
|
||||
/* VCAP_SUPER:VCAP_CORE_CACHE:VCAP_CNT_DAT */
|
||||
#define VCAP_SUPER_VCAP_CNT_DAT(r) __REG(TARGET_VCAP_SUPER, 0, 1, 8, 0, 1, 904, 768, r, 32, 4)
|
||||
|
||||
/* VCAP_SUPER:VCAP_CORE_CACHE:VCAP_CNT_FW_DAT */
|
||||
#define VCAP_SUPER_VCAP_CNT_FW_DAT __REG(TARGET_VCAP_SUPER, 0, 1, 8, 0, 1, 904, 896, 0, 1, 4)
|
||||
|
||||
/* VCAP_SUPER:VCAP_CORE_CACHE:VCAP_TG_DAT */
|
||||
#define VCAP_SUPER_VCAP_TG_DAT __REG(TARGET_VCAP_SUPER, 0, 1, 8, 0, 1, 904, 900, 0, 1, 4)
|
||||
|
||||
/* VCAP_SUPER:VCAP_CORE_MAP:VCAP_CORE_IDX */
|
||||
#define VCAP_SUPER_IDX __REG(TARGET_VCAP_SUPER, 0, 1, 912, 0, 1, 8, 0, 0, 1, 4)
|
||||
|
||||
#define VCAP_SUPER_IDX_CORE_IDX GENMASK(3, 0)
|
||||
#define VCAP_SUPER_IDX_CORE_IDX_SET(x)\
|
||||
FIELD_PREP(VCAP_SUPER_IDX_CORE_IDX, x)
|
||||
#define VCAP_SUPER_IDX_CORE_IDX_GET(x)\
|
||||
FIELD_GET(VCAP_SUPER_IDX_CORE_IDX, x)
|
||||
|
||||
/* VCAP_SUPER:VCAP_CORE_MAP:VCAP_CORE_MAP */
|
||||
#define VCAP_SUPER_MAP __REG(TARGET_VCAP_SUPER, 0, 1, 912, 0, 1, 8, 4, 0, 1, 4)
|
||||
|
||||
#define VCAP_SUPER_MAP_CORE_MAP GENMASK(2, 0)
|
||||
#define VCAP_SUPER_MAP_CORE_MAP_SET(x)\
|
||||
FIELD_PREP(VCAP_SUPER_MAP_CORE_MAP, x)
|
||||
#define VCAP_SUPER_MAP_CORE_MAP_GET(x)\
|
||||
FIELD_GET(VCAP_SUPER_MAP_CORE_MAP, x)
|
||||
|
||||
/* VCAP_SUPER:VCAP_CONST:VCAP_VER */
|
||||
#define VCAP_SUPER_VCAP_VER __REG(TARGET_VCAP_SUPER, 0, 1, 924, 0, 1, 40, 0, 0, 1, 4)
|
||||
|
||||
/* VCAP_SUPER:VCAP_CONST:ENTRY_WIDTH */
|
||||
#define VCAP_SUPER_ENTRY_WIDTH __REG(TARGET_VCAP_SUPER, 0, 1, 924, 0, 1, 40, 4, 0, 1, 4)
|
||||
|
||||
/* VCAP_SUPER:VCAP_CONST:ENTRY_CNT */
|
||||
#define VCAP_SUPER_ENTRY_CNT __REG(TARGET_VCAP_SUPER, 0, 1, 924, 0, 1, 40, 8, 0, 1, 4)
|
||||
|
||||
/* VCAP_SUPER:VCAP_CONST:ENTRY_SWCNT */
|
||||
#define VCAP_SUPER_ENTRY_SWCNT __REG(TARGET_VCAP_SUPER, 0, 1, 924, 0, 1, 40, 12, 0, 1, 4)
|
||||
|
||||
/* VCAP_SUPER:VCAP_CONST:ENTRY_TG_WIDTH */
|
||||
#define VCAP_SUPER_ENTRY_TG_WIDTH __REG(TARGET_VCAP_SUPER, 0, 1, 924, 0, 1, 40, 16, 0, 1, 4)
|
||||
|
||||
/* VCAP_SUPER:VCAP_CONST:ACTION_DEF_CNT */
|
||||
#define VCAP_SUPER_ACTION_DEF_CNT __REG(TARGET_VCAP_SUPER, 0, 1, 924, 0, 1, 40, 20, 0, 1, 4)
|
||||
|
||||
/* VCAP_SUPER:VCAP_CONST:ACTION_WIDTH */
|
||||
#define VCAP_SUPER_ACTION_WIDTH __REG(TARGET_VCAP_SUPER, 0, 1, 924, 0, 1, 40, 24, 0, 1, 4)
|
||||
|
||||
/* VCAP_SUPER:VCAP_CONST:CNT_WIDTH */
|
||||
#define VCAP_SUPER_CNT_WIDTH __REG(TARGET_VCAP_SUPER, 0, 1, 924, 0, 1, 40, 28, 0, 1, 4)
|
||||
|
||||
/* VCAP_SUPER:VCAP_CONST:CORE_CNT */
|
||||
#define VCAP_SUPER_CORE_CNT __REG(TARGET_VCAP_SUPER, 0, 1, 924, 0, 1, 40, 32, 0, 1, 4)
|
||||
|
||||
/* VCAP_SUPER:VCAP_CONST:IF_CNT */
|
||||
#define VCAP_SUPER_IF_CNT __REG(TARGET_VCAP_SUPER, 0, 1, 924, 0, 1, 40, 36, 0, 1, 4)
|
||||
|
||||
/* VCAP_SUPER:RAM_CTRL:RAM_INIT */
|
||||
#define VCAP_SUPER_RAM_INIT __REG(TARGET_VCAP_SUPER, 0, 1, 1120, 0, 1, 4, 0, 0, 1, 4)
|
||||
|
||||
|
||||
@ -10,6 +10,50 @@
|
||||
#include "sparx5_main.h"
|
||||
#include "sparx5_qos.h"
|
||||
|
||||
/* tc block handling */
|
||||
static LIST_HEAD(sparx5_block_cb_list);
|
||||
|
||||
static int sparx5_tc_block_cb(enum tc_setup_type type,
|
||||
void *type_data,
|
||||
void *cb_priv, bool ingress)
|
||||
{
|
||||
struct net_device *ndev = cb_priv;
|
||||
|
||||
if (type == TC_SETUP_CLSFLOWER)
|
||||
return sparx5_tc_flower(ndev, type_data, ingress);
|
||||
return -EOPNOTSUPP;
|
||||
}
|
||||
|
||||
static int sparx5_tc_block_cb_ingress(enum tc_setup_type type,
|
||||
void *type_data,
|
||||
void *cb_priv)
|
||||
{
|
||||
return sparx5_tc_block_cb(type, type_data, cb_priv, true);
|
||||
}
|
||||
|
||||
static int sparx5_tc_block_cb_egress(enum tc_setup_type type,
|
||||
void *type_data,
|
||||
void *cb_priv)
|
||||
{
|
||||
return sparx5_tc_block_cb(type, type_data, cb_priv, false);
|
||||
}
|
||||
|
||||
static int sparx5_tc_setup_block(struct net_device *ndev,
|
||||
struct flow_block_offload *fbo)
|
||||
{
|
||||
flow_setup_cb_t *cb;
|
||||
|
||||
if (fbo->binder_type == FLOW_BLOCK_BINDER_TYPE_CLSACT_INGRESS)
|
||||
cb = sparx5_tc_block_cb_ingress;
|
||||
else if (fbo->binder_type == FLOW_BLOCK_BINDER_TYPE_CLSACT_EGRESS)
|
||||
cb = sparx5_tc_block_cb_egress;
|
||||
else
|
||||
return -EOPNOTSUPP;
|
||||
|
||||
return flow_block_cb_setup_simple(fbo, &sparx5_block_cb_list,
|
||||
cb, ndev, ndev, false);
|
||||
}
|
||||
|
||||
static void sparx5_tc_get_layer_and_idx(u32 parent, u32 portno, u32 *layer,
|
||||
u32 *idx)
|
||||
{
|
||||
@ -111,6 +155,8 @@ int sparx5_port_setup_tc(struct net_device *ndev, enum tc_setup_type type,
|
||||
void *type_data)
|
||||
{
|
||||
switch (type) {
|
||||
case TC_SETUP_BLOCK:
|
||||
return sparx5_tc_setup_block(ndev, type_data);
|
||||
case TC_SETUP_QDISC_MQPRIO:
|
||||
return sparx5_tc_setup_qdisc_mqprio(ndev, type_data);
|
||||
case TC_SETUP_QDISC_TBF:
|
||||
|
||||
@ -7,9 +7,23 @@
|
||||
#ifndef __SPARX5_TC_H__
|
||||
#define __SPARX5_TC_H__
|
||||
|
||||
#include <net/flow_offload.h>
|
||||
#include <linux/netdevice.h>
|
||||
|
||||
/* Controls how PORT_MASK is applied */
|
||||
enum SPX5_PORT_MASK_MODE {
|
||||
SPX5_PMM_OR_DSTMASK,
|
||||
SPX5_PMM_AND_VLANMASK,
|
||||
SPX5_PMM_REPLACE_PGID,
|
||||
SPX5_PMM_REPLACE_ALL,
|
||||
SPX5_PMM_REDIR_PGID,
|
||||
SPX5_PMM_OR_PGID_MASK,
|
||||
};
|
||||
|
||||
int sparx5_port_setup_tc(struct net_device *ndev, enum tc_setup_type type,
|
||||
void *type_data);
|
||||
|
||||
int sparx5_tc_flower(struct net_device *ndev, struct flow_cls_offload *fco,
|
||||
bool ingress);
|
||||
|
||||
#endif /* __SPARX5_TC_H__ */
|
||||
|
||||
217
drivers/net/ethernet/microchip/sparx5/sparx5_tc_flower.c
Normal file
217
drivers/net/ethernet/microchip/sparx5/sparx5_tc_flower.c
Normal file
@ -0,0 +1,217 @@
|
||||
// SPDX-License-Identifier: GPL-2.0+
|
||||
/* Microchip VCAP API
|
||||
*
|
||||
* Copyright (c) 2022 Microchip Technology Inc. and its subsidiaries.
|
||||
*/
|
||||
|
||||
#include <net/tcp.h>
|
||||
|
||||
#include "sparx5_tc.h"
|
||||
#include "vcap_api.h"
|
||||
#include "vcap_api_client.h"
|
||||
#include "sparx5_main.h"
|
||||
#include "sparx5_vcap_impl.h"
|
||||
|
||||
struct sparx5_tc_flower_parse_usage {
|
||||
struct flow_cls_offload *fco;
|
||||
struct flow_rule *frule;
|
||||
struct vcap_rule *vrule;
|
||||
unsigned int used_keys;
|
||||
};
|
||||
|
||||
static int sparx5_tc_flower_handler_ethaddr_usage(struct sparx5_tc_flower_parse_usage *st)
|
||||
{
|
||||
enum vcap_key_field smac_key = VCAP_KF_L2_SMAC;
|
||||
enum vcap_key_field dmac_key = VCAP_KF_L2_DMAC;
|
||||
struct flow_match_eth_addrs match;
|
||||
struct vcap_u48_key smac, dmac;
|
||||
int err = 0;
|
||||
|
||||
flow_rule_match_eth_addrs(st->frule, &match);
|
||||
|
||||
if (!is_zero_ether_addr(match.mask->src)) {
|
||||
vcap_netbytes_copy(smac.value, match.key->src, ETH_ALEN);
|
||||
vcap_netbytes_copy(smac.mask, match.mask->src, ETH_ALEN);
|
||||
err = vcap_rule_add_key_u48(st->vrule, smac_key, &smac);
|
||||
if (err)
|
||||
goto out;
|
||||
}
|
||||
|
||||
if (!is_zero_ether_addr(match.mask->dst)) {
|
||||
vcap_netbytes_copy(dmac.value, match.key->dst, ETH_ALEN);
|
||||
vcap_netbytes_copy(dmac.mask, match.mask->dst, ETH_ALEN);
|
||||
err = vcap_rule_add_key_u48(st->vrule, dmac_key, &dmac);
|
||||
if (err)
|
||||
goto out;
|
||||
}
|
||||
|
||||
st->used_keys |= BIT(FLOW_DISSECTOR_KEY_ETH_ADDRS);
|
||||
|
||||
return err;
|
||||
|
||||
out:
|
||||
NL_SET_ERR_MSG_MOD(st->fco->common.extack, "eth_addr parse error");
|
||||
return err;
|
||||
}
|
||||
|
||||
static int (*sparx5_tc_flower_usage_handlers[])(struct sparx5_tc_flower_parse_usage *st) = {
|
||||
/* More dissector handlers will be added here later */
|
||||
[FLOW_DISSECTOR_KEY_ETH_ADDRS] = sparx5_tc_flower_handler_ethaddr_usage,
|
||||
};
|
||||
|
||||
static int sparx5_tc_use_dissectors(struct flow_cls_offload *fco,
|
||||
struct vcap_admin *admin,
|
||||
struct vcap_rule *vrule)
|
||||
{
|
||||
struct sparx5_tc_flower_parse_usage state = {
|
||||
.fco = fco,
|
||||
.vrule = vrule,
|
||||
};
|
||||
int idx, err = 0;
|
||||
|
||||
state.frule = flow_cls_offload_flow_rule(fco);
|
||||
for (idx = 0; idx < ARRAY_SIZE(sparx5_tc_flower_usage_handlers); ++idx) {
|
||||
if (!flow_rule_match_key(state.frule, idx))
|
||||
continue;
|
||||
if (!sparx5_tc_flower_usage_handlers[idx])
|
||||
continue;
|
||||
err = sparx5_tc_flower_usage_handlers[idx](&state);
|
||||
if (err)
|
||||
return err;
|
||||
}
|
||||
return err;
|
||||
}
|
||||
|
||||
static int sparx5_tc_flower_replace(struct net_device *ndev,
|
||||
struct flow_cls_offload *fco,
|
||||
struct vcap_admin *admin)
|
||||
{
|
||||
struct sparx5_port *port = netdev_priv(ndev);
|
||||
struct flow_action_entry *act;
|
||||
struct vcap_control *vctrl;
|
||||
struct flow_rule *frule;
|
||||
struct vcap_rule *vrule;
|
||||
int err, idx;
|
||||
|
||||
frule = flow_cls_offload_flow_rule(fco);
|
||||
if (!flow_action_has_entries(&frule->action)) {
|
||||
NL_SET_ERR_MSG_MOD(fco->common.extack, "No actions");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (!flow_action_basic_hw_stats_check(&frule->action, fco->common.extack))
|
||||
return -EOPNOTSUPP;
|
||||
|
||||
vctrl = port->sparx5->vcap_ctrl;
|
||||
vrule = vcap_alloc_rule(vctrl, ndev, fco->common.chain_index, VCAP_USER_TC,
|
||||
fco->common.prio, 0);
|
||||
if (IS_ERR(vrule))
|
||||
return PTR_ERR(vrule);
|
||||
|
||||
vrule->cookie = fco->cookie;
|
||||
sparx5_tc_use_dissectors(fco, admin, vrule);
|
||||
flow_action_for_each(idx, act, &frule->action) {
|
||||
switch (act->id) {
|
||||
case FLOW_ACTION_TRAP:
|
||||
err = vcap_rule_add_action_bit(vrule,
|
||||
VCAP_AF_CPU_COPY_ENA,
|
||||
VCAP_BIT_1);
|
||||
if (err)
|
||||
goto out;
|
||||
err = vcap_rule_add_action_u32(vrule,
|
||||
VCAP_AF_CPU_QUEUE_NUM, 0);
|
||||
if (err)
|
||||
goto out;
|
||||
err = vcap_rule_add_action_u32(vrule, VCAP_AF_MASK_MODE,
|
||||
SPX5_PMM_REPLACE_ALL);
|
||||
if (err)
|
||||
goto out;
|
||||
/* For now the actionset is hardcoded */
|
||||
err = vcap_set_rule_set_actionset(vrule,
|
||||
VCAP_AFS_BASE_TYPE);
|
||||
if (err)
|
||||
goto out;
|
||||
break;
|
||||
case FLOW_ACTION_ACCEPT:
|
||||
/* For now the actionset is hardcoded */
|
||||
err = vcap_set_rule_set_actionset(vrule,
|
||||
VCAP_AFS_BASE_TYPE);
|
||||
if (err)
|
||||
goto out;
|
||||
break;
|
||||
default:
|
||||
NL_SET_ERR_MSG_MOD(fco->common.extack,
|
||||
"Unsupported TC action");
|
||||
err = -EOPNOTSUPP;
|
||||
goto out;
|
||||
}
|
||||
}
|
||||
/* For now the keyset is hardcoded */
|
||||
err = vcap_set_rule_set_keyset(vrule, VCAP_KFS_MAC_ETYPE);
|
||||
if (err) {
|
||||
NL_SET_ERR_MSG_MOD(fco->common.extack,
|
||||
"No matching port keyset for filter protocol and keys");
|
||||
goto out;
|
||||
}
|
||||
err = vcap_val_rule(vrule, ETH_P_ALL);
|
||||
if (err) {
|
||||
vcap_set_tc_exterr(fco, vrule);
|
||||
goto out;
|
||||
}
|
||||
err = vcap_add_rule(vrule);
|
||||
if (err)
|
||||
NL_SET_ERR_MSG_MOD(fco->common.extack,
|
||||
"Could not add the filter");
|
||||
out:
|
||||
vcap_free_rule(vrule);
|
||||
return err;
|
||||
}
|
||||
|
||||
static int sparx5_tc_flower_destroy(struct net_device *ndev,
|
||||
struct flow_cls_offload *fco,
|
||||
struct vcap_admin *admin)
|
||||
{
|
||||
struct sparx5_port *port = netdev_priv(ndev);
|
||||
struct vcap_control *vctrl;
|
||||
int err = -ENOENT, rule_id;
|
||||
|
||||
vctrl = port->sparx5->vcap_ctrl;
|
||||
while (true) {
|
||||
rule_id = vcap_lookup_rule_by_cookie(vctrl, fco->cookie);
|
||||
if (rule_id <= 0)
|
||||
break;
|
||||
err = vcap_del_rule(vctrl, ndev, rule_id);
|
||||
if (err) {
|
||||
pr_err("%s:%d: could not delete rule %d\n",
|
||||
__func__, __LINE__, rule_id);
|
||||
break;
|
||||
}
|
||||
}
|
||||
return err;
|
||||
}
|
||||
|
||||
int sparx5_tc_flower(struct net_device *ndev, struct flow_cls_offload *fco,
|
||||
bool ingress)
|
||||
{
|
||||
struct sparx5_port *port = netdev_priv(ndev);
|
||||
struct vcap_control *vctrl;
|
||||
struct vcap_admin *admin;
|
||||
int err = -EINVAL;
|
||||
|
||||
/* Get vcap instance from the chain id */
|
||||
vctrl = port->sparx5->vcap_ctrl;
|
||||
admin = vcap_find_admin(vctrl, fco->common.chain_index);
|
||||
if (!admin) {
|
||||
NL_SET_ERR_MSG_MOD(fco->common.extack, "Invalid chain");
|
||||
return err;
|
||||
}
|
||||
|
||||
switch (fco->command) {
|
||||
case FLOW_CLS_REPLACE:
|
||||
return sparx5_tc_flower_replace(ndev, fco, admin);
|
||||
case FLOW_CLS_DESTROY:
|
||||
return sparx5_tc_flower_destroy(ndev, fco, admin);
|
||||
default:
|
||||
return -EOPNOTSUPP;
|
||||
}
|
||||
}
|
||||
1351
drivers/net/ethernet/microchip/sparx5/sparx5_vcap_ag_api.c
Normal file
1351
drivers/net/ethernet/microchip/sparx5/sparx5_vcap_ag_api.c
Normal file
File diff suppressed because it is too large
Load Diff
18
drivers/net/ethernet/microchip/sparx5/sparx5_vcap_ag_api.h
Normal file
18
drivers/net/ethernet/microchip/sparx5/sparx5_vcap_ag_api.h
Normal file
@ -0,0 +1,18 @@
|
||||
/* SPDX-License-Identifier: BSD-3-Clause */
|
||||
/* Copyright (C) 2022 Microchip Technology Inc. and its subsidiaries.
|
||||
* Microchip VCAP API
|
||||
*/
|
||||
|
||||
/* This file is autogenerated by cml-utils 2022-10-13 10:04:41 +0200.
|
||||
* Commit ID: fd7cafd175899f0672c73afb3a30fc872500ae86
|
||||
*/
|
||||
|
||||
#ifndef __SPARX5_VCAP_AG_API_H__
|
||||
#define __SPARX5_VCAP_AG_API_H__
|
||||
|
||||
/* VCAPs */
|
||||
extern const struct vcap_info sparx5_vcaps[];
|
||||
extern const struct vcap_statistics sparx5_vcap_stats;
|
||||
|
||||
#endif /* __SPARX5_VCAP_AG_API_H__ */
|
||||
|
||||
527
drivers/net/ethernet/microchip/sparx5/sparx5_vcap_impl.c
Normal file
527
drivers/net/ethernet/microchip/sparx5/sparx5_vcap_impl.c
Normal file
@ -0,0 +1,527 @@
|
||||
// SPDX-License-Identifier: GPL-2.0+
|
||||
/* Microchip Sparx5 Switch driver VCAP implementation
|
||||
*
|
||||
* Copyright (c) 2022 Microchip Technology Inc. and its subsidiaries.
|
||||
*
|
||||
* The Sparx5 Chip Register Model can be browsed at this location:
|
||||
* https://github.com/microchip-ung/sparx-5_reginfo
|
||||
*/
|
||||
|
||||
#include <linux/types.h>
|
||||
#include <linux/list.h>
|
||||
|
||||
#include "vcap_api.h"
|
||||
#include "vcap_api_client.h"
|
||||
#include "sparx5_main_regs.h"
|
||||
#include "sparx5_main.h"
|
||||
#include "sparx5_vcap_impl.h"
|
||||
#include "sparx5_vcap_ag_api.h"
|
||||
|
||||
#define SUPER_VCAP_BLK_SIZE 3072 /* addresses per Super VCAP block */
|
||||
#define STREAMSIZE (64 * 4) /* bytes in the VCAP cache area */
|
||||
|
||||
#define SPARX5_IS2_LOOKUPS 4
|
||||
|
||||
/* IS2 port keyset selection control */
|
||||
|
||||
/* IS2 non-ethernet traffic type keyset generation */
|
||||
enum vcap_is2_port_sel_noneth {
|
||||
VCAP_IS2_PS_NONETH_MAC_ETYPE,
|
||||
VCAP_IS2_PS_NONETH_CUSTOM_1,
|
||||
VCAP_IS2_PS_NONETH_CUSTOM_2,
|
||||
VCAP_IS2_PS_NONETH_NO_LOOKUP
|
||||
};
|
||||
|
||||
/* IS2 IPv4 unicast traffic type keyset generation */
|
||||
enum vcap_is2_port_sel_ipv4_uc {
|
||||
VCAP_IS2_PS_IPV4_UC_MAC_ETYPE,
|
||||
VCAP_IS2_PS_IPV4_UC_IP4_TCP_UDP_OTHER,
|
||||
VCAP_IS2_PS_IPV4_UC_IP_7TUPLE,
|
||||
};
|
||||
|
||||
/* IS2 IPv4 multicast traffic type keyset generation */
|
||||
enum vcap_is2_port_sel_ipv4_mc {
|
||||
VCAP_IS2_PS_IPV4_MC_MAC_ETYPE,
|
||||
VCAP_IS2_PS_IPV4_MC_IP4_TCP_UDP_OTHER,
|
||||
VCAP_IS2_PS_IPV4_MC_IP_7TUPLE,
|
||||
VCAP_IS2_PS_IPV4_MC_IP4_VID,
|
||||
};
|
||||
|
||||
/* IS2 IPv6 unicast traffic type keyset generation */
|
||||
enum vcap_is2_port_sel_ipv6_uc {
|
||||
VCAP_IS2_PS_IPV6_UC_MAC_ETYPE,
|
||||
VCAP_IS2_PS_IPV6_UC_IP_7TUPLE,
|
||||
VCAP_IS2_PS_IPV6_UC_IP6_STD,
|
||||
VCAP_IS2_PS_IPV6_UC_IP4_TCP_UDP_OTHER,
|
||||
};
|
||||
|
||||
/* IS2 IPv6 multicast traffic type keyset generation */
|
||||
enum vcap_is2_port_sel_ipv6_mc {
|
||||
VCAP_IS2_PS_IPV6_MC_MAC_ETYPE,
|
||||
VCAP_IS2_PS_IPV6_MC_IP_7TUPLE,
|
||||
VCAP_IS2_PS_IPV6_MC_IP6_VID,
|
||||
VCAP_IS2_PS_IPV6_MC_IP6_STD,
|
||||
VCAP_IS2_PS_IPV6_MC_IP4_TCP_UDP_OTHER,
|
||||
};
|
||||
|
||||
/* IS2 ARP traffic type keyset generation */
|
||||
enum vcap_is2_port_sel_arp {
|
||||
VCAP_IS2_PS_ARP_MAC_ETYPE,
|
||||
VCAP_IS2_PS_ARP_ARP,
|
||||
};
|
||||
|
||||
static struct sparx5_vcap_inst {
|
||||
enum vcap_type vtype; /* type of vcap */
|
||||
int vinst; /* instance number within the same type */
|
||||
int lookups; /* number of lookups in this vcap type */
|
||||
int lookups_per_instance; /* number of lookups in this instance */
|
||||
int first_cid; /* first chain id in this vcap */
|
||||
int last_cid; /* last chain id in this vcap */
|
||||
int count; /* number of available addresses, not in super vcap */
|
||||
int map_id; /* id in the super vcap block mapping (if applicable) */
|
||||
int blockno; /* starting block in super vcap (if applicable) */
|
||||
int blocks; /* number of blocks in super vcap (if applicable) */
|
||||
} sparx5_vcap_inst_cfg[] = {
|
||||
{
|
||||
.vtype = VCAP_TYPE_IS2, /* IS2-0 */
|
||||
.vinst = 0,
|
||||
.map_id = 4,
|
||||
.lookups = SPARX5_IS2_LOOKUPS,
|
||||
.lookups_per_instance = SPARX5_IS2_LOOKUPS / 2,
|
||||
.first_cid = SPARX5_VCAP_CID_IS2_L0,
|
||||
.last_cid = SPARX5_VCAP_CID_IS2_L2 - 1,
|
||||
.blockno = 0, /* Maps block 0-1 */
|
||||
.blocks = 2,
|
||||
},
|
||||
{
|
||||
.vtype = VCAP_TYPE_IS2, /* IS2-1 */
|
||||
.vinst = 1,
|
||||
.map_id = 5,
|
||||
.lookups = SPARX5_IS2_LOOKUPS,
|
||||
.lookups_per_instance = SPARX5_IS2_LOOKUPS / 2,
|
||||
.first_cid = SPARX5_VCAP_CID_IS2_L2,
|
||||
.last_cid = SPARX5_VCAP_CID_IS2_MAX,
|
||||
.blockno = 2, /* Maps block 2-3 */
|
||||
.blocks = 2,
|
||||
},
|
||||
};
|
||||
|
||||
/* Await the super VCAP completion of the current operation */
|
||||
static void sparx5_vcap_wait_super_update(struct sparx5 *sparx5)
|
||||
{
|
||||
u32 value;
|
||||
|
||||
read_poll_timeout(spx5_rd, value,
|
||||
!VCAP_SUPER_CTRL_UPDATE_SHOT_GET(value), 500, 10000,
|
||||
false, sparx5, VCAP_SUPER_CTRL);
|
||||
}
|
||||
|
||||
/* Initializing a VCAP address range: only IS2 for now */
|
||||
static void _sparx5_vcap_range_init(struct sparx5 *sparx5,
|
||||
struct vcap_admin *admin,
|
||||
u32 addr, u32 count)
|
||||
{
|
||||
u32 size = count - 1;
|
||||
|
||||
spx5_wr(VCAP_SUPER_CFG_MV_NUM_POS_SET(0) |
|
||||
VCAP_SUPER_CFG_MV_SIZE_SET(size),
|
||||
sparx5, VCAP_SUPER_CFG);
|
||||
spx5_wr(VCAP_SUPER_CTRL_UPDATE_CMD_SET(VCAP_CMD_INITIALIZE) |
|
||||
VCAP_SUPER_CTRL_UPDATE_ENTRY_DIS_SET(0) |
|
||||
VCAP_SUPER_CTRL_UPDATE_ACTION_DIS_SET(0) |
|
||||
VCAP_SUPER_CTRL_UPDATE_CNT_DIS_SET(0) |
|
||||
VCAP_SUPER_CTRL_UPDATE_ADDR_SET(addr) |
|
||||
VCAP_SUPER_CTRL_CLEAR_CACHE_SET(true) |
|
||||
VCAP_SUPER_CTRL_UPDATE_SHOT_SET(true),
|
||||
sparx5, VCAP_SUPER_CTRL);
|
||||
sparx5_vcap_wait_super_update(sparx5);
|
||||
}
|
||||
|
||||
/* Initializing VCAP rule data area */
|
||||
static void sparx5_vcap_block_init(struct sparx5 *sparx5,
|
||||
struct vcap_admin *admin)
|
||||
{
|
||||
_sparx5_vcap_range_init(sparx5, admin, admin->first_valid_addr,
|
||||
admin->last_valid_addr -
|
||||
admin->first_valid_addr);
|
||||
}
|
||||
|
||||
/* Get the keyset name from the sparx5 VCAP model */
|
||||
static const char *sparx5_vcap_keyset_name(struct net_device *ndev,
|
||||
enum vcap_keyfield_set keyset)
|
||||
{
|
||||
struct sparx5_port *port = netdev_priv(ndev);
|
||||
|
||||
return port->sparx5->vcap_ctrl->stats->keyfield_set_names[keyset];
|
||||
}
|
||||
|
||||
/* Check if this is the first lookup of IS2 */
|
||||
static bool sparx5_vcap_is2_is_first_chain(struct vcap_rule *rule)
|
||||
{
|
||||
return (rule->vcap_chain_id >= SPARX5_VCAP_CID_IS2_L0 &&
|
||||
rule->vcap_chain_id < SPARX5_VCAP_CID_IS2_L1) ||
|
||||
((rule->vcap_chain_id >= SPARX5_VCAP_CID_IS2_L2 &&
|
||||
rule->vcap_chain_id < SPARX5_VCAP_CID_IS2_L3));
|
||||
}
|
||||
|
||||
/* Set the narrow range ingress port mask on a rule */
|
||||
static void sparx5_vcap_add_range_port_mask(struct vcap_rule *rule,
|
||||
struct net_device *ndev)
|
||||
{
|
||||
struct sparx5_port *port = netdev_priv(ndev);
|
||||
u32 port_mask;
|
||||
u32 range;
|
||||
|
||||
range = port->portno / BITS_PER_TYPE(u32);
|
||||
/* Port bit set to match-any */
|
||||
port_mask = ~BIT(port->portno % BITS_PER_TYPE(u32));
|
||||
vcap_rule_add_key_u32(rule, VCAP_KF_IF_IGR_PORT_MASK_SEL, 0, 0xf);
|
||||
vcap_rule_add_key_u32(rule, VCAP_KF_IF_IGR_PORT_MASK_RNG, range, 0xf);
|
||||
vcap_rule_add_key_u32(rule, VCAP_KF_IF_IGR_PORT_MASK, 0, port_mask);
|
||||
}
|
||||
|
||||
/* Set the wide range ingress port mask on a rule */
|
||||
static void sparx5_vcap_add_wide_port_mask(struct vcap_rule *rule,
|
||||
struct net_device *ndev)
|
||||
{
|
||||
struct sparx5_port *port = netdev_priv(ndev);
|
||||
struct vcap_u72_key port_mask;
|
||||
u32 range;
|
||||
|
||||
/* Port bit set to match-any */
|
||||
memset(port_mask.value, 0, sizeof(port_mask.value));
|
||||
memset(port_mask.mask, 0xff, sizeof(port_mask.mask));
|
||||
range = port->portno / BITS_PER_BYTE;
|
||||
port_mask.mask[range] = ~BIT(port->portno % BITS_PER_BYTE);
|
||||
vcap_rule_add_key_u72(rule, VCAP_KF_IF_IGR_PORT_MASK, &port_mask);
|
||||
}
|
||||
|
||||
/* API callback used for validating a field keyset (check the port keysets) */
|
||||
static enum vcap_keyfield_set
|
||||
sparx5_vcap_validate_keyset(struct net_device *ndev,
|
||||
struct vcap_admin *admin,
|
||||
struct vcap_rule *rule,
|
||||
struct vcap_keyset_list *kslist,
|
||||
u16 l3_proto)
|
||||
{
|
||||
if (!kslist || kslist->cnt == 0)
|
||||
return VCAP_KFS_NO_VALUE;
|
||||
/* for now just return whatever the API suggests */
|
||||
return kslist->keysets[0];
|
||||
}
|
||||
|
||||
/* API callback used for adding default fields to a rule */
|
||||
static void sparx5_vcap_add_default_fields(struct net_device *ndev,
|
||||
struct vcap_admin *admin,
|
||||
struct vcap_rule *rule)
|
||||
{
|
||||
const struct vcap_field *field;
|
||||
|
||||
field = vcap_lookup_keyfield(rule, VCAP_KF_IF_IGR_PORT_MASK);
|
||||
if (field && field->width == SPX5_PORTS)
|
||||
sparx5_vcap_add_wide_port_mask(rule, ndev);
|
||||
else if (field && field->width == BITS_PER_TYPE(u32))
|
||||
sparx5_vcap_add_range_port_mask(rule, ndev);
|
||||
else
|
||||
pr_err("%s:%d: %s: could not add an ingress port mask for: %s\n",
|
||||
__func__, __LINE__, netdev_name(ndev),
|
||||
sparx5_vcap_keyset_name(ndev, rule->keyset));
|
||||
/* add the lookup bit */
|
||||
if (sparx5_vcap_is2_is_first_chain(rule))
|
||||
vcap_rule_add_key_bit(rule, VCAP_KF_LOOKUP_FIRST_IS, VCAP_BIT_1);
|
||||
else
|
||||
vcap_rule_add_key_bit(rule, VCAP_KF_LOOKUP_FIRST_IS, VCAP_BIT_0);
|
||||
}
|
||||
|
||||
/* API callback used for erasing the vcap cache area (not the register area) */
|
||||
static void sparx5_vcap_cache_erase(struct vcap_admin *admin)
|
||||
{
|
||||
memset(admin->cache.keystream, 0, STREAMSIZE);
|
||||
memset(admin->cache.maskstream, 0, STREAMSIZE);
|
||||
memset(admin->cache.actionstream, 0, STREAMSIZE);
|
||||
memset(&admin->cache.counter, 0, sizeof(admin->cache.counter));
|
||||
}
|
||||
|
||||
/* API callback used for writing to the VCAP cache */
|
||||
static void sparx5_vcap_cache_write(struct net_device *ndev,
|
||||
struct vcap_admin *admin,
|
||||
enum vcap_selection sel,
|
||||
u32 start,
|
||||
u32 count)
|
||||
{
|
||||
struct sparx5_port *port = netdev_priv(ndev);
|
||||
struct sparx5 *sparx5 = port->sparx5;
|
||||
u32 *keystr, *mskstr, *actstr;
|
||||
int idx;
|
||||
|
||||
keystr = &admin->cache.keystream[start];
|
||||
mskstr = &admin->cache.maskstream[start];
|
||||
actstr = &admin->cache.actionstream[start];
|
||||
switch (sel) {
|
||||
case VCAP_SEL_ENTRY:
|
||||
for (idx = 0; idx < count; ++idx) {
|
||||
/* Avoid 'match-off' by setting value & mask */
|
||||
spx5_wr(keystr[idx] & mskstr[idx], sparx5,
|
||||
VCAP_SUPER_VCAP_ENTRY_DAT(idx));
|
||||
spx5_wr(~mskstr[idx], sparx5,
|
||||
VCAP_SUPER_VCAP_MASK_DAT(idx));
|
||||
}
|
||||
break;
|
||||
case VCAP_SEL_ACTION:
|
||||
for (idx = 0; idx < count; ++idx)
|
||||
spx5_wr(actstr[idx], sparx5,
|
||||
VCAP_SUPER_VCAP_ACTION_DAT(idx));
|
||||
break;
|
||||
case VCAP_SEL_ALL:
|
||||
pr_err("%s:%d: cannot write all streams at once\n",
|
||||
__func__, __LINE__);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* API callback used for reading from the VCAP into the VCAP cache */
|
||||
static void sparx5_vcap_cache_read(struct net_device *ndev,
|
||||
struct vcap_admin *admin,
|
||||
enum vcap_selection sel, u32 start,
|
||||
u32 count)
|
||||
{
|
||||
/* this will be added later */
|
||||
}
|
||||
|
||||
/* API callback used for initializing a VCAP address range */
|
||||
static void sparx5_vcap_range_init(struct net_device *ndev,
|
||||
struct vcap_admin *admin, u32 addr,
|
||||
u32 count)
|
||||
{
|
||||
struct sparx5_port *port = netdev_priv(ndev);
|
||||
struct sparx5 *sparx5 = port->sparx5;
|
||||
|
||||
_sparx5_vcap_range_init(sparx5, admin, addr, count);
|
||||
}
|
||||
|
||||
/* API callback used for updating the VCAP cache */
|
||||
static void sparx5_vcap_update(struct net_device *ndev,
|
||||
struct vcap_admin *admin, enum vcap_command cmd,
|
||||
enum vcap_selection sel, u32 addr)
|
||||
{
|
||||
struct sparx5_port *port = netdev_priv(ndev);
|
||||
struct sparx5 *sparx5 = port->sparx5;
|
||||
bool clear;
|
||||
|
||||
clear = (cmd == VCAP_CMD_INITIALIZE);
|
||||
spx5_wr(VCAP_SUPER_CFG_MV_NUM_POS_SET(0) |
|
||||
VCAP_SUPER_CFG_MV_SIZE_SET(0), sparx5, VCAP_SUPER_CFG);
|
||||
spx5_wr(VCAP_SUPER_CTRL_UPDATE_CMD_SET(cmd) |
|
||||
VCAP_SUPER_CTRL_UPDATE_ENTRY_DIS_SET((VCAP_SEL_ENTRY & sel) == 0) |
|
||||
VCAP_SUPER_CTRL_UPDATE_ACTION_DIS_SET((VCAP_SEL_ACTION & sel) == 0) |
|
||||
VCAP_SUPER_CTRL_UPDATE_CNT_DIS_SET((VCAP_SEL_COUNTER & sel) == 0) |
|
||||
VCAP_SUPER_CTRL_UPDATE_ADDR_SET(addr) |
|
||||
VCAP_SUPER_CTRL_CLEAR_CACHE_SET(clear) |
|
||||
VCAP_SUPER_CTRL_UPDATE_SHOT_SET(true),
|
||||
sparx5, VCAP_SUPER_CTRL);
|
||||
sparx5_vcap_wait_super_update(sparx5);
|
||||
}
|
||||
|
||||
/* API callback used for moving a block of rules in the VCAP */
|
||||
static void sparx5_vcap_move(struct net_device *ndev, struct vcap_admin *admin,
|
||||
u32 addr, int offset, int count)
|
||||
{
|
||||
/* this will be added later */
|
||||
}
|
||||
|
||||
/* Provide port information via a callback interface */
|
||||
static int sparx5_port_info(struct net_device *ndev, enum vcap_type vtype,
|
||||
int (*pf)(void *out, int arg, const char *fmt, ...),
|
||||
void *out, int arg)
|
||||
{
|
||||
/* this will be added later */
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* API callback operations: only IS2 is supported for now */
|
||||
static struct vcap_operations sparx5_vcap_ops = {
|
||||
.validate_keyset = sparx5_vcap_validate_keyset,
|
||||
.add_default_fields = sparx5_vcap_add_default_fields,
|
||||
.cache_erase = sparx5_vcap_cache_erase,
|
||||
.cache_write = sparx5_vcap_cache_write,
|
||||
.cache_read = sparx5_vcap_cache_read,
|
||||
.init = sparx5_vcap_range_init,
|
||||
.update = sparx5_vcap_update,
|
||||
.move = sparx5_vcap_move,
|
||||
.port_info = sparx5_port_info,
|
||||
};
|
||||
|
||||
/* Enable lookups per port and set the keyset generation: only IS2 for now */
|
||||
static void sparx5_vcap_port_key_selection(struct sparx5 *sparx5,
|
||||
struct vcap_admin *admin)
|
||||
{
|
||||
int portno, lookup;
|
||||
u32 keysel;
|
||||
|
||||
/* enable all 4 lookups on all ports */
|
||||
for (portno = 0; portno < SPX5_PORTS; ++portno)
|
||||
spx5_wr(ANA_ACL_VCAP_S2_CFG_SEC_ENA_SET(0xf), sparx5,
|
||||
ANA_ACL_VCAP_S2_CFG(portno));
|
||||
|
||||
/* all traffic types generate the MAC_ETYPE keyset for now in all
|
||||
* lookups on all ports
|
||||
*/
|
||||
keysel = ANA_ACL_VCAP_S2_KEY_SEL_KEY_SEL_ENA_SET(true) |
|
||||
ANA_ACL_VCAP_S2_KEY_SEL_NON_ETH_KEY_SEL_SET(VCAP_IS2_PS_NONETH_MAC_ETYPE) |
|
||||
ANA_ACL_VCAP_S2_KEY_SEL_IP4_MC_KEY_SEL_SET(VCAP_IS2_PS_IPV4_MC_MAC_ETYPE) |
|
||||
ANA_ACL_VCAP_S2_KEY_SEL_IP4_UC_KEY_SEL_SET(VCAP_IS2_PS_IPV4_UC_MAC_ETYPE) |
|
||||
ANA_ACL_VCAP_S2_KEY_SEL_IP6_MC_KEY_SEL_SET(VCAP_IS2_PS_IPV6_MC_MAC_ETYPE) |
|
||||
ANA_ACL_VCAP_S2_KEY_SEL_IP6_UC_KEY_SEL_SET(VCAP_IS2_PS_IPV6_UC_MAC_ETYPE) |
|
||||
ANA_ACL_VCAP_S2_KEY_SEL_ARP_KEY_SEL_SET(VCAP_IS2_PS_ARP_MAC_ETYPE);
|
||||
for (lookup = 0; lookup < admin->lookups; ++lookup) {
|
||||
for (portno = 0; portno < SPX5_PORTS; ++portno) {
|
||||
spx5_wr(keysel, sparx5,
|
||||
ANA_ACL_VCAP_S2_KEY_SEL(portno, lookup));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Disable lookups per port and set the keyset generation: only IS2 for now */
|
||||
static void sparx5_vcap_port_key_deselection(struct sparx5 *sparx5,
|
||||
struct vcap_admin *admin)
|
||||
{
|
||||
int portno;
|
||||
|
||||
for (portno = 0; portno < SPX5_PORTS; ++portno)
|
||||
spx5_rmw(ANA_ACL_VCAP_S2_CFG_SEC_ENA_SET(0),
|
||||
ANA_ACL_VCAP_S2_CFG_SEC_ENA,
|
||||
sparx5,
|
||||
ANA_ACL_VCAP_S2_CFG(portno));
|
||||
}
|
||||
|
||||
static void sparx5_vcap_admin_free(struct vcap_admin *admin)
|
||||
{
|
||||
if (!admin)
|
||||
return;
|
||||
kfree(admin->cache.keystream);
|
||||
kfree(admin->cache.maskstream);
|
||||
kfree(admin->cache.actionstream);
|
||||
kfree(admin);
|
||||
}
|
||||
|
||||
/* Allocate a vcap instance with a rule list and a cache area */
|
||||
static struct vcap_admin *
|
||||
sparx5_vcap_admin_alloc(struct sparx5 *sparx5, struct vcap_control *ctrl,
|
||||
const struct sparx5_vcap_inst *cfg)
|
||||
{
|
||||
struct vcap_admin *admin;
|
||||
|
||||
admin = kzalloc(sizeof(*admin), GFP_KERNEL);
|
||||
if (!admin)
|
||||
return ERR_PTR(-ENOMEM);
|
||||
INIT_LIST_HEAD(&admin->list);
|
||||
INIT_LIST_HEAD(&admin->rules);
|
||||
admin->vtype = cfg->vtype;
|
||||
admin->vinst = cfg->vinst;
|
||||
admin->lookups = cfg->lookups;
|
||||
admin->lookups_per_instance = cfg->lookups_per_instance;
|
||||
admin->first_cid = cfg->first_cid;
|
||||
admin->last_cid = cfg->last_cid;
|
||||
admin->cache.keystream =
|
||||
kzalloc(STREAMSIZE, GFP_KERNEL);
|
||||
admin->cache.maskstream =
|
||||
kzalloc(STREAMSIZE, GFP_KERNEL);
|
||||
admin->cache.actionstream =
|
||||
kzalloc(STREAMSIZE, GFP_KERNEL);
|
||||
if (!admin->cache.keystream || !admin->cache.maskstream ||
|
||||
!admin->cache.actionstream) {
|
||||
sparx5_vcap_admin_free(admin);
|
||||
return ERR_PTR(-ENOMEM);
|
||||
}
|
||||
return admin;
|
||||
}
|
||||
|
||||
/* Do block allocations and provide addresses for VCAP instances */
|
||||
static void sparx5_vcap_block_alloc(struct sparx5 *sparx5,
|
||||
struct vcap_admin *admin,
|
||||
const struct sparx5_vcap_inst *cfg)
|
||||
{
|
||||
int idx;
|
||||
|
||||
/* Super VCAP block mapping and address configuration. Block 0
|
||||
* is assigned addresses 0 through 3071, block 1 is assigned
|
||||
* addresses 3072 though 6143, and so on.
|
||||
*/
|
||||
for (idx = cfg->blockno; idx < cfg->blockno + cfg->blocks; ++idx) {
|
||||
spx5_wr(VCAP_SUPER_IDX_CORE_IDX_SET(idx), sparx5,
|
||||
VCAP_SUPER_IDX);
|
||||
spx5_wr(VCAP_SUPER_MAP_CORE_MAP_SET(cfg->map_id), sparx5,
|
||||
VCAP_SUPER_MAP);
|
||||
}
|
||||
admin->first_valid_addr = cfg->blockno * SUPER_VCAP_BLK_SIZE;
|
||||
admin->last_used_addr = admin->first_valid_addr +
|
||||
cfg->blocks * SUPER_VCAP_BLK_SIZE;
|
||||
admin->last_valid_addr = admin->last_used_addr - 1;
|
||||
}
|
||||
|
||||
/* Allocate a vcap control and vcap instances and configure the system */
|
||||
int sparx5_vcap_init(struct sparx5 *sparx5)
|
||||
{
|
||||
const struct sparx5_vcap_inst *cfg;
|
||||
struct vcap_control *ctrl;
|
||||
struct vcap_admin *admin;
|
||||
int err = 0, idx;
|
||||
|
||||
/* Create a VCAP control instance that owns the platform specific VCAP
|
||||
* model with VCAP instances and information about keysets, keys,
|
||||
* actionsets and actions
|
||||
* - Create administrative state for each available VCAP
|
||||
* - Lists of rules
|
||||
* - Address information
|
||||
* - Initialize VCAP blocks
|
||||
* - Configure port keysets
|
||||
*/
|
||||
ctrl = kzalloc(sizeof(*ctrl), GFP_KERNEL);
|
||||
if (!ctrl)
|
||||
return -ENOMEM;
|
||||
|
||||
sparx5->vcap_ctrl = ctrl;
|
||||
/* select the sparx5 VCAP model */
|
||||
ctrl->vcaps = sparx5_vcaps;
|
||||
ctrl->stats = &sparx5_vcap_stats;
|
||||
/* Setup callbacks to allow the API to use the VCAP HW */
|
||||
ctrl->ops = &sparx5_vcap_ops;
|
||||
|
||||
INIT_LIST_HEAD(&ctrl->list);
|
||||
for (idx = 0; idx < ARRAY_SIZE(sparx5_vcap_inst_cfg); ++idx) {
|
||||
cfg = &sparx5_vcap_inst_cfg[idx];
|
||||
admin = sparx5_vcap_admin_alloc(sparx5, ctrl, cfg);
|
||||
if (IS_ERR(admin)) {
|
||||
err = PTR_ERR(admin);
|
||||
pr_err("%s:%d: vcap allocation failed: %d\n",
|
||||
__func__, __LINE__, err);
|
||||
return err;
|
||||
}
|
||||
sparx5_vcap_block_alloc(sparx5, admin, cfg);
|
||||
sparx5_vcap_block_init(sparx5, admin);
|
||||
if (cfg->vinst == 0)
|
||||
sparx5_vcap_port_key_selection(sparx5, admin);
|
||||
list_add_tail(&admin->list, &ctrl->list);
|
||||
}
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
void sparx5_vcap_destroy(struct sparx5 *sparx5)
|
||||
{
|
||||
struct vcap_control *ctrl = sparx5->vcap_ctrl;
|
||||
struct vcap_admin *admin, *admin_next;
|
||||
|
||||
if (!ctrl)
|
||||
return;
|
||||
|
||||
list_for_each_entry_safe(admin, admin_next, &ctrl->list, list) {
|
||||
sparx5_vcap_port_key_deselection(sparx5, admin);
|
||||
vcap_del_rules(ctrl, admin);
|
||||
list_del(&admin->list);
|
||||
sparx5_vcap_admin_free(admin);
|
||||
}
|
||||
kfree(ctrl);
|
||||
}
|
||||
20
drivers/net/ethernet/microchip/sparx5/sparx5_vcap_impl.h
Normal file
20
drivers/net/ethernet/microchip/sparx5/sparx5_vcap_impl.h
Normal file
@ -0,0 +1,20 @@
|
||||
/* SPDX-License-Identifier: GPL-2.0+ */
|
||||
/* Microchip Sparx5 Switch driver VCAP implementation
|
||||
*
|
||||
* Copyright (c) 2022 Microchip Technology Inc. and its subsidiaries.
|
||||
*
|
||||
* The Sparx5 Chip Register Model can be browsed at this location:
|
||||
* https://github.com/microchip-ung/sparx-5_reginfo
|
||||
*/
|
||||
|
||||
#ifndef __SPARX5_VCAP_IMPL_H__
|
||||
#define __SPARX5_VCAP_IMPL_H__
|
||||
|
||||
#define SPARX5_VCAP_CID_IS2_L0 VCAP_CID_INGRESS_STAGE2_L0 /* IS2 lookup 0 */
|
||||
#define SPARX5_VCAP_CID_IS2_L1 VCAP_CID_INGRESS_STAGE2_L1 /* IS2 lookup 1 */
|
||||
#define SPARX5_VCAP_CID_IS2_L2 VCAP_CID_INGRESS_STAGE2_L2 /* IS2 lookup 2 */
|
||||
#define SPARX5_VCAP_CID_IS2_L3 VCAP_CID_INGRESS_STAGE2_L3 /* IS2 lookup 3 */
|
||||
#define SPARX5_VCAP_CID_IS2_MAX \
|
||||
(VCAP_CID_INGRESS_STAGE2_L3 + VCAP_CID_LOOKUP_SIZE - 1) /* IS2 Max */
|
||||
|
||||
#endif /* __SPARX5_VCAP_IMPL_H__ */
|
||||
52
drivers/net/ethernet/microchip/vcap/Kconfig
Normal file
52
drivers/net/ethernet/microchip/vcap/Kconfig
Normal file
@ -0,0 +1,52 @@
|
||||
# SPDX-License-Identifier: GPL-2.0-only
|
||||
#
|
||||
# Microchip VCAP API configuration
|
||||
#
|
||||
|
||||
if NET_VENDOR_MICROCHIP
|
||||
|
||||
config VCAP
|
||||
bool "VCAP (Versatile Content-Aware Processor) library"
|
||||
help
|
||||
Provides the basic VCAP functionality for multiple Microchip switchcores
|
||||
|
||||
A VCAP is essentially a TCAM with rules consisting of
|
||||
|
||||
- Programmable key fields
|
||||
- Programmable action fields
|
||||
- A counter (which may be only one bit wide)
|
||||
|
||||
Besides this each VCAP has:
|
||||
|
||||
- A number of lookups
|
||||
- A keyset configuration per port per lookup
|
||||
|
||||
The VCAP implementation provides switchcore independent handling of rules
|
||||
and supports:
|
||||
|
||||
- Creating and deleting rules
|
||||
- Updating and getting rules
|
||||
|
||||
The platform specific configuration as well as the platform specific model
|
||||
of the VCAP instances are attached to the VCAP API and a client can then
|
||||
access rules via the API in a platform independent way, with the
|
||||
limitations that each VCAP has in terms of its supported keys and actions.
|
||||
|
||||
Different switchcores will have different VCAP instances with different
|
||||
characteristics. Look in the datasheet for the VCAP specifications for the
|
||||
specific switchcore.
|
||||
|
||||
config VCAP_KUNIT_TEST
|
||||
bool "KUnit test for VCAP library" if !KUNIT_ALL_TESTS
|
||||
depends on KUNIT
|
||||
depends on KUNIT=y && VCAP=y && y
|
||||
default KUNIT_ALL_TESTS
|
||||
help
|
||||
This builds unit tests for the VCAP library.
|
||||
|
||||
For more information on KUnit and unit tests in general, please refer
|
||||
to the KUnit documentation in Documentation/dev-tools/kunit/.
|
||||
|
||||
If unsure, say N.
|
||||
|
||||
endif # NET_VENDOR_MICROCHIP
|
||||
9
drivers/net/ethernet/microchip/vcap/Makefile
Normal file
9
drivers/net/ethernet/microchip/vcap/Makefile
Normal file
@ -0,0 +1,9 @@
|
||||
# SPDX-License-Identifier: GPL-2.0-only
|
||||
#
|
||||
# Makefile for the Microchip VCAP API
|
||||
#
|
||||
|
||||
obj-$(CONFIG_VCAP) += vcap.o
|
||||
obj-$(CONFIG_VCAP_KUNIT_TEST) += vcap_model_kunit.o
|
||||
|
||||
vcap-y += vcap_api.o
|
||||
326
drivers/net/ethernet/microchip/vcap/vcap_ag_api.h
Normal file
326
drivers/net/ethernet/microchip/vcap/vcap_ag_api.h
Normal file
@ -0,0 +1,326 @@
|
||||
/* SPDX-License-Identifier: BSD-3-Clause */
|
||||
/* Copyright (C) 2022 Microchip Technology Inc. and its subsidiaries.
|
||||
* Microchip VCAP API
|
||||
*/
|
||||
|
||||
/* This file is autogenerated by cml-utils 2022-10-13 10:04:41 +0200.
|
||||
* Commit ID: fd7cafd175899f0672c73afb3a30fc872500ae86
|
||||
*/
|
||||
|
||||
#ifndef __VCAP_AG_API__
|
||||
#define __VCAP_AG_API__
|
||||
|
||||
enum vcap_type {
|
||||
VCAP_TYPE_IS2,
|
||||
VCAP_TYPE_MAX
|
||||
};
|
||||
|
||||
/* Keyfieldset names with origin information */
|
||||
enum vcap_keyfield_set {
|
||||
VCAP_KFS_NO_VALUE, /* initial value */
|
||||
VCAP_KFS_ARP, /* sparx5 is2 X6 */
|
||||
VCAP_KFS_IP4_OTHER, /* sparx5 is2 X6 */
|
||||
VCAP_KFS_IP4_TCP_UDP, /* sparx5 is2 X6 */
|
||||
VCAP_KFS_IP6_STD, /* sparx5 is2 X6 */
|
||||
VCAP_KFS_IP_7TUPLE, /* sparx5 is2 X12 */
|
||||
VCAP_KFS_MAC_ETYPE, /* sparx5 is2 X6 */
|
||||
};
|
||||
|
||||
/* List of keyfields with description
|
||||
*
|
||||
* Keys ending in _IS are booleans derived from frame data
|
||||
* Keys ending in _CLS are classified frame data
|
||||
*
|
||||
* VCAP_KF_8021Q_DEI_CLS: W1, sparx5: is2
|
||||
* Classified DEI
|
||||
* VCAP_KF_8021Q_PCP_CLS: W3, sparx5: is2
|
||||
* Classified PCP
|
||||
* VCAP_KF_8021Q_VID_CLS: W13, sparx5: is2
|
||||
* Classified VID
|
||||
* VCAP_KF_8021Q_VLAN_TAGGED_IS: W1, sparx5: is2
|
||||
* Sparx5: Set if frame was received with a VLAN tag, LAN966x: Set if frame has
|
||||
* one or more Q-tags. Independent of port VLAN awareness
|
||||
* VCAP_KF_ARP_ADDR_SPACE_OK_IS: W1, sparx5: is2
|
||||
* Set if hardware address is Ethernet
|
||||
* VCAP_KF_ARP_LEN_OK_IS: W1, sparx5: is2
|
||||
* Set if hardware address length = 6 (Ethernet) and IP address length = 4 (IP).
|
||||
* VCAP_KF_ARP_OPCODE: W2, sparx5: is2
|
||||
* ARP opcode
|
||||
* VCAP_KF_ARP_OPCODE_UNKNOWN_IS: W1, sparx5: is2
|
||||
* Set if not one of the codes defined in VCAP_KF_ARP_OPCODE
|
||||
* VCAP_KF_ARP_PROTO_SPACE_OK_IS: W1, sparx5: is2
|
||||
* Set if protocol address space is 0x0800
|
||||
* VCAP_KF_ARP_SENDER_MATCH_IS: W1, sparx5: is2
|
||||
* Sender Hardware Address = SMAC (ARP)
|
||||
* VCAP_KF_ARP_TGT_MATCH_IS: W1, sparx5: is2
|
||||
* Target Hardware Address = SMAC (RARP)
|
||||
* VCAP_KF_ETYPE: W16, sparx5: is2
|
||||
* Ethernet type
|
||||
* VCAP_KF_ETYPE_LEN_IS: W1, sparx5: is2
|
||||
* Set if frame has EtherType >= 0x600
|
||||
* VCAP_KF_IF_IGR_PORT_MASK: sparx5 is2 W32, sparx5 is2 W65
|
||||
* Ingress port mask, one bit per port/erleg
|
||||
* VCAP_KF_IF_IGR_PORT_MASK_L3: W1, sparx5: is2
|
||||
* If set, IF_IGR_PORT_MASK, IF_IGR_PORT_MASK_RNG, and IF_IGR_PORT_MASK_SEL are
|
||||
* used to specify L3 interfaces
|
||||
* VCAP_KF_IF_IGR_PORT_MASK_RNG: W4, sparx5: is2
|
||||
* Range selector for IF_IGR_PORT_MASK. Specifies which group of 32 ports are
|
||||
* available in IF_IGR_PORT_MASK
|
||||
* VCAP_KF_IF_IGR_PORT_MASK_SEL: W2, sparx5: is2
|
||||
* Mode selector for IF_IGR_PORT_MASK, applicable when IF_IGR_PORT_MASK_L3 == 0.
|
||||
* Mapping: 0: DEFAULT 1: LOOPBACK 2: MASQUERADE 3: CPU_VD
|
||||
* VCAP_KF_IP4_IS: W1, sparx5: is2
|
||||
* Set if frame has EtherType = 0x800 and IP version = 4
|
||||
* VCAP_KF_ISDX_CLS: W12, sparx5: is2
|
||||
* Classified ISDX
|
||||
* VCAP_KF_ISDX_GT0_IS: W1, sparx5: is2
|
||||
* Set if classified ISDX > 0
|
||||
* VCAP_KF_L2_BC_IS: W1, sparx5: is2
|
||||
* Set if frame’s destination MAC address is the broadcast address
|
||||
* (FF-FF-FF-FF-FF-FF).
|
||||
* VCAP_KF_L2_DMAC: W48, sparx5: is2
|
||||
* Destination MAC address
|
||||
* VCAP_KF_L2_FWD_IS: W1, sparx5: is2
|
||||
* Set if the frame is allowed to be forwarded to front ports
|
||||
* VCAP_KF_L2_MC_IS: W1, sparx5: is2
|
||||
* Set if frame’s destination MAC address is a multicast address (bit 40 = 1).
|
||||
* VCAP_KF_L2_PAYLOAD_ETYPE: W64, sparx5: is2
|
||||
* Byte 0-7 of L2 payload after Type/Len field and overloading for OAM
|
||||
* VCAP_KF_L2_SMAC: W48, sparx5: is2
|
||||
* Source MAC address
|
||||
* VCAP_KF_L3_DIP_EQ_SIP_IS: W1, sparx5: is2
|
||||
* Set if Src IP matches Dst IP address
|
||||
* VCAP_KF_L3_DST_IS: W1, sparx5: is2
|
||||
* Set if lookup is done for egress router leg
|
||||
* VCAP_KF_L3_FRAGMENT_TYPE: W2, sparx5: is2
|
||||
* L3 Fragmentation type (none, initial, suspicious, valid follow up)
|
||||
* VCAP_KF_L3_FRAG_INVLD_L4_LEN: W1, sparx5: is2
|
||||
* Set if frame's L4 length is less than ANA_CL:COMMON:CLM_FRAGMENT_CFG.L4_MIN_L
|
||||
* EN
|
||||
* VCAP_KF_L3_IP4_DIP: W32, sparx5: is2
|
||||
* Destination IPv4 Address
|
||||
* VCAP_KF_L3_IP4_SIP: W32, sparx5: is2
|
||||
* Source IPv4 Address
|
||||
* VCAP_KF_L3_IP6_DIP: W128, sparx5: is2
|
||||
* Sparx5: Full IPv6 DIP, LAN966x: Either Full IPv6 DIP or a subset depending on
|
||||
* frame type
|
||||
* VCAP_KF_L3_IP6_SIP: W128, sparx5: is2
|
||||
* Sparx5: Full IPv6 SIP, LAN966x: Either Full IPv6 SIP or a subset depending on
|
||||
* frame type
|
||||
* VCAP_KF_L3_IP_PROTO: W8, sparx5: is2
|
||||
* IPv4 frames: IP protocol. IPv6 frames: Next header, same as for IPV4
|
||||
* VCAP_KF_L3_OPTIONS_IS: W1, sparx5: is2
|
||||
* Set if IPv4 frame contains options (IP len > 5)
|
||||
* VCAP_KF_L3_PAYLOAD: sparx5 is2 W96, sparx5 is2 W40
|
||||
* Sparx5: Payload bytes after IP header. IPv4: IPv4 options are not parsed so
|
||||
* payload is always taken 20 bytes after the start of the IPv4 header, LAN966x:
|
||||
* Bytes 0-6 after IP header
|
||||
* VCAP_KF_L3_RT_IS: W1, sparx5: is2
|
||||
* Set if frame has hit a router leg
|
||||
* VCAP_KF_L3_TOS: W8, sparx5: is2
|
||||
* Sparx5: Frame's IPv4/IPv6 DSCP and ECN fields, LAN966x: IP TOS field
|
||||
* VCAP_KF_L3_TTL_GT0: W1, sparx5: is2
|
||||
* Set if IPv4 TTL / IPv6 hop limit is greater than 0
|
||||
* VCAP_KF_L4_ACK: W1, sparx5: is2
|
||||
* Sparx5 and LAN966x: TCP flag ACK, LAN966x only: PTP over UDP: flagField bit 2
|
||||
* (unicastFlag)
|
||||
* VCAP_KF_L4_DPORT: W16, sparx5: is2
|
||||
* Sparx5: TCP/UDP destination port. Overloading for IP_7TUPLE: Non-TCP/UDP IP
|
||||
* frames: L4_DPORT = L3_IP_PROTO, LAN966x: TCP/UDP destination port
|
||||
* VCAP_KF_L4_FIN: W1, sparx5: is2
|
||||
* TCP flag FIN, LAN966x: TCP flag FIN, and for PTP over UDP: messageType bit 1
|
||||
* VCAP_KF_L4_PAYLOAD: W64, sparx5: is2
|
||||
* Payload bytes after TCP/UDP header Overloading for IP_7TUPLE: Non TCP/UDP
|
||||
* frames: Payload bytes 0–7 after IP header. IPv4 options are not parsed so
|
||||
* payload is always taken 20 bytes after the start of the IPv4 header for non
|
||||
* TCP/UDP IPv4 frames
|
||||
* VCAP_KF_L4_PSH: W1, sparx5: is2
|
||||
* Sparx5: TCP flag PSH, LAN966x: TCP: TCP flag PSH. PTP over UDP: flagField bit
|
||||
* 1 (twoStepFlag)
|
||||
* VCAP_KF_L4_RNG: W16, sparx5: is2
|
||||
* Range checker bitmask (one for each range checker). Input into range checkers
|
||||
* is taken from classified results (VID, DSCP) and frame (SPORT, DPORT, ETYPE,
|
||||
* outer VID, inner VID)
|
||||
* VCAP_KF_L4_RST: W1, sparx5: is2
|
||||
* Sparx5: TCP flag RST , LAN966x: TCP: TCP flag RST. PTP over UDP: messageType
|
||||
* bit 3
|
||||
* VCAP_KF_L4_SEQUENCE_EQ0_IS: W1, sparx5: is2
|
||||
* Set if TCP sequence number is 0, LAN966x: Overlayed with PTP over UDP:
|
||||
* messageType bit 0
|
||||
* VCAP_KF_L4_SPORT: W16, sparx5: is2
|
||||
* TCP/UDP source port
|
||||
* VCAP_KF_L4_SPORT_EQ_DPORT_IS: W1, sparx5: is2
|
||||
* Set if UDP or TCP source port equals UDP or TCP destination port
|
||||
* VCAP_KF_L4_SYN: W1, sparx5: is2
|
||||
* Sparx5: TCP flag SYN, LAN966x: TCP: TCP flag SYN. PTP over UDP: messageType
|
||||
* bit 2
|
||||
* VCAP_KF_L4_URG: W1, sparx5: is2
|
||||
* Sparx5: TCP flag URG, LAN966x: TCP: TCP flag URG. PTP over UDP: flagField bit
|
||||
* 7 (reserved)
|
||||
* VCAP_KF_LOOKUP_FIRST_IS: W1, sparx5: is2
|
||||
* Selects between entries relevant for first and second lookup. Set for first
|
||||
* lookup, cleared for second lookup.
|
||||
* VCAP_KF_LOOKUP_PAG: W8, sparx5: is2
|
||||
* Classified Policy Association Group: chains rules from IS1/CLM to IS2
|
||||
* VCAP_KF_OAM_CCM_CNTS_EQ0: W1, sparx5: is2
|
||||
* Dual-ended loss measurement counters in CCM frames are all zero
|
||||
* VCAP_KF_OAM_Y1731_IS: W1, sparx5: is2
|
||||
* Set if frame’s EtherType = 0x8902
|
||||
* VCAP_KF_TCP_IS: W1, sparx5: is2
|
||||
* Set if frame is IPv4 TCP frame (IP protocol = 6) or IPv6 TCP frames (Next
|
||||
* header = 6)
|
||||
* VCAP_KF_TCP_UDP_IS: W1, sparx5: is2
|
||||
* Set if frame is IPv4/IPv6 TCP or UDP frame (IP protocol/next header equals 6
|
||||
* or 17)
|
||||
* VCAP_KF_TYPE: sparx5 is2 W4, sparx5 is2 W2
|
||||
* Keyset type id - set by the API
|
||||
*/
|
||||
|
||||
/* Keyfield names */
|
||||
enum vcap_key_field {
|
||||
VCAP_KF_NO_VALUE, /* initial value */
|
||||
VCAP_KF_8021Q_DEI_CLS,
|
||||
VCAP_KF_8021Q_PCP_CLS,
|
||||
VCAP_KF_8021Q_VID_CLS,
|
||||
VCAP_KF_8021Q_VLAN_TAGGED_IS,
|
||||
VCAP_KF_ARP_ADDR_SPACE_OK_IS,
|
||||
VCAP_KF_ARP_LEN_OK_IS,
|
||||
VCAP_KF_ARP_OPCODE,
|
||||
VCAP_KF_ARP_OPCODE_UNKNOWN_IS,
|
||||
VCAP_KF_ARP_PROTO_SPACE_OK_IS,
|
||||
VCAP_KF_ARP_SENDER_MATCH_IS,
|
||||
VCAP_KF_ARP_TGT_MATCH_IS,
|
||||
VCAP_KF_ETYPE,
|
||||
VCAP_KF_ETYPE_LEN_IS,
|
||||
VCAP_KF_IF_IGR_PORT_MASK,
|
||||
VCAP_KF_IF_IGR_PORT_MASK_L3,
|
||||
VCAP_KF_IF_IGR_PORT_MASK_RNG,
|
||||
VCAP_KF_IF_IGR_PORT_MASK_SEL,
|
||||
VCAP_KF_IP4_IS,
|
||||
VCAP_KF_ISDX_CLS,
|
||||
VCAP_KF_ISDX_GT0_IS,
|
||||
VCAP_KF_L2_BC_IS,
|
||||
VCAP_KF_L2_DMAC,
|
||||
VCAP_KF_L2_FWD_IS,
|
||||
VCAP_KF_L2_MC_IS,
|
||||
VCAP_KF_L2_PAYLOAD_ETYPE,
|
||||
VCAP_KF_L2_SMAC,
|
||||
VCAP_KF_L3_DIP_EQ_SIP_IS,
|
||||
VCAP_KF_L3_DST_IS,
|
||||
VCAP_KF_L3_FRAGMENT_TYPE,
|
||||
VCAP_KF_L3_FRAG_INVLD_L4_LEN,
|
||||
VCAP_KF_L3_IP4_DIP,
|
||||
VCAP_KF_L3_IP4_SIP,
|
||||
VCAP_KF_L3_IP6_DIP,
|
||||
VCAP_KF_L3_IP6_SIP,
|
||||
VCAP_KF_L3_IP_PROTO,
|
||||
VCAP_KF_L3_OPTIONS_IS,
|
||||
VCAP_KF_L3_PAYLOAD,
|
||||
VCAP_KF_L3_RT_IS,
|
||||
VCAP_KF_L3_TOS,
|
||||
VCAP_KF_L3_TTL_GT0,
|
||||
VCAP_KF_L4_ACK,
|
||||
VCAP_KF_L4_DPORT,
|
||||
VCAP_KF_L4_FIN,
|
||||
VCAP_KF_L4_PAYLOAD,
|
||||
VCAP_KF_L4_PSH,
|
||||
VCAP_KF_L4_RNG,
|
||||
VCAP_KF_L4_RST,
|
||||
VCAP_KF_L4_SEQUENCE_EQ0_IS,
|
||||
VCAP_KF_L4_SPORT,
|
||||
VCAP_KF_L4_SPORT_EQ_DPORT_IS,
|
||||
VCAP_KF_L4_SYN,
|
||||
VCAP_KF_L4_URG,
|
||||
VCAP_KF_LOOKUP_FIRST_IS,
|
||||
VCAP_KF_LOOKUP_PAG,
|
||||
VCAP_KF_OAM_CCM_CNTS_EQ0,
|
||||
VCAP_KF_OAM_Y1731_IS,
|
||||
VCAP_KF_TCP_IS,
|
||||
VCAP_KF_TCP_UDP_IS,
|
||||
VCAP_KF_TYPE,
|
||||
};
|
||||
|
||||
/* Actionset names with origin information */
|
||||
enum vcap_actionfield_set {
|
||||
VCAP_AFS_NO_VALUE, /* initial value */
|
||||
VCAP_AFS_BASE_TYPE, /* sparx5 is2 X3 */
|
||||
};
|
||||
|
||||
/* List of actionfields with description
|
||||
*
|
||||
* VCAP_AF_CNT_ID: W12, sparx5: is2
|
||||
* Counter ID, used per lookup to index the 4K frame counters (ANA_ACL:CNT_TBL).
|
||||
* Multiple VCAP IS2 entries can use the same counter.
|
||||
* VCAP_AF_CPU_COPY_ENA: W1, sparx5: is2
|
||||
* Setting this bit to 1 causes all frames that hit this action to be copied to
|
||||
* the CPU extraction queue specified in CPU_QUEUE_NUM.
|
||||
* VCAP_AF_CPU_QUEUE_NUM: W3, sparx5: is2
|
||||
* CPU queue number. Used when CPU_COPY_ENA is set.
|
||||
* VCAP_AF_HIT_ME_ONCE: W1, sparx5: is2
|
||||
* Setting this bit to 1 causes the first frame that hits this action where the
|
||||
* HIT_CNT counter is zero to be copied to the CPU extraction queue specified in
|
||||
* CPU_QUEUE_NUM. The HIT_CNT counter is then incremented and any frames that
|
||||
* hit this action later are not copied to the CPU. To re-enable the HIT_ME_ONCE
|
||||
* functionality, the HIT_CNT counter must be cleared.
|
||||
* VCAP_AF_IGNORE_PIPELINE_CTRL: W1, sparx5: is2
|
||||
* Ignore ingress pipeline control. This enforces the use of the VCAP IS2 action
|
||||
* even when the pipeline control has terminated the frame before VCAP IS2.
|
||||
* VCAP_AF_INTR_ENA: W1, sparx5: is2
|
||||
* If set, an interrupt is triggered when this rule is hit
|
||||
* VCAP_AF_LRN_DIS: W1, sparx5: is2
|
||||
* Setting this bit to 1 disables learning of frames hitting this action.
|
||||
* VCAP_AF_MASK_MODE: W3, sparx5: is2
|
||||
* Controls the PORT_MASK use. Sparx5: 0: OR_DSTMASK, 1: AND_VLANMASK, 2:
|
||||
* REPLACE_PGID, 3: REPLACE_ALL, 4: REDIR_PGID, 5: OR_PGID_MASK, 6: VSTAX, 7:
|
||||
* Not applicable. LAN966X: 0: No action, 1: Permit/deny (AND), 2: Policy
|
||||
* forwarding (DMAC lookup), 3: Redirect. The CPU port is untouched by
|
||||
* MASK_MODE.
|
||||
* VCAP_AF_MATCH_ID: W16, sparx5: is2
|
||||
* Logical ID for the entry. The MATCH_ID is extracted together with the frame
|
||||
* if the frame is forwarded to the CPU (CPU_COPY_ENA). The result is placed in
|
||||
* IFH.CL_RSLT.
|
||||
* VCAP_AF_MATCH_ID_MASK: W16, sparx5: is2
|
||||
* Mask used by MATCH_ID.
|
||||
* VCAP_AF_MIRROR_PROBE: W2, sparx5: is2
|
||||
* Mirroring performed according to configuration of a mirror probe. 0: No
|
||||
* mirroring. 1: Mirror probe 0. 2: Mirror probe 1. 3: Mirror probe 2
|
||||
* VCAP_AF_PIPELINE_FORCE_ENA: W1, sparx5: is2
|
||||
* If set, use PIPELINE_PT unconditionally and set PIPELINE_ACT = NONE if
|
||||
* PIPELINE_PT == NONE. Overrules previous settings of pipeline point.
|
||||
* VCAP_AF_PIPELINE_PT: W5, sparx5: is2
|
||||
* Pipeline point used if PIPELINE_FORCE_ENA is set
|
||||
* VCAP_AF_POLICE_ENA: W1, sparx5: is2
|
||||
* Setting this bit to 1 causes frames that hit this action to be policed by the
|
||||
* ACL policer specified in POLICE_IDX. Only applies to the first lookup.
|
||||
* VCAP_AF_POLICE_IDX: W6, sparx5: is2
|
||||
* Selects VCAP policer used when policing frames (POLICE_ENA)
|
||||
* VCAP_AF_PORT_MASK: W68, sparx5: is2
|
||||
* Port mask applied to the forwarding decision based on MASK_MODE.
|
||||
* VCAP_AF_RT_DIS: W1, sparx5: is2
|
||||
* If set, routing is disallowed. Only applies when IS_INNER_ACL is 0. See also
|
||||
* IGR_ACL_ENA, EGR_ACL_ENA, and RLEG_STAT_IDX.
|
||||
*/
|
||||
|
||||
/* Actionfield names */
|
||||
enum vcap_action_field {
|
||||
VCAP_AF_NO_VALUE, /* initial value */
|
||||
VCAP_AF_CNT_ID,
|
||||
VCAP_AF_CPU_COPY_ENA,
|
||||
VCAP_AF_CPU_QUEUE_NUM,
|
||||
VCAP_AF_HIT_ME_ONCE,
|
||||
VCAP_AF_IGNORE_PIPELINE_CTRL,
|
||||
VCAP_AF_INTR_ENA,
|
||||
VCAP_AF_LRN_DIS,
|
||||
VCAP_AF_MASK_MODE,
|
||||
VCAP_AF_MATCH_ID,
|
||||
VCAP_AF_MATCH_ID_MASK,
|
||||
VCAP_AF_MIRROR_PROBE,
|
||||
VCAP_AF_PIPELINE_FORCE_ENA,
|
||||
VCAP_AF_PIPELINE_PT,
|
||||
VCAP_AF_POLICE_ENA,
|
||||
VCAP_AF_POLICE_IDX,
|
||||
VCAP_AF_PORT_MASK,
|
||||
VCAP_AF_RT_DIS,
|
||||
};
|
||||
|
||||
#endif /* __VCAP_AG_API__ */
|
||||
643
drivers/net/ethernet/microchip/vcap/vcap_ag_api_kunit.h
Normal file
643
drivers/net/ethernet/microchip/vcap/vcap_ag_api_kunit.h
Normal file
@ -0,0 +1,643 @@
|
||||
/* SPDX-License-Identifier: BSD-3-Clause */
|
||||
/* Copyright (C) 2022 Microchip Technology Inc. and its subsidiaries.
|
||||
* Microchip VCAP API interface for kunit testing
|
||||
* This is a different interface, to be able to include different VCAPs
|
||||
*/
|
||||
|
||||
/* Use same include guard as the official API to be able to override it */
|
||||
#ifndef __VCAP_AG_API__
|
||||
#define __VCAP_AG_API__
|
||||
|
||||
enum vcap_type {
|
||||
VCAP_TYPE_ES2,
|
||||
VCAP_TYPE_IS0,
|
||||
VCAP_TYPE_IS2,
|
||||
VCAP_TYPE_MAX
|
||||
};
|
||||
|
||||
/* Keyfieldset names with origin information */
|
||||
enum vcap_keyfield_set {
|
||||
VCAP_KFS_NO_VALUE, /* initial value */
|
||||
VCAP_KFS_ARP, /* sparx5 is2 X6, sparx5 es2 X6 */
|
||||
VCAP_KFS_ETAG, /* sparx5 is0 X2 */
|
||||
VCAP_KFS_IP4_OTHER, /* sparx5 is2 X6, sparx5 es2 X6 */
|
||||
VCAP_KFS_IP4_TCP_UDP, /* sparx5 is2 X6, sparx5 es2 X6 */
|
||||
VCAP_KFS_IP4_VID, /* sparx5 es2 X3 */
|
||||
VCAP_KFS_IP6_STD, /* sparx5 is2 X6 */
|
||||
VCAP_KFS_IP6_VID, /* sparx5 is2 X6, sparx5 es2 X6 */
|
||||
VCAP_KFS_IP_7TUPLE, /* sparx5 is2 X12, sparx5 es2 X12 */
|
||||
VCAP_KFS_LL_FULL, /* sparx5 is0 X6 */
|
||||
VCAP_KFS_MAC_ETYPE, /* sparx5 is2 X6, sparx5 es2 X6 */
|
||||
VCAP_KFS_MLL, /* sparx5 is0 X3 */
|
||||
VCAP_KFS_NORMAL, /* sparx5 is0 X6 */
|
||||
VCAP_KFS_NORMAL_5TUPLE_IP4, /* sparx5 is0 X6 */
|
||||
VCAP_KFS_NORMAL_7TUPLE, /* sparx5 is0 X12 */
|
||||
VCAP_KFS_PURE_5TUPLE_IP4, /* sparx5 is0 X3 */
|
||||
VCAP_KFS_TRI_VID, /* sparx5 is0 X2 */
|
||||
};
|
||||
|
||||
/* List of keyfields with description
|
||||
*
|
||||
* Keys ending in _IS are booleans derived from frame data
|
||||
* Keys ending in _CLS are classified frame data
|
||||
*
|
||||
* VCAP_KF_8021BR_ECID_BASE: W12, sparx5: is0
|
||||
* Used by 802.1BR Bridge Port Extension in an E-Tag
|
||||
* VCAP_KF_8021BR_ECID_EXT: W8, sparx5: is0
|
||||
* Used by 802.1BR Bridge Port Extension in an E-Tag
|
||||
* VCAP_KF_8021BR_E_TAGGED: W1, sparx5: is0
|
||||
* Set for frames containing an E-TAG (802.1BR Ethertype 893f)
|
||||
* VCAP_KF_8021BR_GRP: W2, sparx5: is0
|
||||
* E-Tag group bits in 802.1BR Bridge Port Extension
|
||||
* VCAP_KF_8021BR_IGR_ECID_BASE: W12, sparx5: is0
|
||||
* Used by 802.1BR Bridge Port Extension in an E-Tag
|
||||
* VCAP_KF_8021BR_IGR_ECID_EXT: W8, sparx5: is0
|
||||
* Used by 802.1BR Bridge Port Extension in an E-Tag
|
||||
* VCAP_KF_8021Q_DEI0: W1, sparx5: is0
|
||||
* First DEI in multiple vlan tags (outer tag or default port tag)
|
||||
* VCAP_KF_8021Q_DEI1: W1, sparx5: is0
|
||||
* Second DEI in multiple vlan tags (inner tag)
|
||||
* VCAP_KF_8021Q_DEI2: W1, sparx5: is0
|
||||
* Third DEI in multiple vlan tags (not always available)
|
||||
* VCAP_KF_8021Q_DEI_CLS: W1, sparx5: is2/es2
|
||||
* Classified DEI
|
||||
* VCAP_KF_8021Q_PCP0: W3, sparx5: is0
|
||||
* First PCP in multiple vlan tags (outer tag or default port tag)
|
||||
* VCAP_KF_8021Q_PCP1: W3, sparx5: is0
|
||||
* Second PCP in multiple vlan tags (inner tag)
|
||||
* VCAP_KF_8021Q_PCP2: W3, sparx5: is0
|
||||
* Third PCP in multiple vlan tags (not always available)
|
||||
* VCAP_KF_8021Q_PCP_CLS: W3, sparx5: is2/es2
|
||||
* Classified PCP
|
||||
* VCAP_KF_8021Q_TPID0: W3, sparx5: is0
|
||||
* First TPIC in multiple vlan tags (outer tag or default port tag)
|
||||
* VCAP_KF_8021Q_TPID1: W3, sparx5: is0
|
||||
* Second TPID in multiple vlan tags (inner tag)
|
||||
* VCAP_KF_8021Q_TPID2: W3, sparx5: is0
|
||||
* Third TPID in multiple vlan tags (not always available)
|
||||
* VCAP_KF_8021Q_VID0: W12, sparx5: is0
|
||||
* First VID in multiple vlan tags (outer tag or default port tag)
|
||||
* VCAP_KF_8021Q_VID1: W12, sparx5: is0
|
||||
* Second VID in multiple vlan tags (inner tag)
|
||||
* VCAP_KF_8021Q_VID2: W12, sparx5: is0
|
||||
* Third VID in multiple vlan tags (not always available)
|
||||
* VCAP_KF_8021Q_VID_CLS: W13, sparx5: is2/es2
|
||||
* Classified VID
|
||||
* VCAP_KF_8021Q_VLAN_TAGGED_IS: W1, sparx5: is2/es2
|
||||
* Sparx5: Set if frame was received with a VLAN tag, LAN966x: Set if frame has
|
||||
* one or more Q-tags. Independent of port VLAN awareness
|
||||
* VCAP_KF_8021Q_VLAN_TAGS: W3, sparx5: is0
|
||||
* Number of VLAN tags in frame: 0: Untagged, 1: Single tagged, 3: Double
|
||||
* tagged, 7: Triple tagged
|
||||
* VCAP_KF_ACL_GRP_ID: W8, sparx5: es2
|
||||
* Used in interface map table
|
||||
* VCAP_KF_ARP_ADDR_SPACE_OK_IS: W1, sparx5: is2/es2
|
||||
* Set if hardware address is Ethernet
|
||||
* VCAP_KF_ARP_LEN_OK_IS: W1, sparx5: is2/es2
|
||||
* Set if hardware address length = 6 (Ethernet) and IP address length = 4 (IP).
|
||||
* VCAP_KF_ARP_OPCODE: W2, sparx5: is2/es2
|
||||
* ARP opcode
|
||||
* VCAP_KF_ARP_OPCODE_UNKNOWN_IS: W1, sparx5: is2/es2
|
||||
* Set if not one of the codes defined in VCAP_KF_ARP_OPCODE
|
||||
* VCAP_KF_ARP_PROTO_SPACE_OK_IS: W1, sparx5: is2/es2
|
||||
* Set if protocol address space is 0x0800
|
||||
* VCAP_KF_ARP_SENDER_MATCH_IS: W1, sparx5: is2/es2
|
||||
* Sender Hardware Address = SMAC (ARP)
|
||||
* VCAP_KF_ARP_TGT_MATCH_IS: W1, sparx5: is2/es2
|
||||
* Target Hardware Address = SMAC (RARP)
|
||||
* VCAP_KF_COSID_CLS: W3, sparx5: es2
|
||||
* Class of service
|
||||
* VCAP_KF_DST_ENTRY: W1, sparx5: is0
|
||||
* Selects whether the frame’s destination or source information is used for
|
||||
* fields L2_SMAC and L3_IP4_SIP
|
||||
* VCAP_KF_ES0_ISDX_KEY_ENA: W1, sparx5: es2
|
||||
* The value taken from the IFH .FWD.ES0_ISDX_KEY_ENA
|
||||
* VCAP_KF_ETYPE: W16, sparx5: is0/is2/es2
|
||||
* Ethernet type
|
||||
* VCAP_KF_ETYPE_LEN_IS: W1, sparx5: is0/is2/es2
|
||||
* Set if frame has EtherType >= 0x600
|
||||
* VCAP_KF_ETYPE_MPLS: W2, sparx5: is0
|
||||
* Type of MPLS Ethertype (or not)
|
||||
* VCAP_KF_IF_EGR_PORT_MASK: W32, sparx5: es2
|
||||
* Egress port mask, one bit per port
|
||||
* VCAP_KF_IF_EGR_PORT_MASK_RNG: W3, sparx5: es2
|
||||
* Select which 32 port group is available in IF_EGR_PORT (or virtual ports or
|
||||
* CPU queue)
|
||||
* VCAP_KF_IF_IGR_PORT: sparx5 is0 W7, sparx5 es2 W9
|
||||
* Sparx5: Logical ingress port number retrieved from
|
||||
* ANA_CL::PORT_ID_CFG.LPORT_NUM or ERLEG, LAN966x: ingress port nunmber
|
||||
* VCAP_KF_IF_IGR_PORT_MASK: sparx5 is0 W65, sparx5 is2 W32, sparx5 is2 W65
|
||||
* Ingress port mask, one bit per port/erleg
|
||||
* VCAP_KF_IF_IGR_PORT_MASK_L3: W1, sparx5: is2
|
||||
* If set, IF_IGR_PORT_MASK, IF_IGR_PORT_MASK_RNG, and IF_IGR_PORT_MASK_SEL are
|
||||
* used to specify L3 interfaces
|
||||
* VCAP_KF_IF_IGR_PORT_MASK_RNG: W4, sparx5: is2
|
||||
* Range selector for IF_IGR_PORT_MASK. Specifies which group of 32 ports are
|
||||
* available in IF_IGR_PORT_MASK
|
||||
* VCAP_KF_IF_IGR_PORT_MASK_SEL: W2, sparx5: is0/is2
|
||||
* Mode selector for IF_IGR_PORT_MASK, applicable when IF_IGR_PORT_MASK_L3 == 0.
|
||||
* Mapping: 0: DEFAULT 1: LOOPBACK 2: MASQUERADE 3: CPU_VD
|
||||
* VCAP_KF_IF_IGR_PORT_SEL: W1, sparx5: es2
|
||||
* Selector for IF_IGR_PORT: physical port number or ERLEG
|
||||
* VCAP_KF_IP4_IS: W1, sparx5: is0/is2/es2
|
||||
* Set if frame has EtherType = 0x800 and IP version = 4
|
||||
* VCAP_KF_IP_MC_IS: W1, sparx5: is0
|
||||
* Set if frame is IPv4 frame and frame’s destination MAC address is an IPv4
|
||||
* multicast address (0x01005E0 /25). Set if frame is IPv6 frame and frame’s
|
||||
* destination MAC address is an IPv6 multicast address (0x3333/16).
|
||||
* VCAP_KF_IP_PAYLOAD_5TUPLE: W32, sparx5: is0
|
||||
* Payload bytes after IP header
|
||||
* VCAP_KF_IP_SNAP_IS: W1, sparx5: is0
|
||||
* Set if frame is IPv4, IPv6, or SNAP frame
|
||||
* VCAP_KF_ISDX_CLS: W12, sparx5: is2/es2
|
||||
* Classified ISDX
|
||||
* VCAP_KF_ISDX_GT0_IS: W1, sparx5: is2/es2
|
||||
* Set if classified ISDX > 0
|
||||
* VCAP_KF_L2_BC_IS: W1, sparx5: is0/is2/es2
|
||||
* Set if frame’s destination MAC address is the broadcast address
|
||||
* (FF-FF-FF-FF-FF-FF).
|
||||
* VCAP_KF_L2_DMAC: W48, sparx5: is0/is2/es2
|
||||
* Destination MAC address
|
||||
* VCAP_KF_L2_FWD_IS: W1, sparx5: is2
|
||||
* Set if the frame is allowed to be forwarded to front ports
|
||||
* VCAP_KF_L2_MC_IS: W1, sparx5: is0/is2/es2
|
||||
* Set if frame’s destination MAC address is a multicast address (bit 40 = 1).
|
||||
* VCAP_KF_L2_PAYLOAD_ETYPE: W64, sparx5: is2/es2
|
||||
* Byte 0-7 of L2 payload after Type/Len field and overloading for OAM
|
||||
* VCAP_KF_L2_SMAC: W48, sparx5: is0/is2/es2
|
||||
* Source MAC address
|
||||
* VCAP_KF_L3_DIP_EQ_SIP_IS: W1, sparx5: is2/es2
|
||||
* Set if Src IP matches Dst IP address
|
||||
* VCAP_KF_L3_DMAC_DIP_MATCH: W1, sparx5: is2
|
||||
* Match found in DIP security lookup in ANA_L3
|
||||
* VCAP_KF_L3_DPL_CLS: W1, sparx5: es2
|
||||
* The frames drop precedence level
|
||||
* VCAP_KF_L3_DSCP: W6, sparx5: is0
|
||||
* Frame’s DSCP value
|
||||
* VCAP_KF_L3_DST_IS: W1, sparx5: is2
|
||||
* Set if lookup is done for egress router leg
|
||||
* VCAP_KF_L3_FRAGMENT_TYPE: W2, sparx5: is0/is2/es2
|
||||
* L3 Fragmentation type (none, initial, suspicious, valid follow up)
|
||||
* VCAP_KF_L3_FRAG_INVLD_L4_LEN: W1, sparx5: is0/is2
|
||||
* Set if frame's L4 length is less than ANA_CL:COMMON:CLM_FRAGMENT_CFG.L4_MIN_L
|
||||
* EN
|
||||
* VCAP_KF_L3_IP4_DIP: W32, sparx5: is0/is2/es2
|
||||
* Destination IPv4 Address
|
||||
* VCAP_KF_L3_IP4_SIP: W32, sparx5: is0/is2/es2
|
||||
* Source IPv4 Address
|
||||
* VCAP_KF_L3_IP6_DIP: W128, sparx5: is0/is2/es2
|
||||
* Sparx5: Full IPv6 DIP, LAN966x: Either Full IPv6 DIP or a subset depending on
|
||||
* frame type
|
||||
* VCAP_KF_L3_IP6_SIP: W128, sparx5: is0/is2/es2
|
||||
* Sparx5: Full IPv6 SIP, LAN966x: Either Full IPv6 SIP or a subset depending on
|
||||
* frame type
|
||||
* VCAP_KF_L3_IP_PROTO: W8, sparx5: is0/is2/es2
|
||||
* IPv4 frames: IP protocol. IPv6 frames: Next header, same as for IPV4
|
||||
* VCAP_KF_L3_OPTIONS_IS: W1, sparx5: is0/is2/es2
|
||||
* Set if IPv4 frame contains options (IP len > 5)
|
||||
* VCAP_KF_L3_PAYLOAD: sparx5 is2 W96, sparx5 is2 W40, sparx5 es2 W96
|
||||
* Sparx5: Payload bytes after IP header. IPv4: IPv4 options are not parsed so
|
||||
* payload is always taken 20 bytes after the start of the IPv4 header, LAN966x:
|
||||
* Bytes 0-6 after IP header
|
||||
* VCAP_KF_L3_RT_IS: W1, sparx5: is2/es2
|
||||
* Set if frame has hit a router leg
|
||||
* VCAP_KF_L3_SMAC_SIP_MATCH: W1, sparx5: is2
|
||||
* Match found in SIP security lookup in ANA_L3
|
||||
* VCAP_KF_L3_TOS: W8, sparx5: is2/es2
|
||||
* Sparx5: Frame's IPv4/IPv6 DSCP and ECN fields, LAN966x: IP TOS field
|
||||
* VCAP_KF_L3_TTL_GT0: W1, sparx5: is2/es2
|
||||
* Set if IPv4 TTL / IPv6 hop limit is greater than 0
|
||||
* VCAP_KF_L4_ACK: W1, sparx5: is2/es2
|
||||
* Sparx5 and LAN966x: TCP flag ACK, LAN966x only: PTP over UDP: flagField bit 2
|
||||
* (unicastFlag)
|
||||
* VCAP_KF_L4_DPORT: W16, sparx5: is2/es2
|
||||
* Sparx5: TCP/UDP destination port. Overloading for IP_7TUPLE: Non-TCP/UDP IP
|
||||
* frames: L4_DPORT = L3_IP_PROTO, LAN966x: TCP/UDP destination port
|
||||
* VCAP_KF_L4_FIN: W1, sparx5: is2/es2
|
||||
* TCP flag FIN, LAN966x: TCP flag FIN, and for PTP over UDP: messageType bit 1
|
||||
* VCAP_KF_L4_PAYLOAD: W64, sparx5: is2/es2
|
||||
* Payload bytes after TCP/UDP header Overloading for IP_7TUPLE: Non TCP/UDP
|
||||
* frames: Payload bytes 0–7 after IP header. IPv4 options are not parsed so
|
||||
* payload is always taken 20 bytes after the start of the IPv4 header for non
|
||||
* TCP/UDP IPv4 frames
|
||||
* VCAP_KF_L4_PSH: W1, sparx5: is2/es2
|
||||
* Sparx5: TCP flag PSH, LAN966x: TCP: TCP flag PSH. PTP over UDP: flagField bit
|
||||
* 1 (twoStepFlag)
|
||||
* VCAP_KF_L4_RNG: sparx5 is0 W8, sparx5 is2 W16, sparx5 es2 W16
|
||||
* Range checker bitmask (one for each range checker). Input into range checkers
|
||||
* is taken from classified results (VID, DSCP) and frame (SPORT, DPORT, ETYPE,
|
||||
* outer VID, inner VID)
|
||||
* VCAP_KF_L4_RST: W1, sparx5: is2/es2
|
||||
* Sparx5: TCP flag RST , LAN966x: TCP: TCP flag RST. PTP over UDP: messageType
|
||||
* bit 3
|
||||
* VCAP_KF_L4_SEQUENCE_EQ0_IS: W1, sparx5: is2/es2
|
||||
* Set if TCP sequence number is 0, LAN966x: Overlayed with PTP over UDP:
|
||||
* messageType bit 0
|
||||
* VCAP_KF_L4_SPORT: W16, sparx5: is0/is2/es2
|
||||
* TCP/UDP source port
|
||||
* VCAP_KF_L4_SPORT_EQ_DPORT_IS: W1, sparx5: is2/es2
|
||||
* Set if UDP or TCP source port equals UDP or TCP destination port
|
||||
* VCAP_KF_L4_SYN: W1, sparx5: is2/es2
|
||||
* Sparx5: TCP flag SYN, LAN966x: TCP: TCP flag SYN. PTP over UDP: messageType
|
||||
* bit 2
|
||||
* VCAP_KF_L4_URG: W1, sparx5: is2/es2
|
||||
* Sparx5: TCP flag URG, LAN966x: TCP: TCP flag URG. PTP over UDP: flagField bit
|
||||
* 7 (reserved)
|
||||
* VCAP_KF_LOOKUP_FIRST_IS: W1, sparx5: is0/is2/es2
|
||||
* Selects between entries relevant for first and second lookup. Set for first
|
||||
* lookup, cleared for second lookup.
|
||||
* VCAP_KF_LOOKUP_GEN_IDX: W12, sparx5: is0
|
||||
* Generic index - for chaining CLM instances
|
||||
* VCAP_KF_LOOKUP_GEN_IDX_SEL: W2, sparx5: is0
|
||||
* Select the mode of the Generic Index
|
||||
* VCAP_KF_LOOKUP_PAG: W8, sparx5: is2
|
||||
* Classified Policy Association Group: chains rules from IS1/CLM to IS2
|
||||
* VCAP_KF_OAM_CCM_CNTS_EQ0: W1, sparx5: is2/es2
|
||||
* Dual-ended loss measurement counters in CCM frames are all zero
|
||||
* VCAP_KF_OAM_MEL_FLAGS: W7, sparx5: is0
|
||||
* Encoding of MD level/MEG level (MEL)
|
||||
* VCAP_KF_OAM_Y1731_IS: W1, sparx5: is0/is2/es2
|
||||
* Set if frame’s EtherType = 0x8902
|
||||
* VCAP_KF_PROT_ACTIVE: W1, sparx5: es2
|
||||
* Protection is active
|
||||
* VCAP_KF_TCP_IS: W1, sparx5: is0/is2/es2
|
||||
* Set if frame is IPv4 TCP frame (IP protocol = 6) or IPv6 TCP frames (Next
|
||||
* header = 6)
|
||||
* VCAP_KF_TCP_UDP_IS: W1, sparx5: is0/is2/es2
|
||||
* Set if frame is IPv4/IPv6 TCP or UDP frame (IP protocol/next header equals 6
|
||||
* or 17)
|
||||
* VCAP_KF_TYPE: sparx5 is0 W2, sparx5 is0 W1, sparx5 is2 W4, sparx5 is2 W2,
|
||||
* sparx5 es2 W3
|
||||
* Keyset type id - set by the API
|
||||
*/
|
||||
|
||||
/* Keyfield names */
|
||||
enum vcap_key_field {
|
||||
VCAP_KF_NO_VALUE, /* initial value */
|
||||
VCAP_KF_8021BR_ECID_BASE,
|
||||
VCAP_KF_8021BR_ECID_EXT,
|
||||
VCAP_KF_8021BR_E_TAGGED,
|
||||
VCAP_KF_8021BR_GRP,
|
||||
VCAP_KF_8021BR_IGR_ECID_BASE,
|
||||
VCAP_KF_8021BR_IGR_ECID_EXT,
|
||||
VCAP_KF_8021Q_DEI0,
|
||||
VCAP_KF_8021Q_DEI1,
|
||||
VCAP_KF_8021Q_DEI2,
|
||||
VCAP_KF_8021Q_DEI_CLS,
|
||||
VCAP_KF_8021Q_PCP0,
|
||||
VCAP_KF_8021Q_PCP1,
|
||||
VCAP_KF_8021Q_PCP2,
|
||||
VCAP_KF_8021Q_PCP_CLS,
|
||||
VCAP_KF_8021Q_TPID0,
|
||||
VCAP_KF_8021Q_TPID1,
|
||||
VCAP_KF_8021Q_TPID2,
|
||||
VCAP_KF_8021Q_VID0,
|
||||
VCAP_KF_8021Q_VID1,
|
||||
VCAP_KF_8021Q_VID2,
|
||||
VCAP_KF_8021Q_VID_CLS,
|
||||
VCAP_KF_8021Q_VLAN_TAGGED_IS,
|
||||
VCAP_KF_8021Q_VLAN_TAGS,
|
||||
VCAP_KF_ACL_GRP_ID,
|
||||
VCAP_KF_ARP_ADDR_SPACE_OK_IS,
|
||||
VCAP_KF_ARP_LEN_OK_IS,
|
||||
VCAP_KF_ARP_OPCODE,
|
||||
VCAP_KF_ARP_OPCODE_UNKNOWN_IS,
|
||||
VCAP_KF_ARP_PROTO_SPACE_OK_IS,
|
||||
VCAP_KF_ARP_SENDER_MATCH_IS,
|
||||
VCAP_KF_ARP_TGT_MATCH_IS,
|
||||
VCAP_KF_COSID_CLS,
|
||||
VCAP_KF_DST_ENTRY,
|
||||
VCAP_KF_ES0_ISDX_KEY_ENA,
|
||||
VCAP_KF_ETYPE,
|
||||
VCAP_KF_ETYPE_LEN_IS,
|
||||
VCAP_KF_ETYPE_MPLS,
|
||||
VCAP_KF_IF_EGR_PORT_MASK,
|
||||
VCAP_KF_IF_EGR_PORT_MASK_RNG,
|
||||
VCAP_KF_IF_IGR_PORT,
|
||||
VCAP_KF_IF_IGR_PORT_MASK,
|
||||
VCAP_KF_IF_IGR_PORT_MASK_L3,
|
||||
VCAP_KF_IF_IGR_PORT_MASK_RNG,
|
||||
VCAP_KF_IF_IGR_PORT_MASK_SEL,
|
||||
VCAP_KF_IF_IGR_PORT_SEL,
|
||||
VCAP_KF_IP4_IS,
|
||||
VCAP_KF_IP_MC_IS,
|
||||
VCAP_KF_IP_PAYLOAD_5TUPLE,
|
||||
VCAP_KF_IP_SNAP_IS,
|
||||
VCAP_KF_ISDX_CLS,
|
||||
VCAP_KF_ISDX_GT0_IS,
|
||||
VCAP_KF_L2_BC_IS,
|
||||
VCAP_KF_L2_DMAC,
|
||||
VCAP_KF_L2_FWD_IS,
|
||||
VCAP_KF_L2_MC_IS,
|
||||
VCAP_KF_L2_PAYLOAD_ETYPE,
|
||||
VCAP_KF_L2_SMAC,
|
||||
VCAP_KF_L3_DIP_EQ_SIP_IS,
|
||||
VCAP_KF_L3_DMAC_DIP_MATCH,
|
||||
VCAP_KF_L3_DPL_CLS,
|
||||
VCAP_KF_L3_DSCP,
|
||||
VCAP_KF_L3_DST_IS,
|
||||
VCAP_KF_L3_FRAGMENT_TYPE,
|
||||
VCAP_KF_L3_FRAG_INVLD_L4_LEN,
|
||||
VCAP_KF_L3_IP4_DIP,
|
||||
VCAP_KF_L3_IP4_SIP,
|
||||
VCAP_KF_L3_IP6_DIP,
|
||||
VCAP_KF_L3_IP6_SIP,
|
||||
VCAP_KF_L3_IP_PROTO,
|
||||
VCAP_KF_L3_OPTIONS_IS,
|
||||
VCAP_KF_L3_PAYLOAD,
|
||||
VCAP_KF_L3_RT_IS,
|
||||
VCAP_KF_L3_SMAC_SIP_MATCH,
|
||||
VCAP_KF_L3_TOS,
|
||||
VCAP_KF_L3_TTL_GT0,
|
||||
VCAP_KF_L4_ACK,
|
||||
VCAP_KF_L4_DPORT,
|
||||
VCAP_KF_L4_FIN,
|
||||
VCAP_KF_L4_PAYLOAD,
|
||||
VCAP_KF_L4_PSH,
|
||||
VCAP_KF_L4_RNG,
|
||||
VCAP_KF_L4_RST,
|
||||
VCAP_KF_L4_SEQUENCE_EQ0_IS,
|
||||
VCAP_KF_L4_SPORT,
|
||||
VCAP_KF_L4_SPORT_EQ_DPORT_IS,
|
||||
VCAP_KF_L4_SYN,
|
||||
VCAP_KF_L4_URG,
|
||||
VCAP_KF_LOOKUP_FIRST_IS,
|
||||
VCAP_KF_LOOKUP_GEN_IDX,
|
||||
VCAP_KF_LOOKUP_GEN_IDX_SEL,
|
||||
VCAP_KF_LOOKUP_PAG,
|
||||
VCAP_KF_MIRROR_ENA,
|
||||
VCAP_KF_OAM_CCM_CNTS_EQ0,
|
||||
VCAP_KF_OAM_MEL_FLAGS,
|
||||
VCAP_KF_OAM_Y1731_IS,
|
||||
VCAP_KF_PROT_ACTIVE,
|
||||
VCAP_KF_TCP_IS,
|
||||
VCAP_KF_TCP_UDP_IS,
|
||||
VCAP_KF_TYPE,
|
||||
};
|
||||
|
||||
/* Actionset names with origin information */
|
||||
enum vcap_actionfield_set {
|
||||
VCAP_AFS_NO_VALUE, /* initial value */
|
||||
VCAP_AFS_BASE_TYPE, /* sparx5 is2 X3, sparx5 es2 X3 */
|
||||
VCAP_AFS_CLASSIFICATION, /* sparx5 is0 X2 */
|
||||
VCAP_AFS_CLASS_REDUCED, /* sparx5 is0 X1 */
|
||||
VCAP_AFS_FULL, /* sparx5 is0 X3 */
|
||||
VCAP_AFS_MLBS, /* sparx5 is0 X2 */
|
||||
VCAP_AFS_MLBS_REDUCED, /* sparx5 is0 X1 */
|
||||
};
|
||||
|
||||
/* List of actionfields with description
|
||||
*
|
||||
* VCAP_AF_CLS_VID_SEL: W3, sparx5: is0
|
||||
* Controls the classified VID: 0: VID_NONE: No action. 1: VID_ADD: New VID =
|
||||
* old VID + VID_VAL. 2: VID_REPLACE: New VID = VID_VAL. 3: VID_FIRST_TAG: New
|
||||
* VID = VID from frame's first tag (outer tag) if available, otherwise VID_VAL.
|
||||
* 4: VID_SECOND_TAG: New VID = VID from frame's second tag (middle tag) if
|
||||
* available, otherwise VID_VAL. 5: VID_THIRD_TAG: New VID = VID from frame's
|
||||
* third tag (inner tag) if available, otherwise VID_VAL.
|
||||
* VCAP_AF_CNT_ID: sparx5 is2 W12, sparx5 es2 W11
|
||||
* Counter ID, used per lookup to index the 4K frame counters (ANA_ACL:CNT_TBL).
|
||||
* Multiple VCAP IS2 entries can use the same counter.
|
||||
* VCAP_AF_COPY_PORT_NUM: W7, sparx5: es2
|
||||
* QSYS port number when FWD_MODE is redirect or copy
|
||||
* VCAP_AF_COPY_QUEUE_NUM: W16, sparx5: es2
|
||||
* QSYS queue number when FWD_MODE is redirect or copy
|
||||
* VCAP_AF_CPU_COPY_ENA: W1, sparx5: is2/es2
|
||||
* Setting this bit to 1 causes all frames that hit this action to be copied to
|
||||
* the CPU extraction queue specified in CPU_QUEUE_NUM.
|
||||
* VCAP_AF_CPU_QUEUE_NUM: W3, sparx5: is2/es2
|
||||
* CPU queue number. Used when CPU_COPY_ENA is set.
|
||||
* VCAP_AF_DEI_ENA: W1, sparx5: is0
|
||||
* If set, use DEI_VAL as classified DEI value. Otherwise, DEI from basic
|
||||
* classification is used
|
||||
* VCAP_AF_DEI_VAL: W1, sparx5: is0
|
||||
* See DEI_ENA
|
||||
* VCAP_AF_DP_ENA: W1, sparx5: is0
|
||||
* If set, use DP_VAL as classified drop precedence level. Otherwise, drop
|
||||
* precedence level from basic classification is used.
|
||||
* VCAP_AF_DP_VAL: W2, sparx5: is0
|
||||
* See DP_ENA.
|
||||
* VCAP_AF_DSCP_ENA: W1, sparx5: is0
|
||||
* If set, use DSCP_VAL as classified DSCP value. Otherwise, DSCP value from
|
||||
* basic classification is used.
|
||||
* VCAP_AF_DSCP_VAL: W6, sparx5: is0
|
||||
* See DSCP_ENA.
|
||||
* VCAP_AF_ES2_REW_CMD: W3, sparx5: es2
|
||||
* Command forwarded to REW: 0: No action. 1: SWAP MAC addresses. 2: Do L2CP
|
||||
* DMAC translation when entering or leaving a tunnel.
|
||||
* VCAP_AF_FWD_MODE: W2, sparx5: es2
|
||||
* Forward selector: 0: Forward. 1: Discard. 2: Redirect. 3: Copy.
|
||||
* VCAP_AF_HIT_ME_ONCE: W1, sparx5: is2/es2
|
||||
* Setting this bit to 1 causes the first frame that hits this action where the
|
||||
* HIT_CNT counter is zero to be copied to the CPU extraction queue specified in
|
||||
* CPU_QUEUE_NUM. The HIT_CNT counter is then incremented and any frames that
|
||||
* hit this action later are not copied to the CPU. To re-enable the HIT_ME_ONCE
|
||||
* functionality, the HIT_CNT counter must be cleared.
|
||||
* VCAP_AF_IGNORE_PIPELINE_CTRL: W1, sparx5: is2/es2
|
||||
* Ignore ingress pipeline control. This enforces the use of the VCAP IS2 action
|
||||
* even when the pipeline control has terminated the frame before VCAP IS2.
|
||||
* VCAP_AF_INTR_ENA: W1, sparx5: is2/es2
|
||||
* If set, an interrupt is triggered when this rule is hit
|
||||
* VCAP_AF_ISDX_ADD_REPLACE_SEL: W1, sparx5: is0
|
||||
* Controls the classified ISDX. 0: New ISDX = old ISDX + ISDX_VAL. 1: New ISDX
|
||||
* = ISDX_VAL.
|
||||
* VCAP_AF_ISDX_VAL: W12, sparx5: is0
|
||||
* See isdx_add_replace_sel
|
||||
* VCAP_AF_LRN_DIS: W1, sparx5: is2
|
||||
* Setting this bit to 1 disables learning of frames hitting this action.
|
||||
* VCAP_AF_MAP_IDX: W9, sparx5: is0
|
||||
* Index for QoS mapping table lookup
|
||||
* VCAP_AF_MAP_KEY: W3, sparx5: is0
|
||||
* Key type for QoS mapping table lookup. 0: DEI0, PCP0 (outer tag). 1: DEI1,
|
||||
* PCP1 (middle tag). 2: DEI2, PCP2 (inner tag). 3: MPLS TC. 4: PCP0 (outer
|
||||
* tag). 5: E-DEI, E-PCP (E-TAG). 6: DSCP if available, otherwise none. 7: DSCP
|
||||
* if available, otherwise DEI0, PCP0 (outer tag) if available using MAP_IDX+8,
|
||||
* otherwise none
|
||||
* VCAP_AF_MAP_LOOKUP_SEL: W2, sparx5: is0
|
||||
* Selects which of the two QoS Mapping Table lookups that MAP_KEY and MAP_IDX
|
||||
* are applied to. 0: No changes to the QoS Mapping Table lookup. 1: Update key
|
||||
* type and index for QoS Mapping Table lookup #0. 2: Update key type and index
|
||||
* for QoS Mapping Table lookup #1. 3: Reserved.
|
||||
* VCAP_AF_MASK_MODE: W3, sparx5: is0/is2
|
||||
* Controls the PORT_MASK use. Sparx5: 0: OR_DSTMASK, 1: AND_VLANMASK, 2:
|
||||
* REPLACE_PGID, 3: REPLACE_ALL, 4: REDIR_PGID, 5: OR_PGID_MASK, 6: VSTAX, 7:
|
||||
* Not applicable. LAN966X: 0: No action, 1: Permit/deny (AND), 2: Policy
|
||||
* forwarding (DMAC lookup), 3: Redirect. The CPU port is untouched by
|
||||
* MASK_MODE.
|
||||
* VCAP_AF_MATCH_ID: W16, sparx5: is0/is2
|
||||
* Logical ID for the entry. The MATCH_ID is extracted together with the frame
|
||||
* if the frame is forwarded to the CPU (CPU_COPY_ENA). The result is placed in
|
||||
* IFH.CL_RSLT.
|
||||
* VCAP_AF_MATCH_ID_MASK: W16, sparx5: is0/is2
|
||||
* Mask used by MATCH_ID.
|
||||
* VCAP_AF_MIRROR_PROBE: W2, sparx5: is2
|
||||
* Mirroring performed according to configuration of a mirror probe. 0: No
|
||||
* mirroring. 1: Mirror probe 0. 2: Mirror probe 1. 3: Mirror probe 2
|
||||
* VCAP_AF_MIRROR_PROBE_ID: W2, sparx5: es2
|
||||
* Signals a mirror probe to be placed in the IFH. Only possible when FWD_MODE
|
||||
* is copy. 0: No mirroring. 1–3: Use mirror probe 0-2.
|
||||
* VCAP_AF_NXT_IDX: W12, sparx5: is0
|
||||
* Index used as part of key (field G_IDX) in the next lookup.
|
||||
* VCAP_AF_NXT_IDX_CTRL: W3, sparx5: is0
|
||||
* Controls the generation of the G_IDX used in the VCAP CLM next lookup
|
||||
* VCAP_AF_PAG_OVERRIDE_MASK: W8, sparx5: is0
|
||||
* Bits set in this mask will override PAG_VAL from port profile. New PAG =
|
||||
* (PAG (input) AND ~PAG_OVERRIDE_MASK) OR (PAG_VAL AND PAG_OVERRIDE_MASK)
|
||||
* VCAP_AF_PAG_VAL: W8, sparx5: is0
|
||||
* See PAG_OVERRIDE_MASK.
|
||||
* VCAP_AF_PCP_ENA: W1, sparx5: is0
|
||||
* If set, use PCP_VAL as classified PCP value. Otherwise, PCP from basic
|
||||
* classification is used.
|
||||
* VCAP_AF_PCP_VAL: W3, sparx5: is0
|
||||
* See PCP_ENA.
|
||||
* VCAP_AF_PIPELINE_FORCE_ENA: sparx5 is0 W2, sparx5 is2 W1
|
||||
* If set, use PIPELINE_PT unconditionally and set PIPELINE_ACT = NONE if
|
||||
* PIPELINE_PT == NONE. Overrules previous settings of pipeline point.
|
||||
* VCAP_AF_PIPELINE_PT: W5, sparx5: is0/is2
|
||||
* Pipeline point used if PIPELINE_FORCE_ENA is set
|
||||
* VCAP_AF_POLICE_ENA: W1, sparx5: is2/es2
|
||||
* Setting this bit to 1 causes frames that hit this action to be policed by the
|
||||
* ACL policer specified in POLICE_IDX. Only applies to the first lookup.
|
||||
* VCAP_AF_POLICE_IDX: W6, sparx5: is2/es2
|
||||
* Selects VCAP policer used when policing frames (POLICE_ENA)
|
||||
* VCAP_AF_POLICE_REMARK: W1, sparx5: es2
|
||||
* If set, frames exceeding policer rates are marked as yellow but not
|
||||
* discarded.
|
||||
* VCAP_AF_PORT_MASK: sparx5 is0 W65, sparx5 is2 W68
|
||||
* Port mask applied to the forwarding decision based on MASK_MODE.
|
||||
* VCAP_AF_QOS_ENA: W1, sparx5: is0
|
||||
* If set, use QOS_VAL as classified QoS class. Otherwise, QoS class from basic
|
||||
* classification is used.
|
||||
* VCAP_AF_QOS_VAL: W3, sparx5: is0
|
||||
* See QOS_ENA.
|
||||
* VCAP_AF_RT_DIS: W1, sparx5: is2
|
||||
* If set, routing is disallowed. Only applies when IS_INNER_ACL is 0. See also
|
||||
* IGR_ACL_ENA, EGR_ACL_ENA, and RLEG_STAT_IDX.
|
||||
* VCAP_AF_TYPE: W1, sparx5: is0
|
||||
* Actionset type id - Set by the API
|
||||
* VCAP_AF_VID_VAL: W13, sparx5: is0
|
||||
* New VID Value
|
||||
*/
|
||||
|
||||
/* Actionfield names */
|
||||
enum vcap_action_field {
|
||||
VCAP_AF_NO_VALUE, /* initial value */
|
||||
VCAP_AF_ACL_MAC,
|
||||
VCAP_AF_ACL_RT_MODE,
|
||||
VCAP_AF_CLS_VID_SEL,
|
||||
VCAP_AF_CNT_ID,
|
||||
VCAP_AF_COPY_PORT_NUM,
|
||||
VCAP_AF_COPY_QUEUE_NUM,
|
||||
VCAP_AF_COSID_ENA,
|
||||
VCAP_AF_COSID_VAL,
|
||||
VCAP_AF_CPU_COPY_ENA,
|
||||
VCAP_AF_CPU_DIS,
|
||||
VCAP_AF_CPU_ENA,
|
||||
VCAP_AF_CPU_Q,
|
||||
VCAP_AF_CPU_QUEUE_NUM,
|
||||
VCAP_AF_CUSTOM_ACE_ENA,
|
||||
VCAP_AF_CUSTOM_ACE_OFFSET,
|
||||
VCAP_AF_DEI_ENA,
|
||||
VCAP_AF_DEI_VAL,
|
||||
VCAP_AF_DLB_OFFSET,
|
||||
VCAP_AF_DMAC_OFFSET_ENA,
|
||||
VCAP_AF_DP_ENA,
|
||||
VCAP_AF_DP_VAL,
|
||||
VCAP_AF_DSCP_ENA,
|
||||
VCAP_AF_DSCP_VAL,
|
||||
VCAP_AF_EGR_ACL_ENA,
|
||||
VCAP_AF_ES2_REW_CMD,
|
||||
VCAP_AF_FWD_DIS,
|
||||
VCAP_AF_FWD_MODE,
|
||||
VCAP_AF_FWD_TYPE,
|
||||
VCAP_AF_GVID_ADD_REPLACE_SEL,
|
||||
VCAP_AF_HIT_ME_ONCE,
|
||||
VCAP_AF_IGNORE_PIPELINE_CTRL,
|
||||
VCAP_AF_IGR_ACL_ENA,
|
||||
VCAP_AF_INJ_MASQ_ENA,
|
||||
VCAP_AF_INJ_MASQ_LPORT,
|
||||
VCAP_AF_INJ_MASQ_PORT,
|
||||
VCAP_AF_INTR_ENA,
|
||||
VCAP_AF_ISDX_ADD_REPLACE_SEL,
|
||||
VCAP_AF_ISDX_VAL,
|
||||
VCAP_AF_IS_INNER_ACL,
|
||||
VCAP_AF_L3_MAC_UPDATE_DIS,
|
||||
VCAP_AF_LOG_MSG_INTERVAL,
|
||||
VCAP_AF_LPM_AFFIX_ENA,
|
||||
VCAP_AF_LPM_AFFIX_VAL,
|
||||
VCAP_AF_LPORT_ENA,
|
||||
VCAP_AF_LRN_DIS,
|
||||
VCAP_AF_MAP_IDX,
|
||||
VCAP_AF_MAP_KEY,
|
||||
VCAP_AF_MAP_LOOKUP_SEL,
|
||||
VCAP_AF_MASK_MODE,
|
||||
VCAP_AF_MATCH_ID,
|
||||
VCAP_AF_MATCH_ID_MASK,
|
||||
VCAP_AF_MIP_SEL,
|
||||
VCAP_AF_MIRROR_PROBE,
|
||||
VCAP_AF_MIRROR_PROBE_ID,
|
||||
VCAP_AF_MPLS_IP_CTRL_ENA,
|
||||
VCAP_AF_MPLS_MEP_ENA,
|
||||
VCAP_AF_MPLS_MIP_ENA,
|
||||
VCAP_AF_MPLS_OAM_FLAVOR,
|
||||
VCAP_AF_MPLS_OAM_TYPE,
|
||||
VCAP_AF_NUM_VLD_LABELS,
|
||||
VCAP_AF_NXT_IDX,
|
||||
VCAP_AF_NXT_IDX_CTRL,
|
||||
VCAP_AF_NXT_KEY_TYPE,
|
||||
VCAP_AF_NXT_NORMALIZE,
|
||||
VCAP_AF_NXT_NORM_W16_OFFSET,
|
||||
VCAP_AF_NXT_NORM_W32_OFFSET,
|
||||
VCAP_AF_NXT_OFFSET_FROM_TYPE,
|
||||
VCAP_AF_NXT_TYPE_AFTER_OFFSET,
|
||||
VCAP_AF_OAM_IP_BFD_ENA,
|
||||
VCAP_AF_OAM_TWAMP_ENA,
|
||||
VCAP_AF_OAM_Y1731_SEL,
|
||||
VCAP_AF_PAG_OVERRIDE_MASK,
|
||||
VCAP_AF_PAG_VAL,
|
||||
VCAP_AF_PCP_ENA,
|
||||
VCAP_AF_PCP_VAL,
|
||||
VCAP_AF_PIPELINE_ACT_SEL,
|
||||
VCAP_AF_PIPELINE_FORCE_ENA,
|
||||
VCAP_AF_PIPELINE_PT,
|
||||
VCAP_AF_PIPELINE_PT_REDUCED,
|
||||
VCAP_AF_POLICE_ENA,
|
||||
VCAP_AF_POLICE_IDX,
|
||||
VCAP_AF_POLICE_REMARK,
|
||||
VCAP_AF_PORT_MASK,
|
||||
VCAP_AF_PTP_MASTER_SEL,
|
||||
VCAP_AF_QOS_ENA,
|
||||
VCAP_AF_QOS_VAL,
|
||||
VCAP_AF_REW_CMD,
|
||||
VCAP_AF_RLEG_DMAC_CHK_DIS,
|
||||
VCAP_AF_RLEG_STAT_IDX,
|
||||
VCAP_AF_RSDX_ENA,
|
||||
VCAP_AF_RSDX_VAL,
|
||||
VCAP_AF_RSVD_LBL_VAL,
|
||||
VCAP_AF_RT_DIS,
|
||||
VCAP_AF_RT_SEL,
|
||||
VCAP_AF_S2_KEY_SEL_ENA,
|
||||
VCAP_AF_S2_KEY_SEL_IDX,
|
||||
VCAP_AF_SAM_SEQ_ENA,
|
||||
VCAP_AF_SIP_IDX,
|
||||
VCAP_AF_SWAP_MAC_ENA,
|
||||
VCAP_AF_TCP_UDP_DPORT,
|
||||
VCAP_AF_TCP_UDP_ENA,
|
||||
VCAP_AF_TCP_UDP_SPORT,
|
||||
VCAP_AF_TC_ENA,
|
||||
VCAP_AF_TC_LABEL,
|
||||
VCAP_AF_TPID_SEL,
|
||||
VCAP_AF_TTL_DECR_DIS,
|
||||
VCAP_AF_TTL_ENA,
|
||||
VCAP_AF_TTL_LABEL,
|
||||
VCAP_AF_TTL_UPDATE_ENA,
|
||||
VCAP_AF_TYPE,
|
||||
VCAP_AF_VID_VAL,
|
||||
VCAP_AF_VLAN_POP_CNT,
|
||||
VCAP_AF_VLAN_POP_CNT_ENA,
|
||||
VCAP_AF_VLAN_PUSH_CNT,
|
||||
VCAP_AF_VLAN_PUSH_CNT_ENA,
|
||||
VCAP_AF_VLAN_WAS_TAGGED,
|
||||
};
|
||||
|
||||
#endif /* __VCAP_AG_API__ */
|
||||
1184
drivers/net/ethernet/microchip/vcap/vcap_api.c
Normal file
1184
drivers/net/ethernet/microchip/vcap/vcap_api.c
Normal file
File diff suppressed because it is too large
Load Diff
272
drivers/net/ethernet/microchip/vcap/vcap_api.h
Normal file
272
drivers/net/ethernet/microchip/vcap/vcap_api.h
Normal file
@ -0,0 +1,272 @@
|
||||
/* SPDX-License-Identifier: BSD-3-Clause */
|
||||
/* Copyright (C) 2022 Microchip Technology Inc. and its subsidiaries.
|
||||
* Microchip VCAP API
|
||||
*/
|
||||
|
||||
#ifndef __VCAP_API__
|
||||
#define __VCAP_API__
|
||||
|
||||
#include <linux/types.h>
|
||||
#include <linux/list.h>
|
||||
#include <linux/netdevice.h>
|
||||
|
||||
/* Use the generated API model */
|
||||
#ifdef CONFIG_VCAP_KUNIT_TEST
|
||||
#include "vcap_ag_api_kunit.h"
|
||||
#endif
|
||||
#include "vcap_ag_api.h"
|
||||
|
||||
#define VCAP_CID_LOOKUP_SIZE 100000 /* Chains in a lookup */
|
||||
#define VCAP_CID_INGRESS_L0 1000000 /* Ingress Stage 1 Lookup 0 */
|
||||
#define VCAP_CID_INGRESS_L1 1100000 /* Ingress Stage 1 Lookup 1 */
|
||||
#define VCAP_CID_INGRESS_L2 1200000 /* Ingress Stage 1 Lookup 2 */
|
||||
#define VCAP_CID_INGRESS_L3 1300000 /* Ingress Stage 1 Lookup 3 */
|
||||
#define VCAP_CID_INGRESS_L4 1400000 /* Ingress Stage 1 Lookup 4 */
|
||||
#define VCAP_CID_INGRESS_L5 1500000 /* Ingress Stage 1 Lookup 5 */
|
||||
|
||||
#define VCAP_CID_PREROUTING_IPV6 3000000 /* Prerouting Stage */
|
||||
#define VCAP_CID_PREROUTING 6000000 /* Prerouting Stage */
|
||||
|
||||
#define VCAP_CID_INGRESS_STAGE2_L0 8000000 /* Ingress Stage 2 Lookup 0 */
|
||||
#define VCAP_CID_INGRESS_STAGE2_L1 8100000 /* Ingress Stage 2 Lookup 1 */
|
||||
#define VCAP_CID_INGRESS_STAGE2_L2 8200000 /* Ingress Stage 2 Lookup 2 */
|
||||
#define VCAP_CID_INGRESS_STAGE2_L3 8300000 /* Ingress Stage 2 Lookup 3 */
|
||||
|
||||
#define VCAP_CID_EGRESS_L0 10000000 /* Egress Lookup 0 */
|
||||
#define VCAP_CID_EGRESS_L1 10100000 /* Egress Lookup 1 */
|
||||
|
||||
#define VCAP_CID_EGRESS_STAGE2_L0 20000000 /* Egress Stage 2 Lookup 0 */
|
||||
#define VCAP_CID_EGRESS_STAGE2_L1 20100000 /* Egress Stage 2 Lookup 1 */
|
||||
|
||||
/* Known users of the VCAP API */
|
||||
enum vcap_user {
|
||||
VCAP_USER_PTP,
|
||||
VCAP_USER_MRP,
|
||||
VCAP_USER_CFM,
|
||||
VCAP_USER_VLAN,
|
||||
VCAP_USER_QOS,
|
||||
VCAP_USER_VCAP_UTIL,
|
||||
VCAP_USER_TC,
|
||||
VCAP_USER_TC_EXTRA,
|
||||
|
||||
/* add new users above here */
|
||||
|
||||
/* used to define VCAP_USER_MAX below */
|
||||
__VCAP_USER_AFTER_LAST,
|
||||
VCAP_USER_MAX = __VCAP_USER_AFTER_LAST - 1,
|
||||
};
|
||||
|
||||
/* VCAP information used for displaying data */
|
||||
struct vcap_statistics {
|
||||
char *name;
|
||||
int count;
|
||||
const char * const *keyfield_set_names;
|
||||
const char * const *actionfield_set_names;
|
||||
const char * const *keyfield_names;
|
||||
const char * const *actionfield_names;
|
||||
};
|
||||
|
||||
/* VCAP key/action field type, position and width */
|
||||
struct vcap_field {
|
||||
u16 type;
|
||||
u16 width;
|
||||
u16 offset;
|
||||
};
|
||||
|
||||
/* VCAP keyset or actionset type and width */
|
||||
struct vcap_set {
|
||||
u8 type_id;
|
||||
u8 sw_per_item;
|
||||
u8 sw_cnt;
|
||||
};
|
||||
|
||||
/* VCAP typegroup position and bitvalue */
|
||||
struct vcap_typegroup {
|
||||
u16 offset;
|
||||
u16 width;
|
||||
u16 value;
|
||||
};
|
||||
|
||||
/* VCAP model data */
|
||||
struct vcap_info {
|
||||
char *name; /* user-friendly name */
|
||||
u16 rows; /* number of row in instance */
|
||||
u16 sw_count; /* maximum subwords used per rule */
|
||||
u16 sw_width; /* bits per subword in a keyset */
|
||||
u16 sticky_width; /* sticky bits per rule */
|
||||
u16 act_width; /* bits per subword in an actionset */
|
||||
u16 default_cnt; /* number of default rules */
|
||||
u16 require_cnt_dis; /* not used */
|
||||
u16 version; /* vcap rtl version */
|
||||
const struct vcap_set *keyfield_set; /* keysets */
|
||||
int keyfield_set_size; /* number of keysets */
|
||||
const struct vcap_set *actionfield_set; /* actionsets */
|
||||
int actionfield_set_size; /* number of actionsets */
|
||||
/* map of keys per keyset */
|
||||
const struct vcap_field **keyfield_set_map;
|
||||
/* number of entries in the above map */
|
||||
int *keyfield_set_map_size;
|
||||
/* map of actions per actionset */
|
||||
const struct vcap_field **actionfield_set_map;
|
||||
/* number of entries in the above map */
|
||||
int *actionfield_set_map_size;
|
||||
/* map of keyset typegroups per subword size */
|
||||
const struct vcap_typegroup **keyfield_set_typegroups;
|
||||
/* map of actionset typegroups per subword size */
|
||||
const struct vcap_typegroup **actionfield_set_typegroups;
|
||||
};
|
||||
|
||||
enum vcap_field_type {
|
||||
VCAP_FIELD_BIT,
|
||||
VCAP_FIELD_U32,
|
||||
VCAP_FIELD_U48,
|
||||
VCAP_FIELD_U56,
|
||||
VCAP_FIELD_U64,
|
||||
VCAP_FIELD_U72,
|
||||
VCAP_FIELD_U112,
|
||||
VCAP_FIELD_U128,
|
||||
};
|
||||
|
||||
/* VCAP rule data towards the VCAP cache */
|
||||
struct vcap_cache_data {
|
||||
u32 *keystream;
|
||||
u32 *maskstream;
|
||||
u32 *actionstream;
|
||||
u32 counter;
|
||||
bool sticky;
|
||||
};
|
||||
|
||||
/* Selects which part of the rule must be updated */
|
||||
enum vcap_selection {
|
||||
VCAP_SEL_ENTRY = 0x01,
|
||||
VCAP_SEL_ACTION = 0x02,
|
||||
VCAP_SEL_COUNTER = 0x04,
|
||||
VCAP_SEL_ALL = 0xff,
|
||||
};
|
||||
|
||||
/* Commands towards the VCAP cache */
|
||||
enum vcap_command {
|
||||
VCAP_CMD_WRITE = 0,
|
||||
VCAP_CMD_READ = 1,
|
||||
VCAP_CMD_MOVE_DOWN = 2,
|
||||
VCAP_CMD_MOVE_UP = 3,
|
||||
VCAP_CMD_INITIALIZE = 4,
|
||||
};
|
||||
|
||||
enum vcap_rule_error {
|
||||
VCAP_ERR_NONE = 0, /* No known error */
|
||||
VCAP_ERR_NO_ADMIN, /* No admin instance */
|
||||
VCAP_ERR_NO_NETDEV, /* No netdev instance */
|
||||
VCAP_ERR_NO_KEYSET_MATCH, /* No keyset matched the rule keys */
|
||||
VCAP_ERR_NO_ACTIONSET_MATCH, /* No actionset matched the rule actions */
|
||||
VCAP_ERR_NO_PORT_KEYSET_MATCH, /* No port keyset matched the rule keys */
|
||||
};
|
||||
|
||||
/* Administration of each VCAP instance */
|
||||
struct vcap_admin {
|
||||
struct list_head list; /* for insertion in vcap_control */
|
||||
struct list_head rules; /* list of rules */
|
||||
enum vcap_type vtype; /* type of vcap */
|
||||
int vinst; /* instance number within the same type */
|
||||
int first_cid; /* first chain id in this vcap */
|
||||
int last_cid; /* last chain id in this vcap */
|
||||
int tgt_inst; /* hardware instance number */
|
||||
int lookups; /* number of lookups in this vcap type */
|
||||
int lookups_per_instance; /* number of lookups in this instance */
|
||||
int last_valid_addr; /* top of address range to be used */
|
||||
int first_valid_addr; /* bottom of address range to be used */
|
||||
int last_used_addr; /* address of lowest added rule */
|
||||
bool w32be; /* vcap uses "32bit-word big-endian" encoding */
|
||||
struct vcap_cache_data cache; /* encoded rule data */
|
||||
};
|
||||
|
||||
/* Client supplied VCAP rule data */
|
||||
struct vcap_rule {
|
||||
int vcap_chain_id; /* chain used for this rule */
|
||||
enum vcap_user user; /* rule owner */
|
||||
u16 priority;
|
||||
u32 id; /* vcap rule id, must be unique, 0 will auto-generate a value */
|
||||
u64 cookie; /* used by the client to identify the rule */
|
||||
struct list_head keyfields; /* list of vcap_client_keyfield */
|
||||
struct list_head actionfields; /* list of vcap_client_actionfield */
|
||||
enum vcap_keyfield_set keyset; /* keyset used: may be derived from fields */
|
||||
enum vcap_actionfield_set actionset; /* actionset used: may be derived from fields */
|
||||
enum vcap_rule_error exterr; /* extended error - used by TC */
|
||||
u64 client; /* space for client defined data */
|
||||
};
|
||||
|
||||
/* List of keysets */
|
||||
struct vcap_keyset_list {
|
||||
int max; /* size of the keyset list */
|
||||
int cnt; /* count of keysets actually in the list */
|
||||
enum vcap_keyfield_set *keysets; /* the list of keysets */
|
||||
};
|
||||
|
||||
/* Client supplied VCAP callback operations */
|
||||
struct vcap_operations {
|
||||
/* validate port keyset operation */
|
||||
enum vcap_keyfield_set (*validate_keyset)
|
||||
(struct net_device *ndev,
|
||||
struct vcap_admin *admin,
|
||||
struct vcap_rule *rule,
|
||||
struct vcap_keyset_list *kslist,
|
||||
u16 l3_proto);
|
||||
/* add default rule fields for the selected keyset operations */
|
||||
void (*add_default_fields)
|
||||
(struct net_device *ndev,
|
||||
struct vcap_admin *admin,
|
||||
struct vcap_rule *rule);
|
||||
/* cache operations */
|
||||
void (*cache_erase)
|
||||
(struct vcap_admin *admin);
|
||||
void (*cache_write)
|
||||
(struct net_device *ndev,
|
||||
struct vcap_admin *admin,
|
||||
enum vcap_selection sel,
|
||||
u32 idx, u32 count);
|
||||
void (*cache_read)
|
||||
(struct net_device *ndev,
|
||||
struct vcap_admin *admin,
|
||||
enum vcap_selection sel,
|
||||
u32 idx,
|
||||
u32 count);
|
||||
/* block operations */
|
||||
void (*init)
|
||||
(struct net_device *ndev,
|
||||
struct vcap_admin *admin,
|
||||
u32 addr,
|
||||
u32 count);
|
||||
void (*update)
|
||||
(struct net_device *ndev,
|
||||
struct vcap_admin *admin,
|
||||
enum vcap_command cmd,
|
||||
enum vcap_selection sel,
|
||||
u32 addr);
|
||||
void (*move)
|
||||
(struct net_device *ndev,
|
||||
struct vcap_admin *admin,
|
||||
u32 addr,
|
||||
int offset,
|
||||
int count);
|
||||
/* informational */
|
||||
int (*port_info)
|
||||
(struct net_device *ndev,
|
||||
enum vcap_type vtype,
|
||||
int (*pf)(void *out, int arg, const char *fmt, ...),
|
||||
void *out,
|
||||
int arg);
|
||||
};
|
||||
|
||||
/* VCAP API Client control interface */
|
||||
struct vcap_control {
|
||||
u32 rule_id; /* last used rule id (unique across VCAP instances) */
|
||||
struct vcap_operations *ops; /* client supplied operations */
|
||||
const struct vcap_info *vcaps; /* client supplied vcap models */
|
||||
const struct vcap_statistics *stats; /* client supplied vcap stats */
|
||||
struct list_head list; /* list of vcap instances */
|
||||
};
|
||||
|
||||
/* Set client control interface on the API */
|
||||
int vcap_api_set_client(struct vcap_control *vctrl);
|
||||
|
||||
#endif /* __VCAP_API__ */
|
||||
202
drivers/net/ethernet/microchip/vcap/vcap_api_client.h
Normal file
202
drivers/net/ethernet/microchip/vcap/vcap_api_client.h
Normal file
@ -0,0 +1,202 @@
|
||||
/* SPDX-License-Identifier: GPL-2.0+ */
|
||||
/* Copyright (C) 2022 Microchip Technology Inc. and its subsidiaries.
|
||||
* Microchip VCAP API
|
||||
*/
|
||||
|
||||
#ifndef __VCAP_API_CLIENT__
|
||||
#define __VCAP_API_CLIENT__
|
||||
|
||||
#include <linux/types.h>
|
||||
#include <linux/list.h>
|
||||
#include <linux/netdevice.h>
|
||||
#include <net/flow_offload.h>
|
||||
|
||||
#include "vcap_api.h"
|
||||
|
||||
/* Client supplied VCAP rule key control part */
|
||||
struct vcap_client_keyfield_ctrl {
|
||||
struct list_head list; /* For insertion into a rule */
|
||||
enum vcap_key_field key;
|
||||
enum vcap_field_type type;
|
||||
};
|
||||
|
||||
struct vcap_u1_key {
|
||||
u8 value;
|
||||
u8 mask;
|
||||
};
|
||||
|
||||
struct vcap_u32_key {
|
||||
u32 value;
|
||||
u32 mask;
|
||||
};
|
||||
|
||||
struct vcap_u48_key {
|
||||
u8 value[6];
|
||||
u8 mask[6];
|
||||
};
|
||||
|
||||
struct vcap_u56_key {
|
||||
u8 value[7];
|
||||
u8 mask[7];
|
||||
};
|
||||
|
||||
struct vcap_u64_key {
|
||||
u8 value[8];
|
||||
u8 mask[8];
|
||||
};
|
||||
|
||||
struct vcap_u72_key {
|
||||
u8 value[9];
|
||||
u8 mask[9];
|
||||
};
|
||||
|
||||
struct vcap_u112_key {
|
||||
u8 value[14];
|
||||
u8 mask[14];
|
||||
};
|
||||
|
||||
struct vcap_u128_key {
|
||||
u8 value[16];
|
||||
u8 mask[16];
|
||||
};
|
||||
|
||||
/* Client supplied VCAP rule field data */
|
||||
struct vcap_client_keyfield_data {
|
||||
union {
|
||||
struct vcap_u1_key u1;
|
||||
struct vcap_u32_key u32;
|
||||
struct vcap_u48_key u48;
|
||||
struct vcap_u56_key u56;
|
||||
struct vcap_u64_key u64;
|
||||
struct vcap_u72_key u72;
|
||||
struct vcap_u112_key u112;
|
||||
struct vcap_u128_key u128;
|
||||
};
|
||||
};
|
||||
|
||||
/* Client supplied VCAP rule key (value, mask) */
|
||||
struct vcap_client_keyfield {
|
||||
struct vcap_client_keyfield_ctrl ctrl;
|
||||
struct vcap_client_keyfield_data data;
|
||||
};
|
||||
|
||||
/* Client supplied VCAP rule action control part */
|
||||
struct vcap_client_actionfield_ctrl {
|
||||
struct list_head list; /* For insertion into a rule */
|
||||
enum vcap_action_field action;
|
||||
enum vcap_field_type type;
|
||||
};
|
||||
|
||||
struct vcap_u1_action {
|
||||
u8 value;
|
||||
};
|
||||
|
||||
struct vcap_u32_action {
|
||||
u32 value;
|
||||
};
|
||||
|
||||
struct vcap_u48_action {
|
||||
u8 value[6];
|
||||
};
|
||||
|
||||
struct vcap_u56_action {
|
||||
u8 value[7];
|
||||
};
|
||||
|
||||
struct vcap_u64_action {
|
||||
u8 value[8];
|
||||
};
|
||||
|
||||
struct vcap_u72_action {
|
||||
u8 value[9];
|
||||
};
|
||||
|
||||
struct vcap_u112_action {
|
||||
u8 value[14];
|
||||
};
|
||||
|
||||
struct vcap_u128_action {
|
||||
u8 value[16];
|
||||
};
|
||||
|
||||
struct vcap_client_actionfield_data {
|
||||
union {
|
||||
struct vcap_u1_action u1;
|
||||
struct vcap_u32_action u32;
|
||||
struct vcap_u48_action u48;
|
||||
struct vcap_u56_action u56;
|
||||
struct vcap_u64_action u64;
|
||||
struct vcap_u72_action u72;
|
||||
struct vcap_u112_action u112;
|
||||
struct vcap_u128_action u128;
|
||||
};
|
||||
};
|
||||
|
||||
struct vcap_client_actionfield {
|
||||
struct vcap_client_actionfield_ctrl ctrl;
|
||||
struct vcap_client_actionfield_data data;
|
||||
};
|
||||
|
||||
enum vcap_bit {
|
||||
VCAP_BIT_ANY,
|
||||
VCAP_BIT_0,
|
||||
VCAP_BIT_1
|
||||
};
|
||||
|
||||
/* VCAP rule operations */
|
||||
/* Allocate a rule and fill in the basic information */
|
||||
struct vcap_rule *vcap_alloc_rule(struct vcap_control *vctrl,
|
||||
struct net_device *ndev,
|
||||
int vcap_chain_id,
|
||||
enum vcap_user user,
|
||||
u16 priority,
|
||||
u32 id);
|
||||
/* Free mem of a rule owned by client */
|
||||
void vcap_free_rule(struct vcap_rule *rule);
|
||||
/* Validate a rule before adding it to the VCAP */
|
||||
int vcap_val_rule(struct vcap_rule *rule, u16 l3_proto);
|
||||
/* Add rule to a VCAP instance */
|
||||
int vcap_add_rule(struct vcap_rule *rule);
|
||||
/* Delete rule in a VCAP instance */
|
||||
int vcap_del_rule(struct vcap_control *vctrl, struct net_device *ndev, u32 id);
|
||||
|
||||
/* Update the keyset for the rule */
|
||||
int vcap_set_rule_set_keyset(struct vcap_rule *rule,
|
||||
enum vcap_keyfield_set keyset);
|
||||
/* Update the actionset for the rule */
|
||||
int vcap_set_rule_set_actionset(struct vcap_rule *rule,
|
||||
enum vcap_actionfield_set actionset);
|
||||
|
||||
/* VCAP rule field operations */
|
||||
int vcap_rule_add_key_bit(struct vcap_rule *rule, enum vcap_key_field key,
|
||||
enum vcap_bit val);
|
||||
int vcap_rule_add_key_u32(struct vcap_rule *rule, enum vcap_key_field key,
|
||||
u32 value, u32 mask);
|
||||
int vcap_rule_add_key_u48(struct vcap_rule *rule, enum vcap_key_field key,
|
||||
struct vcap_u48_key *fieldval);
|
||||
int vcap_rule_add_key_u72(struct vcap_rule *rule, enum vcap_key_field key,
|
||||
struct vcap_u72_key *fieldval);
|
||||
int vcap_rule_add_action_bit(struct vcap_rule *rule,
|
||||
enum vcap_action_field action, enum vcap_bit val);
|
||||
int vcap_rule_add_action_u32(struct vcap_rule *rule,
|
||||
enum vcap_action_field action, u32 value);
|
||||
|
||||
/* VCAP lookup operations */
|
||||
/* Lookup a vcap instance using chain id */
|
||||
struct vcap_admin *vcap_find_admin(struct vcap_control *vctrl, int cid);
|
||||
/* Find information on a key field in a rule */
|
||||
const struct vcap_field *vcap_lookup_keyfield(struct vcap_rule *rule,
|
||||
enum vcap_key_field key);
|
||||
/* Find a rule id with a provided cookie */
|
||||
int vcap_lookup_rule_by_cookie(struct vcap_control *vctrl, u64 cookie);
|
||||
|
||||
/* Copy to host byte order */
|
||||
void vcap_netbytes_copy(u8 *dst, u8 *src, int count);
|
||||
|
||||
/* Convert validation error code into tc extact error message */
|
||||
void vcap_set_tc_exterr(struct flow_cls_offload *fco, struct vcap_rule *vrule);
|
||||
|
||||
/* Cleanup a VCAP instance */
|
||||
int vcap_del_rules(struct vcap_control *vctrl, struct vcap_admin *admin);
|
||||
|
||||
#endif /* __VCAP_API_CLIENT__ */
|
||||
933
drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c
Normal file
933
drivers/net/ethernet/microchip/vcap/vcap_api_kunit.c
Normal file
@ -0,0 +1,933 @@
|
||||
// SPDX-License-Identifier: BSD-3-Clause
|
||||
/* Copyright (C) 2022 Microchip Technology Inc. and its subsidiaries.
|
||||
* Microchip VCAP API kunit test suite
|
||||
*/
|
||||
|
||||
#include <kunit/test.h>
|
||||
#include "vcap_api.h"
|
||||
#include "vcap_api_client.h"
|
||||
#include "vcap_model_kunit.h"
|
||||
|
||||
/* First we have the test infrastructure that emulates the platform
|
||||
* implementation
|
||||
*/
|
||||
#define TEST_BUF_CNT 100
|
||||
#define TEST_BUF_SZ 350
|
||||
#define STREAMWSIZE 64
|
||||
|
||||
static u32 test_updateaddr[STREAMWSIZE] = {};
|
||||
static int test_updateaddridx;
|
||||
static int test_cache_erase_count;
|
||||
static u32 test_init_start;
|
||||
static u32 test_init_count;
|
||||
static u32 test_hw_counter_id;
|
||||
static struct vcap_cache_data test_hw_cache;
|
||||
|
||||
/* Callback used by the VCAP API */
|
||||
static enum vcap_keyfield_set test_val_keyset(struct net_device *ndev,
|
||||
struct vcap_admin *admin,
|
||||
struct vcap_rule *rule,
|
||||
struct vcap_keyset_list *kslist,
|
||||
u16 l3_proto)
|
||||
{
|
||||
int idx;
|
||||
|
||||
if (kslist->cnt > 0) {
|
||||
switch (admin->vtype) {
|
||||
case VCAP_TYPE_IS0:
|
||||
for (idx = 0; idx < kslist->cnt; idx++) {
|
||||
if (kslist->keysets[idx] == VCAP_KFS_ETAG)
|
||||
return kslist->keysets[idx];
|
||||
if (kslist->keysets[idx] == VCAP_KFS_PURE_5TUPLE_IP4)
|
||||
return kslist->keysets[idx];
|
||||
if (kslist->keysets[idx] == VCAP_KFS_NORMAL_5TUPLE_IP4)
|
||||
return kslist->keysets[idx];
|
||||
if (kslist->keysets[idx] == VCAP_KFS_NORMAL_7TUPLE)
|
||||
return kslist->keysets[idx];
|
||||
}
|
||||
break;
|
||||
case VCAP_TYPE_IS2:
|
||||
for (idx = 0; idx < kslist->cnt; idx++) {
|
||||
if (kslist->keysets[idx] == VCAP_KFS_MAC_ETYPE)
|
||||
return kslist->keysets[idx];
|
||||
if (kslist->keysets[idx] == VCAP_KFS_ARP)
|
||||
return kslist->keysets[idx];
|
||||
if (kslist->keysets[idx] == VCAP_KFS_IP_7TUPLE)
|
||||
return kslist->keysets[idx];
|
||||
}
|
||||
break;
|
||||
default:
|
||||
pr_info("%s:%d: no validation for VCAP %d\n",
|
||||
__func__, __LINE__, admin->vtype);
|
||||
break;
|
||||
}
|
||||
}
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/* Callback used by the VCAP API */
|
||||
static void test_add_def_fields(struct net_device *ndev,
|
||||
struct vcap_admin *admin,
|
||||
struct vcap_rule *rule)
|
||||
{
|
||||
if (admin->vinst == 0 || admin->vinst == 2)
|
||||
vcap_rule_add_key_bit(rule, VCAP_KF_LOOKUP_FIRST_IS, VCAP_BIT_1);
|
||||
else
|
||||
vcap_rule_add_key_bit(rule, VCAP_KF_LOOKUP_FIRST_IS, VCAP_BIT_0);
|
||||
}
|
||||
|
||||
/* Callback used by the VCAP API */
|
||||
static void test_cache_erase(struct vcap_admin *admin)
|
||||
{
|
||||
if (test_cache_erase_count) {
|
||||
memset(admin->cache.keystream, 0, test_cache_erase_count);
|
||||
memset(admin->cache.maskstream, 0, test_cache_erase_count);
|
||||
memset(admin->cache.actionstream, 0, test_cache_erase_count);
|
||||
test_cache_erase_count = 0;
|
||||
}
|
||||
}
|
||||
|
||||
/* Callback used by the VCAP API */
|
||||
static void test_cache_init(struct net_device *ndev, struct vcap_admin *admin,
|
||||
u32 start, u32 count)
|
||||
{
|
||||
test_init_start = start;
|
||||
test_init_count = count;
|
||||
}
|
||||
|
||||
/* Callback used by the VCAP API */
|
||||
static void test_cache_read(struct net_device *ndev, struct vcap_admin *admin,
|
||||
enum vcap_selection sel, u32 start, u32 count)
|
||||
{
|
||||
u32 *keystr, *mskstr, *actstr;
|
||||
int idx;
|
||||
|
||||
pr_debug("%s:%d: %d %d\n", __func__, __LINE__, start, count);
|
||||
switch (sel) {
|
||||
case VCAP_SEL_ENTRY:
|
||||
keystr = &admin->cache.keystream[start];
|
||||
mskstr = &admin->cache.maskstream[start];
|
||||
for (idx = 0; idx < count; ++idx) {
|
||||
pr_debug("%s:%d: keydata[%02d]: 0x%08x\n", __func__,
|
||||
__LINE__, start + idx, keystr[idx]);
|
||||
}
|
||||
for (idx = 0; idx < count; ++idx) {
|
||||
/* Invert the mask before decoding starts */
|
||||
mskstr[idx] = ~mskstr[idx];
|
||||
pr_debug("%s:%d: mskdata[%02d]: 0x%08x\n", __func__,
|
||||
__LINE__, start + idx, mskstr[idx]);
|
||||
}
|
||||
break;
|
||||
case VCAP_SEL_ACTION:
|
||||
actstr = &admin->cache.actionstream[start];
|
||||
for (idx = 0; idx < count; ++idx) {
|
||||
pr_debug("%s:%d: actdata[%02d]: 0x%08x\n", __func__,
|
||||
__LINE__, start + idx, actstr[idx]);
|
||||
}
|
||||
break;
|
||||
case VCAP_SEL_COUNTER:
|
||||
pr_debug("%s:%d\n", __func__, __LINE__);
|
||||
test_hw_counter_id = start;
|
||||
admin->cache.counter = test_hw_cache.counter;
|
||||
admin->cache.sticky = test_hw_cache.sticky;
|
||||
break;
|
||||
case VCAP_SEL_ALL:
|
||||
pr_debug("%s:%d\n", __func__, __LINE__);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* Callback used by the VCAP API */
|
||||
static void test_cache_write(struct net_device *ndev, struct vcap_admin *admin,
|
||||
enum vcap_selection sel, u32 start, u32 count)
|
||||
{
|
||||
u32 *keystr, *mskstr, *actstr;
|
||||
int idx;
|
||||
|
||||
switch (sel) {
|
||||
case VCAP_SEL_ENTRY:
|
||||
keystr = &admin->cache.keystream[start];
|
||||
mskstr = &admin->cache.maskstream[start];
|
||||
for (idx = 0; idx < count; ++idx) {
|
||||
pr_debug("%s:%d: keydata[%02d]: 0x%08x\n", __func__,
|
||||
__LINE__, start + idx, keystr[idx]);
|
||||
}
|
||||
for (idx = 0; idx < count; ++idx) {
|
||||
/* Invert the mask before encoding starts */
|
||||
mskstr[idx] = ~mskstr[idx];
|
||||
pr_debug("%s:%d: mskdata[%02d]: 0x%08x\n", __func__,
|
||||
__LINE__, start + idx, mskstr[idx]);
|
||||
}
|
||||
break;
|
||||
case VCAP_SEL_ACTION:
|
||||
actstr = &admin->cache.actionstream[start];
|
||||
for (idx = 0; idx < count; ++idx) {
|
||||
pr_debug("%s:%d: actdata[%02d]: 0x%08x\n", __func__,
|
||||
__LINE__, start + idx, actstr[idx]);
|
||||
}
|
||||
break;
|
||||
case VCAP_SEL_COUNTER:
|
||||
pr_debug("%s:%d\n", __func__, __LINE__);
|
||||
test_hw_counter_id = start;
|
||||
test_hw_cache.counter = admin->cache.counter;
|
||||
test_hw_cache.sticky = admin->cache.sticky;
|
||||
break;
|
||||
case VCAP_SEL_ALL:
|
||||
pr_err("%s:%d: cannot write all streams at once\n",
|
||||
__func__, __LINE__);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* Callback used by the VCAP API */
|
||||
static void test_cache_update(struct net_device *ndev, struct vcap_admin *admin,
|
||||
enum vcap_command cmd,
|
||||
enum vcap_selection sel, u32 addr)
|
||||
{
|
||||
if (test_updateaddridx < ARRAY_SIZE(test_updateaddr))
|
||||
test_updateaddr[test_updateaddridx] = addr;
|
||||
else
|
||||
pr_err("%s:%d: overflow: %d\n", __func__, __LINE__, test_updateaddridx);
|
||||
test_updateaddridx++;
|
||||
}
|
||||
|
||||
static void test_cache_move(struct net_device *ndev, struct vcap_admin *admin,
|
||||
u32 addr, int offset, int count)
|
||||
{
|
||||
}
|
||||
|
||||
/* Provide port information via a callback interface */
|
||||
static int vcap_test_port_info(struct net_device *ndev, enum vcap_type vtype,
|
||||
int (*pf)(void *out, int arg, const char *fmt, ...),
|
||||
void *out, int arg)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
struct vcap_operations test_callbacks = {
|
||||
.validate_keyset = test_val_keyset,
|
||||
.add_default_fields = test_add_def_fields,
|
||||
.cache_erase = test_cache_erase,
|
||||
.cache_write = test_cache_write,
|
||||
.cache_read = test_cache_read,
|
||||
.init = test_cache_init,
|
||||
.update = test_cache_update,
|
||||
.move = test_cache_move,
|
||||
.port_info = vcap_test_port_info,
|
||||
};
|
||||
|
||||
struct vcap_control test_vctrl = {
|
||||
.vcaps = kunit_test_vcaps,
|
||||
.stats = &kunit_test_vcap_stats,
|
||||
.ops = &test_callbacks,
|
||||
};
|
||||
|
||||
static void vcap_test_api_init(struct vcap_admin *admin)
|
||||
{
|
||||
/* Initialize the shared objects */
|
||||
INIT_LIST_HEAD(&test_vctrl.list);
|
||||
INIT_LIST_HEAD(&admin->list);
|
||||
INIT_LIST_HEAD(&admin->rules);
|
||||
list_add_tail(&admin->list, &test_vctrl.list);
|
||||
memset(test_updateaddr, 0, sizeof(test_updateaddr));
|
||||
test_updateaddridx = 0;
|
||||
}
|
||||
|
||||
/* Define the test cases. */
|
||||
|
||||
static void vcap_api_set_bit_1_test(struct kunit *test)
|
||||
{
|
||||
struct vcap_stream_iter iter = {
|
||||
.offset = 35,
|
||||
.sw_width = 52,
|
||||
.reg_idx = 1,
|
||||
.reg_bitpos = 20,
|
||||
.tg = 0
|
||||
};
|
||||
u32 stream[2] = {0};
|
||||
|
||||
vcap_set_bit(stream, &iter, 1);
|
||||
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x0, stream[0]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)BIT(20), stream[1]);
|
||||
}
|
||||
|
||||
static void vcap_api_set_bit_0_test(struct kunit *test)
|
||||
{
|
||||
struct vcap_stream_iter iter = {
|
||||
.offset = 35,
|
||||
.sw_width = 52,
|
||||
.reg_idx = 2,
|
||||
.reg_bitpos = 11,
|
||||
.tg = 0
|
||||
};
|
||||
u32 stream[3] = {~0, ~0, ~0};
|
||||
|
||||
vcap_set_bit(stream, &iter, 0);
|
||||
|
||||
KUNIT_EXPECT_EQ(test, (u32)~0, stream[0]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)~0, stream[1]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)~BIT(11), stream[2]);
|
||||
}
|
||||
|
||||
static void vcap_api_iterator_init_test(struct kunit *test)
|
||||
{
|
||||
struct vcap_stream_iter iter;
|
||||
struct vcap_typegroup typegroups[] = {
|
||||
{ .offset = 0, .width = 2, .value = 2, },
|
||||
{ .offset = 156, .width = 1, .value = 0, },
|
||||
{ .offset = 0, .width = 0, .value = 0, },
|
||||
};
|
||||
struct vcap_typegroup typegroups2[] = {
|
||||
{ .offset = 0, .width = 3, .value = 4, },
|
||||
{ .offset = 49, .width = 2, .value = 0, },
|
||||
{ .offset = 98, .width = 2, .value = 0, },
|
||||
};
|
||||
|
||||
vcap_iter_init(&iter, 52, typegroups, 86);
|
||||
|
||||
KUNIT_EXPECT_EQ(test, 52, iter.sw_width);
|
||||
KUNIT_EXPECT_EQ(test, 86 + 2, iter.offset);
|
||||
KUNIT_EXPECT_EQ(test, 3, iter.reg_idx);
|
||||
KUNIT_EXPECT_EQ(test, 4, iter.reg_bitpos);
|
||||
|
||||
vcap_iter_init(&iter, 49, typegroups2, 134);
|
||||
|
||||
KUNIT_EXPECT_EQ(test, 49, iter.sw_width);
|
||||
KUNIT_EXPECT_EQ(test, 134 + 7, iter.offset);
|
||||
KUNIT_EXPECT_EQ(test, 5, iter.reg_idx);
|
||||
KUNIT_EXPECT_EQ(test, 11, iter.reg_bitpos);
|
||||
}
|
||||
|
||||
static void vcap_api_iterator_next_test(struct kunit *test)
|
||||
{
|
||||
struct vcap_stream_iter iter;
|
||||
struct vcap_typegroup typegroups[] = {
|
||||
{ .offset = 0, .width = 4, .value = 8, },
|
||||
{ .offset = 49, .width = 1, .value = 0, },
|
||||
{ .offset = 98, .width = 2, .value = 0, },
|
||||
{ .offset = 147, .width = 3, .value = 0, },
|
||||
{ .offset = 196, .width = 2, .value = 0, },
|
||||
{ .offset = 245, .width = 1, .value = 0, },
|
||||
};
|
||||
int idx;
|
||||
|
||||
vcap_iter_init(&iter, 49, typegroups, 86);
|
||||
|
||||
KUNIT_EXPECT_EQ(test, 49, iter.sw_width);
|
||||
KUNIT_EXPECT_EQ(test, 86 + 5, iter.offset);
|
||||
KUNIT_EXPECT_EQ(test, 3, iter.reg_idx);
|
||||
KUNIT_EXPECT_EQ(test, 10, iter.reg_bitpos);
|
||||
|
||||
vcap_iter_next(&iter);
|
||||
|
||||
KUNIT_EXPECT_EQ(test, 91 + 1, iter.offset);
|
||||
KUNIT_EXPECT_EQ(test, 3, iter.reg_idx);
|
||||
KUNIT_EXPECT_EQ(test, 11, iter.reg_bitpos);
|
||||
|
||||
for (idx = 0; idx < 6; idx++)
|
||||
vcap_iter_next(&iter);
|
||||
|
||||
KUNIT_EXPECT_EQ(test, 92 + 6 + 2, iter.offset);
|
||||
KUNIT_EXPECT_EQ(test, 4, iter.reg_idx);
|
||||
KUNIT_EXPECT_EQ(test, 2, iter.reg_bitpos);
|
||||
}
|
||||
|
||||
static void vcap_api_encode_typegroups_test(struct kunit *test)
|
||||
{
|
||||
u32 stream[12] = {0};
|
||||
struct vcap_typegroup typegroups[] = {
|
||||
{ .offset = 0, .width = 4, .value = 8, },
|
||||
{ .offset = 49, .width = 1, .value = 1, },
|
||||
{ .offset = 98, .width = 2, .value = 3, },
|
||||
{ .offset = 147, .width = 3, .value = 5, },
|
||||
{ .offset = 196, .width = 2, .value = 2, },
|
||||
{ .offset = 245, .width = 5, .value = 27, },
|
||||
{ .offset = 0, .width = 0, .value = 0, },
|
||||
};
|
||||
|
||||
vcap_encode_typegroups(stream, 49, typegroups, false);
|
||||
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x8, stream[0]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x0, stream[1]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x1, stream[2]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x0, stream[3]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x3, stream[4]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x0, stream[5]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x5, stream[6]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x0, stream[7]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x2, stream[8]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x0, stream[9]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)27, stream[10]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x0, stream[11]);
|
||||
}
|
||||
|
||||
static void vcap_api_encode_bit_test(struct kunit *test)
|
||||
{
|
||||
struct vcap_stream_iter iter;
|
||||
u32 stream[4] = {0};
|
||||
struct vcap_typegroup typegroups[] = {
|
||||
{ .offset = 0, .width = 4, .value = 8, },
|
||||
{ .offset = 49, .width = 1, .value = 1, },
|
||||
{ .offset = 98, .width = 2, .value = 3, },
|
||||
{ .offset = 147, .width = 3, .value = 5, },
|
||||
{ .offset = 196, .width = 2, .value = 2, },
|
||||
{ .offset = 245, .width = 1, .value = 0, },
|
||||
};
|
||||
|
||||
vcap_iter_init(&iter, 49, typegroups, 44);
|
||||
|
||||
KUNIT_EXPECT_EQ(test, 48, iter.offset);
|
||||
KUNIT_EXPECT_EQ(test, 1, iter.reg_idx);
|
||||
KUNIT_EXPECT_EQ(test, 16, iter.reg_bitpos);
|
||||
|
||||
vcap_encode_bit(stream, &iter, 1);
|
||||
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x0, stream[0]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)BIT(16), stream[1]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x0, stream[2]);
|
||||
}
|
||||
|
||||
static void vcap_api_encode_field_test(struct kunit *test)
|
||||
{
|
||||
struct vcap_stream_iter iter;
|
||||
u32 stream[16] = {0};
|
||||
struct vcap_typegroup typegroups[] = {
|
||||
{ .offset = 0, .width = 4, .value = 8, },
|
||||
{ .offset = 49, .width = 1, .value = 1, },
|
||||
{ .offset = 98, .width = 2, .value = 3, },
|
||||
{ .offset = 147, .width = 3, .value = 5, },
|
||||
{ .offset = 196, .width = 2, .value = 2, },
|
||||
{ .offset = 245, .width = 5, .value = 27, },
|
||||
{ .offset = 0, .width = 0, .value = 0, },
|
||||
};
|
||||
struct vcap_field rf = {
|
||||
.type = VCAP_FIELD_U32,
|
||||
.offset = 86,
|
||||
.width = 4,
|
||||
};
|
||||
u8 value[] = {0x5};
|
||||
|
||||
vcap_iter_init(&iter, 49, typegroups, rf.offset);
|
||||
|
||||
KUNIT_EXPECT_EQ(test, 91, iter.offset);
|
||||
KUNIT_EXPECT_EQ(test, 3, iter.reg_idx);
|
||||
KUNIT_EXPECT_EQ(test, 10, iter.reg_bitpos);
|
||||
|
||||
vcap_encode_field(stream, &iter, rf.width, value);
|
||||
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x0, stream[0]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x0, stream[1]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x0, stream[2]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)(0x5 << 10), stream[3]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x0, stream[4]);
|
||||
|
||||
vcap_encode_typegroups(stream, 49, typegroups, false);
|
||||
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x8, stream[0]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x0, stream[1]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x1, stream[2]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)(0x5 << 10), stream[3]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x3, stream[4]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x0, stream[5]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x5, stream[6]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x0, stream[7]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x2, stream[8]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x0, stream[9]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)27, stream[10]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x0, stream[11]);
|
||||
}
|
||||
|
||||
/* In this testcase the subword is smaller than a register */
|
||||
static void vcap_api_encode_short_field_test(struct kunit *test)
|
||||
{
|
||||
struct vcap_stream_iter iter;
|
||||
int sw_width = 21;
|
||||
u32 stream[6] = {0};
|
||||
struct vcap_typegroup tgt[] = {
|
||||
{ .offset = 0, .width = 3, .value = 7, },
|
||||
{ .offset = 21, .width = 2, .value = 3, },
|
||||
{ .offset = 42, .width = 1, .value = 1, },
|
||||
{ .offset = 0, .width = 0, .value = 0, },
|
||||
};
|
||||
struct vcap_field rf = {
|
||||
.type = VCAP_FIELD_U32,
|
||||
.offset = 25,
|
||||
.width = 4,
|
||||
};
|
||||
u8 value[] = {0x5};
|
||||
|
||||
vcap_iter_init(&iter, sw_width, tgt, rf.offset);
|
||||
|
||||
KUNIT_EXPECT_EQ(test, 1, iter.regs_per_sw);
|
||||
KUNIT_EXPECT_EQ(test, 21, iter.sw_width);
|
||||
KUNIT_EXPECT_EQ(test, 25 + 3 + 2, iter.offset);
|
||||
KUNIT_EXPECT_EQ(test, 1, iter.reg_idx);
|
||||
KUNIT_EXPECT_EQ(test, 25 + 3 + 2 - sw_width, iter.reg_bitpos);
|
||||
|
||||
vcap_encode_field(stream, &iter, rf.width, value);
|
||||
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x0, stream[0]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)(0x5 << (25 + 3 + 2 - sw_width)), stream[1]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x0, stream[2]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x0, stream[3]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x0, stream[4]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x0, stream[5]);
|
||||
|
||||
vcap_encode_typegroups(stream, sw_width, tgt, false);
|
||||
|
||||
KUNIT_EXPECT_EQ(test, (u32)7, stream[0]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)((0x5 << (25 + 3 + 2 - sw_width)) + 3), stream[1]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)1, stream[2]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0, stream[3]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0, stream[4]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0, stream[5]);
|
||||
}
|
||||
|
||||
static void vcap_api_encode_keyfield_test(struct kunit *test)
|
||||
{
|
||||
u32 keywords[16] = {0};
|
||||
u32 maskwords[16] = {0};
|
||||
struct vcap_admin admin = {
|
||||
.vtype = VCAP_TYPE_IS2,
|
||||
.cache = {
|
||||
.keystream = keywords,
|
||||
.maskstream = maskwords,
|
||||
.actionstream = keywords,
|
||||
},
|
||||
};
|
||||
struct vcap_rule_internal rule = {
|
||||
.admin = &admin,
|
||||
.data = {
|
||||
.keyset = VCAP_KFS_MAC_ETYPE,
|
||||
},
|
||||
.vctrl = &test_vctrl,
|
||||
};
|
||||
struct vcap_client_keyfield ckf = {
|
||||
.ctrl.list = {},
|
||||
.ctrl.key = VCAP_KF_ISDX_CLS,
|
||||
.ctrl.type = VCAP_FIELD_U32,
|
||||
.data.u32.value = 0xeef014a1,
|
||||
.data.u32.mask = 0xfff,
|
||||
};
|
||||
struct vcap_field rf = {
|
||||
.type = VCAP_FIELD_U32,
|
||||
.offset = 56,
|
||||
.width = 12,
|
||||
};
|
||||
struct vcap_typegroup tgt[] = {
|
||||
{ .offset = 0, .width = 2, .value = 2, },
|
||||
{ .offset = 156, .width = 1, .value = 1, },
|
||||
{ .offset = 0, .width = 0, .value = 0, },
|
||||
};
|
||||
|
||||
vcap_test_api_init(&admin);
|
||||
vcap_encode_keyfield(&rule, &ckf, &rf, tgt);
|
||||
|
||||
/* Key */
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x0, keywords[0]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x0, keywords[1]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)(0x04a1 << 6), keywords[2]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x0, keywords[3]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x0, keywords[4]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x0, keywords[5]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x0, keywords[6]);
|
||||
|
||||
/* Mask */
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x0, maskwords[0]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x0, maskwords[1]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)(0x0fff << 6), maskwords[2]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x0, maskwords[3]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x0, maskwords[4]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x0, maskwords[5]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x0, maskwords[6]);
|
||||
}
|
||||
|
||||
static void vcap_api_encode_max_keyfield_test(struct kunit *test)
|
||||
{
|
||||
int idx;
|
||||
u32 keywords[6] = {0};
|
||||
u32 maskwords[6] = {0};
|
||||
struct vcap_admin admin = {
|
||||
.vtype = VCAP_TYPE_IS2,
|
||||
/* IS2 sw_width = 52 bit */
|
||||
.cache = {
|
||||
.keystream = keywords,
|
||||
.maskstream = maskwords,
|
||||
.actionstream = keywords,
|
||||
},
|
||||
};
|
||||
struct vcap_rule_internal rule = {
|
||||
.admin = &admin,
|
||||
.data = {
|
||||
.keyset = VCAP_KFS_IP_7TUPLE,
|
||||
},
|
||||
.vctrl = &test_vctrl,
|
||||
};
|
||||
struct vcap_client_keyfield ckf = {
|
||||
.ctrl.list = {},
|
||||
.ctrl.key = VCAP_KF_L3_IP6_DIP,
|
||||
.ctrl.type = VCAP_FIELD_U128,
|
||||
.data.u128.value = { 0xa1, 0xa2, 0xa3, 0xa4, 0, 0, 0x43, 0,
|
||||
0, 0, 0, 0, 0, 0, 0x78, 0x8e, },
|
||||
.data.u128.mask = { 0xff, 0xff, 0xff, 0xff, 0, 0, 0xff, 0,
|
||||
0, 0, 0, 0, 0, 0, 0xff, 0xff },
|
||||
};
|
||||
struct vcap_field rf = {
|
||||
.type = VCAP_FIELD_U128,
|
||||
.offset = 0,
|
||||
.width = 128,
|
||||
};
|
||||
struct vcap_typegroup tgt[] = {
|
||||
{ .offset = 0, .width = 2, .value = 2, },
|
||||
{ .offset = 156, .width = 1, .value = 1, },
|
||||
{ .offset = 0, .width = 0, .value = 0, },
|
||||
};
|
||||
u32 keyres[] = {
|
||||
0x928e8a84,
|
||||
0x000c0002,
|
||||
0x00000010,
|
||||
0x00000000,
|
||||
0x0239e000,
|
||||
0x00000000,
|
||||
};
|
||||
u32 mskres[] = {
|
||||
0xfffffffc,
|
||||
0x000c0003,
|
||||
0x0000003f,
|
||||
0x00000000,
|
||||
0x03fffc00,
|
||||
0x00000000,
|
||||
};
|
||||
|
||||
vcap_encode_keyfield(&rule, &ckf, &rf, tgt);
|
||||
|
||||
/* Key */
|
||||
for (idx = 0; idx < ARRAY_SIZE(keyres); ++idx)
|
||||
KUNIT_EXPECT_EQ(test, keyres[idx], keywords[idx]);
|
||||
/* Mask */
|
||||
for (idx = 0; idx < ARRAY_SIZE(mskres); ++idx)
|
||||
KUNIT_EXPECT_EQ(test, mskres[idx], maskwords[idx]);
|
||||
}
|
||||
|
||||
static void vcap_api_encode_actionfield_test(struct kunit *test)
|
||||
{
|
||||
u32 actwords[16] = {0};
|
||||
int sw_width = 21;
|
||||
struct vcap_admin admin = {
|
||||
.vtype = VCAP_TYPE_ES2, /* act_width = 21 */
|
||||
.cache = {
|
||||
.actionstream = actwords,
|
||||
},
|
||||
};
|
||||
struct vcap_rule_internal rule = {
|
||||
.admin = &admin,
|
||||
.data = {
|
||||
.actionset = VCAP_AFS_BASE_TYPE,
|
||||
},
|
||||
.vctrl = &test_vctrl,
|
||||
};
|
||||
struct vcap_client_actionfield caf = {
|
||||
.ctrl.list = {},
|
||||
.ctrl.action = VCAP_AF_POLICE_IDX,
|
||||
.ctrl.type = VCAP_FIELD_U32,
|
||||
.data.u32.value = 0x67908032,
|
||||
};
|
||||
struct vcap_field rf = {
|
||||
.type = VCAP_FIELD_U32,
|
||||
.offset = 35,
|
||||
.width = 6,
|
||||
};
|
||||
struct vcap_typegroup tgt[] = {
|
||||
{ .offset = 0, .width = 2, .value = 2, },
|
||||
{ .offset = 21, .width = 1, .value = 1, },
|
||||
{ .offset = 42, .width = 1, .value = 0, },
|
||||
{ .offset = 0, .width = 0, .value = 0, },
|
||||
};
|
||||
|
||||
vcap_encode_actionfield(&rule, &caf, &rf, tgt);
|
||||
|
||||
/* Action */
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x0, actwords[0]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)((0x32 << (35 + 2 + 1 - sw_width)) & 0x1fffff), actwords[1]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)((0x32 >> ((2 * sw_width) - 38 - 1))), actwords[2]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x0, actwords[3]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x0, actwords[4]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x0, actwords[5]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x0, actwords[6]);
|
||||
}
|
||||
|
||||
static void vcap_api_keyfield_typegroup_test(struct kunit *test)
|
||||
{
|
||||
const struct vcap_typegroup *tg;
|
||||
|
||||
tg = vcap_keyfield_typegroup(&test_vctrl, VCAP_TYPE_IS2, VCAP_KFS_MAC_ETYPE);
|
||||
KUNIT_EXPECT_PTR_NE(test, NULL, tg);
|
||||
KUNIT_EXPECT_EQ(test, 0, tg[0].offset);
|
||||
KUNIT_EXPECT_EQ(test, 2, tg[0].width);
|
||||
KUNIT_EXPECT_EQ(test, 2, tg[0].value);
|
||||
KUNIT_EXPECT_EQ(test, 156, tg[1].offset);
|
||||
KUNIT_EXPECT_EQ(test, 1, tg[1].width);
|
||||
KUNIT_EXPECT_EQ(test, 0, tg[1].value);
|
||||
KUNIT_EXPECT_EQ(test, 0, tg[2].offset);
|
||||
KUNIT_EXPECT_EQ(test, 0, tg[2].width);
|
||||
KUNIT_EXPECT_EQ(test, 0, tg[2].value);
|
||||
|
||||
tg = vcap_keyfield_typegroup(&test_vctrl, VCAP_TYPE_ES2, VCAP_KFS_LL_FULL);
|
||||
KUNIT_EXPECT_PTR_EQ(test, NULL, tg);
|
||||
}
|
||||
|
||||
static void vcap_api_actionfield_typegroup_test(struct kunit *test)
|
||||
{
|
||||
const struct vcap_typegroup *tg;
|
||||
|
||||
tg = vcap_actionfield_typegroup(&test_vctrl, VCAP_TYPE_IS0, VCAP_AFS_FULL);
|
||||
KUNIT_EXPECT_PTR_NE(test, NULL, tg);
|
||||
KUNIT_EXPECT_EQ(test, 0, tg[0].offset);
|
||||
KUNIT_EXPECT_EQ(test, 3, tg[0].width);
|
||||
KUNIT_EXPECT_EQ(test, 4, tg[0].value);
|
||||
KUNIT_EXPECT_EQ(test, 110, tg[1].offset);
|
||||
KUNIT_EXPECT_EQ(test, 2, tg[1].width);
|
||||
KUNIT_EXPECT_EQ(test, 0, tg[1].value);
|
||||
KUNIT_EXPECT_EQ(test, 220, tg[2].offset);
|
||||
KUNIT_EXPECT_EQ(test, 2, tg[2].width);
|
||||
KUNIT_EXPECT_EQ(test, 0, tg[2].value);
|
||||
KUNIT_EXPECT_EQ(test, 0, tg[3].offset);
|
||||
KUNIT_EXPECT_EQ(test, 0, tg[3].width);
|
||||
KUNIT_EXPECT_EQ(test, 0, tg[3].value);
|
||||
|
||||
tg = vcap_actionfield_typegroup(&test_vctrl, VCAP_TYPE_IS2, VCAP_AFS_CLASSIFICATION);
|
||||
KUNIT_EXPECT_PTR_EQ(test, NULL, tg);
|
||||
}
|
||||
|
||||
static void vcap_api_vcap_keyfields_test(struct kunit *test)
|
||||
{
|
||||
const struct vcap_field *ft;
|
||||
|
||||
ft = vcap_keyfields(&test_vctrl, VCAP_TYPE_IS2, VCAP_KFS_MAC_ETYPE);
|
||||
KUNIT_EXPECT_PTR_NE(test, NULL, ft);
|
||||
|
||||
/* Keyset that is not available and within the maximum keyset enum value */
|
||||
ft = vcap_keyfields(&test_vctrl, VCAP_TYPE_ES2, VCAP_KFS_PURE_5TUPLE_IP4);
|
||||
KUNIT_EXPECT_PTR_EQ(test, NULL, ft);
|
||||
|
||||
/* Keyset that is not available and beyond the maximum keyset enum value */
|
||||
ft = vcap_keyfields(&test_vctrl, VCAP_TYPE_ES2, VCAP_KFS_LL_FULL);
|
||||
KUNIT_EXPECT_PTR_EQ(test, NULL, ft);
|
||||
}
|
||||
|
||||
static void vcap_api_vcap_actionfields_test(struct kunit *test)
|
||||
{
|
||||
const struct vcap_field *ft;
|
||||
|
||||
ft = vcap_actionfields(&test_vctrl, VCAP_TYPE_IS0, VCAP_AFS_FULL);
|
||||
KUNIT_EXPECT_PTR_NE(test, NULL, ft);
|
||||
|
||||
ft = vcap_actionfields(&test_vctrl, VCAP_TYPE_IS2, VCAP_AFS_FULL);
|
||||
KUNIT_EXPECT_PTR_EQ(test, NULL, ft);
|
||||
|
||||
ft = vcap_actionfields(&test_vctrl, VCAP_TYPE_IS2, VCAP_AFS_CLASSIFICATION);
|
||||
KUNIT_EXPECT_PTR_EQ(test, NULL, ft);
|
||||
}
|
||||
|
||||
static void vcap_api_encode_rule_keyset_test(struct kunit *test)
|
||||
{
|
||||
u32 keywords[16] = {0};
|
||||
u32 maskwords[16] = {0};
|
||||
struct vcap_admin admin = {
|
||||
.vtype = VCAP_TYPE_IS2,
|
||||
.cache = {
|
||||
.keystream = keywords,
|
||||
.maskstream = maskwords,
|
||||
},
|
||||
};
|
||||
struct vcap_rule_internal rule = {
|
||||
.admin = &admin,
|
||||
.data = {
|
||||
.keyset = VCAP_KFS_MAC_ETYPE,
|
||||
},
|
||||
.vctrl = &test_vctrl,
|
||||
};
|
||||
struct vcap_client_keyfield ckf[] = {
|
||||
{
|
||||
.ctrl.key = VCAP_KF_TYPE,
|
||||
.ctrl.type = VCAP_FIELD_U32,
|
||||
.data.u32.value = 0x00,
|
||||
.data.u32.mask = 0x0f,
|
||||
},
|
||||
{
|
||||
.ctrl.key = VCAP_KF_LOOKUP_FIRST_IS,
|
||||
.ctrl.type = VCAP_FIELD_BIT,
|
||||
.data.u1.value = 0x01,
|
||||
.data.u1.mask = 0x01,
|
||||
},
|
||||
{
|
||||
.ctrl.key = VCAP_KF_IF_IGR_PORT_MASK_L3,
|
||||
.ctrl.type = VCAP_FIELD_BIT,
|
||||
.data.u1.value = 0x00,
|
||||
.data.u1.mask = 0x01,
|
||||
},
|
||||
{
|
||||
.ctrl.key = VCAP_KF_IF_IGR_PORT_MASK_RNG,
|
||||
.ctrl.type = VCAP_FIELD_U32,
|
||||
.data.u32.value = 0x00,
|
||||
.data.u32.mask = 0x0f,
|
||||
},
|
||||
{
|
||||
.ctrl.key = VCAP_KF_IF_IGR_PORT_MASK,
|
||||
.ctrl.type = VCAP_FIELD_U72,
|
||||
.data.u72.value = {0x0, 0x00, 0x00, 0x00},
|
||||
.data.u72.mask = {0xfd, 0xff, 0xff, 0xff},
|
||||
},
|
||||
{
|
||||
.ctrl.key = VCAP_KF_L2_DMAC,
|
||||
.ctrl.type = VCAP_FIELD_U48,
|
||||
/* Opposite endianness */
|
||||
.data.u48.value = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06},
|
||||
.data.u48.mask = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
|
||||
},
|
||||
{
|
||||
.ctrl.key = VCAP_KF_ETYPE_LEN_IS,
|
||||
.ctrl.type = VCAP_FIELD_BIT,
|
||||
.data.u1.value = 0x01,
|
||||
.data.u1.mask = 0x01,
|
||||
},
|
||||
{
|
||||
.ctrl.key = VCAP_KF_ETYPE,
|
||||
.ctrl.type = VCAP_FIELD_U32,
|
||||
.data.u32.value = 0xaabb,
|
||||
.data.u32.mask = 0xffff,
|
||||
},
|
||||
};
|
||||
int idx;
|
||||
int ret;
|
||||
|
||||
/* Empty entry list */
|
||||
INIT_LIST_HEAD(&rule.data.keyfields);
|
||||
ret = vcap_encode_rule_keyset(&rule);
|
||||
KUNIT_EXPECT_EQ(test, -EINVAL, ret);
|
||||
|
||||
for (idx = 0; idx < ARRAY_SIZE(ckf); idx++)
|
||||
list_add_tail(&ckf[idx].ctrl.list, &rule.data.keyfields);
|
||||
ret = vcap_encode_rule_keyset(&rule);
|
||||
KUNIT_EXPECT_EQ(test, 0, ret);
|
||||
|
||||
/* The key and mask values below are from an actual Sparx5 rule config */
|
||||
/* Key */
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x00000042, keywords[0]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x00000000, keywords[1]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x00000000, keywords[2]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x00020100, keywords[3]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x60504030, keywords[4]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x00000000, keywords[5]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x00000000, keywords[6]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x0002aaee, keywords[7]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x00000000, keywords[8]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x00000000, keywords[9]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x00000000, keywords[10]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x00000000, keywords[11]);
|
||||
|
||||
/* Mask: they will be inverted when applied to the register */
|
||||
KUNIT_EXPECT_EQ(test, (u32)~0x00b07f80, maskwords[0]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)~0xfff00000, maskwords[1]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)~0xfffffffc, maskwords[2]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)~0xfff000ff, maskwords[3]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)~0x00000000, maskwords[4]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)~0xfffffff0, maskwords[5]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)~0xfffffffe, maskwords[6]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)~0xfffc0001, maskwords[7]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)~0xffffffff, maskwords[8]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)~0xffffffff, maskwords[9]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)~0xffffffff, maskwords[10]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)~0xffffffff, maskwords[11]);
|
||||
}
|
||||
|
||||
static void vcap_api_encode_rule_actionset_test(struct kunit *test)
|
||||
{
|
||||
u32 actwords[16] = {0};
|
||||
struct vcap_admin admin = {
|
||||
.vtype = VCAP_TYPE_IS2,
|
||||
.cache = {
|
||||
.actionstream = actwords,
|
||||
},
|
||||
};
|
||||
struct vcap_rule_internal rule = {
|
||||
.admin = &admin,
|
||||
.data = {
|
||||
.actionset = VCAP_AFS_BASE_TYPE,
|
||||
},
|
||||
.vctrl = &test_vctrl,
|
||||
};
|
||||
struct vcap_client_actionfield caf[] = {
|
||||
{
|
||||
.ctrl.action = VCAP_AF_MATCH_ID,
|
||||
.ctrl.type = VCAP_FIELD_U32,
|
||||
.data.u32.value = 0x01,
|
||||
},
|
||||
{
|
||||
.ctrl.action = VCAP_AF_MATCH_ID_MASK,
|
||||
.ctrl.type = VCAP_FIELD_U32,
|
||||
.data.u32.value = 0x01,
|
||||
},
|
||||
{
|
||||
.ctrl.action = VCAP_AF_CNT_ID,
|
||||
.ctrl.type = VCAP_FIELD_U32,
|
||||
.data.u32.value = 0x64,
|
||||
},
|
||||
};
|
||||
int idx;
|
||||
int ret;
|
||||
|
||||
/* Empty entry list */
|
||||
INIT_LIST_HEAD(&rule.data.actionfields);
|
||||
ret = vcap_encode_rule_actionset(&rule);
|
||||
/* We allow rules with no actions */
|
||||
KUNIT_EXPECT_EQ(test, 0, ret);
|
||||
|
||||
for (idx = 0; idx < ARRAY_SIZE(caf); idx++)
|
||||
list_add_tail(&caf[idx].ctrl.list, &rule.data.actionfields);
|
||||
ret = vcap_encode_rule_actionset(&rule);
|
||||
KUNIT_EXPECT_EQ(test, 0, ret);
|
||||
|
||||
/* The action values below are from an actual Sparx5 rule config */
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x00000002, actwords[0]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x00000000, actwords[1]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x00000000, actwords[2]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x00000000, actwords[3]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x00000000, actwords[4]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x00100000, actwords[5]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x06400010, actwords[6]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x00000000, actwords[7]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x00000000, actwords[8]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x00000000, actwords[9]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x00000000, actwords[10]);
|
||||
KUNIT_EXPECT_EQ(test, (u32)0x00000000, actwords[11]);
|
||||
}
|
||||
|
||||
static struct kunit_case vcap_api_encoding_test_cases[] = {
|
||||
KUNIT_CASE(vcap_api_set_bit_1_test),
|
||||
KUNIT_CASE(vcap_api_set_bit_0_test),
|
||||
KUNIT_CASE(vcap_api_iterator_init_test),
|
||||
KUNIT_CASE(vcap_api_iterator_next_test),
|
||||
KUNIT_CASE(vcap_api_encode_typegroups_test),
|
||||
KUNIT_CASE(vcap_api_encode_bit_test),
|
||||
KUNIT_CASE(vcap_api_encode_field_test),
|
||||
KUNIT_CASE(vcap_api_encode_short_field_test),
|
||||
KUNIT_CASE(vcap_api_encode_keyfield_test),
|
||||
KUNIT_CASE(vcap_api_encode_max_keyfield_test),
|
||||
KUNIT_CASE(vcap_api_encode_actionfield_test),
|
||||
KUNIT_CASE(vcap_api_keyfield_typegroup_test),
|
||||
KUNIT_CASE(vcap_api_actionfield_typegroup_test),
|
||||
KUNIT_CASE(vcap_api_vcap_keyfields_test),
|
||||
KUNIT_CASE(vcap_api_vcap_actionfields_test),
|
||||
KUNIT_CASE(vcap_api_encode_rule_keyset_test),
|
||||
KUNIT_CASE(vcap_api_encode_rule_actionset_test),
|
||||
{}
|
||||
};
|
||||
|
||||
static struct kunit_suite vcap_api_encoding_test_suite = {
|
||||
.name = "VCAP_API_Encoding_Testsuite",
|
||||
.test_cases = vcap_api_encoding_test_cases,
|
||||
};
|
||||
|
||||
kunit_test_suite(vcap_api_encoding_test_suite);
|
||||
5570
drivers/net/ethernet/microchip/vcap/vcap_model_kunit.c
Normal file
5570
drivers/net/ethernet/microchip/vcap/vcap_model_kunit.c
Normal file
File diff suppressed because it is too large
Load Diff
10
drivers/net/ethernet/microchip/vcap/vcap_model_kunit.h
Normal file
10
drivers/net/ethernet/microchip/vcap/vcap_model_kunit.h
Normal file
@ -0,0 +1,10 @@
|
||||
/* SPDX-License-Identifier: BSD-3-Clause */
|
||||
/* Copyright (C) 2022 Microchip Technology Inc. and its subsidiaries.
|
||||
* Microchip VCAP test model interface for kunit testing
|
||||
*/
|
||||
|
||||
#ifndef __VCAP_MODEL_KUNIT_H__
|
||||
#define __VCAP_MODEL_KUNIT_H__
|
||||
extern const struct vcap_info kunit_test_vcaps[];
|
||||
extern const struct vcap_statistics kunit_test_vcap_stats;
|
||||
#endif /* __VCAP_MODEL_KUNIT_H__ */
|
||||
Loading…
x
Reference in New Issue
Block a user