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