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

   1 /*
   2  * drivers/net/ethernet/mellanox/mlxsw/spectrum.c
   3  * Copyright (c) 2015 Mellanox Technologies. All rights reserved.
   4  * Copyright (c) 2015 Jiri Pirko <jiri@mellanox.com>
   5  * Copyright (c) 2015 Ido Schimmel <idosch@mellanox.com>
   6  * Copyright (c) 2015 Elad Raz <eladr@mellanox.com>
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions are met:
  10  *
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. Neither the names of the copyright holders nor the names of its
  17  *    contributors may be used to endorse or promote products derived from
  18  *    this software without specific prior written permission.
  19  *
  20  * Alternatively, this software may be distributed under the terms of the
  21  * GNU General Public License ("GPL") version 2 as published by the Free
  22  * Software Foundation.
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  25  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  28  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  29  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  30  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  31  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  32  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  33  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  34  * POSSIBILITY OF SUCH DAMAGE.
  35  */
  36
  37 #include <linux/kernel.h>
  38 #include <linux/module.h>
  39 #include <linux/types.h>
  40 #include <linux/netdevice.h>
  41 #include <linux/etherdevice.h>
  42 #include <linux/ethtool.h>
  43 #include <linux/slab.h>
  44 #include <linux/device.h>
  45 #include <linux/skbuff.h>
  46 #include <linux/if_vlan.h>
  47 #include <linux/if_bridge.h>
  48 #include <linux/workqueue.h>
  49 #include <linux/jiffies.h>
  50 #include <linux/bitops.h>
  51 #include <linux/list.h>
  52 #include <net/switchdev.h>
  53 #include <generated/utsrelease.h>
  54
  55 #include "spectrum.h"
  56 #include "core.h"
  57 #include "reg.h"
  58 #include "port.h"
  59 #include "trap.h"
  60 #include "txheader.h"
  61
  62 static const char mlxsw_sp_driver_name[] = "mlxsw_spectrum";
  63 static const char mlxsw_sp_driver_version[] = "1.0";
  64
  65 /* tx_hdr_version
  66  * Tx header version.
  67  * Must be set to 1.
  68  */
  69 MLXSW_ITEM32(tx, hdr, version, 0x00, 28, 4);
  70
  71 /* tx_hdr_ctl
  72  * Packet control type.
  73  * 0 - Ethernet control (e.g. EMADs, LACP)
  74  * 1 - Ethernet data
  75  */
  76 MLXSW_ITEM32(tx, hdr, ctl, 0x00, 26, 2);
  77
  78 /* tx_hdr_proto
  79  * Packet protocol type. Must be set to 1 (Ethernet).
  80  */
  81 MLXSW_ITEM32(tx, hdr, proto, 0x00, 21, 3);
  82
  83 /* tx_hdr_rx_is_router
  84  * Packet is sent from the router. Valid for data packets only.
  85  */
  86 MLXSW_ITEM32(tx, hdr, rx_is_router, 0x00, 19, 1);
  87
  88 /* tx_hdr_fid_valid
  89  * Indicates if the 'fid' field is valid and should be used for
  90  * forwarding lookup. Valid for data packets only.
  91  */
  92 MLXSW_ITEM32(tx, hdr, fid_valid, 0x00, 16, 1);
  93
  94 /* tx_hdr_swid
  95  * Switch partition ID. Must be set to 0.
  96  */
  97 MLXSW_ITEM32(tx, hdr, swid, 0x00, 12, 3);
  98
  99 /* tx_hdr_control_tclass
 100  * Indicates if the packet should use the control TClass and not one
 101  * of the data TClasses.
 102  */
 103 MLXSW_ITEM32(tx, hdr, control_tclass, 0x00, 6, 1);
 104
 105 /* tx_hdr_etclass
 106  * Egress TClass to be used on the egress device on the egress port.
 107  */
 108 MLXSW_ITEM32(tx, hdr, etclass, 0x00, 0, 4);
 109
 110 /* tx_hdr_port_mid
 111  * Destination local port for unicast packets.
 112  * Destination multicast ID for multicast packets.
 113  *
 114  * Control packets are directed to a specific egress port, while data
 115  * packets are transmitted through the CPU port (0) into the switch partition,
 116  * where forwarding rules are applied.
 117  */
 118 MLXSW_ITEM32(tx, hdr, port_mid, 0x04, 16, 16);
 119
 120 /* tx_hdr_fid
 121  * Forwarding ID used for L2 forwarding lookup. Valid only if 'fid_valid' is
 122  * set, otherwise calculated based on the packet's VID using VID to FID mapping.
 123  * Valid for data packets only.
 124  */
 125 MLXSW_ITEM32(tx, hdr, fid, 0x08, 0, 16);
 126
 127 /* tx_hdr_type
 128  * 0 - Data packets
 129  * 6 - Control packets
 130  */
 131 MLXSW_ITEM32(tx, hdr, type, 0x0C, 0, 4);
 132
 133 static void mlxsw_sp_txhdr_construct(struct sk_buff *skb,
 134                                      const struct mlxsw_tx_info *tx_info)
 135 {
 136         char *txhdr = skb_push(skb, MLXSW_TXHDR_LEN);
 137
 138         memset(txhdr, 0, MLXSW_TXHDR_LEN);
 139
 140         mlxsw_tx_hdr_version_set(txhdr, MLXSW_TXHDR_VERSION_1);
 141         mlxsw_tx_hdr_ctl_set(txhdr, MLXSW_TXHDR_ETH_CTL);
 142         mlxsw_tx_hdr_proto_set(txhdr, MLXSW_TXHDR_PROTO_ETH);
 143         mlxsw_tx_hdr_swid_set(txhdr, 0);
 144         mlxsw_tx_hdr_control_tclass_set(txhdr, 1);
 145         mlxsw_tx_hdr_port_mid_set(txhdr, tx_info->local_port);
 146         mlxsw_tx_hdr_type_set(txhdr, MLXSW_TXHDR_TYPE_CONTROL);
 147 }
 148
 149 static int mlxsw_sp_base_mac_get(struct mlxsw_sp *mlxsw_sp)
 150 {
 151         char spad_pl[MLXSW_REG_SPAD_LEN];
 152         int err;
 153
 154         err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(spad), spad_pl);
 155         if (err)
 156                 return err;
 157         mlxsw_reg_spad_base_mac_memcpy_from(spad_pl, mlxsw_sp->base_mac);
 158         return 0;
 159 }
 160
 161 static int mlxsw_sp_port_admin_status_set(struct mlxsw_sp_port *mlxsw_sp_port,
 162                                           bool is_up)
 163 {
 164         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
 165         char paos_pl[MLXSW_REG_PAOS_LEN];
 166
 167         mlxsw_reg_paos_pack(paos_pl, mlxsw_sp_port->local_port,
 168                             is_up ? MLXSW_PORT_ADMIN_STATUS_UP :
 169                             MLXSW_PORT_ADMIN_STATUS_DOWN);
 170         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(paos), paos_pl);
 171 }
 172
 173 static int mlxsw_sp_port_oper_status_get(struct mlxsw_sp_port *mlxsw_sp_port,
 174                                          bool *p_is_up)
 175 {
 176         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
 177         char paos_pl[MLXSW_REG_PAOS_LEN];
 178         u8 oper_status;
 179         int err;
 180
 181         mlxsw_reg_paos_pack(paos_pl, mlxsw_sp_port->local_port, 0);
 182         err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(paos), paos_pl);
 183         if (err)
 184                 return err;
 185         oper_status = mlxsw_reg_paos_oper_status_get(paos_pl);
 186         *p_is_up = oper_status == MLXSW_PORT_ADMIN_STATUS_UP ? true : false;
 187         return 0;
 188 }
 189
 190 static int mlxsw_sp_port_dev_addr_set(struct mlxsw_sp_port *mlxsw_sp_port,
 191                                       unsigned char *addr)
 192 {
 193         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
 194         char ppad_pl[MLXSW_REG_PPAD_LEN];
 195
 196         mlxsw_reg_ppad_pack(ppad_pl, true, mlxsw_sp_port->local_port);
 197         mlxsw_reg_ppad_mac_memcpy_to(ppad_pl, addr);
 198         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ppad), ppad_pl);
 199 }
 200
 201 static int mlxsw_sp_port_dev_addr_init(struct mlxsw_sp_port *mlxsw_sp_port)
 202 {
 203         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
 204         unsigned char *addr = mlxsw_sp_port->dev->dev_addr;
 205
 206         ether_addr_copy(addr, mlxsw_sp->base_mac);
 207         addr[ETH_ALEN - 1] += mlxsw_sp_port->local_port;
 208         return mlxsw_sp_port_dev_addr_set(mlxsw_sp_port, addr);
 209 }
 210
 211 static int mlxsw_sp_port_stp_state_set(struct mlxsw_sp_port *mlxsw_sp_port,
 212                                        u16 vid, enum mlxsw_reg_spms_state state)
 213 {
 214         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
 215         char *spms_pl;
 216         int err;
 217
 218         spms_pl = kmalloc(MLXSW_REG_SPMS_LEN, GFP_KERNEL);
 219         if (!spms_pl)
 220                 return -ENOMEM;
 221         mlxsw_reg_spms_pack(spms_pl, mlxsw_sp_port->local_port);
 222         mlxsw_reg_spms_vid_pack(spms_pl, vid, state);
 223         err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(spms), spms_pl);
 224         kfree(spms_pl);
 225         return err;
 226 }
 227
 228 static int mlxsw_sp_port_mtu_set(struct mlxsw_sp_port *mlxsw_sp_port, u16 mtu)
 229 {
 230         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
 231         char pmtu_pl[MLXSW_REG_PMTU_LEN];
 232         int max_mtu;
 233         int err;
 234
 235         mtu += MLXSW_TXHDR_LEN + ETH_HLEN;
 236         mlxsw_reg_pmtu_pack(pmtu_pl, mlxsw_sp_port->local_port, 0);
 237         err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(pmtu), pmtu_pl);
 238         if (err)
 239                 return err;
 240         max_mtu = mlxsw_reg_pmtu_max_mtu_get(pmtu_pl);
 241
 242         if (mtu > max_mtu)
 243                 return -EINVAL;
 244
 245         mlxsw_reg_pmtu_pack(pmtu_pl, mlxsw_sp_port->local_port, mtu);
 246         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(pmtu), pmtu_pl);
 247 }
 248
 249 static int mlxsw_sp_port_swid_set(struct mlxsw_sp_port *mlxsw_sp_port, u8 swid)
 250 {
 251         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
 252         char pspa_pl[MLXSW_REG_PSPA_LEN];
 253
 254         mlxsw_reg_pspa_pack(pspa_pl, swid, mlxsw_sp_port->local_port);
 255         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(pspa), pspa_pl);
 256 }
 257
 258 static int mlxsw_sp_port_vp_mode_set(struct mlxsw_sp_port *mlxsw_sp_port,
 259                                      bool enable)
 260 {
 261         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
 262         char svpe_pl[MLXSW_REG_SVPE_LEN];
 263
 264         mlxsw_reg_svpe_pack(svpe_pl, mlxsw_sp_port->local_port, enable);
 265         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(svpe), svpe_pl);
 266 }
 267
 268 int mlxsw_sp_port_vid_to_fid_set(struct mlxsw_sp_port *mlxsw_sp_port,
 269                                  enum mlxsw_reg_svfa_mt mt, bool valid, u16 fid,
 270                                  u16 vid)
 271 {
 272         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
 273         char svfa_pl[MLXSW_REG_SVFA_LEN];
 274
 275         mlxsw_reg_svfa_pack(svfa_pl, mlxsw_sp_port->local_port, mt, valid,
 276                             fid, vid);
 277         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(svfa), svfa_pl);
 278 }
 279
 280 static int mlxsw_sp_port_vid_learning_set(struct mlxsw_sp_port *mlxsw_sp_port,
 281                                           u16 vid, bool learn_enable)
 282 {
 283         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
 284         char *spvmlr_pl;
 285         int err;
 286
 287         spvmlr_pl = kmalloc(MLXSW_REG_SPVMLR_LEN, GFP_KERNEL);
 288         if (!spvmlr_pl)
 289                 return -ENOMEM;
 290         mlxsw_reg_spvmlr_pack(spvmlr_pl, mlxsw_sp_port->local_port, vid, vid,
 291                               learn_enable);
 292         err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(spvmlr), spvmlr_pl);
 293         kfree(spvmlr_pl);
 294         return err;
 295 }
 296
 297 static int
 298 mlxsw_sp_port_system_port_mapping_set(struct mlxsw_sp_port *mlxsw_sp_port)
 299 {
 300         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
 301         char sspr_pl[MLXSW_REG_SSPR_LEN];
 302
 303         mlxsw_reg_sspr_pack(sspr_pl, mlxsw_sp_port->local_port);
 304         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sspr), sspr_pl);
 305 }
 306
 307 static int mlxsw_sp_port_module_check(struct mlxsw_sp_port *mlxsw_sp_port,
 308                                       bool *p_usable)
 309 {
 310         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
 311         char pmlp_pl[MLXSW_REG_PMLP_LEN];
 312         int err;
 313
 314         mlxsw_reg_pmlp_pack(pmlp_pl, mlxsw_sp_port->local_port);
 315         err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(pmlp), pmlp_pl);
 316         if (err)
 317                 return err;
 318         *p_usable = mlxsw_reg_pmlp_width_get(pmlp_pl) ? true : false;
 319         return 0;
 320 }
 321
 322 static int mlxsw_sp_port_open(struct net_device *dev)
 323 {
 324         struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
 325         int err;
 326
 327         err = mlxsw_sp_port_admin_status_set(mlxsw_sp_port, true);
 328         if (err)
 329                 return err;
 330         netif_start_queue(dev);
 331         return 0;
 332 }
 333
 334 static int mlxsw_sp_port_stop(struct net_device *dev)
 335 {
 336         struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
 337
 338         netif_stop_queue(dev);
 339         return mlxsw_sp_port_admin_status_set(mlxsw_sp_port, false);
 340 }
 341
 342 static netdev_tx_t mlxsw_sp_port_xmit(struct sk_buff *skb,
 343                                       struct net_device *dev)
 344 {
 345         struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
 346         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
 347         struct mlxsw_sp_port_pcpu_stats *pcpu_stats;
 348         const struct mlxsw_tx_info tx_info = {
 349                 .local_port = mlxsw_sp_port->local_port,
 350                 .is_emad = false,
 351         };
 352         u64 len;
 353         int err;
 354
 355         if (mlxsw_core_skb_transmit_busy(mlxsw_sp, &tx_info))
 356                 return NETDEV_TX_BUSY;
 357
 358         if (unlikely(skb_headroom(skb) < MLXSW_TXHDR_LEN)) {
 359                 struct sk_buff *skb_orig = skb;
 360
 361                 skb = skb_realloc_headroom(skb, MLXSW_TXHDR_LEN);
 362                 if (!skb) {
 363                         this_cpu_inc(mlxsw_sp_port->pcpu_stats->tx_dropped);
 364                         dev_kfree_skb_any(skb_orig);
 365                         return NETDEV_TX_OK;
 366                 }
 367         }
 368
 369         if (eth_skb_pad(skb)) {
 370                 this_cpu_inc(mlxsw_sp_port->pcpu_stats->tx_dropped);
 371                 return NETDEV_TX_OK;
 372         }
 373
 374         mlxsw_sp_txhdr_construct(skb, &tx_info);
 375         len = skb->len;
 376         /* Due to a race we might fail here because of a full queue. In that
 377          * unlikely case we simply drop the packet.
 378          */
 379         err = mlxsw_core_skb_transmit(mlxsw_sp, skb, &tx_info);
 380
 381         if (!err) {
 382                 pcpu_stats = this_cpu_ptr(mlxsw_sp_port->pcpu_stats);
 383                 u64_stats_update_begin(&pcpu_stats->syncp);
 384                 pcpu_stats->tx_packets++;
 385                 pcpu_stats->tx_bytes += len;
 386                 u64_stats_update_end(&pcpu_stats->syncp);
 387         } else {
 388                 this_cpu_inc(mlxsw_sp_port->pcpu_stats->tx_dropped);
 389                 dev_kfree_skb_any(skb);
 390         }
 391         return NETDEV_TX_OK;
 392 }
 393
 394 static void mlxsw_sp_set_rx_mode(struct net_device *dev)
 395 {
 396 }
 397
 398 static int mlxsw_sp_port_set_mac_address(struct net_device *dev, void *p)
 399 {
 400         struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
 401         struct sockaddr *addr = p;
 402         int err;
 403
 404         if (!is_valid_ether_addr(addr->sa_data))
 405                 return -EADDRNOTAVAIL;
 406
 407         err = mlxsw_sp_port_dev_addr_set(mlxsw_sp_port, addr->sa_data);
 408         if (err)
 409                 return err;
 410         memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
 411         return 0;
 412 }
 413
 414 static int mlxsw_sp_port_change_mtu(struct net_device *dev, int mtu)
 415 {
 416         struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
 417         int err;
 418
 419         err = mlxsw_sp_port_mtu_set(mlxsw_sp_port, mtu);
 420         if (err)
 421                 return err;
 422         dev->mtu = mtu;
 423         return 0;
 424 }
 425
 426 static struct rtnl_link_stats64 *
 427 mlxsw_sp_port_get_stats64(struct net_device *dev,
 428                           struct rtnl_link_stats64 *stats)
 429 {
 430         struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
 431         struct mlxsw_sp_port_pcpu_stats *p;
 432         u64 rx_packets, rx_bytes, tx_packets, tx_bytes;
 433         u32 tx_dropped = 0;
 434         unsigned int start;
 435         int i;
 436
 437         for_each_possible_cpu(i) {
 438                 p = per_cpu_ptr(mlxsw_sp_port->pcpu_stats, i);
 439                 do {
 440                         start = u64_stats_fetch_begin_irq(&p->syncp);
 441                         rx_packets      = p->rx_packets;
 442                         rx_bytes        = p->rx_bytes;
 443                         tx_packets      = p->tx_packets;
 444                         tx_bytes        = p->tx_bytes;
 445                 } while (u64_stats_fetch_retry_irq(&p->syncp, start));
 446
 447                 stats->rx_packets       += rx_packets;
 448                 stats->rx_bytes         += rx_bytes;
 449                 stats->tx_packets       += tx_packets;
 450                 stats->tx_bytes         += tx_bytes;
 451                 /* tx_dropped is u32, updated without syncp protection. */
 452                 tx_dropped      += p->tx_dropped;
 453         }
 454         stats->tx_dropped       = tx_dropped;
 455         return stats;
 456 }
 457
 458 int mlxsw_sp_port_vlan_set(struct mlxsw_sp_port *mlxsw_sp_port, u16 vid_begin,
 459                            u16 vid_end, bool is_member, bool untagged)
 460 {
 461         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
 462         char *spvm_pl;
 463         int err;
 464
 465         spvm_pl = kmalloc(MLXSW_REG_SPVM_LEN, GFP_KERNEL);
 466         if (!spvm_pl)
 467                 return -ENOMEM;
 468
 469         mlxsw_reg_spvm_pack(spvm_pl, mlxsw_sp_port->local_port, vid_begin,
 470                             vid_end, is_member, untagged);
 471         err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(spvm), spvm_pl);
 472         kfree(spvm_pl);
 473         return err;
 474 }
 475
 476 static int mlxsw_sp_port_vp_mode_trans(struct mlxsw_sp_port *mlxsw_sp_port)
 477 {
 478         enum mlxsw_reg_svfa_mt mt = MLXSW_REG_SVFA_MT_PORT_VID_TO_FID;
 479         u16 vid, last_visited_vid;
 480         int err;
 481
 482         for_each_set_bit(vid, mlxsw_sp_port->active_vlans, VLAN_N_VID) {
 483                 err = mlxsw_sp_port_vid_to_fid_set(mlxsw_sp_port, mt, true, vid,
 484                                                    vid);
 485                 if (err) {
 486                         last_visited_vid = vid;
 487                         goto err_port_vid_to_fid_set;
 488                 }
 489         }
 490
 491         err = mlxsw_sp_port_vp_mode_set(mlxsw_sp_port, true);
 492         if (err) {
 493                 last_visited_vid = VLAN_N_VID;
 494                 goto err_port_vid_to_fid_set;
 495         }
 496
 497         return 0;
 498
 499 err_port_vid_to_fid_set:
 500         for_each_set_bit(vid, mlxsw_sp_port->active_vlans, last_visited_vid)
 501                 mlxsw_sp_port_vid_to_fid_set(mlxsw_sp_port, mt, false, vid,
 502                                              vid);
 503         return err;
 504 }
 505
 506 static int mlxsw_sp_port_vlan_mode_trans(struct mlxsw_sp_port *mlxsw_sp_port)
 507 {
 508         enum mlxsw_reg_svfa_mt mt = MLXSW_REG_SVFA_MT_PORT_VID_TO_FID;
 509         u16 vid;
 510         int err;
 511
 512         err = mlxsw_sp_port_vp_mode_set(mlxsw_sp_port, false);
 513         if (err)
 514                 return err;
 515
 516         for_each_set_bit(vid, mlxsw_sp_port->active_vlans, VLAN_N_VID) {
 517                 err = mlxsw_sp_port_vid_to_fid_set(mlxsw_sp_port, mt, false,
 518                                                    vid, vid);
 519                 if (err)
 520                         return err;
 521         }
 522
 523         return 0;
 524 }
 525
 526 static struct mlxsw_sp_vfid *
 527 mlxsw_sp_vfid_find(const struct mlxsw_sp *mlxsw_sp, u16 vid)
 528 {
 529         struct mlxsw_sp_vfid *vfid;
 530
 531         list_for_each_entry(vfid, &mlxsw_sp->port_vfids.list, list) {
 532                 if (vfid->vid == vid)
 533                         return vfid;
 534         }
 535
 536         return NULL;
 537 }
 538
 539 static u16 mlxsw_sp_avail_vfid_get(const struct mlxsw_sp *mlxsw_sp)
 540 {
 541         return find_first_zero_bit(mlxsw_sp->port_vfids.mapped,
 542                                    MLXSW_SP_VFID_PORT_MAX);
 543 }
 544
 545 static int __mlxsw_sp_vfid_create(struct mlxsw_sp *mlxsw_sp, u16 vfid)
 546 {
 547         u16 fid = mlxsw_sp_vfid_to_fid(vfid);
 548         char sfmr_pl[MLXSW_REG_SFMR_LEN];
 549
 550         mlxsw_reg_sfmr_pack(sfmr_pl, MLXSW_REG_SFMR_OP_CREATE_FID, fid, 0);
 551         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfmr), sfmr_pl);
 552 }
 553
 554 static void __mlxsw_sp_vfid_destroy(struct mlxsw_sp *mlxsw_sp, u16 vfid)
 555 {
 556         u16 fid = mlxsw_sp_vfid_to_fid(vfid);
 557         char sfmr_pl[MLXSW_REG_SFMR_LEN];
 558
 559         mlxsw_reg_sfmr_pack(sfmr_pl, MLXSW_REG_SFMR_OP_DESTROY_FID, fid, 0);
 560         mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfmr), sfmr_pl);
 561 }
 562
 563 static struct mlxsw_sp_vfid *mlxsw_sp_vfid_create(struct mlxsw_sp *mlxsw_sp,
 564                                                   u16 vid)
 565 {
 566         struct device *dev = mlxsw_sp->bus_info->dev;
 567         struct mlxsw_sp_vfid *vfid;
 568         u16 n_vfid;
 569         int err;
 570
 571         n_vfid = mlxsw_sp_avail_vfid_get(mlxsw_sp);
 572         if (n_vfid == MLXSW_SP_VFID_PORT_MAX) {
 573                 dev_err(dev, "No available vFIDs\n");
 574                 return ERR_PTR(-ERANGE);
 575         }
 576
 577         err = __mlxsw_sp_vfid_create(mlxsw_sp, n_vfid);
 578         if (err) {
 579                 dev_err(dev, "Failed to create vFID=%d\n", n_vfid);
 580                 return ERR_PTR(err);
 581         }
 582
 583         vfid = kzalloc(sizeof(*vfid), GFP_KERNEL);
 584         if (!vfid)
 585                 goto err_allocate_vfid;
 586
 587         vfid->vfid = n_vfid;
 588         vfid->vid = vid;
 589
 590         list_add(&vfid->list, &mlxsw_sp->port_vfids.list);
 591         set_bit(n_vfid, mlxsw_sp->port_vfids.mapped);
 592
 593         return vfid;
 594
 595 err_allocate_vfid:
 596         __mlxsw_sp_vfid_destroy(mlxsw_sp, n_vfid);
 597         return ERR_PTR(-ENOMEM);
 598 }
 599
 600 static void mlxsw_sp_vfid_destroy(struct mlxsw_sp *mlxsw_sp,
 601                                   struct mlxsw_sp_vfid *vfid)
 602 {
 603         clear_bit(vfid->vfid, mlxsw_sp->port_vfids.mapped);
 604         list_del(&vfid->list);
 605
 606         __mlxsw_sp_vfid_destroy(mlxsw_sp, vfid->vfid);
 607
 608         kfree(vfid);
 609 }
 610
 611 static struct mlxsw_sp_port *
 612 mlxsw_sp_port_vport_create(struct mlxsw_sp_port *mlxsw_sp_port,
 613                            struct mlxsw_sp_vfid *vfid)
 614 {
 615         struct mlxsw_sp_port *mlxsw_sp_vport;
 616
 617         mlxsw_sp_vport = kzalloc(sizeof(*mlxsw_sp_vport), GFP_KERNEL);
 618         if (!mlxsw_sp_vport)
 619                 return NULL;
 620
 621         /* dev will be set correctly after the VLAN device is linked
 622          * with the real device. In case of bridge SELF invocation, dev
 623          * will remain as is.
 624          */
 625         mlxsw_sp_vport->dev = mlxsw_sp_port->dev;
 626         mlxsw_sp_vport->mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
 627         mlxsw_sp_vport->local_port = mlxsw_sp_port->local_port;
 628         mlxsw_sp_vport->stp_state = BR_STATE_FORWARDING;
 629         mlxsw_sp_vport->lagged = mlxsw_sp_port->lagged;
 630         mlxsw_sp_vport->lag_id = mlxsw_sp_port->lag_id;
 631         mlxsw_sp_vport->vport.vfid = vfid;
 632         mlxsw_sp_vport->vport.vid = vfid->vid;
 633
 634         list_add(&mlxsw_sp_vport->vport.list, &mlxsw_sp_port->vports_list);
 635
 636         return mlxsw_sp_vport;
 637 }
 638
 639 static void mlxsw_sp_port_vport_destroy(struct mlxsw_sp_port *mlxsw_sp_vport)
 640 {
 641         list_del(&mlxsw_sp_vport->vport.list);
 642         kfree(mlxsw_sp_vport);
 643 }
 644
 645 int mlxsw_sp_port_add_vid(struct net_device *dev, __be16 __always_unused proto,
 646                           u16 vid)
 647 {
 648         struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
 649         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
 650         struct mlxsw_sp_port *mlxsw_sp_vport;
 651         struct mlxsw_sp_vfid *vfid;
 652         int err;
 653
 654         /* VLAN 0 is added to HW filter when device goes up, but it is
 655          * reserved in our case, so simply return.
 656          */
 657         if (!vid)
 658                 return 0;
 659
 660         if (mlxsw_sp_port_vport_find(mlxsw_sp_port, vid)) {
 661                 netdev_warn(dev, "VID=%d already configured\n", vid);
 662                 return 0;
 663         }
 664
 665         vfid = mlxsw_sp_vfid_find(mlxsw_sp, vid);
 666         if (!vfid) {
 667                 vfid = mlxsw_sp_vfid_create(mlxsw_sp, vid);
 668                 if (IS_ERR(vfid)) {
 669                         netdev_err(dev, "Failed to create vFID for VID=%d\n",
 670                                    vid);
 671                         return PTR_ERR(vfid);
 672                 }
 673         }
 674
 675         mlxsw_sp_vport = mlxsw_sp_port_vport_create(mlxsw_sp_port, vfid);
 676         if (!mlxsw_sp_vport) {
 677                 netdev_err(dev, "Failed to create vPort for VID=%d\n", vid);
 678                 err = -ENOMEM;
 679                 goto err_port_vport_create;
 680         }
 681
 682         if (!vfid->nr_vports) {
 683                 err = mlxsw_sp_vport_flood_set(mlxsw_sp_vport, vfid->vfid,
 684                                                true, false);
 685                 if (err) {
 686                         netdev_err(dev, "Failed to setup flooding for vFID=%d\n",
 687                                    vfid->vfid);
 688                         goto err_vport_flood_set;
 689                 }
 690         }
 691
 692         /* When adding the first VLAN interface on a bridged port we need to
 693          * transition all the active 802.1Q bridge VLANs to use explicit
 694          * {Port, VID} to FID mappings and set the port's mode to Virtual mode.
 695          */
 696         if (list_is_singular(&mlxsw_sp_port->vports_list)) {
 697                 err = mlxsw_sp_port_vp_mode_trans(mlxsw_sp_port);
 698                 if (err) {
 699                         netdev_err(dev, "Failed to set to Virtual mode\n");
 700                         goto err_port_vp_mode_trans;
 701                 }
 702         }
 703
 704         err = mlxsw_sp_port_vid_to_fid_set(mlxsw_sp_vport,
 705                                            MLXSW_REG_SVFA_MT_PORT_VID_TO_FID,
 706                                            true,
 707                                            mlxsw_sp_vfid_to_fid(vfid->vfid),
 708                                            vid);
 709         if (err) {
 710                 netdev_err(dev, "Failed to map {Port, VID=%d} to vFID=%d\n",
 711                            vid, vfid->vfid);
 712                 goto err_port_vid_to_fid_set;
 713         }
 714
 715         err = mlxsw_sp_port_vid_learning_set(mlxsw_sp_vport, vid, false);
 716         if (err) {
 717                 netdev_err(dev, "Failed to disable learning for VID=%d\n", vid);
 718                 goto err_port_vid_learning_set;
 719         }
 720
 721         err = mlxsw_sp_port_vlan_set(mlxsw_sp_vport, vid, vid, true, false);
 722         if (err) {
 723                 netdev_err(dev, "Failed to set VLAN membership for VID=%d\n",
 724                            vid);
 725                 goto err_port_add_vid;
 726         }
 727
 728         err = mlxsw_sp_port_stp_state_set(mlxsw_sp_vport, vid,
 729                                           MLXSW_REG_SPMS_STATE_FORWARDING);
 730         if (err) {
 731                 netdev_err(dev, "Failed to set STP state for VID=%d\n", vid);
 732                 goto err_port_stp_state_set;
 733         }
 734
 735         vfid->nr_vports++;
 736
 737         return 0;
 738
 739 err_port_stp_state_set:
 740         mlxsw_sp_port_vlan_set(mlxsw_sp_vport, vid, vid, false, false);
 741 err_port_add_vid:
 742         mlxsw_sp_port_vid_learning_set(mlxsw_sp_vport, vid, true);
 743 err_port_vid_learning_set:
 744         mlxsw_sp_port_vid_to_fid_set(mlxsw_sp_vport,
 745                                      MLXSW_REG_SVFA_MT_PORT_VID_TO_FID, false,
 746                                      mlxsw_sp_vfid_to_fid(vfid->vfid), vid);
 747 err_port_vid_to_fid_set:
 748         if (list_is_singular(&mlxsw_sp_port->vports_list))
 749                 mlxsw_sp_port_vlan_mode_trans(mlxsw_sp_port);
 750 err_port_vp_mode_trans:
 751         if (!vfid->nr_vports)
 752                 mlxsw_sp_vport_flood_set(mlxsw_sp_vport, vfid->vfid, false,
 753                                          false);
 754 err_vport_flood_set:
 755         mlxsw_sp_port_vport_destroy(mlxsw_sp_vport);
 756 err_port_vport_create:
 757         if (!vfid->nr_vports)
 758                 mlxsw_sp_vfid_destroy(mlxsw_sp, vfid);
 759         return err;
 760 }
 761
 762 int mlxsw_sp_port_kill_vid(struct net_device *dev,
 763                            __be16 __always_unused proto, u16 vid)
 764 {
 765         struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
 766         struct mlxsw_sp_port *mlxsw_sp_vport;
 767         struct mlxsw_sp_vfid *vfid;
 768         int err;
 769
 770         /* VLAN 0 is removed from HW filter when device goes down, but
 771          * it is reserved in our case, so simply return.
 772          */
 773         if (!vid)
 774                 return 0;
 775
 776         mlxsw_sp_vport = mlxsw_sp_port_vport_find(mlxsw_sp_port, vid);
 777         if (!mlxsw_sp_vport) {
 778                 netdev_warn(dev, "VID=%d does not exist\n", vid);
 779                 return 0;
 780         }
 781
 782         vfid = mlxsw_sp_vport->vport.vfid;
 783
 784         err = mlxsw_sp_port_stp_state_set(mlxsw_sp_vport, vid,
 785                                           MLXSW_REG_SPMS_STATE_DISCARDING);
 786         if (err) {
 787                 netdev_err(dev, "Failed to set STP state for VID=%d\n", vid);
 788                 return err;
 789         }
 790
 791         err = mlxsw_sp_port_vlan_set(mlxsw_sp_vport, vid, vid, false, false);
 792         if (err) {
 793                 netdev_err(dev, "Failed to set VLAN membership for VID=%d\n",
 794                            vid);
 795                 return err;
 796         }
 797
 798         err = mlxsw_sp_port_vid_learning_set(mlxsw_sp_vport, vid, true);
 799         if (err) {
 800                 netdev_err(dev, "Failed to enable learning for VID=%d\n", vid);
 801                 return err;
 802         }
 803
 804         err = mlxsw_sp_port_vid_to_fid_set(mlxsw_sp_vport,
 805                                            MLXSW_REG_SVFA_MT_PORT_VID_TO_FID,
 806                                            false,
 807                                            mlxsw_sp_vfid_to_fid(vfid->vfid),
 808                                            vid);
 809         if (err) {
 810                 netdev_err(dev, "Failed to invalidate {Port, VID=%d} to vFID=%d mapping\n",
 811                            vid, vfid->vfid);
 812                 return err;
 813         }
 814
 815         /* When removing the last VLAN interface on a bridged port we need to
 816          * transition all active 802.1Q bridge VLANs to use VID to FID
 817          * mappings and set port's mode to VLAN mode.
 818          */
 819         if (list_is_singular(&mlxsw_sp_port->vports_list)) {
 820                 err = mlxsw_sp_port_vlan_mode_trans(mlxsw_sp_port);
 821                 if (err) {
 822                         netdev_err(dev, "Failed to set to VLAN mode\n");
 823                         return err;
 824                 }
 825         }
 826
 827         vfid->nr_vports--;
 828         mlxsw_sp_port_vport_destroy(mlxsw_sp_vport);
 829
 830         /* Destroy the vFID if no vPorts are assigned to it anymore. */
 831         if (!vfid->nr_vports)
 832                 mlxsw_sp_vfid_destroy(mlxsw_sp_port->mlxsw_sp, vfid);
 833
 834         return 0;
 835 }
 836
 837 static const struct net_device_ops mlxsw_sp_port_netdev_ops = {
 838         .ndo_open               = mlxsw_sp_port_open,
 839         .ndo_stop               = mlxsw_sp_port_stop,
 840         .ndo_start_xmit         = mlxsw_sp_port_xmit,
 841         .ndo_set_rx_mode        = mlxsw_sp_set_rx_mode,
 842         .ndo_set_mac_address    = mlxsw_sp_port_set_mac_address,
 843         .ndo_change_mtu         = mlxsw_sp_port_change_mtu,
 844         .ndo_get_stats64        = mlxsw_sp_port_get_stats64,
 845         .ndo_vlan_rx_add_vid    = mlxsw_sp_port_add_vid,
 846         .ndo_vlan_rx_kill_vid   = mlxsw_sp_port_kill_vid,
 847         .ndo_fdb_add            = switchdev_port_fdb_add,
 848         .ndo_fdb_del            = switchdev_port_fdb_del,
 849         .ndo_fdb_dump           = switchdev_port_fdb_dump,
 850         .ndo_bridge_setlink     = switchdev_port_bridge_setlink,
 851         .ndo_bridge_getlink     = switchdev_port_bridge_getlink,
 852         .ndo_bridge_dellink     = switchdev_port_bridge_dellink,
 853 };
 854
 855 static void mlxsw_sp_port_get_drvinfo(struct net_device *dev,
 856                                       struct ethtool_drvinfo *drvinfo)
 857 {
 858         struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
 859         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
 860
 861         strlcpy(drvinfo->driver, mlxsw_sp_driver_name, sizeof(drvinfo->driver));
 862         strlcpy(drvinfo->version, mlxsw_sp_driver_version,
 863                 sizeof(drvinfo->version));
 864         snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version),
 865                  "%d.%d.%d",
 866                  mlxsw_sp->bus_info->fw_rev.major,
 867                  mlxsw_sp->bus_info->fw_rev.minor,
 868                  mlxsw_sp->bus_info->fw_rev.subminor);
 869         strlcpy(drvinfo->bus_info, mlxsw_sp->bus_info->device_name,
 870                 sizeof(drvinfo->bus_info));
 871 }
 872
 873 struct mlxsw_sp_port_hw_stats {
 874         char str[ETH_GSTRING_LEN];
 875         u64 (*getter)(char *payload);
 876 };
 877
 878 static const struct mlxsw_sp_port_hw_stats mlxsw_sp_port_hw_stats[] = {
 879         {
 880                 .str = "a_frames_transmitted_ok",
 881                 .getter = mlxsw_reg_ppcnt_a_frames_transmitted_ok_get,
 882         },
 883         {
 884                 .str = "a_frames_received_ok",
 885                 .getter = mlxsw_reg_ppcnt_a_frames_received_ok_get,
 886         },
 887         {
 888                 .str = "a_frame_check_sequence_errors",
 889                 .getter = mlxsw_reg_ppcnt_a_frame_check_sequence_errors_get,
 890         },
 891         {
 892                 .str = "a_alignment_errors",
 893                 .getter = mlxsw_reg_ppcnt_a_alignment_errors_get,
 894         },
 895         {
 896                 .str = "a_octets_transmitted_ok",
 897                 .getter = mlxsw_reg_ppcnt_a_octets_transmitted_ok_get,
 898         },
 899         {
 900                 .str = "a_octets_received_ok",
 901                 .getter = mlxsw_reg_ppcnt_a_octets_received_ok_get,
 902         },
 903         {
 904                 .str = "a_multicast_frames_xmitted_ok",
 905                 .getter = mlxsw_reg_ppcnt_a_multicast_frames_xmitted_ok_get,
 906         },
 907         {
 908                 .str = "a_broadcast_frames_xmitted_ok",
 909                 .getter = mlxsw_reg_ppcnt_a_broadcast_frames_xmitted_ok_get,
 910         },
 911         {
 912                 .str = "a_multicast_frames_received_ok",
 913                 .getter = mlxsw_reg_ppcnt_a_multicast_frames_received_ok_get,
 914         },
 915         {
 916                 .str = "a_broadcast_frames_received_ok",
 917                 .getter = mlxsw_reg_ppcnt_a_broadcast_frames_received_ok_get,
 918         },
 919         {
 920                 .str = "a_in_range_length_errors",
 921                 .getter = mlxsw_reg_ppcnt_a_in_range_length_errors_get,
 922         },
 923         {
 924                 .str = "a_out_of_range_length_field",
 925                 .getter = mlxsw_reg_ppcnt_a_out_of_range_length_field_get,
 926         },
 927         {
 928                 .str = "a_frame_too_long_errors",
 929                 .getter = mlxsw_reg_ppcnt_a_frame_too_long_errors_get,
 930         },
 931         {
 932                 .str = "a_symbol_error_during_carrier",
 933                 .getter = mlxsw_reg_ppcnt_a_symbol_error_during_carrier_get,
 934         },
 935         {
 936                 .str = "a_mac_control_frames_transmitted",
 937                 .getter = mlxsw_reg_ppcnt_a_mac_control_frames_transmitted_get,
 938         },
 939         {
 940                 .str = "a_mac_control_frames_received",
 941                 .getter = mlxsw_reg_ppcnt_a_mac_control_frames_received_get,
 942         },
 943         {
 944                 .str = "a_unsupported_opcodes_received",
 945                 .getter = mlxsw_reg_ppcnt_a_unsupported_opcodes_received_get,
 946         },
 947         {
 948                 .str = "a_pause_mac_ctrl_frames_received",
 949                 .getter = mlxsw_reg_ppcnt_a_pause_mac_ctrl_frames_received_get,
 950         },
 951         {
 952                 .str = "a_pause_mac_ctrl_frames_xmitted",
 953                 .getter = mlxsw_reg_ppcnt_a_pause_mac_ctrl_frames_transmitted_get,
 954         },
 955 };
 956
 957 #define MLXSW_SP_PORT_HW_STATS_LEN ARRAY_SIZE(mlxsw_sp_port_hw_stats)
 958
 959 static void mlxsw_sp_port_get_strings(struct net_device *dev,
 960                                       u32 stringset, u8 *data)
 961 {
 962         u8 *p = data;
 963         int i;
 964
 965         switch (stringset) {
 966         case ETH_SS_STATS:
 967                 for (i = 0; i < MLXSW_SP_PORT_HW_STATS_LEN; i++) {
 968                         memcpy(p, mlxsw_sp_port_hw_stats[i].str,
 969                                ETH_GSTRING_LEN);
 970                         p += ETH_GSTRING_LEN;
 971                 }
 972                 break;
 973         }
 974 }
 975
 976 static int mlxsw_sp_port_set_phys_id(struct net_device *dev,
 977                                      enum ethtool_phys_id_state state)
 978 {
 979         struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
 980         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
 981         char mlcr_pl[MLXSW_REG_MLCR_LEN];
 982         bool active;
 983
 984         switch (state) {
 985         case ETHTOOL_ID_ACTIVE:
 986                 active = true;
 987                 break;
 988         case ETHTOOL_ID_INACTIVE:
 989                 active = false;
 990                 break;
 991         default:
 992                 return -EOPNOTSUPP;
 993         }
 994
 995         mlxsw_reg_mlcr_pack(mlcr_pl, mlxsw_sp_port->local_port, active);
 996         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(mlcr), mlcr_pl);
 997 }
 998
 999 static void mlxsw_sp_port_get_stats(struct net_device *dev,
1000                                     struct ethtool_stats *stats, u64 *data)
1001 {
1002         struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
1003         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1004         char ppcnt_pl[MLXSW_REG_PPCNT_LEN];
1005         int i;
1006         int err;
1007
1008         mlxsw_reg_ppcnt_pack(ppcnt_pl, mlxsw_sp_port->local_port);
1009         err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(ppcnt), ppcnt_pl);
1010         for (i = 0; i < MLXSW_SP_PORT_HW_STATS_LEN; i++)
1011                 data[i] = !err ? mlxsw_sp_port_hw_stats[i].getter(ppcnt_pl) : 0;
1012 }
1013
1014 static int mlxsw_sp_port_get_sset_count(struct net_device *dev, int sset)
1015 {
1016         switch (sset) {
1017         case ETH_SS_STATS:
1018                 return MLXSW_SP_PORT_HW_STATS_LEN;
1019         default:
1020                 return -EOPNOTSUPP;
1021         }
1022 }
1023
1024 struct mlxsw_sp_port_link_mode {
1025         u32 mask;
1026         u32 supported;
1027         u32 advertised;
1028         u32 speed;
1029 };
1030
1031 static const struct mlxsw_sp_port_link_mode mlxsw_sp_port_link_mode[] = {
1032         {
1033                 .mask           = MLXSW_REG_PTYS_ETH_SPEED_100BASE_T,
1034                 .supported      = SUPPORTED_100baseT_Full,
1035                 .advertised     = ADVERTISED_100baseT_Full,
1036                 .speed          = 100,
1037         },
1038         {
1039                 .mask           = MLXSW_REG_PTYS_ETH_SPEED_100BASE_TX,
1040                 .speed          = 100,
1041         },
1042         {
1043                 .mask           = MLXSW_REG_PTYS_ETH_SPEED_SGMII |
1044                                   MLXSW_REG_PTYS_ETH_SPEED_1000BASE_KX,
1045                 .supported      = SUPPORTED_1000baseKX_Full,
1046                 .advertised     = ADVERTISED_1000baseKX_Full,
1047                 .speed          = 1000,
1048         },
1049         {
1050                 .mask           = MLXSW_REG_PTYS_ETH_SPEED_10GBASE_T,
1051                 .supported      = SUPPORTED_10000baseT_Full,
1052                 .advertised     = ADVERTISED_10000baseT_Full,
1053                 .speed          = 10000,
1054         },
1055         {
1056                 .mask           = MLXSW_REG_PTYS_ETH_SPEED_10GBASE_CX4 |
1057                                   MLXSW_REG_PTYS_ETH_SPEED_10GBASE_KX4,
1058                 .supported      = SUPPORTED_10000baseKX4_Full,
1059                 .advertised     = ADVERTISED_10000baseKX4_Full,
1060                 .speed          = 10000,
1061         },
1062         {
1063                 .mask           = MLXSW_REG_PTYS_ETH_SPEED_10GBASE_KR |
1064                                   MLXSW_REG_PTYS_ETH_SPEED_10GBASE_CR |
1065                                   MLXSW_REG_PTYS_ETH_SPEED_10GBASE_SR |
1066                                   MLXSW_REG_PTYS_ETH_SPEED_10GBASE_ER_LR,
1067                 .supported      = SUPPORTED_10000baseKR_Full,
1068                 .advertised     = ADVERTISED_10000baseKR_Full,
1069                 .speed          = 10000,
1070         },
1071         {
1072                 .mask           = MLXSW_REG_PTYS_ETH_SPEED_20GBASE_KR2,
1073                 .supported      = SUPPORTED_20000baseKR2_Full,
1074                 .advertised     = ADVERTISED_20000baseKR2_Full,
1075                 .speed          = 20000,
1076         },
1077         {
1078                 .mask           = MLXSW_REG_PTYS_ETH_SPEED_40GBASE_CR4,
1079                 .supported      = SUPPORTED_40000baseCR4_Full,
1080                 .advertised     = ADVERTISED_40000baseCR4_Full,
1081                 .speed          = 40000,
1082         },
1083         {
1084                 .mask           = MLXSW_REG_PTYS_ETH_SPEED_40GBASE_KR4,
1085                 .supported      = SUPPORTED_40000baseKR4_Full,
1086                 .advertised     = ADVERTISED_40000baseKR4_Full,
1087                 .speed          = 40000,
1088         },
1089         {
1090                 .mask           = MLXSW_REG_PTYS_ETH_SPEED_40GBASE_SR4,
1091                 .supported      = SUPPORTED_40000baseSR4_Full,
1092                 .advertised     = ADVERTISED_40000baseSR4_Full,
1093                 .speed          = 40000,
1094         },
1095         {
1096                 .mask           = MLXSW_REG_PTYS_ETH_SPEED_40GBASE_LR4_ER4,
1097                 .supported      = SUPPORTED_40000baseLR4_Full,
1098                 .advertised     = ADVERTISED_40000baseLR4_Full,
1099                 .speed          = 40000,
1100         },
1101         {
1102                 .mask           = MLXSW_REG_PTYS_ETH_SPEED_25GBASE_CR |
1103                                   MLXSW_REG_PTYS_ETH_SPEED_25GBASE_KR |
1104                                   MLXSW_REG_PTYS_ETH_SPEED_25GBASE_SR,
1105                 .speed          = 25000,
1106         },
1107         {
1108                 .mask           = MLXSW_REG_PTYS_ETH_SPEED_50GBASE_KR4 |
1109                                   MLXSW_REG_PTYS_ETH_SPEED_50GBASE_CR2 |
1110                                   MLXSW_REG_PTYS_ETH_SPEED_50GBASE_KR2,
1111                 .speed          = 50000,
1112         },
1113         {
1114                 .mask           = MLXSW_REG_PTYS_ETH_SPEED_56GBASE_R4,
1115                 .supported      = SUPPORTED_56000baseKR4_Full,
1116                 .advertised     = ADVERTISED_56000baseKR4_Full,
1117                 .speed          = 56000,
1118         },
1119         {
1120                 .mask           = MLXSW_REG_PTYS_ETH_SPEED_100GBASE_CR4 |
1121                                   MLXSW_REG_PTYS_ETH_SPEED_100GBASE_SR4 |
1122                                   MLXSW_REG_PTYS_ETH_SPEED_100GBASE_KR4 |
1123                                   MLXSW_REG_PTYS_ETH_SPEED_100GBASE_LR4_ER4,
1124                 .speed          = 100000,
1125         },
1126 };
1127
1128 #define MLXSW_SP_PORT_LINK_MODE_LEN ARRAY_SIZE(mlxsw_sp_port_link_mode)
1129
1130 static u32 mlxsw_sp_from_ptys_supported_port(u32 ptys_eth_proto)
1131 {
1132         if (ptys_eth_proto & (MLXSW_REG_PTYS_ETH_SPEED_10GBASE_CR |
1133                               MLXSW_REG_PTYS_ETH_SPEED_10GBASE_SR |
1134                               MLXSW_REG_PTYS_ETH_SPEED_40GBASE_CR4 |
1135                               MLXSW_REG_PTYS_ETH_SPEED_40GBASE_SR4 |
1136                               MLXSW_REG_PTYS_ETH_SPEED_100GBASE_SR4 |
1137                               MLXSW_REG_PTYS_ETH_SPEED_SGMII))
1138                 return SUPPORTED_FIBRE;
1139
1140         if (ptys_eth_proto & (MLXSW_REG_PTYS_ETH_SPEED_10GBASE_KR |
1141                               MLXSW_REG_PTYS_ETH_SPEED_10GBASE_KX4 |
1142                               MLXSW_REG_PTYS_ETH_SPEED_40GBASE_KR4 |
1143                               MLXSW_REG_PTYS_ETH_SPEED_100GBASE_KR4 |
1144                               MLXSW_REG_PTYS_ETH_SPEED_1000BASE_KX))
1145                 return SUPPORTED_Backplane;
1146         return 0;
1147 }
1148
1149 static u32 mlxsw_sp_from_ptys_supported_link(u32 ptys_eth_proto)
1150 {
1151         u32 modes = 0;
1152         int i;
1153
1154         for (i = 0; i < MLXSW_SP_PORT_LINK_MODE_LEN; i++) {
1155                 if (ptys_eth_proto & mlxsw_sp_port_link_mode[i].mask)
1156                         modes |= mlxsw_sp_port_link_mode[i].supported;
1157         }
1158         return modes;
1159 }
1160
1161 static u32 mlxsw_sp_from_ptys_advert_link(u32 ptys_eth_proto)
1162 {
1163         u32 modes = 0;
1164         int i;
1165
1166         for (i = 0; i < MLXSW_SP_PORT_LINK_MODE_LEN; i++) {
1167                 if (ptys_eth_proto & mlxsw_sp_port_link_mode[i].mask)
1168                         modes |= mlxsw_sp_port_link_mode[i].advertised;
1169         }
1170         return modes;
1171 }
1172
1173 static void mlxsw_sp_from_ptys_speed_duplex(bool carrier_ok, u32 ptys_eth_proto,
1174                                             struct ethtool_cmd *cmd)
1175 {
1176         u32 speed = SPEED_UNKNOWN;
1177         u8 duplex = DUPLEX_UNKNOWN;
1178         int i;
1179
1180         if (!carrier_ok)
1181                 goto out;
1182
1183         for (i = 0; i < MLXSW_SP_PORT_LINK_MODE_LEN; i++) {
1184                 if (ptys_eth_proto & mlxsw_sp_port_link_mode[i].mask) {
1185                         speed = mlxsw_sp_port_link_mode[i].speed;
1186                         duplex = DUPLEX_FULL;
1187                         break;
1188                 }
1189         }
1190 out:
1191         ethtool_cmd_speed_set(cmd, speed);
1192         cmd->duplex = duplex;
1193 }
1194
1195 static u8 mlxsw_sp_port_connector_port(u32 ptys_eth_proto)
1196 {
1197         if (ptys_eth_proto & (MLXSW_REG_PTYS_ETH_SPEED_10GBASE_SR |
1198                               MLXSW_REG_PTYS_ETH_SPEED_40GBASE_SR4 |
1199                               MLXSW_REG_PTYS_ETH_SPEED_100GBASE_SR4 |
1200                               MLXSW_REG_PTYS_ETH_SPEED_SGMII))
1201                 return PORT_FIBRE;
1202
1203         if (ptys_eth_proto & (MLXSW_REG_PTYS_ETH_SPEED_10GBASE_CR |
1204                               MLXSW_REG_PTYS_ETH_SPEED_40GBASE_CR4 |
1205                               MLXSW_REG_PTYS_ETH_SPEED_100GBASE_CR4))
1206                 return PORT_DA;
1207
1208         if (ptys_eth_proto & (MLXSW_REG_PTYS_ETH_SPEED_10GBASE_KR |
1209                               MLXSW_REG_PTYS_ETH_SPEED_10GBASE_KX4 |
1210                               MLXSW_REG_PTYS_ETH_SPEED_40GBASE_KR4 |
1211                               MLXSW_REG_PTYS_ETH_SPEED_100GBASE_KR4))
1212                 return PORT_NONE;
1213
1214         return PORT_OTHER;
1215 }
1216
1217 static int mlxsw_sp_port_get_settings(struct net_device *dev,
1218                                       struct ethtool_cmd *cmd)
1219 {
1220         struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
1221         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1222         char ptys_pl[MLXSW_REG_PTYS_LEN];
1223         u32 eth_proto_cap;
1224         u32 eth_proto_admin;
1225         u32 eth_proto_oper;
1226         int err;
1227
1228         mlxsw_reg_ptys_pack(ptys_pl, mlxsw_sp_port->local_port, 0);
1229         err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(ptys), ptys_pl);
1230         if (err) {
1231                 netdev_err(dev, "Failed to get proto");
1232                 return err;
1233         }
1234         mlxsw_reg_ptys_unpack(ptys_pl, &eth_proto_cap,
1235                               &eth_proto_admin, &eth_proto_oper);
1236
1237         cmd->supported = mlxsw_sp_from_ptys_supported_port(eth_proto_cap) |
1238                          mlxsw_sp_from_ptys_supported_link(eth_proto_cap) |
1239                          SUPPORTED_Pause | SUPPORTED_Asym_Pause;
1240         cmd->advertising = mlxsw_sp_from_ptys_advert_link(eth_proto_admin);
1241         mlxsw_sp_from_ptys_speed_duplex(netif_carrier_ok(dev),
1242                                         eth_proto_oper, cmd);
1243
1244         eth_proto_oper = eth_proto_oper ? eth_proto_oper : eth_proto_cap;
1245         cmd->port = mlxsw_sp_port_connector_port(eth_proto_oper);
1246         cmd->lp_advertising = mlxsw_sp_from_ptys_advert_link(eth_proto_oper);
1247
1248         cmd->transceiver = XCVR_INTERNAL;
1249         return 0;
1250 }
1251
1252 static u32 mlxsw_sp_to_ptys_advert_link(u32 advertising)
1253 {
1254         u32 ptys_proto = 0;
1255         int i;
1256
1257         for (i = 0; i < MLXSW_SP_PORT_LINK_MODE_LEN; i++) {
1258                 if (advertising & mlxsw_sp_port_link_mode[i].advertised)
1259                         ptys_proto |= mlxsw_sp_port_link_mode[i].mask;
1260         }
1261         return ptys_proto;
1262 }
1263
1264 static u32 mlxsw_sp_to_ptys_speed(u32 speed)
1265 {
1266         u32 ptys_proto = 0;
1267         int i;
1268
1269         for (i = 0; i < MLXSW_SP_PORT_LINK_MODE_LEN; i++) {
1270                 if (speed == mlxsw_sp_port_link_mode[i].speed)
1271                         ptys_proto |= mlxsw_sp_port_link_mode[i].mask;
1272         }
1273         return ptys_proto;
1274 }
1275
1276 static int mlxsw_sp_port_set_settings(struct net_device *dev,
1277                                       struct ethtool_cmd *cmd)
1278 {
1279         struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
1280         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
1281         char ptys_pl[MLXSW_REG_PTYS_LEN];
1282         u32 speed;
1283         u32 eth_proto_new;
1284         u32 eth_proto_cap;
1285         u32 eth_proto_admin;
1286         bool is_up;
1287         int err;
1288
1289         speed = ethtool_cmd_speed(cmd);
1290
1291         eth_proto_new = cmd->autoneg == AUTONEG_ENABLE ?
1292                 mlxsw_sp_to_ptys_advert_link(cmd->advertising) :
1293                 mlxsw_sp_to_ptys_speed(speed);
1294
1295         mlxsw_reg_ptys_pack(ptys_pl, mlxsw_sp_port->local_port, 0);
1296         err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(ptys), ptys_pl);
1297         if (err) {
1298                 netdev_err(dev, "Failed to get proto");
1299                 return err;
1300         }
1301         mlxsw_reg_ptys_unpack(ptys_pl, &eth_proto_cap, &eth_proto_admin, NULL);
1302
1303         eth_proto_new = eth_proto_new & eth_proto_cap;
1304         if (!eth_proto_new) {
1305                 netdev_err(dev, "Not supported proto admin requested");
1306                 return -EINVAL;
1307         }
1308         if (eth_proto_new == eth_proto_admin)
1309                 return 0;
1310
1311         mlxsw_reg_ptys_pack(ptys_pl, mlxsw_sp_port->local_port, eth_proto_new);
1312         err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ptys), ptys_pl);
1313         if (err) {
1314                 netdev_err(dev, "Failed to set proto admin");
1315                 return err;
1316         }
1317
1318         err = mlxsw_sp_port_oper_status_get(mlxsw_sp_port, &is_up);
1319         if (err) {
1320                 netdev_err(dev, "Failed to get oper status");
1321                 return err;
1322         }
1323         if (!is_up)
1324                 return 0;
1325
1326         err = mlxsw_sp_port_admin_status_set(mlxsw_sp_port, false);
1327         if (err) {
1328                 netdev_err(dev, "Failed to set admin status");
1329                 return err;
1330         }
1331
1332         err = mlxsw_sp_port_admin_status_set(mlxsw_sp_port, true);
1333         if (err) {
1334                 netdev_err(dev, "Failed to set admin status");
1335                 return err;
1336         }
1337
1338         return 0;
1339 }
1340
1341 static const struct ethtool_ops mlxsw_sp_port_ethtool_ops = {
1342         .get_drvinfo            = mlxsw_sp_port_get_drvinfo,
1343         .get_link               = ethtool_op_get_link,
1344         .get_strings            = mlxsw_sp_port_get_strings,
1345         .set_phys_id            = mlxsw_sp_port_set_phys_id,
1346         .get_ethtool_stats      = mlxsw_sp_port_get_stats,
1347         .get_sset_count         = mlxsw_sp_port_get_sset_count,
1348         .get_settings           = mlxsw_sp_port_get_settings,
1349         .set_settings           = mlxsw_sp_port_set_settings,
1350 };
1351
1352 static int mlxsw_sp_port_create(struct mlxsw_sp *mlxsw_sp, u8 local_port)
1353 {
1354         struct mlxsw_sp_port *mlxsw_sp_port;
1355         struct net_device *dev;
1356         bool usable;
1357         size_t bytes;
1358         int err;
1359
1360         dev = alloc_etherdev(sizeof(struct mlxsw_sp_port));
1361         if (!dev)
1362                 return -ENOMEM;
1363         mlxsw_sp_port = netdev_priv(dev);
1364         mlxsw_sp_port->dev = dev;
1365         mlxsw_sp_port->mlxsw_sp = mlxsw_sp;
1366         mlxsw_sp_port->local_port = local_port;
1367         mlxsw_sp_port->learning = 1;
1368         mlxsw_sp_port->learning_sync = 1;
1369         mlxsw_sp_port->uc_flood = 1;
1370         mlxsw_sp_port->pvid = 1;
1371         bytes = DIV_ROUND_UP(VLAN_N_VID, BITS_PER_BYTE);
1372         mlxsw_sp_port->active_vlans = kzalloc(bytes, GFP_KERNEL);
1373         if (!mlxsw_sp_port->active_vlans) {
1374                 err = -ENOMEM;
1375                 goto err_port_active_vlans_alloc;
1376         }
1377         INIT_LIST_HEAD(&mlxsw_sp_port->vports_list);
1378
1379         mlxsw_sp_port->pcpu_stats =
1380                 netdev_alloc_pcpu_stats(struct mlxsw_sp_port_pcpu_stats);
1381         if (!mlxsw_sp_port->pcpu_stats) {
1382                 err = -ENOMEM;
1383                 goto err_alloc_stats;
1384         }
1385
1386         dev->netdev_ops = &mlxsw_sp_port_netdev_ops;
1387         dev->ethtool_ops = &mlxsw_sp_port_ethtool_ops;
1388
1389         err = mlxsw_sp_port_dev_addr_init(mlxsw_sp_port);
1390         if (err) {
1391                 dev_err(mlxsw_sp->bus_info->dev, "Port %d: Unable to init port mac address\n",
1392                         mlxsw_sp_port->local_port);
1393                 goto err_dev_addr_init;
1394         }
1395
1396         netif_carrier_off(dev);
1397
1398         dev->features |= NETIF_F_NETNS_LOCAL | NETIF_F_LLTX | NETIF_F_SG |
1399                          NETIF_F_HW_VLAN_CTAG_FILTER;
1400
1401         /* Each packet needs to have a Tx header (metadata) on top all other
1402          * headers.
1403          */
1404         dev->hard_header_len += MLXSW_TXHDR_LEN;
1405
1406         err = mlxsw_sp_port_module_check(mlxsw_sp_port, &usable);
1407         if (err) {
1408                 dev_err(mlxsw_sp->bus_info->dev, "Port %d: Failed to check module\n",
1409                         mlxsw_sp_port->local_port);
1410                 goto err_port_module_check;
1411         }
1412
1413         if (!usable) {
1414                 dev_dbg(mlxsw_sp->bus_info->dev, "Port %d: Not usable, skipping initialization\n",
1415                         mlxsw_sp_port->local_port);
1416                 goto port_not_usable;
1417         }
1418
1419         err = mlxsw_sp_port_system_port_mapping_set(mlxsw_sp_port);
1420         if (err) {
1421                 dev_err(mlxsw_sp->bus_info->dev, "Port %d: Failed to set system port mapping\n",
1422                         mlxsw_sp_port->local_port);
1423                 goto err_port_system_port_mapping_set;
1424         }
1425
1426         err = mlxsw_sp_port_swid_set(mlxsw_sp_port, 0);
1427         if (err) {
1428                 dev_err(mlxsw_sp->bus_info->dev, "Port %d: Failed to set SWID\n",
1429                         mlxsw_sp_port->local_port);
1430                 goto err_port_swid_set;
1431         }
1432
1433         err = mlxsw_sp_port_mtu_set(mlxsw_sp_port, ETH_DATA_LEN);
1434         if (err) {
1435                 dev_err(mlxsw_sp->bus_info->dev, "Port %d: Failed to set MTU\n",
1436                         mlxsw_sp_port->local_port);
1437                 goto err_port_mtu_set;
1438         }
1439
1440         err = mlxsw_sp_port_admin_status_set(mlxsw_sp_port, false);
1441         if (err)
1442                 goto err_port_admin_status_set;
1443
1444         err = mlxsw_sp_port_buffers_init(mlxsw_sp_port);
1445         if (err) {
1446                 dev_err(mlxsw_sp->bus_info->dev, "Port %d: Failed to initialize buffers\n",
1447                         mlxsw_sp_port->local_port);
1448                 goto err_port_buffers_init;
1449         }
1450
1451         mlxsw_sp_port_switchdev_init(mlxsw_sp_port);
1452         err = register_netdev(dev);
1453         if (err) {
1454                 dev_err(mlxsw_sp->bus_info->dev, "Port %d: Failed to register netdev\n",
1455                         mlxsw_sp_port->local_port);
1456                 goto err_register_netdev;
1457         }
1458
1459         err = mlxsw_sp_port_vlan_init(mlxsw_sp_port);
1460         if (err)
1461                 goto err_port_vlan_init;
1462
1463         mlxsw_sp->ports[local_port] = mlxsw_sp_port;
1464         return 0;
1465
1466 err_port_vlan_init:
1467         unregister_netdev(dev);
1468 err_register_netdev:
1469 err_port_buffers_init:
1470 err_port_admin_status_set:
1471 err_port_mtu_set:
1472 err_port_swid_set:
1473 err_port_system_port_mapping_set:
1474 port_not_usable:
1475 err_port_module_check:
1476 err_dev_addr_init:
1477         free_percpu(mlxsw_sp_port->pcpu_stats);
1478 err_alloc_stats:
1479         kfree(mlxsw_sp_port->active_vlans);
1480 err_port_active_vlans_alloc:
1481         free_netdev(dev);
1482         return err;
1483 }
1484
1485 static void mlxsw_sp_port_vports_fini(struct mlxsw_sp_port *mlxsw_sp_port)
1486 {
1487         struct net_device *dev = mlxsw_sp_port->dev;
1488         struct mlxsw_sp_port *mlxsw_sp_vport, *tmp;
1489
1490         list_for_each_entry_safe(mlxsw_sp_vport, tmp,
1491                                  &mlxsw_sp_port->vports_list, vport.list) {
1492                 u16 vid = mlxsw_sp_vport_vid_get(mlxsw_sp_vport);
1493
1494                 /* vPorts created for VLAN devices should already be gone
1495                  * by now, since we unregistered the port netdev.
1496                  */
1497                 WARN_ON(is_vlan_dev(mlxsw_sp_vport->dev));
1498                 mlxsw_sp_port_kill_vid(dev, 0, vid);
1499         }
1500 }
1501
1502 static void mlxsw_sp_port_remove(struct mlxsw_sp *mlxsw_sp, u8 local_port)
1503 {
1504         struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp->ports[local_port];
1505
1506         if (!mlxsw_sp_port)
1507                 return;
1508         unregister_netdev(mlxsw_sp_port->dev); /* This calls ndo_stop */
1509         mlxsw_sp_port_vports_fini(mlxsw_sp_port);
1510         mlxsw_sp_port_switchdev_fini(mlxsw_sp_port);
1511         free_percpu(mlxsw_sp_port->pcpu_stats);
1512         kfree(mlxsw_sp_port->active_vlans);
1513         free_netdev(mlxsw_sp_port->dev);
1514 }
1515
1516 static void mlxsw_sp_ports_remove(struct mlxsw_sp *mlxsw_sp)
1517 {
1518         int i;
1519
1520         for (i = 1; i < MLXSW_PORT_MAX_PORTS; i++)
1521                 mlxsw_sp_port_remove(mlxsw_sp, i);
1522         kfree(mlxsw_sp->ports);
1523 }
1524
1525 static int mlxsw_sp_ports_create(struct mlxsw_sp *mlxsw_sp)
1526 {
1527         size_t alloc_size;
1528         int i;
1529         int err;
1530
1531         alloc_size = sizeof(struct mlxsw_sp_port *) * MLXSW_PORT_MAX_PORTS;
1532         mlxsw_sp->ports = kzalloc(alloc_size, GFP_KERNEL);
1533         if (!mlxsw_sp->ports)
1534                 return -ENOMEM;
1535
1536         for (i = 1; i < MLXSW_PORT_MAX_PORTS; i++) {
1537                 err = mlxsw_sp_port_create(mlxsw_sp, i);
1538                 if (err)
1539                         goto err_port_create;
1540         }
1541         return 0;
1542
1543 err_port_create:
1544         for (i--; i >= 1; i--)
1545                 mlxsw_sp_port_remove(mlxsw_sp, i);
1546         kfree(mlxsw_sp->ports);
1547         return err;
1548 }
1549
1550 static void mlxsw_sp_pude_event_func(const struct mlxsw_reg_info *reg,
1551                                      char *pude_pl, void *priv)
1552 {
1553         struct mlxsw_sp *mlxsw_sp = priv;
1554         struct mlxsw_sp_port *mlxsw_sp_port;
1555         enum mlxsw_reg_pude_oper_status status;
1556         u8 local_port;
1557
1558         local_port = mlxsw_reg_pude_local_port_get(pude_pl);
1559         mlxsw_sp_port = mlxsw_sp->ports[local_port];
1560         if (!mlxsw_sp_port) {
1561                 dev_warn(mlxsw_sp->bus_info->dev, "Port %d: Link event received for non-existent port\n",
1562                          local_port);
1563                 return;
1564         }
1565
1566         status = mlxsw_reg_pude_oper_status_get(pude_pl);
1567         if (status == MLXSW_PORT_OPER_STATUS_UP) {
1568                 netdev_info(mlxsw_sp_port->dev, "link up\n");
1569                 netif_carrier_on(mlxsw_sp_port->dev);
1570         } else {
1571                 netdev_info(mlxsw_sp_port->dev, "link down\n");
1572                 netif_carrier_off(mlxsw_sp_port->dev);
1573         }
1574 }
1575
1576 static struct mlxsw_event_listener mlxsw_sp_pude_event = {
1577         .func = mlxsw_sp_pude_event_func,
1578         .trap_id = MLXSW_TRAP_ID_PUDE,
1579 };
1580
1581 static int mlxsw_sp_event_register(struct mlxsw_sp *mlxsw_sp,
1582                                    enum mlxsw_event_trap_id trap_id)
1583 {
1584         struct mlxsw_event_listener *el;
1585         char hpkt_pl[MLXSW_REG_HPKT_LEN];
1586         int err;
1587
1588         switch (trap_id) {
1589         case MLXSW_TRAP_ID_PUDE:
1590                 el = &mlxsw_sp_pude_event;
1591                 break;
1592         }
1593         err = mlxsw_core_event_listener_register(mlxsw_sp->core, el, mlxsw_sp);
1594         if (err)
1595                 return err;
1596
1597         mlxsw_reg_hpkt_pack(hpkt_pl, MLXSW_REG_HPKT_ACTION_FORWARD, trap_id);
1598         err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(hpkt), hpkt_pl);
1599         if (err)
1600                 goto err_event_trap_set;
1601
1602         return 0;
1603
1604 err_event_trap_set:
1605         mlxsw_core_event_listener_unregister(mlxsw_sp->core, el, mlxsw_sp);
1606         return err;
1607 }
1608
1609 static void mlxsw_sp_event_unregister(struct mlxsw_sp *mlxsw_sp,
1610                                       enum mlxsw_event_trap_id trap_id)
1611 {
1612         struct mlxsw_event_listener *el;
1613
1614         switch (trap_id) {
1615         case MLXSW_TRAP_ID_PUDE:
1616                 el = &mlxsw_sp_pude_event;
1617                 break;
1618         }
1619         mlxsw_core_event_listener_unregister(mlxsw_sp->core, el, mlxsw_sp);
1620 }
1621
1622 static void mlxsw_sp_rx_listener_func(struct sk_buff *skb, u8 local_port,
1623                                       void *priv)
1624 {
1625         struct mlxsw_sp *mlxsw_sp = priv;
1626         struct mlxsw_sp_port *mlxsw_sp_port = mlxsw_sp->ports[local_port];
1627         struct mlxsw_sp_port_pcpu_stats *pcpu_stats;
1628
1629         if (unlikely(!mlxsw_sp_port)) {
1630                 dev_warn_ratelimited(mlxsw_sp->bus_info->dev, "Port %d: skb received for non-existent port\n",
1631                                      local_port);
1632                 return;
1633         }
1634
1635         skb->dev = mlxsw_sp_port->dev;
1636
1637         pcpu_stats = this_cpu_ptr(mlxsw_sp_port->pcpu_stats);
1638         u64_stats_update_begin(&pcpu_stats->syncp);
1639         pcpu_stats->rx_packets++;
1640         pcpu_stats->rx_bytes += skb->len;
1641         u64_stats_update_end(&pcpu_stats->syncp);
1642
1643         skb->protocol = eth_type_trans(skb, skb->dev);
1644         netif_receive_skb(skb);
1645 }
1646
1647 static const struct mlxsw_rx_listener mlxsw_sp_rx_listener[] = {
1648         {
1649                 .func = mlxsw_sp_rx_listener_func,
1650                 .local_port = MLXSW_PORT_DONT_CARE,
1651                 .trap_id = MLXSW_TRAP_ID_FDB_MC,
1652         },
1653         /* Traps for specific L2 packet types, not trapped as FDB MC */
1654         {
1655                 .func = mlxsw_sp_rx_listener_func,
1656                 .local_port = MLXSW_PORT_DONT_CARE,
1657                 .trap_id = MLXSW_TRAP_ID_STP,
1658         },
1659         {
1660                 .func = mlxsw_sp_rx_listener_func,
1661                 .local_port = MLXSW_PORT_DONT_CARE,
1662                 .trap_id = MLXSW_TRAP_ID_LACP,
1663         },
1664         {
1665                 .func = mlxsw_sp_rx_listener_func,
1666                 .local_port = MLXSW_PORT_DONT_CARE,
1667                 .trap_id = MLXSW_TRAP_ID_EAPOL,
1668         },
1669         {
1670                 .func = mlxsw_sp_rx_listener_func,
1671                 .local_port = MLXSW_PORT_DONT_CARE,
1672                 .trap_id = MLXSW_TRAP_ID_LLDP,
1673         },
1674         {
1675                 .func = mlxsw_sp_rx_listener_func,
1676                 .local_port = MLXSW_PORT_DONT_CARE,
1677                 .trap_id = MLXSW_TRAP_ID_MMRP,
1678         },
1679         {
1680                 .func = mlxsw_sp_rx_listener_func,
1681                 .local_port = MLXSW_PORT_DONT_CARE,
1682                 .trap_id = MLXSW_TRAP_ID_MVRP,
1683         },
1684         {
1685                 .func = mlxsw_sp_rx_listener_func,
1686                 .local_port = MLXSW_PORT_DONT_CARE,
1687                 .trap_id = MLXSW_TRAP_ID_RPVST,
1688         },
1689         {
1690                 .func = mlxsw_sp_rx_listener_func,
1691                 .local_port = MLXSW_PORT_DONT_CARE,
1692                 .trap_id = MLXSW_TRAP_ID_DHCP,
1693         },
1694         {
1695                 .func = mlxsw_sp_rx_listener_func,
1696                 .local_port = MLXSW_PORT_DONT_CARE,
1697                 .trap_id = MLXSW_TRAP_ID_IGMP_QUERY,
1698         },
1699         {
1700                 .func = mlxsw_sp_rx_listener_func,
1701                 .local_port = MLXSW_PORT_DONT_CARE,
1702                 .trap_id = MLXSW_TRAP_ID_IGMP_V1_REPORT,
1703         },
1704         {
1705                 .func = mlxsw_sp_rx_listener_func,
1706                 .local_port = MLXSW_PORT_DONT_CARE,
1707                 .trap_id = MLXSW_TRAP_ID_IGMP_V2_REPORT,
1708         },
1709         {
1710                 .func = mlxsw_sp_rx_listener_func,
1711                 .local_port = MLXSW_PORT_DONT_CARE,
1712                 .trap_id = MLXSW_TRAP_ID_IGMP_V2_LEAVE,
1713         },
1714         {
1715                 .func = mlxsw_sp_rx_listener_func,
1716                 .local_port = MLXSW_PORT_DONT_CARE,
1717                 .trap_id = MLXSW_TRAP_ID_IGMP_V3_REPORT,
1718         },
1719 };
1720
1721 static int mlxsw_sp_traps_init(struct mlxsw_sp *mlxsw_sp)
1722 {
1723         char htgt_pl[MLXSW_REG_HTGT_LEN];
1724         char hpkt_pl[MLXSW_REG_HPKT_LEN];
1725         int i;
1726         int err;
1727
1728         mlxsw_reg_htgt_pack(htgt_pl, MLXSW_REG_HTGT_TRAP_GROUP_RX);
1729         err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(htgt), htgt_pl);
1730         if (err)
1731                 return err;
1732
1733         mlxsw_reg_htgt_pack(htgt_pl, MLXSW_REG_HTGT_TRAP_GROUP_CTRL);
1734         err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(htgt), htgt_pl);
1735         if (err)
1736                 return err;
1737
1738         for (i = 0; i < ARRAY_SIZE(mlxsw_sp_rx_listener); i++) {
1739                 err = mlxsw_core_rx_listener_register(mlxsw_sp->core,
1740                                                       &mlxsw_sp_rx_listener[i],
1741                                                       mlxsw_sp);
1742                 if (err)
1743                         goto err_rx_listener_register;
1744
1745                 mlxsw_reg_hpkt_pack(hpkt_pl, MLXSW_REG_HPKT_ACTION_TRAP_TO_CPU,
1746                                     mlxsw_sp_rx_listener[i].trap_id);
1747                 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(hpkt), hpkt_pl);
1748                 if (err)
1749                         goto err_rx_trap_set;
1750         }
1751         return 0;
1752
1753 err_rx_trap_set:
1754         mlxsw_core_rx_listener_unregister(mlxsw_sp->core,
1755                                           &mlxsw_sp_rx_listener[i],
1756                                           mlxsw_sp);
1757 err_rx_listener_register:
1758         for (i--; i >= 0; i--) {
1759                 mlxsw_reg_hpkt_pack(hpkt_pl, MLXSW_REG_HPKT_ACTION_FORWARD,
1760                                     mlxsw_sp_rx_listener[i].trap_id);
1761                 mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(hpkt), hpkt_pl);
1762
1763                 mlxsw_core_rx_listener_unregister(mlxsw_sp->core,
1764                                                   &mlxsw_sp_rx_listener[i],
1765                                                   mlxsw_sp);
1766         }
1767         return err;
1768 }
1769
1770 static void mlxsw_sp_traps_fini(struct mlxsw_sp *mlxsw_sp)
1771 {
1772         char hpkt_pl[MLXSW_REG_HPKT_LEN];
1773         int i;
1774
1775         for (i = 0; i < ARRAY_SIZE(mlxsw_sp_rx_listener); i++) {
1776                 mlxsw_reg_hpkt_pack(hpkt_pl, MLXSW_REG_HPKT_ACTION_FORWARD,
1777                                     mlxsw_sp_rx_listener[i].trap_id);
1778                 mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(hpkt), hpkt_pl);
1779
1780                 mlxsw_core_rx_listener_unregister(mlxsw_sp->core,
1781                                                   &mlxsw_sp_rx_listener[i],
1782                                                   mlxsw_sp);
1783         }
1784 }
1785
1786 static int __mlxsw_sp_flood_init(struct mlxsw_core *mlxsw_core,
1787                                  enum mlxsw_reg_sfgc_type type,
1788                                  enum mlxsw_reg_sfgc_bridge_type bridge_type)
1789 {
1790         enum mlxsw_flood_table_type table_type;
1791         enum mlxsw_sp_flood_table flood_table;
1792         char sfgc_pl[MLXSW_REG_SFGC_LEN];
1793
1794         if (bridge_type == MLXSW_REG_SFGC_BRIDGE_TYPE_VFID)
1795                 table_type = MLXSW_REG_SFGC_TABLE_TYPE_FID;
1796         else
1797                 table_type = MLXSW_REG_SFGC_TABLE_TYPE_FID_OFFEST;
1798
1799         if (type == MLXSW_REG_SFGC_TYPE_UNKNOWN_UNICAST)
1800                 flood_table = MLXSW_SP_FLOOD_TABLE_UC;
1801         else
1802                 flood_table = MLXSW_SP_FLOOD_TABLE_BM;
1803
1804         mlxsw_reg_sfgc_pack(sfgc_pl, type, bridge_type, table_type,
1805                             flood_table);
1806         return mlxsw_reg_write(mlxsw_core, MLXSW_REG(sfgc), sfgc_pl);
1807 }
1808
1809 static int mlxsw_sp_flood_init(struct mlxsw_sp *mlxsw_sp)
1810 {
1811         int type, err;
1812
1813         for (type = 0; type < MLXSW_REG_SFGC_TYPE_MAX; type++) {
1814                 if (type == MLXSW_REG_SFGC_TYPE_RESERVED)
1815                         continue;
1816
1817                 err = __mlxsw_sp_flood_init(mlxsw_sp->core, type,
1818                                             MLXSW_REG_SFGC_BRIDGE_TYPE_VFID);
1819                 if (err)
1820                         return err;
1821
1822                 err = __mlxsw_sp_flood_init(mlxsw_sp->core, type,
1823                                             MLXSW_REG_SFGC_BRIDGE_TYPE_1Q_FID);
1824                 if (err)
1825                         return err;
1826         }
1827
1828         return 0;
1829 }
1830
1831 static int mlxsw_sp_lag_init(struct mlxsw_sp *mlxsw_sp)
1832 {
1833         char slcr_pl[MLXSW_REG_SLCR_LEN];
1834
1835         mlxsw_reg_slcr_pack(slcr_pl, MLXSW_REG_SLCR_LAG_HASH_SMAC |
1836                                      MLXSW_REG_SLCR_LAG_HASH_DMAC |
1837                                      MLXSW_REG_SLCR_LAG_HASH_ETHERTYPE |
1838                                      MLXSW_REG_SLCR_LAG_HASH_VLANID |
1839                                      MLXSW_REG_SLCR_LAG_HASH_SIP |
1840                                      MLXSW_REG_SLCR_LAG_HASH_DIP |
1841                                      MLXSW_REG_SLCR_LAG_HASH_SPORT |
1842                                      MLXSW_REG_SLCR_LAG_HASH_DPORT |
1843                                      MLXSW_REG_SLCR_LAG_HASH_IPPROTO);
1844         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(slcr), slcr_pl);
1845 }
1846
1847 static int mlxsw_sp_init(void *priv, struct mlxsw_core *mlxsw_core,
1848                          const struct mlxsw_bus_info *mlxsw_bus_info)
1849 {
1850         struct mlxsw_sp *mlxsw_sp = priv;
1851         int err;
1852
1853         mlxsw_sp->core = mlxsw_core;
1854         mlxsw_sp->bus_info = mlxsw_bus_info;
1855         INIT_LIST_HEAD(&mlxsw_sp->port_vfids.list);
1856         INIT_LIST_HEAD(&mlxsw_sp->br_vfids.list);
1857
1858         err = mlxsw_sp_base_mac_get(mlxsw_sp);
1859         if (err) {
1860                 dev_err(mlxsw_sp->bus_info->dev, "Failed to get base mac\n");
1861                 return err;
1862         }
1863
1864         err = mlxsw_sp_ports_create(mlxsw_sp);
1865         if (err) {
1866                 dev_err(mlxsw_sp->bus_info->dev, "Failed to create ports\n");
1867                 return err;
1868         }
1869
1870         err = mlxsw_sp_event_register(mlxsw_sp, MLXSW_TRAP_ID_PUDE);
1871         if (err) {
1872                 dev_err(mlxsw_sp->bus_info->dev, "Failed to register for PUDE events\n");
1873                 goto err_event_register;
1874         }
1875
1876         err = mlxsw_sp_traps_init(mlxsw_sp);
1877         if (err) {
1878                 dev_err(mlxsw_sp->bus_info->dev, "Failed to set traps for RX\n");
1879                 goto err_rx_listener_register;
1880         }
1881
1882         err = mlxsw_sp_flood_init(mlxsw_sp);
1883         if (err) {
1884                 dev_err(mlxsw_sp->bus_info->dev, "Failed to initialize flood tables\n");
1885                 goto err_flood_init;
1886         }
1887
1888         err = mlxsw_sp_buffers_init(mlxsw_sp);
1889         if (err) {
1890                 dev_err(mlxsw_sp->bus_info->dev, "Failed to initialize buffers\n");
1891                 goto err_buffers_init;
1892         }
1893
1894         err = mlxsw_sp_lag_init(mlxsw_sp);
1895         if (err) {
1896                 dev_err(mlxsw_sp->bus_info->dev, "Failed to initialize LAG\n");
1897                 goto err_lag_init;
1898         }
1899
1900         err = mlxsw_sp_switchdev_init(mlxsw_sp);
1901         if (err) {
1902                 dev_err(mlxsw_sp->bus_info->dev, "Failed to initialize switchdev\n");
1903                 goto err_switchdev_init;
1904         }
1905
1906         return 0;
1907
1908 err_switchdev_init:
1909 err_lag_init:
1910 err_buffers_init:
1911 err_flood_init:
1912         mlxsw_sp_traps_fini(mlxsw_sp);
1913 err_rx_listener_register:
1914         mlxsw_sp_event_unregister(mlxsw_sp, MLXSW_TRAP_ID_PUDE);
1915 err_event_register:
1916         mlxsw_sp_ports_remove(mlxsw_sp);
1917         return err;
1918 }
1919
1920 static void mlxsw_sp_fini(void *priv)
1921 {
1922         struct mlxsw_sp *mlxsw_sp = priv;
1923
1924         mlxsw_sp_switchdev_fini(mlxsw_sp);
1925         mlxsw_sp_traps_fini(mlxsw_sp);
1926         mlxsw_sp_event_unregister(mlxsw_sp, MLXSW_TRAP_ID_PUDE);
1927         mlxsw_sp_ports_remove(mlxsw_sp);
1928 }
1929
1930 static struct mlxsw_config_profile mlxsw_sp_config_profile = {
1931         .used_max_vepa_channels         = 1,
1932         .max_vepa_channels              = 0,
1933         .used_max_lag                   = 1,
1934         .max_lag                        = MLXSW_SP_LAG_MAX,
1935         .used_max_port_per_lag          = 1,
1936         .max_port_per_lag               = MLXSW_SP_PORT_PER_LAG_MAX,
1937         .used_max_mid                   = 1,
1938         .max_mid                        = 7000,
1939         .used_max_pgt                   = 1,
1940         .max_pgt                        = 0,
1941         .used_max_system_port           = 1,
1942         .max_system_port                = 64,
1943         .used_max_vlan_groups           = 1,
1944         .max_vlan_groups                = 127,
1945         .used_max_regions               = 1,
1946         .max_regions                    = 400,
1947         .used_flood_tables              = 1,
1948         .used_flood_mode                = 1,
1949         .flood_mode                     = 3,
1950         .max_fid_offset_flood_tables    = 2,
1951         .fid_offset_flood_table_size    = VLAN_N_VID - 1,
1952         .max_fid_flood_tables           = 2,
1953         .fid_flood_table_size           = MLXSW_SP_VFID_MAX,
1954         .used_max_ib_mc                 = 1,
1955         .max_ib_mc                      = 0,
1956         .used_max_pkey                  = 1,
1957         .max_pkey                       = 0,
1958         .swid_config                    = {
1959                 {
1960                         .used_type      = 1,
1961                         .type           = MLXSW_PORT_SWID_TYPE_ETH,
1962                 }
1963         },
1964 };
1965
1966 static struct mlxsw_driver mlxsw_sp_driver = {
1967         .kind                   = MLXSW_DEVICE_KIND_SPECTRUM,
1968         .owner                  = THIS_MODULE,
1969         .priv_size              = sizeof(struct mlxsw_sp),
1970         .init                   = mlxsw_sp_init,
1971         .fini                   = mlxsw_sp_fini,
1972         .txhdr_construct        = mlxsw_sp_txhdr_construct,
1973         .txhdr_len              = MLXSW_TXHDR_LEN,
1974         .profile                = &mlxsw_sp_config_profile,
1975 };
1976
1977 static bool mlxsw_sp_port_dev_check(const struct net_device *dev)
1978 {
1979         return dev->netdev_ops == &mlxsw_sp_port_netdev_ops;
1980 }
1981
1982 static int mlxsw_sp_port_bridge_join(struct mlxsw_sp_port *mlxsw_sp_port)
1983 {
1984         struct net_device *dev = mlxsw_sp_port->dev;
1985         int err;
1986
1987         /* When port is not bridged untagged packets are tagged with
1988          * PVID=VID=1, thereby creating an implicit VLAN interface in
1989          * the device. Remove it and let bridge code take care of its
1990          * own VLANs.
1991          */
1992         err = mlxsw_sp_port_kill_vid(dev, 0, 1);
1993         if (err)
1994                 netdev_err(dev, "Failed to remove VID 1\n");
1995
1996         return err;
1997 }
1998
1999 static int mlxsw_sp_port_bridge_leave(struct mlxsw_sp_port *mlxsw_sp_port)
2000 {
2001         struct net_device *dev = mlxsw_sp_port->dev;
2002         int err;
2003
2004         /* Add implicit VLAN interface in the device, so that untagged
2005          * packets will be classified to the default vFID.
2006          */
2007         err = mlxsw_sp_port_add_vid(dev, 0, 1);
2008         if (err)
2009                 netdev_err(dev, "Failed to add VID 1\n");
2010
2011         return err;
2012 }
2013
2014 static bool mlxsw_sp_master_bridge_check(struct mlxsw_sp *mlxsw_sp,
2015                                          struct net_device *br_dev)
2016 {
2017         return !mlxsw_sp->master_bridge.dev ||
2018                mlxsw_sp->master_bridge.dev == br_dev;
2019 }
2020
2021 static void mlxsw_sp_master_bridge_inc(struct mlxsw_sp *mlxsw_sp,
2022                                        struct net_device *br_dev)
2023 {
2024         mlxsw_sp->master_bridge.dev = br_dev;
2025         mlxsw_sp->master_bridge.ref_count++;
2026 }
2027
2028 static void mlxsw_sp_master_bridge_dec(struct mlxsw_sp *mlxsw_sp,
2029                                        struct net_device *br_dev)
2030 {
2031         if (--mlxsw_sp->master_bridge.ref_count == 0)
2032                 mlxsw_sp->master_bridge.dev = NULL;
2033 }
2034
2035 static int mlxsw_sp_lag_create(struct mlxsw_sp *mlxsw_sp, u16 lag_id)
2036 {
2037         char sldr_pl[MLXSW_REG_SLDR_LEN];
2038
2039         mlxsw_reg_sldr_lag_create_pack(sldr_pl, lag_id);
2040         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sldr), sldr_pl);
2041 }
2042
2043 static int mlxsw_sp_lag_destroy(struct mlxsw_sp *mlxsw_sp, u16 lag_id)
2044 {
2045         char sldr_pl[MLXSW_REG_SLDR_LEN];
2046
2047         mlxsw_reg_sldr_lag_destroy_pack(sldr_pl, lag_id);
2048         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sldr), sldr_pl);
2049 }
2050
2051 static int mlxsw_sp_lag_col_port_add(struct mlxsw_sp_port *mlxsw_sp_port,
2052                                      u16 lag_id, u8 port_index)
2053 {
2054         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
2055         char slcor_pl[MLXSW_REG_SLCOR_LEN];
2056
2057         mlxsw_reg_slcor_port_add_pack(slcor_pl, mlxsw_sp_port->local_port,
2058                                       lag_id, port_index);
2059         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(slcor), slcor_pl);
2060 }
2061
2062 static int mlxsw_sp_lag_col_port_remove(struct mlxsw_sp_port *mlxsw_sp_port,
2063                                         u16 lag_id)
2064 {
2065         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
2066         char slcor_pl[MLXSW_REG_SLCOR_LEN];
2067
2068         mlxsw_reg_slcor_port_remove_pack(slcor_pl, mlxsw_sp_port->local_port,
2069                                          lag_id);
2070         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(slcor), slcor_pl);
2071 }
2072
2073 static int mlxsw_sp_lag_col_port_enable(struct mlxsw_sp_port *mlxsw_sp_port,
2074                                         u16 lag_id)
2075 {
2076         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
2077         char slcor_pl[MLXSW_REG_SLCOR_LEN];
2078
2079         mlxsw_reg_slcor_col_enable_pack(slcor_pl, mlxsw_sp_port->local_port,
2080                                         lag_id);
2081         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(slcor), slcor_pl);
2082 }
2083
2084 static int mlxsw_sp_lag_col_port_disable(struct mlxsw_sp_port *mlxsw_sp_port,
2085                                          u16 lag_id)
2086 {
2087         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
2088         char slcor_pl[MLXSW_REG_SLCOR_LEN];
2089
2090         mlxsw_reg_slcor_col_disable_pack(slcor_pl, mlxsw_sp_port->local_port,
2091                                          lag_id);
2092         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(slcor), slcor_pl);
2093 }
2094
2095 static int mlxsw_sp_lag_index_get(struct mlxsw_sp *mlxsw_sp,
2096                                   struct net_device *lag_dev,
2097                                   u16 *p_lag_id)
2098 {
2099         struct mlxsw_sp_upper *lag;
2100         int free_lag_id = -1;
2101         int i;
2102
2103         for (i = 0; i < MLXSW_SP_LAG_MAX; i++) {
2104                 lag = mlxsw_sp_lag_get(mlxsw_sp, i);
2105                 if (lag->ref_count) {
2106                         if (lag->dev == lag_dev) {
2107                                 *p_lag_id = i;
2108                                 return 0;
2109                         }
2110                 } else if (free_lag_id < 0) {
2111                         free_lag_id = i;
2112                 }
2113         }
2114         if (free_lag_id < 0)
2115                 return -EBUSY;
2116         *p_lag_id = free_lag_id;
2117         return 0;
2118 }
2119
2120 static bool
2121 mlxsw_sp_master_lag_check(struct mlxsw_sp *mlxsw_sp,
2122                           struct net_device *lag_dev,
2123                           struct netdev_lag_upper_info *lag_upper_info)
2124 {
2125         u16 lag_id;
2126
2127         if (mlxsw_sp_lag_index_get(mlxsw_sp, lag_dev, &lag_id) != 0)
2128                 return false;
2129         if (lag_upper_info->tx_type != NETDEV_LAG_TX_TYPE_HASH)
2130                 return false;
2131         return true;
2132 }
2133
2134 static int mlxsw_sp_port_lag_index_get(struct mlxsw_sp *mlxsw_sp,
2135                                        u16 lag_id, u8 *p_port_index)
2136 {
2137         int i;
2138
2139         for (i = 0; i < MLXSW_SP_PORT_PER_LAG_MAX; i++) {
2140                 if (!mlxsw_sp_port_lagged_get(mlxsw_sp, lag_id, i)) {
2141                         *p_port_index = i;
2142                         return 0;
2143                 }
2144         }
2145         return -EBUSY;
2146 }
2147
2148 static int mlxsw_sp_port_lag_join(struct mlxsw_sp_port *mlxsw_sp_port,
2149                                   struct net_device *lag_dev)
2150 {
2151         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
2152         struct mlxsw_sp_upper *lag;
2153         u16 lag_id;
2154         u8 port_index;
2155         int err;
2156
2157         err = mlxsw_sp_lag_index_get(mlxsw_sp, lag_dev, &lag_id);
2158         if (err)
2159                 return err;
2160         lag = mlxsw_sp_lag_get(mlxsw_sp, lag_id);
2161         if (!lag->ref_count) {
2162                 err = mlxsw_sp_lag_create(mlxsw_sp, lag_id);
2163                 if (err)
2164                         return err;
2165                 lag->dev = lag_dev;
2166         }
2167
2168         err = mlxsw_sp_port_lag_index_get(mlxsw_sp, lag_id, &port_index);
2169         if (err)
2170                 return err;
2171         err = mlxsw_sp_lag_col_port_add(mlxsw_sp_port, lag_id, port_index);
2172         if (err)
2173                 goto err_col_port_add;
2174         err = mlxsw_sp_lag_col_port_enable(mlxsw_sp_port, lag_id);
2175         if (err)
2176                 goto err_col_port_enable;
2177
2178         mlxsw_core_lag_mapping_set(mlxsw_sp->core, lag_id, port_index,
2179                                    mlxsw_sp_port->local_port);
2180         mlxsw_sp_port->lag_id = lag_id;
2181         mlxsw_sp_port->lagged = 1;
2182         lag->ref_count++;
2183         return 0;
2184
2185 err_col_port_add:
2186         if (!lag->ref_count)
2187                 mlxsw_sp_lag_destroy(mlxsw_sp, lag_id);
2188 err_col_port_enable:
2189         mlxsw_sp_lag_col_port_remove(mlxsw_sp_port, lag_id);
2190         return err;
2191 }
2192
2193 static int mlxsw_sp_port_lag_leave(struct mlxsw_sp_port *mlxsw_sp_port,
2194                                    struct net_device *lag_dev)
2195 {
2196         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
2197         struct mlxsw_sp_upper *lag;
2198         u16 lag_id = mlxsw_sp_port->lag_id;
2199         int err;
2200
2201         if (!mlxsw_sp_port->lagged)
2202                 return 0;
2203         lag = mlxsw_sp_lag_get(mlxsw_sp, lag_id);
2204         WARN_ON(lag->ref_count == 0);
2205
2206         err = mlxsw_sp_lag_col_port_disable(mlxsw_sp_port, lag_id);
2207         if (err)
2208                 return err;
2209         err = mlxsw_sp_lag_col_port_remove(mlxsw_sp_port, lag_id);
2210         if (err)
2211                 return err;
2212
2213         if (lag->ref_count == 1) {
2214                 err = mlxsw_sp_lag_destroy(mlxsw_sp, lag_id);
2215                 if (err)
2216                         return err;
2217         }
2218
2219         mlxsw_core_lag_mapping_clear(mlxsw_sp->core, lag_id,
2220                                      mlxsw_sp_port->local_port);
2221         mlxsw_sp_port->lagged = 0;
2222         lag->ref_count--;
2223         return 0;
2224 }
2225
2226 static int mlxsw_sp_lag_dist_port_add(struct mlxsw_sp_port *mlxsw_sp_port,
2227                                       u16 lag_id)
2228 {
2229         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
2230         char sldr_pl[MLXSW_REG_SLDR_LEN];
2231
2232         mlxsw_reg_sldr_lag_add_port_pack(sldr_pl, lag_id,
2233                                          mlxsw_sp_port->local_port);
2234         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sldr), sldr_pl);
2235 }
2236
2237 static int mlxsw_sp_lag_dist_port_remove(struct mlxsw_sp_port *mlxsw_sp_port,
2238                                          u16 lag_id)
2239 {
2240         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
2241         char sldr_pl[MLXSW_REG_SLDR_LEN];
2242
2243         mlxsw_reg_sldr_lag_remove_port_pack(sldr_pl, lag_id,
2244                                             mlxsw_sp_port->local_port);
2245         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sldr), sldr_pl);
2246 }
2247
2248 static int mlxsw_sp_port_lag_tx_en_set(struct mlxsw_sp_port *mlxsw_sp_port,
2249                                        bool lag_tx_enabled)
2250 {
2251         if (lag_tx_enabled)
2252                 return mlxsw_sp_lag_dist_port_add(mlxsw_sp_port,
2253                                                   mlxsw_sp_port->lag_id);
2254         else
2255                 return mlxsw_sp_lag_dist_port_remove(mlxsw_sp_port,
2256                                                      mlxsw_sp_port->lag_id);
2257 }
2258
2259 static int mlxsw_sp_port_lag_changed(struct mlxsw_sp_port *mlxsw_sp_port,
2260                                      struct netdev_lag_lower_state_info *info)
2261 {
2262         return mlxsw_sp_port_lag_tx_en_set(mlxsw_sp_port, info->tx_enabled);
2263 }
2264
2265 static int mlxsw_sp_vport_bridge_leave(struct mlxsw_sp_port *mlxsw_sp_vport,
2266                                        struct net_device *br_dev);
2267
2268 static int mlxsw_sp_port_vlan_link(struct mlxsw_sp_port *mlxsw_sp_port,
2269                                    struct net_device *vlan_dev)
2270 {
2271         struct mlxsw_sp_port *mlxsw_sp_vport;
2272         u16 vid = vlan_dev_vlan_id(vlan_dev);
2273
2274         mlxsw_sp_vport = mlxsw_sp_port_vport_find(mlxsw_sp_port, vid);
2275         if (!mlxsw_sp_vport) {
2276                 WARN_ON(!mlxsw_sp_vport);
2277                 return -EINVAL;
2278         }
2279
2280         mlxsw_sp_vport->dev = vlan_dev;
2281
2282         return 0;
2283 }
2284
2285 static int mlxsw_sp_port_vlan_unlink(struct mlxsw_sp_port *mlxsw_sp_port,
2286                                      struct net_device *vlan_dev)
2287 {
2288         struct mlxsw_sp_port *mlxsw_sp_vport;
2289         u16 vid = vlan_dev_vlan_id(vlan_dev);
2290
2291         mlxsw_sp_vport = mlxsw_sp_port_vport_find(mlxsw_sp_port, vid);
2292         if (!mlxsw_sp_vport) {
2293                 WARN_ON(!mlxsw_sp_vport);
2294                 return -EINVAL;
2295         }
2296
2297         /* When removing a VLAN device while still bridged we should first
2298          * remove it from the bridge, as we receive the bridge's notification
2299          * when the vPort is already gone.
2300          */
2301         if (mlxsw_sp_vport->bridged) {
2302                 struct net_device *br_dev;
2303
2304                 br_dev = mlxsw_sp_vport_br_get(mlxsw_sp_vport);
2305                 mlxsw_sp_vport_bridge_leave(mlxsw_sp_vport, br_dev);
2306         }
2307
2308         mlxsw_sp_vport->dev = mlxsw_sp_port->dev;
2309
2310         return 0;
2311 }
2312
2313 static int mlxsw_sp_netdevice_port_upper_event(struct net_device *dev,
2314                                                unsigned long event, void *ptr)
2315 {
2316         struct netdev_notifier_changeupper_info *info;
2317         struct mlxsw_sp_port *mlxsw_sp_port;
2318         struct net_device *upper_dev;
2319         struct mlxsw_sp *mlxsw_sp;
2320         int err;
2321
2322         mlxsw_sp_port = netdev_priv(dev);
2323         mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
2324         info = ptr;
2325
2326         switch (event) {
2327         case NETDEV_PRECHANGEUPPER:
2328                 upper_dev = info->upper_dev;
2329                 if (!info->master || !info->linking)
2330                         break;
2331                 /* HW limitation forbids to put ports to multiple bridges. */
2332                 if (netif_is_bridge_master(upper_dev) &&
2333                     !mlxsw_sp_master_bridge_check(mlxsw_sp, upper_dev))
2334                         return NOTIFY_BAD;
2335                 if (netif_is_lag_master(upper_dev) &&
2336                     !mlxsw_sp_master_lag_check(mlxsw_sp, upper_dev,
2337                                                info->upper_info))
2338                         return NOTIFY_BAD;
2339                 break;
2340         case NETDEV_CHANGEUPPER:
2341                 upper_dev = info->upper_dev;
2342                 if (is_vlan_dev(upper_dev)) {
2343                         if (info->linking) {
2344                                 err = mlxsw_sp_port_vlan_link(mlxsw_sp_port,
2345                                                               upper_dev);
2346                                 if (err) {
2347                                         netdev_err(dev, "Failed to link VLAN device\n");
2348                                         return NOTIFY_BAD;
2349                                 }
2350                         } else {
2351                                 err = mlxsw_sp_port_vlan_unlink(mlxsw_sp_port,
2352                                                                 upper_dev);
2353                                 if (err) {
2354                                         netdev_err(dev, "Failed to unlink VLAN device\n");
2355                                         return NOTIFY_BAD;
2356                                 }
2357                         }
2358                 } else if (netif_is_bridge_master(upper_dev)) {
2359                         if (info->linking) {
2360                                 err = mlxsw_sp_port_bridge_join(mlxsw_sp_port);
2361                                 if (err)
2362                                         netdev_err(dev, "Failed to join bridge\n");
2363                                 mlxsw_sp_master_bridge_inc(mlxsw_sp, upper_dev);
2364                                 mlxsw_sp_port->bridged = 1;
2365                         } else {
2366                                 err = mlxsw_sp_port_bridge_leave(mlxsw_sp_port);
2367                                 if (err)
2368                                         netdev_err(dev, "Failed to leave bridge\n");
2369                                 mlxsw_sp_port->bridged = 0;
2370                                 mlxsw_sp_master_bridge_dec(mlxsw_sp, upper_dev);
2371                         }
2372                 } else if (netif_is_lag_master(upper_dev)) {
2373                         if (info->linking) {
2374                                 err = mlxsw_sp_port_lag_join(mlxsw_sp_port,
2375                                                              upper_dev);
2376                                 if (err) {
2377                                         netdev_err(dev, "Failed to join link aggregation\n");
2378                                         return NOTIFY_BAD;
2379                                 }
2380                         } else {
2381                                 err = mlxsw_sp_port_lag_leave(mlxsw_sp_port,
2382                                                               upper_dev);
2383                                 if (err) {
2384                                         netdev_err(dev, "Failed to leave link aggregation\n");
2385                                         return NOTIFY_BAD;
2386                                 }
2387                         }
2388                 }
2389                 break;
2390         }
2391
2392         return NOTIFY_DONE;
2393 }
2394
2395 static int mlxsw_sp_netdevice_port_lower_event(struct net_device *dev,
2396                                                unsigned long event, void *ptr)
2397 {
2398         struct netdev_notifier_changelowerstate_info *info;
2399         struct mlxsw_sp_port *mlxsw_sp_port;
2400         int err;
2401
2402         mlxsw_sp_port = netdev_priv(dev);
2403         info = ptr;
2404
2405         switch (event) {
2406         case NETDEV_CHANGELOWERSTATE:
2407                 if (netif_is_lag_port(dev) && mlxsw_sp_port->lagged) {
2408                         err = mlxsw_sp_port_lag_changed(mlxsw_sp_port,
2409                                                         info->lower_state_info);
2410                         if (err)
2411                                 netdev_err(dev, "Failed to reflect link aggregation lower state change\n");
2412                 }
2413                 break;
2414         }
2415
2416         return NOTIFY_DONE;
2417 }
2418
2419 static int mlxsw_sp_netdevice_port_event(struct net_device *dev,
2420                                          unsigned long event, void *ptr)
2421 {
2422         switch (event) {
2423         case NETDEV_PRECHANGEUPPER:
2424         case NETDEV_CHANGEUPPER:
2425                 return mlxsw_sp_netdevice_port_upper_event(dev, event, ptr);
2426         case NETDEV_CHANGELOWERSTATE:
2427                 return mlxsw_sp_netdevice_port_lower_event(dev, event, ptr);
2428         }
2429
2430         return NOTIFY_DONE;
2431 }
2432
2433 static int mlxsw_sp_netdevice_lag_event(struct net_device *lag_dev,
2434                                         unsigned long event, void *ptr)
2435 {
2436         struct net_device *dev;
2437         struct list_head *iter;
2438         int ret;
2439
2440         netdev_for_each_lower_dev(lag_dev, dev, iter) {
2441                 if (mlxsw_sp_port_dev_check(dev)) {
2442                         ret = mlxsw_sp_netdevice_port_event(dev, event, ptr);
2443                         if (ret == NOTIFY_BAD)
2444                                 return ret;
2445                 }
2446         }
2447
2448         return NOTIFY_DONE;
2449 }
2450
2451 static struct mlxsw_sp_vfid *
2452 mlxsw_sp_br_vfid_find(const struct mlxsw_sp *mlxsw_sp,
2453                       const struct net_device *br_dev)
2454 {
2455         struct mlxsw_sp_vfid *vfid;
2456
2457         list_for_each_entry(vfid, &mlxsw_sp->br_vfids.list, list) {
2458                 if (vfid->br_dev == br_dev)
2459                         return vfid;
2460         }
2461
2462         return NULL;
2463 }
2464
2465 static u16 mlxsw_sp_vfid_to_br_vfid(u16 vfid)
2466 {
2467         return vfid - MLXSW_SP_VFID_PORT_MAX;
2468 }
2469
2470 static u16 mlxsw_sp_br_vfid_to_vfid(u16 br_vfid)
2471 {
2472         return MLXSW_SP_VFID_PORT_MAX + br_vfid;
2473 }
2474
2475 static u16 mlxsw_sp_avail_br_vfid_get(const struct mlxsw_sp *mlxsw_sp)
2476 {
2477         return find_first_zero_bit(mlxsw_sp->br_vfids.mapped,
2478                                    MLXSW_SP_VFID_BR_MAX);
2479 }
2480
2481 static struct mlxsw_sp_vfid *mlxsw_sp_br_vfid_create(struct mlxsw_sp *mlxsw_sp,
2482                                                      struct net_device *br_dev)
2483 {
2484         struct device *dev = mlxsw_sp->bus_info->dev;
2485         struct mlxsw_sp_vfid *vfid;
2486         u16 n_vfid;
2487         int err;
2488
2489         n_vfid = mlxsw_sp_br_vfid_to_vfid(mlxsw_sp_avail_br_vfid_get(mlxsw_sp));
2490         if (n_vfid == MLXSW_SP_VFID_MAX) {
2491                 dev_err(dev, "No available vFIDs\n");
2492                 return ERR_PTR(-ERANGE);
2493         }
2494
2495         err = __mlxsw_sp_vfid_create(mlxsw_sp, n_vfid);
2496         if (err) {
2497                 dev_err(dev, "Failed to create vFID=%d\n", n_vfid);
2498                 return ERR_PTR(err);
2499         }
2500
2501         vfid = kzalloc(sizeof(*vfid), GFP_KERNEL);
2502         if (!vfid)
2503                 goto err_allocate_vfid;
2504
2505         vfid->vfid = n_vfid;
2506         vfid->br_dev = br_dev;
2507
2508         list_add(&vfid->list, &mlxsw_sp->br_vfids.list);
2509         set_bit(mlxsw_sp_vfid_to_br_vfid(n_vfid), mlxsw_sp->br_vfids.mapped);
2510
2511         return vfid;
2512
2513 err_allocate_vfid:
2514         __mlxsw_sp_vfid_destroy(mlxsw_sp, n_vfid);
2515         return ERR_PTR(-ENOMEM);
2516 }
2517
2518 static void mlxsw_sp_br_vfid_destroy(struct mlxsw_sp *mlxsw_sp,
2519                                      struct mlxsw_sp_vfid *vfid)
2520 {
2521         u16 br_vfid = mlxsw_sp_vfid_to_br_vfid(vfid->vfid);
2522
2523         clear_bit(br_vfid, mlxsw_sp->br_vfids.mapped);
2524         list_del(&vfid->list);
2525
2526         __mlxsw_sp_vfid_destroy(mlxsw_sp, vfid->vfid);
2527
2528         kfree(vfid);
2529 }
2530
2531 static int mlxsw_sp_vport_bridge_leave(struct mlxsw_sp_port *mlxsw_sp_vport,
2532                                        struct net_device *br_dev)
2533 {
2534         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_vport->mlxsw_sp;
2535         u16 vid = mlxsw_sp_vport_vid_get(mlxsw_sp_vport);
2536         struct net_device *dev = mlxsw_sp_vport->dev;
2537         struct mlxsw_sp_vfid *vfid, *new_vfid;
2538         int err;
2539
2540         vfid = mlxsw_sp_br_vfid_find(mlxsw_sp, br_dev);
2541         if (!vfid) {
2542                 WARN_ON(!vfid);
2543                 return -EINVAL;
2544         }
2545
2546         /* We need a vFID to go back to after leaving the bridge's vFID. */
2547         new_vfid = mlxsw_sp_vfid_find(mlxsw_sp, vid);
2548         if (!new_vfid) {
2549                 new_vfid = mlxsw_sp_vfid_create(mlxsw_sp, vid);
2550                 if (IS_ERR(new_vfid)) {
2551                         netdev_err(dev, "Failed to create vFID for VID=%d\n",
2552                                    vid);
2553                         return PTR_ERR(new_vfid);
2554                 }
2555         }
2556
2557         /* Invalidate existing {Port, VID} to vFID mapping and create a new
2558          * one for the new vFID.
2559          */
2560         err = mlxsw_sp_port_vid_to_fid_set(mlxsw_sp_vport,
2561                                            MLXSW_REG_SVFA_MT_PORT_VID_TO_FID,
2562                                            false,
2563                                            mlxsw_sp_vfid_to_fid(vfid->vfid),
2564                                            vid);
2565         if (err) {
2566                 netdev_err(dev, "Failed to invalidate {Port, VID} to vFID=%d mapping\n",
2567                            vfid->vfid);
2568                 goto err_port_vid_to_fid_invalidate;
2569         }
2570
2571         err = mlxsw_sp_port_vid_to_fid_set(mlxsw_sp_vport,
2572                                            MLXSW_REG_SVFA_MT_PORT_VID_TO_FID,
2573                                            true,
2574                                            mlxsw_sp_vfid_to_fid(new_vfid->vfid),
2575                                            vid);
2576         if (err) {
2577                 netdev_err(dev, "Failed to map {Port, VID} to vFID=%d\n",
2578                            new_vfid->vfid);
2579                 goto err_port_vid_to_fid_validate;
2580         }
2581
2582         err = mlxsw_sp_port_vid_learning_set(mlxsw_sp_vport, vid, false);
2583         if (err) {
2584                 netdev_err(dev, "Failed to disable learning\n");
2585                 goto err_port_vid_learning_set;
2586         }
2587
2588         err = mlxsw_sp_vport_flood_set(mlxsw_sp_vport, vfid->vfid, false,
2589                                        false);
2590         if (err) {
2591                 netdev_err(dev, "Failed clear to clear flooding\n");
2592                 goto err_vport_flood_set;
2593         }
2594
2595         /* Switch between the vFIDs and destroy the old one if needed. */
2596         new_vfid->nr_vports++;
2597         mlxsw_sp_vport->vport.vfid = new_vfid;
2598         vfid->nr_vports--;
2599         if (!vfid->nr_vports)
2600                 mlxsw_sp_br_vfid_destroy(mlxsw_sp, vfid);
2601
2602         mlxsw_sp_vport->learning = 0;
2603         mlxsw_sp_vport->learning_sync = 0;
2604         mlxsw_sp_vport->uc_flood = 0;
2605         mlxsw_sp_vport->bridged = 0;
2606
2607         return 0;
2608
2609 err_vport_flood_set:
2610 err_port_vid_learning_set:
2611 err_port_vid_to_fid_validate:
2612 err_port_vid_to_fid_invalidate:
2613         /* Rollback vFID only if new. */
2614         if (!new_vfid->nr_vports)
2615                 mlxsw_sp_vfid_destroy(mlxsw_sp, new_vfid);
2616         return err;
2617 }
2618
2619 static int mlxsw_sp_vport_bridge_join(struct mlxsw_sp_port *mlxsw_sp_vport,
2620                                       struct net_device *br_dev)
2621 {
2622         struct mlxsw_sp_vfid *old_vfid = mlxsw_sp_vport->vport.vfid;
2623         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_vport->mlxsw_sp;
2624         u16 vid = mlxsw_sp_vport_vid_get(mlxsw_sp_vport);
2625         struct net_device *dev = mlxsw_sp_vport->dev;
2626         struct mlxsw_sp_vfid *vfid;
2627         int err;
2628
2629         vfid = mlxsw_sp_br_vfid_find(mlxsw_sp, br_dev);
2630         if (!vfid) {
2631                 vfid = mlxsw_sp_br_vfid_create(mlxsw_sp, br_dev);
2632                 if (IS_ERR(vfid)) {
2633                         netdev_err(dev, "Failed to create bridge vFID\n");
2634                         return PTR_ERR(vfid);
2635                 }
2636         }
2637
2638         err = mlxsw_sp_vport_flood_set(mlxsw_sp_vport, vfid->vfid, true, false);
2639         if (err) {
2640                 netdev_err(dev, "Failed to setup flooding for vFID=%d\n",
2641                            vfid->vfid);
2642                 goto err_port_flood_set;
2643         }
2644
2645         err = mlxsw_sp_port_vid_learning_set(mlxsw_sp_vport, vid, true);
2646         if (err) {
2647                 netdev_err(dev, "Failed to enable learning\n");
2648                 goto err_port_vid_learning_set;
2649         }
2650
2651         /* We need to invalidate existing {Port, VID} to vFID mapping and
2652          * create a new one for the bridge's vFID.
2653          */
2654         err = mlxsw_sp_port_vid_to_fid_set(mlxsw_sp_vport,
2655                                            MLXSW_REG_SVFA_MT_PORT_VID_TO_FID,
2656                                            false,
2657                                            mlxsw_sp_vfid_to_fid(old_vfid->vfid),
2658                                            vid);
2659         if (err) {
2660                 netdev_err(dev, "Failed to invalidate {Port, VID} to vFID=%d mapping\n",
2661                            old_vfid->vfid);
2662                 goto err_port_vid_to_fid_invalidate;
2663         }
2664
2665         err = mlxsw_sp_port_vid_to_fid_set(mlxsw_sp_vport,
2666                                            MLXSW_REG_SVFA_MT_PORT_VID_TO_FID,
2667                                            true,
2668                                            mlxsw_sp_vfid_to_fid(vfid->vfid),
2669                                            vid);
2670         if (err) {
2671                 netdev_err(dev, "Failed to map {Port, VID} to vFID=%d\n",
2672                            vfid->vfid);
2673                 goto err_port_vid_to_fid_validate;
2674         }
2675
2676         /* Switch between the vFIDs and destroy the old one if needed. */
2677         vfid->nr_vports++;
2678         mlxsw_sp_vport->vport.vfid = vfid;
2679         old_vfid->nr_vports--;
2680         if (!old_vfid->nr_vports)
2681                 mlxsw_sp_vfid_destroy(mlxsw_sp, old_vfid);
2682
2683         mlxsw_sp_vport->learning = 1;
2684         mlxsw_sp_vport->learning_sync = 1;
2685         mlxsw_sp_vport->uc_flood = 1;
2686         mlxsw_sp_vport->bridged = 1;
2687
2688         return 0;
2689
2690 err_port_vid_to_fid_validate:
2691         mlxsw_sp_port_vid_to_fid_set(mlxsw_sp_vport,
2692                                      MLXSW_REG_SVFA_MT_PORT_VID_TO_FID, false,
2693                                      mlxsw_sp_vfid_to_fid(old_vfid->vfid), vid);
2694 err_port_vid_to_fid_invalidate:
2695         mlxsw_sp_port_vid_learning_set(mlxsw_sp_vport, vid, false);
2696 err_port_vid_learning_set:
2697         mlxsw_sp_vport_flood_set(mlxsw_sp_vport, vfid->vfid, false, false);
2698 err_port_flood_set:
2699         if (!vfid->nr_vports)
2700                 mlxsw_sp_br_vfid_destroy(mlxsw_sp, vfid);
2701         return err;
2702 }
2703
2704 static bool
2705 mlxsw_sp_port_master_bridge_check(const struct mlxsw_sp_port *mlxsw_sp_port,
2706                                   const struct net_device *br_dev)
2707 {
2708         struct mlxsw_sp_port *mlxsw_sp_vport;
2709
2710         list_for_each_entry(mlxsw_sp_vport, &mlxsw_sp_port->vports_list,
2711                             vport.list) {
2712                 if (mlxsw_sp_vport_br_get(mlxsw_sp_vport) == br_dev)
2713                         return false;
2714         }
2715
2716         return true;
2717 }
2718
2719 static int mlxsw_sp_netdevice_vport_event(struct net_device *dev,
2720                                           unsigned long event, void *ptr,
2721                                           u16 vid)
2722 {
2723         struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
2724         struct netdev_notifier_changeupper_info *info = ptr;
2725         struct mlxsw_sp_port *mlxsw_sp_vport;
2726         struct net_device *upper_dev;
2727         int err;
2728
2729         mlxsw_sp_vport = mlxsw_sp_port_vport_find(mlxsw_sp_port, vid);
2730
2731         switch (event) {
2732         case NETDEV_PRECHANGEUPPER:
2733                 upper_dev = info->upper_dev;
2734                 if (!info->master || !info->linking)
2735                         break;
2736                 if (!netif_is_bridge_master(upper_dev))
2737                         return NOTIFY_BAD;
2738                 /* We can't have multiple VLAN interfaces configured on
2739                  * the same port and being members in the same bridge.
2740                  */
2741                 if (!mlxsw_sp_port_master_bridge_check(mlxsw_sp_port,
2742                                                        upper_dev))
2743                         return NOTIFY_BAD;
2744                 break;
2745         case NETDEV_CHANGEUPPER:
2746                 upper_dev = info->upper_dev;
2747                 if (!info->master)
2748                         break;
2749                 if (info->linking) {
2750                         if (!mlxsw_sp_vport) {
2751                                 WARN_ON(!mlxsw_sp_vport);
2752                                 return NOTIFY_BAD;
2753                         }
2754                         err = mlxsw_sp_vport_bridge_join(mlxsw_sp_vport,
2755                                                          upper_dev);
2756                         if (err) {
2757                                 netdev_err(dev, "Failed to join bridge\n");
2758                                 return NOTIFY_BAD;
2759                         }
2760                 } else {
2761                         /* We ignore bridge's unlinking notifications if vPort
2762                          * is gone, since we already left the bridge when the
2763                          * VLAN device was unlinked from the real device.
2764                          */
2765                         if (!mlxsw_sp_vport)
2766                                 return NOTIFY_DONE;
2767                         err = mlxsw_sp_vport_bridge_leave(mlxsw_sp_vport,
2768                                                           upper_dev);
2769                         if (err) {
2770                                 netdev_err(dev, "Failed to leave bridge\n");
2771                                 return NOTIFY_BAD;
2772                         }
2773                 }
2774         }
2775
2776         return NOTIFY_DONE;
2777 }
2778
2779 static int mlxsw_sp_netdevice_lag_vport_event(struct net_device *lag_dev,
2780                                               unsigned long event, void *ptr,
2781                                               u16 vid)
2782 {
2783         struct net_device *dev;
2784         struct list_head *iter;
2785         int ret;
2786
2787         netdev_for_each_lower_dev(lag_dev, dev, iter) {
2788                 if (mlxsw_sp_port_dev_check(dev)) {
2789                         ret = mlxsw_sp_netdevice_vport_event(dev, event, ptr,
2790                                                              vid);
2791                         if (ret == NOTIFY_BAD)
2792                                 return ret;
2793                 }
2794         }
2795
2796         return NOTIFY_DONE;
2797 }
2798
2799 static int mlxsw_sp_netdevice_vlan_event(struct net_device *vlan_dev,
2800                                          unsigned long event, void *ptr)
2801 {
2802         struct net_device *real_dev = vlan_dev_real_dev(vlan_dev);
2803         u16 vid = vlan_dev_vlan_id(vlan_dev);
2804
2805         if (mlxsw_sp_port_dev_check(real_dev))
2806                 return mlxsw_sp_netdevice_vport_event(real_dev, event, ptr,
2807                                                       vid);
2808         else if (netif_is_lag_master(real_dev))
2809                 return mlxsw_sp_netdevice_lag_vport_event(real_dev, event, ptr,
2810                                                           vid);
2811
2812         return NOTIFY_DONE;
2813 }
2814
2815 static int mlxsw_sp_netdevice_event(struct notifier_block *unused,
2816                                     unsigned long event, void *ptr)
2817 {
2818         struct net_device *dev = netdev_notifier_info_to_dev(ptr);
2819
2820         if (mlxsw_sp_port_dev_check(dev))
2821                 return mlxsw_sp_netdevice_port_event(dev, event, ptr);
2822
2823         if (netif_is_lag_master(dev))
2824                 return mlxsw_sp_netdevice_lag_event(dev, event, ptr);
2825
2826         if (is_vlan_dev(dev))
2827                 return mlxsw_sp_netdevice_vlan_event(dev, event, ptr);
2828
2829         return NOTIFY_DONE;
2830 }
2831
2832 static struct notifier_block mlxsw_sp_netdevice_nb __read_mostly = {
2833         .notifier_call = mlxsw_sp_netdevice_event,
2834 };
2835
2836 static int __init mlxsw_sp_module_init(void)
2837 {
2838         int err;
2839
2840         register_netdevice_notifier(&mlxsw_sp_netdevice_nb);
2841         err = mlxsw_core_driver_register(&mlxsw_sp_driver);
2842         if (err)
2843                 goto err_core_driver_register;
2844         return 0;
2845
2846 err_core_driver_register:
2847         unregister_netdevice_notifier(&mlxsw_sp_netdevice_nb);
2848         return err;
2849 }
2850
2851 static void __exit mlxsw_sp_module_exit(void)
2852 {
2853         mlxsw_core_driver_unregister(&mlxsw_sp_driver);
2854         unregister_netdevice_notifier(&mlxsw_sp_netdevice_nb);
2855 }
2856
2857 module_init(mlxsw_sp_module_init);
2858 module_exit(mlxsw_sp_module_exit);
2859
2860 MODULE_LICENSE("Dual BSD/GPL");
2861 MODULE_AUTHOR("Jiri Pirko <jiri@mellanox.com>");
2862 MODULE_DESCRIPTION("Mellanox Spectrum driver");
2863 MODULE_MLXSW_DRIVER_ALIAS(MLXSW_DEVICE_KIND_SPECTRUM);