drivers/net/dsa/mv88e6xxx.c

   1 /*
   2  * net/dsa/mv88e6xxx.c - Marvell 88e6xxx switch chip support
   3  * Copyright (c) 2008 Marvell Semiconductor
   4  *
   5  * Copyright (c) 2015 CMC Electronics, Inc.
   6  *      Added support for VLAN Table Unit operations
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  */
  13
  14 #include <linux/debugfs.h>
  15 #include <linux/delay.h>
  16 #include <linux/etherdevice.h>
  17 #include <linux/ethtool.h>
  18 #include <linux/if_bridge.h>
  19 #include <linux/jiffies.h>
  20 #include <linux/list.h>
  21 #include <linux/module.h>
  22 #include <linux/netdevice.h>
  23 #include <linux/phy.h>
  24 #include <linux/seq_file.h>
  25 #include <net/dsa.h>
  26 #include "mv88e6xxx.h"
  27
  28 /* MDIO bus access can be nested in the case of PHYs connected to the
  29  * internal MDIO bus of the switch, which is accessed via MDIO bus of
  30  * the Ethernet interface. Avoid lockdep false positives by using
  31  * mutex_lock_nested().
  32  */
  33 static int mv88e6xxx_mdiobus_read(struct mii_bus *bus, int addr, u32 regnum)
  34 {
  35         int ret;
  36
  37         mutex_lock_nested(&bus->mdio_lock, SINGLE_DEPTH_NESTING);
  38         ret = bus->read(bus, addr, regnum);
  39         mutex_unlock(&bus->mdio_lock);
  40
  41         return ret;
  42 }
  43
  44 static int mv88e6xxx_mdiobus_write(struct mii_bus *bus, int addr, u32 regnum,
  45                                    u16 val)
  46 {
  47         int ret;
  48
  49         mutex_lock_nested(&bus->mdio_lock, SINGLE_DEPTH_NESTING);
  50         ret = bus->write(bus, addr, regnum, val);
  51         mutex_unlock(&bus->mdio_lock);
  52
  53         return ret;
  54 }
  55
  56 /* If the switch's ADDR[4:0] strap pins are strapped to zero, it will
  57  * use all 32 SMI bus addresses on its SMI bus, and all switch registers
  58  * will be directly accessible on some {device address,register address}
  59  * pair.  If the ADDR[4:0] pins are not strapped to zero, the switch
  60  * will only respond to SMI transactions to that specific address, and
  61  * an indirect addressing mechanism needs to be used to access its
  62  * registers.
  63  */
  64 static int mv88e6xxx_reg_wait_ready(struct mii_bus *bus, int sw_addr)
  65 {
  66         int ret;
  67         int i;
  68
  69         for (i = 0; i < 16; i++) {
  70                 ret = mv88e6xxx_mdiobus_read(bus, sw_addr, SMI_CMD);
  71                 if (ret < 0)
  72                         return ret;
  73
  74                 if ((ret & SMI_CMD_BUSY) == 0)
  75                         return 0;
  76         }
  77
  78         return -ETIMEDOUT;
  79 }
  80
  81 int __mv88e6xxx_reg_read(struct mii_bus *bus, int sw_addr, int addr, int reg)
  82 {
  83         int ret;
  84
  85         if (sw_addr == 0)
  86                 return mv88e6xxx_mdiobus_read(bus, addr, reg);
  87
  88         /* Wait for the bus to become free. */
  89         ret = mv88e6xxx_reg_wait_ready(bus, sw_addr);
  90         if (ret < 0)
  91                 return ret;
  92
  93         /* Transmit the read command. */
  94         ret = mv88e6xxx_mdiobus_write(bus, sw_addr, SMI_CMD,
  95                                       SMI_CMD_OP_22_READ | (addr << 5) | reg);
  96         if (ret < 0)
  97                 return ret;
  98
  99         /* Wait for the read command to complete. */
 100         ret = mv88e6xxx_reg_wait_ready(bus, sw_addr);
 101         if (ret < 0)
 102                 return ret;
 103
 104         /* Read the data. */
 105         ret = mv88e6xxx_mdiobus_read(bus, sw_addr, SMI_DATA);
 106         if (ret < 0)
 107                 return ret;
 108
 109         return ret & 0xffff;
 110 }
 111
 112 /* Must be called with SMI mutex held */
 113 static int _mv88e6xxx_reg_read(struct dsa_switch *ds, int addr, int reg)
 114 {
 115         struct mii_bus *bus = dsa_host_dev_to_mii_bus(ds->master_dev);
 116         int ret;
 117
 118         if (bus == NULL)
 119                 return -EINVAL;
 120
 121         ret = __mv88e6xxx_reg_read(bus, ds->pd->sw_addr, addr, reg);
 122         if (ret < 0)
 123                 return ret;
 124
 125         dev_dbg(ds->master_dev, "<- addr: 0x%.2x reg: 0x%.2x val: 0x%.4x\n",
 126                 addr, reg, ret);
 127
 128         return ret;
 129 }
 130
 131 int mv88e6xxx_reg_read(struct dsa_switch *ds, int addr, int reg)
 132 {
 133         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
 134         int ret;
 135
 136         mutex_lock(&ps->smi_mutex);
 137         ret = _mv88e6xxx_reg_read(ds, addr, reg);
 138         mutex_unlock(&ps->smi_mutex);
 139
 140         return ret;
 141 }
 142
 143 int __mv88e6xxx_reg_write(struct mii_bus *bus, int sw_addr, int addr,
 144                           int reg, u16 val)
 145 {
 146         int ret;
 147
 148         if (sw_addr == 0)
 149                 return mv88e6xxx_mdiobus_write(bus, addr, reg, val);
 150
 151         /* Wait for the bus to become free. */
 152         ret = mv88e6xxx_reg_wait_ready(bus, sw_addr);
 153         if (ret < 0)
 154                 return ret;
 155
 156         /* Transmit the data to write. */
 157         ret = mv88e6xxx_mdiobus_write(bus, sw_addr, SMI_DATA, val);
 158         if (ret < 0)
 159                 return ret;
 160
 161         /* Transmit the write command. */
 162         ret = mv88e6xxx_mdiobus_write(bus, sw_addr, SMI_CMD,
 163                                       SMI_CMD_OP_22_WRITE | (addr << 5) | reg);
 164         if (ret < 0)
 165                 return ret;
 166
 167         /* Wait for the write command to complete. */
 168         ret = mv88e6xxx_reg_wait_ready(bus, sw_addr);
 169         if (ret < 0)
 170                 return ret;
 171
 172         return 0;
 173 }
 174
 175 /* Must be called with SMI mutex held */
 176 static int _mv88e6xxx_reg_write(struct dsa_switch *ds, int addr, int reg,
 177                                 u16 val)
 178 {
 179         struct mii_bus *bus = dsa_host_dev_to_mii_bus(ds->master_dev);
 180
 181         if (bus == NULL)
 182                 return -EINVAL;
 183
 184         dev_dbg(ds->master_dev, "-> addr: 0x%.2x reg: 0x%.2x val: 0x%.4x\n",
 185                 addr, reg, val);
 186
 187         return __mv88e6xxx_reg_write(bus, ds->pd->sw_addr, addr, reg, val);
 188 }
 189
 190 int mv88e6xxx_reg_write(struct dsa_switch *ds, int addr, int reg, u16 val)
 191 {
 192         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
 193         int ret;
 194
 195         mutex_lock(&ps->smi_mutex);
 196         ret = _mv88e6xxx_reg_write(ds, addr, reg, val);
 197         mutex_unlock(&ps->smi_mutex);
 198
 199         return ret;
 200 }
 201
 202 int mv88e6xxx_set_addr_direct(struct dsa_switch *ds, u8 *addr)
 203 {
 204         REG_WRITE(REG_GLOBAL, GLOBAL_MAC_01, (addr[0] << 8) | addr[1]);
 205         REG_WRITE(REG_GLOBAL, GLOBAL_MAC_23, (addr[2] << 8) | addr[3]);
 206         REG_WRITE(REG_GLOBAL, GLOBAL_MAC_45, (addr[4] << 8) | addr[5]);
 207
 208         return 0;
 209 }
 210
 211 int mv88e6xxx_set_addr_indirect(struct dsa_switch *ds, u8 *addr)
 212 {
 213         int i;
 214         int ret;
 215
 216         for (i = 0; i < 6; i++) {
 217                 int j;
 218
 219                 /* Write the MAC address byte. */
 220                 REG_WRITE(REG_GLOBAL2, GLOBAL2_SWITCH_MAC,
 221                           GLOBAL2_SWITCH_MAC_BUSY | (i << 8) | addr[i]);
 222
 223                 /* Wait for the write to complete. */
 224                 for (j = 0; j < 16; j++) {
 225                         ret = REG_READ(REG_GLOBAL2, GLOBAL2_SWITCH_MAC);
 226                         if ((ret & GLOBAL2_SWITCH_MAC_BUSY) == 0)
 227                                 break;
 228                 }
 229                 if (j == 16)
 230                         return -ETIMEDOUT;
 231         }
 232
 233         return 0;
 234 }
 235
 236 /* Must be called with SMI mutex held */
 237 static int _mv88e6xxx_phy_read(struct dsa_switch *ds, int addr, int regnum)
 238 {
 239         if (addr >= 0)
 240                 return _mv88e6xxx_reg_read(ds, addr, regnum);
 241         return 0xffff;
 242 }
 243
 244 /* Must be called with SMI mutex held */
 245 static int _mv88e6xxx_phy_write(struct dsa_switch *ds, int addr, int regnum,
 246                                 u16 val)
 247 {
 248         if (addr >= 0)
 249                 return _mv88e6xxx_reg_write(ds, addr, regnum, val);
 250         return 0;
 251 }
 252
 253 #ifdef CONFIG_NET_DSA_MV88E6XXX_NEED_PPU
 254 static int mv88e6xxx_ppu_disable(struct dsa_switch *ds)
 255 {
 256         int ret;
 257         unsigned long timeout;
 258
 259         ret = REG_READ(REG_GLOBAL, GLOBAL_CONTROL);
 260         REG_WRITE(REG_GLOBAL, GLOBAL_CONTROL,
 261                   ret & ~GLOBAL_CONTROL_PPU_ENABLE);
 262
 263         timeout = jiffies + 1 * HZ;
 264         while (time_before(jiffies, timeout)) {
 265                 ret = REG_READ(REG_GLOBAL, GLOBAL_STATUS);
 266                 usleep_range(1000, 2000);
 267                 if ((ret & GLOBAL_STATUS_PPU_MASK) !=
 268                     GLOBAL_STATUS_PPU_POLLING)
 269                         return 0;
 270         }
 271
 272         return -ETIMEDOUT;
 273 }
 274
 275 static int mv88e6xxx_ppu_enable(struct dsa_switch *ds)
 276 {
 277         int ret;
 278         unsigned long timeout;
 279
 280         ret = REG_READ(REG_GLOBAL, GLOBAL_CONTROL);
 281         REG_WRITE(REG_GLOBAL, GLOBAL_CONTROL, ret | GLOBAL_CONTROL_PPU_ENABLE);
 282
 283         timeout = jiffies + 1 * HZ;
 284         while (time_before(jiffies, timeout)) {
 285                 ret = REG_READ(REG_GLOBAL, GLOBAL_STATUS);
 286                 usleep_range(1000, 2000);
 287                 if ((ret & GLOBAL_STATUS_PPU_MASK) ==
 288                     GLOBAL_STATUS_PPU_POLLING)
 289                         return 0;
 290         }
 291
 292         return -ETIMEDOUT;
 293 }
 294
 295 static void mv88e6xxx_ppu_reenable_work(struct work_struct *ugly)
 296 {
 297         struct mv88e6xxx_priv_state *ps;
 298
 299         ps = container_of(ugly, struct mv88e6xxx_priv_state, ppu_work);
 300         if (mutex_trylock(&ps->ppu_mutex)) {
 301                 struct dsa_switch *ds = ((struct dsa_switch *)ps) - 1;
 302
 303                 if (mv88e6xxx_ppu_enable(ds) == 0)
 304                         ps->ppu_disabled = 0;
 305                 mutex_unlock(&ps->ppu_mutex);
 306         }
 307 }
 308
 309 static void mv88e6xxx_ppu_reenable_timer(unsigned long _ps)
 310 {
 311         struct mv88e6xxx_priv_state *ps = (void *)_ps;
 312
 313         schedule_work(&ps->ppu_work);
 314 }
 315
 316 static int mv88e6xxx_ppu_access_get(struct dsa_switch *ds)
 317 {
 318         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
 319         int ret;
 320
 321         mutex_lock(&ps->ppu_mutex);
 322
 323         /* If the PHY polling unit is enabled, disable it so that
 324          * we can access the PHY registers.  If it was already
 325          * disabled, cancel the timer that is going to re-enable
 326          * it.
 327          */
 328         if (!ps->ppu_disabled) {
 329                 ret = mv88e6xxx_ppu_disable(ds);
 330                 if (ret < 0) {
 331                         mutex_unlock(&ps->ppu_mutex);
 332                         return ret;
 333                 }
 334                 ps->ppu_disabled = 1;
 335         } else {
 336                 del_timer(&ps->ppu_timer);
 337                 ret = 0;
 338         }
 339
 340         return ret;
 341 }
 342
 343 static void mv88e6xxx_ppu_access_put(struct dsa_switch *ds)
 344 {
 345         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
 346
 347         /* Schedule a timer to re-enable the PHY polling unit. */
 348         mod_timer(&ps->ppu_timer, jiffies + msecs_to_jiffies(10));
 349         mutex_unlock(&ps->ppu_mutex);
 350 }
 351
 352 void mv88e6xxx_ppu_state_init(struct dsa_switch *ds)
 353 {
 354         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
 355
 356         mutex_init(&ps->ppu_mutex);
 357         INIT_WORK(&ps->ppu_work, mv88e6xxx_ppu_reenable_work);
 358         init_timer(&ps->ppu_timer);
 359         ps->ppu_timer.data = (unsigned long)ps;
 360         ps->ppu_timer.function = mv88e6xxx_ppu_reenable_timer;
 361 }
 362
 363 int mv88e6xxx_phy_read_ppu(struct dsa_switch *ds, int addr, int regnum)
 364 {
 365         int ret;
 366
 367         ret = mv88e6xxx_ppu_access_get(ds);
 368         if (ret >= 0) {
 369                 ret = mv88e6xxx_reg_read(ds, addr, regnum);
 370                 mv88e6xxx_ppu_access_put(ds);
 371         }
 372
 373         return ret;
 374 }
 375
 376 int mv88e6xxx_phy_write_ppu(struct dsa_switch *ds, int addr,
 377                             int regnum, u16 val)
 378 {
 379         int ret;
 380
 381         ret = mv88e6xxx_ppu_access_get(ds);
 382         if (ret >= 0) {
 383                 ret = mv88e6xxx_reg_write(ds, addr, regnum, val);
 384                 mv88e6xxx_ppu_access_put(ds);
 385         }
 386
 387         return ret;
 388 }
 389 #endif
 390
 391 void mv88e6xxx_poll_link(struct dsa_switch *ds)
 392 {
 393         int i;
 394
 395         for (i = 0; i < DSA_MAX_PORTS; i++) {
 396                 struct net_device *dev;
 397                 int uninitialized_var(port_status);
 398                 int pcs_ctrl;
 399                 int link;
 400                 int speed;
 401                 int duplex;
 402                 int fc;
 403
 404                 dev = ds->ports[i];
 405                 if (dev == NULL)
 406                         continue;
 407
 408                 pcs_ctrl = mv88e6xxx_reg_read(ds, REG_PORT(i), PORT_PCS_CTRL);
 409                 if (pcs_ctrl < 0 || pcs_ctrl & PORT_PCS_CTRL_FORCE_LINK)
 410                         continue;
 411
 412                 link = 0;
 413                 if (dev->flags & IFF_UP) {
 414                         port_status = mv88e6xxx_reg_read(ds, REG_PORT(i),
 415                                                          PORT_STATUS);
 416                         if (port_status < 0)
 417                                 continue;
 418
 419                         link = !!(port_status & PORT_STATUS_LINK);
 420                 }
 421
 422                 if (!link) {
 423                         if (netif_carrier_ok(dev)) {
 424                                 netdev_info(dev, "link down\n");
 425                                 netif_carrier_off(dev);
 426                         }
 427                         continue;
 428                 }
 429
 430                 switch (port_status & PORT_STATUS_SPEED_MASK) {
 431                 case PORT_STATUS_SPEED_10:
 432                         speed = 10;
 433                         break;
 434                 case PORT_STATUS_SPEED_100:
 435                         speed = 100;
 436                         break;
 437                 case PORT_STATUS_SPEED_1000:
 438                         speed = 1000;
 439                         break;
 440                 default:
 441                         speed = -1;
 442                         break;
 443                 }
 444                 duplex = (port_status & PORT_STATUS_DUPLEX) ? 1 : 0;
 445                 fc = (port_status & PORT_STATUS_PAUSE_EN) ? 1 : 0;
 446
 447                 if (!netif_carrier_ok(dev)) {
 448                         netdev_info(dev,
 449                                     "link up, %d Mb/s, %s duplex, flow control %sabled\n",
 450                                     speed,
 451                                     duplex ? "full" : "half",
 452                                     fc ? "en" : "dis");
 453                         netif_carrier_on(dev);
 454                 }
 455         }
 456 }
 457
 458 static bool mv88e6xxx_6065_family(struct dsa_switch *ds)
 459 {
 460         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
 461
 462         switch (ps->id) {
 463         case PORT_SWITCH_ID_6031:
 464         case PORT_SWITCH_ID_6061:
 465         case PORT_SWITCH_ID_6035:
 466         case PORT_SWITCH_ID_6065:
 467                 return true;
 468         }
 469         return false;
 470 }
 471
 472 static bool mv88e6xxx_6095_family(struct dsa_switch *ds)
 473 {
 474         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
 475
 476         switch (ps->id) {
 477         case PORT_SWITCH_ID_6092:
 478         case PORT_SWITCH_ID_6095:
 479                 return true;
 480         }
 481         return false;
 482 }
 483
 484 static bool mv88e6xxx_6097_family(struct dsa_switch *ds)
 485 {
 486         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
 487
 488         switch (ps->id) {
 489         case PORT_SWITCH_ID_6046:
 490         case PORT_SWITCH_ID_6085:
 491         case PORT_SWITCH_ID_6096:
 492         case PORT_SWITCH_ID_6097:
 493                 return true;
 494         }
 495         return false;
 496 }
 497
 498 static bool mv88e6xxx_6165_family(struct dsa_switch *ds)
 499 {
 500         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
 501
 502         switch (ps->id) {
 503         case PORT_SWITCH_ID_6123:
 504         case PORT_SWITCH_ID_6161:
 505         case PORT_SWITCH_ID_6165:
 506                 return true;
 507         }
 508         return false;
 509 }
 510
 511 static bool mv88e6xxx_6185_family(struct dsa_switch *ds)
 512 {
 513         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
 514
 515         switch (ps->id) {
 516         case PORT_SWITCH_ID_6121:
 517         case PORT_SWITCH_ID_6122:
 518         case PORT_SWITCH_ID_6152:
 519         case PORT_SWITCH_ID_6155:
 520         case PORT_SWITCH_ID_6182:
 521         case PORT_SWITCH_ID_6185:
 522         case PORT_SWITCH_ID_6108:
 523         case PORT_SWITCH_ID_6131:
 524                 return true;
 525         }
 526         return false;
 527 }
 528
 529 static bool mv88e6xxx_6320_family(struct dsa_switch *ds)
 530 {
 531         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
 532
 533         switch (ps->id) {
 534         case PORT_SWITCH_ID_6320:
 535         case PORT_SWITCH_ID_6321:
 536                 return true;
 537         }
 538         return false;
 539 }
 540
 541 static bool mv88e6xxx_6351_family(struct dsa_switch *ds)
 542 {
 543         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
 544
 545         switch (ps->id) {
 546         case PORT_SWITCH_ID_6171:
 547         case PORT_SWITCH_ID_6175:
 548         case PORT_SWITCH_ID_6350:
 549         case PORT_SWITCH_ID_6351:
 550                 return true;
 551         }
 552         return false;
 553 }
 554
 555 static bool mv88e6xxx_6352_family(struct dsa_switch *ds)
 556 {
 557         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
 558
 559         switch (ps->id) {
 560         case PORT_SWITCH_ID_6172:
 561         case PORT_SWITCH_ID_6176:
 562         case PORT_SWITCH_ID_6240:
 563         case PORT_SWITCH_ID_6352:
 564                 return true;
 565         }
 566         return false;
 567 }
 568
 569 /* We expect the switch to perform auto negotiation if there is a real
 570  * phy. However, in the case of a fixed link phy, we force the port
 571  * settings from the fixed link settings.
 572  */
 573 void mv88e6xxx_adjust_link(struct dsa_switch *ds, int port,
 574                            struct phy_device *phydev)
 575 {
 576         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
 577         u32 ret, reg;
 578
 579         if (!phy_is_pseudo_fixed_link(phydev))
 580                 return;
 581
 582         mutex_lock(&ps->smi_mutex);
 583
 584         ret = _mv88e6xxx_reg_read(ds, REG_PORT(port), PORT_PCS_CTRL);
 585         if (ret < 0)
 586                 goto out;
 587
 588         reg = ret & ~(PORT_PCS_CTRL_LINK_UP |
 589                       PORT_PCS_CTRL_FORCE_LINK |
 590                       PORT_PCS_CTRL_DUPLEX_FULL |
 591                       PORT_PCS_CTRL_FORCE_DUPLEX |
 592                       PORT_PCS_CTRL_UNFORCED);
 593
 594         reg |= PORT_PCS_CTRL_FORCE_LINK;
 595         if (phydev->link)
 596                         reg |= PORT_PCS_CTRL_LINK_UP;
 597
 598         if (mv88e6xxx_6065_family(ds) && phydev->speed > SPEED_100)
 599                 goto out;
 600
 601         switch (phydev->speed) {
 602         case SPEED_1000:
 603                 reg |= PORT_PCS_CTRL_1000;
 604                 break;
 605         case SPEED_100:
 606                 reg |= PORT_PCS_CTRL_100;
 607                 break;
 608         case SPEED_10:
 609                 reg |= PORT_PCS_CTRL_10;
 610                 break;
 611         default:
 612                 pr_info("Unknown speed");
 613                 goto out;
 614         }
 615
 616         reg |= PORT_PCS_CTRL_FORCE_DUPLEX;
 617         if (phydev->duplex == DUPLEX_FULL)
 618                 reg |= PORT_PCS_CTRL_DUPLEX_FULL;
 619
 620         if ((mv88e6xxx_6352_family(ds) || mv88e6xxx_6351_family(ds)) &&
 621             (port >= ps->num_ports - 2)) {
 622                 if (phydev->interface == PHY_INTERFACE_MODE_RGMII_RXID)
 623                         reg |= PORT_PCS_CTRL_RGMII_DELAY_RXCLK;
 624                 if (phydev->interface == PHY_INTERFACE_MODE_RGMII_TXID)
 625                         reg |= PORT_PCS_CTRL_RGMII_DELAY_TXCLK;
 626                 if (phydev->interface == PHY_INTERFACE_MODE_RGMII_ID)
 627                         reg |= (PORT_PCS_CTRL_RGMII_DELAY_RXCLK |
 628                                 PORT_PCS_CTRL_RGMII_DELAY_TXCLK);
 629         }
 630         _mv88e6xxx_reg_write(ds, REG_PORT(port), PORT_PCS_CTRL, reg);
 631
 632 out:
 633         mutex_unlock(&ps->smi_mutex);
 634 }
 635
 636 /* Must be called with SMI mutex held */
 637 static int _mv88e6xxx_stats_wait(struct dsa_switch *ds)
 638 {
 639         int ret;
 640         int i;
 641
 642         for (i = 0; i < 10; i++) {
 643                 ret = _mv88e6xxx_reg_read(ds, REG_GLOBAL, GLOBAL_STATS_OP);
 644                 if ((ret & GLOBAL_STATS_OP_BUSY) == 0)
 645                         return 0;
 646         }
 647
 648         return -ETIMEDOUT;
 649 }
 650
 651 /* Must be called with SMI mutex held */
 652 static int _mv88e6xxx_stats_snapshot(struct dsa_switch *ds, int port)
 653 {
 654         int ret;
 655
 656         if (mv88e6xxx_6320_family(ds) || mv88e6xxx_6352_family(ds))
 657                 port = (port + 1) << 5;
 658
 659         /* Snapshot the hardware statistics counters for this port. */
 660         ret = _mv88e6xxx_reg_write(ds, REG_GLOBAL, GLOBAL_STATS_OP,
 661                                    GLOBAL_STATS_OP_CAPTURE_PORT |
 662                                    GLOBAL_STATS_OP_HIST_RX_TX | port);
 663         if (ret < 0)
 664                 return ret;
 665
 666         /* Wait for the snapshotting to complete. */
 667         ret = _mv88e6xxx_stats_wait(ds);
 668         if (ret < 0)
 669                 return ret;
 670
 671         return 0;
 672 }
 673
 674 /* Must be called with SMI mutex held */
 675 static void _mv88e6xxx_stats_read(struct dsa_switch *ds, int stat, u32 *val)
 676 {
 677         u32 _val;
 678         int ret;
 679
 680         *val = 0;
 681
 682         ret = _mv88e6xxx_reg_write(ds, REG_GLOBAL, GLOBAL_STATS_OP,
 683                                    GLOBAL_STATS_OP_READ_CAPTURED |
 684                                    GLOBAL_STATS_OP_HIST_RX_TX | stat);
 685         if (ret < 0)
 686                 return;
 687
 688         ret = _mv88e6xxx_stats_wait(ds);
 689         if (ret < 0)
 690                 return;
 691
 692         ret = _mv88e6xxx_reg_read(ds, REG_GLOBAL, GLOBAL_STATS_COUNTER_32);
 693         if (ret < 0)
 694                 return;
 695
 696         _val = ret << 16;
 697
 698         ret = _mv88e6xxx_reg_read(ds, REG_GLOBAL, GLOBAL_STATS_COUNTER_01);
 699         if (ret < 0)
 700                 return;
 701
 702         *val = _val | ret;
 703 }
 704
 705 static struct mv88e6xxx_hw_stat mv88e6xxx_hw_stats[] = {
 706         { "in_good_octets", 8, 0x00, },
 707         { "in_bad_octets", 4, 0x02, },
 708         { "in_unicast", 4, 0x04, },
 709         { "in_broadcasts", 4, 0x06, },
 710         { "in_multicasts", 4, 0x07, },
 711         { "in_pause", 4, 0x16, },
 712         { "in_undersize", 4, 0x18, },
 713         { "in_fragments", 4, 0x19, },
 714         { "in_oversize", 4, 0x1a, },
 715         { "in_jabber", 4, 0x1b, },
 716         { "in_rx_error", 4, 0x1c, },
 717         { "in_fcs_error", 4, 0x1d, },
 718         { "out_octets", 8, 0x0e, },
 719         { "out_unicast", 4, 0x10, },
 720         { "out_broadcasts", 4, 0x13, },
 721         { "out_multicasts", 4, 0x12, },
 722         { "out_pause", 4, 0x15, },
 723         { "excessive", 4, 0x11, },
 724         { "collisions", 4, 0x1e, },
 725         { "deferred", 4, 0x05, },
 726         { "single", 4, 0x14, },
 727         { "multiple", 4, 0x17, },
 728         { "out_fcs_error", 4, 0x03, },
 729         { "late", 4, 0x1f, },
 730         { "hist_64bytes", 4, 0x08, },
 731         { "hist_65_127bytes", 4, 0x09, },
 732         { "hist_128_255bytes", 4, 0x0a, },
 733         { "hist_256_511bytes", 4, 0x0b, },
 734         { "hist_512_1023bytes", 4, 0x0c, },
 735         { "hist_1024_max_bytes", 4, 0x0d, },
 736         /* Not all devices have the following counters */
 737         { "sw_in_discards", 4, 0x110, },
 738         { "sw_in_filtered", 2, 0x112, },
 739         { "sw_out_filtered", 2, 0x113, },
 740
 741 };
 742
 743 static bool have_sw_in_discards(struct dsa_switch *ds)
 744 {
 745         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
 746
 747         switch (ps->id) {
 748         case PORT_SWITCH_ID_6095: case PORT_SWITCH_ID_6161:
 749         case PORT_SWITCH_ID_6165: case PORT_SWITCH_ID_6171:
 750         case PORT_SWITCH_ID_6172: case PORT_SWITCH_ID_6176:
 751         case PORT_SWITCH_ID_6182: case PORT_SWITCH_ID_6185:
 752         case PORT_SWITCH_ID_6352:
 753                 return true;
 754         default:
 755                 return false;
 756         }
 757 }
 758
 759 static void _mv88e6xxx_get_strings(struct dsa_switch *ds,
 760                                    int nr_stats,
 761                                    struct mv88e6xxx_hw_stat *stats,
 762                                    int port, uint8_t *data)
 763 {
 764         int i;
 765
 766         for (i = 0; i < nr_stats; i++) {
 767                 memcpy(data + i * ETH_GSTRING_LEN,
 768                        stats[i].string, ETH_GSTRING_LEN);
 769         }
 770 }
 771
 772 static uint64_t _mv88e6xxx_get_ethtool_stat(struct dsa_switch *ds,
 773                                             int stat,
 774                                             struct mv88e6xxx_hw_stat *stats,
 775                                             int port)
 776 {
 777         struct mv88e6xxx_hw_stat *s = stats + stat;
 778         u32 low;
 779         u32 high = 0;
 780         int ret;
 781         u64 value;
 782
 783         if (s->reg >= 0x100) {
 784                 ret = _mv88e6xxx_reg_read(ds, REG_PORT(port),
 785                                           s->reg - 0x100);
 786                 if (ret < 0)
 787                         return UINT64_MAX;
 788
 789                 low = ret;
 790                 if (s->sizeof_stat == 4) {
 791                         ret = _mv88e6xxx_reg_read(ds, REG_PORT(port),
 792                                                   s->reg - 0x100 + 1);
 793                         if (ret < 0)
 794                                 return UINT64_MAX;
 795                         high = ret;
 796                 }
 797         } else {
 798                 _mv88e6xxx_stats_read(ds, s->reg, &low);
 799                 if (s->sizeof_stat == 8)
 800                         _mv88e6xxx_stats_read(ds, s->reg + 1, &high);
 801         }
 802         value = (((u64)high) << 16) | low;
 803         return value;
 804 }
 805
 806 static void _mv88e6xxx_get_ethtool_stats(struct dsa_switch *ds,
 807                                          int nr_stats,
 808                                          struct mv88e6xxx_hw_stat *stats,
 809                                          int port, uint64_t *data)
 810 {
 811         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
 812         int ret;
 813         int i;
 814
 815         mutex_lock(&ps->smi_mutex);
 816
 817         ret = _mv88e6xxx_stats_snapshot(ds, port);
 818         if (ret < 0) {
 819                 mutex_unlock(&ps->smi_mutex);
 820                 return;
 821         }
 822
 823         /* Read each of the counters. */
 824         for (i = 0; i < nr_stats; i++)
 825                 data[i] = _mv88e6xxx_get_ethtool_stat(ds, i, stats, port);
 826
 827         mutex_unlock(&ps->smi_mutex);
 828 }
 829
 830 /* All the statistics in the table */
 831 void
 832 mv88e6xxx_get_strings(struct dsa_switch *ds, int port, uint8_t *data)
 833 {
 834         if (have_sw_in_discards(ds))
 835                 _mv88e6xxx_get_strings(ds, ARRAY_SIZE(mv88e6xxx_hw_stats),
 836                                        mv88e6xxx_hw_stats, port, data);
 837         else
 838                 _mv88e6xxx_get_strings(ds, ARRAY_SIZE(mv88e6xxx_hw_stats) - 3,
 839                                        mv88e6xxx_hw_stats, port, data);
 840 }
 841
 842 int mv88e6xxx_get_sset_count(struct dsa_switch *ds)
 843 {
 844         if (have_sw_in_discards(ds))
 845                 return ARRAY_SIZE(mv88e6xxx_hw_stats);
 846         return ARRAY_SIZE(mv88e6xxx_hw_stats) - 3;
 847 }
 848
 849 void
 850 mv88e6xxx_get_ethtool_stats(struct dsa_switch *ds,
 851                             int port, uint64_t *data)
 852 {
 853         if (have_sw_in_discards(ds))
 854                 _mv88e6xxx_get_ethtool_stats(
 855                         ds, ARRAY_SIZE(mv88e6xxx_hw_stats),
 856                         mv88e6xxx_hw_stats, port, data);
 857         else
 858                 _mv88e6xxx_get_ethtool_stats(
 859                         ds, ARRAY_SIZE(mv88e6xxx_hw_stats) - 3,
 860                         mv88e6xxx_hw_stats, port, data);
 861 }
 862
 863 int mv88e6xxx_get_regs_len(struct dsa_switch *ds, int port)
 864 {
 865         return 32 * sizeof(u16);
 866 }
 867
 868 void mv88e6xxx_get_regs(struct dsa_switch *ds, int port,
 869                         struct ethtool_regs *regs, void *_p)
 870 {
 871         u16 *p = _p;
 872         int i;
 873
 874         regs->version = 0;
 875
 876         memset(p, 0xff, 32 * sizeof(u16));
 877
 878         for (i = 0; i < 32; i++) {
 879                 int ret;
 880
 881                 ret = mv88e6xxx_reg_read(ds, REG_PORT(port), i);
 882                 if (ret >= 0)
 883                         p[i] = ret;
 884         }
 885 }
 886
 887 /* Must be called with SMI lock held */
 888 static int _mv88e6xxx_wait(struct dsa_switch *ds, int reg, int offset,
 889                            u16 mask)
 890 {
 891         unsigned long timeout = jiffies + HZ / 10;
 892
 893         while (time_before(jiffies, timeout)) {
 894                 int ret;
 895
 896                 ret = _mv88e6xxx_reg_read(ds, reg, offset);
 897                 if (ret < 0)
 898                         return ret;
 899                 if (!(ret & mask))
 900                         return 0;
 901
 902                 usleep_range(1000, 2000);
 903         }
 904         return -ETIMEDOUT;
 905 }
 906
 907 static int mv88e6xxx_wait(struct dsa_switch *ds, int reg, int offset, u16 mask)
 908 {
 909         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
 910         int ret;
 911
 912         mutex_lock(&ps->smi_mutex);
 913         ret = _mv88e6xxx_wait(ds, reg, offset, mask);
 914         mutex_unlock(&ps->smi_mutex);
 915
 916         return ret;
 917 }
 918
 919 static int _mv88e6xxx_phy_wait(struct dsa_switch *ds)
 920 {
 921         return _mv88e6xxx_wait(ds, REG_GLOBAL2, GLOBAL2_SMI_OP,
 922                                GLOBAL2_SMI_OP_BUSY);
 923 }
 924
 925 int mv88e6xxx_eeprom_load_wait(struct dsa_switch *ds)
 926 {
 927         return mv88e6xxx_wait(ds, REG_GLOBAL2, GLOBAL2_EEPROM_OP,
 928                               GLOBAL2_EEPROM_OP_LOAD);
 929 }
 930
 931 int mv88e6xxx_eeprom_busy_wait(struct dsa_switch *ds)
 932 {
 933         return mv88e6xxx_wait(ds, REG_GLOBAL2, GLOBAL2_EEPROM_OP,
 934                               GLOBAL2_EEPROM_OP_BUSY);
 935 }
 936
 937 /* Must be called with SMI lock held */
 938 static int _mv88e6xxx_atu_wait(struct dsa_switch *ds)
 939 {
 940         return _mv88e6xxx_wait(ds, REG_GLOBAL, GLOBAL_ATU_OP,
 941                                GLOBAL_ATU_OP_BUSY);
 942 }
 943
 944 /* Must be called with SMI lock held */
 945 static int _mv88e6xxx_scratch_wait(struct dsa_switch *ds)
 946 {
 947         return _mv88e6xxx_wait(ds, REG_GLOBAL2, GLOBAL2_SCRATCH_MISC,
 948                                GLOBAL2_SCRATCH_BUSY);
 949 }
 950
 951 /* Must be called with SMI mutex held */
 952 static int _mv88e6xxx_phy_read_indirect(struct dsa_switch *ds, int addr,
 953                                         int regnum)
 954 {
 955         int ret;
 956
 957         ret = _mv88e6xxx_reg_write(ds, REG_GLOBAL2, GLOBAL2_SMI_OP,
 958                                    GLOBAL2_SMI_OP_22_READ | (addr << 5) |
 959                                    regnum);
 960         if (ret < 0)
 961                 return ret;
 962
 963         ret = _mv88e6xxx_phy_wait(ds);
 964         if (ret < 0)
 965                 return ret;
 966
 967         return _mv88e6xxx_reg_read(ds, REG_GLOBAL2, GLOBAL2_SMI_DATA);
 968 }
 969
 970 /* Must be called with SMI mutex held */
 971 static int _mv88e6xxx_phy_write_indirect(struct dsa_switch *ds, int addr,
 972                                          int regnum, u16 val)
 973 {
 974         int ret;
 975
 976         ret = _mv88e6xxx_reg_write(ds, REG_GLOBAL2, GLOBAL2_SMI_DATA, val);
 977         if (ret < 0)
 978                 return ret;
 979
 980         ret = _mv88e6xxx_reg_write(ds, REG_GLOBAL2, GLOBAL2_SMI_OP,
 981                                    GLOBAL2_SMI_OP_22_WRITE | (addr << 5) |
 982                                    regnum);
 983
 984         return _mv88e6xxx_phy_wait(ds);
 985 }
 986
 987 int mv88e6xxx_get_eee(struct dsa_switch *ds, int port, struct ethtool_eee *e)
 988 {
 989         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
 990         int reg;
 991
 992         mutex_lock(&ps->smi_mutex);
 993
 994         reg = _mv88e6xxx_phy_read_indirect(ds, port, 16);
 995         if (reg < 0)
 996                 goto out;
 997
 998         e->eee_enabled = !!(reg & 0x0200);
 999         e->tx_lpi_enabled = !!(reg & 0x0100);
1000
1001         reg = _mv88e6xxx_reg_read(ds, REG_PORT(port), PORT_STATUS);
1002         if (reg < 0)
1003                 goto out;
1004
1005         e->eee_active = !!(reg & PORT_STATUS_EEE);
1006         reg = 0;
1007
1008 out:
1009         mutex_unlock(&ps->smi_mutex);
1010         return reg;
1011 }
1012
1013 int mv88e6xxx_set_eee(struct dsa_switch *ds, int port,
1014                       struct phy_device *phydev, struct ethtool_eee *e)
1015 {
1016         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
1017         int reg;
1018         int ret;
1019
1020         mutex_lock(&ps->smi_mutex);
1021
1022         ret = _mv88e6xxx_phy_read_indirect(ds, port, 16);
1023         if (ret < 0)
1024                 goto out;
1025
1026         reg = ret & ~0x0300;
1027         if (e->eee_enabled)
1028                 reg |= 0x0200;
1029         if (e->tx_lpi_enabled)
1030                 reg |= 0x0100;
1031
1032         ret = _mv88e6xxx_phy_write_indirect(ds, port, 16, reg);
1033 out:
1034         mutex_unlock(&ps->smi_mutex);
1035
1036         return ret;
1037 }
1038
1039 static int _mv88e6xxx_atu_cmd(struct dsa_switch *ds, int fid, u16 cmd)
1040 {
1041         int ret;
1042
1043         ret = _mv88e6xxx_reg_write(ds, REG_GLOBAL, GLOBAL_ATU_FID, fid);
1044         if (ret < 0)
1045                 return ret;
1046
1047         ret = _mv88e6xxx_reg_write(ds, REG_GLOBAL, GLOBAL_ATU_OP, cmd);
1048         if (ret < 0)
1049                 return ret;
1050
1051         return _mv88e6xxx_atu_wait(ds);
1052 }
1053
1054 static int _mv88e6xxx_flush_fid(struct dsa_switch *ds, int fid)
1055 {
1056         int ret;
1057
1058         ret = _mv88e6xxx_atu_wait(ds);
1059         if (ret < 0)
1060                 return ret;
1061
1062         return _mv88e6xxx_atu_cmd(ds, fid, GLOBAL_ATU_OP_FLUSH_NON_STATIC_DB);
1063 }
1064
1065 static int mv88e6xxx_set_port_state(struct dsa_switch *ds, int port, u8 state)
1066 {
1067         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
1068         int reg, ret = 0;
1069         u8 oldstate;
1070
1071         mutex_lock(&ps->smi_mutex);
1072
1073         reg = _mv88e6xxx_reg_read(ds, REG_PORT(port), PORT_CONTROL);
1074         if (reg < 0) {
1075                 ret = reg;
1076                 goto abort;
1077         }
1078
1079         oldstate = reg & PORT_CONTROL_STATE_MASK;
1080         if (oldstate != state) {
1081                 /* Flush forwarding database if we're moving a port
1082                  * from Learning or Forwarding state to Disabled or
1083                  * Blocking or Listening state.
1084                  */
1085                 if (oldstate >= PORT_CONTROL_STATE_LEARNING &&
1086                     state <= PORT_CONTROL_STATE_BLOCKING) {
1087                         ret = _mv88e6xxx_flush_fid(ds, ps->fid[port]);
1088                         if (ret)
1089                                 goto abort;
1090                 }
1091                 reg = (reg & ~PORT_CONTROL_STATE_MASK) | state;
1092                 ret = _mv88e6xxx_reg_write(ds, REG_PORT(port), PORT_CONTROL,
1093                                            reg);
1094         }
1095
1096 abort:
1097         mutex_unlock(&ps->smi_mutex);
1098         return ret;
1099 }
1100
1101 /* Must be called with smi lock held */
1102 static int _mv88e6xxx_update_port_config(struct dsa_switch *ds, int port)
1103 {
1104         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
1105         u8 fid = ps->fid[port];
1106         u16 reg = fid << 12;
1107
1108         if (dsa_is_cpu_port(ds, port))
1109                 reg |= ds->phys_port_mask;
1110         else
1111                 reg |= (ps->bridge_mask[fid] |
1112                        (1 << dsa_upstream_port(ds))) & ~(1 << port);
1113
1114         return _mv88e6xxx_reg_write(ds, REG_PORT(port), PORT_BASE_VLAN, reg);
1115 }
1116
1117 /* Must be called with smi lock held */
1118 static int _mv88e6xxx_update_bridge_config(struct dsa_switch *ds, int fid)
1119 {
1120         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
1121         int port;
1122         u32 mask;
1123         int ret;
1124
1125         mask = ds->phys_port_mask;
1126         while (mask) {
1127                 port = __ffs(mask);
1128                 mask &= ~(1 << port);
1129                 if (ps->fid[port] != fid)
1130                         continue;
1131
1132                 ret = _mv88e6xxx_update_port_config(ds, port);
1133                 if (ret)
1134                         return ret;
1135         }
1136
1137         return _mv88e6xxx_flush_fid(ds, fid);
1138 }
1139
1140 /* Bridge handling functions */
1141
1142 int mv88e6xxx_join_bridge(struct dsa_switch *ds, int port, u32 br_port_mask)
1143 {
1144         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
1145         int ret = 0;
1146         u32 nmask;
1147         int fid;
1148
1149         /* If the bridge group is not empty, join that group.
1150          * Otherwise create a new group.
1151          */
1152         fid = ps->fid[port];
1153         nmask = br_port_mask & ~(1 << port);
1154         if (nmask)
1155                 fid = ps->fid[__ffs(nmask)];
1156
1157         nmask = ps->bridge_mask[fid] | (1 << port);
1158         if (nmask != br_port_mask) {
1159                 netdev_err(ds->ports[port],
1160                            "join: Bridge port mask mismatch fid=%d mask=0x%x expected 0x%x\n",
1161                            fid, br_port_mask, nmask);
1162                 return -EINVAL;
1163         }
1164
1165         mutex_lock(&ps->smi_mutex);
1166
1167         ps->bridge_mask[fid] = br_port_mask;
1168
1169         if (fid != ps->fid[port]) {
1170                 clear_bit(ps->fid[port], ps->fid_bitmap);
1171                 ps->fid[port] = fid;
1172                 ret = _mv88e6xxx_update_bridge_config(ds, fid);
1173         }
1174
1175         mutex_unlock(&ps->smi_mutex);
1176
1177         return ret;
1178 }
1179
1180 int mv88e6xxx_leave_bridge(struct dsa_switch *ds, int port, u32 br_port_mask)
1181 {
1182         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
1183         u8 fid, newfid;
1184         int ret;
1185
1186         fid = ps->fid[port];
1187
1188         if (ps->bridge_mask[fid] != br_port_mask) {
1189                 netdev_err(ds->ports[port],
1190                            "leave: Bridge port mask mismatch fid=%d mask=0x%x expected 0x%x\n",
1191                            fid, br_port_mask, ps->bridge_mask[fid]);
1192                 return -EINVAL;
1193         }
1194
1195         /* If the port was the last port of a bridge, we are done.
1196          * Otherwise assign a new fid to the port, and fix up
1197          * the bridge configuration.
1198          */
1199         if (br_port_mask == (1 << port))
1200                 return 0;
1201
1202         mutex_lock(&ps->smi_mutex);
1203
1204         newfid = find_next_zero_bit(ps->fid_bitmap, VLAN_N_VID, 1);
1205         if (unlikely(newfid > ps->num_ports)) {
1206                 netdev_err(ds->ports[port], "all first %d FIDs are used\n",
1207                            ps->num_ports);
1208                 ret = -ENOSPC;
1209                 goto unlock;
1210         }
1211
1212         ps->fid[port] = newfid;
1213         set_bit(newfid, ps->fid_bitmap);
1214         ps->bridge_mask[fid] &= ~(1 << port);
1215         ps->bridge_mask[newfid] = 1 << port;
1216
1217         ret = _mv88e6xxx_update_bridge_config(ds, fid);
1218         if (!ret)
1219                 ret = _mv88e6xxx_update_bridge_config(ds, newfid);
1220
1221 unlock:
1222         mutex_unlock(&ps->smi_mutex);
1223
1224         return ret;
1225 }
1226
1227 int mv88e6xxx_port_stp_update(struct dsa_switch *ds, int port, u8 state)
1228 {
1229         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
1230         int stp_state;
1231
1232         switch (state) {
1233         case BR_STATE_DISABLED:
1234                 stp_state = PORT_CONTROL_STATE_DISABLED;
1235                 break;
1236         case BR_STATE_BLOCKING:
1237         case BR_STATE_LISTENING:
1238                 stp_state = PORT_CONTROL_STATE_BLOCKING;
1239                 break;
1240         case BR_STATE_LEARNING:
1241                 stp_state = PORT_CONTROL_STATE_LEARNING;
1242                 break;
1243         case BR_STATE_FORWARDING:
1244         default:
1245                 stp_state = PORT_CONTROL_STATE_FORWARDING;
1246                 break;
1247         }
1248
1249         netdev_dbg(ds->ports[port], "port state %d [%d]\n", state, stp_state);
1250
1251         /* mv88e6xxx_port_stp_update may be called with softirqs disabled,
1252          * so we can not update the port state directly but need to schedule it.
1253          */
1254         ps->port_state[port] = stp_state;
1255         set_bit(port, &ps->port_state_update_mask);
1256         schedule_work(&ps->bridge_work);
1257
1258         return 0;
1259 }
1260
1261 int mv88e6xxx_port_pvid_get(struct dsa_switch *ds, int port, u16 *pvid)
1262 {
1263         int ret;
1264
1265         ret = mv88e6xxx_reg_read(ds, REG_PORT(port), PORT_DEFAULT_VLAN);
1266         if (ret < 0)
1267                 return ret;
1268
1269         *pvid = ret & PORT_DEFAULT_VLAN_MASK;
1270
1271         return 0;
1272 }
1273
1274 int mv88e6xxx_port_pvid_set(struct dsa_switch *ds, int port, u16 pvid)
1275 {
1276         return mv88e6xxx_reg_write(ds, REG_PORT(port), PORT_DEFAULT_VLAN,
1277                                    pvid & PORT_DEFAULT_VLAN_MASK);
1278 }
1279
1280 static int _mv88e6xxx_vtu_wait(struct dsa_switch *ds)
1281 {
1282         return _mv88e6xxx_wait(ds, REG_GLOBAL, GLOBAL_VTU_OP,
1283                                GLOBAL_VTU_OP_BUSY);
1284 }
1285
1286 static int _mv88e6xxx_vtu_cmd(struct dsa_switch *ds, u16 op)
1287 {
1288         int ret;
1289
1290         ret = _mv88e6xxx_reg_write(ds, REG_GLOBAL, GLOBAL_VTU_OP, op);
1291         if (ret < 0)
1292                 return ret;
1293
1294         return _mv88e6xxx_vtu_wait(ds);
1295 }
1296
1297 static int _mv88e6xxx_vtu_stu_flush(struct dsa_switch *ds)
1298 {
1299         int ret;
1300
1301         ret = _mv88e6xxx_vtu_wait(ds);
1302         if (ret < 0)
1303                 return ret;
1304
1305         return _mv88e6xxx_vtu_cmd(ds, GLOBAL_VTU_OP_FLUSH_ALL);
1306 }
1307
1308 static int _mv88e6xxx_vtu_stu_data_read(struct dsa_switch *ds,
1309                                         struct mv88e6xxx_vtu_stu_entry *entry,
1310                                         unsigned int nibble_offset)
1311 {
1312         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
1313         u16 regs[3];
1314         int i;
1315         int ret;
1316
1317         for (i = 0; i < 3; ++i) {
1318                 ret = _mv88e6xxx_reg_read(ds, REG_GLOBAL,
1319                                           GLOBAL_VTU_DATA_0_3 + i);
1320                 if (ret < 0)
1321                         return ret;
1322
1323                 regs[i] = ret;
1324         }
1325
1326         for (i = 0; i < ps->num_ports; ++i) {
1327                 unsigned int shift = (i % 4) * 4 + nibble_offset;
1328                 u16 reg = regs[i / 4];
1329
1330                 entry->data[i] = (reg >> shift) & GLOBAL_VTU_STU_DATA_MASK;
1331         }
1332
1333         return 0;
1334 }
1335
1336 static int _mv88e6xxx_vtu_stu_data_write(struct dsa_switch *ds,
1337                                          struct mv88e6xxx_vtu_stu_entry *entry,
1338                                          unsigned int nibble_offset)
1339 {
1340         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
1341         u16 regs[3] = { 0 };
1342         int i;
1343         int ret;
1344
1345         for (i = 0; i < ps->num_ports; ++i) {
1346                 unsigned int shift = (i % 4) * 4 + nibble_offset;
1347                 u8 data = entry->data[i];
1348
1349                 regs[i / 4] |= (data & GLOBAL_VTU_STU_DATA_MASK) << shift;
1350         }
1351
1352         for (i = 0; i < 3; ++i) {
1353                 ret = _mv88e6xxx_reg_write(ds, REG_GLOBAL,
1354                                            GLOBAL_VTU_DATA_0_3 + i, regs[i]);
1355                 if (ret < 0)
1356                         return ret;
1357         }
1358
1359         return 0;
1360 }
1361
1362 static int _mv88e6xxx_vtu_getnext(struct dsa_switch *ds, u16 vid,
1363                                   struct mv88e6xxx_vtu_stu_entry *entry)
1364 {
1365         struct mv88e6xxx_vtu_stu_entry next = { 0 };
1366         int ret;
1367
1368         ret = _mv88e6xxx_vtu_wait(ds);
1369         if (ret < 0)
1370                 return ret;
1371
1372         ret = _mv88e6xxx_reg_write(ds, REG_GLOBAL, GLOBAL_VTU_VID,
1373                                    vid & GLOBAL_VTU_VID_MASK);
1374         if (ret < 0)
1375                 return ret;
1376
1377         ret = _mv88e6xxx_vtu_cmd(ds, GLOBAL_VTU_OP_VTU_GET_NEXT);
1378         if (ret < 0)
1379                 return ret;
1380
1381         ret = _mv88e6xxx_reg_read(ds, REG_GLOBAL, GLOBAL_VTU_VID);
1382         if (ret < 0)
1383                 return ret;
1384
1385         next.vid = ret & GLOBAL_VTU_VID_MASK;
1386         next.valid = !!(ret & GLOBAL_VTU_VID_VALID);
1387
1388         if (next.valid) {
1389                 ret = _mv88e6xxx_vtu_stu_data_read(ds, &next, 0);
1390                 if (ret < 0)
1391                         return ret;
1392
1393                 if (mv88e6xxx_6097_family(ds) || mv88e6xxx_6165_family(ds) ||
1394                     mv88e6xxx_6351_family(ds) || mv88e6xxx_6352_family(ds)) {
1395                         ret = _mv88e6xxx_reg_read(ds, REG_GLOBAL,
1396                                                   GLOBAL_VTU_FID);
1397                         if (ret < 0)
1398                                 return ret;
1399
1400                         next.fid = ret & GLOBAL_VTU_FID_MASK;
1401
1402                         ret = _mv88e6xxx_reg_read(ds, REG_GLOBAL,
1403                                                   GLOBAL_VTU_SID);
1404                         if (ret < 0)
1405                                 return ret;
1406
1407                         next.sid = ret & GLOBAL_VTU_SID_MASK;
1408                 }
1409         }
1410
1411         *entry = next;
1412         return 0;
1413 }
1414
1415 static int _mv88e6xxx_vtu_loadpurge(struct dsa_switch *ds,
1416                                     struct mv88e6xxx_vtu_stu_entry *entry)
1417 {
1418         u16 reg = 0;
1419         int ret;
1420
1421         ret = _mv88e6xxx_vtu_wait(ds);
1422         if (ret < 0)
1423                 return ret;
1424
1425         if (!entry->valid)
1426                 goto loadpurge;
1427
1428         /* Write port member tags */
1429         ret = _mv88e6xxx_vtu_stu_data_write(ds, entry, 0);
1430         if (ret < 0)
1431                 return ret;
1432
1433         if (mv88e6xxx_6097_family(ds) || mv88e6xxx_6165_family(ds) ||
1434             mv88e6xxx_6351_family(ds) || mv88e6xxx_6352_family(ds)) {
1435                 reg = entry->sid & GLOBAL_VTU_SID_MASK;
1436                 ret = _mv88e6xxx_reg_write(ds, REG_GLOBAL, GLOBAL_VTU_SID, reg);
1437                 if (ret < 0)
1438                         return ret;
1439
1440                 reg = entry->fid & GLOBAL_VTU_FID_MASK;
1441                 ret = _mv88e6xxx_reg_write(ds, REG_GLOBAL, GLOBAL_VTU_FID, reg);
1442                 if (ret < 0)
1443                         return ret;
1444         }
1445
1446         reg = GLOBAL_VTU_VID_VALID;
1447 loadpurge:
1448         reg |= entry->vid & GLOBAL_VTU_VID_MASK;
1449         ret = _mv88e6xxx_reg_write(ds, REG_GLOBAL, GLOBAL_VTU_VID, reg);
1450         if (ret < 0)
1451                 return ret;
1452
1453         return _mv88e6xxx_vtu_cmd(ds, GLOBAL_VTU_OP_VTU_LOAD_PURGE);
1454 }
1455
1456 static int _mv88e6xxx_stu_getnext(struct dsa_switch *ds, u8 sid,
1457                                   struct mv88e6xxx_vtu_stu_entry *entry)
1458 {
1459         struct mv88e6xxx_vtu_stu_entry next = { 0 };
1460         int ret;
1461
1462         ret = _mv88e6xxx_vtu_wait(ds);
1463         if (ret < 0)
1464                 return ret;
1465
1466         ret = _mv88e6xxx_reg_write(ds, REG_GLOBAL, GLOBAL_VTU_SID,
1467                                    sid & GLOBAL_VTU_SID_MASK);
1468         if (ret < 0)
1469                 return ret;
1470
1471         ret = _mv88e6xxx_vtu_cmd(ds, GLOBAL_VTU_OP_STU_GET_NEXT);
1472         if (ret < 0)
1473                 return ret;
1474
1475         ret = _mv88e6xxx_reg_read(ds, REG_GLOBAL, GLOBAL_VTU_SID);
1476         if (ret < 0)
1477                 return ret;
1478
1479         next.sid = ret & GLOBAL_VTU_SID_MASK;
1480
1481         ret = _mv88e6xxx_reg_read(ds, REG_GLOBAL, GLOBAL_VTU_VID);
1482         if (ret < 0)
1483                 return ret;
1484
1485         next.valid = !!(ret & GLOBAL_VTU_VID_VALID);
1486
1487         if (next.valid) {
1488                 ret = _mv88e6xxx_vtu_stu_data_read(ds, &next, 2);
1489                 if (ret < 0)
1490                         return ret;
1491         }
1492
1493         *entry = next;
1494         return 0;
1495 }
1496
1497 static int _mv88e6xxx_stu_loadpurge(struct dsa_switch *ds,
1498                                     struct mv88e6xxx_vtu_stu_entry *entry)
1499 {
1500         u16 reg = 0;
1501         int ret;
1502
1503         ret = _mv88e6xxx_vtu_wait(ds);
1504         if (ret < 0)
1505                 return ret;
1506
1507         if (!entry->valid)
1508                 goto loadpurge;
1509
1510         /* Write port states */
1511         ret = _mv88e6xxx_vtu_stu_data_write(ds, entry, 2);
1512         if (ret < 0)
1513                 return ret;
1514
1515         reg = GLOBAL_VTU_VID_VALID;
1516 loadpurge:
1517         ret = _mv88e6xxx_reg_write(ds, REG_GLOBAL, GLOBAL_VTU_VID, reg);
1518         if (ret < 0)
1519                 return ret;
1520
1521         reg = entry->sid & GLOBAL_VTU_SID_MASK;
1522         ret = _mv88e6xxx_reg_write(ds, REG_GLOBAL, GLOBAL_VTU_SID, reg);
1523         if (ret < 0)
1524                 return ret;
1525
1526         return _mv88e6xxx_vtu_cmd(ds, GLOBAL_VTU_OP_STU_LOAD_PURGE);
1527 }
1528
1529 static int _mv88e6xxx_vlan_init(struct dsa_switch *ds, u16 vid,
1530                                 struct mv88e6xxx_vtu_stu_entry *entry)
1531 {
1532         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
1533         struct mv88e6xxx_vtu_stu_entry vlan = {
1534                 .valid = true,
1535                 .vid = vid,
1536         };
1537         int i;
1538
1539         /* exclude all ports except the CPU */
1540         for (i = 0; i < ps->num_ports; ++i)
1541                 vlan.data[i] = dsa_is_cpu_port(ds, i) ?
1542                         GLOBAL_VTU_DATA_MEMBER_TAG_TAGGED :
1543                         GLOBAL_VTU_DATA_MEMBER_TAG_NON_MEMBER;
1544
1545         if (mv88e6xxx_6097_family(ds) || mv88e6xxx_6165_family(ds) ||
1546             mv88e6xxx_6351_family(ds) || mv88e6xxx_6352_family(ds)) {
1547                 struct mv88e6xxx_vtu_stu_entry vstp;
1548                 int err;
1549
1550                 /* Adding a VTU entry requires a valid STU entry. As VSTP is not
1551                  * implemented, only one STU entry is needed to cover all VTU
1552                  * entries. Thus, validate the SID 0.
1553                  */
1554                 vlan.sid = 0;
1555                 err = _mv88e6xxx_stu_getnext(ds, GLOBAL_VTU_SID_MASK, &vstp);
1556                 if (err)
1557                         return err;
1558
1559                 if (vstp.sid != vlan.sid || !vstp.valid) {
1560                         memset(&vstp, 0, sizeof(vstp));
1561                         vstp.valid = true;
1562                         vstp.sid = vlan.sid;
1563
1564                         err = _mv88e6xxx_stu_loadpurge(ds, &vstp);
1565                         if (err)
1566                                 return err;
1567                 }
1568
1569                 /* Non-bridged ports and bridge groups use FIDs from 1 to
1570                  * num_ports; VLANs use FIDs from num_ports+1 to 4095.
1571                  */
1572                 vlan.fid = find_next_zero_bit(ps->fid_bitmap, VLAN_N_VID,
1573                                               ps->num_ports + 1);
1574                 if (unlikely(vlan.fid == VLAN_N_VID)) {
1575                         pr_err("no more FID available for VLAN %d\n", vid);
1576                         return -ENOSPC;
1577                 }
1578
1579                 err = _mv88e6xxx_flush_fid(ds, vlan.fid);
1580                 if (err)
1581                         return err;
1582
1583                 set_bit(vlan.fid, ps->fid_bitmap);
1584         }
1585
1586         *entry = vlan;
1587         return 0;
1588 }
1589
1590 int mv88e6xxx_port_vlan_add(struct dsa_switch *ds, int port, u16 vid,
1591                             bool untagged)
1592 {
1593         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
1594         struct mv88e6xxx_vtu_stu_entry vlan;
1595         int err;
1596
1597         mutex_lock(&ps->smi_mutex);
1598         err = _mv88e6xxx_vtu_getnext(ds, vid - 1, &vlan);
1599         if (err)
1600                 goto unlock;
1601
1602         if (vlan.vid != vid || !vlan.valid) {
1603                 err = _mv88e6xxx_vlan_init(ds, vid, &vlan);
1604                 if (err)
1605                         goto unlock;
1606         }
1607
1608         vlan.data[port] = untagged ?
1609                 GLOBAL_VTU_DATA_MEMBER_TAG_UNTAGGED :
1610                 GLOBAL_VTU_DATA_MEMBER_TAG_TAGGED;
1611
1612         err = _mv88e6xxx_vtu_loadpurge(ds, &vlan);
1613 unlock:
1614         mutex_unlock(&ps->smi_mutex);
1615
1616         return err;
1617 }
1618
1619 int mv88e6xxx_port_vlan_del(struct dsa_switch *ds, int port, u16 vid)
1620 {
1621         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
1622         struct mv88e6xxx_vtu_stu_entry vlan;
1623         bool keep = false;
1624         int i, err;
1625
1626         mutex_lock(&ps->smi_mutex);
1627
1628         err = _mv88e6xxx_vtu_getnext(ds, vid - 1, &vlan);
1629         if (err)
1630                 goto unlock;
1631
1632         if (vlan.vid != vid || !vlan.valid ||
1633             vlan.data[port] == GLOBAL_VTU_DATA_MEMBER_TAG_NON_MEMBER) {
1634                 err = -ENOENT;
1635                 goto unlock;
1636         }
1637
1638         vlan.data[port] = GLOBAL_VTU_DATA_MEMBER_TAG_NON_MEMBER;
1639
1640         /* keep the VLAN unless all ports are excluded */
1641         for (i = 0; i < ps->num_ports; ++i) {
1642                 if (dsa_is_cpu_port(ds, i))
1643                         continue;
1644
1645                 if (vlan.data[i] != GLOBAL_VTU_DATA_MEMBER_TAG_NON_MEMBER) {
1646                         keep = true;
1647                         break;
1648                 }
1649         }
1650
1651         vlan.valid = keep;
1652         err = _mv88e6xxx_vtu_loadpurge(ds, &vlan);
1653         if (err)
1654                 goto unlock;
1655
1656         if (!keep)
1657                 clear_bit(vlan.fid, ps->fid_bitmap);
1658
1659 unlock:
1660         mutex_unlock(&ps->smi_mutex);
1661
1662         return err;
1663 }
1664
1665 static int _mv88e6xxx_port_vtu_getnext(struct dsa_switch *ds, int port, u16 vid,
1666                                        struct mv88e6xxx_vtu_stu_entry *entry)
1667 {
1668         int err;
1669
1670         do {
1671                 if (vid == 4095)
1672                         return -ENOENT;
1673
1674                 err = _mv88e6xxx_vtu_getnext(ds, vid, entry);
1675                 if (err)
1676                         return err;
1677
1678                 if (!entry->valid)
1679                         return -ENOENT;
1680
1681                 vid = entry->vid;
1682         } while (entry->data[port] != GLOBAL_VTU_DATA_MEMBER_TAG_TAGGED &&
1683                  entry->data[port] != GLOBAL_VTU_DATA_MEMBER_TAG_UNTAGGED);
1684
1685         return 0;
1686 }
1687
1688 int mv88e6xxx_vlan_getnext(struct dsa_switch *ds, u16 *vid,
1689                            unsigned long *ports, unsigned long *untagged)
1690 {
1691         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
1692         struct mv88e6xxx_vtu_stu_entry next;
1693         int port;
1694         int err;
1695
1696         if (*vid == 4095)
1697                 return -ENOENT;
1698
1699         mutex_lock(&ps->smi_mutex);
1700         err = _mv88e6xxx_vtu_getnext(ds, *vid, &next);
1701         mutex_unlock(&ps->smi_mutex);
1702
1703         if (err)
1704                 return err;
1705
1706         if (!next.valid)
1707                 return -ENOENT;
1708
1709         *vid = next.vid;
1710
1711         for (port = 0; port < ps->num_ports; ++port) {
1712                 clear_bit(port, ports);
1713                 clear_bit(port, untagged);
1714
1715                 if (dsa_is_cpu_port(ds, port))
1716                         continue;
1717
1718                 if (next.data[port] == GLOBAL_VTU_DATA_MEMBER_TAG_TAGGED ||
1719                     next.data[port] == GLOBAL_VTU_DATA_MEMBER_TAG_UNTAGGED)
1720                         set_bit(port, ports);
1721
1722                 if (next.data[port] == GLOBAL_VTU_DATA_MEMBER_TAG_UNTAGGED)
1723                         set_bit(port, untagged);
1724         }
1725
1726         return 0;
1727 }
1728
1729 static int _mv88e6xxx_atu_mac_write(struct dsa_switch *ds,
1730                                     const unsigned char *addr)
1731 {
1732         int i, ret;
1733
1734         for (i = 0; i < 3; i++) {
1735                 ret = _mv88e6xxx_reg_write(
1736                         ds, REG_GLOBAL, GLOBAL_ATU_MAC_01 + i,
1737                         (addr[i * 2] << 8) | addr[i * 2 + 1]);
1738                 if (ret < 0)
1739                         return ret;
1740         }
1741
1742         return 0;
1743 }
1744
1745 static int _mv88e6xxx_atu_mac_read(struct dsa_switch *ds, unsigned char *addr)
1746 {
1747         int i, ret;
1748
1749         for (i = 0; i < 3; i++) {
1750                 ret = _mv88e6xxx_reg_read(ds, REG_GLOBAL,
1751                                           GLOBAL_ATU_MAC_01 + i);
1752                 if (ret < 0)
1753                         return ret;
1754                 addr[i * 2] = ret >> 8;
1755                 addr[i * 2 + 1] = ret & 0xff;
1756         }
1757
1758         return 0;
1759 }
1760
1761 static int _mv88e6xxx_atu_load(struct dsa_switch *ds,
1762                                struct mv88e6xxx_atu_entry *entry)
1763 {
1764         u16 reg = 0;
1765         int ret;
1766
1767         ret = _mv88e6xxx_atu_wait(ds);
1768         if (ret < 0)
1769                 return ret;
1770
1771         ret = _mv88e6xxx_atu_mac_write(ds, entry->mac);
1772         if (ret < 0)
1773                 return ret;
1774
1775         if (entry->state != GLOBAL_ATU_DATA_STATE_UNUSED) {
1776                 unsigned int mask, shift;
1777
1778                 if (entry->trunk) {
1779                         reg |= GLOBAL_ATU_DATA_TRUNK;
1780                         mask = GLOBAL_ATU_DATA_TRUNK_ID_MASK;
1781                         shift = GLOBAL_ATU_DATA_TRUNK_ID_SHIFT;
1782                 } else {
1783                         mask = GLOBAL_ATU_DATA_PORT_VECTOR_MASK;
1784                         shift = GLOBAL_ATU_DATA_PORT_VECTOR_SHIFT;
1785                 }
1786
1787                 reg |= (entry->portv_trunkid << shift) & mask;
1788         }
1789
1790         reg |= entry->state & GLOBAL_ATU_DATA_STATE_MASK;
1791
1792         ret = _mv88e6xxx_reg_write(ds, REG_GLOBAL, GLOBAL_ATU_DATA, reg);
1793         if (ret < 0)
1794                 return ret;
1795
1796         return _mv88e6xxx_atu_cmd(ds, entry->fid, GLOBAL_ATU_OP_LOAD_DB);
1797 }
1798
1799 static int _mv88e6xxx_port_vid_to_fid(struct dsa_switch *ds, int port, u16 vid)
1800 {
1801         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
1802         struct mv88e6xxx_vtu_stu_entry vlan;
1803         int err;
1804
1805         if (vid == 0)
1806                 return ps->fid[port];
1807
1808         err = _mv88e6xxx_port_vtu_getnext(ds, port, vid - 1, &vlan);
1809         if (err)
1810                 return err;
1811
1812         if (vlan.vid == vid)
1813                 return vlan.fid;
1814
1815         return -ENOENT;
1816 }
1817
1818 static int _mv88e6xxx_port_fdb_load(struct dsa_switch *ds, int port,
1819                                     const unsigned char *addr, u16 vid,
1820                                     u8 state)
1821 {
1822         struct mv88e6xxx_atu_entry entry = { 0 };
1823         int ret;
1824
1825         ret = _mv88e6xxx_port_vid_to_fid(ds, port, vid);
1826         if (ret < 0)
1827                 return ret;
1828
1829         entry.fid = ret;
1830         entry.state = state;
1831         ether_addr_copy(entry.mac, addr);
1832         if (state != GLOBAL_ATU_DATA_STATE_UNUSED) {
1833                 entry.trunk = false;
1834                 entry.portv_trunkid = BIT(port);
1835         }
1836
1837         return _mv88e6xxx_atu_load(ds, &entry);
1838 }
1839
1840 int mv88e6xxx_port_fdb_add(struct dsa_switch *ds, int port,
1841                            const unsigned char *addr, u16 vid)
1842 {
1843         int state = is_multicast_ether_addr(addr) ?
1844                 GLOBAL_ATU_DATA_STATE_MC_STATIC :
1845                 GLOBAL_ATU_DATA_STATE_UC_STATIC;
1846         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
1847         int ret;
1848
1849         mutex_lock(&ps->smi_mutex);
1850         ret = _mv88e6xxx_port_fdb_load(ds, port, addr, vid, state);
1851         mutex_unlock(&ps->smi_mutex);
1852
1853         return ret;
1854 }
1855
1856 int mv88e6xxx_port_fdb_del(struct dsa_switch *ds, int port,
1857                            const unsigned char *addr, u16 vid)
1858 {
1859         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
1860         int ret;
1861
1862         mutex_lock(&ps->smi_mutex);
1863         ret = _mv88e6xxx_port_fdb_load(ds, port, addr, vid,
1864                                        GLOBAL_ATU_DATA_STATE_UNUSED);
1865         mutex_unlock(&ps->smi_mutex);
1866
1867         return ret;
1868 }
1869
1870 static int _mv88e6xxx_atu_getnext(struct dsa_switch *ds, u16 fid,
1871                                   const unsigned char *addr,
1872                                   struct mv88e6xxx_atu_entry *entry)
1873 {
1874         struct mv88e6xxx_atu_entry next = { 0 };
1875         int ret;
1876
1877         next.fid = fid;
1878
1879         ret = _mv88e6xxx_atu_wait(ds);
1880         if (ret < 0)
1881                 return ret;
1882
1883         ret = _mv88e6xxx_atu_mac_write(ds, addr);
1884         if (ret < 0)
1885                 return ret;
1886
1887         ret = _mv88e6xxx_atu_cmd(ds, fid, GLOBAL_ATU_OP_GET_NEXT_DB);
1888         if (ret < 0)
1889                 return ret;
1890
1891         ret = _mv88e6xxx_atu_mac_read(ds, next.mac);
1892         if (ret < 0)
1893                 return ret;
1894
1895         ret = _mv88e6xxx_reg_read(ds, REG_GLOBAL, GLOBAL_ATU_DATA);
1896         if (ret < 0)
1897                 return ret;
1898
1899         next.state = ret & GLOBAL_ATU_DATA_STATE_MASK;
1900         if (next.state != GLOBAL_ATU_DATA_STATE_UNUSED) {
1901                 unsigned int mask, shift;
1902
1903                 if (ret & GLOBAL_ATU_DATA_TRUNK) {
1904                         next.trunk = true;
1905                         mask = GLOBAL_ATU_DATA_TRUNK_ID_MASK;
1906                         shift = GLOBAL_ATU_DATA_TRUNK_ID_SHIFT;
1907                 } else {
1908                         next.trunk = false;
1909                         mask = GLOBAL_ATU_DATA_PORT_VECTOR_MASK;
1910                         shift = GLOBAL_ATU_DATA_PORT_VECTOR_SHIFT;
1911                 }
1912
1913                 next.portv_trunkid = (ret & mask) >> shift;
1914         }
1915
1916         *entry = next;
1917         return 0;
1918 }
1919
1920 /* get next entry for port */
1921 int mv88e6xxx_port_fdb_getnext(struct dsa_switch *ds, int port,
1922                                unsigned char *addr, u16 *vid, bool *is_static)
1923 {
1924         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
1925         struct mv88e6xxx_atu_entry next;
1926         u16 fid;
1927         int ret;
1928
1929         mutex_lock(&ps->smi_mutex);
1930
1931         ret = _mv88e6xxx_port_vid_to_fid(ds, port, *vid);
1932         if (ret < 0)
1933                 goto unlock;
1934         fid = ret;
1935
1936         do {
1937                 if (is_broadcast_ether_addr(addr)) {
1938                         struct mv88e6xxx_vtu_stu_entry vtu;
1939
1940                         ret = _mv88e6xxx_port_vtu_getnext(ds, port, *vid, &vtu);
1941                         if (ret < 0)
1942                                 goto unlock;
1943
1944                         *vid = vtu.vid;
1945                         fid = vtu.fid;
1946                 }
1947
1948                 ret = _mv88e6xxx_atu_getnext(ds, fid, addr, &next);
1949                 if (ret < 0)
1950                         goto unlock;
1951
1952                 ether_addr_copy(addr, next.mac);
1953
1954                 if (next.state == GLOBAL_ATU_DATA_STATE_UNUSED)
1955                         continue;
1956         } while (next.trunk || (next.portv_trunkid & BIT(port)) == 0);
1957
1958         *is_static = next.state == (is_multicast_ether_addr(addr) ?
1959                                     GLOBAL_ATU_DATA_STATE_MC_STATIC :
1960                                     GLOBAL_ATU_DATA_STATE_UC_STATIC);
1961 unlock:
1962         mutex_unlock(&ps->smi_mutex);
1963
1964         return ret;
1965 }
1966
1967 static void mv88e6xxx_bridge_work(struct work_struct *work)
1968 {
1969         struct mv88e6xxx_priv_state *ps;
1970         struct dsa_switch *ds;
1971         int port;
1972
1973         ps = container_of(work, struct mv88e6xxx_priv_state, bridge_work);
1974         ds = ((struct dsa_switch *)ps) - 1;
1975
1976         while (ps->port_state_update_mask) {
1977                 port = __ffs(ps->port_state_update_mask);
1978                 clear_bit(port, &ps->port_state_update_mask);
1979                 mv88e6xxx_set_port_state(ds, port, ps->port_state[port]);
1980         }
1981 }
1982
1983 static int mv88e6xxx_setup_port(struct dsa_switch *ds, int port)
1984 {
1985         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
1986         int ret, fid;
1987         u16 reg;
1988
1989         mutex_lock(&ps->smi_mutex);
1990
1991         if (mv88e6xxx_6352_family(ds) || mv88e6xxx_6351_family(ds) ||
1992             mv88e6xxx_6165_family(ds) || mv88e6xxx_6097_family(ds) ||
1993             mv88e6xxx_6185_family(ds) || mv88e6xxx_6095_family(ds) ||
1994             mv88e6xxx_6065_family(ds) || mv88e6xxx_6320_family(ds)) {
1995                 /* MAC Forcing register: don't force link, speed,
1996                  * duplex or flow control state to any particular
1997                  * values on physical ports, but force the CPU port
1998                  * and all DSA ports to their maximum bandwidth and
1999                  * full duplex.
2000                  */
2001                 reg = _mv88e6xxx_reg_read(ds, REG_PORT(port), PORT_PCS_CTRL);
2002                 if (dsa_is_cpu_port(ds, port) || dsa_is_dsa_port(ds, port)) {
2003                         reg &= ~PORT_PCS_CTRL_UNFORCED;
2004                         reg |= PORT_PCS_CTRL_FORCE_LINK |
2005                                 PORT_PCS_CTRL_LINK_UP |
2006                                 PORT_PCS_CTRL_DUPLEX_FULL |
2007                                 PORT_PCS_CTRL_FORCE_DUPLEX;
2008                         if (mv88e6xxx_6065_family(ds))
2009                                 reg |= PORT_PCS_CTRL_100;
2010                         else
2011                                 reg |= PORT_PCS_CTRL_1000;
2012                 } else {
2013                         reg |= PORT_PCS_CTRL_UNFORCED;
2014                 }
2015
2016                 ret = _mv88e6xxx_reg_write(ds, REG_PORT(port),
2017                                            PORT_PCS_CTRL, reg);
2018                 if (ret)
2019                         goto abort;
2020         }
2021
2022         /* Port Control: disable Drop-on-Unlock, disable Drop-on-Lock,
2023          * disable Header mode, enable IGMP/MLD snooping, disable VLAN
2024          * tunneling, determine priority by looking at 802.1p and IP
2025          * priority fields (IP prio has precedence), and set STP state
2026          * to Forwarding.
2027          *
2028          * If this is the CPU link, use DSA or EDSA tagging depending
2029          * on which tagging mode was configured.
2030          *
2031          * If this is a link to another switch, use DSA tagging mode.
2032          *
2033          * If this is the upstream port for this switch, enable
2034          * forwarding of unknown unicasts and multicasts.
2035          */
2036         reg = 0;
2037         if (mv88e6xxx_6352_family(ds) || mv88e6xxx_6351_family(ds) ||
2038             mv88e6xxx_6165_family(ds) || mv88e6xxx_6097_family(ds) ||
2039             mv88e6xxx_6095_family(ds) || mv88e6xxx_6065_family(ds) ||
2040             mv88e6xxx_6185_family(ds) || mv88e6xxx_6320_family(ds))
2041                 reg = PORT_CONTROL_IGMP_MLD_SNOOP |
2042                 PORT_CONTROL_USE_TAG | PORT_CONTROL_USE_IP |
2043                 PORT_CONTROL_STATE_FORWARDING;
2044         if (dsa_is_cpu_port(ds, port)) {
2045                 if (mv88e6xxx_6095_family(ds) || mv88e6xxx_6185_family(ds))
2046                         reg |= PORT_CONTROL_DSA_TAG;
2047                 if (mv88e6xxx_6352_family(ds) || mv88e6xxx_6351_family(ds) ||
2048                     mv88e6xxx_6165_family(ds) || mv88e6xxx_6097_family(ds) ||
2049                     mv88e6xxx_6320_family(ds)) {
2050                         if (ds->dst->tag_protocol == DSA_TAG_PROTO_EDSA)
2051                                 reg |= PORT_CONTROL_FRAME_ETHER_TYPE_DSA;
2052                         else
2053                                 reg |= PORT_CONTROL_FRAME_MODE_DSA;
2054                 }
2055
2056                 if (mv88e6xxx_6352_family(ds) || mv88e6xxx_6351_family(ds) ||
2057                     mv88e6xxx_6165_family(ds) || mv88e6xxx_6097_family(ds) ||
2058                     mv88e6xxx_6095_family(ds) || mv88e6xxx_6065_family(ds) ||
2059                     mv88e6xxx_6185_family(ds) || mv88e6xxx_6320_family(ds)) {
2060                         if (ds->dst->tag_protocol == DSA_TAG_PROTO_EDSA)
2061                                 reg |= PORT_CONTROL_EGRESS_ADD_TAG;
2062                 }
2063         }
2064         if (dsa_is_dsa_port(ds, port)) {
2065                 if (mv88e6xxx_6095_family(ds) || mv88e6xxx_6185_family(ds))
2066                         reg |= PORT_CONTROL_DSA_TAG;
2067                 if (mv88e6xxx_6352_family(ds) || mv88e6xxx_6351_family(ds) ||
2068                     mv88e6xxx_6165_family(ds) || mv88e6xxx_6097_family(ds) ||
2069                     mv88e6xxx_6320_family(ds)) {
2070                         reg |= PORT_CONTROL_FRAME_MODE_DSA;
2071                 }
2072
2073                 if (port == dsa_upstream_port(ds))
2074                         reg |= PORT_CONTROL_FORWARD_UNKNOWN |
2075                                 PORT_CONTROL_FORWARD_UNKNOWN_MC;
2076         }
2077         if (reg) {
2078                 ret = _mv88e6xxx_reg_write(ds, REG_PORT(port),
2079                                            PORT_CONTROL, reg);
2080                 if (ret)
2081                         goto abort;
2082         }
2083
2084         /* Port Control 2: don't force a good FCS, set the maximum frame size to
2085          * 10240 bytes, enable secure 802.1q tags, don't discard tagged or
2086          * untagged frames on this port, do a destination address lookup on all
2087          * received packets as usual, disable ARP mirroring and don't send a
2088          * copy of all transmitted/received frames on this port to the CPU.
2089          */
2090         reg = 0;
2091         if (mv88e6xxx_6352_family(ds) || mv88e6xxx_6351_family(ds) ||
2092             mv88e6xxx_6165_family(ds) || mv88e6xxx_6097_family(ds) ||
2093             mv88e6xxx_6095_family(ds) || mv88e6xxx_6320_family(ds))
2094                 reg = PORT_CONTROL_2_MAP_DA;
2095
2096         if (mv88e6xxx_6352_family(ds) || mv88e6xxx_6351_family(ds) ||
2097             mv88e6xxx_6165_family(ds) || mv88e6xxx_6320_family(ds))
2098                 reg |= PORT_CONTROL_2_JUMBO_10240;
2099
2100         if (mv88e6xxx_6095_family(ds) || mv88e6xxx_6185_family(ds)) {
2101                 /* Set the upstream port this port should use */
2102                 reg |= dsa_upstream_port(ds);
2103                 /* enable forwarding of unknown multicast addresses to
2104                  * the upstream port
2105                  */
2106                 if (port == dsa_upstream_port(ds))
2107                         reg |= PORT_CONTROL_2_FORWARD_UNKNOWN;
2108         }
2109
2110         reg |= PORT_CONTROL_2_8021Q_FALLBACK;
2111
2112         if (reg) {
2113                 ret = _mv88e6xxx_reg_write(ds, REG_PORT(port),
2114                                            PORT_CONTROL_2, reg);
2115                 if (ret)
2116                         goto abort;
2117         }
2118
2119         /* Port Association Vector: when learning source addresses
2120          * of packets, add the address to the address database using
2121          * a port bitmap that has only the bit for this port set and
2122          * the other bits clear.
2123          */
2124         ret = _mv88e6xxx_reg_write(ds, REG_PORT(port), PORT_ASSOC_VECTOR,
2125                                    1 << port);
2126         if (ret)
2127                 goto abort;
2128
2129         /* Egress rate control 2: disable egress rate control. */
2130         ret = _mv88e6xxx_reg_write(ds, REG_PORT(port), PORT_RATE_CONTROL_2,
2131                                    0x0000);
2132         if (ret)
2133                 goto abort;
2134
2135         if (mv88e6xxx_6352_family(ds) || mv88e6xxx_6351_family(ds) ||
2136             mv88e6xxx_6165_family(ds) || mv88e6xxx_6097_family(ds) ||
2137             mv88e6xxx_6320_family(ds)) {
2138                 /* Do not limit the period of time that this port can
2139                  * be paused for by the remote end or the period of
2140                  * time that this port can pause the remote end.
2141                  */
2142                 ret = _mv88e6xxx_reg_write(ds, REG_PORT(port),
2143                                            PORT_PAUSE_CTRL, 0x0000);
2144                 if (ret)
2145                         goto abort;
2146
2147                 /* Port ATU control: disable limiting the number of
2148                  * address database entries that this port is allowed
2149                  * to use.
2150                  */
2151                 ret = _mv88e6xxx_reg_write(ds, REG_PORT(port),
2152                                            PORT_ATU_CONTROL, 0x0000);
2153                 /* Priority Override: disable DA, SA and VTU priority
2154                  * override.
2155                  */
2156                 ret = _mv88e6xxx_reg_write(ds, REG_PORT(port),
2157                                            PORT_PRI_OVERRIDE, 0x0000);
2158                 if (ret)
2159                         goto abort;
2160
2161                 /* Port Ethertype: use the Ethertype DSA Ethertype
2162                  * value.
2163                  */
2164                 ret = _mv88e6xxx_reg_write(ds, REG_PORT(port),
2165                                            PORT_ETH_TYPE, ETH_P_EDSA);
2166                 if (ret)
2167                         goto abort;
2168                 /* Tag Remap: use an identity 802.1p prio -> switch
2169                  * prio mapping.
2170                  */
2171                 ret = _mv88e6xxx_reg_write(ds, REG_PORT(port),
2172                                            PORT_TAG_REGMAP_0123, 0x3210);
2173                 if (ret)
2174                         goto abort;
2175
2176                 /* Tag Remap 2: use an identity 802.1p prio -> switch
2177                  * prio mapping.
2178                  */
2179                 ret = _mv88e6xxx_reg_write(ds, REG_PORT(port),
2180                                            PORT_TAG_REGMAP_4567, 0x7654);
2181                 if (ret)
2182                         goto abort;
2183         }
2184
2185         if (mv88e6xxx_6352_family(ds) || mv88e6xxx_6351_family(ds) ||
2186             mv88e6xxx_6165_family(ds) || mv88e6xxx_6097_family(ds) ||
2187             mv88e6xxx_6185_family(ds) || mv88e6xxx_6095_family(ds) ||
2188             mv88e6xxx_6320_family(ds)) {
2189                 /* Rate Control: disable ingress rate limiting. */
2190                 ret = _mv88e6xxx_reg_write(ds, REG_PORT(port),
2191                                            PORT_RATE_CONTROL, 0x0001);
2192                 if (ret)
2193                         goto abort;
2194         }
2195
2196         /* Port Control 1: disable trunking, disable sending
2197          * learning messages to this port.
2198          */
2199         ret = _mv88e6xxx_reg_write(ds, REG_PORT(port), PORT_CONTROL_1, 0x0000);
2200         if (ret)
2201                 goto abort;
2202
2203         /* Port based VLAN map: give each port its own address
2204          * database, allow the CPU port to talk to each of the 'real'
2205          * ports, and allow each of the 'real' ports to only talk to
2206          * the upstream port.
2207          */
2208         fid = port + 1;
2209         ps->fid[port] = fid;
2210         set_bit(fid, ps->fid_bitmap);
2211
2212         if (!dsa_is_cpu_port(ds, port))
2213                 ps->bridge_mask[fid] = 1 << port;
2214
2215         ret = _mv88e6xxx_update_port_config(ds, port);
2216         if (ret)
2217                 goto abort;
2218
2219         /* Default VLAN ID and priority: don't set a default VLAN
2220          * ID, and set the default packet priority to zero.
2221          */
2222         ret = _mv88e6xxx_reg_write(ds, REG_PORT(port), PORT_DEFAULT_VLAN,
2223                                    0x0000);
2224 abort:
2225         mutex_unlock(&ps->smi_mutex);
2226         return ret;
2227 }
2228
2229 int mv88e6xxx_setup_ports(struct dsa_switch *ds)
2230 {
2231         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
2232         int ret;
2233         int i;
2234
2235         for (i = 0; i < ps->num_ports; i++) {
2236                 ret = mv88e6xxx_setup_port(ds, i);
2237                 if (ret < 0)
2238                         return ret;
2239         }
2240         return 0;
2241 }
2242
2243 static int mv88e6xxx_regs_show(struct seq_file *s, void *p)
2244 {
2245         struct dsa_switch *ds = s->private;
2246
2247         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
2248         int reg, port;
2249
2250         seq_puts(s, "    GLOBAL GLOBAL2 ");
2251         for (port = 0 ; port < ps->num_ports; port++)
2252                 seq_printf(s, " %2d  ", port);
2253         seq_puts(s, "\n");
2254
2255         for (reg = 0; reg < 32; reg++) {
2256                 seq_printf(s, "%2x: ", reg);
2257                 seq_printf(s, " %4x    %4x  ",
2258                            mv88e6xxx_reg_read(ds, REG_GLOBAL, reg),
2259                            mv88e6xxx_reg_read(ds, REG_GLOBAL2, reg));
2260
2261                 for (port = 0 ; port < ps->num_ports; port++)
2262                         seq_printf(s, "%4x ",
2263                                    mv88e6xxx_reg_read(ds, REG_PORT(port), reg));
2264                 seq_puts(s, "\n");
2265         }
2266
2267         return 0;
2268 }
2269
2270 static int mv88e6xxx_regs_open(struct inode *inode, struct file *file)
2271 {
2272         return single_open(file, mv88e6xxx_regs_show, inode->i_private);
2273 }
2274
2275 static const struct file_operations mv88e6xxx_regs_fops = {
2276         .open   = mv88e6xxx_regs_open,
2277         .read   = seq_read,
2278         .llseek = no_llseek,
2279         .release = single_release,
2280         .owner  = THIS_MODULE,
2281 };
2282
2283 static void mv88e6xxx_atu_show_header(struct seq_file *s)
2284 {
2285         seq_puts(s, "DB   T/P  Vec State Addr\n");
2286 }
2287
2288 static void mv88e6xxx_atu_show_entry(struct seq_file *s, int dbnum,
2289                                      unsigned char *addr, int data)
2290 {
2291         bool trunk = !!(data & GLOBAL_ATU_DATA_TRUNK);
2292         int portvec = ((data & GLOBAL_ATU_DATA_PORT_VECTOR_MASK) >>
2293                        GLOBAL_ATU_DATA_PORT_VECTOR_SHIFT);
2294         int state = data & GLOBAL_ATU_DATA_STATE_MASK;
2295
2296         seq_printf(s, "%03x %5s %10pb   %x   %pM\n",
2297                    dbnum, (trunk ? "Trunk" : "Port"), &portvec, state, addr);
2298 }
2299
2300 static int mv88e6xxx_atu_show_db(struct seq_file *s, struct dsa_switch *ds,
2301                                  int dbnum)
2302 {
2303         unsigned char bcast[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
2304         unsigned char addr[6];
2305         int ret, data, state;
2306
2307         ret = _mv88e6xxx_atu_mac_write(ds, bcast);
2308         if (ret < 0)
2309                 return ret;
2310
2311         do {
2312                 ret = _mv88e6xxx_atu_cmd(ds, dbnum, GLOBAL_ATU_OP_GET_NEXT_DB);
2313                 if (ret < 0)
2314                         return ret;
2315                 data = _mv88e6xxx_reg_read(ds, REG_GLOBAL, GLOBAL_ATU_DATA);
2316                 if (data < 0)
2317                         return data;
2318
2319                 state = data & GLOBAL_ATU_DATA_STATE_MASK;
2320                 if (state == GLOBAL_ATU_DATA_STATE_UNUSED)
2321                         break;
2322                 ret = _mv88e6xxx_atu_mac_read(ds, addr);
2323                 if (ret < 0)
2324                         return ret;
2325                 mv88e6xxx_atu_show_entry(s, dbnum, addr, data);
2326         } while (state != GLOBAL_ATU_DATA_STATE_UNUSED);
2327
2328         return 0;
2329 }
2330
2331 static int mv88e6xxx_atu_show(struct seq_file *s, void *p)
2332 {
2333         struct dsa_switch *ds = s->private;
2334         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
2335         int dbnum;
2336
2337         mv88e6xxx_atu_show_header(s);
2338
2339         for (dbnum = 0; dbnum < 255; dbnum++) {
2340                 mutex_lock(&ps->smi_mutex);
2341                 mv88e6xxx_atu_show_db(s, ds, dbnum);
2342                 mutex_unlock(&ps->smi_mutex);
2343         }
2344
2345         return 0;
2346 }
2347
2348 static int mv88e6xxx_atu_open(struct inode *inode, struct file *file)
2349 {
2350         return single_open(file, mv88e6xxx_atu_show, inode->i_private);
2351 }
2352
2353 static const struct file_operations mv88e6xxx_atu_fops = {
2354         .open   = mv88e6xxx_atu_open,
2355         .read   = seq_read,
2356         .llseek = no_llseek,
2357         .release = single_release,
2358         .owner  = THIS_MODULE,
2359 };
2360
2361 static void mv88e6xxx_stats_show_header(struct seq_file *s,
2362                                         struct mv88e6xxx_priv_state *ps)
2363 {
2364         int port;
2365
2366         seq_puts(s, "      Statistic       ");
2367         for (port = 0 ; port < ps->num_ports; port++)
2368                 seq_printf(s, "Port %2d  ", port);
2369         seq_puts(s, "\n");
2370 }
2371
2372 static int mv88e6xxx_stats_show(struct seq_file *s, void *p)
2373 {
2374         struct dsa_switch *ds = s->private;
2375         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
2376         struct mv88e6xxx_hw_stat *stats = mv88e6xxx_hw_stats;
2377         int port, stat, max_stats;
2378         uint64_t value;
2379
2380         if (have_sw_in_discards(ds))
2381                 max_stats = ARRAY_SIZE(mv88e6xxx_hw_stats);
2382         else
2383                 max_stats = ARRAY_SIZE(mv88e6xxx_hw_stats) - 3;
2384
2385         mv88e6xxx_stats_show_header(s, ps);
2386
2387         mutex_lock(&ps->smi_mutex);
2388
2389         for (stat = 0; stat < max_stats; stat++) {
2390                 seq_printf(s, "%19s: ", stats[stat].string);
2391                 for (port = 0 ; port < ps->num_ports; port++) {
2392                         _mv88e6xxx_stats_snapshot(ds, port);
2393                         value = _mv88e6xxx_get_ethtool_stat(ds, stat, stats,
2394                                                             port);
2395                         seq_printf(s, "%8llu ", value);
2396                 }
2397                 seq_puts(s, "\n");
2398         }
2399         mutex_unlock(&ps->smi_mutex);
2400
2401         return 0;
2402 }
2403
2404 static int mv88e6xxx_stats_open(struct inode *inode, struct file *file)
2405 {
2406         return single_open(file, mv88e6xxx_stats_show, inode->i_private);
2407 }
2408
2409 static const struct file_operations mv88e6xxx_stats_fops = {
2410         .open   = mv88e6xxx_stats_open,
2411         .read   = seq_read,
2412         .llseek = no_llseek,
2413         .release = single_release,
2414         .owner  = THIS_MODULE,
2415 };
2416
2417 static int mv88e6xxx_device_map_show(struct seq_file *s, void *p)
2418 {
2419         struct dsa_switch *ds = s->private;
2420         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
2421         int target, ret;
2422
2423         seq_puts(s, "Target Port\n");
2424
2425         mutex_lock(&ps->smi_mutex);
2426         for (target = 0; target < 32; target++) {
2427                 ret = _mv88e6xxx_reg_write(
2428                         ds, REG_GLOBAL2, GLOBAL2_DEVICE_MAPPING,
2429                         target << GLOBAL2_DEVICE_MAPPING_TARGET_SHIFT);
2430                 if (ret < 0)
2431                         goto out;
2432                 ret = _mv88e6xxx_reg_read(ds, REG_GLOBAL2,
2433                                           GLOBAL2_DEVICE_MAPPING);
2434                 seq_printf(s, "  %2d   %2d\n", target,
2435                            ret & GLOBAL2_DEVICE_MAPPING_PORT_MASK);
2436         }
2437 out:
2438         mutex_unlock(&ps->smi_mutex);
2439
2440         return 0;
2441 }
2442
2443 static int mv88e6xxx_device_map_open(struct inode *inode, struct file *file)
2444 {
2445         return single_open(file, mv88e6xxx_device_map_show, inode->i_private);
2446 }
2447
2448 static const struct file_operations mv88e6xxx_device_map_fops = {
2449         .open   = mv88e6xxx_device_map_open,
2450         .read   = seq_read,
2451         .llseek = no_llseek,
2452         .release = single_release,
2453         .owner  = THIS_MODULE,
2454 };
2455
2456 static int mv88e6xxx_scratch_show(struct seq_file *s, void *p)
2457 {
2458         struct dsa_switch *ds = s->private;
2459         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
2460         int reg, ret;
2461
2462         seq_puts(s, "Register Value\n");
2463
2464         mutex_lock(&ps->smi_mutex);
2465         for (reg = 0; reg < 0x80; reg++) {
2466                 ret = _mv88e6xxx_reg_write(
2467                         ds, REG_GLOBAL2, GLOBAL2_SCRATCH_MISC,
2468                         reg << GLOBAL2_SCRATCH_REGISTER_SHIFT);
2469                 if (ret < 0)
2470                         goto out;
2471
2472                 ret = _mv88e6xxx_scratch_wait(ds);
2473                 if (ret < 0)
2474                         goto out;
2475
2476                 ret = _mv88e6xxx_reg_read(ds, REG_GLOBAL2,
2477                                           GLOBAL2_SCRATCH_MISC);
2478                 seq_printf(s, "  %2x   %2x\n", reg,
2479                            ret & GLOBAL2_SCRATCH_VALUE_MASK);
2480         }
2481 out:
2482         mutex_unlock(&ps->smi_mutex);
2483
2484         return 0;
2485 }
2486
2487 static int mv88e6xxx_scratch_open(struct inode *inode, struct file *file)
2488 {
2489         return single_open(file, mv88e6xxx_scratch_show, inode->i_private);
2490 }
2491
2492 static const struct file_operations mv88e6xxx_scratch_fops = {
2493         .open   = mv88e6xxx_scratch_open,
2494         .read   = seq_read,
2495         .llseek = no_llseek,
2496         .release = single_release,
2497         .owner  = THIS_MODULE,
2498 };
2499
2500 int mv88e6xxx_setup_common(struct dsa_switch *ds)
2501 {
2502         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
2503         char *name;
2504
2505         mutex_init(&ps->smi_mutex);
2506
2507         ps->id = REG_READ(REG_PORT(0), PORT_SWITCH_ID) & 0xfff0;
2508
2509         INIT_WORK(&ps->bridge_work, mv88e6xxx_bridge_work);
2510
2511         name = kasprintf(GFP_KERNEL, "dsa%d", ds->index);
2512         ps->dbgfs = debugfs_create_dir(name, NULL);
2513         kfree(name);
2514
2515         debugfs_create_file("regs", S_IRUGO, ps->dbgfs, ds,
2516                             &mv88e6xxx_regs_fops);
2517
2518         debugfs_create_file("atu", S_IRUGO, ps->dbgfs, ds,
2519                             &mv88e6xxx_atu_fops);
2520
2521         debugfs_create_file("stats", S_IRUGO, ps->dbgfs, ds,
2522                             &mv88e6xxx_stats_fops);
2523
2524         debugfs_create_file("device_map", S_IRUGO, ps->dbgfs, ds,
2525                             &mv88e6xxx_device_map_fops);
2526
2527         debugfs_create_file("scratch", S_IRUGO, ps->dbgfs, ds,
2528                             &mv88e6xxx_scratch_fops);
2529         return 0;
2530 }
2531
2532 int mv88e6xxx_setup_global(struct dsa_switch *ds)
2533 {
2534         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
2535         int ret;
2536         int i;
2537
2538         /* Set the default address aging time to 5 minutes, and
2539          * enable address learn messages to be sent to all message
2540          * ports.
2541          */
2542         REG_WRITE(REG_GLOBAL, GLOBAL_ATU_CONTROL,
2543                   0x0140 | GLOBAL_ATU_CONTROL_LEARN2ALL);
2544
2545         /* Configure the IP ToS mapping registers. */
2546         REG_WRITE(REG_GLOBAL, GLOBAL_IP_PRI_0, 0x0000);
2547         REG_WRITE(REG_GLOBAL, GLOBAL_IP_PRI_1, 0x0000);
2548         REG_WRITE(REG_GLOBAL, GLOBAL_IP_PRI_2, 0x5555);
2549         REG_WRITE(REG_GLOBAL, GLOBAL_IP_PRI_3, 0x5555);
2550         REG_WRITE(REG_GLOBAL, GLOBAL_IP_PRI_4, 0xaaaa);
2551         REG_WRITE(REG_GLOBAL, GLOBAL_IP_PRI_5, 0xaaaa);
2552         REG_WRITE(REG_GLOBAL, GLOBAL_IP_PRI_6, 0xffff);
2553         REG_WRITE(REG_GLOBAL, GLOBAL_IP_PRI_7, 0xffff);
2554
2555         /* Configure the IEEE 802.1p priority mapping register. */
2556         REG_WRITE(REG_GLOBAL, GLOBAL_IEEE_PRI, 0xfa41);
2557
2558         /* Send all frames with destination addresses matching
2559          * 01:80:c2:00:00:0x to the CPU port.
2560          */
2561         REG_WRITE(REG_GLOBAL2, GLOBAL2_MGMT_EN_0X, 0xffff);
2562
2563         /* Ignore removed tag data on doubly tagged packets, disable
2564          * flow control messages, force flow control priority to the
2565          * highest, and send all special multicast frames to the CPU
2566          * port at the highest priority.
2567          */
2568         REG_WRITE(REG_GLOBAL2, GLOBAL2_SWITCH_MGMT,
2569                   0x7 | GLOBAL2_SWITCH_MGMT_RSVD2CPU | 0x70 |
2570                   GLOBAL2_SWITCH_MGMT_FORCE_FLOW_CTRL_PRI);
2571
2572         /* Program the DSA routing table. */
2573         for (i = 0; i < 32; i++) {
2574                 int nexthop = 0x1f;
2575
2576                 if (ds->pd->rtable &&
2577                     i != ds->index && i < ds->dst->pd->nr_chips)
2578                         nexthop = ds->pd->rtable[i] & 0x1f;
2579
2580                 REG_WRITE(REG_GLOBAL2, GLOBAL2_DEVICE_MAPPING,
2581                           GLOBAL2_DEVICE_MAPPING_UPDATE |
2582                           (i << GLOBAL2_DEVICE_MAPPING_TARGET_SHIFT) |
2583                           nexthop);
2584         }
2585
2586         /* Clear all trunk masks. */
2587         for (i = 0; i < 8; i++)
2588                 REG_WRITE(REG_GLOBAL2, GLOBAL2_TRUNK_MASK,
2589                           0x8000 | (i << GLOBAL2_TRUNK_MASK_NUM_SHIFT) |
2590                           ((1 << ps->num_ports) - 1));
2591
2592         /* Clear all trunk mappings. */
2593         for (i = 0; i < 16; i++)
2594                 REG_WRITE(REG_GLOBAL2, GLOBAL2_TRUNK_MAPPING,
2595                           GLOBAL2_TRUNK_MAPPING_UPDATE |
2596                           (i << GLOBAL2_TRUNK_MAPPING_ID_SHIFT));
2597
2598         if (mv88e6xxx_6352_family(ds) || mv88e6xxx_6351_family(ds) ||
2599             mv88e6xxx_6165_family(ds) || mv88e6xxx_6097_family(ds) ||
2600             mv88e6xxx_6320_family(ds)) {
2601                 /* Send all frames with destination addresses matching
2602                  * 01:80:c2:00:00:2x to the CPU port.
2603                  */
2604                 REG_WRITE(REG_GLOBAL2, GLOBAL2_MGMT_EN_2X, 0xffff);
2605
2606                 /* Initialise cross-chip port VLAN table to reset
2607                  * defaults.
2608                  */
2609                 REG_WRITE(REG_GLOBAL2, GLOBAL2_PVT_ADDR, 0x9000);
2610
2611                 /* Clear the priority override table. */
2612                 for (i = 0; i < 16; i++)
2613                         REG_WRITE(REG_GLOBAL2, GLOBAL2_PRIO_OVERRIDE,
2614                                   0x8000 | (i << 8));
2615         }
2616
2617         if (mv88e6xxx_6352_family(ds) || mv88e6xxx_6351_family(ds) ||
2618             mv88e6xxx_6165_family(ds) || mv88e6xxx_6097_family(ds) ||
2619             mv88e6xxx_6185_family(ds) || mv88e6xxx_6095_family(ds) ||
2620             mv88e6xxx_6320_family(ds)) {
2621                 /* Disable ingress rate limiting by resetting all
2622                  * ingress rate limit registers to their initial
2623                  * state.
2624                  */
2625                 for (i = 0; i < ps->num_ports; i++)
2626                         REG_WRITE(REG_GLOBAL2, GLOBAL2_INGRESS_OP,
2627                                   0x9000 | (i << 8));
2628         }
2629
2630         /* Clear the statistics counters for all ports */
2631         REG_WRITE(REG_GLOBAL, GLOBAL_STATS_OP, GLOBAL_STATS_OP_FLUSH_ALL);
2632
2633         /* Wait for the flush to complete. */
2634         mutex_lock(&ps->smi_mutex);
2635         ret = _mv88e6xxx_stats_wait(ds);
2636         if (ret < 0)
2637                 goto unlock;
2638
2639         /* Clear all the VTU and STU entries */
2640         ret = _mv88e6xxx_vtu_stu_flush(ds);
2641 unlock:
2642         mutex_unlock(&ps->smi_mutex);
2643
2644         return ret;
2645 }
2646
2647 int mv88e6xxx_switch_reset(struct dsa_switch *ds, bool ppu_active)
2648 {
2649         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
2650         u16 is_reset = (ppu_active ? 0x8800 : 0xc800);
2651         unsigned long timeout;
2652         int ret;
2653         int i;
2654
2655         /* Set all ports to the disabled state. */
2656         for (i = 0; i < ps->num_ports; i++) {
2657                 ret = REG_READ(REG_PORT(i), PORT_CONTROL);
2658                 REG_WRITE(REG_PORT(i), PORT_CONTROL, ret & 0xfffc);
2659         }
2660
2661         /* Wait for transmit queues to drain. */
2662         usleep_range(2000, 4000);
2663
2664         /* Reset the switch. Keep the PPU active if requested. The PPU
2665          * needs to be active to support indirect phy register access
2666          * through global registers 0x18 and 0x19.
2667          */
2668         if (ppu_active)
2669                 REG_WRITE(REG_GLOBAL, 0x04, 0xc000);
2670         else
2671                 REG_WRITE(REG_GLOBAL, 0x04, 0xc400);
2672
2673         /* Wait up to one second for reset to complete. */
2674         timeout = jiffies + 1 * HZ;
2675         while (time_before(jiffies, timeout)) {
2676                 ret = REG_READ(REG_GLOBAL, 0x00);
2677                 if ((ret & is_reset) == is_reset)
2678                         break;
2679                 usleep_range(1000, 2000);
2680         }
2681         if (time_after(jiffies, timeout))
2682                 return -ETIMEDOUT;
2683
2684         return 0;
2685 }
2686
2687 int mv88e6xxx_phy_page_read(struct dsa_switch *ds, int port, int page, int reg)
2688 {
2689         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
2690         int ret;
2691
2692         mutex_lock(&ps->smi_mutex);
2693         ret = _mv88e6xxx_phy_write_indirect(ds, port, 0x16, page);
2694         if (ret < 0)
2695                 goto error;
2696         ret = _mv88e6xxx_phy_read_indirect(ds, port, reg);
2697 error:
2698         _mv88e6xxx_phy_write_indirect(ds, port, 0x16, 0x0);
2699         mutex_unlock(&ps->smi_mutex);
2700         return ret;
2701 }
2702
2703 int mv88e6xxx_phy_page_write(struct dsa_switch *ds, int port, int page,
2704                              int reg, int val)
2705 {
2706         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
2707         int ret;
2708
2709         mutex_lock(&ps->smi_mutex);
2710         ret = _mv88e6xxx_phy_write_indirect(ds, port, 0x16, page);
2711         if (ret < 0)
2712                 goto error;
2713
2714         ret = _mv88e6xxx_phy_write_indirect(ds, port, reg, val);
2715 error:
2716         _mv88e6xxx_phy_write_indirect(ds, port, 0x16, 0x0);
2717         mutex_unlock(&ps->smi_mutex);
2718         return ret;
2719 }
2720
2721 static int mv88e6xxx_port_to_phy_addr(struct dsa_switch *ds, int port)
2722 {
2723         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
2724
2725         if (port >= 0 && port < ps->num_ports)
2726                 return port;
2727         return -EINVAL;
2728 }
2729
2730 int
2731 mv88e6xxx_phy_read(struct dsa_switch *ds, int port, int regnum)
2732 {
2733         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
2734         int addr = mv88e6xxx_port_to_phy_addr(ds, port);
2735         int ret;
2736
2737         if (addr < 0)
2738                 return addr;
2739
2740         mutex_lock(&ps->smi_mutex);
2741         ret = _mv88e6xxx_phy_read(ds, addr, regnum);
2742         mutex_unlock(&ps->smi_mutex);
2743         return ret;
2744 }
2745
2746 int
2747 mv88e6xxx_phy_write(struct dsa_switch *ds, int port, int regnum, u16 val)
2748 {
2749         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
2750         int addr = mv88e6xxx_port_to_phy_addr(ds, port);
2751         int ret;
2752
2753         if (addr < 0)
2754                 return addr;
2755
2756         mutex_lock(&ps->smi_mutex);
2757         ret = _mv88e6xxx_phy_write(ds, addr, regnum, val);
2758         mutex_unlock(&ps->smi_mutex);
2759         return ret;
2760 }
2761
2762 int
2763 mv88e6xxx_phy_read_indirect(struct dsa_switch *ds, int port, int regnum)
2764 {
2765         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
2766         int addr = mv88e6xxx_port_to_phy_addr(ds, port);
2767         int ret;
2768
2769         if (addr < 0)
2770                 return addr;
2771
2772         mutex_lock(&ps->smi_mutex);
2773         ret = _mv88e6xxx_phy_read_indirect(ds, addr, regnum);
2774         mutex_unlock(&ps->smi_mutex);
2775         return ret;
2776 }
2777
2778 int
2779 mv88e6xxx_phy_write_indirect(struct dsa_switch *ds, int port, int regnum,
2780                              u16 val)
2781 {
2782         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
2783         int addr = mv88e6xxx_port_to_phy_addr(ds, port);
2784         int ret;
2785
2786         if (addr < 0)
2787                 return addr;
2788
2789         mutex_lock(&ps->smi_mutex);
2790         ret = _mv88e6xxx_phy_write_indirect(ds, addr, regnum, val);
2791         mutex_unlock(&ps->smi_mutex);
2792         return ret;
2793 }
2794
2795 #ifdef CONFIG_NET_DSA_HWMON
2796
2797 static int mv88e61xx_get_temp(struct dsa_switch *ds, int *temp)
2798 {
2799         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
2800         int ret;
2801         int val;
2802
2803         *temp = 0;
2804
2805         mutex_lock(&ps->smi_mutex);
2806
2807         ret = _mv88e6xxx_phy_write(ds, 0x0, 0x16, 0x6);
2808         if (ret < 0)
2809                 goto error;
2810
2811         /* Enable temperature sensor */
2812         ret = _mv88e6xxx_phy_read(ds, 0x0, 0x1a);
2813         if (ret < 0)
2814                 goto error;
2815
2816         ret = _mv88e6xxx_phy_write(ds, 0x0, 0x1a, ret | (1 << 5));
2817         if (ret < 0)
2818                 goto error;
2819
2820         /* Wait for temperature to stabilize */
2821         usleep_range(10000, 12000);
2822
2823         val = _mv88e6xxx_phy_read(ds, 0x0, 0x1a);
2824         if (val < 0) {
2825                 ret = val;
2826                 goto error;
2827         }
2828
2829         /* Disable temperature sensor */
2830         ret = _mv88e6xxx_phy_write(ds, 0x0, 0x1a, ret & ~(1 << 5));
2831         if (ret < 0)
2832                 goto error;
2833
2834         *temp = ((val & 0x1f) - 5) * 5;
2835
2836 error:
2837         _mv88e6xxx_phy_write(ds, 0x0, 0x16, 0x0);
2838         mutex_unlock(&ps->smi_mutex);
2839         return ret;
2840 }
2841
2842 static int mv88e63xx_get_temp(struct dsa_switch *ds, int *temp)
2843 {
2844         int phy = mv88e6xxx_6320_family(ds) ? 3 : 0;
2845         int ret;
2846
2847         *temp = 0;
2848
2849         ret = mv88e6xxx_phy_page_read(ds, phy, 6, 27);
2850         if (ret < 0)
2851                 return ret;
2852
2853         *temp = (ret & 0xff) - 25;
2854
2855         return 0;
2856 }
2857
2858 int mv88e6xxx_get_temp(struct dsa_switch *ds, int *temp)
2859 {
2860         if (mv88e6xxx_6320_family(ds) || mv88e6xxx_6352_family(ds))
2861                 return mv88e63xx_get_temp(ds, temp);
2862
2863         return mv88e61xx_get_temp(ds, temp);
2864 }
2865
2866 int mv88e6xxx_get_temp_limit(struct dsa_switch *ds, int *temp)
2867 {
2868         int phy = mv88e6xxx_6320_family(ds) ? 3 : 0;
2869         int ret;
2870
2871         if (!mv88e6xxx_6320_family(ds) && !mv88e6xxx_6352_family(ds))
2872                 return -EOPNOTSUPP;
2873
2874         *temp = 0;
2875
2876         ret = mv88e6xxx_phy_page_read(ds, phy, 6, 26);
2877         if (ret < 0)
2878                 return ret;
2879
2880         *temp = (((ret >> 8) & 0x1f) * 5) - 25;
2881
2882         return 0;
2883 }
2884
2885 int mv88e6xxx_set_temp_limit(struct dsa_switch *ds, int temp)
2886 {
2887         int phy = mv88e6xxx_6320_family(ds) ? 3 : 0;
2888         int ret;
2889
2890         if (!mv88e6xxx_6320_family(ds) && !mv88e6xxx_6352_family(ds))
2891                 return -EOPNOTSUPP;
2892
2893         ret = mv88e6xxx_phy_page_read(ds, phy, 6, 26);
2894         if (ret < 0)
2895                 return ret;
2896         temp = clamp_val(DIV_ROUND_CLOSEST(temp, 5) + 5, 0, 0x1f);
2897         return mv88e6xxx_phy_page_write(ds, phy, 6, 26,
2898                                         (ret & 0xe0ff) | (temp << 8));
2899 }
2900
2901 int mv88e6xxx_get_temp_alarm(struct dsa_switch *ds, bool *alarm)
2902 {
2903         int phy = mv88e6xxx_6320_family(ds) ? 3 : 0;
2904         int ret;
2905
2906         if (!mv88e6xxx_6320_family(ds) && !mv88e6xxx_6352_family(ds))
2907                 return -EOPNOTSUPP;
2908
2909         *alarm = false;
2910
2911         ret = mv88e6xxx_phy_page_read(ds, phy, 6, 26);
2912         if (ret < 0)
2913                 return ret;
2914
2915         *alarm = !!(ret & 0x40);
2916
2917         return 0;
2918 }
2919 #endif /* CONFIG_NET_DSA_HWMON */
2920
2921 static int __init mv88e6xxx_init(void)
2922 {
2923 #if IS_ENABLED(CONFIG_NET_DSA_MV88E6131)
2924         register_switch_driver(&mv88e6131_switch_driver);
2925 #endif
2926 #if IS_ENABLED(CONFIG_NET_DSA_MV88E6123_61_65)
2927         register_switch_driver(&mv88e6123_61_65_switch_driver);
2928 #endif
2929 #if IS_ENABLED(CONFIG_NET_DSA_MV88E6352)
2930         register_switch_driver(&mv88e6352_switch_driver);
2931 #endif
2932 #if IS_ENABLED(CONFIG_NET_DSA_MV88E6171)
2933         register_switch_driver(&mv88e6171_switch_driver);
2934 #endif
2935         return 0;
2936 }
2937 module_init(mv88e6xxx_init);
2938
2939 static void __exit mv88e6xxx_cleanup(void)
2940 {
2941 #if IS_ENABLED(CONFIG_NET_DSA_MV88E6171)
2942         unregister_switch_driver(&mv88e6171_switch_driver);
2943 #endif
2944 #if IS_ENABLED(CONFIG_NET_DSA_MV88E6352)
2945         unregister_switch_driver(&mv88e6352_switch_driver);
2946 #endif
2947 #if IS_ENABLED(CONFIG_NET_DSA_MV88E6123_61_65)
2948         unregister_switch_driver(&mv88e6123_61_65_switch_driver);
2949 #endif
2950 #if IS_ENABLED(CONFIG_NET_DSA_MV88E6131)
2951         unregister_switch_driver(&mv88e6131_switch_driver);
2952 #endif
2953 }
2954 module_exit(mv88e6xxx_cleanup);
2955
2956 MODULE_AUTHOR("Lennert Buytenhek <buytenh@wantstofly.org>");
2957 MODULE_DESCRIPTION("Driver for Marvell 88E6XXX ethernet switch chips");
2958 MODULE_LICENSE("GPL");