Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
0002 /* Copyright (c) 2018 Mellanox Technologies. All rights reserved */
0003 
0004 #include <linux/if_bridge.h>
0005 #include <linux/list.h>
0006 #include <linux/mutex.h>
0007 #include <linux/refcount.h>
0008 #include <linux/rtnetlink.h>
0009 #include <linux/workqueue.h>
0010 #include <net/arp.h>
0011 #include <net/gre.h>
0012 #include <net/lag.h>
0013 #include <net/ndisc.h>
0014 #include <net/ip6_tunnel.h>
0015 
0016 #include "spectrum.h"
0017 #include "spectrum_ipip.h"
0018 #include "spectrum_span.h"
0019 #include "spectrum_switchdev.h"
0020 
0021 struct mlxsw_sp_span {
0022     struct work_struct work;
0023     struct mlxsw_sp *mlxsw_sp;
0024     const struct mlxsw_sp_span_trigger_ops **span_trigger_ops_arr;
0025     const struct mlxsw_sp_span_entry_ops **span_entry_ops_arr;
0026     size_t span_entry_ops_arr_size;
0027     struct list_head analyzed_ports_list;
0028     struct mutex analyzed_ports_lock; /* Protects analyzed_ports_list */
0029     struct list_head trigger_entries_list;
0030     u16 policer_id_base;
0031     refcount_t policer_id_base_ref_count;
0032     atomic_t active_entries_count;
0033     int entries_count;
0034     struct mlxsw_sp_span_entry entries[];
0035 };
0036 
0037 struct mlxsw_sp_span_analyzed_port {
0038     struct list_head list; /* Member of analyzed_ports_list */
0039     refcount_t ref_count;
0040     u16 local_port;
0041     bool ingress;
0042 };
0043 
0044 struct mlxsw_sp_span_trigger_entry {
0045     struct list_head list; /* Member of trigger_entries_list */
0046     struct mlxsw_sp_span *span;
0047     const struct mlxsw_sp_span_trigger_ops *ops;
0048     refcount_t ref_count;
0049     u16 local_port;
0050     enum mlxsw_sp_span_trigger trigger;
0051     struct mlxsw_sp_span_trigger_parms parms;
0052 };
0053 
0054 enum mlxsw_sp_span_trigger_type {
0055     MLXSW_SP_SPAN_TRIGGER_TYPE_PORT,
0056     MLXSW_SP_SPAN_TRIGGER_TYPE_GLOBAL,
0057 };
0058 
0059 struct mlxsw_sp_span_trigger_ops {
0060     int (*bind)(struct mlxsw_sp_span_trigger_entry *trigger_entry);
0061     void (*unbind)(struct mlxsw_sp_span_trigger_entry *trigger_entry);
0062     bool (*matches)(struct mlxsw_sp_span_trigger_entry *trigger_entry,
0063             enum mlxsw_sp_span_trigger trigger,
0064             struct mlxsw_sp_port *mlxsw_sp_port);
0065     int (*enable)(struct mlxsw_sp_span_trigger_entry *trigger_entry,
0066               struct mlxsw_sp_port *mlxsw_sp_port, u8 tc);
0067     void (*disable)(struct mlxsw_sp_span_trigger_entry *trigger_entry,
0068             struct mlxsw_sp_port *mlxsw_sp_port, u8 tc);
0069 };
0070 
0071 static void mlxsw_sp_span_respin_work(struct work_struct *work);
0072 
0073 static u64 mlxsw_sp_span_occ_get(void *priv)
0074 {
0075     const struct mlxsw_sp *mlxsw_sp = priv;
0076 
0077     return atomic_read(&mlxsw_sp->span->active_entries_count);
0078 }
0079 
0080 int mlxsw_sp_span_init(struct mlxsw_sp *mlxsw_sp)
0081 {
0082     struct devlink *devlink = priv_to_devlink(mlxsw_sp->core);
0083     struct mlxsw_sp_span *span;
0084     int i, entries_count, err;
0085 
0086     if (!MLXSW_CORE_RES_VALID(mlxsw_sp->core, MAX_SPAN))
0087         return -EIO;
0088 
0089     entries_count = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_SPAN);
0090     span = kzalloc(struct_size(span, entries, entries_count), GFP_KERNEL);
0091     if (!span)
0092         return -ENOMEM;
0093     refcount_set(&span->policer_id_base_ref_count, 0);
0094     span->entries_count = entries_count;
0095     atomic_set(&span->active_entries_count, 0);
0096     mutex_init(&span->analyzed_ports_lock);
0097     INIT_LIST_HEAD(&span->analyzed_ports_list);
0098     INIT_LIST_HEAD(&span->trigger_entries_list);
0099     span->mlxsw_sp = mlxsw_sp;
0100     mlxsw_sp->span = span;
0101 
0102     for (i = 0; i < mlxsw_sp->span->entries_count; i++)
0103         mlxsw_sp->span->entries[i].id = i;
0104 
0105     err = mlxsw_sp->span_ops->init(mlxsw_sp);
0106     if (err)
0107         goto err_init;
0108 
0109     devl_resource_occ_get_register(devlink, MLXSW_SP_RESOURCE_SPAN,
0110                        mlxsw_sp_span_occ_get, mlxsw_sp);
0111     INIT_WORK(&span->work, mlxsw_sp_span_respin_work);
0112 
0113     return 0;
0114 
0115 err_init:
0116     mutex_destroy(&mlxsw_sp->span->analyzed_ports_lock);
0117     kfree(mlxsw_sp->span);
0118     return err;
0119 }
0120 
0121 void mlxsw_sp_span_fini(struct mlxsw_sp *mlxsw_sp)
0122 {
0123     struct devlink *devlink = priv_to_devlink(mlxsw_sp->core);
0124 
0125     cancel_work_sync(&mlxsw_sp->span->work);
0126     devl_resource_occ_get_unregister(devlink, MLXSW_SP_RESOURCE_SPAN);
0127 
0128     WARN_ON_ONCE(!list_empty(&mlxsw_sp->span->trigger_entries_list));
0129     WARN_ON_ONCE(!list_empty(&mlxsw_sp->span->analyzed_ports_list));
0130     mutex_destroy(&mlxsw_sp->span->analyzed_ports_lock);
0131     kfree(mlxsw_sp->span);
0132 }
0133 
0134 static bool mlxsw_sp1_span_cpu_can_handle(const struct net_device *dev)
0135 {
0136     return !dev;
0137 }
0138 
0139 static int mlxsw_sp1_span_entry_cpu_parms(struct mlxsw_sp *mlxsw_sp,
0140                       const struct net_device *to_dev,
0141                       struct mlxsw_sp_span_parms *sparmsp)
0142 {
0143     return -EOPNOTSUPP;
0144 }
0145 
0146 static int
0147 mlxsw_sp1_span_entry_cpu_configure(struct mlxsw_sp_span_entry *span_entry,
0148                    struct mlxsw_sp_span_parms sparms)
0149 {
0150     return -EOPNOTSUPP;
0151 }
0152 
0153 static void
0154 mlxsw_sp1_span_entry_cpu_deconfigure(struct mlxsw_sp_span_entry *span_entry)
0155 {
0156 }
0157 
0158 static const
0159 struct mlxsw_sp_span_entry_ops mlxsw_sp1_span_entry_ops_cpu = {
0160     .is_static = true,
0161     .can_handle = mlxsw_sp1_span_cpu_can_handle,
0162     .parms_set = mlxsw_sp1_span_entry_cpu_parms,
0163     .configure = mlxsw_sp1_span_entry_cpu_configure,
0164     .deconfigure = mlxsw_sp1_span_entry_cpu_deconfigure,
0165 };
0166 
0167 static int
0168 mlxsw_sp_span_entry_phys_parms(struct mlxsw_sp *mlxsw_sp,
0169                    const struct net_device *to_dev,
0170                    struct mlxsw_sp_span_parms *sparmsp)
0171 {
0172     sparmsp->dest_port = netdev_priv(to_dev);
0173     return 0;
0174 }
0175 
0176 static int
0177 mlxsw_sp_span_entry_phys_configure(struct mlxsw_sp_span_entry *span_entry,
0178                    struct mlxsw_sp_span_parms sparms)
0179 {
0180     struct mlxsw_sp_port *dest_port = sparms.dest_port;
0181     struct mlxsw_sp *mlxsw_sp = dest_port->mlxsw_sp;
0182     u16 local_port = dest_port->local_port;
0183     char mpat_pl[MLXSW_REG_MPAT_LEN];
0184     int pa_id = span_entry->id;
0185 
0186     /* Create a new port analayzer entry for local_port. */
0187     mlxsw_reg_mpat_pack(mpat_pl, pa_id, local_port, true,
0188                 MLXSW_REG_MPAT_SPAN_TYPE_LOCAL_ETH);
0189     mlxsw_reg_mpat_session_id_set(mpat_pl, sparms.session_id);
0190     mlxsw_reg_mpat_pide_set(mpat_pl, sparms.policer_enable);
0191     mlxsw_reg_mpat_pid_set(mpat_pl, sparms.policer_id);
0192 
0193     return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(mpat), mpat_pl);
0194 }
0195 
0196 static void
0197 mlxsw_sp_span_entry_deconfigure_common(struct mlxsw_sp_span_entry *span_entry,
0198                        enum mlxsw_reg_mpat_span_type span_type)
0199 {
0200     struct mlxsw_sp_port *dest_port = span_entry->parms.dest_port;
0201     struct mlxsw_sp *mlxsw_sp = dest_port->mlxsw_sp;
0202     u16 local_port = dest_port->local_port;
0203     char mpat_pl[MLXSW_REG_MPAT_LEN];
0204     int pa_id = span_entry->id;
0205 
0206     mlxsw_reg_mpat_pack(mpat_pl, pa_id, local_port, false, span_type);
0207     mlxsw_reg_mpat_session_id_set(mpat_pl, span_entry->parms.session_id);
0208     mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(mpat), mpat_pl);
0209 }
0210 
0211 static void
0212 mlxsw_sp_span_entry_phys_deconfigure(struct mlxsw_sp_span_entry *span_entry)
0213 {
0214     mlxsw_sp_span_entry_deconfigure_common(span_entry,
0215                         MLXSW_REG_MPAT_SPAN_TYPE_LOCAL_ETH);
0216 }
0217 
0218 static const
0219 struct mlxsw_sp_span_entry_ops mlxsw_sp_span_entry_ops_phys = {
0220     .is_static = true,
0221     .can_handle = mlxsw_sp_port_dev_check,
0222     .parms_set = mlxsw_sp_span_entry_phys_parms,
0223     .configure = mlxsw_sp_span_entry_phys_configure,
0224     .deconfigure = mlxsw_sp_span_entry_phys_deconfigure,
0225 };
0226 
0227 static int mlxsw_sp_span_dmac(struct neigh_table *tbl,
0228                   const void *pkey,
0229                   struct net_device *dev,
0230                   unsigned char dmac[ETH_ALEN])
0231 {
0232     struct neighbour *neigh = neigh_lookup(tbl, pkey, dev);
0233     int err = 0;
0234 
0235     if (!neigh) {
0236         neigh = neigh_create(tbl, pkey, dev);
0237         if (IS_ERR(neigh))
0238             return PTR_ERR(neigh);
0239     }
0240 
0241     neigh_event_send(neigh, NULL);
0242 
0243     read_lock_bh(&neigh->lock);
0244     if ((neigh->nud_state & NUD_VALID) && !neigh->dead)
0245         memcpy(dmac, neigh->ha, ETH_ALEN);
0246     else
0247         err = -ENOENT;
0248     read_unlock_bh(&neigh->lock);
0249 
0250     neigh_release(neigh);
0251     return err;
0252 }
0253 
0254 static int
0255 mlxsw_sp_span_entry_unoffloadable(struct mlxsw_sp_span_parms *sparmsp)
0256 {
0257     sparmsp->dest_port = NULL;
0258     return 0;
0259 }
0260 
0261 static struct net_device *
0262 mlxsw_sp_span_entry_bridge_8021q(const struct net_device *br_dev,
0263                  unsigned char *dmac,
0264                  u16 *p_vid)
0265 {
0266     struct bridge_vlan_info vinfo;
0267     struct net_device *edev;
0268     u16 vid = *p_vid;
0269 
0270     if (!vid && WARN_ON(br_vlan_get_pvid(br_dev, &vid)))
0271         return NULL;
0272     if (!vid || br_vlan_get_info(br_dev, vid, &vinfo) ||
0273         !(vinfo.flags & BRIDGE_VLAN_INFO_BRENTRY))
0274         return NULL;
0275 
0276     edev = br_fdb_find_port(br_dev, dmac, vid);
0277     if (!edev)
0278         return NULL;
0279 
0280     if (br_vlan_get_info(edev, vid, &vinfo))
0281         return NULL;
0282     if (vinfo.flags & BRIDGE_VLAN_INFO_UNTAGGED)
0283         *p_vid = 0;
0284     else
0285         *p_vid = vid;
0286     return edev;
0287 }
0288 
0289 static struct net_device *
0290 mlxsw_sp_span_entry_bridge_8021d(const struct net_device *br_dev,
0291                  unsigned char *dmac)
0292 {
0293     return br_fdb_find_port(br_dev, dmac, 0);
0294 }
0295 
0296 static struct net_device *
0297 mlxsw_sp_span_entry_bridge(const struct net_device *br_dev,
0298                unsigned char dmac[ETH_ALEN],
0299                u16 *p_vid)
0300 {
0301     struct mlxsw_sp_bridge_port *bridge_port;
0302     enum mlxsw_reg_spms_state spms_state;
0303     struct net_device *dev = NULL;
0304     struct mlxsw_sp_port *port;
0305     u8 stp_state;
0306 
0307     if (br_vlan_enabled(br_dev))
0308         dev = mlxsw_sp_span_entry_bridge_8021q(br_dev, dmac, p_vid);
0309     else if (!*p_vid)
0310         dev = mlxsw_sp_span_entry_bridge_8021d(br_dev, dmac);
0311     if (!dev)
0312         return NULL;
0313 
0314     port = mlxsw_sp_port_dev_lower_find(dev);
0315     if (!port)
0316         return NULL;
0317 
0318     bridge_port = mlxsw_sp_bridge_port_find(port->mlxsw_sp->bridge, dev);
0319     if (!bridge_port)
0320         return NULL;
0321 
0322     stp_state = mlxsw_sp_bridge_port_stp_state(bridge_port);
0323     spms_state = mlxsw_sp_stp_spms_state(stp_state);
0324     if (spms_state != MLXSW_REG_SPMS_STATE_FORWARDING)
0325         return NULL;
0326 
0327     return dev;
0328 }
0329 
0330 static struct net_device *
0331 mlxsw_sp_span_entry_vlan(const struct net_device *vlan_dev,
0332              u16 *p_vid)
0333 {
0334     *p_vid = vlan_dev_vlan_id(vlan_dev);
0335     return vlan_dev_real_dev(vlan_dev);
0336 }
0337 
0338 static struct net_device *
0339 mlxsw_sp_span_entry_lag(struct net_device *lag_dev)
0340 {
0341     struct net_device *dev;
0342     struct list_head *iter;
0343 
0344     netdev_for_each_lower_dev(lag_dev, dev, iter)
0345         if (netif_carrier_ok(dev) &&
0346             net_lag_port_dev_txable(dev) &&
0347             mlxsw_sp_port_dev_check(dev))
0348             return dev;
0349 
0350     return NULL;
0351 }
0352 
0353 static __maybe_unused int
0354 mlxsw_sp_span_entry_tunnel_parms_common(struct net_device *edev,
0355                     union mlxsw_sp_l3addr saddr,
0356                     union mlxsw_sp_l3addr daddr,
0357                     union mlxsw_sp_l3addr gw,
0358                     __u8 ttl,
0359                     struct neigh_table *tbl,
0360                     struct mlxsw_sp_span_parms *sparmsp)
0361 {
0362     unsigned char dmac[ETH_ALEN];
0363     u16 vid = 0;
0364 
0365     if (mlxsw_sp_l3addr_is_zero(gw))
0366         gw = daddr;
0367 
0368     if (!edev || mlxsw_sp_span_dmac(tbl, &gw, edev, dmac))
0369         goto unoffloadable;
0370 
0371     if (is_vlan_dev(edev))
0372         edev = mlxsw_sp_span_entry_vlan(edev, &vid);
0373 
0374     if (netif_is_bridge_master(edev)) {
0375         edev = mlxsw_sp_span_entry_bridge(edev, dmac, &vid);
0376         if (!edev)
0377             goto unoffloadable;
0378     }
0379 
0380     if (is_vlan_dev(edev)) {
0381         if (vid || !(edev->flags & IFF_UP))
0382             goto unoffloadable;
0383         edev = mlxsw_sp_span_entry_vlan(edev, &vid);
0384     }
0385 
0386     if (netif_is_lag_master(edev)) {
0387         if (!(edev->flags & IFF_UP))
0388             goto unoffloadable;
0389         edev = mlxsw_sp_span_entry_lag(edev);
0390         if (!edev)
0391             goto unoffloadable;
0392     }
0393 
0394     if (!mlxsw_sp_port_dev_check(edev))
0395         goto unoffloadable;
0396 
0397     sparmsp->dest_port = netdev_priv(edev);
0398     sparmsp->ttl = ttl;
0399     memcpy(sparmsp->dmac, dmac, ETH_ALEN);
0400     memcpy(sparmsp->smac, edev->dev_addr, ETH_ALEN);
0401     sparmsp->saddr = saddr;
0402     sparmsp->daddr = daddr;
0403     sparmsp->vid = vid;
0404     return 0;
0405 
0406 unoffloadable:
0407     return mlxsw_sp_span_entry_unoffloadable(sparmsp);
0408 }
0409 
0410 #if IS_ENABLED(CONFIG_NET_IPGRE)
0411 static struct net_device *
0412 mlxsw_sp_span_gretap4_route(const struct net_device *to_dev,
0413                 __be32 *saddrp, __be32 *daddrp)
0414 {
0415     struct ip_tunnel *tun = netdev_priv(to_dev);
0416     struct net_device *dev = NULL;
0417     struct ip_tunnel_parm parms;
0418     struct rtable *rt = NULL;
0419     struct flowi4 fl4;
0420 
0421     /* We assume "dev" stays valid after rt is put. */
0422     ASSERT_RTNL();
0423 
0424     parms = mlxsw_sp_ipip_netdev_parms4(to_dev);
0425     ip_tunnel_init_flow(&fl4, parms.iph.protocol, *daddrp, *saddrp,
0426                 0, 0, dev_net(to_dev), parms.link, tun->fwmark, 0,
0427                 0);
0428 
0429     rt = ip_route_output_key(tun->net, &fl4);
0430     if (IS_ERR(rt))
0431         return NULL;
0432 
0433     if (rt->rt_type != RTN_UNICAST)
0434         goto out;
0435 
0436     dev = rt->dst.dev;
0437     *saddrp = fl4.saddr;
0438     if (rt->rt_gw_family == AF_INET)
0439         *daddrp = rt->rt_gw4;
0440     /* can not offload if route has an IPv6 gateway */
0441     else if (rt->rt_gw_family == AF_INET6)
0442         dev = NULL;
0443 
0444 out:
0445     ip_rt_put(rt);
0446     return dev;
0447 }
0448 
0449 static int
0450 mlxsw_sp_span_entry_gretap4_parms(struct mlxsw_sp *mlxsw_sp,
0451                   const struct net_device *to_dev,
0452                   struct mlxsw_sp_span_parms *sparmsp)
0453 {
0454     struct ip_tunnel_parm tparm = mlxsw_sp_ipip_netdev_parms4(to_dev);
0455     union mlxsw_sp_l3addr saddr = { .addr4 = tparm.iph.saddr };
0456     union mlxsw_sp_l3addr daddr = { .addr4 = tparm.iph.daddr };
0457     bool inherit_tos = tparm.iph.tos & 0x1;
0458     bool inherit_ttl = !tparm.iph.ttl;
0459     union mlxsw_sp_l3addr gw = daddr;
0460     struct net_device *l3edev;
0461 
0462     if (!(to_dev->flags & IFF_UP) ||
0463         /* Reject tunnels with GRE keys, checksums, etc. */
0464         tparm.i_flags || tparm.o_flags ||
0465         /* Require a fixed TTL and a TOS copied from the mirrored packet. */
0466         inherit_ttl || !inherit_tos ||
0467         /* A destination address may not be "any". */
0468         mlxsw_sp_l3addr_is_zero(daddr))
0469         return mlxsw_sp_span_entry_unoffloadable(sparmsp);
0470 
0471     l3edev = mlxsw_sp_span_gretap4_route(to_dev, &saddr.addr4, &gw.addr4);
0472     return mlxsw_sp_span_entry_tunnel_parms_common(l3edev, saddr, daddr, gw,
0473                                tparm.iph.ttl,
0474                                &arp_tbl, sparmsp);
0475 }
0476 
0477 static int
0478 mlxsw_sp_span_entry_gretap4_configure(struct mlxsw_sp_span_entry *span_entry,
0479                       struct mlxsw_sp_span_parms sparms)
0480 {
0481     struct mlxsw_sp_port *dest_port = sparms.dest_port;
0482     struct mlxsw_sp *mlxsw_sp = dest_port->mlxsw_sp;
0483     u16 local_port = dest_port->local_port;
0484     char mpat_pl[MLXSW_REG_MPAT_LEN];
0485     int pa_id = span_entry->id;
0486 
0487     /* Create a new port analayzer entry for local_port. */
0488     mlxsw_reg_mpat_pack(mpat_pl, pa_id, local_port, true,
0489                 MLXSW_REG_MPAT_SPAN_TYPE_REMOTE_ETH_L3);
0490     mlxsw_reg_mpat_pide_set(mpat_pl, sparms.policer_enable);
0491     mlxsw_reg_mpat_pid_set(mpat_pl, sparms.policer_id);
0492     mlxsw_reg_mpat_eth_rspan_pack(mpat_pl, sparms.vid);
0493     mlxsw_reg_mpat_eth_rspan_l2_pack(mpat_pl,
0494                     MLXSW_REG_MPAT_ETH_RSPAN_VERSION_NO_HEADER,
0495                     sparms.dmac, !!sparms.vid);
0496     mlxsw_reg_mpat_eth_rspan_l3_ipv4_pack(mpat_pl,
0497                           sparms.ttl, sparms.smac,
0498                           be32_to_cpu(sparms.saddr.addr4),
0499                           be32_to_cpu(sparms.daddr.addr4));
0500 
0501     return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(mpat), mpat_pl);
0502 }
0503 
0504 static void
0505 mlxsw_sp_span_entry_gretap4_deconfigure(struct mlxsw_sp_span_entry *span_entry)
0506 {
0507     mlxsw_sp_span_entry_deconfigure_common(span_entry,
0508                     MLXSW_REG_MPAT_SPAN_TYPE_REMOTE_ETH_L3);
0509 }
0510 
0511 static const struct mlxsw_sp_span_entry_ops mlxsw_sp_span_entry_ops_gretap4 = {
0512     .can_handle = netif_is_gretap,
0513     .parms_set = mlxsw_sp_span_entry_gretap4_parms,
0514     .configure = mlxsw_sp_span_entry_gretap4_configure,
0515     .deconfigure = mlxsw_sp_span_entry_gretap4_deconfigure,
0516 };
0517 #endif
0518 
0519 #if IS_ENABLED(CONFIG_IPV6_GRE)
0520 static struct net_device *
0521 mlxsw_sp_span_gretap6_route(const struct net_device *to_dev,
0522                 struct in6_addr *saddrp,
0523                 struct in6_addr *daddrp)
0524 {
0525     struct ip6_tnl *t = netdev_priv(to_dev);
0526     struct flowi6 fl6 = t->fl.u.ip6;
0527     struct net_device *dev = NULL;
0528     struct dst_entry *dst;
0529     struct rt6_info *rt6;
0530 
0531     /* We assume "dev" stays valid after dst is released. */
0532     ASSERT_RTNL();
0533 
0534     fl6.flowi6_mark = t->parms.fwmark;
0535     if (!ip6_tnl_xmit_ctl(t, &fl6.saddr, &fl6.daddr))
0536         return NULL;
0537 
0538     dst = ip6_route_output(t->net, NULL, &fl6);
0539     if (!dst || dst->error)
0540         goto out;
0541 
0542     rt6 = container_of(dst, struct rt6_info, dst);
0543 
0544     dev = dst->dev;
0545     *saddrp = fl6.saddr;
0546     *daddrp = rt6->rt6i_gateway;
0547 
0548 out:
0549     dst_release(dst);
0550     return dev;
0551 }
0552 
0553 static int
0554 mlxsw_sp_span_entry_gretap6_parms(struct mlxsw_sp *mlxsw_sp,
0555                   const struct net_device *to_dev,
0556                   struct mlxsw_sp_span_parms *sparmsp)
0557 {
0558     struct __ip6_tnl_parm tparm = mlxsw_sp_ipip_netdev_parms6(to_dev);
0559     bool inherit_tos = tparm.flags & IP6_TNL_F_USE_ORIG_TCLASS;
0560     union mlxsw_sp_l3addr saddr = { .addr6 = tparm.laddr };
0561     union mlxsw_sp_l3addr daddr = { .addr6 = tparm.raddr };
0562     bool inherit_ttl = !tparm.hop_limit;
0563     union mlxsw_sp_l3addr gw = daddr;
0564     struct net_device *l3edev;
0565 
0566     if (!(to_dev->flags & IFF_UP) ||
0567         /* Reject tunnels with GRE keys, checksums, etc. */
0568         tparm.i_flags || tparm.o_flags ||
0569         /* Require a fixed TTL and a TOS copied from the mirrored packet. */
0570         inherit_ttl || !inherit_tos ||
0571         /* A destination address may not be "any". */
0572         mlxsw_sp_l3addr_is_zero(daddr))
0573         return mlxsw_sp_span_entry_unoffloadable(sparmsp);
0574 
0575     l3edev = mlxsw_sp_span_gretap6_route(to_dev, &saddr.addr6, &gw.addr6);
0576     return mlxsw_sp_span_entry_tunnel_parms_common(l3edev, saddr, daddr, gw,
0577                                tparm.hop_limit,
0578                                &nd_tbl, sparmsp);
0579 }
0580 
0581 static int
0582 mlxsw_sp_span_entry_gretap6_configure(struct mlxsw_sp_span_entry *span_entry,
0583                       struct mlxsw_sp_span_parms sparms)
0584 {
0585     struct mlxsw_sp_port *dest_port = sparms.dest_port;
0586     struct mlxsw_sp *mlxsw_sp = dest_port->mlxsw_sp;
0587     u16 local_port = dest_port->local_port;
0588     char mpat_pl[MLXSW_REG_MPAT_LEN];
0589     int pa_id = span_entry->id;
0590 
0591     /* Create a new port analayzer entry for local_port. */
0592     mlxsw_reg_mpat_pack(mpat_pl, pa_id, local_port, true,
0593                 MLXSW_REG_MPAT_SPAN_TYPE_REMOTE_ETH_L3);
0594     mlxsw_reg_mpat_pide_set(mpat_pl, sparms.policer_enable);
0595     mlxsw_reg_mpat_pid_set(mpat_pl, sparms.policer_id);
0596     mlxsw_reg_mpat_eth_rspan_pack(mpat_pl, sparms.vid);
0597     mlxsw_reg_mpat_eth_rspan_l2_pack(mpat_pl,
0598                     MLXSW_REG_MPAT_ETH_RSPAN_VERSION_NO_HEADER,
0599                     sparms.dmac, !!sparms.vid);
0600     mlxsw_reg_mpat_eth_rspan_l3_ipv6_pack(mpat_pl, sparms.ttl, sparms.smac,
0601                           sparms.saddr.addr6,
0602                           sparms.daddr.addr6);
0603 
0604     return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(mpat), mpat_pl);
0605 }
0606 
0607 static void
0608 mlxsw_sp_span_entry_gretap6_deconfigure(struct mlxsw_sp_span_entry *span_entry)
0609 {
0610     mlxsw_sp_span_entry_deconfigure_common(span_entry,
0611                     MLXSW_REG_MPAT_SPAN_TYPE_REMOTE_ETH_L3);
0612 }
0613 
0614 static const
0615 struct mlxsw_sp_span_entry_ops mlxsw_sp_span_entry_ops_gretap6 = {
0616     .can_handle = netif_is_ip6gretap,
0617     .parms_set = mlxsw_sp_span_entry_gretap6_parms,
0618     .configure = mlxsw_sp_span_entry_gretap6_configure,
0619     .deconfigure = mlxsw_sp_span_entry_gretap6_deconfigure,
0620 };
0621 #endif
0622 
0623 static bool
0624 mlxsw_sp_span_vlan_can_handle(const struct net_device *dev)
0625 {
0626     return is_vlan_dev(dev) &&
0627            mlxsw_sp_port_dev_check(vlan_dev_real_dev(dev));
0628 }
0629 
0630 static int
0631 mlxsw_sp_span_entry_vlan_parms(struct mlxsw_sp *mlxsw_sp,
0632                    const struct net_device *to_dev,
0633                    struct mlxsw_sp_span_parms *sparmsp)
0634 {
0635     struct net_device *real_dev;
0636     u16 vid;
0637 
0638     if (!(to_dev->flags & IFF_UP))
0639         return mlxsw_sp_span_entry_unoffloadable(sparmsp);
0640 
0641     real_dev = mlxsw_sp_span_entry_vlan(to_dev, &vid);
0642     sparmsp->dest_port = netdev_priv(real_dev);
0643     sparmsp->vid = vid;
0644     return 0;
0645 }
0646 
0647 static int
0648 mlxsw_sp_span_entry_vlan_configure(struct mlxsw_sp_span_entry *span_entry,
0649                    struct mlxsw_sp_span_parms sparms)
0650 {
0651     struct mlxsw_sp_port *dest_port = sparms.dest_port;
0652     struct mlxsw_sp *mlxsw_sp = dest_port->mlxsw_sp;
0653     u16 local_port = dest_port->local_port;
0654     char mpat_pl[MLXSW_REG_MPAT_LEN];
0655     int pa_id = span_entry->id;
0656 
0657     mlxsw_reg_mpat_pack(mpat_pl, pa_id, local_port, true,
0658                 MLXSW_REG_MPAT_SPAN_TYPE_REMOTE_ETH);
0659     mlxsw_reg_mpat_pide_set(mpat_pl, sparms.policer_enable);
0660     mlxsw_reg_mpat_pid_set(mpat_pl, sparms.policer_id);
0661     mlxsw_reg_mpat_eth_rspan_pack(mpat_pl, sparms.vid);
0662 
0663     return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(mpat), mpat_pl);
0664 }
0665 
0666 static void
0667 mlxsw_sp_span_entry_vlan_deconfigure(struct mlxsw_sp_span_entry *span_entry)
0668 {
0669     mlxsw_sp_span_entry_deconfigure_common(span_entry,
0670                     MLXSW_REG_MPAT_SPAN_TYPE_REMOTE_ETH);
0671 }
0672 
0673 static const
0674 struct mlxsw_sp_span_entry_ops mlxsw_sp_span_entry_ops_vlan = {
0675     .can_handle = mlxsw_sp_span_vlan_can_handle,
0676     .parms_set = mlxsw_sp_span_entry_vlan_parms,
0677     .configure = mlxsw_sp_span_entry_vlan_configure,
0678     .deconfigure = mlxsw_sp_span_entry_vlan_deconfigure,
0679 };
0680 
0681 static const
0682 struct mlxsw_sp_span_entry_ops *mlxsw_sp1_span_entry_ops_arr[] = {
0683     &mlxsw_sp1_span_entry_ops_cpu,
0684     &mlxsw_sp_span_entry_ops_phys,
0685 #if IS_ENABLED(CONFIG_NET_IPGRE)
0686     &mlxsw_sp_span_entry_ops_gretap4,
0687 #endif
0688 #if IS_ENABLED(CONFIG_IPV6_GRE)
0689     &mlxsw_sp_span_entry_ops_gretap6,
0690 #endif
0691     &mlxsw_sp_span_entry_ops_vlan,
0692 };
0693 
0694 static bool mlxsw_sp2_span_cpu_can_handle(const struct net_device *dev)
0695 {
0696     return !dev;
0697 }
0698 
0699 static int mlxsw_sp2_span_entry_cpu_parms(struct mlxsw_sp *mlxsw_sp,
0700                       const struct net_device *to_dev,
0701                       struct mlxsw_sp_span_parms *sparmsp)
0702 {
0703     sparmsp->dest_port = mlxsw_sp->ports[MLXSW_PORT_CPU_PORT];
0704     return 0;
0705 }
0706 
0707 static int
0708 mlxsw_sp2_span_entry_cpu_configure(struct mlxsw_sp_span_entry *span_entry,
0709                    struct mlxsw_sp_span_parms sparms)
0710 {
0711     /* Mirroring to the CPU port is like mirroring to any other physical
0712      * port. Its local port is used instead of that of the physical port.
0713      */
0714     return mlxsw_sp_span_entry_phys_configure(span_entry, sparms);
0715 }
0716 
0717 static void
0718 mlxsw_sp2_span_entry_cpu_deconfigure(struct mlxsw_sp_span_entry *span_entry)
0719 {
0720     enum mlxsw_reg_mpat_span_type span_type;
0721 
0722     span_type = MLXSW_REG_MPAT_SPAN_TYPE_LOCAL_ETH;
0723     mlxsw_sp_span_entry_deconfigure_common(span_entry, span_type);
0724 }
0725 
0726 static const
0727 struct mlxsw_sp_span_entry_ops mlxsw_sp2_span_entry_ops_cpu = {
0728     .is_static = true,
0729     .can_handle = mlxsw_sp2_span_cpu_can_handle,
0730     .parms_set = mlxsw_sp2_span_entry_cpu_parms,
0731     .configure = mlxsw_sp2_span_entry_cpu_configure,
0732     .deconfigure = mlxsw_sp2_span_entry_cpu_deconfigure,
0733 };
0734 
0735 static const
0736 struct mlxsw_sp_span_entry_ops *mlxsw_sp2_span_entry_ops_arr[] = {
0737     &mlxsw_sp2_span_entry_ops_cpu,
0738     &mlxsw_sp_span_entry_ops_phys,
0739 #if IS_ENABLED(CONFIG_NET_IPGRE)
0740     &mlxsw_sp_span_entry_ops_gretap4,
0741 #endif
0742 #if IS_ENABLED(CONFIG_IPV6_GRE)
0743     &mlxsw_sp_span_entry_ops_gretap6,
0744 #endif
0745     &mlxsw_sp_span_entry_ops_vlan,
0746 };
0747 
0748 static int
0749 mlxsw_sp_span_entry_nop_parms(struct mlxsw_sp *mlxsw_sp,
0750                   const struct net_device *to_dev,
0751                   struct mlxsw_sp_span_parms *sparmsp)
0752 {
0753     return mlxsw_sp_span_entry_unoffloadable(sparmsp);
0754 }
0755 
0756 static int
0757 mlxsw_sp_span_entry_nop_configure(struct mlxsw_sp_span_entry *span_entry,
0758                   struct mlxsw_sp_span_parms sparms)
0759 {
0760     return 0;
0761 }
0762 
0763 static void
0764 mlxsw_sp_span_entry_nop_deconfigure(struct mlxsw_sp_span_entry *span_entry)
0765 {
0766 }
0767 
0768 static const struct mlxsw_sp_span_entry_ops mlxsw_sp_span_entry_ops_nop = {
0769     .parms_set = mlxsw_sp_span_entry_nop_parms,
0770     .configure = mlxsw_sp_span_entry_nop_configure,
0771     .deconfigure = mlxsw_sp_span_entry_nop_deconfigure,
0772 };
0773 
0774 static void
0775 mlxsw_sp_span_entry_configure(struct mlxsw_sp *mlxsw_sp,
0776                   struct mlxsw_sp_span_entry *span_entry,
0777                   struct mlxsw_sp_span_parms sparms)
0778 {
0779     int err;
0780 
0781     if (!sparms.dest_port)
0782         goto set_parms;
0783 
0784     if (sparms.dest_port->mlxsw_sp != mlxsw_sp) {
0785         dev_err(mlxsw_sp->bus_info->dev,
0786             "Cannot mirror to a port which belongs to a different mlxsw instance\n");
0787         sparms.dest_port = NULL;
0788         goto set_parms;
0789     }
0790 
0791     err = span_entry->ops->configure(span_entry, sparms);
0792     if (err) {
0793         dev_err(mlxsw_sp->bus_info->dev, "Failed to offload mirror\n");
0794         sparms.dest_port = NULL;
0795         goto set_parms;
0796     }
0797 
0798 set_parms:
0799     span_entry->parms = sparms;
0800 }
0801 
0802 static void
0803 mlxsw_sp_span_entry_deconfigure(struct mlxsw_sp_span_entry *span_entry)
0804 {
0805     if (span_entry->parms.dest_port)
0806         span_entry->ops->deconfigure(span_entry);
0807 }
0808 
0809 static int mlxsw_sp_span_policer_id_base_set(struct mlxsw_sp_span *span,
0810                          u16 policer_id)
0811 {
0812     struct mlxsw_sp *mlxsw_sp = span->mlxsw_sp;
0813     u16 policer_id_base;
0814     int err;
0815 
0816     /* Policers set on SPAN agents must be in the range of
0817      * `policer_id_base .. policer_id_base + max_span_agents - 1`. If the
0818      * base is set and the new policer is not within the range, then we
0819      * must error out.
0820      */
0821     if (refcount_read(&span->policer_id_base_ref_count)) {
0822         if (policer_id < span->policer_id_base ||
0823             policer_id >= span->policer_id_base + span->entries_count)
0824             return -EINVAL;
0825 
0826         refcount_inc(&span->policer_id_base_ref_count);
0827         return 0;
0828     }
0829 
0830     /* Base must be even. */
0831     policer_id_base = policer_id % 2 == 0 ? policer_id : policer_id - 1;
0832     err = mlxsw_sp->span_ops->policer_id_base_set(mlxsw_sp,
0833                               policer_id_base);
0834     if (err)
0835         return err;
0836 
0837     span->policer_id_base = policer_id_base;
0838     refcount_set(&span->policer_id_base_ref_count, 1);
0839 
0840     return 0;
0841 }
0842 
0843 static void mlxsw_sp_span_policer_id_base_unset(struct mlxsw_sp_span *span)
0844 {
0845     if (refcount_dec_and_test(&span->policer_id_base_ref_count))
0846         span->policer_id_base = 0;
0847 }
0848 
0849 static struct mlxsw_sp_span_entry *
0850 mlxsw_sp_span_entry_create(struct mlxsw_sp *mlxsw_sp,
0851                const struct net_device *to_dev,
0852                const struct mlxsw_sp_span_entry_ops *ops,
0853                struct mlxsw_sp_span_parms sparms)
0854 {
0855     struct mlxsw_sp_span_entry *span_entry = NULL;
0856     int i;
0857 
0858     /* find a free entry to use */
0859     for (i = 0; i < mlxsw_sp->span->entries_count; i++) {
0860         if (!refcount_read(&mlxsw_sp->span->entries[i].ref_count)) {
0861             span_entry = &mlxsw_sp->span->entries[i];
0862             break;
0863         }
0864     }
0865     if (!span_entry)
0866         return NULL;
0867 
0868     if (sparms.policer_enable) {
0869         int err;
0870 
0871         err = mlxsw_sp_span_policer_id_base_set(mlxsw_sp->span,
0872                             sparms.policer_id);
0873         if (err)
0874             return NULL;
0875     }
0876 
0877     atomic_inc(&mlxsw_sp->span->active_entries_count);
0878     span_entry->ops = ops;
0879     refcount_set(&span_entry->ref_count, 1);
0880     span_entry->to_dev = to_dev;
0881     mlxsw_sp_span_entry_configure(mlxsw_sp, span_entry, sparms);
0882 
0883     return span_entry;
0884 }
0885 
0886 static void mlxsw_sp_span_entry_destroy(struct mlxsw_sp *mlxsw_sp,
0887                     struct mlxsw_sp_span_entry *span_entry)
0888 {
0889     mlxsw_sp_span_entry_deconfigure(span_entry);
0890     atomic_dec(&mlxsw_sp->span->active_entries_count);
0891     if (span_entry->parms.policer_enable)
0892         mlxsw_sp_span_policer_id_base_unset(mlxsw_sp->span);
0893 }
0894 
0895 struct mlxsw_sp_span_entry *
0896 mlxsw_sp_span_entry_find_by_port(struct mlxsw_sp *mlxsw_sp,
0897                  const struct net_device *to_dev)
0898 {
0899     int i;
0900 
0901     for (i = 0; i < mlxsw_sp->span->entries_count; i++) {
0902         struct mlxsw_sp_span_entry *curr = &mlxsw_sp->span->entries[i];
0903 
0904         if (refcount_read(&curr->ref_count) && curr->to_dev == to_dev)
0905             return curr;
0906     }
0907     return NULL;
0908 }
0909 
0910 void mlxsw_sp_span_entry_invalidate(struct mlxsw_sp *mlxsw_sp,
0911                     struct mlxsw_sp_span_entry *span_entry)
0912 {
0913     mlxsw_sp_span_entry_deconfigure(span_entry);
0914     span_entry->ops = &mlxsw_sp_span_entry_ops_nop;
0915 }
0916 
0917 static struct mlxsw_sp_span_entry *
0918 mlxsw_sp_span_entry_find_by_id(struct mlxsw_sp *mlxsw_sp, int span_id)
0919 {
0920     int i;
0921 
0922     for (i = 0; i < mlxsw_sp->span->entries_count; i++) {
0923         struct mlxsw_sp_span_entry *curr = &mlxsw_sp->span->entries[i];
0924 
0925         if (refcount_read(&curr->ref_count) && curr->id == span_id)
0926             return curr;
0927     }
0928     return NULL;
0929 }
0930 
0931 static struct mlxsw_sp_span_entry *
0932 mlxsw_sp_span_entry_find_by_parms(struct mlxsw_sp *mlxsw_sp,
0933                   const struct net_device *to_dev,
0934                   const struct mlxsw_sp_span_parms *sparms)
0935 {
0936     int i;
0937 
0938     for (i = 0; i < mlxsw_sp->span->entries_count; i++) {
0939         struct mlxsw_sp_span_entry *curr = &mlxsw_sp->span->entries[i];
0940 
0941         if (refcount_read(&curr->ref_count) && curr->to_dev == to_dev &&
0942             curr->parms.policer_enable == sparms->policer_enable &&
0943             curr->parms.policer_id == sparms->policer_id &&
0944             curr->parms.session_id == sparms->session_id)
0945             return curr;
0946     }
0947     return NULL;
0948 }
0949 
0950 static struct mlxsw_sp_span_entry *
0951 mlxsw_sp_span_entry_get(struct mlxsw_sp *mlxsw_sp,
0952             const struct net_device *to_dev,
0953             const struct mlxsw_sp_span_entry_ops *ops,
0954             struct mlxsw_sp_span_parms sparms)
0955 {
0956     struct mlxsw_sp_span_entry *span_entry;
0957 
0958     span_entry = mlxsw_sp_span_entry_find_by_parms(mlxsw_sp, to_dev,
0959                                &sparms);
0960     if (span_entry) {
0961         /* Already exists, just take a reference */
0962         refcount_inc(&span_entry->ref_count);
0963         return span_entry;
0964     }
0965 
0966     return mlxsw_sp_span_entry_create(mlxsw_sp, to_dev, ops, sparms);
0967 }
0968 
0969 static int mlxsw_sp_span_entry_put(struct mlxsw_sp *mlxsw_sp,
0970                    struct mlxsw_sp_span_entry *span_entry)
0971 {
0972     if (refcount_dec_and_test(&span_entry->ref_count))
0973         mlxsw_sp_span_entry_destroy(mlxsw_sp, span_entry);
0974     return 0;
0975 }
0976 
0977 static int mlxsw_sp_span_port_buffer_update(struct mlxsw_sp_port *mlxsw_sp_port, bool enable)
0978 {
0979     struct mlxsw_sp_hdroom hdroom;
0980 
0981     hdroom = *mlxsw_sp_port->hdroom;
0982     hdroom.int_buf.enable = enable;
0983     mlxsw_sp_hdroom_bufs_reset_sizes(mlxsw_sp_port, &hdroom);
0984 
0985     return mlxsw_sp_hdroom_configure(mlxsw_sp_port, &hdroom);
0986 }
0987 
0988 static int
0989 mlxsw_sp_span_port_buffer_enable(struct mlxsw_sp_port *mlxsw_sp_port)
0990 {
0991     return mlxsw_sp_span_port_buffer_update(mlxsw_sp_port, true);
0992 }
0993 
0994 static void mlxsw_sp_span_port_buffer_disable(struct mlxsw_sp_port *mlxsw_sp_port)
0995 {
0996     mlxsw_sp_span_port_buffer_update(mlxsw_sp_port, false);
0997 }
0998 
0999 static struct mlxsw_sp_span_analyzed_port *
1000 mlxsw_sp_span_analyzed_port_find(struct mlxsw_sp_span *span, u16 local_port,
1001                  bool ingress)
1002 {
1003     struct mlxsw_sp_span_analyzed_port *analyzed_port;
1004 
1005     list_for_each_entry(analyzed_port, &span->analyzed_ports_list, list) {
1006         if (analyzed_port->local_port == local_port &&
1007             analyzed_port->ingress == ingress)
1008             return analyzed_port;
1009     }
1010 
1011     return NULL;
1012 }
1013 
1014 static const struct mlxsw_sp_span_entry_ops *
1015 mlxsw_sp_span_entry_ops(struct mlxsw_sp *mlxsw_sp,
1016             const struct net_device *to_dev)
1017 {
1018     struct mlxsw_sp_span *span = mlxsw_sp->span;
1019     size_t i;
1020 
1021     for (i = 0; i < span->span_entry_ops_arr_size; ++i)
1022         if (span->span_entry_ops_arr[i]->can_handle(to_dev))
1023             return span->span_entry_ops_arr[i];
1024 
1025     return NULL;
1026 }
1027 
1028 static void mlxsw_sp_span_respin_work(struct work_struct *work)
1029 {
1030     struct mlxsw_sp_span *span;
1031     struct mlxsw_sp *mlxsw_sp;
1032     int i, err;
1033 
1034     span = container_of(work, struct mlxsw_sp_span, work);
1035     mlxsw_sp = span->mlxsw_sp;
1036 
1037     rtnl_lock();
1038     for (i = 0; i < mlxsw_sp->span->entries_count; i++) {
1039         struct mlxsw_sp_span_entry *curr = &mlxsw_sp->span->entries[i];
1040         struct mlxsw_sp_span_parms sparms = {NULL};
1041 
1042         if (!refcount_read(&curr->ref_count))
1043             continue;
1044 
1045         if (curr->ops->is_static)
1046             continue;
1047 
1048         err = curr->ops->parms_set(mlxsw_sp, curr->to_dev, &sparms);
1049         if (err)
1050             continue;
1051 
1052         if (memcmp(&sparms, &curr->parms, sizeof(sparms))) {
1053             mlxsw_sp_span_entry_deconfigure(curr);
1054             mlxsw_sp_span_entry_configure(mlxsw_sp, curr, sparms);
1055         }
1056     }
1057     rtnl_unlock();
1058 }
1059 
1060 void mlxsw_sp_span_respin(struct mlxsw_sp *mlxsw_sp)
1061 {
1062     if (atomic_read(&mlxsw_sp->span->active_entries_count) == 0)
1063         return;
1064     mlxsw_core_schedule_work(&mlxsw_sp->span->work);
1065 }
1066 
1067 int mlxsw_sp_span_agent_get(struct mlxsw_sp *mlxsw_sp, int *p_span_id,
1068                 const struct mlxsw_sp_span_agent_parms *parms)
1069 {
1070     const struct net_device *to_dev = parms->to_dev;
1071     const struct mlxsw_sp_span_entry_ops *ops;
1072     struct mlxsw_sp_span_entry *span_entry;
1073     struct mlxsw_sp_span_parms sparms;
1074     int err;
1075 
1076     ASSERT_RTNL();
1077 
1078     ops = mlxsw_sp_span_entry_ops(mlxsw_sp, to_dev);
1079     if (!ops) {
1080         dev_err(mlxsw_sp->bus_info->dev, "Cannot mirror to requested destination\n");
1081         return -EOPNOTSUPP;
1082     }
1083 
1084     memset(&sparms, 0, sizeof(sparms));
1085     err = ops->parms_set(mlxsw_sp, to_dev, &sparms);
1086     if (err)
1087         return err;
1088 
1089     sparms.policer_id = parms->policer_id;
1090     sparms.policer_enable = parms->policer_enable;
1091     sparms.session_id = parms->session_id;
1092     span_entry = mlxsw_sp_span_entry_get(mlxsw_sp, to_dev, ops, sparms);
1093     if (!span_entry)
1094         return -ENOBUFS;
1095 
1096     *p_span_id = span_entry->id;
1097 
1098     return 0;
1099 }
1100 
1101 void mlxsw_sp_span_agent_put(struct mlxsw_sp *mlxsw_sp, int span_id)
1102 {
1103     struct mlxsw_sp_span_entry *span_entry;
1104 
1105     ASSERT_RTNL();
1106 
1107     span_entry = mlxsw_sp_span_entry_find_by_id(mlxsw_sp, span_id);
1108     if (WARN_ON_ONCE(!span_entry))
1109         return;
1110 
1111     mlxsw_sp_span_entry_put(mlxsw_sp, span_entry);
1112 }
1113 
1114 static struct mlxsw_sp_span_analyzed_port *
1115 mlxsw_sp_span_analyzed_port_create(struct mlxsw_sp_span *span,
1116                    struct mlxsw_sp_port *mlxsw_sp_port,
1117                    bool ingress)
1118 {
1119     struct mlxsw_sp_span_analyzed_port *analyzed_port;
1120     int err;
1121 
1122     analyzed_port = kzalloc(sizeof(*analyzed_port), GFP_KERNEL);
1123     if (!analyzed_port)
1124         return ERR_PTR(-ENOMEM);
1125 
1126     refcount_set(&analyzed_port->ref_count, 1);
1127     analyzed_port->local_port = mlxsw_sp_port->local_port;
1128     analyzed_port->ingress = ingress;
1129     list_add_tail(&analyzed_port->list, &span->analyzed_ports_list);
1130 
1131     /* An egress mirror buffer should be allocated on the egress port which
1132      * does the mirroring.
1133      */
1134     if (!ingress) {
1135         err = mlxsw_sp_span_port_buffer_enable(mlxsw_sp_port);
1136         if (err)
1137             goto err_buffer_update;
1138     }
1139 
1140     return analyzed_port;
1141 
1142 err_buffer_update:
1143     list_del(&analyzed_port->list);
1144     kfree(analyzed_port);
1145     return ERR_PTR(err);
1146 }
1147 
1148 static void
1149 mlxsw_sp_span_analyzed_port_destroy(struct mlxsw_sp_port *mlxsw_sp_port,
1150                     struct mlxsw_sp_span_analyzed_port *
1151                     analyzed_port)
1152 {
1153     /* Remove egress mirror buffer now that port is no longer analyzed
1154      * at egress.
1155      */
1156     if (!analyzed_port->ingress)
1157         mlxsw_sp_span_port_buffer_disable(mlxsw_sp_port);
1158 
1159     list_del(&analyzed_port->list);
1160     kfree(analyzed_port);
1161 }
1162 
1163 int mlxsw_sp_span_analyzed_port_get(struct mlxsw_sp_port *mlxsw_sp_port,
1164                     bool ingress)
1165 {
1166     struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1167     struct mlxsw_sp_span_analyzed_port *analyzed_port;
1168     u16 local_port = mlxsw_sp_port->local_port;
1169     int err = 0;
1170 
1171     mutex_lock(&mlxsw_sp->span->analyzed_ports_lock);
1172 
1173     analyzed_port = mlxsw_sp_span_analyzed_port_find(mlxsw_sp->span,
1174                              local_port, ingress);
1175     if (analyzed_port) {
1176         refcount_inc(&analyzed_port->ref_count);
1177         goto out_unlock;
1178     }
1179 
1180     analyzed_port = mlxsw_sp_span_analyzed_port_create(mlxsw_sp->span,
1181                                mlxsw_sp_port,
1182                                ingress);
1183     if (IS_ERR(analyzed_port))
1184         err = PTR_ERR(analyzed_port);
1185 
1186 out_unlock:
1187     mutex_unlock(&mlxsw_sp->span->analyzed_ports_lock);
1188     return err;
1189 }
1190 
1191 void mlxsw_sp_span_analyzed_port_put(struct mlxsw_sp_port *mlxsw_sp_port,
1192                      bool ingress)
1193 {
1194     struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1195     struct mlxsw_sp_span_analyzed_port *analyzed_port;
1196     u16 local_port = mlxsw_sp_port->local_port;
1197 
1198     mutex_lock(&mlxsw_sp->span->analyzed_ports_lock);
1199 
1200     analyzed_port = mlxsw_sp_span_analyzed_port_find(mlxsw_sp->span,
1201                              local_port, ingress);
1202     if (WARN_ON_ONCE(!analyzed_port))
1203         goto out_unlock;
1204 
1205     if (!refcount_dec_and_test(&analyzed_port->ref_count))
1206         goto out_unlock;
1207 
1208     mlxsw_sp_span_analyzed_port_destroy(mlxsw_sp_port, analyzed_port);
1209 
1210 out_unlock:
1211     mutex_unlock(&mlxsw_sp->span->analyzed_ports_lock);
1212 }
1213 
1214 static int
1215 __mlxsw_sp_span_trigger_port_bind(struct mlxsw_sp_span *span,
1216                   struct mlxsw_sp_span_trigger_entry *
1217                   trigger_entry, bool enable)
1218 {
1219     char mpar_pl[MLXSW_REG_MPAR_LEN];
1220     enum mlxsw_reg_mpar_i_e i_e;
1221 
1222     switch (trigger_entry->trigger) {
1223     case MLXSW_SP_SPAN_TRIGGER_INGRESS:
1224         i_e = MLXSW_REG_MPAR_TYPE_INGRESS;
1225         break;
1226     case MLXSW_SP_SPAN_TRIGGER_EGRESS:
1227         i_e = MLXSW_REG_MPAR_TYPE_EGRESS;
1228         break;
1229     default:
1230         WARN_ON_ONCE(1);
1231         return -EINVAL;
1232     }
1233 
1234     if (trigger_entry->parms.probability_rate > MLXSW_REG_MPAR_RATE_MAX)
1235         return -EINVAL;
1236 
1237     mlxsw_reg_mpar_pack(mpar_pl, trigger_entry->local_port, i_e, enable,
1238                 trigger_entry->parms.span_id,
1239                 trigger_entry->parms.probability_rate);
1240     return mlxsw_reg_write(span->mlxsw_sp->core, MLXSW_REG(mpar), mpar_pl);
1241 }
1242 
1243 static int
1244 mlxsw_sp_span_trigger_port_bind(struct mlxsw_sp_span_trigger_entry *
1245                 trigger_entry)
1246 {
1247     return __mlxsw_sp_span_trigger_port_bind(trigger_entry->span,
1248                          trigger_entry, true);
1249 }
1250 
1251 static void
1252 mlxsw_sp_span_trigger_port_unbind(struct mlxsw_sp_span_trigger_entry *
1253                   trigger_entry)
1254 {
1255     __mlxsw_sp_span_trigger_port_bind(trigger_entry->span, trigger_entry,
1256                       false);
1257 }
1258 
1259 static bool
1260 mlxsw_sp_span_trigger_port_matches(struct mlxsw_sp_span_trigger_entry *
1261                    trigger_entry,
1262                    enum mlxsw_sp_span_trigger trigger,
1263                    struct mlxsw_sp_port *mlxsw_sp_port)
1264 {
1265     return trigger_entry->trigger == trigger &&
1266            trigger_entry->local_port == mlxsw_sp_port->local_port;
1267 }
1268 
1269 static int
1270 mlxsw_sp_span_trigger_port_enable(struct mlxsw_sp_span_trigger_entry *
1271                   trigger_entry,
1272                   struct mlxsw_sp_port *mlxsw_sp_port, u8 tc)
1273 {
1274     /* Port trigger are enabled during binding. */
1275     return 0;
1276 }
1277 
1278 static void
1279 mlxsw_sp_span_trigger_port_disable(struct mlxsw_sp_span_trigger_entry *
1280                    trigger_entry,
1281                    struct mlxsw_sp_port *mlxsw_sp_port, u8 tc)
1282 {
1283 }
1284 
1285 static const struct mlxsw_sp_span_trigger_ops
1286 mlxsw_sp_span_trigger_port_ops = {
1287     .bind = mlxsw_sp_span_trigger_port_bind,
1288     .unbind = mlxsw_sp_span_trigger_port_unbind,
1289     .matches = mlxsw_sp_span_trigger_port_matches,
1290     .enable = mlxsw_sp_span_trigger_port_enable,
1291     .disable = mlxsw_sp_span_trigger_port_disable,
1292 };
1293 
1294 static int
1295 mlxsw_sp1_span_trigger_global_bind(struct mlxsw_sp_span_trigger_entry *
1296                    trigger_entry)
1297 {
1298     return -EOPNOTSUPP;
1299 }
1300 
1301 static void
1302 mlxsw_sp1_span_trigger_global_unbind(struct mlxsw_sp_span_trigger_entry *
1303                      trigger_entry)
1304 {
1305 }
1306 
1307 static bool
1308 mlxsw_sp1_span_trigger_global_matches(struct mlxsw_sp_span_trigger_entry *
1309                       trigger_entry,
1310                       enum mlxsw_sp_span_trigger trigger,
1311                       struct mlxsw_sp_port *mlxsw_sp_port)
1312 {
1313     WARN_ON_ONCE(1);
1314     return false;
1315 }
1316 
1317 static int
1318 mlxsw_sp1_span_trigger_global_enable(struct mlxsw_sp_span_trigger_entry *
1319                      trigger_entry,
1320                      struct mlxsw_sp_port *mlxsw_sp_port,
1321                      u8 tc)
1322 {
1323     return -EOPNOTSUPP;
1324 }
1325 
1326 static void
1327 mlxsw_sp1_span_trigger_global_disable(struct mlxsw_sp_span_trigger_entry *
1328                       trigger_entry,
1329                       struct mlxsw_sp_port *mlxsw_sp_port,
1330                       u8 tc)
1331 {
1332 }
1333 
1334 static const struct mlxsw_sp_span_trigger_ops
1335 mlxsw_sp1_span_trigger_global_ops = {
1336     .bind = mlxsw_sp1_span_trigger_global_bind,
1337     .unbind = mlxsw_sp1_span_trigger_global_unbind,
1338     .matches = mlxsw_sp1_span_trigger_global_matches,
1339     .enable = mlxsw_sp1_span_trigger_global_enable,
1340     .disable = mlxsw_sp1_span_trigger_global_disable,
1341 };
1342 
1343 static const struct mlxsw_sp_span_trigger_ops *
1344 mlxsw_sp1_span_trigger_ops_arr[] = {
1345     [MLXSW_SP_SPAN_TRIGGER_TYPE_PORT] = &mlxsw_sp_span_trigger_port_ops,
1346     [MLXSW_SP_SPAN_TRIGGER_TYPE_GLOBAL] =
1347         &mlxsw_sp1_span_trigger_global_ops,
1348 };
1349 
1350 static int
1351 mlxsw_sp2_span_trigger_global_bind(struct mlxsw_sp_span_trigger_entry *
1352                    trigger_entry)
1353 {
1354     struct mlxsw_sp *mlxsw_sp = trigger_entry->span->mlxsw_sp;
1355     enum mlxsw_reg_mpagr_trigger trigger;
1356     char mpagr_pl[MLXSW_REG_MPAGR_LEN];
1357 
1358     switch (trigger_entry->trigger) {
1359     case MLXSW_SP_SPAN_TRIGGER_TAIL_DROP:
1360         trigger = MLXSW_REG_MPAGR_TRIGGER_INGRESS_SHARED_BUFFER;
1361         break;
1362     case MLXSW_SP_SPAN_TRIGGER_EARLY_DROP:
1363         trigger = MLXSW_REG_MPAGR_TRIGGER_INGRESS_WRED;
1364         break;
1365     case MLXSW_SP_SPAN_TRIGGER_ECN:
1366         trigger = MLXSW_REG_MPAGR_TRIGGER_EGRESS_ECN;
1367         break;
1368     default:
1369         WARN_ON_ONCE(1);
1370         return -EINVAL;
1371     }
1372 
1373     if (trigger_entry->parms.probability_rate > MLXSW_REG_MPAGR_RATE_MAX)
1374         return -EINVAL;
1375 
1376     mlxsw_reg_mpagr_pack(mpagr_pl, trigger, trigger_entry->parms.span_id,
1377                  trigger_entry->parms.probability_rate);
1378     return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(mpagr), mpagr_pl);
1379 }
1380 
1381 static void
1382 mlxsw_sp2_span_trigger_global_unbind(struct mlxsw_sp_span_trigger_entry *
1383                      trigger_entry)
1384 {
1385     /* There is no unbinding for global triggers. The trigger should be
1386      * disabled on all ports by now.
1387      */
1388 }
1389 
1390 static bool
1391 mlxsw_sp2_span_trigger_global_matches(struct mlxsw_sp_span_trigger_entry *
1392                       trigger_entry,
1393                       enum mlxsw_sp_span_trigger trigger,
1394                       struct mlxsw_sp_port *mlxsw_sp_port)
1395 {
1396     return trigger_entry->trigger == trigger;
1397 }
1398 
1399 static int
1400 __mlxsw_sp2_span_trigger_global_enable(struct mlxsw_sp_span_trigger_entry *
1401                        trigger_entry,
1402                        struct mlxsw_sp_port *mlxsw_sp_port,
1403                        u8 tc, bool enable)
1404 {
1405     struct mlxsw_sp *mlxsw_sp = trigger_entry->span->mlxsw_sp;
1406     char momte_pl[MLXSW_REG_MOMTE_LEN];
1407     enum mlxsw_reg_momte_type type;
1408     int err;
1409 
1410     switch (trigger_entry->trigger) {
1411     case MLXSW_SP_SPAN_TRIGGER_TAIL_DROP:
1412         type = MLXSW_REG_MOMTE_TYPE_SHARED_BUFFER_TCLASS;
1413         break;
1414     case MLXSW_SP_SPAN_TRIGGER_EARLY_DROP:
1415         type = MLXSW_REG_MOMTE_TYPE_WRED;
1416         break;
1417     case MLXSW_SP_SPAN_TRIGGER_ECN:
1418         type = MLXSW_REG_MOMTE_TYPE_ECN;
1419         break;
1420     default:
1421         WARN_ON_ONCE(1);
1422         return -EINVAL;
1423     }
1424 
1425     /* Query existing configuration in order to only change the state of
1426      * the specified traffic class.
1427      */
1428     mlxsw_reg_momte_pack(momte_pl, mlxsw_sp_port->local_port, type);
1429     err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(momte), momte_pl);
1430     if (err)
1431         return err;
1432 
1433     mlxsw_reg_momte_tclass_en_set(momte_pl, tc, enable);
1434     return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(momte), momte_pl);
1435 }
1436 
1437 static int
1438 mlxsw_sp2_span_trigger_global_enable(struct mlxsw_sp_span_trigger_entry *
1439                      trigger_entry,
1440                      struct mlxsw_sp_port *mlxsw_sp_port,
1441                      u8 tc)
1442 {
1443     return __mlxsw_sp2_span_trigger_global_enable(trigger_entry,
1444                               mlxsw_sp_port, tc, true);
1445 }
1446 
1447 static void
1448 mlxsw_sp2_span_trigger_global_disable(struct mlxsw_sp_span_trigger_entry *
1449                       trigger_entry,
1450                       struct mlxsw_sp_port *mlxsw_sp_port,
1451                       u8 tc)
1452 {
1453     __mlxsw_sp2_span_trigger_global_enable(trigger_entry, mlxsw_sp_port, tc,
1454                            false);
1455 }
1456 
1457 static const struct mlxsw_sp_span_trigger_ops
1458 mlxsw_sp2_span_trigger_global_ops = {
1459     .bind = mlxsw_sp2_span_trigger_global_bind,
1460     .unbind = mlxsw_sp2_span_trigger_global_unbind,
1461     .matches = mlxsw_sp2_span_trigger_global_matches,
1462     .enable = mlxsw_sp2_span_trigger_global_enable,
1463     .disable = mlxsw_sp2_span_trigger_global_disable,
1464 };
1465 
1466 static const struct mlxsw_sp_span_trigger_ops *
1467 mlxsw_sp2_span_trigger_ops_arr[] = {
1468     [MLXSW_SP_SPAN_TRIGGER_TYPE_PORT] = &mlxsw_sp_span_trigger_port_ops,
1469     [MLXSW_SP_SPAN_TRIGGER_TYPE_GLOBAL] =
1470         &mlxsw_sp2_span_trigger_global_ops,
1471 };
1472 
1473 static void
1474 mlxsw_sp_span_trigger_ops_set(struct mlxsw_sp_span_trigger_entry *trigger_entry)
1475 {
1476     struct mlxsw_sp_span *span = trigger_entry->span;
1477     enum mlxsw_sp_span_trigger_type type;
1478 
1479     switch (trigger_entry->trigger) {
1480     case MLXSW_SP_SPAN_TRIGGER_INGRESS:
1481     case MLXSW_SP_SPAN_TRIGGER_EGRESS:
1482         type = MLXSW_SP_SPAN_TRIGGER_TYPE_PORT;
1483         break;
1484     case MLXSW_SP_SPAN_TRIGGER_TAIL_DROP:
1485     case MLXSW_SP_SPAN_TRIGGER_EARLY_DROP:
1486     case MLXSW_SP_SPAN_TRIGGER_ECN:
1487         type = MLXSW_SP_SPAN_TRIGGER_TYPE_GLOBAL;
1488         break;
1489     default:
1490         WARN_ON_ONCE(1);
1491         return;
1492     }
1493 
1494     trigger_entry->ops = span->span_trigger_ops_arr[type];
1495 }
1496 
1497 static struct mlxsw_sp_span_trigger_entry *
1498 mlxsw_sp_span_trigger_entry_create(struct mlxsw_sp_span *span,
1499                    enum mlxsw_sp_span_trigger trigger,
1500                    struct mlxsw_sp_port *mlxsw_sp_port,
1501                    const struct mlxsw_sp_span_trigger_parms
1502                    *parms)
1503 {
1504     struct mlxsw_sp_span_trigger_entry *trigger_entry;
1505     int err;
1506 
1507     trigger_entry = kzalloc(sizeof(*trigger_entry), GFP_KERNEL);
1508     if (!trigger_entry)
1509         return ERR_PTR(-ENOMEM);
1510 
1511     refcount_set(&trigger_entry->ref_count, 1);
1512     trigger_entry->local_port = mlxsw_sp_port ? mlxsw_sp_port->local_port :
1513                             0;
1514     trigger_entry->trigger = trigger;
1515     memcpy(&trigger_entry->parms, parms, sizeof(trigger_entry->parms));
1516     trigger_entry->span = span;
1517     mlxsw_sp_span_trigger_ops_set(trigger_entry);
1518     list_add_tail(&trigger_entry->list, &span->trigger_entries_list);
1519 
1520     err = trigger_entry->ops->bind(trigger_entry);
1521     if (err)
1522         goto err_trigger_entry_bind;
1523 
1524     return trigger_entry;
1525 
1526 err_trigger_entry_bind:
1527     list_del(&trigger_entry->list);
1528     kfree(trigger_entry);
1529     return ERR_PTR(err);
1530 }
1531 
1532 static void
1533 mlxsw_sp_span_trigger_entry_destroy(struct mlxsw_sp_span *span,
1534                     struct mlxsw_sp_span_trigger_entry *
1535                     trigger_entry)
1536 {
1537     trigger_entry->ops->unbind(trigger_entry);
1538     list_del(&trigger_entry->list);
1539     kfree(trigger_entry);
1540 }
1541 
1542 static struct mlxsw_sp_span_trigger_entry *
1543 mlxsw_sp_span_trigger_entry_find(struct mlxsw_sp_span *span,
1544                  enum mlxsw_sp_span_trigger trigger,
1545                  struct mlxsw_sp_port *mlxsw_sp_port)
1546 {
1547     struct mlxsw_sp_span_trigger_entry *trigger_entry;
1548 
1549     list_for_each_entry(trigger_entry, &span->trigger_entries_list, list) {
1550         if (trigger_entry->ops->matches(trigger_entry, trigger,
1551                         mlxsw_sp_port))
1552             return trigger_entry;
1553     }
1554 
1555     return NULL;
1556 }
1557 
1558 int mlxsw_sp_span_agent_bind(struct mlxsw_sp *mlxsw_sp,
1559                  enum mlxsw_sp_span_trigger trigger,
1560                  struct mlxsw_sp_port *mlxsw_sp_port,
1561                  const struct mlxsw_sp_span_trigger_parms *parms)
1562 {
1563     struct mlxsw_sp_span_trigger_entry *trigger_entry;
1564     int err = 0;
1565 
1566     ASSERT_RTNL();
1567 
1568     if (!mlxsw_sp_span_entry_find_by_id(mlxsw_sp, parms->span_id))
1569         return -EINVAL;
1570 
1571     trigger_entry = mlxsw_sp_span_trigger_entry_find(mlxsw_sp->span,
1572                              trigger,
1573                              mlxsw_sp_port);
1574     if (trigger_entry) {
1575         if (trigger_entry->parms.span_id != parms->span_id ||
1576             trigger_entry->parms.probability_rate !=
1577             parms->probability_rate)
1578             return -EINVAL;
1579         refcount_inc(&trigger_entry->ref_count);
1580         goto out;
1581     }
1582 
1583     trigger_entry = mlxsw_sp_span_trigger_entry_create(mlxsw_sp->span,
1584                                trigger,
1585                                mlxsw_sp_port,
1586                                parms);
1587     if (IS_ERR(trigger_entry))
1588         err = PTR_ERR(trigger_entry);
1589 
1590 out:
1591     return err;
1592 }
1593 
1594 void mlxsw_sp_span_agent_unbind(struct mlxsw_sp *mlxsw_sp,
1595                 enum mlxsw_sp_span_trigger trigger,
1596                 struct mlxsw_sp_port *mlxsw_sp_port,
1597                 const struct mlxsw_sp_span_trigger_parms *parms)
1598 {
1599     struct mlxsw_sp_span_trigger_entry *trigger_entry;
1600 
1601     ASSERT_RTNL();
1602 
1603     if (WARN_ON_ONCE(!mlxsw_sp_span_entry_find_by_id(mlxsw_sp,
1604                              parms->span_id)))
1605         return;
1606 
1607     trigger_entry = mlxsw_sp_span_trigger_entry_find(mlxsw_sp->span,
1608                              trigger,
1609                              mlxsw_sp_port);
1610     if (WARN_ON_ONCE(!trigger_entry))
1611         return;
1612 
1613     if (!refcount_dec_and_test(&trigger_entry->ref_count))
1614         return;
1615 
1616     mlxsw_sp_span_trigger_entry_destroy(mlxsw_sp->span, trigger_entry);
1617 }
1618 
1619 int mlxsw_sp_span_trigger_enable(struct mlxsw_sp_port *mlxsw_sp_port,
1620                  enum mlxsw_sp_span_trigger trigger, u8 tc)
1621 {
1622     struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1623     struct mlxsw_sp_span_trigger_entry *trigger_entry;
1624 
1625     ASSERT_RTNL();
1626 
1627     trigger_entry = mlxsw_sp_span_trigger_entry_find(mlxsw_sp->span,
1628                              trigger,
1629                              mlxsw_sp_port);
1630     if (WARN_ON_ONCE(!trigger_entry))
1631         return -EINVAL;
1632 
1633     return trigger_entry->ops->enable(trigger_entry, mlxsw_sp_port, tc);
1634 }
1635 
1636 void mlxsw_sp_span_trigger_disable(struct mlxsw_sp_port *mlxsw_sp_port,
1637                    enum mlxsw_sp_span_trigger trigger, u8 tc)
1638 {
1639     struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1640     struct mlxsw_sp_span_trigger_entry *trigger_entry;
1641 
1642     ASSERT_RTNL();
1643 
1644     trigger_entry = mlxsw_sp_span_trigger_entry_find(mlxsw_sp->span,
1645                              trigger,
1646                              mlxsw_sp_port);
1647     if (WARN_ON_ONCE(!trigger_entry))
1648         return;
1649 
1650     return trigger_entry->ops->disable(trigger_entry, mlxsw_sp_port, tc);
1651 }
1652 
1653 bool mlxsw_sp_span_trigger_is_ingress(enum mlxsw_sp_span_trigger trigger)
1654 {
1655     switch (trigger) {
1656     case MLXSW_SP_SPAN_TRIGGER_INGRESS:
1657     case MLXSW_SP_SPAN_TRIGGER_EARLY_DROP:
1658     case MLXSW_SP_SPAN_TRIGGER_TAIL_DROP:
1659         return true;
1660     case MLXSW_SP_SPAN_TRIGGER_EGRESS:
1661     case MLXSW_SP_SPAN_TRIGGER_ECN:
1662         return false;
1663     }
1664 
1665     WARN_ON_ONCE(1);
1666     return false;
1667 }
1668 
1669 static int mlxsw_sp1_span_init(struct mlxsw_sp *mlxsw_sp)
1670 {
1671     size_t arr_size = ARRAY_SIZE(mlxsw_sp1_span_entry_ops_arr);
1672 
1673     /* Must be first to avoid NULL pointer dereference by subsequent
1674      * can_handle() callbacks.
1675      */
1676     if (WARN_ON(mlxsw_sp1_span_entry_ops_arr[0] !=
1677             &mlxsw_sp1_span_entry_ops_cpu))
1678         return -EINVAL;
1679 
1680     mlxsw_sp->span->span_trigger_ops_arr = mlxsw_sp1_span_trigger_ops_arr;
1681     mlxsw_sp->span->span_entry_ops_arr = mlxsw_sp1_span_entry_ops_arr;
1682     mlxsw_sp->span->span_entry_ops_arr_size = arr_size;
1683 
1684     return 0;
1685 }
1686 
1687 static int mlxsw_sp1_span_policer_id_base_set(struct mlxsw_sp *mlxsw_sp,
1688                           u16 policer_id_base)
1689 {
1690     return -EOPNOTSUPP;
1691 }
1692 
1693 const struct mlxsw_sp_span_ops mlxsw_sp1_span_ops = {
1694     .init = mlxsw_sp1_span_init,
1695     .policer_id_base_set = mlxsw_sp1_span_policer_id_base_set,
1696 };
1697 
1698 static int mlxsw_sp2_span_init(struct mlxsw_sp *mlxsw_sp)
1699 {
1700     size_t arr_size = ARRAY_SIZE(mlxsw_sp2_span_entry_ops_arr);
1701 
1702     /* Must be first to avoid NULL pointer dereference by subsequent
1703      * can_handle() callbacks.
1704      */
1705     if (WARN_ON(mlxsw_sp2_span_entry_ops_arr[0] !=
1706             &mlxsw_sp2_span_entry_ops_cpu))
1707         return -EINVAL;
1708 
1709     mlxsw_sp->span->span_trigger_ops_arr = mlxsw_sp2_span_trigger_ops_arr;
1710     mlxsw_sp->span->span_entry_ops_arr = mlxsw_sp2_span_entry_ops_arr;
1711     mlxsw_sp->span->span_entry_ops_arr_size = arr_size;
1712 
1713     return 0;
1714 }
1715 
1716 #define MLXSW_SP2_SPAN_EG_MIRROR_BUFFER_FACTOR 38
1717 #define MLXSW_SP3_SPAN_EG_MIRROR_BUFFER_FACTOR 50
1718 
1719 static int mlxsw_sp2_span_policer_id_base_set(struct mlxsw_sp *mlxsw_sp,
1720                           u16 policer_id_base)
1721 {
1722     char mogcr_pl[MLXSW_REG_MOGCR_LEN];
1723     int err;
1724 
1725     err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(mogcr), mogcr_pl);
1726     if (err)
1727         return err;
1728 
1729     mlxsw_reg_mogcr_mirroring_pid_base_set(mogcr_pl, policer_id_base);
1730     return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(mogcr), mogcr_pl);
1731 }
1732 
1733 const struct mlxsw_sp_span_ops mlxsw_sp2_span_ops = {
1734     .init = mlxsw_sp2_span_init,
1735     .policer_id_base_set = mlxsw_sp2_span_policer_id_base_set,
1736 };
1737 
1738 const struct mlxsw_sp_span_ops mlxsw_sp3_span_ops = {
1739     .init = mlxsw_sp2_span_init,
1740     .policer_id_base_set = mlxsw_sp2_span_policer_id_base_set,
1741 };
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!