drivers/net/phy/b53.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (C) 2017
   4  * Broadcom
   5  * Florian Fainelli <f.fainelli@gmail.com>
   6  */
   7
   8 /*
   9  * PHY driver for Broadcom BCM53xx (roboswitch) Ethernet switches.
  10  *
  11  * This driver configures the b53 for basic use as a PHY. The switch supports
  12  * vendor tags and VLAN configuration that can affect the switching decisions.
  13  * This driver uses a simple configuration in which all ports are only allowed
  14  * to send frames to the CPU port and receive frames from the CPU port this
  15  * providing port isolation (no cross talk).
  16  *
  17  * The configuration determines which PHY ports to activate using the
  18  * CONFIG_B53_PHY_PORTS bitmask. Set bit N will active port N and so on.
  19  *
  20  * This driver was written primarily for the Lamobo R1 platform using a BCM53152
  21  * switch but the BCM53xx being largely register compatible, extending it to
  22  * cover other switches would be trivial.
  23  */
  24
  25 #include <common.h>
  26
  27 #include <errno.h>
  28 #include <malloc.h>
  29 #include <miiphy.h>
  30 #include <netdev.h>
  31
  32 /* Pseudo-PHY address (non configurable) to access internal registers */
  33 #define BRCM_PSEUDO_PHY_ADDR            30
  34
  35 /* Maximum number of ports possible */
  36 #define B53_N_PORTS                     9
  37
  38 #define B53_CTRL_PAGE                   0x00 /* Control */
  39 #define B53_MGMT_PAGE                   0x02 /* Management Mode */
  40 /* Port VLAN Page */
  41 #define B53_PVLAN_PAGE                  0x31
  42
  43 /* Control Page registers */
  44 #define B53_PORT_CTRL(i)                (0x00 + (i))
  45 #define   PORT_CTRL_RX_DISABLE          BIT(0)
  46 #define   PORT_CTRL_TX_DISABLE          BIT(1)
  47 #define   PORT_CTRL_RX_BCST_EN          BIT(2) /* Broadcast RX (P8 only) */
  48 #define   PORT_CTRL_RX_MCST_EN          BIT(3) /* Multicast RX (P8 only) */
  49 #define   PORT_CTRL_RX_UCST_EN          BIT(4) /* Unicast RX (P8 only) */
  50
  51 /* Switch Mode Control Register (8 bit) */
  52 #define B53_SWITCH_MODE                 0x0b
  53 #define   SM_SW_FWD_MODE                BIT(0)  /* 1 = Managed Mode */
  54 #define   SM_SW_FWD_EN                  BIT(1)  /* Forwarding Enable */
  55
  56 /* IMP Port state override register (8 bit) */
  57 #define B53_PORT_OVERRIDE_CTRL          0x0e
  58 #define   PORT_OVERRIDE_LINK            BIT(0)
  59 #define   PORT_OVERRIDE_FULL_DUPLEX     BIT(1) /* 0 = Half Duplex */
  60 #define   PORT_OVERRIDE_SPEED_S         2
  61 #define   PORT_OVERRIDE_SPEED_10M       (0 << PORT_OVERRIDE_SPEED_S)
  62 #define   PORT_OVERRIDE_SPEED_100M      (1 << PORT_OVERRIDE_SPEED_S)
  63 #define   PORT_OVERRIDE_SPEED_1000M     (2 << PORT_OVERRIDE_SPEED_S)
  64 /* BCM5325 only */
  65 #define   PORT_OVERRIDE_RV_MII_25       BIT(4)
  66 #define   PORT_OVERRIDE_RX_FLOW         BIT(4)
  67 #define   PORT_OVERRIDE_TX_FLOW         BIT(5)
  68 /* BCM5301X only, requires setting 1000M */
  69 #define   PORT_OVERRIDE_SPEED_2000M     BIT(6)
  70 #define   PORT_OVERRIDE_EN              BIT(7) /* Use the register contents */
  71
  72 #define B53_RGMII_CTRL_IMP              0x60
  73 #define   RGMII_CTRL_ENABLE_GMII        BIT(7)
  74 #define   RGMII_CTRL_TIMING_SEL         BIT(2)
  75 #define   RGMII_CTRL_DLL_RXC            BIT(1)
  76 #define   RGMII_CTRL_DLL_TXC            BIT(0)
  77
  78 /* Switch control (8 bit) */
  79 #define B53_SWITCH_CTRL                 0x22
  80 #define  B53_MII_DUMB_FWDG_EN           BIT(6)
  81
  82 /* Software reset register (8 bit) */
  83 #define B53_SOFTRESET                   0x79
  84 #define   SW_RST                        BIT(7)
  85 #define   EN_CH_RST                     BIT(6)
  86 #define   EN_SW_RST                     BIT(4)
  87
  88 /* Fast Aging Control register (8 bit) */
  89 #define B53_FAST_AGE_CTRL               0x88
  90 #define   FAST_AGE_STATIC               BIT(0)
  91 #define   FAST_AGE_DYNAMIC              BIT(1)
  92 #define   FAST_AGE_PORT                 BIT(2)
  93 #define   FAST_AGE_VLAN                 BIT(3)
  94 #define   FAST_AGE_STP                  BIT(4)
  95 #define   FAST_AGE_MC                   BIT(5)
  96 #define   FAST_AGE_DONE                 BIT(7)
  97
  98 /* Port VLAN mask (16 bit) IMP port is always 8, also on 5325 & co */
  99 #define B53_PVLAN_PORT_MASK(i)          ((i) * 2)
 100
 101 /* MII registers */
 102 #define REG_MII_PAGE    0x10    /* MII Page register */
 103 #define REG_MII_ADDR    0x11    /* MII Address register */
 104 #define REG_MII_DATA0   0x18    /* MII Data register 0 */
 105 #define REG_MII_DATA1   0x19    /* MII Data register 1 */
 106 #define REG_MII_DATA2   0x1a    /* MII Data register 2 */
 107 #define REG_MII_DATA3   0x1b    /* MII Data register 3 */
 108
 109 #define REG_MII_PAGE_ENABLE     BIT(0)
 110 #define REG_MII_ADDR_WRITE      BIT(0)
 111 #define REG_MII_ADDR_READ       BIT(1)
 112
 113 struct b53_device {
 114         struct mii_dev  *bus;
 115         unsigned int cpu_port;
 116 };
 117
 118 static int b53_mdio_op(struct mii_dev *bus, u8 page, u8 reg, u16 op)
 119 {
 120         int ret;
 121         int i;
 122         u16 v;
 123
 124         /* set page number */
 125         v = (page << 8) | REG_MII_PAGE_ENABLE;
 126         ret = bus->write(bus, BRCM_PSEUDO_PHY_ADDR, MDIO_DEVAD_NONE,
 127                          REG_MII_PAGE, v);
 128         if (ret)
 129                 return ret;
 130
 131         /* set register address */
 132         v = (reg << 8) | op;
 133         ret = bus->write(bus, BRCM_PSEUDO_PHY_ADDR, MDIO_DEVAD_NONE,
 134                          REG_MII_ADDR, v);
 135         if (ret)
 136                 return ret;
 137
 138         /* check if operation completed */
 139         for (i = 0; i < 5; ++i) {
 140                 v = bus->read(bus, BRCM_PSEUDO_PHY_ADDR, MDIO_DEVAD_NONE,
 141                               REG_MII_ADDR);
 142                 if (!(v & (REG_MII_ADDR_WRITE | REG_MII_ADDR_READ)))
 143                         break;
 144
 145                 udelay(100);
 146         }
 147
 148         if (i == 5)
 149                 return -EIO;
 150
 151         return 0;
 152 }
 153
 154 static int b53_mdio_read8(struct mii_dev *bus, u8 page, u8 reg, u8 *val)
 155 {
 156         int ret;
 157
 158         ret = b53_mdio_op(bus, page, reg, REG_MII_ADDR_READ);
 159         if (ret)
 160                 return ret;
 161
 162         *val = bus->read(bus, BRCM_PSEUDO_PHY_ADDR, MDIO_DEVAD_NONE,
 163                          REG_MII_DATA0) & 0xff;
 164
 165         return 0;
 166 }
 167
 168 static int b53_mdio_read16(struct mii_dev *bus, u8 page, u8 reg, u16 *val)
 169 {
 170         int ret;
 171
 172         ret = b53_mdio_op(bus, page, reg, REG_MII_ADDR_READ);
 173         if (ret)
 174                 return ret;
 175
 176         *val = bus->read(bus, BRCM_PSEUDO_PHY_ADDR, MDIO_DEVAD_NONE,
 177                          REG_MII_DATA0);
 178
 179         return 0;
 180 }
 181
 182 static int b53_mdio_read32(struct mii_dev *bus, u8 page, u8 reg, u32 *val)
 183 {
 184         int ret;
 185
 186         ret = b53_mdio_op(bus, page, reg, REG_MII_ADDR_READ);
 187         if (ret)
 188                 return ret;
 189
 190         *val = bus->read(bus, BRCM_PSEUDO_PHY_ADDR, MDIO_DEVAD_NONE,
 191                          REG_MII_DATA0);
 192         *val |= bus->read(bus, BRCM_PSEUDO_PHY_ADDR, MDIO_DEVAD_NONE,
 193                           REG_MII_DATA1) << 16;
 194
 195         return 0;
 196 }
 197
 198 static int b53_mdio_read48(struct mii_dev *bus, u8 page, u8 reg, u64 *val)
 199 {
 200         u64 temp = 0;
 201         int i;
 202         int ret;
 203
 204         ret = b53_mdio_op(bus, page, reg, REG_MII_ADDR_READ);
 205         if (ret)
 206                 return ret;
 207
 208         for (i = 2; i >= 0; i--) {
 209                 temp <<= 16;
 210                 temp |= bus->read(bus, BRCM_PSEUDO_PHY_ADDR, MDIO_DEVAD_NONE,
 211                                   REG_MII_DATA0 + i);
 212         }
 213
 214         *val = temp;
 215
 216         return 0;
 217 }
 218
 219 static int b53_mdio_read64(struct mii_dev *bus, u8 page, u8 reg, u64 *val)
 220 {
 221         u64 temp = 0;
 222         int i;
 223         int ret;
 224
 225         ret = b53_mdio_op(bus, page, reg, REG_MII_ADDR_READ);
 226         if (ret)
 227                 return ret;
 228
 229         for (i = 3; i >= 0; i--) {
 230                 temp <<= 16;
 231                 temp |= bus->read(bus, BRCM_PSEUDO_PHY_ADDR, MDIO_DEVAD_NONE,
 232                                   REG_MII_DATA0 + i);
 233         }
 234
 235         *val = temp;
 236
 237         return 0;
 238 }
 239
 240 static int b53_mdio_write8(struct mii_dev *bus, u8 page, u8 reg, u8 value)
 241 {
 242         int ret;
 243
 244         ret = bus->write(bus, BRCM_PSEUDO_PHY_ADDR, MDIO_DEVAD_NONE,
 245                          REG_MII_DATA0, value);
 246         if (ret)
 247                 return ret;
 248
 249         return b53_mdio_op(bus, page, reg, REG_MII_ADDR_WRITE);
 250 }
 251
 252 static int b53_mdio_write16(struct mii_dev *bus, u8 page, u8 reg,
 253                             u16 value)
 254 {
 255         int ret;
 256
 257         ret = bus->write(bus, BRCM_PSEUDO_PHY_ADDR, MDIO_DEVAD_NONE,
 258                          REG_MII_DATA0, value);
 259         if (ret)
 260                 return ret;
 261
 262         return b53_mdio_op(bus, page, reg, REG_MII_ADDR_WRITE);
 263 }
 264
 265 static int b53_mdio_write32(struct mii_dev *bus, u8 page, u8 reg,
 266                             u32 value)
 267 {
 268         unsigned int i;
 269         u32 temp = value;
 270
 271         for (i = 0; i < 2; i++) {
 272                 int ret = bus->write(bus, BRCM_PSEUDO_PHY_ADDR,
 273                                      MDIO_DEVAD_NONE,
 274                                      REG_MII_DATA0 + i, temp & 0xffff);
 275                 if (ret)
 276                         return ret;
 277                 temp >>= 16;
 278         }
 279
 280         return b53_mdio_op(bus, page, reg, REG_MII_ADDR_WRITE);
 281 }
 282
 283 static int b53_mdio_write48(struct mii_dev *bus, u8 page, u8 reg,
 284                             u64 value)
 285 {
 286         unsigned int i;
 287         u64 temp = value;
 288
 289         for (i = 0; i < 3; i++) {
 290                 int ret = bus->write(bus, BRCM_PSEUDO_PHY_ADDR,
 291                                      MDIO_DEVAD_NONE,
 292                                      REG_MII_DATA0 + i, temp & 0xffff);
 293                 if (ret)
 294                         return ret;
 295                 temp >>= 16;
 296         }
 297
 298         return b53_mdio_op(bus, page, reg, REG_MII_ADDR_WRITE);
 299 }
 300
 301 static int b53_mdio_write64(struct mii_dev *bus, u8 page, u8 reg,
 302                             u64 value)
 303 {
 304         unsigned int i;
 305         u64 temp = value;
 306
 307         for (i = 0; i < 4; i++) {
 308                 int ret = bus->write(bus, BRCM_PSEUDO_PHY_ADDR,
 309                                      MDIO_DEVAD_NONE,
 310                                      REG_MII_DATA0 + i, temp & 0xffff);
 311                 if (ret)
 312                         return ret;
 313                 temp >>= 16;
 314         }
 315
 316         return b53_mdio_op(bus, page, reg, REG_MII_ADDR_WRITE);
 317 }
 318
 319 static inline int b53_read8(struct b53_device *dev, u8 page,
 320                             u8 reg, u8 *value)
 321 {
 322         return b53_mdio_read8(dev->bus, page, reg, value);
 323 }
 324
 325 static inline int b53_read16(struct b53_device *dev, u8 page,
 326                              u8 reg, u16 *value)
 327 {
 328         return b53_mdio_read16(dev->bus, page, reg, value);
 329 }
 330
 331 static inline int b53_read32(struct b53_device *dev, u8 page,
 332                              u8 reg, u32 *value)
 333 {
 334         return b53_mdio_read32(dev->bus, page, reg, value);
 335 }
 336
 337 static inline int b53_read48(struct b53_device *dev, u8 page,
 338                              u8 reg, u64 *value)
 339 {
 340         return b53_mdio_read48(dev->bus, page, reg, value);
 341 }
 342
 343 static inline int b53_read64(struct b53_device *dev, u8 page,
 344                              u8 reg, u64 *value)
 345 {
 346         return b53_mdio_read64(dev->bus, page, reg, value);
 347 }
 348
 349 static inline int b53_write8(struct b53_device *dev, u8 page,
 350                              u8 reg, u8 value)
 351 {
 352         return b53_mdio_write8(dev->bus, page, reg, value);
 353 }
 354
 355 static inline int b53_write16(struct b53_device *dev, u8 page,
 356                               u8 reg, u16 value)
 357 {
 358         return b53_mdio_write16(dev->bus, page, reg, value);
 359 }
 360
 361 static inline int b53_write32(struct b53_device *dev, u8 page,
 362                               u8 reg, u32 value)
 363 {
 364         return b53_mdio_write32(dev->bus, page, reg, value);
 365 }
 366
 367 static inline int b53_write48(struct b53_device *dev, u8 page,
 368                               u8 reg, u64 value)
 369 {
 370         return b53_mdio_write48(dev->bus, page, reg, value);
 371 }
 372
 373 static inline int b53_write64(struct b53_device *dev, u8 page,
 374                               u8 reg, u64 value)
 375 {
 376         return b53_mdio_write64(dev->bus, page, reg, value);
 377 }
 378
 379 static int b53_flush_arl(struct b53_device *dev, u8 mask)
 380 {
 381         unsigned int i;
 382
 383         b53_write8(dev, B53_CTRL_PAGE, B53_FAST_AGE_CTRL,
 384                    FAST_AGE_DONE | FAST_AGE_DYNAMIC | mask);
 385
 386         for (i = 0; i < 10; i++) {
 387                 u8 fast_age_ctrl;
 388
 389                 b53_read8(dev, B53_CTRL_PAGE, B53_FAST_AGE_CTRL,
 390                           &fast_age_ctrl);
 391
 392                 if (!(fast_age_ctrl & FAST_AGE_DONE))
 393                         goto out;
 394
 395                 mdelay(1);
 396         }
 397
 398         return -ETIMEDOUT;
 399 out:
 400         /* Only age dynamic entries (default behavior) */
 401         b53_write8(dev, B53_CTRL_PAGE, B53_FAST_AGE_CTRL, FAST_AGE_DYNAMIC);
 402         return 0;
 403 }
 404
 405 static int b53_switch_reset(struct phy_device *phydev)
 406 {
 407         struct b53_device *dev = phydev->priv;
 408         unsigned int timeout = 1000;
 409         u8 mgmt;
 410         u8 reg;
 411
 412         b53_read8(dev, B53_CTRL_PAGE, B53_SOFTRESET, &reg);
 413         reg |= SW_RST | EN_SW_RST | EN_CH_RST;
 414         b53_write8(dev, B53_CTRL_PAGE, B53_SOFTRESET, reg);
 415
 416         do {
 417                 b53_read8(dev, B53_CTRL_PAGE, B53_SOFTRESET, &reg);
 418                 if (!(reg & SW_RST))
 419                         break;
 420
 421                 mdelay(1);
 422         } while (timeout-- > 0);
 423
 424         if (timeout == 0)
 425                 return -ETIMEDOUT;
 426
 427         b53_read8(dev, B53_CTRL_PAGE, B53_SWITCH_MODE, &mgmt);
 428
 429         if (!(mgmt & SM_SW_FWD_EN)) {
 430                 mgmt &= ~SM_SW_FWD_MODE;
 431                 mgmt |= SM_SW_FWD_EN;
 432
 433                 b53_write8(dev, B53_CTRL_PAGE, B53_SWITCH_MODE, mgmt);
 434                 b53_read8(dev, B53_CTRL_PAGE, B53_SWITCH_MODE, &mgmt);
 435
 436                 if (!(mgmt & SM_SW_FWD_EN)) {
 437                         printf("Failed to enable switch!\n");
 438                         return -EINVAL;
 439                 }
 440         }
 441
 442         /* Include IMP port in dumb forwarding mode when no tagging protocol
 443          * is configured
 444          */
 445         b53_read8(dev, B53_CTRL_PAGE, B53_SWITCH_CTRL, &mgmt);
 446         mgmt |= B53_MII_DUMB_FWDG_EN;
 447         b53_write8(dev, B53_CTRL_PAGE, B53_SWITCH_CTRL, mgmt);
 448
 449         return b53_flush_arl(dev, FAST_AGE_STATIC);
 450 }
 451
 452 static void b53_enable_cpu_port(struct phy_device *phydev)
 453 {
 454         struct b53_device *dev = phydev->priv;
 455         u8 port_ctrl;
 456
 457         port_ctrl = PORT_CTRL_RX_BCST_EN |
 458                     PORT_CTRL_RX_MCST_EN |
 459                     PORT_CTRL_RX_UCST_EN;
 460         b53_write8(dev, B53_CTRL_PAGE, B53_PORT_CTRL(dev->cpu_port), port_ctrl);
 461
 462         port_ctrl = PORT_OVERRIDE_EN | PORT_OVERRIDE_LINK |
 463                     PORT_OVERRIDE_FULL_DUPLEX | PORT_OVERRIDE_SPEED_1000M;
 464         b53_write8(dev, B53_CTRL_PAGE, B53_PORT_OVERRIDE_CTRL, port_ctrl);
 465
 466         b53_read8(dev, B53_CTRL_PAGE, B53_RGMII_CTRL_IMP, &port_ctrl);
 467 }
 468
 469 static void b53_imp_vlan_setup(struct b53_device *dev, int cpu_port)
 470 {
 471         unsigned int port;
 472         u16 pvlan;
 473
 474         /* Enable the IMP port to be in the same VLAN as the other ports
 475          * on a per-port basis such that we only have Port i and IMP in
 476          * the same VLAN.
 477          */
 478         for (port = 0; port < B53_N_PORTS; port++) {
 479                 if (!((1 << port) & CONFIG_B53_PHY_PORTS))
 480                         continue;
 481
 482                 b53_read16(dev, B53_PVLAN_PAGE, B53_PVLAN_PORT_MASK(port),
 483                            &pvlan);
 484                 pvlan |= BIT(cpu_port);
 485                 b53_write16(dev, B53_PVLAN_PAGE, B53_PVLAN_PORT_MASK(port),
 486                             pvlan);
 487         }
 488 }
 489
 490 static int b53_port_enable(struct phy_device *phydev, unsigned int port)
 491 {
 492         struct b53_device *dev = phydev->priv;
 493         unsigned int cpu_port = dev->cpu_port;
 494         u16 pvlan;
 495
 496         /* Clear the Rx and Tx disable bits and set to no spanning tree */
 497         b53_write8(dev, B53_CTRL_PAGE, B53_PORT_CTRL(port), 0);
 498
 499         /* Set this port, and only this one to be in the default VLAN */
 500         b53_read16(dev, B53_PVLAN_PAGE, B53_PVLAN_PORT_MASK(port), &pvlan);
 501         pvlan &= ~0x1ff;
 502         pvlan |= BIT(port);
 503         b53_write16(dev, B53_PVLAN_PAGE, B53_PVLAN_PORT_MASK(port), pvlan);
 504
 505         b53_imp_vlan_setup(dev, cpu_port);
 506
 507         return 0;
 508 }
 509
 510 static int b53_switch_init(struct phy_device *phydev)
 511 {
 512         static int init;
 513         int ret;
 514
 515         if (init)
 516                 return 0;
 517
 518         ret = b53_switch_reset(phydev);
 519         if (ret < 0)
 520                 return ret;
 521
 522         b53_enable_cpu_port(phydev);
 523
 524         init = 1;
 525
 526         return 0;
 527 }
 528
 529 static int b53_probe(struct phy_device *phydev)
 530 {
 531         struct b53_device *dev;
 532         int ret;
 533
 534         dev = malloc(sizeof(*dev));
 535         if (!dev)
 536                 return -ENOMEM;
 537
 538         memset(dev, 0, sizeof(*dev));
 539
 540         phydev->priv = dev;
 541         dev->bus = phydev->bus;
 542         dev->cpu_port = CONFIG_B53_CPU_PORT;
 543
 544         ret = b53_switch_reset(phydev);
 545         if (ret < 0)
 546                 return ret;
 547
 548         return 0;
 549 }
 550
 551 static int b53_phy_config(struct phy_device *phydev)
 552 {
 553         unsigned int port;
 554         int res;
 555
 556         res = b53_switch_init(phydev);
 557         if (res < 0)
 558                 return res;
 559
 560         for (port = 0; port < B53_N_PORTS; port++) {
 561                 if (!((1 << port) & CONFIG_B53_PHY_PORTS))
 562                         continue;
 563
 564                 res = b53_port_enable(phydev, port);
 565                 if (res < 0) {
 566                         printf("Error enabling port %i\n", port);
 567                         continue;
 568                 }
 569
 570                 res = genphy_config_aneg(phydev);
 571                 if (res < 0) {
 572                         printf("Error setting PHY %i autoneg\n", port);
 573                         continue;
 574                 }
 575
 576                 res = 0;
 577         }
 578
 579         return res;
 580 }
 581
 582 static int b53_phy_startup(struct phy_device *phydev)
 583 {
 584         unsigned int port;
 585         int res;
 586
 587         for (port = 0; port < B53_N_PORTS; port++) {
 588                 if (!((1 << port) & CONFIG_B53_PHY_PORTS))
 589                         continue;
 590
 591                 phydev->addr = port;
 592
 593                 res = genphy_startup(phydev);
 594                 if (res < 0)
 595                         continue;
 596                 else
 597                         break;
 598         }
 599
 600         /* Since we are connected directly to the switch, hardcode the link
 601          * parameters to match those of the CPU port configured in
 602          * b53_enable_cpu_port, we cannot be dependent on the user-facing port
 603          * settings (e.g: 100Mbits/sec would not work here)
 604          */
 605         phydev->speed = 1000;
 606         phydev->duplex = 1;
 607         phydev->link = 1;
 608
 609         return 0;
 610 }
 611
 612 static struct phy_driver b53_driver = {
 613         .name = "Broadcom BCM53125",
 614         .uid = 0x03625c00,
 615         .mask = 0xfffffc00,
 616         .features = PHY_GBIT_FEATURES,
 617         .probe = b53_probe,
 618         .config = b53_phy_config,
 619         .startup = b53_phy_startup,
 620         .shutdown = &genphy_shutdown,
 621 };
 622
 623 int phy_b53_init(void)
 624 {
 625         phy_register(&b53_driver);
 626
 627         return 0;
 628 }
 629
 630 int do_b53_reg_read(const char *name, int argc, char * const argv[])
 631 {
 632         u8 page, offset, width;
 633         struct mii_dev *bus;
 634         int ret = -EINVAL;
 635         u64 value64 = 0;
 636         u32 value32 = 0;
 637         u16 value16 = 0;
 638         u8 value8 = 0;
 639
 640         bus = miiphy_get_dev_by_name(name);
 641         if (!bus) {
 642                 printf("unable to find MDIO bus: %s\n", name);
 643                 return ret;
 644         }
 645
 646         page = simple_strtoul(argv[1], NULL, 16);
 647         offset = simple_strtoul(argv[2], NULL, 16);
 648         width = simple_strtoul(argv[3], NULL, 10);
 649
 650         switch (width) {
 651         case 8:
 652                 ret = b53_mdio_read8(bus, page, offset, &value8);
 653                 printf("page=0x%02x, offset=0x%02x, value=0x%02x\n",
 654                        page, offset, value8);
 655                 break;
 656         case 16:
 657                 ret = b53_mdio_read16(bus, page, offset, &value16);
 658                 printf("page=0x%02x, offset=0x%02x, value=0x%04x\n",
 659                        page, offset, value16);
 660                 break;
 661         case 32:
 662                 ret = b53_mdio_read32(bus, page, offset, &value32);
 663                 printf("page=0x%02x, offset=0x%02x, value=0x%08x\n",
 664                        page, offset, value32);
 665                 break;
 666         case 48:
 667                 ret = b53_mdio_read48(bus, page, offset, &value64);
 668                 printf("page=0x%02x, offset=0x%02x, value=0x%012llx\n",
 669                        page, offset, value64);
 670                 break;
 671         case 64:
 672                 ret = b53_mdio_read48(bus, page, offset, &value64);
 673                 printf("page=0x%02x, offset=0x%02x, value=0x%016llx\n",
 674                        page, offset, value64);
 675                 break;
 676         default:
 677                 printf("Unsupported width: %d\n", width);
 678                 break;
 679         }
 680
 681         return ret;
 682 }
 683
 684 int do_b53_reg_write(const char *name, int argc, char * const argv[])
 685 {
 686         u8 page, offset, width;
 687         struct mii_dev *bus;
 688         int ret = -EINVAL;
 689         u64 value64 = 0;
 690         u32 value = 0;
 691
 692         bus = miiphy_get_dev_by_name(name);
 693         if (!bus) {
 694                 printf("unable to find MDIO bus: %s\n", name);
 695                 return ret;
 696         }
 697
 698         page = simple_strtoul(argv[1], NULL, 16);
 699         offset = simple_strtoul(argv[2], NULL, 16);
 700         width = simple_strtoul(argv[3], NULL, 10);
 701         if (width == 48 || width == 64)
 702                 value64 = simple_strtoull(argv[4], NULL, 16);
 703         else
 704                 value = simple_strtoul(argv[4], NULL, 16);
 705
 706         switch (width) {
 707         case 8:
 708                 ret = b53_mdio_write8(bus, page, offset, value & 0xff);
 709                 break;
 710         case 16:
 711                 ret = b53_mdio_write16(bus, page, offset, value);
 712                 break;
 713         case 32:
 714                 ret = b53_mdio_write32(bus, page, offset, value);
 715                 break;
 716         case 48:
 717                 ret = b53_mdio_write48(bus, page, offset, value64);
 718                 break;
 719         case 64:
 720                 ret = b53_mdio_write64(bus, page, offset, value64);
 721                 break;
 722         default:
 723                 printf("Unsupported width: %d\n", width);
 724                 break;
 725         }
 726
 727         return ret;
 728 }
 729
 730 int do_b53_reg(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 731 {
 732         const char *cmd, *mdioname;
 733         int ret = 0;
 734
 735         if (argc < 2)
 736                 return cmd_usage(cmdtp);
 737
 738         cmd = argv[1];
 739         --argc;
 740         ++argv;
 741
 742         if (!strcmp(cmd, "write")) {
 743                 if (argc < 4)
 744                         return cmd_usage(cmdtp);
 745                 mdioname = argv[1];
 746                 --argc;
 747                 ++argv;
 748                 ret = do_b53_reg_write(mdioname, argc, argv);
 749         } else if (!strcmp(cmd, "read")) {
 750                 if (argc < 5)
 751                         return cmd_usage(cmdtp);
 752                 mdioname = argv[1];
 753                 --argc;
 754                 ++argv;
 755                 ret = do_b53_reg_read(mdioname, argc, argv);
 756         } else {
 757                 return cmd_usage(cmdtp);
 758         }
 759
 760         return ret;
 761 }
 762
 763 U_BOOT_CMD(b53_reg, 7, 1, do_b53_reg,
 764            "Broadcom B53 switch register access",
 765            "write mdioname page (hex) offset (hex) width (dec) value (hex)\n"
 766            "read mdioname page (hex) offset (hex) width (dec)\n"
 767           );