drivers/net/dsa/bcm_sf2.c

   1 /*
   2  * Broadcom Starfighter 2 DSA switch driver
   3  *
   4  * Copyright (C) 2014, Broadcom Corporation
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  */
  11
  12 #include <linux/list.h>
  13 #include <linux/module.h>
  14 #include <linux/netdevice.h>
  15 #include <linux/interrupt.h>
  16 #include <linux/platform_device.h>
  17 #include <linux/of.h>
  18 #include <linux/phy.h>
  19 #include <linux/phy_fixed.h>
  20 #include <linux/mii.h>
  21 #include <linux/of.h>
  22 #include <linux/of_irq.h>
  23 #include <linux/of_address.h>
  24 #include <linux/of_net.h>
  25 #include <linux/of_mdio.h>
  26 #include <net/dsa.h>
  27 #include <linux/ethtool.h>
  28 #include <linux/if_bridge.h>
  29 #include <linux/brcmphy.h>
  30 #include <linux/etherdevice.h>
  31 #include <linux/platform_data/b53.h>
  32
  33 #include "bcm_sf2.h"
  34 #include "bcm_sf2_regs.h"
  35 #include "b53/b53_priv.h"
  36 #include "b53/b53_regs.h"
  37
  38 static enum dsa_tag_protocol bcm_sf2_sw_get_tag_protocol(struct dsa_switch *ds)
  39 {
  40         return DSA_TAG_PROTO_BRCM;
  41 }
  42
  43 static void bcm_sf2_imp_vlan_setup(struct dsa_switch *ds, int cpu_port)
  44 {
  45         struct bcm_sf2_priv *priv = bcm_sf2_to_priv(ds);
  46         unsigned int i;
  47         u32 reg;
  48
  49         /* Enable the IMP Port to be in the same VLAN as the other ports
  50          * on a per-port basis such that we only have Port i and IMP in
  51          * the same VLAN.
  52          */
  53         for (i = 0; i < priv->hw_params.num_ports; i++) {
  54                 if (!((1 << i) & ds->enabled_port_mask))
  55                         continue;
  56
  57                 reg = core_readl(priv, CORE_PORT_VLAN_CTL_PORT(i));
  58                 reg |= (1 << cpu_port);
  59                 core_writel(priv, reg, CORE_PORT_VLAN_CTL_PORT(i));
  60         }
  61 }
  62
  63 static void bcm_sf2_brcm_hdr_setup(struct bcm_sf2_priv *priv, int port)
  64 {
  65         u32 reg, val;
  66
  67         /* Resolve which bit controls the Broadcom tag */
  68         switch (port) {
  69         case 8:
  70                 val = BRCM_HDR_EN_P8;
  71                 break;
  72         case 7:
  73                 val = BRCM_HDR_EN_P7;
  74                 break;
  75         case 5:
  76                 val = BRCM_HDR_EN_P5;
  77                 break;
  78         default:
  79                 val = 0;
  80                 break;
  81         }
  82
  83         /* Enable Broadcom tags for IMP port */
  84         reg = core_readl(priv, CORE_BRCM_HDR_CTRL);
  85         reg |= val;
  86         core_writel(priv, reg, CORE_BRCM_HDR_CTRL);
  87
  88         /* Enable reception Broadcom tag for CPU TX (switch RX) to
  89          * allow us to tag outgoing frames
  90          */
  91         reg = core_readl(priv, CORE_BRCM_HDR_RX_DIS);
  92         reg &= ~(1 << port);
  93         core_writel(priv, reg, CORE_BRCM_HDR_RX_DIS);
  94
  95         /* Enable transmission of Broadcom tags from the switch (CPU RX) to
  96          * allow delivering frames to the per-port net_devices
  97          */
  98         reg = core_readl(priv, CORE_BRCM_HDR_TX_DIS);
  99         reg &= ~(1 << port);
 100         core_writel(priv, reg, CORE_BRCM_HDR_TX_DIS);
 101 }
 102
 103 static void bcm_sf2_imp_setup(struct dsa_switch *ds, int port)
 104 {
 105         struct bcm_sf2_priv *priv = bcm_sf2_to_priv(ds);
 106         unsigned int i;
 107         u32 reg, offset;
 108
 109         /* Enable the port memories */
 110         reg = core_readl(priv, CORE_MEM_PSM_VDD_CTRL);
 111         reg &= ~P_TXQ_PSM_VDD(port);
 112         core_writel(priv, reg, CORE_MEM_PSM_VDD_CTRL);
 113
 114         /* Enable forwarding */
 115         core_writel(priv, SW_FWDG_EN, CORE_SWMODE);
 116
 117         /* Enable IMP port in dumb mode */
 118         reg = core_readl(priv, CORE_SWITCH_CTRL);
 119         reg |= MII_DUMB_FWDG_EN;
 120         core_writel(priv, reg, CORE_SWITCH_CTRL);
 121
 122         /* Configure Traffic Class to QoS mapping, allow each priority to map
 123          * to a different queue number
 124          */
 125         reg = core_readl(priv, CORE_PORT_TC2_QOS_MAP_PORT(port));
 126         for (i = 0; i < SF2_NUM_EGRESS_QUEUES; i++)
 127                 reg |= i << (PRT_TO_QID_SHIFT * i);
 128         core_writel(priv, reg, CORE_PORT_TC2_QOS_MAP_PORT(port));
 129
 130         bcm_sf2_brcm_hdr_setup(priv, port);
 131
 132         if (port == 8) {
 133                 if (priv->type == BCM7445_DEVICE_ID)
 134                         offset = CORE_STS_OVERRIDE_IMP;
 135                 else
 136                         offset = CORE_STS_OVERRIDE_IMP2;
 137
 138                 /* Force link status for IMP port */
 139                 reg = core_readl(priv, offset);
 140                 reg |= (MII_SW_OR | LINK_STS);
 141                 reg &= ~GMII_SPEED_UP_2G;
 142                 core_writel(priv, reg, offset);
 143
 144                 /* Enable Broadcast, Multicast, Unicast forwarding to IMP port */
 145                 reg = core_readl(priv, CORE_IMP_CTL);
 146                 reg |= (RX_BCST_EN | RX_MCST_EN | RX_UCST_EN);
 147                 reg &= ~(RX_DIS | TX_DIS);
 148                 core_writel(priv, reg, CORE_IMP_CTL);
 149         } else {
 150                 reg = core_readl(priv, CORE_G_PCTL_PORT(port));
 151                 reg &= ~(RX_DIS | TX_DIS);
 152                 core_writel(priv, reg, CORE_G_PCTL_PORT(port));
 153         }
 154 }
 155
 156 static void bcm_sf2_eee_enable_set(struct dsa_switch *ds, int port, bool enable)
 157 {
 158         struct bcm_sf2_priv *priv = bcm_sf2_to_priv(ds);
 159         u32 reg;
 160
 161         reg = core_readl(priv, CORE_EEE_EN_CTRL);
 162         if (enable)
 163                 reg |= 1 << port;
 164         else
 165                 reg &= ~(1 << port);
 166         core_writel(priv, reg, CORE_EEE_EN_CTRL);
 167 }
 168
 169 static void bcm_sf2_gphy_enable_set(struct dsa_switch *ds, bool enable)
 170 {
 171         struct bcm_sf2_priv *priv = bcm_sf2_to_priv(ds);
 172         u32 reg;
 173
 174         reg = reg_readl(priv, REG_SPHY_CNTRL);
 175         if (enable) {
 176                 reg |= PHY_RESET;
 177                 reg &= ~(EXT_PWR_DOWN | IDDQ_BIAS | IDDQ_GLOBAL_PWR | CK25_DIS);
 178                 reg_writel(priv, reg, REG_SPHY_CNTRL);
 179                 udelay(21);
 180                 reg = reg_readl(priv, REG_SPHY_CNTRL);
 181                 reg &= ~PHY_RESET;
 182         } else {
 183                 reg |= EXT_PWR_DOWN | IDDQ_BIAS | PHY_RESET;
 184                 reg_writel(priv, reg, REG_SPHY_CNTRL);
 185                 mdelay(1);
 186                 reg |= CK25_DIS;
 187         }
 188         reg_writel(priv, reg, REG_SPHY_CNTRL);
 189
 190         /* Use PHY-driven LED signaling */
 191         if (!enable) {
 192                 reg = reg_readl(priv, REG_LED_CNTRL(0));
 193                 reg |= SPDLNK_SRC_SEL;
 194                 reg_writel(priv, reg, REG_LED_CNTRL(0));
 195         }
 196 }
 197
 198 static inline void bcm_sf2_port_intr_enable(struct bcm_sf2_priv *priv,
 199                                             int port)
 200 {
 201         unsigned int off;
 202
 203         switch (port) {
 204         case 7:
 205                 off = P7_IRQ_OFF;
 206                 break;
 207         case 0:
 208                 /* Port 0 interrupts are located on the first bank */
 209                 intrl2_0_mask_clear(priv, P_IRQ_MASK(P0_IRQ_OFF));
 210                 return;
 211         default:
 212                 off = P_IRQ_OFF(port);
 213                 break;
 214         }
 215
 216         intrl2_1_mask_clear(priv, P_IRQ_MASK(off));
 217 }
 218
 219 static inline void bcm_sf2_port_intr_disable(struct bcm_sf2_priv *priv,
 220                                              int port)
 221 {
 222         unsigned int off;
 223
 224         switch (port) {
 225         case 7:
 226                 off = P7_IRQ_OFF;
 227                 break;
 228         case 0:
 229                 /* Port 0 interrupts are located on the first bank */
 230                 intrl2_0_mask_set(priv, P_IRQ_MASK(P0_IRQ_OFF));
 231                 intrl2_0_writel(priv, P_IRQ_MASK(P0_IRQ_OFF), INTRL2_CPU_CLEAR);
 232                 return;
 233         default:
 234                 off = P_IRQ_OFF(port);
 235                 break;
 236         }
 237
 238         intrl2_1_mask_set(priv, P_IRQ_MASK(off));
 239         intrl2_1_writel(priv, P_IRQ_MASK(off), INTRL2_CPU_CLEAR);
 240 }
 241
 242 static int bcm_sf2_port_setup(struct dsa_switch *ds, int port,
 243                               struct phy_device *phy)
 244 {
 245         struct bcm_sf2_priv *priv = bcm_sf2_to_priv(ds);
 246         s8 cpu_port = ds->dst->cpu_dp->index;
 247         unsigned int i;
 248         u32 reg;
 249
 250         /* Clear the memory power down */
 251         reg = core_readl(priv, CORE_MEM_PSM_VDD_CTRL);
 252         reg &= ~P_TXQ_PSM_VDD(port);
 253         core_writel(priv, reg, CORE_MEM_PSM_VDD_CTRL);
 254
 255         /* Disable learning */
 256         reg = core_readl(priv, CORE_DIS_LEARN);
 257         reg |= BIT(port);
 258         core_writel(priv, reg, CORE_DIS_LEARN);
 259
 260         /* Enable Broadcom tags for that port if requested */
 261         if (priv->brcm_tag_mask & BIT(port))
 262                 bcm_sf2_brcm_hdr_setup(priv, port);
 263
 264         /* Configure Traffic Class to QoS mapping, allow each priority to map
 265          * to a different queue number
 266          */
 267         reg = core_readl(priv, CORE_PORT_TC2_QOS_MAP_PORT(port));
 268         for (i = 0; i < SF2_NUM_EGRESS_QUEUES; i++)
 269                 reg |= i << (PRT_TO_QID_SHIFT * i);
 270         core_writel(priv, reg, CORE_PORT_TC2_QOS_MAP_PORT(port));
 271
 272         /* Clear the Rx and Tx disable bits and set to no spanning tree */
 273         core_writel(priv, 0, CORE_G_PCTL_PORT(port));
 274
 275         /* Re-enable the GPHY and re-apply workarounds */
 276         if (priv->int_phy_mask & 1 << port && priv->hw_params.num_gphy == 1) {
 277                 bcm_sf2_gphy_enable_set(ds, true);
 278                 if (phy) {
 279                         /* if phy_stop() has been called before, phy
 280                          * will be in halted state, and phy_start()
 281                          * will call resume.
 282                          *
 283                          * the resume path does not configure back
 284                          * autoneg settings, and since we hard reset
 285                          * the phy manually here, we need to reset the
 286                          * state machine also.
 287                          */
 288                         phy->state = PHY_READY;
 289                         phy_init_hw(phy);
 290                 }
 291         }
 292
 293         /* Enable MoCA port interrupts to get notified */
 294         if (port == priv->moca_port)
 295                 bcm_sf2_port_intr_enable(priv, port);
 296
 297         /* Set this port, and only this one to be in the default VLAN,
 298          * if member of a bridge, restore its membership prior to
 299          * bringing down this port.
 300          */
 301         reg = core_readl(priv, CORE_PORT_VLAN_CTL_PORT(port));
 302         reg &= ~PORT_VLAN_CTRL_MASK;
 303         reg |= (1 << port);
 304         reg |= priv->dev->ports[port].vlan_ctl_mask;
 305         core_writel(priv, reg, CORE_PORT_VLAN_CTL_PORT(port));
 306
 307         bcm_sf2_imp_vlan_setup(ds, cpu_port);
 308
 309         /* If EEE was enabled, restore it */
 310         if (priv->port_sts[port].eee.eee_enabled)
 311                 bcm_sf2_eee_enable_set(ds, port, true);
 312
 313         return 0;
 314 }
 315
 316 static void bcm_sf2_port_disable(struct dsa_switch *ds, int port,
 317                                  struct phy_device *phy)
 318 {
 319         struct bcm_sf2_priv *priv = bcm_sf2_to_priv(ds);
 320         u32 off, reg;
 321
 322         if (priv->wol_ports_mask & (1 << port))
 323                 return;
 324
 325         if (port == priv->moca_port)
 326                 bcm_sf2_port_intr_disable(priv, port);
 327
 328         if (priv->int_phy_mask & 1 << port && priv->hw_params.num_gphy == 1)
 329                 bcm_sf2_gphy_enable_set(ds, false);
 330
 331         if (dsa_is_cpu_port(ds, port))
 332                 off = CORE_IMP_CTL;
 333         else
 334                 off = CORE_G_PCTL_PORT(port);
 335
 336         reg = core_readl(priv, off);
 337         reg |= RX_DIS | TX_DIS;
 338         core_writel(priv, reg, off);
 339
 340         /* Power down the port memory */
 341         reg = core_readl(priv, CORE_MEM_PSM_VDD_CTRL);
 342         reg |= P_TXQ_PSM_VDD(port);
 343         core_writel(priv, reg, CORE_MEM_PSM_VDD_CTRL);
 344 }
 345
 346 /* Returns 0 if EEE was not enabled, or 1 otherwise
 347  */
 348 static int bcm_sf2_eee_init(struct dsa_switch *ds, int port,
 349                             struct phy_device *phy)
 350 {
 351         int ret;
 352
 353         ret = phy_init_eee(phy, 0);
 354         if (ret)
 355                 return 0;
 356
 357         bcm_sf2_eee_enable_set(ds, port, true);
 358
 359         return 1;
 360 }
 361
 362 static int bcm_sf2_sw_get_mac_eee(struct dsa_switch *ds, int port,
 363                                   struct ethtool_eee *e)
 364 {
 365         struct bcm_sf2_priv *priv = bcm_sf2_to_priv(ds);
 366         struct ethtool_eee *p = &priv->port_sts[port].eee;
 367         u32 reg;
 368
 369         reg = core_readl(priv, CORE_EEE_LPI_INDICATE);
 370         e->eee_enabled = p->eee_enabled;
 371         e->eee_active = !!(reg & (1 << port));
 372
 373         return 0;
 374 }
 375
 376 static int bcm_sf2_sw_set_mac_eee(struct dsa_switch *ds, int port,
 377                                   struct ethtool_eee *e)
 378 {
 379         struct bcm_sf2_priv *priv = bcm_sf2_to_priv(ds);
 380         struct ethtool_eee *p = &priv->port_sts[port].eee;
 381
 382         p->eee_enabled = e->eee_enabled;
 383         bcm_sf2_eee_enable_set(ds, port, e->eee_enabled);
 384
 385         return 0;
 386 }
 387
 388 static int bcm_sf2_sw_indir_rw(struct bcm_sf2_priv *priv, int op, int addr,
 389                                int regnum, u16 val)
 390 {
 391         int ret = 0;
 392         u32 reg;
 393
 394         reg = reg_readl(priv, REG_SWITCH_CNTRL);
 395         reg |= MDIO_MASTER_SEL;
 396         reg_writel(priv, reg, REG_SWITCH_CNTRL);
 397
 398         /* Page << 8 | offset */
 399         reg = 0x70;
 400         reg <<= 2;
 401         core_writel(priv, addr, reg);
 402
 403         /* Page << 8 | offset */
 404         reg = 0x80 << 8 | regnum << 1;
 405         reg <<= 2;
 406
 407         if (op)
 408                 ret = core_readl(priv, reg);
 409         else
 410                 core_writel(priv, val, reg);
 411
 412         reg = reg_readl(priv, REG_SWITCH_CNTRL);
 413         reg &= ~MDIO_MASTER_SEL;
 414         reg_writel(priv, reg, REG_SWITCH_CNTRL);
 415
 416         return ret & 0xffff;
 417 }
 418
 419 static int bcm_sf2_sw_mdio_read(struct mii_bus *bus, int addr, int regnum)
 420 {
 421         struct bcm_sf2_priv *priv = bus->priv;
 422
 423         /* Intercept reads from Broadcom pseudo-PHY address, else, send
 424          * them to our master MDIO bus controller
 425          */
 426         if (addr == BRCM_PSEUDO_PHY_ADDR && priv->indir_phy_mask & BIT(addr))
 427                 return bcm_sf2_sw_indir_rw(priv, 1, addr, regnum, 0);
 428         else
 429                 return mdiobus_read_nested(priv->master_mii_bus, addr, regnum);
 430 }
 431
 432 static int bcm_sf2_sw_mdio_write(struct mii_bus *bus, int addr, int regnum,
 433                                  u16 val)
 434 {
 435         struct bcm_sf2_priv *priv = bus->priv;
 436
 437         /* Intercept writes to the Broadcom pseudo-PHY address, else,
 438          * send them to our master MDIO bus controller
 439          */
 440         if (addr == BRCM_PSEUDO_PHY_ADDR && priv->indir_phy_mask & BIT(addr))
 441                 return bcm_sf2_sw_indir_rw(priv, 0, addr, regnum, val);
 442         else
 443                 return mdiobus_write_nested(priv->master_mii_bus, addr,
 444                                 regnum, val);
 445 }
 446
 447 static irqreturn_t bcm_sf2_switch_0_isr(int irq, void *dev_id)
 448 {
 449         struct bcm_sf2_priv *priv = dev_id;
 450
 451         priv->irq0_stat = intrl2_0_readl(priv, INTRL2_CPU_STATUS) &
 452                                 ~priv->irq0_mask;
 453         intrl2_0_writel(priv, priv->irq0_stat, INTRL2_CPU_CLEAR);
 454
 455         return IRQ_HANDLED;
 456 }
 457
 458 static irqreturn_t bcm_sf2_switch_1_isr(int irq, void *dev_id)
 459 {
 460         struct bcm_sf2_priv *priv = dev_id;
 461
 462         priv->irq1_stat = intrl2_1_readl(priv, INTRL2_CPU_STATUS) &
 463                                 ~priv->irq1_mask;
 464         intrl2_1_writel(priv, priv->irq1_stat, INTRL2_CPU_CLEAR);
 465
 466         if (priv->irq1_stat & P_LINK_UP_IRQ(P7_IRQ_OFF))
 467                 priv->port_sts[7].link = 1;
 468         if (priv->irq1_stat & P_LINK_DOWN_IRQ(P7_IRQ_OFF))
 469                 priv->port_sts[7].link = 0;
 470
 471         return IRQ_HANDLED;
 472 }
 473
 474 static int bcm_sf2_sw_rst(struct bcm_sf2_priv *priv)
 475 {
 476         unsigned int timeout = 1000;
 477         u32 reg;
 478
 479         reg = core_readl(priv, CORE_WATCHDOG_CTRL);
 480         reg |= SOFTWARE_RESET | EN_CHIP_RST | EN_SW_RESET;
 481         core_writel(priv, reg, CORE_WATCHDOG_CTRL);
 482
 483         do {
 484                 reg = core_readl(priv, CORE_WATCHDOG_CTRL);
 485                 if (!(reg & SOFTWARE_RESET))
 486                         break;
 487
 488                 usleep_range(1000, 2000);
 489         } while (timeout-- > 0);
 490
 491         if (timeout == 0)
 492                 return -ETIMEDOUT;
 493
 494         return 0;
 495 }
 496
 497 static void bcm_sf2_intr_disable(struct bcm_sf2_priv *priv)
 498 {
 499         intrl2_0_mask_set(priv, 0xffffffff);
 500         intrl2_0_writel(priv, 0xffffffff, INTRL2_CPU_CLEAR);
 501         intrl2_1_mask_set(priv, 0xffffffff);
 502         intrl2_1_writel(priv, 0xffffffff, INTRL2_CPU_CLEAR);
 503 }
 504
 505 static void bcm_sf2_identify_ports(struct bcm_sf2_priv *priv,
 506                                    struct device_node *dn)
 507 {
 508         struct device_node *port;
 509         int mode;
 510         unsigned int port_num;
 511
 512         priv->moca_port = -1;
 513
 514         for_each_available_child_of_node(dn, port) {
 515                 if (of_property_read_u32(port, "reg", &port_num))
 516                         continue;
 517
 518                 /* Internal PHYs get assigned a specific 'phy-mode' property
 519                  * value: "internal" to help flag them before MDIO probing
 520                  * has completed, since they might be turned off at that
 521                  * time
 522                  */
 523                 mode = of_get_phy_mode(port);
 524                 if (mode < 0)
 525                         continue;
 526
 527                 if (mode == PHY_INTERFACE_MODE_INTERNAL)
 528                         priv->int_phy_mask |= 1 << port_num;
 529
 530                 if (mode == PHY_INTERFACE_MODE_MOCA)
 531                         priv->moca_port = port_num;
 532
 533                 if (of_property_read_bool(port, "brcm,use-bcm-hdr"))
 534                         priv->brcm_tag_mask |= 1 << port_num;
 535         }
 536 }
 537
 538 static int bcm_sf2_mdio_register(struct dsa_switch *ds)
 539 {
 540         struct bcm_sf2_priv *priv = bcm_sf2_to_priv(ds);
 541         struct device_node *dn;
 542         static int index;
 543         int err;
 544
 545         /* Find our integrated MDIO bus node */
 546         dn = of_find_compatible_node(NULL, NULL, "brcm,unimac-mdio");
 547         priv->master_mii_bus = of_mdio_find_bus(dn);
 548         if (!priv->master_mii_bus) {
 549                 of_node_put(dn);
 550                 return -EPROBE_DEFER;
 551         }
 552
 553         get_device(&priv->master_mii_bus->dev);
 554         priv->master_mii_dn = dn;
 555
 556         priv->slave_mii_bus = devm_mdiobus_alloc(ds->dev);
 557         if (!priv->slave_mii_bus) {
 558                 of_node_put(dn);
 559                 return -ENOMEM;
 560         }
 561
 562         priv->slave_mii_bus->priv = priv;
 563         priv->slave_mii_bus->name = "sf2 slave mii";
 564         priv->slave_mii_bus->read = bcm_sf2_sw_mdio_read;
 565         priv->slave_mii_bus->write = bcm_sf2_sw_mdio_write;
 566         snprintf(priv->slave_mii_bus->id, MII_BUS_ID_SIZE, "sf2-%d",
 567                  index++);
 568         priv->slave_mii_bus->dev.of_node = dn;
 569
 570         /* Include the pseudo-PHY address to divert reads towards our
 571          * workaround. This is only required for 7445D0, since 7445E0
 572          * disconnects the internal switch pseudo-PHY such that we can use the
 573          * regular SWITCH_MDIO master controller instead.
 574          *
 575          * Here we flag the pseudo PHY as needing special treatment and would
 576          * otherwise make all other PHY read/writes go to the master MDIO bus
 577          * controller that comes with this switch backed by the "mdio-unimac"
 578          * driver.
 579          */
 580         if (of_machine_is_compatible("brcm,bcm7445d0"))
 581                 priv->indir_phy_mask |= (1 << BRCM_PSEUDO_PHY_ADDR);
 582         else
 583                 priv->indir_phy_mask = 0;
 584
 585         ds->phys_mii_mask = priv->indir_phy_mask;
 586         ds->slave_mii_bus = priv->slave_mii_bus;
 587         priv->slave_mii_bus->parent = ds->dev->parent;
 588         priv->slave_mii_bus->phy_mask = ~priv->indir_phy_mask;
 589
 590         if (dn)
 591                 err = of_mdiobus_register(priv->slave_mii_bus, dn);
 592         else
 593                 err = mdiobus_register(priv->slave_mii_bus);
 594
 595         if (err)
 596                 of_node_put(dn);
 597
 598         return err;
 599 }
 600
 601 static void bcm_sf2_mdio_unregister(struct bcm_sf2_priv *priv)
 602 {
 603         mdiobus_unregister(priv->slave_mii_bus);
 604         if (priv->master_mii_dn)
 605                 of_node_put(priv->master_mii_dn);
 606 }
 607
 608 static u32 bcm_sf2_sw_get_phy_flags(struct dsa_switch *ds, int port)
 609 {
 610         struct bcm_sf2_priv *priv = bcm_sf2_to_priv(ds);
 611
 612         /* The BCM7xxx PHY driver expects to find the integrated PHY revision
 613          * in bits 15:8 and the patch level in bits 7:0 which is exactly what
 614          * the REG_PHY_REVISION register layout is.
 615          */
 616         if (priv->int_phy_mask & BIT(port))
 617                 return priv->hw_params.gphy_rev;
 618         else
 619                 return 0;
 620 }
 621
 622 static void bcm_sf2_sw_adjust_link(struct dsa_switch *ds, int port,
 623                                    struct phy_device *phydev)
 624 {
 625         struct bcm_sf2_priv *priv = bcm_sf2_to_priv(ds);
 626         struct ethtool_eee *p = &priv->port_sts[port].eee;
 627         u32 id_mode_dis = 0, port_mode;
 628         const char *str = NULL;
 629         u32 reg, offset;
 630
 631         if (priv->type == BCM7445_DEVICE_ID)
 632                 offset = CORE_STS_OVERRIDE_GMIIP_PORT(port);
 633         else
 634                 offset = CORE_STS_OVERRIDE_GMIIP2_PORT(port);
 635
 636         switch (phydev->interface) {
 637         case PHY_INTERFACE_MODE_RGMII:
 638                 str = "RGMII (no delay)";
 639                 id_mode_dis = 1;
 640         case PHY_INTERFACE_MODE_RGMII_TXID:
 641                 if (!str)
 642                         str = "RGMII (TX delay)";
 643                 port_mode = EXT_GPHY;
 644                 break;
 645         case PHY_INTERFACE_MODE_MII:
 646                 str = "MII";
 647                 port_mode = EXT_EPHY;
 648                 break;
 649         case PHY_INTERFACE_MODE_REVMII:
 650                 str = "Reverse MII";
 651                 port_mode = EXT_REVMII;
 652                 break;
 653         default:
 654                 /* All other PHYs: internal and MoCA */
 655                 goto force_link;
 656         }
 657
 658         /* If the link is down, just disable the interface to conserve power */
 659         if (!phydev->link) {
 660                 reg = reg_readl(priv, REG_RGMII_CNTRL_P(port));
 661                 reg &= ~RGMII_MODE_EN;
 662                 reg_writel(priv, reg, REG_RGMII_CNTRL_P(port));
 663                 goto force_link;
 664         }
 665
 666         /* Clear id_mode_dis bit, and the existing port mode, but
 667          * make sure we enable the RGMII block for data to pass
 668          */
 669         reg = reg_readl(priv, REG_RGMII_CNTRL_P(port));
 670         reg &= ~ID_MODE_DIS;
 671         reg &= ~(PORT_MODE_MASK << PORT_MODE_SHIFT);
 672         reg &= ~(RX_PAUSE_EN | TX_PAUSE_EN);
 673
 674         reg |= port_mode | RGMII_MODE_EN;
 675         if (id_mode_dis)
 676                 reg |= ID_MODE_DIS;
 677
 678         if (phydev->pause) {
 679                 if (phydev->asym_pause)
 680                         reg |= TX_PAUSE_EN;
 681                 reg |= RX_PAUSE_EN;
 682         }
 683
 684         reg_writel(priv, reg, REG_RGMII_CNTRL_P(port));
 685
 686         pr_info("Port %d configured for %s\n", port, str);
 687
 688 force_link:
 689         /* Force link settings detected from the PHY */
 690         reg = SW_OVERRIDE;
 691         switch (phydev->speed) {
 692         case SPEED_1000:
 693                 reg |= SPDSTS_1000 << SPEED_SHIFT;
 694                 break;
 695         case SPEED_100:
 696                 reg |= SPDSTS_100 << SPEED_SHIFT;
 697                 break;
 698         }
 699
 700         if (phydev->link)
 701                 reg |= LINK_STS;
 702         if (phydev->duplex == DUPLEX_FULL)
 703                 reg |= DUPLX_MODE;
 704
 705         core_writel(priv, reg, offset);
 706
 707         if (!phydev->is_pseudo_fixed_link)
 708                 p->eee_enabled = bcm_sf2_eee_init(ds, port, phydev);
 709 }
 710
 711 static void bcm_sf2_sw_fixed_link_update(struct dsa_switch *ds, int port,
 712                                          struct fixed_phy_status *status)
 713 {
 714         struct bcm_sf2_priv *priv = bcm_sf2_to_priv(ds);
 715         u32 duplex, pause, offset;
 716         u32 reg;
 717
 718         if (priv->type == BCM7445_DEVICE_ID)
 719                 offset = CORE_STS_OVERRIDE_GMIIP_PORT(port);
 720         else
 721                 offset = CORE_STS_OVERRIDE_GMIIP2_PORT(port);
 722
 723         duplex = core_readl(priv, CORE_DUPSTS);
 724         pause = core_readl(priv, CORE_PAUSESTS);
 725
 726         status->link = 0;
 727
 728         /* MoCA port is special as we do not get link status from CORE_LNKSTS,
 729          * which means that we need to force the link at the port override
 730          * level to get the data to flow. We do use what the interrupt handler
 731          * did determine before.
 732          *
 733          * For the other ports, we just force the link status, since this is
 734          * a fixed PHY device.
 735          */
 736         if (port == priv->moca_port) {
 737                 status->link = priv->port_sts[port].link;
 738                 /* For MoCA interfaces, also force a link down notification
 739                  * since some version of the user-space daemon (mocad) use
 740                  * cmd->autoneg to force the link, which messes up the PHY
 741                  * state machine and make it go in PHY_FORCING state instead.
 742                  */
 743                 if (!status->link)
 744                         netif_carrier_off(ds->ports[port].netdev);
 745                 status->duplex = 1;
 746         } else {
 747                 status->link = 1;
 748                 status->duplex = !!(duplex & (1 << port));
 749         }
 750
 751         reg = core_readl(priv, offset);
 752         reg |= SW_OVERRIDE;
 753         if (status->link)
 754                 reg |= LINK_STS;
 755         else
 756                 reg &= ~LINK_STS;
 757         core_writel(priv, reg, offset);
 758
 759         if ((pause & (1 << port)) &&
 760             (pause & (1 << (port + PAUSESTS_TX_PAUSE_SHIFT)))) {
 761                 status->asym_pause = 1;
 762                 status->pause = 1;
 763         }
 764
 765         if (pause & (1 << port))
 766                 status->pause = 1;
 767 }
 768
 769 static int bcm_sf2_sw_suspend(struct dsa_switch *ds)
 770 {
 771         struct bcm_sf2_priv *priv = bcm_sf2_to_priv(ds);
 772         unsigned int port;
 773
 774         bcm_sf2_intr_disable(priv);
 775
 776         /* Disable all ports physically present including the IMP
 777          * port, the other ones have already been disabled during
 778          * bcm_sf2_sw_setup
 779          */
 780         for (port = 0; port < DSA_MAX_PORTS; port++) {
 781                 if ((1 << port) & ds->enabled_port_mask ||
 782                     dsa_is_cpu_port(ds, port))
 783                         bcm_sf2_port_disable(ds, port, NULL);
 784         }
 785
 786         return 0;
 787 }
 788
 789 static int bcm_sf2_sw_resume(struct dsa_switch *ds)
 790 {
 791         struct bcm_sf2_priv *priv = bcm_sf2_to_priv(ds);
 792         int ret;
 793
 794         ret = bcm_sf2_sw_rst(priv);
 795         if (ret) {
 796                 pr_err("%s: failed to software reset switch\n", __func__);
 797                 return ret;
 798         }
 799
 800         if (priv->hw_params.num_gphy == 1)
 801                 bcm_sf2_gphy_enable_set(ds, true);
 802
 803         ds->ops->setup(ds);
 804
 805         return 0;
 806 }
 807
 808 static void bcm_sf2_sw_get_wol(struct dsa_switch *ds, int port,
 809                                struct ethtool_wolinfo *wol)
 810 {
 811         struct net_device *p = ds->dst->cpu_dp->netdev;
 812         struct bcm_sf2_priv *priv = bcm_sf2_to_priv(ds);
 813         struct ethtool_wolinfo pwol;
 814
 815         /* Get the parent device WoL settings */
 816         p->ethtool_ops->get_wol(p, &pwol);
 817
 818         /* Advertise the parent device supported settings */
 819         wol->supported = pwol.supported;
 820         memset(&wol->sopass, 0, sizeof(wol->sopass));
 821
 822         if (pwol.wolopts & WAKE_MAGICSECURE)
 823                 memcpy(&wol->sopass, pwol.sopass, sizeof(wol->sopass));
 824
 825         if (priv->wol_ports_mask & (1 << port))
 826                 wol->wolopts = pwol.wolopts;
 827         else
 828                 wol->wolopts = 0;
 829 }
 830
 831 static int bcm_sf2_sw_set_wol(struct dsa_switch *ds, int port,
 832                               struct ethtool_wolinfo *wol)
 833 {
 834         struct net_device *p = ds->dst->cpu_dp->netdev;
 835         struct bcm_sf2_priv *priv = bcm_sf2_to_priv(ds);
 836         s8 cpu_port = ds->dst->cpu_dp->index;
 837         struct ethtool_wolinfo pwol;
 838
 839         p->ethtool_ops->get_wol(p, &pwol);
 840         if (wol->wolopts & ~pwol.supported)
 841                 return -EINVAL;
 842
 843         if (wol->wolopts)
 844                 priv->wol_ports_mask |= (1 << port);
 845         else
 846                 priv->wol_ports_mask &= ~(1 << port);
 847
 848         /* If we have at least one port enabled, make sure the CPU port
 849          * is also enabled. If the CPU port is the last one enabled, we disable
 850          * it since this configuration does not make sense.
 851          */
 852         if (priv->wol_ports_mask && priv->wol_ports_mask != (1 << cpu_port))
 853                 priv->wol_ports_mask |= (1 << cpu_port);
 854         else
 855                 priv->wol_ports_mask &= ~(1 << cpu_port);
 856
 857         return p->ethtool_ops->set_wol(p, wol);
 858 }
 859
 860 static int bcm_sf2_vlan_op_wait(struct bcm_sf2_priv *priv)
 861 {
 862         unsigned int timeout = 10;
 863         u32 reg;
 864
 865         do {
 866                 reg = core_readl(priv, CORE_ARLA_VTBL_RWCTRL);
 867                 if (!(reg & ARLA_VTBL_STDN))
 868                         return 0;
 869
 870                 usleep_range(1000, 2000);
 871         } while (timeout--);
 872
 873         return -ETIMEDOUT;
 874 }
 875
 876 static int bcm_sf2_vlan_op(struct bcm_sf2_priv *priv, u8 op)
 877 {
 878         core_writel(priv, ARLA_VTBL_STDN | op, CORE_ARLA_VTBL_RWCTRL);
 879
 880         return bcm_sf2_vlan_op_wait(priv);
 881 }
 882
 883 static void bcm_sf2_sw_configure_vlan(struct dsa_switch *ds)
 884 {
 885         struct bcm_sf2_priv *priv = bcm_sf2_to_priv(ds);
 886         unsigned int port;
 887
 888         /* Clear all VLANs */
 889         bcm_sf2_vlan_op(priv, ARLA_VTBL_CMD_CLEAR);
 890
 891         for (port = 0; port < priv->hw_params.num_ports; port++) {
 892                 if (!((1 << port) & ds->enabled_port_mask))
 893                         continue;
 894
 895                 core_writel(priv, 1, CORE_DEFAULT_1Q_TAG_P(port));
 896         }
 897 }
 898
 899 static int bcm_sf2_sw_setup(struct dsa_switch *ds)
 900 {
 901         struct bcm_sf2_priv *priv = bcm_sf2_to_priv(ds);
 902         unsigned int port;
 903
 904         /* Enable all valid ports and disable those unused */
 905         for (port = 0; port < priv->hw_params.num_ports; port++) {
 906                 /* IMP port receives special treatment */
 907                 if ((1 << port) & ds->enabled_port_mask)
 908                         bcm_sf2_port_setup(ds, port, NULL);
 909                 else if (dsa_is_cpu_port(ds, port))
 910                         bcm_sf2_imp_setup(ds, port);
 911                 else
 912                         bcm_sf2_port_disable(ds, port, NULL);
 913         }
 914
 915         bcm_sf2_sw_configure_vlan(ds);
 916
 917         return 0;
 918 }
 919
 920 /* The SWITCH_CORE register space is managed by b53 but operates on a page +
 921  * register basis so we need to translate that into an address that the
 922  * bus-glue understands.
 923  */
 924 #define SF2_PAGE_REG_MKADDR(page, reg)  ((page) << 10 | (reg) << 2)
 925
 926 static int bcm_sf2_core_read8(struct b53_device *dev, u8 page, u8 reg,
 927                               u8 *val)
 928 {
 929         struct bcm_sf2_priv *priv = dev->priv;
 930
 931         *val = core_readl(priv, SF2_PAGE_REG_MKADDR(page, reg));
 932
 933         return 0;
 934 }
 935
 936 static int bcm_sf2_core_read16(struct b53_device *dev, u8 page, u8 reg,
 937                                u16 *val)
 938 {
 939         struct bcm_sf2_priv *priv = dev->priv;
 940
 941         *val = core_readl(priv, SF2_PAGE_REG_MKADDR(page, reg));
 942
 943         return 0;
 944 }
 945
 946 static int bcm_sf2_core_read32(struct b53_device *dev, u8 page, u8 reg,
 947                                u32 *val)
 948 {
 949         struct bcm_sf2_priv *priv = dev->priv;
 950
 951         *val = core_readl(priv, SF2_PAGE_REG_MKADDR(page, reg));
 952
 953         return 0;
 954 }
 955
 956 static int bcm_sf2_core_read64(struct b53_device *dev, u8 page, u8 reg,
 957                                u64 *val)
 958 {
 959         struct bcm_sf2_priv *priv = dev->priv;
 960
 961         *val = core_readq(priv, SF2_PAGE_REG_MKADDR(page, reg));
 962
 963         return 0;
 964 }
 965
 966 static int bcm_sf2_core_write8(struct b53_device *dev, u8 page, u8 reg,
 967                                u8 value)
 968 {
 969         struct bcm_sf2_priv *priv = dev->priv;
 970
 971         core_writel(priv, value, SF2_PAGE_REG_MKADDR(page, reg));
 972
 973         return 0;
 974 }
 975
 976 static int bcm_sf2_core_write16(struct b53_device *dev, u8 page, u8 reg,
 977                                 u16 value)
 978 {
 979         struct bcm_sf2_priv *priv = dev->priv;
 980
 981         core_writel(priv, value, SF2_PAGE_REG_MKADDR(page, reg));
 982
 983         return 0;
 984 }
 985
 986 static int bcm_sf2_core_write32(struct b53_device *dev, u8 page, u8 reg,
 987                                 u32 value)
 988 {
 989         struct bcm_sf2_priv *priv = dev->priv;
 990
 991         core_writel(priv, value, SF2_PAGE_REG_MKADDR(page, reg));
 992
 993         return 0;
 994 }
 995
 996 static int bcm_sf2_core_write64(struct b53_device *dev, u8 page, u8 reg,
 997                                 u64 value)
 998 {
 999         struct bcm_sf2_priv *priv = dev->priv;
1000
1001         core_writeq(priv, value, SF2_PAGE_REG_MKADDR(page, reg));
1002
1003         return 0;
1004 }
1005
1006 static const struct b53_io_ops bcm_sf2_io_ops = {
1007         .read8  = bcm_sf2_core_read8,
1008         .read16 = bcm_sf2_core_read16,
1009         .read32 = bcm_sf2_core_read32,
1010         .read48 = bcm_sf2_core_read64,
1011         .read64 = bcm_sf2_core_read64,
1012         .write8 = bcm_sf2_core_write8,
1013         .write16 = bcm_sf2_core_write16,
1014         .write32 = bcm_sf2_core_write32,
1015         .write48 = bcm_sf2_core_write64,
1016         .write64 = bcm_sf2_core_write64,
1017 };
1018
1019 static const struct dsa_switch_ops bcm_sf2_ops = {
1020         .get_tag_protocol       = bcm_sf2_sw_get_tag_protocol,
1021         .setup                  = bcm_sf2_sw_setup,
1022         .get_strings            = b53_get_strings,
1023         .get_ethtool_stats      = b53_get_ethtool_stats,
1024         .get_sset_count         = b53_get_sset_count,
1025         .get_phy_flags          = bcm_sf2_sw_get_phy_flags,
1026         .adjust_link            = bcm_sf2_sw_adjust_link,
1027         .fixed_link_update      = bcm_sf2_sw_fixed_link_update,
1028         .suspend                = bcm_sf2_sw_suspend,
1029         .resume                 = bcm_sf2_sw_resume,
1030         .get_wol                = bcm_sf2_sw_get_wol,
1031         .set_wol                = bcm_sf2_sw_set_wol,
1032         .port_enable            = bcm_sf2_port_setup,
1033         .port_disable           = bcm_sf2_port_disable,
1034         .get_mac_eee            = bcm_sf2_sw_get_mac_eee,
1035         .set_mac_eee            = bcm_sf2_sw_set_mac_eee,
1036         .port_bridge_join       = b53_br_join,
1037         .port_bridge_leave      = b53_br_leave,
1038         .port_stp_state_set     = b53_br_set_stp_state,
1039         .port_fast_age          = b53_br_fast_age,
1040         .port_vlan_filtering    = b53_vlan_filtering,
1041         .port_vlan_prepare      = b53_vlan_prepare,
1042         .port_vlan_add          = b53_vlan_add,
1043         .port_vlan_del          = b53_vlan_del,
1044         .port_fdb_dump          = b53_fdb_dump,
1045         .port_fdb_add           = b53_fdb_add,
1046         .port_fdb_del           = b53_fdb_del,
1047         .get_rxnfc              = bcm_sf2_get_rxnfc,
1048         .set_rxnfc              = bcm_sf2_set_rxnfc,
1049         .port_mirror_add        = b53_mirror_add,
1050         .port_mirror_del        = b53_mirror_del,
1051 };
1052
1053 struct bcm_sf2_of_data {
1054         u32 type;
1055         const u16 *reg_offsets;
1056         unsigned int core_reg_align;
1057         unsigned int num_cfp_rules;
1058 };
1059
1060 /* Register offsets for the SWITCH_REG_* block */
1061 static const u16 bcm_sf2_7445_reg_offsets[] = {
1062         [REG_SWITCH_CNTRL]      = 0x00,
1063         [REG_SWITCH_STATUS]     = 0x04,
1064         [REG_DIR_DATA_WRITE]    = 0x08,
1065         [REG_DIR_DATA_READ]     = 0x0C,
1066         [REG_SWITCH_REVISION]   = 0x18,
1067         [REG_PHY_REVISION]      = 0x1C,
1068         [REG_SPHY_CNTRL]        = 0x2C,
1069         [REG_RGMII_0_CNTRL]     = 0x34,
1070         [REG_RGMII_1_CNTRL]     = 0x40,
1071         [REG_RGMII_2_CNTRL]     = 0x4c,
1072         [REG_LED_0_CNTRL]       = 0x90,
1073         [REG_LED_1_CNTRL]       = 0x94,
1074         [REG_LED_2_CNTRL]       = 0x98,
1075 };
1076
1077 static const struct bcm_sf2_of_data bcm_sf2_7445_data = {
1078         .type           = BCM7445_DEVICE_ID,
1079         .core_reg_align = 0,
1080         .reg_offsets    = bcm_sf2_7445_reg_offsets,
1081         .num_cfp_rules  = 256,
1082 };
1083
1084 static const u16 bcm_sf2_7278_reg_offsets[] = {
1085         [REG_SWITCH_CNTRL]      = 0x00,
1086         [REG_SWITCH_STATUS]     = 0x04,
1087         [REG_DIR_DATA_WRITE]    = 0x08,
1088         [REG_DIR_DATA_READ]     = 0x0c,
1089         [REG_SWITCH_REVISION]   = 0x10,
1090         [REG_PHY_REVISION]      = 0x14,
1091         [REG_SPHY_CNTRL]        = 0x24,
1092         [REG_RGMII_0_CNTRL]     = 0xe0,
1093         [REG_RGMII_1_CNTRL]     = 0xec,
1094         [REG_RGMII_2_CNTRL]     = 0xf8,
1095         [REG_LED_0_CNTRL]       = 0x40,
1096         [REG_LED_1_CNTRL]       = 0x4c,
1097         [REG_LED_2_CNTRL]       = 0x58,
1098 };
1099
1100 static const struct bcm_sf2_of_data bcm_sf2_7278_data = {
1101         .type           = BCM7278_DEVICE_ID,
1102         .core_reg_align = 1,
1103         .reg_offsets    = bcm_sf2_7278_reg_offsets,
1104         .num_cfp_rules  = 128,
1105 };
1106
1107 static const struct of_device_id bcm_sf2_of_match[] = {
1108         { .compatible = "brcm,bcm7445-switch-v4.0",
1109           .data = &bcm_sf2_7445_data
1110         },
1111         { .compatible = "brcm,bcm7278-switch-v4.0",
1112           .data = &bcm_sf2_7278_data
1113         },
1114         { /* sentinel */ },
1115 };
1116 MODULE_DEVICE_TABLE(of, bcm_sf2_of_match);
1117
1118 static int bcm_sf2_sw_probe(struct platform_device *pdev)
1119 {
1120         const char *reg_names[BCM_SF2_REGS_NUM] = BCM_SF2_REGS_NAME;
1121         struct device_node *dn = pdev->dev.of_node;
1122         const struct of_device_id *of_id = NULL;
1123         const struct bcm_sf2_of_data *data;
1124         struct b53_platform_data *pdata;
1125         struct dsa_switch_ops *ops;
1126         struct device_node *ports;
1127         struct bcm_sf2_priv *priv;
1128         struct b53_device *dev;
1129         struct dsa_switch *ds;
1130         void __iomem **base;
1131         struct resource *r;
1132         unsigned int i;
1133         u32 reg, rev;
1134         int ret;
1135
1136         priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
1137         if (!priv)
1138                 return -ENOMEM;
1139
1140         ops = devm_kzalloc(&pdev->dev, sizeof(*ops), GFP_KERNEL);
1141         if (!ops)
1142                 return -ENOMEM;
1143
1144         dev = b53_switch_alloc(&pdev->dev, &bcm_sf2_io_ops, priv);
1145         if (!dev)
1146                 return -ENOMEM;
1147
1148         pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
1149         if (!pdata)
1150                 return -ENOMEM;
1151
1152         of_id = of_match_node(bcm_sf2_of_match, dn);
1153         if (!of_id || !of_id->data)
1154                 return -EINVAL;
1155
1156         data = of_id->data;
1157
1158         /* Set SWITCH_REG register offsets and SWITCH_CORE align factor */
1159         priv->type = data->type;
1160         priv->reg_offsets = data->reg_offsets;
1161         priv->core_reg_align = data->core_reg_align;
1162         priv->num_cfp_rules = data->num_cfp_rules;
1163
1164         /* Auto-detection using standard registers will not work, so
1165          * provide an indication of what kind of device we are for
1166          * b53_common to work with
1167          */
1168         pdata->chip_id = priv->type;
1169         dev->pdata = pdata;
1170
1171         priv->dev = dev;
1172         ds = dev->ds;
1173         ds->ops = &bcm_sf2_ops;
1174
1175         /* Advertise the 8 egress queues */
1176         ds->num_tx_queues = SF2_NUM_EGRESS_QUEUES;
1177
1178         dev_set_drvdata(&pdev->dev, priv);
1179
1180         spin_lock_init(&priv->indir_lock);
1181         mutex_init(&priv->stats_mutex);
1182         mutex_init(&priv->cfp.lock);
1183
1184         /* CFP rule #0 cannot be used for specific classifications, flag it as
1185          * permanently used
1186          */
1187         set_bit(0, priv->cfp.used);
1188
1189         /* Balance of_node_put() done by of_find_node_by_name() */
1190         of_node_get(dn);
1191         ports = of_find_node_by_name(dn, "ports");
1192         if (ports) {
1193                 bcm_sf2_identify_ports(priv, ports);
1194                 of_node_put(ports);
1195         }
1196
1197         priv->irq0 = irq_of_parse_and_map(dn, 0);
1198         priv->irq1 = irq_of_parse_and_map(dn, 1);
1199
1200         base = &priv->core;
1201         for (i = 0; i < BCM_SF2_REGS_NUM; i++) {
1202                 r = platform_get_resource(pdev, IORESOURCE_MEM, i);
1203                 *base = devm_ioremap_resource(&pdev->dev, r);
1204                 if (IS_ERR(*base)) {
1205                         pr_err("unable to find register: %s\n", reg_names[i]);
1206                         return PTR_ERR(*base);
1207                 }
1208                 base++;
1209         }
1210
1211         ret = bcm_sf2_sw_rst(priv);
1212         if (ret) {
1213                 pr_err("unable to software reset switch: %d\n", ret);
1214                 return ret;
1215         }
1216
1217         bcm_sf2_gphy_enable_set(priv->dev->ds, true);
1218
1219         ret = bcm_sf2_mdio_register(ds);
1220         if (ret) {
1221                 pr_err("failed to register MDIO bus\n");
1222                 return ret;
1223         }
1224
1225         bcm_sf2_gphy_enable_set(priv->dev->ds, false);
1226
1227         ret = bcm_sf2_cfp_rst(priv);
1228         if (ret) {
1229                 pr_err("failed to reset CFP\n");
1230                 goto out_mdio;
1231         }
1232
1233         /* Disable all interrupts and request them */
1234         bcm_sf2_intr_disable(priv);
1235
1236         ret = devm_request_irq(&pdev->dev, priv->irq0, bcm_sf2_switch_0_isr, 0,
1237                                "switch_0", priv);
1238         if (ret < 0) {
1239                 pr_err("failed to request switch_0 IRQ\n");
1240                 goto out_mdio;
1241         }
1242
1243         ret = devm_request_irq(&pdev->dev, priv->irq1, bcm_sf2_switch_1_isr, 0,
1244                                "switch_1", priv);
1245         if (ret < 0) {
1246                 pr_err("failed to request switch_1 IRQ\n");
1247                 goto out_mdio;
1248         }
1249
1250         /* Reset the MIB counters */
1251         reg = core_readl(priv, CORE_GMNCFGCFG);
1252         reg |= RST_MIB_CNT;
1253         core_writel(priv, reg, CORE_GMNCFGCFG);
1254         reg &= ~RST_MIB_CNT;
1255         core_writel(priv, reg, CORE_GMNCFGCFG);
1256
1257         /* Get the maximum number of ports for this switch */
1258         priv->hw_params.num_ports = core_readl(priv, CORE_IMP0_PRT_ID) + 1;
1259         if (priv->hw_params.num_ports > DSA_MAX_PORTS)
1260                 priv->hw_params.num_ports = DSA_MAX_PORTS;
1261
1262         /* Assume a single GPHY setup if we can't read that property */
1263         if (of_property_read_u32(dn, "brcm,num-gphy",
1264                                  &priv->hw_params.num_gphy))
1265                 priv->hw_params.num_gphy = 1;
1266
1267         rev = reg_readl(priv, REG_SWITCH_REVISION);
1268         priv->hw_params.top_rev = (rev >> SWITCH_TOP_REV_SHIFT) &
1269                                         SWITCH_TOP_REV_MASK;
1270         priv->hw_params.core_rev = (rev & SF2_REV_MASK);
1271
1272         rev = reg_readl(priv, REG_PHY_REVISION);
1273         priv->hw_params.gphy_rev = rev & PHY_REVISION_MASK;
1274
1275         ret = b53_switch_register(dev);
1276         if (ret)
1277                 goto out_mdio;
1278
1279         pr_info("Starfighter 2 top: %x.%02x, core: %x.%02x base: 0x%p, IRQs: %d, %d\n",
1280                 priv->hw_params.top_rev >> 8, priv->hw_params.top_rev & 0xff,
1281                 priv->hw_params.core_rev >> 8, priv->hw_params.core_rev & 0xff,
1282                 priv->core, priv->irq0, priv->irq1);
1283
1284         return 0;
1285
1286 out_mdio:
1287         bcm_sf2_mdio_unregister(priv);
1288         return ret;
1289 }
1290
1291 static int bcm_sf2_sw_remove(struct platform_device *pdev)
1292 {
1293         struct bcm_sf2_priv *priv = platform_get_drvdata(pdev);
1294
1295         priv->wol_ports_mask = 0;
1296         dsa_unregister_switch(priv->dev->ds);
1297         /* Disable all ports and interrupts */
1298         bcm_sf2_sw_suspend(priv->dev->ds);
1299         bcm_sf2_mdio_unregister(priv);
1300
1301         return 0;
1302 }
1303
1304 static void bcm_sf2_sw_shutdown(struct platform_device *pdev)
1305 {
1306         struct bcm_sf2_priv *priv = platform_get_drvdata(pdev);
1307
1308         /* For a kernel about to be kexec'd we want to keep the GPHY on for a
1309          * successful MDIO bus scan to occur. If we did turn off the GPHY
1310          * before (e.g: port_disable), this will also power it back on.
1311          *
1312          * Do not rely on kexec_in_progress, just power the PHY on.
1313          */
1314         if (priv->hw_params.num_gphy == 1)
1315                 bcm_sf2_gphy_enable_set(priv->dev->ds, true);
1316 }
1317
1318 #ifdef CONFIG_PM_SLEEP
1319 static int bcm_sf2_suspend(struct device *dev)
1320 {
1321         struct platform_device *pdev = to_platform_device(dev);
1322         struct bcm_sf2_priv *priv = platform_get_drvdata(pdev);
1323
1324         return dsa_switch_suspend(priv->dev->ds);
1325 }
1326
1327 static int bcm_sf2_resume(struct device *dev)
1328 {
1329         struct platform_device *pdev = to_platform_device(dev);
1330         struct bcm_sf2_priv *priv = platform_get_drvdata(pdev);
1331
1332         return dsa_switch_resume(priv->dev->ds);
1333 }
1334 #endif /* CONFIG_PM_SLEEP */
1335
1336 static SIMPLE_DEV_PM_OPS(bcm_sf2_pm_ops,
1337                          bcm_sf2_suspend, bcm_sf2_resume);
1338
1339
1340 static struct platform_driver bcm_sf2_driver = {
1341         .probe  = bcm_sf2_sw_probe,
1342         .remove = bcm_sf2_sw_remove,
1343         .shutdown = bcm_sf2_sw_shutdown,
1344         .driver = {
1345                 .name = "brcm-sf2",
1346                 .of_match_table = bcm_sf2_of_match,
1347                 .pm = &bcm_sf2_pm_ops,
1348         },
1349 };
1350 module_platform_driver(bcm_sf2_driver);
1351
1352 MODULE_AUTHOR("Broadcom Corporation");
1353 MODULE_DESCRIPTION("Driver for Broadcom Starfighter 2 ethernet switch chip");
1354 MODULE_LICENSE("GPL");
1355 MODULE_ALIAS("platform:brcm-sf2");