drivers/net/ethernet/amd/xgbe/xgbe-phy-v2.c

   1 /*
   2  * AMD 10Gb Ethernet driver
   3  *
   4  * This file is available to you under your choice of the following two
   5  * licenses:
   6  *
   7  * License 1: GPLv2
   8  *
   9  * Copyright (c) 2016 Advanced Micro Devices, Inc.
  10  *
  11  * This file is free software; you may copy, redistribute 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 (at
  14  * your option) any later version.
  15  *
  16  * This file is distributed in the hope that it will be useful, but
  17  * WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  19  * General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  23  *
  24  * This file incorporates work covered by the following copyright and
  25  * permission notice:
  26  *     The Synopsys DWC ETHER XGMAC Software Driver and documentation
  27  *     (hereinafter "Software") is an unsupported proprietary work of Synopsys,
  28  *     Inc. unless otherwise expressly agreed to in writing between Synopsys
  29  *     and you.
  30  *
  31  *     The Software IS NOT an item of Licensed Software or Licensed Product
  32  *     under any End User Software License Agreement or Agreement for Licensed
  33  *     Product with Synopsys or any supplement thereto.  Permission is hereby
  34  *     granted, free of charge, to any person obtaining a copy of this software
  35  *     annotated with this license and the Software, to deal in the Software
  36  *     without restriction, including without limitation the rights to use,
  37  *     copy, modify, merge, publish, distribute, sublicense, and/or sell copies
  38  *     of the Software, and to permit persons to whom the Software is furnished
  39  *     to do so, subject to the following conditions:
  40  *
  41  *     The above copyright notice and this permission notice shall be included
  42  *     in all copies or substantial portions of the Software.
  43  *
  44  *     THIS SOFTWARE IS BEING DISTRIBUTED BY SYNOPSYS SOLELY ON AN "AS IS"
  45  *     BASIS AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  46  *     TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  47  *     PARTICULAR PURPOSE ARE HEREBY DISCLAIMED. IN NO EVENT SHALL SYNOPSYS
  48  *     BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  49  *     CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  50  *     SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  51  *     INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  52  *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  53  *     ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  54  *     THE POSSIBILITY OF SUCH DAMAGE.
  55  *
  56  *
  57  * License 2: Modified BSD
  58  *
  59  * Copyright (c) 2016 Advanced Micro Devices, Inc.
  60  * All rights reserved.
  61  *
  62  * Redistribution and use in source and binary forms, with or without
  63  * modification, are permitted provided that the following conditions are met:
  64  *     * Redistributions of source code must retain the above copyright
  65  *       notice, this list of conditions and the following disclaimer.
  66  *     * Redistributions in binary form must reproduce the above copyright
  67  *       notice, this list of conditions and the following disclaimer in the
  68  *       documentation and/or other materials provided with the distribution.
  69  *     * Neither the name of Advanced Micro Devices, Inc. nor the
  70  *       names of its contributors may be used to endorse or promote products
  71  *       derived from this software without specific prior written permission.
  72  *
  73  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  74  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  75  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  76  * ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
  77  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  78  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  79  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  80  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  81  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  82  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  83  *
  84  * This file incorporates work covered by the following copyright and
  85  * permission notice:
  86  *     The Synopsys DWC ETHER XGMAC Software Driver and documentation
  87  *     (hereinafter "Software") is an unsupported proprietary work of Synopsys,
  88  *     Inc. unless otherwise expressly agreed to in writing between Synopsys
  89  *     and you.
  90  *
  91  *     The Software IS NOT an item of Licensed Software or Licensed Product
  92  *     under any End User Software License Agreement or Agreement for Licensed
  93  *     Product with Synopsys or any supplement thereto.  Permission is hereby
  94  *     granted, free of charge, to any person obtaining a copy of this software
  95  *     annotated with this license and the Software, to deal in the Software
  96  *     without restriction, including without limitation the rights to use,
  97  *     copy, modify, merge, publish, distribute, sublicense, and/or sell copies
  98  *     of the Software, and to permit persons to whom the Software is furnished
  99  *     to do so, subject to the following conditions:
 100  *
 101  *     The above copyright notice and this permission notice shall be included
 102  *     in all copies or substantial portions of the Software.
 103  *
 104  *     THIS SOFTWARE IS BEING DISTRIBUTED BY SYNOPSYS SOLELY ON AN "AS IS"
 105  *     BASIS AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 106  *     TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
 107  *     PARTICULAR PURPOSE ARE HEREBY DISCLAIMED. IN NO EVENT SHALL SYNOPSYS
 108  *     BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 109  *     CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 110  *     SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 111  *     INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 112  *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 113  *     ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 114  *     THE POSSIBILITY OF SUCH DAMAGE.
 115  */
 116
 117 #include <linux/module.h>
 118 #include <linux/device.h>
 119 #include <linux/kmod.h>
 120 #include <linux/mdio.h>
 121 #include <linux/phy.h>
 122 #include <linux/ethtool.h>
 123
 124 #include "xgbe.h"
 125 #include "xgbe-common.h"
 126
 127 #define XGBE_PHY_PORT_SPEED_100         BIT(0)
 128 #define XGBE_PHY_PORT_SPEED_1000        BIT(1)
 129 #define XGBE_PHY_PORT_SPEED_2500        BIT(2)
 130 #define XGBE_PHY_PORT_SPEED_10000       BIT(3)
 131
 132 #define XGBE_MUTEX_RELEASE              0x80000000
 133
 134 #define XGBE_SFP_DIRECT                 7
 135
 136 /* I2C target addresses */
 137 #define XGBE_SFP_SERIAL_ID_ADDRESS      0x50
 138 #define XGBE_SFP_DIAG_INFO_ADDRESS      0x51
 139 #define XGBE_SFP_PHY_ADDRESS            0x56
 140 #define XGBE_GPIO_ADDRESS_PCA9555       0x20
 141
 142 /* SFP sideband signal indicators */
 143 #define XGBE_GPIO_NO_TX_FAULT           BIT(0)
 144 #define XGBE_GPIO_NO_RATE_SELECT        BIT(1)
 145 #define XGBE_GPIO_NO_MOD_ABSENT         BIT(2)
 146 #define XGBE_GPIO_NO_RX_LOS             BIT(3)
 147
 148 /* Rate-change complete wait/retry count */
 149 #define XGBE_RATECHANGE_COUNT           500
 150
 151 /* CDR delay values for KR support (in usec) */
 152 #define XGBE_CDR_DELAY_INIT             10000
 153 #define XGBE_CDR_DELAY_INC              10000
 154 #define XGBE_CDR_DELAY_MAX              100000
 155
 156 /* RRC frequency during link status check */
 157 #define XGBE_RRC_FREQUENCY              10
 158
 159 enum xgbe_port_mode {
 160         XGBE_PORT_MODE_RSVD = 0,
 161         XGBE_PORT_MODE_BACKPLANE,
 162         XGBE_PORT_MODE_BACKPLANE_2500,
 163         XGBE_PORT_MODE_1000BASE_T,
 164         XGBE_PORT_MODE_1000BASE_X,
 165         XGBE_PORT_MODE_NBASE_T,
 166         XGBE_PORT_MODE_10GBASE_T,
 167         XGBE_PORT_MODE_10GBASE_R,
 168         XGBE_PORT_MODE_SFP,
 169         XGBE_PORT_MODE_MAX,
 170 };
 171
 172 enum xgbe_conn_type {
 173         XGBE_CONN_TYPE_NONE = 0,
 174         XGBE_CONN_TYPE_SFP,
 175         XGBE_CONN_TYPE_MDIO,
 176         XGBE_CONN_TYPE_RSVD1,
 177         XGBE_CONN_TYPE_BACKPLANE,
 178         XGBE_CONN_TYPE_MAX,
 179 };
 180
 181 /* SFP/SFP+ related definitions */
 182 enum xgbe_sfp_comm {
 183         XGBE_SFP_COMM_DIRECT = 0,
 184         XGBE_SFP_COMM_PCA9545,
 185 };
 186
 187 enum xgbe_sfp_cable {
 188         XGBE_SFP_CABLE_UNKNOWN = 0,
 189         XGBE_SFP_CABLE_ACTIVE,
 190         XGBE_SFP_CABLE_PASSIVE,
 191 };
 192
 193 enum xgbe_sfp_base {
 194         XGBE_SFP_BASE_UNKNOWN = 0,
 195         XGBE_SFP_BASE_1000_T,
 196         XGBE_SFP_BASE_1000_SX,
 197         XGBE_SFP_BASE_1000_LX,
 198         XGBE_SFP_BASE_1000_CX,
 199         XGBE_SFP_BASE_10000_SR,
 200         XGBE_SFP_BASE_10000_LR,
 201         XGBE_SFP_BASE_10000_LRM,
 202         XGBE_SFP_BASE_10000_ER,
 203         XGBE_SFP_BASE_10000_CR,
 204 };
 205
 206 enum xgbe_sfp_speed {
 207         XGBE_SFP_SPEED_UNKNOWN = 0,
 208         XGBE_SFP_SPEED_100_1000,
 209         XGBE_SFP_SPEED_1000,
 210         XGBE_SFP_SPEED_10000,
 211 };
 212
 213 /* SFP Serial ID Base ID values relative to an offset of 0 */
 214 #define XGBE_SFP_BASE_ID                        0
 215 #define XGBE_SFP_ID_SFP                         0x03
 216
 217 #define XGBE_SFP_BASE_EXT_ID                    1
 218 #define XGBE_SFP_EXT_ID_SFP                     0x04
 219
 220 #define XGBE_SFP_BASE_10GBE_CC                  3
 221 #define XGBE_SFP_BASE_10GBE_CC_SR               BIT(4)
 222 #define XGBE_SFP_BASE_10GBE_CC_LR               BIT(5)
 223 #define XGBE_SFP_BASE_10GBE_CC_LRM              BIT(6)
 224 #define XGBE_SFP_BASE_10GBE_CC_ER               BIT(7)
 225
 226 #define XGBE_SFP_BASE_1GBE_CC                   6
 227 #define XGBE_SFP_BASE_1GBE_CC_SX                BIT(0)
 228 #define XGBE_SFP_BASE_1GBE_CC_LX                BIT(1)
 229 #define XGBE_SFP_BASE_1GBE_CC_CX                BIT(2)
 230 #define XGBE_SFP_BASE_1GBE_CC_T                 BIT(3)
 231
 232 #define XGBE_SFP_BASE_CABLE                     8
 233 #define XGBE_SFP_BASE_CABLE_PASSIVE             BIT(2)
 234 #define XGBE_SFP_BASE_CABLE_ACTIVE              BIT(3)
 235
 236 #define XGBE_SFP_BASE_BR                        12
 237 #define XGBE_SFP_BASE_BR_1GBE_MIN               0x0a
 238 #define XGBE_SFP_BASE_BR_1GBE_MAX               0x0d
 239 #define XGBE_SFP_BASE_BR_10GBE_MIN              0x64
 240 #define XGBE_SFP_BASE_BR_10GBE_MAX              0x68
 241 #define XGBE_MOLEX_SFP_BASE_BR_10GBE_MAX        0x78
 242
 243 #define XGBE_SFP_BASE_CU_CABLE_LEN              18
 244
 245 #define XGBE_SFP_BASE_VENDOR_NAME               20
 246 #define XGBE_SFP_BASE_VENDOR_NAME_LEN           16
 247 #define XGBE_SFP_BASE_VENDOR_PN                 40
 248 #define XGBE_SFP_BASE_VENDOR_PN_LEN             16
 249 #define XGBE_SFP_BASE_VENDOR_REV                56
 250 #define XGBE_SFP_BASE_VENDOR_REV_LEN            4
 251
 252 #define XGBE_SFP_BASE_CC                        63
 253
 254 /* SFP Serial ID Extended ID values relative to an offset of 64 */
 255 #define XGBE_SFP_BASE_VENDOR_SN                 4
 256 #define XGBE_SFP_BASE_VENDOR_SN_LEN             16
 257
 258 #define XGBE_SFP_EXTD_OPT1                      1
 259 #define XGBE_SFP_EXTD_OPT1_RX_LOS               BIT(1)
 260 #define XGBE_SFP_EXTD_OPT1_TX_FAULT             BIT(3)
 261
 262 #define XGBE_SFP_EXTD_DIAG                      28
 263 #define XGBE_SFP_EXTD_DIAG_ADDR_CHANGE          BIT(2)
 264
 265 #define XGBE_SFP_EXTD_SFF_8472                  30
 266
 267 #define XGBE_SFP_EXTD_CC                        31
 268
 269 struct xgbe_sfp_eeprom {
 270         u8 base[64];
 271         u8 extd[32];
 272         u8 vendor[32];
 273 };
 274
 275 #define XGBE_SFP_DIAGS_SUPPORTED(_x)                    \
 276         ((_x)->extd[XGBE_SFP_EXTD_SFF_8472] &&          \
 277          !((_x)->extd[XGBE_SFP_EXTD_DIAG] & XGBE_SFP_EXTD_DIAG_ADDR_CHANGE))
 278
 279 #define XGBE_SFP_EEPROM_BASE_LEN        256
 280 #define XGBE_SFP_EEPROM_DIAG_LEN        256
 281 #define XGBE_SFP_EEPROM_MAX             (XGBE_SFP_EEPROM_BASE_LEN +     \
 282                                          XGBE_SFP_EEPROM_DIAG_LEN)
 283
 284 #define XGBE_BEL_FUSE_VENDOR    "BEL-FUSE        "
 285 #define XGBE_BEL_FUSE_PARTNO    "1GBT-SFP06      "
 286
 287 #define XGBE_MOLEX_VENDOR       "Molex Inc.      "
 288
 289 struct xgbe_sfp_ascii {
 290         union {
 291                 char vendor[XGBE_SFP_BASE_VENDOR_NAME_LEN + 1];
 292                 char partno[XGBE_SFP_BASE_VENDOR_PN_LEN + 1];
 293                 char rev[XGBE_SFP_BASE_VENDOR_REV_LEN + 1];
 294                 char serno[XGBE_SFP_BASE_VENDOR_SN_LEN + 1];
 295         } u;
 296 };
 297
 298 /* MDIO PHY reset types */
 299 enum xgbe_mdio_reset {
 300         XGBE_MDIO_RESET_NONE = 0,
 301         XGBE_MDIO_RESET_I2C_GPIO,
 302         XGBE_MDIO_RESET_INT_GPIO,
 303         XGBE_MDIO_RESET_MAX,
 304 };
 305
 306 /* Re-driver related definitions */
 307 enum xgbe_phy_redrv_if {
 308         XGBE_PHY_REDRV_IF_MDIO = 0,
 309         XGBE_PHY_REDRV_IF_I2C,
 310         XGBE_PHY_REDRV_IF_MAX,
 311 };
 312
 313 enum xgbe_phy_redrv_model {
 314         XGBE_PHY_REDRV_MODEL_4223 = 0,
 315         XGBE_PHY_REDRV_MODEL_4227,
 316         XGBE_PHY_REDRV_MODEL_MAX,
 317 };
 318
 319 enum xgbe_phy_redrv_mode {
 320         XGBE_PHY_REDRV_MODE_CX = 5,
 321         XGBE_PHY_REDRV_MODE_SR = 9,
 322 };
 323
 324 #define XGBE_PHY_REDRV_MODE_REG 0x12b0
 325
 326 /* PHY related configuration information */
 327 struct xgbe_phy_data {
 328         enum xgbe_port_mode port_mode;
 329
 330         unsigned int port_id;
 331
 332         unsigned int port_speeds;
 333
 334         enum xgbe_conn_type conn_type;
 335
 336         enum xgbe_mode cur_mode;
 337         enum xgbe_mode start_mode;
 338
 339         unsigned int rrc_count;
 340
 341         unsigned int mdio_addr;
 342
 343         /* SFP Support */
 344         enum xgbe_sfp_comm sfp_comm;
 345         unsigned int sfp_mux_address;
 346         unsigned int sfp_mux_channel;
 347
 348         unsigned int sfp_gpio_address;
 349         unsigned int sfp_gpio_mask;
 350         unsigned int sfp_gpio_inputs;
 351         unsigned int sfp_gpio_rx_los;
 352         unsigned int sfp_gpio_tx_fault;
 353         unsigned int sfp_gpio_mod_absent;
 354         unsigned int sfp_gpio_rate_select;
 355
 356         unsigned int sfp_rx_los;
 357         unsigned int sfp_tx_fault;
 358         unsigned int sfp_mod_absent;
 359         unsigned int sfp_changed;
 360         unsigned int sfp_phy_avail;
 361         unsigned int sfp_cable_len;
 362         enum xgbe_sfp_base sfp_base;
 363         enum xgbe_sfp_cable sfp_cable;
 364         enum xgbe_sfp_speed sfp_speed;
 365         struct xgbe_sfp_eeprom sfp_eeprom;
 366
 367         /* External PHY support */
 368         enum xgbe_mdio_mode phydev_mode;
 369         struct mii_bus *mii;
 370         struct phy_device *phydev;
 371         enum xgbe_mdio_reset mdio_reset;
 372         unsigned int mdio_reset_addr;
 373         unsigned int mdio_reset_gpio;
 374
 375         /* Re-driver support */
 376         unsigned int redrv;
 377         unsigned int redrv_if;
 378         unsigned int redrv_addr;
 379         unsigned int redrv_lane;
 380         unsigned int redrv_model;
 381
 382         /* KR AN support */
 383         unsigned int phy_cdr_notrack;
 384         unsigned int phy_cdr_delay;
 385 };
 386
 387 /* I2C, MDIO and GPIO lines are muxed, so only one device at a time */
 388 static DEFINE_MUTEX(xgbe_phy_comm_lock);
 389
 390 static enum xgbe_an_mode xgbe_phy_an_mode(struct xgbe_prv_data *pdata);
 391
 392 static int xgbe_phy_i2c_xfer(struct xgbe_prv_data *pdata,
 393                              struct xgbe_i2c_op *i2c_op)
 394 {
 395         return pdata->i2c_if.i2c_xfer(pdata, i2c_op);
 396 }
 397
 398 static int xgbe_phy_redrv_write(struct xgbe_prv_data *pdata, unsigned int reg,
 399                                 unsigned int val)
 400 {
 401         struct xgbe_phy_data *phy_data = pdata->phy_data;
 402         struct xgbe_i2c_op i2c_op;
 403         __be16 *redrv_val;
 404         u8 redrv_data[5], csum;
 405         unsigned int i, retry;
 406         int ret;
 407
 408         /* High byte of register contains read/write indicator */
 409         redrv_data[0] = ((reg >> 8) & 0xff) << 1;
 410         redrv_data[1] = reg & 0xff;
 411         redrv_val = (__be16 *)&redrv_data[2];
 412         *redrv_val = cpu_to_be16(val);
 413
 414         /* Calculate 1 byte checksum */
 415         csum = 0;
 416         for (i = 0; i < 4; i++) {
 417                 csum += redrv_data[i];
 418                 if (redrv_data[i] > csum)
 419                         csum++;
 420         }
 421         redrv_data[4] = ~csum;
 422
 423         retry = 1;
 424 again1:
 425         i2c_op.cmd = XGBE_I2C_CMD_WRITE;
 426         i2c_op.target = phy_data->redrv_addr;
 427         i2c_op.len = sizeof(redrv_data);
 428         i2c_op.buf = redrv_data;
 429         ret = xgbe_phy_i2c_xfer(pdata, &i2c_op);
 430         if (ret) {
 431                 if ((ret == -EAGAIN) && retry--)
 432                         goto again1;
 433
 434                 return ret;
 435         }
 436
 437         retry = 1;
 438 again2:
 439         i2c_op.cmd = XGBE_I2C_CMD_READ;
 440         i2c_op.target = phy_data->redrv_addr;
 441         i2c_op.len = 1;
 442         i2c_op.buf = redrv_data;
 443         ret = xgbe_phy_i2c_xfer(pdata, &i2c_op);
 444         if (ret) {
 445                 if ((ret == -EAGAIN) && retry--)
 446                         goto again2;
 447
 448                 return ret;
 449         }
 450
 451         if (redrv_data[0] != 0xff) {
 452                 netif_dbg(pdata, drv, pdata->netdev,
 453                           "Redriver write checksum error\n");
 454                 ret = -EIO;
 455         }
 456
 457         return ret;
 458 }
 459
 460 static int xgbe_phy_i2c_write(struct xgbe_prv_data *pdata, unsigned int target,
 461                               void *val, unsigned int val_len)
 462 {
 463         struct xgbe_i2c_op i2c_op;
 464         int retry, ret;
 465
 466         retry = 1;
 467 again:
 468         /* Write the specfied register */
 469         i2c_op.cmd = XGBE_I2C_CMD_WRITE;
 470         i2c_op.target = target;
 471         i2c_op.len = val_len;
 472         i2c_op.buf = val;
 473         ret = xgbe_phy_i2c_xfer(pdata, &i2c_op);
 474         if ((ret == -EAGAIN) && retry--)
 475                 goto again;
 476
 477         return ret;
 478 }
 479
 480 static int xgbe_phy_i2c_read(struct xgbe_prv_data *pdata, unsigned int target,
 481                              void *reg, unsigned int reg_len,
 482                              void *val, unsigned int val_len)
 483 {
 484         struct xgbe_i2c_op i2c_op;
 485         int retry, ret;
 486
 487         retry = 1;
 488 again1:
 489         /* Set the specified register to read */
 490         i2c_op.cmd = XGBE_I2C_CMD_WRITE;
 491         i2c_op.target = target;
 492         i2c_op.len = reg_len;
 493         i2c_op.buf = reg;
 494         ret = xgbe_phy_i2c_xfer(pdata, &i2c_op);
 495         if (ret) {
 496                 if ((ret == -EAGAIN) && retry--)
 497                         goto again1;
 498
 499                 return ret;
 500         }
 501
 502         retry = 1;
 503 again2:
 504         /* Read the specfied register */
 505         i2c_op.cmd = XGBE_I2C_CMD_READ;
 506         i2c_op.target = target;
 507         i2c_op.len = val_len;
 508         i2c_op.buf = val;
 509         ret = xgbe_phy_i2c_xfer(pdata, &i2c_op);
 510         if ((ret == -EAGAIN) && retry--)
 511                 goto again2;
 512
 513         return ret;
 514 }
 515
 516 static int xgbe_phy_sfp_put_mux(struct xgbe_prv_data *pdata)
 517 {
 518         struct xgbe_phy_data *phy_data = pdata->phy_data;
 519         struct xgbe_i2c_op i2c_op;
 520         u8 mux_channel;
 521
 522         if (phy_data->sfp_comm == XGBE_SFP_COMM_DIRECT)
 523                 return 0;
 524
 525         /* Select no mux channels */
 526         mux_channel = 0;
 527         i2c_op.cmd = XGBE_I2C_CMD_WRITE;
 528         i2c_op.target = phy_data->sfp_mux_address;
 529         i2c_op.len = sizeof(mux_channel);
 530         i2c_op.buf = &mux_channel;
 531
 532         return xgbe_phy_i2c_xfer(pdata, &i2c_op);
 533 }
 534
 535 static int xgbe_phy_sfp_get_mux(struct xgbe_prv_data *pdata)
 536 {
 537         struct xgbe_phy_data *phy_data = pdata->phy_data;
 538         struct xgbe_i2c_op i2c_op;
 539         u8 mux_channel;
 540
 541         if (phy_data->sfp_comm == XGBE_SFP_COMM_DIRECT)
 542                 return 0;
 543
 544         /* Select desired mux channel */
 545         mux_channel = 1 << phy_data->sfp_mux_channel;
 546         i2c_op.cmd = XGBE_I2C_CMD_WRITE;
 547         i2c_op.target = phy_data->sfp_mux_address;
 548         i2c_op.len = sizeof(mux_channel);
 549         i2c_op.buf = &mux_channel;
 550
 551         return xgbe_phy_i2c_xfer(pdata, &i2c_op);
 552 }
 553
 554 static void xgbe_phy_put_comm_ownership(struct xgbe_prv_data *pdata)
 555 {
 556         mutex_unlock(&xgbe_phy_comm_lock);
 557 }
 558
 559 static int xgbe_phy_get_comm_ownership(struct xgbe_prv_data *pdata)
 560 {
 561         struct xgbe_phy_data *phy_data = pdata->phy_data;
 562         unsigned long timeout;
 563         unsigned int mutex_id;
 564
 565         /* The I2C and MDIO/GPIO bus is multiplexed between multiple devices,
 566          * the driver needs to take the software mutex and then the hardware
 567          * mutexes before being able to use the busses.
 568          */
 569         mutex_lock(&xgbe_phy_comm_lock);
 570
 571         /* Clear the mutexes */
 572         XP_IOWRITE(pdata, XP_I2C_MUTEX, XGBE_MUTEX_RELEASE);
 573         XP_IOWRITE(pdata, XP_MDIO_MUTEX, XGBE_MUTEX_RELEASE);
 574
 575         /* Mutex formats are the same for I2C and MDIO/GPIO */
 576         mutex_id = 0;
 577         XP_SET_BITS(mutex_id, XP_I2C_MUTEX, ID, phy_data->port_id);
 578         XP_SET_BITS(mutex_id, XP_I2C_MUTEX, ACTIVE, 1);
 579
 580         timeout = jiffies + (5 * HZ);
 581         while (time_before(jiffies, timeout)) {
 582                 /* Must be all zeroes in order to obtain the mutex */
 583                 if (XP_IOREAD(pdata, XP_I2C_MUTEX) ||
 584                     XP_IOREAD(pdata, XP_MDIO_MUTEX)) {
 585                         usleep_range(100, 200);
 586                         continue;
 587                 }
 588
 589                 /* Obtain the mutex */
 590                 XP_IOWRITE(pdata, XP_I2C_MUTEX, mutex_id);
 591                 XP_IOWRITE(pdata, XP_MDIO_MUTEX, mutex_id);
 592
 593                 return 0;
 594         }
 595
 596         mutex_unlock(&xgbe_phy_comm_lock);
 597
 598         netdev_err(pdata->netdev, "unable to obtain hardware mutexes\n");
 599
 600         return -ETIMEDOUT;
 601 }
 602
 603 static int xgbe_phy_mdio_mii_write(struct xgbe_prv_data *pdata, int addr,
 604                                    int reg, u16 val)
 605 {
 606         struct xgbe_phy_data *phy_data = pdata->phy_data;
 607
 608         if (reg & MII_ADDR_C45) {
 609                 if (phy_data->phydev_mode != XGBE_MDIO_MODE_CL45)
 610                         return -ENOTSUPP;
 611         } else {
 612                 if (phy_data->phydev_mode != XGBE_MDIO_MODE_CL22)
 613                         return -ENOTSUPP;
 614         }
 615
 616         return pdata->hw_if.write_ext_mii_regs(pdata, addr, reg, val);
 617 }
 618
 619 static int xgbe_phy_i2c_mii_write(struct xgbe_prv_data *pdata, int reg, u16 val)
 620 {
 621         __be16 *mii_val;
 622         u8 mii_data[3];
 623         int ret;
 624
 625         ret = xgbe_phy_sfp_get_mux(pdata);
 626         if (ret)
 627                 return ret;
 628
 629         mii_data[0] = reg & 0xff;
 630         mii_val = (__be16 *)&mii_data[1];
 631         *mii_val = cpu_to_be16(val);
 632
 633         ret = xgbe_phy_i2c_write(pdata, XGBE_SFP_PHY_ADDRESS,
 634                                  mii_data, sizeof(mii_data));
 635
 636         xgbe_phy_sfp_put_mux(pdata);
 637
 638         return ret;
 639 }
 640
 641 static int xgbe_phy_mii_write(struct mii_bus *mii, int addr, int reg, u16 val)
 642 {
 643         struct xgbe_prv_data *pdata = mii->priv;
 644         struct xgbe_phy_data *phy_data = pdata->phy_data;
 645         int ret;
 646
 647         ret = xgbe_phy_get_comm_ownership(pdata);
 648         if (ret)
 649                 return ret;
 650
 651         if (phy_data->conn_type == XGBE_CONN_TYPE_SFP)
 652                 ret = xgbe_phy_i2c_mii_write(pdata, reg, val);
 653         else if (phy_data->conn_type & XGBE_CONN_TYPE_MDIO)
 654                 ret = xgbe_phy_mdio_mii_write(pdata, addr, reg, val);
 655         else
 656                 ret = -ENOTSUPP;
 657
 658         xgbe_phy_put_comm_ownership(pdata);
 659
 660         return ret;
 661 }
 662
 663 static int xgbe_phy_mdio_mii_read(struct xgbe_prv_data *pdata, int addr,
 664                                   int reg)
 665 {
 666         struct xgbe_phy_data *phy_data = pdata->phy_data;
 667
 668         if (reg & MII_ADDR_C45) {
 669                 if (phy_data->phydev_mode != XGBE_MDIO_MODE_CL45)
 670                         return -ENOTSUPP;
 671         } else {
 672                 if (phy_data->phydev_mode != XGBE_MDIO_MODE_CL22)
 673                         return -ENOTSUPP;
 674         }
 675
 676         return pdata->hw_if.read_ext_mii_regs(pdata, addr, reg);
 677 }
 678
 679 static int xgbe_phy_i2c_mii_read(struct xgbe_prv_data *pdata, int reg)
 680 {
 681         __be16 mii_val;
 682         u8 mii_reg;
 683         int ret;
 684
 685         ret = xgbe_phy_sfp_get_mux(pdata);
 686         if (ret)
 687                 return ret;
 688
 689         mii_reg = reg;
 690         ret = xgbe_phy_i2c_read(pdata, XGBE_SFP_PHY_ADDRESS,
 691                                 &mii_reg, sizeof(mii_reg),
 692                                 &mii_val, sizeof(mii_val));
 693         if (!ret)
 694                 ret = be16_to_cpu(mii_val);
 695
 696         xgbe_phy_sfp_put_mux(pdata);
 697
 698         return ret;
 699 }
 700
 701 static int xgbe_phy_mii_read(struct mii_bus *mii, int addr, int reg)
 702 {
 703         struct xgbe_prv_data *pdata = mii->priv;
 704         struct xgbe_phy_data *phy_data = pdata->phy_data;
 705         int ret;
 706
 707         ret = xgbe_phy_get_comm_ownership(pdata);
 708         if (ret)
 709                 return ret;
 710
 711         if (phy_data->conn_type == XGBE_CONN_TYPE_SFP)
 712                 ret = xgbe_phy_i2c_mii_read(pdata, reg);
 713         else if (phy_data->conn_type & XGBE_CONN_TYPE_MDIO)
 714                 ret = xgbe_phy_mdio_mii_read(pdata, addr, reg);
 715         else
 716                 ret = -ENOTSUPP;
 717
 718         xgbe_phy_put_comm_ownership(pdata);
 719
 720         return ret;
 721 }
 722
 723 static void xgbe_phy_sfp_phy_settings(struct xgbe_prv_data *pdata)
 724 {
 725         struct ethtool_link_ksettings *lks = &pdata->phy.lks;
 726         struct xgbe_phy_data *phy_data = pdata->phy_data;
 727
 728         if (!phy_data->sfp_mod_absent && !phy_data->sfp_changed)
 729                 return;
 730
 731         XGBE_ZERO_SUP(lks);
 732
 733         if (phy_data->sfp_mod_absent) {
 734                 pdata->phy.speed = SPEED_UNKNOWN;
 735                 pdata->phy.duplex = DUPLEX_UNKNOWN;
 736                 pdata->phy.autoneg = AUTONEG_ENABLE;
 737                 pdata->phy.pause_autoneg = AUTONEG_ENABLE;
 738
 739                 XGBE_SET_SUP(lks, Autoneg);
 740                 XGBE_SET_SUP(lks, Pause);
 741                 XGBE_SET_SUP(lks, Asym_Pause);
 742                 XGBE_SET_SUP(lks, TP);
 743                 XGBE_SET_SUP(lks, FIBRE);
 744
 745                 XGBE_LM_COPY(lks, advertising, lks, supported);
 746
 747                 return;
 748         }
 749
 750         switch (phy_data->sfp_base) {
 751         case XGBE_SFP_BASE_1000_T:
 752         case XGBE_SFP_BASE_1000_SX:
 753         case XGBE_SFP_BASE_1000_LX:
 754         case XGBE_SFP_BASE_1000_CX:
 755                 pdata->phy.speed = SPEED_UNKNOWN;
 756                 pdata->phy.duplex = DUPLEX_UNKNOWN;
 757                 pdata->phy.autoneg = AUTONEG_ENABLE;
 758                 pdata->phy.pause_autoneg = AUTONEG_ENABLE;
 759                 XGBE_SET_SUP(lks, Autoneg);
 760                 XGBE_SET_SUP(lks, Pause);
 761                 XGBE_SET_SUP(lks, Asym_Pause);
 762                 if (phy_data->sfp_base == XGBE_SFP_BASE_1000_T) {
 763                         if (phy_data->port_speeds & XGBE_PHY_PORT_SPEED_100)
 764                                 XGBE_SET_SUP(lks, 100baseT_Full);
 765                         if (phy_data->port_speeds & XGBE_PHY_PORT_SPEED_1000)
 766                                 XGBE_SET_SUP(lks, 1000baseT_Full);
 767                 } else {
 768                         if (phy_data->port_speeds & XGBE_PHY_PORT_SPEED_1000)
 769                                 XGBE_SET_SUP(lks, 1000baseX_Full);
 770                 }
 771                 break;
 772         case XGBE_SFP_BASE_10000_SR:
 773         case XGBE_SFP_BASE_10000_LR:
 774         case XGBE_SFP_BASE_10000_LRM:
 775         case XGBE_SFP_BASE_10000_ER:
 776         case XGBE_SFP_BASE_10000_CR:
 777                 pdata->phy.speed = SPEED_10000;
 778                 pdata->phy.duplex = DUPLEX_FULL;
 779                 pdata->phy.autoneg = AUTONEG_DISABLE;
 780                 pdata->phy.pause_autoneg = AUTONEG_DISABLE;
 781                 if (phy_data->port_speeds & XGBE_PHY_PORT_SPEED_10000) {
 782                         switch (phy_data->sfp_base) {
 783                         case XGBE_SFP_BASE_10000_SR:
 784                                 XGBE_SET_SUP(lks, 10000baseSR_Full);
 785                                 break;
 786                         case XGBE_SFP_BASE_10000_LR:
 787                                 XGBE_SET_SUP(lks, 10000baseLR_Full);
 788                                 break;
 789                         case XGBE_SFP_BASE_10000_LRM:
 790                                 XGBE_SET_SUP(lks, 10000baseLRM_Full);
 791                                 break;
 792                         case XGBE_SFP_BASE_10000_ER:
 793                                 XGBE_SET_SUP(lks, 10000baseER_Full);
 794                                 break;
 795                         case XGBE_SFP_BASE_10000_CR:
 796                                 XGBE_SET_SUP(lks, 10000baseCR_Full);
 797                                 break;
 798                         default:
 799                                 break;
 800                         }
 801                 }
 802                 break;
 803         default:
 804                 pdata->phy.speed = SPEED_UNKNOWN;
 805                 pdata->phy.duplex = DUPLEX_UNKNOWN;
 806                 pdata->phy.autoneg = AUTONEG_DISABLE;
 807                 pdata->phy.pause_autoneg = AUTONEG_DISABLE;
 808                 break;
 809         }
 810
 811         switch (phy_data->sfp_base) {
 812         case XGBE_SFP_BASE_1000_T:
 813         case XGBE_SFP_BASE_1000_CX:
 814         case XGBE_SFP_BASE_10000_CR:
 815                 XGBE_SET_SUP(lks, TP);
 816                 break;
 817         default:
 818                 XGBE_SET_SUP(lks, FIBRE);
 819                 break;
 820         }
 821
 822         XGBE_LM_COPY(lks, advertising, lks, supported);
 823 }
 824
 825 static bool xgbe_phy_sfp_bit_rate(struct xgbe_sfp_eeprom *sfp_eeprom,
 826                                   enum xgbe_sfp_speed sfp_speed)
 827 {
 828         u8 *sfp_base, min, max;
 829
 830         sfp_base = sfp_eeprom->base;
 831
 832         switch (sfp_speed) {
 833         case XGBE_SFP_SPEED_1000:
 834                 min = XGBE_SFP_BASE_BR_1GBE_MIN;
 835                 max = XGBE_SFP_BASE_BR_1GBE_MAX;
 836                 break;
 837         case XGBE_SFP_SPEED_10000:
 838                 min = XGBE_SFP_BASE_BR_10GBE_MIN;
 839                 if (memcmp(&sfp_eeprom->base[XGBE_SFP_BASE_VENDOR_NAME],
 840                            XGBE_MOLEX_VENDOR, XGBE_SFP_BASE_VENDOR_NAME_LEN) == 0)
 841                         max = XGBE_MOLEX_SFP_BASE_BR_10GBE_MAX;
 842                 else
 843                         max = XGBE_SFP_BASE_BR_10GBE_MAX;
 844                 break;
 845         default:
 846                 return false;
 847         }
 848
 849         return ((sfp_base[XGBE_SFP_BASE_BR] >= min) &&
 850                 (sfp_base[XGBE_SFP_BASE_BR] <= max));
 851 }
 852
 853 static void xgbe_phy_free_phy_device(struct xgbe_prv_data *pdata)
 854 {
 855         struct xgbe_phy_data *phy_data = pdata->phy_data;
 856
 857         if (phy_data->phydev) {
 858                 phy_detach(phy_data->phydev);
 859                 phy_device_remove(phy_data->phydev);
 860                 phy_device_free(phy_data->phydev);
 861                 phy_data->phydev = NULL;
 862         }
 863 }
 864
 865 static bool xgbe_phy_finisar_phy_quirks(struct xgbe_prv_data *pdata)
 866 {
 867         struct xgbe_phy_data *phy_data = pdata->phy_data;
 868         unsigned int phy_id = phy_data->phydev->phy_id;
 869
 870         if (phy_data->port_mode != XGBE_PORT_MODE_SFP)
 871                 return false;
 872
 873         if ((phy_id & 0xfffffff0) != 0x01ff0cc0)
 874                 return false;
 875
 876         /* Enable Base-T AN */
 877         phy_write(phy_data->phydev, 0x16, 0x0001);
 878         phy_write(phy_data->phydev, 0x00, 0x9140);
 879         phy_write(phy_data->phydev, 0x16, 0x0000);
 880
 881         /* Enable SGMII at 100Base-T/1000Base-T Full Duplex */
 882         phy_write(phy_data->phydev, 0x1b, 0x9084);
 883         phy_write(phy_data->phydev, 0x09, 0x0e00);
 884         phy_write(phy_data->phydev, 0x00, 0x8140);
 885         phy_write(phy_data->phydev, 0x04, 0x0d01);
 886         phy_write(phy_data->phydev, 0x00, 0x9140);
 887
 888         phy_data->phydev->supported = PHY_GBIT_FEATURES;
 889         phy_data->phydev->supported |= SUPPORTED_Pause | SUPPORTED_Asym_Pause;
 890         phy_data->phydev->advertising = phy_data->phydev->supported;
 891
 892         netif_dbg(pdata, drv, pdata->netdev,
 893                   "Finisar PHY quirk in place\n");
 894
 895         return true;
 896 }
 897
 898 static bool xgbe_phy_belfuse_phy_quirks(struct xgbe_prv_data *pdata)
 899 {
 900         struct xgbe_phy_data *phy_data = pdata->phy_data;
 901         struct xgbe_sfp_eeprom *sfp_eeprom = &phy_data->sfp_eeprom;
 902         unsigned int phy_id = phy_data->phydev->phy_id;
 903         int reg;
 904
 905         if (phy_data->port_mode != XGBE_PORT_MODE_SFP)
 906                 return false;
 907
 908         if (memcmp(&sfp_eeprom->base[XGBE_SFP_BASE_VENDOR_NAME],
 909                    XGBE_BEL_FUSE_VENDOR, XGBE_SFP_BASE_VENDOR_NAME_LEN))
 910                 return false;
 911
 912         /* For Bel-Fuse, use the extra AN flag */
 913         pdata->an_again = 1;
 914
 915         if (memcmp(&sfp_eeprom->base[XGBE_SFP_BASE_VENDOR_PN],
 916                    XGBE_BEL_FUSE_PARTNO, XGBE_SFP_BASE_VENDOR_PN_LEN))
 917                 return false;
 918
 919         if ((phy_id & 0xfffffff0) != 0x03625d10)
 920                 return false;
 921
 922         /* Reset PHY - wait for self-clearing reset bit to clear */
 923         genphy_soft_reset(phy_data->phydev);
 924
 925         /* Disable RGMII mode */
 926         phy_write(phy_data->phydev, 0x18, 0x7007);
 927         reg = phy_read(phy_data->phydev, 0x18);
 928         phy_write(phy_data->phydev, 0x18, reg & ~0x0080);
 929
 930         /* Enable fiber register bank */
 931         phy_write(phy_data->phydev, 0x1c, 0x7c00);
 932         reg = phy_read(phy_data->phydev, 0x1c);
 933         reg &= 0x03ff;
 934         reg &= ~0x0001;
 935         phy_write(phy_data->phydev, 0x1c, 0x8000 | 0x7c00 | reg | 0x0001);
 936
 937         /* Power down SerDes */
 938         reg = phy_read(phy_data->phydev, 0x00);
 939         phy_write(phy_data->phydev, 0x00, reg | 0x00800);
 940
 941         /* Configure SGMII-to-Copper mode */
 942         phy_write(phy_data->phydev, 0x1c, 0x7c00);
 943         reg = phy_read(phy_data->phydev, 0x1c);
 944         reg &= 0x03ff;
 945         reg &= ~0x0006;
 946         phy_write(phy_data->phydev, 0x1c, 0x8000 | 0x7c00 | reg | 0x0004);
 947
 948         /* Power up SerDes */
 949         reg = phy_read(phy_data->phydev, 0x00);
 950         phy_write(phy_data->phydev, 0x00, reg & ~0x00800);
 951
 952         /* Enable copper register bank */
 953         phy_write(phy_data->phydev, 0x1c, 0x7c00);
 954         reg = phy_read(phy_data->phydev, 0x1c);
 955         reg &= 0x03ff;
 956         reg &= ~0x0001;
 957         phy_write(phy_data->phydev, 0x1c, 0x8000 | 0x7c00 | reg);
 958
 959         /* Power up SerDes */
 960         reg = phy_read(phy_data->phydev, 0x00);
 961         phy_write(phy_data->phydev, 0x00, reg & ~0x00800);
 962
 963         phy_data->phydev->supported = PHY_GBIT_FEATURES;
 964         phy_data->phydev->supported |= SUPPORTED_Pause | SUPPORTED_Asym_Pause;
 965         phy_data->phydev->advertising = phy_data->phydev->supported;
 966
 967         netif_dbg(pdata, drv, pdata->netdev,
 968                   "BelFuse PHY quirk in place\n");
 969
 970         return true;
 971 }
 972
 973 static void xgbe_phy_external_phy_quirks(struct xgbe_prv_data *pdata)
 974 {
 975         if (xgbe_phy_belfuse_phy_quirks(pdata))
 976                 return;
 977
 978         if (xgbe_phy_finisar_phy_quirks(pdata))
 979                 return;
 980 }
 981
 982 static int xgbe_phy_find_phy_device(struct xgbe_prv_data *pdata)
 983 {
 984         struct ethtool_link_ksettings *lks = &pdata->phy.lks;
 985         struct xgbe_phy_data *phy_data = pdata->phy_data;
 986         struct phy_device *phydev;
 987         u32 advertising;
 988         int ret;
 989
 990         /* If we already have a PHY, just return */
 991         if (phy_data->phydev)
 992                 return 0;
 993
 994         /* Clear the extra AN flag */
 995         pdata->an_again = 0;
 996
 997         /* Check for the use of an external PHY */
 998         if (phy_data->phydev_mode == XGBE_MDIO_MODE_NONE)
 999                 return 0;
1000
1001         /* For SFP, only use an external PHY if available */
1002         if ((phy_data->port_mode == XGBE_PORT_MODE_SFP) &&
1003             !phy_data->sfp_phy_avail)
1004                 return 0;
1005
1006         /* Set the proper MDIO mode for the PHY */
1007         ret = pdata->hw_if.set_ext_mii_mode(pdata, phy_data->mdio_addr,
1008                                             phy_data->phydev_mode);
1009         if (ret) {
1010                 netdev_err(pdata->netdev,
1011                            "mdio port/clause not compatible (%u/%u)\n",
1012                            phy_data->mdio_addr, phy_data->phydev_mode);
1013                 return ret;
1014         }
1015
1016         /* Create and connect to the PHY device */
1017         phydev = get_phy_device(phy_data->mii, phy_data->mdio_addr,
1018                                 (phy_data->phydev_mode == XGBE_MDIO_MODE_CL45));
1019         if (IS_ERR(phydev)) {
1020                 netdev_err(pdata->netdev, "get_phy_device failed\n");
1021                 return -ENODEV;
1022         }
1023         netif_dbg(pdata, drv, pdata->netdev, "external PHY id is %#010x\n",
1024                   phydev->phy_id);
1025
1026         /*TODO: If c45, add request_module based on one of the MMD ids? */
1027
1028         ret = phy_device_register(phydev);
1029         if (ret) {
1030                 netdev_err(pdata->netdev, "phy_device_register failed\n");
1031                 phy_device_free(phydev);
1032                 return ret;
1033         }
1034
1035         ret = phy_attach_direct(pdata->netdev, phydev, phydev->dev_flags,
1036                                 PHY_INTERFACE_MODE_SGMII);
1037         if (ret) {
1038                 netdev_err(pdata->netdev, "phy_attach_direct failed\n");
1039                 phy_device_remove(phydev);
1040                 phy_device_free(phydev);
1041                 return ret;
1042         }
1043         phy_data->phydev = phydev;
1044
1045         xgbe_phy_external_phy_quirks(pdata);
1046
1047         ethtool_convert_link_mode_to_legacy_u32(&advertising,
1048                                                 lks->link_modes.advertising);
1049         phydev->advertising &= advertising;
1050
1051         phy_start_aneg(phy_data->phydev);
1052
1053         return 0;
1054 }
1055
1056 static void xgbe_phy_sfp_external_phy(struct xgbe_prv_data *pdata)
1057 {
1058         struct xgbe_phy_data *phy_data = pdata->phy_data;
1059         int ret;
1060
1061         if (!phy_data->sfp_changed)
1062                 return;
1063
1064         phy_data->sfp_phy_avail = 0;
1065
1066         if (phy_data->sfp_base != XGBE_SFP_BASE_1000_T)
1067                 return;
1068
1069         /* Check access to the PHY by reading CTRL1 */
1070         ret = xgbe_phy_i2c_mii_read(pdata, MII_BMCR);
1071         if (ret < 0)
1072                 return;
1073
1074         /* Successfully accessed the PHY */
1075         phy_data->sfp_phy_avail = 1;
1076 }
1077
1078 static bool xgbe_phy_check_sfp_rx_los(struct xgbe_phy_data *phy_data)
1079 {
1080         u8 *sfp_extd = phy_data->sfp_eeprom.extd;
1081
1082         if (!(sfp_extd[XGBE_SFP_EXTD_OPT1] & XGBE_SFP_EXTD_OPT1_RX_LOS))
1083                 return false;
1084
1085         if (phy_data->sfp_gpio_mask & XGBE_GPIO_NO_RX_LOS)
1086                 return false;
1087
1088         if (phy_data->sfp_gpio_inputs & (1 << phy_data->sfp_gpio_rx_los))
1089                 return true;
1090
1091         return false;
1092 }
1093
1094 static bool xgbe_phy_check_sfp_tx_fault(struct xgbe_phy_data *phy_data)
1095 {
1096         u8 *sfp_extd = phy_data->sfp_eeprom.extd;
1097
1098         if (!(sfp_extd[XGBE_SFP_EXTD_OPT1] & XGBE_SFP_EXTD_OPT1_TX_FAULT))
1099                 return false;
1100
1101         if (phy_data->sfp_gpio_mask & XGBE_GPIO_NO_TX_FAULT)
1102                 return false;
1103
1104         if (phy_data->sfp_gpio_inputs & (1 << phy_data->sfp_gpio_tx_fault))
1105                 return true;
1106
1107         return false;
1108 }
1109
1110 static bool xgbe_phy_check_sfp_mod_absent(struct xgbe_phy_data *phy_data)
1111 {
1112         if (phy_data->sfp_gpio_mask & XGBE_GPIO_NO_MOD_ABSENT)
1113                 return false;
1114
1115         if (phy_data->sfp_gpio_inputs & (1 << phy_data->sfp_gpio_mod_absent))
1116                 return true;
1117
1118         return false;
1119 }
1120
1121 static void xgbe_phy_sfp_parse_eeprom(struct xgbe_prv_data *pdata)
1122 {
1123         struct xgbe_phy_data *phy_data = pdata->phy_data;
1124         struct xgbe_sfp_eeprom *sfp_eeprom = &phy_data->sfp_eeprom;
1125         u8 *sfp_base;
1126
1127         sfp_base = sfp_eeprom->base;
1128
1129         if (sfp_base[XGBE_SFP_BASE_ID] != XGBE_SFP_ID_SFP)
1130                 return;
1131
1132         if (sfp_base[XGBE_SFP_BASE_EXT_ID] != XGBE_SFP_EXT_ID_SFP)
1133                 return;
1134
1135         /* Update transceiver signals (eeprom extd/options) */
1136         phy_data->sfp_tx_fault = xgbe_phy_check_sfp_tx_fault(phy_data);
1137         phy_data->sfp_rx_los = xgbe_phy_check_sfp_rx_los(phy_data);
1138
1139         /* Assume ACTIVE cable unless told it is PASSIVE */
1140         if (sfp_base[XGBE_SFP_BASE_CABLE] & XGBE_SFP_BASE_CABLE_PASSIVE) {
1141                 phy_data->sfp_cable = XGBE_SFP_CABLE_PASSIVE;
1142                 phy_data->sfp_cable_len = sfp_base[XGBE_SFP_BASE_CU_CABLE_LEN];
1143         } else {
1144                 phy_data->sfp_cable = XGBE_SFP_CABLE_ACTIVE;
1145         }
1146
1147         /* Determine the type of SFP */
1148         if (phy_data->sfp_cable == XGBE_SFP_CABLE_PASSIVE &&
1149             xgbe_phy_sfp_bit_rate(sfp_eeprom, XGBE_SFP_SPEED_10000))
1150                 phy_data->sfp_base = XGBE_SFP_BASE_10000_CR;
1151         else if (sfp_base[XGBE_SFP_BASE_10GBE_CC] & XGBE_SFP_BASE_10GBE_CC_SR)
1152                 phy_data->sfp_base = XGBE_SFP_BASE_10000_SR;
1153         else if (sfp_base[XGBE_SFP_BASE_10GBE_CC] & XGBE_SFP_BASE_10GBE_CC_LR)
1154                 phy_data->sfp_base = XGBE_SFP_BASE_10000_LR;
1155         else if (sfp_base[XGBE_SFP_BASE_10GBE_CC] & XGBE_SFP_BASE_10GBE_CC_LRM)
1156                 phy_data->sfp_base = XGBE_SFP_BASE_10000_LRM;
1157         else if (sfp_base[XGBE_SFP_BASE_10GBE_CC] & XGBE_SFP_BASE_10GBE_CC_ER)
1158                 phy_data->sfp_base = XGBE_SFP_BASE_10000_ER;
1159         else if (sfp_base[XGBE_SFP_BASE_1GBE_CC] & XGBE_SFP_BASE_1GBE_CC_SX)
1160                 phy_data->sfp_base = XGBE_SFP_BASE_1000_SX;
1161         else if (sfp_base[XGBE_SFP_BASE_1GBE_CC] & XGBE_SFP_BASE_1GBE_CC_LX)
1162                 phy_data->sfp_base = XGBE_SFP_BASE_1000_LX;
1163         else if (sfp_base[XGBE_SFP_BASE_1GBE_CC] & XGBE_SFP_BASE_1GBE_CC_CX)
1164                 phy_data->sfp_base = XGBE_SFP_BASE_1000_CX;
1165         else if (sfp_base[XGBE_SFP_BASE_1GBE_CC] & XGBE_SFP_BASE_1GBE_CC_T)
1166                 phy_data->sfp_base = XGBE_SFP_BASE_1000_T;
1167
1168         switch (phy_data->sfp_base) {
1169         case XGBE_SFP_BASE_1000_T:
1170                 phy_data->sfp_speed = XGBE_SFP_SPEED_100_1000;
1171                 break;
1172         case XGBE_SFP_BASE_1000_SX:
1173         case XGBE_SFP_BASE_1000_LX:
1174         case XGBE_SFP_BASE_1000_CX:
1175                 phy_data->sfp_speed = XGBE_SFP_SPEED_1000;
1176                 break;
1177         case XGBE_SFP_BASE_10000_SR:
1178         case XGBE_SFP_BASE_10000_LR:
1179         case XGBE_SFP_BASE_10000_LRM:
1180         case XGBE_SFP_BASE_10000_ER:
1181         case XGBE_SFP_BASE_10000_CR:
1182                 phy_data->sfp_speed = XGBE_SFP_SPEED_10000;
1183                 break;
1184         default:
1185                 break;
1186         }
1187 }
1188
1189 static void xgbe_phy_sfp_eeprom_info(struct xgbe_prv_data *pdata,
1190                                      struct xgbe_sfp_eeprom *sfp_eeprom)
1191 {
1192         struct xgbe_sfp_ascii sfp_ascii;
1193         char *sfp_data = (char *)&sfp_ascii;
1194
1195         netif_dbg(pdata, drv, pdata->netdev, "SFP detected:\n");
1196         memcpy(sfp_data, &sfp_eeprom->base[XGBE_SFP_BASE_VENDOR_NAME],
1197                XGBE_SFP_BASE_VENDOR_NAME_LEN);
1198         sfp_data[XGBE_SFP_BASE_VENDOR_NAME_LEN] = '\0';
1199         netif_dbg(pdata, drv, pdata->netdev, "  vendor:         %s\n",
1200                   sfp_data);
1201
1202         memcpy(sfp_data, &sfp_eeprom->base[XGBE_SFP_BASE_VENDOR_PN],
1203                XGBE_SFP_BASE_VENDOR_PN_LEN);
1204         sfp_data[XGBE_SFP_BASE_VENDOR_PN_LEN] = '\0';
1205         netif_dbg(pdata, drv, pdata->netdev, "  part number:    %s\n",
1206                   sfp_data);
1207
1208         memcpy(sfp_data, &sfp_eeprom->base[XGBE_SFP_BASE_VENDOR_REV],
1209                XGBE_SFP_BASE_VENDOR_REV_LEN);
1210         sfp_data[XGBE_SFP_BASE_VENDOR_REV_LEN] = '\0';
1211         netif_dbg(pdata, drv, pdata->netdev, "  revision level: %s\n",
1212                   sfp_data);
1213
1214         memcpy(sfp_data, &sfp_eeprom->extd[XGBE_SFP_BASE_VENDOR_SN],
1215                XGBE_SFP_BASE_VENDOR_SN_LEN);
1216         sfp_data[XGBE_SFP_BASE_VENDOR_SN_LEN] = '\0';
1217         netif_dbg(pdata, drv, pdata->netdev, "  serial number:  %s\n",
1218                   sfp_data);
1219 }
1220
1221 static bool xgbe_phy_sfp_verify_eeprom(u8 cc_in, u8 *buf, unsigned int len)
1222 {
1223         u8 cc;
1224
1225         for (cc = 0; len; buf++, len--)
1226                 cc += *buf;
1227
1228         return (cc == cc_in) ? true : false;
1229 }
1230
1231 static int xgbe_phy_sfp_read_eeprom(struct xgbe_prv_data *pdata)
1232 {
1233         struct xgbe_phy_data *phy_data = pdata->phy_data;
1234         struct xgbe_sfp_eeprom sfp_eeprom;
1235         u8 eeprom_addr;
1236         int ret;
1237
1238         ret = xgbe_phy_sfp_get_mux(pdata);
1239         if (ret) {
1240                 dev_err_once(pdata->dev, "%s: I2C error setting SFP MUX\n",
1241                              netdev_name(pdata->netdev));
1242                 return ret;
1243         }
1244
1245         /* Read the SFP serial ID eeprom */
1246         eeprom_addr = 0;
1247         ret = xgbe_phy_i2c_read(pdata, XGBE_SFP_SERIAL_ID_ADDRESS,
1248                                 &eeprom_addr, sizeof(eeprom_addr),
1249                                 &sfp_eeprom, sizeof(sfp_eeprom));
1250         if (ret) {
1251                 dev_err_once(pdata->dev, "%s: I2C error reading SFP EEPROM\n",
1252                              netdev_name(pdata->netdev));
1253                 goto put;
1254         }
1255
1256         /* Validate the contents read */
1257         if (!xgbe_phy_sfp_verify_eeprom(sfp_eeprom.base[XGBE_SFP_BASE_CC],
1258                                         sfp_eeprom.base,
1259                                         sizeof(sfp_eeprom.base) - 1)) {
1260                 ret = -EINVAL;
1261                 goto put;
1262         }
1263
1264         if (!xgbe_phy_sfp_verify_eeprom(sfp_eeprom.extd[XGBE_SFP_EXTD_CC],
1265                                         sfp_eeprom.extd,
1266                                         sizeof(sfp_eeprom.extd) - 1)) {
1267                 ret = -EINVAL;
1268                 goto put;
1269         }
1270
1271         /* Check for an added or changed SFP */
1272         if (memcmp(&phy_data->sfp_eeprom, &sfp_eeprom, sizeof(sfp_eeprom))) {
1273                 phy_data->sfp_changed = 1;
1274
1275                 if (netif_msg_drv(pdata))
1276                         xgbe_phy_sfp_eeprom_info(pdata, &sfp_eeprom);
1277
1278                 memcpy(&phy_data->sfp_eeprom, &sfp_eeprom, sizeof(sfp_eeprom));
1279
1280                 xgbe_phy_free_phy_device(pdata);
1281         } else {
1282                 phy_data->sfp_changed = 0;
1283         }
1284
1285 put:
1286         xgbe_phy_sfp_put_mux(pdata);
1287
1288         return ret;
1289 }
1290
1291 static void xgbe_phy_sfp_signals(struct xgbe_prv_data *pdata)
1292 {
1293         struct xgbe_phy_data *phy_data = pdata->phy_data;
1294         u8 gpio_reg, gpio_ports[2];
1295         int ret;
1296
1297         /* Read the input port registers */
1298         gpio_reg = 0;
1299         ret = xgbe_phy_i2c_read(pdata, phy_data->sfp_gpio_address,
1300                                 &gpio_reg, sizeof(gpio_reg),
1301                                 gpio_ports, sizeof(gpio_ports));
1302         if (ret) {
1303                 dev_err_once(pdata->dev, "%s: I2C error reading SFP GPIOs\n",
1304                              netdev_name(pdata->netdev));
1305                 return;
1306         }
1307
1308         phy_data->sfp_gpio_inputs = (gpio_ports[1] << 8) | gpio_ports[0];
1309
1310         phy_data->sfp_mod_absent = xgbe_phy_check_sfp_mod_absent(phy_data);
1311 }
1312
1313 static void xgbe_phy_sfp_mod_absent(struct xgbe_prv_data *pdata)
1314 {
1315         struct xgbe_phy_data *phy_data = pdata->phy_data;
1316
1317         xgbe_phy_free_phy_device(pdata);
1318
1319         phy_data->sfp_mod_absent = 1;
1320         phy_data->sfp_phy_avail = 0;
1321         memset(&phy_data->sfp_eeprom, 0, sizeof(phy_data->sfp_eeprom));
1322 }
1323
1324 static void xgbe_phy_sfp_reset(struct xgbe_phy_data *phy_data)
1325 {
1326         phy_data->sfp_rx_los = 0;
1327         phy_data->sfp_tx_fault = 0;
1328         phy_data->sfp_mod_absent = 1;
1329         phy_data->sfp_base = XGBE_SFP_BASE_UNKNOWN;
1330         phy_data->sfp_cable = XGBE_SFP_CABLE_UNKNOWN;
1331         phy_data->sfp_speed = XGBE_SFP_SPEED_UNKNOWN;
1332 }
1333
1334 static void xgbe_phy_sfp_detect(struct xgbe_prv_data *pdata)
1335 {
1336         struct xgbe_phy_data *phy_data = pdata->phy_data;
1337         int ret;
1338
1339         /* Reset the SFP signals and info */
1340         xgbe_phy_sfp_reset(phy_data);
1341
1342         ret = xgbe_phy_get_comm_ownership(pdata);
1343         if (ret)
1344                 return;
1345
1346         /* Read the SFP signals and check for module presence */
1347         xgbe_phy_sfp_signals(pdata);
1348         if (phy_data->sfp_mod_absent) {
1349                 xgbe_phy_sfp_mod_absent(pdata);
1350                 goto put;
1351         }
1352
1353         ret = xgbe_phy_sfp_read_eeprom(pdata);
1354         if (ret) {
1355                 /* Treat any error as if there isn't an SFP plugged in */
1356                 xgbe_phy_sfp_reset(phy_data);
1357                 xgbe_phy_sfp_mod_absent(pdata);
1358                 goto put;
1359         }
1360
1361         xgbe_phy_sfp_parse_eeprom(pdata);
1362
1363         xgbe_phy_sfp_external_phy(pdata);
1364
1365 put:
1366         xgbe_phy_sfp_phy_settings(pdata);
1367
1368         xgbe_phy_put_comm_ownership(pdata);
1369 }
1370
1371 static int xgbe_phy_module_eeprom(struct xgbe_prv_data *pdata,
1372                                   struct ethtool_eeprom *eeprom, u8 *data)
1373 {
1374         struct xgbe_phy_data *phy_data = pdata->phy_data;
1375         u8 eeprom_addr, eeprom_data[XGBE_SFP_EEPROM_MAX];
1376         struct xgbe_sfp_eeprom *sfp_eeprom;
1377         unsigned int i, j, rem;
1378         int ret;
1379
1380         rem = eeprom->len;
1381
1382         if (!eeprom->len) {
1383                 ret = -EINVAL;
1384                 goto done;
1385         }
1386
1387         if ((eeprom->offset + eeprom->len) > XGBE_SFP_EEPROM_MAX) {
1388                 ret = -EINVAL;
1389                 goto done;
1390         }
1391
1392         if (phy_data->port_mode != XGBE_PORT_MODE_SFP) {
1393                 ret = -ENXIO;
1394                 goto done;
1395         }
1396
1397         if (!netif_running(pdata->netdev)) {
1398                 ret = -EIO;
1399                 goto done;
1400         }
1401
1402         if (phy_data->sfp_mod_absent) {
1403                 ret = -EIO;
1404                 goto done;
1405         }
1406
1407         ret = xgbe_phy_get_comm_ownership(pdata);
1408         if (ret) {
1409                 ret = -EIO;
1410                 goto done;
1411         }
1412
1413         ret = xgbe_phy_sfp_get_mux(pdata);
1414         if (ret) {
1415                 netdev_err(pdata->netdev, "I2C error setting SFP MUX\n");
1416                 ret = -EIO;
1417                 goto put_own;
1418         }
1419
1420         /* Read the SFP serial ID eeprom */
1421         eeprom_addr = 0;
1422         ret = xgbe_phy_i2c_read(pdata, XGBE_SFP_SERIAL_ID_ADDRESS,
1423                                 &eeprom_addr, sizeof(eeprom_addr),
1424                                 eeprom_data, XGBE_SFP_EEPROM_BASE_LEN);
1425         if (ret) {
1426                 netdev_err(pdata->netdev,
1427                            "I2C error reading SFP EEPROM\n");
1428                 ret = -EIO;
1429                 goto put_mux;
1430         }
1431
1432         sfp_eeprom = (struct xgbe_sfp_eeprom *)eeprom_data;
1433
1434         if (XGBE_SFP_DIAGS_SUPPORTED(sfp_eeprom)) {
1435                 /* Read the SFP diagnostic eeprom */
1436                 eeprom_addr = 0;
1437                 ret = xgbe_phy_i2c_read(pdata, XGBE_SFP_DIAG_INFO_ADDRESS,
1438                                         &eeprom_addr, sizeof(eeprom_addr),
1439                                         eeprom_data + XGBE_SFP_EEPROM_BASE_LEN,
1440                                         XGBE_SFP_EEPROM_DIAG_LEN);
1441                 if (ret) {
1442                         netdev_err(pdata->netdev,
1443                                    "I2C error reading SFP DIAGS\n");
1444                         ret = -EIO;
1445                         goto put_mux;
1446                 }
1447         }
1448
1449         for (i = 0, j = eeprom->offset; i < eeprom->len; i++, j++) {
1450                 if ((j >= XGBE_SFP_EEPROM_BASE_LEN) &&
1451                     !XGBE_SFP_DIAGS_SUPPORTED(sfp_eeprom))
1452                         break;
1453
1454                 data[i] = eeprom_data[j];
1455                 rem--;
1456         }
1457
1458 put_mux:
1459         xgbe_phy_sfp_put_mux(pdata);
1460
1461 put_own:
1462         xgbe_phy_put_comm_ownership(pdata);
1463
1464 done:
1465         eeprom->len -= rem;
1466
1467         return ret;
1468 }
1469
1470 static int xgbe_phy_module_info(struct xgbe_prv_data *pdata,
1471                                 struct ethtool_modinfo *modinfo)
1472 {
1473         struct xgbe_phy_data *phy_data = pdata->phy_data;
1474
1475         if (phy_data->port_mode != XGBE_PORT_MODE_SFP)
1476                 return -ENXIO;
1477
1478         if (!netif_running(pdata->netdev))
1479                 return -EIO;
1480
1481         if (phy_data->sfp_mod_absent)
1482                 return -EIO;
1483
1484         if (XGBE_SFP_DIAGS_SUPPORTED(&phy_data->sfp_eeprom)) {
1485                 modinfo->type = ETH_MODULE_SFF_8472;
1486                 modinfo->eeprom_len = ETH_MODULE_SFF_8472_LEN;
1487         } else {
1488                 modinfo->type = ETH_MODULE_SFF_8079;
1489                 modinfo->eeprom_len = ETH_MODULE_SFF_8079_LEN;
1490         }
1491
1492         return 0;
1493 }
1494
1495 static void xgbe_phy_phydev_flowctrl(struct xgbe_prv_data *pdata)
1496 {
1497         struct ethtool_link_ksettings *lks = &pdata->phy.lks;
1498         struct xgbe_phy_data *phy_data = pdata->phy_data;
1499         u16 lcl_adv = 0, rmt_adv = 0;
1500         u8 fc;
1501
1502         pdata->phy.tx_pause = 0;
1503         pdata->phy.rx_pause = 0;
1504
1505         if (!phy_data->phydev)
1506                 return;
1507
1508         if (phy_data->phydev->advertising & ADVERTISED_Pause)
1509                 lcl_adv |= ADVERTISE_PAUSE_CAP;
1510         if (phy_data->phydev->advertising & ADVERTISED_Asym_Pause)
1511                 lcl_adv |= ADVERTISE_PAUSE_ASYM;
1512
1513         if (phy_data->phydev->pause) {
1514                 XGBE_SET_LP_ADV(lks, Pause);
1515                 rmt_adv |= LPA_PAUSE_CAP;
1516         }
1517         if (phy_data->phydev->asym_pause) {
1518                 XGBE_SET_LP_ADV(lks, Asym_Pause);
1519                 rmt_adv |= LPA_PAUSE_ASYM;
1520         }
1521
1522         fc = mii_resolve_flowctrl_fdx(lcl_adv, rmt_adv);
1523         if (fc & FLOW_CTRL_TX)
1524                 pdata->phy.tx_pause = 1;
1525         if (fc & FLOW_CTRL_RX)
1526                 pdata->phy.rx_pause = 1;
1527 }
1528
1529 static enum xgbe_mode xgbe_phy_an37_sgmii_outcome(struct xgbe_prv_data *pdata)
1530 {
1531         struct ethtool_link_ksettings *lks = &pdata->phy.lks;
1532         enum xgbe_mode mode;
1533
1534         XGBE_SET_LP_ADV(lks, Autoneg);
1535         XGBE_SET_LP_ADV(lks, TP);
1536
1537         /* Use external PHY to determine flow control */
1538         if (pdata->phy.pause_autoneg)
1539                 xgbe_phy_phydev_flowctrl(pdata);
1540
1541         switch (pdata->an_status & XGBE_SGMII_AN_LINK_SPEED) {
1542         case XGBE_SGMII_AN_LINK_SPEED_100:
1543                 if (pdata->an_status & XGBE_SGMII_AN_LINK_DUPLEX) {
1544                         XGBE_SET_LP_ADV(lks, 100baseT_Full);
1545                         mode = XGBE_MODE_SGMII_100;
1546                 } else {
1547                         /* Half-duplex not supported */
1548                         XGBE_SET_LP_ADV(lks, 100baseT_Half);
1549                         mode = XGBE_MODE_UNKNOWN;
1550                 }
1551                 break;
1552         case XGBE_SGMII_AN_LINK_SPEED_1000:
1553                 if (pdata->an_status & XGBE_SGMII_AN_LINK_DUPLEX) {
1554                         XGBE_SET_LP_ADV(lks, 1000baseT_Full);
1555                         mode = XGBE_MODE_SGMII_1000;
1556                 } else {
1557                         /* Half-duplex not supported */
1558                         XGBE_SET_LP_ADV(lks, 1000baseT_Half);
1559                         mode = XGBE_MODE_UNKNOWN;
1560                 }
1561                 break;
1562         default:
1563                 mode = XGBE_MODE_UNKNOWN;
1564         }
1565
1566         return mode;
1567 }
1568
1569 static enum xgbe_mode xgbe_phy_an37_outcome(struct xgbe_prv_data *pdata)
1570 {
1571         struct ethtool_link_ksettings *lks = &pdata->phy.lks;
1572         enum xgbe_mode mode;
1573         unsigned int ad_reg, lp_reg;
1574
1575         XGBE_SET_LP_ADV(lks, Autoneg);
1576         XGBE_SET_LP_ADV(lks, FIBRE);
1577
1578         /* Compare Advertisement and Link Partner register */
1579         ad_reg = XMDIO_READ(pdata, MDIO_MMD_VEND2, MDIO_VEND2_AN_ADVERTISE);
1580         lp_reg = XMDIO_READ(pdata, MDIO_MMD_VEND2, MDIO_VEND2_AN_LP_ABILITY);
1581         if (lp_reg & 0x100)
1582                 XGBE_SET_LP_ADV(lks, Pause);
1583         if (lp_reg & 0x80)
1584                 XGBE_SET_LP_ADV(lks, Asym_Pause);
1585
1586         if (pdata->phy.pause_autoneg) {
1587                 /* Set flow control based on auto-negotiation result */
1588                 pdata->phy.tx_pause = 0;
1589                 pdata->phy.rx_pause = 0;
1590
1591                 if (ad_reg & lp_reg & 0x100) {
1592                         pdata->phy.tx_pause = 1;
1593                         pdata->phy.rx_pause = 1;
1594                 } else if (ad_reg & lp_reg & 0x80) {
1595                         if (ad_reg & 0x100)
1596                                 pdata->phy.rx_pause = 1;
1597                         else if (lp_reg & 0x100)
1598                                 pdata->phy.tx_pause = 1;
1599                 }
1600         }
1601
1602         if (lp_reg & 0x20)
1603                 XGBE_SET_LP_ADV(lks, 1000baseX_Full);
1604
1605         /* Half duplex is not supported */
1606         ad_reg &= lp_reg;
1607         mode = (ad_reg & 0x20) ? XGBE_MODE_X : XGBE_MODE_UNKNOWN;
1608
1609         return mode;
1610 }
1611
1612 static enum xgbe_mode xgbe_phy_an73_redrv_outcome(struct xgbe_prv_data *pdata)
1613 {
1614         struct ethtool_link_ksettings *lks = &pdata->phy.lks;
1615         struct xgbe_phy_data *phy_data = pdata->phy_data;
1616         enum xgbe_mode mode;
1617         unsigned int ad_reg, lp_reg;
1618
1619         XGBE_SET_LP_ADV(lks, Autoneg);
1620         XGBE_SET_LP_ADV(lks, Backplane);
1621
1622         /* Use external PHY to determine flow control */
1623         if (pdata->phy.pause_autoneg)
1624                 xgbe_phy_phydev_flowctrl(pdata);
1625
1626         /* Compare Advertisement and Link Partner register 2 */
1627         ad_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_ADVERTISE + 1);
1628         lp_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_LPA + 1);
1629         if (lp_reg & 0x80)
1630                 XGBE_SET_LP_ADV(lks, 10000baseKR_Full);
1631         if (lp_reg & 0x20)
1632                 XGBE_SET_LP_ADV(lks, 1000baseKX_Full);
1633
1634         ad_reg &= lp_reg;
1635         if (ad_reg & 0x80) {
1636                 switch (phy_data->port_mode) {
1637                 case XGBE_PORT_MODE_BACKPLANE:
1638                         mode = XGBE_MODE_KR;
1639                         break;
1640                 default:
1641                         mode = XGBE_MODE_SFI;
1642                         break;
1643                 }
1644         } else if (ad_reg & 0x20) {
1645                 switch (phy_data->port_mode) {
1646                 case XGBE_PORT_MODE_BACKPLANE:
1647                         mode = XGBE_MODE_KX_1000;
1648                         break;
1649                 case XGBE_PORT_MODE_1000BASE_X:
1650                         mode = XGBE_MODE_X;
1651                         break;
1652                 case XGBE_PORT_MODE_SFP:
1653                         switch (phy_data->sfp_base) {
1654                         case XGBE_SFP_BASE_1000_T:
1655                                 if (phy_data->phydev &&
1656                                     (phy_data->phydev->speed == SPEED_100))
1657                                         mode = XGBE_MODE_SGMII_100;
1658                                 else
1659                                         mode = XGBE_MODE_SGMII_1000;
1660                                 break;
1661                         case XGBE_SFP_BASE_1000_SX:
1662                         case XGBE_SFP_BASE_1000_LX:
1663                         case XGBE_SFP_BASE_1000_CX:
1664                         default:
1665                                 mode = XGBE_MODE_X;
1666                                 break;
1667                         }
1668                         break;
1669                 default:
1670                         if (phy_data->phydev &&
1671                             (phy_data->phydev->speed == SPEED_100))
1672                                 mode = XGBE_MODE_SGMII_100;
1673                         else
1674                                 mode = XGBE_MODE_SGMII_1000;
1675                         break;
1676                 }
1677         } else {
1678                 mode = XGBE_MODE_UNKNOWN;
1679         }
1680
1681         /* Compare Advertisement and Link Partner register 3 */
1682         ad_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_ADVERTISE + 2);
1683         lp_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_LPA + 2);
1684         if (lp_reg & 0xc000)
1685                 XGBE_SET_LP_ADV(lks, 10000baseR_FEC);
1686
1687         return mode;
1688 }
1689
1690 static enum xgbe_mode xgbe_phy_an73_outcome(struct xgbe_prv_data *pdata)
1691 {
1692         struct ethtool_link_ksettings *lks = &pdata->phy.lks;
1693         enum xgbe_mode mode;
1694         unsigned int ad_reg, lp_reg;
1695
1696         XGBE_SET_LP_ADV(lks, Autoneg);
1697         XGBE_SET_LP_ADV(lks, Backplane);
1698
1699         /* Compare Advertisement and Link Partner register 1 */
1700         ad_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_ADVERTISE);
1701         lp_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_LPA);
1702         if (lp_reg & 0x400)
1703                 XGBE_SET_LP_ADV(lks, Pause);
1704         if (lp_reg & 0x800)
1705                 XGBE_SET_LP_ADV(lks, Asym_Pause);
1706
1707         if (pdata->phy.pause_autoneg) {
1708                 /* Set flow control based on auto-negotiation result */
1709                 pdata->phy.tx_pause = 0;
1710                 pdata->phy.rx_pause = 0;
1711
1712                 if (ad_reg & lp_reg & 0x400) {
1713                         pdata->phy.tx_pause = 1;
1714                         pdata->phy.rx_pause = 1;
1715                 } else if (ad_reg & lp_reg & 0x800) {
1716                         if (ad_reg & 0x400)
1717                                 pdata->phy.rx_pause = 1;
1718                         else if (lp_reg & 0x400)
1719                                 pdata->phy.tx_pause = 1;
1720                 }
1721         }
1722
1723         /* Compare Advertisement and Link Partner register 2 */
1724         ad_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_ADVERTISE + 1);
1725         lp_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_LPA + 1);
1726         if (lp_reg & 0x80)
1727                 XGBE_SET_LP_ADV(lks, 10000baseKR_Full);
1728         if (lp_reg & 0x20)
1729                 XGBE_SET_LP_ADV(lks, 1000baseKX_Full);
1730
1731         ad_reg &= lp_reg;
1732         if (ad_reg & 0x80)
1733                 mode = XGBE_MODE_KR;
1734         else if (ad_reg & 0x20)
1735                 mode = XGBE_MODE_KX_1000;
1736         else
1737                 mode = XGBE_MODE_UNKNOWN;
1738
1739         /* Compare Advertisement and Link Partner register 3 */
1740         ad_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_ADVERTISE + 2);
1741         lp_reg = XMDIO_READ(pdata, MDIO_MMD_AN, MDIO_AN_LPA + 2);
1742         if (lp_reg & 0xc000)
1743                 XGBE_SET_LP_ADV(lks, 10000baseR_FEC);
1744
1745         return mode;
1746 }
1747
1748 static enum xgbe_mode xgbe_phy_an_outcome(struct xgbe_prv_data *pdata)
1749 {
1750         switch (pdata->an_mode) {
1751         case XGBE_AN_MODE_CL73:
1752                 return xgbe_phy_an73_outcome(pdata);
1753         case XGBE_AN_MODE_CL73_REDRV:
1754                 return xgbe_phy_an73_redrv_outcome(pdata);
1755         case XGBE_AN_MODE_CL37:
1756                 return xgbe_phy_an37_outcome(pdata);
1757         case XGBE_AN_MODE_CL37_SGMII:
1758                 return xgbe_phy_an37_sgmii_outcome(pdata);
1759         default:
1760                 return XGBE_MODE_UNKNOWN;
1761         }
1762 }
1763
1764 static void xgbe_phy_an_advertising(struct xgbe_prv_data *pdata,
1765                                     struct ethtool_link_ksettings *dlks)
1766 {
1767         struct ethtool_link_ksettings *slks = &pdata->phy.lks;
1768         struct xgbe_phy_data *phy_data = pdata->phy_data;
1769
1770         XGBE_LM_COPY(dlks, advertising, slks, advertising);
1771
1772         /* Without a re-driver, just return current advertising */
1773         if (!phy_data->redrv)
1774                 return;
1775
1776         /* With the KR re-driver we need to advertise a single speed */
1777         XGBE_CLR_ADV(dlks, 1000baseKX_Full);
1778         XGBE_CLR_ADV(dlks, 10000baseKR_Full);
1779
1780         /* Advertise FEC support is present */
1781         if (pdata->fec_ability & MDIO_PMA_10GBR_FECABLE_ABLE)
1782                 XGBE_SET_ADV(dlks, 10000baseR_FEC);
1783
1784         switch (phy_data->port_mode) {
1785         case XGBE_PORT_MODE_BACKPLANE:
1786                 XGBE_SET_ADV(dlks, 10000baseKR_Full);
1787                 break;
1788         case XGBE_PORT_MODE_BACKPLANE_2500:
1789                 XGBE_SET_ADV(dlks, 1000baseKX_Full);
1790                 break;
1791         case XGBE_PORT_MODE_1000BASE_T:
1792         case XGBE_PORT_MODE_1000BASE_X:
1793         case XGBE_PORT_MODE_NBASE_T:
1794                 XGBE_SET_ADV(dlks, 1000baseKX_Full);
1795                 break;
1796         case XGBE_PORT_MODE_10GBASE_T:
1797                 if (phy_data->phydev &&
1798                     (phy_data->phydev->speed == SPEED_10000))
1799                         XGBE_SET_ADV(dlks, 10000baseKR_Full);
1800                 else
1801                         XGBE_SET_ADV(dlks, 1000baseKX_Full);
1802                 break;
1803         case XGBE_PORT_MODE_10GBASE_R:
1804                 XGBE_SET_ADV(dlks, 10000baseKR_Full);
1805                 break;
1806         case XGBE_PORT_MODE_SFP:
1807                 switch (phy_data->sfp_base) {
1808                 case XGBE_SFP_BASE_1000_T:
1809                 case XGBE_SFP_BASE_1000_SX:
1810                 case XGBE_SFP_BASE_1000_LX:
1811                 case XGBE_SFP_BASE_1000_CX:
1812                         XGBE_SET_ADV(dlks, 1000baseKX_Full);
1813                         break;
1814                 default:
1815                         XGBE_SET_ADV(dlks, 10000baseKR_Full);
1816                         break;
1817                 }
1818                 break;
1819         default:
1820                 XGBE_SET_ADV(dlks, 10000baseKR_Full);
1821                 break;
1822         }
1823 }
1824
1825 static int xgbe_phy_an_config(struct xgbe_prv_data *pdata)
1826 {
1827         struct ethtool_link_ksettings *lks = &pdata->phy.lks;
1828         struct xgbe_phy_data *phy_data = pdata->phy_data;
1829         u32 advertising;
1830         int ret;
1831
1832         ret = xgbe_phy_find_phy_device(pdata);
1833         if (ret)
1834                 return ret;
1835
1836         if (!phy_data->phydev)
1837                 return 0;
1838
1839         ethtool_convert_link_mode_to_legacy_u32(&advertising,
1840                                                 lks->link_modes.advertising);
1841
1842         phy_data->phydev->autoneg = pdata->phy.autoneg;
1843         phy_data->phydev->advertising = phy_data->phydev->supported &
1844                                         advertising;
1845
1846         if (pdata->phy.autoneg != AUTONEG_ENABLE) {
1847                 phy_data->phydev->speed = pdata->phy.speed;
1848                 phy_data->phydev->duplex = pdata->phy.duplex;
1849         }
1850
1851         ret = phy_start_aneg(phy_data->phydev);
1852
1853         return ret;
1854 }
1855
1856 static enum xgbe_an_mode xgbe_phy_an_sfp_mode(struct xgbe_phy_data *phy_data)
1857 {
1858         switch (phy_data->sfp_base) {
1859         case XGBE_SFP_BASE_1000_T:
1860                 return XGBE_AN_MODE_CL37_SGMII;
1861         case XGBE_SFP_BASE_1000_SX:
1862         case XGBE_SFP_BASE_1000_LX:
1863         case XGBE_SFP_BASE_1000_CX:
1864                 return XGBE_AN_MODE_CL37;
1865         default:
1866                 return XGBE_AN_MODE_NONE;
1867         }
1868 }
1869
1870 static enum xgbe_an_mode xgbe_phy_an_mode(struct xgbe_prv_data *pdata)
1871 {
1872         struct xgbe_phy_data *phy_data = pdata->phy_data;
1873
1874         /* A KR re-driver will always require CL73 AN */
1875         if (phy_data->redrv)
1876                 return XGBE_AN_MODE_CL73_REDRV;
1877
1878         switch (phy_data->port_mode) {
1879         case XGBE_PORT_MODE_BACKPLANE:
1880                 return XGBE_AN_MODE_CL73;
1881         case XGBE_PORT_MODE_BACKPLANE_2500:
1882                 return XGBE_AN_MODE_NONE;
1883         case XGBE_PORT_MODE_1000BASE_T:
1884                 return XGBE_AN_MODE_CL37_SGMII;
1885         case XGBE_PORT_MODE_1000BASE_X:
1886                 return XGBE_AN_MODE_CL37;
1887         case XGBE_PORT_MODE_NBASE_T:
1888                 return XGBE_AN_MODE_CL37_SGMII;
1889         case XGBE_PORT_MODE_10GBASE_T:
1890                 return XGBE_AN_MODE_CL73;
1891         case XGBE_PORT_MODE_10GBASE_R:
1892                 return XGBE_AN_MODE_NONE;
1893         case XGBE_PORT_MODE_SFP:
1894                 return xgbe_phy_an_sfp_mode(phy_data);
1895         default:
1896                 return XGBE_AN_MODE_NONE;
1897         }
1898 }
1899
1900 static int xgbe_phy_set_redrv_mode_mdio(struct xgbe_prv_data *pdata,
1901                                         enum xgbe_phy_redrv_mode mode)
1902 {
1903         struct xgbe_phy_data *phy_data = pdata->phy_data;
1904         u16 redrv_reg, redrv_val;
1905
1906         redrv_reg = XGBE_PHY_REDRV_MODE_REG + (phy_data->redrv_lane * 0x1000);
1907         redrv_val = (u16)mode;
1908
1909         return pdata->hw_if.write_ext_mii_regs(pdata, phy_data->redrv_addr,
1910                                                redrv_reg, redrv_val);
1911 }
1912
1913 static int xgbe_phy_set_redrv_mode_i2c(struct xgbe_prv_data *pdata,
1914                                        enum xgbe_phy_redrv_mode mode)
1915 {
1916         struct xgbe_phy_data *phy_data = pdata->phy_data;
1917         unsigned int redrv_reg;
1918         int ret;
1919
1920         /* Calculate the register to write */
1921         redrv_reg = XGBE_PHY_REDRV_MODE_REG + (phy_data->redrv_lane * 0x1000);
1922
1923         ret = xgbe_phy_redrv_write(pdata, redrv_reg, mode);
1924
1925         return ret;
1926 }
1927
1928 static void xgbe_phy_set_redrv_mode(struct xgbe_prv_data *pdata)
1929 {
1930         struct xgbe_phy_data *phy_data = pdata->phy_data;
1931         enum xgbe_phy_redrv_mode mode;
1932         int ret;
1933
1934         if (!phy_data->redrv)
1935                 return;
1936
1937         mode = XGBE_PHY_REDRV_MODE_CX;
1938         if ((phy_data->port_mode == XGBE_PORT_MODE_SFP) &&
1939             (phy_data->sfp_base != XGBE_SFP_BASE_1000_CX) &&
1940             (phy_data->sfp_base != XGBE_SFP_BASE_10000_CR))
1941                 mode = XGBE_PHY_REDRV_MODE_SR;
1942
1943         ret = xgbe_phy_get_comm_ownership(pdata);
1944         if (ret)
1945                 return;
1946
1947         if (phy_data->redrv_if)
1948                 xgbe_phy_set_redrv_mode_i2c(pdata, mode);
1949         else
1950                 xgbe_phy_set_redrv_mode_mdio(pdata, mode);
1951
1952         xgbe_phy_put_comm_ownership(pdata);
1953 }
1954
1955 static void xgbe_phy_rx_reset(struct xgbe_prv_data *pdata)
1956 {
1957         int reg;
1958
1959         reg = XMDIO_READ_BITS(pdata, MDIO_MMD_PCS, MDIO_PCS_DIGITAL_STAT,
1960                               XGBE_PCS_PSEQ_STATE_MASK);
1961         if (reg == XGBE_PCS_PSEQ_STATE_POWER_GOOD) {
1962                 /* Mailbox command timed out, reset of RX block is required.
1963                  * This can be done by asseting the reset bit and wait for
1964                  * its compeletion.
1965                  */
1966                 XMDIO_WRITE_BITS(pdata, MDIO_MMD_PMAPMD, MDIO_PMA_RX_CTRL1,
1967                                  XGBE_PMA_RX_RST_0_MASK, XGBE_PMA_RX_RST_0_RESET_ON);
1968                 ndelay(20);
1969                 XMDIO_WRITE_BITS(pdata, MDIO_MMD_PMAPMD, MDIO_PMA_RX_CTRL1,
1970                                  XGBE_PMA_RX_RST_0_MASK, XGBE_PMA_RX_RST_0_RESET_OFF);
1971                 usleep_range(40, 50);
1972                 netif_err(pdata, link, pdata->netdev, "firmware mailbox reset performed\n");
1973         }
1974 }
1975
1976 static void xgbe_phy_pll_ctrl(struct xgbe_prv_data *pdata, bool enable)
1977 {
1978         XMDIO_WRITE_BITS(pdata, MDIO_MMD_PMAPMD, MDIO_VEND2_PMA_MISC_CTRL0,
1979                          XGBE_PMA_PLL_CTRL_MASK,
1980                          enable ? XGBE_PMA_PLL_CTRL_ENABLE
1981                                 : XGBE_PMA_PLL_CTRL_DISABLE);
1982
1983         /* Wait for command to complete */
1984         usleep_range(100, 200);
1985 }
1986
1987 static void xgbe_phy_perform_ratechange(struct xgbe_prv_data *pdata,
1988                                         unsigned int cmd, unsigned int sub_cmd)
1989 {
1990         unsigned int s0 = 0;
1991         unsigned int wait;
1992
1993         /* Disable PLL re-initialization during FW command processing */
1994         xgbe_phy_pll_ctrl(pdata, false);
1995
1996         /* Log if a previous command did not complete */
1997         if (XP_IOREAD_BITS(pdata, XP_DRIVER_INT_RO, STATUS)) {
1998                 netif_dbg(pdata, link, pdata->netdev,
1999                           "firmware mailbox not ready for command\n");
2000                 xgbe_phy_rx_reset(pdata);
2001         }
2002
2003         /* Construct the command */
2004         XP_SET_BITS(s0, XP_DRIVER_SCRATCH_0, COMMAND, cmd);
2005         XP_SET_BITS(s0, XP_DRIVER_SCRATCH_0, SUB_COMMAND, sub_cmd);
2006
2007         /* Issue the command */
2008         XP_IOWRITE(pdata, XP_DRIVER_SCRATCH_0, s0);
2009         XP_IOWRITE(pdata, XP_DRIVER_SCRATCH_1, 0);
2010         XP_IOWRITE_BITS(pdata, XP_DRIVER_INT_REQ, REQUEST, 1);
2011
2012         /* Wait for command to complete */
2013         wait = XGBE_RATECHANGE_COUNT;
2014         while (wait--) {
2015                 if (!XP_IOREAD_BITS(pdata, XP_DRIVER_INT_RO, STATUS))
2016                         goto reenable_pll;
2017
2018                 usleep_range(1000, 2000);
2019         }
2020
2021         netif_dbg(pdata, link, pdata->netdev,
2022                   "firmware mailbox command did not complete\n");
2023
2024         /* Reset on error */
2025         xgbe_phy_rx_reset(pdata);
2026
2027 reenable_pll:
2028         /* Enable PLL re-initialization */
2029         xgbe_phy_pll_ctrl(pdata, true);
2030 }
2031
2032 static void xgbe_phy_rrc(struct xgbe_prv_data *pdata)
2033 {
2034         /* Receiver Reset Cycle */
2035         xgbe_phy_perform_ratechange(pdata, 5, 0);
2036
2037         netif_dbg(pdata, link, pdata->netdev, "receiver reset complete\n");
2038 }
2039
2040 static void xgbe_phy_power_off(struct xgbe_prv_data *pdata)
2041 {
2042         struct xgbe_phy_data *phy_data = pdata->phy_data;
2043
2044         /* Power off */
2045         xgbe_phy_perform_ratechange(pdata, 0, 0);
2046
2047         phy_data->cur_mode = XGBE_MODE_UNKNOWN;
2048
2049         netif_dbg(pdata, link, pdata->netdev, "phy powered off\n");
2050 }
2051
2052 static void xgbe_phy_sfi_mode(struct xgbe_prv_data *pdata)
2053 {
2054         struct xgbe_phy_data *phy_data = pdata->phy_data;
2055
2056         xgbe_phy_set_redrv_mode(pdata);
2057
2058         /* 10G/SFI */
2059         if (phy_data->sfp_cable != XGBE_SFP_CABLE_PASSIVE) {
2060                 xgbe_phy_perform_ratechange(pdata, 3, 0);
2061         } else {
2062                 if (phy_data->sfp_cable_len <= 1)
2063                         xgbe_phy_perform_ratechange(pdata, 3, 1);
2064                 else if (phy_data->sfp_cable_len <= 3)
2065                         xgbe_phy_perform_ratechange(pdata, 3, 2);
2066                 else
2067                         xgbe_phy_perform_ratechange(pdata, 3, 3);
2068         }
2069
2070         phy_data->cur_mode = XGBE_MODE_SFI;
2071
2072         netif_dbg(pdata, link, pdata->netdev, "10GbE SFI mode set\n");
2073 }
2074
2075 static void xgbe_phy_x_mode(struct xgbe_prv_data *pdata)
2076 {
2077         struct xgbe_phy_data *phy_data = pdata->phy_data;
2078
2079         xgbe_phy_set_redrv_mode(pdata);
2080
2081         /* 1G/X */
2082         xgbe_phy_perform_ratechange(pdata, 1, 3);
2083
2084         phy_data->cur_mode = XGBE_MODE_X;
2085
2086         netif_dbg(pdata, link, pdata->netdev, "1GbE X mode set\n");
2087 }
2088
2089 static void xgbe_phy_sgmii_1000_mode(struct xgbe_prv_data *pdata)
2090 {
2091         struct xgbe_phy_data *phy_data = pdata->phy_data;
2092
2093         xgbe_phy_set_redrv_mode(pdata);
2094
2095         /* 1G/SGMII */
2096         xgbe_phy_perform_ratechange(pdata, 1, 2);
2097
2098         phy_data->cur_mode = XGBE_MODE_SGMII_1000;
2099
2100         netif_dbg(pdata, link, pdata->netdev, "1GbE SGMII mode set\n");
2101 }
2102
2103 static void xgbe_phy_sgmii_100_mode(struct xgbe_prv_data *pdata)
2104 {
2105         struct xgbe_phy_data *phy_data = pdata->phy_data;
2106
2107         xgbe_phy_set_redrv_mode(pdata);
2108
2109         /* 100M/SGMII */
2110         xgbe_phy_perform_ratechange(pdata, 1, 1);
2111
2112         phy_data->cur_mode = XGBE_MODE_SGMII_100;
2113
2114         netif_dbg(pdata, link, pdata->netdev, "100MbE SGMII mode set\n");
2115 }
2116
2117 static void xgbe_phy_kr_mode(struct xgbe_prv_data *pdata)
2118 {
2119         struct xgbe_phy_data *phy_data = pdata->phy_data;
2120
2121         xgbe_phy_set_redrv_mode(pdata);
2122
2123         /* 10G/KR */
2124         xgbe_phy_perform_ratechange(pdata, 4, 0);
2125
2126         phy_data->cur_mode = XGBE_MODE_KR;
2127
2128         netif_dbg(pdata, link, pdata->netdev, "10GbE KR mode set\n");
2129 }
2130
2131 static void xgbe_phy_kx_2500_mode(struct xgbe_prv_data *pdata)
2132 {
2133         struct xgbe_phy_data *phy_data = pdata->phy_data;
2134
2135         xgbe_phy_set_redrv_mode(pdata);
2136
2137         /* 2.5G/KX */
2138         xgbe_phy_perform_ratechange(pdata, 2, 0);
2139
2140         phy_data->cur_mode = XGBE_MODE_KX_2500;
2141
2142         netif_dbg(pdata, link, pdata->netdev, "2.5GbE KX mode set\n");
2143 }
2144
2145 static void xgbe_phy_kx_1000_mode(struct xgbe_prv_data *pdata)
2146 {
2147         struct xgbe_phy_data *phy_data = pdata->phy_data;
2148
2149         xgbe_phy_set_redrv_mode(pdata);
2150
2151         /* 1G/KX */
2152         xgbe_phy_perform_ratechange(pdata, 1, 3);
2153
2154         phy_data->cur_mode = XGBE_MODE_KX_1000;
2155
2156         netif_dbg(pdata, link, pdata->netdev, "1GbE KX mode set\n");
2157 }
2158
2159 static enum xgbe_mode xgbe_phy_cur_mode(struct xgbe_prv_data *pdata)
2160 {
2161         struct xgbe_phy_data *phy_data = pdata->phy_data;
2162
2163         return phy_data->cur_mode;
2164 }
2165
2166 static enum xgbe_mode xgbe_phy_switch_baset_mode(struct xgbe_prv_data *pdata)
2167 {
2168         struct xgbe_phy_data *phy_data = pdata->phy_data;
2169
2170         /* No switching if not 10GBase-T */
2171         if (phy_data->port_mode != XGBE_PORT_MODE_10GBASE_T)
2172                 return xgbe_phy_cur_mode(pdata);
2173
2174         switch (xgbe_phy_cur_mode(pdata)) {
2175         case XGBE_MODE_SGMII_100:
2176         case XGBE_MODE_SGMII_1000:
2177                 return XGBE_MODE_KR;
2178         case XGBE_MODE_KR:
2179         default:
2180                 return XGBE_MODE_SGMII_1000;
2181         }
2182 }
2183
2184 static enum xgbe_mode xgbe_phy_switch_bp_2500_mode(struct xgbe_prv_data *pdata)
2185 {
2186         return XGBE_MODE_KX_2500;
2187 }
2188
2189 static enum xgbe_mode xgbe_phy_switch_bp_mode(struct xgbe_prv_data *pdata)
2190 {
2191         /* If we are in KR switch to KX, and vice-versa */
2192         switch (xgbe_phy_cur_mode(pdata)) {
2193         case XGBE_MODE_KX_1000:
2194                 return XGBE_MODE_KR;
2195         case XGBE_MODE_KR:
2196         default:
2197                 return XGBE_MODE_KX_1000;
2198         }
2199 }
2200
2201 static enum xgbe_mode xgbe_phy_switch_mode(struct xgbe_prv_data *pdata)
2202 {
2203         struct xgbe_phy_data *phy_data = pdata->phy_data;
2204
2205         switch (phy_data->port_mode) {
2206         case XGBE_PORT_MODE_BACKPLANE:
2207                 return xgbe_phy_switch_bp_mode(pdata);
2208         case XGBE_PORT_MODE_BACKPLANE_2500:
2209                 return xgbe_phy_switch_bp_2500_mode(pdata);
2210         case XGBE_PORT_MODE_1000BASE_T:
2211         case XGBE_PORT_MODE_NBASE_T:
2212         case XGBE_PORT_MODE_10GBASE_T:
2213                 return xgbe_phy_switch_baset_mode(pdata);
2214         case XGBE_PORT_MODE_1000BASE_X:
2215         case XGBE_PORT_MODE_10GBASE_R:
2216         case XGBE_PORT_MODE_SFP:
2217                 /* No switching, so just return current mode */
2218                 return xgbe_phy_cur_mode(pdata);
2219         default:
2220                 return XGBE_MODE_UNKNOWN;
2221         }
2222 }
2223
2224 static enum xgbe_mode xgbe_phy_get_basex_mode(struct xgbe_phy_data *phy_data,
2225                                               int speed)
2226 {
2227         switch (speed) {
2228         case SPEED_1000:
2229                 return XGBE_MODE_X;
2230         case SPEED_10000:
2231                 return XGBE_MODE_KR;
2232         default:
2233                 return XGBE_MODE_UNKNOWN;
2234         }
2235 }
2236
2237 static enum xgbe_mode xgbe_phy_get_baset_mode(struct xgbe_phy_data *phy_data,
2238                                               int speed)
2239 {
2240         switch (speed) {
2241         case SPEED_100:
2242                 return XGBE_MODE_SGMII_100;
2243         case SPEED_1000:
2244                 return XGBE_MODE_SGMII_1000;
2245         case SPEED_2500:
2246                 return XGBE_MODE_KX_2500;
2247         case SPEED_10000:
2248                 return XGBE_MODE_KR;
2249         default:
2250                 return XGBE_MODE_UNKNOWN;
2251         }
2252 }
2253
2254 static enum xgbe_mode xgbe_phy_get_sfp_mode(struct xgbe_phy_data *phy_data,
2255                                             int speed)
2256 {
2257         switch (speed) {
2258         case SPEED_100:
2259                 return XGBE_MODE_SGMII_100;
2260         case SPEED_1000:
2261                 if (phy_data->sfp_base == XGBE_SFP_BASE_1000_T)
2262                         return XGBE_MODE_SGMII_1000;
2263                 else
2264                         return XGBE_MODE_X;
2265         case SPEED_10000:
2266         case SPEED_UNKNOWN:
2267                 return XGBE_MODE_SFI;
2268         default:
2269                 return XGBE_MODE_UNKNOWN;
2270         }
2271 }
2272
2273 static enum xgbe_mode xgbe_phy_get_bp_2500_mode(int speed)
2274 {
2275         switch (speed) {
2276         case SPEED_2500:
2277                 return XGBE_MODE_KX_2500;
2278         default:
2279                 return XGBE_MODE_UNKNOWN;
2280         }
2281 }
2282
2283 static enum xgbe_mode xgbe_phy_get_bp_mode(int speed)
2284 {
2285         switch (speed) {
2286         case SPEED_1000:
2287                 return XGBE_MODE_KX_1000;
2288         case SPEED_10000:
2289                 return XGBE_MODE_KR;
2290         default:
2291                 return XGBE_MODE_UNKNOWN;
2292         }
2293 }
2294
2295 static enum xgbe_mode xgbe_phy_get_mode(struct xgbe_prv_data *pdata,
2296                                         int speed)
2297 {
2298         struct xgbe_phy_data *phy_data = pdata->phy_data;
2299
2300         switch (phy_data->port_mode) {
2301         case XGBE_PORT_MODE_BACKPLANE:
2302                 return xgbe_phy_get_bp_mode(speed);
2303         case XGBE_PORT_MODE_BACKPLANE_2500:
2304                 return xgbe_phy_get_bp_2500_mode(speed);
2305         case XGBE_PORT_MODE_1000BASE_T:
2306         case XGBE_PORT_MODE_NBASE_T:
2307         case XGBE_PORT_MODE_10GBASE_T:
2308                 return xgbe_phy_get_baset_mode(phy_data, speed);
2309         case XGBE_PORT_MODE_1000BASE_X:
2310         case XGBE_PORT_MODE_10GBASE_R:
2311                 return xgbe_phy_get_basex_mode(phy_data, speed);
2312         case XGBE_PORT_MODE_SFP:
2313                 return xgbe_phy_get_sfp_mode(phy_data, speed);
2314         default:
2315                 return XGBE_MODE_UNKNOWN;
2316         }
2317 }
2318
2319 static void xgbe_phy_set_mode(struct xgbe_prv_data *pdata, enum xgbe_mode mode)
2320 {
2321         switch (mode) {
2322         case XGBE_MODE_KX_1000:
2323                 xgbe_phy_kx_1000_mode(pdata);
2324                 break;
2325         case XGBE_MODE_KX_2500:
2326                 xgbe_phy_kx_2500_mode(pdata);
2327                 break;
2328         case XGBE_MODE_KR:
2329                 xgbe_phy_kr_mode(pdata);
2330                 break;
2331         case XGBE_MODE_SGMII_100:
2332                 xgbe_phy_sgmii_100_mode(pdata);
2333                 break;
2334         case XGBE_MODE_SGMII_1000:
2335                 xgbe_phy_sgmii_1000_mode(pdata);
2336                 break;
2337         case XGBE_MODE_X:
2338                 xgbe_phy_x_mode(pdata);
2339                 break;
2340         case XGBE_MODE_SFI:
2341                 xgbe_phy_sfi_mode(pdata);
2342                 break;
2343         default:
2344                 break;
2345         }
2346 }
2347
2348 static bool xgbe_phy_check_mode(struct xgbe_prv_data *pdata,
2349                                 enum xgbe_mode mode, bool advert)
2350 {
2351         if (pdata->phy.autoneg == AUTONEG_ENABLE) {
2352                 return advert;
2353         } else {
2354                 enum xgbe_mode cur_mode;
2355
2356                 cur_mode = xgbe_phy_get_mode(pdata, pdata->phy.speed);
2357                 if (cur_mode == mode)
2358                         return true;
2359         }
2360
2361         return false;
2362 }
2363
2364 static bool xgbe_phy_use_basex_mode(struct xgbe_prv_data *pdata,
2365                                     enum xgbe_mode mode)
2366 {
2367         struct ethtool_link_ksettings *lks = &pdata->phy.lks;
2368
2369         switch (mode) {
2370         case XGBE_MODE_X:
2371                 return xgbe_phy_check_mode(pdata, mode,
2372                                            XGBE_ADV(lks, 1000baseX_Full));
2373         case XGBE_MODE_KR:
2374                 return xgbe_phy_check_mode(pdata, mode,
2375                                            XGBE_ADV(lks, 10000baseKR_Full));
2376         default:
2377                 return false;
2378         }
2379 }
2380
2381 static bool xgbe_phy_use_baset_mode(struct xgbe_prv_data *pdata,
2382                                     enum xgbe_mode mode)
2383 {
2384         struct ethtool_link_ksettings *lks = &pdata->phy.lks;
2385
2386         switch (mode) {
2387         case XGBE_MODE_SGMII_100:
2388                 return xgbe_phy_check_mode(pdata, mode,
2389                                            XGBE_ADV(lks, 100baseT_Full));
2390         case XGBE_MODE_SGMII_1000:
2391                 return xgbe_phy_check_mode(pdata, mode,
2392                                            XGBE_ADV(lks, 1000baseT_Full));
2393         case XGBE_MODE_KX_2500:
2394                 return xgbe_phy_check_mode(pdata, mode,
2395                                            XGBE_ADV(lks, 2500baseT_Full));
2396         case XGBE_MODE_KR:
2397                 return xgbe_phy_check_mode(pdata, mode,
2398                                            XGBE_ADV(lks, 10000baseT_Full));
2399         default:
2400                 return false;
2401         }
2402 }
2403
2404 static bool xgbe_phy_use_sfp_mode(struct xgbe_prv_data *pdata,
2405                                   enum xgbe_mode mode)
2406 {
2407         struct ethtool_link_ksettings *lks = &pdata->phy.lks;
2408         struct xgbe_phy_data *phy_data = pdata->phy_data;
2409
2410         switch (mode) {
2411         case XGBE_MODE_X:
2412                 if (phy_data->sfp_base == XGBE_SFP_BASE_1000_T)
2413                         return false;
2414                 return xgbe_phy_check_mode(pdata, mode,
2415                                            XGBE_ADV(lks, 1000baseX_Full));
2416         case XGBE_MODE_SGMII_100:
2417                 if (phy_data->sfp_base != XGBE_SFP_BASE_1000_T)
2418                         return false;
2419                 return xgbe_phy_check_mode(pdata, mode,
2420                                            XGBE_ADV(lks, 100baseT_Full));
2421         case XGBE_MODE_SGMII_1000:
2422                 if (phy_data->sfp_base != XGBE_SFP_BASE_1000_T)
2423                         return false;
2424                 return xgbe_phy_check_mode(pdata, mode,
2425                                            XGBE_ADV(lks, 1000baseT_Full));
2426         case XGBE_MODE_SFI:
2427                 if (phy_data->sfp_mod_absent)
2428                         return true;
2429                 return xgbe_phy_check_mode(pdata, mode,
2430                                            XGBE_ADV(lks, 10000baseSR_Full)  ||
2431                                            XGBE_ADV(lks, 10000baseLR_Full)  ||
2432                                            XGBE_ADV(lks, 10000baseLRM_Full) ||
2433                                            XGBE_ADV(lks, 10000baseER_Full)  ||
2434                                            XGBE_ADV(lks, 10000baseCR_Full));
2435         default:
2436                 return false;
2437         }
2438 }
2439
2440 static bool xgbe_phy_use_bp_2500_mode(struct xgbe_prv_data *pdata,
2441                                       enum xgbe_mode mode)
2442 {
2443         struct ethtool_link_ksettings *lks = &pdata->phy.lks;
2444
2445         switch (mode) {
2446         case XGBE_MODE_KX_2500:
2447                 return xgbe_phy_check_mode(pdata, mode,
2448                                            XGBE_ADV(lks, 2500baseX_Full));
2449         default:
2450                 return false;
2451         }
2452 }
2453
2454 static bool xgbe_phy_use_bp_mode(struct xgbe_prv_data *pdata,
2455                                  enum xgbe_mode mode)
2456 {
2457         struct ethtool_link_ksettings *lks = &pdata->phy.lks;
2458
2459         switch (mode) {
2460         case XGBE_MODE_KX_1000:
2461                 return xgbe_phy_check_mode(pdata, mode,
2462                                            XGBE_ADV(lks, 1000baseKX_Full));
2463         case XGBE_MODE_KR:
2464                 return xgbe_phy_check_mode(pdata, mode,
2465                                            XGBE_ADV(lks, 10000baseKR_Full));
2466         default:
2467                 return false;
2468         }
2469 }
2470
2471 static bool xgbe_phy_use_mode(struct xgbe_prv_data *pdata, enum xgbe_mode mode)
2472 {
2473         struct xgbe_phy_data *phy_data = pdata->phy_data;
2474
2475         switch (phy_data->port_mode) {
2476         case XGBE_PORT_MODE_BACKPLANE:
2477                 return xgbe_phy_use_bp_mode(pdata, mode);
2478         case XGBE_PORT_MODE_BACKPLANE_2500:
2479                 return xgbe_phy_use_bp_2500_mode(pdata, mode);
2480         case XGBE_PORT_MODE_1000BASE_T:
2481         case XGBE_PORT_MODE_NBASE_T:
2482         case XGBE_PORT_MODE_10GBASE_T:
2483                 return xgbe_phy_use_baset_mode(pdata, mode);
2484         case XGBE_PORT_MODE_1000BASE_X:
2485         case XGBE_PORT_MODE_10GBASE_R:
2486                 return xgbe_phy_use_basex_mode(pdata, mode);
2487         case XGBE_PORT_MODE_SFP:
2488                 return xgbe_phy_use_sfp_mode(pdata, mode);
2489         default:
2490                 return false;
2491         }
2492 }
2493
2494 static bool xgbe_phy_valid_speed_basex_mode(struct xgbe_phy_data *phy_data,
2495                                             int speed)
2496 {
2497         switch (speed) {
2498         case SPEED_1000:
2499                 return (phy_data->port_mode == XGBE_PORT_MODE_1000BASE_X);
2500         case SPEED_10000:
2501                 return (phy_data->port_mode == XGBE_PORT_MODE_10GBASE_R);
2502         default:
2503                 return false;
2504         }
2505 }
2506
2507 static bool xgbe_phy_valid_speed_baset_mode(struct xgbe_phy_data *phy_data,
2508                                             int speed)
2509 {
2510         switch (speed) {
2511         case SPEED_100:
2512         case SPEED_1000:
2513                 return true;
2514         case SPEED_2500:
2515                 return (phy_data->port_mode == XGBE_PORT_MODE_NBASE_T);
2516         case SPEED_10000:
2517                 return (phy_data->port_mode == XGBE_PORT_MODE_10GBASE_T);
2518         default:
2519                 return false;
2520         }
2521 }
2522
2523 static bool xgbe_phy_valid_speed_sfp_mode(struct xgbe_phy_data *phy_data,
2524                                           int speed)
2525 {
2526         switch (speed) {
2527         case SPEED_100:
2528                 return (phy_data->sfp_speed == XGBE_SFP_SPEED_100_1000);
2529         case SPEED_1000:
2530                 return ((phy_data->sfp_speed == XGBE_SFP_SPEED_100_1000) ||
2531                         (phy_data->sfp_speed == XGBE_SFP_SPEED_1000));
2532         case SPEED_10000:
2533                 return (phy_data->sfp_speed == XGBE_SFP_SPEED_10000);
2534         default:
2535                 return false;
2536         }
2537 }
2538
2539 static bool xgbe_phy_valid_speed_bp_2500_mode(int speed)
2540 {
2541         switch (speed) {
2542         case SPEED_2500:
2543                 return true;
2544         default:
2545                 return false;
2546         }
2547 }
2548
2549 static bool xgbe_phy_valid_speed_bp_mode(int speed)
2550 {
2551         switch (speed) {
2552         case SPEED_1000:
2553         case SPEED_10000:
2554                 return true;
2555         default:
2556                 return false;
2557         }
2558 }
2559
2560 static bool xgbe_phy_valid_speed(struct xgbe_prv_data *pdata, int speed)
2561 {
2562         struct xgbe_phy_data *phy_data = pdata->phy_data;
2563
2564         switch (phy_data->port_mode) {
2565         case XGBE_PORT_MODE_BACKPLANE:
2566                 return xgbe_phy_valid_speed_bp_mode(speed);
2567         case XGBE_PORT_MODE_BACKPLANE_2500:
2568                 return xgbe_phy_valid_speed_bp_2500_mode(speed);
2569         case XGBE_PORT_MODE_1000BASE_T:
2570         case XGBE_PORT_MODE_NBASE_T:
2571         case XGBE_PORT_MODE_10GBASE_T:
2572                 return xgbe_phy_valid_speed_baset_mode(phy_data, speed);
2573         case XGBE_PORT_MODE_1000BASE_X:
2574         case XGBE_PORT_MODE_10GBASE_R:
2575                 return xgbe_phy_valid_speed_basex_mode(phy_data, speed);
2576         case XGBE_PORT_MODE_SFP:
2577                 return xgbe_phy_valid_speed_sfp_mode(phy_data, speed);
2578         default:
2579                 return false;
2580         }
2581 }
2582
2583 static int xgbe_phy_link_status(struct xgbe_prv_data *pdata, int *an_restart)
2584 {
2585         struct xgbe_phy_data *phy_data = pdata->phy_data;
2586         unsigned int reg;
2587         int ret;
2588
2589         *an_restart = 0;
2590
2591         if (phy_data->port_mode == XGBE_PORT_MODE_SFP) {
2592                 /* Check SFP signals */
2593                 xgbe_phy_sfp_detect(pdata);
2594
2595                 if (phy_data->sfp_changed) {
2596                         *an_restart = 1;
2597                         return 0;
2598                 }
2599
2600                 if (phy_data->sfp_mod_absent || phy_data->sfp_rx_los)
2601                         return 0;
2602         }
2603
2604         if (phy_data->phydev) {
2605                 /* Check external PHY */
2606                 ret = phy_read_status(phy_data->phydev);
2607                 if (ret < 0)
2608                         return 0;
2609
2610                 if ((pdata->phy.autoneg == AUTONEG_ENABLE) &&
2611                     !phy_aneg_done(phy_data->phydev))
2612                         return 0;
2613
2614                 if (!phy_data->phydev->link)
2615                         return 0;
2616         }
2617
2618         /* Link status is latched low, so read once to clear
2619          * and then read again to get current state
2620          */
2621         reg = XMDIO_READ(pdata, MDIO_MMD_PCS, MDIO_STAT1);
2622         reg = XMDIO_READ(pdata, MDIO_MMD_PCS, MDIO_STAT1);
2623         if (reg & MDIO_STAT1_LSTATUS)
2624                 return 1;
2625
2626         if (pdata->phy.autoneg == AUTONEG_ENABLE &&
2627             phy_data->port_mode == XGBE_PORT_MODE_BACKPLANE) {
2628                 if (!test_bit(XGBE_LINK_INIT, &pdata->dev_state)) {
2629                         netif_carrier_off(pdata->netdev);
2630                         *an_restart = 1;
2631                 }
2632         }
2633
2634         /* No link, attempt a receiver reset cycle */
2635         if (phy_data->rrc_count++ > XGBE_RRC_FREQUENCY) {
2636                 phy_data->rrc_count = 0;
2637                 xgbe_phy_rrc(pdata);
2638         }
2639
2640         return 0;
2641 }
2642
2643 static void xgbe_phy_sfp_gpio_setup(struct xgbe_prv_data *pdata)
2644 {
2645         struct xgbe_phy_data *phy_data = pdata->phy_data;
2646
2647         phy_data->sfp_gpio_address = XGBE_GPIO_ADDRESS_PCA9555 +
2648                                      XP_GET_BITS(pdata->pp3, XP_PROP_3,
2649                                                  GPIO_ADDR);
2650
2651         phy_data->sfp_gpio_mask = XP_GET_BITS(pdata->pp3, XP_PROP_3,
2652                                               GPIO_MASK);
2653
2654         phy_data->sfp_gpio_rx_los = XP_GET_BITS(pdata->pp3, XP_PROP_3,
2655                                                 GPIO_RX_LOS);
2656         phy_data->sfp_gpio_tx_fault = XP_GET_BITS(pdata->pp3, XP_PROP_3,
2657                                                   GPIO_TX_FAULT);
2658         phy_data->sfp_gpio_mod_absent = XP_GET_BITS(pdata->pp3, XP_PROP_3,
2659                                                     GPIO_MOD_ABS);
2660         phy_data->sfp_gpio_rate_select = XP_GET_BITS(pdata->pp3, XP_PROP_3,
2661                                                      GPIO_RATE_SELECT);
2662
2663         if (netif_msg_probe(pdata)) {
2664                 dev_dbg(pdata->dev, "SFP: gpio_address=%#x\n",
2665                         phy_data->sfp_gpio_address);
2666                 dev_dbg(pdata->dev, "SFP: gpio_mask=%#x\n",
2667                         phy_data->sfp_gpio_mask);
2668                 dev_dbg(pdata->dev, "SFP: gpio_rx_los=%u\n",
2669                         phy_data->sfp_gpio_rx_los);
2670                 dev_dbg(pdata->dev, "SFP: gpio_tx_fault=%u\n",
2671                         phy_data->sfp_gpio_tx_fault);
2672                 dev_dbg(pdata->dev, "SFP: gpio_mod_absent=%u\n",
2673                         phy_data->sfp_gpio_mod_absent);
2674                 dev_dbg(pdata->dev, "SFP: gpio_rate_select=%u\n",
2675                         phy_data->sfp_gpio_rate_select);
2676         }
2677 }
2678
2679 static void xgbe_phy_sfp_comm_setup(struct xgbe_prv_data *pdata)
2680 {
2681         struct xgbe_phy_data *phy_data = pdata->phy_data;
2682         unsigned int mux_addr_hi, mux_addr_lo;
2683
2684         mux_addr_hi = XP_GET_BITS(pdata->pp4, XP_PROP_4, MUX_ADDR_HI);
2685         mux_addr_lo = XP_GET_BITS(pdata->pp4, XP_PROP_4, MUX_ADDR_LO);
2686         if (mux_addr_lo == XGBE_SFP_DIRECT)
2687                 return;
2688
2689         phy_data->sfp_comm = XGBE_SFP_COMM_PCA9545;
2690         phy_data->sfp_mux_address = (mux_addr_hi << 2) + mux_addr_lo;
2691         phy_data->sfp_mux_channel = XP_GET_BITS(pdata->pp4, XP_PROP_4,
2692                                                 MUX_CHAN);
2693
2694         if (netif_msg_probe(pdata)) {
2695                 dev_dbg(pdata->dev, "SFP: mux_address=%#x\n",
2696                         phy_data->sfp_mux_address);
2697                 dev_dbg(pdata->dev, "SFP: mux_channel=%u\n",
2698                         phy_data->sfp_mux_channel);
2699         }
2700 }
2701
2702 static void xgbe_phy_sfp_setup(struct xgbe_prv_data *pdata)
2703 {
2704         xgbe_phy_sfp_comm_setup(pdata);
2705         xgbe_phy_sfp_gpio_setup(pdata);
2706 }
2707
2708 static int xgbe_phy_int_mdio_reset(struct xgbe_prv_data *pdata)
2709 {
2710         struct xgbe_phy_data *phy_data = pdata->phy_data;
2711         unsigned int ret;
2712
2713         ret = pdata->hw_if.set_gpio(pdata, phy_data->mdio_reset_gpio);
2714         if (ret)
2715                 return ret;
2716
2717         ret = pdata->hw_if.clr_gpio(pdata, phy_data->mdio_reset_gpio);
2718
2719         return ret;
2720 }
2721
2722 static int xgbe_phy_i2c_mdio_reset(struct xgbe_prv_data *pdata)
2723 {
2724         struct xgbe_phy_data *phy_data = pdata->phy_data;
2725         u8 gpio_reg, gpio_ports[2], gpio_data[3];
2726         int ret;
2727
2728         /* Read the output port registers */
2729         gpio_reg = 2;
2730         ret = xgbe_phy_i2c_read(pdata, phy_data->mdio_reset_addr,
2731                                 &gpio_reg, sizeof(gpio_reg),
2732                                 gpio_ports, sizeof(gpio_ports));
2733         if (ret)
2734                 return ret;
2735
2736         /* Prepare to write the GPIO data */
2737         gpio_data[0] = 2;
2738         gpio_data[1] = gpio_ports[0];
2739         gpio_data[2] = gpio_ports[1];
2740
2741         /* Set the GPIO pin */
2742         if (phy_data->mdio_reset_gpio < 8)
2743                 gpio_data[1] |= (1 << (phy_data->mdio_reset_gpio % 8));
2744         else
2745                 gpio_data[2] |= (1 << (phy_data->mdio_reset_gpio % 8));
2746
2747         /* Write the output port registers */
2748         ret = xgbe_phy_i2c_write(pdata, phy_data->mdio_reset_addr,
2749                                  gpio_data, sizeof(gpio_data));
2750         if (ret)
2751                 return ret;
2752
2753         /* Clear the GPIO pin */
2754         if (phy_data->mdio_reset_gpio < 8)
2755                 gpio_data[1] &= ~(1 << (phy_data->mdio_reset_gpio % 8));
2756         else
2757                 gpio_data[2] &= ~(1 << (phy_data->mdio_reset_gpio % 8));
2758
2759         /* Write the output port registers */
2760         ret = xgbe_phy_i2c_write(pdata, phy_data->mdio_reset_addr,
2761                                  gpio_data, sizeof(gpio_data));
2762
2763         return ret;
2764 }
2765
2766 static int xgbe_phy_mdio_reset(struct xgbe_prv_data *pdata)
2767 {
2768         struct xgbe_phy_data *phy_data = pdata->phy_data;
2769         int ret;
2770
2771         if (phy_data->conn_type != XGBE_CONN_TYPE_MDIO)
2772                 return 0;
2773
2774         ret = xgbe_phy_get_comm_ownership(pdata);
2775         if (ret)
2776                 return ret;
2777
2778         if (phy_data->mdio_reset == XGBE_MDIO_RESET_I2C_GPIO)
2779                 ret = xgbe_phy_i2c_mdio_reset(pdata);
2780         else if (phy_data->mdio_reset == XGBE_MDIO_RESET_INT_GPIO)
2781                 ret = xgbe_phy_int_mdio_reset(pdata);
2782
2783         xgbe_phy_put_comm_ownership(pdata);
2784
2785         return ret;
2786 }
2787
2788 static bool xgbe_phy_redrv_error(struct xgbe_phy_data *phy_data)
2789 {
2790         if (!phy_data->redrv)
2791                 return false;
2792
2793         if (phy_data->redrv_if >= XGBE_PHY_REDRV_IF_MAX)
2794                 return true;
2795
2796         switch (phy_data->redrv_model) {
2797         case XGBE_PHY_REDRV_MODEL_4223:
2798                 if (phy_data->redrv_lane > 3)
2799                         return true;
2800                 break;
2801         case XGBE_PHY_REDRV_MODEL_4227:
2802                 if (phy_data->redrv_lane > 1)
2803                         return true;
2804                 break;
2805         default:
2806                 return true;
2807         }
2808
2809         return false;
2810 }
2811
2812 static int xgbe_phy_mdio_reset_setup(struct xgbe_prv_data *pdata)
2813 {
2814         struct xgbe_phy_data *phy_data = pdata->phy_data;
2815
2816         if (phy_data->conn_type != XGBE_CONN_TYPE_MDIO)
2817                 return 0;
2818
2819         phy_data->mdio_reset = XP_GET_BITS(pdata->pp3, XP_PROP_3, MDIO_RESET);
2820         switch (phy_data->mdio_reset) {
2821         case XGBE_MDIO_RESET_NONE:
2822         case XGBE_MDIO_RESET_I2C_GPIO:
2823         case XGBE_MDIO_RESET_INT_GPIO:
2824                 break;
2825         default:
2826                 dev_err(pdata->dev, "unsupported MDIO reset (%#x)\n",
2827                         phy_data->mdio_reset);
2828                 return -EINVAL;
2829         }
2830
2831         if (phy_data->mdio_reset == XGBE_MDIO_RESET_I2C_GPIO) {
2832                 phy_data->mdio_reset_addr = XGBE_GPIO_ADDRESS_PCA9555 +
2833                                             XP_GET_BITS(pdata->pp3, XP_PROP_3,
2834                                                         MDIO_RESET_I2C_ADDR);
2835                 phy_data->mdio_reset_gpio = XP_GET_BITS(pdata->pp3, XP_PROP_3,
2836                                                         MDIO_RESET_I2C_GPIO);
2837         } else if (phy_data->mdio_reset == XGBE_MDIO_RESET_INT_GPIO) {
2838                 phy_data->mdio_reset_gpio = XP_GET_BITS(pdata->pp3, XP_PROP_3,
2839                                                         MDIO_RESET_INT_GPIO);
2840         }
2841
2842         return 0;
2843 }
2844
2845 static bool xgbe_phy_port_mode_mismatch(struct xgbe_prv_data *pdata)
2846 {
2847         struct xgbe_phy_data *phy_data = pdata->phy_data;
2848
2849         switch (phy_data->port_mode) {
2850         case XGBE_PORT_MODE_BACKPLANE:
2851                 if ((phy_data->port_speeds & XGBE_PHY_PORT_SPEED_1000) ||
2852                     (phy_data->port_speeds & XGBE_PHY_PORT_SPEED_10000))
2853                         return false;
2854                 break;
2855         case XGBE_PORT_MODE_BACKPLANE_2500:
2856                 if (phy_data->port_speeds & XGBE_PHY_PORT_SPEED_2500)
2857                         return false;
2858                 break;
2859         case XGBE_PORT_MODE_1000BASE_T:
2860                 if ((phy_data->port_speeds & XGBE_PHY_PORT_SPEED_100) ||
2861                     (phy_data->port_speeds & XGBE_PHY_PORT_SPEED_1000))
2862                         return false;
2863                 break;
2864         case XGBE_PORT_MODE_1000BASE_X:
2865                 if (phy_data->port_speeds & XGBE_PHY_PORT_SPEED_1000)
2866                         return false;
2867                 break;
2868         case XGBE_PORT_MODE_NBASE_T:
2869                 if ((phy_data->port_speeds & XGBE_PHY_PORT_SPEED_100) ||
2870                     (phy_data->port_speeds & XGBE_PHY_PORT_SPEED_1000) ||
2871                     (phy_data->port_speeds & XGBE_PHY_PORT_SPEED_2500))
2872                         return false;
2873                 break;
2874         case XGBE_PORT_MODE_10GBASE_T:
2875                 if ((phy_data->port_speeds & XGBE_PHY_PORT_SPEED_100) ||
2876                     (phy_data->port_speeds & XGBE_PHY_PORT_SPEED_1000) ||
2877                     (phy_data->port_speeds & XGBE_PHY_PORT_SPEED_10000))
2878                         return false;
2879                 break;
2880         case XGBE_PORT_MODE_10GBASE_R:
2881                 if (phy_data->port_speeds & XGBE_PHY_PORT_SPEED_10000)
2882                         return false;
2883                 break;
2884         case XGBE_PORT_MODE_SFP:
2885                 if ((phy_data->port_speeds & XGBE_PHY_PORT_SPEED_100) ||
2886                     (phy_data->port_speeds & XGBE_PHY_PORT_SPEED_1000) ||
2887                     (phy_data->port_speeds & XGBE_PHY_PORT_SPEED_10000))
2888                         return false;
2889                 break;
2890         default:
2891                 break;
2892         }
2893
2894         return true;
2895 }
2896
2897 static bool xgbe_phy_conn_type_mismatch(struct xgbe_prv_data *pdata)
2898 {
2899         struct xgbe_phy_data *phy_data = pdata->phy_data;
2900
2901         switch (phy_data->port_mode) {
2902         case XGBE_PORT_MODE_BACKPLANE:
2903         case XGBE_PORT_MODE_BACKPLANE_2500:
2904                 if (phy_data->conn_type == XGBE_CONN_TYPE_BACKPLANE)
2905                         return false;
2906                 break;
2907         case XGBE_PORT_MODE_1000BASE_T:
2908         case XGBE_PORT_MODE_1000BASE_X:
2909         case XGBE_PORT_MODE_NBASE_T:
2910         case XGBE_PORT_MODE_10GBASE_T:
2911         case XGBE_PORT_MODE_10GBASE_R:
2912                 if (phy_data->conn_type == XGBE_CONN_TYPE_MDIO)
2913                         return false;
2914                 break;
2915         case XGBE_PORT_MODE_SFP:
2916                 if (phy_data->conn_type == XGBE_CONN_TYPE_SFP)
2917                         return false;
2918                 break;
2919         default:
2920                 break;
2921         }
2922
2923         return true;
2924 }
2925
2926 static bool xgbe_phy_port_enabled(struct xgbe_prv_data *pdata)
2927 {
2928         if (!XP_GET_BITS(pdata->pp0, XP_PROP_0, PORT_SPEEDS))
2929                 return false;
2930         if (!XP_GET_BITS(pdata->pp0, XP_PROP_0, CONN_TYPE))
2931                 return false;
2932
2933         return true;
2934 }
2935
2936 static void xgbe_phy_cdr_track(struct xgbe_prv_data *pdata)
2937 {
2938         struct xgbe_phy_data *phy_data = pdata->phy_data;
2939
2940         if (!pdata->debugfs_an_cdr_workaround)
2941                 return;
2942
2943         if (!phy_data->phy_cdr_notrack)
2944                 return;
2945
2946         usleep_range(phy_data->phy_cdr_delay,
2947                      phy_data->phy_cdr_delay + 500);
2948
2949         XMDIO_WRITE_BITS(pdata, MDIO_MMD_PMAPMD, MDIO_VEND2_PMA_CDR_CONTROL,
2950                          XGBE_PMA_CDR_TRACK_EN_MASK,
2951                          XGBE_PMA_CDR_TRACK_EN_ON);
2952
2953         phy_data->phy_cdr_notrack = 0;
2954 }
2955
2956 static void xgbe_phy_cdr_notrack(struct xgbe_prv_data *pdata)
2957 {
2958         struct xgbe_phy_data *phy_data = pdata->phy_data;
2959
2960         if (!pdata->debugfs_an_cdr_workaround)
2961                 return;
2962
2963         if (phy_data->phy_cdr_notrack)
2964                 return;
2965
2966         XMDIO_WRITE_BITS(pdata, MDIO_MMD_PMAPMD, MDIO_VEND2_PMA_CDR_CONTROL,
2967                          XGBE_PMA_CDR_TRACK_EN_MASK,
2968                          XGBE_PMA_CDR_TRACK_EN_OFF);
2969
2970         xgbe_phy_rrc(pdata);
2971
2972         phy_data->phy_cdr_notrack = 1;
2973 }
2974
2975 static void xgbe_phy_kr_training_post(struct xgbe_prv_data *pdata)
2976 {
2977         if (!pdata->debugfs_an_cdr_track_early)
2978                 xgbe_phy_cdr_track(pdata);
2979 }
2980
2981 static void xgbe_phy_kr_training_pre(struct xgbe_prv_data *pdata)
2982 {
2983         if (pdata->debugfs_an_cdr_track_early)
2984                 xgbe_phy_cdr_track(pdata);
2985 }
2986
2987 static void xgbe_phy_an_post(struct xgbe_prv_data *pdata)
2988 {
2989         struct xgbe_phy_data *phy_data = pdata->phy_data;
2990
2991         switch (pdata->an_mode) {
2992         case XGBE_AN_MODE_CL73:
2993         case XGBE_AN_MODE_CL73_REDRV:
2994                 if (phy_data->cur_mode != XGBE_MODE_KR)
2995                         break;
2996
2997                 xgbe_phy_cdr_track(pdata);
2998
2999                 switch (pdata->an_result) {
3000                 case XGBE_AN_READY:
3001                 case XGBE_AN_COMPLETE:
3002                         break;
3003                 default:
3004                         if (phy_data->phy_cdr_delay < XGBE_CDR_DELAY_MAX)
3005                                 phy_data->phy_cdr_delay += XGBE_CDR_DELAY_INC;
3006                         else
3007                                 phy_data->phy_cdr_delay = XGBE_CDR_DELAY_INIT;
3008                         break;
3009                 }
3010                 break;
3011         default:
3012                 break;
3013         }
3014 }
3015
3016 static void xgbe_phy_an_pre(struct xgbe_prv_data *pdata)
3017 {
3018         struct xgbe_phy_data *phy_data = pdata->phy_data;
3019
3020         switch (pdata->an_mode) {
3021         case XGBE_AN_MODE_CL73:
3022         case XGBE_AN_MODE_CL73_REDRV:
3023                 if (phy_data->cur_mode != XGBE_MODE_KR)
3024                         break;
3025
3026                 xgbe_phy_cdr_notrack(pdata);
3027                 break;
3028         default:
3029                 break;
3030         }
3031 }
3032
3033 static void xgbe_phy_stop(struct xgbe_prv_data *pdata)
3034 {
3035         struct xgbe_phy_data *phy_data = pdata->phy_data;
3036
3037         /* If we have an external PHY, free it */
3038         xgbe_phy_free_phy_device(pdata);
3039
3040         /* Reset SFP data */
3041         xgbe_phy_sfp_reset(phy_data);
3042         xgbe_phy_sfp_mod_absent(pdata);
3043
3044         /* Reset CDR support */
3045         xgbe_phy_cdr_track(pdata);
3046
3047         /* Power off the PHY */
3048         xgbe_phy_power_off(pdata);
3049
3050         /* Stop the I2C controller */
3051         pdata->i2c_if.i2c_stop(pdata);
3052 }
3053
3054 static int xgbe_phy_start(struct xgbe_prv_data *pdata)
3055 {
3056         struct xgbe_phy_data *phy_data = pdata->phy_data;
3057         int ret;
3058
3059         /* Start the I2C controller */
3060         ret = pdata->i2c_if.i2c_start(pdata);
3061         if (ret)
3062                 return ret;
3063
3064         /* Set the proper MDIO mode for the re-driver */
3065         if (phy_data->redrv && !phy_data->redrv_if) {
3066                 ret = pdata->hw_if.set_ext_mii_mode(pdata, phy_data->redrv_addr,
3067                                                     XGBE_MDIO_MODE_CL22);
3068                 if (ret) {
3069                         netdev_err(pdata->netdev,
3070                                    "redriver mdio port not compatible (%u)\n",
3071                                    phy_data->redrv_addr);
3072                         return ret;
3073                 }
3074         }
3075
3076         /* Start in highest supported mode */
3077         xgbe_phy_set_mode(pdata, phy_data->start_mode);
3078
3079         /* Reset CDR support */
3080         xgbe_phy_cdr_track(pdata);
3081
3082         /* After starting the I2C controller, we can check for an SFP */
3083         switch (phy_data->port_mode) {
3084         case XGBE_PORT_MODE_SFP:
3085                 xgbe_phy_sfp_detect(pdata);
3086                 break;
3087         default:
3088                 break;
3089         }
3090
3091         /* If we have an external PHY, start it */
3092         ret = xgbe_phy_find_phy_device(pdata);
3093         if (ret)
3094                 goto err_i2c;
3095
3096         return 0;
3097
3098 err_i2c:
3099         pdata->i2c_if.i2c_stop(pdata);
3100
3101         return ret;
3102 }
3103
3104 static int xgbe_phy_reset(struct xgbe_prv_data *pdata)
3105 {
3106         struct xgbe_phy_data *phy_data = pdata->phy_data;
3107         enum xgbe_mode cur_mode;
3108         int ret;
3109
3110         /* Reset by power cycling the PHY */
3111         cur_mode = phy_data->cur_mode;
3112         xgbe_phy_power_off(pdata);
3113         xgbe_phy_set_mode(pdata, cur_mode);
3114
3115         if (!phy_data->phydev)
3116                 return 0;
3117
3118         /* Reset the external PHY */
3119         ret = xgbe_phy_mdio_reset(pdata);
3120         if (ret)
3121                 return ret;
3122
3123         return phy_init_hw(phy_data->phydev);
3124 }
3125
3126 static void xgbe_phy_exit(struct xgbe_prv_data *pdata)
3127 {
3128         struct xgbe_phy_data *phy_data = pdata->phy_data;
3129
3130         /* Unregister for driving external PHYs */
3131         mdiobus_unregister(phy_data->mii);
3132 }
3133
3134 static int xgbe_phy_init(struct xgbe_prv_data *pdata)
3135 {
3136         struct ethtool_link_ksettings *lks = &pdata->phy.lks;
3137         struct xgbe_phy_data *phy_data;
3138         struct mii_bus *mii;
3139         int ret;
3140
3141         /* Check if enabled */
3142         if (!xgbe_phy_port_enabled(pdata)) {
3143                 dev_info(pdata->dev, "device is not enabled\n");
3144                 return -ENODEV;
3145         }
3146
3147         /* Initialize the I2C controller */
3148         ret = pdata->i2c_if.i2c_init(pdata);
3149         if (ret)
3150                 return ret;
3151
3152         phy_data = devm_kzalloc(pdata->dev, sizeof(*phy_data), GFP_KERNEL);
3153         if (!phy_data)
3154                 return -ENOMEM;
3155         pdata->phy_data = phy_data;
3156
3157         phy_data->port_mode = XP_GET_BITS(pdata->pp0, XP_PROP_0, PORT_MODE);
3158         phy_data->port_id = XP_GET_BITS(pdata->pp0, XP_PROP_0, PORT_ID);
3159         phy_data->port_speeds = XP_GET_BITS(pdata->pp0, XP_PROP_0, PORT_SPEEDS);
3160         phy_data->conn_type = XP_GET_BITS(pdata->pp0, XP_PROP_0, CONN_TYPE);
3161         phy_data->mdio_addr = XP_GET_BITS(pdata->pp0, XP_PROP_0, MDIO_ADDR);
3162         if (netif_msg_probe(pdata)) {
3163                 dev_dbg(pdata->dev, "port mode=%u\n", phy_data->port_mode);
3164                 dev_dbg(pdata->dev, "port id=%u\n", phy_data->port_id);
3165                 dev_dbg(pdata->dev, "port speeds=%#x\n", phy_data->port_speeds);
3166                 dev_dbg(pdata->dev, "conn type=%u\n", phy_data->conn_type);
3167                 dev_dbg(pdata->dev, "mdio addr=%u\n", phy_data->mdio_addr);
3168         }
3169
3170         phy_data->redrv = XP_GET_BITS(pdata->pp4, XP_PROP_4, REDRV_PRESENT);
3171         phy_data->redrv_if = XP_GET_BITS(pdata->pp4, XP_PROP_4, REDRV_IF);
3172         phy_data->redrv_addr = XP_GET_BITS(pdata->pp4, XP_PROP_4, REDRV_ADDR);
3173         phy_data->redrv_lane = XP_GET_BITS(pdata->pp4, XP_PROP_4, REDRV_LANE);
3174         phy_data->redrv_model = XP_GET_BITS(pdata->pp4, XP_PROP_4, REDRV_MODEL);
3175         if (phy_data->redrv && netif_msg_probe(pdata)) {
3176                 dev_dbg(pdata->dev, "redrv present\n");
3177                 dev_dbg(pdata->dev, "redrv i/f=%u\n", phy_data->redrv_if);
3178                 dev_dbg(pdata->dev, "redrv addr=%#x\n", phy_data->redrv_addr);
3179                 dev_dbg(pdata->dev, "redrv lane=%u\n", phy_data->redrv_lane);
3180                 dev_dbg(pdata->dev, "redrv model=%u\n", phy_data->redrv_model);
3181         }
3182
3183         /* Validate the connection requested */
3184         if (xgbe_phy_conn_type_mismatch(pdata)) {
3185                 dev_err(pdata->dev, "phy mode/connection mismatch (%#x/%#x)\n",
3186                         phy_data->port_mode, phy_data->conn_type);
3187                 return -EINVAL;
3188         }
3189
3190         /* Validate the mode requested */
3191         if (xgbe_phy_port_mode_mismatch(pdata)) {
3192                 dev_err(pdata->dev, "phy mode/speed mismatch (%#x/%#x)\n",
3193                         phy_data->port_mode, phy_data->port_speeds);
3194                 return -EINVAL;
3195         }
3196
3197         /* Check for and validate MDIO reset support */
3198         ret = xgbe_phy_mdio_reset_setup(pdata);
3199         if (ret)
3200                 return ret;
3201
3202         /* Validate the re-driver information */
3203         if (xgbe_phy_redrv_error(phy_data)) {
3204                 dev_err(pdata->dev, "phy re-driver settings error\n");
3205                 return -EINVAL;
3206         }
3207         pdata->kr_redrv = phy_data->redrv;
3208
3209         /* Indicate current mode is unknown */
3210         phy_data->cur_mode = XGBE_MODE_UNKNOWN;
3211
3212         /* Initialize supported features */
3213         XGBE_ZERO_SUP(lks);
3214
3215         switch (phy_data->port_mode) {
3216         /* Backplane support */
3217         case XGBE_PORT_MODE_BACKPLANE:
3218                 XGBE_SET_SUP(lks, Autoneg);
3219                 XGBE_SET_SUP(lks, Pause);
3220                 XGBE_SET_SUP(lks, Asym_Pause);
3221                 XGBE_SET_SUP(lks, Backplane);
3222                 if (phy_data->port_speeds & XGBE_PHY_PORT_SPEED_1000) {
3223                         XGBE_SET_SUP(lks, 1000baseKX_Full);
3224                         phy_data->start_mode = XGBE_MODE_KX_1000;
3225                 }
3226                 if (phy_data->port_speeds & XGBE_PHY_PORT_SPEED_10000) {
3227                         XGBE_SET_SUP(lks, 10000baseKR_Full);
3228                         if (pdata->fec_ability & MDIO_PMA_10GBR_FECABLE_ABLE)
3229                                 XGBE_SET_SUP(lks, 10000baseR_FEC);
3230                         phy_data->start_mode = XGBE_MODE_KR;
3231                 }
3232
3233                 phy_data->phydev_mode = XGBE_MDIO_MODE_NONE;
3234                 break;
3235         case XGBE_PORT_MODE_BACKPLANE_2500:
3236                 XGBE_SET_SUP(lks, Pause);
3237                 XGBE_SET_SUP(lks, Asym_Pause);
3238                 XGBE_SET_SUP(lks, Backplane);
3239                 XGBE_SET_SUP(lks, 2500baseX_Full);
3240                 phy_data->start_mode = XGBE_MODE_KX_2500;
3241
3242                 phy_data->phydev_mode = XGBE_MDIO_MODE_NONE;
3243                 break;
3244
3245         /* MDIO 1GBase-T support */
3246         case XGBE_PORT_MODE_1000BASE_T:
3247                 XGBE_SET_SUP(lks, Autoneg);
3248                 XGBE_SET_SUP(lks, Pause);
3249                 XGBE_SET_SUP(lks, Asym_Pause);
3250                 XGBE_SET_SUP(lks, TP);
3251                 if (phy_data->port_speeds & XGBE_PHY_PORT_SPEED_100) {
3252                         XGBE_SET_SUP(lks, 100baseT_Full);
3253                         phy_data->start_mode = XGBE_MODE_SGMII_100;
3254                 }
3255                 if (phy_data->port_speeds & XGBE_PHY_PORT_SPEED_1000) {
3256                         XGBE_SET_SUP(lks, 1000baseT_Full);
3257                         phy_data->start_mode = XGBE_MODE_SGMII_1000;
3258                 }
3259
3260                 phy_data->phydev_mode = XGBE_MDIO_MODE_CL22;
3261                 break;
3262
3263         /* MDIO Base-X support */
3264         case XGBE_PORT_MODE_1000BASE_X:
3265                 XGBE_SET_SUP(lks, Autoneg);
3266                 XGBE_SET_SUP(lks, Pause);
3267                 XGBE_SET_SUP(lks, Asym_Pause);
3268                 XGBE_SET_SUP(lks, FIBRE);
3269                 XGBE_SET_SUP(lks, 1000baseX_Full);
3270                 phy_data->start_mode = XGBE_MODE_X;
3271
3272                 phy_data->phydev_mode = XGBE_MDIO_MODE_CL22;
3273                 break;
3274
3275         /* MDIO NBase-T support */
3276         case XGBE_PORT_MODE_NBASE_T:
3277                 XGBE_SET_SUP(lks, Autoneg);
3278                 XGBE_SET_SUP(lks, Pause);
3279                 XGBE_SET_SUP(lks, Asym_Pause);
3280                 XGBE_SET_SUP(lks, TP);
3281                 if (phy_data->port_speeds & XGBE_PHY_PORT_SPEED_100) {
3282                         XGBE_SET_SUP(lks, 100baseT_Full);
3283                         phy_data->start_mode = XGBE_MODE_SGMII_100;
3284                 }
3285                 if (phy_data->port_speeds & XGBE_PHY_PORT_SPEED_1000) {
3286                         XGBE_SET_SUP(lks, 1000baseT_Full);
3287                         phy_data->start_mode = XGBE_MODE_SGMII_1000;
3288                 }
3289                 if (phy_data->port_speeds & XGBE_PHY_PORT_SPEED_2500) {
3290                         XGBE_SET_SUP(lks, 2500baseT_Full);
3291                         phy_data->start_mode = XGBE_MODE_KX_2500;
3292                 }
3293
3294                 phy_data->phydev_mode = XGBE_MDIO_MODE_CL45;
3295                 break;
3296
3297         /* 10GBase-T support */
3298         case XGBE_PORT_MODE_10GBASE_T:
3299                 XGBE_SET_SUP(lks, Autoneg);
3300                 XGBE_SET_SUP(lks, Pause);
3301                 XGBE_SET_SUP(lks, Asym_Pause);
3302                 XGBE_SET_SUP(lks, TP);
3303                 if (phy_data->port_speeds & XGBE_PHY_PORT_SPEED_100) {
3304                         XGBE_SET_SUP(lks, 100baseT_Full);
3305                         phy_data->start_mode = XGBE_MODE_SGMII_100;
3306                 }
3307                 if (phy_data->port_speeds & XGBE_PHY_PORT_SPEED_1000) {
3308                         XGBE_SET_SUP(lks, 1000baseT_Full);
3309                         phy_data->start_mode = XGBE_MODE_SGMII_1000;
3310                 }
3311                 if (phy_data->port_speeds & XGBE_PHY_PORT_SPEED_10000) {
3312                         XGBE_SET_SUP(lks, 10000baseT_Full);
3313                         phy_data->start_mode = XGBE_MODE_KR;
3314                 }
3315
3316                 phy_data->phydev_mode = XGBE_MDIO_MODE_CL45;
3317                 break;
3318
3319         /* 10GBase-R support */
3320         case XGBE_PORT_MODE_10GBASE_R:
3321                 XGBE_SET_SUP(lks, Autoneg);
3322                 XGBE_SET_SUP(lks, Pause);
3323                 XGBE_SET_SUP(lks, Asym_Pause);
3324                 XGBE_SET_SUP(lks, FIBRE);
3325                 XGBE_SET_SUP(lks, 10000baseSR_Full);
3326                 XGBE_SET_SUP(lks, 10000baseLR_Full);
3327                 XGBE_SET_SUP(lks, 10000baseLRM_Full);
3328                 XGBE_SET_SUP(lks, 10000baseER_Full);
3329                 if (pdata->fec_ability & MDIO_PMA_10GBR_FECABLE_ABLE)
3330                         XGBE_SET_SUP(lks, 10000baseR_FEC);
3331                 phy_data->start_mode = XGBE_MODE_SFI;
3332
3333                 phy_data->phydev_mode = XGBE_MDIO_MODE_NONE;
3334                 break;
3335
3336         /* SFP support */
3337         case XGBE_PORT_MODE_SFP:
3338                 XGBE_SET_SUP(lks, Autoneg);
3339                 XGBE_SET_SUP(lks, Pause);
3340                 XGBE_SET_SUP(lks, Asym_Pause);
3341                 XGBE_SET_SUP(lks, TP);
3342                 XGBE_SET_SUP(lks, FIBRE);
3343                 if (phy_data->port_speeds & XGBE_PHY_PORT_SPEED_100)
3344                         phy_data->start_mode = XGBE_MODE_SGMII_100;
3345                 if (phy_data->port_speeds & XGBE_PHY_PORT_SPEED_1000)
3346                         phy_data->start_mode = XGBE_MODE_SGMII_1000;
3347                 if (phy_data->port_speeds & XGBE_PHY_PORT_SPEED_10000)
3348                         phy_data->start_mode = XGBE_MODE_SFI;
3349
3350                 phy_data->phydev_mode = XGBE_MDIO_MODE_CL22;
3351
3352                 xgbe_phy_sfp_setup(pdata);
3353                 break;
3354         default:
3355                 return -EINVAL;
3356         }
3357
3358         if (netif_msg_probe(pdata))
3359                 dev_dbg(pdata->dev, "phy supported=0x%*pb\n",
3360                         __ETHTOOL_LINK_MODE_MASK_NBITS,
3361                         lks->link_modes.supported);
3362
3363         if ((phy_data->conn_type & XGBE_CONN_TYPE_MDIO) &&
3364             (phy_data->phydev_mode != XGBE_MDIO_MODE_NONE)) {
3365                 ret = pdata->hw_if.set_ext_mii_mode(pdata, phy_data->mdio_addr,
3366                                                     phy_data->phydev_mode);
3367                 if (ret) {
3368                         dev_err(pdata->dev,
3369                                 "mdio port/clause not compatible (%d/%u)\n",
3370                                 phy_data->mdio_addr, phy_data->phydev_mode);
3371                         return -EINVAL;
3372                 }
3373         }
3374
3375         if (phy_data->redrv && !phy_data->redrv_if) {
3376                 ret = pdata->hw_if.set_ext_mii_mode(pdata, phy_data->redrv_addr,
3377                                                     XGBE_MDIO_MODE_CL22);
3378                 if (ret) {
3379                         dev_err(pdata->dev,
3380                                 "redriver mdio port not compatible (%u)\n",
3381                                 phy_data->redrv_addr);
3382                         return -EINVAL;
3383                 }
3384         }
3385
3386         phy_data->phy_cdr_delay = XGBE_CDR_DELAY_INIT;
3387
3388         /* Register for driving external PHYs */
3389         mii = devm_mdiobus_alloc(pdata->dev);
3390         if (!mii) {
3391                 dev_err(pdata->dev, "mdiobus_alloc failed\n");
3392                 return -ENOMEM;
3393         }
3394
3395         mii->priv = pdata;
3396         mii->name = "amd-xgbe-mii";
3397         mii->read = xgbe_phy_mii_read;
3398         mii->write = xgbe_phy_mii_write;
3399         mii->parent = pdata->dev;
3400         mii->phy_mask = ~0;
3401         snprintf(mii->id, sizeof(mii->id), "%s", dev_name(pdata->dev));
3402         ret = mdiobus_register(mii);
3403         if (ret) {
3404                 dev_err(pdata->dev, "mdiobus_register failed\n");
3405                 return ret;
3406         }
3407         phy_data->mii = mii;
3408
3409         return 0;
3410 }
3411
3412 void xgbe_init_function_ptrs_phy_v2(struct xgbe_phy_if *phy_if)
3413 {
3414         struct xgbe_phy_impl_if *phy_impl = &phy_if->phy_impl;
3415
3416         phy_impl->init                  = xgbe_phy_init;
3417         phy_impl->exit                  = xgbe_phy_exit;
3418
3419         phy_impl->reset                 = xgbe_phy_reset;
3420         phy_impl->start                 = xgbe_phy_start;
3421         phy_impl->stop                  = xgbe_phy_stop;
3422
3423         phy_impl->link_status           = xgbe_phy_link_status;
3424
3425         phy_impl->valid_speed           = xgbe_phy_valid_speed;
3426
3427         phy_impl->use_mode              = xgbe_phy_use_mode;
3428         phy_impl->set_mode              = xgbe_phy_set_mode;
3429         phy_impl->get_mode              = xgbe_phy_get_mode;
3430         phy_impl->switch_mode           = xgbe_phy_switch_mode;
3431         phy_impl->cur_mode              = xgbe_phy_cur_mode;
3432
3433         phy_impl->an_mode               = xgbe_phy_an_mode;
3434
3435         phy_impl->an_config             = xgbe_phy_an_config;
3436
3437         phy_impl->an_advertising        = xgbe_phy_an_advertising;
3438
3439         phy_impl->an_outcome            = xgbe_phy_an_outcome;
3440
3441         phy_impl->an_pre                = xgbe_phy_an_pre;
3442         phy_impl->an_post               = xgbe_phy_an_post;
3443
3444         phy_impl->kr_training_pre       = xgbe_phy_kr_training_pre;
3445         phy_impl->kr_training_post      = xgbe_phy_kr_training_post;
3446
3447         phy_impl->module_info           = xgbe_phy_module_info;
3448         phy_impl->module_eeprom         = xgbe_phy_module_eeprom;
3449 }