net/dsa/dsa2.c

   1 /*
   2  * net/dsa/dsa2.c - Hardware switch handling, binding version 2
   3  * Copyright (c) 2008-2009 Marvell Semiconductor
   4  * Copyright (c) 2013 Florian Fainelli <florian@openwrt.org>
   5  * Copyright (c) 2016 Andrew Lunn <andrew@lunn.ch>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  */
  12
  13 #include <linux/device.h>
  14 #include <linux/err.h>
  15 #include <linux/list.h>
  16 #include <linux/slab.h>
  17 #include <linux/rtnetlink.h>
  18 #include <net/dsa.h>
  19 #include <linux/of.h>
  20 #include <linux/of_net.h>
  21 #include "dsa_priv.h"
  22
  23 static LIST_HEAD(dsa_switch_trees);
  24 static DEFINE_MUTEX(dsa2_mutex);
  25
  26 static struct dsa_switch_tree *dsa_get_dst(u32 tree)
  27 {
  28         struct dsa_switch_tree *dst;
  29
  30         list_for_each_entry(dst, &dsa_switch_trees, list)
  31                 if (dst->tree == tree) {
  32                         kref_get(&dst->refcount);
  33                         return dst;
  34                 }
  35         return NULL;
  36 }
  37
  38 static void dsa_free_dst(struct kref *ref)
  39 {
  40         struct dsa_switch_tree *dst = container_of(ref, struct dsa_switch_tree,
  41                                                    refcount);
  42
  43         list_del(&dst->list);
  44         kfree(dst);
  45 }
  46
  47 static void dsa_put_dst(struct dsa_switch_tree *dst)
  48 {
  49         kref_put(&dst->refcount, dsa_free_dst);
  50 }
  51
  52 static struct dsa_switch_tree *dsa_add_dst(u32 tree)
  53 {
  54         struct dsa_switch_tree *dst;
  55
  56         dst = kzalloc(sizeof(*dst), GFP_KERNEL);
  57         if (!dst)
  58                 return NULL;
  59         dst->tree = tree;
  60         dst->cpu_switch = -1;
  61         INIT_LIST_HEAD(&dst->list);
  62         list_add_tail(&dsa_switch_trees, &dst->list);
  63         kref_init(&dst->refcount);
  64
  65         return dst;
  66 }
  67
  68 static void dsa_dst_add_ds(struct dsa_switch_tree *dst,
  69                            struct dsa_switch *ds, u32 index)
  70 {
  71         kref_get(&dst->refcount);
  72         dst->ds[index] = ds;
  73 }
  74
  75 static void dsa_dst_del_ds(struct dsa_switch_tree *dst,
  76                            struct dsa_switch *ds, u32 index)
  77 {
  78         dst->ds[index] = NULL;
  79         kref_put(&dst->refcount, dsa_free_dst);
  80 }
  81
  82 static bool dsa_port_is_dsa(struct device_node *port)
  83 {
  84         const char *name;
  85
  86         name = of_get_property(port, "label", NULL);
  87         if (!name)
  88                 return false;
  89
  90         if (!strcmp(name, "dsa"))
  91                 return true;
  92
  93         return false;
  94 }
  95
  96 static bool dsa_port_is_cpu(struct device_node *port)
  97 {
  98         const char *name;
  99
 100         name = of_get_property(port, "label", NULL);
 101         if (!name)
 102                 return false;
 103
 104         if (!strcmp(name, "cpu"))
 105                 return true;
 106
 107         return false;
 108 }
 109
 110 static bool dsa_ds_find_port(struct dsa_switch *ds,
 111                              struct device_node *port)
 112 {
 113         u32 index;
 114
 115         for (index = 0; index < DSA_MAX_PORTS; index++)
 116                 if (ds->ports[index].dn == port)
 117                         return true;
 118         return false;
 119 }
 120
 121 static struct dsa_switch *dsa_dst_find_port(struct dsa_switch_tree *dst,
 122                                             struct device_node *port)
 123 {
 124         struct dsa_switch *ds;
 125         u32 index;
 126
 127         for (index = 0; index < DSA_MAX_SWITCHES; index++) {
 128                 ds = dst->ds[index];
 129                 if (!ds)
 130                         continue;
 131
 132                 if (dsa_ds_find_port(ds, port))
 133                         return ds;
 134         }
 135
 136         return NULL;
 137 }
 138
 139 static int dsa_port_complete(struct dsa_switch_tree *dst,
 140                              struct dsa_switch *src_ds,
 141                              struct device_node *port,
 142                              u32 src_port)
 143 {
 144         struct device_node *link;
 145         int index;
 146         struct dsa_switch *dst_ds;
 147
 148         for (index = 0;; index++) {
 149                 link = of_parse_phandle(port, "link", index);
 150                 if (!link)
 151                         break;
 152
 153                 dst_ds = dsa_dst_find_port(dst, link);
 154                 of_node_put(link);
 155
 156                 if (!dst_ds)
 157                         return 1;
 158
 159                 src_ds->rtable[dst_ds->index] = src_port;
 160         }
 161
 162         return 0;
 163 }
 164
 165 /* A switch is complete if all the DSA ports phandles point to ports
 166  * known in the tree. A return value of 1 means the tree is not
 167  * complete. This is not an error condition. A value of 0 is
 168  * success.
 169  */
 170 static int dsa_ds_complete(struct dsa_switch_tree *dst, struct dsa_switch *ds)
 171 {
 172         struct device_node *port;
 173         u32 index;
 174         int err;
 175
 176         for (index = 0; index < DSA_MAX_PORTS; index++) {
 177                 port = ds->ports[index].dn;
 178                 if (!port)
 179                         continue;
 180
 181                 if (!dsa_port_is_dsa(port))
 182                         continue;
 183
 184                 err = dsa_port_complete(dst, ds, port, index);
 185                 if (err != 0)
 186                         return err;
 187
 188                 ds->dsa_port_mask |= BIT(index);
 189         }
 190
 191         return 0;
 192 }
 193
 194 /* A tree is complete if all the DSA ports phandles point to ports
 195  * known in the tree. A return value of 1 means the tree is not
 196  * complete. This is not an error condition. A value of 0 is
 197  * success.
 198  */
 199 static int dsa_dst_complete(struct dsa_switch_tree *dst)
 200 {
 201         struct dsa_switch *ds;
 202         u32 index;
 203         int err;
 204
 205         for (index = 0; index < DSA_MAX_SWITCHES; index++) {
 206                 ds = dst->ds[index];
 207                 if (!ds)
 208                         continue;
 209
 210                 err = dsa_ds_complete(dst, ds);
 211                 if (err != 0)
 212                         return err;
 213         }
 214
 215         return 0;
 216 }
 217
 218 static int dsa_dsa_port_apply(struct device_node *port, u32 index,
 219                               struct dsa_switch *ds)
 220 {
 221         int err;
 222
 223         err = dsa_cpu_dsa_setup(ds, ds->dev, port, index);
 224         if (err) {
 225                 dev_warn(ds->dev, "Failed to setup dsa port %d: %d\n",
 226                          index, err);
 227                 return err;
 228         }
 229
 230         return 0;
 231 }
 232
 233 static void dsa_dsa_port_unapply(struct device_node *port, u32 index,
 234                                  struct dsa_switch *ds)
 235 {
 236         dsa_cpu_dsa_destroy(port);
 237 }
 238
 239 static int dsa_cpu_port_apply(struct device_node *port, u32 index,
 240                               struct dsa_switch *ds)
 241 {
 242         int err;
 243
 244         err = dsa_cpu_dsa_setup(ds, ds->dev, port, index);
 245         if (err) {
 246                 dev_warn(ds->dev, "Failed to setup cpu port %d: %d\n",
 247                          index, err);
 248                 return err;
 249         }
 250
 251         ds->cpu_port_mask |= BIT(index);
 252
 253         return 0;
 254 }
 255
 256 static void dsa_cpu_port_unapply(struct device_node *port, u32 index,
 257                                  struct dsa_switch *ds)
 258 {
 259         dsa_cpu_dsa_destroy(port);
 260         ds->cpu_port_mask &= ~BIT(index);
 261
 262 }
 263
 264 static int dsa_user_port_apply(struct device_node *port, u32 index,
 265                                struct dsa_switch *ds)
 266 {
 267         const char *name;
 268         int err;
 269
 270         name = of_get_property(port, "label", NULL);
 271
 272         err = dsa_slave_create(ds, ds->dev, index, name);
 273         if (err) {
 274                 dev_warn(ds->dev, "Failed to create slave %d: %d\n",
 275                          index, err);
 276                 ds->ports[index].netdev = NULL;
 277                 return err;
 278         }
 279
 280         return 0;
 281 }
 282
 283 static void dsa_user_port_unapply(struct device_node *port, u32 index,
 284                                   struct dsa_switch *ds)
 285 {
 286         if (ds->ports[index].netdev) {
 287                 dsa_slave_destroy(ds->ports[index].netdev);
 288                 ds->ports[index].netdev = NULL;
 289                 ds->enabled_port_mask &= ~(1 << index);
 290         }
 291 }
 292
 293 static int dsa_ds_apply(struct dsa_switch_tree *dst, struct dsa_switch *ds)
 294 {
 295         struct device_node *port;
 296         u32 index;
 297         int err;
 298
 299         /* Initialize ds->phys_mii_mask before registering the slave MDIO bus
 300          * driver and before ops->setup() has run, since the switch drivers and
 301          * the slave MDIO bus driver rely on these values for probing PHY
 302          * devices or not
 303          */
 304         ds->phys_mii_mask = ds->enabled_port_mask;
 305
 306         err = ds->ops->setup(ds);
 307         if (err < 0)
 308                 return err;
 309
 310         if (ds->ops->set_addr) {
 311                 err = ds->ops->set_addr(ds, dst->master_netdev->dev_addr);
 312                 if (err < 0)
 313                         return err;
 314         }
 315
 316         if (!ds->slave_mii_bus && ds->ops->phy_read) {
 317                 ds->slave_mii_bus = devm_mdiobus_alloc(ds->dev);
 318                 if (!ds->slave_mii_bus)
 319                         return -ENOMEM;
 320
 321                 dsa_slave_mii_bus_init(ds);
 322
 323                 err = mdiobus_register(ds->slave_mii_bus);
 324                 if (err < 0)
 325                         return err;
 326         }
 327
 328         for (index = 0; index < DSA_MAX_PORTS; index++) {
 329                 port = ds->ports[index].dn;
 330                 if (!port)
 331                         continue;
 332
 333                 if (dsa_port_is_dsa(port)) {
 334                         err = dsa_dsa_port_apply(port, index, ds);
 335                         if (err)
 336                                 return err;
 337                         continue;
 338                 }
 339
 340                 if (dsa_port_is_cpu(port)) {
 341                         err = dsa_cpu_port_apply(port, index, ds);
 342                         if (err)
 343                                 return err;
 344                         continue;
 345                 }
 346
 347                 err = dsa_user_port_apply(port, index, ds);
 348                 if (err)
 349                         continue;
 350         }
 351
 352         return 0;
 353 }
 354
 355 static void dsa_ds_unapply(struct dsa_switch_tree *dst, struct dsa_switch *ds)
 356 {
 357         struct device_node *port;
 358         u32 index;
 359
 360         for (index = 0; index < DSA_MAX_PORTS; index++) {
 361                 port = ds->ports[index].dn;
 362                 if (!port)
 363                         continue;
 364
 365                 if (dsa_port_is_dsa(port)) {
 366                         dsa_dsa_port_unapply(port, index, ds);
 367                         continue;
 368                 }
 369
 370                 if (dsa_port_is_cpu(port)) {
 371                         dsa_cpu_port_unapply(port, index, ds);
 372                         continue;
 373                 }
 374
 375                 dsa_user_port_unapply(port, index, ds);
 376         }
 377
 378         if (ds->slave_mii_bus && ds->ops->phy_read)
 379                 mdiobus_unregister(ds->slave_mii_bus);
 380 }
 381
 382 static int dsa_dst_apply(struct dsa_switch_tree *dst)
 383 {
 384         struct dsa_switch *ds;
 385         u32 index;
 386         int err;
 387
 388         for (index = 0; index < DSA_MAX_SWITCHES; index++) {
 389                 ds = dst->ds[index];
 390                 if (!ds)
 391                         continue;
 392
 393                 err = dsa_ds_apply(dst, ds);
 394                 if (err)
 395                         return err;
 396         }
 397
 398         if (dst->ds[0]) {
 399                 err = dsa_cpu_port_ethtool_setup(dst->ds[0]);
 400                 if (err)
 401                         return err;
 402         }
 403
 404         /* If we use a tagging format that doesn't have an ethertype
 405          * field, make sure that all packets from this point on get
 406          * sent to the tag format's receive function.
 407          */
 408         wmb();
 409         dst->master_netdev->dsa_ptr = (void *)dst;
 410         dst->applied = true;
 411
 412         return 0;
 413 }
 414
 415 static void dsa_dst_unapply(struct dsa_switch_tree *dst)
 416 {
 417         struct dsa_switch *ds;
 418         u32 index;
 419
 420         if (!dst->applied)
 421                 return;
 422
 423         dst->master_netdev->dsa_ptr = NULL;
 424
 425         /* If we used a tagging format that doesn't have an ethertype
 426          * field, make sure that all packets from this point get sent
 427          * without the tag and go through the regular receive path.
 428          */
 429         wmb();
 430
 431         for (index = 0; index < DSA_MAX_SWITCHES; index++) {
 432                 ds = dst->ds[index];
 433                 if (!ds)
 434                         continue;
 435
 436                 dsa_ds_unapply(dst, ds);
 437         }
 438
 439         if (dst->ds[0])
 440                 dsa_cpu_port_ethtool_restore(dst->ds[0]);
 441
 442         pr_info("DSA: tree %d unapplied\n", dst->tree);
 443         dst->applied = false;
 444 }
 445
 446 static int dsa_cpu_parse(struct device_node *port, u32 index,
 447                          struct dsa_switch_tree *dst,
 448                          struct dsa_switch *ds)
 449 {
 450         enum dsa_tag_protocol tag_protocol;
 451         struct net_device *ethernet_dev;
 452         struct device_node *ethernet;
 453
 454         ethernet = of_parse_phandle(port, "ethernet", 0);
 455         if (!ethernet)
 456                 return -EINVAL;
 457
 458         ethernet_dev = of_find_net_device_by_node(ethernet);
 459         if (!ethernet_dev)
 460                 return -EPROBE_DEFER;
 461
 462         if (!ds->master_netdev)
 463                 ds->master_netdev = ethernet_dev;
 464
 465         if (!dst->master_netdev)
 466                 dst->master_netdev = ethernet_dev;
 467
 468         if (dst->cpu_switch == -1) {
 469                 dst->cpu_switch = ds->index;
 470                 dst->cpu_port = index;
 471         }
 472
 473         tag_protocol = ds->ops->get_tag_protocol(ds);
 474         dst->tag_ops = dsa_resolve_tag_protocol(tag_protocol);
 475         if (IS_ERR(dst->tag_ops)) {
 476                 dev_warn(ds->dev, "No tagger for this switch\n");
 477                 return PTR_ERR(dst->tag_ops);
 478         }
 479
 480         dst->rcv = dst->tag_ops->rcv;
 481
 482         return 0;
 483 }
 484
 485 static int dsa_ds_parse(struct dsa_switch_tree *dst, struct dsa_switch *ds)
 486 {
 487         struct device_node *port;
 488         u32 index;
 489         int err;
 490
 491         for (index = 0; index < DSA_MAX_PORTS; index++) {
 492                 port = ds->ports[index].dn;
 493                 if (!port)
 494                         continue;
 495
 496                 if (dsa_port_is_cpu(port)) {
 497                         err = dsa_cpu_parse(port, index, dst, ds);
 498                         if (err)
 499                                 return err;
 500                 }
 501         }
 502
 503         pr_info("DSA: switch %d %d parsed\n", dst->tree, ds->index);
 504
 505         return 0;
 506 }
 507
 508 static int dsa_dst_parse(struct dsa_switch_tree *dst)
 509 {
 510         struct dsa_switch *ds;
 511         u32 index;
 512         int err;
 513
 514         for (index = 0; index < DSA_MAX_SWITCHES; index++) {
 515                 ds = dst->ds[index];
 516                 if (!ds)
 517                         continue;
 518
 519                 err = dsa_ds_parse(dst, ds);
 520                 if (err)
 521                         return err;
 522         }
 523
 524         if (!dst->master_netdev) {
 525                 pr_warn("Tree has no master device\n");
 526                 return -EINVAL;
 527         }
 528
 529         pr_info("DSA: tree %d parsed\n", dst->tree);
 530
 531         return 0;
 532 }
 533
 534 static int dsa_parse_ports_dn(struct device_node *ports, struct dsa_switch *ds)
 535 {
 536         struct device_node *port;
 537         int err;
 538         u32 reg;
 539
 540         for_each_available_child_of_node(ports, port) {
 541                 err = of_property_read_u32(port, "reg", &reg);
 542                 if (err)
 543                         return err;
 544
 545                 if (reg >= DSA_MAX_PORTS)
 546                         return -EINVAL;
 547
 548                 ds->ports[reg].dn = port;
 549
 550                 /* Initialize enabled_port_mask now for ops->setup()
 551                  * to have access to a correct value, just like what
 552                  * net/dsa/dsa.c::dsa_switch_setup_one does.
 553                  */
 554                 if (!dsa_port_is_cpu(port))
 555                         ds->enabled_port_mask |= 1 << reg;
 556         }
 557
 558         return 0;
 559 }
 560
 561 static int dsa_parse_member(struct device_node *np, u32 *tree, u32 *index)
 562 {
 563         int err;
 564
 565         *tree = *index = 0;
 566
 567         err = of_property_read_u32_index(np, "dsa,member", 0, tree);
 568         if (err) {
 569                 /* Does not exist, but it is optional */
 570                 if (err == -EINVAL)
 571                         return 0;
 572                 return err;
 573         }
 574
 575         err = of_property_read_u32_index(np, "dsa,member", 1, index);
 576         if (err)
 577                 return err;
 578
 579         if (*index >= DSA_MAX_SWITCHES)
 580                 return -EINVAL;
 581
 582         return 0;
 583 }
 584
 585 static struct device_node *dsa_get_ports(struct dsa_switch *ds,
 586                                          struct device_node *np)
 587 {
 588         struct device_node *ports;
 589
 590         ports = of_get_child_by_name(np, "ports");
 591         if (!ports) {
 592                 dev_err(ds->dev, "no ports child node found\n");
 593                 return ERR_PTR(-EINVAL);
 594         }
 595
 596         return ports;
 597 }
 598
 599 static int _dsa_register_switch(struct dsa_switch *ds, struct device_node *np)
 600 {
 601         struct device_node *ports = dsa_get_ports(ds, np);
 602         struct dsa_switch_tree *dst;
 603         u32 tree, index;
 604         int i, err;
 605
 606         err = dsa_parse_member(np, &tree, &index);
 607         if (err)
 608                 return err;
 609
 610         if (IS_ERR(ports))
 611                 return PTR_ERR(ports);
 612
 613         err = dsa_parse_ports_dn(ports, ds);
 614         if (err)
 615                 return err;
 616
 617         dst = dsa_get_dst(tree);
 618         if (!dst) {
 619                 dst = dsa_add_dst(tree);
 620                 if (!dst)
 621                         return -ENOMEM;
 622         }
 623
 624         if (dst->ds[index]) {
 625                 err = -EBUSY;
 626                 goto out;
 627         }
 628
 629         ds->dst = dst;
 630         ds->index = index;
 631
 632         /* Initialize the routing table */
 633         for (i = 0; i < DSA_MAX_SWITCHES; ++i)
 634                 ds->rtable[i] = DSA_RTABLE_NONE;
 635
 636         dsa_dst_add_ds(dst, ds, index);
 637
 638         err = dsa_dst_complete(dst);
 639         if (err < 0)
 640                 goto out_del_dst;
 641
 642         if (err == 1) {
 643                 /* Not all switches registered yet */
 644                 err = 0;
 645                 goto out;
 646         }
 647
 648         if (dst->applied) {
 649                 pr_info("DSA: Disjoint trees?\n");
 650                 return -EINVAL;
 651         }
 652
 653         err = dsa_dst_parse(dst);
 654         if (err)
 655                 goto out_del_dst;
 656
 657         err = dsa_dst_apply(dst);
 658         if (err) {
 659                 dsa_dst_unapply(dst);
 660                 goto out_del_dst;
 661         }
 662
 663         dsa_put_dst(dst);
 664         return 0;
 665
 666 out_del_dst:
 667         dsa_dst_del_ds(dst, ds, ds->index);
 668 out:
 669         dsa_put_dst(dst);
 670
 671         return err;
 672 }
 673
 674 int dsa_register_switch(struct dsa_switch *ds, struct device_node *np)
 675 {
 676         int err;
 677
 678         mutex_lock(&dsa2_mutex);
 679         err = _dsa_register_switch(ds, np);
 680         mutex_unlock(&dsa2_mutex);
 681
 682         return err;
 683 }
 684 EXPORT_SYMBOL_GPL(dsa_register_switch);
 685
 686 static void _dsa_unregister_switch(struct dsa_switch *ds)
 687 {
 688         struct dsa_switch_tree *dst = ds->dst;
 689
 690         dsa_dst_unapply(dst);
 691
 692         dsa_dst_del_ds(dst, ds, ds->index);
 693 }
 694
 695 void dsa_unregister_switch(struct dsa_switch *ds)
 696 {
 697         mutex_lock(&dsa2_mutex);
 698         _dsa_unregister_switch(ds);
 699         mutex_unlock(&dsa2_mutex);
 700 }
 701 EXPORT_SYMBOL_GPL(dsa_unregister_switch);