drivers/net/ethernet/microchip/lan966x/lan966x_mdb.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2
   3 #include <net/switchdev.h>
   4
   5 #include "lan966x_main.h"
   6
   7 struct lan966x_pgid_entry {
   8         struct list_head list;
   9         int index;
  10         refcount_t refcount;
  11         u16 ports;
  12 };
  13
  14 struct lan966x_mdb_entry {
  15         struct list_head list;
  16         unsigned char mac[ETH_ALEN];
  17         u16 vid;
  18         u16 ports;
  19         struct lan966x_pgid_entry *pgid;
  20         u8 cpu_copy;
  21 };
  22
  23 void lan966x_mdb_init(struct lan966x *lan966x)
  24 {
  25         INIT_LIST_HEAD(&lan966x->mdb_entries);
  26         INIT_LIST_HEAD(&lan966x->pgid_entries);
  27 }
  28
  29 static void lan966x_mdb_purge_mdb_entries(struct lan966x *lan966x)
  30 {
  31         struct lan966x_mdb_entry *mdb_entry, *tmp;
  32
  33         list_for_each_entry_safe(mdb_entry, tmp, &lan966x->mdb_entries, list) {
  34                 list_del(&mdb_entry->list);
  35                 kfree(mdb_entry);
  36         }
  37 }
  38
  39 static void lan966x_mdb_purge_pgid_entries(struct lan966x *lan966x)
  40 {
  41         struct lan966x_pgid_entry *pgid_entry, *tmp;
  42
  43         list_for_each_entry_safe(pgid_entry, tmp, &lan966x->pgid_entries, list) {
  44                 list_del(&pgid_entry->list);
  45                 kfree(pgid_entry);
  46         }
  47 }
  48
  49 void lan966x_mdb_deinit(struct lan966x *lan966x)
  50 {
  51         lan966x_mdb_purge_mdb_entries(lan966x);
  52         lan966x_mdb_purge_pgid_entries(lan966x);
  53 }
  54
  55 static struct lan966x_mdb_entry *
  56 lan966x_mdb_entry_get(struct lan966x *lan966x,
  57                       const unsigned char *mac,
  58                       u16 vid)
  59 {
  60         struct lan966x_mdb_entry *mdb_entry;
  61
  62         list_for_each_entry(mdb_entry, &lan966x->mdb_entries, list) {
  63                 if (ether_addr_equal(mdb_entry->mac, mac) &&
  64                     mdb_entry->vid == vid)
  65                         return mdb_entry;
  66         }
  67
  68         return NULL;
  69 }
  70
  71 static struct lan966x_mdb_entry *
  72 lan966x_mdb_entry_add(struct lan966x *lan966x,
  73                       const struct switchdev_obj_port_mdb *mdb)
  74 {
  75         struct lan966x_mdb_entry *mdb_entry;
  76
  77         mdb_entry = kzalloc(sizeof(*mdb_entry), GFP_KERNEL);
  78         if (!mdb_entry)
  79                 return ERR_PTR(-ENOMEM);
  80
  81         ether_addr_copy(mdb_entry->mac, mdb->addr);
  82         mdb_entry->vid = mdb->vid;
  83
  84         list_add_tail(&mdb_entry->list, &lan966x->mdb_entries);
  85
  86         return mdb_entry;
  87 }
  88
  89 static void lan966x_mdb_encode_mac(unsigned char *mac,
  90                                    struct lan966x_mdb_entry *mdb_entry,
  91                                    enum macaccess_entry_type type)
  92 {
  93         ether_addr_copy(mac, mdb_entry->mac);
  94
  95         if (type == ENTRYTYPE_MACV4) {
  96                 mac[0] = 0;
  97                 mac[1] = mdb_entry->ports >> 8;
  98                 mac[2] = mdb_entry->ports & 0xff;
  99         } else if (type == ENTRYTYPE_MACV6) {
 100                 mac[0] = mdb_entry->ports >> 8;
 101                 mac[1] = mdb_entry->ports & 0xff;
 102         }
 103 }
 104
 105 static int lan966x_mdb_ip_add(struct lan966x_port *port,
 106                               const struct switchdev_obj_port_mdb *mdb,
 107                               enum macaccess_entry_type type)
 108 {
 109         bool cpu_port = netif_is_bridge_master(mdb->obj.orig_dev);
 110         struct lan966x *lan966x = port->lan966x;
 111         struct lan966x_mdb_entry *mdb_entry;
 112         unsigned char mac[ETH_ALEN];
 113         bool cpu_copy = false;
 114
 115         mdb_entry = lan966x_mdb_entry_get(lan966x, mdb->addr, mdb->vid);
 116         if (!mdb_entry) {
 117                 mdb_entry = lan966x_mdb_entry_add(lan966x, mdb);
 118                 if (IS_ERR(mdb_entry))
 119                         return PTR_ERR(mdb_entry);
 120         } else {
 121                 lan966x_mdb_encode_mac(mac, mdb_entry, type);
 122                 lan966x_mac_forget(lan966x, mac, mdb_entry->vid, type);
 123         }
 124
 125         if (cpu_port)
 126                 mdb_entry->cpu_copy++;
 127         else
 128                 mdb_entry->ports |= BIT(port->chip_port);
 129
 130         /* Copy the frame to CPU only if the CPU is in the VLAN */
 131         if (lan966x_vlan_cpu_member_cpu_vlan_mask(lan966x, mdb_entry->vid) &&
 132             mdb_entry->cpu_copy)
 133                 cpu_copy = true;
 134
 135         lan966x_mdb_encode_mac(mac, mdb_entry, type);
 136         return lan966x_mac_ip_learn(lan966x, cpu_copy,
 137                                     mac, mdb_entry->vid, type);
 138 }
 139
 140 static int lan966x_mdb_ip_del(struct lan966x_port *port,
 141                               const struct switchdev_obj_port_mdb *mdb,
 142                               enum macaccess_entry_type type)
 143 {
 144         bool cpu_port = netif_is_bridge_master(mdb->obj.orig_dev);
 145         struct lan966x *lan966x = port->lan966x;
 146         struct lan966x_mdb_entry *mdb_entry;
 147         unsigned char mac[ETH_ALEN];
 148         u16 ports;
 149
 150         mdb_entry = lan966x_mdb_entry_get(lan966x, mdb->addr, mdb->vid);
 151         if (!mdb_entry)
 152                 return -ENOENT;
 153
 154         ports = mdb_entry->ports;
 155         if (cpu_port) {
 156                 /* If there are still other references to the CPU port then
 157                  * there is no point to delete and add again the same entry
 158                  */
 159                 mdb_entry->cpu_copy--;
 160                 if (mdb_entry->cpu_copy)
 161                         return 0;
 162         } else {
 163                 ports &= ~BIT(port->chip_port);
 164         }
 165
 166         lan966x_mdb_encode_mac(mac, mdb_entry, type);
 167         lan966x_mac_forget(lan966x, mac, mdb_entry->vid, type);
 168
 169         mdb_entry->ports = ports;
 170
 171         if (!mdb_entry->ports && !mdb_entry->cpu_copy) {
 172                 list_del(&mdb_entry->list);
 173                 kfree(mdb_entry);
 174                 return 0;
 175         }
 176
 177         lan966x_mdb_encode_mac(mac, mdb_entry, type);
 178         return lan966x_mac_ip_learn(lan966x, mdb_entry->cpu_copy,
 179                                     mac, mdb_entry->vid, type);
 180 }
 181
 182 static struct lan966x_pgid_entry *
 183 lan966x_pgid_entry_add(struct lan966x *lan966x, int index, u16 ports)
 184 {
 185         struct lan966x_pgid_entry *pgid_entry;
 186
 187         pgid_entry = kzalloc(sizeof(*pgid_entry), GFP_KERNEL);
 188         if (!pgid_entry)
 189                 return ERR_PTR(-ENOMEM);
 190
 191         pgid_entry->ports = ports;
 192         pgid_entry->index = index;
 193         refcount_set(&pgid_entry->refcount, 1);
 194
 195         list_add_tail(&pgid_entry->list, &lan966x->pgid_entries);
 196
 197         return pgid_entry;
 198 }
 199
 200 static struct lan966x_pgid_entry *
 201 lan966x_pgid_entry_get(struct lan966x *lan966x,
 202                        struct lan966x_mdb_entry *mdb_entry)
 203 {
 204         struct lan966x_pgid_entry *pgid_entry;
 205         int index;
 206
 207         /* Try to find an existing pgid that uses the same ports as the
 208          * mdb_entry
 209          */
 210         list_for_each_entry(pgid_entry, &lan966x->pgid_entries, list) {
 211                 if (pgid_entry->ports == mdb_entry->ports) {
 212                         refcount_inc(&pgid_entry->refcount);
 213                         return pgid_entry;
 214                 }
 215         }
 216
 217         /* Try to find an empty pgid entry and allocate one in case it finds it,
 218          * otherwise it means that there are no more resources
 219          */
 220         for (index = PGID_GP_START; index < PGID_GP_END; index++) {
 221                 bool used = false;
 222
 223                 list_for_each_entry(pgid_entry, &lan966x->pgid_entries, list) {
 224                         if (pgid_entry->index == index) {
 225                                 used = true;
 226                                 break;
 227                         }
 228                 }
 229
 230                 if (!used)
 231                         return lan966x_pgid_entry_add(lan966x, index,
 232                                                       mdb_entry->ports);
 233         }
 234
 235         return ERR_PTR(-ENOSPC);
 236 }
 237
 238 static void lan966x_pgid_entry_del(struct lan966x *lan966x,
 239                                    struct lan966x_pgid_entry *pgid_entry)
 240 {
 241         if (!refcount_dec_and_test(&pgid_entry->refcount))
 242                 return;
 243
 244         list_del(&pgid_entry->list);
 245         kfree(pgid_entry);
 246 }
 247
 248 static int lan966x_mdb_l2_add(struct lan966x_port *port,
 249                               const struct switchdev_obj_port_mdb *mdb,
 250                               enum macaccess_entry_type type)
 251 {
 252         bool cpu_port = netif_is_bridge_master(mdb->obj.orig_dev);
 253         struct lan966x *lan966x = port->lan966x;
 254         struct lan966x_pgid_entry *pgid_entry;
 255         struct lan966x_mdb_entry *mdb_entry;
 256         unsigned char mac[ETH_ALEN];
 257
 258         mdb_entry = lan966x_mdb_entry_get(lan966x, mdb->addr, mdb->vid);
 259         if (!mdb_entry) {
 260                 mdb_entry = lan966x_mdb_entry_add(lan966x, mdb);
 261                 if (IS_ERR(mdb_entry))
 262                         return PTR_ERR(mdb_entry);
 263         } else {
 264                 lan966x_pgid_entry_del(lan966x, mdb_entry->pgid);
 265                 lan966x_mdb_encode_mac(mac, mdb_entry, type);
 266                 lan966x_mac_forget(lan966x, mac, mdb_entry->vid, type);
 267         }
 268
 269         if (cpu_port) {
 270                 mdb_entry->ports |= BIT(CPU_PORT);
 271                 mdb_entry->cpu_copy++;
 272         } else {
 273                 mdb_entry->ports |= BIT(port->chip_port);
 274         }
 275
 276         pgid_entry = lan966x_pgid_entry_get(lan966x, mdb_entry);
 277         if (IS_ERR(pgid_entry)) {
 278                 list_del(&mdb_entry->list);
 279                 kfree(mdb_entry);
 280                 return PTR_ERR(pgid_entry);
 281         }
 282         mdb_entry->pgid = pgid_entry;
 283
 284         /* Copy the frame to CPU only if the CPU is in the VLAN */
 285         if (!lan966x_vlan_cpu_member_cpu_vlan_mask(lan966x, mdb_entry->vid) &&
 286             mdb_entry->cpu_copy)
 287                 mdb_entry->ports &= BIT(CPU_PORT);
 288
 289         lan_rmw(ANA_PGID_PGID_SET(mdb_entry->ports),
 290                 ANA_PGID_PGID,
 291                 lan966x, ANA_PGID(pgid_entry->index));
 292
 293         return lan966x_mac_learn(lan966x, pgid_entry->index, mdb_entry->mac,
 294                                  mdb_entry->vid, type);
 295 }
 296
 297 static int lan966x_mdb_l2_del(struct lan966x_port *port,
 298                               const struct switchdev_obj_port_mdb *mdb,
 299                               enum macaccess_entry_type type)
 300 {
 301         bool cpu_port = netif_is_bridge_master(mdb->obj.orig_dev);
 302         struct lan966x *lan966x = port->lan966x;
 303         struct lan966x_pgid_entry *pgid_entry;
 304         struct lan966x_mdb_entry *mdb_entry;
 305         unsigned char mac[ETH_ALEN];
 306         u16 ports;
 307
 308         mdb_entry = lan966x_mdb_entry_get(lan966x, mdb->addr, mdb->vid);
 309         if (!mdb_entry)
 310                 return -ENOENT;
 311
 312         ports = mdb_entry->ports;
 313         if (cpu_port) {
 314                 /* If there are still other references to the CPU port then
 315                  * there is no point to delete and add again the same entry
 316                  */
 317                 mdb_entry->cpu_copy--;
 318                 if (mdb_entry->cpu_copy)
 319                         return 0;
 320
 321                 ports &= ~BIT(CPU_PORT);
 322         } else {
 323                 ports &= ~BIT(port->chip_port);
 324         }
 325
 326         lan966x_mdb_encode_mac(mac, mdb_entry, type);
 327         lan966x_mac_forget(lan966x, mac, mdb_entry->vid, type);
 328         lan966x_pgid_entry_del(lan966x, mdb_entry->pgid);
 329
 330         mdb_entry->ports = ports;
 331
 332         if (!mdb_entry->ports) {
 333                 list_del(&mdb_entry->list);
 334                 kfree(mdb_entry);
 335                 return 0;
 336         }
 337
 338         pgid_entry = lan966x_pgid_entry_get(lan966x, mdb_entry);
 339         if (IS_ERR(pgid_entry)) {
 340                 list_del(&mdb_entry->list);
 341                 kfree(mdb_entry);
 342                 return PTR_ERR(pgid_entry);
 343         }
 344         mdb_entry->pgid = pgid_entry;
 345
 346         lan_rmw(ANA_PGID_PGID_SET(mdb_entry->ports),
 347                 ANA_PGID_PGID,
 348                 lan966x, ANA_PGID(pgid_entry->index));
 349
 350         return lan966x_mac_learn(lan966x, pgid_entry->index, mdb_entry->mac,
 351                                  mdb_entry->vid, type);
 352 }
 353
 354 static enum macaccess_entry_type
 355 lan966x_mdb_classify(const unsigned char *mac)
 356 {
 357         if (mac[0] == 0x01 && mac[1] == 0x00 && mac[2] == 0x5e)
 358                 return ENTRYTYPE_MACV4;
 359         if (mac[0] == 0x33 && mac[1] == 0x33)
 360                 return ENTRYTYPE_MACV6;
 361         return ENTRYTYPE_LOCKED;
 362 }
 363
 364 int lan966x_handle_port_mdb_add(struct lan966x_port *port,
 365                                 const struct switchdev_obj *obj)
 366 {
 367         const struct switchdev_obj_port_mdb *mdb = SWITCHDEV_OBJ_PORT_MDB(obj);
 368         enum macaccess_entry_type type;
 369
 370         /* Split the way the entries are added for ipv4/ipv6 and for l2. The
 371          * reason is that for ipv4/ipv6 it doesn't require to use any pgid
 372          * entry, while for l2 is required to use pgid entries
 373          */
 374         type = lan966x_mdb_classify(mdb->addr);
 375         if (type == ENTRYTYPE_MACV4 || type == ENTRYTYPE_MACV6)
 376                 return lan966x_mdb_ip_add(port, mdb, type);
 377
 378         return lan966x_mdb_l2_add(port, mdb, type);
 379 }
 380
 381 int lan966x_handle_port_mdb_del(struct lan966x_port *port,
 382                                 const struct switchdev_obj *obj)
 383 {
 384         const struct switchdev_obj_port_mdb *mdb = SWITCHDEV_OBJ_PORT_MDB(obj);
 385         enum macaccess_entry_type type;
 386
 387         /* Split the way the entries are removed for ipv4/ipv6 and for l2. The
 388          * reason is that for ipv4/ipv6 it doesn't require to use any pgid
 389          * entry, while for l2 is required to use pgid entries
 390          */
 391         type = lan966x_mdb_classify(mdb->addr);
 392         if (type == ENTRYTYPE_MACV4 || type == ENTRYTYPE_MACV6)
 393                 return lan966x_mdb_ip_del(port, mdb, type);
 394
 395         return lan966x_mdb_l2_del(port, mdb, type);
 396 }
 397
 398 static void lan966x_mdb_ip_cpu_copy(struct lan966x *lan966x,
 399                                     struct lan966x_mdb_entry *mdb_entry,
 400                                     enum macaccess_entry_type type)
 401 {
 402         unsigned char mac[ETH_ALEN];
 403
 404         lan966x_mdb_encode_mac(mac, mdb_entry, type);
 405         lan966x_mac_forget(lan966x, mac, mdb_entry->vid, type);
 406         lan966x_mac_ip_learn(lan966x, true, mac, mdb_entry->vid, type);
 407 }
 408
 409 static void lan966x_mdb_l2_cpu_copy(struct lan966x *lan966x,
 410                                     struct lan966x_mdb_entry *mdb_entry,
 411                                     enum macaccess_entry_type type)
 412 {
 413         struct lan966x_pgid_entry *pgid_entry;
 414         unsigned char mac[ETH_ALEN];
 415
 416         lan966x_pgid_entry_del(lan966x, mdb_entry->pgid);
 417         lan966x_mdb_encode_mac(mac, mdb_entry, type);
 418         lan966x_mac_forget(lan966x, mac, mdb_entry->vid, type);
 419
 420         mdb_entry->ports |= BIT(CPU_PORT);
 421
 422         pgid_entry = lan966x_pgid_entry_get(lan966x, mdb_entry);
 423         if (IS_ERR(pgid_entry))
 424                 return;
 425
 426         mdb_entry->pgid = pgid_entry;
 427
 428         lan_rmw(ANA_PGID_PGID_SET(mdb_entry->ports),
 429                 ANA_PGID_PGID,
 430                 lan966x, ANA_PGID(pgid_entry->index));
 431
 432         lan966x_mac_learn(lan966x, pgid_entry->index, mdb_entry->mac,
 433                           mdb_entry->vid, type);
 434 }
 435
 436 void lan966x_mdb_write_entries(struct lan966x *lan966x, u16 vid)
 437 {
 438         struct lan966x_mdb_entry *mdb_entry;
 439         enum macaccess_entry_type type;
 440
 441         list_for_each_entry(mdb_entry, &lan966x->mdb_entries, list) {
 442                 if (mdb_entry->vid != vid || !mdb_entry->cpu_copy)
 443                         continue;
 444
 445                 type = lan966x_mdb_classify(mdb_entry->mac);
 446                 if (type == ENTRYTYPE_MACV4 || type == ENTRYTYPE_MACV6)
 447                         lan966x_mdb_ip_cpu_copy(lan966x, mdb_entry, type);
 448                 else
 449                         lan966x_mdb_l2_cpu_copy(lan966x, mdb_entry, type);
 450         }
 451 }
 452
 453 static void lan966x_mdb_ip_cpu_remove(struct lan966x *lan966x,
 454                                       struct lan966x_mdb_entry *mdb_entry,
 455                                       enum macaccess_entry_type type)
 456 {
 457         unsigned char mac[ETH_ALEN];
 458
 459         lan966x_mdb_encode_mac(mac, mdb_entry, type);
 460         lan966x_mac_forget(lan966x, mac, mdb_entry->vid, type);
 461         lan966x_mac_ip_learn(lan966x, false, mac, mdb_entry->vid, type);
 462 }
 463
 464 static void lan966x_mdb_l2_cpu_remove(struct lan966x *lan966x,
 465                                       struct lan966x_mdb_entry *mdb_entry,
 466                                       enum macaccess_entry_type type)
 467 {
 468         struct lan966x_pgid_entry *pgid_entry;
 469         unsigned char mac[ETH_ALEN];
 470
 471         lan966x_pgid_entry_del(lan966x, mdb_entry->pgid);
 472         lan966x_mdb_encode_mac(mac, mdb_entry, type);
 473         lan966x_mac_forget(lan966x, mac, mdb_entry->vid, type);
 474
 475         mdb_entry->ports &= ~BIT(CPU_PORT);
 476
 477         pgid_entry = lan966x_pgid_entry_get(lan966x, mdb_entry);
 478         if (IS_ERR(pgid_entry))
 479                 return;
 480
 481         mdb_entry->pgid = pgid_entry;
 482
 483         lan_rmw(ANA_PGID_PGID_SET(mdb_entry->ports),
 484                 ANA_PGID_PGID,
 485                 lan966x, ANA_PGID(pgid_entry->index));
 486
 487         lan966x_mac_learn(lan966x, pgid_entry->index, mdb_entry->mac,
 488                           mdb_entry->vid, type);
 489 }
 490
 491 void lan966x_mdb_erase_entries(struct lan966x *lan966x, u16 vid)
 492 {
 493         struct lan966x_mdb_entry *mdb_entry;
 494         enum macaccess_entry_type type;
 495
 496         list_for_each_entry(mdb_entry, &lan966x->mdb_entries, list) {
 497                 if (mdb_entry->vid != vid || !mdb_entry->cpu_copy)
 498                         continue;
 499
 500                 type = lan966x_mdb_classify(mdb_entry->mac);
 501                 if (type == ENTRYTYPE_MACV4 || type == ENTRYTYPE_MACV6)
 502                         lan966x_mdb_ip_cpu_remove(lan966x, mdb_entry, type);
 503                 else
 504                         lan966x_mdb_l2_cpu_remove(lan966x, mdb_entry, type);
 505         }
 506 }
 507
 508 void lan966x_mdb_clear_entries(struct lan966x *lan966x)
 509 {
 510         struct lan966x_mdb_entry *mdb_entry;
 511         enum macaccess_entry_type type;
 512         unsigned char mac[ETH_ALEN];
 513
 514         list_for_each_entry(mdb_entry, &lan966x->mdb_entries, list) {
 515                 type = lan966x_mdb_classify(mdb_entry->mac);
 516
 517                 lan966x_mdb_encode_mac(mac, mdb_entry, type);
 518                 /* Remove just the MAC entry, still keep the PGID in case of L2
 519                  * entries because this can be restored at later point
 520                  */
 521                 lan966x_mac_forget(lan966x, mac, mdb_entry->vid, type);
 522         }
 523 }
 524
 525 void lan966x_mdb_restore_entries(struct lan966x *lan966x)
 526 {
 527         struct lan966x_mdb_entry *mdb_entry;
 528         enum macaccess_entry_type type;
 529         unsigned char mac[ETH_ALEN];
 530         bool cpu_copy = false;
 531
 532         list_for_each_entry(mdb_entry, &lan966x->mdb_entries, list) {
 533                 type = lan966x_mdb_classify(mdb_entry->mac);
 534
 535                 lan966x_mdb_encode_mac(mac, mdb_entry, type);
 536                 if (type == ENTRYTYPE_MACV4 || type == ENTRYTYPE_MACV6) {
 537                         /* Copy the frame to CPU only if the CPU is in the VLAN */
 538                         if (lan966x_vlan_cpu_member_cpu_vlan_mask(lan966x,
 539                                                                   mdb_entry->vid) &&
 540                             mdb_entry->cpu_copy)
 541                                 cpu_copy = true;
 542
 543                         lan966x_mac_ip_learn(lan966x, cpu_copy, mac,
 544                                              mdb_entry->vid, type);
 545                 } else {
 546                         lan966x_mac_learn(lan966x, mdb_entry->pgid->index,
 547                                           mdb_entry->mac,
 548                                           mdb_entry->vid, type);
 549                 }
 550         }
 551 }