drivers/net/ethernet/mellanox/mlxsw/spectrum_span.c

   1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
   2 /* Copyright (c) 2018 Mellanox Technologies. All rights reserved */
   3
   4 #include <linux/if_bridge.h>
   5 #include <linux/list.h>
   6 #include <linux/mutex.h>
   7 #include <linux/refcount.h>
   8 #include <linux/rtnetlink.h>
   9 #include <linux/workqueue.h>
  10 #include <net/arp.h>
  11 #include <net/gre.h>
  12 #include <net/lag.h>
  13 #include <net/ndisc.h>
  14 #include <net/ip6_tunnel.h>
  15
  16 #include "spectrum.h"
  17 #include "spectrum_ipip.h"
  18 #include "spectrum_span.h"
  19 #include "spectrum_switchdev.h"
  20
  21 struct mlxsw_sp_span {
  22         struct work_struct work;
  23         struct mlxsw_sp *mlxsw_sp;
  24         const struct mlxsw_sp_span_trigger_ops **span_trigger_ops_arr;
  25         const struct mlxsw_sp_span_entry_ops **span_entry_ops_arr;
  26         size_t span_entry_ops_arr_size;
  27         struct list_head analyzed_ports_list;
  28         struct mutex analyzed_ports_lock; /* Protects analyzed_ports_list */
  29         struct list_head trigger_entries_list;
  30         u16 policer_id_base;
  31         refcount_t policer_id_base_ref_count;
  32         atomic_t active_entries_count;
  33         int entries_count;
  34         struct mlxsw_sp_span_entry entries[] __counted_by(entries_count);
  35 };
  36
  37 struct mlxsw_sp_span_analyzed_port {
  38         struct list_head list; /* Member of analyzed_ports_list */
  39         refcount_t ref_count;
  40         u16 local_port;
  41         bool ingress;
  42 };
  43
  44 struct mlxsw_sp_span_trigger_entry {
  45         struct list_head list; /* Member of trigger_entries_list */
  46         struct mlxsw_sp_span *span;
  47         const struct mlxsw_sp_span_trigger_ops *ops;
  48         refcount_t ref_count;
  49         u16 local_port;
  50         enum mlxsw_sp_span_trigger trigger;
  51         struct mlxsw_sp_span_trigger_parms parms;
  52 };
  53
  54 enum mlxsw_sp_span_trigger_type {
  55         MLXSW_SP_SPAN_TRIGGER_TYPE_PORT,
  56         MLXSW_SP_SPAN_TRIGGER_TYPE_GLOBAL,
  57 };
  58
  59 struct mlxsw_sp_span_trigger_ops {
  60         int (*bind)(struct mlxsw_sp_span_trigger_entry *trigger_entry);
  61         void (*unbind)(struct mlxsw_sp_span_trigger_entry *trigger_entry);
  62         bool (*matches)(struct mlxsw_sp_span_trigger_entry *trigger_entry,
  63                         enum mlxsw_sp_span_trigger trigger,
  64                         struct mlxsw_sp_port *mlxsw_sp_port);
  65         int (*enable)(struct mlxsw_sp_span_trigger_entry *trigger_entry,
  66                       struct mlxsw_sp_port *mlxsw_sp_port, u8 tc);
  67         void (*disable)(struct mlxsw_sp_span_trigger_entry *trigger_entry,
  68                         struct mlxsw_sp_port *mlxsw_sp_port, u8 tc);
  69 };
  70
  71 static void mlxsw_sp_span_respin_work(struct work_struct *work);
  72
  73 static u64 mlxsw_sp_span_occ_get(void *priv)
  74 {
  75         const struct mlxsw_sp *mlxsw_sp = priv;
  76
  77         return atomic_read(&mlxsw_sp->span->active_entries_count);
  78 }
  79
  80 int mlxsw_sp_span_init(struct mlxsw_sp *mlxsw_sp)
  81 {
  82         struct devlink *devlink = priv_to_devlink(mlxsw_sp->core);
  83         struct mlxsw_sp_span *span;
  84         int i, entries_count, err;
  85
  86         if (!MLXSW_CORE_RES_VALID(mlxsw_sp->core, MAX_SPAN))
  87                 return -EIO;
  88
  89         entries_count = MLXSW_CORE_RES_GET(mlxsw_sp->core, MAX_SPAN);
  90         span = kzalloc(struct_size(span, entries, entries_count), GFP_KERNEL);
  91         if (!span)
  92                 return -ENOMEM;
  93         refcount_set(&span->policer_id_base_ref_count, 0);
  94         span->entries_count = entries_count;
  95         atomic_set(&span->active_entries_count, 0);
  96         mutex_init(&span->analyzed_ports_lock);
  97         INIT_LIST_HEAD(&span->analyzed_ports_list);
  98         INIT_LIST_HEAD(&span->trigger_entries_list);
  99         span->mlxsw_sp = mlxsw_sp;
 100         mlxsw_sp->span = span;
 101
 102         for (i = 0; i < mlxsw_sp->span->entries_count; i++)
 103                 mlxsw_sp->span->entries[i].id = i;
 104
 105         err = mlxsw_sp->span_ops->init(mlxsw_sp);
 106         if (err)
 107                 goto err_init;
 108
 109         devl_resource_occ_get_register(devlink, MLXSW_SP_RESOURCE_SPAN,
 110                                        mlxsw_sp_span_occ_get, mlxsw_sp);
 111         INIT_WORK(&span->work, mlxsw_sp_span_respin_work);
 112
 113         return 0;
 114
 115 err_init:
 116         mutex_destroy(&mlxsw_sp->span->analyzed_ports_lock);
 117         kfree(mlxsw_sp->span);
 118         return err;
 119 }
 120
 121 void mlxsw_sp_span_fini(struct mlxsw_sp *mlxsw_sp)
 122 {
 123         struct devlink *devlink = priv_to_devlink(mlxsw_sp->core);
 124
 125         cancel_work_sync(&mlxsw_sp->span->work);
 126         devl_resource_occ_get_unregister(devlink, MLXSW_SP_RESOURCE_SPAN);
 127
 128         WARN_ON_ONCE(!list_empty(&mlxsw_sp->span->trigger_entries_list));
 129         WARN_ON_ONCE(!list_empty(&mlxsw_sp->span->analyzed_ports_list));
 130         mutex_destroy(&mlxsw_sp->span->analyzed_ports_lock);
 131         kfree(mlxsw_sp->span);
 132 }
 133
 134 static bool mlxsw_sp1_span_cpu_can_handle(const struct net_device *dev)
 135 {
 136         return !dev;
 137 }
 138
 139 static int mlxsw_sp1_span_entry_cpu_parms(struct mlxsw_sp *mlxsw_sp,
 140                                           const struct net_device *to_dev,
 141                                           struct mlxsw_sp_span_parms *sparmsp)
 142 {
 143         return -EOPNOTSUPP;
 144 }
 145
 146 static int
 147 mlxsw_sp1_span_entry_cpu_configure(struct mlxsw_sp_span_entry *span_entry,
 148                                    struct mlxsw_sp_span_parms sparms)
 149 {
 150         return -EOPNOTSUPP;
 151 }
 152
 153 static void
 154 mlxsw_sp1_span_entry_cpu_deconfigure(struct mlxsw_sp_span_entry *span_entry)
 155 {
 156 }
 157
 158 static const
 159 struct mlxsw_sp_span_entry_ops mlxsw_sp1_span_entry_ops_cpu = {
 160         .is_static = true,
 161         .can_handle = mlxsw_sp1_span_cpu_can_handle,
 162         .parms_set = mlxsw_sp1_span_entry_cpu_parms,
 163         .configure = mlxsw_sp1_span_entry_cpu_configure,
 164         .deconfigure = mlxsw_sp1_span_entry_cpu_deconfigure,
 165 };
 166
 167 static int
 168 mlxsw_sp_span_entry_phys_parms(struct mlxsw_sp *mlxsw_sp,
 169                                const struct net_device *to_dev,
 170                                struct mlxsw_sp_span_parms *sparmsp)
 171 {
 172         sparmsp->dest_port = netdev_priv(to_dev);
 173         return 0;
 174 }
 175
 176 static int
 177 mlxsw_sp_span_entry_phys_configure(struct mlxsw_sp_span_entry *span_entry,
 178                                    struct mlxsw_sp_span_parms sparms)
 179 {
 180         struct mlxsw_sp_port *dest_port = sparms.dest_port;
 181         struct mlxsw_sp *mlxsw_sp = dest_port->mlxsw_sp;
 182         u16 local_port = dest_port->local_port;
 183         char mpat_pl[MLXSW_REG_MPAT_LEN];
 184         int pa_id = span_entry->id;
 185
 186         /* Create a new port analayzer entry for local_port. */
 187         mlxsw_reg_mpat_pack(mpat_pl, pa_id, local_port, true,
 188                             MLXSW_REG_MPAT_SPAN_TYPE_LOCAL_ETH);
 189         mlxsw_reg_mpat_session_id_set(mpat_pl, sparms.session_id);
 190         mlxsw_reg_mpat_pide_set(mpat_pl, sparms.policer_enable);
 191         mlxsw_reg_mpat_pid_set(mpat_pl, sparms.policer_id);
 192
 193         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(mpat), mpat_pl);
 194 }
 195
 196 static void
 197 mlxsw_sp_span_entry_deconfigure_common(struct mlxsw_sp_span_entry *span_entry,
 198                                        enum mlxsw_reg_mpat_span_type span_type)
 199 {
 200         struct mlxsw_sp_port *dest_port = span_entry->parms.dest_port;
 201         struct mlxsw_sp *mlxsw_sp = dest_port->mlxsw_sp;
 202         u16 local_port = dest_port->local_port;
 203         char mpat_pl[MLXSW_REG_MPAT_LEN];
 204         int pa_id = span_entry->id;
 205
 206         mlxsw_reg_mpat_pack(mpat_pl, pa_id, local_port, false, span_type);
 207         mlxsw_reg_mpat_session_id_set(mpat_pl, span_entry->parms.session_id);
 208         mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(mpat), mpat_pl);
 209 }
 210
 211 static void
 212 mlxsw_sp_span_entry_phys_deconfigure(struct mlxsw_sp_span_entry *span_entry)
 213 {
 214         mlxsw_sp_span_entry_deconfigure_common(span_entry,
 215                                             MLXSW_REG_MPAT_SPAN_TYPE_LOCAL_ETH);
 216 }
 217
 218 static const
 219 struct mlxsw_sp_span_entry_ops mlxsw_sp_span_entry_ops_phys = {
 220         .is_static = true,
 221         .can_handle = mlxsw_sp_port_dev_check,
 222         .parms_set = mlxsw_sp_span_entry_phys_parms,
 223         .configure = mlxsw_sp_span_entry_phys_configure,
 224         .deconfigure = mlxsw_sp_span_entry_phys_deconfigure,
 225 };
 226
 227 static int mlxsw_sp_span_dmac(struct neigh_table *tbl,
 228                               const void *pkey,
 229                               struct net_device *dev,
 230                               unsigned char dmac[ETH_ALEN])
 231 {
 232         struct neighbour *neigh = neigh_lookup(tbl, pkey, dev);
 233         int err = 0;
 234
 235         if (!neigh) {
 236                 neigh = neigh_create(tbl, pkey, dev);
 237                 if (IS_ERR(neigh))
 238                         return PTR_ERR(neigh);
 239         }
 240
 241         neigh_event_send(neigh, NULL);
 242
 243         read_lock_bh(&neigh->lock);
 244         if ((neigh->nud_state & NUD_VALID) && !neigh->dead)
 245                 memcpy(dmac, neigh->ha, ETH_ALEN);
 246         else
 247                 err = -ENOENT;
 248         read_unlock_bh(&neigh->lock);
 249
 250         neigh_release(neigh);
 251         return err;
 252 }
 253
 254 static int
 255 mlxsw_sp_span_entry_unoffloadable(struct mlxsw_sp_span_parms *sparmsp)
 256 {
 257         sparmsp->dest_port = NULL;
 258         return 0;
 259 }
 260
 261 static struct net_device *
 262 mlxsw_sp_span_entry_bridge_8021q(const struct net_device *br_dev,
 263                                  unsigned char *dmac,
 264                                  u16 *p_vid)
 265 {
 266         struct bridge_vlan_info vinfo;
 267         struct net_device *edev;
 268         u16 vid = *p_vid;
 269
 270         if (!vid && WARN_ON(br_vlan_get_pvid(br_dev, &vid)))
 271                 return NULL;
 272         if (!vid || br_vlan_get_info(br_dev, vid, &vinfo) ||
 273             !(vinfo.flags & BRIDGE_VLAN_INFO_BRENTRY))
 274                 return NULL;
 275
 276         edev = br_fdb_find_port(br_dev, dmac, vid);
 277         if (!edev)
 278                 return NULL;
 279
 280         if (br_vlan_get_info(edev, vid, &vinfo))
 281                 return NULL;
 282         if (vinfo.flags & BRIDGE_VLAN_INFO_UNTAGGED)
 283                 *p_vid = 0;
 284         else
 285                 *p_vid = vid;
 286         return edev;
 287 }
 288
 289 static struct net_device *
 290 mlxsw_sp_span_entry_bridge_8021d(const struct net_device *br_dev,
 291                                  unsigned char *dmac)
 292 {
 293         return br_fdb_find_port(br_dev, dmac, 0);
 294 }
 295
 296 static struct net_device *
 297 mlxsw_sp_span_entry_bridge(const struct net_device *br_dev,
 298                            unsigned char dmac[ETH_ALEN],
 299                            u16 *p_vid)
 300 {
 301         struct mlxsw_sp_bridge_port *bridge_port;
 302         enum mlxsw_reg_spms_state spms_state;
 303         struct net_device *dev = NULL;
 304         struct mlxsw_sp_port *port;
 305         u8 stp_state;
 306
 307         if (br_vlan_enabled(br_dev))
 308                 dev = mlxsw_sp_span_entry_bridge_8021q(br_dev, dmac, p_vid);
 309         else if (!*p_vid)
 310                 dev = mlxsw_sp_span_entry_bridge_8021d(br_dev, dmac);
 311         if (!dev)
 312                 return NULL;
 313
 314         port = mlxsw_sp_port_dev_lower_find(dev);
 315         if (!port)
 316                 return NULL;
 317
 318         bridge_port = mlxsw_sp_bridge_port_find(port->mlxsw_sp->bridge, dev);
 319         if (!bridge_port)
 320                 return NULL;
 321
 322         stp_state = mlxsw_sp_bridge_port_stp_state(bridge_port);
 323         spms_state = mlxsw_sp_stp_spms_state(stp_state);
 324         if (spms_state != MLXSW_REG_SPMS_STATE_FORWARDING)
 325                 return NULL;
 326
 327         return dev;
 328 }
 329
 330 static struct net_device *
 331 mlxsw_sp_span_entry_vlan(const struct net_device *vlan_dev,
 332                          u16 *p_vid)
 333 {
 334         *p_vid = vlan_dev_vlan_id(vlan_dev);
 335         return vlan_dev_real_dev(vlan_dev);
 336 }
 337
 338 static struct net_device *
 339 mlxsw_sp_span_entry_lag(struct net_device *lag_dev)
 340 {
 341         struct net_device *dev;
 342         struct list_head *iter;
 343
 344         netdev_for_each_lower_dev(lag_dev, dev, iter)
 345                 if (netif_carrier_ok(dev) &&
 346                     net_lag_port_dev_txable(dev) &&
 347                     mlxsw_sp_port_dev_check(dev))
 348                         return dev;
 349
 350         return NULL;
 351 }
 352
 353 static __maybe_unused int
 354 mlxsw_sp_span_entry_tunnel_parms_common(struct net_device *edev,
 355                                         union mlxsw_sp_l3addr saddr,
 356                                         union mlxsw_sp_l3addr daddr,
 357                                         union mlxsw_sp_l3addr gw,
 358                                         __u8 ttl,
 359                                         struct neigh_table *tbl,
 360                                         struct mlxsw_sp_span_parms *sparmsp)
 361 {
 362         unsigned char dmac[ETH_ALEN];
 363         u16 vid = 0;
 364
 365         if (mlxsw_sp_l3addr_is_zero(gw))
 366                 gw = daddr;
 367
 368         if (!edev || mlxsw_sp_span_dmac(tbl, &gw, edev, dmac))
 369                 goto unoffloadable;
 370
 371         if (is_vlan_dev(edev))
 372                 edev = mlxsw_sp_span_entry_vlan(edev, &vid);
 373
 374         if (netif_is_bridge_master(edev)) {
 375                 edev = mlxsw_sp_span_entry_bridge(edev, dmac, &vid);
 376                 if (!edev)
 377                         goto unoffloadable;
 378         }
 379
 380         if (is_vlan_dev(edev)) {
 381                 if (vid || !(edev->flags & IFF_UP))
 382                         goto unoffloadable;
 383                 edev = mlxsw_sp_span_entry_vlan(edev, &vid);
 384         }
 385
 386         if (netif_is_lag_master(edev)) {
 387                 if (!(edev->flags & IFF_UP))
 388                         goto unoffloadable;
 389                 edev = mlxsw_sp_span_entry_lag(edev);
 390                 if (!edev)
 391                         goto unoffloadable;
 392         }
 393
 394         if (!mlxsw_sp_port_dev_check(edev))
 395                 goto unoffloadable;
 396
 397         sparmsp->dest_port = netdev_priv(edev);
 398         sparmsp->ttl = ttl;
 399         memcpy(sparmsp->dmac, dmac, ETH_ALEN);
 400         memcpy(sparmsp->smac, edev->dev_addr, ETH_ALEN);
 401         sparmsp->saddr = saddr;
 402         sparmsp->daddr = daddr;
 403         sparmsp->vid = vid;
 404         return 0;
 405
 406 unoffloadable:
 407         return mlxsw_sp_span_entry_unoffloadable(sparmsp);
 408 }
 409
 410 #if IS_ENABLED(CONFIG_NET_IPGRE)
 411 static struct net_device *
 412 mlxsw_sp_span_gretap4_route(const struct net_device *to_dev,
 413                             __be32 *saddrp, __be32 *daddrp)
 414 {
 415         struct ip_tunnel *tun = netdev_priv(to_dev);
 416         struct net_device *dev = NULL;
 417         struct ip_tunnel_parm parms;
 418         struct rtable *rt = NULL;
 419         struct flowi4 fl4;
 420
 421         /* We assume "dev" stays valid after rt is put. */
 422         ASSERT_RTNL();
 423
 424         parms = mlxsw_sp_ipip_netdev_parms4(to_dev);
 425         ip_tunnel_init_flow(&fl4, parms.iph.protocol, *daddrp, *saddrp,
 426                             0, 0, dev_net(to_dev), parms.link, tun->fwmark, 0,
 427                             0);
 428
 429         rt = ip_route_output_key(tun->net, &fl4);
 430         if (IS_ERR(rt))
 431                 return NULL;
 432
 433         if (rt->rt_type != RTN_UNICAST)
 434                 goto out;
 435
 436         dev = rt->dst.dev;
 437         *saddrp = fl4.saddr;
 438         if (rt->rt_gw_family == AF_INET)
 439                 *daddrp = rt->rt_gw4;
 440         /* can not offload if route has an IPv6 gateway */
 441         else if (rt->rt_gw_family == AF_INET6)
 442                 dev = NULL;
 443
 444 out:
 445         ip_rt_put(rt);
 446         return dev;
 447 }
 448
 449 static int
 450 mlxsw_sp_span_entry_gretap4_parms(struct mlxsw_sp *mlxsw_sp,
 451                                   const struct net_device *to_dev,
 452                                   struct mlxsw_sp_span_parms *sparmsp)
 453 {
 454         struct ip_tunnel_parm tparm = mlxsw_sp_ipip_netdev_parms4(to_dev);
 455         union mlxsw_sp_l3addr saddr = { .addr4 = tparm.iph.saddr };
 456         union mlxsw_sp_l3addr daddr = { .addr4 = tparm.iph.daddr };
 457         bool inherit_tos = tparm.iph.tos & 0x1;
 458         bool inherit_ttl = !tparm.iph.ttl;
 459         union mlxsw_sp_l3addr gw = daddr;
 460         struct net_device *l3edev;
 461
 462         if (!(to_dev->flags & IFF_UP) ||
 463             /* Reject tunnels with GRE keys, checksums, etc. */
 464             tparm.i_flags || tparm.o_flags ||
 465             /* Require a fixed TTL and a TOS copied from the mirrored packet. */
 466             inherit_ttl || !inherit_tos ||
 467             /* A destination address may not be "any". */
 468             mlxsw_sp_l3addr_is_zero(daddr))
 469                 return mlxsw_sp_span_entry_unoffloadable(sparmsp);
 470
 471         l3edev = mlxsw_sp_span_gretap4_route(to_dev, &saddr.addr4, &gw.addr4);
 472         return mlxsw_sp_span_entry_tunnel_parms_common(l3edev, saddr, daddr, gw,
 473                                                        tparm.iph.ttl,
 474                                                        &arp_tbl, sparmsp);
 475 }
 476
 477 static int
 478 mlxsw_sp_span_entry_gretap4_configure(struct mlxsw_sp_span_entry *span_entry,
 479                                       struct mlxsw_sp_span_parms sparms)
 480 {
 481         struct mlxsw_sp_port *dest_port = sparms.dest_port;
 482         struct mlxsw_sp *mlxsw_sp = dest_port->mlxsw_sp;
 483         u16 local_port = dest_port->local_port;
 484         char mpat_pl[MLXSW_REG_MPAT_LEN];
 485         int pa_id = span_entry->id;
 486
 487         /* Create a new port analayzer entry for local_port. */
 488         mlxsw_reg_mpat_pack(mpat_pl, pa_id, local_port, true,
 489                             MLXSW_REG_MPAT_SPAN_TYPE_REMOTE_ETH_L3);
 490         mlxsw_reg_mpat_pide_set(mpat_pl, sparms.policer_enable);
 491         mlxsw_reg_mpat_pid_set(mpat_pl, sparms.policer_id);
 492         mlxsw_reg_mpat_eth_rspan_pack(mpat_pl, sparms.vid);
 493         mlxsw_reg_mpat_eth_rspan_l2_pack(mpat_pl,
 494                                     MLXSW_REG_MPAT_ETH_RSPAN_VERSION_NO_HEADER,
 495                                     sparms.dmac, !!sparms.vid);
 496         mlxsw_reg_mpat_eth_rspan_l3_ipv4_pack(mpat_pl,
 497                                               sparms.ttl, sparms.smac,
 498                                               be32_to_cpu(sparms.saddr.addr4),
 499                                               be32_to_cpu(sparms.daddr.addr4));
 500
 501         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(mpat), mpat_pl);
 502 }
 503
 504 static void
 505 mlxsw_sp_span_entry_gretap4_deconfigure(struct mlxsw_sp_span_entry *span_entry)
 506 {
 507         mlxsw_sp_span_entry_deconfigure_common(span_entry,
 508                                         MLXSW_REG_MPAT_SPAN_TYPE_REMOTE_ETH_L3);
 509 }
 510
 511 static const struct mlxsw_sp_span_entry_ops mlxsw_sp_span_entry_ops_gretap4 = {
 512         .can_handle = netif_is_gretap,
 513         .parms_set = mlxsw_sp_span_entry_gretap4_parms,
 514         .configure = mlxsw_sp_span_entry_gretap4_configure,
 515         .deconfigure = mlxsw_sp_span_entry_gretap4_deconfigure,
 516 };
 517 #endif
 518
 519 #if IS_ENABLED(CONFIG_IPV6_GRE)
 520 static struct net_device *
 521 mlxsw_sp_span_gretap6_route(const struct net_device *to_dev,
 522                             struct in6_addr *saddrp,
 523                             struct in6_addr *daddrp)
 524 {
 525         struct ip6_tnl *t = netdev_priv(to_dev);
 526         struct flowi6 fl6 = t->fl.u.ip6;
 527         struct net_device *dev = NULL;
 528         struct dst_entry *dst;
 529         struct rt6_info *rt6;
 530
 531         /* We assume "dev" stays valid after dst is released. */
 532         ASSERT_RTNL();
 533
 534         fl6.flowi6_mark = t->parms.fwmark;
 535         if (!ip6_tnl_xmit_ctl(t, &fl6.saddr, &fl6.daddr))
 536                 return NULL;
 537
 538         dst = ip6_route_output(t->net, NULL, &fl6);
 539         if (!dst || dst->error)
 540                 goto out;
 541
 542         rt6 = container_of(dst, struct rt6_info, dst);
 543
 544         dev = dst->dev;
 545         *saddrp = fl6.saddr;
 546         *daddrp = rt6->rt6i_gateway;
 547
 548 out:
 549         dst_release(dst);
 550         return dev;
 551 }
 552
 553 static int
 554 mlxsw_sp_span_entry_gretap6_parms(struct mlxsw_sp *mlxsw_sp,
 555                                   const struct net_device *to_dev,
 556                                   struct mlxsw_sp_span_parms *sparmsp)
 557 {
 558         struct __ip6_tnl_parm tparm = mlxsw_sp_ipip_netdev_parms6(to_dev);
 559         bool inherit_tos = tparm.flags & IP6_TNL_F_USE_ORIG_TCLASS;
 560         union mlxsw_sp_l3addr saddr = { .addr6 = tparm.laddr };
 561         union mlxsw_sp_l3addr daddr = { .addr6 = tparm.raddr };
 562         bool inherit_ttl = !tparm.hop_limit;
 563         union mlxsw_sp_l3addr gw = daddr;
 564         struct net_device *l3edev;
 565
 566         if (!(to_dev->flags & IFF_UP) ||
 567             /* Reject tunnels with GRE keys, checksums, etc. */
 568             tparm.i_flags || tparm.o_flags ||
 569             /* Require a fixed TTL and a TOS copied from the mirrored packet. */
 570             inherit_ttl || !inherit_tos ||
 571             /* A destination address may not be "any". */
 572             mlxsw_sp_l3addr_is_zero(daddr))
 573                 return mlxsw_sp_span_entry_unoffloadable(sparmsp);
 574
 575         l3edev = mlxsw_sp_span_gretap6_route(to_dev, &saddr.addr6, &gw.addr6);
 576         return mlxsw_sp_span_entry_tunnel_parms_common(l3edev, saddr, daddr, gw,
 577                                                        tparm.hop_limit,
 578                                                        &nd_tbl, sparmsp);
 579 }
 580
 581 static int
 582 mlxsw_sp_span_entry_gretap6_configure(struct mlxsw_sp_span_entry *span_entry,
 583                                       struct mlxsw_sp_span_parms sparms)
 584 {
 585         struct mlxsw_sp_port *dest_port = sparms.dest_port;
 586         struct mlxsw_sp *mlxsw_sp = dest_port->mlxsw_sp;
 587         u16 local_port = dest_port->local_port;
 588         char mpat_pl[MLXSW_REG_MPAT_LEN];
 589         int pa_id = span_entry->id;
 590
 591         /* Create a new port analayzer entry for local_port. */
 592         mlxsw_reg_mpat_pack(mpat_pl, pa_id, local_port, true,
 593                             MLXSW_REG_MPAT_SPAN_TYPE_REMOTE_ETH_L3);
 594         mlxsw_reg_mpat_pide_set(mpat_pl, sparms.policer_enable);
 595         mlxsw_reg_mpat_pid_set(mpat_pl, sparms.policer_id);
 596         mlxsw_reg_mpat_eth_rspan_pack(mpat_pl, sparms.vid);
 597         mlxsw_reg_mpat_eth_rspan_l2_pack(mpat_pl,
 598                                     MLXSW_REG_MPAT_ETH_RSPAN_VERSION_NO_HEADER,
 599                                     sparms.dmac, !!sparms.vid);
 600         mlxsw_reg_mpat_eth_rspan_l3_ipv6_pack(mpat_pl, sparms.ttl, sparms.smac,
 601                                               sparms.saddr.addr6,
 602                                               sparms.daddr.addr6);
 603
 604         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(mpat), mpat_pl);
 605 }
 606
 607 static void
 608 mlxsw_sp_span_entry_gretap6_deconfigure(struct mlxsw_sp_span_entry *span_entry)
 609 {
 610         mlxsw_sp_span_entry_deconfigure_common(span_entry,
 611                                         MLXSW_REG_MPAT_SPAN_TYPE_REMOTE_ETH_L3);
 612 }
 613
 614 static const
 615 struct mlxsw_sp_span_entry_ops mlxsw_sp_span_entry_ops_gretap6 = {
 616         .can_handle = netif_is_ip6gretap,
 617         .parms_set = mlxsw_sp_span_entry_gretap6_parms,
 618         .configure = mlxsw_sp_span_entry_gretap6_configure,
 619         .deconfigure = mlxsw_sp_span_entry_gretap6_deconfigure,
 620 };
 621 #endif
 622
 623 static bool
 624 mlxsw_sp_span_vlan_can_handle(const struct net_device *dev)
 625 {
 626         return is_vlan_dev(dev) &&
 627                mlxsw_sp_port_dev_check(vlan_dev_real_dev(dev));
 628 }
 629
 630 static int
 631 mlxsw_sp_span_entry_vlan_parms(struct mlxsw_sp *mlxsw_sp,
 632                                const struct net_device *to_dev,
 633                                struct mlxsw_sp_span_parms *sparmsp)
 634 {
 635         struct net_device *real_dev;
 636         u16 vid;
 637
 638         if (!(to_dev->flags & IFF_UP))
 639                 return mlxsw_sp_span_entry_unoffloadable(sparmsp);
 640
 641         real_dev = mlxsw_sp_span_entry_vlan(to_dev, &vid);
 642         sparmsp->dest_port = netdev_priv(real_dev);
 643         sparmsp->vid = vid;
 644         return 0;
 645 }
 646
 647 static int
 648 mlxsw_sp_span_entry_vlan_configure(struct mlxsw_sp_span_entry *span_entry,
 649                                    struct mlxsw_sp_span_parms sparms)
 650 {
 651         struct mlxsw_sp_port *dest_port = sparms.dest_port;
 652         struct mlxsw_sp *mlxsw_sp = dest_port->mlxsw_sp;
 653         u16 local_port = dest_port->local_port;
 654         char mpat_pl[MLXSW_REG_MPAT_LEN];
 655         int pa_id = span_entry->id;
 656
 657         mlxsw_reg_mpat_pack(mpat_pl, pa_id, local_port, true,
 658                             MLXSW_REG_MPAT_SPAN_TYPE_REMOTE_ETH);
 659         mlxsw_reg_mpat_pide_set(mpat_pl, sparms.policer_enable);
 660         mlxsw_reg_mpat_pid_set(mpat_pl, sparms.policer_id);
 661         mlxsw_reg_mpat_eth_rspan_pack(mpat_pl, sparms.vid);
 662
 663         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(mpat), mpat_pl);
 664 }
 665
 666 static void
 667 mlxsw_sp_span_entry_vlan_deconfigure(struct mlxsw_sp_span_entry *span_entry)
 668 {
 669         mlxsw_sp_span_entry_deconfigure_common(span_entry,
 670                                         MLXSW_REG_MPAT_SPAN_TYPE_REMOTE_ETH);
 671 }
 672
 673 static const
 674 struct mlxsw_sp_span_entry_ops mlxsw_sp_span_entry_ops_vlan = {
 675         .can_handle = mlxsw_sp_span_vlan_can_handle,
 676         .parms_set = mlxsw_sp_span_entry_vlan_parms,
 677         .configure = mlxsw_sp_span_entry_vlan_configure,
 678         .deconfigure = mlxsw_sp_span_entry_vlan_deconfigure,
 679 };
 680
 681 static const
 682 struct mlxsw_sp_span_entry_ops *mlxsw_sp1_span_entry_ops_arr[] = {
 683         &mlxsw_sp1_span_entry_ops_cpu,
 684         &mlxsw_sp_span_entry_ops_phys,
 685 #if IS_ENABLED(CONFIG_NET_IPGRE)
 686         &mlxsw_sp_span_entry_ops_gretap4,
 687 #endif
 688 #if IS_ENABLED(CONFIG_IPV6_GRE)
 689         &mlxsw_sp_span_entry_ops_gretap6,
 690 #endif
 691         &mlxsw_sp_span_entry_ops_vlan,
 692 };
 693
 694 static bool mlxsw_sp2_span_cpu_can_handle(const struct net_device *dev)
 695 {
 696         return !dev;
 697 }
 698
 699 static int mlxsw_sp2_span_entry_cpu_parms(struct mlxsw_sp *mlxsw_sp,
 700                                           const struct net_device *to_dev,
 701                                           struct mlxsw_sp_span_parms *sparmsp)
 702 {
 703         sparmsp->dest_port = mlxsw_sp->ports[MLXSW_PORT_CPU_PORT];
 704         return 0;
 705 }
 706
 707 static int
 708 mlxsw_sp2_span_entry_cpu_configure(struct mlxsw_sp_span_entry *span_entry,
 709                                    struct mlxsw_sp_span_parms sparms)
 710 {
 711         /* Mirroring to the CPU port is like mirroring to any other physical
 712          * port. Its local port is used instead of that of the physical port.
 713          */
 714         return mlxsw_sp_span_entry_phys_configure(span_entry, sparms);
 715 }
 716
 717 static void
 718 mlxsw_sp2_span_entry_cpu_deconfigure(struct mlxsw_sp_span_entry *span_entry)
 719 {
 720         enum mlxsw_reg_mpat_span_type span_type;
 721
 722         span_type = MLXSW_REG_MPAT_SPAN_TYPE_LOCAL_ETH;
 723         mlxsw_sp_span_entry_deconfigure_common(span_entry, span_type);
 724 }
 725
 726 static const
 727 struct mlxsw_sp_span_entry_ops mlxsw_sp2_span_entry_ops_cpu = {
 728         .is_static = true,
 729         .can_handle = mlxsw_sp2_span_cpu_can_handle,
 730         .parms_set = mlxsw_sp2_span_entry_cpu_parms,
 731         .configure = mlxsw_sp2_span_entry_cpu_configure,
 732         .deconfigure = mlxsw_sp2_span_entry_cpu_deconfigure,
 733 };
 734
 735 static const
 736 struct mlxsw_sp_span_entry_ops *mlxsw_sp2_span_entry_ops_arr[] = {
 737         &mlxsw_sp2_span_entry_ops_cpu,
 738         &mlxsw_sp_span_entry_ops_phys,
 739 #if IS_ENABLED(CONFIG_NET_IPGRE)
 740         &mlxsw_sp_span_entry_ops_gretap4,
 741 #endif
 742 #if IS_ENABLED(CONFIG_IPV6_GRE)
 743         &mlxsw_sp_span_entry_ops_gretap6,
 744 #endif
 745         &mlxsw_sp_span_entry_ops_vlan,
 746 };
 747
 748 static int
 749 mlxsw_sp_span_entry_nop_parms(struct mlxsw_sp *mlxsw_sp,
 750                               const struct net_device *to_dev,
 751                               struct mlxsw_sp_span_parms *sparmsp)
 752 {
 753         return mlxsw_sp_span_entry_unoffloadable(sparmsp);
 754 }
 755
 756 static int
 757 mlxsw_sp_span_entry_nop_configure(struct mlxsw_sp_span_entry *span_entry,
 758                                   struct mlxsw_sp_span_parms sparms)
 759 {
 760         return 0;
 761 }
 762
 763 static void
 764 mlxsw_sp_span_entry_nop_deconfigure(struct mlxsw_sp_span_entry *span_entry)
 765 {
 766 }
 767
 768 static const struct mlxsw_sp_span_entry_ops mlxsw_sp_span_entry_ops_nop = {
 769         .parms_set = mlxsw_sp_span_entry_nop_parms,
 770         .configure = mlxsw_sp_span_entry_nop_configure,
 771         .deconfigure = mlxsw_sp_span_entry_nop_deconfigure,
 772 };
 773
 774 static void
 775 mlxsw_sp_span_entry_configure(struct mlxsw_sp *mlxsw_sp,
 776                               struct mlxsw_sp_span_entry *span_entry,
 777                               struct mlxsw_sp_span_parms sparms)
 778 {
 779         int err;
 780
 781         if (!sparms.dest_port)
 782                 goto set_parms;
 783
 784         if (sparms.dest_port->mlxsw_sp != mlxsw_sp) {
 785                 dev_err(mlxsw_sp->bus_info->dev,
 786                         "Cannot mirror to a port which belongs to a different mlxsw instance\n");
 787                 sparms.dest_port = NULL;
 788                 goto set_parms;
 789         }
 790
 791         err = span_entry->ops->configure(span_entry, sparms);
 792         if (err) {
 793                 dev_err(mlxsw_sp->bus_info->dev, "Failed to offload mirror\n");
 794                 sparms.dest_port = NULL;
 795                 goto set_parms;
 796         }
 797
 798 set_parms:
 799         span_entry->parms = sparms;
 800 }
 801
 802 static void
 803 mlxsw_sp_span_entry_deconfigure(struct mlxsw_sp_span_entry *span_entry)
 804 {
 805         if (span_entry->parms.dest_port)
 806                 span_entry->ops->deconfigure(span_entry);
 807 }
 808
 809 static int mlxsw_sp_span_policer_id_base_set(struct mlxsw_sp_span *span,
 810                                              u16 policer_id)
 811 {
 812         struct mlxsw_sp *mlxsw_sp = span->mlxsw_sp;
 813         u16 policer_id_base;
 814         int err;
 815
 816         /* Policers set on SPAN agents must be in the range of
 817          * `policer_id_base .. policer_id_base + max_span_agents - 1`. If the
 818          * base is set and the new policer is not within the range, then we
 819          * must error out.
 820          */
 821         if (refcount_read(&span->policer_id_base_ref_count)) {
 822                 if (policer_id < span->policer_id_base ||
 823                     policer_id >= span->policer_id_base + span->entries_count)
 824                         return -EINVAL;
 825
 826                 refcount_inc(&span->policer_id_base_ref_count);
 827                 return 0;
 828         }
 829
 830         /* Base must be even. */
 831         policer_id_base = policer_id % 2 == 0 ? policer_id : policer_id - 1;
 832         err = mlxsw_sp->span_ops->policer_id_base_set(mlxsw_sp,
 833                                                       policer_id_base);
 834         if (err)
 835                 return err;
 836
 837         span->policer_id_base = policer_id_base;
 838         refcount_set(&span->policer_id_base_ref_count, 1);
 839
 840         return 0;
 841 }
 842
 843 static void mlxsw_sp_span_policer_id_base_unset(struct mlxsw_sp_span *span)
 844 {
 845         if (refcount_dec_and_test(&span->policer_id_base_ref_count))
 846                 span->policer_id_base = 0;
 847 }
 848
 849 static struct mlxsw_sp_span_entry *
 850 mlxsw_sp_span_entry_create(struct mlxsw_sp *mlxsw_sp,
 851                            const struct net_device *to_dev,
 852                            const struct mlxsw_sp_span_entry_ops *ops,
 853                            struct mlxsw_sp_span_parms sparms)
 854 {
 855         struct mlxsw_sp_span_entry *span_entry = NULL;
 856         int i;
 857
 858         /* find a free entry to use */
 859         for (i = 0; i < mlxsw_sp->span->entries_count; i++) {
 860                 if (!refcount_read(&mlxsw_sp->span->entries[i].ref_count)) {
 861                         span_entry = &mlxsw_sp->span->entries[i];
 862                         break;
 863                 }
 864         }
 865         if (!span_entry)
 866                 return NULL;
 867
 868         if (sparms.policer_enable) {
 869                 int err;
 870
 871                 err = mlxsw_sp_span_policer_id_base_set(mlxsw_sp->span,
 872                                                         sparms.policer_id);
 873                 if (err)
 874                         return NULL;
 875         }
 876
 877         atomic_inc(&mlxsw_sp->span->active_entries_count);
 878         span_entry->ops = ops;
 879         refcount_set(&span_entry->ref_count, 1);
 880         span_entry->to_dev = to_dev;
 881         mlxsw_sp_span_entry_configure(mlxsw_sp, span_entry, sparms);
 882
 883         return span_entry;
 884 }
 885
 886 static void mlxsw_sp_span_entry_destroy(struct mlxsw_sp *mlxsw_sp,
 887                                         struct mlxsw_sp_span_entry *span_entry)
 888 {
 889         mlxsw_sp_span_entry_deconfigure(span_entry);
 890         atomic_dec(&mlxsw_sp->span->active_entries_count);
 891         if (span_entry->parms.policer_enable)
 892                 mlxsw_sp_span_policer_id_base_unset(mlxsw_sp->span);
 893 }
 894
 895 struct mlxsw_sp_span_entry *
 896 mlxsw_sp_span_entry_find_by_port(struct mlxsw_sp *mlxsw_sp,
 897                                  const struct net_device *to_dev)
 898 {
 899         int i;
 900
 901         for (i = 0; i < mlxsw_sp->span->entries_count; i++) {
 902                 struct mlxsw_sp_span_entry *curr = &mlxsw_sp->span->entries[i];
 903
 904                 if (refcount_read(&curr->ref_count) && curr->to_dev == to_dev)
 905                         return curr;
 906         }
 907         return NULL;
 908 }
 909
 910 void mlxsw_sp_span_entry_invalidate(struct mlxsw_sp *mlxsw_sp,
 911                                     struct mlxsw_sp_span_entry *span_entry)
 912 {
 913         mlxsw_sp_span_entry_deconfigure(span_entry);
 914         span_entry->ops = &mlxsw_sp_span_entry_ops_nop;
 915 }
 916
 917 static struct mlxsw_sp_span_entry *
 918 mlxsw_sp_span_entry_find_by_id(struct mlxsw_sp *mlxsw_sp, int span_id)
 919 {
 920         int i;
 921
 922         for (i = 0; i < mlxsw_sp->span->entries_count; i++) {
 923                 struct mlxsw_sp_span_entry *curr = &mlxsw_sp->span->entries[i];
 924
 925                 if (refcount_read(&curr->ref_count) && curr->id == span_id)
 926                         return curr;
 927         }
 928         return NULL;
 929 }
 930
 931 static struct mlxsw_sp_span_entry *
 932 mlxsw_sp_span_entry_find_by_parms(struct mlxsw_sp *mlxsw_sp,
 933                                   const struct net_device *to_dev,
 934                                   const struct mlxsw_sp_span_parms *sparms)
 935 {
 936         int i;
 937
 938         for (i = 0; i < mlxsw_sp->span->entries_count; i++) {
 939                 struct mlxsw_sp_span_entry *curr = &mlxsw_sp->span->entries[i];
 940
 941                 if (refcount_read(&curr->ref_count) && curr->to_dev == to_dev &&
 942                     curr->parms.policer_enable == sparms->policer_enable &&
 943                     curr->parms.policer_id == sparms->policer_id &&
 944                     curr->parms.session_id == sparms->session_id)
 945                         return curr;
 946         }
 947         return NULL;
 948 }
 949
 950 static struct mlxsw_sp_span_entry *
 951 mlxsw_sp_span_entry_get(struct mlxsw_sp *mlxsw_sp,
 952                         const struct net_device *to_dev,
 953                         const struct mlxsw_sp_span_entry_ops *ops,
 954                         struct mlxsw_sp_span_parms sparms)
 955 {
 956         struct mlxsw_sp_span_entry *span_entry;
 957
 958         span_entry = mlxsw_sp_span_entry_find_by_parms(mlxsw_sp, to_dev,
 959                                                        &sparms);
 960         if (span_entry) {
 961                 /* Already exists, just take a reference */
 962                 refcount_inc(&span_entry->ref_count);
 963                 return span_entry;
 964         }
 965
 966         return mlxsw_sp_span_entry_create(mlxsw_sp, to_dev, ops, sparms);
 967 }
 968
 969 static int mlxsw_sp_span_entry_put(struct mlxsw_sp *mlxsw_sp,
 970                                    struct mlxsw_sp_span_entry *span_entry)
 971 {
 972         if (refcount_dec_and_test(&span_entry->ref_count))
 973                 mlxsw_sp_span_entry_destroy(mlxsw_sp, span_entry);
 974         return 0;
 975 }
 976
 977 static int mlxsw_sp_span_port_buffer_update(struct mlxsw_sp_port *mlxsw_sp_port, bool enable)
 978 {
 979         struct mlxsw_sp_hdroom hdroom;
 980
 981         hdroom = *mlxsw_sp_port->hdroom;
 982         hdroom.int_buf.enable = enable;
 983         mlxsw_sp_hdroom_bufs_reset_sizes(mlxsw_sp_port, &hdroom);
 984
 985         return mlxsw_sp_hdroom_configure(mlxsw_sp_port, &hdroom);
 986 }
 987
 988 static int
 989 mlxsw_sp_span_port_buffer_enable(struct mlxsw_sp_port *mlxsw_sp_port)
 990 {
 991         return mlxsw_sp_span_port_buffer_update(mlxsw_sp_port, true);
 992 }
 993
 994 static void mlxsw_sp_span_port_buffer_disable(struct mlxsw_sp_port *mlxsw_sp_port)
 995 {
 996         mlxsw_sp_span_port_buffer_update(mlxsw_sp_port, false);
 997 }
 998
 999 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 };