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

   1 /*
   2  * drivers/net/ethernet/mellanox/mlxsw/spectrum_switchdev.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/types.h>
  39 #include <linux/netdevice.h>
  40 #include <linux/etherdevice.h>
  41 #include <linux/slab.h>
  42 #include <linux/device.h>
  43 #include <linux/skbuff.h>
  44 #include <linux/if_vlan.h>
  45 #include <linux/if_bridge.h>
  46 #include <linux/workqueue.h>
  47 #include <linux/jiffies.h>
  48 #include <net/switchdev.h>
  49
  50 #include "spectrum.h"
  51 #include "core.h"
  52 #include "reg.h"
  53
  54 static int mlxsw_sp_port_attr_get(struct net_device *dev,
  55                                   struct switchdev_attr *attr)
  56 {
  57         struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
  58         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
  59
  60         switch (attr->id) {
  61         case SWITCHDEV_ATTR_ID_PORT_PARENT_ID:
  62                 attr->u.ppid.id_len = sizeof(mlxsw_sp->base_mac);
  63                 memcpy(&attr->u.ppid.id, &mlxsw_sp->base_mac,
  64                        attr->u.ppid.id_len);
  65                 break;
  66         case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS:
  67                 attr->u.brport_flags =
  68                         (mlxsw_sp_port->learning ? BR_LEARNING : 0) |
  69                         (mlxsw_sp_port->learning_sync ? BR_LEARNING_SYNC : 0) |
  70                         (mlxsw_sp_port->uc_flood ? BR_FLOOD : 0);
  71                 break;
  72         default:
  73                 return -EOPNOTSUPP;
  74         }
  75
  76         return 0;
  77 }
  78
  79 static int mlxsw_sp_port_stp_state_set(struct mlxsw_sp_port *mlxsw_sp_port,
  80                                        u8 state)
  81 {
  82         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
  83         enum mlxsw_reg_spms_state spms_state;
  84         char *spms_pl;
  85         u16 vid;
  86         int err;
  87
  88         switch (state) {
  89         case BR_STATE_DISABLED: /* fall-through */
  90         case BR_STATE_FORWARDING:
  91                 spms_state = MLXSW_REG_SPMS_STATE_FORWARDING;
  92                 break;
  93         case BR_STATE_LISTENING: /* fall-through */
  94         case BR_STATE_LEARNING:
  95                 spms_state = MLXSW_REG_SPMS_STATE_LEARNING;
  96                 break;
  97         case BR_STATE_BLOCKING:
  98                 spms_state = MLXSW_REG_SPMS_STATE_DISCARDING;
  99                 break;
 100         default:
 101                 BUG();
 102         }
 103
 104         spms_pl = kmalloc(MLXSW_REG_SPMS_LEN, GFP_KERNEL);
 105         if (!spms_pl)
 106                 return -ENOMEM;
 107         mlxsw_reg_spms_pack(spms_pl, mlxsw_sp_port->local_port);
 108         for_each_set_bit(vid, mlxsw_sp_port->active_vlans, VLAN_N_VID)
 109                 mlxsw_reg_spms_vid_pack(spms_pl, vid, spms_state);
 110
 111         err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(spms), spms_pl);
 112         kfree(spms_pl);
 113         return err;
 114 }
 115
 116 static int mlxsw_sp_port_attr_stp_state_set(struct mlxsw_sp_port *mlxsw_sp_port,
 117                                             struct switchdev_trans *trans,
 118                                             u8 state)
 119 {
 120         if (switchdev_trans_ph_prepare(trans))
 121                 return 0;
 122
 123         mlxsw_sp_port->stp_state = state;
 124         return mlxsw_sp_port_stp_state_set(mlxsw_sp_port, state);
 125 }
 126
 127 static int __mlxsw_sp_port_flood_set(struct mlxsw_sp_port *mlxsw_sp_port,
 128                                      u16 fid_begin, u16 fid_end, bool set,
 129                                      bool only_uc)
 130 {
 131         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
 132         u16 range = fid_end - fid_begin + 1;
 133         char *sftr_pl;
 134         int err;
 135
 136         sftr_pl = kmalloc(MLXSW_REG_SFTR_LEN, GFP_KERNEL);
 137         if (!sftr_pl)
 138                 return -ENOMEM;
 139
 140         mlxsw_reg_sftr_pack(sftr_pl, MLXSW_SP_FLOOD_TABLE_UC, fid_begin,
 141                             MLXSW_REG_SFGC_TABLE_TYPE_FID_OFFEST, range,
 142                             mlxsw_sp_port->local_port, set);
 143         err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sftr), sftr_pl);
 144         if (err)
 145                 goto buffer_out;
 146
 147         /* Flooding control allows one to decide whether a given port will
 148          * flood unicast traffic for which there is no FDB entry.
 149          */
 150         if (only_uc)
 151                 goto buffer_out;
 152
 153         mlxsw_reg_sftr_pack(sftr_pl, MLXSW_SP_FLOOD_TABLE_BM, fid_begin,
 154                             MLXSW_REG_SFGC_TABLE_TYPE_FID_OFFEST, range,
 155                             mlxsw_sp_port->local_port, set);
 156         err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sftr), sftr_pl);
 157
 158 buffer_out:
 159         kfree(sftr_pl);
 160         return err;
 161 }
 162
 163 static int mlxsw_sp_port_uc_flood_set(struct mlxsw_sp_port *mlxsw_sp_port,
 164                                       bool set)
 165 {
 166         struct net_device *dev = mlxsw_sp_port->dev;
 167         u16 vid, last_visited_vid;
 168         int err;
 169
 170         for_each_set_bit(vid, mlxsw_sp_port->active_vlans, VLAN_N_VID) {
 171                 err = __mlxsw_sp_port_flood_set(mlxsw_sp_port, vid, vid, set,
 172                                                 true);
 173                 if (err) {
 174                         last_visited_vid = vid;
 175                         goto err_port_flood_set;
 176                 }
 177         }
 178
 179         return 0;
 180
 181 err_port_flood_set:
 182         for_each_set_bit(vid, mlxsw_sp_port->active_vlans, last_visited_vid)
 183                 __mlxsw_sp_port_flood_set(mlxsw_sp_port, vid, vid, !set, true);
 184         netdev_err(dev, "Failed to configure unicast flooding\n");
 185         return err;
 186 }
 187
 188 static int mlxsw_sp_port_attr_br_flags_set(struct mlxsw_sp_port *mlxsw_sp_port,
 189                                            struct switchdev_trans *trans,
 190                                            unsigned long brport_flags)
 191 {
 192         unsigned long uc_flood = mlxsw_sp_port->uc_flood ? BR_FLOOD : 0;
 193         bool set;
 194         int err;
 195
 196         if (switchdev_trans_ph_prepare(trans))
 197                 return 0;
 198
 199         if ((uc_flood ^ brport_flags) & BR_FLOOD) {
 200                 set = mlxsw_sp_port->uc_flood ? false : true;
 201                 err = mlxsw_sp_port_uc_flood_set(mlxsw_sp_port, set);
 202                 if (err)
 203                         return err;
 204         }
 205
 206         mlxsw_sp_port->uc_flood = brport_flags & BR_FLOOD ? 1 : 0;
 207         mlxsw_sp_port->learning = brport_flags & BR_LEARNING ? 1 : 0;
 208         mlxsw_sp_port->learning_sync = brport_flags & BR_LEARNING_SYNC ? 1 : 0;
 209
 210         return 0;
 211 }
 212
 213 static int mlxsw_sp_ageing_set(struct mlxsw_sp *mlxsw_sp, u32 ageing_time)
 214 {
 215         char sfdat_pl[MLXSW_REG_SFDAT_LEN];
 216         int err;
 217
 218         mlxsw_reg_sfdat_pack(sfdat_pl, ageing_time);
 219         err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfdat), sfdat_pl);
 220         if (err)
 221                 return err;
 222         mlxsw_sp->ageing_time = ageing_time;
 223         return 0;
 224 }
 225
 226 static int mlxsw_sp_port_attr_br_ageing_set(struct mlxsw_sp_port *mlxsw_sp_port,
 227                                             struct switchdev_trans *trans,
 228                                             unsigned long ageing_jiffies)
 229 {
 230         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
 231         u32 ageing_time = jiffies_to_msecs(ageing_jiffies) / 1000;
 232
 233         if (switchdev_trans_ph_prepare(trans))
 234                 return 0;
 235
 236         return mlxsw_sp_ageing_set(mlxsw_sp, ageing_time);
 237 }
 238
 239 static int mlxsw_sp_port_attr_set(struct net_device *dev,
 240                                   const struct switchdev_attr *attr,
 241                                   struct switchdev_trans *trans)
 242 {
 243         struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
 244         int err = 0;
 245
 246         switch (attr->id) {
 247         case SWITCHDEV_ATTR_ID_PORT_STP_STATE:
 248                 err = mlxsw_sp_port_attr_stp_state_set(mlxsw_sp_port, trans,
 249                                                        attr->u.stp_state);
 250                 break;
 251         case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS:
 252                 err = mlxsw_sp_port_attr_br_flags_set(mlxsw_sp_port, trans,
 253                                                       attr->u.brport_flags);
 254                 break;
 255         case SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME:
 256                 err = mlxsw_sp_port_attr_br_ageing_set(mlxsw_sp_port, trans,
 257                                                        attr->u.ageing_time);
 258                 break;
 259         default:
 260                 err = -EOPNOTSUPP;
 261                 break;
 262         }
 263
 264         return err;
 265 }
 266
 267 static int mlxsw_sp_port_pvid_set(struct mlxsw_sp_port *mlxsw_sp_port, u16 vid)
 268 {
 269         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
 270         char spvid_pl[MLXSW_REG_SPVID_LEN];
 271
 272         mlxsw_reg_spvid_pack(spvid_pl, mlxsw_sp_port->local_port, vid);
 273         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(spvid), spvid_pl);
 274 }
 275
 276 static int mlxsw_sp_fid_create(struct mlxsw_sp *mlxsw_sp, u16 fid)
 277 {
 278         char sfmr_pl[MLXSW_REG_SFMR_LEN];
 279         int err;
 280
 281         mlxsw_reg_sfmr_pack(sfmr_pl, MLXSW_REG_SFMR_OP_CREATE_FID, fid, fid);
 282         err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfmr), sfmr_pl);
 283
 284         if (err)
 285                 return err;
 286
 287         set_bit(fid, mlxsw_sp->active_fids);
 288         return 0;
 289 }
 290
 291 static void mlxsw_sp_fid_destroy(struct mlxsw_sp *mlxsw_sp, u16 fid)
 292 {
 293         char sfmr_pl[MLXSW_REG_SFMR_LEN];
 294
 295         clear_bit(fid, mlxsw_sp->active_fids);
 296
 297         mlxsw_reg_sfmr_pack(sfmr_pl, MLXSW_REG_SFMR_OP_DESTROY_FID,
 298                             fid, fid);
 299         mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfmr), sfmr_pl);
 300 }
 301
 302 static int mlxsw_sp_port_fid_map(struct mlxsw_sp_port *mlxsw_sp_port, u16 fid)
 303 {
 304         enum mlxsw_reg_svfa_mt mt;
 305
 306         if (mlxsw_sp_port->nr_vfids)
 307                 mt = MLXSW_REG_SVFA_MT_PORT_VID_TO_FID;
 308         else
 309                 mt = MLXSW_REG_SVFA_MT_VID_TO_FID;
 310
 311         return mlxsw_sp_port_vid_to_fid_set(mlxsw_sp_port, mt, true, fid, fid);
 312 }
 313
 314 static int mlxsw_sp_port_fid_unmap(struct mlxsw_sp_port *mlxsw_sp_port, u16 fid)
 315 {
 316         enum mlxsw_reg_svfa_mt mt;
 317
 318         if (!mlxsw_sp_port->nr_vfids)
 319                 return 0;
 320
 321         mt = MLXSW_REG_SVFA_MT_PORT_VID_TO_FID;
 322         return mlxsw_sp_port_vid_to_fid_set(mlxsw_sp_port, mt, false, fid, fid);
 323 }
 324
 325 static int mlxsw_sp_port_add_vids(struct net_device *dev, u16 vid_begin,
 326                                   u16 vid_end)
 327 {
 328         u16 vid;
 329         int err;
 330
 331         for (vid = vid_begin; vid <= vid_end; vid++) {
 332                 err = mlxsw_sp_port_add_vid(dev, 0, vid);
 333                 if (err)
 334                         goto err_port_add_vid;
 335         }
 336         return 0;
 337
 338 err_port_add_vid:
 339         for (vid--; vid >= vid_begin; vid--)
 340                 mlxsw_sp_port_kill_vid(dev, 0, vid);
 341         return err;
 342 }
 343
 344 static int __mlxsw_sp_port_vlans_add(struct mlxsw_sp_port *mlxsw_sp_port,
 345                                      u16 vid_begin, u16 vid_end,
 346                                      bool flag_untagged, bool flag_pvid)
 347 {
 348         struct mlxsw_sp *mlxsw_sp = mlxsw_sp_port->mlxsw_sp;
 349         struct net_device *dev = mlxsw_sp_port->dev;
 350         enum mlxsw_reg_svfa_mt mt;
 351         u16 vid, vid_e;
 352         int err;
 353
 354         /* In case this is invoked with BRIDGE_FLAGS_SELF and port is
 355          * not bridged, then packets ingressing through the port with
 356          * the specified VIDs will be directed to CPU.
 357          */
 358         if (!mlxsw_sp_port->bridged)
 359                 return mlxsw_sp_port_add_vids(dev, vid_begin, vid_end);
 360
 361         for (vid = vid_begin; vid <= vid_end; vid++) {
 362                 if (!test_bit(vid, mlxsw_sp->active_fids)) {
 363                         err = mlxsw_sp_fid_create(mlxsw_sp, vid);
 364                         if (err) {
 365                                 netdev_err(dev, "Failed to create FID=%d\n",
 366                                            vid);
 367                                 return err;
 368                         }
 369
 370                         /* When creating a FID, we set a VID to FID mapping
 371                          * regardless of the port's mode.
 372                          */
 373                         mt = MLXSW_REG_SVFA_MT_VID_TO_FID;
 374                         err = mlxsw_sp_port_vid_to_fid_set(mlxsw_sp_port, mt,
 375                                                            true, vid, vid);
 376                         if (err) {
 377                                 netdev_err(dev, "Failed to create FID=VID=%d mapping\n",
 378                                            vid);
 379                                 return err;
 380                         }
 381                 }
 382
 383                 /* Set FID mapping according to port's mode */
 384                 err = mlxsw_sp_port_fid_map(mlxsw_sp_port, vid);
 385                 if (err) {
 386                         netdev_err(dev, "Failed to map FID=%d", vid);
 387                         return err;
 388                 }
 389         }
 390
 391         err = __mlxsw_sp_port_flood_set(mlxsw_sp_port, vid_begin, vid_end,
 392                                         true, false);
 393         if (err) {
 394                 netdev_err(dev, "Failed to configure flooding\n");
 395                 return err;
 396         }
 397
 398         for (vid = vid_begin; vid <= vid_end;
 399              vid += MLXSW_REG_SPVM_REC_MAX_COUNT) {
 400                 vid_e = min((u16) (vid + MLXSW_REG_SPVM_REC_MAX_COUNT - 1),
 401                             vid_end);
 402
 403                 err = mlxsw_sp_port_vlan_set(mlxsw_sp_port, vid, vid_e, true,
 404                                              flag_untagged);
 405                 if (err) {
 406                         netdev_err(mlxsw_sp_port->dev, "Unable to add VIDs %d-%d\n",
 407                                    vid, vid_e);
 408                         return err;
 409                 }
 410         }
 411
 412         vid = vid_begin;
 413         if (flag_pvid && mlxsw_sp_port->pvid != vid) {
 414                 err = mlxsw_sp_port_pvid_set(mlxsw_sp_port, vid);
 415                 if (err) {
 416                         netdev_err(mlxsw_sp_port->dev, "Unable to add PVID %d\n",
 417                                    vid);
 418                         return err;
 419                 }
 420                 mlxsw_sp_port->pvid = vid;
 421         }
 422
 423         /* Changing activity bits only if HW operation succeded */
 424         for (vid = vid_begin; vid <= vid_end; vid++)
 425                 set_bit(vid, mlxsw_sp_port->active_vlans);
 426
 427         return mlxsw_sp_port_stp_state_set(mlxsw_sp_port,
 428                                            mlxsw_sp_port->stp_state);
 429 }
 430
 431 static int mlxsw_sp_port_vlans_add(struct mlxsw_sp_port *mlxsw_sp_port,
 432                                    const struct switchdev_obj_port_vlan *vlan,
 433                                    struct switchdev_trans *trans)
 434 {
 435         bool untagged_flag = vlan->flags & BRIDGE_VLAN_INFO_UNTAGGED;
 436         bool pvid_flag = vlan->flags & BRIDGE_VLAN_INFO_PVID;
 437
 438         if (switchdev_trans_ph_prepare(trans))
 439                 return 0;
 440
 441         return __mlxsw_sp_port_vlans_add(mlxsw_sp_port,
 442                                          vlan->vid_begin, vlan->vid_end,
 443                                          untagged_flag, pvid_flag);
 444 }
 445
 446 static int mlxsw_sp_port_fdb_op(struct mlxsw_sp_port *mlxsw_sp_port,
 447                                 const char *mac, u16 vid, bool adding,
 448                                 bool dynamic)
 449 {
 450         enum mlxsw_reg_sfd_rec_policy policy;
 451         enum mlxsw_reg_sfd_op op;
 452         char *sfd_pl;
 453         int err;
 454
 455         if (!vid)
 456                 vid = mlxsw_sp_port->pvid;
 457
 458         sfd_pl = kmalloc(MLXSW_REG_SFD_LEN, GFP_KERNEL);
 459         if (!sfd_pl)
 460                 return -ENOMEM;
 461
 462         policy = dynamic ? MLXSW_REG_SFD_REC_POLICY_DYNAMIC_ENTRY_INGRESS :
 463                            MLXSW_REG_SFD_REC_POLICY_STATIC_ENTRY;
 464         op = adding ? MLXSW_REG_SFD_OP_WRITE_EDIT :
 465                       MLXSW_REG_SFD_OP_WRITE_REMOVE;
 466         mlxsw_reg_sfd_pack(sfd_pl, op, 0);
 467         mlxsw_reg_sfd_uc_pack(sfd_pl, 0, policy,
 468                               mac, vid, MLXSW_REG_SFD_REC_ACTION_NOP,
 469                               mlxsw_sp_port->local_port);
 470         err = mlxsw_reg_write(mlxsw_sp_port->mlxsw_sp->core, MLXSW_REG(sfd),
 471                               sfd_pl);
 472         kfree(sfd_pl);
 473
 474         return err;
 475 }
 476
 477 static int
 478 mlxsw_sp_port_fdb_static_add(struct mlxsw_sp_port *mlxsw_sp_port,
 479                              const struct switchdev_obj_port_fdb *fdb,
 480                              struct switchdev_trans *trans)
 481 {
 482         if (switchdev_trans_ph_prepare(trans))
 483                 return 0;
 484
 485         return mlxsw_sp_port_fdb_op(mlxsw_sp_port, fdb->addr, fdb->vid,
 486                                     true, false);
 487 }
 488
 489 static int mlxsw_sp_port_obj_add(struct net_device *dev,
 490                                  const struct switchdev_obj *obj,
 491                                  struct switchdev_trans *trans)
 492 {
 493         struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
 494         int err = 0;
 495
 496         switch (obj->id) {
 497         case SWITCHDEV_OBJ_ID_PORT_VLAN:
 498                 err = mlxsw_sp_port_vlans_add(mlxsw_sp_port,
 499                                               SWITCHDEV_OBJ_PORT_VLAN(obj),
 500                                               trans);
 501                 break;
 502         case SWITCHDEV_OBJ_ID_PORT_FDB:
 503                 err = mlxsw_sp_port_fdb_static_add(mlxsw_sp_port,
 504                                                    SWITCHDEV_OBJ_PORT_FDB(obj),
 505                                                    trans);
 506                 break;
 507         default:
 508                 err = -EOPNOTSUPP;
 509                 break;
 510         }
 511
 512         return err;
 513 }
 514
 515 static int mlxsw_sp_port_kill_vids(struct net_device *dev, u16 vid_begin,
 516                                    u16 vid_end)
 517 {
 518         u16 vid;
 519         int err;
 520
 521         for (vid = vid_begin; vid <= vid_end; vid++) {
 522                 err = mlxsw_sp_port_kill_vid(dev, 0, vid);
 523                 if (err)
 524                         return err;
 525         }
 526
 527         return 0;
 528 }
 529
 530 static int __mlxsw_sp_port_vlans_del(struct mlxsw_sp_port *mlxsw_sp_port,
 531                                      u16 vid_begin, u16 vid_end, bool init)
 532 {
 533         struct net_device *dev = mlxsw_sp_port->dev;
 534         u16 vid, vid_e;
 535         int err;
 536
 537         /* In case this is invoked with BRIDGE_FLAGS_SELF and port is
 538          * not bridged, then prevent packets ingressing through the
 539          * port with the specified VIDs from being trapped to CPU.
 540          */
 541         if (!init && !mlxsw_sp_port->bridged)
 542                 return mlxsw_sp_port_kill_vids(dev, vid_begin, vid_end);
 543
 544         for (vid = vid_begin; vid <= vid_end;
 545              vid += MLXSW_REG_SPVM_REC_MAX_COUNT) {
 546                 vid_e = min((u16) (vid + MLXSW_REG_SPVM_REC_MAX_COUNT - 1),
 547                             vid_end);
 548                 err = mlxsw_sp_port_vlan_set(mlxsw_sp_port, vid, vid_e, false,
 549                                              false);
 550                 if (err) {
 551                         netdev_err(mlxsw_sp_port->dev, "Unable to del VIDs %d-%d\n",
 552                                    vid, vid_e);
 553                         return err;
 554                 }
 555         }
 556
 557         if ((mlxsw_sp_port->pvid >= vid_begin) &&
 558             (mlxsw_sp_port->pvid <= vid_end)) {
 559                 /* Default VLAN is always 1 */
 560                 mlxsw_sp_port->pvid = 1;
 561                 err = mlxsw_sp_port_pvid_set(mlxsw_sp_port,
 562                                              mlxsw_sp_port->pvid);
 563                 if (err) {
 564                         netdev_err(mlxsw_sp_port->dev, "Unable to del PVID %d\n",
 565                                    vid);
 566                         return err;
 567                 }
 568         }
 569
 570         if (init)
 571                 goto out;
 572
 573         err = __mlxsw_sp_port_flood_set(mlxsw_sp_port, vid_begin, vid_end,
 574                                         false, false);
 575         if (err) {
 576                 netdev_err(dev, "Failed to clear flooding\n");
 577                 return err;
 578         }
 579
 580         for (vid = vid_begin; vid <= vid_end; vid++) {
 581                 /* Remove FID mapping in case of Virtual mode */
 582                 err = mlxsw_sp_port_fid_unmap(mlxsw_sp_port, vid);
 583                 if (err) {
 584                         netdev_err(dev, "Failed to unmap FID=%d", vid);
 585                         return err;
 586                 }
 587         }
 588
 589 out:
 590         /* Changing activity bits only if HW operation succeded */
 591         for (vid = vid_begin; vid <= vid_end; vid++)
 592                 clear_bit(vid, mlxsw_sp_port->active_vlans);
 593
 594         return 0;
 595 }
 596
 597 static int mlxsw_sp_port_vlans_del(struct mlxsw_sp_port *mlxsw_sp_port,
 598                                    const struct switchdev_obj_port_vlan *vlan)
 599 {
 600         return __mlxsw_sp_port_vlans_del(mlxsw_sp_port,
 601                                          vlan->vid_begin, vlan->vid_end, false);
 602 }
 603
 604 static int
 605 mlxsw_sp_port_fdb_static_del(struct mlxsw_sp_port *mlxsw_sp_port,
 606                              const struct switchdev_obj_port_fdb *fdb)
 607 {
 608         return mlxsw_sp_port_fdb_op(mlxsw_sp_port, fdb->addr, fdb->vid,
 609                                     false, false);
 610 }
 611
 612 static int mlxsw_sp_port_obj_del(struct net_device *dev,
 613                                  const struct switchdev_obj *obj)
 614 {
 615         struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
 616         int err = 0;
 617
 618         switch (obj->id) {
 619         case SWITCHDEV_OBJ_ID_PORT_VLAN:
 620                 err = mlxsw_sp_port_vlans_del(mlxsw_sp_port,
 621                                               SWITCHDEV_OBJ_PORT_VLAN(obj));
 622                 break;
 623         case SWITCHDEV_OBJ_ID_PORT_FDB:
 624                 err = mlxsw_sp_port_fdb_static_del(mlxsw_sp_port,
 625                                                    SWITCHDEV_OBJ_PORT_FDB(obj));
 626                 break;
 627         default:
 628                 err = -EOPNOTSUPP;
 629                 break;
 630         }
 631
 632         return err;
 633 }
 634
 635 static int mlxsw_sp_port_fdb_dump(struct mlxsw_sp_port *mlxsw_sp_port,
 636                                   struct switchdev_obj_port_fdb *fdb,
 637                                   switchdev_obj_dump_cb_t *cb)
 638 {
 639         char *sfd_pl;
 640         char mac[ETH_ALEN];
 641         u16 vid;
 642         u8 local_port;
 643         u8 num_rec;
 644         int stored_err = 0;
 645         int i;
 646         int err;
 647
 648         sfd_pl = kmalloc(MLXSW_REG_SFD_LEN, GFP_KERNEL);
 649         if (!sfd_pl)
 650                 return -ENOMEM;
 651
 652         mlxsw_reg_sfd_pack(sfd_pl, MLXSW_REG_SFD_OP_QUERY_DUMP, 0);
 653         do {
 654                 mlxsw_reg_sfd_num_rec_set(sfd_pl, MLXSW_REG_SFD_REC_MAX_COUNT);
 655                 err = mlxsw_reg_query(mlxsw_sp_port->mlxsw_sp->core,
 656                                       MLXSW_REG(sfd), sfd_pl);
 657                 if (err)
 658                         goto out;
 659
 660                 num_rec = mlxsw_reg_sfd_num_rec_get(sfd_pl);
 661
 662                 /* Even in case of error, we have to run the dump to the end
 663                  * so the session in firmware is finished.
 664                  */
 665                 if (stored_err)
 666                         continue;
 667
 668                 for (i = 0; i < num_rec; i++) {
 669                         switch (mlxsw_reg_sfd_rec_type_get(sfd_pl, i)) {
 670                         case MLXSW_REG_SFD_REC_TYPE_UNICAST:
 671                                 mlxsw_reg_sfd_uc_unpack(sfd_pl, i, mac, &vid,
 672                                                         &local_port);
 673                                 if (local_port == mlxsw_sp_port->local_port) {
 674                                         ether_addr_copy(fdb->addr, mac);
 675                                         fdb->ndm_state = NUD_REACHABLE;
 676                                         fdb->vid = vid;
 677                                         err = cb(&fdb->obj);
 678                                         if (err)
 679                                                 stored_err = err;
 680                                 }
 681                         }
 682                 }
 683         } while (num_rec == MLXSW_REG_SFD_REC_MAX_COUNT);
 684
 685 out:
 686         kfree(sfd_pl);
 687         return stored_err ? stored_err : err;
 688 }
 689
 690 static int mlxsw_sp_port_vlan_dump(struct mlxsw_sp_port *mlxsw_sp_port,
 691                                    struct switchdev_obj_port_vlan *vlan,
 692                                    switchdev_obj_dump_cb_t *cb)
 693 {
 694         u16 vid;
 695         int err = 0;
 696
 697         for_each_set_bit(vid, mlxsw_sp_port->active_vlans, VLAN_N_VID) {
 698                 vlan->flags = 0;
 699                 if (vid == mlxsw_sp_port->pvid)
 700                         vlan->flags |= BRIDGE_VLAN_INFO_PVID;
 701                 vlan->vid_begin = vid;
 702                 vlan->vid_end = vid;
 703                 err = cb(&vlan->obj);
 704                 if (err)
 705                         break;
 706         }
 707         return err;
 708 }
 709
 710 static int mlxsw_sp_port_obj_dump(struct net_device *dev,
 711                                   struct switchdev_obj *obj,
 712                                   switchdev_obj_dump_cb_t *cb)
 713 {
 714         struct mlxsw_sp_port *mlxsw_sp_port = netdev_priv(dev);
 715         int err = 0;
 716
 717         switch (obj->id) {
 718         case SWITCHDEV_OBJ_ID_PORT_VLAN:
 719                 err = mlxsw_sp_port_vlan_dump(mlxsw_sp_port,
 720                                               SWITCHDEV_OBJ_PORT_VLAN(obj), cb);
 721                 break;
 722         case SWITCHDEV_OBJ_ID_PORT_FDB:
 723                 err = mlxsw_sp_port_fdb_dump(mlxsw_sp_port,
 724                                              SWITCHDEV_OBJ_PORT_FDB(obj), cb);
 725                 break;
 726         default:
 727                 err = -EOPNOTSUPP;
 728                 break;
 729         }
 730
 731         return err;
 732 }
 733
 734 const struct switchdev_ops mlxsw_sp_port_switchdev_ops = {
 735         .switchdev_port_attr_get        = mlxsw_sp_port_attr_get,
 736         .switchdev_port_attr_set        = mlxsw_sp_port_attr_set,
 737         .switchdev_port_obj_add         = mlxsw_sp_port_obj_add,
 738         .switchdev_port_obj_del         = mlxsw_sp_port_obj_del,
 739         .switchdev_port_obj_dump        = mlxsw_sp_port_obj_dump,
 740 };
 741
 742 static void mlxsw_sp_fdb_notify_mac_process(struct mlxsw_sp *mlxsw_sp,
 743                                             char *sfn_pl, int rec_index,
 744                                             bool adding)
 745 {
 746         struct mlxsw_sp_port *mlxsw_sp_port;
 747         char mac[ETH_ALEN];
 748         u8 local_port;
 749         u16 vid;
 750         int err;
 751
 752         mlxsw_reg_sfn_mac_unpack(sfn_pl, rec_index, mac, &vid, &local_port);
 753         mlxsw_sp_port = mlxsw_sp->ports[local_port];
 754         if (!mlxsw_sp_port) {
 755                 dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Incorrect local port in FDB notification\n");
 756                 return;
 757         }
 758
 759         err = mlxsw_sp_port_fdb_op(mlxsw_sp_port, mac, vid,
 760                                    adding && mlxsw_sp_port->learning, true);
 761         if (err) {
 762                 if (net_ratelimit())
 763                         netdev_err(mlxsw_sp_port->dev, "Failed to set FDB entry\n");
 764                 return;
 765         }
 766
 767         if (mlxsw_sp_port->learning && mlxsw_sp_port->learning_sync) {
 768                 struct switchdev_notifier_fdb_info info;
 769                 unsigned long notifier_type;
 770
 771                 info.addr = mac;
 772                 info.vid = vid;
 773                 notifier_type = adding ? SWITCHDEV_FDB_ADD : SWITCHDEV_FDB_DEL;
 774                 call_switchdev_notifiers(notifier_type, mlxsw_sp_port->dev,
 775                                          &info.info);
 776         }
 777 }
 778
 779 static void mlxsw_sp_fdb_notify_rec_process(struct mlxsw_sp *mlxsw_sp,
 780                                             char *sfn_pl, int rec_index)
 781 {
 782         switch (mlxsw_reg_sfn_rec_type_get(sfn_pl, rec_index)) {
 783         case MLXSW_REG_SFN_REC_TYPE_LEARNED_MAC:
 784                 mlxsw_sp_fdb_notify_mac_process(mlxsw_sp, sfn_pl,
 785                                                 rec_index, true);
 786                 break;
 787         case MLXSW_REG_SFN_REC_TYPE_AGED_OUT_MAC:
 788                 mlxsw_sp_fdb_notify_mac_process(mlxsw_sp, sfn_pl,
 789                                                 rec_index, false);
 790                 break;
 791         }
 792 }
 793
 794 static void mlxsw_sp_fdb_notify_work_schedule(struct mlxsw_sp *mlxsw_sp)
 795 {
 796         schedule_delayed_work(&mlxsw_sp->fdb_notify.dw,
 797                               msecs_to_jiffies(mlxsw_sp->fdb_notify.interval));
 798 }
 799
 800 static void mlxsw_sp_fdb_notify_work(struct work_struct *work)
 801 {
 802         struct mlxsw_sp *mlxsw_sp;
 803         char *sfn_pl;
 804         u8 num_rec;
 805         int i;
 806         int err;
 807
 808         sfn_pl = kmalloc(MLXSW_REG_SFN_LEN, GFP_KERNEL);
 809         if (!sfn_pl)
 810                 return;
 811
 812         mlxsw_sp = container_of(work, struct mlxsw_sp, fdb_notify.dw.work);
 813
 814         do {
 815                 mlxsw_reg_sfn_pack(sfn_pl);
 816                 err = mlxsw_reg_query(mlxsw_sp->core, MLXSW_REG(sfn), sfn_pl);
 817                 if (err) {
 818                         dev_err_ratelimited(mlxsw_sp->bus_info->dev, "Failed to get FDB notifications\n");
 819                         break;
 820                 }
 821                 num_rec = mlxsw_reg_sfn_num_rec_get(sfn_pl);
 822                 for (i = 0; i < num_rec; i++)
 823                         mlxsw_sp_fdb_notify_rec_process(mlxsw_sp, sfn_pl, i);
 824
 825         } while (num_rec);
 826
 827         kfree(sfn_pl);
 828         mlxsw_sp_fdb_notify_work_schedule(mlxsw_sp);
 829 }
 830
 831 static int mlxsw_sp_fdb_init(struct mlxsw_sp *mlxsw_sp)
 832 {
 833         int err;
 834
 835         err = mlxsw_sp_ageing_set(mlxsw_sp, MLXSW_SP_DEFAULT_AGEING_TIME);
 836         if (err) {
 837                 dev_err(mlxsw_sp->bus_info->dev, "Failed to set default ageing time\n");
 838                 return err;
 839         }
 840         INIT_DELAYED_WORK(&mlxsw_sp->fdb_notify.dw, mlxsw_sp_fdb_notify_work);
 841         mlxsw_sp->fdb_notify.interval = MLXSW_SP_DEFAULT_LEARNING_INTERVAL;
 842         mlxsw_sp_fdb_notify_work_schedule(mlxsw_sp);
 843         return 0;
 844 }
 845
 846 static void mlxsw_sp_fdb_fini(struct mlxsw_sp *mlxsw_sp)
 847 {
 848         cancel_delayed_work_sync(&mlxsw_sp->fdb_notify.dw);
 849 }
 850
 851 static void mlxsw_sp_fids_fini(struct mlxsw_sp *mlxsw_sp)
 852 {
 853         u16 fid;
 854
 855         for_each_set_bit(fid, mlxsw_sp->active_fids, VLAN_N_VID)
 856                 mlxsw_sp_fid_destroy(mlxsw_sp, fid);
 857 }
 858
 859 int mlxsw_sp_switchdev_init(struct mlxsw_sp *mlxsw_sp)
 860 {
 861         return mlxsw_sp_fdb_init(mlxsw_sp);
 862 }
 863
 864 void mlxsw_sp_switchdev_fini(struct mlxsw_sp *mlxsw_sp)
 865 {
 866         mlxsw_sp_fdb_fini(mlxsw_sp);
 867         mlxsw_sp_fids_fini(mlxsw_sp);
 868 }
 869
 870 int mlxsw_sp_port_vlan_init(struct mlxsw_sp_port *mlxsw_sp_port)
 871 {
 872         struct net_device *dev = mlxsw_sp_port->dev;
 873         int err;
 874
 875         /* Allow only untagged packets to ingress and tag them internally
 876          * with VID 1.
 877          */
 878         mlxsw_sp_port->pvid = 1;
 879         err = __mlxsw_sp_port_vlans_del(mlxsw_sp_port, 0, VLAN_N_VID, true);
 880         if (err) {
 881                 netdev_err(dev, "Unable to init VLANs\n");
 882                 return err;
 883         }
 884
 885         /* Add implicit VLAN interface in the device, so that untagged
 886          * packets will be classified to the default vFID.
 887          */
 888         err = mlxsw_sp_port_add_vid(dev, 0, 1);
 889         if (err)
 890                 netdev_err(dev, "Failed to configure default vFID\n");
 891
 892         return err;
 893 }
 894
 895 void mlxsw_sp_port_switchdev_init(struct mlxsw_sp_port *mlxsw_sp_port)
 896 {
 897         mlxsw_sp_port->dev->switchdev_ops = &mlxsw_sp_port_switchdev_ops;
 898 }
 899
 900 void mlxsw_sp_port_switchdev_fini(struct mlxsw_sp_port *mlxsw_sp_port)
 901 {
 902 }