drivers/net/dsa/mv88e6xxx/serdes.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Marvell 88E6xxx SERDES manipulation, via SMI bus
   4  *
   5  * Copyright (c) 2008 Marvell Semiconductor
   6  *
   7  * Copyright (c) 2017 Andrew Lunn <andrew@lunn.ch>
   8  */
   9
  10 #include <linux/interrupt.h>
  11 #include <linux/irqdomain.h>
  12 #include <linux/mii.h>
  13
  14 #include "chip.h"
  15 #include "global2.h"
  16 #include "phy.h"
  17 #include "port.h"
  18 #include "serdes.h"
  19
  20 static int mv88e6352_serdes_read(struct mv88e6xxx_chip *chip, int reg,
  21                                  u16 *val)
  22 {
  23         return mv88e6xxx_phy_page_read(chip, MV88E6352_ADDR_SERDES,
  24                                        MV88E6352_SERDES_PAGE_FIBER,
  25                                        reg, val);
  26 }
  27
  28 static int mv88e6352_serdes_write(struct mv88e6xxx_chip *chip, int reg,
  29                                   u16 val)
  30 {
  31         return mv88e6xxx_phy_page_write(chip, MV88E6352_ADDR_SERDES,
  32                                         MV88E6352_SERDES_PAGE_FIBER,
  33                                         reg, val);
  34 }
  35
  36 static int mv88e6390_serdes_read(struct mv88e6xxx_chip *chip,
  37                                  int lane, int device, int reg, u16 *val)
  38 {
  39         int reg_c45 = MII_ADDR_C45 | device << 16 | reg;
  40
  41         return mv88e6xxx_phy_read(chip, lane, reg_c45, val);
  42 }
  43
  44 static int mv88e6390_serdes_write(struct mv88e6xxx_chip *chip,
  45                                   int lane, int device, int reg, u16 val)
  46 {
  47         int reg_c45 = MII_ADDR_C45 | device << 16 | reg;
  48
  49         return mv88e6xxx_phy_write(chip, lane, reg_c45, val);
  50 }
  51
  52 static int mv88e6xxx_serdes_pcs_get_state(struct mv88e6xxx_chip *chip,
  53                                           u16 status, u16 lpa,
  54                                           struct phylink_link_state *state)
  55 {
  56         if (status & MV88E6390_SGMII_PHY_STATUS_SPD_DPL_VALID) {
  57                 state->link = !!(status & MV88E6390_SGMII_PHY_STATUS_LINK);
  58                 state->duplex = status &
  59                                 MV88E6390_SGMII_PHY_STATUS_DUPLEX_FULL ?
  60                                                  DUPLEX_FULL : DUPLEX_HALF;
  61
  62                 if (status & MV88E6390_SGMII_PHY_STATUS_TX_PAUSE)
  63                         state->pause |= MLO_PAUSE_TX;
  64                 if (status & MV88E6390_SGMII_PHY_STATUS_RX_PAUSE)
  65                         state->pause |= MLO_PAUSE_RX;
  66
  67                 switch (status & MV88E6390_SGMII_PHY_STATUS_SPEED_MASK) {
  68                 case MV88E6390_SGMII_PHY_STATUS_SPEED_1000:
  69                         if (state->interface == PHY_INTERFACE_MODE_2500BASEX)
  70                                 state->speed = SPEED_2500;
  71                         else
  72                                 state->speed = SPEED_1000;
  73                         break;
  74                 case MV88E6390_SGMII_PHY_STATUS_SPEED_100:
  75                         state->speed = SPEED_100;
  76                         break;
  77                 case MV88E6390_SGMII_PHY_STATUS_SPEED_10:
  78                         state->speed = SPEED_10;
  79                         break;
  80                 default:
  81                         dev_err(chip->dev, "invalid PHY speed\n");
  82                         return -EINVAL;
  83                 }
  84         } else {
  85                 state->link = false;
  86         }
  87
  88         if (state->interface == PHY_INTERFACE_MODE_2500BASEX)
  89                 mii_lpa_mod_linkmode_x(state->lp_advertising, lpa,
  90                                        ETHTOOL_LINK_MODE_2500baseX_Full_BIT);
  91         else if (state->interface == PHY_INTERFACE_MODE_1000BASEX)
  92                 mii_lpa_mod_linkmode_x(state->lp_advertising, lpa,
  93                                        ETHTOOL_LINK_MODE_1000baseX_Full_BIT);
  94
  95         return 0;
  96 }
  97
  98 int mv88e6352_serdes_power(struct mv88e6xxx_chip *chip, int port, int lane,
  99                            bool up)
 100 {
 101         u16 val, new_val;
 102         int err;
 103
 104         err = mv88e6352_serdes_read(chip, MII_BMCR, &val);
 105         if (err)
 106                 return err;
 107
 108         if (up)
 109                 new_val = val & ~BMCR_PDOWN;
 110         else
 111                 new_val = val | BMCR_PDOWN;
 112
 113         if (val != new_val)
 114                 err = mv88e6352_serdes_write(chip, MII_BMCR, new_val);
 115
 116         return err;
 117 }
 118
 119 int mv88e6352_serdes_pcs_config(struct mv88e6xxx_chip *chip, int port,
 120                                 int lane, unsigned int mode,
 121                                 phy_interface_t interface,
 122                                 const unsigned long *advertise)
 123 {
 124         u16 adv, bmcr, val;
 125         bool changed;
 126         int err;
 127
 128         switch (interface) {
 129         case PHY_INTERFACE_MODE_SGMII:
 130                 adv = 0x0001;
 131                 break;
 132
 133         case PHY_INTERFACE_MODE_1000BASEX:
 134                 adv = linkmode_adv_to_mii_adv_x(advertise,
 135                                         ETHTOOL_LINK_MODE_1000baseX_Full_BIT);
 136                 break;
 137
 138         default:
 139                 return 0;
 140         }
 141
 142         err = mv88e6352_serdes_read(chip, MII_ADVERTISE, &val);
 143         if (err)
 144                 return err;
 145
 146         changed = val != adv;
 147         if (changed) {
 148                 err = mv88e6352_serdes_write(chip, MII_ADVERTISE, adv);
 149                 if (err)
 150                         return err;
 151         }
 152
 153         err = mv88e6352_serdes_read(chip, MII_BMCR, &val);
 154         if (err)
 155                 return err;
 156
 157         if (phylink_autoneg_inband(mode))
 158                 bmcr = val | BMCR_ANENABLE;
 159         else
 160                 bmcr = val & ~BMCR_ANENABLE;
 161
 162         if (bmcr == val)
 163                 return changed;
 164
 165         return mv88e6352_serdes_write(chip, MII_BMCR, bmcr);
 166 }
 167
 168 int mv88e6352_serdes_pcs_get_state(struct mv88e6xxx_chip *chip, int port,
 169                                    int lane, struct phylink_link_state *state)
 170 {
 171         u16 lpa, status;
 172         int err;
 173
 174         err = mv88e6352_serdes_read(chip, 0x11, &status);
 175         if (err) {
 176                 dev_err(chip->dev, "can't read Serdes PHY status: %d\n", err);
 177                 return err;
 178         }
 179
 180         err = mv88e6352_serdes_read(chip, MII_LPA, &lpa);
 181         if (err) {
 182                 dev_err(chip->dev, "can't read Serdes PHY LPA: %d\n", err);
 183                 return err;
 184         }
 185
 186         return mv88e6xxx_serdes_pcs_get_state(chip, status, lpa, state);
 187 }
 188
 189 int mv88e6352_serdes_pcs_an_restart(struct mv88e6xxx_chip *chip, int port,
 190                                     int lane)
 191 {
 192         u16 bmcr;
 193         int err;
 194
 195         err = mv88e6352_serdes_read(chip, MII_BMCR, &bmcr);
 196         if (err)
 197                 return err;
 198
 199         return mv88e6352_serdes_write(chip, MII_BMCR, bmcr | BMCR_ANRESTART);
 200 }
 201
 202 int mv88e6352_serdes_pcs_link_up(struct mv88e6xxx_chip *chip, int port,
 203                                  int lane, int speed, int duplex)
 204 {
 205         u16 val, bmcr;
 206         int err;
 207
 208         err = mv88e6352_serdes_read(chip, MII_BMCR, &val);
 209         if (err)
 210                 return err;
 211
 212         bmcr = val & ~(BMCR_SPEED100 | BMCR_FULLDPLX | BMCR_SPEED1000);
 213         switch (speed) {
 214         case SPEED_1000:
 215                 bmcr |= BMCR_SPEED1000;
 216                 break;
 217         case SPEED_100:
 218                 bmcr |= BMCR_SPEED100;
 219                 break;
 220         case SPEED_10:
 221                 break;
 222         }
 223
 224         if (duplex == DUPLEX_FULL)
 225                 bmcr |= BMCR_FULLDPLX;
 226
 227         if (bmcr == val)
 228                 return 0;
 229
 230         return mv88e6352_serdes_write(chip, MII_BMCR, bmcr);
 231 }
 232
 233 int mv88e6352_serdes_get_lane(struct mv88e6xxx_chip *chip, int port)
 234 {
 235         u8 cmode = chip->ports[port].cmode;
 236         int lane = -ENODEV;
 237
 238         if ((cmode == MV88E6XXX_PORT_STS_CMODE_100BASEX) ||
 239             (cmode == MV88E6XXX_PORT_STS_CMODE_1000BASEX) ||
 240             (cmode == MV88E6XXX_PORT_STS_CMODE_SGMII))
 241                 lane = 0xff; /* Unused */
 242
 243         return lane;
 244 }
 245
 246 static bool mv88e6352_port_has_serdes(struct mv88e6xxx_chip *chip, int port)
 247 {
 248         if (mv88e6xxx_serdes_get_lane(chip, port) >= 0)
 249                 return true;
 250
 251         return false;
 252 }
 253
 254 struct mv88e6352_serdes_hw_stat {
 255         char string[ETH_GSTRING_LEN];
 256         int sizeof_stat;
 257         int reg;
 258 };
 259
 260 static struct mv88e6352_serdes_hw_stat mv88e6352_serdes_hw_stats[] = {
 261         { "serdes_fibre_rx_error", 16, 21 },
 262         { "serdes_PRBS_error", 32, 24 },
 263 };
 264
 265 int mv88e6352_serdes_get_sset_count(struct mv88e6xxx_chip *chip, int port)
 266 {
 267         if (mv88e6352_port_has_serdes(chip, port))
 268                 return ARRAY_SIZE(mv88e6352_serdes_hw_stats);
 269
 270         return 0;
 271 }
 272
 273 int mv88e6352_serdes_get_strings(struct mv88e6xxx_chip *chip,
 274                                  int port, uint8_t *data)
 275 {
 276         struct mv88e6352_serdes_hw_stat *stat;
 277         int i;
 278
 279         if (!mv88e6352_port_has_serdes(chip, port))
 280                 return 0;
 281
 282         for (i = 0; i < ARRAY_SIZE(mv88e6352_serdes_hw_stats); i++) {
 283                 stat = &mv88e6352_serdes_hw_stats[i];
 284                 memcpy(data + i * ETH_GSTRING_LEN, stat->string,
 285                        ETH_GSTRING_LEN);
 286         }
 287         return ARRAY_SIZE(mv88e6352_serdes_hw_stats);
 288 }
 289
 290 static uint64_t mv88e6352_serdes_get_stat(struct mv88e6xxx_chip *chip,
 291                                           struct mv88e6352_serdes_hw_stat *stat)
 292 {
 293         u64 val = 0;
 294         u16 reg;
 295         int err;
 296
 297         err = mv88e6352_serdes_read(chip, stat->reg, &reg);
 298         if (err) {
 299                 dev_err(chip->dev, "failed to read statistic\n");
 300                 return 0;
 301         }
 302
 303         val = reg;
 304
 305         if (stat->sizeof_stat == 32) {
 306                 err = mv88e6352_serdes_read(chip, stat->reg + 1, &reg);
 307                 if (err) {
 308                         dev_err(chip->dev, "failed to read statistic\n");
 309                         return 0;
 310                 }
 311                 val = val << 16 | reg;
 312         }
 313
 314         return val;
 315 }
 316
 317 int mv88e6352_serdes_get_stats(struct mv88e6xxx_chip *chip, int port,
 318                                uint64_t *data)
 319 {
 320         struct mv88e6xxx_port *mv88e6xxx_port = &chip->ports[port];
 321         struct mv88e6352_serdes_hw_stat *stat;
 322         u64 value;
 323         int i;
 324
 325         if (!mv88e6352_port_has_serdes(chip, port))
 326                 return 0;
 327
 328         BUILD_BUG_ON(ARRAY_SIZE(mv88e6352_serdes_hw_stats) >
 329                      ARRAY_SIZE(mv88e6xxx_port->serdes_stats));
 330
 331         for (i = 0; i < ARRAY_SIZE(mv88e6352_serdes_hw_stats); i++) {
 332                 stat = &mv88e6352_serdes_hw_stats[i];
 333                 value = mv88e6352_serdes_get_stat(chip, stat);
 334                 mv88e6xxx_port->serdes_stats[i] += value;
 335                 data[i] = mv88e6xxx_port->serdes_stats[i];
 336         }
 337
 338         return ARRAY_SIZE(mv88e6352_serdes_hw_stats);
 339 }
 340
 341 static void mv88e6352_serdes_irq_link(struct mv88e6xxx_chip *chip, int port)
 342 {
 343         u16 bmsr;
 344         int err;
 345
 346         /* If the link has dropped, we want to know about it. */
 347         err = mv88e6352_serdes_read(chip, MII_BMSR, &bmsr);
 348         if (err) {
 349                 dev_err(chip->dev, "can't read Serdes BMSR: %d\n", err);
 350                 return;
 351         }
 352
 353         dsa_port_phylink_mac_change(chip->ds, port, !!(bmsr & BMSR_LSTATUS));
 354 }
 355
 356 irqreturn_t mv88e6352_serdes_irq_status(struct mv88e6xxx_chip *chip, int port,
 357                                         int lane)
 358 {
 359         irqreturn_t ret = IRQ_NONE;
 360         u16 status;
 361         int err;
 362
 363         err = mv88e6352_serdes_read(chip, MV88E6352_SERDES_INT_STATUS, &status);
 364         if (err)
 365                 return ret;
 366
 367         if (status & MV88E6352_SERDES_INT_LINK_CHANGE) {
 368                 ret = IRQ_HANDLED;
 369                 mv88e6352_serdes_irq_link(chip, port);
 370         }
 371
 372         return ret;
 373 }
 374
 375 int mv88e6352_serdes_irq_enable(struct mv88e6xxx_chip *chip, int port, int lane,
 376                                 bool enable)
 377 {
 378         u16 val = 0;
 379
 380         if (enable)
 381                 val |= MV88E6352_SERDES_INT_LINK_CHANGE;
 382
 383         return mv88e6352_serdes_write(chip, MV88E6352_SERDES_INT_ENABLE, val);
 384 }
 385
 386 unsigned int mv88e6352_serdes_irq_mapping(struct mv88e6xxx_chip *chip, int port)
 387 {
 388         return irq_find_mapping(chip->g2_irq.domain, MV88E6352_SERDES_IRQ);
 389 }
 390
 391 int mv88e6352_serdes_get_regs_len(struct mv88e6xxx_chip *chip, int port)
 392 {
 393         if (!mv88e6352_port_has_serdes(chip, port))
 394                 return 0;
 395
 396         return 32 * sizeof(u16);
 397 }
 398
 399 void mv88e6352_serdes_get_regs(struct mv88e6xxx_chip *chip, int port, void *_p)
 400 {
 401         u16 *p = _p;
 402         u16 reg;
 403         int err;
 404         int i;
 405
 406         if (!mv88e6352_port_has_serdes(chip, port))
 407                 return;
 408
 409         for (i = 0 ; i < 32; i++) {
 410                 err = mv88e6352_serdes_read(chip, i, &reg);
 411                 if (!err)
 412                         p[i] = reg;
 413         }
 414 }
 415
 416 int mv88e6341_serdes_get_lane(struct mv88e6xxx_chip *chip, int port)
 417 {
 418         u8 cmode = chip->ports[port].cmode;
 419         int lane = -ENODEV;
 420
 421         switch (port) {
 422         case 5:
 423                 if (cmode == MV88E6XXX_PORT_STS_CMODE_1000BASEX ||
 424                     cmode == MV88E6XXX_PORT_STS_CMODE_SGMII ||
 425                     cmode == MV88E6XXX_PORT_STS_CMODE_2500BASEX)
 426                         lane = MV88E6341_PORT5_LANE;
 427                 break;
 428         }
 429
 430         return lane;
 431 }
 432
 433 int mv88e6185_serdes_power(struct mv88e6xxx_chip *chip, int port, int lane,
 434                            bool up)
 435 {
 436         /* The serdes power can't be controlled on this switch chip but we need
 437          * to supply this function to avoid returning -EOPNOTSUPP in
 438          * mv88e6xxx_serdes_power_up/mv88e6xxx_serdes_power_down
 439          */
 440         return 0;
 441 }
 442
 443 int mv88e6185_serdes_get_lane(struct mv88e6xxx_chip *chip, int port)
 444 {
 445         /* There are no configurable serdes lanes on this switch chip but we
 446          * need to return a non-negative lane number so that callers of
 447          * mv88e6xxx_serdes_get_lane() know this is a serdes port.
 448          */
 449         switch (chip->ports[port].cmode) {
 450         case MV88E6185_PORT_STS_CMODE_SERDES:
 451         case MV88E6185_PORT_STS_CMODE_1000BASE_X:
 452                 return 0;
 453         default:
 454                 return -ENODEV;
 455         }
 456 }
 457
 458 int mv88e6185_serdes_pcs_get_state(struct mv88e6xxx_chip *chip, int port,
 459                                    int lane, struct phylink_link_state *state)
 460 {
 461         int err;
 462         u16 status;
 463
 464         err = mv88e6xxx_port_read(chip, port, MV88E6XXX_PORT_STS, &status);
 465         if (err)
 466                 return err;
 467
 468         state->link = !!(status & MV88E6XXX_PORT_STS_LINK);
 469
 470         if (state->link) {
 471                 state->duplex = status & MV88E6XXX_PORT_STS_DUPLEX ? DUPLEX_FULL : DUPLEX_HALF;
 472
 473                 switch (status &  MV88E6XXX_PORT_STS_SPEED_MASK) {
 474                 case MV88E6XXX_PORT_STS_SPEED_1000:
 475                         state->speed = SPEED_1000;
 476                         break;
 477                 case MV88E6XXX_PORT_STS_SPEED_100:
 478                         state->speed = SPEED_100;
 479                         break;
 480                 case MV88E6XXX_PORT_STS_SPEED_10:
 481                         state->speed = SPEED_10;
 482                         break;
 483                 default:
 484                         dev_err(chip->dev, "invalid PHY speed\n");
 485                         return -EINVAL;
 486                 }
 487         } else {
 488                 state->duplex = DUPLEX_UNKNOWN;
 489                 state->speed = SPEED_UNKNOWN;
 490         }
 491
 492         return 0;
 493 }
 494
 495 int mv88e6097_serdes_irq_enable(struct mv88e6xxx_chip *chip, int port, int lane,
 496                                 bool enable)
 497 {
 498         u8 cmode = chip->ports[port].cmode;
 499
 500         /* The serdes interrupts are enabled in the G2_INT_MASK register. We
 501          * need to return 0 to avoid returning -EOPNOTSUPP in
 502          * mv88e6xxx_serdes_irq_enable/mv88e6xxx_serdes_irq_disable
 503          */
 504         switch (cmode) {
 505         case MV88E6185_PORT_STS_CMODE_SERDES:
 506         case MV88E6185_PORT_STS_CMODE_1000BASE_X:
 507                 return 0;
 508         }
 509
 510         return -EOPNOTSUPP;
 511 }
 512
 513 static void mv88e6097_serdes_irq_link(struct mv88e6xxx_chip *chip, int port)
 514 {
 515         u16 status;
 516         int err;
 517
 518         err = mv88e6xxx_port_read(chip, port, MV88E6XXX_PORT_STS, &status);
 519         if (err) {
 520                 dev_err(chip->dev, "can't read port status: %d\n", err);
 521                 return;
 522         }
 523
 524         dsa_port_phylink_mac_change(chip->ds, port, !!(status & MV88E6XXX_PORT_STS_LINK));
 525 }
 526
 527 irqreturn_t mv88e6097_serdes_irq_status(struct mv88e6xxx_chip *chip, int port,
 528                                         int lane)
 529 {
 530         u8 cmode = chip->ports[port].cmode;
 531
 532         switch (cmode) {
 533         case MV88E6185_PORT_STS_CMODE_SERDES:
 534         case MV88E6185_PORT_STS_CMODE_1000BASE_X:
 535                 mv88e6097_serdes_irq_link(chip, port);
 536                 return IRQ_HANDLED;
 537         }
 538
 539         return IRQ_NONE;
 540 }
 541
 542 int mv88e6390_serdes_get_lane(struct mv88e6xxx_chip *chip, int port)
 543 {
 544         u8 cmode = chip->ports[port].cmode;
 545         int lane = -ENODEV;
 546
 547         switch (port) {
 548         case 9:
 549                 if (cmode == MV88E6XXX_PORT_STS_CMODE_1000BASEX ||
 550                     cmode == MV88E6XXX_PORT_STS_CMODE_SGMII ||
 551                     cmode == MV88E6XXX_PORT_STS_CMODE_2500BASEX)
 552                         lane = MV88E6390_PORT9_LANE0;
 553                 break;
 554         case 10:
 555                 if (cmode == MV88E6XXX_PORT_STS_CMODE_1000BASEX ||
 556                     cmode == MV88E6XXX_PORT_STS_CMODE_SGMII ||
 557                     cmode == MV88E6XXX_PORT_STS_CMODE_2500BASEX)
 558                         lane = MV88E6390_PORT10_LANE0;
 559                 break;
 560         }
 561
 562         return lane;
 563 }
 564
 565 int mv88e6390x_serdes_get_lane(struct mv88e6xxx_chip *chip, int port)
 566 {
 567         u8 cmode_port = chip->ports[port].cmode;
 568         u8 cmode_port10 = chip->ports[10].cmode;
 569         u8 cmode_port9 = chip->ports[9].cmode;
 570         int lane = -ENODEV;
 571
 572         switch (port) {
 573         case 2:
 574                 if (cmode_port9 == MV88E6XXX_PORT_STS_CMODE_1000BASEX ||
 575                     cmode_port9 == MV88E6XXX_PORT_STS_CMODE_SGMII ||
 576                     cmode_port9 == MV88E6XXX_PORT_STS_CMODE_2500BASEX)
 577                         if (cmode_port == MV88E6XXX_PORT_STS_CMODE_1000BASEX)
 578                                 lane = MV88E6390_PORT9_LANE1;
 579                 break;
 580         case 3:
 581                 if (cmode_port9 == MV88E6XXX_PORT_STS_CMODE_1000BASEX ||
 582                     cmode_port9 == MV88E6XXX_PORT_STS_CMODE_SGMII ||
 583                     cmode_port9 == MV88E6XXX_PORT_STS_CMODE_2500BASEX ||
 584                     cmode_port9 == MV88E6XXX_PORT_STS_CMODE_RXAUI)
 585                         if (cmode_port == MV88E6XXX_PORT_STS_CMODE_1000BASEX)
 586                                 lane = MV88E6390_PORT9_LANE2;
 587                 break;
 588         case 4:
 589                 if (cmode_port9 == MV88E6XXX_PORT_STS_CMODE_1000BASEX ||
 590                     cmode_port9 == MV88E6XXX_PORT_STS_CMODE_SGMII ||
 591                     cmode_port9 == MV88E6XXX_PORT_STS_CMODE_2500BASEX ||
 592                     cmode_port9 == MV88E6XXX_PORT_STS_CMODE_RXAUI)
 593                         if (cmode_port == MV88E6XXX_PORT_STS_CMODE_1000BASEX)
 594                                 lane = MV88E6390_PORT9_LANE3;
 595                 break;
 596         case 5:
 597                 if (cmode_port10 == MV88E6XXX_PORT_STS_CMODE_1000BASEX ||
 598                     cmode_port10 == MV88E6XXX_PORT_STS_CMODE_SGMII ||
 599                     cmode_port10 == MV88E6XXX_PORT_STS_CMODE_2500BASEX)
 600                         if (cmode_port == MV88E6XXX_PORT_STS_CMODE_1000BASEX)
 601                                 lane = MV88E6390_PORT10_LANE1;
 602                 break;
 603         case 6:
 604                 if (cmode_port10 == MV88E6XXX_PORT_STS_CMODE_1000BASEX ||
 605                     cmode_port10 == MV88E6XXX_PORT_STS_CMODE_SGMII ||
 606                     cmode_port10 == MV88E6XXX_PORT_STS_CMODE_2500BASEX ||
 607                     cmode_port10 == MV88E6XXX_PORT_STS_CMODE_RXAUI)
 608                         if (cmode_port == MV88E6XXX_PORT_STS_CMODE_1000BASEX)
 609                                 lane = MV88E6390_PORT10_LANE2;
 610                 break;
 611         case 7:
 612                 if (cmode_port10 == MV88E6XXX_PORT_STS_CMODE_1000BASEX ||
 613                     cmode_port10 == MV88E6XXX_PORT_STS_CMODE_SGMII ||
 614                     cmode_port10 == MV88E6XXX_PORT_STS_CMODE_2500BASEX ||
 615                     cmode_port10 == MV88E6XXX_PORT_STS_CMODE_RXAUI)
 616                         if (cmode_port == MV88E6XXX_PORT_STS_CMODE_1000BASEX)
 617                                 lane = MV88E6390_PORT10_LANE3;
 618                 break;
 619         case 9:
 620                 if (cmode_port9 == MV88E6XXX_PORT_STS_CMODE_1000BASEX ||
 621                     cmode_port9 == MV88E6XXX_PORT_STS_CMODE_SGMII ||
 622                     cmode_port9 == MV88E6XXX_PORT_STS_CMODE_2500BASEX ||
 623                     cmode_port9 == MV88E6XXX_PORT_STS_CMODE_XAUI ||
 624                     cmode_port9 == MV88E6XXX_PORT_STS_CMODE_RXAUI)
 625                         lane = MV88E6390_PORT9_LANE0;
 626                 break;
 627         case 10:
 628                 if (cmode_port10 == MV88E6XXX_PORT_STS_CMODE_1000BASEX ||
 629                     cmode_port10 == MV88E6XXX_PORT_STS_CMODE_SGMII ||
 630                     cmode_port10 == MV88E6XXX_PORT_STS_CMODE_2500BASEX ||
 631                     cmode_port10 == MV88E6XXX_PORT_STS_CMODE_XAUI ||
 632                     cmode_port10 == MV88E6XXX_PORT_STS_CMODE_RXAUI)
 633                         lane = MV88E6390_PORT10_LANE0;
 634                 break;
 635         }
 636
 637         return lane;
 638 }
 639
 640 /* Only Ports 0, 9 and 10 have SERDES lanes. Return the SERDES lane address
 641  * a port is using else Returns -ENODEV.
 642  */
 643 int mv88e6393x_serdes_get_lane(struct mv88e6xxx_chip *chip, int port)
 644 {
 645         u8 cmode = chip->ports[port].cmode;
 646         int lane = -ENODEV;
 647
 648         if (port != 0 && port != 9 && port != 10)
 649                 return -EOPNOTSUPP;
 650
 651         if (cmode == MV88E6XXX_PORT_STS_CMODE_1000BASEX ||
 652             cmode == MV88E6XXX_PORT_STS_CMODE_SGMII ||
 653             cmode == MV88E6XXX_PORT_STS_CMODE_2500BASEX ||
 654             cmode == MV88E6393X_PORT_STS_CMODE_5GBASER ||
 655             cmode == MV88E6393X_PORT_STS_CMODE_10GBASER)
 656                 lane = port;
 657
 658         return lane;
 659 }
 660
 661 /* Set power up/down for 10GBASE-R and 10GBASE-X4/X2 */
 662 static int mv88e6390_serdes_power_10g(struct mv88e6xxx_chip *chip, int lane,
 663                                       bool up)
 664 {
 665         u16 val, new_val;
 666         int err;
 667
 668         err = mv88e6390_serdes_read(chip, lane, MDIO_MMD_PHYXS,
 669                                     MV88E6390_10G_CTRL1, &val);
 670
 671         if (err)
 672                 return err;
 673
 674         if (up)
 675                 new_val = val & ~(MDIO_CTRL1_RESET |
 676                                   MDIO_PCS_CTRL1_LOOPBACK |
 677                                   MDIO_CTRL1_LPOWER);
 678         else
 679                 new_val = val | MDIO_CTRL1_LPOWER;
 680
 681         if (val != new_val)
 682                 err = mv88e6390_serdes_write(chip, lane, MDIO_MMD_PHYXS,
 683                                              MV88E6390_10G_CTRL1, new_val);
 684
 685         return err;
 686 }
 687
 688 /* Set power up/down for SGMII and 1000Base-X */
 689 static int mv88e6390_serdes_power_sgmii(struct mv88e6xxx_chip *chip, int lane,
 690                                         bool up)
 691 {
 692         u16 val, new_val;
 693         int err;
 694
 695         err = mv88e6390_serdes_read(chip, lane, MDIO_MMD_PHYXS,
 696                                     MV88E6390_SGMII_BMCR, &val);
 697         if (err)
 698                 return err;
 699
 700         if (up)
 701                 new_val = val & ~(BMCR_RESET | BMCR_LOOPBACK | BMCR_PDOWN);
 702         else
 703                 new_val = val | BMCR_PDOWN;
 704
 705         if (val != new_val)
 706                 err = mv88e6390_serdes_write(chip, lane, MDIO_MMD_PHYXS,
 707                                              MV88E6390_SGMII_BMCR, new_val);
 708
 709         return err;
 710 }
 711
 712 struct mv88e6390_serdes_hw_stat {
 713         char string[ETH_GSTRING_LEN];
 714         int reg;
 715 };
 716
 717 static struct mv88e6390_serdes_hw_stat mv88e6390_serdes_hw_stats[] = {
 718         { "serdes_rx_pkts", 0xf021 },
 719         { "serdes_rx_bytes", 0xf024 },
 720         { "serdes_rx_pkts_error", 0xf027 },
 721 };
 722
 723 int mv88e6390_serdes_get_sset_count(struct mv88e6xxx_chip *chip, int port)
 724 {
 725         if (mv88e6xxx_serdes_get_lane(chip, port) < 0)
 726                 return 0;
 727
 728         return ARRAY_SIZE(mv88e6390_serdes_hw_stats);
 729 }
 730
 731 int mv88e6390_serdes_get_strings(struct mv88e6xxx_chip *chip,
 732                                  int port, uint8_t *data)
 733 {
 734         struct mv88e6390_serdes_hw_stat *stat;
 735         int i;
 736
 737         if (mv88e6xxx_serdes_get_lane(chip, port) < 0)
 738                 return 0;
 739
 740         for (i = 0; i < ARRAY_SIZE(mv88e6390_serdes_hw_stats); i++) {
 741                 stat = &mv88e6390_serdes_hw_stats[i];
 742                 memcpy(data + i * ETH_GSTRING_LEN, stat->string,
 743                        ETH_GSTRING_LEN);
 744         }
 745         return ARRAY_SIZE(mv88e6390_serdes_hw_stats);
 746 }
 747
 748 static uint64_t mv88e6390_serdes_get_stat(struct mv88e6xxx_chip *chip, int lane,
 749                                           struct mv88e6390_serdes_hw_stat *stat)
 750 {
 751         u16 reg[3];
 752         int err, i;
 753
 754         for (i = 0; i < 3; i++) {
 755                 err = mv88e6390_serdes_read(chip, lane, MDIO_MMD_PHYXS,
 756                                             stat->reg + i, &reg[i]);
 757                 if (err) {
 758                         dev_err(chip->dev, "failed to read statistic\n");
 759                         return 0;
 760                 }
 761         }
 762
 763         return reg[0] | ((u64)reg[1] << 16) | ((u64)reg[2] << 32);
 764 }
 765
 766 int mv88e6390_serdes_get_stats(struct mv88e6xxx_chip *chip, int port,
 767                                uint64_t *data)
 768 {
 769         struct mv88e6390_serdes_hw_stat *stat;
 770         int lane;
 771         int i;
 772
 773         lane = mv88e6xxx_serdes_get_lane(chip, port);
 774         if (lane < 0)
 775                 return 0;
 776
 777         for (i = 0; i < ARRAY_SIZE(mv88e6390_serdes_hw_stats); i++) {
 778                 stat = &mv88e6390_serdes_hw_stats[i];
 779                 data[i] = mv88e6390_serdes_get_stat(chip, lane, stat);
 780         }
 781
 782         return ARRAY_SIZE(mv88e6390_serdes_hw_stats);
 783 }
 784
 785 static int mv88e6390_serdes_enable_checker(struct mv88e6xxx_chip *chip, int lane)
 786 {
 787         u16 reg;
 788         int err;
 789
 790         err = mv88e6390_serdes_read(chip, lane, MDIO_MMD_PHYXS,
 791                                     MV88E6390_PG_CONTROL, &reg);
 792         if (err)
 793                 return err;
 794
 795         reg |= MV88E6390_PG_CONTROL_ENABLE_PC;
 796         return mv88e6390_serdes_write(chip, lane, MDIO_MMD_PHYXS,
 797                                       MV88E6390_PG_CONTROL, reg);
 798 }
 799
 800 int mv88e6390_serdes_power(struct mv88e6xxx_chip *chip, int port, int lane,
 801                            bool up)
 802 {
 803         u8 cmode = chip->ports[port].cmode;
 804         int err = 0;
 805
 806         switch (cmode) {
 807         case MV88E6XXX_PORT_STS_CMODE_SGMII:
 808         case MV88E6XXX_PORT_STS_CMODE_1000BASEX:
 809         case MV88E6XXX_PORT_STS_CMODE_2500BASEX:
 810                 err = mv88e6390_serdes_power_sgmii(chip, lane, up);
 811                 break;
 812         case MV88E6XXX_PORT_STS_CMODE_XAUI:
 813         case MV88E6XXX_PORT_STS_CMODE_RXAUI:
 814                 err = mv88e6390_serdes_power_10g(chip, lane, up);
 815                 break;
 816         }
 817
 818         if (!err && up)
 819                 err = mv88e6390_serdes_enable_checker(chip, lane);
 820
 821         return err;
 822 }
 823
 824 int mv88e6390_serdes_pcs_config(struct mv88e6xxx_chip *chip, int port,
 825                                 int lane, unsigned int mode,
 826                                 phy_interface_t interface,
 827                                 const unsigned long *advertise)
 828 {
 829         u16 val, bmcr, adv;
 830         bool changed;
 831         int err;
 832
 833         switch (interface) {
 834         case PHY_INTERFACE_MODE_SGMII:
 835                 adv = 0x0001;
 836                 break;
 837
 838         case PHY_INTERFACE_MODE_1000BASEX:
 839                 adv = linkmode_adv_to_mii_adv_x(advertise,
 840                                         ETHTOOL_LINK_MODE_1000baseX_Full_BIT);
 841                 break;
 842
 843         case PHY_INTERFACE_MODE_2500BASEX:
 844                 adv = linkmode_adv_to_mii_adv_x(advertise,
 845                                         ETHTOOL_LINK_MODE_2500baseX_Full_BIT);
 846                 break;
 847
 848         default:
 849                 return 0;
 850         }
 851
 852         err = mv88e6390_serdes_read(chip, lane, MDIO_MMD_PHYXS,
 853                                     MV88E6390_SGMII_ADVERTISE, &val);
 854         if (err)
 855                 return err;
 856
 857         changed = val != adv;
 858         if (changed) {
 859                 err = mv88e6390_serdes_write(chip, lane, MDIO_MMD_PHYXS,
 860                                              MV88E6390_SGMII_ADVERTISE, adv);
 861                 if (err)
 862                         return err;
 863         }
 864
 865         err = mv88e6390_serdes_read(chip, lane, MDIO_MMD_PHYXS,
 866                                     MV88E6390_SGMII_BMCR, &val);
 867         if (err)
 868                 return err;
 869
 870         if (phylink_autoneg_inband(mode))
 871                 bmcr = val | BMCR_ANENABLE;
 872         else
 873                 bmcr = val & ~BMCR_ANENABLE;
 874
 875         /* setting ANENABLE triggers a restart of negotiation */
 876         if (bmcr == val)
 877                 return changed;
 878
 879         return mv88e6390_serdes_write(chip, lane, MDIO_MMD_PHYXS,
 880                                       MV88E6390_SGMII_BMCR, bmcr);
 881 }
 882
 883 static int mv88e6390_serdes_pcs_get_state_sgmii(struct mv88e6xxx_chip *chip,
 884         int port, int lane, struct phylink_link_state *state)
 885 {
 886         u16 lpa, status;
 887         int err;
 888
 889         err = mv88e6390_serdes_read(chip, lane, MDIO_MMD_PHYXS,
 890                                     MV88E6390_SGMII_PHY_STATUS, &status);
 891         if (err) {
 892                 dev_err(chip->dev, "can't read Serdes PHY status: %d\n", err);
 893                 return err;
 894         }
 895
 896         err = mv88e6390_serdes_read(chip, lane, MDIO_MMD_PHYXS,
 897                                     MV88E6390_SGMII_LPA, &lpa);
 898         if (err) {
 899                 dev_err(chip->dev, "can't read Serdes PHY LPA: %d\n", err);
 900                 return err;
 901         }
 902
 903         return mv88e6xxx_serdes_pcs_get_state(chip, status, lpa, state);
 904 }
 905
 906 static int mv88e6390_serdes_pcs_get_state_10g(struct mv88e6xxx_chip *chip,
 907         int port, int lane, struct phylink_link_state *state)
 908 {
 909         u16 status;
 910         int err;
 911
 912         err = mv88e6390_serdes_read(chip, lane, MDIO_MMD_PHYXS,
 913                                     MV88E6390_10G_STAT1, &status);
 914         if (err)
 915                 return err;
 916
 917         state->link = !!(status & MDIO_STAT1_LSTATUS);
 918         if (state->link) {
 919                 state->speed = SPEED_10000;
 920                 state->duplex = DUPLEX_FULL;
 921         }
 922
 923         return 0;
 924 }
 925
 926 static int mv88e6393x_serdes_pcs_get_state_10g(struct mv88e6xxx_chip *chip,
 927                                                int port, int lane,
 928                                                struct phylink_link_state *state)
 929 {
 930         u16 status;
 931         int err;
 932
 933         err = mv88e6390_serdes_read(chip, lane, MDIO_MMD_PHYXS,
 934                                     MV88E6390_10G_STAT1, &status);
 935         if (err)
 936                 return err;
 937
 938         state->link = !!(status & MDIO_STAT1_LSTATUS);
 939         if (state->link) {
 940                 if (state->interface == PHY_INTERFACE_MODE_5GBASER)
 941                         state->speed = SPEED_5000;
 942                 else
 943                         state->speed = SPEED_10000;
 944                 state->duplex = DUPLEX_FULL;
 945         }
 946
 947         return 0;
 948 }
 949
 950 int mv88e6390_serdes_pcs_get_state(struct mv88e6xxx_chip *chip, int port,
 951                                    int lane, struct phylink_link_state *state)
 952 {
 953         switch (state->interface) {
 954         case PHY_INTERFACE_MODE_SGMII:
 955         case PHY_INTERFACE_MODE_1000BASEX:
 956         case PHY_INTERFACE_MODE_2500BASEX:
 957                 return mv88e6390_serdes_pcs_get_state_sgmii(chip, port, lane,
 958                                                             state);
 959         case PHY_INTERFACE_MODE_XAUI:
 960         case PHY_INTERFACE_MODE_RXAUI:
 961                 return mv88e6390_serdes_pcs_get_state_10g(chip, port, lane,
 962                                                           state);
 963
 964         default:
 965                 return -EOPNOTSUPP;
 966         }
 967 }
 968
 969 int mv88e6393x_serdes_pcs_get_state(struct mv88e6xxx_chip *chip, int port,
 970                                     int lane, struct phylink_link_state *state)
 971 {
 972         switch (state->interface) {
 973         case PHY_INTERFACE_MODE_SGMII:
 974         case PHY_INTERFACE_MODE_1000BASEX:
 975         case PHY_INTERFACE_MODE_2500BASEX:
 976                 return mv88e6390_serdes_pcs_get_state_sgmii(chip, port, lane,
 977                                                             state);
 978         case PHY_INTERFACE_MODE_5GBASER:
 979         case PHY_INTERFACE_MODE_10GBASER:
 980                 return mv88e6393x_serdes_pcs_get_state_10g(chip, port, lane,
 981                                                            state);
 982
 983         default:
 984                 return -EOPNOTSUPP;
 985         }
 986 }
 987
 988 int mv88e6390_serdes_pcs_an_restart(struct mv88e6xxx_chip *chip, int port,
 989                                     int lane)
 990 {
 991         u16 bmcr;
 992         int err;
 993
 994         err = mv88e6390_serdes_read(chip, lane, MDIO_MMD_PHYXS,
 995                                     MV88E6390_SGMII_BMCR, &bmcr);
 996         if (err)
 997                 return err;
 998
 999         return mv88e6390_serdes_write(chip, lane, MDIO_MMD_PHYXS,
1000                                       MV88E6390_SGMII_BMCR,
1001                                       bmcr | BMCR_ANRESTART);
1002 }
1003
1004 int mv88e6390_serdes_pcs_link_up(struct mv88e6xxx_chip *chip, int port,
1005                                  int lane, int speed, int duplex)
1006 {
1007         u16 val, bmcr;
1008         int err;
1009
1010         err = mv88e6390_serdes_read(chip, lane, MDIO_MMD_PHYXS,
1011                                     MV88E6390_SGMII_BMCR, &val);
1012         if (err)
1013                 return err;
1014
1015         bmcr = val & ~(BMCR_SPEED100 | BMCR_FULLDPLX | BMCR_SPEED1000);
1016         switch (speed) {
1017         case SPEED_2500:
1018         case SPEED_1000:
1019                 bmcr |= BMCR_SPEED1000;
1020                 break;
1021         case SPEED_100:
1022                 bmcr |= BMCR_SPEED100;
1023                 break;
1024         case SPEED_10:
1025                 break;
1026         }
1027
1028         if (duplex == DUPLEX_FULL)
1029                 bmcr |= BMCR_FULLDPLX;
1030
1031         if (bmcr == val)
1032                 return 0;
1033
1034         return mv88e6390_serdes_write(chip, lane, MDIO_MMD_PHYXS,
1035                                       MV88E6390_SGMII_BMCR, bmcr);
1036 }
1037
1038 static void mv88e6390_serdes_irq_link_sgmii(struct mv88e6xxx_chip *chip,
1039                                             int port, int lane)
1040 {
1041         u16 bmsr;
1042         int err;
1043
1044         /* If the link has dropped, we want to know about it. */
1045         err = mv88e6390_serdes_read(chip, lane, MDIO_MMD_PHYXS,
1046                                     MV88E6390_SGMII_BMSR, &bmsr);
1047         if (err) {
1048                 dev_err(chip->dev, "can't read Serdes BMSR: %d\n", err);
1049                 return;
1050         }
1051
1052         dsa_port_phylink_mac_change(chip->ds, port, !!(bmsr & BMSR_LSTATUS));
1053 }
1054
1055 static void mv88e6393x_serdes_irq_link_10g(struct mv88e6xxx_chip *chip,
1056                                            int port, u8 lane)
1057 {
1058         u16 status;
1059         int err;
1060
1061         /* If the link has dropped, we want to know about it. */
1062         err = mv88e6390_serdes_read(chip, lane, MDIO_MMD_PHYXS,
1063                                     MV88E6390_10G_STAT1, &status);
1064         if (err) {
1065                 dev_err(chip->dev, "can't read Serdes STAT1: %d\n", err);
1066                 return;
1067         }
1068
1069         dsa_port_phylink_mac_change(chip->ds, port, !!(status & MDIO_STAT1_LSTATUS));
1070 }
1071
1072 static int mv88e6390_serdes_irq_enable_sgmii(struct mv88e6xxx_chip *chip,
1073                                              int lane, bool enable)
1074 {
1075         u16 val = 0;
1076
1077         if (enable)
1078                 val |= MV88E6390_SGMII_INT_LINK_DOWN |
1079                         MV88E6390_SGMII_INT_LINK_UP;
1080
1081         return mv88e6390_serdes_write(chip, lane, MDIO_MMD_PHYXS,
1082                                       MV88E6390_SGMII_INT_ENABLE, val);
1083 }
1084
1085 int mv88e6390_serdes_irq_enable(struct mv88e6xxx_chip *chip, int port, int lane,
1086                                 bool enable)
1087 {
1088         u8 cmode = chip->ports[port].cmode;
1089
1090         switch (cmode) {
1091         case MV88E6XXX_PORT_STS_CMODE_SGMII:
1092         case MV88E6XXX_PORT_STS_CMODE_1000BASEX:
1093         case MV88E6XXX_PORT_STS_CMODE_2500BASEX:
1094                 return mv88e6390_serdes_irq_enable_sgmii(chip, lane, enable);
1095         }
1096
1097         return 0;
1098 }
1099
1100 static int mv88e6390_serdes_irq_status_sgmii(struct mv88e6xxx_chip *chip,
1101                                              int lane, u16 *status)
1102 {
1103         int err;
1104
1105         err = mv88e6390_serdes_read(chip, lane, MDIO_MMD_PHYXS,
1106                                     MV88E6390_SGMII_INT_STATUS, status);
1107
1108         return err;
1109 }
1110
1111 static int mv88e6393x_serdes_irq_enable_10g(struct mv88e6xxx_chip *chip,
1112                                             u8 lane, bool enable)
1113 {
1114         u16 val = 0;
1115
1116         if (enable)
1117                 val |= MV88E6393X_10G_INT_LINK_CHANGE;
1118
1119         return mv88e6390_serdes_write(chip, lane, MDIO_MMD_PHYXS,
1120                                       MV88E6393X_10G_INT_ENABLE, val);
1121 }
1122
1123 int mv88e6393x_serdes_irq_enable(struct mv88e6xxx_chip *chip, int port,
1124                                  int lane, bool enable)
1125 {
1126         u8 cmode = chip->ports[port].cmode;
1127
1128         switch (cmode) {
1129         case MV88E6XXX_PORT_STS_CMODE_SGMII:
1130         case MV88E6XXX_PORT_STS_CMODE_1000BASEX:
1131         case MV88E6XXX_PORT_STS_CMODE_2500BASEX:
1132                 return mv88e6390_serdes_irq_enable_sgmii(chip, lane, enable);
1133         case MV88E6393X_PORT_STS_CMODE_5GBASER:
1134         case MV88E6393X_PORT_STS_CMODE_10GBASER:
1135                 return mv88e6393x_serdes_irq_enable_10g(chip, lane, enable);
1136         }
1137
1138         return 0;
1139 }
1140
1141 static int mv88e6393x_serdes_irq_status_10g(struct mv88e6xxx_chip *chip,
1142                                             u8 lane, u16 *status)
1143 {
1144         int err;
1145
1146         err = mv88e6390_serdes_read(chip, lane, MDIO_MMD_PHYXS,
1147                                     MV88E6393X_10G_INT_STATUS, status);
1148
1149         return err;
1150 }
1151
1152 irqreturn_t mv88e6393x_serdes_irq_status(struct mv88e6xxx_chip *chip, int port,
1153                                          int lane)
1154 {
1155         u8 cmode = chip->ports[port].cmode;
1156         irqreturn_t ret = IRQ_NONE;
1157         u16 status;
1158         int err;
1159
1160         switch (cmode) {
1161         case MV88E6XXX_PORT_STS_CMODE_SGMII:
1162         case MV88E6XXX_PORT_STS_CMODE_1000BASEX:
1163         case MV88E6XXX_PORT_STS_CMODE_2500BASEX:
1164                 err = mv88e6390_serdes_irq_status_sgmii(chip, lane, &status);
1165                 if (err)
1166                         return ret;
1167                 if (status & (MV88E6390_SGMII_INT_LINK_DOWN |
1168                               MV88E6390_SGMII_INT_LINK_UP)) {
1169                         ret = IRQ_HANDLED;
1170                         mv88e6390_serdes_irq_link_sgmii(chip, port, lane);
1171                 }
1172                 break;
1173         case MV88E6393X_PORT_STS_CMODE_5GBASER:
1174         case MV88E6393X_PORT_STS_CMODE_10GBASER:
1175                 err = mv88e6393x_serdes_irq_status_10g(chip, lane, &status);
1176                 if (err)
1177                         return err;
1178                 if (status & MV88E6393X_10G_INT_LINK_CHANGE) {
1179                         ret = IRQ_HANDLED;
1180                         mv88e6393x_serdes_irq_link_10g(chip, port, lane);
1181                 }
1182                 break;
1183         }
1184
1185         return ret;
1186 }
1187
1188 irqreturn_t mv88e6390_serdes_irq_status(struct mv88e6xxx_chip *chip, int port,
1189                                         int lane)
1190 {
1191         u8 cmode = chip->ports[port].cmode;
1192         irqreturn_t ret = IRQ_NONE;
1193         u16 status;
1194         int err;
1195
1196         switch (cmode) {
1197         case MV88E6XXX_PORT_STS_CMODE_SGMII:
1198         case MV88E6XXX_PORT_STS_CMODE_1000BASEX:
1199         case MV88E6XXX_PORT_STS_CMODE_2500BASEX:
1200                 err = mv88e6390_serdes_irq_status_sgmii(chip, lane, &status);
1201                 if (err)
1202                         return ret;
1203                 if (status & (MV88E6390_SGMII_INT_LINK_DOWN |
1204                               MV88E6390_SGMII_INT_LINK_UP)) {
1205                         ret = IRQ_HANDLED;
1206                         mv88e6390_serdes_irq_link_sgmii(chip, port, lane);
1207                 }
1208         }
1209
1210         return ret;
1211 }
1212
1213 unsigned int mv88e6390_serdes_irq_mapping(struct mv88e6xxx_chip *chip, int port)
1214 {
1215         return irq_find_mapping(chip->g2_irq.domain, port);
1216 }
1217
1218 static const u16 mv88e6390_serdes_regs[] = {
1219         /* SERDES common registers */
1220         0xf00a, 0xf00b, 0xf00c,
1221         0xf010, 0xf011, 0xf012, 0xf013,
1222         0xf016, 0xf017, 0xf018,
1223         0xf01b, 0xf01c, 0xf01d, 0xf01e, 0xf01f,
1224         0xf020, 0xf021, 0xf022, 0xf023, 0xf024, 0xf025, 0xf026, 0xf027,
1225         0xf028, 0xf029,
1226         0xf030, 0xf031, 0xf032, 0xf033, 0xf034, 0xf035, 0xf036, 0xf037,
1227         0xf038, 0xf039,
1228         /* SGMII */
1229         0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, 0x2006, 0x2007,
1230         0x2008,
1231         0x200f,
1232         0xa000, 0xa001, 0xa002, 0xa003,
1233         /* 10Gbase-X */
1234         0x1000, 0x1001, 0x1002, 0x1003, 0x1004, 0x1005, 0x1006, 0x1007,
1235         0x1008,
1236         0x100e, 0x100f,
1237         0x1018, 0x1019,
1238         0x9000, 0x9001, 0x9002, 0x9003, 0x9004,
1239         0x9006,
1240         0x9010, 0x9011, 0x9012, 0x9013, 0x9014, 0x9015, 0x9016,
1241         /* 10Gbase-R */
1242         0x1020, 0x1021, 0x1022, 0x1023, 0x1024, 0x1025, 0x1026, 0x1027,
1243         0x1028, 0x1029, 0x102a, 0x102b,
1244 };
1245
1246 int mv88e6390_serdes_get_regs_len(struct mv88e6xxx_chip *chip, int port)
1247 {
1248         if (mv88e6xxx_serdes_get_lane(chip, port) < 0)
1249                 return 0;
1250
1251         return ARRAY_SIZE(mv88e6390_serdes_regs) * sizeof(u16);
1252 }
1253
1254 void mv88e6390_serdes_get_regs(struct mv88e6xxx_chip *chip, int port, void *_p)
1255 {
1256         u16 *p = _p;
1257         int lane;
1258         u16 reg;
1259         int err;
1260         int i;
1261
1262         lane = mv88e6xxx_serdes_get_lane(chip, port);
1263         if (lane < 0)
1264                 return;
1265
1266         for (i = 0 ; i < ARRAY_SIZE(mv88e6390_serdes_regs); i++) {
1267                 err = mv88e6390_serdes_read(chip, lane, MDIO_MMD_PHYXS,
1268                                             mv88e6390_serdes_regs[i], &reg);
1269                 if (!err)
1270                         p[i] = reg;
1271         }
1272 }
1273
1274 static int mv88e6393x_serdes_port_errata(struct mv88e6xxx_chip *chip, int lane)
1275 {
1276         u16 reg, pcs;
1277         int err;
1278
1279         /* mv88e6393x family errata 4.6:
1280          * Cannot clear PwrDn bit on SERDES on port 0 if device is configured
1281          * CPU_MGD mode or P0_mode is configured for [x]MII.
1282          * Workaround: Set Port0 SERDES register 4.F002 bit 5=0 and bit 15=1.
1283          *
1284          * It seems that after this workaround the SERDES is automatically
1285          * powered up (the bit is cleared), so power it down.
1286          */
1287         if (lane == MV88E6393X_PORT0_LANE) {
1288                 err = mv88e6390_serdes_read(chip, MV88E6393X_PORT0_LANE,
1289                                             MDIO_MMD_PHYXS,
1290                                             MV88E6393X_SERDES_POC, &reg);
1291                 if (err)
1292                         return err;
1293
1294                 reg &= ~MV88E6393X_SERDES_POC_PDOWN;
1295                 reg |= MV88E6393X_SERDES_POC_RESET;
1296
1297                 err = mv88e6390_serdes_write(chip, lane, MDIO_MMD_PHYXS,
1298                                              MV88E6393X_SERDES_POC, reg);
1299                 if (err)
1300                         return err;
1301
1302                 err = mv88e6390_serdes_power_sgmii(chip, lane, false);
1303                 if (err)
1304                         return err;
1305         }
1306
1307         /* mv88e6393x family errata 4.8:
1308          * When a SERDES port is operating in 1000BASE-X or SGMII mode link may
1309          * not come up after hardware reset or software reset of SERDES core.
1310          * Workaround is to write SERDES register 4.F074.14=1 for only those
1311          * modes and 0 in all other modes.
1312          */
1313         err = mv88e6390_serdes_read(chip, lane, MDIO_MMD_PHYXS,
1314                                     MV88E6393X_SERDES_POC, &pcs);
1315         if (err)
1316                 return err;
1317
1318         pcs &= MV88E6393X_SERDES_POC_PCS_MASK;
1319
1320         err = mv88e6390_serdes_read(chip, lane, MDIO_MMD_PHYXS,
1321                                     MV88E6393X_ERRATA_4_8_REG, &reg);
1322         if (err)
1323                 return err;
1324
1325         if (pcs == MV88E6393X_SERDES_POC_PCS_1000BASEX ||
1326             pcs == MV88E6393X_SERDES_POC_PCS_SGMII_PHY ||
1327             pcs == MV88E6393X_SERDES_POC_PCS_SGMII_MAC)
1328                 reg |= MV88E6393X_ERRATA_4_8_BIT;
1329         else
1330                 reg &= ~MV88E6393X_ERRATA_4_8_BIT;
1331
1332         return mv88e6390_serdes_write(chip, lane, MDIO_MMD_PHYXS,
1333                                       MV88E6393X_ERRATA_4_8_REG, reg);
1334 }
1335
1336 int mv88e6393x_serdes_setup_errata(struct mv88e6xxx_chip *chip)
1337 {
1338         int err;
1339
1340         err = mv88e6393x_serdes_port_errata(chip, MV88E6393X_PORT0_LANE);
1341         if (err)
1342                 return err;
1343
1344         err = mv88e6393x_serdes_port_errata(chip, MV88E6393X_PORT9_LANE);
1345         if (err)
1346                 return err;
1347
1348         return mv88e6393x_serdes_port_errata(chip, MV88E6393X_PORT10_LANE);
1349 }
1350
1351 int mv88e6393x_serdes_power(struct mv88e6xxx_chip *chip, int port, int lane,
1352                             bool on)
1353 {
1354         u8 cmode = chip->ports[port].cmode;
1355
1356         if (port != 0 && port != 9 && port != 10)
1357                 return -EOPNOTSUPP;
1358
1359         switch (cmode) {
1360         case MV88E6XXX_PORT_STS_CMODE_SGMII:
1361         case MV88E6XXX_PORT_STS_CMODE_1000BASEX:
1362         case MV88E6XXX_PORT_STS_CMODE_2500BASEX:
1363                 return mv88e6390_serdes_power_sgmii(chip, lane, on);
1364         case MV88E6393X_PORT_STS_CMODE_5GBASER:
1365         case MV88E6393X_PORT_STS_CMODE_10GBASER:
1366                 return mv88e6390_serdes_power_10g(chip, lane, on);
1367         }
1368
1369         return 0;
1370 }