net/dsa/dsa2.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * net/dsa/dsa2.c - Hardware switch handling, binding version 2
   4  * Copyright (c) 2008-2009 Marvell Semiconductor
   5  * Copyright (c) 2013 Florian Fainelli <florian@openwrt.org>
   6  * Copyright (c) 2016 Andrew Lunn <andrew@lunn.ch>
   7  */
   8
   9 #include <linux/device.h>
  10 #include <linux/err.h>
  11 #include <linux/list.h>
  12 #include <linux/netdevice.h>
  13 #include <linux/slab.h>
  14 #include <linux/rtnetlink.h>
  15 #include <linux/of.h>
  16 #include <linux/of_net.h>
  17 #include <net/devlink.h>
  18
  19 #include "dsa_priv.h"
  20
  21 static DEFINE_MUTEX(dsa2_mutex);
  22 LIST_HEAD(dsa_tree_list);
  23
  24 /**
  25  * dsa_tree_notify - Execute code for all switches in a DSA switch tree.
  26  * @dst: collection of struct dsa_switch devices to notify.
  27  * @e: event, must be of type DSA_NOTIFIER_*
  28  * @v: event-specific value.
  29  *
  30  * Given a struct dsa_switch_tree, this can be used to run a function once for
  31  * each member DSA switch. The other alternative of traversing the tree is only
  32  * through its ports list, which does not uniquely list the switches.
  33  */
  34 int dsa_tree_notify(struct dsa_switch_tree *dst, unsigned long e, void *v)
  35 {
  36         struct raw_notifier_head *nh = &dst->nh;
  37         int err;
  38
  39         err = raw_notifier_call_chain(nh, e, v);
  40
  41         return notifier_to_errno(err);
  42 }
  43
  44 /**
  45  * dsa_broadcast - Notify all DSA trees in the system.
  46  * @e: event, must be of type DSA_NOTIFIER_*
  47  * @v: event-specific value.
  48  *
  49  * Can be used to notify the switching fabric of events such as cross-chip
  50  * bridging between disjoint trees (such as islands of tagger-compatible
  51  * switches bridged by an incompatible middle switch).
  52  */
  53 int dsa_broadcast(unsigned long e, void *v)
  54 {
  55         struct dsa_switch_tree *dst;
  56         int err = 0;
  57
  58         list_for_each_entry(dst, &dsa_tree_list, list) {
  59                 err = dsa_tree_notify(dst, e, v);
  60                 if (err)
  61                         break;
  62         }
  63
  64         return err;
  65 }
  66
  67 /**
  68  * dsa_lag_map() - Map LAG netdev to a linear LAG ID
  69  * @dst: Tree in which to record the mapping.
  70  * @lag: Netdev that is to be mapped to an ID.
  71  *
  72  * dsa_lag_id/dsa_lag_dev can then be used to translate between the
  73  * two spaces. The size of the mapping space is determined by the
  74  * driver by setting ds->num_lag_ids. It is perfectly legal to leave
  75  * it unset if it is not needed, in which case these functions become
  76  * no-ops.
  77  */
  78 void dsa_lag_map(struct dsa_switch_tree *dst, struct net_device *lag)
  79 {
  80         unsigned int id;
  81
  82         if (dsa_lag_id(dst, lag) >= 0)
  83                 /* Already mapped */
  84                 return;
  85
  86         for (id = 0; id < dst->lags_len; id++) {
  87                 if (!dsa_lag_dev(dst, id)) {
  88                         dst->lags[id] = lag;
  89                         return;
  90                 }
  91         }
  92
  93         /* No IDs left, which is OK. Some drivers do not need it. The
  94          * ones that do, e.g. mv88e6xxx, will discover that dsa_lag_id
  95          * returns an error for this device when joining the LAG. The
  96          * driver can then return -EOPNOTSUPP back to DSA, which will
  97          * fall back to a software LAG.
  98          */
  99 }
 100
 101 /**
 102  * dsa_lag_unmap() - Remove a LAG ID mapping
 103  * @dst: Tree in which the mapping is recorded.
 104  * @lag: Netdev that was mapped.
 105  *
 106  * As there may be multiple users of the mapping, it is only removed
 107  * if there are no other references to it.
 108  */
 109 void dsa_lag_unmap(struct dsa_switch_tree *dst, struct net_device *lag)
 110 {
 111         struct dsa_port *dp;
 112         unsigned int id;
 113
 114         dsa_lag_foreach_port(dp, dst, lag)
 115                 /* There are remaining users of this mapping */
 116                 return;
 117
 118         dsa_lags_foreach_id(id, dst) {
 119                 if (dsa_lag_dev(dst, id) == lag) {
 120                         dst->lags[id] = NULL;
 121                         break;
 122                 }
 123         }
 124 }
 125
 126 struct dsa_switch *dsa_switch_find(int tree_index, int sw_index)
 127 {
 128         struct dsa_switch_tree *dst;
 129         struct dsa_port *dp;
 130
 131         list_for_each_entry(dst, &dsa_tree_list, list) {
 132                 if (dst->index != tree_index)
 133                         continue;
 134
 135                 list_for_each_entry(dp, &dst->ports, list) {
 136                         if (dp->ds->index != sw_index)
 137                                 continue;
 138
 139                         return dp->ds;
 140                 }
 141         }
 142
 143         return NULL;
 144 }
 145 EXPORT_SYMBOL_GPL(dsa_switch_find);
 146
 147 static struct dsa_switch_tree *dsa_tree_find(int index)
 148 {
 149         struct dsa_switch_tree *dst;
 150
 151         list_for_each_entry(dst, &dsa_tree_list, list)
 152                 if (dst->index == index)
 153                         return dst;
 154
 155         return NULL;
 156 }
 157
 158 static struct dsa_switch_tree *dsa_tree_alloc(int index)
 159 {
 160         struct dsa_switch_tree *dst;
 161
 162         dst = kzalloc(sizeof(*dst), GFP_KERNEL);
 163         if (!dst)
 164                 return NULL;
 165
 166         dst->index = index;
 167
 168         INIT_LIST_HEAD(&dst->rtable);
 169
 170         INIT_LIST_HEAD(&dst->ports);
 171
 172         INIT_LIST_HEAD(&dst->list);
 173         list_add_tail(&dst->list, &dsa_tree_list);
 174
 175         kref_init(&dst->refcount);
 176
 177         return dst;
 178 }
 179
 180 static void dsa_tree_free(struct dsa_switch_tree *dst)
 181 {
 182         if (dst->tag_ops)
 183                 dsa_tag_driver_put(dst->tag_ops);
 184         list_del(&dst->list);
 185         kfree(dst);
 186 }
 187
 188 static struct dsa_switch_tree *dsa_tree_get(struct dsa_switch_tree *dst)
 189 {
 190         if (dst)
 191                 kref_get(&dst->refcount);
 192
 193         return dst;
 194 }
 195
 196 static struct dsa_switch_tree *dsa_tree_touch(int index)
 197 {
 198         struct dsa_switch_tree *dst;
 199
 200         dst = dsa_tree_find(index);
 201         if (dst)
 202                 return dsa_tree_get(dst);
 203         else
 204                 return dsa_tree_alloc(index);
 205 }
 206
 207 static void dsa_tree_release(struct kref *ref)
 208 {
 209         struct dsa_switch_tree *dst;
 210
 211         dst = container_of(ref, struct dsa_switch_tree, refcount);
 212
 213         dsa_tree_free(dst);
 214 }
 215
 216 static void dsa_tree_put(struct dsa_switch_tree *dst)
 217 {
 218         if (dst)
 219                 kref_put(&dst->refcount, dsa_tree_release);
 220 }
 221
 222 static bool dsa_port_is_dsa(struct dsa_port *port)
 223 {
 224         return port->type == DSA_PORT_TYPE_DSA;
 225 }
 226
 227 static bool dsa_port_is_cpu(struct dsa_port *port)
 228 {
 229         return port->type == DSA_PORT_TYPE_CPU;
 230 }
 231
 232 static bool dsa_port_is_user(struct dsa_port *dp)
 233 {
 234         return dp->type == DSA_PORT_TYPE_USER;
 235 }
 236
 237 static struct dsa_port *dsa_tree_find_port_by_node(struct dsa_switch_tree *dst,
 238                                                    struct device_node *dn)
 239 {
 240         struct dsa_port *dp;
 241
 242         list_for_each_entry(dp, &dst->ports, list)
 243                 if (dp->dn == dn)
 244                         return dp;
 245
 246         return NULL;
 247 }
 248
 249 static struct dsa_link *dsa_link_touch(struct dsa_port *dp,
 250                                        struct dsa_port *link_dp)
 251 {
 252         struct dsa_switch *ds = dp->ds;
 253         struct dsa_switch_tree *dst;
 254         struct dsa_link *dl;
 255
 256         dst = ds->dst;
 257
 258         list_for_each_entry(dl, &dst->rtable, list)
 259                 if (dl->dp == dp && dl->link_dp == link_dp)
 260                         return dl;
 261
 262         dl = kzalloc(sizeof(*dl), GFP_KERNEL);
 263         if (!dl)
 264                 return NULL;
 265
 266         dl->dp = dp;
 267         dl->link_dp = link_dp;
 268
 269         INIT_LIST_HEAD(&dl->list);
 270         list_add_tail(&dl->list, &dst->rtable);
 271
 272         return dl;
 273 }
 274
 275 static bool dsa_port_setup_routing_table(struct dsa_port *dp)
 276 {
 277         struct dsa_switch *ds = dp->ds;
 278         struct dsa_switch_tree *dst = ds->dst;
 279         struct device_node *dn = dp->dn;
 280         struct of_phandle_iterator it;
 281         struct dsa_port *link_dp;
 282         struct dsa_link *dl;
 283         int err;
 284
 285         of_for_each_phandle(&it, err, dn, "link", NULL, 0) {
 286                 link_dp = dsa_tree_find_port_by_node(dst, it.node);
 287                 if (!link_dp) {
 288                         of_node_put(it.node);
 289                         return false;
 290                 }
 291
 292                 dl = dsa_link_touch(dp, link_dp);
 293                 if (!dl) {
 294                         of_node_put(it.node);
 295                         return false;
 296                 }
 297         }
 298
 299         return true;
 300 }
 301
 302 static bool dsa_tree_setup_routing_table(struct dsa_switch_tree *dst)
 303 {
 304         bool complete = true;
 305         struct dsa_port *dp;
 306
 307         list_for_each_entry(dp, &dst->ports, list) {
 308                 if (dsa_port_is_dsa(dp)) {
 309                         complete = dsa_port_setup_routing_table(dp);
 310                         if (!complete)
 311                                 break;
 312                 }
 313         }
 314
 315         return complete;
 316 }
 317
 318 static struct dsa_port *dsa_tree_find_first_cpu(struct dsa_switch_tree *dst)
 319 {
 320         struct dsa_port *dp;
 321
 322         list_for_each_entry(dp, &dst->ports, list)
 323                 if (dsa_port_is_cpu(dp))
 324                         return dp;
 325
 326         return NULL;
 327 }
 328
 329 static int dsa_tree_setup_default_cpu(struct dsa_switch_tree *dst)
 330 {
 331         struct dsa_port *cpu_dp, *dp;
 332
 333         cpu_dp = dsa_tree_find_first_cpu(dst);
 334         if (!cpu_dp) {
 335                 pr_err("DSA: tree %d has no CPU port\n", dst->index);
 336                 return -EINVAL;
 337         }
 338
 339         /* Assign the default CPU port to all ports of the fabric */
 340         list_for_each_entry(dp, &dst->ports, list)
 341                 if (dsa_port_is_user(dp) || dsa_port_is_dsa(dp))
 342                         dp->cpu_dp = cpu_dp;
 343
 344         return 0;
 345 }
 346
 347 static void dsa_tree_teardown_default_cpu(struct dsa_switch_tree *dst)
 348 {
 349         struct dsa_port *dp;
 350
 351         list_for_each_entry(dp, &dst->ports, list)
 352                 if (dsa_port_is_user(dp) || dsa_port_is_dsa(dp))
 353                         dp->cpu_dp = NULL;
 354 }
 355
 356 static int dsa_port_setup(struct dsa_port *dp)
 357 {
 358         struct devlink_port *dlp = &dp->devlink_port;
 359         bool dsa_port_link_registered = false;
 360         bool dsa_port_enabled = false;
 361         int err = 0;
 362
 363         if (dp->setup)
 364                 return 0;
 365
 366         switch (dp->type) {
 367         case DSA_PORT_TYPE_UNUSED:
 368                 dsa_port_disable(dp);
 369                 break;
 370         case DSA_PORT_TYPE_CPU:
 371                 err = dsa_port_link_register_of(dp);
 372                 if (err)
 373                         break;
 374                 dsa_port_link_registered = true;
 375
 376                 err = dsa_port_enable(dp, NULL);
 377                 if (err)
 378                         break;
 379                 dsa_port_enabled = true;
 380
 381                 break;
 382         case DSA_PORT_TYPE_DSA:
 383                 err = dsa_port_link_register_of(dp);
 384                 if (err)
 385                         break;
 386                 dsa_port_link_registered = true;
 387
 388                 err = dsa_port_enable(dp, NULL);
 389                 if (err)
 390                         break;
 391                 dsa_port_enabled = true;
 392
 393                 break;
 394         case DSA_PORT_TYPE_USER:
 395                 dp->mac = of_get_mac_address(dp->dn);
 396                 err = dsa_slave_create(dp);
 397                 if (err)
 398                         break;
 399
 400                 devlink_port_type_eth_set(dlp, dp->slave);
 401                 break;
 402         }
 403
 404         if (err && dsa_port_enabled)
 405                 dsa_port_disable(dp);
 406         if (err && dsa_port_link_registered)
 407                 dsa_port_link_unregister_of(dp);
 408         if (err)
 409                 return err;
 410
 411         dp->setup = true;
 412
 413         return 0;
 414 }
 415
 416 static int dsa_port_devlink_setup(struct dsa_port *dp)
 417 {
 418         struct devlink_port *dlp = &dp->devlink_port;
 419         struct dsa_switch_tree *dst = dp->ds->dst;
 420         struct devlink_port_attrs attrs = {};
 421         struct devlink *dl = dp->ds->devlink;
 422         const unsigned char *id;
 423         unsigned char len;
 424         int err;
 425
 426         id = (const unsigned char *)&dst->index;
 427         len = sizeof(dst->index);
 428
 429         attrs.phys.port_number = dp->index;
 430         memcpy(attrs.switch_id.id, id, len);
 431         attrs.switch_id.id_len = len;
 432         memset(dlp, 0, sizeof(*dlp));
 433
 434         switch (dp->type) {
 435         case DSA_PORT_TYPE_UNUSED:
 436                 attrs.flavour = DEVLINK_PORT_FLAVOUR_UNUSED;
 437                 break;
 438         case DSA_PORT_TYPE_CPU:
 439                 attrs.flavour = DEVLINK_PORT_FLAVOUR_CPU;
 440                 break;
 441         case DSA_PORT_TYPE_DSA:
 442                 attrs.flavour = DEVLINK_PORT_FLAVOUR_DSA;
 443                 break;
 444         case DSA_PORT_TYPE_USER:
 445                 attrs.flavour = DEVLINK_PORT_FLAVOUR_PHYSICAL;
 446                 break;
 447         }
 448
 449         devlink_port_attrs_set(dlp, &attrs);
 450         err = devlink_port_register(dl, dlp, dp->index);
 451
 452         if (!err)
 453                 dp->devlink_port_setup = true;
 454
 455         return err;
 456 }
 457
 458 static void dsa_port_teardown(struct dsa_port *dp)
 459 {
 460         struct devlink_port *dlp = &dp->devlink_port;
 461
 462         if (!dp->setup)
 463                 return;
 464
 465         devlink_port_type_clear(dlp);
 466
 467         switch (dp->type) {
 468         case DSA_PORT_TYPE_UNUSED:
 469                 break;
 470         case DSA_PORT_TYPE_CPU:
 471                 dsa_port_disable(dp);
 472                 dsa_port_link_unregister_of(dp);
 473                 break;
 474         case DSA_PORT_TYPE_DSA:
 475                 dsa_port_disable(dp);
 476                 dsa_port_link_unregister_of(dp);
 477                 break;
 478         case DSA_PORT_TYPE_USER:
 479                 if (dp->slave) {
 480                         dsa_slave_destroy(dp->slave);
 481                         dp->slave = NULL;
 482                 }
 483                 break;
 484         }
 485
 486         dp->setup = false;
 487 }
 488
 489 static void dsa_port_devlink_teardown(struct dsa_port *dp)
 490 {
 491         struct devlink_port *dlp = &dp->devlink_port;
 492
 493         if (dp->devlink_port_setup)
 494                 devlink_port_unregister(dlp);
 495         dp->devlink_port_setup = false;
 496 }
 497
 498 static int dsa_devlink_info_get(struct devlink *dl,
 499                                 struct devlink_info_req *req,
 500                                 struct netlink_ext_ack *extack)
 501 {
 502         struct dsa_switch *ds = dsa_devlink_to_ds(dl);
 503
 504         if (ds->ops->devlink_info_get)
 505                 return ds->ops->devlink_info_get(ds, req, extack);
 506
 507         return -EOPNOTSUPP;
 508 }
 509
 510 static int dsa_devlink_sb_pool_get(struct devlink *dl,
 511                                    unsigned int sb_index, u16 pool_index,
 512                                    struct devlink_sb_pool_info *pool_info)
 513 {
 514         struct dsa_switch *ds = dsa_devlink_to_ds(dl);
 515
 516         if (!ds->ops->devlink_sb_pool_get)
 517                 return -EOPNOTSUPP;
 518
 519         return ds->ops->devlink_sb_pool_get(ds, sb_index, pool_index,
 520                                             pool_info);
 521 }
 522
 523 static int dsa_devlink_sb_pool_set(struct devlink *dl, unsigned int sb_index,
 524                                    u16 pool_index, u32 size,
 525                                    enum devlink_sb_threshold_type threshold_type,
 526                                    struct netlink_ext_ack *extack)
 527 {
 528         struct dsa_switch *ds = dsa_devlink_to_ds(dl);
 529
 530         if (!ds->ops->devlink_sb_pool_set)
 531                 return -EOPNOTSUPP;
 532
 533         return ds->ops->devlink_sb_pool_set(ds, sb_index, pool_index, size,
 534                                             threshold_type, extack);
 535 }
 536
 537 static int dsa_devlink_sb_port_pool_get(struct devlink_port *dlp,
 538                                         unsigned int sb_index, u16 pool_index,
 539                                         u32 *p_threshold)
 540 {
 541         struct dsa_switch *ds = dsa_devlink_port_to_ds(dlp);
 542         int port = dsa_devlink_port_to_port(dlp);
 543
 544         if (!ds->ops->devlink_sb_port_pool_get)
 545                 return -EOPNOTSUPP;
 546
 547         return ds->ops->devlink_sb_port_pool_get(ds, port, sb_index,
 548                                                  pool_index, p_threshold);
 549 }
 550
 551 static int dsa_devlink_sb_port_pool_set(struct devlink_port *dlp,
 552                                         unsigned int sb_index, u16 pool_index,
 553                                         u32 threshold,
 554                                         struct netlink_ext_ack *extack)
 555 {
 556         struct dsa_switch *ds = dsa_devlink_port_to_ds(dlp);
 557         int port = dsa_devlink_port_to_port(dlp);
 558
 559         if (!ds->ops->devlink_sb_port_pool_set)
 560                 return -EOPNOTSUPP;
 561
 562         return ds->ops->devlink_sb_port_pool_set(ds, port, sb_index,
 563                                                  pool_index, threshold, extack);
 564 }
 565
 566 static int
 567 dsa_devlink_sb_tc_pool_bind_get(struct devlink_port *dlp,
 568                                 unsigned int sb_index, u16 tc_index,
 569                                 enum devlink_sb_pool_type pool_type,
 570                                 u16 *p_pool_index, u32 *p_threshold)
 571 {
 572         struct dsa_switch *ds = dsa_devlink_port_to_ds(dlp);
 573         int port = dsa_devlink_port_to_port(dlp);
 574
 575         if (!ds->ops->devlink_sb_tc_pool_bind_get)
 576                 return -EOPNOTSUPP;
 577
 578         return ds->ops->devlink_sb_tc_pool_bind_get(ds, port, sb_index,
 579                                                     tc_index, pool_type,
 580                                                     p_pool_index, p_threshold);
 581 }
 582
 583 static int
 584 dsa_devlink_sb_tc_pool_bind_set(struct devlink_port *dlp,
 585                                 unsigned int sb_index, u16 tc_index,
 586                                 enum devlink_sb_pool_type pool_type,
 587                                 u16 pool_index, u32 threshold,
 588                                 struct netlink_ext_ack *extack)
 589 {
 590         struct dsa_switch *ds = dsa_devlink_port_to_ds(dlp);
 591         int port = dsa_devlink_port_to_port(dlp);
 592
 593         if (!ds->ops->devlink_sb_tc_pool_bind_set)
 594                 return -EOPNOTSUPP;
 595
 596         return ds->ops->devlink_sb_tc_pool_bind_set(ds, port, sb_index,
 597                                                     tc_index, pool_type,
 598                                                     pool_index, threshold,
 599                                                     extack);
 600 }
 601
 602 static int dsa_devlink_sb_occ_snapshot(struct devlink *dl,
 603                                        unsigned int sb_index)
 604 {
 605         struct dsa_switch *ds = dsa_devlink_to_ds(dl);
 606
 607         if (!ds->ops->devlink_sb_occ_snapshot)
 608                 return -EOPNOTSUPP;
 609
 610         return ds->ops->devlink_sb_occ_snapshot(ds, sb_index);
 611 }
 612
 613 static int dsa_devlink_sb_occ_max_clear(struct devlink *dl,
 614                                         unsigned int sb_index)
 615 {
 616         struct dsa_switch *ds = dsa_devlink_to_ds(dl);
 617
 618         if (!ds->ops->devlink_sb_occ_max_clear)
 619                 return -EOPNOTSUPP;
 620
 621         return ds->ops->devlink_sb_occ_max_clear(ds, sb_index);
 622 }
 623
 624 static int dsa_devlink_sb_occ_port_pool_get(struct devlink_port *dlp,
 625                                             unsigned int sb_index,
 626                                             u16 pool_index, u32 *p_cur,
 627                                             u32 *p_max)
 628 {
 629         struct dsa_switch *ds = dsa_devlink_port_to_ds(dlp);
 630         int port = dsa_devlink_port_to_port(dlp);
 631
 632         if (!ds->ops->devlink_sb_occ_port_pool_get)
 633                 return -EOPNOTSUPP;
 634
 635         return ds->ops->devlink_sb_occ_port_pool_get(ds, port, sb_index,
 636                                                      pool_index, p_cur, p_max);
 637 }
 638
 639 static int
 640 dsa_devlink_sb_occ_tc_port_bind_get(struct devlink_port *dlp,
 641                                     unsigned int sb_index, u16 tc_index,
 642                                     enum devlink_sb_pool_type pool_type,
 643                                     u32 *p_cur, u32 *p_max)
 644 {
 645         struct dsa_switch *ds = dsa_devlink_port_to_ds(dlp);
 646         int port = dsa_devlink_port_to_port(dlp);
 647
 648         if (!ds->ops->devlink_sb_occ_tc_port_bind_get)
 649                 return -EOPNOTSUPP;
 650
 651         return ds->ops->devlink_sb_occ_tc_port_bind_get(ds, port,
 652                                                         sb_index, tc_index,
 653                                                         pool_type, p_cur,
 654                                                         p_max);
 655 }
 656
 657 static const struct devlink_ops dsa_devlink_ops = {
 658         .info_get                       = dsa_devlink_info_get,
 659         .sb_pool_get                    = dsa_devlink_sb_pool_get,
 660         .sb_pool_set                    = dsa_devlink_sb_pool_set,
 661         .sb_port_pool_get               = dsa_devlink_sb_port_pool_get,
 662         .sb_port_pool_set               = dsa_devlink_sb_port_pool_set,
 663         .sb_tc_pool_bind_get            = dsa_devlink_sb_tc_pool_bind_get,
 664         .sb_tc_pool_bind_set            = dsa_devlink_sb_tc_pool_bind_set,
 665         .sb_occ_snapshot                = dsa_devlink_sb_occ_snapshot,
 666         .sb_occ_max_clear               = dsa_devlink_sb_occ_max_clear,
 667         .sb_occ_port_pool_get           = dsa_devlink_sb_occ_port_pool_get,
 668         .sb_occ_tc_port_bind_get        = dsa_devlink_sb_occ_tc_port_bind_get,
 669 };
 670
 671 static int dsa_switch_setup(struct dsa_switch *ds)
 672 {
 673         struct dsa_devlink_priv *dl_priv;
 674         struct dsa_port *dp;
 675         int err;
 676
 677         if (ds->setup)
 678                 return 0;
 679
 680         /* Initialize ds->phys_mii_mask before registering the slave MDIO bus
 681          * driver and before ops->setup() has run, since the switch drivers and
 682          * the slave MDIO bus driver rely on these values for probing PHY
 683          * devices or not
 684          */
 685         ds->phys_mii_mask |= dsa_user_ports(ds);
 686
 687         /* Add the switch to devlink before calling setup, so that setup can
 688          * add dpipe tables
 689          */
 690         ds->devlink = devlink_alloc(&dsa_devlink_ops, sizeof(*dl_priv));
 691         if (!ds->devlink)
 692                 return -ENOMEM;
 693         dl_priv = devlink_priv(ds->devlink);
 694         dl_priv->ds = ds;
 695
 696         err = devlink_register(ds->devlink, ds->dev);
 697         if (err)
 698                 goto free_devlink;
 699
 700         /* Setup devlink port instances now, so that the switch
 701          * setup() can register regions etc, against the ports
 702          */
 703         list_for_each_entry(dp, &ds->dst->ports, list) {
 704                 if (dp->ds == ds) {
 705                         err = dsa_port_devlink_setup(dp);
 706                         if (err)
 707                                 goto unregister_devlink_ports;
 708                 }
 709         }
 710
 711         err = dsa_switch_register_notifier(ds);
 712         if (err)
 713                 goto unregister_devlink_ports;
 714
 715         ds->configure_vlan_while_not_filtering = true;
 716
 717         err = ds->ops->setup(ds);
 718         if (err < 0)
 719                 goto unregister_notifier;
 720
 721         devlink_params_publish(ds->devlink);
 722
 723         if (!ds->slave_mii_bus && ds->ops->phy_read) {
 724                 ds->slave_mii_bus = devm_mdiobus_alloc(ds->dev);
 725                 if (!ds->slave_mii_bus) {
 726                         err = -ENOMEM;
 727                         goto teardown;
 728                 }
 729
 730                 dsa_slave_mii_bus_init(ds);
 731
 732                 err = mdiobus_register(ds->slave_mii_bus);
 733                 if (err < 0)
 734                         goto teardown;
 735         }
 736
 737         ds->setup = true;
 738
 739         return 0;
 740
 741 teardown:
 742         if (ds->ops->teardown)
 743                 ds->ops->teardown(ds);
 744 unregister_notifier:
 745         dsa_switch_unregister_notifier(ds);
 746 unregister_devlink_ports:
 747         list_for_each_entry(dp, &ds->dst->ports, list)
 748                 if (dp->ds == ds)
 749                         dsa_port_devlink_teardown(dp);
 750         devlink_unregister(ds->devlink);
 751 free_devlink:
 752         devlink_free(ds->devlink);
 753         ds->devlink = NULL;
 754
 755         return err;
 756 }
 757
 758 static void dsa_switch_teardown(struct dsa_switch *ds)
 759 {
 760         struct dsa_port *dp;
 761
 762         if (!ds->setup)
 763                 return;
 764
 765         if (ds->slave_mii_bus && ds->ops->phy_read)
 766                 mdiobus_unregister(ds->slave_mii_bus);
 767
 768         dsa_switch_unregister_notifier(ds);
 769
 770         if (ds->ops->teardown)
 771                 ds->ops->teardown(ds);
 772
 773         if (ds->devlink) {
 774                 list_for_each_entry(dp, &ds->dst->ports, list)
 775                         if (dp->ds == ds)
 776                                 dsa_port_devlink_teardown(dp);
 777                 devlink_unregister(ds->devlink);
 778                 devlink_free(ds->devlink);
 779                 ds->devlink = NULL;
 780         }
 781
 782         ds->setup = false;
 783 }
 784
 785 static int dsa_tree_setup_switches(struct dsa_switch_tree *dst)
 786 {
 787         struct dsa_port *dp;
 788         int err;
 789
 790         list_for_each_entry(dp, &dst->ports, list) {
 791                 err = dsa_switch_setup(dp->ds);
 792                 if (err)
 793                         goto teardown;
 794         }
 795
 796         list_for_each_entry(dp, &dst->ports, list) {
 797                 err = dsa_port_setup(dp);
 798                 if (err)
 799                         continue;
 800         }
 801
 802         return 0;
 803
 804 teardown:
 805         list_for_each_entry(dp, &dst->ports, list)
 806                 dsa_port_teardown(dp);
 807
 808         list_for_each_entry(dp, &dst->ports, list)
 809                 dsa_switch_teardown(dp->ds);
 810
 811         return err;
 812 }
 813
 814 static void dsa_tree_teardown_switches(struct dsa_switch_tree *dst)
 815 {
 816         struct dsa_port *dp;
 817
 818         list_for_each_entry(dp, &dst->ports, list)
 819                 dsa_port_teardown(dp);
 820
 821         list_for_each_entry(dp, &dst->ports, list)
 822                 dsa_switch_teardown(dp->ds);
 823 }
 824
 825 static int dsa_tree_setup_master(struct dsa_switch_tree *dst)
 826 {
 827         struct dsa_port *dp;
 828         int err;
 829
 830         list_for_each_entry(dp, &dst->ports, list) {
 831                 if (dsa_port_is_cpu(dp)) {
 832                         err = dsa_master_setup(dp->master, dp);
 833                         if (err)
 834                                 return err;
 835                 }
 836         }
 837
 838         return 0;
 839 }
 840
 841 static void dsa_tree_teardown_master(struct dsa_switch_tree *dst)
 842 {
 843         struct dsa_port *dp;
 844
 845         list_for_each_entry(dp, &dst->ports, list)
 846                 if (dsa_port_is_cpu(dp))
 847                         dsa_master_teardown(dp->master);
 848 }
 849
 850 static int dsa_tree_setup_lags(struct dsa_switch_tree *dst)
 851 {
 852         unsigned int len = 0;
 853         struct dsa_port *dp;
 854
 855         list_for_each_entry(dp, &dst->ports, list) {
 856                 if (dp->ds->num_lag_ids > len)
 857                         len = dp->ds->num_lag_ids;
 858         }
 859
 860         if (!len)
 861                 return 0;
 862
 863         dst->lags = kcalloc(len, sizeof(*dst->lags), GFP_KERNEL);
 864         if (!dst->lags)
 865                 return -ENOMEM;
 866
 867         dst->lags_len = len;
 868         return 0;
 869 }
 870
 871 static void dsa_tree_teardown_lags(struct dsa_switch_tree *dst)
 872 {
 873         kfree(dst->lags);
 874 }
 875
 876 static int dsa_tree_setup(struct dsa_switch_tree *dst)
 877 {
 878         bool complete;
 879         int err;
 880
 881         if (dst->setup) {
 882                 pr_err("DSA: tree %d already setup! Disjoint trees?\n",
 883                        dst->index);
 884                 return -EEXIST;
 885         }
 886
 887         complete = dsa_tree_setup_routing_table(dst);
 888         if (!complete)
 889                 return 0;
 890
 891         err = dsa_tree_setup_default_cpu(dst);
 892         if (err)
 893                 return err;
 894
 895         err = dsa_tree_setup_switches(dst);
 896         if (err)
 897                 goto teardown_default_cpu;
 898
 899         err = dsa_tree_setup_master(dst);
 900         if (err)
 901                 goto teardown_switches;
 902
 903         err = dsa_tree_setup_lags(dst);
 904         if (err)
 905                 goto teardown_master;
 906
 907         dst->setup = true;
 908
 909         pr_info("DSA: tree %d setup\n", dst->index);
 910
 911         return 0;
 912
 913 teardown_master:
 914         dsa_tree_teardown_master(dst);
 915 teardown_switches:
 916         dsa_tree_teardown_switches(dst);
 917 teardown_default_cpu:
 918         dsa_tree_teardown_default_cpu(dst);
 919
 920         return err;
 921 }
 922
 923 static void dsa_tree_teardown(struct dsa_switch_tree *dst)
 924 {
 925         struct dsa_link *dl, *next;
 926
 927         if (!dst->setup)
 928                 return;
 929
 930         dsa_tree_teardown_lags(dst);
 931
 932         dsa_tree_teardown_master(dst);
 933
 934         dsa_tree_teardown_switches(dst);
 935
 936         dsa_tree_teardown_default_cpu(dst);
 937
 938         list_for_each_entry_safe(dl, next, &dst->rtable, list) {
 939                 list_del(&dl->list);
 940                 kfree(dl);
 941         }
 942
 943         pr_info("DSA: tree %d torn down\n", dst->index);
 944
 945         dst->setup = false;
 946 }
 947
 948 /* Since the dsa/tagging sysfs device attribute is per master, the assumption
 949  * is that all DSA switches within a tree share the same tagger, otherwise
 950  * they would have formed disjoint trees (different "dsa,member" values).
 951  */
 952 int dsa_tree_change_tag_proto(struct dsa_switch_tree *dst,
 953                               struct net_device *master,
 954                               const struct dsa_device_ops *tag_ops,
 955                               const struct dsa_device_ops *old_tag_ops)
 956 {
 957         struct dsa_notifier_tag_proto_info info;
 958         struct dsa_port *dp;
 959         int err = -EBUSY;
 960
 961         if (!rtnl_trylock())
 962                 return restart_syscall();
 963
 964         /* At the moment we don't allow changing the tag protocol under
 965          * traffic. The rtnl_mutex also happens to serialize concurrent
 966          * attempts to change the tagging protocol. If we ever lift the IFF_UP
 967          * restriction, there needs to be another mutex which serializes this.
 968          */
 969         if (master->flags & IFF_UP)
 970                 goto out_unlock;
 971
 972         list_for_each_entry(dp, &dst->ports, list) {
 973                 if (!dsa_is_user_port(dp->ds, dp->index))
 974                         continue;
 975
 976                 if (dp->slave->flags & IFF_UP)
 977                         goto out_unlock;
 978         }
 979
 980         info.tag_ops = tag_ops;
 981         err = dsa_tree_notify(dst, DSA_NOTIFIER_TAG_PROTO, &info);
 982         if (err)
 983                 goto out_unwind_tagger;
 984
 985         dst->tag_ops = tag_ops;
 986
 987         rtnl_unlock();
 988
 989         return 0;
 990
 991 out_unwind_tagger:
 992         info.tag_ops = old_tag_ops;
 993         dsa_tree_notify(dst, DSA_NOTIFIER_TAG_PROTO, &info);
 994 out_unlock:
 995         rtnl_unlock();
 996         return err;
 997 }
 998
 999 static struct dsa_port *dsa_port_touch(struct dsa_switch *ds, int index)
1000 {
1001         struct dsa_switch_tree *dst = ds->dst;
1002         struct dsa_port *dp;
1003
1004         list_for_each_entry(dp, &dst->ports, list)
1005                 if (dp->ds == ds && dp->index == index)
1006                         return dp;
1007
1008         dp = kzalloc(sizeof(*dp), GFP_KERNEL);
1009         if (!dp)
1010                 return NULL;
1011
1012         dp->ds = ds;
1013         dp->index = index;
1014
1015         INIT_LIST_HEAD(&dp->list);
1016         list_add_tail(&dp->list, &dst->ports);
1017
1018         return dp;
1019 }
1020
1021 static int dsa_port_parse_user(struct dsa_port *dp, const char *name)
1022 {
1023         if (!name)
1024                 name = "eth%d";
1025
1026         dp->type = DSA_PORT_TYPE_USER;
1027         dp->name = name;
1028
1029         return 0;
1030 }
1031
1032 static int dsa_port_parse_dsa(struct dsa_port *dp)
1033 {
1034         dp->type = DSA_PORT_TYPE_DSA;
1035
1036         return 0;
1037 }
1038
1039 static enum dsa_tag_protocol dsa_get_tag_protocol(struct dsa_port *dp,
1040                                                   struct net_device *master)
1041 {
1042         enum dsa_tag_protocol tag_protocol = DSA_TAG_PROTO_NONE;
1043         struct dsa_switch *mds, *ds = dp->ds;
1044         unsigned int mdp_upstream;
1045         struct dsa_port *mdp;
1046
1047         /* It is possible to stack DSA switches onto one another when that
1048          * happens the switch driver may want to know if its tagging protocol
1049          * is going to work in such a configuration.
1050          */
1051         if (dsa_slave_dev_check(master)) {
1052                 mdp = dsa_slave_to_port(master);
1053                 mds = mdp->ds;
1054                 mdp_upstream = dsa_upstream_port(mds, mdp->index);
1055                 tag_protocol = mds->ops->get_tag_protocol(mds, mdp_upstream,
1056                                                           DSA_TAG_PROTO_NONE);
1057         }
1058
1059         /* If the master device is not itself a DSA slave in a disjoint DSA
1060          * tree, then return immediately.
1061          */
1062         return ds->ops->get_tag_protocol(ds, dp->index, tag_protocol);
1063 }
1064
1065 static int dsa_port_parse_cpu(struct dsa_port *dp, struct net_device *master)
1066 {
1067         struct dsa_switch *ds = dp->ds;
1068         struct dsa_switch_tree *dst = ds->dst;
1069         const struct dsa_device_ops *tag_ops;
1070         enum dsa_tag_protocol tag_protocol;
1071
1072         tag_protocol = dsa_get_tag_protocol(dp, master);
1073         if (dst->tag_ops) {
1074                 if (dst->tag_ops->proto != tag_protocol) {
1075                         dev_err(ds->dev,
1076                                 "A DSA switch tree can have only one tagging protocol\n");
1077                         return -EINVAL;
1078                 }
1079                 /* In the case of multiple CPU ports per switch, the tagging
1080                  * protocol is still reference-counted only per switch tree, so
1081                  * nothing to do here.
1082                  */
1083         } else {
1084                 tag_ops = dsa_tag_driver_get(tag_protocol);
1085                 if (IS_ERR(tag_ops)) {
1086                         if (PTR_ERR(tag_ops) == -ENOPROTOOPT)
1087                                 return -EPROBE_DEFER;
1088                         dev_warn(ds->dev, "No tagger for this switch\n");
1089                         dp->master = NULL;
1090                         return PTR_ERR(tag_ops);
1091                 }
1092
1093                 dst->tag_ops = tag_ops;
1094         }
1095
1096         dp->master = master;
1097         dp->type = DSA_PORT_TYPE_CPU;
1098         dsa_port_set_tag_protocol(dp, dst->tag_ops);
1099         dp->dst = dst;
1100
1101         return 0;
1102 }
1103
1104 static int dsa_port_parse_of(struct dsa_port *dp, struct device_node *dn)
1105 {
1106         struct device_node *ethernet = of_parse_phandle(dn, "ethernet", 0);
1107         const char *name = of_get_property(dn, "label", NULL);
1108         bool link = of_property_read_bool(dn, "link");
1109
1110         dp->dn = dn;
1111
1112         if (ethernet) {
1113                 struct net_device *master;
1114
1115                 master = of_find_net_device_by_node(ethernet);
1116                 if (!master)
1117                         return -EPROBE_DEFER;
1118
1119                 return dsa_port_parse_cpu(dp, master);
1120         }
1121
1122         if (link)
1123                 return dsa_port_parse_dsa(dp);
1124
1125         return dsa_port_parse_user(dp, name);
1126 }
1127
1128 static int dsa_switch_parse_ports_of(struct dsa_switch *ds,
1129                                      struct device_node *dn)
1130 {
1131         struct device_node *ports, *port;
1132         struct dsa_port *dp;
1133         int err = 0;
1134         u32 reg;
1135
1136         ports = of_get_child_by_name(dn, "ports");
1137         if (!ports) {
1138                 /* The second possibility is "ethernet-ports" */
1139                 ports = of_get_child_by_name(dn, "ethernet-ports");
1140                 if (!ports) {
1141                         dev_err(ds->dev, "no ports child node found\n");
1142                         return -EINVAL;
1143                 }
1144         }
1145
1146         for_each_available_child_of_node(ports, port) {
1147                 err = of_property_read_u32(port, "reg", &reg);
1148                 if (err)
1149                         goto out_put_node;
1150
1151                 if (reg >= ds->num_ports) {
1152                         dev_err(ds->dev, "port %pOF index %u exceeds num_ports (%zu)\n",
1153                                 port, reg, ds->num_ports);
1154                         err = -EINVAL;
1155                         goto out_put_node;
1156                 }
1157
1158                 dp = dsa_to_port(ds, reg);
1159
1160                 err = dsa_port_parse_of(dp, port);
1161                 if (err)
1162                         goto out_put_node;
1163         }
1164
1165 out_put_node:
1166         of_node_put(ports);
1167         return err;
1168 }
1169
1170 static int dsa_switch_parse_member_of(struct dsa_switch *ds,
1171                                       struct device_node *dn)
1172 {
1173         u32 m[2] = { 0, 0 };
1174         int sz;
1175
1176         /* Don't error out if this optional property isn't found */
1177         sz = of_property_read_variable_u32_array(dn, "dsa,member", m, 2, 2);
1178         if (sz < 0 && sz != -EINVAL)
1179                 return sz;
1180
1181         ds->index = m[1];
1182
1183         ds->dst = dsa_tree_touch(m[0]);
1184         if (!ds->dst)
1185                 return -ENOMEM;
1186
1187         return 0;
1188 }
1189
1190 static int dsa_switch_touch_ports(struct dsa_switch *ds)
1191 {
1192         struct dsa_port *dp;
1193         int port;
1194
1195         for (port = 0; port < ds->num_ports; port++) {
1196                 dp = dsa_port_touch(ds, port);
1197                 if (!dp)
1198                         return -ENOMEM;
1199         }
1200
1201         return 0;
1202 }
1203
1204 static int dsa_switch_parse_of(struct dsa_switch *ds, struct device_node *dn)
1205 {
1206         int err;
1207
1208         err = dsa_switch_parse_member_of(ds, dn);
1209         if (err)
1210                 return err;
1211
1212         err = dsa_switch_touch_ports(ds);
1213         if (err)
1214                 return err;
1215
1216         return dsa_switch_parse_ports_of(ds, dn);
1217 }
1218
1219 static int dsa_port_parse(struct dsa_port *dp, const char *name,
1220                           struct device *dev)
1221 {
1222         if (!strcmp(name, "cpu")) {
1223                 struct net_device *master;
1224
1225                 master = dsa_dev_to_net_device(dev);
1226                 if (!master)
1227                         return -EPROBE_DEFER;
1228
1229                 dev_put(master);
1230
1231                 return dsa_port_parse_cpu(dp, master);
1232         }
1233
1234         if (!strcmp(name, "dsa"))
1235                 return dsa_port_parse_dsa(dp);
1236
1237         return dsa_port_parse_user(dp, name);
1238 }
1239
1240 static int dsa_switch_parse_ports(struct dsa_switch *ds,
1241                                   struct dsa_chip_data *cd)
1242 {
1243         bool valid_name_found = false;
1244         struct dsa_port *dp;
1245         struct device *dev;
1246         const char *name;
1247         unsigned int i;
1248         int err;
1249
1250         for (i = 0; i < DSA_MAX_PORTS; i++) {
1251                 name = cd->port_names[i];
1252                 dev = cd->netdev[i];
1253                 dp = dsa_to_port(ds, i);
1254
1255                 if (!name)
1256                         continue;
1257
1258                 err = dsa_port_parse(dp, name, dev);
1259                 if (err)
1260                         return err;
1261
1262                 valid_name_found = true;
1263         }
1264
1265         if (!valid_name_found && i == DSA_MAX_PORTS)
1266                 return -EINVAL;
1267
1268         return 0;
1269 }
1270
1271 static int dsa_switch_parse(struct dsa_switch *ds, struct dsa_chip_data *cd)
1272 {
1273         int err;
1274
1275         ds->cd = cd;
1276
1277         /* We don't support interconnected switches nor multiple trees via
1278          * platform data, so this is the unique switch of the tree.
1279          */
1280         ds->index = 0;
1281         ds->dst = dsa_tree_touch(0);
1282         if (!ds->dst)
1283                 return -ENOMEM;
1284
1285         err = dsa_switch_touch_ports(ds);
1286         if (err)
1287                 return err;
1288
1289         return dsa_switch_parse_ports(ds, cd);
1290 }
1291
1292 static void dsa_switch_release_ports(struct dsa_switch *ds)
1293 {
1294         struct dsa_switch_tree *dst = ds->dst;
1295         struct dsa_port *dp, *next;
1296
1297         list_for_each_entry_safe(dp, next, &dst->ports, list) {
1298                 if (dp->ds != ds)
1299                         continue;
1300                 list_del(&dp->list);
1301                 kfree(dp);
1302         }
1303 }
1304
1305 static int dsa_switch_probe(struct dsa_switch *ds)
1306 {
1307         struct dsa_switch_tree *dst;
1308         struct dsa_chip_data *pdata;
1309         struct device_node *np;
1310         int err;
1311
1312         if (!ds->dev)
1313                 return -ENODEV;
1314
1315         pdata = ds->dev->platform_data;
1316         np = ds->dev->of_node;
1317
1318         if (!ds->num_ports)
1319                 return -EINVAL;
1320
1321         if (np) {
1322                 err = dsa_switch_parse_of(ds, np);
1323                 if (err)
1324                         dsa_switch_release_ports(ds);
1325         } else if (pdata) {
1326                 err = dsa_switch_parse(ds, pdata);
1327                 if (err)
1328                         dsa_switch_release_ports(ds);
1329         } else {
1330                 err = -ENODEV;
1331         }
1332
1333         if (err)
1334                 return err;
1335
1336         dst = ds->dst;
1337         dsa_tree_get(dst);
1338         err = dsa_tree_setup(dst);
1339         if (err) {
1340                 dsa_switch_release_ports(ds);
1341                 dsa_tree_put(dst);
1342         }
1343
1344         return err;
1345 }
1346
1347 int dsa_register_switch(struct dsa_switch *ds)
1348 {
1349         int err;
1350
1351         mutex_lock(&dsa2_mutex);
1352         err = dsa_switch_probe(ds);
1353         dsa_tree_put(ds->dst);
1354         mutex_unlock(&dsa2_mutex);
1355
1356         return err;
1357 }
1358 EXPORT_SYMBOL_GPL(dsa_register_switch);
1359
1360 static void dsa_switch_remove(struct dsa_switch *ds)
1361 {
1362         struct dsa_switch_tree *dst = ds->dst;
1363
1364         dsa_tree_teardown(dst);
1365         dsa_switch_release_ports(ds);
1366         dsa_tree_put(dst);
1367 }
1368
1369 void dsa_unregister_switch(struct dsa_switch *ds)
1370 {
1371         mutex_lock(&dsa2_mutex);
1372         dsa_switch_remove(ds);
1373         mutex_unlock(&dsa2_mutex);
1374 }
1375 EXPORT_SYMBOL_GPL(dsa_unregister_switch);