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                 return err;
 277         }
 278
 279         return 0;
 280 }
 281
 282 static void dsa_user_port_unapply(struct device_node *port, u32 index,
 283                                   struct dsa_switch *ds)
 284 {
 285         if (ds->ports[index].netdev) {
 286                 dsa_slave_destroy(ds->ports[index].netdev);
 287                 ds->ports[index].netdev = NULL;
 288                 ds->enabled_port_mask &= ~(1 << index);
 289         }
 290 }
 291
 292 static int dsa_ds_apply(struct dsa_switch_tree *dst, struct dsa_switch *ds)
 293 {
 294         struct device_node *port;
 295         u32 index;
 296         int err;
 297
 298         /* Initialize ds->phys_mii_mask before registering the slave MDIO bus
 299          * driver and before ops->setup() has run, since the switch drivers and
 300          * the slave MDIO bus driver rely on these values for probing PHY
 301          * devices or not
 302          */
 303         ds->phys_mii_mask = ds->enabled_port_mask;
 304
 305         err = ds->ops->setup(ds);
 306         if (err < 0)
 307                 return err;
 308
 309         if (ds->ops->set_addr) {
 310                 err = ds->ops->set_addr(ds, dst->master_netdev->dev_addr);
 311                 if (err < 0)
 312                         return err;
 313         }
 314
 315         if (!ds->slave_mii_bus && ds->ops->phy_read) {
 316                 ds->slave_mii_bus = devm_mdiobus_alloc(ds->dev);
 317                 if (!ds->slave_mii_bus)
 318                         return -ENOMEM;
 319
 320                 dsa_slave_mii_bus_init(ds);
 321
 322                 err = mdiobus_register(ds->slave_mii_bus);
 323                 if (err < 0)
 324                         return err;
 325         }
 326
 327         for (index = 0; index < DSA_MAX_PORTS; index++) {
 328                 port = ds->ports[index].dn;
 329                 if (!port)
 330                         continue;
 331
 332                 if (dsa_port_is_dsa(port)) {
 333                         err = dsa_dsa_port_apply(port, index, ds);
 334                         if (err)
 335                                 return err;
 336                         continue;
 337                 }
 338
 339                 if (dsa_port_is_cpu(port)) {
 340                         err = dsa_cpu_port_apply(port, index, ds);
 341                         if (err)
 342                                 return err;
 343                         continue;
 344                 }
 345
 346                 err = dsa_user_port_apply(port, index, ds);
 347                 if (err)
 348                         continue;
 349         }
 350
 351         return 0;
 352 }
 353
 354 static void dsa_ds_unapply(struct dsa_switch_tree *dst, struct dsa_switch *ds)
 355 {
 356         struct device_node *port;
 357         u32 index;
 358
 359         for (index = 0; index < DSA_MAX_PORTS; index++) {
 360                 port = ds->ports[index].dn;
 361                 if (!port)
 362                         continue;
 363
 364                 if (dsa_port_is_dsa(port)) {
 365                         dsa_dsa_port_unapply(port, index, ds);
 366                         continue;
 367                 }
 368
 369                 if (dsa_port_is_cpu(port)) {
 370                         dsa_cpu_port_unapply(port, index, ds);
 371                         continue;
 372                 }
 373
 374                 dsa_user_port_unapply(port, index, ds);
 375         }
 376
 377         if (ds->slave_mii_bus && ds->ops->phy_read)
 378                 mdiobus_unregister(ds->slave_mii_bus);
 379 }
 380
 381 static int dsa_dst_apply(struct dsa_switch_tree *dst)
 382 {
 383         struct dsa_switch *ds;
 384         u32 index;
 385         int err;
 386
 387         for (index = 0; index < DSA_MAX_SWITCHES; index++) {
 388                 ds = dst->ds[index];
 389                 if (!ds)
 390                         continue;
 391
 392                 err = dsa_ds_apply(dst, ds);
 393                 if (err)
 394                         return err;
 395         }
 396
 397         if (dst->ds[0]) {
 398                 err = dsa_cpu_port_ethtool_setup(dst->ds[0]);
 399                 if (err)
 400                         return err;
 401         }
 402
 403         /* If we use a tagging format that doesn't have an ethertype
 404          * field, make sure that all packets from this point on get
 405          * sent to the tag format's receive function.
 406          */
 407         wmb();
 408         dst->master_netdev->dsa_ptr = (void *)dst;
 409         dst->applied = true;
 410
 411         return 0;
 412 }
 413
 414 static void dsa_dst_unapply(struct dsa_switch_tree *dst)
 415 {
 416         struct dsa_switch *ds;
 417         u32 index;
 418
 419         if (!dst->applied)
 420                 return;
 421
 422         dst->master_netdev->dsa_ptr = NULL;
 423
 424         /* If we used a tagging format that doesn't have an ethertype
 425          * field, make sure that all packets from this point get sent
 426          * without the tag and go through the regular receive path.
 427          */
 428         wmb();
 429
 430         for (index = 0; index < DSA_MAX_SWITCHES; index++) {
 431                 ds = dst->ds[index];
 432                 if (!ds)
 433                         continue;
 434
 435                 dsa_ds_unapply(dst, ds);
 436         }
 437
 438         if (dst->ds[0])
 439                 dsa_cpu_port_ethtool_restore(dst->ds[0]);
 440
 441         pr_info("DSA: tree %d unapplied\n", dst->tree);
 442         dst->applied = false;
 443 }
 444
 445 static int dsa_cpu_parse(struct device_node *port, u32 index,
 446                          struct dsa_switch_tree *dst,
 447                          struct dsa_switch *ds)
 448 {
 449         enum dsa_tag_protocol tag_protocol;
 450         struct net_device *ethernet_dev;
 451         struct device_node *ethernet;
 452
 453         ethernet = of_parse_phandle(port, "ethernet", 0);
 454         if (!ethernet)
 455                 return -EINVAL;
 456
 457         ethernet_dev = of_find_net_device_by_node(ethernet);
 458         if (!ethernet_dev)
 459                 return -EPROBE_DEFER;
 460
 461         if (!ds->master_netdev)
 462                 ds->master_netdev = ethernet_dev;
 463
 464         if (!dst->master_netdev)
 465                 dst->master_netdev = ethernet_dev;
 466
 467         if (dst->cpu_switch == -1) {
 468                 dst->cpu_switch = ds->index;
 469                 dst->cpu_port = index;
 470         }
 471
 472         tag_protocol = ds->ops->get_tag_protocol(ds);
 473         dst->tag_ops = dsa_resolve_tag_protocol(tag_protocol);
 474         if (IS_ERR(dst->tag_ops)) {
 475                 dev_warn(ds->dev, "No tagger for this switch\n");
 476                 return PTR_ERR(dst->tag_ops);
 477         }
 478
 479         dst->rcv = dst->tag_ops->rcv;
 480
 481         return 0;
 482 }
 483
 484 static int dsa_ds_parse(struct dsa_switch_tree *dst, struct dsa_switch *ds)
 485 {
 486         struct device_node *port;
 487         u32 index;
 488         int err;
 489
 490         for (index = 0; index < DSA_MAX_PORTS; index++) {
 491                 port = ds->ports[index].dn;
 492                 if (!port)
 493                         continue;
 494
 495                 if (dsa_port_is_cpu(port)) {
 496                         err = dsa_cpu_parse(port, index, dst, ds);
 497                         if (err)
 498                                 return err;
 499                 }
 500         }
 501
 502         pr_info("DSA: switch %d %d parsed\n", dst->tree, ds->index);
 503
 504         return 0;
 505 }
 506
 507 static int dsa_dst_parse(struct dsa_switch_tree *dst)
 508 {
 509         struct dsa_switch *ds;
 510         u32 index;
 511         int err;
 512
 513         for (index = 0; index < DSA_MAX_SWITCHES; index++) {
 514                 ds = dst->ds[index];
 515                 if (!ds)
 516                         continue;
 517
 518                 err = dsa_ds_parse(dst, ds);
 519                 if (err)
 520                         return err;
 521         }
 522
 523         if (!dst->master_netdev) {
 524                 pr_warn("Tree has no master device\n");
 525                 return -EINVAL;
 526         }
 527
 528         pr_info("DSA: tree %d parsed\n", dst->tree);
 529
 530         return 0;
 531 }
 532
 533 static int dsa_parse_ports_dn(struct device_node *ports, struct dsa_switch *ds)
 534 {
 535         struct device_node *port;
 536         int err;
 537         u32 reg;
 538
 539         for_each_available_child_of_node(ports, port) {
 540                 err = of_property_read_u32(port, "reg", &reg);
 541                 if (err)
 542                         return err;
 543
 544                 if (reg >= DSA_MAX_PORTS)
 545                         return -EINVAL;
 546
 547                 ds->ports[reg].dn = port;
 548
 549                 /* Initialize enabled_port_mask now for ops->setup()
 550                  * to have access to a correct value, just like what
 551                  * net/dsa/dsa.c::dsa_switch_setup_one does.
 552                  */
 553                 if (!dsa_port_is_cpu(port))
 554                         ds->enabled_port_mask |= 1 << reg;
 555         }
 556
 557         return 0;
 558 }
 559
 560 static int dsa_parse_member(struct device_node *np, u32 *tree, u32 *index)
 561 {
 562         int err;
 563
 564         *tree = *index = 0;
 565
 566         err = of_property_read_u32_index(np, "dsa,member", 0, tree);
 567         if (err) {
 568                 /* Does not exist, but it is optional */
 569                 if (err == -EINVAL)
 570                         return 0;
 571                 return err;
 572         }
 573
 574         err = of_property_read_u32_index(np, "dsa,member", 1, index);
 575         if (err)
 576                 return err;
 577
 578         if (*index >= DSA_MAX_SWITCHES)
 579                 return -EINVAL;
 580
 581         return 0;
 582 }
 583
 584 static struct device_node *dsa_get_ports(struct dsa_switch *ds,
 585                                          struct device_node *np)
 586 {
 587         struct device_node *ports;
 588
 589         ports = of_get_child_by_name(np, "ports");
 590         if (!ports) {
 591                 dev_err(ds->dev, "no ports child node found\n");
 592                 return ERR_PTR(-EINVAL);
 593         }
 594
 595         return ports;
 596 }
 597
 598 static int _dsa_register_switch(struct dsa_switch *ds, struct device_node *np)
 599 {
 600         struct device_node *ports = dsa_get_ports(ds, np);
 601         struct dsa_switch_tree *dst;
 602         u32 tree, index;
 603         int i, err;
 604
 605         err = dsa_parse_member(np, &tree, &index);
 606         if (err)
 607                 return err;
 608
 609         if (IS_ERR(ports))
 610                 return PTR_ERR(ports);
 611
 612         err = dsa_parse_ports_dn(ports, ds);
 613         if (err)
 614                 return err;
 615
 616         dst = dsa_get_dst(tree);
 617         if (!dst) {
 618                 dst = dsa_add_dst(tree);
 619                 if (!dst)
 620                         return -ENOMEM;
 621         }
 622
 623         if (dst->ds[index]) {
 624                 err = -EBUSY;
 625                 goto out;
 626         }
 627
 628         ds->dst = dst;
 629         ds->index = index;
 630
 631         /* Initialize the routing table */
 632         for (i = 0; i < DSA_MAX_SWITCHES; ++i)
 633                 ds->rtable[i] = DSA_RTABLE_NONE;
 634
 635         dsa_dst_add_ds(dst, ds, index);
 636
 637         err = dsa_dst_complete(dst);
 638         if (err < 0)
 639                 goto out_del_dst;
 640
 641         if (err == 1) {
 642                 /* Not all switches registered yet */
 643                 err = 0;
 644                 goto out;
 645         }
 646
 647         if (dst->applied) {
 648                 pr_info("DSA: Disjoint trees?\n");
 649                 return -EINVAL;
 650         }
 651
 652         err = dsa_dst_parse(dst);
 653         if (err)
 654                 goto out_del_dst;
 655
 656         err = dsa_dst_apply(dst);
 657         if (err) {
 658                 dsa_dst_unapply(dst);
 659                 goto out_del_dst;
 660         }
 661
 662         dsa_put_dst(dst);
 663         return 0;
 664
 665 out_del_dst:
 666         dsa_dst_del_ds(dst, ds, ds->index);
 667 out:
 668         dsa_put_dst(dst);
 669
 670         return err;
 671 }
 672
 673 int dsa_register_switch(struct dsa_switch *ds, struct device_node *np)
 674 {
 675         int err;
 676
 677         mutex_lock(&dsa2_mutex);
 678         err = _dsa_register_switch(ds, np);
 679         mutex_unlock(&dsa2_mutex);
 680
 681         return err;
 682 }
 683 EXPORT_SYMBOL_GPL(dsa_register_switch);
 684
 685 static void _dsa_unregister_switch(struct dsa_switch *ds)
 686 {
 687         struct dsa_switch_tree *dst = ds->dst;
 688
 689         dsa_dst_unapply(dst);
 690
 691         dsa_dst_del_ds(dst, ds, ds->index);
 692 }
 693
 694 void dsa_unregister_switch(struct dsa_switch *ds)
 695 {
 696         mutex_lock(&dsa2_mutex);
 697         _dsa_unregister_switch(ds);
 698         mutex_unlock(&dsa2_mutex);
 699 }
 700 EXPORT_SYMBOL_GPL(dsa_unregister_switch);