drivers/net/dsa/mv88e6xxx/chip.c

   1 /*
   2  * Marvell 88e6xxx Ethernet switch single-chip support
   3  *
   4  * Copyright (c) 2008 Marvell Semiconductor
   5  *
   6  * Copyright (c) 2016 Andrew Lunn <andrew@lunn.ch>
   7  *
   8  * Copyright (c) 2016-2017 Savoir-faire Linux Inc.
   9  *      Vivien Didelot <vivien.didelot@savoirfairelinux.com>
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  */
  16
  17 #include <linux/delay.h>
  18 #include <linux/etherdevice.h>
  19 #include <linux/ethtool.h>
  20 #include <linux/if_bridge.h>
  21 #include <linux/interrupt.h>
  22 #include <linux/irq.h>
  23 #include <linux/irqdomain.h>
  24 #include <linux/jiffies.h>
  25 #include <linux/list.h>
  26 #include <linux/mdio.h>
  27 #include <linux/module.h>
  28 #include <linux/of_device.h>
  29 #include <linux/of_irq.h>
  30 #include <linux/of_mdio.h>
  31 #include <linux/netdevice.h>
  32 #include <linux/gpio/consumer.h>
  33 #include <linux/phy.h>
  34 #include <net/dsa.h>
  35
  36 #include "chip.h"
  37 #include "global1.h"
  38 #include "global2.h"
  39 #include "phy.h"
  40 #include "port.h"
  41 #include "serdes.h"
  42
  43 static void assert_reg_lock(struct mv88e6xxx_chip *chip)
  44 {
  45         if (unlikely(!mutex_is_locked(&chip->reg_lock))) {
  46                 dev_err(chip->dev, "Switch registers lock not held!\n");
  47                 dump_stack();
  48         }
  49 }
  50
  51 /* The switch ADDR[4:1] configuration pins define the chip SMI device address
  52  * (ADDR[0] is always zero, thus only even SMI addresses can be strapped).
  53  *
  54  * When ADDR is all zero, the chip uses Single-chip Addressing Mode, assuming it
  55  * is the only device connected to the SMI master. In this mode it responds to
  56  * all 32 possible SMI addresses, and thus maps directly the internal devices.
  57  *
  58  * When ADDR is non-zero, the chip uses Multi-chip Addressing Mode, allowing
  59  * multiple devices to share the SMI interface. In this mode it responds to only
  60  * 2 registers, used to indirectly access the internal SMI devices.
  61  */
  62
  63 static int mv88e6xxx_smi_read(struct mv88e6xxx_chip *chip,
  64                               int addr, int reg, u16 *val)
  65 {
  66         if (!chip->smi_ops)
  67                 return -EOPNOTSUPP;
  68
  69         return chip->smi_ops->read(chip, addr, reg, val);
  70 }
  71
  72 static int mv88e6xxx_smi_write(struct mv88e6xxx_chip *chip,
  73                                int addr, int reg, u16 val)
  74 {
  75         if (!chip->smi_ops)
  76                 return -EOPNOTSUPP;
  77
  78         return chip->smi_ops->write(chip, addr, reg, val);
  79 }
  80
  81 static int mv88e6xxx_smi_single_chip_read(struct mv88e6xxx_chip *chip,
  82                                           int addr, int reg, u16 *val)
  83 {
  84         int ret;
  85
  86         ret = mdiobus_read_nested(chip->bus, addr, reg);
  87         if (ret < 0)
  88                 return ret;
  89
  90         *val = ret & 0xffff;
  91
  92         return 0;
  93 }
  94
  95 static int mv88e6xxx_smi_single_chip_write(struct mv88e6xxx_chip *chip,
  96                                            int addr, int reg, u16 val)
  97 {
  98         int ret;
  99
 100         ret = mdiobus_write_nested(chip->bus, addr, reg, val);
 101         if (ret < 0)
 102                 return ret;
 103
 104         return 0;
 105 }
 106
 107 static const struct mv88e6xxx_bus_ops mv88e6xxx_smi_single_chip_ops = {
 108         .read = mv88e6xxx_smi_single_chip_read,
 109         .write = mv88e6xxx_smi_single_chip_write,
 110 };
 111
 112 static int mv88e6xxx_smi_multi_chip_wait(struct mv88e6xxx_chip *chip)
 113 {
 114         int ret;
 115         int i;
 116
 117         for (i = 0; i < 16; i++) {
 118                 ret = mdiobus_read_nested(chip->bus, chip->sw_addr, SMI_CMD);
 119                 if (ret < 0)
 120                         return ret;
 121
 122                 if ((ret & SMI_CMD_BUSY) == 0)
 123                         return 0;
 124         }
 125
 126         return -ETIMEDOUT;
 127 }
 128
 129 static int mv88e6xxx_smi_multi_chip_read(struct mv88e6xxx_chip *chip,
 130                                          int addr, int reg, u16 *val)
 131 {
 132         int ret;
 133
 134         /* Wait for the bus to become free. */
 135         ret = mv88e6xxx_smi_multi_chip_wait(chip);
 136         if (ret < 0)
 137                 return ret;
 138
 139         /* Transmit the read command. */
 140         ret = mdiobus_write_nested(chip->bus, chip->sw_addr, SMI_CMD,
 141                                    SMI_CMD_OP_22_READ | (addr << 5) | reg);
 142         if (ret < 0)
 143                 return ret;
 144
 145         /* Wait for the read command to complete. */
 146         ret = mv88e6xxx_smi_multi_chip_wait(chip);
 147         if (ret < 0)
 148                 return ret;
 149
 150         /* Read the data. */
 151         ret = mdiobus_read_nested(chip->bus, chip->sw_addr, SMI_DATA);
 152         if (ret < 0)
 153                 return ret;
 154
 155         *val = ret & 0xffff;
 156
 157         return 0;
 158 }
 159
 160 static int mv88e6xxx_smi_multi_chip_write(struct mv88e6xxx_chip *chip,
 161                                           int addr, int reg, u16 val)
 162 {
 163         int ret;
 164
 165         /* Wait for the bus to become free. */
 166         ret = mv88e6xxx_smi_multi_chip_wait(chip);
 167         if (ret < 0)
 168                 return ret;
 169
 170         /* Transmit the data to write. */
 171         ret = mdiobus_write_nested(chip->bus, chip->sw_addr, SMI_DATA, val);
 172         if (ret < 0)
 173                 return ret;
 174
 175         /* Transmit the write command. */
 176         ret = mdiobus_write_nested(chip->bus, chip->sw_addr, SMI_CMD,
 177                                    SMI_CMD_OP_22_WRITE | (addr << 5) | reg);
 178         if (ret < 0)
 179                 return ret;
 180
 181         /* Wait for the write command to complete. */
 182         ret = mv88e6xxx_smi_multi_chip_wait(chip);
 183         if (ret < 0)
 184                 return ret;
 185
 186         return 0;
 187 }
 188
 189 static const struct mv88e6xxx_bus_ops mv88e6xxx_smi_multi_chip_ops = {
 190         .read = mv88e6xxx_smi_multi_chip_read,
 191         .write = mv88e6xxx_smi_multi_chip_write,
 192 };
 193
 194 int mv88e6xxx_read(struct mv88e6xxx_chip *chip, int addr, int reg, u16 *val)
 195 {
 196         int err;
 197
 198         assert_reg_lock(chip);
 199
 200         err = mv88e6xxx_smi_read(chip, addr, reg, val);
 201         if (err)
 202                 return err;
 203
 204         dev_dbg(chip->dev, "<- addr: 0x%.2x reg: 0x%.2x val: 0x%.4x\n",
 205                 addr, reg, *val);
 206
 207         return 0;
 208 }
 209
 210 int mv88e6xxx_write(struct mv88e6xxx_chip *chip, int addr, int reg, u16 val)
 211 {
 212         int err;
 213
 214         assert_reg_lock(chip);
 215
 216         err = mv88e6xxx_smi_write(chip, addr, reg, val);
 217         if (err)
 218                 return err;
 219
 220         dev_dbg(chip->dev, "-> addr: 0x%.2x reg: 0x%.2x val: 0x%.4x\n",
 221                 addr, reg, val);
 222
 223         return 0;
 224 }
 225
 226 struct mii_bus *mv88e6xxx_default_mdio_bus(struct mv88e6xxx_chip *chip)
 227 {
 228         struct mv88e6xxx_mdio_bus *mdio_bus;
 229
 230         mdio_bus = list_first_entry(&chip->mdios, struct mv88e6xxx_mdio_bus,
 231                                     list);
 232         if (!mdio_bus)
 233                 return NULL;
 234
 235         return mdio_bus->bus;
 236 }
 237
 238 static void mv88e6xxx_g1_irq_mask(struct irq_data *d)
 239 {
 240         struct mv88e6xxx_chip *chip = irq_data_get_irq_chip_data(d);
 241         unsigned int n = d->hwirq;
 242
 243         chip->g1_irq.masked |= (1 << n);
 244 }
 245
 246 static void mv88e6xxx_g1_irq_unmask(struct irq_data *d)
 247 {
 248         struct mv88e6xxx_chip *chip = irq_data_get_irq_chip_data(d);
 249         unsigned int n = d->hwirq;
 250
 251         chip->g1_irq.masked &= ~(1 << n);
 252 }
 253
 254 static irqreturn_t mv88e6xxx_g1_irq_thread_fn(int irq, void *dev_id)
 255 {
 256         struct mv88e6xxx_chip *chip = dev_id;
 257         unsigned int nhandled = 0;
 258         unsigned int sub_irq;
 259         unsigned int n;
 260         u16 reg;
 261         int err;
 262
 263         mutex_lock(&chip->reg_lock);
 264         err = mv88e6xxx_g1_read(chip, MV88E6XXX_G1_STS, &reg);
 265         mutex_unlock(&chip->reg_lock);
 266
 267         if (err)
 268                 goto out;
 269
 270         for (n = 0; n < chip->g1_irq.nirqs; ++n) {
 271                 if (reg & (1 << n)) {
 272                         sub_irq = irq_find_mapping(chip->g1_irq.domain, n);
 273                         handle_nested_irq(sub_irq);
 274                         ++nhandled;
 275                 }
 276         }
 277 out:
 278         return (nhandled > 0 ? IRQ_HANDLED : IRQ_NONE);
 279 }
 280
 281 static void mv88e6xxx_g1_irq_bus_lock(struct irq_data *d)
 282 {
 283         struct mv88e6xxx_chip *chip = irq_data_get_irq_chip_data(d);
 284
 285         mutex_lock(&chip->reg_lock);
 286 }
 287
 288 static void mv88e6xxx_g1_irq_bus_sync_unlock(struct irq_data *d)
 289 {
 290         struct mv88e6xxx_chip *chip = irq_data_get_irq_chip_data(d);
 291         u16 mask = GENMASK(chip->g1_irq.nirqs, 0);
 292         u16 reg;
 293         int err;
 294
 295         err = mv88e6xxx_g1_read(chip, MV88E6XXX_G1_CTL1, &reg);
 296         if (err)
 297                 goto out;
 298
 299         reg &= ~mask;
 300         reg |= (~chip->g1_irq.masked & mask);
 301
 302         err = mv88e6xxx_g1_write(chip, MV88E6XXX_G1_CTL1, reg);
 303         if (err)
 304                 goto out;
 305
 306 out:
 307         mutex_unlock(&chip->reg_lock);
 308 }
 309
 310 static struct irq_chip mv88e6xxx_g1_irq_chip = {
 311         .name                   = "mv88e6xxx-g1",
 312         .irq_mask               = mv88e6xxx_g1_irq_mask,
 313         .irq_unmask             = mv88e6xxx_g1_irq_unmask,
 314         .irq_bus_lock           = mv88e6xxx_g1_irq_bus_lock,
 315         .irq_bus_sync_unlock    = mv88e6xxx_g1_irq_bus_sync_unlock,
 316 };
 317
 318 static int mv88e6xxx_g1_irq_domain_map(struct irq_domain *d,
 319                                        unsigned int irq,
 320                                        irq_hw_number_t hwirq)
 321 {
 322         struct mv88e6xxx_chip *chip = d->host_data;
 323
 324         irq_set_chip_data(irq, d->host_data);
 325         irq_set_chip_and_handler(irq, &chip->g1_irq.chip, handle_level_irq);
 326         irq_set_noprobe(irq);
 327
 328         return 0;
 329 }
 330
 331 static const struct irq_domain_ops mv88e6xxx_g1_irq_domain_ops = {
 332         .map    = mv88e6xxx_g1_irq_domain_map,
 333         .xlate  = irq_domain_xlate_twocell,
 334 };
 335
 336 static void mv88e6xxx_g1_irq_free(struct mv88e6xxx_chip *chip)
 337 {
 338         int irq, virq;
 339         u16 mask;
 340
 341         mv88e6xxx_g1_read(chip, MV88E6XXX_G1_CTL1, &mask);
 342         mask |= GENMASK(chip->g1_irq.nirqs, 0);
 343         mv88e6xxx_g1_write(chip, MV88E6XXX_G1_CTL1, mask);
 344
 345         free_irq(chip->irq, chip);
 346
 347         for (irq = 0; irq < chip->g1_irq.nirqs; irq++) {
 348                 virq = irq_find_mapping(chip->g1_irq.domain, irq);
 349                 irq_dispose_mapping(virq);
 350         }
 351
 352         irq_domain_remove(chip->g1_irq.domain);
 353 }
 354
 355 static int mv88e6xxx_g1_irq_setup(struct mv88e6xxx_chip *chip)
 356 {
 357         int err, irq, virq;
 358         u16 reg, mask;
 359
 360         chip->g1_irq.nirqs = chip->info->g1_irqs;
 361         chip->g1_irq.domain = irq_domain_add_simple(
 362                 NULL, chip->g1_irq.nirqs, 0,
 363                 &mv88e6xxx_g1_irq_domain_ops, chip);
 364         if (!chip->g1_irq.domain)
 365                 return -ENOMEM;
 366
 367         for (irq = 0; irq < chip->g1_irq.nirqs; irq++)
 368                 irq_create_mapping(chip->g1_irq.domain, irq);
 369
 370         chip->g1_irq.chip = mv88e6xxx_g1_irq_chip;
 371         chip->g1_irq.masked = ~0;
 372
 373         err = mv88e6xxx_g1_read(chip, MV88E6XXX_G1_CTL1, &mask);
 374         if (err)
 375                 goto out_mapping;
 376
 377         mask &= ~GENMASK(chip->g1_irq.nirqs, 0);
 378
 379         err = mv88e6xxx_g1_write(chip, MV88E6XXX_G1_CTL1, mask);
 380         if (err)
 381                 goto out_disable;
 382
 383         /* Reading the interrupt status clears (most of) them */
 384         err = mv88e6xxx_g1_read(chip, MV88E6XXX_G1_STS, &reg);
 385         if (err)
 386                 goto out_disable;
 387
 388         err = request_threaded_irq(chip->irq, NULL,
 389                                    mv88e6xxx_g1_irq_thread_fn,
 390                                    IRQF_ONESHOT | IRQF_TRIGGER_FALLING,
 391                                    dev_name(chip->dev), chip);
 392         if (err)
 393                 goto out_disable;
 394
 395         return 0;
 396
 397 out_disable:
 398         mask |= GENMASK(chip->g1_irq.nirqs, 0);
 399         mv88e6xxx_g1_write(chip, MV88E6XXX_G1_CTL1, mask);
 400
 401 out_mapping:
 402         for (irq = 0; irq < 16; irq++) {
 403                 virq = irq_find_mapping(chip->g1_irq.domain, irq);
 404                 irq_dispose_mapping(virq);
 405         }
 406
 407         irq_domain_remove(chip->g1_irq.domain);
 408
 409         return err;
 410 }
 411
 412 int mv88e6xxx_wait(struct mv88e6xxx_chip *chip, int addr, int reg, u16 mask)
 413 {
 414         int i;
 415
 416         for (i = 0; i < 16; i++) {
 417                 u16 val;
 418                 int err;
 419
 420                 err = mv88e6xxx_read(chip, addr, reg, &val);
 421                 if (err)
 422                         return err;
 423
 424                 if (!(val & mask))
 425                         return 0;
 426
 427                 usleep_range(1000, 2000);
 428         }
 429
 430         dev_err(chip->dev, "Timeout while waiting for switch\n");
 431         return -ETIMEDOUT;
 432 }
 433
 434 /* Indirect write to single pointer-data register with an Update bit */
 435 int mv88e6xxx_update(struct mv88e6xxx_chip *chip, int addr, int reg, u16 update)
 436 {
 437         u16 val;
 438         int err;
 439
 440         /* Wait until the previous operation is completed */
 441         err = mv88e6xxx_wait(chip, addr, reg, BIT(15));
 442         if (err)
 443                 return err;
 444
 445         /* Set the Update bit to trigger a write operation */
 446         val = BIT(15) | update;
 447
 448         return mv88e6xxx_write(chip, addr, reg, val);
 449 }
 450
 451 static int mv88e6xxx_port_setup_mac(struct mv88e6xxx_chip *chip, int port,
 452                                     int link, int speed, int duplex,
 453                                     phy_interface_t mode)
 454 {
 455         int err;
 456
 457         if (!chip->info->ops->port_set_link)
 458                 return 0;
 459
 460         /* Port's MAC control must not be changed unless the link is down */
 461         err = chip->info->ops->port_set_link(chip, port, 0);
 462         if (err)
 463                 return err;
 464
 465         if (chip->info->ops->port_set_speed) {
 466                 err = chip->info->ops->port_set_speed(chip, port, speed);
 467                 if (err && err != -EOPNOTSUPP)
 468                         goto restore_link;
 469         }
 470
 471         if (chip->info->ops->port_set_duplex) {
 472                 err = chip->info->ops->port_set_duplex(chip, port, duplex);
 473                 if (err && err != -EOPNOTSUPP)
 474                         goto restore_link;
 475         }
 476
 477         if (chip->info->ops->port_set_rgmii_delay) {
 478                 err = chip->info->ops->port_set_rgmii_delay(chip, port, mode);
 479                 if (err && err != -EOPNOTSUPP)
 480                         goto restore_link;
 481         }
 482
 483         if (chip->info->ops->port_set_cmode) {
 484                 err = chip->info->ops->port_set_cmode(chip, port, mode);
 485                 if (err && err != -EOPNOTSUPP)
 486                         goto restore_link;
 487         }
 488
 489         err = 0;
 490 restore_link:
 491         if (chip->info->ops->port_set_link(chip, port, link))
 492                 dev_err(chip->dev, "p%d: failed to restore MAC's link\n", port);
 493
 494         return err;
 495 }
 496
 497 /* We expect the switch to perform auto negotiation if there is a real
 498  * phy. However, in the case of a fixed link phy, we force the port
 499  * settings from the fixed link settings.
 500  */
 501 static void mv88e6xxx_adjust_link(struct dsa_switch *ds, int port,
 502                                   struct phy_device *phydev)
 503 {
 504         struct mv88e6xxx_chip *chip = ds->priv;
 505         int err;
 506
 507         if (!phy_is_pseudo_fixed_link(phydev))
 508                 return;
 509
 510         mutex_lock(&chip->reg_lock);
 511         err = mv88e6xxx_port_setup_mac(chip, port, phydev->link, phydev->speed,
 512                                        phydev->duplex, phydev->interface);
 513         mutex_unlock(&chip->reg_lock);
 514
 515         if (err && err != -EOPNOTSUPP)
 516                 dev_err(ds->dev, "p%d: failed to configure MAC\n", port);
 517 }
 518
 519 static int mv88e6xxx_stats_snapshot(struct mv88e6xxx_chip *chip, int port)
 520 {
 521         if (!chip->info->ops->stats_snapshot)
 522                 return -EOPNOTSUPP;
 523
 524         return chip->info->ops->stats_snapshot(chip, port);
 525 }
 526
 527 static struct mv88e6xxx_hw_stat mv88e6xxx_hw_stats[] = {
 528         { "in_good_octets",             8, 0x00, STATS_TYPE_BANK0, },
 529         { "in_bad_octets",              4, 0x02, STATS_TYPE_BANK0, },
 530         { "in_unicast",                 4, 0x04, STATS_TYPE_BANK0, },
 531         { "in_broadcasts",              4, 0x06, STATS_TYPE_BANK0, },
 532         { "in_multicasts",              4, 0x07, STATS_TYPE_BANK0, },
 533         { "in_pause",                   4, 0x16, STATS_TYPE_BANK0, },
 534         { "in_undersize",               4, 0x18, STATS_TYPE_BANK0, },
 535         { "in_fragments",               4, 0x19, STATS_TYPE_BANK0, },
 536         { "in_oversize",                4, 0x1a, STATS_TYPE_BANK0, },
 537         { "in_jabber",                  4, 0x1b, STATS_TYPE_BANK0, },
 538         { "in_rx_error",                4, 0x1c, STATS_TYPE_BANK0, },
 539         { "in_fcs_error",               4, 0x1d, STATS_TYPE_BANK0, },
 540         { "out_octets",                 8, 0x0e, STATS_TYPE_BANK0, },
 541         { "out_unicast",                4, 0x10, STATS_TYPE_BANK0, },
 542         { "out_broadcasts",             4, 0x13, STATS_TYPE_BANK0, },
 543         { "out_multicasts",             4, 0x12, STATS_TYPE_BANK0, },
 544         { "out_pause",                  4, 0x15, STATS_TYPE_BANK0, },
 545         { "excessive",                  4, 0x11, STATS_TYPE_BANK0, },
 546         { "collisions",                 4, 0x1e, STATS_TYPE_BANK0, },
 547         { "deferred",                   4, 0x05, STATS_TYPE_BANK0, },
 548         { "single",                     4, 0x14, STATS_TYPE_BANK0, },
 549         { "multiple",                   4, 0x17, STATS_TYPE_BANK0, },
 550         { "out_fcs_error",              4, 0x03, STATS_TYPE_BANK0, },
 551         { "late",                       4, 0x1f, STATS_TYPE_BANK0, },
 552         { "hist_64bytes",               4, 0x08, STATS_TYPE_BANK0, },
 553         { "hist_65_127bytes",           4, 0x09, STATS_TYPE_BANK0, },
 554         { "hist_128_255bytes",          4, 0x0a, STATS_TYPE_BANK0, },
 555         { "hist_256_511bytes",          4, 0x0b, STATS_TYPE_BANK0, },
 556         { "hist_512_1023bytes",         4, 0x0c, STATS_TYPE_BANK0, },
 557         { "hist_1024_max_bytes",        4, 0x0d, STATS_TYPE_BANK0, },
 558         { "sw_in_discards",             4, 0x10, STATS_TYPE_PORT, },
 559         { "sw_in_filtered",             2, 0x12, STATS_TYPE_PORT, },
 560         { "sw_out_filtered",            2, 0x13, STATS_TYPE_PORT, },
 561         { "in_discards",                4, 0x00, STATS_TYPE_BANK1, },
 562         { "in_filtered",                4, 0x01, STATS_TYPE_BANK1, },
 563         { "in_accepted",                4, 0x02, STATS_TYPE_BANK1, },
 564         { "in_bad_accepted",            4, 0x03, STATS_TYPE_BANK1, },
 565         { "in_good_avb_class_a",        4, 0x04, STATS_TYPE_BANK1, },
 566         { "in_good_avb_class_b",        4, 0x05, STATS_TYPE_BANK1, },
 567         { "in_bad_avb_class_a",         4, 0x06, STATS_TYPE_BANK1, },
 568         { "in_bad_avb_class_b",         4, 0x07, STATS_TYPE_BANK1, },
 569         { "tcam_counter_0",             4, 0x08, STATS_TYPE_BANK1, },
 570         { "tcam_counter_1",             4, 0x09, STATS_TYPE_BANK1, },
 571         { "tcam_counter_2",             4, 0x0a, STATS_TYPE_BANK1, },
 572         { "tcam_counter_3",             4, 0x0b, STATS_TYPE_BANK1, },
 573         { "in_da_unknown",              4, 0x0e, STATS_TYPE_BANK1, },
 574         { "in_management",              4, 0x0f, STATS_TYPE_BANK1, },
 575         { "out_queue_0",                4, 0x10, STATS_TYPE_BANK1, },
 576         { "out_queue_1",                4, 0x11, STATS_TYPE_BANK1, },
 577         { "out_queue_2",                4, 0x12, STATS_TYPE_BANK1, },
 578         { "out_queue_3",                4, 0x13, STATS_TYPE_BANK1, },
 579         { "out_queue_4",                4, 0x14, STATS_TYPE_BANK1, },
 580         { "out_queue_5",                4, 0x15, STATS_TYPE_BANK1, },
 581         { "out_queue_6",                4, 0x16, STATS_TYPE_BANK1, },
 582         { "out_queue_7",                4, 0x17, STATS_TYPE_BANK1, },
 583         { "out_cut_through",            4, 0x18, STATS_TYPE_BANK1, },
 584         { "out_octets_a",               4, 0x1a, STATS_TYPE_BANK1, },
 585         { "out_octets_b",               4, 0x1b, STATS_TYPE_BANK1, },
 586         { "out_management",             4, 0x1f, STATS_TYPE_BANK1, },
 587 };
 588
 589 static uint64_t _mv88e6xxx_get_ethtool_stat(struct mv88e6xxx_chip *chip,
 590                                             struct mv88e6xxx_hw_stat *s,
 591                                             int port, u16 bank1_select,
 592                                             u16 histogram)
 593 {
 594         u32 low;
 595         u32 high = 0;
 596         u16 reg = 0;
 597         int err;
 598         u64 value;
 599
 600         switch (s->type) {
 601         case STATS_TYPE_PORT:
 602                 err = mv88e6xxx_port_read(chip, port, s->reg, &reg);
 603                 if (err)
 604                         return UINT64_MAX;
 605
 606                 low = reg;
 607                 if (s->sizeof_stat == 4) {
 608                         err = mv88e6xxx_port_read(chip, port, s->reg + 1, &reg);
 609                         if (err)
 610                                 return UINT64_MAX;
 611                         high = reg;
 612                 }
 613                 break;
 614         case STATS_TYPE_BANK1:
 615                 reg = bank1_select;
 616                 /* fall through */
 617         case STATS_TYPE_BANK0:
 618                 reg |= s->reg | histogram;
 619                 mv88e6xxx_g1_stats_read(chip, reg, &low);
 620                 if (s->sizeof_stat == 8)
 621                         mv88e6xxx_g1_stats_read(chip, reg + 1, &high);
 622                 break;
 623         default:
 624                 return UINT64_MAX;
 625         }
 626         value = (((u64)high) << 16) | low;
 627         return value;
 628 }
 629
 630 static void mv88e6xxx_stats_get_strings(struct mv88e6xxx_chip *chip,
 631                                         uint8_t *data, int types)
 632 {
 633         struct mv88e6xxx_hw_stat *stat;
 634         int i, j;
 635
 636         for (i = 0, j = 0; i < ARRAY_SIZE(mv88e6xxx_hw_stats); i++) {
 637                 stat = &mv88e6xxx_hw_stats[i];
 638                 if (stat->type & types) {
 639                         memcpy(data + j * ETH_GSTRING_LEN, stat->string,
 640                                ETH_GSTRING_LEN);
 641                         j++;
 642                 }
 643         }
 644 }
 645
 646 static void mv88e6095_stats_get_strings(struct mv88e6xxx_chip *chip,
 647                                         uint8_t *data)
 648 {
 649         mv88e6xxx_stats_get_strings(chip, data,
 650                                     STATS_TYPE_BANK0 | STATS_TYPE_PORT);
 651 }
 652
 653 static void mv88e6320_stats_get_strings(struct mv88e6xxx_chip *chip,
 654                                         uint8_t *data)
 655 {
 656         mv88e6xxx_stats_get_strings(chip, data,
 657                                     STATS_TYPE_BANK0 | STATS_TYPE_BANK1);
 658 }
 659
 660 static void mv88e6xxx_get_strings(struct dsa_switch *ds, int port,
 661                                   uint8_t *data)
 662 {
 663         struct mv88e6xxx_chip *chip = ds->priv;
 664
 665         if (chip->info->ops->stats_get_strings)
 666                 chip->info->ops->stats_get_strings(chip, data);
 667 }
 668
 669 static int mv88e6xxx_stats_get_sset_count(struct mv88e6xxx_chip *chip,
 670                                           int types)
 671 {
 672         struct mv88e6xxx_hw_stat *stat;
 673         int i, j;
 674
 675         for (i = 0, j = 0; i < ARRAY_SIZE(mv88e6xxx_hw_stats); i++) {
 676                 stat = &mv88e6xxx_hw_stats[i];
 677                 if (stat->type & types)
 678                         j++;
 679         }
 680         return j;
 681 }
 682
 683 static int mv88e6095_stats_get_sset_count(struct mv88e6xxx_chip *chip)
 684 {
 685         return mv88e6xxx_stats_get_sset_count(chip, STATS_TYPE_BANK0 |
 686                                               STATS_TYPE_PORT);
 687 }
 688
 689 static int mv88e6320_stats_get_sset_count(struct mv88e6xxx_chip *chip)
 690 {
 691         return mv88e6xxx_stats_get_sset_count(chip, STATS_TYPE_BANK0 |
 692                                               STATS_TYPE_BANK1);
 693 }
 694
 695 static int mv88e6xxx_get_sset_count(struct dsa_switch *ds)
 696 {
 697         struct mv88e6xxx_chip *chip = ds->priv;
 698
 699         if (chip->info->ops->stats_get_sset_count)
 700                 return chip->info->ops->stats_get_sset_count(chip);
 701
 702         return 0;
 703 }
 704
 705 static void mv88e6xxx_stats_get_stats(struct mv88e6xxx_chip *chip, int port,
 706                                       uint64_t *data, int types,
 707                                       u16 bank1_select, u16 histogram)
 708 {
 709         struct mv88e6xxx_hw_stat *stat;
 710         int i, j;
 711
 712         for (i = 0, j = 0; i < ARRAY_SIZE(mv88e6xxx_hw_stats); i++) {
 713                 stat = &mv88e6xxx_hw_stats[i];
 714                 if (stat->type & types) {
 715                         data[j] = _mv88e6xxx_get_ethtool_stat(chip, stat, port,
 716                                                               bank1_select,
 717                                                               histogram);
 718                         j++;
 719                 }
 720         }
 721 }
 722
 723 static void mv88e6095_stats_get_stats(struct mv88e6xxx_chip *chip, int port,
 724                                       uint64_t *data)
 725 {
 726         return mv88e6xxx_stats_get_stats(chip, port, data,
 727                                          STATS_TYPE_BANK0 | STATS_TYPE_PORT,
 728                                          0, MV88E6XXX_G1_STATS_OP_HIST_RX_TX);
 729 }
 730
 731 static void mv88e6320_stats_get_stats(struct mv88e6xxx_chip *chip, int port,
 732                                       uint64_t *data)
 733 {
 734         return mv88e6xxx_stats_get_stats(chip, port, data,
 735                                          STATS_TYPE_BANK0 | STATS_TYPE_BANK1,
 736                                          MV88E6XXX_G1_STATS_OP_BANK_1_BIT_9,
 737                                          MV88E6XXX_G1_STATS_OP_HIST_RX_TX);
 738 }
 739
 740 static void mv88e6390_stats_get_stats(struct mv88e6xxx_chip *chip, int port,
 741                                       uint64_t *data)
 742 {
 743         return mv88e6xxx_stats_get_stats(chip, port, data,
 744                                          STATS_TYPE_BANK0 | STATS_TYPE_BANK1,
 745                                          MV88E6XXX_G1_STATS_OP_BANK_1_BIT_10,
 746                                          0);
 747 }
 748
 749 static void mv88e6xxx_get_stats(struct mv88e6xxx_chip *chip, int port,
 750                                 uint64_t *data)
 751 {
 752         if (chip->info->ops->stats_get_stats)
 753                 chip->info->ops->stats_get_stats(chip, port, data);
 754 }
 755
 756 static void mv88e6xxx_get_ethtool_stats(struct dsa_switch *ds, int port,
 757                                         uint64_t *data)
 758 {
 759         struct mv88e6xxx_chip *chip = ds->priv;
 760         int ret;
 761
 762         mutex_lock(&chip->reg_lock);
 763
 764         ret = mv88e6xxx_stats_snapshot(chip, port);
 765         if (ret < 0) {
 766                 mutex_unlock(&chip->reg_lock);
 767                 return;
 768         }
 769
 770         mv88e6xxx_get_stats(chip, port, data);
 771
 772         mutex_unlock(&chip->reg_lock);
 773 }
 774
 775 static int mv88e6xxx_stats_set_histogram(struct mv88e6xxx_chip *chip)
 776 {
 777         if (chip->info->ops->stats_set_histogram)
 778                 return chip->info->ops->stats_set_histogram(chip);
 779
 780         return 0;
 781 }
 782
 783 static int mv88e6xxx_get_regs_len(struct dsa_switch *ds, int port)
 784 {
 785         return 32 * sizeof(u16);
 786 }
 787
 788 static void mv88e6xxx_get_regs(struct dsa_switch *ds, int port,
 789                                struct ethtool_regs *regs, void *_p)
 790 {
 791         struct mv88e6xxx_chip *chip = ds->priv;
 792         int err;
 793         u16 reg;
 794         u16 *p = _p;
 795         int i;
 796
 797         regs->version = 0;
 798
 799         memset(p, 0xff, 32 * sizeof(u16));
 800
 801         mutex_lock(&chip->reg_lock);
 802
 803         for (i = 0; i < 32; i++) {
 804
 805                 err = mv88e6xxx_port_read(chip, port, i, &reg);
 806                 if (!err)
 807                         p[i] = reg;
 808         }
 809
 810         mutex_unlock(&chip->reg_lock);
 811 }
 812
 813 static int mv88e6xxx_energy_detect_read(struct mv88e6xxx_chip *chip, int port,
 814                                         struct ethtool_eee *eee)
 815 {
 816         int err;
 817
 818         if (!chip->info->ops->phy_energy_detect_read)
 819                 return -EOPNOTSUPP;
 820
 821         /* assign eee->eee_enabled and eee->tx_lpi_enabled */
 822         err = chip->info->ops->phy_energy_detect_read(chip, port, eee);
 823         if (err)
 824                 return err;
 825
 826         /* assign eee->eee_active */
 827         return mv88e6xxx_port_status_eee(chip, port, eee);
 828 }
 829
 830 static int mv88e6xxx_energy_detect_write(struct mv88e6xxx_chip *chip, int port,
 831                                          struct ethtool_eee *eee)
 832 {
 833         if (!chip->info->ops->phy_energy_detect_write)
 834                 return -EOPNOTSUPP;
 835
 836         return chip->info->ops->phy_energy_detect_write(chip, port, eee);
 837 }
 838
 839 static int mv88e6xxx_get_eee(struct dsa_switch *ds, int port,
 840                              struct ethtool_eee *e)
 841 {
 842         struct mv88e6xxx_chip *chip = ds->priv;
 843         int err;
 844
 845         mutex_lock(&chip->reg_lock);
 846         err = mv88e6xxx_energy_detect_read(chip, port, e);
 847         mutex_unlock(&chip->reg_lock);
 848
 849         return err;
 850 }
 851
 852 static int mv88e6xxx_set_eee(struct dsa_switch *ds, int port,
 853                              struct phy_device *phydev, struct ethtool_eee *e)
 854 {
 855         struct mv88e6xxx_chip *chip = ds->priv;
 856         int err;
 857
 858         if (e->eee_enabled) {
 859                 err = phy_init_eee(phydev, 0);
 860                 if (err)
 861                         return err;
 862         }
 863
 864         mutex_lock(&chip->reg_lock);
 865         err = mv88e6xxx_energy_detect_write(chip, port, e);
 866         mutex_unlock(&chip->reg_lock);
 867
 868         return err;
 869 }
 870
 871 static u16 mv88e6xxx_port_vlan(struct mv88e6xxx_chip *chip, int dev, int port)
 872 {
 873         struct dsa_switch *ds = NULL;
 874         struct net_device *br;
 875         u16 pvlan;
 876         int i;
 877
 878         if (dev < DSA_MAX_SWITCHES)
 879                 ds = chip->ds->dst->ds[dev];
 880
 881         /* Prevent frames from unknown switch or port */
 882         if (!ds || port >= ds->num_ports)
 883                 return 0;
 884
 885         /* Frames from DSA links and CPU ports can egress any local port */
 886         if (dsa_is_cpu_port(ds, port) || dsa_is_dsa_port(ds, port))
 887                 return mv88e6xxx_port_mask(chip);
 888
 889         br = ds->ports[port].bridge_dev;
 890         pvlan = 0;
 891
 892         /* Frames from user ports can egress any local DSA links and CPU ports,
 893          * as well as any local member of their bridge group.
 894          */
 895         for (i = 0; i < mv88e6xxx_num_ports(chip); ++i)
 896                 if (dsa_is_cpu_port(chip->ds, i) ||
 897                     dsa_is_dsa_port(chip->ds, i) ||
 898                     (br && chip->ds->ports[i].bridge_dev == br))
 899                         pvlan |= BIT(i);
 900
 901         return pvlan;
 902 }
 903
 904 static int mv88e6xxx_port_vlan_map(struct mv88e6xxx_chip *chip, int port)
 905 {
 906         u16 output_ports = mv88e6xxx_port_vlan(chip, chip->ds->index, port);
 907
 908         /* prevent frames from going back out of the port they came in on */
 909         output_ports &= ~BIT(port);
 910
 911         return mv88e6xxx_port_set_vlan_map(chip, port, output_ports);
 912 }
 913
 914 static void mv88e6xxx_port_stp_state_set(struct dsa_switch *ds, int port,
 915                                          u8 state)
 916 {
 917         struct mv88e6xxx_chip *chip = ds->priv;
 918         int err;
 919
 920         mutex_lock(&chip->reg_lock);
 921         err = mv88e6xxx_port_set_state(chip, port, state);
 922         mutex_unlock(&chip->reg_lock);
 923
 924         if (err)
 925                 dev_err(ds->dev, "p%d: failed to update state\n", port);
 926 }
 927
 928 static int mv88e6xxx_pot_setup(struct mv88e6xxx_chip *chip)
 929 {
 930         if (chip->info->ops->pot_clear)
 931                 return chip->info->ops->pot_clear(chip);
 932
 933         return 0;
 934 }
 935
 936 static int mv88e6xxx_rsvd2cpu_setup(struct mv88e6xxx_chip *chip)
 937 {
 938         if (chip->info->ops->mgmt_rsvd2cpu)
 939                 return chip->info->ops->mgmt_rsvd2cpu(chip);
 940
 941         return 0;
 942 }
 943
 944 static int mv88e6xxx_atu_setup(struct mv88e6xxx_chip *chip)
 945 {
 946         int err;
 947
 948         err = mv88e6xxx_g1_atu_flush(chip, 0, true);
 949         if (err)
 950                 return err;
 951
 952         err = mv88e6xxx_g1_atu_set_learn2all(chip, true);
 953         if (err)
 954                 return err;
 955
 956         return mv88e6xxx_g1_atu_set_age_time(chip, 300000);
 957 }
 958
 959 static int mv88e6xxx_irl_setup(struct mv88e6xxx_chip *chip)
 960 {
 961         int port;
 962         int err;
 963
 964         if (!chip->info->ops->irl_init_all)
 965                 return 0;
 966
 967         for (port = 0; port < mv88e6xxx_num_ports(chip); port++) {
 968                 /* Disable ingress rate limiting by resetting all per port
 969                  * ingress rate limit resources to their initial state.
 970                  */
 971                 err = chip->info->ops->irl_init_all(chip, port);
 972                 if (err)
 973                         return err;
 974         }
 975
 976         return 0;
 977 }
 978
 979 static int mv88e6xxx_pvt_map(struct mv88e6xxx_chip *chip, int dev, int port)
 980 {
 981         u16 pvlan = 0;
 982
 983         if (!mv88e6xxx_has_pvt(chip))
 984                 return -EOPNOTSUPP;
 985
 986         /* Skip the local source device, which uses in-chip port VLAN */
 987         if (dev != chip->ds->index)
 988                 pvlan = mv88e6xxx_port_vlan(chip, dev, port);
 989
 990         return mv88e6xxx_g2_pvt_write(chip, dev, port, pvlan);
 991 }
 992
 993 static int mv88e6xxx_pvt_setup(struct mv88e6xxx_chip *chip)
 994 {
 995         int dev, port;
 996         int err;
 997
 998         if (!mv88e6xxx_has_pvt(chip))
 999                 return 0;
1000
1001         /* Clear 5 Bit Port for usage with Marvell Link Street devices:
1002          * use 4 bits for the Src_Port/Src_Trunk and 5 bits for the Src_Dev.
1003          */
1004         err = mv88e6xxx_g2_misc_4_bit_port(chip);
1005         if (err)
1006                 return err;
1007
1008         for (dev = 0; dev < MV88E6XXX_MAX_PVT_SWITCHES; ++dev) {
1009                 for (port = 0; port < MV88E6XXX_MAX_PVT_PORTS; ++port) {
1010                         err = mv88e6xxx_pvt_map(chip, dev, port);
1011                         if (err)
1012                                 return err;
1013                 }
1014         }
1015
1016         return 0;
1017 }
1018
1019 static void mv88e6xxx_port_fast_age(struct dsa_switch *ds, int port)
1020 {
1021         struct mv88e6xxx_chip *chip = ds->priv;
1022         int err;
1023
1024         mutex_lock(&chip->reg_lock);
1025         err = mv88e6xxx_g1_atu_remove(chip, 0, port, false);
1026         mutex_unlock(&chip->reg_lock);
1027
1028         if (err)
1029                 dev_err(ds->dev, "p%d: failed to flush ATU\n", port);
1030 }
1031
1032 static int mv88e6xxx_vtu_setup(struct mv88e6xxx_chip *chip)
1033 {
1034         if (!chip->info->max_vid)
1035                 return 0;
1036
1037         return mv88e6xxx_g1_vtu_flush(chip);
1038 }
1039
1040 static int mv88e6xxx_vtu_getnext(struct mv88e6xxx_chip *chip,
1041                                  struct mv88e6xxx_vtu_entry *entry)
1042 {
1043         if (!chip->info->ops->vtu_getnext)
1044                 return -EOPNOTSUPP;
1045
1046         return chip->info->ops->vtu_getnext(chip, entry);
1047 }
1048
1049 static int mv88e6xxx_vtu_loadpurge(struct mv88e6xxx_chip *chip,
1050                                    struct mv88e6xxx_vtu_entry *entry)
1051 {
1052         if (!chip->info->ops->vtu_loadpurge)
1053                 return -EOPNOTSUPP;
1054
1055         return chip->info->ops->vtu_loadpurge(chip, entry);
1056 }
1057
1058 static int mv88e6xxx_port_vlan_dump(struct dsa_switch *ds, int port,
1059                                     struct switchdev_obj_port_vlan *vlan,
1060                                     switchdev_obj_dump_cb_t *cb)
1061 {
1062         struct mv88e6xxx_chip *chip = ds->priv;
1063         struct mv88e6xxx_vtu_entry next = {
1064                 .vid = chip->info->max_vid,
1065         };
1066         u16 pvid;
1067         int err;
1068
1069         if (!chip->info->max_vid)
1070                 return -EOPNOTSUPP;
1071
1072         mutex_lock(&chip->reg_lock);
1073
1074         err = mv88e6xxx_port_get_pvid(chip, port, &pvid);
1075         if (err)
1076                 goto unlock;
1077
1078         do {
1079                 err = mv88e6xxx_vtu_getnext(chip, &next);
1080                 if (err)
1081                         break;
1082
1083                 if (!next.valid)
1084                         break;
1085
1086                 if (next.member[port] ==
1087                     MV88E6XXX_G1_VTU_DATA_MEMBER_TAG_NON_MEMBER)
1088                         continue;
1089
1090                 /* reinit and dump this VLAN obj */
1091                 vlan->vid_begin = next.vid;
1092                 vlan->vid_end = next.vid;
1093                 vlan->flags = 0;
1094
1095                 if (next.member[port] ==
1096                     MV88E6XXX_G1_VTU_DATA_MEMBER_TAG_UNTAGGED)
1097                         vlan->flags |= BRIDGE_VLAN_INFO_UNTAGGED;
1098
1099                 if (next.vid == pvid)
1100                         vlan->flags |= BRIDGE_VLAN_INFO_PVID;
1101
1102                 err = cb(&vlan->obj);
1103                 if (err)
1104                         break;
1105         } while (next.vid < chip->info->max_vid);
1106
1107 unlock:
1108         mutex_unlock(&chip->reg_lock);
1109
1110         return err;
1111 }
1112
1113 static int mv88e6xxx_atu_new(struct mv88e6xxx_chip *chip, u16 *fid)
1114 {
1115         DECLARE_BITMAP(fid_bitmap, MV88E6XXX_N_FID);
1116         struct mv88e6xxx_vtu_entry vlan = {
1117                 .vid = chip->info->max_vid,
1118         };
1119         int i, err;
1120
1121         bitmap_zero(fid_bitmap, MV88E6XXX_N_FID);
1122
1123         /* Set every FID bit used by the (un)bridged ports */
1124         for (i = 0; i < mv88e6xxx_num_ports(chip); ++i) {
1125                 err = mv88e6xxx_port_get_fid(chip, i, fid);
1126                 if (err)
1127                         return err;
1128
1129                 set_bit(*fid, fid_bitmap);
1130         }
1131
1132         /* Set every FID bit used by the VLAN entries */
1133         do {
1134                 err = mv88e6xxx_vtu_getnext(chip, &vlan);
1135                 if (err)
1136                         return err;
1137
1138                 if (!vlan.valid)
1139                         break;
1140
1141                 set_bit(vlan.fid, fid_bitmap);
1142         } while (vlan.vid < chip->info->max_vid);
1143
1144         /* The reset value 0x000 is used to indicate that multiple address
1145          * databases are not needed. Return the next positive available.
1146          */
1147         *fid = find_next_zero_bit(fid_bitmap, MV88E6XXX_N_FID, 1);
1148         if (unlikely(*fid >= mv88e6xxx_num_databases(chip)))
1149                 return -ENOSPC;
1150
1151         /* Clear the database */
1152         return mv88e6xxx_g1_atu_flush(chip, *fid, true);
1153 }
1154
1155 static int mv88e6xxx_vtu_get(struct mv88e6xxx_chip *chip, u16 vid,
1156                              struct mv88e6xxx_vtu_entry *entry, bool new)
1157 {
1158         int err;
1159
1160         if (!vid)
1161                 return -EINVAL;
1162
1163         entry->vid = vid - 1;
1164         entry->valid = false;
1165
1166         err = mv88e6xxx_vtu_getnext(chip, entry);
1167         if (err)
1168                 return err;
1169
1170         if (entry->vid == vid && entry->valid)
1171                 return 0;
1172
1173         if (new) {
1174                 int i;
1175
1176                 /* Initialize a fresh VLAN entry */
1177                 memset(entry, 0, sizeof(*entry));
1178                 entry->valid = true;
1179                 entry->vid = vid;
1180
1181                 /* Exclude all ports */
1182                 for (i = 0; i < mv88e6xxx_num_ports(chip); ++i)
1183                         entry->member[i] =
1184                                 MV88E6XXX_G1_VTU_DATA_MEMBER_TAG_NON_MEMBER;
1185
1186                 return mv88e6xxx_atu_new(chip, &entry->fid);
1187         }
1188
1189         /* switchdev expects -EOPNOTSUPP to honor software VLANs */
1190         return -EOPNOTSUPP;
1191 }
1192
1193 static int mv88e6xxx_port_check_hw_vlan(struct dsa_switch *ds, int port,
1194                                         u16 vid_begin, u16 vid_end)
1195 {
1196         struct mv88e6xxx_chip *chip = ds->priv;
1197         struct mv88e6xxx_vtu_entry vlan = {
1198                 .vid = vid_begin - 1,
1199         };
1200         int i, err;
1201
1202         if (!vid_begin)
1203                 return -EOPNOTSUPP;
1204
1205         mutex_lock(&chip->reg_lock);
1206
1207         do {
1208                 err = mv88e6xxx_vtu_getnext(chip, &vlan);
1209                 if (err)
1210                         goto unlock;
1211
1212                 if (!vlan.valid)
1213                         break;
1214
1215                 if (vlan.vid > vid_end)
1216                         break;
1217
1218                 for (i = 0; i < mv88e6xxx_num_ports(chip); ++i) {
1219                         if (dsa_is_dsa_port(ds, i) || dsa_is_cpu_port(ds, i))
1220                                 continue;
1221
1222                         if (!ds->ports[port].netdev)
1223                                 continue;
1224
1225                         if (vlan.member[i] ==
1226                             MV88E6XXX_G1_VTU_DATA_MEMBER_TAG_NON_MEMBER)
1227                                 continue;
1228
1229                         if (ds->ports[i].bridge_dev ==
1230                             ds->ports[port].bridge_dev)
1231                                 break; /* same bridge, check next VLAN */
1232
1233                         if (!ds->ports[i].bridge_dev)
1234                                 continue;
1235
1236                         dev_err(ds->dev, "p%d: hw VLAN %d already used by %s\n",
1237                                 port, vlan.vid,
1238                                 netdev_name(ds->ports[i].bridge_dev));
1239                         err = -EOPNOTSUPP;
1240                         goto unlock;
1241                 }
1242         } while (vlan.vid < vid_end);
1243
1244 unlock:
1245         mutex_unlock(&chip->reg_lock);
1246
1247         return err;
1248 }
1249
1250 static int mv88e6xxx_port_vlan_filtering(struct dsa_switch *ds, int port,
1251                                          bool vlan_filtering)
1252 {
1253         struct mv88e6xxx_chip *chip = ds->priv;
1254         u16 mode = vlan_filtering ? MV88E6XXX_PORT_CTL2_8021Q_MODE_SECURE :
1255                 MV88E6XXX_PORT_CTL2_8021Q_MODE_DISABLED;
1256         int err;
1257
1258         if (!chip->info->max_vid)
1259                 return -EOPNOTSUPP;
1260
1261         mutex_lock(&chip->reg_lock);
1262         err = mv88e6xxx_port_set_8021q_mode(chip, port, mode);
1263         mutex_unlock(&chip->reg_lock);
1264
1265         return err;
1266 }
1267
1268 static int
1269 mv88e6xxx_port_vlan_prepare(struct dsa_switch *ds, int port,
1270                             const struct switchdev_obj_port_vlan *vlan,
1271                             struct switchdev_trans *trans)
1272 {
1273         struct mv88e6xxx_chip *chip = ds->priv;
1274         int err;
1275
1276         if (!chip->info->max_vid)
1277                 return -EOPNOTSUPP;
1278
1279         /* If the requested port doesn't belong to the same bridge as the VLAN
1280          * members, do not support it (yet) and fallback to software VLAN.
1281          */
1282         err = mv88e6xxx_port_check_hw_vlan(ds, port, vlan->vid_begin,
1283                                            vlan->vid_end);
1284         if (err)
1285                 return err;
1286
1287         /* We don't need any dynamic resource from the kernel (yet),
1288          * so skip the prepare phase.
1289          */
1290         return 0;
1291 }
1292
1293 static int _mv88e6xxx_port_vlan_add(struct mv88e6xxx_chip *chip, int port,
1294                                     u16 vid, u8 member)
1295 {
1296         struct mv88e6xxx_vtu_entry vlan;
1297         int err;
1298
1299         err = mv88e6xxx_vtu_get(chip, vid, &vlan, true);
1300         if (err)
1301                 return err;
1302
1303         vlan.member[port] = member;
1304
1305         return mv88e6xxx_vtu_loadpurge(chip, &vlan);
1306 }
1307
1308 static void mv88e6xxx_port_vlan_add(struct dsa_switch *ds, int port,
1309                                     const struct switchdev_obj_port_vlan *vlan,
1310                                     struct switchdev_trans *trans)
1311 {
1312         struct mv88e6xxx_chip *chip = ds->priv;
1313         bool untagged = vlan->flags & BRIDGE_VLAN_INFO_UNTAGGED;
1314         bool pvid = vlan->flags & BRIDGE_VLAN_INFO_PVID;
1315         u8 member;
1316         u16 vid;
1317
1318         if (!chip->info->max_vid)
1319                 return;
1320
1321         if (dsa_is_dsa_port(ds, port) || dsa_is_cpu_port(ds, port))
1322                 member = MV88E6XXX_G1_VTU_DATA_MEMBER_TAG_UNMODIFIED;
1323         else if (untagged)
1324                 member = MV88E6XXX_G1_VTU_DATA_MEMBER_TAG_UNTAGGED;
1325         else
1326                 member = MV88E6XXX_G1_VTU_DATA_MEMBER_TAG_TAGGED;
1327
1328         mutex_lock(&chip->reg_lock);
1329
1330         for (vid = vlan->vid_begin; vid <= vlan->vid_end; ++vid)
1331                 if (_mv88e6xxx_port_vlan_add(chip, port, vid, member))
1332                         dev_err(ds->dev, "p%d: failed to add VLAN %d%c\n", port,
1333                                 vid, untagged ? 'u' : 't');
1334
1335         if (pvid && mv88e6xxx_port_set_pvid(chip, port, vlan->vid_end))
1336                 dev_err(ds->dev, "p%d: failed to set PVID %d\n", port,
1337                         vlan->vid_end);
1338
1339         mutex_unlock(&chip->reg_lock);
1340 }
1341
1342 static int _mv88e6xxx_port_vlan_del(struct mv88e6xxx_chip *chip,
1343                                     int port, u16 vid)
1344 {
1345         struct mv88e6xxx_vtu_entry vlan;
1346         int i, err;
1347
1348         err = mv88e6xxx_vtu_get(chip, vid, &vlan, false);
1349         if (err)
1350                 return err;
1351
1352         /* Tell switchdev if this VLAN is handled in software */
1353         if (vlan.member[port] == MV88E6XXX_G1_VTU_DATA_MEMBER_TAG_NON_MEMBER)
1354                 return -EOPNOTSUPP;
1355
1356         vlan.member[port] = MV88E6XXX_G1_VTU_DATA_MEMBER_TAG_NON_MEMBER;
1357
1358         /* keep the VLAN unless all ports are excluded */
1359         vlan.valid = false;
1360         for (i = 0; i < mv88e6xxx_num_ports(chip); ++i) {
1361                 if (vlan.member[i] !=
1362                     MV88E6XXX_G1_VTU_DATA_MEMBER_TAG_NON_MEMBER) {
1363                         vlan.valid = true;
1364                         break;
1365                 }
1366         }
1367
1368         err = mv88e6xxx_vtu_loadpurge(chip, &vlan);
1369         if (err)
1370                 return err;
1371
1372         return mv88e6xxx_g1_atu_remove(chip, vlan.fid, port, false);
1373 }
1374
1375 static int mv88e6xxx_port_vlan_del(struct dsa_switch *ds, int port,
1376                                    const struct switchdev_obj_port_vlan *vlan)
1377 {
1378         struct mv88e6xxx_chip *chip = ds->priv;
1379         u16 pvid, vid;
1380         int err = 0;
1381
1382         if (!chip->info->max_vid)
1383                 return -EOPNOTSUPP;
1384
1385         mutex_lock(&chip->reg_lock);
1386
1387         err = mv88e6xxx_port_get_pvid(chip, port, &pvid);
1388         if (err)
1389                 goto unlock;
1390
1391         for (vid = vlan->vid_begin; vid <= vlan->vid_end; ++vid) {
1392                 err = _mv88e6xxx_port_vlan_del(chip, port, vid);
1393                 if (err)
1394                         goto unlock;
1395
1396                 if (vid == pvid) {
1397                         err = mv88e6xxx_port_set_pvid(chip, port, 0);
1398                         if (err)
1399                                 goto unlock;
1400                 }
1401         }
1402
1403 unlock:
1404         mutex_unlock(&chip->reg_lock);
1405
1406         return err;
1407 }
1408
1409 static int mv88e6xxx_port_db_load_purge(struct mv88e6xxx_chip *chip, int port,
1410                                         const unsigned char *addr, u16 vid,
1411                                         u8 state)
1412 {
1413         struct mv88e6xxx_vtu_entry vlan;
1414         struct mv88e6xxx_atu_entry entry;
1415         int err;
1416
1417         /* Null VLAN ID corresponds to the port private database */
1418         if (vid == 0)
1419                 err = mv88e6xxx_port_get_fid(chip, port, &vlan.fid);
1420         else
1421                 err = mv88e6xxx_vtu_get(chip, vid, &vlan, false);
1422         if (err)
1423                 return err;
1424
1425         entry.state = MV88E6XXX_G1_ATU_DATA_STATE_UNUSED;
1426         ether_addr_copy(entry.mac, addr);
1427         eth_addr_dec(entry.mac);
1428
1429         err = mv88e6xxx_g1_atu_getnext(chip, vlan.fid, &entry);
1430         if (err)
1431                 return err;
1432
1433         /* Initialize a fresh ATU entry if it isn't found */
1434         if (entry.state == MV88E6XXX_G1_ATU_DATA_STATE_UNUSED ||
1435             !ether_addr_equal(entry.mac, addr)) {
1436                 memset(&entry, 0, sizeof(entry));
1437                 ether_addr_copy(entry.mac, addr);
1438         }
1439
1440         /* Purge the ATU entry only if no port is using it anymore */
1441         if (state == MV88E6XXX_G1_ATU_DATA_STATE_UNUSED) {
1442                 entry.portvec &= ~BIT(port);
1443                 if (!entry.portvec)
1444                         entry.state = MV88E6XXX_G1_ATU_DATA_STATE_UNUSED;
1445         } else {
1446                 entry.portvec |= BIT(port);
1447                 entry.state = state;
1448         }
1449
1450         return mv88e6xxx_g1_atu_loadpurge(chip, vlan.fid, &entry);
1451 }
1452
1453 static int mv88e6xxx_port_fdb_prepare(struct dsa_switch *ds, int port,
1454                                       const struct switchdev_obj_port_fdb *fdb,
1455                                       struct switchdev_trans *trans)
1456 {
1457         /* We don't need any dynamic resource from the kernel (yet),
1458          * so skip the prepare phase.
1459          */
1460         return 0;
1461 }
1462
1463 static void mv88e6xxx_port_fdb_add(struct dsa_switch *ds, int port,
1464                                    const struct switchdev_obj_port_fdb *fdb,
1465                                    struct switchdev_trans *trans)
1466 {
1467         struct mv88e6xxx_chip *chip = ds->priv;
1468
1469         mutex_lock(&chip->reg_lock);
1470         if (mv88e6xxx_port_db_load_purge(chip, port, fdb->addr, fdb->vid,
1471                                          MV88E6XXX_G1_ATU_DATA_STATE_UC_STATIC))
1472                 dev_err(ds->dev, "p%d: failed to load unicast MAC address\n",
1473                         port);
1474         mutex_unlock(&chip->reg_lock);
1475 }
1476
1477 static int mv88e6xxx_port_fdb_del(struct dsa_switch *ds, int port,
1478                                   const struct switchdev_obj_port_fdb *fdb)
1479 {
1480         struct mv88e6xxx_chip *chip = ds->priv;
1481         int err;
1482
1483         mutex_lock(&chip->reg_lock);
1484         err = mv88e6xxx_port_db_load_purge(chip, port, fdb->addr, fdb->vid,
1485                                            MV88E6XXX_G1_ATU_DATA_STATE_UNUSED);
1486         mutex_unlock(&chip->reg_lock);
1487
1488         return err;
1489 }
1490
1491 static int mv88e6xxx_port_db_dump_fid(struct mv88e6xxx_chip *chip,
1492                                       u16 fid, u16 vid, int port,
1493                                       struct switchdev_obj *obj,
1494                                       switchdev_obj_dump_cb_t *cb)
1495 {
1496         struct mv88e6xxx_atu_entry addr;
1497         int err;
1498
1499         addr.state = MV88E6XXX_G1_ATU_DATA_STATE_UNUSED;
1500         eth_broadcast_addr(addr.mac);
1501
1502         do {
1503                 err = mv88e6xxx_g1_atu_getnext(chip, fid, &addr);
1504                 if (err)
1505                         return err;
1506
1507                 if (addr.state == MV88E6XXX_G1_ATU_DATA_STATE_UNUSED)
1508                         break;
1509
1510                 if (addr.trunk || (addr.portvec & BIT(port)) == 0)
1511                         continue;
1512
1513                 if (obj->id == SWITCHDEV_OBJ_ID_PORT_FDB) {
1514                         struct switchdev_obj_port_fdb *fdb;
1515
1516                         if (!is_unicast_ether_addr(addr.mac))
1517                                 continue;
1518
1519                         fdb = SWITCHDEV_OBJ_PORT_FDB(obj);
1520                         fdb->vid = vid;
1521                         ether_addr_copy(fdb->addr, addr.mac);
1522                         if (addr.state == MV88E6XXX_G1_ATU_DATA_STATE_UC_STATIC)
1523                                 fdb->ndm_state = NUD_NOARP;
1524                         else
1525                                 fdb->ndm_state = NUD_REACHABLE;
1526                 } else if (obj->id == SWITCHDEV_OBJ_ID_PORT_MDB) {
1527                         struct switchdev_obj_port_mdb *mdb;
1528
1529                         if (!is_multicast_ether_addr(addr.mac))
1530                                 continue;
1531
1532                         mdb = SWITCHDEV_OBJ_PORT_MDB(obj);
1533                         mdb->vid = vid;
1534                         ether_addr_copy(mdb->addr, addr.mac);
1535                 } else {
1536                         return -EOPNOTSUPP;
1537                 }
1538
1539                 err = cb(obj);
1540                 if (err)
1541                         return err;
1542         } while (!is_broadcast_ether_addr(addr.mac));
1543
1544         return err;
1545 }
1546
1547 static int mv88e6xxx_port_db_dump(struct mv88e6xxx_chip *chip, int port,
1548                                   struct switchdev_obj *obj,
1549                                   switchdev_obj_dump_cb_t *cb)
1550 {
1551         struct mv88e6xxx_vtu_entry vlan = {
1552                 .vid = chip->info->max_vid,
1553         };
1554         u16 fid;
1555         int err;
1556
1557         /* Dump port's default Filtering Information Database (VLAN ID 0) */
1558         err = mv88e6xxx_port_get_fid(chip, port, &fid);
1559         if (err)
1560                 return err;
1561
1562         err = mv88e6xxx_port_db_dump_fid(chip, fid, 0, port, obj, cb);
1563         if (err)
1564                 return err;
1565
1566         /* Dump VLANs' Filtering Information Databases */
1567         do {
1568                 err = mv88e6xxx_vtu_getnext(chip, &vlan);
1569                 if (err)
1570                         return err;
1571
1572                 if (!vlan.valid)
1573                         break;
1574
1575                 err = mv88e6xxx_port_db_dump_fid(chip, vlan.fid, vlan.vid, port,
1576                                                  obj, cb);
1577                 if (err)
1578                         return err;
1579         } while (vlan.vid < chip->info->max_vid);
1580
1581         return err;
1582 }
1583
1584 static int mv88e6xxx_port_fdb_dump(struct dsa_switch *ds, int port,
1585                                    struct switchdev_obj_port_fdb *fdb,
1586                                    switchdev_obj_dump_cb_t *cb)
1587 {
1588         struct mv88e6xxx_chip *chip = ds->priv;
1589         int err;
1590
1591         mutex_lock(&chip->reg_lock);
1592         err = mv88e6xxx_port_db_dump(chip, port, &fdb->obj, cb);
1593         mutex_unlock(&chip->reg_lock);
1594
1595         return err;
1596 }
1597
1598 static int mv88e6xxx_bridge_map(struct mv88e6xxx_chip *chip,
1599                                 struct net_device *br)
1600 {
1601         struct dsa_switch *ds;
1602         int port;
1603         int dev;
1604         int err;
1605
1606         /* Remap the Port VLAN of each local bridge group member */
1607         for (port = 0; port < mv88e6xxx_num_ports(chip); ++port) {
1608                 if (chip->ds->ports[port].bridge_dev == br) {
1609                         err = mv88e6xxx_port_vlan_map(chip, port);
1610                         if (err)
1611                                 return err;
1612                 }
1613         }
1614
1615         if (!mv88e6xxx_has_pvt(chip))
1616                 return 0;
1617
1618         /* Remap the Port VLAN of each cross-chip bridge group member */
1619         for (dev = 0; dev < DSA_MAX_SWITCHES; ++dev) {
1620                 ds = chip->ds->dst->ds[dev];
1621                 if (!ds)
1622                         break;
1623
1624                 for (port = 0; port < ds->num_ports; ++port) {
1625                         if (ds->ports[port].bridge_dev == br) {
1626                                 err = mv88e6xxx_pvt_map(chip, dev, port);
1627                                 if (err)
1628                                         return err;
1629                         }
1630                 }
1631         }
1632
1633         return 0;
1634 }
1635
1636 static int mv88e6xxx_port_bridge_join(struct dsa_switch *ds, int port,
1637                                       struct net_device *br)
1638 {
1639         struct mv88e6xxx_chip *chip = ds->priv;
1640         int err;
1641
1642         mutex_lock(&chip->reg_lock);
1643         err = mv88e6xxx_bridge_map(chip, br);
1644         mutex_unlock(&chip->reg_lock);
1645
1646         return err;
1647 }
1648
1649 static void mv88e6xxx_port_bridge_leave(struct dsa_switch *ds, int port,
1650                                         struct net_device *br)
1651 {
1652         struct mv88e6xxx_chip *chip = ds->priv;
1653
1654         mutex_lock(&chip->reg_lock);
1655         if (mv88e6xxx_bridge_map(chip, br) ||
1656             mv88e6xxx_port_vlan_map(chip, port))
1657                 dev_err(ds->dev, "failed to remap in-chip Port VLAN\n");
1658         mutex_unlock(&chip->reg_lock);
1659 }
1660
1661 static int mv88e6xxx_crosschip_bridge_join(struct dsa_switch *ds, int dev,
1662                                            int port, struct net_device *br)
1663 {
1664         struct mv88e6xxx_chip *chip = ds->priv;
1665         int err;
1666
1667         if (!mv88e6xxx_has_pvt(chip))
1668                 return 0;
1669
1670         mutex_lock(&chip->reg_lock);
1671         err = mv88e6xxx_pvt_map(chip, dev, port);
1672         mutex_unlock(&chip->reg_lock);
1673
1674         return err;
1675 }
1676
1677 static void mv88e6xxx_crosschip_bridge_leave(struct dsa_switch *ds, int dev,
1678                                              int port, struct net_device *br)
1679 {
1680         struct mv88e6xxx_chip *chip = ds->priv;
1681
1682         if (!mv88e6xxx_has_pvt(chip))
1683                 return;
1684
1685         mutex_lock(&chip->reg_lock);
1686         if (mv88e6xxx_pvt_map(chip, dev, port))
1687                 dev_err(ds->dev, "failed to remap cross-chip Port VLAN\n");
1688         mutex_unlock(&chip->reg_lock);
1689 }
1690
1691 static int mv88e6xxx_software_reset(struct mv88e6xxx_chip *chip)
1692 {
1693         if (chip->info->ops->reset)
1694                 return chip->info->ops->reset(chip);
1695
1696         return 0;
1697 }
1698
1699 static void mv88e6xxx_hardware_reset(struct mv88e6xxx_chip *chip)
1700 {
1701         struct gpio_desc *gpiod = chip->reset;
1702
1703         /* If there is a GPIO connected to the reset pin, toggle it */
1704         if (gpiod) {
1705                 gpiod_set_value_cansleep(gpiod, 1);
1706                 usleep_range(10000, 20000);
1707                 gpiod_set_value_cansleep(gpiod, 0);
1708                 usleep_range(10000, 20000);
1709         }
1710 }
1711
1712 static int mv88e6xxx_disable_ports(struct mv88e6xxx_chip *chip)
1713 {
1714         int i, err;
1715
1716         /* Set all ports to the Disabled state */
1717         for (i = 0; i < mv88e6xxx_num_ports(chip); i++) {
1718                 err = mv88e6xxx_port_set_state(chip, i, BR_STATE_DISABLED);
1719                 if (err)
1720                         return err;
1721         }
1722
1723         /* Wait for transmit queues to drain,
1724          * i.e. 2ms for a maximum frame to be transmitted at 10 Mbps.
1725          */
1726         usleep_range(2000, 4000);
1727
1728         return 0;
1729 }
1730
1731 static int mv88e6xxx_switch_reset(struct mv88e6xxx_chip *chip)
1732 {
1733         int err;
1734
1735         err = mv88e6xxx_disable_ports(chip);
1736         if (err)
1737                 return err;
1738
1739         mv88e6xxx_hardware_reset(chip);
1740
1741         return mv88e6xxx_software_reset(chip);
1742 }
1743
1744 static int mv88e6xxx_set_port_mode(struct mv88e6xxx_chip *chip, int port,
1745                                    enum mv88e6xxx_frame_mode frame,
1746                                    enum mv88e6xxx_egress_mode egress, u16 etype)
1747 {
1748         int err;
1749
1750         if (!chip->info->ops->port_set_frame_mode)
1751                 return -EOPNOTSUPP;
1752
1753         err = mv88e6xxx_port_set_egress_mode(chip, port, egress);
1754         if (err)
1755                 return err;
1756
1757         err = chip->info->ops->port_set_frame_mode(chip, port, frame);
1758         if (err)
1759                 return err;
1760
1761         if (chip->info->ops->port_set_ether_type)
1762                 return chip->info->ops->port_set_ether_type(chip, port, etype);
1763
1764         return 0;
1765 }
1766
1767 static int mv88e6xxx_set_port_mode_normal(struct mv88e6xxx_chip *chip, int port)
1768 {
1769         return mv88e6xxx_set_port_mode(chip, port, MV88E6XXX_FRAME_MODE_NORMAL,
1770                                        MV88E6XXX_EGRESS_MODE_UNMODIFIED,
1771                                        MV88E6XXX_PORT_ETH_TYPE_DEFAULT);
1772 }
1773
1774 static int mv88e6xxx_set_port_mode_dsa(struct mv88e6xxx_chip *chip, int port)
1775 {
1776         return mv88e6xxx_set_port_mode(chip, port, MV88E6XXX_FRAME_MODE_DSA,
1777                                        MV88E6XXX_EGRESS_MODE_UNMODIFIED,
1778                                        MV88E6XXX_PORT_ETH_TYPE_DEFAULT);
1779 }
1780
1781 static int mv88e6xxx_set_port_mode_edsa(struct mv88e6xxx_chip *chip, int port)
1782 {
1783         return mv88e6xxx_set_port_mode(chip, port,
1784                                        MV88E6XXX_FRAME_MODE_ETHERTYPE,
1785                                        MV88E6XXX_EGRESS_MODE_ETHERTYPE,
1786                                        ETH_P_EDSA);
1787 }
1788
1789 static int mv88e6xxx_setup_port_mode(struct mv88e6xxx_chip *chip, int port)
1790 {
1791         if (dsa_is_dsa_port(chip->ds, port))
1792                 return mv88e6xxx_set_port_mode_dsa(chip, port);
1793
1794         if (dsa_is_normal_port(chip->ds, port))
1795                 return mv88e6xxx_set_port_mode_normal(chip, port);
1796
1797         /* Setup CPU port mode depending on its supported tag format */
1798         if (chip->info->tag_protocol == DSA_TAG_PROTO_DSA)
1799                 return mv88e6xxx_set_port_mode_dsa(chip, port);
1800
1801         if (chip->info->tag_protocol == DSA_TAG_PROTO_EDSA)
1802                 return mv88e6xxx_set_port_mode_edsa(chip, port);
1803
1804         return -EINVAL;
1805 }
1806
1807 static int mv88e6xxx_setup_message_port(struct mv88e6xxx_chip *chip, int port)
1808 {
1809         bool message = dsa_is_dsa_port(chip->ds, port);
1810
1811         return mv88e6xxx_port_set_message_port(chip, port, message);
1812 }
1813
1814 static int mv88e6xxx_setup_egress_floods(struct mv88e6xxx_chip *chip, int port)
1815 {
1816         bool flood = port == dsa_upstream_port(chip->ds);
1817
1818         /* Upstream ports flood frames with unknown unicast or multicast DA */
1819         if (chip->info->ops->port_set_egress_floods)
1820                 return chip->info->ops->port_set_egress_floods(chip, port,
1821                                                                flood, flood);
1822
1823         return 0;
1824 }
1825
1826 static int mv88e6xxx_serdes_power(struct mv88e6xxx_chip *chip, int port,
1827                                   bool on)
1828 {
1829         if (chip->info->ops->serdes_power)
1830                 return chip->info->ops->serdes_power(chip, port, on);
1831
1832         return 0;
1833 }
1834
1835 static int mv88e6xxx_setup_port(struct mv88e6xxx_chip *chip, int port)
1836 {
1837         struct dsa_switch *ds = chip->ds;
1838         int err;
1839         u16 reg;
1840
1841         /* MAC Forcing register: don't force link, speed, duplex or flow control
1842          * state to any particular values on physical ports, but force the CPU
1843          * port and all DSA ports to their maximum bandwidth and full duplex.
1844          */
1845         if (dsa_is_cpu_port(ds, port) || dsa_is_dsa_port(ds, port))
1846                 err = mv88e6xxx_port_setup_mac(chip, port, LINK_FORCED_UP,
1847                                                SPEED_MAX, DUPLEX_FULL,
1848                                                PHY_INTERFACE_MODE_NA);
1849         else
1850                 err = mv88e6xxx_port_setup_mac(chip, port, LINK_UNFORCED,
1851                                                SPEED_UNFORCED, DUPLEX_UNFORCED,
1852                                                PHY_INTERFACE_MODE_NA);
1853         if (err)
1854                 return err;
1855
1856         /* Port Control: disable Drop-on-Unlock, disable Drop-on-Lock,
1857          * disable Header mode, enable IGMP/MLD snooping, disable VLAN
1858          * tunneling, determine priority by looking at 802.1p and IP
1859          * priority fields (IP prio has precedence), and set STP state
1860          * to Forwarding.
1861          *
1862          * If this is the CPU link, use DSA or EDSA tagging depending
1863          * on which tagging mode was configured.
1864          *
1865          * If this is a link to another switch, use DSA tagging mode.
1866          *
1867          * If this is the upstream port for this switch, enable
1868          * forwarding of unknown unicasts and multicasts.
1869          */
1870         reg = MV88E6XXX_PORT_CTL0_IGMP_MLD_SNOOP |
1871                 MV88E6185_PORT_CTL0_USE_TAG | MV88E6185_PORT_CTL0_USE_IP |
1872                 MV88E6XXX_PORT_CTL0_STATE_FORWARDING;
1873         err = mv88e6xxx_port_write(chip, port, MV88E6XXX_PORT_CTL0, reg);
1874         if (err)
1875                 return err;
1876
1877         err = mv88e6xxx_setup_port_mode(chip, port);
1878         if (err)
1879                 return err;
1880
1881         err = mv88e6xxx_setup_egress_floods(chip, port);
1882         if (err)
1883                 return err;
1884
1885         /* Enable the SERDES interface for DSA and CPU ports. Normal
1886          * ports SERDES are enabled when the port is enabled, thus
1887          * saving a bit of power.
1888          */
1889         if ((dsa_is_cpu_port(ds, port) || dsa_is_dsa_port(ds, port))) {
1890                 err = mv88e6xxx_serdes_power(chip, port, true);
1891                 if (err)
1892                         return err;
1893         }
1894
1895         /* Port Control 2: don't force a good FCS, set the maximum frame size to
1896          * 10240 bytes, disable 802.1q tags checking, don't discard tagged or
1897          * untagged frames on this port, do a destination address lookup on all
1898          * received packets as usual, disable ARP mirroring and don't send a
1899          * copy of all transmitted/received frames on this port to the CPU.
1900          */
1901         err = mv88e6xxx_port_set_map_da(chip, port);
1902         if (err)
1903                 return err;
1904
1905         reg = 0;
1906         if (chip->info->ops->port_set_upstream_port) {
1907                 err = chip->info->ops->port_set_upstream_port(
1908                         chip, port, dsa_upstream_port(ds));
1909                 if (err)
1910                         return err;
1911         }
1912
1913         err = mv88e6xxx_port_set_8021q_mode(chip, port,
1914                                 MV88E6XXX_PORT_CTL2_8021Q_MODE_DISABLED);
1915         if (err)
1916                 return err;
1917
1918         if (chip->info->ops->port_set_jumbo_size) {
1919                 err = chip->info->ops->port_set_jumbo_size(chip, port, 10240);
1920                 if (err)
1921                         return err;
1922         }
1923
1924         /* Port Association Vector: when learning source addresses
1925          * of packets, add the address to the address database using
1926          * a port bitmap that has only the bit for this port set and
1927          * the other bits clear.
1928          */
1929         reg = 1 << port;
1930         /* Disable learning for CPU port */
1931         if (dsa_is_cpu_port(ds, port))
1932                 reg = 0;
1933
1934         err = mv88e6xxx_port_write(chip, port, MV88E6XXX_PORT_ASSOC_VECTOR,
1935                                    reg);
1936         if (err)
1937                 return err;
1938
1939         /* Egress rate control 2: disable egress rate control. */
1940         err = mv88e6xxx_port_write(chip, port, MV88E6XXX_PORT_EGRESS_RATE_CTL2,
1941                                    0x0000);
1942         if (err)
1943                 return err;
1944
1945         if (chip->info->ops->port_pause_limit) {
1946                 err = chip->info->ops->port_pause_limit(chip, port, 0, 0);
1947                 if (err)
1948                         return err;
1949         }
1950
1951         if (chip->info->ops->port_disable_learn_limit) {
1952                 err = chip->info->ops->port_disable_learn_limit(chip, port);
1953                 if (err)
1954                         return err;
1955         }
1956
1957         if (chip->info->ops->port_disable_pri_override) {
1958                 err = chip->info->ops->port_disable_pri_override(chip, port);
1959                 if (err)
1960                         return err;
1961         }
1962
1963         if (chip->info->ops->port_tag_remap) {
1964                 err = chip->info->ops->port_tag_remap(chip, port);
1965                 if (err)
1966                         return err;
1967         }
1968
1969         if (chip->info->ops->port_egress_rate_limiting) {
1970                 err = chip->info->ops->port_egress_rate_limiting(chip, port);
1971                 if (err)
1972                         return err;
1973         }
1974
1975         err = mv88e6xxx_setup_message_port(chip, port);
1976         if (err)
1977                 return err;
1978
1979         /* Port based VLAN map: give each port the same default address
1980          * database, and allow bidirectional communication between the
1981          * CPU and DSA port(s), and the other ports.
1982          */
1983         err = mv88e6xxx_port_set_fid(chip, port, 0);
1984         if (err)
1985                 return err;
1986
1987         err = mv88e6xxx_port_vlan_map(chip, port);
1988         if (err)
1989                 return err;
1990
1991         /* Default VLAN ID and priority: don't set a default VLAN
1992          * ID, and set the default packet priority to zero.
1993          */
1994         return mv88e6xxx_port_write(chip, port, MV88E6XXX_PORT_DEFAULT_VLAN, 0);
1995 }
1996
1997 static int mv88e6xxx_port_enable(struct dsa_switch *ds, int port,
1998                                  struct phy_device *phydev)
1999 {
2000         struct mv88e6xxx_chip *chip = ds->priv;
2001         int err;
2002
2003         mutex_lock(&chip->reg_lock);
2004         err = mv88e6xxx_serdes_power(chip, port, true);
2005         mutex_unlock(&chip->reg_lock);
2006
2007         return err;
2008 }
2009
2010 static void mv88e6xxx_port_disable(struct dsa_switch *ds, int port,
2011                                    struct phy_device *phydev)
2012 {
2013         struct mv88e6xxx_chip *chip = ds->priv;
2014
2015         mutex_lock(&chip->reg_lock);
2016         if (mv88e6xxx_serdes_power(chip, port, false))
2017                 dev_err(chip->dev, "failed to power off SERDES\n");
2018         mutex_unlock(&chip->reg_lock);
2019 }
2020
2021 static int mv88e6xxx_set_ageing_time(struct dsa_switch *ds,
2022                                      unsigned int ageing_time)
2023 {
2024         struct mv88e6xxx_chip *chip = ds->priv;
2025         int err;
2026
2027         mutex_lock(&chip->reg_lock);
2028         err = mv88e6xxx_g1_atu_set_age_time(chip, ageing_time);
2029         mutex_unlock(&chip->reg_lock);
2030
2031         return err;
2032 }
2033
2034 static int mv88e6xxx_g1_setup(struct mv88e6xxx_chip *chip)
2035 {
2036         struct dsa_switch *ds = chip->ds;
2037         u32 upstream_port = dsa_upstream_port(ds);
2038         int err;
2039
2040         if (chip->info->ops->set_cpu_port) {
2041                 err = chip->info->ops->set_cpu_port(chip, upstream_port);
2042                 if (err)
2043                         return err;
2044         }
2045
2046         if (chip->info->ops->set_egress_port) {
2047                 err = chip->info->ops->set_egress_port(chip, upstream_port);
2048                 if (err)
2049                         return err;
2050         }
2051
2052         /* Disable remote management, and set the switch's DSA device number. */
2053         err = mv88e6xxx_g1_write(chip, MV88E6XXX_G1_CTL2,
2054                                  MV88E6XXX_G1_CTL2_MULTIPLE_CASCADE |
2055                                  (ds->index & 0x1f));
2056         if (err)
2057                 return err;
2058
2059         /* Configure the IP ToS mapping registers. */
2060         err = mv88e6xxx_g1_write(chip, MV88E6XXX_G1_IP_PRI_0, 0x0000);
2061         if (err)
2062                 return err;
2063         err = mv88e6xxx_g1_write(chip, MV88E6XXX_G1_IP_PRI_1, 0x0000);
2064         if (err)
2065                 return err;
2066         err = mv88e6xxx_g1_write(chip, MV88E6XXX_G1_IP_PRI_2, 0x5555);
2067         if (err)
2068                 return err;
2069         err = mv88e6xxx_g1_write(chip, MV88E6XXX_G1_IP_PRI_3, 0x5555);
2070         if (err)
2071                 return err;
2072         err = mv88e6xxx_g1_write(chip, MV88E6XXX_G1_IP_PRI_4, 0xaaaa);
2073         if (err)
2074                 return err;
2075         err = mv88e6xxx_g1_write(chip, MV88E6XXX_G1_IP_PRI_5, 0xaaaa);
2076         if (err)
2077                 return err;
2078         err = mv88e6xxx_g1_write(chip, MV88E6XXX_G1_IP_PRI_6, 0xffff);
2079         if (err)
2080                 return err;
2081         err = mv88e6xxx_g1_write(chip, MV88E6XXX_G1_IP_PRI_7, 0xffff);
2082         if (err)
2083                 return err;
2084
2085         /* Configure the IEEE 802.1p priority mapping register. */
2086         err = mv88e6xxx_g1_write(chip, MV88E6XXX_G1_IEEE_PRI, 0xfa41);
2087         if (err)
2088                 return err;
2089
2090         /* Initialize the statistics unit */
2091         err = mv88e6xxx_stats_set_histogram(chip);
2092         if (err)
2093                 return err;
2094
2095         /* Clear the statistics counters for all ports */
2096         err = mv88e6xxx_g1_write(chip, MV88E6XXX_G1_STATS_OP,
2097                                  MV88E6XXX_G1_STATS_OP_BUSY |
2098                                  MV88E6XXX_G1_STATS_OP_FLUSH_ALL);
2099         if (err)
2100                 return err;
2101
2102         /* Wait for the flush to complete. */
2103         err = mv88e6xxx_g1_stats_wait(chip);
2104         if (err)
2105                 return err;
2106
2107         return 0;
2108 }
2109
2110 static int mv88e6xxx_setup(struct dsa_switch *ds)
2111 {
2112         struct mv88e6xxx_chip *chip = ds->priv;
2113         int err;
2114         int i;
2115
2116         chip->ds = ds;
2117         ds->slave_mii_bus = mv88e6xxx_default_mdio_bus(chip);
2118
2119         mutex_lock(&chip->reg_lock);
2120
2121         /* Setup Switch Port Registers */
2122         for (i = 0; i < mv88e6xxx_num_ports(chip); i++) {
2123                 err = mv88e6xxx_setup_port(chip, i);
2124                 if (err)
2125                         goto unlock;
2126         }
2127
2128         /* Setup Switch Global 1 Registers */
2129         err = mv88e6xxx_g1_setup(chip);
2130         if (err)
2131                 goto unlock;
2132
2133         /* Setup Switch Global 2 Registers */
2134         if (chip->info->global2_addr) {
2135                 err = mv88e6xxx_g2_setup(chip);
2136                 if (err)
2137                         goto unlock;
2138         }
2139
2140         err = mv88e6xxx_irl_setup(chip);
2141         if (err)
2142                 goto unlock;
2143
2144         err = mv88e6xxx_phy_setup(chip);
2145         if (err)
2146                 goto unlock;
2147
2148         err = mv88e6xxx_vtu_setup(chip);
2149         if (err)
2150                 goto unlock;
2151
2152         err = mv88e6xxx_pvt_setup(chip);
2153         if (err)
2154                 goto unlock;
2155
2156         err = mv88e6xxx_atu_setup(chip);
2157         if (err)
2158                 goto unlock;
2159
2160         err = mv88e6xxx_pot_setup(chip);
2161         if (err)
2162                 goto unlock;
2163
2164         err = mv88e6xxx_rsvd2cpu_setup(chip);
2165         if (err)
2166                 goto unlock;
2167
2168 unlock:
2169         mutex_unlock(&chip->reg_lock);
2170
2171         return err;
2172 }
2173
2174 static int mv88e6xxx_set_addr(struct dsa_switch *ds, u8 *addr)
2175 {
2176         struct mv88e6xxx_chip *chip = ds->priv;
2177         int err;
2178
2179         if (!chip->info->ops->set_switch_mac)
2180                 return -EOPNOTSUPP;
2181
2182         mutex_lock(&chip->reg_lock);
2183         err = chip->info->ops->set_switch_mac(chip, addr);
2184         mutex_unlock(&chip->reg_lock);
2185
2186         return err;
2187 }
2188
2189 static int mv88e6xxx_mdio_read(struct mii_bus *bus, int phy, int reg)
2190 {
2191         struct mv88e6xxx_mdio_bus *mdio_bus = bus->priv;
2192         struct mv88e6xxx_chip *chip = mdio_bus->chip;
2193         u16 val;
2194         int err;
2195
2196         if (!chip->info->ops->phy_read)
2197                 return -EOPNOTSUPP;
2198
2199         mutex_lock(&chip->reg_lock);
2200         err = chip->info->ops->phy_read(chip, bus, phy, reg, &val);
2201         mutex_unlock(&chip->reg_lock);
2202
2203         if (reg == MII_PHYSID2) {
2204                 /* Some internal PHYS don't have a model number.  Use
2205                  * the mv88e6390 family model number instead.
2206                  */
2207                 if (!(val & 0x3f0))
2208                         val |= MV88E6XXX_PORT_SWITCH_ID_PROD_6390 >> 4;
2209         }
2210
2211         return err ? err : val;
2212 }
2213
2214 static int mv88e6xxx_mdio_write(struct mii_bus *bus, int phy, int reg, u16 val)
2215 {
2216         struct mv88e6xxx_mdio_bus *mdio_bus = bus->priv;
2217         struct mv88e6xxx_chip *chip = mdio_bus->chip;
2218         int err;
2219
2220         if (!chip->info->ops->phy_write)
2221                 return -EOPNOTSUPP;
2222
2223         mutex_lock(&chip->reg_lock);
2224         err = chip->info->ops->phy_write(chip, bus, phy, reg, val);
2225         mutex_unlock(&chip->reg_lock);
2226
2227         return err;
2228 }
2229
2230 static int mv88e6xxx_mdio_register(struct mv88e6xxx_chip *chip,
2231                                    struct device_node *np,
2232                                    bool external)
2233 {
2234         static int index;
2235         struct mv88e6xxx_mdio_bus *mdio_bus;
2236         struct mii_bus *bus;
2237         int err;
2238
2239         bus = devm_mdiobus_alloc_size(chip->dev, sizeof(*mdio_bus));
2240         if (!bus)
2241                 return -ENOMEM;
2242
2243         mdio_bus = bus->priv;
2244         mdio_bus->bus = bus;
2245         mdio_bus->chip = chip;
2246         INIT_LIST_HEAD(&mdio_bus->list);
2247         mdio_bus->external = external;
2248
2249         if (np) {
2250                 bus->name = np->full_name;
2251                 snprintf(bus->id, MII_BUS_ID_SIZE, "%pOF", np);
2252         } else {
2253                 bus->name = "mv88e6xxx SMI";
2254                 snprintf(bus->id, MII_BUS_ID_SIZE, "mv88e6xxx-%d", index++);
2255         }
2256
2257         bus->read = mv88e6xxx_mdio_read;
2258         bus->write = mv88e6xxx_mdio_write;
2259         bus->parent = chip->dev;
2260
2261         if (np)
2262                 err = of_mdiobus_register(bus, np);
2263         else
2264                 err = mdiobus_register(bus);
2265         if (err) {
2266                 dev_err(chip->dev, "Cannot register MDIO bus (%d)\n", err);
2267                 return err;
2268         }
2269
2270         if (external)
2271                 list_add_tail(&mdio_bus->list, &chip->mdios);
2272         else
2273                 list_add(&mdio_bus->list, &chip->mdios);
2274
2275         return 0;
2276 }
2277
2278 static const struct of_device_id mv88e6xxx_mdio_external_match[] = {
2279         { .compatible = "marvell,mv88e6xxx-mdio-external",
2280           .data = (void *)true },
2281         { },
2282 };
2283
2284 static int mv88e6xxx_mdios_register(struct mv88e6xxx_chip *chip,
2285                                     struct device_node *np)
2286 {
2287         const struct of_device_id *match;
2288         struct device_node *child;
2289         int err;
2290
2291         /* Always register one mdio bus for the internal/default mdio
2292          * bus. This maybe represented in the device tree, but is
2293          * optional.
2294          */
2295         child = of_get_child_by_name(np, "mdio");
2296         err = mv88e6xxx_mdio_register(chip, child, false);
2297         if (err)
2298                 return err;
2299
2300         /* Walk the device tree, and see if there are any other nodes
2301          * which say they are compatible with the external mdio
2302          * bus.
2303          */
2304         for_each_available_child_of_node(np, child) {
2305                 match = of_match_node(mv88e6xxx_mdio_external_match, child);
2306                 if (match) {
2307                         err = mv88e6xxx_mdio_register(chip, child, true);
2308                         if (err)
2309                                 return err;
2310                 }
2311         }
2312
2313         return 0;
2314 }
2315
2316 static void mv88e6xxx_mdios_unregister(struct mv88e6xxx_chip *chip)
2317
2318 {
2319         struct mv88e6xxx_mdio_bus *mdio_bus;
2320         struct mii_bus *bus;
2321
2322         list_for_each_entry(mdio_bus, &chip->mdios, list) {
2323                 bus = mdio_bus->bus;
2324
2325                 mdiobus_unregister(bus);
2326         }
2327 }
2328
2329 static int mv88e6xxx_get_eeprom_len(struct dsa_switch *ds)
2330 {
2331         struct mv88e6xxx_chip *chip = ds->priv;
2332
2333         return chip->eeprom_len;
2334 }
2335
2336 static int mv88e6xxx_get_eeprom(struct dsa_switch *ds,
2337                                 struct ethtool_eeprom *eeprom, u8 *data)
2338 {
2339         struct mv88e6xxx_chip *chip = ds->priv;
2340         int err;
2341
2342         if (!chip->info->ops->get_eeprom)
2343                 return -EOPNOTSUPP;
2344
2345         mutex_lock(&chip->reg_lock);
2346         err = chip->info->ops->get_eeprom(chip, eeprom, data);
2347         mutex_unlock(&chip->reg_lock);
2348
2349         if (err)
2350                 return err;
2351
2352         eeprom->magic = 0xc3ec4951;
2353
2354         return 0;
2355 }
2356
2357 static int mv88e6xxx_set_eeprom(struct dsa_switch *ds,
2358                                 struct ethtool_eeprom *eeprom, u8 *data)
2359 {
2360         struct mv88e6xxx_chip *chip = ds->priv;
2361         int err;
2362
2363         if (!chip->info->ops->set_eeprom)
2364                 return -EOPNOTSUPP;
2365
2366         if (eeprom->magic != 0xc3ec4951)
2367                 return -EINVAL;
2368
2369         mutex_lock(&chip->reg_lock);
2370         err = chip->info->ops->set_eeprom(chip, eeprom, data);
2371         mutex_unlock(&chip->reg_lock);
2372
2373         return err;
2374 }
2375
2376 static const struct mv88e6xxx_ops mv88e6085_ops = {
2377         /* MV88E6XXX_FAMILY_6097 */
2378         .irl_init_all = mv88e6352_g2_irl_init_all,
2379         .set_switch_mac = mv88e6xxx_g1_set_switch_mac,
2380         .phy_read = mv88e6185_phy_ppu_read,
2381         .phy_write = mv88e6185_phy_ppu_write,
2382         .port_set_link = mv88e6xxx_port_set_link,
2383         .port_set_duplex = mv88e6xxx_port_set_duplex,
2384         .port_set_speed = mv88e6185_port_set_speed,
2385         .port_tag_remap = mv88e6095_port_tag_remap,
2386         .port_set_frame_mode = mv88e6351_port_set_frame_mode,
2387         .port_set_egress_floods = mv88e6352_port_set_egress_floods,
2388         .port_set_ether_type = mv88e6351_port_set_ether_type,
2389         .port_egress_rate_limiting = mv88e6097_port_egress_rate_limiting,
2390         .port_pause_limit = mv88e6097_port_pause_limit,
2391         .port_disable_learn_limit = mv88e6xxx_port_disable_learn_limit,
2392         .port_disable_pri_override = mv88e6xxx_port_disable_pri_override,
2393         .stats_snapshot = mv88e6xxx_g1_stats_snapshot,
2394         .stats_get_sset_count = mv88e6095_stats_get_sset_count,
2395         .stats_get_strings = mv88e6095_stats_get_strings,
2396         .stats_get_stats = mv88e6095_stats_get_stats,
2397         .set_cpu_port = mv88e6095_g1_set_cpu_port,
2398         .set_egress_port = mv88e6095_g1_set_egress_port,
2399         .watchdog_ops = &mv88e6097_watchdog_ops,
2400         .mgmt_rsvd2cpu = mv88e6352_g2_mgmt_rsvd2cpu,
2401         .pot_clear = mv88e6xxx_g2_pot_clear,
2402         .ppu_enable = mv88e6185_g1_ppu_enable,
2403         .ppu_disable = mv88e6185_g1_ppu_disable,
2404         .reset = mv88e6185_g1_reset,
2405         .vtu_getnext = mv88e6352_g1_vtu_getnext,
2406         .vtu_loadpurge = mv88e6352_g1_vtu_loadpurge,
2407 };
2408
2409 static const struct mv88e6xxx_ops mv88e6095_ops = {
2410         /* MV88E6XXX_FAMILY_6095 */
2411         .set_switch_mac = mv88e6xxx_g1_set_switch_mac,
2412         .phy_read = mv88e6185_phy_ppu_read,
2413         .phy_write = mv88e6185_phy_ppu_write,
2414         .port_set_link = mv88e6xxx_port_set_link,
2415         .port_set_duplex = mv88e6xxx_port_set_duplex,
2416         .port_set_speed = mv88e6185_port_set_speed,
2417         .port_set_frame_mode = mv88e6085_port_set_frame_mode,
2418         .port_set_egress_floods = mv88e6185_port_set_egress_floods,
2419         .port_set_upstream_port = mv88e6095_port_set_upstream_port,
2420         .stats_snapshot = mv88e6xxx_g1_stats_snapshot,
2421         .stats_get_sset_count = mv88e6095_stats_get_sset_count,
2422         .stats_get_strings = mv88e6095_stats_get_strings,
2423         .stats_get_stats = mv88e6095_stats_get_stats,
2424         .mgmt_rsvd2cpu = mv88e6185_g2_mgmt_rsvd2cpu,
2425         .ppu_enable = mv88e6185_g1_ppu_enable,
2426         .ppu_disable = mv88e6185_g1_ppu_disable,
2427         .reset = mv88e6185_g1_reset,
2428         .vtu_getnext = mv88e6185_g1_vtu_getnext,
2429         .vtu_loadpurge = mv88e6185_g1_vtu_loadpurge,
2430 };
2431
2432 static const struct mv88e6xxx_ops mv88e6097_ops = {
2433         /* MV88E6XXX_FAMILY_6097 */
2434         .irl_init_all = mv88e6352_g2_irl_init_all,
2435         .set_switch_mac = mv88e6xxx_g2_set_switch_mac,
2436         .phy_read = mv88e6xxx_g2_smi_phy_read,
2437         .phy_write = mv88e6xxx_g2_smi_phy_write,
2438         .port_set_link = mv88e6xxx_port_set_link,
2439         .port_set_duplex = mv88e6xxx_port_set_duplex,
2440         .port_set_speed = mv88e6185_port_set_speed,
2441         .port_tag_remap = mv88e6095_port_tag_remap,
2442         .port_set_frame_mode = mv88e6351_port_set_frame_mode,
2443         .port_set_egress_floods = mv88e6352_port_set_egress_floods,
2444         .port_set_ether_type = mv88e6351_port_set_ether_type,
2445         .port_set_jumbo_size = mv88e6165_port_set_jumbo_size,
2446         .port_egress_rate_limiting = mv88e6095_port_egress_rate_limiting,
2447         .port_pause_limit = mv88e6097_port_pause_limit,
2448         .port_disable_learn_limit = mv88e6xxx_port_disable_learn_limit,
2449         .port_disable_pri_override = mv88e6xxx_port_disable_pri_override,
2450         .stats_snapshot = mv88e6xxx_g1_stats_snapshot,
2451         .stats_get_sset_count = mv88e6095_stats_get_sset_count,
2452         .stats_get_strings = mv88e6095_stats_get_strings,
2453         .stats_get_stats = mv88e6095_stats_get_stats,
2454         .set_cpu_port = mv88e6095_g1_set_cpu_port,
2455         .set_egress_port = mv88e6095_g1_set_egress_port,
2456         .watchdog_ops = &mv88e6097_watchdog_ops,
2457         .mgmt_rsvd2cpu = mv88e6352_g2_mgmt_rsvd2cpu,
2458         .pot_clear = mv88e6xxx_g2_pot_clear,
2459         .reset = mv88e6352_g1_reset,
2460         .vtu_getnext = mv88e6352_g1_vtu_getnext,
2461         .vtu_loadpurge = mv88e6352_g1_vtu_loadpurge,
2462 };
2463
2464 static const struct mv88e6xxx_ops mv88e6123_ops = {
2465         /* MV88E6XXX_FAMILY_6165 */
2466         .irl_init_all = mv88e6352_g2_irl_init_all,
2467         .set_switch_mac = mv88e6xxx_g2_set_switch_mac,
2468         .phy_read = mv88e6xxx_g2_smi_phy_read,
2469         .phy_write = mv88e6xxx_g2_smi_phy_write,
2470         .port_set_link = mv88e6xxx_port_set_link,
2471         .port_set_duplex = mv88e6xxx_port_set_duplex,
2472         .port_set_speed = mv88e6185_port_set_speed,
2473         .port_set_frame_mode = mv88e6085_port_set_frame_mode,
2474         .port_set_egress_floods = mv88e6352_port_set_egress_floods,
2475         .port_disable_learn_limit = mv88e6xxx_port_disable_learn_limit,
2476         .port_disable_pri_override = mv88e6xxx_port_disable_pri_override,
2477         .stats_snapshot = mv88e6320_g1_stats_snapshot,
2478         .stats_get_sset_count = mv88e6095_stats_get_sset_count,
2479         .stats_get_strings = mv88e6095_stats_get_strings,
2480         .stats_get_stats = mv88e6095_stats_get_stats,
2481         .set_cpu_port = mv88e6095_g1_set_cpu_port,
2482         .set_egress_port = mv88e6095_g1_set_egress_port,
2483         .watchdog_ops = &mv88e6097_watchdog_ops,
2484         .mgmt_rsvd2cpu = mv88e6352_g2_mgmt_rsvd2cpu,
2485         .pot_clear = mv88e6xxx_g2_pot_clear,
2486         .reset = mv88e6352_g1_reset,
2487         .vtu_getnext = mv88e6352_g1_vtu_getnext,
2488         .vtu_loadpurge = mv88e6352_g1_vtu_loadpurge,
2489 };
2490
2491 static const struct mv88e6xxx_ops mv88e6131_ops = {
2492         /* MV88E6XXX_FAMILY_6185 */
2493         .set_switch_mac = mv88e6xxx_g1_set_switch_mac,
2494         .phy_read = mv88e6185_phy_ppu_read,
2495         .phy_write = mv88e6185_phy_ppu_write,
2496         .port_set_link = mv88e6xxx_port_set_link,
2497         .port_set_duplex = mv88e6xxx_port_set_duplex,
2498         .port_set_speed = mv88e6185_port_set_speed,
2499         .port_tag_remap = mv88e6095_port_tag_remap,
2500         .port_set_frame_mode = mv88e6351_port_set_frame_mode,
2501         .port_set_egress_floods = mv88e6185_port_set_egress_floods,
2502         .port_set_ether_type = mv88e6351_port_set_ether_type,
2503         .port_set_upstream_port = mv88e6095_port_set_upstream_port,
2504         .port_set_jumbo_size = mv88e6165_port_set_jumbo_size,
2505         .port_egress_rate_limiting = mv88e6097_port_egress_rate_limiting,
2506         .port_pause_limit = mv88e6097_port_pause_limit,
2507         .stats_snapshot = mv88e6xxx_g1_stats_snapshot,
2508         .stats_get_sset_count = mv88e6095_stats_get_sset_count,
2509         .stats_get_strings = mv88e6095_stats_get_strings,
2510         .stats_get_stats = mv88e6095_stats_get_stats,
2511         .set_cpu_port = mv88e6095_g1_set_cpu_port,
2512         .set_egress_port = mv88e6095_g1_set_egress_port,
2513         .watchdog_ops = &mv88e6097_watchdog_ops,
2514         .mgmt_rsvd2cpu = mv88e6185_g2_mgmt_rsvd2cpu,
2515         .ppu_enable = mv88e6185_g1_ppu_enable,
2516         .ppu_disable = mv88e6185_g1_ppu_disable,
2517         .reset = mv88e6185_g1_reset,
2518         .vtu_getnext = mv88e6185_g1_vtu_getnext,
2519         .vtu_loadpurge = mv88e6185_g1_vtu_loadpurge,
2520 };
2521
2522 static const struct mv88e6xxx_ops mv88e6141_ops = {
2523         /* MV88E6XXX_FAMILY_6341 */
2524         .irl_init_all = mv88e6352_g2_irl_init_all,
2525         .get_eeprom = mv88e6xxx_g2_get_eeprom8,
2526         .set_eeprom = mv88e6xxx_g2_set_eeprom8,
2527         .set_switch_mac = mv88e6xxx_g2_set_switch_mac,
2528         .phy_read = mv88e6xxx_g2_smi_phy_read,
2529         .phy_write = mv88e6xxx_g2_smi_phy_write,
2530         .phy_energy_detect_read = mv88e6352_phy_energy_detect_read,
2531         .phy_energy_detect_write = mv88e6352_phy_energy_detect_write,
2532         .port_set_link = mv88e6xxx_port_set_link,
2533         .port_set_duplex = mv88e6xxx_port_set_duplex,
2534         .port_set_rgmii_delay = mv88e6390_port_set_rgmii_delay,
2535         .port_set_speed = mv88e6390_port_set_speed,
2536         .port_tag_remap = mv88e6095_port_tag_remap,
2537         .port_set_frame_mode = mv88e6351_port_set_frame_mode,
2538         .port_set_egress_floods = mv88e6352_port_set_egress_floods,
2539         .port_set_ether_type = mv88e6351_port_set_ether_type,
2540         .port_set_jumbo_size = mv88e6165_port_set_jumbo_size,
2541         .port_egress_rate_limiting = mv88e6097_port_egress_rate_limiting,
2542         .port_pause_limit = mv88e6097_port_pause_limit,
2543         .port_disable_learn_limit = mv88e6xxx_port_disable_learn_limit,
2544         .port_disable_pri_override = mv88e6xxx_port_disable_pri_override,
2545         .stats_snapshot = mv88e6390_g1_stats_snapshot,
2546         .stats_get_sset_count = mv88e6320_stats_get_sset_count,
2547         .stats_get_strings = mv88e6320_stats_get_strings,
2548         .stats_get_stats = mv88e6390_stats_get_stats,
2549         .set_cpu_port = mv88e6390_g1_set_cpu_port,
2550         .set_egress_port = mv88e6390_g1_set_egress_port,
2551         .watchdog_ops = &mv88e6390_watchdog_ops,
2552         .mgmt_rsvd2cpu =  mv88e6390_g1_mgmt_rsvd2cpu,
2553         .pot_clear = mv88e6xxx_g2_pot_clear,
2554         .reset = mv88e6352_g1_reset,
2555         .vtu_getnext = mv88e6352_g1_vtu_getnext,
2556         .vtu_loadpurge = mv88e6352_g1_vtu_loadpurge,
2557 };
2558
2559 static const struct mv88e6xxx_ops mv88e6161_ops = {
2560         /* MV88E6XXX_FAMILY_6165 */
2561         .irl_init_all = mv88e6352_g2_irl_init_all,
2562         .set_switch_mac = mv88e6xxx_g2_set_switch_mac,
2563         .phy_read = mv88e6xxx_g2_smi_phy_read,
2564         .phy_write = mv88e6xxx_g2_smi_phy_write,
2565         .port_set_link = mv88e6xxx_port_set_link,
2566         .port_set_duplex = mv88e6xxx_port_set_duplex,
2567         .port_set_speed = mv88e6185_port_set_speed,
2568         .port_tag_remap = mv88e6095_port_tag_remap,
2569         .port_set_frame_mode = mv88e6351_port_set_frame_mode,
2570         .port_set_egress_floods = mv88e6352_port_set_egress_floods,
2571         .port_set_ether_type = mv88e6351_port_set_ether_type,
2572         .port_set_jumbo_size = mv88e6165_port_set_jumbo_size,
2573         .port_egress_rate_limiting = mv88e6097_port_egress_rate_limiting,
2574         .port_pause_limit = mv88e6097_port_pause_limit,
2575         .port_disable_learn_limit = mv88e6xxx_port_disable_learn_limit,
2576         .port_disable_pri_override = mv88e6xxx_port_disable_pri_override,
2577         .stats_snapshot = mv88e6320_g1_stats_snapshot,
2578         .stats_get_sset_count = mv88e6095_stats_get_sset_count,
2579         .stats_get_strings = mv88e6095_stats_get_strings,
2580         .stats_get_stats = mv88e6095_stats_get_stats,
2581         .set_cpu_port = mv88e6095_g1_set_cpu_port,
2582         .set_egress_port = mv88e6095_g1_set_egress_port,
2583         .watchdog_ops = &mv88e6097_watchdog_ops,
2584         .mgmt_rsvd2cpu = mv88e6352_g2_mgmt_rsvd2cpu,
2585         .pot_clear = mv88e6xxx_g2_pot_clear,
2586         .reset = mv88e6352_g1_reset,
2587         .vtu_getnext = mv88e6352_g1_vtu_getnext,
2588         .vtu_loadpurge = mv88e6352_g1_vtu_loadpurge,
2589 };
2590
2591 static const struct mv88e6xxx_ops mv88e6165_ops = {
2592         /* MV88E6XXX_FAMILY_6165 */
2593         .irl_init_all = mv88e6352_g2_irl_init_all,
2594         .set_switch_mac = mv88e6xxx_g2_set_switch_mac,
2595         .phy_read = mv88e6165_phy_read,
2596         .phy_write = mv88e6165_phy_write,
2597         .port_set_link = mv88e6xxx_port_set_link,
2598         .port_set_duplex = mv88e6xxx_port_set_duplex,
2599         .port_set_speed = mv88e6185_port_set_speed,
2600         .port_disable_learn_limit = mv88e6xxx_port_disable_learn_limit,
2601         .port_disable_pri_override = mv88e6xxx_port_disable_pri_override,
2602         .stats_snapshot = mv88e6xxx_g1_stats_snapshot,
2603         .stats_get_sset_count = mv88e6095_stats_get_sset_count,
2604         .stats_get_strings = mv88e6095_stats_get_strings,
2605         .stats_get_stats = mv88e6095_stats_get_stats,
2606         .set_cpu_port = mv88e6095_g1_set_cpu_port,
2607         .set_egress_port = mv88e6095_g1_set_egress_port,
2608         .watchdog_ops = &mv88e6097_watchdog_ops,
2609         .mgmt_rsvd2cpu = mv88e6352_g2_mgmt_rsvd2cpu,
2610         .pot_clear = mv88e6xxx_g2_pot_clear,
2611         .reset = mv88e6352_g1_reset,
2612         .vtu_getnext = mv88e6352_g1_vtu_getnext,
2613         .vtu_loadpurge = mv88e6352_g1_vtu_loadpurge,
2614 };
2615
2616 static const struct mv88e6xxx_ops mv88e6171_ops = {
2617         /* MV88E6XXX_FAMILY_6351 */
2618         .irl_init_all = mv88e6352_g2_irl_init_all,
2619         .set_switch_mac = mv88e6xxx_g2_set_switch_mac,
2620         .phy_read = mv88e6xxx_g2_smi_phy_read,
2621         .phy_write = mv88e6xxx_g2_smi_phy_write,
2622         .port_set_link = mv88e6xxx_port_set_link,
2623         .port_set_duplex = mv88e6xxx_port_set_duplex,
2624         .port_set_rgmii_delay = mv88e6352_port_set_rgmii_delay,
2625         .port_set_speed = mv88e6185_port_set_speed,
2626         .port_tag_remap = mv88e6095_port_tag_remap,
2627         .port_set_frame_mode = mv88e6351_port_set_frame_mode,
2628         .port_set_egress_floods = mv88e6352_port_set_egress_floods,
2629         .port_set_ether_type = mv88e6351_port_set_ether_type,
2630         .port_set_jumbo_size = mv88e6165_port_set_jumbo_size,
2631         .port_egress_rate_limiting = mv88e6097_port_egress_rate_limiting,
2632         .port_pause_limit = mv88e6097_port_pause_limit,
2633         .port_disable_learn_limit = mv88e6xxx_port_disable_learn_limit,
2634         .port_disable_pri_override = mv88e6xxx_port_disable_pri_override,
2635         .stats_snapshot = mv88e6320_g1_stats_snapshot,
2636         .stats_get_sset_count = mv88e6095_stats_get_sset_count,
2637         .stats_get_strings = mv88e6095_stats_get_strings,
2638         .stats_get_stats = mv88e6095_stats_get_stats,
2639         .set_cpu_port = mv88e6095_g1_set_cpu_port,
2640         .set_egress_port = mv88e6095_g1_set_egress_port,
2641         .watchdog_ops = &mv88e6097_watchdog_ops,
2642         .mgmt_rsvd2cpu = mv88e6352_g2_mgmt_rsvd2cpu,
2643         .pot_clear = mv88e6xxx_g2_pot_clear,
2644         .reset = mv88e6352_g1_reset,
2645         .vtu_getnext = mv88e6352_g1_vtu_getnext,
2646         .vtu_loadpurge = mv88e6352_g1_vtu_loadpurge,
2647 };
2648
2649 static const struct mv88e6xxx_ops mv88e6172_ops = {
2650         /* MV88E6XXX_FAMILY_6352 */
2651         .irl_init_all = mv88e6352_g2_irl_init_all,
2652         .get_eeprom = mv88e6xxx_g2_get_eeprom16,
2653         .set_eeprom = mv88e6xxx_g2_set_eeprom16,
2654         .set_switch_mac = mv88e6xxx_g2_set_switch_mac,
2655         .phy_read = mv88e6xxx_g2_smi_phy_read,
2656         .phy_write = mv88e6xxx_g2_smi_phy_write,
2657         .phy_energy_detect_read = mv88e6352_phy_energy_detect_read,
2658         .phy_energy_detect_write = mv88e6352_phy_energy_detect_write,
2659         .port_set_link = mv88e6xxx_port_set_link,
2660         .port_set_duplex = mv88e6xxx_port_set_duplex,
2661         .port_set_rgmii_delay = mv88e6352_port_set_rgmii_delay,
2662         .port_set_speed = mv88e6352_port_set_speed,
2663         .port_tag_remap = mv88e6095_port_tag_remap,
2664         .port_set_frame_mode = mv88e6351_port_set_frame_mode,
2665         .port_set_egress_floods = mv88e6352_port_set_egress_floods,
2666         .port_set_ether_type = mv88e6351_port_set_ether_type,
2667         .port_set_jumbo_size = mv88e6165_port_set_jumbo_size,
2668         .port_egress_rate_limiting = mv88e6097_port_egress_rate_limiting,
2669         .port_pause_limit = mv88e6097_port_pause_limit,
2670         .port_disable_learn_limit = mv88e6xxx_port_disable_learn_limit,
2671         .port_disable_pri_override = mv88e6xxx_port_disable_pri_override,
2672         .stats_snapshot = mv88e6320_g1_stats_snapshot,
2673         .stats_get_sset_count = mv88e6095_stats_get_sset_count,
2674         .stats_get_strings = mv88e6095_stats_get_strings,
2675         .stats_get_stats = mv88e6095_stats_get_stats,
2676         .set_cpu_port = mv88e6095_g1_set_cpu_port,
2677         .set_egress_port = mv88e6095_g1_set_egress_port,
2678         .watchdog_ops = &mv88e6097_watchdog_ops,
2679         .mgmt_rsvd2cpu = mv88e6352_g2_mgmt_rsvd2cpu,
2680         .pot_clear = mv88e6xxx_g2_pot_clear,
2681         .reset = mv88e6352_g1_reset,
2682         .vtu_getnext = mv88e6352_g1_vtu_getnext,
2683         .vtu_loadpurge = mv88e6352_g1_vtu_loadpurge,
2684         .serdes_power = mv88e6352_serdes_power,
2685 };
2686
2687 static const struct mv88e6xxx_ops mv88e6175_ops = {
2688         /* MV88E6XXX_FAMILY_6351 */
2689         .irl_init_all = mv88e6352_g2_irl_init_all,
2690         .set_switch_mac = mv88e6xxx_g2_set_switch_mac,
2691         .phy_read = mv88e6xxx_g2_smi_phy_read,
2692         .phy_write = mv88e6xxx_g2_smi_phy_write,
2693         .port_set_link = mv88e6xxx_port_set_link,
2694         .port_set_duplex = mv88e6xxx_port_set_duplex,
2695         .port_set_rgmii_delay = mv88e6352_port_set_rgmii_delay,
2696         .port_set_speed = mv88e6185_port_set_speed,
2697         .port_tag_remap = mv88e6095_port_tag_remap,
2698         .port_set_frame_mode = mv88e6351_port_set_frame_mode,
2699         .port_set_egress_floods = mv88e6352_port_set_egress_floods,
2700         .port_set_ether_type = mv88e6351_port_set_ether_type,
2701         .port_set_jumbo_size = mv88e6165_port_set_jumbo_size,
2702         .port_egress_rate_limiting = mv88e6097_port_egress_rate_limiting,
2703         .port_pause_limit = mv88e6097_port_pause_limit,
2704         .port_disable_learn_limit = mv88e6xxx_port_disable_learn_limit,
2705         .port_disable_pri_override = mv88e6xxx_port_disable_pri_override,
2706         .stats_snapshot = mv88e6320_g1_stats_snapshot,
2707         .stats_get_sset_count = mv88e6095_stats_get_sset_count,
2708         .stats_get_strings = mv88e6095_stats_get_strings,
2709         .stats_get_stats = mv88e6095_stats_get_stats,
2710         .set_cpu_port = mv88e6095_g1_set_cpu_port,
2711         .set_egress_port = mv88e6095_g1_set_egress_port,
2712         .watchdog_ops = &mv88e6097_watchdog_ops,
2713         .mgmt_rsvd2cpu = mv88e6352_g2_mgmt_rsvd2cpu,
2714         .pot_clear = mv88e6xxx_g2_pot_clear,
2715         .reset = mv88e6352_g1_reset,
2716         .vtu_getnext = mv88e6352_g1_vtu_getnext,
2717         .vtu_loadpurge = mv88e6352_g1_vtu_loadpurge,
2718 };
2719
2720 static const struct mv88e6xxx_ops mv88e6176_ops = {
2721         /* MV88E6XXX_FAMILY_6352 */
2722         .irl_init_all = mv88e6352_g2_irl_init_all,
2723         .get_eeprom = mv88e6xxx_g2_get_eeprom16,
2724         .set_eeprom = mv88e6xxx_g2_set_eeprom16,
2725         .set_switch_mac = mv88e6xxx_g2_set_switch_mac,
2726         .phy_read = mv88e6xxx_g2_smi_phy_read,
2727         .phy_write = mv88e6xxx_g2_smi_phy_write,
2728         .phy_energy_detect_read = mv88e6352_phy_energy_detect_read,
2729         .phy_energy_detect_write = mv88e6352_phy_energy_detect_write,
2730         .port_set_link = mv88e6xxx_port_set_link,
2731         .port_set_duplex = mv88e6xxx_port_set_duplex,
2732         .port_set_rgmii_delay = mv88e6352_port_set_rgmii_delay,
2733         .port_set_speed = mv88e6352_port_set_speed,
2734         .port_tag_remap = mv88e6095_port_tag_remap,
2735         .port_set_frame_mode = mv88e6351_port_set_frame_mode,
2736         .port_set_egress_floods = mv88e6352_port_set_egress_floods,
2737         .port_set_ether_type = mv88e6351_port_set_ether_type,
2738         .port_set_jumbo_size = mv88e6165_port_set_jumbo_size,
2739         .port_egress_rate_limiting = mv88e6097_port_egress_rate_limiting,
2740         .port_pause_limit = mv88e6097_port_pause_limit,
2741         .port_disable_learn_limit = mv88e6xxx_port_disable_learn_limit,
2742         .port_disable_pri_override = mv88e6xxx_port_disable_pri_override,
2743         .stats_snapshot = mv88e6320_g1_stats_snapshot,
2744         .stats_get_sset_count = mv88e6095_stats_get_sset_count,
2745         .stats_get_strings = mv88e6095_stats_get_strings,
2746         .stats_get_stats = mv88e6095_stats_get_stats,
2747         .set_cpu_port = mv88e6095_g1_set_cpu_port,
2748         .set_egress_port = mv88e6095_g1_set_egress_port,
2749         .watchdog_ops = &mv88e6097_watchdog_ops,
2750         .mgmt_rsvd2cpu = mv88e6352_g2_mgmt_rsvd2cpu,
2751         .pot_clear = mv88e6xxx_g2_pot_clear,
2752         .reset = mv88e6352_g1_reset,
2753         .vtu_getnext = mv88e6352_g1_vtu_getnext,
2754         .vtu_loadpurge = mv88e6352_g1_vtu_loadpurge,
2755         .serdes_power = mv88e6352_serdes_power,
2756 };
2757
2758 static const struct mv88e6xxx_ops mv88e6185_ops = {
2759         /* MV88E6XXX_FAMILY_6185 */
2760         .set_switch_mac = mv88e6xxx_g1_set_switch_mac,
2761         .phy_read = mv88e6185_phy_ppu_read,
2762         .phy_write = mv88e6185_phy_ppu_write,
2763         .port_set_link = mv88e6xxx_port_set_link,
2764         .port_set_duplex = mv88e6xxx_port_set_duplex,
2765         .port_set_speed = mv88e6185_port_set_speed,
2766         .port_set_frame_mode = mv88e6085_port_set_frame_mode,
2767         .port_set_egress_floods = mv88e6185_port_set_egress_floods,
2768         .port_egress_rate_limiting = mv88e6095_port_egress_rate_limiting,
2769         .port_set_upstream_port = mv88e6095_port_set_upstream_port,
2770         .stats_snapshot = mv88e6xxx_g1_stats_snapshot,
2771         .stats_get_sset_count = mv88e6095_stats_get_sset_count,
2772         .stats_get_strings = mv88e6095_stats_get_strings,
2773         .stats_get_stats = mv88e6095_stats_get_stats,
2774         .set_cpu_port = mv88e6095_g1_set_cpu_port,
2775         .set_egress_port = mv88e6095_g1_set_egress_port,
2776         .watchdog_ops = &mv88e6097_watchdog_ops,
2777         .mgmt_rsvd2cpu = mv88e6185_g2_mgmt_rsvd2cpu,
2778         .ppu_enable = mv88e6185_g1_ppu_enable,
2779         .ppu_disable = mv88e6185_g1_ppu_disable,
2780         .reset = mv88e6185_g1_reset,
2781         .vtu_getnext = mv88e6185_g1_vtu_getnext,
2782         .vtu_loadpurge = mv88e6185_g1_vtu_loadpurge,
2783 };
2784
2785 static const struct mv88e6xxx_ops mv88e6190_ops = {
2786         /* MV88E6XXX_FAMILY_6390 */
2787         .irl_init_all = mv88e6390_g2_irl_init_all,
2788         .get_eeprom = mv88e6xxx_g2_get_eeprom8,
2789         .set_eeprom = mv88e6xxx_g2_set_eeprom8,
2790         .set_switch_mac = mv88e6xxx_g2_set_switch_mac,
2791         .phy_read = mv88e6xxx_g2_smi_phy_read,
2792         .phy_write = mv88e6xxx_g2_smi_phy_write,
2793         .phy_energy_detect_read = mv88e6390_phy_energy_detect_read,
2794         .phy_energy_detect_write = mv88e6390_phy_energy_detect_write,
2795         .port_set_link = mv88e6xxx_port_set_link,
2796         .port_set_duplex = mv88e6xxx_port_set_duplex,
2797         .port_set_rgmii_delay = mv88e6390_port_set_rgmii_delay,
2798         .port_set_speed = mv88e6390_port_set_speed,
2799         .port_tag_remap = mv88e6390_port_tag_remap,
2800         .port_set_frame_mode = mv88e6351_port_set_frame_mode,
2801         .port_set_egress_floods = mv88e6352_port_set_egress_floods,
2802         .port_set_ether_type = mv88e6351_port_set_ether_type,
2803         .port_pause_limit = mv88e6390_port_pause_limit,
2804         .port_disable_learn_limit = mv88e6xxx_port_disable_learn_limit,
2805         .port_disable_pri_override = mv88e6xxx_port_disable_pri_override,
2806         .stats_snapshot = mv88e6390_g1_stats_snapshot,
2807         .stats_set_histogram = mv88e6390_g1_stats_set_histogram,
2808         .stats_get_sset_count = mv88e6320_stats_get_sset_count,
2809         .stats_get_strings = mv88e6320_stats_get_strings,
2810         .stats_get_stats = mv88e6390_stats_get_stats,
2811         .set_cpu_port = mv88e6390_g1_set_cpu_port,
2812         .set_egress_port = mv88e6390_g1_set_egress_port,
2813         .watchdog_ops = &mv88e6390_watchdog_ops,
2814         .mgmt_rsvd2cpu = mv88e6390_g1_mgmt_rsvd2cpu,
2815         .pot_clear = mv88e6xxx_g2_pot_clear,
2816         .reset = mv88e6352_g1_reset,
2817         .vtu_getnext = mv88e6390_g1_vtu_getnext,
2818         .vtu_loadpurge = mv88e6390_g1_vtu_loadpurge,
2819         .serdes_power = mv88e6390_serdes_power,
2820 };
2821
2822 static const struct mv88e6xxx_ops mv88e6190x_ops = {
2823         /* MV88E6XXX_FAMILY_6390 */
2824         .irl_init_all = mv88e6390_g2_irl_init_all,
2825         .get_eeprom = mv88e6xxx_g2_get_eeprom8,
2826         .set_eeprom = mv88e6xxx_g2_set_eeprom8,
2827         .set_switch_mac = mv88e6xxx_g2_set_switch_mac,
2828         .phy_read = mv88e6xxx_g2_smi_phy_read,
2829         .phy_write = mv88e6xxx_g2_smi_phy_write,
2830         .phy_energy_detect_read = mv88e6390_phy_energy_detect_read,
2831         .phy_energy_detect_write = mv88e6390_phy_energy_detect_write,
2832         .port_set_link = mv88e6xxx_port_set_link,
2833         .port_set_duplex = mv88e6xxx_port_set_duplex,
2834         .port_set_rgmii_delay = mv88e6390_port_set_rgmii_delay,
2835         .port_set_speed = mv88e6390x_port_set_speed,
2836         .port_tag_remap = mv88e6390_port_tag_remap,
2837         .port_set_frame_mode = mv88e6351_port_set_frame_mode,
2838         .port_set_egress_floods = mv88e6352_port_set_egress_floods,
2839         .port_set_ether_type = mv88e6351_port_set_ether_type,
2840         .port_pause_limit = mv88e6390_port_pause_limit,
2841         .port_disable_learn_limit = mv88e6xxx_port_disable_learn_limit,
2842         .port_disable_pri_override = mv88e6xxx_port_disable_pri_override,
2843         .stats_snapshot = mv88e6390_g1_stats_snapshot,
2844         .stats_set_histogram = mv88e6390_g1_stats_set_histogram,
2845         .stats_get_sset_count = mv88e6320_stats_get_sset_count,
2846         .stats_get_strings = mv88e6320_stats_get_strings,
2847         .stats_get_stats = mv88e6390_stats_get_stats,
2848         .set_cpu_port = mv88e6390_g1_set_cpu_port,
2849         .set_egress_port = mv88e6390_g1_set_egress_port,
2850         .watchdog_ops = &mv88e6390_watchdog_ops,
2851         .mgmt_rsvd2cpu = mv88e6390_g1_mgmt_rsvd2cpu,
2852         .pot_clear = mv88e6xxx_g2_pot_clear,
2853         .reset = mv88e6352_g1_reset,
2854         .vtu_getnext = mv88e6390_g1_vtu_getnext,
2855         .vtu_loadpurge = mv88e6390_g1_vtu_loadpurge,
2856         .serdes_power = mv88e6390_serdes_power,
2857 };
2858
2859 static const struct mv88e6xxx_ops mv88e6191_ops = {
2860         /* MV88E6XXX_FAMILY_6390 */
2861         .irl_init_all = mv88e6390_g2_irl_init_all,
2862         .get_eeprom = mv88e6xxx_g2_get_eeprom8,
2863         .set_eeprom = mv88e6xxx_g2_set_eeprom8,
2864         .set_switch_mac = mv88e6xxx_g2_set_switch_mac,
2865         .phy_read = mv88e6xxx_g2_smi_phy_read,
2866         .phy_write = mv88e6xxx_g2_smi_phy_write,
2867         .phy_energy_detect_read = mv88e6390_phy_energy_detect_read,
2868         .phy_energy_detect_write = mv88e6390_phy_energy_detect_write,
2869         .port_set_link = mv88e6xxx_port_set_link,
2870         .port_set_duplex = mv88e6xxx_port_set_duplex,
2871         .port_set_rgmii_delay = mv88e6390_port_set_rgmii_delay,
2872         .port_set_speed = mv88e6390_port_set_speed,
2873         .port_tag_remap = mv88e6390_port_tag_remap,
2874         .port_set_frame_mode = mv88e6351_port_set_frame_mode,
2875         .port_set_egress_floods = mv88e6352_port_set_egress_floods,
2876         .port_set_ether_type = mv88e6351_port_set_ether_type,
2877         .port_pause_limit = mv88e6390_port_pause_limit,
2878         .port_disable_learn_limit = mv88e6xxx_port_disable_learn_limit,
2879         .port_disable_pri_override = mv88e6xxx_port_disable_pri_override,
2880         .stats_snapshot = mv88e6390_g1_stats_snapshot,
2881         .stats_set_histogram = mv88e6390_g1_stats_set_histogram,
2882         .stats_get_sset_count = mv88e6320_stats_get_sset_count,
2883         .stats_get_strings = mv88e6320_stats_get_strings,
2884         .stats_get_stats = mv88e6390_stats_get_stats,
2885         .set_cpu_port = mv88e6390_g1_set_cpu_port,
2886         .set_egress_port = mv88e6390_g1_set_egress_port,
2887         .watchdog_ops = &mv88e6390_watchdog_ops,
2888         .mgmt_rsvd2cpu = mv88e6390_g1_mgmt_rsvd2cpu,
2889         .pot_clear = mv88e6xxx_g2_pot_clear,
2890         .reset = mv88e6352_g1_reset,
2891         .vtu_getnext = mv88e6390_g1_vtu_getnext,
2892         .vtu_loadpurge = mv88e6390_g1_vtu_loadpurge,
2893         .serdes_power = mv88e6390_serdes_power,
2894 };
2895
2896 static const struct mv88e6xxx_ops mv88e6240_ops = {
2897         /* MV88E6XXX_FAMILY_6352 */
2898         .irl_init_all = mv88e6352_g2_irl_init_all,
2899         .get_eeprom = mv88e6xxx_g2_get_eeprom16,
2900         .set_eeprom = mv88e6xxx_g2_set_eeprom16,
2901         .set_switch_mac = mv88e6xxx_g2_set_switch_mac,
2902         .phy_read = mv88e6xxx_g2_smi_phy_read,
2903         .phy_write = mv88e6xxx_g2_smi_phy_write,
2904         .phy_energy_detect_read = mv88e6352_phy_energy_detect_read,
2905         .phy_energy_detect_write = mv88e6352_phy_energy_detect_write,
2906         .port_set_link = mv88e6xxx_port_set_link,
2907         .port_set_duplex = mv88e6xxx_port_set_duplex,
2908         .port_set_rgmii_delay = mv88e6352_port_set_rgmii_delay,
2909         .port_set_speed = mv88e6352_port_set_speed,
2910         .port_tag_remap = mv88e6095_port_tag_remap,
2911         .port_set_frame_mode = mv88e6351_port_set_frame_mode,
2912         .port_set_egress_floods = mv88e6352_port_set_egress_floods,
2913         .port_set_ether_type = mv88e6351_port_set_ether_type,
2914         .port_set_jumbo_size = mv88e6165_port_set_jumbo_size,
2915         .port_egress_rate_limiting = mv88e6097_port_egress_rate_limiting,
2916         .port_pause_limit = mv88e6097_port_pause_limit,
2917         .port_disable_learn_limit = mv88e6xxx_port_disable_learn_limit,
2918         .port_disable_pri_override = mv88e6xxx_port_disable_pri_override,
2919         .stats_snapshot = mv88e6320_g1_stats_snapshot,
2920         .stats_get_sset_count = mv88e6095_stats_get_sset_count,
2921         .stats_get_strings = mv88e6095_stats_get_strings,
2922         .stats_get_stats = mv88e6095_stats_get_stats,
2923         .set_cpu_port = mv88e6095_g1_set_cpu_port,
2924         .set_egress_port = mv88e6095_g1_set_egress_port,
2925         .watchdog_ops = &mv88e6097_watchdog_ops,
2926         .mgmt_rsvd2cpu = mv88e6352_g2_mgmt_rsvd2cpu,
2927         .pot_clear = mv88e6xxx_g2_pot_clear,
2928         .reset = mv88e6352_g1_reset,
2929         .vtu_getnext = mv88e6352_g1_vtu_getnext,
2930         .vtu_loadpurge = mv88e6352_g1_vtu_loadpurge,
2931         .serdes_power = mv88e6352_serdes_power,
2932 };
2933
2934 static const struct mv88e6xxx_ops mv88e6290_ops = {
2935         /* MV88E6XXX_FAMILY_6390 */
2936         .irl_init_all = mv88e6390_g2_irl_init_all,
2937         .get_eeprom = mv88e6xxx_g2_get_eeprom8,
2938         .set_eeprom = mv88e6xxx_g2_set_eeprom8,
2939         .set_switch_mac = mv88e6xxx_g2_set_switch_mac,
2940         .phy_read = mv88e6xxx_g2_smi_phy_read,
2941         .phy_write = mv88e6xxx_g2_smi_phy_write,
2942         .phy_energy_detect_read = mv88e6390_phy_energy_detect_read,
2943         .phy_energy_detect_write = mv88e6390_phy_energy_detect_write,
2944         .port_set_link = mv88e6xxx_port_set_link,
2945         .port_set_duplex = mv88e6xxx_port_set_duplex,
2946         .port_set_rgmii_delay = mv88e6390_port_set_rgmii_delay,
2947         .port_set_speed = mv88e6390_port_set_speed,
2948         .port_tag_remap = mv88e6390_port_tag_remap,
2949         .port_set_frame_mode = mv88e6351_port_set_frame_mode,
2950         .port_set_egress_floods = mv88e6352_port_set_egress_floods,
2951         .port_set_ether_type = mv88e6351_port_set_ether_type,
2952         .port_pause_limit = mv88e6390_port_pause_limit,
2953         .port_set_cmode = mv88e6390x_port_set_cmode,
2954         .port_disable_learn_limit = mv88e6xxx_port_disable_learn_limit,
2955         .port_disable_pri_override = mv88e6xxx_port_disable_pri_override,
2956         .stats_snapshot = mv88e6390_g1_stats_snapshot,
2957         .stats_set_histogram = mv88e6390_g1_stats_set_histogram,
2958         .stats_get_sset_count = mv88e6320_stats_get_sset_count,
2959         .stats_get_strings = mv88e6320_stats_get_strings,
2960         .stats_get_stats = mv88e6390_stats_get_stats,
2961         .set_cpu_port = mv88e6390_g1_set_cpu_port,
2962         .set_egress_port = mv88e6390_g1_set_egress_port,
2963         .watchdog_ops = &mv88e6390_watchdog_ops,
2964         .mgmt_rsvd2cpu = mv88e6390_g1_mgmt_rsvd2cpu,
2965         .pot_clear = mv88e6xxx_g2_pot_clear,
2966         .reset = mv88e6352_g1_reset,
2967         .vtu_getnext = mv88e6390_g1_vtu_getnext,
2968         .vtu_loadpurge = mv88e6390_g1_vtu_loadpurge,
2969         .serdes_power = mv88e6390_serdes_power,
2970 };
2971
2972 static const struct mv88e6xxx_ops mv88e6320_ops = {
2973         /* MV88E6XXX_FAMILY_6320 */
2974         .irl_init_all = mv88e6352_g2_irl_init_all,
2975         .get_eeprom = mv88e6xxx_g2_get_eeprom16,
2976         .set_eeprom = mv88e6xxx_g2_set_eeprom16,
2977         .set_switch_mac = mv88e6xxx_g2_set_switch_mac,
2978         .phy_read = mv88e6xxx_g2_smi_phy_read,
2979         .phy_write = mv88e6xxx_g2_smi_phy_write,
2980         .phy_energy_detect_read = mv88e6352_phy_energy_detect_read,
2981         .phy_energy_detect_write = mv88e6352_phy_energy_detect_write,
2982         .port_set_link = mv88e6xxx_port_set_link,
2983         .port_set_duplex = mv88e6xxx_port_set_duplex,
2984         .port_set_speed = mv88e6185_port_set_speed,
2985         .port_tag_remap = mv88e6095_port_tag_remap,
2986         .port_set_frame_mode = mv88e6351_port_set_frame_mode,
2987         .port_set_egress_floods = mv88e6352_port_set_egress_floods,
2988         .port_set_ether_type = mv88e6351_port_set_ether_type,
2989         .port_set_jumbo_size = mv88e6165_port_set_jumbo_size,
2990         .port_egress_rate_limiting = mv88e6097_port_egress_rate_limiting,
2991         .port_pause_limit = mv88e6097_port_pause_limit,
2992         .port_disable_learn_limit = mv88e6xxx_port_disable_learn_limit,
2993         .port_disable_pri_override = mv88e6xxx_port_disable_pri_override,
2994         .stats_snapshot = mv88e6320_g1_stats_snapshot,
2995         .stats_get_sset_count = mv88e6320_stats_get_sset_count,
2996         .stats_get_strings = mv88e6320_stats_get_strings,
2997         .stats_get_stats = mv88e6320_stats_get_stats,
2998         .set_cpu_port = mv88e6095_g1_set_cpu_port,
2999         .set_egress_port = mv88e6095_g1_set_egress_port,
3000         .mgmt_rsvd2cpu = mv88e6352_g2_mgmt_rsvd2cpu,
3001         .pot_clear = mv88e6xxx_g2_pot_clear,
3002         .reset = mv88e6352_g1_reset,
3003         .vtu_getnext = mv88e6185_g1_vtu_getnext,
3004         .vtu_loadpurge = mv88e6185_g1_vtu_loadpurge,
3005 };
3006
3007 static const struct mv88e6xxx_ops mv88e6321_ops = {
3008         /* MV88E6XXX_FAMILY_6320 */
3009         .irl_init_all = mv88e6352_g2_irl_init_all,
3010         .get_eeprom = mv88e6xxx_g2_get_eeprom16,
3011         .set_eeprom = mv88e6xxx_g2_set_eeprom16,
3012         .set_switch_mac = mv88e6xxx_g2_set_switch_mac,
3013         .phy_read = mv88e6xxx_g2_smi_phy_read,
3014         .phy_write = mv88e6xxx_g2_smi_phy_write,
3015         .phy_energy_detect_read = mv88e6352_phy_energy_detect_read,
3016         .phy_energy_detect_write = mv88e6352_phy_energy_detect_write,
3017         .port_set_link = mv88e6xxx_port_set_link,
3018         .port_set_duplex = mv88e6xxx_port_set_duplex,
3019         .port_set_speed = mv88e6185_port_set_speed,
3020         .port_tag_remap = mv88e6095_port_tag_remap,
3021         .port_set_frame_mode = mv88e6351_port_set_frame_mode,
3022         .port_set_egress_floods = mv88e6352_port_set_egress_floods,
3023         .port_set_ether_type = mv88e6351_port_set_ether_type,
3024         .port_set_jumbo_size = mv88e6165_port_set_jumbo_size,
3025         .port_egress_rate_limiting = mv88e6097_port_egress_rate_limiting,
3026         .port_pause_limit = mv88e6097_port_pause_limit,
3027         .port_disable_learn_limit = mv88e6xxx_port_disable_learn_limit,
3028         .port_disable_pri_override = mv88e6xxx_port_disable_pri_override,
3029         .stats_snapshot = mv88e6320_g1_stats_snapshot,
3030         .stats_get_sset_count = mv88e6320_stats_get_sset_count,
3031         .stats_get_strings = mv88e6320_stats_get_strings,
3032         .stats_get_stats = mv88e6320_stats_get_stats,
3033         .set_cpu_port = mv88e6095_g1_set_cpu_port,
3034         .set_egress_port = mv88e6095_g1_set_egress_port,
3035         .reset = mv88e6352_g1_reset,
3036         .vtu_getnext = mv88e6185_g1_vtu_getnext,
3037         .vtu_loadpurge = mv88e6185_g1_vtu_loadpurge,
3038 };
3039
3040 static const struct mv88e6xxx_ops mv88e6341_ops = {
3041         /* MV88E6XXX_FAMILY_6341 */
3042         .irl_init_all = mv88e6352_g2_irl_init_all,
3043         .get_eeprom = mv88e6xxx_g2_get_eeprom8,
3044         .set_eeprom = mv88e6xxx_g2_set_eeprom8,
3045         .set_switch_mac = mv88e6xxx_g2_set_switch_mac,
3046         .phy_read = mv88e6xxx_g2_smi_phy_read,
3047         .phy_write = mv88e6xxx_g2_smi_phy_write,
3048         .phy_energy_detect_read = mv88e6352_phy_energy_detect_read,
3049         .phy_energy_detect_write = mv88e6352_phy_energy_detect_write,
3050         .port_set_link = mv88e6xxx_port_set_link,
3051         .port_set_duplex = mv88e6xxx_port_set_duplex,
3052         .port_set_rgmii_delay = mv88e6390_port_set_rgmii_delay,
3053         .port_set_speed = mv88e6390_port_set_speed,
3054         .port_tag_remap = mv88e6095_port_tag_remap,
3055         .port_set_frame_mode = mv88e6351_port_set_frame_mode,
3056         .port_set_egress_floods = mv88e6352_port_set_egress_floods,
3057         .port_set_ether_type = mv88e6351_port_set_ether_type,
3058         .port_set_jumbo_size = mv88e6165_port_set_jumbo_size,
3059         .port_egress_rate_limiting = mv88e6097_port_egress_rate_limiting,
3060         .port_pause_limit = mv88e6097_port_pause_limit,
3061         .port_disable_learn_limit = mv88e6xxx_port_disable_learn_limit,
3062         .port_disable_pri_override = mv88e6xxx_port_disable_pri_override,
3063         .stats_snapshot = mv88e6390_g1_stats_snapshot,
3064         .stats_get_sset_count = mv88e6320_stats_get_sset_count,
3065         .stats_get_strings = mv88e6320_stats_get_strings,
3066         .stats_get_stats = mv88e6390_stats_get_stats,
3067         .set_cpu_port = mv88e6390_g1_set_cpu_port,
3068         .set_egress_port = mv88e6390_g1_set_egress_port,
3069         .watchdog_ops = &mv88e6390_watchdog_ops,
3070         .mgmt_rsvd2cpu =  mv88e6390_g1_mgmt_rsvd2cpu,
3071         .pot_clear = mv88e6xxx_g2_pot_clear,
3072         .reset = mv88e6352_g1_reset,
3073         .vtu_getnext = mv88e6352_g1_vtu_getnext,
3074         .vtu_loadpurge = mv88e6352_g1_vtu_loadpurge,
3075 };
3076
3077 static const struct mv88e6xxx_ops mv88e6350_ops = {
3078         /* MV88E6XXX_FAMILY_6351 */
3079         .irl_init_all = mv88e6352_g2_irl_init_all,
3080         .set_switch_mac = mv88e6xxx_g2_set_switch_mac,
3081         .phy_read = mv88e6xxx_g2_smi_phy_read,
3082         .phy_write = mv88e6xxx_g2_smi_phy_write,
3083         .port_set_link = mv88e6xxx_port_set_link,
3084         .port_set_duplex = mv88e6xxx_port_set_duplex,
3085         .port_set_rgmii_delay = mv88e6352_port_set_rgmii_delay,
3086         .port_set_speed = mv88e6185_port_set_speed,
3087         .port_tag_remap = mv88e6095_port_tag_remap,
3088         .port_set_frame_mode = mv88e6351_port_set_frame_mode,
3089         .port_set_egress_floods = mv88e6352_port_set_egress_floods,
3090         .port_set_ether_type = mv88e6351_port_set_ether_type,
3091         .port_set_jumbo_size = mv88e6165_port_set_jumbo_size,
3092         .port_egress_rate_limiting = mv88e6097_port_egress_rate_limiting,
3093         .port_pause_limit = mv88e6097_port_pause_limit,
3094         .port_disable_learn_limit = mv88e6xxx_port_disable_learn_limit,
3095         .port_disable_pri_override = mv88e6xxx_port_disable_pri_override,
3096         .stats_snapshot = mv88e6320_g1_stats_snapshot,
3097         .stats_get_sset_count = mv88e6095_stats_get_sset_count,
3098         .stats_get_strings = mv88e6095_stats_get_strings,
3099         .stats_get_stats = mv88e6095_stats_get_stats,
3100         .set_cpu_port = mv88e6095_g1_set_cpu_port,
3101         .set_egress_port = mv88e6095_g1_set_egress_port,
3102         .watchdog_ops = &mv88e6097_watchdog_ops,
3103         .mgmt_rsvd2cpu = mv88e6352_g2_mgmt_rsvd2cpu,
3104         .pot_clear = mv88e6xxx_g2_pot_clear,
3105         .reset = mv88e6352_g1_reset,
3106         .vtu_getnext = mv88e6352_g1_vtu_getnext,
3107         .vtu_loadpurge = mv88e6352_g1_vtu_loadpurge,
3108 };
3109
3110 static const struct mv88e6xxx_ops mv88e6351_ops = {
3111         /* MV88E6XXX_FAMILY_6351 */
3112         .irl_init_all = mv88e6352_g2_irl_init_all,
3113         .set_switch_mac = mv88e6xxx_g2_set_switch_mac,
3114         .phy_read = mv88e6xxx_g2_smi_phy_read,
3115         .phy_write = mv88e6xxx_g2_smi_phy_write,
3116         .port_set_link = mv88e6xxx_port_set_link,
3117         .port_set_duplex = mv88e6xxx_port_set_duplex,
3118         .port_set_rgmii_delay = mv88e6352_port_set_rgmii_delay,
3119         .port_set_speed = mv88e6185_port_set_speed,
3120         .port_tag_remap = mv88e6095_port_tag_remap,
3121         .port_set_frame_mode = mv88e6351_port_set_frame_mode,
3122         .port_set_egress_floods = mv88e6352_port_set_egress_floods,
3123         .port_set_ether_type = mv88e6351_port_set_ether_type,
3124         .port_set_jumbo_size = mv88e6165_port_set_jumbo_size,
3125         .port_egress_rate_limiting = mv88e6097_port_egress_rate_limiting,
3126         .port_pause_limit = mv88e6097_port_pause_limit,
3127         .port_disable_learn_limit = mv88e6xxx_port_disable_learn_limit,
3128         .port_disable_pri_override = mv88e6xxx_port_disable_pri_override,
3129         .stats_snapshot = mv88e6320_g1_stats_snapshot,
3130         .stats_get_sset_count = mv88e6095_stats_get_sset_count,
3131         .stats_get_strings = mv88e6095_stats_get_strings,
3132         .stats_get_stats = mv88e6095_stats_get_stats,
3133         .set_cpu_port = mv88e6095_g1_set_cpu_port,
3134         .set_egress_port = mv88e6095_g1_set_egress_port,
3135         .watchdog_ops = &mv88e6097_watchdog_ops,
3136         .mgmt_rsvd2cpu = mv88e6352_g2_mgmt_rsvd2cpu,
3137         .pot_clear = mv88e6xxx_g2_pot_clear,
3138         .reset = mv88e6352_g1_reset,
3139         .vtu_getnext = mv88e6352_g1_vtu_getnext,
3140         .vtu_loadpurge = mv88e6352_g1_vtu_loadpurge,
3141 };
3142
3143 static const struct mv88e6xxx_ops mv88e6352_ops = {
3144         /* MV88E6XXX_FAMILY_6352 */
3145         .irl_init_all = mv88e6352_g2_irl_init_all,
3146         .get_eeprom = mv88e6xxx_g2_get_eeprom16,
3147         .set_eeprom = mv88e6xxx_g2_set_eeprom16,
3148         .set_switch_mac = mv88e6xxx_g2_set_switch_mac,
3149         .phy_read = mv88e6xxx_g2_smi_phy_read,
3150         .phy_write = mv88e6xxx_g2_smi_phy_write,
3151         .phy_energy_detect_read = mv88e6352_phy_energy_detect_read,
3152         .phy_energy_detect_write = mv88e6352_phy_energy_detect_write,
3153         .port_set_link = mv88e6xxx_port_set_link,
3154         .port_set_duplex = mv88e6xxx_port_set_duplex,
3155         .port_set_rgmii_delay = mv88e6352_port_set_rgmii_delay,
3156         .port_set_speed = mv88e6352_port_set_speed,
3157         .port_tag_remap = mv88e6095_port_tag_remap,
3158         .port_set_frame_mode = mv88e6351_port_set_frame_mode,
3159         .port_set_egress_floods = mv88e6352_port_set_egress_floods,
3160         .port_set_ether_type = mv88e6351_port_set_ether_type,
3161         .port_set_jumbo_size = mv88e6165_port_set_jumbo_size,
3162         .port_egress_rate_limiting = mv88e6097_port_egress_rate_limiting,
3163         .port_pause_limit = mv88e6097_port_pause_limit,
3164         .port_disable_learn_limit = mv88e6xxx_port_disable_learn_limit,
3165         .port_disable_pri_override = mv88e6xxx_port_disable_pri_override,
3166         .stats_snapshot = mv88e6320_g1_stats_snapshot,
3167         .stats_get_sset_count = mv88e6095_stats_get_sset_count,
3168         .stats_get_strings = mv88e6095_stats_get_strings,
3169         .stats_get_stats = mv88e6095_stats_get_stats,
3170         .set_cpu_port = mv88e6095_g1_set_cpu_port,
3171         .set_egress_port = mv88e6095_g1_set_egress_port,
3172         .watchdog_ops = &mv88e6097_watchdog_ops,
3173         .mgmt_rsvd2cpu = mv88e6352_g2_mgmt_rsvd2cpu,
3174         .pot_clear = mv88e6xxx_g2_pot_clear,
3175         .reset = mv88e6352_g1_reset,
3176         .vtu_getnext = mv88e6352_g1_vtu_getnext,
3177         .vtu_loadpurge = mv88e6352_g1_vtu_loadpurge,
3178         .serdes_power = mv88e6352_serdes_power,
3179 };
3180
3181 static const struct mv88e6xxx_ops mv88e6390_ops = {
3182         /* MV88E6XXX_FAMILY_6390 */
3183         .irl_init_all = mv88e6390_g2_irl_init_all,
3184         .get_eeprom = mv88e6xxx_g2_get_eeprom8,
3185         .set_eeprom = mv88e6xxx_g2_set_eeprom8,
3186         .set_switch_mac = mv88e6xxx_g2_set_switch_mac,
3187         .phy_read = mv88e6xxx_g2_smi_phy_read,
3188         .phy_write = mv88e6xxx_g2_smi_phy_write,
3189         .phy_energy_detect_read = mv88e6390_phy_energy_detect_read,
3190         .phy_energy_detect_write = mv88e6390_phy_energy_detect_write,
3191         .port_set_link = mv88e6xxx_port_set_link,
3192         .port_set_duplex = mv88e6xxx_port_set_duplex,
3193         .port_set_rgmii_delay = mv88e6390_port_set_rgmii_delay,
3194         .port_set_speed = mv88e6390_port_set_speed,
3195         .port_tag_remap = mv88e6390_port_tag_remap,
3196         .port_set_frame_mode = mv88e6351_port_set_frame_mode,
3197         .port_set_egress_floods = mv88e6352_port_set_egress_floods,
3198         .port_set_ether_type = mv88e6351_port_set_ether_type,
3199         .port_set_jumbo_size = mv88e6165_port_set_jumbo_size,
3200         .port_egress_rate_limiting = mv88e6097_port_egress_rate_limiting,
3201         .port_pause_limit = mv88e6390_port_pause_limit,
3202         .port_set_cmode = mv88e6390x_port_set_cmode,
3203         .port_disable_learn_limit = mv88e6xxx_port_disable_learn_limit,
3204         .port_disable_pri_override = mv88e6xxx_port_disable_pri_override,
3205         .stats_snapshot = mv88e6390_g1_stats_snapshot,
3206         .stats_set_histogram = mv88e6390_g1_stats_set_histogram,
3207         .stats_get_sset_count = mv88e6320_stats_get_sset_count,
3208         .stats_get_strings = mv88e6320_stats_get_strings,
3209         .stats_get_stats = mv88e6390_stats_get_stats,
3210         .set_cpu_port = mv88e6390_g1_set_cpu_port,
3211         .set_egress_port = mv88e6390_g1_set_egress_port,
3212         .watchdog_ops = &mv88e6390_watchdog_ops,
3213         .mgmt_rsvd2cpu = mv88e6390_g1_mgmt_rsvd2cpu,
3214         .pot_clear = mv88e6xxx_g2_pot_clear,
3215         .reset = mv88e6352_g1_reset,
3216         .vtu_getnext = mv88e6390_g1_vtu_getnext,
3217         .vtu_loadpurge = mv88e6390_g1_vtu_loadpurge,
3218         .serdes_power = mv88e6390_serdes_power,
3219 };
3220
3221 static const struct mv88e6xxx_ops mv88e6390x_ops = {
3222         /* MV88E6XXX_FAMILY_6390 */
3223         .irl_init_all = mv88e6390_g2_irl_init_all,
3224         .get_eeprom = mv88e6xxx_g2_get_eeprom8,
3225         .set_eeprom = mv88e6xxx_g2_set_eeprom8,
3226         .set_switch_mac = mv88e6xxx_g2_set_switch_mac,
3227         .phy_read = mv88e6xxx_g2_smi_phy_read,
3228         .phy_write = mv88e6xxx_g2_smi_phy_write,
3229         .phy_energy_detect_read = mv88e6390_phy_energy_detect_read,
3230         .phy_energy_detect_write = mv88e6390_phy_energy_detect_write,
3231         .port_set_link = mv88e6xxx_port_set_link,
3232         .port_set_duplex = mv88e6xxx_port_set_duplex,
3233         .port_set_rgmii_delay = mv88e6390_port_set_rgmii_delay,
3234         .port_set_speed = mv88e6390x_port_set_speed,
3235         .port_tag_remap = mv88e6390_port_tag_remap,
3236         .port_set_frame_mode = mv88e6351_port_set_frame_mode,
3237         .port_set_egress_floods = mv88e6352_port_set_egress_floods,
3238         .port_set_ether_type = mv88e6351_port_set_ether_type,
3239         .port_set_jumbo_size = mv88e6165_port_set_jumbo_size,
3240         .port_egress_rate_limiting = mv88e6097_port_egress_rate_limiting,
3241         .port_pause_limit = mv88e6390_port_pause_limit,
3242         .port_set_cmode = mv88e6390x_port_set_cmode,
3243         .port_disable_learn_limit = mv88e6xxx_port_disable_learn_limit,
3244         .port_disable_pri_override = mv88e6xxx_port_disable_pri_override,
3245         .stats_snapshot = mv88e6390_g1_stats_snapshot,
3246         .stats_set_histogram = mv88e6390_g1_stats_set_histogram,
3247         .stats_get_sset_count = mv88e6320_stats_get_sset_count,
3248         .stats_get_strings = mv88e6320_stats_get_strings,
3249         .stats_get_stats = mv88e6390_stats_get_stats,
3250         .set_cpu_port = mv88e6390_g1_set_cpu_port,
3251         .set_egress_port = mv88e6390_g1_set_egress_port,
3252         .watchdog_ops = &mv88e6390_watchdog_ops,
3253         .mgmt_rsvd2cpu = mv88e6390_g1_mgmt_rsvd2cpu,
3254         .pot_clear = mv88e6xxx_g2_pot_clear,
3255         .reset = mv88e6352_g1_reset,
3256         .vtu_getnext = mv88e6390_g1_vtu_getnext,
3257         .vtu_loadpurge = mv88e6390_g1_vtu_loadpurge,
3258         .serdes_power = mv88e6390_serdes_power,
3259 };
3260
3261 static const struct mv88e6xxx_info mv88e6xxx_table[] = {
3262         [MV88E6085] = {
3263                 .prod_num = MV88E6XXX_PORT_SWITCH_ID_PROD_6085,
3264                 .family = MV88E6XXX_FAMILY_6097,
3265                 .name = "Marvell 88E6085",
3266                 .num_databases = 4096,
3267                 .num_ports = 10,
3268                 .max_vid = 4095,
3269                 .port_base_addr = 0x10,
3270                 .global1_addr = 0x1b,
3271                 .global2_addr = 0x1c,
3272                 .age_time_coeff = 15000,
3273                 .g1_irqs = 8,
3274                 .g2_irqs = 10,
3275                 .atu_move_port_mask = 0xf,
3276                 .pvt = true,
3277                 .multi_chip = true,
3278                 .tag_protocol = DSA_TAG_PROTO_DSA,
3279                 .ops = &mv88e6085_ops,
3280         },
3281
3282         [MV88E6095] = {
3283                 .prod_num = MV88E6XXX_PORT_SWITCH_ID_PROD_6095,
3284                 .family = MV88E6XXX_FAMILY_6095,
3285                 .name = "Marvell 88E6095/88E6095F",
3286                 .num_databases = 256,
3287                 .num_ports = 11,
3288                 .max_vid = 4095,
3289                 .port_base_addr = 0x10,
3290                 .global1_addr = 0x1b,
3291                 .global2_addr = 0x1c,
3292                 .age_time_coeff = 15000,
3293                 .g1_irqs = 8,
3294                 .atu_move_port_mask = 0xf,
3295                 .multi_chip = true,
3296                 .tag_protocol = DSA_TAG_PROTO_DSA,
3297                 .ops = &mv88e6095_ops,
3298         },
3299
3300         [MV88E6097] = {
3301                 .prod_num = MV88E6XXX_PORT_SWITCH_ID_PROD_6097,
3302                 .family = MV88E6XXX_FAMILY_6097,
3303                 .name = "Marvell 88E6097/88E6097F",
3304                 .num_databases = 4096,
3305                 .num_ports = 11,
3306                 .max_vid = 4095,
3307                 .port_base_addr = 0x10,
3308                 .global1_addr = 0x1b,
3309                 .global2_addr = 0x1c,
3310                 .age_time_coeff = 15000,
3311                 .g1_irqs = 8,
3312                 .g2_irqs = 10,
3313                 .atu_move_port_mask = 0xf,
3314                 .pvt = true,
3315                 .multi_chip = true,
3316                 .tag_protocol = DSA_TAG_PROTO_EDSA,
3317                 .ops = &mv88e6097_ops,
3318         },
3319
3320         [MV88E6123] = {
3321                 .prod_num = MV88E6XXX_PORT_SWITCH_ID_PROD_6123,
3322                 .family = MV88E6XXX_FAMILY_6165,
3323                 .name = "Marvell 88E6123",
3324                 .num_databases = 4096,
3325                 .num_ports = 3,
3326                 .max_vid = 4095,
3327                 .port_base_addr = 0x10,
3328                 .global1_addr = 0x1b,
3329                 .global2_addr = 0x1c,
3330                 .age_time_coeff = 15000,
3331                 .g1_irqs = 9,
3332                 .g2_irqs = 10,
3333                 .atu_move_port_mask = 0xf,
3334                 .pvt = true,
3335                 .multi_chip = true,
3336                 .tag_protocol = DSA_TAG_PROTO_EDSA,
3337                 .ops = &mv88e6123_ops,
3338         },
3339
3340         [MV88E6131] = {
3341                 .prod_num = MV88E6XXX_PORT_SWITCH_ID_PROD_6131,
3342                 .family = MV88E6XXX_FAMILY_6185,
3343                 .name = "Marvell 88E6131",
3344                 .num_databases = 256,
3345                 .num_ports = 8,
3346                 .max_vid = 4095,
3347                 .port_base_addr = 0x10,
3348                 .global1_addr = 0x1b,
3349                 .global2_addr = 0x1c,
3350                 .age_time_coeff = 15000,
3351                 .g1_irqs = 9,
3352                 .atu_move_port_mask = 0xf,
3353                 .multi_chip = true,
3354                 .tag_protocol = DSA_TAG_PROTO_DSA,
3355                 .ops = &mv88e6131_ops,
3356         },
3357
3358         [MV88E6141] = {
3359                 .prod_num = MV88E6XXX_PORT_SWITCH_ID_PROD_6141,
3360                 .family = MV88E6XXX_FAMILY_6341,
3361                 .name = "Marvell 88E6341",
3362                 .num_databases = 4096,
3363                 .num_ports = 6,
3364                 .max_vid = 4095,
3365                 .port_base_addr = 0x10,
3366                 .global1_addr = 0x1b,
3367                 .global2_addr = 0x1c,
3368                 .age_time_coeff = 3750,
3369                 .atu_move_port_mask = 0x1f,
3370                 .g2_irqs = 10,
3371                 .pvt = true,
3372                 .multi_chip = true,
3373                 .tag_protocol = DSA_TAG_PROTO_EDSA,
3374                 .ops = &mv88e6141_ops,
3375         },
3376
3377         [MV88E6161] = {
3378                 .prod_num = MV88E6XXX_PORT_SWITCH_ID_PROD_6161,
3379                 .family = MV88E6XXX_FAMILY_6165,
3380                 .name = "Marvell 88E6161",
3381                 .num_databases = 4096,
3382                 .num_ports = 6,
3383                 .max_vid = 4095,
3384                 .port_base_addr = 0x10,
3385                 .global1_addr = 0x1b,
3386                 .global2_addr = 0x1c,
3387                 .age_time_coeff = 15000,
3388                 .g1_irqs = 9,
3389                 .g2_irqs = 10,
3390                 .atu_move_port_mask = 0xf,
3391                 .pvt = true,
3392                 .multi_chip = true,
3393                 .tag_protocol = DSA_TAG_PROTO_EDSA,
3394                 .ops = &mv88e6161_ops,
3395         },
3396
3397         [MV88E6165] = {
3398                 .prod_num = MV88E6XXX_PORT_SWITCH_ID_PROD_6165,
3399                 .family = MV88E6XXX_FAMILY_6165,
3400                 .name = "Marvell 88E6165",
3401                 .num_databases = 4096,
3402                 .num_ports = 6,
3403                 .max_vid = 4095,
3404                 .port_base_addr = 0x10,
3405                 .global1_addr = 0x1b,
3406                 .global2_addr = 0x1c,
3407                 .age_time_coeff = 15000,
3408                 .g1_irqs = 9,
3409                 .g2_irqs = 10,
3410                 .atu_move_port_mask = 0xf,
3411                 .pvt = true,
3412                 .multi_chip = true,
3413                 .tag_protocol = DSA_TAG_PROTO_DSA,
3414                 .ops = &mv88e6165_ops,
3415         },
3416
3417         [MV88E6171] = {
3418                 .prod_num = MV88E6XXX_PORT_SWITCH_ID_PROD_6171,
3419                 .family = MV88E6XXX_FAMILY_6351,
3420                 .name = "Marvell 88E6171",
3421                 .num_databases = 4096,
3422                 .num_ports = 7,
3423                 .max_vid = 4095,
3424                 .port_base_addr = 0x10,
3425                 .global1_addr = 0x1b,
3426                 .global2_addr = 0x1c,
3427                 .age_time_coeff = 15000,
3428                 .g1_irqs = 9,
3429                 .g2_irqs = 10,
3430                 .atu_move_port_mask = 0xf,
3431                 .pvt = true,
3432                 .multi_chip = true,
3433                 .tag_protocol = DSA_TAG_PROTO_EDSA,
3434                 .ops = &mv88e6171_ops,
3435         },
3436
3437         [MV88E6172] = {
3438                 .prod_num = MV88E6XXX_PORT_SWITCH_ID_PROD_6172,
3439                 .family = MV88E6XXX_FAMILY_6352,
3440                 .name = "Marvell 88E6172",
3441                 .num_databases = 4096,
3442                 .num_ports = 7,
3443                 .max_vid = 4095,
3444                 .port_base_addr = 0x10,
3445                 .global1_addr = 0x1b,
3446                 .global2_addr = 0x1c,
3447                 .age_time_coeff = 15000,
3448                 .g1_irqs = 9,
3449                 .g2_irqs = 10,
3450                 .atu_move_port_mask = 0xf,
3451                 .pvt = true,
3452                 .multi_chip = true,
3453                 .tag_protocol = DSA_TAG_PROTO_EDSA,
3454                 .ops = &mv88e6172_ops,
3455         },
3456
3457         [MV88E6175] = {
3458                 .prod_num = MV88E6XXX_PORT_SWITCH_ID_PROD_6175,
3459                 .family = MV88E6XXX_FAMILY_6351,
3460                 .name = "Marvell 88E6175",
3461                 .num_databases = 4096,
3462                 .num_ports = 7,
3463                 .max_vid = 4095,
3464                 .port_base_addr = 0x10,
3465                 .global1_addr = 0x1b,
3466                 .global2_addr = 0x1c,
3467                 .age_time_coeff = 15000,
3468                 .g1_irqs = 9,
3469                 .g2_irqs = 10,
3470                 .atu_move_port_mask = 0xf,
3471                 .pvt = true,
3472                 .multi_chip = true,
3473                 .tag_protocol = DSA_TAG_PROTO_EDSA,
3474                 .ops = &mv88e6175_ops,
3475         },
3476
3477         [MV88E6176] = {
3478                 .prod_num = MV88E6XXX_PORT_SWITCH_ID_PROD_6176,
3479                 .family = MV88E6XXX_FAMILY_6352,
3480                 .name = "Marvell 88E6176",
3481                 .num_databases = 4096,
3482                 .num_ports = 7,
3483                 .max_vid = 4095,
3484                 .port_base_addr = 0x10,
3485                 .global1_addr = 0x1b,
3486                 .global2_addr = 0x1c,
3487                 .age_time_coeff = 15000,
3488                 .g1_irqs = 9,
3489                 .g2_irqs = 10,
3490                 .atu_move_port_mask = 0xf,
3491                 .pvt = true,
3492                 .multi_chip = true,
3493                 .tag_protocol = DSA_TAG_PROTO_EDSA,
3494                 .ops = &mv88e6176_ops,
3495         },
3496
3497         [MV88E6185] = {
3498                 .prod_num = MV88E6XXX_PORT_SWITCH_ID_PROD_6185,
3499                 .family = MV88E6XXX_FAMILY_6185,
3500                 .name = "Marvell 88E6185",
3501                 .num_databases = 256,
3502                 .num_ports = 10,
3503                 .max_vid = 4095,
3504                 .port_base_addr = 0x10,
3505                 .global1_addr = 0x1b,
3506                 .global2_addr = 0x1c,
3507                 .age_time_coeff = 15000,
3508                 .g1_irqs = 8,
3509                 .atu_move_port_mask = 0xf,
3510                 .multi_chip = true,
3511                 .tag_protocol = DSA_TAG_PROTO_EDSA,
3512                 .ops = &mv88e6185_ops,
3513         },
3514
3515         [MV88E6190] = {
3516                 .prod_num = MV88E6XXX_PORT_SWITCH_ID_PROD_6190,
3517                 .family = MV88E6XXX_FAMILY_6390,
3518                 .name = "Marvell 88E6190",
3519                 .num_databases = 4096,
3520                 .num_ports = 11,        /* 10 + Z80 */
3521                 .max_vid = 8191,
3522                 .port_base_addr = 0x0,
3523                 .global1_addr = 0x1b,
3524                 .global2_addr = 0x1c,
3525                 .tag_protocol = DSA_TAG_PROTO_DSA,
3526                 .age_time_coeff = 3750,
3527                 .g1_irqs = 9,
3528                 .g2_irqs = 14,
3529                 .pvt = true,
3530                 .multi_chip = true,
3531                 .atu_move_port_mask = 0x1f,
3532                 .ops = &mv88e6190_ops,
3533         },
3534
3535         [MV88E6190X] = {
3536                 .prod_num = MV88E6XXX_PORT_SWITCH_ID_PROD_6190X,
3537                 .family = MV88E6XXX_FAMILY_6390,
3538                 .name = "Marvell 88E6190X",
3539                 .num_databases = 4096,
3540                 .num_ports = 11,        /* 10 + Z80 */
3541                 .max_vid = 8191,
3542                 .port_base_addr = 0x0,
3543                 .global1_addr = 0x1b,
3544                 .global2_addr = 0x1c,
3545                 .age_time_coeff = 3750,
3546                 .g1_irqs = 9,
3547                 .g2_irqs = 14,
3548                 .atu_move_port_mask = 0x1f,
3549                 .pvt = true,
3550                 .multi_chip = true,
3551                 .tag_protocol = DSA_TAG_PROTO_DSA,
3552                 .ops = &mv88e6190x_ops,
3553         },
3554
3555         [MV88E6191] = {
3556                 .prod_num = MV88E6XXX_PORT_SWITCH_ID_PROD_6191,
3557                 .family = MV88E6XXX_FAMILY_6390,
3558                 .name = "Marvell 88E6191",
3559                 .num_databases = 4096,
3560                 .num_ports = 11,        /* 10 + Z80 */
3561                 .max_vid = 8191,
3562                 .port_base_addr = 0x0,
3563                 .global1_addr = 0x1b,
3564                 .global2_addr = 0x1c,
3565                 .age_time_coeff = 3750,
3566                 .g1_irqs = 9,
3567                 .g2_irqs = 14,
3568                 .atu_move_port_mask = 0x1f,
3569                 .pvt = true,
3570                 .multi_chip = true,
3571                 .tag_protocol = DSA_TAG_PROTO_DSA,
3572                 .ops = &mv88e6191_ops,
3573         },
3574
3575         [MV88E6240] = {
3576                 .prod_num = MV88E6XXX_PORT_SWITCH_ID_PROD_6240,
3577                 .family = MV88E6XXX_FAMILY_6352,
3578                 .name = "Marvell 88E6240",
3579                 .num_databases = 4096,
3580                 .num_ports = 7,
3581                 .max_vid = 4095,
3582                 .port_base_addr = 0x10,
3583                 .global1_addr = 0x1b,
3584                 .global2_addr = 0x1c,
3585                 .age_time_coeff = 15000,
3586                 .g1_irqs = 9,
3587                 .g2_irqs = 10,
3588                 .atu_move_port_mask = 0xf,
3589                 .pvt = true,
3590                 .multi_chip = true,
3591                 .tag_protocol = DSA_TAG_PROTO_EDSA,
3592                 .ops = &mv88e6240_ops,
3593         },
3594
3595         [MV88E6290] = {
3596                 .prod_num = MV88E6XXX_PORT_SWITCH_ID_PROD_6290,
3597                 .family = MV88E6XXX_FAMILY_6390,
3598                 .name = "Marvell 88E6290",
3599                 .num_databases = 4096,
3600                 .num_ports = 11,        /* 10 + Z80 */
3601                 .max_vid = 8191,
3602                 .port_base_addr = 0x0,
3603                 .global1_addr = 0x1b,
3604                 .global2_addr = 0x1c,
3605                 .age_time_coeff = 3750,
3606                 .g1_irqs = 9,
3607                 .g2_irqs = 14,
3608                 .atu_move_port_mask = 0x1f,
3609                 .pvt = true,
3610                 .multi_chip = true,
3611                 .tag_protocol = DSA_TAG_PROTO_DSA,
3612                 .ops = &mv88e6290_ops,
3613         },
3614
3615         [MV88E6320] = {
3616                 .prod_num = MV88E6XXX_PORT_SWITCH_ID_PROD_6320,
3617                 .family = MV88E6XXX_FAMILY_6320,
3618                 .name = "Marvell 88E6320",
3619                 .num_databases = 4096,
3620                 .num_ports = 7,
3621                 .max_vid = 4095,
3622                 .port_base_addr = 0x10,
3623                 .global1_addr = 0x1b,
3624                 .global2_addr = 0x1c,
3625                 .age_time_coeff = 15000,
3626                 .g1_irqs = 8,
3627                 .atu_move_port_mask = 0xf,
3628                 .pvt = true,
3629                 .multi_chip = true,
3630                 .tag_protocol = DSA_TAG_PROTO_EDSA,
3631                 .ops = &mv88e6320_ops,
3632         },
3633
3634         [MV88E6321] = {
3635                 .prod_num = MV88E6XXX_PORT_SWITCH_ID_PROD_6321,
3636                 .family = MV88E6XXX_FAMILY_6320,
3637                 .name = "Marvell 88E6321",
3638                 .num_databases = 4096,
3639                 .num_ports = 7,
3640                 .max_vid = 4095,
3641                 .port_base_addr = 0x10,
3642                 .global1_addr = 0x1b,
3643                 .global2_addr = 0x1c,
3644                 .age_time_coeff = 15000,
3645                 .g1_irqs = 8,
3646                 .atu_move_port_mask = 0xf,
3647                 .multi_chip = true,
3648                 .tag_protocol = DSA_TAG_PROTO_EDSA,
3649                 .ops = &mv88e6321_ops,
3650         },
3651
3652         [MV88E6341] = {
3653                 .prod_num = MV88E6XXX_PORT_SWITCH_ID_PROD_6341,
3654                 .family = MV88E6XXX_FAMILY_6341,
3655                 .name = "Marvell 88E6341",
3656                 .num_databases = 4096,
3657                 .num_ports = 6,
3658                 .max_vid = 4095,
3659                 .port_base_addr = 0x10,
3660                 .global1_addr = 0x1b,
3661                 .global2_addr = 0x1c,
3662                 .age_time_coeff = 3750,
3663                 .atu_move_port_mask = 0x1f,
3664                 .g2_irqs = 10,
3665                 .pvt = true,
3666                 .multi_chip = true,
3667                 .tag_protocol = DSA_TAG_PROTO_EDSA,
3668                 .ops = &mv88e6341_ops,
3669         },
3670
3671         [MV88E6350] = {
3672                 .prod_num = MV88E6XXX_PORT_SWITCH_ID_PROD_6350,
3673                 .family = MV88E6XXX_FAMILY_6351,
3674                 .name = "Marvell 88E6350",
3675                 .num_databases = 4096,
3676                 .num_ports = 7,
3677                 .max_vid = 4095,
3678                 .port_base_addr = 0x10,
3679                 .global1_addr = 0x1b,
3680                 .global2_addr = 0x1c,
3681                 .age_time_coeff = 15000,
3682                 .g1_irqs = 9,
3683                 .g2_irqs = 10,
3684                 .atu_move_port_mask = 0xf,
3685                 .pvt = true,
3686                 .multi_chip = true,
3687                 .tag_protocol = DSA_TAG_PROTO_EDSA,
3688                 .ops = &mv88e6350_ops,
3689         },
3690
3691         [MV88E6351] = {
3692                 .prod_num = MV88E6XXX_PORT_SWITCH_ID_PROD_6351,
3693                 .family = MV88E6XXX_FAMILY_6351,
3694                 .name = "Marvell 88E6351",
3695                 .num_databases = 4096,
3696                 .num_ports = 7,
3697                 .max_vid = 4095,
3698                 .port_base_addr = 0x10,
3699                 .global1_addr = 0x1b,
3700                 .global2_addr = 0x1c,
3701                 .age_time_coeff = 15000,
3702                 .g1_irqs = 9,
3703                 .g2_irqs = 10,
3704                 .atu_move_port_mask = 0xf,
3705                 .pvt = true,
3706                 .multi_chip = true,
3707                 .tag_protocol = DSA_TAG_PROTO_EDSA,
3708                 .ops = &mv88e6351_ops,
3709         },
3710
3711         [MV88E6352] = {
3712                 .prod_num = MV88E6XXX_PORT_SWITCH_ID_PROD_6352,
3713                 .family = MV88E6XXX_FAMILY_6352,
3714                 .name = "Marvell 88E6352",
3715                 .num_databases = 4096,
3716                 .num_ports = 7,
3717                 .max_vid = 4095,
3718                 .port_base_addr = 0x10,
3719                 .global1_addr = 0x1b,
3720                 .global2_addr = 0x1c,
3721                 .age_time_coeff = 15000,
3722                 .g1_irqs = 9,
3723                 .g2_irqs = 10,
3724                 .atu_move_port_mask = 0xf,
3725                 .pvt = true,
3726                 .multi_chip = true,
3727                 .tag_protocol = DSA_TAG_PROTO_EDSA,
3728                 .ops = &mv88e6352_ops,
3729         },
3730         [MV88E6390] = {
3731                 .prod_num = MV88E6XXX_PORT_SWITCH_ID_PROD_6390,
3732                 .family = MV88E6XXX_FAMILY_6390,
3733                 .name = "Marvell 88E6390",
3734                 .num_databases = 4096,
3735                 .num_ports = 11,        /* 10 + Z80 */
3736                 .max_vid = 8191,
3737                 .port_base_addr = 0x0,
3738                 .global1_addr = 0x1b,
3739                 .global2_addr = 0x1c,
3740                 .age_time_coeff = 3750,
3741                 .g1_irqs = 9,
3742                 .g2_irqs = 14,
3743                 .atu_move_port_mask = 0x1f,
3744                 .pvt = true,
3745                 .multi_chip = true,
3746                 .tag_protocol = DSA_TAG_PROTO_DSA,
3747                 .ops = &mv88e6390_ops,
3748         },
3749         [MV88E6390X] = {
3750                 .prod_num = MV88E6XXX_PORT_SWITCH_ID_PROD_6390X,
3751                 .family = MV88E6XXX_FAMILY_6390,
3752                 .name = "Marvell 88E6390X",
3753                 .num_databases = 4096,
3754                 .num_ports = 11,        /* 10 + Z80 */
3755                 .max_vid = 8191,
3756                 .port_base_addr = 0x0,
3757                 .global1_addr = 0x1b,
3758                 .global2_addr = 0x1c,
3759                 .age_time_coeff = 3750,
3760                 .g1_irqs = 9,
3761                 .g2_irqs = 14,
3762                 .atu_move_port_mask = 0x1f,
3763                 .pvt = true,
3764                 .multi_chip = true,
3765                 .tag_protocol = DSA_TAG_PROTO_DSA,
3766                 .ops = &mv88e6390x_ops,
3767         },
3768 };
3769
3770 static const struct mv88e6xxx_info *mv88e6xxx_lookup_info(unsigned int prod_num)
3771 {
3772         int i;
3773
3774         for (i = 0; i < ARRAY_SIZE(mv88e6xxx_table); ++i)
3775                 if (mv88e6xxx_table[i].prod_num == prod_num)
3776                         return &mv88e6xxx_table[i];
3777
3778         return NULL;
3779 }
3780
3781 static int mv88e6xxx_detect(struct mv88e6xxx_chip *chip)
3782 {
3783         const struct mv88e6xxx_info *info;
3784         unsigned int prod_num, rev;
3785         u16 id;
3786         int err;
3787
3788         mutex_lock(&chip->reg_lock);
3789         err = mv88e6xxx_port_read(chip, 0, MV88E6XXX_PORT_SWITCH_ID, &id);
3790         mutex_unlock(&chip->reg_lock);
3791         if (err)
3792                 return err;
3793
3794         prod_num = id & MV88E6XXX_PORT_SWITCH_ID_PROD_MASK;
3795         rev = id & MV88E6XXX_PORT_SWITCH_ID_REV_MASK;
3796
3797         info = mv88e6xxx_lookup_info(prod_num);
3798         if (!info)
3799                 return -ENODEV;
3800
3801         /* Update the compatible info with the probed one */
3802         chip->info = info;
3803
3804         err = mv88e6xxx_g2_require(chip);
3805         if (err)
3806                 return err;
3807
3808         dev_info(chip->dev, "switch 0x%x detected: %s, revision %u\n",
3809                  chip->info->prod_num, chip->info->name, rev);
3810
3811         return 0;
3812 }
3813
3814 static struct mv88e6xxx_chip *mv88e6xxx_alloc_chip(struct device *dev)
3815 {
3816         struct mv88e6xxx_chip *chip;
3817
3818         chip = devm_kzalloc(dev, sizeof(*chip), GFP_KERNEL);
3819         if (!chip)
3820                 return NULL;
3821
3822         chip->dev = dev;
3823
3824         mutex_init(&chip->reg_lock);
3825         INIT_LIST_HEAD(&chip->mdios);
3826
3827         return chip;
3828 }
3829
3830 static int mv88e6xxx_smi_init(struct mv88e6xxx_chip *chip,
3831                               struct mii_bus *bus, int sw_addr)
3832 {
3833         if (sw_addr == 0)
3834                 chip->smi_ops = &mv88e6xxx_smi_single_chip_ops;
3835         else if (chip->info->multi_chip)
3836                 chip->smi_ops = &mv88e6xxx_smi_multi_chip_ops;
3837         else
3838                 return -EINVAL;
3839
3840         chip->bus = bus;
3841         chip->sw_addr = sw_addr;
3842
3843         return 0;
3844 }
3845
3846 static enum dsa_tag_protocol mv88e6xxx_get_tag_protocol(struct dsa_switch *ds)
3847 {
3848         struct mv88e6xxx_chip *chip = ds->priv;
3849
3850         return chip->info->tag_protocol;
3851 }
3852
3853 static const char *mv88e6xxx_drv_probe(struct device *dsa_dev,
3854                                        struct device *host_dev, int sw_addr,
3855                                        void **priv)
3856 {
3857         struct mv88e6xxx_chip *chip;
3858         struct mii_bus *bus;
3859         int err;
3860
3861         bus = dsa_host_dev_to_mii_bus(host_dev);
3862         if (!bus)
3863                 return NULL;
3864
3865         chip = mv88e6xxx_alloc_chip(dsa_dev);
3866         if (!chip)
3867                 return NULL;
3868
3869         /* Legacy SMI probing will only support chips similar to 88E6085 */
3870         chip->info = &mv88e6xxx_table[MV88E6085];
3871
3872         err = mv88e6xxx_smi_init(chip, bus, sw_addr);
3873         if (err)
3874                 goto free;
3875
3876         err = mv88e6xxx_detect(chip);
3877         if (err)
3878                 goto free;
3879
3880         mutex_lock(&chip->reg_lock);
3881         err = mv88e6xxx_switch_reset(chip);
3882         mutex_unlock(&chip->reg_lock);
3883         if (err)
3884                 goto free;
3885
3886         mv88e6xxx_phy_init(chip);
3887
3888         err = mv88e6xxx_mdios_register(chip, NULL);
3889         if (err)
3890                 goto free;
3891
3892         *priv = chip;
3893
3894         return chip->info->name;
3895 free:
3896         devm_kfree(dsa_dev, chip);
3897
3898         return NULL;
3899 }
3900
3901 static int mv88e6xxx_port_mdb_prepare(struct dsa_switch *ds, int port,
3902                                       const struct switchdev_obj_port_mdb *mdb,
3903                                       struct switchdev_trans *trans)
3904 {
3905         /* We don't need any dynamic resource from the kernel (yet),
3906          * so skip the prepare phase.
3907          */
3908
3909         return 0;
3910 }
3911
3912 static void mv88e6xxx_port_mdb_add(struct dsa_switch *ds, int port,
3913                                    const struct switchdev_obj_port_mdb *mdb,
3914                                    struct switchdev_trans *trans)
3915 {
3916         struct mv88e6xxx_chip *chip = ds->priv;
3917
3918         mutex_lock(&chip->reg_lock);
3919         if (mv88e6xxx_port_db_load_purge(chip, port, mdb->addr, mdb->vid,
3920                                          MV88E6XXX_G1_ATU_DATA_STATE_MC_STATIC))
3921                 dev_err(ds->dev, "p%d: failed to load multicast MAC address\n",
3922                         port);
3923         mutex_unlock(&chip->reg_lock);
3924 }
3925
3926 static int mv88e6xxx_port_mdb_del(struct dsa_switch *ds, int port,
3927                                   const struct switchdev_obj_port_mdb *mdb)
3928 {
3929         struct mv88e6xxx_chip *chip = ds->priv;
3930         int err;
3931
3932         mutex_lock(&chip->reg_lock);
3933         err = mv88e6xxx_port_db_load_purge(chip, port, mdb->addr, mdb->vid,
3934                                            MV88E6XXX_G1_ATU_DATA_STATE_UNUSED);
3935         mutex_unlock(&chip->reg_lock);
3936
3937         return err;
3938 }
3939
3940 static int mv88e6xxx_port_mdb_dump(struct dsa_switch *ds, int port,
3941                                    struct switchdev_obj_port_mdb *mdb,
3942                                    switchdev_obj_dump_cb_t *cb)
3943 {
3944         struct mv88e6xxx_chip *chip = ds->priv;
3945         int err;
3946
3947         mutex_lock(&chip->reg_lock);
3948         err = mv88e6xxx_port_db_dump(chip, port, &mdb->obj, cb);
3949         mutex_unlock(&chip->reg_lock);
3950
3951         return err;
3952 }
3953
3954 static const struct dsa_switch_ops mv88e6xxx_switch_ops = {
3955         .probe                  = mv88e6xxx_drv_probe,
3956         .get_tag_protocol       = mv88e6xxx_get_tag_protocol,
3957         .setup                  = mv88e6xxx_setup,
3958         .set_addr               = mv88e6xxx_set_addr,
3959         .adjust_link            = mv88e6xxx_adjust_link,
3960         .get_strings            = mv88e6xxx_get_strings,
3961         .get_ethtool_stats      = mv88e6xxx_get_ethtool_stats,
3962         .get_sset_count         = mv88e6xxx_get_sset_count,
3963         .port_enable            = mv88e6xxx_port_enable,
3964         .port_disable           = mv88e6xxx_port_disable,
3965         .set_eee                = mv88e6xxx_set_eee,
3966         .get_eee                = mv88e6xxx_get_eee,
3967         .get_eeprom_len         = mv88e6xxx_get_eeprom_len,
3968         .get_eeprom             = mv88e6xxx_get_eeprom,
3969         .set_eeprom             = mv88e6xxx_set_eeprom,
3970         .get_regs_len           = mv88e6xxx_get_regs_len,
3971         .get_regs               = mv88e6xxx_get_regs,
3972         .set_ageing_time        = mv88e6xxx_set_ageing_time,
3973         .port_bridge_join       = mv88e6xxx_port_bridge_join,
3974         .port_bridge_leave      = mv88e6xxx_port_bridge_leave,
3975         .port_stp_state_set     = mv88e6xxx_port_stp_state_set,
3976         .port_fast_age          = mv88e6xxx_port_fast_age,
3977         .port_vlan_filtering    = mv88e6xxx_port_vlan_filtering,
3978         .port_vlan_prepare      = mv88e6xxx_port_vlan_prepare,
3979         .port_vlan_add          = mv88e6xxx_port_vlan_add,
3980         .port_vlan_del          = mv88e6xxx_port_vlan_del,
3981         .port_vlan_dump         = mv88e6xxx_port_vlan_dump,
3982         .port_fdb_prepare       = mv88e6xxx_port_fdb_prepare,
3983         .port_fdb_add           = mv88e6xxx_port_fdb_add,
3984         .port_fdb_del           = mv88e6xxx_port_fdb_del,
3985         .port_fdb_dump          = mv88e6xxx_port_fdb_dump,
3986         .port_mdb_prepare       = mv88e6xxx_port_mdb_prepare,
3987         .port_mdb_add           = mv88e6xxx_port_mdb_add,
3988         .port_mdb_del           = mv88e6xxx_port_mdb_del,
3989         .port_mdb_dump          = mv88e6xxx_port_mdb_dump,
3990         .crosschip_bridge_join  = mv88e6xxx_crosschip_bridge_join,
3991         .crosschip_bridge_leave = mv88e6xxx_crosschip_bridge_leave,
3992 };
3993
3994 static struct dsa_switch_driver mv88e6xxx_switch_drv = {
3995         .ops                    = &mv88e6xxx_switch_ops,
3996 };
3997
3998 static int mv88e6xxx_register_switch(struct mv88e6xxx_chip *chip)
3999 {
4000         struct device *dev = chip->dev;
4001         struct dsa_switch *ds;
4002
4003         ds = dsa_switch_alloc(dev, mv88e6xxx_num_ports(chip));
4004         if (!ds)
4005                 return -ENOMEM;
4006
4007         ds->priv = chip;
4008         ds->ops = &mv88e6xxx_switch_ops;
4009         ds->ageing_time_min = chip->info->age_time_coeff;
4010         ds->ageing_time_max = chip->info->age_time_coeff * U8_MAX;
4011
4012         dev_set_drvdata(dev, ds);
4013
4014         return dsa_register_switch(ds);
4015 }
4016
4017 static void mv88e6xxx_unregister_switch(struct mv88e6xxx_chip *chip)
4018 {
4019         dsa_unregister_switch(chip->ds);
4020 }
4021
4022 static int mv88e6xxx_probe(struct mdio_device *mdiodev)
4023 {
4024         struct device *dev = &mdiodev->dev;
4025         struct device_node *np = dev->of_node;
4026         const struct mv88e6xxx_info *compat_info;
4027         struct mv88e6xxx_chip *chip;
4028         u32 eeprom_len;
4029         int err;
4030
4031         compat_info = of_device_get_match_data(dev);
4032         if (!compat_info)
4033                 return -EINVAL;
4034
4035         chip = mv88e6xxx_alloc_chip(dev);
4036         if (!chip)
4037                 return -ENOMEM;
4038
4039         chip->info = compat_info;
4040
4041         err = mv88e6xxx_smi_init(chip, mdiodev->bus, mdiodev->addr);
4042         if (err)
4043                 return err;
4044
4045         chip->reset = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_LOW);
4046         if (IS_ERR(chip->reset))
4047                 return PTR_ERR(chip->reset);
4048
4049         err = mv88e6xxx_detect(chip);
4050         if (err)
4051                 return err;
4052
4053         mv88e6xxx_phy_init(chip);
4054
4055         if (chip->info->ops->get_eeprom &&
4056             !of_property_read_u32(np, "eeprom-length", &eeprom_len))
4057                 chip->eeprom_len = eeprom_len;
4058
4059         mutex_lock(&chip->reg_lock);
4060         err = mv88e6xxx_switch_reset(chip);
4061         mutex_unlock(&chip->reg_lock);
4062         if (err)
4063                 goto out;
4064
4065         chip->irq = of_irq_get(np, 0);
4066         if (chip->irq == -EPROBE_DEFER) {
4067                 err = chip->irq;
4068                 goto out;
4069         }
4070
4071         if (chip->irq > 0) {
4072                 /* Has to be performed before the MDIO bus is created,
4073                  * because the PHYs will link there interrupts to these
4074                  * interrupt controllers
4075                  */
4076                 mutex_lock(&chip->reg_lock);
4077                 err = mv88e6xxx_g1_irq_setup(chip);
4078                 mutex_unlock(&chip->reg_lock);
4079
4080                 if (err)
4081                         goto out;
4082
4083                 if (chip->info->g2_irqs > 0) {
4084                         err = mv88e6xxx_g2_irq_setup(chip);
4085                         if (err)
4086                                 goto out_g1_irq;
4087                 }
4088         }
4089
4090         err = mv88e6xxx_mdios_register(chip, np);
4091         if (err)
4092                 goto out_g2_irq;
4093
4094         err = mv88e6xxx_register_switch(chip);
4095         if (err)
4096                 goto out_mdio;
4097
4098         return 0;
4099
4100 out_mdio:
4101         mv88e6xxx_mdios_unregister(chip);
4102 out_g2_irq:
4103         if (chip->info->g2_irqs > 0 && chip->irq > 0)
4104                 mv88e6xxx_g2_irq_free(chip);
4105 out_g1_irq:
4106         if (chip->irq > 0) {
4107                 mutex_lock(&chip->reg_lock);
4108                 mv88e6xxx_g1_irq_free(chip);
4109                 mutex_unlock(&chip->reg_lock);
4110         }
4111 out:
4112         return err;
4113 }
4114
4115 static void mv88e6xxx_remove(struct mdio_device *mdiodev)
4116 {
4117         struct dsa_switch *ds = dev_get_drvdata(&mdiodev->dev);
4118         struct mv88e6xxx_chip *chip = ds->priv;
4119
4120         mv88e6xxx_phy_destroy(chip);
4121         mv88e6xxx_unregister_switch(chip);
4122         mv88e6xxx_mdios_unregister(chip);
4123
4124         if (chip->irq > 0) {
4125                 if (chip->info->g2_irqs > 0)
4126                         mv88e6xxx_g2_irq_free(chip);
4127                 mv88e6xxx_g1_irq_free(chip);
4128         }
4129 }
4130
4131 static const struct of_device_id mv88e6xxx_of_match[] = {
4132         {
4133                 .compatible = "marvell,mv88e6085",
4134                 .data = &mv88e6xxx_table[MV88E6085],
4135         },
4136         {
4137                 .compatible = "marvell,mv88e6190",
4138                 .data = &mv88e6xxx_table[MV88E6190],
4139         },
4140         { /* sentinel */ },
4141 };
4142
4143 MODULE_DEVICE_TABLE(of, mv88e6xxx_of_match);
4144
4145 static struct mdio_driver mv88e6xxx_driver = {
4146         .probe  = mv88e6xxx_probe,
4147         .remove = mv88e6xxx_remove,
4148         .mdiodrv.driver = {
4149                 .name = "mv88e6085",
4150                 .of_match_table = mv88e6xxx_of_match,
4151         },
4152 };
4153
4154 static int __init mv88e6xxx_init(void)
4155 {
4156         register_switch_driver(&mv88e6xxx_switch_drv);
4157         return mdio_driver_register(&mv88e6xxx_driver);
4158 }
4159 module_init(mv88e6xxx_init);
4160
4161 static void __exit mv88e6xxx_cleanup(void)
4162 {
4163         mdio_driver_unregister(&mv88e6xxx_driver);
4164         unregister_switch_driver(&mv88e6xxx_switch_drv);
4165 }
4166 module_exit(mv88e6xxx_cleanup);
4167
4168 MODULE_AUTHOR("Lennert Buytenhek <buytenh@wantstofly.org>");
4169 MODULE_DESCRIPTION("Driver for Marvell 88E6XXX ethernet switch chips");
4170 MODULE_LICENSE("GPL");