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, u16 cmd)
1040 {
1041         int ret;
1042
1043         ret = _mv88e6xxx_reg_write(ds, REG_GLOBAL, GLOBAL_ATU_OP, cmd);
1044         if (ret < 0)
1045                 return ret;
1046
1047         return _mv88e6xxx_atu_wait(ds);
1048 }
1049
1050 static int _mv88e6xxx_flush_fid(struct dsa_switch *ds, int fid)
1051 {
1052         int ret;
1053
1054         ret = _mv88e6xxx_atu_wait(ds);
1055         if (ret < 0)
1056                 return ret;
1057
1058         ret = _mv88e6xxx_reg_write(ds, REG_GLOBAL, GLOBAL_ATU_FID, fid);
1059         if (ret < 0)
1060                 return ret;
1061
1062         return _mv88e6xxx_atu_cmd(ds, 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         ret = _mv88e6xxx_reg_write(ds, REG_GLOBAL, GLOBAL_ATU_FID, entry->fid);
1797         if (ret < 0)
1798                 return ret;
1799
1800         return _mv88e6xxx_atu_cmd(ds, GLOBAL_ATU_OP_LOAD_DB);
1801 }
1802
1803 static int _mv88e6xxx_port_vid_to_fid(struct dsa_switch *ds, int port, u16 vid)
1804 {
1805         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
1806         struct mv88e6xxx_vtu_stu_entry vlan;
1807         int err;
1808
1809         if (vid == 0)
1810                 return ps->fid[port];
1811
1812         err = _mv88e6xxx_port_vtu_getnext(ds, port, vid - 1, &vlan);
1813         if (err)
1814                 return err;
1815
1816         if (vlan.vid == vid)
1817                 return vlan.fid;
1818
1819         return -ENOENT;
1820 }
1821
1822 static int _mv88e6xxx_port_fdb_load(struct dsa_switch *ds, int port,
1823                                     const unsigned char *addr, u16 vid,
1824                                     u8 state)
1825 {
1826         struct mv88e6xxx_atu_entry entry = { 0 };
1827         int ret;
1828
1829         ret = _mv88e6xxx_port_vid_to_fid(ds, port, vid);
1830         if (ret < 0)
1831                 return ret;
1832
1833         entry.fid = ret;
1834         entry.state = state;
1835         ether_addr_copy(entry.mac, addr);
1836         if (state != GLOBAL_ATU_DATA_STATE_UNUSED) {
1837                 entry.trunk = false;
1838                 entry.portv_trunkid = BIT(port);
1839         }
1840
1841         return _mv88e6xxx_atu_load(ds, &entry);
1842 }
1843
1844 int mv88e6xxx_port_fdb_add(struct dsa_switch *ds, int port,
1845                            const unsigned char *addr, u16 vid)
1846 {
1847         int state = is_multicast_ether_addr(addr) ?
1848                 GLOBAL_ATU_DATA_STATE_MC_STATIC :
1849                 GLOBAL_ATU_DATA_STATE_UC_STATIC;
1850         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
1851         int ret;
1852
1853         mutex_lock(&ps->smi_mutex);
1854         ret = _mv88e6xxx_port_fdb_load(ds, port, addr, vid, state);
1855         mutex_unlock(&ps->smi_mutex);
1856
1857         return ret;
1858 }
1859
1860 int mv88e6xxx_port_fdb_del(struct dsa_switch *ds, int port,
1861                            const unsigned char *addr, u16 vid)
1862 {
1863         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
1864         int ret;
1865
1866         mutex_lock(&ps->smi_mutex);
1867         ret = _mv88e6xxx_port_fdb_load(ds, port, addr, vid,
1868                                        GLOBAL_ATU_DATA_STATE_UNUSED);
1869         mutex_unlock(&ps->smi_mutex);
1870
1871         return ret;
1872 }
1873
1874 static int _mv88e6xxx_atu_getnext(struct dsa_switch *ds, u16 fid,
1875                                   const unsigned char *addr,
1876                                   struct mv88e6xxx_atu_entry *entry)
1877 {
1878         struct mv88e6xxx_atu_entry next = { 0 };
1879         int ret;
1880
1881         next.fid = fid;
1882
1883         ret = _mv88e6xxx_atu_wait(ds);
1884         if (ret < 0)
1885                 return ret;
1886
1887         ret = _mv88e6xxx_atu_mac_write(ds, addr);
1888         if (ret < 0)
1889                 return ret;
1890
1891         ret = _mv88e6xxx_reg_write(ds, REG_GLOBAL, GLOBAL_ATU_FID, fid);
1892         if (ret < 0)
1893                 return ret;
1894
1895         ret = _mv88e6xxx_atu_cmd(ds, GLOBAL_ATU_OP_GET_NEXT_DB);
1896         if (ret < 0)
1897                 return ret;
1898
1899         ret = _mv88e6xxx_atu_mac_read(ds, next.mac);
1900         if (ret < 0)
1901                 return ret;
1902
1903         ret = _mv88e6xxx_reg_read(ds, REG_GLOBAL, GLOBAL_ATU_DATA);
1904         if (ret < 0)
1905                 return ret;
1906
1907         next.state = ret & GLOBAL_ATU_DATA_STATE_MASK;
1908         if (next.state != GLOBAL_ATU_DATA_STATE_UNUSED) {
1909                 unsigned int mask, shift;
1910
1911                 if (ret & GLOBAL_ATU_DATA_TRUNK) {
1912                         next.trunk = true;
1913                         mask = GLOBAL_ATU_DATA_TRUNK_ID_MASK;
1914                         shift = GLOBAL_ATU_DATA_TRUNK_ID_SHIFT;
1915                 } else {
1916                         next.trunk = false;
1917                         mask = GLOBAL_ATU_DATA_PORT_VECTOR_MASK;
1918                         shift = GLOBAL_ATU_DATA_PORT_VECTOR_SHIFT;
1919                 }
1920
1921                 next.portv_trunkid = (ret & mask) >> shift;
1922         }
1923
1924         *entry = next;
1925         return 0;
1926 }
1927
1928 /* get next entry for port */
1929 int mv88e6xxx_port_fdb_getnext(struct dsa_switch *ds, int port,
1930                                unsigned char *addr, u16 *vid, bool *is_static)
1931 {
1932         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
1933         struct mv88e6xxx_atu_entry next;
1934         u16 fid;
1935         int ret;
1936
1937         mutex_lock(&ps->smi_mutex);
1938
1939         ret = _mv88e6xxx_port_vid_to_fid(ds, port, *vid);
1940         if (ret < 0)
1941                 goto unlock;
1942         fid = ret;
1943
1944         do {
1945                 if (is_broadcast_ether_addr(addr)) {
1946                         struct mv88e6xxx_vtu_stu_entry vtu;
1947
1948                         ret = _mv88e6xxx_port_vtu_getnext(ds, port, *vid, &vtu);
1949                         if (ret < 0)
1950                                 goto unlock;
1951
1952                         *vid = vtu.vid;
1953                         fid = vtu.fid;
1954                 }
1955
1956                 ret = _mv88e6xxx_atu_getnext(ds, fid, addr, &next);
1957                 if (ret < 0)
1958                         goto unlock;
1959
1960                 ether_addr_copy(addr, next.mac);
1961
1962                 if (next.state == GLOBAL_ATU_DATA_STATE_UNUSED)
1963                         continue;
1964         } while (next.trunk || (next.portv_trunkid & BIT(port)) == 0);
1965
1966         *is_static = next.state == (is_multicast_ether_addr(addr) ?
1967                                     GLOBAL_ATU_DATA_STATE_MC_STATIC :
1968                                     GLOBAL_ATU_DATA_STATE_UC_STATIC);
1969 unlock:
1970         mutex_unlock(&ps->smi_mutex);
1971
1972         return ret;
1973 }
1974
1975 static void mv88e6xxx_bridge_work(struct work_struct *work)
1976 {
1977         struct mv88e6xxx_priv_state *ps;
1978         struct dsa_switch *ds;
1979         int port;
1980
1981         ps = container_of(work, struct mv88e6xxx_priv_state, bridge_work);
1982         ds = ((struct dsa_switch *)ps) - 1;
1983
1984         while (ps->port_state_update_mask) {
1985                 port = __ffs(ps->port_state_update_mask);
1986                 clear_bit(port, &ps->port_state_update_mask);
1987                 mv88e6xxx_set_port_state(ds, port, ps->port_state[port]);
1988         }
1989 }
1990
1991 static int mv88e6xxx_setup_port(struct dsa_switch *ds, int port)
1992 {
1993         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
1994         int ret, fid;
1995         u16 reg;
1996
1997         mutex_lock(&ps->smi_mutex);
1998
1999         if (mv88e6xxx_6352_family(ds) || mv88e6xxx_6351_family(ds) ||
2000             mv88e6xxx_6165_family(ds) || mv88e6xxx_6097_family(ds) ||
2001             mv88e6xxx_6185_family(ds) || mv88e6xxx_6095_family(ds) ||
2002             mv88e6xxx_6065_family(ds) || mv88e6xxx_6320_family(ds)) {
2003                 /* MAC Forcing register: don't force link, speed,
2004                  * duplex or flow control state to any particular
2005                  * values on physical ports, but force the CPU port
2006                  * and all DSA ports to their maximum bandwidth and
2007                  * full duplex.
2008                  */
2009                 reg = _mv88e6xxx_reg_read(ds, REG_PORT(port), PORT_PCS_CTRL);
2010                 if (dsa_is_cpu_port(ds, port) || dsa_is_dsa_port(ds, port)) {
2011                         reg |= PORT_PCS_CTRL_FORCE_LINK |
2012                                 PORT_PCS_CTRL_LINK_UP |
2013                                 PORT_PCS_CTRL_DUPLEX_FULL |
2014                                 PORT_PCS_CTRL_FORCE_DUPLEX;
2015                         if (mv88e6xxx_6065_family(ds))
2016                                 reg |= PORT_PCS_CTRL_100;
2017                         else
2018                                 reg |= PORT_PCS_CTRL_1000;
2019                 } else {
2020                         reg |= PORT_PCS_CTRL_UNFORCED;
2021                 }
2022
2023                 ret = _mv88e6xxx_reg_write(ds, REG_PORT(port),
2024                                            PORT_PCS_CTRL, reg);
2025                 if (ret)
2026                         goto abort;
2027         }
2028
2029         /* Port Control: disable Drop-on-Unlock, disable Drop-on-Lock,
2030          * disable Header mode, enable IGMP/MLD snooping, disable VLAN
2031          * tunneling, determine priority by looking at 802.1p and IP
2032          * priority fields (IP prio has precedence), and set STP state
2033          * to Forwarding.
2034          *
2035          * If this is the CPU link, use DSA or EDSA tagging depending
2036          * on which tagging mode was configured.
2037          *
2038          * If this is a link to another switch, use DSA tagging mode.
2039          *
2040          * If this is the upstream port for this switch, enable
2041          * forwarding of unknown unicasts and multicasts.
2042          */
2043         reg = 0;
2044         if (mv88e6xxx_6352_family(ds) || mv88e6xxx_6351_family(ds) ||
2045             mv88e6xxx_6165_family(ds) || mv88e6xxx_6097_family(ds) ||
2046             mv88e6xxx_6095_family(ds) || mv88e6xxx_6065_family(ds) ||
2047             mv88e6xxx_6185_family(ds) || mv88e6xxx_6320_family(ds))
2048                 reg = PORT_CONTROL_IGMP_MLD_SNOOP |
2049                 PORT_CONTROL_USE_TAG | PORT_CONTROL_USE_IP |
2050                 PORT_CONTROL_STATE_FORWARDING;
2051         if (dsa_is_cpu_port(ds, port)) {
2052                 if (mv88e6xxx_6095_family(ds) || mv88e6xxx_6185_family(ds))
2053                         reg |= PORT_CONTROL_DSA_TAG;
2054                 if (mv88e6xxx_6352_family(ds) || mv88e6xxx_6351_family(ds) ||
2055                     mv88e6xxx_6165_family(ds) || mv88e6xxx_6097_family(ds) ||
2056                     mv88e6xxx_6320_family(ds)) {
2057                         if (ds->dst->tag_protocol == DSA_TAG_PROTO_EDSA)
2058                                 reg |= PORT_CONTROL_FRAME_ETHER_TYPE_DSA;
2059                         else
2060                                 reg |= PORT_CONTROL_FRAME_MODE_DSA;
2061                 }
2062
2063                 if (mv88e6xxx_6352_family(ds) || mv88e6xxx_6351_family(ds) ||
2064                     mv88e6xxx_6165_family(ds) || mv88e6xxx_6097_family(ds) ||
2065                     mv88e6xxx_6095_family(ds) || mv88e6xxx_6065_family(ds) ||
2066                     mv88e6xxx_6185_family(ds) || mv88e6xxx_6320_family(ds)) {
2067                         if (ds->dst->tag_protocol == DSA_TAG_PROTO_EDSA)
2068                                 reg |= PORT_CONTROL_EGRESS_ADD_TAG;
2069                 }
2070         }
2071         if (dsa_is_dsa_port(ds, port)) {
2072                 if (mv88e6xxx_6095_family(ds) || mv88e6xxx_6185_family(ds))
2073                         reg |= PORT_CONTROL_DSA_TAG;
2074                 if (mv88e6xxx_6352_family(ds) || mv88e6xxx_6351_family(ds) ||
2075                     mv88e6xxx_6165_family(ds) || mv88e6xxx_6097_family(ds) ||
2076                     mv88e6xxx_6320_family(ds)) {
2077                         reg |= PORT_CONTROL_FRAME_MODE_DSA;
2078                 }
2079
2080                 if (port == dsa_upstream_port(ds))
2081                         reg |= PORT_CONTROL_FORWARD_UNKNOWN |
2082                                 PORT_CONTROL_FORWARD_UNKNOWN_MC;
2083         }
2084         if (reg) {
2085                 ret = _mv88e6xxx_reg_write(ds, REG_PORT(port),
2086                                            PORT_CONTROL, reg);
2087                 if (ret)
2088                         goto abort;
2089         }
2090
2091         /* Port Control 2: don't force a good FCS, set the maximum frame size to
2092          * 10240 bytes, enable secure 802.1q tags, don't discard tagged or
2093          * untagged frames on this port, do a destination address lookup on all
2094          * received packets as usual, disable ARP mirroring and don't send a
2095          * copy of all transmitted/received frames on this port to the CPU.
2096          */
2097         reg = 0;
2098         if (mv88e6xxx_6352_family(ds) || mv88e6xxx_6351_family(ds) ||
2099             mv88e6xxx_6165_family(ds) || mv88e6xxx_6097_family(ds) ||
2100             mv88e6xxx_6095_family(ds) || mv88e6xxx_6320_family(ds))
2101                 reg = PORT_CONTROL_2_MAP_DA;
2102
2103         if (mv88e6xxx_6352_family(ds) || mv88e6xxx_6351_family(ds) ||
2104             mv88e6xxx_6165_family(ds) || mv88e6xxx_6320_family(ds))
2105                 reg |= PORT_CONTROL_2_JUMBO_10240;
2106
2107         if (mv88e6xxx_6095_family(ds) || mv88e6xxx_6185_family(ds)) {
2108                 /* Set the upstream port this port should use */
2109                 reg |= dsa_upstream_port(ds);
2110                 /* enable forwarding of unknown multicast addresses to
2111                  * the upstream port
2112                  */
2113                 if (port == dsa_upstream_port(ds))
2114                         reg |= PORT_CONTROL_2_FORWARD_UNKNOWN;
2115         }
2116
2117         reg |= PORT_CONTROL_2_8021Q_FALLBACK;
2118
2119         if (reg) {
2120                 ret = _mv88e6xxx_reg_write(ds, REG_PORT(port),
2121                                            PORT_CONTROL_2, reg);
2122                 if (ret)
2123                         goto abort;
2124         }
2125
2126         /* Port Association Vector: when learning source addresses
2127          * of packets, add the address to the address database using
2128          * a port bitmap that has only the bit for this port set and
2129          * the other bits clear.
2130          */
2131         ret = _mv88e6xxx_reg_write(ds, REG_PORT(port), PORT_ASSOC_VECTOR,
2132                                    1 << port);
2133         if (ret)
2134                 goto abort;
2135
2136         /* Egress rate control 2: disable egress rate control. */
2137         ret = _mv88e6xxx_reg_write(ds, REG_PORT(port), PORT_RATE_CONTROL_2,
2138                                    0x0000);
2139         if (ret)
2140                 goto abort;
2141
2142         if (mv88e6xxx_6352_family(ds) || mv88e6xxx_6351_family(ds) ||
2143             mv88e6xxx_6165_family(ds) || mv88e6xxx_6097_family(ds) ||
2144             mv88e6xxx_6320_family(ds)) {
2145                 /* Do not limit the period of time that this port can
2146                  * be paused for by the remote end or the period of
2147                  * time that this port can pause the remote end.
2148                  */
2149                 ret = _mv88e6xxx_reg_write(ds, REG_PORT(port),
2150                                            PORT_PAUSE_CTRL, 0x0000);
2151                 if (ret)
2152                         goto abort;
2153
2154                 /* Port ATU control: disable limiting the number of
2155                  * address database entries that this port is allowed
2156                  * to use.
2157                  */
2158                 ret = _mv88e6xxx_reg_write(ds, REG_PORT(port),
2159                                            PORT_ATU_CONTROL, 0x0000);
2160                 /* Priority Override: disable DA, SA and VTU priority
2161                  * override.
2162                  */
2163                 ret = _mv88e6xxx_reg_write(ds, REG_PORT(port),
2164                                            PORT_PRI_OVERRIDE, 0x0000);
2165                 if (ret)
2166                         goto abort;
2167
2168                 /* Port Ethertype: use the Ethertype DSA Ethertype
2169                  * value.
2170                  */
2171                 ret = _mv88e6xxx_reg_write(ds, REG_PORT(port),
2172                                            PORT_ETH_TYPE, ETH_P_EDSA);
2173                 if (ret)
2174                         goto abort;
2175                 /* Tag Remap: use an identity 802.1p prio -> switch
2176                  * prio mapping.
2177                  */
2178                 ret = _mv88e6xxx_reg_write(ds, REG_PORT(port),
2179                                            PORT_TAG_REGMAP_0123, 0x3210);
2180                 if (ret)
2181                         goto abort;
2182
2183                 /* Tag Remap 2: use an identity 802.1p prio -> switch
2184                  * prio mapping.
2185                  */
2186                 ret = _mv88e6xxx_reg_write(ds, REG_PORT(port),
2187                                            PORT_TAG_REGMAP_4567, 0x7654);
2188                 if (ret)
2189                         goto abort;
2190         }
2191
2192         if (mv88e6xxx_6352_family(ds) || mv88e6xxx_6351_family(ds) ||
2193             mv88e6xxx_6165_family(ds) || mv88e6xxx_6097_family(ds) ||
2194             mv88e6xxx_6185_family(ds) || mv88e6xxx_6095_family(ds) ||
2195             mv88e6xxx_6320_family(ds)) {
2196                 /* Rate Control: disable ingress rate limiting. */
2197                 ret = _mv88e6xxx_reg_write(ds, REG_PORT(port),
2198                                            PORT_RATE_CONTROL, 0x0001);
2199                 if (ret)
2200                         goto abort;
2201         }
2202
2203         /* Port Control 1: disable trunking, disable sending
2204          * learning messages to this port.
2205          */
2206         ret = _mv88e6xxx_reg_write(ds, REG_PORT(port), PORT_CONTROL_1, 0x0000);
2207         if (ret)
2208                 goto abort;
2209
2210         /* Port based VLAN map: give each port its own address
2211          * database, allow the CPU port to talk to each of the 'real'
2212          * ports, and allow each of the 'real' ports to only talk to
2213          * the upstream port.
2214          */
2215         fid = port + 1;
2216         ps->fid[port] = fid;
2217         set_bit(fid, ps->fid_bitmap);
2218
2219         if (!dsa_is_cpu_port(ds, port))
2220                 ps->bridge_mask[fid] = 1 << port;
2221
2222         ret = _mv88e6xxx_update_port_config(ds, port);
2223         if (ret)
2224                 goto abort;
2225
2226         /* Default VLAN ID and priority: don't set a default VLAN
2227          * ID, and set the default packet priority to zero.
2228          */
2229         ret = _mv88e6xxx_reg_write(ds, REG_PORT(port), PORT_DEFAULT_VLAN,
2230                                    0x0000);
2231 abort:
2232         mutex_unlock(&ps->smi_mutex);
2233         return ret;
2234 }
2235
2236 int mv88e6xxx_setup_ports(struct dsa_switch *ds)
2237 {
2238         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
2239         int ret;
2240         int i;
2241
2242         for (i = 0; i < ps->num_ports; i++) {
2243                 ret = mv88e6xxx_setup_port(ds, i);
2244                 if (ret < 0)
2245                         return ret;
2246         }
2247         return 0;
2248 }
2249
2250 static int mv88e6xxx_regs_show(struct seq_file *s, void *p)
2251 {
2252         struct dsa_switch *ds = s->private;
2253
2254         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
2255         int reg, port;
2256
2257         seq_puts(s, "    GLOBAL GLOBAL2 ");
2258         for (port = 0 ; port < ps->num_ports; port++)
2259                 seq_printf(s, " %2d  ", port);
2260         seq_puts(s, "\n");
2261
2262         for (reg = 0; reg < 32; reg++) {
2263                 seq_printf(s, "%2x: ", reg);
2264                 seq_printf(s, " %4x    %4x  ",
2265                            mv88e6xxx_reg_read(ds, REG_GLOBAL, reg),
2266                            mv88e6xxx_reg_read(ds, REG_GLOBAL2, reg));
2267
2268                 for (port = 0 ; port < ps->num_ports; port++)
2269                         seq_printf(s, "%4x ",
2270                                    mv88e6xxx_reg_read(ds, REG_PORT(port), reg));
2271                 seq_puts(s, "\n");
2272         }
2273
2274         return 0;
2275 }
2276
2277 static int mv88e6xxx_regs_open(struct inode *inode, struct file *file)
2278 {
2279         return single_open(file, mv88e6xxx_regs_show, inode->i_private);
2280 }
2281
2282 static const struct file_operations mv88e6xxx_regs_fops = {
2283         .open   = mv88e6xxx_regs_open,
2284         .read   = seq_read,
2285         .llseek = no_llseek,
2286         .release = single_release,
2287         .owner  = THIS_MODULE,
2288 };
2289
2290 static void mv88e6xxx_atu_show_header(struct seq_file *s)
2291 {
2292         seq_puts(s, "DB   T/P  Vec State Addr\n");
2293 }
2294
2295 static void mv88e6xxx_atu_show_entry(struct seq_file *s, int dbnum,
2296                                      unsigned char *addr, int data)
2297 {
2298         bool trunk = !!(data & GLOBAL_ATU_DATA_TRUNK);
2299         int portvec = ((data & GLOBAL_ATU_DATA_PORT_VECTOR_MASK) >>
2300                        GLOBAL_ATU_DATA_PORT_VECTOR_SHIFT);
2301         int state = data & GLOBAL_ATU_DATA_STATE_MASK;
2302
2303         seq_printf(s, "%03x %5s %10pb   %x   %pM\n",
2304                    dbnum, (trunk ? "Trunk" : "Port"), &portvec, state, addr);
2305 }
2306
2307 static int mv88e6xxx_atu_show_db(struct seq_file *s, struct dsa_switch *ds,
2308                                  int dbnum)
2309 {
2310         unsigned char bcast[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
2311         unsigned char addr[6];
2312         int ret, data, state;
2313
2314         ret = _mv88e6xxx_atu_mac_write(ds, bcast);
2315         if (ret < 0)
2316                 return ret;
2317
2318         do {
2319                 ret = _mv88e6xxx_reg_write(ds, REG_GLOBAL, GLOBAL_ATU_FID,
2320                                            dbnum);
2321                 if (ret < 0)
2322                         return ret;
2323
2324                 ret = _mv88e6xxx_atu_cmd(ds, GLOBAL_ATU_OP_GET_NEXT_DB);
2325                 if (ret < 0)
2326                         return ret;
2327
2328                 data = _mv88e6xxx_reg_read(ds, REG_GLOBAL, GLOBAL_ATU_DATA);
2329                 if (data < 0)
2330                         return data;
2331
2332                 state = data & GLOBAL_ATU_DATA_STATE_MASK;
2333                 if (state == GLOBAL_ATU_DATA_STATE_UNUSED)
2334                         break;
2335                 ret = _mv88e6xxx_atu_mac_read(ds, addr);
2336                 if (ret < 0)
2337                         return ret;
2338                 mv88e6xxx_atu_show_entry(s, dbnum, addr, data);
2339         } while (state != GLOBAL_ATU_DATA_STATE_UNUSED);
2340
2341         return 0;
2342 }
2343
2344 static int mv88e6xxx_atu_show(struct seq_file *s, void *p)
2345 {
2346         struct dsa_switch *ds = s->private;
2347         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
2348         int dbnum;
2349
2350         mv88e6xxx_atu_show_header(s);
2351
2352         for (dbnum = 0; dbnum < 255; dbnum++) {
2353                 mutex_lock(&ps->smi_mutex);
2354                 mv88e6xxx_atu_show_db(s, ds, dbnum);
2355                 mutex_unlock(&ps->smi_mutex);
2356         }
2357
2358         return 0;
2359 }
2360
2361 static int mv88e6xxx_atu_open(struct inode *inode, struct file *file)
2362 {
2363         return single_open(file, mv88e6xxx_atu_show, inode->i_private);
2364 }
2365
2366 static const struct file_operations mv88e6xxx_atu_fops = {
2367         .open   = mv88e6xxx_atu_open,
2368         .read   = seq_read,
2369         .llseek = no_llseek,
2370         .release = single_release,
2371         .owner  = THIS_MODULE,
2372 };
2373
2374 static void mv88e6xxx_stats_show_header(struct seq_file *s,
2375                                         struct mv88e6xxx_priv_state *ps)
2376 {
2377         int port;
2378
2379         seq_puts(s, "      Statistic       ");
2380         for (port = 0 ; port < ps->num_ports; port++)
2381                 seq_printf(s, "Port %2d  ", port);
2382         seq_puts(s, "\n");
2383 }
2384
2385 static int mv88e6xxx_stats_show(struct seq_file *s, void *p)
2386 {
2387         struct dsa_switch *ds = s->private;
2388         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
2389         struct mv88e6xxx_hw_stat *stats = mv88e6xxx_hw_stats;
2390         int port, stat, max_stats;
2391         uint64_t value;
2392
2393         if (have_sw_in_discards(ds))
2394                 max_stats = ARRAY_SIZE(mv88e6xxx_hw_stats);
2395         else
2396                 max_stats = ARRAY_SIZE(mv88e6xxx_hw_stats) - 3;
2397
2398         mv88e6xxx_stats_show_header(s, ps);
2399
2400         mutex_lock(&ps->smi_mutex);
2401
2402         for (stat = 0; stat < max_stats; stat++) {
2403                 seq_printf(s, "%19s: ", stats[stat].string);
2404                 for (port = 0 ; port < ps->num_ports; port++) {
2405                         _mv88e6xxx_stats_snapshot(ds, port);
2406                         value = _mv88e6xxx_get_ethtool_stat(ds, stat, stats,
2407                                                             port);
2408                         seq_printf(s, "%8llu ", value);
2409                 }
2410                 seq_puts(s, "\n");
2411         }
2412         mutex_unlock(&ps->smi_mutex);
2413
2414         return 0;
2415 }
2416
2417 static int mv88e6xxx_stats_open(struct inode *inode, struct file *file)
2418 {
2419         return single_open(file, mv88e6xxx_stats_show, inode->i_private);
2420 }
2421
2422 static const struct file_operations mv88e6xxx_stats_fops = {
2423         .open   = mv88e6xxx_stats_open,
2424         .read   = seq_read,
2425         .llseek = no_llseek,
2426         .release = single_release,
2427         .owner  = THIS_MODULE,
2428 };
2429
2430 static int mv88e6xxx_device_map_show(struct seq_file *s, void *p)
2431 {
2432         struct dsa_switch *ds = s->private;
2433         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
2434         int target, ret;
2435
2436         seq_puts(s, "Target Port\n");
2437
2438         mutex_lock(&ps->smi_mutex);
2439         for (target = 0; target < 32; target++) {
2440                 ret = _mv88e6xxx_reg_write(
2441                         ds, REG_GLOBAL2, GLOBAL2_DEVICE_MAPPING,
2442                         target << GLOBAL2_DEVICE_MAPPING_TARGET_SHIFT);
2443                 if (ret < 0)
2444                         goto out;
2445                 ret = _mv88e6xxx_reg_read(ds, REG_GLOBAL2,
2446                                           GLOBAL2_DEVICE_MAPPING);
2447                 seq_printf(s, "  %2d   %2d\n", target,
2448                            ret & GLOBAL2_DEVICE_MAPPING_PORT_MASK);
2449         }
2450 out:
2451         mutex_unlock(&ps->smi_mutex);
2452
2453         return 0;
2454 }
2455
2456 static int mv88e6xxx_device_map_open(struct inode *inode, struct file *file)
2457 {
2458         return single_open(file, mv88e6xxx_device_map_show, inode->i_private);
2459 }
2460
2461 static const struct file_operations mv88e6xxx_device_map_fops = {
2462         .open   = mv88e6xxx_device_map_open,
2463         .read   = seq_read,
2464         .llseek = no_llseek,
2465         .release = single_release,
2466         .owner  = THIS_MODULE,
2467 };
2468
2469 static int mv88e6xxx_scratch_show(struct seq_file *s, void *p)
2470 {
2471         struct dsa_switch *ds = s->private;
2472         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
2473         int reg, ret;
2474
2475         seq_puts(s, "Register Value\n");
2476
2477         mutex_lock(&ps->smi_mutex);
2478         for (reg = 0; reg < 0x80; reg++) {
2479                 ret = _mv88e6xxx_reg_write(
2480                         ds, REG_GLOBAL2, GLOBAL2_SCRATCH_MISC,
2481                         reg << GLOBAL2_SCRATCH_REGISTER_SHIFT);
2482                 if (ret < 0)
2483                         goto out;
2484
2485                 ret = _mv88e6xxx_scratch_wait(ds);
2486                 if (ret < 0)
2487                         goto out;
2488
2489                 ret = _mv88e6xxx_reg_read(ds, REG_GLOBAL2,
2490                                           GLOBAL2_SCRATCH_MISC);
2491                 seq_printf(s, "  %2x   %2x\n", reg,
2492                            ret & GLOBAL2_SCRATCH_VALUE_MASK);
2493         }
2494 out:
2495         mutex_unlock(&ps->smi_mutex);
2496
2497         return 0;
2498 }
2499
2500 static int mv88e6xxx_scratch_open(struct inode *inode, struct file *file)
2501 {
2502         return single_open(file, mv88e6xxx_scratch_show, inode->i_private);
2503 }
2504
2505 static const struct file_operations mv88e6xxx_scratch_fops = {
2506         .open   = mv88e6xxx_scratch_open,
2507         .read   = seq_read,
2508         .llseek = no_llseek,
2509         .release = single_release,
2510         .owner  = THIS_MODULE,
2511 };
2512
2513 int mv88e6xxx_setup_common(struct dsa_switch *ds)
2514 {
2515         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
2516         char *name;
2517
2518         mutex_init(&ps->smi_mutex);
2519
2520         ps->id = REG_READ(REG_PORT(0), PORT_SWITCH_ID) & 0xfff0;
2521
2522         INIT_WORK(&ps->bridge_work, mv88e6xxx_bridge_work);
2523
2524         name = kasprintf(GFP_KERNEL, "dsa%d", ds->index);
2525         ps->dbgfs = debugfs_create_dir(name, NULL);
2526         kfree(name);
2527
2528         debugfs_create_file("regs", S_IRUGO, ps->dbgfs, ds,
2529                             &mv88e6xxx_regs_fops);
2530
2531         debugfs_create_file("atu", S_IRUGO, ps->dbgfs, ds,
2532                             &mv88e6xxx_atu_fops);
2533
2534         debugfs_create_file("stats", S_IRUGO, ps->dbgfs, ds,
2535                             &mv88e6xxx_stats_fops);
2536
2537         debugfs_create_file("device_map", S_IRUGO, ps->dbgfs, ds,
2538                             &mv88e6xxx_device_map_fops);
2539
2540         debugfs_create_file("scratch", S_IRUGO, ps->dbgfs, ds,
2541                             &mv88e6xxx_scratch_fops);
2542         return 0;
2543 }
2544
2545 int mv88e6xxx_setup_global(struct dsa_switch *ds)
2546 {
2547         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
2548         int ret;
2549         int i;
2550
2551         /* Set the default address aging time to 5 minutes, and
2552          * enable address learn messages to be sent to all message
2553          * ports.
2554          */
2555         REG_WRITE(REG_GLOBAL, GLOBAL_ATU_CONTROL,
2556                   0x0140 | GLOBAL_ATU_CONTROL_LEARN2ALL);
2557
2558         /* Configure the IP ToS mapping registers. */
2559         REG_WRITE(REG_GLOBAL, GLOBAL_IP_PRI_0, 0x0000);
2560         REG_WRITE(REG_GLOBAL, GLOBAL_IP_PRI_1, 0x0000);
2561         REG_WRITE(REG_GLOBAL, GLOBAL_IP_PRI_2, 0x5555);
2562         REG_WRITE(REG_GLOBAL, GLOBAL_IP_PRI_3, 0x5555);
2563         REG_WRITE(REG_GLOBAL, GLOBAL_IP_PRI_4, 0xaaaa);
2564         REG_WRITE(REG_GLOBAL, GLOBAL_IP_PRI_5, 0xaaaa);
2565         REG_WRITE(REG_GLOBAL, GLOBAL_IP_PRI_6, 0xffff);
2566         REG_WRITE(REG_GLOBAL, GLOBAL_IP_PRI_7, 0xffff);
2567
2568         /* Configure the IEEE 802.1p priority mapping register. */
2569         REG_WRITE(REG_GLOBAL, GLOBAL_IEEE_PRI, 0xfa41);
2570
2571         /* Send all frames with destination addresses matching
2572          * 01:80:c2:00:00:0x to the CPU port.
2573          */
2574         REG_WRITE(REG_GLOBAL2, GLOBAL2_MGMT_EN_0X, 0xffff);
2575
2576         /* Ignore removed tag data on doubly tagged packets, disable
2577          * flow control messages, force flow control priority to the
2578          * highest, and send all special multicast frames to the CPU
2579          * port at the highest priority.
2580          */
2581         REG_WRITE(REG_GLOBAL2, GLOBAL2_SWITCH_MGMT,
2582                   0x7 | GLOBAL2_SWITCH_MGMT_RSVD2CPU | 0x70 |
2583                   GLOBAL2_SWITCH_MGMT_FORCE_FLOW_CTRL_PRI);
2584
2585         /* Program the DSA routing table. */
2586         for (i = 0; i < 32; i++) {
2587                 int nexthop = 0x1f;
2588
2589                 if (ds->pd->rtable &&
2590                     i != ds->index && i < ds->dst->pd->nr_chips)
2591                         nexthop = ds->pd->rtable[i] & 0x1f;
2592
2593                 REG_WRITE(REG_GLOBAL2, GLOBAL2_DEVICE_MAPPING,
2594                           GLOBAL2_DEVICE_MAPPING_UPDATE |
2595                           (i << GLOBAL2_DEVICE_MAPPING_TARGET_SHIFT) |
2596                           nexthop);
2597         }
2598
2599         /* Clear all trunk masks. */
2600         for (i = 0; i < 8; i++)
2601                 REG_WRITE(REG_GLOBAL2, GLOBAL2_TRUNK_MASK,
2602                           0x8000 | (i << GLOBAL2_TRUNK_MASK_NUM_SHIFT) |
2603                           ((1 << ps->num_ports) - 1));
2604
2605         /* Clear all trunk mappings. */
2606         for (i = 0; i < 16; i++)
2607                 REG_WRITE(REG_GLOBAL2, GLOBAL2_TRUNK_MAPPING,
2608                           GLOBAL2_TRUNK_MAPPING_UPDATE |
2609                           (i << GLOBAL2_TRUNK_MAPPING_ID_SHIFT));
2610
2611         if (mv88e6xxx_6352_family(ds) || mv88e6xxx_6351_family(ds) ||
2612             mv88e6xxx_6165_family(ds) || mv88e6xxx_6097_family(ds) ||
2613             mv88e6xxx_6320_family(ds)) {
2614                 /* Send all frames with destination addresses matching
2615                  * 01:80:c2:00:00:2x to the CPU port.
2616                  */
2617                 REG_WRITE(REG_GLOBAL2, GLOBAL2_MGMT_EN_2X, 0xffff);
2618
2619                 /* Initialise cross-chip port VLAN table to reset
2620                  * defaults.
2621                  */
2622                 REG_WRITE(REG_GLOBAL2, GLOBAL2_PVT_ADDR, 0x9000);
2623
2624                 /* Clear the priority override table. */
2625                 for (i = 0; i < 16; i++)
2626                         REG_WRITE(REG_GLOBAL2, GLOBAL2_PRIO_OVERRIDE,
2627                                   0x8000 | (i << 8));
2628         }
2629
2630         if (mv88e6xxx_6352_family(ds) || mv88e6xxx_6351_family(ds) ||
2631             mv88e6xxx_6165_family(ds) || mv88e6xxx_6097_family(ds) ||
2632             mv88e6xxx_6185_family(ds) || mv88e6xxx_6095_family(ds) ||
2633             mv88e6xxx_6320_family(ds)) {
2634                 /* Disable ingress rate limiting by resetting all
2635                  * ingress rate limit registers to their initial
2636                  * state.
2637                  */
2638                 for (i = 0; i < ps->num_ports; i++)
2639                         REG_WRITE(REG_GLOBAL2, GLOBAL2_INGRESS_OP,
2640                                   0x9000 | (i << 8));
2641         }
2642
2643         /* Clear the statistics counters for all ports */
2644         REG_WRITE(REG_GLOBAL, GLOBAL_STATS_OP, GLOBAL_STATS_OP_FLUSH_ALL);
2645
2646         /* Wait for the flush to complete. */
2647         mutex_lock(&ps->smi_mutex);
2648         ret = _mv88e6xxx_stats_wait(ds);
2649         if (ret < 0)
2650                 goto unlock;
2651
2652         /* Clear all the VTU and STU entries */
2653         ret = _mv88e6xxx_vtu_stu_flush(ds);
2654 unlock:
2655         mutex_unlock(&ps->smi_mutex);
2656
2657         return ret;
2658 }
2659
2660 int mv88e6xxx_switch_reset(struct dsa_switch *ds, bool ppu_active)
2661 {
2662         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
2663         u16 is_reset = (ppu_active ? 0x8800 : 0xc800);
2664         unsigned long timeout;
2665         int ret;
2666         int i;
2667
2668         /* Set all ports to the disabled state. */
2669         for (i = 0; i < ps->num_ports; i++) {
2670                 ret = REG_READ(REG_PORT(i), PORT_CONTROL);
2671                 REG_WRITE(REG_PORT(i), PORT_CONTROL, ret & 0xfffc);
2672         }
2673
2674         /* Wait for transmit queues to drain. */
2675         usleep_range(2000, 4000);
2676
2677         /* Reset the switch. Keep the PPU active if requested. The PPU
2678          * needs to be active to support indirect phy register access
2679          * through global registers 0x18 and 0x19.
2680          */
2681         if (ppu_active)
2682                 REG_WRITE(REG_GLOBAL, 0x04, 0xc000);
2683         else
2684                 REG_WRITE(REG_GLOBAL, 0x04, 0xc400);
2685
2686         /* Wait up to one second for reset to complete. */
2687         timeout = jiffies + 1 * HZ;
2688         while (time_before(jiffies, timeout)) {
2689                 ret = REG_READ(REG_GLOBAL, 0x00);
2690                 if ((ret & is_reset) == is_reset)
2691                         break;
2692                 usleep_range(1000, 2000);
2693         }
2694         if (time_after(jiffies, timeout))
2695                 return -ETIMEDOUT;
2696
2697         return 0;
2698 }
2699
2700 int mv88e6xxx_phy_page_read(struct dsa_switch *ds, int port, int page, int reg)
2701 {
2702         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
2703         int ret;
2704
2705         mutex_lock(&ps->smi_mutex);
2706         ret = _mv88e6xxx_phy_write_indirect(ds, port, 0x16, page);
2707         if (ret < 0)
2708                 goto error;
2709         ret = _mv88e6xxx_phy_read_indirect(ds, port, reg);
2710 error:
2711         _mv88e6xxx_phy_write_indirect(ds, port, 0x16, 0x0);
2712         mutex_unlock(&ps->smi_mutex);
2713         return ret;
2714 }
2715
2716 int mv88e6xxx_phy_page_write(struct dsa_switch *ds, int port, int page,
2717                              int reg, int val)
2718 {
2719         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
2720         int ret;
2721
2722         mutex_lock(&ps->smi_mutex);
2723         ret = _mv88e6xxx_phy_write_indirect(ds, port, 0x16, page);
2724         if (ret < 0)
2725                 goto error;
2726
2727         ret = _mv88e6xxx_phy_write_indirect(ds, port, reg, val);
2728 error:
2729         _mv88e6xxx_phy_write_indirect(ds, port, 0x16, 0x0);
2730         mutex_unlock(&ps->smi_mutex);
2731         return ret;
2732 }
2733
2734 static int mv88e6xxx_port_to_phy_addr(struct dsa_switch *ds, int port)
2735 {
2736         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
2737
2738         if (port >= 0 && port < ps->num_ports)
2739                 return port;
2740         return -EINVAL;
2741 }
2742
2743 int
2744 mv88e6xxx_phy_read(struct dsa_switch *ds, int port, int regnum)
2745 {
2746         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
2747         int addr = mv88e6xxx_port_to_phy_addr(ds, port);
2748         int ret;
2749
2750         if (addr < 0)
2751                 return addr;
2752
2753         mutex_lock(&ps->smi_mutex);
2754         ret = _mv88e6xxx_phy_read(ds, addr, regnum);
2755         mutex_unlock(&ps->smi_mutex);
2756         return ret;
2757 }
2758
2759 int
2760 mv88e6xxx_phy_write(struct dsa_switch *ds, int port, int regnum, u16 val)
2761 {
2762         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
2763         int addr = mv88e6xxx_port_to_phy_addr(ds, port);
2764         int ret;
2765
2766         if (addr < 0)
2767                 return addr;
2768
2769         mutex_lock(&ps->smi_mutex);
2770         ret = _mv88e6xxx_phy_write(ds, addr, regnum, val);
2771         mutex_unlock(&ps->smi_mutex);
2772         return ret;
2773 }
2774
2775 int
2776 mv88e6xxx_phy_read_indirect(struct dsa_switch *ds, int port, int regnum)
2777 {
2778         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
2779         int addr = mv88e6xxx_port_to_phy_addr(ds, port);
2780         int ret;
2781
2782         if (addr < 0)
2783                 return addr;
2784
2785         mutex_lock(&ps->smi_mutex);
2786         ret = _mv88e6xxx_phy_read_indirect(ds, addr, regnum);
2787         mutex_unlock(&ps->smi_mutex);
2788         return ret;
2789 }
2790
2791 int
2792 mv88e6xxx_phy_write_indirect(struct dsa_switch *ds, int port, int regnum,
2793                              u16 val)
2794 {
2795         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
2796         int addr = mv88e6xxx_port_to_phy_addr(ds, port);
2797         int ret;
2798
2799         if (addr < 0)
2800                 return addr;
2801
2802         mutex_lock(&ps->smi_mutex);
2803         ret = _mv88e6xxx_phy_write_indirect(ds, addr, regnum, val);
2804         mutex_unlock(&ps->smi_mutex);
2805         return ret;
2806 }
2807
2808 #ifdef CONFIG_NET_DSA_HWMON
2809
2810 static int mv88e61xx_get_temp(struct dsa_switch *ds, int *temp)
2811 {
2812         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
2813         int ret;
2814         int val;
2815
2816         *temp = 0;
2817
2818         mutex_lock(&ps->smi_mutex);
2819
2820         ret = _mv88e6xxx_phy_write(ds, 0x0, 0x16, 0x6);
2821         if (ret < 0)
2822                 goto error;
2823
2824         /* Enable temperature sensor */
2825         ret = _mv88e6xxx_phy_read(ds, 0x0, 0x1a);
2826         if (ret < 0)
2827                 goto error;
2828
2829         ret = _mv88e6xxx_phy_write(ds, 0x0, 0x1a, ret | (1 << 5));
2830         if (ret < 0)
2831                 goto error;
2832
2833         /* Wait for temperature to stabilize */
2834         usleep_range(10000, 12000);
2835
2836         val = _mv88e6xxx_phy_read(ds, 0x0, 0x1a);
2837         if (val < 0) {
2838                 ret = val;
2839                 goto error;
2840         }
2841
2842         /* Disable temperature sensor */
2843         ret = _mv88e6xxx_phy_write(ds, 0x0, 0x1a, ret & ~(1 << 5));
2844         if (ret < 0)
2845                 goto error;
2846
2847         *temp = ((val & 0x1f) - 5) * 5;
2848
2849 error:
2850         _mv88e6xxx_phy_write(ds, 0x0, 0x16, 0x0);
2851         mutex_unlock(&ps->smi_mutex);
2852         return ret;
2853 }
2854
2855 static int mv88e63xx_get_temp(struct dsa_switch *ds, int *temp)
2856 {
2857         int phy = mv88e6xxx_6320_family(ds) ? 3 : 0;
2858         int ret;
2859
2860         *temp = 0;
2861
2862         ret = mv88e6xxx_phy_page_read(ds, phy, 6, 27);
2863         if (ret < 0)
2864                 return ret;
2865
2866         *temp = (ret & 0xff) - 25;
2867
2868         return 0;
2869 }
2870
2871 int mv88e6xxx_get_temp(struct dsa_switch *ds, int *temp)
2872 {
2873         if (mv88e6xxx_6320_family(ds) || mv88e6xxx_6352_family(ds))
2874                 return mv88e63xx_get_temp(ds, temp);
2875
2876         return mv88e61xx_get_temp(ds, temp);
2877 }
2878
2879 int mv88e6xxx_get_temp_limit(struct dsa_switch *ds, int *temp)
2880 {
2881         int phy = mv88e6xxx_6320_family(ds) ? 3 : 0;
2882         int ret;
2883
2884         if (!mv88e6xxx_6320_family(ds) && !mv88e6xxx_6352_family(ds))
2885                 return -EOPNOTSUPP;
2886
2887         *temp = 0;
2888
2889         ret = mv88e6xxx_phy_page_read(ds, phy, 6, 26);
2890         if (ret < 0)
2891                 return ret;
2892
2893         *temp = (((ret >> 8) & 0x1f) * 5) - 25;
2894
2895         return 0;
2896 }
2897
2898 int mv88e6xxx_set_temp_limit(struct dsa_switch *ds, int temp)
2899 {
2900         int phy = mv88e6xxx_6320_family(ds) ? 3 : 0;
2901         int ret;
2902
2903         if (!mv88e6xxx_6320_family(ds) && !mv88e6xxx_6352_family(ds))
2904                 return -EOPNOTSUPP;
2905
2906         ret = mv88e6xxx_phy_page_read(ds, phy, 6, 26);
2907         if (ret < 0)
2908                 return ret;
2909         temp = clamp_val(DIV_ROUND_CLOSEST(temp, 5) + 5, 0, 0x1f);
2910         return mv88e6xxx_phy_page_write(ds, phy, 6, 26,
2911                                         (ret & 0xe0ff) | (temp << 8));
2912 }
2913
2914 int mv88e6xxx_get_temp_alarm(struct dsa_switch *ds, bool *alarm)
2915 {
2916         int phy = mv88e6xxx_6320_family(ds) ? 3 : 0;
2917         int ret;
2918
2919         if (!mv88e6xxx_6320_family(ds) && !mv88e6xxx_6352_family(ds))
2920                 return -EOPNOTSUPP;
2921
2922         *alarm = false;
2923
2924         ret = mv88e6xxx_phy_page_read(ds, phy, 6, 26);
2925         if (ret < 0)
2926                 return ret;
2927
2928         *alarm = !!(ret & 0x40);
2929
2930         return 0;
2931 }
2932 #endif /* CONFIG_NET_DSA_HWMON */
2933
2934 static int __init mv88e6xxx_init(void)
2935 {
2936 #if IS_ENABLED(CONFIG_NET_DSA_MV88E6131)
2937         register_switch_driver(&mv88e6131_switch_driver);
2938 #endif
2939 #if IS_ENABLED(CONFIG_NET_DSA_MV88E6123_61_65)
2940         register_switch_driver(&mv88e6123_61_65_switch_driver);
2941 #endif
2942 #if IS_ENABLED(CONFIG_NET_DSA_MV88E6352)
2943         register_switch_driver(&mv88e6352_switch_driver);
2944 #endif
2945 #if IS_ENABLED(CONFIG_NET_DSA_MV88E6171)
2946         register_switch_driver(&mv88e6171_switch_driver);
2947 #endif
2948         return 0;
2949 }
2950 module_init(mv88e6xxx_init);
2951
2952 static void __exit mv88e6xxx_cleanup(void)
2953 {
2954 #if IS_ENABLED(CONFIG_NET_DSA_MV88E6171)
2955         unregister_switch_driver(&mv88e6171_switch_driver);
2956 #endif
2957 #if IS_ENABLED(CONFIG_NET_DSA_MV88E6352)
2958         unregister_switch_driver(&mv88e6352_switch_driver);
2959 #endif
2960 #if IS_ENABLED(CONFIG_NET_DSA_MV88E6123_61_65)
2961         unregister_switch_driver(&mv88e6123_61_65_switch_driver);
2962 #endif
2963 #if IS_ENABLED(CONFIG_NET_DSA_MV88E6131)
2964         unregister_switch_driver(&mv88e6131_switch_driver);
2965 #endif
2966 }
2967 module_exit(mv88e6xxx_cleanup);
2968
2969 MODULE_AUTHOR("Lennert Buytenhek <buytenh@wantstofly.org>");
2970 MODULE_DESCRIPTION("Driver for Marvell 88E6XXX ethernet switch chips");
2971 MODULE_LICENSE("GPL");